multi_agent_search.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "authorship_tag": "ABX9TyMuiP5jobPSI8l3AZqmS6Ot",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jkf87/agents-course-ko/blob/main/multi_agent_search.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 환경설정\n"
      ],
      "metadata": {
        "id": "GDKHMH6rk4jM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install smolagents gradio"
      ],
      "metadata": {
        "id": "zORNSEuylabo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nhcjKevXk1Su"
      },
      "outputs": [],
      "source": [
        "from smolagents import CodeAgent, ToolCallingAgent, DuckDuckGoSearchTool, HfApiModel\n",
        "import json\n",
        "from datetime import datetime\n",
        "import gradio as gr\n",
        "import os"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from huggingface_hub import notebook_login\n",
        "\n",
        "notebook_login()"
      ],
      "metadata": {
        "id": "vsDp7C6PnOzk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def create_search_agent():\n",
        "    # 웹 검색을 수행하는 에이전트\n",
        "    return ToolCallingAgent(\n",
        "        tools=[DuckDuckGoSearchTool()],\n",
        "        model=HfApiModel()\n",
        "    )\n",
        "\n",
        "def create_writer_agent():\n",
        "    # 파일 작성을 수행하는 에이전트\n",
        "    return CodeAgent(\n",
        "        tools=[],  # CodeAgent는 기본적으로 파일 시스템 작업이 가능합니다\n",
        "        model=HfApiModel()\n",
        "    )\n",
        "\n",
        "def create_analyzer_agent():\n",
        "    # 검색 결과를 분석하고 정리하는 에이전트\n",
        "    return ToolCallingAgent(\n",
        "        tools=[],  # 분석 에이전트는 특별한 도구가 필요하지 않으므로 빈 리스트 사용\n",
        "        model=HfApiModel()\n",
        "    )\n",
        "\n",
        "def expand_query(agent, original_query, progress_logs=None):\n",
        "    # 원본 쿼리를 여러 개의 세부 쿼리로 확장\n",
        "    expansion_prompt = f\"\"\"\n",
        "    다음 검색어와 관련된 4개의 구체적인 검색 쿼리를 생성해주세요.\n",
        "    각각의 쿼리는 서로 다른 측면이나 관점을 다뤄야 하며, 실제 검색에 효과적인 형태여야 합니다.\n",
        "\n",
        "    검색어: {original_query}\n",
        "\n",
        "    응답 형식:\n",
        "    1. JSON 형식으로 응답해주세요.\n",
        "    2. 각 쿼리는 검색 엔진에서 좋은 결과를 얻을 수 있도록 구체적이어야 합니다.\n",
        "    3. 쿼리는 한글로 작성해주세요.\n",
        "\n",
        "    다음 형식으로 응답해주세요:\n",
        "    {{\n",
        "        \"queries\": [\n",
        "            \"구체적인 첫 번째 검색어\",\n",
        "            \"구체적인 두 번째 검색어\",\n",
        "            \"구체적인 세 번째 검색어\",\n",
        "            \"구체적인 네 번째 검색어\"\n",
        "        ]\n",
        "    }}\n",
        "    \"\"\"\n",
        "\n",
        "    if progress_logs is not None:\n",
        "        progress_logs.append(\"\\n==== 쿼리 확장 프로세스 ====\")\n",
        "        progress_logs.append(f\"[확장 요청 프롬프트]\\n{expansion_prompt}\")\n",
        "\n",
        "    try:\n",
        "        # 에이전트 응답 받기\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[에이전트에게 쿼리 확장 요청 중...]\")\n",
        "\n",
        "        result = agent.run(expansion_prompt)\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[에이전트 응답 - RAW]\\n{result}\")\n",
        "            progress_logs.append(\"\\n[JSON 파싱 시도 중...]\")\n",
        "\n",
        "        parsed_result = json.loads(result)\n",
        "\n",
        "        if \"queries\" not in parsed_result or not parsed_result[\"queries\"]:\n",
        "            if progress_logs is not None:\n",
        "                progress_logs.append(\"\\n[오류] JSON에 'queries' 키가 없거나 비어 있습니다. 원본 쿼리 사용.\")\n",
        "            return [original_query]\n",
        "\n",
        "        queries = parsed_result[\"queries\"]\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[추출된 쿼리 - 필터링 전]\\n{json.dumps(queries, ensure_ascii=False, indent=2)}\")\n",
        "\n",
        "        # 빈 쿼리나 너무 짧은 쿼리 필터링\n",
        "        queries = [q for q in queries if q and len(q) > 2]\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[필터링 후 쿼리]\\n{json.dumps(queries, ensure_ascii=False, indent=2)}\")\n",
        "\n",
        "        if not queries:\n",
        "            if progress_logs is not None:\n",
        "                progress_logs.append(\"\\n[필터링 후 유효한 쿼리 없음] 원본 쿼리 사용.\")\n",
        "            return [original_query]\n",
        "\n",
        "        return queries\n",
        "\n",
        "    except Exception as e:\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[쿼리 확장 중 오류 발생] {str(e)}\\n원본 쿼리를 사용합니다.\")\n",
        "        return [original_query]\n",
        "\n",
        "def analyze_results(agent, search_results, progress_logs=None):\n",
        "    # 검색 결과를 분석하고 유용한 정보만 추출\n",
        "    analysis_prompt = f\"\"\"\n",
        "    아래 제공된 검색 결과를 깊이 있게 분석하고 가장 중요하고 신뢰할 수 있는 정보를 추출해주세요.\n",
        "\n",
        "    분석 시 다음 사항을 고려해주세요:\n",
        "    1. 여러 소스에서 반복되는 정보는 신뢰성이 높을 가능성이 있습니다.\n",
        "    2. 최신 정보를 우선적으로 고려하세요.\n",
        "    3. 출처가 명확한 정보를 우선적으로 선택하세요.\n",
        "    4. 각 발견사항은 명확하고 구체적인 내용을 담아야 합니다.\n",
        "    5. 모호하거나 불확실한 정보는 제외하세요.\n",
        "\n",
        "    검색 결과:\n",
        "    {json.dumps(search_results, indent=2, ensure_ascii=False)[:100000]}  # 너무 길면 잘라서 사용\n",
        "\n",
        "    다음 JSON 형식으로 응답해주세요:\n",
        "    {{\n",
        "        \"key_findings\": [\n",
        "            {{\n",
        "                \"content\": \"첫 번째 발견사항의 상세 내용\",\n",
        "                \"reliability\": \"높음/중간/낮음\",\n",
        "                \"source\": \"발견된 출처 (알 수 있는 경우)\"\n",
        "            }},\n",
        "            {{\n",
        "                \"content\": \"두 번째 발견사항의 상세 내용\",\n",
        "                \"reliability\": \"높음/중간/낮음\",\n",
        "                \"source\": \"발견된 출처 (알 수 있는 경우)\"\n",
        "            }},\n",
        "            ...계속...\n",
        "        ]\n",
        "    }}\n",
        "    \"\"\"\n",
        "\n",
        "    if progress_logs is not None:\n",
        "        progress_logs.append(\"\\n==== 검색 결과 분석 프로세스 ====\")\n",
        "        progress_logs.append(\"[분석 요청 프롬프트 - 헤더만 표시 (전체 길이가 너무 김)]\\n\" + analysis_prompt.split(\"검색 결과:\")[0])\n",
        "        progress_logs.append(f\"\\n[분석할 검색 결과 개수] {len(search_results)}개\")\n",
        "\n",
        "    try:\n",
        "        # 검색 결과 분석 시도\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[에이전트에게 분석 요청 중...]\")\n",
        "\n",
        "        result = agent.run(analysis_prompt)\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[에이전트 분석 응답 - RAW]\\n{result}\")\n",
        "            progress_logs.append(\"\\n[JSON 파싱 시도 중...]\")\n",
        "\n",
        "        # JSON 파싱 시도\n",
        "        try:\n",
        "            parsed_result = json.loads(result)\n",
        "\n",
        "            if progress_logs is not None:\n",
        "                progress_logs.append(f\"\\n[JSON 파싱 성공]\\n{json.dumps(parsed_result, ensure_ascii=False, indent=2)[:1000]}...\")\n",
        "\n",
        "            if \"key_findings\" in parsed_result and parsed_result[\"key_findings\"]:\n",
        "                # JSON 구조가 예상대로인 경우\n",
        "                if progress_logs is not None:\n",
        "                    progress_logs.append(\"\\n[예상 JSON 구조 확인됨] 'key_findings' 키 있음\")\n",
        "\n",
        "                findings = []\n",
        "                for item in parsed_result[\"key_findings\"]:\n",
        "                    if isinstance(item, dict) and \"content\" in item:\n",
        "                        # 신뢰도 정보 추가\n",
        "                        reliability = item.get(\"reliability\", \"\")\n",
        "                        source = item.get(\"source\", \"\")\n",
        "\n",
        "                        content = item[\"content\"]\n",
        "                        if reliability and source:\n",
        "                            findings.append(f\"{content} (신뢰도: {reliability}, 출처: {source})\")\n",
        "                        elif reliability:\n",
        "                            findings.append(f\"{content} (신뢰도: {reliability})\")\n",
        "                        elif source:\n",
        "                            findings.append(f\"{content} (출처: {source})\")\n",
        "                        else:\n",
        "                            findings.append(content)\n",
        "                    elif isinstance(item, str) and item:\n",
        "                        findings.append(item)\n",
        "\n",
        "                if progress_logs is not None:\n",
        "                    progress_logs.append(f\"\\n[처리된 발견사항] {len(findings)}개 항목 추출됨\")\n",
        "\n",
        "                if findings:\n",
        "                    return findings\n",
        "            elif \"key_findings\" in parsed_result and isinstance(parsed_result[\"key_findings\"], list):\n",
        "                # 단순 문자열 목록인 경우\n",
        "                if progress_logs is not None:\n",
        "                    progress_logs.append(\"\\n[단순 목록 구조 확인됨] 문자열 목록 처리 중\")\n",
        "\n",
        "                findings = [item for item in parsed_result[\"key_findings\"] if item and len(str(item)) > 10]\n",
        "\n",
        "                if progress_logs is not None:\n",
        "                    progress_logs.append(f\"\\n[필터링 후 발견사항] {len(findings)}개 항목 추출됨\")\n",
        "\n",
        "                if findings:\n",
        "                    return findings\n",
        "            else:\n",
        "                if progress_logs is not None:\n",
        "                    progress_logs.append(\"\\n[예상과 다른 JSON 구조] 'key_findings' 키가 없거나 다른 형식\")\n",
        "\n",
        "        except json.JSONDecodeError:\n",
        "            # JSON 파싱에 실패한 경우, 줄 단위로 의미 있는 정보 추출 시도\n",
        "            if progress_logs is not None:\n",
        "                progress_logs.append(\"\\n[JSON 파싱 실패] 텍스트 분석으로 전환\")\n",
        "\n",
        "        # JSON 파싱이 실패하거나 예상 구조가 아닌 경우, 텍스트 분석 시도\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[텍스트 기반 분석 시작] 줄 단위 분석\")\n",
        "\n",
        "        lines = result.split(\"\\n\")\n",
        "        findings = []\n",
        "        for line in lines:\n",
        "            line = line.strip()\n",
        "            # 의미 있는 줄만 추출 (짧은 줄, JSON 표기, 빈 줄 제외)\n",
        "            if line and len(line) > 30 and not (line.startswith('{') or line.startswith('}') or line.startswith('[') or line.startswith(']')):\n",
        "                findings.append(line)\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[텍스트 분석 결과] {len(findings)}개 의미 있는 줄 추출됨\")\n",
        "\n",
        "        if findings:\n",
        "            return findings\n",
        "\n",
        "        # 모든 시도가 실패한 경우 기본 메시지 반환\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[분석 실패] 모든 분석 방법 실패. 기본 메시지 반환\")\n",
        "\n",
        "        return [\"검색 결과에서 유의미한 정보를 추출하지 못했습니다. 다른 검색어로 시도해보세요.\"]\n",
        "\n",
        "    except Exception as e:\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[분석 중 예외 발생] {str(e)}\")\n",
        "\n",
        "        return [f\"검색 결과 분석 중 오류가 발생했습니다: {str(e)}\"]\n",
        "\n",
        "def generate_report(writer_agent, query, findings, expanded_queries, progress_logs=None):\n",
        "    \"\"\"\n",
        "    에이전트를 사용하여 더 풍부한 보고서 생성\n",
        "    \"\"\"\n",
        "    report_prompt = f\"\"\"\n",
        "    다음 주제와 발견된 정보를 바탕으로 상세하고 종합적인 리서치 보고서를 작성해주세요:\n",
        "\n",
        "    주제: {query}\n",
        "\n",
        "    조사에 사용된 검색어:\n",
        "    {expanded_queries}\n",
        "\n",
        "    발견된 주요 정보:\n",
        "    {chr(10).join([f\"- {finding}\" for finding in findings])}\n",
        "\n",
        "    보고서는 다음 형식을 따라주세요:\n",
        "    1. 제목: 주제를 잘 나타내는 명확한 제목 (굵은 글씨)\n",
        "    2. 개요: 주제에 대한 소개와 조사의 배경 및 목적 (최소 200자 이상)\n",
        "    3. 주요 발견사항: 가장 중요하고 관련성 높은 정보를 상세히 설명 (각 항목당 최소 200자 이상, 총 5개 이상의 항목)\n",
        "    4. 세부 분석:\n",
        "       a. 정보의 신뢰성 평가 (소스 분석, 교차 검증 결과)\n",
        "       b. 발견된 쟁점이나 논란 (있는 경우)\n",
        "       c. 시간적 변화나 추세 (관련이 있는 경우)\n",
        "       d. 지역적/문화적 차이점 (관련이 있는 경우)\n",
        "    5. 통합적 분석: 모든 발견사항들을 종합적으로 분석한 심층 해석 (최소 500자 이상)\n",
        "    6. 결론 및 제언: 전체 내용의 요약과 향후 주목할 점 또는 권장사항 (최소 400자 이상)\n",
        "    7. 이 보고서의 한계: 정보 수집 과정의 제한사항이나 향후 추가 연구가 필요한 부분\n",
        "\n",
        "    보고서 작성 시 주의사항:\n",
        "    - 각 섹션마다 충분한 내용과 깊이를 포함할 것 (전체 보고서는 최소 5000자 이상)\n",
        "    - 단순 나열이 아닌 사실들을 연결하고 해석하는 통합적 분석을 제공할 것\n",
        "    - 가능한 경우 출처와 날짜를 포함할 것\n",
        "    - 전문 용어가 있다면 간략히 설명할 것\n",
        "    - 객관적이고 균형 잡힌 관점에서 서술할 것\n",
        "    \"\"\"\n",
        "\n",
        "    if progress_logs is not None:\n",
        "        progress_logs.append(\"\\n==== 보고서 생성 프로세스 ====\")\n",
        "        progress_logs.append(\"[보고서 작성 요청 프롬프트]\\n\" + report_prompt.split(\"발견된 주요 정보:\")[0] + \"발견된 주요 정보: [...]\")\n",
        "        progress_logs.append(f\"\\n[처리할 발견사항 수] {len(findings)}개\")\n",
        "\n",
        "    try:\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[에이전트에게 보고서 작성 요청 중...]\")\n",
        "\n",
        "        report_content = writer_agent.run(report_prompt)\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[에이전트 보고서 응답 - RAW]\\n{report_content[:500]}...(이하 생략)\")\n",
        "            progress_logs.append(f\"\\n[보고서 길이] {len(report_content)} 자\")\n",
        "\n",
        "        # 현재 시간 추가\n",
        "        now = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
        "        final_report = f\"생성 시간: {now}\\n\\n{report_content}\"\n",
        "\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(\"\\n[보고서 생성 완료]\")\n",
        "\n",
        "        return final_report\n",
        "    except Exception as e:\n",
        "        if progress_logs is not None:\n",
        "            progress_logs.append(f\"\\n[보고서 생성 중 오류 발생] {str(e)}\\n기본 보고서 생성으로 전환\")\n",
        "\n",
        "        # 에러 발생시 기본 보고서 생성\n",
        "        return generate_simple_report(query, findings, progress_logs)\n",
        "\n",
        "def generate_simple_report(query, findings, progress_logs=None):\n",
        "    \"\"\"\n",
        "    기본적인 보고서 형식으로 생성 (에이전트 실패 시 대체용)\n",
        "    \"\"\"\n",
        "    if progress_logs is not None:\n",
        "        progress_logs.append(\"\\n[기본 보고서 생성 시작]\")\n",
        "\n",
        "    now = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
        "    report = f\"\"\"\n",
        "=== AI 리서치 보고서: {query} ===\n",
        "생성 시간: {now}\n",
        "\n",
        "🔍 개요:\n",
        "\"{query}\"에 대한 자동화된 웹 검색 결과를 바탕으로 작성된 리포트입니다.\n",
        "이 보고서는 다양한 온라인 소스에서 수집된 정보를 종합하여 제공합니다.\n",
        "\n",
        "📊 주요 발견사항:\n",
        "\n",
        "\"\"\"\n",
        "    for i, finding in enumerate(findings, 1):\n",
        "        report += f\"{i}. {finding}\\n\\n\"\n",
        "\n",
        "    report += \"\"\"\n",
        "💡 결론:\n",
        "위 정보는 자동화된 검색을 통해 수집되었으며, 각 항목의 정확성과 최신성은 원본 출처에 따라 달라질 수 있습니다.\n",
        "더 정확하고 상세한 정보를 위해서는 전문가의 검증이 권장됩니다.\n",
        "\"\"\"\n",
        "\n",
        "    if progress_logs is not None:\n",
        "        progress_logs.append(f\"\\n[기본 보고서 생성 완료] 길이: {len(report)} 자\")\n",
        "\n",
        "    return report\n",
        "\n",
        "def save_logs_to_file(logs, query, timestamp, search_results=None, expanded_queries=None, findings=None, report=None, agent_prompts=None):\n",
        "    \"\"\"로그를 파일로 저장하는 함수\"\"\"\n",
        "    os.makedirs('logs', exist_ok=True)\n",
        "\n",
        "    sanitized_query = \"\".join(c for c in query if c.isalnum() or c in ' -_').strip().replace(' ', '_')[:30]\n",
        "    log_filename = f\"log_{sanitized_query}_{timestamp}.txt\"\n",
        "    log_path = os.path.join('logs', log_filename)\n",
        "\n",
        "    with open(log_path, 'w', encoding='utf-8') as f:\n",
        "        # 헤더 정보\n",
        "        f.write(f\"=========================================================\\n\")\n",
        "        f.write(f\"===== 에이전트 시스템 전체 로그: {query} =====\\n\")\n",
        "        f.write(f\"=========================================================\\n\")\n",
        "        f.write(f\"시작 시간: {datetime.fromtimestamp(int(timestamp.split('_')[0])).strftime('%Y-%m-%d %H:%M:%S')}\\n\\n\")\n",
        "\n",
        "        # 상세 프로세스 로그 (모든 단계와 과정 포함)\n",
        "        f.write(\"=========================================================\\n\")\n",
        "        f.write(\"===== 전체 프로세스 로그 (모든 중간 단계 포함) =====\\n\")\n",
        "        f.write(\"=========================================================\\n\\n\")\n",
        "        f.write(\"\\n\".join(logs))\n",
        "\n",
        "        # 구분선\n",
        "        f.write(\"\\n\\n\")\n",
        "        f.write(\"=========================================================\\n\")\n",
        "        f.write(\"===== 최종 결과 요약 =====\\n\")\n",
        "        f.write(\"=========================================================\\n\\n\")\n",
        "\n",
        "        # 1. 쿼리 확장 로그\n",
        "        f.write(\"===== 1. 쿼리 확장 결과 =====\\n\")\n",
        "        if expanded_queries:\n",
        "            f.write(expanded_queries + \"\\n\\n\")\n",
        "\n",
        "        # 2. 검색 결과 로그\n",
        "        f.write(\"===== 2. 검색 결과 (RAW) =====\\n\")\n",
        "        if search_results:\n",
        "            for i, result in enumerate(search_results):\n",
        "                f.write(f\"\\n--- 검색 {i+1}: \\\"{result['query']}\\\" ---\\n\")\n",
        "                f.write(result['result'])\n",
        "                f.write(\"\\n\" + \"-\" * 80 + \"\\n\")\n",
        "\n",
        "        # 3. 분석 결과 로그\n",
        "        f.write(\"\\n===== 3. 분석 결과 =====\\n\")\n",
        "        if findings:\n",
        "            f.write(findings + \"\\n\\n\")\n",
        "\n",
        "        # 4. 최종 보고서\n",
        "        f.write(\"===== 4. 최종 보고서 =====\\n\")\n",
        "        if report:\n",
        "            f.write(report + \"\\n\\n\")\n",
        "\n",
        "    return log_path\n",
        "\n",
        "def process_query(query):\n",
        "    # 에이전트들 생성\n",
        "    progress_logs = []  # 진행 상황과 모든 중간 과정을 저장할 리스트\n",
        "\n",
        "    # 시작 로깅\n",
        "    progress_logs.append(f\"==================================================\")\n",
        "    progress_logs.append(f\"===== 멀티 에이전트 리서치 시스템 프로세스 시작 =====\")\n",
        "    progress_logs.append(f\"==================================================\")\n",
        "    progress_logs.append(f\"시작 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\")\n",
        "    progress_logs.append(f\"검색 쿼리: '{query}'\")\n",
        "\n",
        "    # 에이전트 생성 로깅\n",
        "    progress_logs.append(\"\\n[에이전트 생성 시작]\")\n",
        "\n",
        "    search_agent = create_search_agent()\n",
        "    progress_logs.append(\"[검색 에이전트 생성 완료] DuckDuckGoSearchTool 사용\")\n",
        "\n",
        "    analyzer_agent = create_analyzer_agent()\n",
        "    progress_logs.append(\"[분석 에이전트 생성 완료] 도구 없음\")\n",
        "\n",
        "    writer_agent = create_writer_agent()\n",
        "    progress_logs.append(\"[작성 에이전트 생성 완료] CodeAgent 사용\\n\")\n",
        "\n",
        "    # 시작 타임스탬프 생성 (파일명용)\n",
        "    timestamp = datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n",
        "\n",
        "    # 진행 상황 업데이트 및 UI 반환 함수\n",
        "    def update_ui(message=None, expanded=None, findings=None, report=None, file=None, log_file=None):\n",
        "        if message:\n",
        "            progress_logs.append(message)\n",
        "\n",
        "        return (\n",
        "            \"\\n\".join(progress_logs[-15:]),  # UI에는 최근 15개 메시지만 표시\n",
        "            expanded if expanded is not None else \"\",\n",
        "            findings if findings is not None else \"\",\n",
        "            report if report is not None else \"\",\n",
        "            file,\n",
        "            log_file\n",
        "        )\n",
        "\n",
        "    # 1단계: 쿼리 확장\n",
        "    yield update_ui(\"1️⃣ 검색 쿼리를 확장하는 중...\")\n",
        "    progress_logs.append(f\"\\n[원본 쿼리] {query}\")\n",
        "\n",
        "    # 쿼리 확장 과정에 로그 전달\n",
        "    expanded_queries = expand_query(analyzer_agent, query, progress_logs)\n",
        "    expanded_queries_text = \"\\n\".join([f\"{i+1}. {q}\" for i, q in enumerate(expanded_queries)])\n",
        "\n",
        "    yield update_ui(f\"✅ 쿼리 확장 완료: {len(expanded_queries)}개의 검색어 생성됨\", expanded_queries_text)\n",
        "    for i, eq in enumerate(expanded_queries, 1):\n",
        "        yield update_ui(f\"   {i}. {eq}\", expanded_queries_text)\n",
        "\n",
        "    # 2단계: 확장된 쿼리로 검색 수행\n",
        "    yield update_ui(\"\\n2️⃣ 검색을 수행하는 중...\", expanded_queries_text)\n",
        "    progress_logs.append(\"\\n==== 검색 프로세스 시작 ====\")\n",
        "\n",
        "    search_results = []\n",
        "    for i, expanded_query in enumerate(expanded_queries, 1):\n",
        "        progress_logs.append(f\"\\n---- 검색 {i}/{len(expanded_queries)} 시작 ----\")\n",
        "        progress_logs.append(f\"[검색 쿼리] \\\"{expanded_query}\\\"\")\n",
        "\n",
        "        yield update_ui(f\"   └ 검색 {i}/{len(expanded_queries)}: \\\"{expanded_query}\\\"\", expanded_queries_text)\n",
        "\n",
        "        # 검색 실행 및 로깅\n",
        "        progress_logs.append(\"[검색 에이전트에 요청 전송 중...]\")\n",
        "        search_start_time = datetime.now()\n",
        "\n",
        "        try:\n",
        "            result = search_agent.run(expanded_query)\n",
        "            search_time = (datetime.now() - search_start_time).total_seconds()\n",
        "\n",
        "            # 검색 결과 로깅\n",
        "            word_count = len(result.split())\n",
        "            char_count = len(result)\n",
        "            progress_logs.append(f\"[검색 완료] 소요 시간: {search_time:.2f}초, 단어 수: {word_count}, 문자 수: {char_count}\")\n",
        "            progress_logs.append(f\"[검색 결과 미리보기] {result[:150]}...\")\n",
        "\n",
        "            search_results.append({\"query\": expanded_query, \"result\": result})\n",
        "\n",
        "            yield update_ui(f\"     ↳ 검색 완료 ({word_count} 단어, {char_count} 글자, {search_time:.1f}초 소요)\", expanded_queries_text)\n",
        "\n",
        "        except Exception as e:\n",
        "            progress_logs.append(f\"[검색 오류 발생] {str(e)}\")\n",
        "            yield update_ui(f\"     ↳ 검색 중 오류 발생: {str(e)}\", expanded_queries_text)\n",
        "\n",
        "        progress_logs.append(f\"---- 검색 {i}/{len(expanded_queries)} 완료 ----\")\n",
        "\n",
        "    progress_logs.append(\"\\n==== 검색 프로세스 완료 ====\")\n",
        "\n",
        "    # 3단계: 검색 결과 분석\n",
        "    yield update_ui(\"\\n3️⃣ 검색 결과를 분석하는 중...\", expanded_queries_text)\n",
        "\n",
        "    # 분석 과정에 로그 전달\n",
        "    key_findings = analyze_results(analyzer_agent, search_results, progress_logs)\n",
        "    findings_text = \"\\n\".join([f\"{i+1}. {finding}\" for i, finding in enumerate(key_findings)])\n",
        "\n",
        "    yield update_ui(f\"✅ 분석 완료. {len(key_findings)}개의 핵심 발견사항 추출됨.\", expanded_queries_text, findings_text)\n",
        "\n",
        "    # 4단계: 보고서 생성 및 저장\n",
        "    yield update_ui(\"\\n4️⃣ 최종 보고서를 생성하는 중...\", expanded_queries_text, findings_text)\n",
        "\n",
        "    # 보고서 생성 과정에 로그 전달\n",
        "    report = generate_report(writer_agent, query, key_findings, expanded_queries_text, progress_logs)\n",
        "\n",
        "    # reports 디렉토리 생성\n",
        "    progress_logs.append(\"\\n[파일 시스템 작업] 'reports' 디렉토리 생성 중...\")\n",
        "    os.makedirs('reports', exist_ok=True)\n",
        "    progress_logs.append(\"[파일 시스템 작업] 디렉토리 준비 완료\")\n",
        "\n",
        "    # 파일명에 타임스탬프 추가\n",
        "    sanitized_query = \"\".join(c for c in query if c.isalnum() or c in ' -_').strip().replace(' ', '_')[:30]\n",
        "    filename = f\"report_{sanitized_query}_{timestamp}.txt\"\n",
        "    report_path = os.path.join('reports', filename)\n",
        "\n",
        "    progress_logs.append(f\"[파일 시스템 작업] 보고서 저장 준비 중: '{report_path}'\")\n",
        "\n",
        "    # 보고서 파일 저장\n",
        "    with open(report_path, 'w', encoding='utf-8') as f:\n",
        "        f.write(report)\n",
        "\n",
        "    progress_logs.append(f\"[파일 시스템 작업] 보고서 저장 완료: {len(report)} 자\")\n",
        "\n",
        "    # 로그 저장 마무리\n",
        "    progress_logs.append(\"\\n==== 프로세스 마무리 ====\")\n",
        "    progress_logs.append(f\"[작업 완료 시간] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\")\n",
        "    progress_logs.append(f\"[총 처리된 검색어] {len(expanded_queries)}개\")\n",
        "    progress_logs.append(f\"[총 발견된 정보] {len(key_findings)}개\")\n",
        "    progress_logs.append(f\"[최종 보고서 크기] {len(report)} 자\")\n",
        "\n",
        "    # 로그 파일 저장 (모든 raw 데이터 및 중간 과정 포함)\n",
        "    log_path = save_logs_to_file(\n",
        "        progress_logs,\n",
        "        query,\n",
        "        timestamp,\n",
        "        search_results=search_results,\n",
        "        expanded_queries=expanded_queries_text,\n",
        "        findings=findings_text,\n",
        "        report=report\n",
        "    )\n",
        "\n",
        "    yield update_ui(\"\\n✨ 작업이 완료되었습니다!\", expanded_queries_text, findings_text, report, report_path, log_path)\n",
        "    yield update_ui(f\"📄 보고서가 '{report_path}' 파일에 저장되었습니다.\", expanded_queries_text, findings_text, report, report_path, log_path)\n",
        "    yield update_ui(f\"📋 전체 과정 상세 로그가 '{log_path}' 파일에 저장되었습니다.\", expanded_queries_text, findings_text, report, report_path, log_path)\n",
        "\n",
        "    # 최종 결과 반환\n",
        "    return (\n",
        "        \"\\n\".join(progress_logs[-15:]),  # UI에는 최근 15개 메시지만 표시\n",
        "        expanded_queries_text,\n",
        "        findings_text,\n",
        "        report,\n",
        "        report_path,\n",
        "        log_path\n",
        "    )\n",
        "\n",
        "def create_gradio_interface():\n",
        "    with gr.Blocks(title=\"멀티 에이전트 리서치 시스템\", theme=gr.themes.Soft()) as interface:\n",
        "        gr.Markdown(\"# 🤖 멀티 에이전트 리서치 시스템\")\n",
        "        gr.Markdown(\"검색하고 싶은 주제를 입력하면, AI 에이전트들이 협력하여 관련 정보를 수집하고 분석합니다.\")\n",
        "\n",
        "        with gr.Row():\n",
        "            with gr.Column(scale=1):\n",
        "                # 입력\n",
        "                query_input = gr.Textbox(\n",
        "                    label=\"검색 주제\",\n",
        "                    placeholder=\"예: 벚꽃 개화시기\",\n",
        "                    lines=2\n",
        "                )\n",
        "                search_button = gr.Button(\"🔍 검색 시작\", variant=\"primary\")\n",
        "\n",
        "            with gr.Column(scale=2):\n",
        "                # 진행 상황\n",
        "                progress_output = gr.Textbox(\n",
        "                    label=\"진행 상황\",\n",
        "                    lines=15,\n",
        "                    interactive=False\n",
        "                )\n",
        "\n",
        "        with gr.Row():\n",
        "            with gr.Column():\n",
        "                # 확장된 쿼리\n",
        "                expanded_queries_output = gr.Textbox(\n",
        "                    label=\"확장된 검색어\",\n",
        "                    lines=5,\n",
        "                    interactive=False\n",
        "                )\n",
        "                # 주요 발견사항\n",
        "                findings_output = gr.Textbox(\n",
        "                    label=\"주요 발견사항\",\n",
        "                    lines=10,\n",
        "                    interactive=False\n",
        "                )\n",
        "\n",
        "            with gr.Column():\n",
        "                # 최종 보고서\n",
        "                report_output = gr.Textbox(\n",
        "                    label=\"최종 보고서\",\n",
        "                    lines=20,\n",
        "                    interactive=False\n",
        "                )\n",
        "                # 파일 다운로드\n",
        "                with gr.Row():\n",
        "                    # 보고서 파일 다운로드\n",
        "                    file_output = gr.File(\n",
        "                        label=\"보고서 다운로드\",\n",
        "                        interactive=False\n",
        "                    )\n",
        "                    # 로그 파일 다운로드\n",
        "                    log_file_output = gr.File(\n",
        "                        label=\"로그 다운로드\",\n",
        "                        interactive=False\n",
        "                    )\n",
        "\n",
        "        # 이벤트 연결\n",
        "        search_button.click(\n",
        "            fn=process_query,\n",
        "            inputs=query_input,\n",
        "            outputs=[\n",
        "                progress_output,\n",
        "                expanded_queries_output,\n",
        "                findings_output,\n",
        "                report_output,\n",
        "                file_output,\n",
        "                log_file_output\n",
        "            ],\n",
        "            show_progress=False\n",
        "        )\n",
        "\n",
        "    return interface\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    interface = create_gradio_interface()\n",
        "    # interface.launch() 대신 아래 코드 사용\n",
        "    interface.queue().launch(\n",
        "        server_name=\"0.0.0.0\",\n",
        "        share=True,\n",
        "        show_error=True,\n",
        "        prevent_thread_lock=True  # 이 옵션이 중요합니다!\n",
        "    )"
      ],
      "metadata": {
        "id": "5xIuPMrSoN_k"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}