Spaces:

jackkuo
/

streamlit-macp-agents

Sleeping

App Files Files Community

jackkuo commited on Aug 22, 2025

Commit

d7500c0

1 Parent(s): c3b9f62

update

Browse files

Files changed (11) hide show

.env +5 -0
MCP-HandsOn-KOR.ipynb +0 -701
README_KOR.md +0 -232
__pycache__/app.cpython-310.pyc +0 -0
__pycache__/app.cpython-312.pyc +0 -0
__pycache__/utils.cpython-310.pyc +0 -0
__pycache__/utils.cpython-312.pyc +0 -0
app.py +403 -16
app_KOR.py +0 -848
config.json +8 -0
run.sh +1 -0

.env ADDED Viewed

	@@ -0,0 +1,5 @@

+ANTHROPIC_API_KEY=sk-0nEqu5ChgjT6aFweA12bC37d6f8f485eAd63848e4c57041d
+ANTHROPIC_BASE_URL=https://openai.sohoyo.io
+# OPENAI_API_KEY=sk-0nEqu5ChgjT6aFweA12bC37d6f8f485eAd63848e4c57041d
+# OPENAI_BASE_URL=https://openai.sohoyo.io/v1

MCP-HandsOn-KOR.ipynb DELETED Viewed

@@ -1,701 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# MCP + LangGraph 핸즈온 튜토리얼\n",
-    "\n",
-    "- 작성자: [테디노트](https://youtube.com/c/teddynote)\n",
-    "- 강의: [패스트캠퍼스 RAG 비법노트](https://fastcampus.co.kr/data_online_teddy)\n",
-    "\n",
-    "**참고자료**\n",
-    "- https://modelcontextprotocol.io/introduction\n",
-    "- https://github.com/langchain-ai/langchain-mcp-adapters"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 환경설정\n",
-    "\n",
-    "아래 설치 방법을 참고하여 `uv` 를 설치합니다.\n",
-    "\n",
-    "**uv 설치 방법**\n",
-    "\n",
-    "```bash\n",
-    "# macOS/Linux\n",
-    "curl -LsSf https://astral.sh/uv/install.sh | sh\n",
-    "\n",
-    "# Windows (PowerShell)\n",
-    "irm https://astral.sh/uv/install.ps1 | iex\n",
-    "```\n",
-    "\n",
-    "**의존성 설치**\n",
-    "\n",
-    "```bash\n",
-    "uv pip install -r requirements.txt\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "환경변수를 가져옵니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## MultiServerMCPClient"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "사전에 `mcp_server_remote.py` 를 실행해둡니다. 터미널을 열고 가상환경이 활성화 되어 있는 상태에서 서버를 실행해 주세요.\n",
-    "\n",
-    "> 명령어\n",
-    "```bash\n",
-    "source .venv/bin/activate\n",
-    "python mcp_server_remote.py\n",
-    "```\n",
-    "\n",
-    "`async with` 로 일시적인 Session 연결을 생성 후 해제"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_mcp_adapters.client import MultiServerMCPClient\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from utils import ainvoke_graph, astream_graph\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "async with MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"weather\": {\n",
-    "            # 서버의 포트와 일치해야 합니다.(8005번 포트)\n",
-    "            \"url\": \"http://localhost:8005/sse\",\n",
-    "            \"transport\": \"sse\",\n",
-    "        }\n",
-    "    }\n",
-    ") as client:\n",
-    "    print(client.get_tools())\n",
-    "    agent = create_react_agent(model, client.get_tools())\n",
-    "    answer = await astream_graph(agent, {\"messages\": \"서울의 날씨는 어떠니?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "다음의 경우에는 session 이 닫혔기 때문에 도구에 접근할 수 없는 것을 확인할 수 있습니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(agent, {\"messages\": \"서울의 날씨는 어떠니?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "이제 그럼 Async Session 을 유지하며 도구에 접근하는 방식으로 변경해 보겠습니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 1. 클라이언트 생성\n",
-    "client = MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"weather\": {\n",
-    "            \"url\": \"http://localhost:8005/sse\",\n",
-    "            \"transport\": \"sse\",\n",
-    "        }\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. 명시적으로 연결 초기화 (이 부분이 필요함)\n",
-    "# 초기화\n",
-    "await client.__aenter__()\n",
-    "\n",
-    "# 이제 도구가 로드됨\n",
-    "print(client.get_tools())  # 도구가 표시됨"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "langgraph 의 에이전트를 생성합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 에이전트 생성\n",
-    "agent = create_react_agent(model, client.get_tools())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "그래프를 실행하여 결과를 확인합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(agent, {\"messages\": \"서울의 날씨는 어떠니?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Stdio 통신 방식\n",
-    "\n",
-    "Stdio 통신 방식은 로컬 환경에서 사용하기 위해 사용합니다.\n",
-    "\n",
-    "- 통신을 위해 표준 입력/출력 사용\n",
-    "\n",
-    "참고: 아래의 python 경로는 수정하세요!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from mcp import ClientSession, StdioServerParameters\n",
-    "from mcp.client.stdio import stdio_client\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from langchain_mcp_adapters.tools import load_mcp_tools\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "# Anthropic의 Claude 모델 초기화\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# StdIO 서버 파라미터 설정\n",
-    "# - command: Python 인터프리터 경로\n",
-    "# - args: 실행할 MCP 서버 스크립트\n",
-    "server_params = StdioServerParameters(\n",
-    "    command=\"./.venv/bin/python\",\n",
-    "    args=[\"mcp_server_local.py\"],\n",
-    ")\n",
-    "\n",
-    "# StdIO 클라이언트를 사용하여 서버와 통신\n",
-    "async with stdio_client(server_params) as (read, write):\n",
-    "    # 클라이언트 세션 생성\n",
-    "    async with ClientSession(read, write) as session:\n",
-    "        # 연결 초기화\n",
-    "        await session.initialize()\n",
-    "\n",
-    "        # MCP 도구 로드\n",
-    "        tools = await load_mcp_tools(session)\n",
-    "        print(tools)\n",
-    "\n",
-    "        # 에이전트 생성\n",
-    "        agent = create_react_agent(model, tools)\n",
-    "\n",
-    "        # 에이전트 응답 스트리밍\n",
-    "        await astream_graph(agent, {\"messages\": \"서울의 날씨는 어떠니?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## RAG 를 구축한 MCP 서버 사용\n",
-    "\n",
-    "- 파일: `mcp_server_rag.py`\n",
-    "\n",
-    "사전에 langchain 으로 구축한 `mcp_server_rag.py` 파일을 사용합니다.\n",
-    "\n",
-    "stdio 통신 방식으로 도구에 대한 정보를 가져옵니다. 여기서 도구는 `retriever` 도구를 가져오게 되며, 이 도구는 `mcp_server_rag.py` 에서 정의된 도구입니다. 이 파일은 사전에 서버에서 실행되지 **않아도** 됩니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from mcp import ClientSession, StdioServerParameters\n",
-    "from mcp.client.stdio import stdio_client\n",
-    "from langchain_mcp_adapters.tools import load_mcp_tools\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "from utils import astream_graph\n",
-    "\n",
-    "# Anthropic의 Claude 모델 초기화\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# RAG 서버를 위한 StdIO 서버 파라미터 설정\n",
-    "server_params = StdioServerParameters(\n",
-    "    command=\"./.venv/bin/python\",\n",
-    "    args=[\"./mcp_server_rag.py\"],\n",
-    ")\n",
-    "\n",
-    "# StdIO 클라이언트를 사용하여 RAG 서버와 통신\n",
-    "async with stdio_client(server_params) as (read, write):\n",
-    "    # 클라이언트 세션 생성\n",
-    "    async with ClientSession(read, write) as session:\n",
-    "        # 연결 초기화\n",
-    "        await session.initialize()\n",
-    "\n",
-    "        # MCP 도구 로드 (여기서는 retriever 도구)\n",
-    "        tools = await load_mcp_tools(session)\n",
-    "\n",
-    "        # 에이전트 생성 및 실행\n",
-    "        agent = create_react_agent(model, tools)\n",
-    "\n",
-    "        # 에이전트 응답 스트리밍\n",
-    "        await astream_graph(\n",
-    "            agent, {\"messages\": \"삼성전자가 개발한 생성형 AI의 이름을 검색해줘\"}\n",
-    "        )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## SSE 방식과 StdIO 방식 혼합 사용\n",
-    "\n",
-    "- 파일: `mcp_server_rag.py` 는 StdIO 방식으로 통신\n",
-    "- `langchain-dev-docs` 는 SSE 방식으로 통신\n",
-    "\n",
-    "SSE 방식과 StdIO 방식을 혼합하여 사용합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_mcp_adapters.client import MultiServerMCPClient\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "# Anthropic의 Claude 모델 초기화\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# 1. 다중 서버 MCP 클라이언트 생성\n",
-    "client = MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"document-retriever\": {\n",
-    "            \"command\": \"./.venv/bin/python\",\n",
-    "            # mcp_server_rag.py 파일의 절대 경로로 업데이트해야 합니다\n",
-    "            \"args\": [\"./mcp_server_rag.py\"],\n",
-    "            # stdio 방식으로 통신 (표준 입출력 사용)\n",
-    "            \"transport\": \"stdio\",\n",
-    "        },\n",
-    "        \"langchain-dev-docs\": {\n",
-    "            # SSE 서버가 실행 중인지 확인하세요\n",
-    "            \"url\": \"https://teddynote.io/mcp/langchain/sse\",\n",
-    "            # SSE(Server-Sent Events) 방식으로 통신\n",
-    "            \"transport\": \"sse\",\n",
-    "        },\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. 비동기 컨텍스트 매니저를 통한 명시적 연결 초기화\n",
-    "await client.__aenter__()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "langgraph 의 `create_react_agent` 를 사용하여 에이전트를 생성합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.checkpoint.memory import MemorySaver\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "prompt = (\n",
-    "    \"You are a smart agent. \"\n",
-    "    \"Use `retriever` tool to search on AI related documents and answer questions.\"\n",
-    "    \"Use `langchain-dev-docs` tool to search on langchain / langgraph related documents and answer questions.\"\n",
-    "    \"Answer in Korean.\"\n",
-    ")\n",
-    "agent = create_react_agent(\n",
-    "    model, client.get_tools(), prompt=prompt, checkpointer=MemorySaver()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "구축해 놓은 `mcp_server_rag.py` 에서 정의한 `retriever` 도구를 사용하여 검색을 수행합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = RunnableConfig(recursion_limit=30, thread_id=1)\n",
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": \"`retriever` 도구를 사용해서 삼성전자가 개발한 생성형 AI 이름을 검색해줘\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "이번에는 `langchain-dev-docs` 도구를 사용하여 검색을 수행합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config = RunnableConfig(recursion_limit=30, thread_id=1)\n",
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\"messages\": \"langgraph-dev-docs 참고해서 self-rag 의 정의에 대해서 알려줘\"},\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`MemorySaver` 를 사용하여 단기 기억을 유지합니다. 따라서, multi-turn 대화도 가능합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent, {\"messages\": \"이전의 내용을 bullet point 로 요약해줘\"}, config=config\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## LangChain 에 통합된 도구 + MCP 도구\n",
-    "\n",
-    "여기서는 LangChain 에 통합된 도구를 기존의 MCP 로만 이루어진 도구와 함께 사용이 가능한지 테스트 합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "\n",
-    "# Tavily 검색 도구를 초기화 합니다. (news 타입, 최근 3일 내 뉴스)\n",
-    "tavily = TavilySearchResults(max_results=3, topic=\"news\", days=3)\n",
-    "\n",
-    "# 기존의 MCP 도구와 함께 사용합니다.\n",
-    "tools = client.get_tools() + [tavily]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "langgraph 의 `create_react_agent` 를 사용하여 에이전트를 생성합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.checkpoint.memory import MemorySaver\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "# 재귀 제한 및 스레드 아이디 설정\n",
-    "config = RunnableConfig(recursion_limit=30, thread_id=2)\n",
-    "\n",
-    "# 프롬프트 설정\n",
-    "prompt = \"You are a smart agent with various tools. Answer questions in Korean.\"\n",
-    "\n",
-    "# 에이전트 생성\n",
-    "agent = create_react_agent(model, tools, prompt=prompt, checkpointer=MemorySaver())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "새롭게 추가한 `tavily` 도구를 사용하여 검색을 수행합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(agent, {\"messages\": \"오늘 뉴스 찾아줘\"}, config=config)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`retriever` 도구가 원활하게 작동하는 것을 확인할 수 있습니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": \"`retriever` 도구를 사용해서 삼성전자가 개발한 생성형 AI 이름을 검색해줘\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Smithery 에서 제공하는 MCP 서버\n",
-    "\n",
-    "- 링크: https://smithery.ai/"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "사용한 도구 목록은 아래와 같습니다.\n",
-    "\n",
-    "- Sequential Thinking: https://smithery.ai/server/@smithery-ai/server-sequential-thinking\n",
-    "  - 구조화된 사고 프로세스를 통해 역동적이고 성찰적인 문제 해결을 위한 도구를 제공하는 MCP 서버\n",
-    "- Desktop Commander: https://smithery.ai/server/@wonderwhy-er/desktop-commander\n",
-    "  - 다양한 편집 기능으로 터미널 명령을 실행하고 파일을 관리하세요. 코딩, 셸 및 터미널, 작업 자동화\n",
-    "\n",
-    "**참고**\n",
-    "\n",
-    "- smithery 에서 제공하는 도구를 JSON 형식으로 가져올때, 아래의 예시처럼 `\"transport\": \"stdio\"` 로 꼭 설정해야 합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_mcp_adapters.client import MultiServerMCPClient\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "# LLM 모델 초기화\n",
-    "model = ChatAnthropic(model=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000)\n",
-    "\n",
-    "# 1. 클라이언트 생성\n",
-    "client = MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"server-sequential-thinking\": {\n",
-    "            \"command\": \"npx\",\n",
-    "            \"args\": [\n",
-    "                \"-y\",\n",
-    "                \"@smithery/cli@latest\",\n",
-    "                \"run\",\n",
-    "                \"@smithery-ai/server-sequential-thinking\",\n",
-    "                \"--key\",\n",
-    "                \"89a4780a-53b7-4b7b-92e9-a29815f2669b\",\n",
-    "            ],\n",
-    "            \"transport\": \"stdio\",  # stdio 방식으로 통신을 추가합니다.\n",
-    "        },\n",
-    "        \"desktop-commander\": {\n",
-    "            \"command\": \"npx\",\n",
-    "            \"args\": [\n",
-    "                \"-y\",\n",
-    "                \"@smithery/cli@latest\",\n",
-    "                \"run\",\n",
-    "                \"@wonderwhy-er/desktop-commander\",\n",
-    "                \"--key\",\n",
-    "                \"89a4780a-53b7-4b7b-92e9-a29815f2669b\",\n",
-    "            ],\n",
-    "            \"transport\": \"stdio\",  # stdio 방식으로 통신을 추가합니다.\n",
-    "        },\n",
-    "        \"document-retriever\": {\n",
-    "            \"command\": \"./.venv/bin/python\",\n",
-    "            # mcp_server_rag.py 파일의 절대 경로로 업데이트해야 합니다\n",
-    "            \"args\": [\"./mcp_server_rag.py\"],\n",
-    "            # stdio 방식으로 통신 (표준 입출력 사용)\n",
-    "            \"transport\": \"stdio\",\n",
-    "        },\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. 명시적으로 연결 초기화\n",
-    "await client.__aenter__()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "langgraph 의 `create_react_agent` 를 사용하여 에이전트를 생성합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.checkpoint.memory import MemorySaver\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "config = RunnableConfig(recursion_limit=30, thread_id=3)\n",
-    "agent = create_react_agent(model, client.get_tools(), checkpointer=MemorySaver())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`Desktop Commander` 도구를 사용하여 터미널 명령을 실행합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": \"현재 경로를 포함한 하위 폴더 구조를 tree 로 그려줘. 단, .venv 폴더는 제외하고 출력해줘.\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "이번에는 `Sequential Thinking` 도구를 사용하여 비교적 복잡한 작업을 수행할 수 있는지 확인합니다."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": (\n",
-    "            \"`retriever` 도구를 사용해서 삼성전자가 개발한 생성형 AI 관련 내용을 검색하고 \"\n",
-    "            \"`Sequential Thinking` 도구를 사용해서 보고서를 작성해줘.\"\n",
-    "        )\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

README_KOR.md DELETED Viewed

@@ -1,232 +0,0 @@
-# LangGraph 에이전트 + MCP
-[![English](https://img.shields.io/badge/Language-English-blue)](README.md) [![Korean](https://img.shields.io/badge/Language-한국어-red)](README_KOR.md)
-[![GitHub](https://img.shields.io/badge/GitHub-langgraph--mcp--agents-black?logo=github)](https://github.com/teddylee777/langgraph-mcp-agents)
-[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
-[![Python](https://img.shields.io/badge/Python-≥3.12-blue?logo=python&logoColor=white)](https://www.python.org/)
-[![Version](https://img.shields.io/badge/Version-0.1.0-orange)](https://github.com/teddylee777/langgraph-mcp-agents)
-![project demo](./assets/project-demo.png)
-## 프로젝트 개요
-![project architecture](./assets/architecture.png)
-`LangChain-MCP-Adapters`는 **LangChain AI**에서 제공하는 툴킷으로, AI 에이전트가 Model Context Protocol(MCP)을 통해 외부 도구 및 데이터 소스와 상호작용할 수 있게 해줍니다. 이 프로젝트는 MCP 도구를 통해 다양한 데이터 소스와 API에 접근할 수 있는 ReAct 에이전트를 배포하기 위한 사용자 친화적인 인터페이스를 제공합니다.
-### 특징
-- **Streamlit 인터페이스**: MCP 도구가 포함된 LangGraph `ReAct Agent`와 상호작용하기 위한 사용자 친화적인 웹 인터페이스
-- **도구 관리**: UI를 통해 MCP 도구를 추가, 제거 및 구성(Smithery JSON 형식 지원). 애플리케이션을 재시작하지 않고도 동적으로 이루어집니다.
-- **스트리밍 응답**: 에이전트 응답과 도구 호출을 실시간으로 확인
-- **대화 기록**: 에이전트와의 대화 추적 및 관리
-## MCP 아키텍처
-MCP(Model Context Protocol)는 세 가지 주요 구성 요소로 이루어져 있습니다.
-1. **MCP 호스트**: Claude Desktop, IDE 또는 LangChain/LangGraph와 같이 MCP를 통해 데이터에 접근하고자 하는 프로그램.
-2. **MCP 클라이언트**: 서버와 1:1 연결을 유지하는 프로토콜 클라이언트로, 호스트와 서버 사이의 중개자 역할을 합니다.
-3. **MCP 서버**: 표준화된 모델 컨텍스트 프로토콜을 통해 특정 기능을 노출하는 경량 프로그램으로, 주요 데이터 소스 역할을 합니다.
-## Docker 로 빠른 실행
-로컬 Python 환경을 설정하지 않고도 Docker를 사용하여 이 프로젝트를 쉽게 실행할 수 있습니다.
-### 필수 요구사항(Docker Desktop)
-아래의 링크에서 Docker Desktop을 설치합니다.
-- [Docker Desktop 설치](https://www.docker.com/products/docker-desktop/)
-### Docker Compose로 실행하기
-1. `dockers` 디렉토리로 이동
-```bash
-cd dockers
-```
-2. 프로젝트 루트 디렉토리에 API 키가 포함된 `.env` 파일 생성.
-```bash
-cp .env.example .env
-```
-발급 받은 API 키를 `.env` 파일에 입력합니다.
-(참고) 모든 API 키가 필요하지 않습니다. 필요한 경우에만 입력하세요.
-- `ANTHROPIC_API_KEY`: Anthropic API 키를 입력할 경우 "claude-3-7-sonnet-latest", "claude-3-5-sonnet-latest", "claude-3-haiku-latest" 모델을 사용합니다.
-- `OPENAI_API_KEY`: OpenAI API 키를 입력할 경우 "gpt-4o", "gpt-4o-mini" 모델을 사용합니다.
-- `LANGSMITH_API_KEY`: LangSmith API 키를 입력할 경우 LangSmith tracing을 사용합니다.
-```bash
-ANTHROPIC_API_KEY=your_anthropic_api_key
-OPENAI_API_KEY=your_openai_api_key
-LANGSMITH_API_KEY=your_langsmith_api_key
-LANGSMITH_PROJECT=LangGraph-MCP-Agents
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-```
-(신규 기능) 로그인/로그아웃 기능 사용
-로그인 기능을 사용시 `USE_LOGIN`을 `true`로 설정하고, `USER_ID`와 `USER_PASSWORD`를 입력합니다.
-```bash
-USE_LOGIN=true
-USER_ID=admin
-USER_PASSWORD=admin123
-```
-만약, 로그인 기능을 사용하고 싶지 않다면, `USE_LOGIN`을 `false`로 설정합니다.
-```bash
-USE_LOGIN=false
-```
-3. 시스템 아키텍처에 맞는 Docker Compose 파일 선택.
-**AMD64/x86_64 아키텍처(Intel/AMD 프로세서)**
-```bash
-# 컨테이너 실행
-docker compose -f docker-compose-KOR.yaml up -d
-```
-**ARM64 아키텍처(Apple Silicon M1/M2/M3/M4)**
-```bash
-# 컨테이너 실행
-docker compose -f docker-compose-KOR-mac.yaml up -d
-```
-4. 브라우저에서 http://localhost:8585 로 애플리케이션 접속
-(참고)
-- 포트나 다른 설정을 수정해야 하는 경우, 빌드 전에 해당 docker-compose-KOR.yaml 파일을 편집하세요.
-## 소스코드로 부터 직접 설치
-1. 이 저장소를 클론합니다
-```bash
-git clone https://github.com/teddynote-lab/langgraph-mcp-agents.git
-cd langgraph-mcp-agents
-```
-2. 가상 환경을 생성하고 uv를 사용하여 의존성을 설치합니다
-```bash
-uv venv
-uv pip install -r requirements.txt
-source .venv/bin/activate  # Windows의 경우: .venv\Scripts\activate
-```
-3. API 키가 포함된 `.env` ��일을 생성합니다(`.env.example` 에서 복사)
-```bash
-cp .env.example .env
-```
-발급 받은 API 키를 `.env` 파일에 입력합니다.
-(참고) 모든 API 키가 필요하지 않습니다. 필요한 경우에만 입력하세요.
-- `ANTHROPIC_API_KEY`: Anthropic API 키를 입력할 경우 "claude-3-7-sonnet-latest", "claude-3-5-sonnet-latest", "claude-3-haiku-latest" 모델을 사용합니다.
-- `OPENAI_API_KEY`: OpenAI API 키를 입력할 경우 "gpt-4o", "gpt-4o-mini" 모델을 사용합니다.
-- `LANGSMITH_API_KEY`: LangSmith API 키를 입력할 경우 LangSmith tracing을 사용합니다.
-```bash
-ANTHROPIC_API_KEY=your_anthropic_api_key
-OPENAI_API_KEY=your_openai_api_key(optional)
-LANGSMITH_API_KEY=your_langsmith_api_key
-LANGSMITH_PROJECT=LangGraph-MCP-Agents
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-```
-4. (신규 기능) 로그인/로그아웃 기능 사용
-로그인 기능을 사용시 `USE_LOGIN`을 `true`로 설정하고, `USER_ID`와 `USER_PASSWORD`를 입력합니다.
-```bash
-USE_LOGIN=true
-USER_ID=admin
-USER_PASSWORD=admin123
-```
-만약, 로그인 기능을 사용하고 싶지 않다면, `USE_LOGIN`을 `false`로 설정합니다.
-```bash
-USE_LOGIN=false
-```
-## 사용법
-1. Streamlit 애플리케이션을 시작합니다. (한국어 버전 파일은 `app_KOR.py` 입니다.)
-```bash
-streamlit run app_KOR.py
-```
-2. 애플리케이션이 브라우저에서 실행되어 메인 인터페이스를 표시합니다.
-3. 사이드바를 사용하여 MCP 도구를 추가하고 구성합니다
-유용한 MCP 서버를 찾으려면 [Smithery](https://smithery.ai/)를 방문하세요.
-먼저, 사용하고자 하는 도구를 선택합니다.
-오른쪽의 JSON 구성에서 COPY 버튼을 누릅니다.
-![copy from Smithery](./assets/smithery-copy-json.png)
-복사된 JSON 문자열을 `Tool JSON` 섹션에 붙여넣습니다.
-<img src="./assets/add-tools.png" alt="tool json" style="width: auto; height: auto;">
-`Add Tool` 버튼을 눌러 "Registered Tools List" 섹션에 추가합니다.
-마지막으로, "Apply" 버튼을 눌러 새로운 도구로 에이전트를 초기화하도록 변경사항을 적용합니다.
-<img src="./assets/apply-tool-configuration.png" alt="tool json" style="width: auto; height: auto;">
-4. 에이전트의 상태를 확인합니다.
-![check status](./assets/check-status.png)
-5. 채팅 인터페이스에서 질문을 하여 구성된 MCP 도구를 활용하는 ReAct 에이전트와 상호작용합니다.
-![project demo](./assets/project-demo.png)
-## 핸즈온 튜토리얼
-개발자가 MCP와 LangGraph의 통합 작동 방식에 대해 더 깊이 알아보려면, 포괄적인 Jupyter 노트북 튜토리얼을 제공합니다:
-- 링크: [MCP-HandsOn-KOR.ipynb](./MCP-HandsOn-KOR.ipynb)
-이 핸즈온 튜토리얼은 다음 내용을 다룹니다.
-1. **MCP 클라이언트 설정** - MCP 서버에 연결하기 위한 MultiServerMCPClient 구성 및 초기화 방법 학습
-2. **로컬 MCP 서버 통합** - SSE 및 Stdio 메서드를 통해 로컬에서 실행 중인 MCP 서버에 연결
-3. **RAG 통합** - 문서 검색 기능을 위해 MCP를 사용하여 리트리버 도구 접근
-4. **혼합 전송 방법** - 하나의 에이전트에서 다양한 전송 프로토콜(SSE 및 Stdio) 결합
-5. **LangChain 도구 + MCP** - MCP 도구와 함께 네이티브 LangChain 도구 통합
-이 튜토리얼은 MCP 도구를 LangGraph 에이전트에 구축하고 통합하는 방법을 이해하는 데 도움이 되는 단계별 설명이 포함된 실용적인 예제를 제공합니다.
-## 라이선스
-MIT License
-## 튜토리얼 비디오 보기(한국어)
-[![Tutorial Video Thumbnail](https://img.youtube.com/vi/ISrYHGg2C2c/maxresdefault.jpg)](https://youtu.be/ISrYHGg2C2c?si=eWmKFVUS1BLtPm5U)
-## 참고 자료
-- https://github.com/langchain-ai/langchain-mcp-adapters

__pycache__/app.cpython-310.pyc ADDED Viewed

Binary file (21.6 kB). View file

__pycache__/app.cpython-312.pyc ADDED Viewed

Binary file (38.6 kB). View file

__pycache__/utils.cpython-310.pyc ADDED Viewed

Binary file (6.32 kB). View file

__pycache__/utils.cpython-312.pyc ADDED Viewed

Binary file (10.5 kB). View file

app.py CHANGED Viewed

@@ -52,10 +52,14 @@ def load_config_from_json():
         }
     }
     try:
         if os.path.exists(CONFIG_FILE_PATH):
             with open(CONFIG_FILE_PATH, "r", encoding="utf-8") as f:
-                return json.load(f)
         else:
             # Create file with default settings if it doesn't exist
             save_config_to_json(default_config)
@@ -186,8 +190,8 @@ Guidelines:
 OUTPUT_TOKEN_INFO = {
     "claude-3-5-sonnet-latest": {"max_tokens": 8192},
     "claude-3-5-haiku-latest": {"max_tokens": 8192},
-    "claude-3-7-sonnet-latest": {"max_tokens": 64000},
-    "gpt-4o": {"max_tokens": 16000},
     "gpt-4o-mini": {"max_tokens": 16000},
 }
@@ -198,10 +202,10 @@ if "session_initialized" not in st.session_state:
     st.session_state.history = []  # List for storing conversation history
     st.session_state.mcp_client = None  # Storage for MCP client object
     st.session_state.timeout_seconds = (
-        120  # Response generation time limit (seconds), default 120 seconds
     )
     st.session_state.selected_model = (
-        "claude-3-7-sonnet-latest"  # Default model selection
     )
     st.session_state.recursion_limit = 100  # Recursion call limit, default 100
@@ -230,6 +234,9 @@ async def cleanup_mcp_client():
             # st.warning(traceback.format_exc())
 def print_message():
     """
     Displays chat history on the screen.
@@ -272,6 +279,7 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
     This function creates a callback function to display responses generated from the LLM in real-time.
     It displays text responses and tool call information in separate areas.
     Args:
         text_placeholder: Streamlit component to display text responses
@@ -288,9 +296,26 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
     def callback_func(message: dict):
         nonlocal accumulated_text, accumulated_tool
         message_content = message.get("content", None)
         if isinstance(message_content, AIMessageChunk):
             content = message_content.content
             # If content is in list form (mainly occurs in Claude models)
             if isinstance(content, list) and len(content) > 0:
                 message_chunk = content[0]
@@ -320,12 +345,16 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
             ):
                 tool_call_info = message_content.tool_calls[0]
                 accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
                     st.markdown("".join(accumulated_tool))
             # Process if content is a simple string
             elif isinstance(content, str):
                 accumulated_text.append(content)
                 text_placeholder.markdown("".join(accumulated_text))
             # Process if invalid tool call information exists
@@ -345,9 +374,22 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                 and message_content.tool_call_chunks
             ):
                 tool_call_chunk = message_content.tool_call_chunks[0]
                 accumulated_tool.append(
-                    "\n```json\n" + str(tool_call_chunk) + "\n```\n"
                 )
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
@@ -359,17 +401,330 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
             ):
                 tool_call_info = message_content.additional_kwargs["tool_calls"][0]
                 accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
                     st.markdown("".join(accumulated_tool))
         # Process if it's a tool message (tool response)
         elif isinstance(message_content, ToolMessage):
-            accumulated_tool.append(
-                "\n```json\n" + str(message_content.content) + "\n```\n"
-            )
-            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
-                st.markdown("".join(accumulated_tool))
         return None
     return callback_func, accumulated_text, accumulated_tool
@@ -412,8 +767,37 @@ async def process_query(query, text_placeholder, tool_placeholder, timeout_secon
                     timeout=timeout_seconds,
                 )
             except asyncio.TimeoutError:
-                error_msg = f"⏱️ Request time exceeded {timeout_seconds} seconds. Please try again later."
                 return {"error": error_msg}, error_msg, ""
             final_text = "".join(accumulated_text_obj)
             final_tool = "".join(accumulated_tool_obj)
@@ -448,6 +832,7 @@ async def initialize_session(mcp_config=None):
         if mcp_config is None:
             # Load settings from config.json file
             mcp_config = load_config_from_json()
         client = MultiServerMCPClient(mcp_config)
         await client.__aenter__()
         tools = client.get_tools()
@@ -458,7 +843,7 @@ async def initialize_session(mcp_config=None):
         selected_model = st.session_state.selected_model
         if selected_model in [
-            "claude-3-7-sonnet-latest",
             "claude-3-5-sonnet-latest",
             "claude-3-5-haiku-latest",
         ]:
@@ -469,6 +854,7 @@ async def initialize_session(mcp_config=None):
             )
         else:  # Use OpenAI model
             model = ChatOpenAI(
                 model=selected_model,
                 temperature=0.1,
                 max_tokens=OUTPUT_TOKEN_INFO[selected_model]["max_tokens"],
@@ -497,7 +883,7 @@ with st.sidebar:
     if has_anthropic_key:
         available_models.extend(
             [
-                "claude-3-7-sonnet-latest",
                 "claude-3-5-sonnet-latest",
                 "claude-3-5-haiku-latest",
             ]
@@ -514,7 +900,7 @@ with st.sidebar:
             "⚠️ API keys are not configured. Please add ANTHROPIC_API_KEY or OPENAI_API_KEY to your .env file."
         )
         # Add Claude model as default (to show UI even without keys)
-        available_models = ["claude-3-7-sonnet-latest"]
     # Model selection dropdown
     previous_model = st.session_state.selected_model
@@ -542,7 +928,7 @@ with st.sidebar:
     st.session_state.timeout_seconds = st.slider(
         "⏱️ Response generation time limit (seconds)",
         min_value=60,
-        max_value=300,
         value=st.session_state.timeout_seconds,
         step=10,
         help="Set the maximum time for the agent to generate a response. Complex tasks may require more time.",
@@ -655,6 +1041,7 @@ with st.sidebar:
                                 st.info(
                                     f"URL detected in '{tool_name}' tool, setting transport to 'sse'."
                                 )
                             elif "transport" not in tool_config:
                                 # Set default "stdio" if URL doesn't exist and transport isn't specified
                                 tool_config["transport"] = "stdio"

         }
     }
     try:
         if os.path.exists(CONFIG_FILE_PATH):
             with open(CONFIG_FILE_PATH, "r", encoding="utf-8") as f:
+                config = json.load(f)
+                return config
         else:
             # Create file with default settings if it doesn't exist
             save_config_to_json(default_config)
 OUTPUT_TOKEN_INFO = {
     "claude-3-5-sonnet-latest": {"max_tokens": 8192},
     "claude-3-5-haiku-latest": {"max_tokens": 8192},
+    "claude-3-5-sonnet-20241022": {"max_tokens": 64000},
+    "gpt-4o": {"max_tokens": 4096}, # 16000},
     "gpt-4o-mini": {"max_tokens": 16000},
 }
     st.session_state.history = []  # List for storing conversation history
     st.session_state.mcp_client = None  # Storage for MCP client object
     st.session_state.timeout_seconds = (
+        30000  # Response generation time limit (seconds), default 120 seconds
     )
     st.session_state.selected_model = (
+        "claude-3-5-sonnet-20241022"  # Default model selection
     )
     st.session_state.recursion_limit = 100  # Recursion call limit, default 100
             # st.warning(traceback.format_exc())
 def print_message():
     """
     Displays chat history on the screen.
     This function creates a callback function to display responses generated from the LLM in real-time.
     It displays text responses and tool call information in separate areas.
+    It also supports real-time streaming updates from MCP tools.
     Args:
         text_placeholder: Streamlit component to display text responses
     def callback_func(message: dict):
         nonlocal accumulated_text, accumulated_tool
         message_content = message.get("content", None)
+        # Initialize data counter for tracking data: messages
+        if not hasattr(callback_func, '_data_counter'):
+            callback_func._data_counter = 0
+        # Initialize persistent storage for all processed data
+        if not hasattr(callback_func, '_persistent_data'):
+            callback_func._persistent_data = []
+            callback_func._persistent_data.append("🚀 **Session Started** - All data will be preserved\n")
+            callback_func._persistent_data.append("---\n")
         if isinstance(message_content, AIMessageChunk):
             content = message_content.content
             # If content is in list form (mainly occurs in Claude models)
             if isinstance(content, list) and len(content) > 0:
                 message_chunk = content[0]
             ):
                 tool_call_info = message_content.tool_calls[0]
                 accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
                     st.markdown("".join(accumulated_tool))
             # Process if content is a simple string
             elif isinstance(content, str):
+                # Regular text content
                 accumulated_text.append(content)
                 text_placeholder.markdown("".join(accumulated_text))
             # Process if invalid tool call information exists
                 and message_content.tool_call_chunks
             ):
                 tool_call_chunk = message_content.tool_call_chunks[0]
+                tool_name = tool_call_chunk.get('name', 'Unknown')
+                # Only show tool call info if it's a new tool or has meaningful changes
+                if not hasattr(callback_func, '_last_tool_name') or callback_func._last_tool_name != tool_name:
+                    accumulated_tool.append(
+                        f"\n🔧 **Tool Call**: {tool_name}\n"
+                    )
+                    callback_func._last_tool_name = tool_name
+                # Show tool call details in a more compact format
                 accumulated_tool.append(
+                    f"```json\n{str(tool_call_chunk)}\n```\n"
                 )
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
             ):
                 tool_call_info = message_content.additional_kwargs["tool_calls"][0]
                 accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
                 with tool_placeholder.expander(
                     "🔧 Tool Call Information", expanded=True
                 ):
                     st.markdown("".join(accumulated_tool))
         # Process if it's a tool message (tool response)
         elif isinstance(message_content, ToolMessage):
+            # Don't show Tool Completed immediately - wait for all streaming content
+            # Just store the tool name for later display
+            if not hasattr(callback_func, '_pending_tool_completion'):
+                callback_func._pending_tool_completion = []
+            callback_func._pending_tool_completion.append(message_content.name or "Unknown Tool")
+            # Convert streaming text to final result
+            streaming_text_items = [item for item in accumulated_tool if item.startswith("\n📊 **Streaming Text**:")]
+            if streaming_text_items:
+                # Get the last streaming text (most complete)
+                last_streaming = streaming_text_items[-1]
+                # Extract the text content
+                final_text = last_streaming.replace("\n📊 **Streaming Text**: ", "").strip()
+                if final_text:
+                    # Remove all streaming text entries
+                    accumulated_tool = [item for item in accumulated_tool if not item.startswith("\n📊 **Streaming Text**:")]
+                    # Add the final complete result
+                    accumulated_tool.append(f"\n📊 **Final Result**: {final_text}\n")
+            # Handle tool response content
+            tool_content = message_content.content
+            # Handle tool response content
+            if isinstance(tool_content, str):
+                # Look for SSE data patterns
+                if "data:" in tool_content:
+                    # Parse SSE data and extract meaningful content
+                    lines = tool_content.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if line.startswith('data:'):
+                            # Increment data counter for each data: message
+                            callback_func._data_counter += 1
+                            try:
+                                # Extract JSON content from SSE data
+                                json_str = line[5:].strip()  # Remove 'data:' prefix
+                                if json_str:
+                                    # Try to parse as JSON
+                                    import json
+                                    try:
+                                        data_obj = json.loads(json_str)
+                                        if isinstance(data_obj, dict):
+                                            # Handle different types of SSE data
+                                            if data_obj.get("type") == "result":
+                                                content = data_obj.get("content", "")
+                                                if content:
+                                                    # Check for specific server output formats
+                                                    if "```bdd-long-task-start" in content:
+                                                        # Extract task info
+                                                        import re
+                                                        match = re.search(r'```bdd-long-task-start\s*\n(.*?)\n```', content, re.DOTALL)
+                                                        if match:
+                                                            try:
+                                                                task_info = json.loads(match.group(1))
+                                                                task_id = task_info.get('id', 'Unknown')
+                                                                task_label = task_info.get('label', 'Unknown task')
+                                                                accumulated_tool.append(f"\n🚀 **Task Started** [{task_id}]: {task_label}\n")
+                                                            except:
+                                                                accumulated_tool.append(f"\n🚀 **Task Started**: {content}\n")
+                                                        # Real-time UI update for task start
+                                                        with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                            # Show data counter at the top
+                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
+                                                            st.markdown("---")
+                                                            st.markdown("".join(accumulated_tool))
+                                                    elif "```bdd-long-task-end" in content:
+                                                        # Extract task info
+                                                        import re
+                                                        match = re.search(r'```bdd-long-task-end\s*\n(.*?)\n```', content, re.DOTALL)
+                                                        if match:
+                                                            try:
+                                                                task_info = json.loads(match.group(1))
+                                                                task_id = task_info.get('id', 'Unknown')
+                                                                accumulated_tool.append(f"\n✅ **Task Completed** [{task_id}]\n")
+                                                            except:
+                                                                accumulated_tool.append(f"\n✅ **Task Completed**: {content}\n")
+                                                        # Real-time UI update for task completion
+                                                        with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                            # Show data counter at the top
+                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
+                                                            st.markdown("---")
+                                                            st.markdown("".join(accumulated_tool))
+                                                    elif "```bdd-resource-lookup" in content:
+                                                        # Extract resource info
+                                                        import re
+                                                        match = re.search(r'```bdd-resource-lookup\s*\n(.*?)\n```', content, re.DOTALL)
+                                                        if match:
+                                                            try:
+                                                                resources = json.loads(match.group(1))
+                                                                if isinstance(resources, list):
+                                                                    accumulated_tool.append(f"\n📚 **Resources Found**: {len(resources)} items\n")
+                                                                    for i, resource in enumerate(resources[:3]):  # Show first 3
+                                                                        source = resource.get('source', 'Unknown')
+                                                                        doc_id = resource.get('docId', 'Unknown')
+                                                                        citation = resource.get('citation', '')
+                                                                        accumulated_tool.append(f"  - {source}: {doc_id} [citation:{citation}]\n")
+                                                                    if len(resources) > 3:
+                                                                        accumulated_tool.append(f"  ... and {len(resources) - 3} more\n")
+                                                            except:
+                                                                accumulated_tool.append(f"\n📚 **Resources**: {content}\n")
+                                                        # Real-time UI update for resources
+                                                        with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                            # Show data counter at the top
+                                                            st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
+                                                            st.markdown("---")
+                                                            st.markdown("".join(accumulated_tool))
+                                                    elif "```bdd-chat-agent-task" in content:
+                                                        # Extract chat agent task info
+                                                        import re
+                                                        match = re.search(r'```bdd-chat-agent-task\s*\n(.*?)\n```', content, re.DOTALL)
+                                                        if match:
+                                                            try:
+                                                                task_info = json.loads(match.group(1))
+                                                                task_type = task_info.get('type', 'Unknown')
+                                                                task_label = task_info.get('label', 'Unknown')
+                                                                task_status = task_info.get('status', 'Unknown')
+                                                                accumulated_tool.append(f"\n🤖 **Agent Task** [{task_status}]: {task_type} - {task_label}\n")
+                                                            except:
+                                                                accumulated_tool.append(f"\n🤖 **Agent Task**: {content}\n")
+                                                    elif "ping - " in content:
+                                                        # Extract timestamp from ping messages
+                                                        timestamp = content.split("ping - ")[-1]
+                                                        accumulated_tool.append(f"⏱️ **Progress Update**: {timestamp}\n")
+                                                    elif data_obj.get("type") == "done":
+                                                        # Task completion
+                                                        accumulated_tool.append(f"\n🎯 **Task Done**: {content}\n")
+                                                    else:
+                                                        # Regular result content - accumulate text for better readability
+                                                        if not hasattr(callback_func, '_result_buffer'):
+                                                            callback_func._result_buffer = ""
+                                                        callback_func._result_buffer += content
+                                                        # For simple text streams (like health check or mock mock), update more frequently
+                                                        # Check if this is a simple text response (not BDD format)
+                                                        is_simple_text = not any(marker in content for marker in ['```bdd-', 'ping -', 'data:'])
+                                                        # For simple text streams, always update immediately to show all fragments
+                                                        if is_simple_text and content.strip():
+                                                            # Clear previous streaming text entries and add updated one
+                                                            accumulated_tool = [item for item in accumulated_tool if not item.startswith("\n📊 **Streaming Text**:")]
+                                                            # Add the updated complete streaming text in one line
+                                                            accumulated_tool.append(f"\n📊 **Streaming Text**: {callback_func._result_buffer}\n")
+                                                            # Immediate UI update for text streams
+                                                            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                                st.markdown("".join(accumulated_tool))
+                                                        else:
+                                                            # For complex content, use timed updates
+                                                            update_interval = 0.2 if len(content.strip()) <= 10 else 0.5
+                                                            # Only update display periodically to avoid excessive updates
+                                                            if not hasattr(callback_func, '_last_update_time'):
+                                                                callback_func._last_update_time = 0
+                                                            import time
+                                                            current_time = time.time()
+                                                            if current_time - callback_func._last_update_time > update_interval:
+                                                                # For complex content, show accumulated buffer
+                                                                accumulated_tool.append(f"\n📊 **Result Update**:\n")
+                                                                accumulated_tool.append(f"```\n{callback_func._result_buffer}\n```\n")
+                                                                callback_func._last_update_time = current_time
+                                                                # Real-time UI update
+                                                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                                    st.markdown("".join(accumulated_tool))
+                                            else:
+                                                # Handle other data types that are not "result" type
+                                                # This ensures ALL data: messages are processed and displayed
+                                                data_type = data_obj.get("type", "unknown")
+                                                data_content = data_obj.get("content", str(data_obj))
+                                                # Add timestamp for real-time tracking
+                                                import time
+                                                timestamp = time.strftime("%H:%M:%S")
+                                                # Format the data for display
+                                                data_entry = ""
+                                                if isinstance(data_content, str):
+                                                    data_entry = f"\n📡 **Data [{data_type}]** [{timestamp}]: {data_content}\n"
+                                                else:
+                                                    data_entry = f"\n📡 **Data [{data_type}]** [{timestamp}]:\n```json\n{json.dumps(data_obj, indent=2)}\n```\n"
+                                                # Add to both temporary and persistent storage
+                                                accumulated_tool.append(data_entry)
+                                                callback_func._persistent_data.append(data_entry)
+                                                # Immediate real-time UI update for any data: message
+                                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                    # Show data counter at the top
+                                                    st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
+                                                    st.markdown("---")
+                                                    # Show persistent data first, then current accumulated data
+                                                    st.markdown("".join(callback_func._persistent_data))
+                                                    st.markdown("---")
+                                                    st.markdown("**🔄 Current Stream:**")
+                                                    st.markdown("".join(accumulated_tool))
+                                        else:
+                                            # Handle non-dict data objects
+                                            import time
+                                            timestamp = time.strftime("%H:%M:%S")
+                                            data_entry = f"\n📡 **Raw Data** [{timestamp}]:\n```json\n{json_str}\n```\n"
+                                            # Add to both temporary and persistent storage
+                                            accumulated_tool.append(data_entry)
+                                            callback_func._persistent_data.append(data_entry)
+                                            # Immediate real-time UI update
+                                            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                # Show data counter at the top
+                                                st.markdown(f"**📊 Total Data Messages: {callback_func._data_counter}**")
+                                                st.markdown("---")
+                                                # Show persistent data first, then current accumulated data
+                                                st.markdown("".join(callback_func._persistent_data))
+                                                st.markdown("---")
+                                                st.markdown("**🔄 Current Stream:**")
+                                                st.markdown("".join(accumulated_tool))
+                                    except json.JSONDecodeError:
+                                        # If not valid JSON, check if it's streaming text content
+                                        if json_str and len(json_str.strip()) > 0:
+                                            # This might be streaming text, accumulate it
+                                            if not hasattr(callback_func, '_stream_buffer'):
+                                                callback_func._stream_buffer = ""
+                                            callback_func._stream_buffer += json_str
+                                            # Only show streaming content periodically
+                                            if not hasattr(callback_func, '_stream_update_time'):
+                                                callback_func._stream_update_time = 0
+                                            import time
+                                            current_time = time.time()
+                                            if current_time - callback_func._stream_update_time > 0.3:  # Update every 0.3 seconds for better responsiveness
+                                                # Add new streaming update without clearing previous ones
+                                                if callback_func._stream_buffer.strip():
+                                                    accumulated_tool.append(f"\n📝 **Streaming Update**: {callback_func._stream_buffer}\n")
+                                                callback_func._stream_update_time = current_time
+                                                # Real-time UI update
+                                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                    st.markdown("".join(accumulated_tool))
+                                        else:
+                                            # Handle empty or whitespace-only data
+                                            import time
+                                            timestamp = time.strftime("%H:%M:%S")
+                                            accumulated_tool.append(f"\n📡 **Empty Data** [{timestamp}]: (empty or whitespace)\n")
+                                            # Immediate real-time UI update
+                                            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                                st.markdown("".join(accumulated_tool))
+                            except Exception as e:
+                                # Fallback: treat as plain text, but only if it's meaningful
+                                import time
+                                timestamp = time.strftime("%H:%M:%S")
+                                if line.strip() and len(line.strip()) > 1:  # Only show non-trivial content
+                                    accumulated_tool.append(f"\n📝 **Info** [{timestamp}]: {line.strip()}\n")
+                                else:
+                                    accumulated_tool.append(f"\n⚠️ **Error** [{timestamp}]: {str(e)}\n")
+                                # Immediate real-time UI update for error cases
+                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                    st.markdown("".join(accumulated_tool))
+                        elif line.startswith('ping - '):
+                            # Handle ping messages directly
+                            timestamp = line.split('ping - ')[-1]
+                            accumulated_tool.append(f"⏱️ **Progress Update**: {timestamp}\n")
+                            # Immediate real-time UI update for ping messages
+                            with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                st.markdown("".join(accumulated_tool))
+                        elif line and not line.startswith(':'):
+                            # Other non-empty lines - capture any other data patterns
+                            import time
+                            timestamp = time.strftime("%H:%M:%S")
+                            # Check if this line contains any meaningful data
+                            if line.strip() and len(line.strip()) > 1:
+                                # Try to detect if it's JSON-like content
+                                if line.strip().startswith('{') or line.strip().startswith('['):
+                                    try:
+                                        # Try to parse as JSON for better formatting
+                                        import json
+                                        parsed_json = json.loads(line.strip())
+                                        accumulated_tool.append(f"\n📡 **JSON Data** [{timestamp}]:\n```json\n{json.dumps(parsed_json, indent=2)}\n```\n")
+                                    except:
+                                        # If not valid JSON, show as regular data
+                                        accumulated_tool.append(f"\n📡 **Data** [{timestamp}]: {line.strip()}\n")
+                                else:
+                                    # Regular text data
+                                    accumulated_tool.append(f"\n📝 **Info** [{timestamp}]: {line.strip()}\n")
+                                # Immediate real-time UI update for any captured data
+                                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
+                                    st.markdown("".join(accumulated_tool))
+                else:
+                    # Regular tool response content
+                    accumulated_tool.append(
+                        "\n```json\n" + str(tool_content) + "\n```\n"
+                    )
+            else:
+                # Non-string content
+                accumulated_tool.append(
+                    "\n```json\n" + str(tool_content) + "\n```\n"
+                )
+            # Show pending tool completion status after all streaming content
+            if hasattr(callback_func, '_pending_tool_completion') and callback_func._pending_tool_completion:
+                for tool_name in callback_func._pending_tool_completion:
+                    accumulated_tool.append(f"\n✅ **Tool Completed**: {tool_name}\n")
+                # Clear the pending list
+                callback_func._pending_tool_completion = []
         return None
     return callback_func, accumulated_text, accumulated_tool
                     timeout=timeout_seconds,
                 )
             except asyncio.TimeoutError:
+                # On timeout, reset thread to avoid leaving an incomplete tool call in memory
+                st.session_state.thread_id = random_uuid()
+                error_msg = (
+                    f"⏱️ Request time exceeded {timeout_seconds} seconds. Conversation was reset. Please retry."
+                )
                 return {"error": error_msg}, error_msg, ""
+            except ValueError as e:
+                # Handle invalid chat history caused by incomplete tool calls
+                if "Found AIMessages with tool_calls" in str(e):
+                    # Reset thread and retry once
+                    st.session_state.thread_id = random_uuid()
+                    try:
+                        response = await asyncio.wait_for(
+                            astream_graph(
+                                st.session_state.agent,
+                                {"messages": [HumanMessage(content=query)]},
+                                callback=streaming_callback,
+                                config=RunnableConfig(
+                                    recursion_limit=st.session_state.recursion_limit,
+                                    thread_id=st.session_state.thread_id,
+                                ),
+                            ),
+                            timeout=timeout_seconds,
+                        )
+                    except Exception:
+                        error_msg = (
+                            "⚠️ Conversation state was invalid and has been reset. Please try again."
+                        )
+                        return {"error": error_msg}, error_msg, ""
+                else:
+                    raise
             final_text = "".join(accumulated_text_obj)
             final_tool = "".join(accumulated_tool_obj)
         if mcp_config is None:
             # Load settings from config.json file
             mcp_config = load_config_from_json()
         client = MultiServerMCPClient(mcp_config)
         await client.__aenter__()
         tools = client.get_tools()
         selected_model = st.session_state.selected_model
         if selected_model in [
+            "claude-3-5-sonnet-20241022",
             "claude-3-5-sonnet-latest",
             "claude-3-5-haiku-latest",
         ]:
             )
         else:  # Use OpenAI model
             model = ChatOpenAI(
+                base_url=os.environ.get("OPENAI_API_BASE"),
                 model=selected_model,
                 temperature=0.1,
                 max_tokens=OUTPUT_TOKEN_INFO[selected_model]["max_tokens"],
     if has_anthropic_key:
         available_models.extend(
             [
+                "claude-3-5-sonnet-20241022",
                 "claude-3-5-sonnet-latest",
                 "claude-3-5-haiku-latest",
             ]
             "⚠️ API keys are not configured. Please add ANTHROPIC_API_KEY or OPENAI_API_KEY to your .env file."
         )
         # Add Claude model as default (to show UI even without keys)
+        available_models = ["claude-3-5-sonnet-20241022"]
     # Model selection dropdown
     previous_model = st.session_state.selected_model
     st.session_state.timeout_seconds = st.slider(
         "⏱️ Response generation time limit (seconds)",
         min_value=60,
+        max_value=300000,
         value=st.session_state.timeout_seconds,
         step=10,
         help="Set the maximum time for the agent to generate a response. Complex tasks may require more time.",
                                 st.info(
                                     f"URL detected in '{tool_name}' tool, setting transport to 'sse'."
                                 )
                             elif "transport" not in tool_config:
                                 # Set default "stdio" if URL doesn't exist and transport isn't specified
                                 tool_config["transport"] = "stdio"

app_KOR.py DELETED Viewed

@@ -1,848 +0,0 @@
-import streamlit as st
-import asyncio
-import nest_asyncio
-import json
-import os
-import platform
-if platform.system() == "Windows":
-    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-# nest_asyncio 적용: 이미 실행 중인 이벤트 루프 내에서 중첩 호출 허용
-nest_asyncio.apply()
-# 전역 이벤트 루프 생성 및 재사용 (한번 생성한 후 계속 사용)
-if "event_loop" not in st.session_state:
-    loop = asyncio.new_event_loop()
-    st.session_state.event_loop = loop
-    asyncio.set_event_loop(loop)
-from langgraph.prebuilt import create_react_agent
-from langchain_anthropic import ChatAnthropic
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import HumanMessage
-from dotenv import load_dotenv
-from langchain_mcp_adapters.client import MultiServerMCPClient
-from utils import astream_graph, random_uuid
-from langchain_core.messages.ai import AIMessageChunk
-from langchain_core.messages.tool import ToolMessage
-from langgraph.checkpoint.memory import MemorySaver
-from langchain_core.runnables import RunnableConfig
-# 환경 변수 로드 (.env 파일에서 API 키 등의 설정을 가져옴)
-load_dotenv(override=True)
-# config.json 파일 경로 설정
-CONFIG_FILE_PATH = "config.json"
-# JSON 설정 파일 로드 함수
-def load_config_from_json():
-    """
-    config.json 파일에서 설정을 로드합니다.
-    파일이 없는 경우 기본 설정으로 파일을 생성합니다.
-    반환값:
-        dict: 로드된 설정
-    """
-    default_config = {
-        "get_current_time": {
-            "command": "python",
-            "args": ["./mcp_server_time.py"],
-            "transport": "stdio"
-        }
-    }
-    try:
-        if os.path.exists(CONFIG_FILE_PATH):
-            with open(CONFIG_FILE_PATH, "r", encoding="utf-8") as f:
-                return json.load(f)
-        else:
-            # 파일이 없는 경우 기본 설정으로 파일 생성
-            save_config_to_json(default_config)
-            return default_config
-    except Exception as e:
-        st.error(f"설정 파일 로드 중 오류 발생: {str(e)}")
-        return default_config
-# JSON 설정 파일 저장 함수
-def save_config_to_json(config):
-    """
-    설정을 config.json 파일에 저장합니다.
-    매개변수:
-        config (dict): 저장할 설정
-    반환값:
-        bool: 저장 성공 여부
-    """
-    try:
-        with open(CONFIG_FILE_PATH, "w", encoding="utf-8") as f:
-            json.dump(config, f, indent=2, ensure_ascii=False)
-        return True
-    except Exception as e:
-        st.error(f"설정 파일 저장 중 오류 발생: {str(e)}")
-        return False
-# 로그인 세션 변수 초기화
-if "authenticated" not in st.session_state:
-    st.session_state.authenticated = False
-# 로그인 필요 여부 확인
-use_login = os.environ.get("USE_LOGIN", "false").lower() == "true"
-# 로그인 상태에 따라 페이지 설정 변경
-if use_login and not st.session_state.authenticated:
-    # 로그인 페이지는 기본(narrow) 레이아웃 사용
-    st.set_page_config(page_title="Agent with MCP Tools", page_icon="🧠")
-else:
-    # 메인 앱은 wide 레이아웃 사용
-    st.set_page_config(page_title="Agent with MCP Tools", page_icon="🧠", layout="wide")
-# 로그인 기능이 활성화되어 있고 아직 인증되지 않은 경우 로그인 화면 표시
-if use_login and not st.session_state.authenticated:
-    st.title("🔐 로그인")
-    st.markdown("시스템을 사용하려면 로그인이 필요합니다.")
-    # 로그인 폼을 화면 중앙에 좁게 배치
-    with st.form("login_form"):
-        username = st.text_input("아이디")
-        password = st.text_input("비밀번호", type="password")
-        submit_button = st.form_submit_button("로그인")
-        if submit_button:
-            expected_username = os.environ.get("USER_ID")
-            expected_password = os.environ.get("USER_PASSWORD")
-            if username == expected_username and password == expected_password:
-                st.session_state.authenticated = True
-                st.success("✅ 로그인 성공! 잠시만 기다려주세요...")
-                st.rerun()
-            else:
-                st.error("❌ 아이디 또는 비밀번호가 올바르지 않습니다.")
-    # 로그인 화면에서는 메인 앱을 표시하지 않음
-    st.stop()
-# 사이드바 최상단에 저자 정보 추가 (다른 사이드바 요소보다 먼저 배치)
-st.sidebar.markdown("### ✍️ Made by [테디노트](https://youtube.com/c/teddynote) 🚀")
-st.sidebar.markdown(
-    "### 💻 [Project Page](https://github.com/teddynote-lab/langgraph-mcp-agents)"
-)
-st.sidebar.divider()  # 구분선 추가
-# 기존 페이지 타이틀 및 설명
-st.title("💬 MCP 도구 활용 에이전트")
-st.markdown("✨ MCP 도구를 활용한 ReAct 에이전트에게 질문해보세요.")
-SYSTEM_PROMPT = """<ROLE>
-You are a smart agent with an ability to use tools.
-You will be given a question and you will use the tools to answer the question.
-Pick the most relevant tool to answer the question.
-If you are failed to answer the question, try different tools to get context.
-Your answer should be very polite and professional.
-</ROLE>
-----
-<INSTRUCTIONS>
-Step 1: Analyze the question
-- Analyze user's question and final goal.
-- If the user's question is consist of multiple sub-questions, split them into smaller sub-questions.
-Step 2: Pick the most relevant tool
-- Pick the most relevant tool to answer the question.
-- If you are failed to answer the question, try different tools to get context.
-Step 3: Answer the question
-- Answer the question in the same language as the question.
-- Your answer should be very polite and professional.
-Step 4: Provide the source of the answer(if applicable)
-- If you've used the tool, provide the source of the answer.
-- Valid sources are either a website(URL) or a document(PDF, etc).
-Guidelines:
-- If you've used the tool, your answer should be based on the tool's output(tool's output is more important than your own knowledge).
-- If you've used the tool, and the source is valid URL, provide the source(URL) of the answer.
-- Skip providing the source if the source is not URL.
-- Answer in the same language as the question.
-- Answer should be concise and to the point.
-- Avoid response your output with any other information than the answer and the source.
-</INSTRUCTIONS>
-----
-<OUTPUT_FORMAT>
-(concise answer to the question)
-**Source**(if applicable)
-- (source1: valid URL)
-- (source2: valid URL)
-- ...
-</OUTPUT_FORMAT>
-"""
-OUTPUT_TOKEN_INFO = {
-    "claude-3-5-sonnet-latest": {"max_tokens": 8192},
-    "claude-3-5-haiku-latest": {"max_tokens": 8192},
-    "claude-3-7-sonnet-latest": {"max_tokens": 64000},
-    "gpt-4o": {"max_tokens": 16000},
-    "gpt-4o-mini": {"max_tokens": 16000},
-}
-# 세션 상태 초기화
-if "session_initialized" not in st.session_state:
-    st.session_state.session_initialized = False  # 세션 초기화 상태 플래그
-    st.session_state.agent = None  # ReAct 에이전트 객체 저장 공간
-    st.session_state.history = []  # 대화 기록 저장 리스트
-    st.session_state.mcp_client = None  # MCP 클라이언트 객체 저장 공간
-    st.session_state.timeout_seconds = 120  # 응답 생성 제한 시간(초), 기본값 120초
-    st.session_state.selected_model = "claude-3-7-sonnet-latest"  # 기본 모델 선택
-    st.session_state.recursion_limit = 100  # 재귀 호출 제한, 기본값 100
-if "thread_id" not in st.session_state:
-    st.session_state.thread_id = random_uuid()
-# --- 함수 정의 부분 ---
-async def cleanup_mcp_client():
-    """
-    기존 MCP 클라이언트를 안전하게 종료합니다.
-    기존 클라이언트가 있는 경우 정상적으로 리소스를 해제합니다.
-    """
-    if "mcp_client" in st.session_state and st.session_state.mcp_client is not None:
-        try:
-            await st.session_state.mcp_client.__aexit__(None, None, None)
-            st.session_state.mcp_client = None
-        except Exception as e:
-            import traceback
-            # st.warning(f"MCP 클라이언트 종료 중 오류: {str(e)}")
-            # st.warning(traceback.format_exc())
-def print_message():
-    """
-    채팅 기록을 화면에 출력합니다.
-    사용자와 어시스턴트의 메시지를 구분하여 화면에 표시하고,
-    도구 호출 정보는 어시스턴트 메시지 컨테이너 내에 표시합니다.
-    """
-    i = 0
-    while i < len(st.session_state.history):
-        message = st.session_state.history[i]
-        if message["role"] == "user":
-            st.chat_message("user", avatar="🧑‍💻").markdown(message["content"])
-            i += 1
-        elif message["role"] == "assistant":
-            # 어시스턴트 메시지 컨테이너 생성
-            with st.chat_message("assistant", avatar="🤖"):
-                # 어시스턴트 메시지 내용 표시
-                st.markdown(message["content"])
-                # 다음 메시지가 도구 호출 정보인지 확인
-                if (
-                    i + 1 < len(st.session_state.history)
-                    and st.session_state.history[i + 1]["role"] == "assistant_tool"
-                ):
-                    # 도구 호출 정보를 동일한 컨테이너 내에 expander로 표시
-                    with st.expander("🔧 도구 호출 정보", expanded=False):
-                        st.markdown(st.session_state.history[i + 1]["content"])
-                    i += 2  # 두 메시지를 함께 처리했으므로 2 증가
-                else:
-                    i += 1  # 일반 메시지만 처리했으므로 1 증가
-        else:
-            # assistant_tool 메시지는 위에서 처리되므로 건너뜀
-            i += 1
-def get_streaming_callback(text_placeholder, tool_placeholder):
-    """
-    스트리밍 콜백 함수를 생성합니다.
-    이 함수는 LLM에서 생성되는 응답을 실시간으로 화면에 표시하기 위한 콜백 함수를 생성합니다.
-    텍스트 응답과 도구 호출 정보를 각각 다른 영역에 표시합니다.
-    매개변수:
-        text_placeholder: 텍스트 응답을 표시할 Streamlit 컴포넌트
-        tool_placeholder: 도구 호출 정보를 표시할 Streamlit 컴포넌트
-    반환값:
-        callback_func: 스트리밍 콜백 함수
-        accumulated_text: 누적된 텍스트 응답을 저장하는 리스트
-        accumulated_tool: 누적된 도구 호출 정보를 저장하는 리스트
-    """
-    accumulated_text = []
-    accumulated_tool = []
-    def callback_func(message: dict):
-        nonlocal accumulated_text, accumulated_tool
-        message_content = message.get("content", None)
-        if isinstance(message_content, AIMessageChunk):
-            content = message_content.content
-            # 콘텐츠가 리스트 형태인 경우 (Claude 모델 등에서 주로 발생)
-            if isinstance(content, list) and len(content) > 0:
-                message_chunk = content[0]
-                # 텍스트 타입인 경우 처리
-                if message_chunk["type"] == "text":
-                    accumulated_text.append(message_chunk["text"])
-                    text_placeholder.markdown("".join(accumulated_text))
-                # 도구 사용 타입인 경우 처리
-                elif message_chunk["type"] == "tool_use":
-                    if "partial_json" in message_chunk:
-                        accumulated_tool.append(message_chunk["partial_json"])
-                    else:
-                        tool_call_chunks = message_content.tool_call_chunks
-                        tool_call_chunk = tool_call_chunks[0]
-                        accumulated_tool.append(
-                            "\n```json\n" + str(tool_call_chunk) + "\n```\n"
-                        )
-                    with tool_placeholder.expander("🔧 도구 호출 정보", expanded=True):
-                        st.markdown("".join(accumulated_tool))
-            # tool_calls 속성이 있는 경우 처리 (OpenAI 모델 등에서 주로 발생)
-            elif (
-                hasattr(message_content, "tool_calls")
-                and message_content.tool_calls
-                and len(message_content.tool_calls[0]["name"]) > 0
-            ):
-                tool_call_info = message_content.tool_calls[0]
-                accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
-                with tool_placeholder.expander("🔧 도구 호출 정보", expanded=True):
-                    st.markdown("".join(accumulated_tool))
-            # 단순 문자열인 경우 처리
-            elif isinstance(content, str):
-                accumulated_text.append(content)
-                text_placeholder.markdown("".join(accumulated_text))
-            # 유효하지 않은 도구 호출 정보가 있는 경우 처리
-            elif (
-                hasattr(message_content, "invalid_tool_calls")
-                and message_content.invalid_tool_calls
-            ):
-                tool_call_info = message_content.invalid_tool_calls[0]
-                accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
-                with tool_placeholder.expander(
-                    "🔧 도구 호출 정보 (유효하지 않음)", expanded=True
-                ):
-                    st.markdown("".join(accumulated_tool))
-            # tool_call_chunks 속성이 있는 경우 처리
-            elif (
-                hasattr(message_content, "tool_call_chunks")
-                and message_content.tool_call_chunks
-            ):
-                tool_call_chunk = message_content.tool_call_chunks[0]
-                accumulated_tool.append(
-                    "\n```json\n" + str(tool_call_chunk) + "\n```\n"
-                )
-                with tool_placeholder.expander("🔧 도구 호출 정보", expanded=True):
-                    st.markdown("".join(accumulated_tool))
-            # additional_kwargs에 tool_calls가 있는 경우 처리 (다양한 모델 호환성 지원)
-            elif (
-                hasattr(message_content, "additional_kwargs")
-                and "tool_calls" in message_content.additional_kwargs
-            ):
-                tool_call_info = message_content.additional_kwargs["tool_calls"][0]
-                accumulated_tool.append("\n```json\n" + str(tool_call_info) + "\n```\n")
-                with tool_placeholder.expander("🔧 도구 호출 정보", expanded=True):
-                    st.markdown("".join(accumulated_tool))
-        # 도구 메시지인 경우 처리 (도구의 응답)
-        elif isinstance(message_content, ToolMessage):
-            accumulated_tool.append(
-                "\n```json\n" + str(message_content.content) + "\n```\n"
-            )
-            with tool_placeholder.expander("🔧 도구 호��� 정보", expanded=True):
-                st.markdown("".join(accumulated_tool))
-        return None
-    return callback_func, accumulated_text, accumulated_tool
-async def process_query(query, text_placeholder, tool_placeholder, timeout_seconds=60):
-    """
-    사용자 질문을 처리하고 응답을 생성합니다.
-    이 함수는 사용자의 질문을 에이전트에 전달하고, 응답을 실시간으로 스트리밍하여 표시합니다.
-    지정된 시간 내에 응답이 완료되지 않으면 타임아웃 오류를 반환합니다.
-    매개변수:
-        query: 사용자가 입력한 질문 텍스트
-        text_placeholder: 텍스트 응답을 표시할 Streamlit 컴포넌트
-        tool_placeholder: 도구 호출 정보를 표시할 Streamlit 컴포넌트
-        timeout_seconds: 응답 생성 제한 시간(초)
-    반환값:
-        response: 에이전트의 응답 객체
-        final_text: 최종 텍스트 응답
-        final_tool: 최종 도구 호출 정보
-    """
-    try:
-        if st.session_state.agent:
-            streaming_callback, accumulated_text_obj, accumulated_tool_obj = (
-                get_streaming_callback(text_placeholder, tool_placeholder)
-            )
-            try:
-                response = await asyncio.wait_for(
-                    astream_graph(
-                        st.session_state.agent,
-                        {"messages": [HumanMessage(content=query)]},
-                        callback=streaming_callback,
-                        config=RunnableConfig(
-                            recursion_limit=st.session_state.recursion_limit,
-                            thread_id=st.session_state.thread_id,
-                        ),
-                    ),
-                    timeout=timeout_seconds,
-                )
-            except asyncio.TimeoutError:
-                error_msg = f"⏱️ 요청 시간이 {timeout_seconds}초를 초과했습니다. 나중에 다시 시도해 주세요."
-                return {"error": error_msg}, error_msg, ""
-            final_text = "".join(accumulated_text_obj)
-            final_tool = "".join(accumulated_tool_obj)
-            return response, final_text, final_tool
-        else:
-            return (
-                {"error": "🚫 에이전트가 초기화되지 않았습니다."},
-                "🚫 에이전트가 초기화되지 않았습니다.",
-                "",
-            )
-    except Exception as e:
-        import traceback
-        error_msg = f"❌ 쿼리 처리 중 오류 발생: {str(e)}\n{traceback.format_exc()}"
-        return {"error": error_msg}, error_msg, ""
-async def initialize_session(mcp_config=None):
-    """
-    MCP 세션과 에이전트를 초기화합니다.
-    매개변수:
-        mcp_config: MCP 도구 설정 정보(JSON). None인 경우 기본 설정 사용
-    반환값:
-        bool: 초기화 성공 여부
-    """
-    with st.spinner("🔄 MCP 서버에 연결 중..."):
-        # 먼저 기존 클라이언트를 안전하게 정리
-        await cleanup_mcp_client()
-        if mcp_config is None:
-            # config.json 파일에서 설정 로드
-            mcp_config = load_config_from_json()
-        client = MultiServerMCPClient(mcp_config)
-        await client.__aenter__()
-        tools = client.get_tools()
-        st.session_state.tool_count = len(tools)
-        st.session_state.mcp_client = client
-        # 선택된 모델에 따라 적절한 모델 초기화
-        selected_model = st.session_state.selected_model
-        if selected_model in [
-            "claude-3-7-sonnet-latest",
-            "claude-3-5-sonnet-latest",
-            "claude-3-5-haiku-latest",
-        ]:
-            model = ChatAnthropic(
-                model=selected_model,
-                temperature=0.1,
-                max_tokens=OUTPUT_TOKEN_INFO[selected_model]["max_tokens"],
-            )
-        else:  # OpenAI 모델 사용
-            model = ChatOpenAI(
-                model=selected_model,
-                temperature=0.1,
-                max_tokens=OUTPUT_TOKEN_INFO[selected_model]["max_tokens"],
-            )
-        agent = create_react_agent(
-            model,
-            tools,
-            checkpointer=MemorySaver(),
-            prompt=SYSTEM_PROMPT,
-        )
-        st.session_state.agent = agent
-        st.session_state.session_initialized = True
-        return True
-# --- 사이드바: 시스템 설정 섹션 ---
-with st.sidebar:
-    st.subheader("⚙️ 시스템 설정")
-    # 모델 선택 기능
-    # 사용 가능한 모델 목록 생성
-    available_models = []
-    # Anthropic API 키 확인
-    has_anthropic_key = os.environ.get("ANTHROPIC_API_KEY") is not None
-    if has_anthropic_key:
-        available_models.extend(
-            [
-                "claude-3-7-sonnet-latest",
-                "claude-3-5-sonnet-latest",
-                "claude-3-5-haiku-latest",
-            ]
-        )
-    # OpenAI API 키 확인
-    has_openai_key = os.environ.get("OPENAI_API_KEY") is not None
-    if has_openai_key:
-        available_models.extend(["gpt-4o", "gpt-4o-mini"])
-    # 사용 가능한 모델이 없는 경우 메시지 표시
-    if not available_models:
-        st.warning(
-            "⚠️ API 키가 설정되지 않았습니다. .env 파일에 ANTHROPIC_API_KEY 또는 OPENAI_API_KEY를 추가해주세요."
-        )
-        # 기본값으로 Claude 모델 추가 (키가 없어도 UI를 보여주기 위함)
-        available_models = ["claude-3-7-sonnet-latest"]
-    # 모델 선택 드롭다운
-    previous_model = st.session_state.selected_model
-    st.session_state.selected_model = st.selectbox(
-        "🤖 사용할 모델 선택",
-        options=available_models,
-        index=(
-            available_models.index(st.session_state.selected_model)
-            if st.session_state.selected_model in available_models
-            else 0
-        ),
-        help="Anthropic 모델은 ANTHROPIC_API_KEY가, OpenAI 모델은 OPENAI_API_KEY가 환경변수로 설정되어야 합니다.",
-    )
-    # 모델이 변경되었을 때 세션 초기화 필요 알림
-    if (
-        previous_model != st.session_state.selected_model
-        and st.session_state.session_initialized
-    ):
-        st.warning(
-            "⚠️ 모델이 변경되었습니다. '설정 적용하기' 버튼을 눌러 변경사항을 적용하세요."
-        )
-    # 타임아웃 설정 슬라이더 추가
-    st.session_state.timeout_seconds = st.slider(
-        "⏱️ 응답 생성 제한 시간(초)",
-        min_value=60,
-        max_value=300,
-        value=st.session_state.timeout_seconds,
-        step=10,
-        help="에이전트가 응답을 생성하는 최대 시간을 설정합니다. 복잡한 작업은 더 긴 시간이 필요할 수 있습니다.",
-    )
-    st.session_state.recursion_limit = st.slider(
-        "⏱️ 재귀 호출 제한(횟수)",
-        min_value=10,
-        max_value=200,
-        value=st.session_state.recursion_limit,
-        step=10,
-        help="재귀 호출 제한 횟수를 설정합니다. 너무 높은 값을 설정하면 메모리 부족 문제가 발생할 수 있습니다.",
-    )
-    st.divider()  # 구분선 추가
-    # 도구 설정 섹션 추가
-    st.subheader("🔧 도구 설정")
-    # expander 상태를 세션 상태로 관리
-    if "mcp_tools_expander" not in st.session_state:
-        st.session_state.mcp_tools_expander = False
-    # MCP 도구 추가 인터페이스
-    with st.expander("🧰 MCP 도구 추가", expanded=st.session_state.mcp_tools_expander):
-        # config.json 파일에서 설정 로드하여 표시
-        loaded_config = load_config_from_json()
-        default_config_text = json.dumps(loaded_config, indent=2, ensure_ascii=False)
-        # pending config가 없으면 기존 mcp_config_text 기반으로 생성
-        if "pending_mcp_config" not in st.session_state:
-            try:
-                st.session_state.pending_mcp_config = loaded_config
-            except Exception as e:
-                st.error(f"초기 pending config 설정 실패: {e}")
-        # 개별 도구 추가를 위한 UI
-        st.subheader("도구 추가")
-        st.markdown(
-            """
-            [어떻게 설정 하나요?](https://teddylee777.notion.site/MCP-1d324f35d12980c8b018e12afdf545a1?pvs=4)
-            ⚠️ **중요**: JSON을 반드시 중괄호(`{}`)로 감싸야 합니다."""
-        )
-        # 보다 명확한 예시 제공
-        example_json = {
-            "github": {
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@smithery/cli@latest",
-                    "run",
-                    "@smithery-ai/github",
-                    "--config",
-                    '{"githubPersonalAccessToken":"your_token_here"}',
-                ],
-                "transport": "stdio",
-            }
-        }
-        default_text = json.dumps(example_json, indent=2, ensure_ascii=False)
-        new_tool_json = st.text_area(
-            "도구 JSON",
-            default_text,
-            height=250,
-        )
-        # 추가하기 버튼
-        if st.button(
-            "도구 추가",
-            type="primary",
-            key="add_tool_button",
-            use_container_width=True,
-        ):
-            try:
-                # 입력값 검증
-                if not new_tool_json.strip().startswith(
-                    "{"
-                ) or not new_tool_json.strip().endswith("}"):
-                    st.error("JSON은 중괄호({})로 시작하고 끝나야 합니다.")
-                    st.markdown('올바른 형식: `{ "도구이름": { ... } }`')
-                else:
-                    # JSON 파싱
-                    parsed_tool = json.loads(new_tool_json)
-                    # mcpServers 형식인지 확인하고 처리
-                    if "mcpServers" in parsed_tool:
-                        # mcpServers 안의 내용을 최상위로 이동
-                        parsed_tool = parsed_tool["mcpServers"]
-                        st.info(
-                            "'mcpServers' 형식이 감지되었습니다. 자동으로 변환합니다."
-                        )
-                    # 입력된 도구 수 확인
-                    if len(parsed_tool) == 0:
-                        st.error("최소 하나 이상의 도구를 입력해주세요.")
-                    else:
-                        # 모든 도구에 대해 처리
-                        success_tools = []
-                        for tool_name, tool_config in parsed_tool.items():
-                            # URL 필드 확인 및 transport 설정
-                            if "url" in tool_config:
-                                # URL이 있는 경우 transport를 "sse"로 설정
-                                tool_config["transport"] = "sse"
-                                st.info(
-                                    f"'{tool_name}' 도구에 URL이 감지되어 transport를 'sse'로 설정했습니다."
-                                )
-                            elif "transport" not in tool_config:
-                                # URL이 없고 transport도 없는 경우 기본값 "stdio" 설정
-                                tool_config["transport"] = "stdio"
-                            # 필수 필드 확인
-                            if (
-                                "command" not in tool_config
-                                and "url" not in tool_config
-                            ):
-                                st.error(
-                                    f"'{tool_name}' 도구 설정에는 'command' 또는 'url' 필드가 필요합니다."
-                                )
-                            elif "command" in tool_config and "args" not in tool_config:
-                                st.error(
-                                    f"'{tool_name}' 도구 설정에는 'args' 필드가 필요합니다."
-                                )
-                            elif "command" in tool_config and not isinstance(
-                                tool_config["args"], list
-                            ):
-                                st.error(
-                                    f"'{tool_name}' 도구의 'args' 필드는 반드시 배열([]) 형식이어야 합니다."
-                                )
-                            else:
-                                # pending_mcp_config에 도구 추가
-                                st.session_state.pending_mcp_config[tool_name] = (
-                                    tool_config
-                                )
-                                success_tools.append(tool_name)
-                        # 성공 메시지
-                        if success_tools:
-                            if len(success_tools) == 1:
-                                st.success(
-                                    f"{success_tools[0]} 도구가 추가되었습니다. 적용하려면 '설정 적용하기' 버튼을 눌러주세요."
-                                )
-                            else:
-                                tool_names = ", ".join(success_tools)
-                                st.success(
-                                    f"총 {len(success_tools)}개 도구({tool_names})가 추가되었습니다. 적용하려면 '설정 적용하기' 버튼을 눌러주세요."
-                                )
-                            # 추가되면 expander를 접어줌
-                            st.session_state.mcp_tools_expander = False
-                            st.rerun()
-            except json.JSONDecodeError as e:
-                st.error(f"JSON 파싱 에러: {e}")
-                st.markdown(
-                    f"""
-                **수정 방법**:
-                1. JSON 형식이 올바른지 확인하세요.
-                2. 모든 키는 큰따옴표(")로 감싸야 합니다.
-                3. 문자열 값도 큰따옴표(")로 감싸야 합니다.
-                4. 문자열 내에서 큰따옴표를 사용할 경우 이스케이프(\\")해야 합니다.
-                """
-                )
-            except Exception as e:
-                st.error(f"오류 발생: {e}")
-    # 등록된 도구 목록 표시 및 삭제 버튼 추가
-    with st.expander("📋 등록된 도구 목록", expanded=True):
-        try:
-            pending_config = st.session_state.pending_mcp_config
-        except Exception as e:
-            st.error("유효한 MCP 도구 설정이 아닙니다.")
-        else:
-            # pending config의 키(도구 이름) 목록을 순회하며 표시
-            for tool_name in list(pending_config.keys()):
-                col1, col2 = st.columns([8, 2])
-                col1.markdown(f"- **{tool_name}**")
-                if col2.button("삭제", key=f"delete_{tool_name}"):
-                    # pending config에서 해당 도구 삭제 (즉시 ��용되지는 않음)
-                    del st.session_state.pending_mcp_config[tool_name]
-                    st.success(
-                        f"{tool_name} 도구가 삭제되었습니다. 적용하려면 '설정 적용하기' 버튼을 눌러주세요."
-                    )
-    st.divider()  # 구분선 추가
-# --- 사이드바: 시스템 정보 및 작업 버튼 섹션 ---
-with st.sidebar:
-    st.subheader("📊 시스템 정보")
-    st.write(f"🛠️ MCP 도구 수: {st.session_state.get('tool_count', '초기화 중...')}")
-    selected_model_name = st.session_state.selected_model
-    st.write(f"🧠 현재 모델: {selected_model_name}")
-    # 설정 적용하기 버튼을 여기로 이동
-    if st.button(
-        "설정 적용하기",
-        key="apply_button",
-        type="primary",
-        use_container_width=True,
-    ):
-        # 적용 중 메시지 표시
-        apply_status = st.empty()
-        with apply_status.container():
-            st.warning("🔄 변경사항을 적용하고 있습니다. 잠시만 기다려주세요...")
-            progress_bar = st.progress(0)
-            # 설정 저장
-            st.session_state.mcp_config_text = json.dumps(
-                st.session_state.pending_mcp_config, indent=2, ensure_ascii=False
-            )
-            # config.json 파일에 설정 저장
-            save_result = save_config_to_json(st.session_state.pending_mcp_config)
-            if not save_result:
-                st.error("❌ 설정 파일 저장에 실패했습니다.")
-            progress_bar.progress(15)
-            # 세션 초기화 준비
-            st.session_state.session_initialized = False
-            st.session_state.agent = None
-            # 진행 상태 업데이트
-            progress_bar.progress(30)
-            # 초기화 실행
-            success = st.session_state.event_loop.run_until_complete(
-                initialize_session(st.session_state.pending_mcp_config)
-            )
-            # 진행 상태 업데이트
-            progress_bar.progress(100)
-            if success:
-                st.success("✅ 새로운 설정이 적용되었습니다.")
-                # 도구 추가 expander 접기
-                if "mcp_tools_expander" in st.session_state:
-                    st.session_state.mcp_tools_expander = False
-            else:
-                st.error("❌ 설정 적용에 실패하였습니다.")
-        # 페이지 새로고침
-        st.rerun()
-    st.divider()  # 구분선 추가
-    # 작업 버튼 섹션
-    st.subheader("🔄 작업")
-    # 대화 초기화 버튼
-    if st.button("대화 초기화", use_container_width=True, type="primary"):
-        # thread_id 초기화
-        st.session_state.thread_id = random_uuid()
-        # 대화 히스토리 초기화
-        st.session_state.history = []
-        # 알림 메시지
-        st.success("✅ 대화가 초기화되었습니다.")
-        # 페이지 새로고침
-        st.rerun()
-    # 로그인 기능이 활성화된 경우에만 로그아웃 버튼 표시
-    if use_login and st.session_state.authenticated:
-        st.divider()  # 구분선 추가
-        if st.button("로그아웃", use_container_width=True, type="secondary"):
-            st.session_state.authenticated = False
-            st.success("✅ 로그아웃 되었습니다.")
-            st.rerun()
-# --- 기본 세션 초기화 (초기화되지 않은 경우) ---
-if not st.session_state.session_initialized:
-    st.info(
-        "MCP 서버와 에이전트가 초기화되지 않았습니다. 왼쪽 사이드바의 '설정 적용하기' 버튼을 클릭하여 초기화해주세요."
-    )
-# --- 대화 기록 출력 ---
-print_message()
-# --- 사용자 입력 및 처리 ---
-user_query = st.chat_input("💬 질문을 입력하세요")
-if user_query:
-    if st.session_state.session_initialized:
-        st.chat_message("user", avatar="🧑‍💻").markdown(user_query)
-        with st.chat_message("assistant", avatar="🤖"):
-            tool_placeholder = st.empty()
-            text_placeholder = st.empty()
-            resp, final_text, final_tool = (
-                st.session_state.event_loop.run_until_complete(
-                    process_query(
-                        user_query,
-                        text_placeholder,
-                        tool_placeholder,
-                        st.session_state.timeout_seconds,
-                    )
-                )
-            )
-        if "error" in resp:
-            st.error(resp["error"])
-        else:
-            st.session_state.history.append({"role": "user", "content": user_query})
-            st.session_state.history.append(
-                {"role": "assistant", "content": final_text}
-            )
-            if final_tool.strip():
-                st.session_state.history.append(
-                    {"role": "assistant_tool", "content": final_tool}
-                )
-            st.rerun()
-    else:
-        st.warning(
-            "⚠️ MCP 서버와 에이전트가 초기화되지 않았습니다. 왼쪽 사이드바의 '설정 적용하기' 버튼을 클릭하여 초기화해주세요."
-        )

config.json CHANGED Viewed

@@ -5,5 +5,13 @@
       "./mcp_server_time.py"
     ],
     "transport": "stdio"
   }
 }

       "./mcp_server_time.py"
     ],
     "transport": "stdio"
+  },
+  "qa": {
+    "transport": "sse",
+    "url": "http://10.15.56.148:8000/qa"
+  },
+  "review_generate": {
+    "transport": "sse",
+    "url": "http://10.15.56.148:8000/review"
   }
 }

run.sh ADDED Viewed

	@@ -0,0 +1 @@


1	+ streamlit run app.py --server.address=0.0.0.0