update

DOCKER_README.md

@@ -0,0 +1,133 @@
+# Docker 化 MCP Hub Streamlit 应用
+
+本项目已完全 Docker 化，现在使用MCP（Model Context Protocol）服务器架构。
+
+## 🏗️ 项目架构
+
+```
+.
+├── app.py                          # 主 Streamlit 应用
+├── requirements.txt                # 主应用依赖
+├── Dockerfile                      # 主应用 Docker 镜像
+├── docker-compose.yml              # Docker Compose 配置
+├── docker-config.json              # Docker 环境配置文件
+├── docker-run.sh                   # 启动脚本
+├── docker-stop.sh                  # 停止脚本
+├── docker-logs.sh                  # 日志查看脚本
+├── config.json                     # MCP服务器配置
+└── python-services/                # MCP服务器目录
+    ├── service1/                   # RequestProcessor MCP服务器
+    │   ├── mcp_server.py          # MCP服务器实现
+    │   └── requirements.txt       # MCP服务器依赖
+    ├── service2/                   # DataAnalyzer MCP服务器
+    │   ├── mcp_server.py          # MCP服务器实现
+    │   └── requirements.txt       # MCP服务器依赖
+    └── service3/                   # MathComputer MCP服务器
+        ├── mcp_server.py          # MCP服务器实现
+        └── requirements.txt       # MCP服务器依赖
+```
+
+## 🚀 快速开始
+
+### 1. 启动应用
+
+```bash
+# 给脚本执行权限
+chmod +x docker-run.sh docker-stop.sh docker-logs.sh
+
+# 启动应用
+./docker-run.sh
+```
+
+### 2. 访问服务
+
+- **Streamlit 应用**: http://localhost:8501
+- **MCP服务器**: 通过主应用自动加载，无需单独访问
+
+### 3. 停止服务
+
+```bash
+./docker-stop.sh
+```
+
+### 4. 查看日志
+
+```bash
+# 查看应用日志
+./docker-logs.sh streamlit
+```
+
+## 🔧 架构说明
+
+### 旧架构 (已废弃)
+- 三个独立的FastAPI HTTP服务
+- 分别运行在端口8001、8002、8003
+- 需要手动管理服务依赖
+
+### 新架构 (当前使用)
+- 三个MCP服务器集成到主应用中
+- 通过stdio传输方式通信
+- 自动工具发现和注册
+- 更好的集成性和扩展性
+
+## 📝 MCP服务器功能
+
+### RequestProcessor (service1)
+- **功能**: 通用请求处理和数据分析
+- **工具**: 请求处理、数据验证、服务信息
+
+### DataAnalyzer (service2)
+- **功能**: 数据分析和统计计算
+- **工具**: 数据分析、统计计算、结构分析
+
+### MathComputer (service3)
+- **功能**: 数学计算和统计函数
+- **工具**: 基本运算、高级统计、百分位数计算
+
+## 🔄 配置更新
+
+MCP服务器配置在 `config.json` 中：
+
+```json
+{
+  "request_processor": {
+    "command": "python",
+    "args": ["./python-services/service1/mcp_server.py"],
+    "transport": "stdio"
+  },
+  "data_analyzer": {
+    "command": "python",
+    "args": ["./python-services/service2/mcp_server.py"],
+    "transport": "stdio"
+  },
+  "math_computer": {
+    "command": "python",
+    "args": ["./python-services/service3/mcp_server.py"],
+    "transport": "stdio"
+  }
+}
+```
+
+## 💡 优势
+
+1. **简化部署**: 只需要启动一个主应用容器
+2. **统一管理**: 所有MCP服务器通过主应用管理
+3. **自动发现**: 工具自动发现和注册
+4. **更好集成**: 与LangChain等框架无缝集成
+
+## 🐛 故障排除
+
+如果MCP服务器加载失败：
+
+1. 检查依赖是否正确安装
+2. 确认Python版本兼容性（建议3.8+）
+3. 检查文件路径是否正确
+4. 查看主应用日志获取详细信息
+
+## 🔮 扩展建议
+
+可以基于现有MCP服务器模板创建更多专用服务：
+- 文件处理服务
+- 数据库查询服务
+- 外部API集成服务
+- 机器学习推理服务 

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install MCP server dependencies
+RUN pip install --no-cache-dir fastmcp
+
+# Copy application code
+COPY . .
+
+# Install MCP server dependencies for each service
+RUN cd python-services/service1 && pip install --no-cache-dir -r requirements.txt
+RUN cd python-services/service2 && pip install --no-cache-dir -r requirements.txt  
+RUN cd python-services/service3 && pip install --no-cache-dir -r requirements.txt
+
+# Expose port
+EXPOSE 8501
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+# Run the application
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=8501"] 

MCP-HandsOn-ENG.ipynb

@@ -1,702 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# MCP + LangGraph Hands-On Tutorial\n",
-    "\n",
-    "- Author: [Teddy Notes](https://youtube.com/c/teddynote)\n",
-    "- Lecture: [Fastcampus RAG trick notes](https://fastcampus.co.kr/data_online_teddy)\n",
-    "\n",
-    "**References**\n",
-    "- https://modelcontextprotocol.io/introduction\n",
-    "- https://github.com/langchain-ai/langchain-mcp-adapters"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## configure\n",
-    "\n",
-    "Refer to the installation instructions below to install `uv`.\n",
-    "\n",
-    "**How to install `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",
-    "Install **dependencies**\n",
-    "\n",
-    "```bash\n",
-    "uv pip install -r requirements.txt\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Gets the environment variables."
-   ]
-  },
-  {
-   "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": [
-    "Run `mcp_server_remote.py` in advance. Open a terminal with the virtual environment activated and run the server.\n",
-    "\n",
-    "> Command\n",
-    "```bash\n",
-    "source .venv/bin/activate\n",
-    "python mcp_server_remote.py\n",
-    "```\n",
-    "\n",
-    "Create and terminate a temporary Session connection using `async with`"
-   ]
-  },
-  {
-   "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",
-    "            # Must match the server's port (port 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(\n",
-    "        agent, {\"messages\": \"What's the weather like in Seoul?\"}\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You might notice that you can't access the tool because the session is closed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(agent, {\"messages\": \"What's the weather like in Seoul?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now let's change that to accessing the tool while maintaining an Async Session."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 1. Create client\n",
-    "client = MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"weather\": {\n",
-    "            \"url\": \"http://localhost:8005/sse\",\n",
-    "            \"transport\": \"sse\",\n",
-    "        }\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. Explicitly initialize connection (this part is necessary)\n",
-    "# Initialize\n",
-    "await client.__aenter__()\n",
-    "\n",
-    "# Now tools are loaded\n",
-    "print(client.get_tools())  # Tools are displayed"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create an agent with langgraph(`create_react_agent`)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create agent\n",
-    "agent = create_react_agent(model, client.get_tools())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Run the graph to see the results."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(agent, {\"messages\": \"What's the weather like in Seoul?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Stdio method\n",
-    "\n",
-    "The Stdio method is intended for use in a local environment.\n",
-    "\n",
-    "- Use standard input/output for communication"
-   ]
-  },
-  {
-   "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",
-    "# Initialize Anthropic's Claude model\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# Set up StdIO server parameters\n",
-    "# - command: Path to Python interpreter\n",
-    "# - args: MCP server script to execute\n",
-    "server_params = StdioServerParameters(\n",
-    "    command=\"./.venv/bin/python\",\n",
-    "    args=[\"mcp_server_local.py\"],\n",
-    ")\n",
-    "\n",
-    "# Use StdIO client to communicate with the server\n",
-    "async with stdio_client(server_params) as (read, write):\n",
-    "    # Create client session\n",
-    "    async with ClientSession(read, write) as session:\n",
-    "        # Initialize connection\n",
-    "        await session.initialize()\n",
-    "\n",
-    "        # Load MCP tools\n",
-    "        tools = await load_mcp_tools(session)\n",
-    "        print(tools)\n",
-    "\n",
-    "        # Create agent\n",
-    "        agent = create_react_agent(model, tools)\n",
-    "\n",
-    "        # Stream agent responses\n",
-    "        await astream_graph(agent, {\"messages\": \"What's the weather like in Seoul?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Use MCP server with RAG deployed\n",
-    "\n",
-    "- File: `mcp_server_rag.py`\n",
-    "\n",
-    "Use the `mcp_server_rag.py` file that we built with langchain in advance.\n",
-    "\n",
-    "It uses stdio communication to get information about the tools, where it gets the `retriever` tool, which is the tool defined in `mcp_server_rag.py`. This file **doesn't** need to be running on the server beforehand."
-   ]
-  },
-  {
-   "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",
-    "# Initialize Anthropic's Claude model\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# Set up StdIO server parameters for the RAG server\n",
-    "server_params = StdioServerParameters(\n",
-    "    command=\"./.venv/bin/python\",\n",
-    "    args=[\"./mcp_server_rag.py\"],\n",
-    ")\n",
-    "\n",
-    "# Use StdIO client to communicate with the RAG server\n",
-    "async with stdio_client(server_params) as (read, write):\n",
-    "    # Create client session\n",
-    "    async with ClientSession(read, write) as session:\n",
-    "        # Initialize connection\n",
-    "        await session.initialize()\n",
-    "\n",
-    "        # Load MCP tools (in this case, the retriever tool)\n",
-    "        tools = await load_mcp_tools(session)\n",
-    "\n",
-    "        # Create and run the agent\n",
-    "        agent = create_react_agent(model, tools)\n",
-    "\n",
-    "        # Stream agent responses\n",
-    "        await astream_graph(\n",
-    "            agent,\n",
-    "            {\n",
-    "                \"messages\": \"Search for the name of the generative AI developed by Samsung Electronics\"\n",
-    "            },\n",
-    "        )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Use a mix of SSE and Stdio methods\n",
-    "\n",
-    "- File: `mcp_server_rag.py` communicates over Stdio\n",
-    "- `langchain-dev-docs` communicates via SSE\n",
-    "\n",
-    "Use a mix of SSE and Stdio methods."
-   ]
-  },
-  {
-   "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",
-    "# Initialize Anthropic's Claude model\n",
-    "model = ChatAnthropic(\n",
-    "    model_name=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000\n",
-    ")\n",
-    "\n",
-    "# 1. Create multi-server MCP client\n",
-    "client = MultiServerMCPClient(\n",
-    "    {\n",
-    "        \"document-retriever\": {\n",
-    "            \"command\": \"./.venv/bin/python\",\n",
-    "            # Update with the absolute path to mcp_server_rag.py file\n",
-    "            \"args\": [\"./mcp_server_rag.py\"],\n",
-    "            # Communicate via stdio (using standard input/output)\n",
-    "            \"transport\": \"stdio\",\n",
-    "        },\n",
-    "        \"langchain-dev-docs\": {\n",
-    "            # Make sure the SSE server is running\n",
-    "            \"url\": \"https://teddynote.io/mcp/langchain/sse\",\n",
-    "            # Communicate via SSE (Server-Sent Events)\n",
-    "            \"transport\": \"sse\",\n",
-    "        },\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. Initialize connection explicitly through async context manager\n",
-    "await client.__aenter__()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create an agent using `create_react_agent` in langgraph."
-   ]
-  },
-  {
-   "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 English.\"\n",
-    ")\n",
-    "agent = create_react_agent(\n",
-    "    model, client.get_tools(), prompt=prompt, checkpointer=MemorySaver()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Use the `retriever` tool defined in `mcp_server_rag.py` that you built to perform the search."
-   ]
-  },
-  {
-   "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\": \"Use the `retriever` tool to search for the name of the generative AI developed by Samsung Electronics\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This time, we'll use the `langchain-dev-docs` tool to perform the search."
-   ]
-  },
-  {
-   "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\": \"Please tell me about the definition of self-rag by referring to the langchain-dev-docs\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Use `MemorySaver` to maintain short-term memory, so multi-turn conversations are possible."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\"messages\": \"Summarize the previous content in bullet points\"},\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## LangChain-integrated tools + MCP tools\n",
-    "\n",
-    "Here we confirm that tools integrated into LangChain can be used in conjunction with existing MCP-only tools."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "\n",
-    "# Initialize the Tavily search tool (news type, news from the last 3 days)\n",
-    "tavily = TavilySearchResults(max_results=3, topic=\"news\", days=3)\n",
-    "\n",
-    "# Use it together with existing MCP tools\n",
-    "tools = client.get_tools() + [tavily]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create an agent using `create_react_agent` in langgraph."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.checkpoint.memory import MemorySaver\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "prompt = \"You are a smart agent with various tools. Answer questions in English.\"\n",
-    "agent = create_react_agent(model, tools, prompt=prompt, checkpointer=MemorySaver())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Perform a search using the newly added `tavily` tool."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent, {\"messages\": \"Tell me about today's news for me\"}, config=config\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can see that the `retriever` tool is working smoothly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": \"Use the `retriever` tool to search for the name of the generative AI developed by Samsung Electronics\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Smithery MCP Server\n",
-    "\n",
-    "- Link: https://smithery.ai/\n",
-    "\n",
-    "List of tools used:\n",
-    "\n",
-    "- Sequential Thinking: https://smithery.ai/server/@smithery-ai/server-sequential-thinking\n",
-    "  - MCP server providing tools for dynamic and reflective problem-solving through structured thinking processes\n",
-    "- Desktop Commander: https://smithery.ai/server/@wonderwhy-er/desktop-commander\n",
-    "  - Run terminal commands and manage files with various editing capabilities. Coding, shell and terminal, task automation\n",
-    "\n",
-    "**Note**\n",
-    "\n",
-    "- When importing tools provided by smithery in JSON format, you must set `\"transport\": \"stdio\"` as shown in the example below."
-   ]
-  },
-  {
-   "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",
-    "# Initialize LLM model\n",
-    "model = ChatAnthropic(model=\"claude-3-7-sonnet-latest\", temperature=0, max_tokens=20000)\n",
-    "\n",
-    "# 1. Create client\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",
-    "                \"your_smithery_api_key\",\n",
-    "            ],\n",
-    "            \"transport\": \"stdio\",  # Add communication using stdio method\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",
-    "                \"your_smithery_api_key\",\n",
-    "            ],\n",
-    "            \"transport\": \"stdio\",  # Add communication using stdio method\n",
-    "        },\n",
-    "        \"document-retriever\": {\n",
-    "            \"command\": \"./.venv/bin/python\",\n",
-    "            # Update with the absolute path to the mcp_server_rag.py file\n",
-    "            \"args\": [\"./mcp_server_rag.py\"],\n",
-    "            # Communication using stdio (standard input/output)\n",
-    "            \"transport\": \"stdio\",\n",
-    "        },\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "\n",
-    "# 2. Explicitly initialize connection\n",
-    "await client.__aenter__()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create an agent using `create_react_agent` in langgraph."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.checkpoint.memory import MemorySaver\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "# Set up configuration\n",
-    "config = RunnableConfig(recursion_limit=30, thread_id=3)\n",
-    "\n",
-    "# Create agent\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\": \"Draw the folder structure including the current path as a tree. However, exclude the .venv folder from the output.\"\n",
-    "    },\n",
-    "    config=config,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We'll use the `Sequential Thinking` tool to see if we can accomplish a relatively complex task."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "await astream_graph(\n",
-    "    agent,\n",
-    "    {\n",
-    "        \"messages\": (\n",
-    "            \"Use the `retriever` tool to search for information about generative AI developed by Samsung Electronics, \"\n",
-    "            \"and then use the `Sequential Thinking` tool to write a report.\"\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.md

@@ -15,227 +15,82 @@ tags:
 - MCP
 ---
 
-# LangGraph Agents + MCP
+# LLM-Agent-Chatbot-MCP
 
-[![English](https://img.shields.io/badge/Language-English-blue)](README.md) [![Korean](https://img.shields.io/badge/Language-한국어-red)](README_KOR.md)
+一个基于MCP（Model Context Protocol）的智能体框架，提供复杂的推理能力和多种MCP工具集成。
 
-[![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)
+- **MCP服务器集成**: 包含多个专用MCP服务器
+- **智能体框架**: 基于LangGraph的智能体系统
+- **Streamlit界面**: 现代化的Web用户界面
+- **多模型支持**: 支持OpenAI、Anthropic等多种LLM
+- **工具管理**: 自动工具发现和注册
 
-## Project Overview
+## 🏗️ 项目结构
 
-![project architecture](./assets/architecture.png)
-
-`LangChain-MCP-Adapters` is a toolkit provided by **LangChain AI** that enables AI agents to interact with external tools and data sources through the Model Context Protocol (MCP). This project provides a user-friendly interface for deploying ReAct agents that can access various data sources and APIs through MCP tools.
-
-### Features
-
-- **Streamlit Interface**: A user-friendly web interface for interacting with LangGraph `ReAct Agent` with MCP tools
-- **Tool Management**: Add, remove, and configure MCP tools through the UI (Smithery JSON format supported). This is done dynamically without restarting the application
-- **Streaming Responses**: View agent responses and tool calls in real-time
-- **Conversation History**: Track and manage conversations with the agent
-
-## MCP Architecture
-
-The Model Context Protocol (MCP) consists of three main components:
-
-1. **MCP Host**: Programs seeking to access data through MCP, such as Claude Desktop, IDEs, or LangChain/LangGraph.
-
-2. **MCP Client**: A protocol client that maintains a 1:1 connection with the server, acting as an intermediary between the host and server.
-
-3. **MCP Server**: A lightweight program that exposes specific functionalities through a standardized model context protocol, serving as the primary data source.
-
-## Quick Start with Docker
-
-You can easily run this project using Docker without setting up a local Python environment.
-
-### Requirements (Docker Desktop)
-
-Install Docker Desktop from the link below:
-
-- [Install Docker Desktop](https://www.docker.com/products/docker-desktop/)
-
-### Run with Docker Compose
-
-1. Navigate to the `dockers` directory
-
-```bash
-cd dockers
-```
-
-2. Create a `.env` file with your API keys in the project root directory.
-
-```bash
-cp .env.example .env
 ```
-
-Enter your obtained API keys in the `.env` file.
-
-(Note) Not all API keys are required. Only enter the ones you need.
-- `ANTHROPIC_API_KEY`: If you enter an Anthropic API key, you can use "claude-3-7-sonnet-latest", "claude-3-5-sonnet-latest", "claude-3-haiku-latest" models.
-- `OPENAI_API_KEY`: If you enter an OpenAI API key, you can use "gpt-4o", "gpt-4o-mini" models.
-- `LANGSMITH_API_KEY`: If you enter a LangSmith API key, you can use 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_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_PROJECT=LangGraph-MCP-Agents
+.
+├── app.py                          # 主Streamlit应用
+├── config.json                     # MCP服务器配置
+├── python-services/                # MCP服务器目录
+│   ├── service1/                   # RequestProcessor MCP服务器
+│   │   ├── mcp_server.py          # MCP服务器实现
+│   │   └── requirements.txt       # 依赖文件
+│   ├── service2/                   # DataAnalyzer MCP服务器
+│   │   ├── mcp_server.py          # MCP服务器实现
+│   │   └── requirements.txt       # 依赖文件
+│   └── service3/                   # MathComputer MCP服务器
+│       ├── mcp_server.py          # MCP服务器实现
+│       └── requirements.txt       # 依赖文件
+├── mcp_server_time.py             # 时间服务MCP服务器
+└── requirements.txt                # 主应用依赖
 ```
 
-When using the login feature, set `USE_LOGIN` to `true` and enter `USER_ID` and `USER_PASSWORD`.
+## 🔧 MCP服务器
 
-```bash
-USE_LOGIN=true
-USER_ID=admin
-USER_PASSWORD=admin123
-```
+### 1. RequestProcessor
+- **功能**: 通用请求处理和数据分析
+- **工具**: 请求处理、数据验证、服务信息
 
-If you don't want to use the login feature, set `USE_LOGIN` to `false`.
+### 2. DataAnalyzer  
+- **功能**: 数据分析和统计计算
+- **工具**: 数据分析、统计计算、结构分析
 
-```bash
-USE_LOGIN=false
-```
+### 3. MathComputer
+- **功能**: 数学计算和统计函数
+- **工具**: 基本运算、高级统计、百分位数计算
 
-3. Select the Docker Compose file that matches your system architecture.
+### 4. TimeService
+- **功能**: 时区和时间服务
+- **工具**: 多时区时间查询
 
-**AMD64/x86_64 Architecture (Intel/AMD Processors)**
+## 🚀 快速开始
 
+### 安装依赖
 ```bash
-# Run container
-docker compose -f docker-compose.yaml up -d
+pip install -r requirements.txt
+cd python-services/service1 && pip install -r requirements.txt
+cd ../service2 && pip install -r requirements.txt  
+cd ../service3 && pip install -r requirements.txt
 ```
 
-**ARM64 Architecture (Apple Silicon M1/M2/M3/M4)**
-
+### 启动应用
 ```bash
-# Run container
-docker compose -f docker-compose-mac.yaml up -d
+python app.py
 ```
 
-4. Access the application in your browser at http://localhost:8585
-
-(Note)
-- If you need to modify ports or other settings, edit the docker-compose.yaml file before building.
-
-## Install Directly from Source Code
-
-1. Clone this repository
-
-```bash
-git clone https://github.com/teddynote-lab/langgraph-mcp-agents.git
-cd langgraph-mcp-agents
-```
-
-2. Create a virtual environment and install dependencies using uv
-
-```bash
-uv venv
-uv pip install -r requirements.txt
-source .venv/bin/activate  # For Windows: .venv\Scripts\activate
-```
-
-3. Create a `.env` file with your API keys (copy from `.env.example`)
-
-```bash
-cp .env.example .env
-```
-
-Enter your obtained API keys in the `.env` file.
-
-(Note) Not all API keys are required. Only enter the ones you need.
-- `ANTHROPIC_API_KEY`: If you enter an Anthropic API key, you can use "claude-3-7-sonnet-latest", "claude-3-5-sonnet-latest", "claude-3-haiku-latest" models.
-- `OPENAI_API_KEY`: If you enter an OpenAI API key, you can use "gpt-4o", "gpt-4o-mini" models.
-- `LANGSMITH_API_KEY`: If you enter a LangSmith API key, you can use 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_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_PROJECT=LangGraph-MCP-Agents
-```
-
-4. (New) Use the login/logout feature
-
-When using the login feature, set `USE_LOGIN` to `true` and enter `USER_ID` and `USER_PASSWORD`.
-
-```bash
-USE_LOGIN=true
-USER_ID=admin
-USER_PASSWORD=admin123
-```
-
-If you don't want to use the login feature, set `USE_LOGIN` to `false`.
-
-```bash
-USE_LOGIN=false
-```
-
-## Usage
-
-1. Start the Streamlit application.
-
-```bash
-streamlit run app.py
-```
-
-2. The application will run in the browser and display the main interface.
-
-3. Use the sidebar to add and configure MCP tools
-
-Visit [Smithery](https://smithery.ai/) to find useful MCP servers.
-
-First, select the tool you want to use.
-
-Click the COPY button in the JSON configuration on the right.
-
-![copy from Smithery](./assets/smithery-copy-json.png)
-
-Paste the copied JSON string in the `Tool JSON` section.
-
-<img src="./assets/add-tools.png" alt="tool json" style="width: auto; height: auto;">
-
-Click the `Add Tool` button to add it to the "Registered Tools List" section.
-
-Finally, click the "Apply" button to apply the changes to initialize the agent with the new tools.
-
-<img src="./assets/apply-tool-configuration.png" alt="tool json" style="width: auto; height: auto;">
-
-4. Check the agent's status.
-
-![check status](./assets/check-status.png)
-
-5. Interact with the ReAct agent that utilizes the configured MCP tools by asking questions in the chat interface.
-
-![project demo](./assets/project-demo.png)
-
-## Hands-on Tutorial
-
-For developers who want to learn more deeply about how MCP and LangGraph integration works, we provide a comprehensive Jupyter notebook tutorial:
-
-- Link: [MCP-HandsOn-KOR.ipynb](./MCP-HandsOn-KOR.ipynb)
-
-This hands-on tutorial covers:
-
-1. **MCP Client Setup** - Learn how to configure and initialize the MultiServerMCPClient to connect to MCP servers
-2. **Local MCP Server Integration** - Connect to locally running MCP servers via SSE and Stdio methods
-3. **RAG Integration** - Access retriever tools using MCP for document retrieval capabilities
-4. **Mixed Transport Methods** - Combine different transport protocols (SSE and Stdio) in a single agent
-5. **LangChain Tools + MCP** - Integrate native LangChain tools alongside MCP tools
-
-This tutorial provides practical examples with step-by-step explanations that help you understand how to build and integrate MCP tools into LangGraph agents.
+应用将在 http://localhost:8501 启动，自动加载所有MCP服务器。
 
-## License
+## 📖 详细文档
 
-MIT License 
+- [MCP服务器说明](python-services/MCP_README.md)
+- [Docker部署指南](DOCKER_README.md)
 
-## References
+## 🔮 扩展
 
-- https://github.com/langchain-ai/langchain-mcp-adapters
+可以基于现有MCP服务器模板创建更多专用服务，如：
+- 文件处理服务
+- 数据库查询服务
+- 外部API集成服务
+- 机器学习推理服务

app.py

@@ -4,6 +4,7 @@ import nest_asyncio
 import json
 import os
 import platform
+import time
 
 if platform.system() == "Windows":
     asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
@@ -223,12 +224,10 @@ async def cleanup_mcp_client():
     """
     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)
+            # New version doesn't use async context managers, just set to None
             st.session_state.mcp_client = None
         except Exception as e:
             import traceback
-
             # st.warning(f"Error while terminating MCP client: {str(e)}")
             # st.warning(traceback.format_exc())
 
@@ -300,17 +299,31 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
         if not hasattr(callback_func, '_data_counter'):
             callback_func._data_counter = 0
         
-
+        # Initialize tool result tracking
+        if not hasattr(callback_func, '_tool_results'):
+            callback_func._tool_results = {}
         
-
+        # Check if this is a tool result message
+        if isinstance(message_content, dict) and 'tool_results' in message_content:
+            tool_results = message_content['tool_results']
+            for tool_name, result in tool_results.items():
+                callback_func._tool_results[tool_name] = result
         
-
-
+        # Check if this is a tool call completion message
+        if isinstance(message_content, dict) and 'tool_calls' in message_content:
+            tool_calls = message_content['tool_calls']
+            for tool_call in tool_calls:
+                if isinstance(tool_call, dict) and 'name' in tool_call:
+                    tool_name = tool_call['name']
+                    if 'result' in tool_call:
+                        # Store tool result
+                        callback_func._tool_results[tool_name] = tool_call['result']
+        
+        # Handle different message types
         if isinstance(message_content, AIMessageChunk):
+            # Process AIMessageChunk content
             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]
@@ -341,8 +354,6 @@ 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
                 ):
@@ -359,9 +370,7 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
             ):
                 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(
-                    "🔧 Tool Call Information (Invalid)", expanded=True
-                ):
+                with tool_placeholder.expander("🔧 Tool Call Information (Invalid)", expanded=True):
                     st.markdown("".join(accumulated_tool))
             # Process if tool_call_chunks attribute exists
             elif (
@@ -383,11 +392,7 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                     f"```json\n{str(tool_call_chunk)}\n```\n"
                 )
                 
-
-                
-                with tool_placeholder.expander(
-                    "🔧 Tool Call Information", expanded=True
-                ):
+                with tool_placeholder.expander("🔧 Tool Call Information", expanded=True):
                     st.markdown("".join(accumulated_tool))
             # Process if tool_calls exists in additional_kwargs (supports various model compatibility)
             elif (
@@ -397,11 +402,7 @@ 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
-                ):
+                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):
@@ -409,7 +410,13 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
             # 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")
+            
+            tool_name = message_content.name or "Unknown Tool"
+            callback_func._pending_tool_completion.append(tool_name)
+            
+            # Debug: Log tool message received
+            accumulated_tool.append(f"\n🔍 **Tool Message Received**: {tool_name}\n")
+            accumulated_tool.append(f"📋 **Message Type**: {type(message_content).__name__}\n")
             
             # Convert streaming text to final result
             streaming_text_items = [item for item in accumulated_tool if item.startswith("\n📊 **Streaming Text**:")]
@@ -426,7 +433,17 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
             
             # Handle tool response content
             tool_content = message_content.content
-
+            
+            # Debug: Log tool content
+            accumulated_tool.append(f"📄 **Tool Content Type**: {type(tool_content).__name__}\n")
+            if isinstance(tool_content, str):
+                accumulated_tool.append(f"📏 **Content Length**: {len(tool_content)} characters\n")
+                if len(tool_content) > 100:
+                    accumulated_tool.append(f"📝 **Content Preview**: {tool_content[:100]}...\n")
+                else:
+                    accumulated_tool.append(f"📝 **Content**: {tool_content}\n")
+            else:
+                accumulated_tool.append(f"📝 **Content**: {str(tool_content)[:200]}...\n")
             
             # Handle tool response content
             if isinstance(tool_content, str):
@@ -636,23 +653,90 @@ def get_streaming_callback(text_placeholder, tool_placeholder):
                     accumulated_tool.append(
                         "\n```json\n" + str(tool_content) + "\n```\n"
                     )
+                    
+                    # Capture tool result for display
+                    if hasattr(callback_func, '_pending_tool_completion') and callback_func._pending_tool_completion:
+                        # Get the last completed tool name
+                        last_tool_name = callback_func._pending_tool_completion[-1] if callback_func._pending_tool_completion else "Unknown Tool"
+                        
+                        # Store the tool result
+                        if not hasattr(callback_func, '_tool_results'):
+                            callback_func._tool_results = {}
+                        callback_func._tool_results[last_tool_name] = tool_content
+                        
+                        # Create tool result for display
+                        callback_func._last_tool_result = {
+                            'name': last_tool_name,
+                            'output': tool_content
+                        }
             else:
                 # Non-string content
                 accumulated_tool.append(
                     "\n```json\n" + str(tool_content) + "\n```\n"
                 )
+                
+                # Capture tool result for non-string content too
+                if hasattr(callback_func, '_pending_tool_completion') and callback_func._pending_tool_completion:
+                    last_tool_name = callback_func._pending_tool_completion[-1] if callback_func._pending_tool_completion else "Unknown Tool"
+                    
+                    if not hasattr(callback_func, '_tool_results'):
+                        callback_func._tool_results = {}
+                    callback_func._tool_results[last_tool_name] = tool_content
+                    
+                    callback_func._last_tool_result = {
+                        'name': last_tool_name,
+                        'output': tool_content
+                    }
             
             # 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")
+                    
+                    # Check if we have a result for this tool
+                    if hasattr(callback_func, '_tool_results') and tool_name in callback_func._tool_results:
+                        tool_result = callback_func._tool_results[tool_name]
+                        callback_func._last_tool_result = {
+                            'name': tool_name,
+                            'output': tool_result
+                        }
+                        accumulated_tool.append(f"📊 **Tool Output Captured**: {len(str(tool_result))} characters\n")
+                    else:
+                        accumulated_tool.append(f"⚠️ **No Tool Output Captured** for {tool_name}\n")
+                        # Try to create a basic result structure
+                        callback_func._last_tool_result = {
+                            'name': tool_name,
+                            'output': f"Tool {tool_name} completed but output was not captured"
+                        }
+                    
                 # Clear the pending list
                 callback_func._pending_tool_completion = []
-        
-
-        
-        return None
-
+            
+            # Enhanced tool result display for MCP tools
+            if hasattr(callback_func, '_last_tool_result') and callback_func._last_tool_result:
+                tool_result = callback_func._last_tool_result
+                if isinstance(tool_result, dict):
+                    # Extract tool name and result
+                    tool_name = tool_result.get('name', 'Unknown Tool')
+                    tool_output = tool_result.get('output', tool_result.get('result', tool_result.get('content', str(tool_result))))
+                    
+                    accumulated_tool.append(f"\n🔧 **Tool Result - {tool_name}**:\n")
+                    if isinstance(tool_output, str) and tool_output.strip():
+                        # Format the output nicely
+                        if len(tool_output) > 200:
+                            accumulated_tool.append(f"```\n{tool_output[:200]}...\n```\n")
+                            accumulated_tool.append(f"📏 *Output truncated. Full length: {len(tool_output)} characters*\n")
+                        else:
+                            accumulated_tool.append(f"```\n{tool_output}\n```\n")
+                    else:
+                        accumulated_tool.append(f"```json\n{tool_output}\n```\n")
+                else:
+                    accumulated_tool.append(f"\n🔧 **Tool Result**:\n```\n{str(tool_result)}\n```\n")
+                
+                # Clear the tool result after displaying
+                callback_func._last_tool_result = None
+    
+    # Return the callback function and accumulated lists
     return callback_func, accumulated_text, accumulated_tool
 
 
@@ -759,12 +843,131 @@ async def initialize_session(mcp_config=None):
             # Load settings from config.json file
             mcp_config = load_config_from_json()
         
+        # Validate MCP configuration before connecting
+        st.info("🔍 Validating MCP server configurations...")
+        config_errors = []
+        for server_name, server_config in mcp_config.items():
+            st.write(f"📋 Checking {server_name}...")
+            
+            # Check required fields
+            if "transport" not in server_config:
+                config_errors.append(f"{server_name}: Missing 'transport' field")
+                st.error(f"❌ {server_name}: Missing 'transport' field")
+            elif server_config["transport"] not in ["stdio", "sse", "http", "streamable_http", "websocket"]:
+                config_errors.append(f"{server_name}: Invalid transport '{server_config['transport']}'")
+                st.error(f"❌ {server_name}: Invalid transport '{server_config['transport']}'")
+            
+            if "url" in server_config:
+                if "transport" in server_config and server_config["transport"] == "stdio":
+                    config_errors.append(f"{server_name}: Cannot use 'stdio' transport with URL")
+                    st.error(f"❌ {server_name}: Cannot use 'stdio' transport with URL")
+            elif "command" not in server_config:
+                config_errors.append(f"{server_name}: Missing 'command' field for stdio transport")
+                st.error(f"❌ {server_name}: Missing 'command' field for stdio transport")
+            elif "args" not in server_config:
+                config_errors.append(f"{server_name}: Missing 'args' field for stdio transport")
+                st.error(f"❌ {server_name}: Missing 'args' field for stdio transport")
+        
+        if config_errors:
+            st.error("🚫 Configuration validation failed!")
+            st.error("Please fix the following issues:")
+            for error in config_errors:
+                st.error(f"   • {error}")
+            return False
+        
+        st.success("✅ MCP configuration validation passed!")
+        
         client = MultiServerMCPClient(mcp_config)
-        await client.__aenter__()
-        tools = client.get_tools()
-        st.session_state.tool_count = len(tools)
+        
+        # Get tools with error handling for malformed schemas
+        try:
+            tools = await client.get_tools()
+            st.session_state.tool_count = len(tools)
+            st.success(f"✅ Successfully loaded {len(tools)} tools from all MCP servers")
+        except Exception as e:
+            st.error(f"❌ Error loading MCP tools: {str(e)}")
+            st.error(f"🔍 Error type: {type(e).__name__}")
+            st.error(f"📋 Full error details: {repr(e)}")
+            st.warning("🔄 Attempting to load tools individually to identify problematic servers...")
+            
+            # Try to load tools from each server individually
+            tools = []
+            failed_servers = []
+            
+            for server_name, server_config in mcp_config.items():
+                try:
+                    st.info(f"🔄 Testing connection to {server_name}...")
+                    st.json(server_config)  # Show server configuration
+                    
+                    # Create a single server client to test
+                    single_client = MultiServerMCPClient({server_name: server_config})
+                    server_tools = await single_client.get_tools()
+                    tools.extend(server_tools)
+                    st.success(f"✅ Loaded {len(server_tools)} tools from {server_name}")
+                    
+                except Exception as server_error:
+                    error_msg = f"❌ Failed to load tools from {server_name}"
+                    st.error(error_msg)
+                    st.error(f"   Error: {str(server_error)}")
+                    st.error(f"   Type: {type(server_error).__name__}")
+                    st.error(f"   Details: {repr(server_error)}")
+                    failed_servers.append(server_name)
+                    continue
+            
+            # Summary of results
+            if failed_servers:
+                st.error(f"🚫 Failed servers: {', '.join(failed_servers)}")
+                st.error("💡 Check server configurations and ensure servers are running")
+            
+            if not tools:
+                st.error("❌ No tools could be loaded from any MCP server. Please check your server configurations.")
+                st.error("🔧 Troubleshooting tips:")
+                st.error("   1. Ensure all MCP servers are running")
+                st.error("   2. Check network connectivity and ports")
+                st.error("   3. Verify server configurations in config.json")
+                st.error("   4. Check server logs for errors")
+                return False
+            else:
+                st.success(f"✅ Successfully loaded {len(tools)} tools from working servers")
+                st.warning(f"⚠️ Some servers failed: {', '.join(failed_servers)}" if failed_servers else "✅ All servers loaded successfully")
+        
         st.session_state.mcp_client = client
 
+        # Validate and filter tools to remove malformed schemas
+        def validate_tool(tool):
+            try:
+                # Try to access the tool's schema to validate it
+                if hasattr(tool, 'schema'):
+                    # This will trigger schema validation
+                    _ = tool.schema
+                
+                # Additional validation: check if tool can be converted to OpenAI format
+                # This catches the FileData reference issue
+                try:
+                    from langchain_core.utils.function_calling import convert_to_openai_tool
+                    _ = convert_to_openai_tool(tool)
+                    return True
+                except Exception as schema_error:
+                    if "FileData" in str(schema_error) or "Reference" in str(schema_error):
+                        st.warning(f"⚠️ Tool '{getattr(tool, 'name', 'unknown')}' has malformed schema: {str(schema_error)}")
+                    return False
+                
+            except Exception as e:
+                st.warning(f"⚠️ Tool '{getattr(tool, 'name', 'unknown')}' validation failed: {str(e)}")
+                return False
+        
+        # Filter out invalid tools
+        valid_tools = [tool for tool in tools if validate_tool(tool)]
+        if len(valid_tools) < len(tools):
+            st.warning(f"⚠️ Filtered out {len(tools) - len(valid_tools)} tools with malformed schemas")
+            tools = valid_tools
+            st.session_state.tool_count = len(tools)
+        
+        # Ensure we have at least some valid tools
+        if not tools:
+            st.error("❌ No valid tools could be loaded. Please check your MCP server configurations.")
+            return False
+
         # Initialize appropriate model based on selection
         selected_model = st.session_state.selected_model
 
@@ -785,12 +988,50 @@ async def initialize_session(mcp_config=None):
                 temperature=0.1,
                 max_tokens=OUTPUT_TOKEN_INFO[selected_model]["max_tokens"],
             )
-        agent = create_react_agent(
-            model,
-            tools,
-            checkpointer=MemorySaver(),
-            prompt=SYSTEM_PROMPT,
-        )
+        
+        # Create agent with error handling
+        try:
+            agent = create_react_agent(
+                model,
+                tools,
+                checkpointer=MemorySaver(),
+                prompt=SYSTEM_PROMPT,
+            )
+        except Exception as agent_error:
+            st.error(f"❌ Failed to create agent: {str(agent_error)}")
+            st.warning("🔄 Attempting to create agent with individual tool validation...")
+            
+            # Try to create agent with tools one by one
+            working_tools = []
+            for i, tool in enumerate(tools):
+                try:
+                    test_agent = create_react_agent(
+                        model,
+                        [tool],
+                        checkpointer=MemorySaver(),
+                        prompt=SYSTEM_PROMPT,
+                    )
+                    working_tools.append(tool)
+                    st.success(f"✅ Tool {i+1} validated successfully")
+                except Exception as tool_error:
+                    st.error(f"❌ Tool {i+1} failed validation: {str(tool_error)}")
+                    continue
+            
+            if not working_tools:
+                st.error("❌ No tools could be used to create the agent. Please check your MCP server configurations.")
+                return False
+            
+            # Create agent with only working tools
+            tools = working_tools
+            st.session_state.tool_count = len(tools)
+            agent = create_react_agent(
+                model,
+                tools,
+                checkpointer=MemorySaver(),
+                prompt=SYSTEM_PROMPT,
+            )
+            st.success(f"✅ Agent created successfully with {len(tools)} working tools")
+        
         st.session_state.agent = agent
         st.session_state.session_initialized = True
         return True
@@ -962,11 +1203,29 @@ with st.sidebar:
                         for tool_name, tool_config in parsed_tool.items():
                             # Check URL field and set transport
                             if "url" in tool_config:
-                                # Set transport to "sse" if URL exists
-                                tool_config["transport"] = "sse"
-                                st.info(
-                                    f"URL detected in '{tool_name}' tool, setting transport to 'sse'."
-                                )
+                                # Set transport to "streamable_http" if URL exists (preferred) or fallback to "sse"
+                                if "transport" not in tool_config:
+                                    tool_config["transport"] = "streamable_http"
+                                    st.info(
+                                        f"URL detected in '{tool_name}' tool, setting transport to 'streamable_http' (recommended)."
+                                    )
+                                elif tool_config["transport"] == "sse":
+                                    st.info(
+                                        f"'{tool_name}' tool using SSE transport (deprecated but still supported)."
+                                    )
+                                elif tool_config["transport"] == "streamable_http":
+                                    st.success(
+                                        f"'{tool_name}' tool using Streamable HTTP transport (recommended)."
+                                    )
+                                elif tool_config["transport"] == "http":
+                                    st.warning(
+                                        f"'{tool_name}' tool using HTTP transport (updating to 'streamable_http' for better compatibility)."
+                                    )
+                                    tool_config["transport"] = "streamable_http"
+                                elif tool_config["transport"] == "websocket":
+                                    st.info(
+                                        f"'{tool_name}' tool using WebSocket transport."
+                                    )
 
                             elif "transport" not in tool_config:
                                 # Set default "stdio" if URL doesn't exist and transport isn't specified

config.json

@@ -6,6 +6,27 @@
     ],
     "transport": "stdio"
   },
+  "request_processor": {
+    "command": "python",
+    "args": [
+      "./python-services/service1/mcp_server.py"
+    ],
+    "transport": "stdio"
+  },
+  "data_analyzer": {
+    "command": "python",
+    "args": [
+      "./python-services/service2/mcp_server.py"
+    ],
+    "transport": "stdio"
+  },
+  "math_computer": {
+    "command": "python",
+    "args": [
+      "./python-services/service3/mcp_server.py"
+    ],
+    "transport": "stdio"
+  },
   "qa": {
     "transport": "sse",
     "url": "http://10.15.56.148:9230/sse"
@@ -13,5 +34,9 @@
   "review_generate": {
     "transport": "sse",
     "url": "http://10.15.56.148:8000/review"
+  },
+  "机械问题": {
+    "transport": "streamable_http",
+    "url": "http://127.0.0.1:7860/gradio_api/mcp/"
   }
 }

docker-compose.yml

@@ -0,0 +1,24 @@
+version: '3.8'
+
+services:
+  # 主Streamlit应用
+  streamlit-app:
+    build: .
+    container_name: streamlit-mcp-app
+    ports:
+      - "8501:8501"
+    environment:
+      - USE_LOGIN=false
+    volumes:
+      - ./config.json:/app/config.json:ro
+      - ./.env:/app/.env:ro
+    networks:
+      - mcp-network
+    restart: unless-stopped
+
+networks:
+  mcp-network:
+    driver: bridge
+
+volumes:
+  app-data: 

docker-config.json

@@ -0,0 +1,33 @@
+{
+  "get_current_time": {
+    "command": "python",
+    "args": [
+      "./mcp_server_time.py"
+    ],
+    "transport": "stdio"
+  },
+  "python_service_1": {
+    "transport": "http",
+    "url": "http://python-service-1:8000/process"
+  },
+  "python_service_2": {
+    "transport": "http",
+    "url": "http://python-service-2:8000/analyze"
+  },
+  "python_service_3": {
+    "transport": "http",
+    "url": "http://python-service-3:8000/compute"
+  },
+  "qa": {
+    "transport": "sse",
+    "url": "http://10.15.56.148:9230/sse"
+  },
+  "review_generate": {
+    "transport": "sse",
+    "url": "http://10.15.56.148:8000/review"
+  },
+  "机械问题": {
+    "transport": "streamable_http",
+    "url": "http://127.0.0.1:7860/gradio_api/mcp/"
+  }
+} 

dockers/.env.example

@@ -1,10 +0,0 @@
-ANTHROPIC_API_KEY=sk-ant-api03...
-OPENAI_API_KEY=sk-proj-o0gulL2J2a...
-LANGSMITH_API_KEY=lsv2_sk_ed22...
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_PROJECT=LangGraph-MCP-Agents
-
-USE_LOGIN=true
-USER_ID=admin
-USER_PASSWORD=admin1234

dockers/config.json

@@ -1,9 +0,0 @@
-{
-  "get_current_time": {
-    "command": "python",
-    "args": [
-      "./mcp_server_time.py"
-    ],
-    "transport": "stdio"
-  }
-}

dockers/docker-compose-KOR-mac.yaml

@@ -1,36 +0,0 @@
-services:
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        BUILDPLATFORM: ${BUILDPLATFORM:-linux/arm64}
-        TARGETPLATFORM: "linux/arm64"
-    image: teddylee777/langgraph-mcp-agents:KOR-0.2.1
-    platform: "linux/arm64"
-    ports:
-      - "8585:8585"
-    env_file:
-      - ./.env
-    environment:
-      - PYTHONUNBUFFERED=1
-      # Mac-specific optimizations
-      - NODE_OPTIONS=--max_old_space_size=2048
-      # Delegated file system performance for macOS
-      - PYTHONMALLOC=malloc
-      - USE_LOGIN=${USE_LOGIN:-false}
-      - USER_ID=${USER_ID:-}
-      - USER_PASSWORD=${USER_PASSWORD:-}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
-      - NODE_OPTIONS=${NODE_OPTIONS:-}
-    volumes:
-      - ./data:/app/data:cached
-      - ./config.json:/app/config.json
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "--fail", "http://localhost:8585/_stcore/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s

dockers/docker-compose-KOR.yaml

@@ -1,33 +0,0 @@
-services:
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        BUILDPLATFORM: ${BUILDPLATFORM:-linux/amd64}
-        TARGETPLATFORM: ${TARGETPLATFORM:-linux/amd64}
-    image: teddylee777/langgraph-mcp-agents:KOR-0.2.1
-    platform: ${TARGETPLATFORM:-linux/amd64}
-    ports:
-      - "8585:8585"
-    volumes:
-      - ./.env:/app/.env:ro
-      - ./data:/app/data:rw
-      - ./config.json:/app/config.json
-    env_file:
-      - ./.env
-    environment:
-      - PYTHONUNBUFFERED=1
-      - USE_LOGIN=${USE_LOGIN:-false}
-      - USER_ID=${USER_ID:-}
-      - USER_PASSWORD=${USER_PASSWORD:-}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
-      - NODE_OPTIONS=${NODE_OPTIONS:-}
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "--fail", "http://localhost:8585/_stcore/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s

dockers/docker-compose-mac.yaml

@@ -1,36 +0,0 @@
-services:
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        BUILDPLATFORM: ${BUILDPLATFORM:-linux/arm64}
-        TARGETPLATFORM: "linux/arm64"
-    image: teddylee777/langgraph-mcp-agents:0.2.1
-    platform: "linux/arm64"
-    ports:
-      - "8585:8585"
-    env_file:
-      - ./.env
-    environment:
-      - PYTHONUNBUFFERED=1
-      # Mac-specific optimizations
-      - NODE_OPTIONS=--max_old_space_size=2048
-      # Delegated file system performance for macOS
-      - PYTHONMALLOC=malloc
-      - USE_LOGIN=${USE_LOGIN:-false}
-      - USER_ID=${USER_ID:-}
-      - USER_PASSWORD=${USER_PASSWORD:-}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
-      - NODE_OPTIONS=${NODE_OPTIONS:-}
-    volumes:
-      - ./data:/app/data:cached
-      - ./config.json:/app/config.json
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "--fail", "http://localhost:8585/_stcore/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s

dockers/docker-compose.yaml

@@ -1,34 +0,0 @@
-services:
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        BUILDPLATFORM: ${BUILDPLATFORM:-linux/amd64}
-        TARGETPLATFORM: ${TARGETPLATFORM:-linux/amd64}
-    image: teddylee777/langgraph-mcp-agents:0.2.1
-    platform: ${TARGETPLATFORM:-linux/amd64}
-    ports:
-      - "8585:8585"
-    volumes:
-      # Optionally, you can remove this volume if you don’t need the file at runtime
-      - ./.env:/app/.env:ro
-      - ./data:/app/data:rw
-      - ./config.json:/app/config.json
-    env_file:
-      - ./.env
-    environment:
-      - PYTHONUNBUFFERED=1
-      - USE_LOGIN=${USE_LOGIN:-false}
-      - USER_ID=${USER_ID:-}
-      - USER_PASSWORD=${USER_PASSWORD:-}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
-      - NODE_OPTIONS=${NODE_OPTIONS:-}
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "--fail", "http://localhost:8585/_stcore/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s

mcp_server_local.py

@@ -1,36 +0,0 @@
-from mcp.server.fastmcp import FastMCP
-
-# Initialize FastMCP server with configuration
-mcp = FastMCP(
-    "Weather",  # Name of the MCP server
-    instructions="You are a weather assistant that can answer questions about the weather in a given location.",  # Instructions for the LLM on how to use this tool
-    host="0.0.0.0",  # Host address (0.0.0.0 allows connections from any IP)
-    port=8005,  # Port number for the server
-)
-
-
-@mcp.tool()
-async def get_weather(location: str) -> str:
-    """
-    Get current weather information for the specified location.
-
-    This function simulates a weather service by returning a fixed response.
-    In a production environment, this would connect to a real weather API.
-
-    Args:
-        location (str): The name of the location (city, region, etc.) to get weather for
-
-    Returns:
-        str: A string containing the weather information for the specified location
-    """
-    # Return a mock weather response
-    # In a real implementation, this would call a weather API
-    return f"It's always Sunny in {location}"
-
-
-if __name__ == "__main__":
-    # Start the MCP server with stdio transport
-    # stdio transport allows the server to communicate with clients
-    # through standard input/output streams, making it suitable for
-    # local development and testing
-    mcp.run(transport="stdio")

mcp_server_rag.py

@@ -1,89 +0,0 @@
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders import PyMuPDFLoader
-from langchain_community.vectorstores import FAISS
-from langchain_openai import OpenAIEmbeddings
-from mcp.server.fastmcp import FastMCP
-from dotenv import load_dotenv
-from typing import Any
-
-# Load environment variables from .env file (contains API keys)
-load_dotenv(override=True)
-
-
-def create_retriever() -> Any:
-    """
-    Creates and returns a document retriever based on FAISS vector store.
-
-    This function performs the following steps:
-    1. Loads a PDF document(place your PDF file in the data folder)
-    2. Splits the document into manageable chunks
-    3. Creates embeddings for each chunk
-    4. Builds a FAISS vector store from the embeddings
-    5. Returns a retriever interface to the vector store
-
-    Returns:
-        Any: A retriever object that can be used to query the document database
-    """
-    # Step 1: Load Documents
-    # PyMuPDFLoader is used to extract text from PDF files
-    loader = PyMuPDFLoader("data/sample.pdf")
-    docs = loader.load()
-
-    # Step 2: Split Documents
-    # Recursive splitter divides documents into chunks with some overlap to maintain context
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=50)
-    split_documents = text_splitter.split_documents(docs)
-
-    # Step 3: Create Embeddings
-    # OpenAI's text-embedding-3-small model is used to convert text chunks into vector embeddings
-    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
-
-    # Step 4: Create Vector Database
-    # FAISS is an efficient similarity search library that stores vector embeddings
-    # and allows for fast retrieval of similar vectors
-    vectorstore = FAISS.from_documents(documents=split_documents, embedding=embeddings)
-
-    # Step 5: Create Retriever
-    # The retriever provides an interface to search the vector database
-    # and retrieve documents relevant to a query
-    retriever = vectorstore.as_retriever()
-    return retriever
-
-
-# Initialize FastMCP server with configuration
-mcp = FastMCP(
-    "Retriever",
-    instructions="A Retriever that can retrieve information from the database.",
-    host="0.0.0.0",
-    port=8005,
-)
-
-
-@mcp.tool()
-async def retrieve(query: str) -> str:
-    """
-    Retrieves information from the document database based on the query.
-
-    This function creates a retriever, queries it with the provided input,
-    and returns the concatenated content of all retrieved documents.
-
-    Args:
-        query (str): The search query to find relevant information
-
-    Returns:
-        str: Concatenated text content from all retrieved documents
-    """
-    # Create a new retriever instance for each query
-    # Note: In production, consider caching the retriever for better performance
-    retriever = create_retriever()
-
-    # Use the invoke() method to get relevant documents based on the query
-    retrieved_docs = retriever.invoke(query)
-
-    # Join all document contents with newlines and return as a single string
-    return "\n".join([doc.page_content for doc in retrieved_docs])
-
-
-if __name__ == "__main__":
-    # Run the MCP server with stdio transport for integration with MCP clients
-    mcp.run(transport="stdio")

mcp_server_remote.py

@@ -1,37 +0,0 @@
-from mcp.server.fastmcp import FastMCP
-
-mcp = FastMCP(
-    "Weather",  # Name of the MCP server
-    instructions="You are a weather assistant that can answer questions about the weather in a given location.",  # Instructions for the LLM on how to use this tool
-    host="0.0.0.0",  # Host address (0.0.0.0 allows connections from any IP)
-    port=8005,  # Port number for the server
-)
-
-
-@mcp.tool()
-async def get_weather(location: str) -> str:
-    """
-    Get current weather information for the specified location.
-
-    This function simulates a weather service by returning a fixed response.
-    In a production environment, this would connect to a real weather API.
-
-    Args:
-        location (str): The name of the location (city, region, etc.) to get weather for
-
-    Returns:
-        str: A string containing the weather information for the specified location
-    """
-    # Return a mock weather response
-    # In a real implementation, this would call a weather API
-    return f"It's always Sunny in {location}"
-
-
-if __name__ == "__main__":
-    # Print a message indicating the server is starting
-    print("mcp remote server is running...")
-
-    # Start the MCP server with SSE transport
-    # Server-Sent Events (SSE) transport allows the server to communicate with clients
-    # over HTTP, making it suitable for remote/distributed deployments
-    mcp.run(transport="sse")

packages.txt

@@ -1,5 +0,0 @@
-curl
-gnupg
-ca-certificates
-nodejs
-npm

pyproject.toml

@@ -1,21 +0,0 @@
-[project]
-name = "langgraph-mcp-agents"
-version = "0.1.0"
-description = "LangGraph Agent with MCP Adapters"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "nest-asyncio>=1.6.0",
-    "faiss-cpu>=1.10.0",
-    "jupyter>=1.1.1",
-    "langchain-anthropic>=0.3.10",
-    "langchain-community>=0.3.20",
-    "langchain-mcp-adapters>=0.0.7",
-    "langchain-openai>=0.3.11",
-    "langgraph>=0.3.21",
-    "mcp[cli]>=1.6.0",
-    "notebook>=7.3.3",
-    "pymupdf>=1.25.4",
-    "python-dotenv>=1.1.0",
-    "streamlit>=1.44.1",
-]

python-services/MCP_README.md

@@ -0,0 +1,154 @@
+# MCP 服务器说明
+
+本项目现在包含三个MCP（Model Context Protocol）服务器，它们替代了原来的FastAPI HTTP服务。
+
+## 🚀 MCP 服务器概览
+
+### 1. RequestProcessor (service1)
+**功能**: 通用请求处理和数据分析
+**工具**:
+- `process_request`: 处理各种类型的请求和响应
+- `get_service_info`: 获取服务信息
+- `validate_data`: 验证数据结构
+
+**使用示例**:
+```python
+# 处理请求
+result = await process_request(
+    message="analyze this data", 
+    data={"key": "value"}
+)
+
+# 验证数据
+validation = await validate_data({"name": "test", "value": 123})
+```
+
+### 2. DataAnalyzer (service2)
+**功能**: 数据分析和统计计算
+**工具**:
+- `analyze_data`: 执行数据分析
+- `get_data_statistics`: 计算数值统计
+- `get_service_statistics`: 获取服务统计信息
+
+**使用示例**:
+```python
+# 分析数据
+analysis = await analyze_data(
+    input_data={"scores": [85, 90, 78, 92, 88]}, 
+    operation="statistics"
+)
+
+# 计算统计
+stats = await get_data_statistics([1, 2, 3, 4, 5])
+```
+
+### 3. MathComputer (service3)
+**功能**: 数学计算和统计函数
+**工具**:
+- `compute_operation`: 基本数学运算
+- `get_supported_operations`: 获取支持的操作
+- `advanced_math_operations`: 高级数学运算
+
+**使用示例**:
+```python
+# 基本计算
+result = await compute_operation(
+    numbers=[1, 2, 3, 4, 5], 
+    operation="average"
+)
+
+# 高级运算
+percentile = await advanced_math_operations(
+    operation="percentile",
+    numbers=[1, 2, 3, 4, 5],
+    percentile=75
+)
+```
+
+## 🔧 配置说明
+
+这些MCP服务器已在 `config.json` 中配置：
+
+```json
+{
+  "request_processor": {
+    "command": "python",
+    "args": ["./python-services/service1/mcp_server.py"],
+    "transport": "stdio"
+  },
+  "data_analyzer": {
+    "command": "python",
+    "args": ["./python-services/service2/mcp_server.py"],
+    "transport": "stdio"
+  },
+  "math_computer": {
+    "command": "python",
+    "args": ["./python-services/service3/mcp_server.py"],
+    "transport": "stdio"
+  }
+}
+```
+
+## 🚀 启动方式
+
+### 方式1: 通过主应用启动
+主Streamlit应用会自动启动这些MCP服务器：
+```bash
+python app.py
+```
+
+### 方式2: 独立启动
+```bash
+# 启动RequestProcessor
+python python-services/service1/mcp_server.py
+
+# 启动DataAnalyzer  
+python python-services/service2/mcp_server.py
+
+# 启动MathComputer
+python python-services/service3/mcp_server.py
+```
+
+## 📋 依赖要求
+
+每个MCP服务器需要以下依赖：
+```
+mcp
+fastmcp
+pydantic
+```
+
+## 🔄 从HTTP服务迁移
+
+原来的三个FastAPI HTTP服务已被MCP服务器替代：
+
+| 原HTTP服务 | 新MCP服务器 | 功能对比 |
+|-----------|------------|----------|
+| service1 (8001) | RequestProcessor | 请求处理 → 通用MCP工具 |
+| service2 (8002) | DataAnalyzer | 数据分析 → 数据分析MCP工具 |
+| service3 (8003) | MathComputer | 数学计算 → 数学计算MCP工具 |
+
+## 💡 优势
+
+1. **统一协议**: 所有服务都使用MCP协议
+2. **更好的集成**: 与LangChain等框架无缝集成
+3. **工具发现**: 自动工具发现和注册
+4. **类型安全**: 更好的参数类型定义和验证
+5. **异步支持**: 原生异步操作支持
+
+## 🐛 故障排除
+
+如果MCP服务器启动失败：
+
+1. 检查依赖是否正确安装：`pip install mcp fastmcp`
+2. 确认Python版本兼容性（建议3.8+）
+3. 检查文件路径是否正确
+4. 查看错误日志获取详细信息
+
+## 🔮 扩展建议
+
+可以基于这些MCP服务器模板创建更多专用服务：
+- 文件处理服务
+- 数据库查询服务  
+- 外部API集成服务
+- 机器学习推理服务 

python-services/service1/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8000/health || exit 1
+
+# Run the service
+CMD ["python", "main.py"] 

python-services/service1/mcp_server.py

@@ -0,0 +1,117 @@
+from mcp.server.fastmcp import FastMCP
+from typing import Dict, Any, Optional
+import json
+from datetime import datetime
+
+# Initialize FastMCP server
+mcp = FastMCP(
+    "RequestProcessor",  # Name of the MCP server
+    instructions="You are a request processing assistant that can handle various types of requests and perform data processing tasks.",
+    host="0.0.0.0",
+    port=8001,
+)
+
+@mcp.tool()
+async def process_request(message: str, data: Optional[Dict[str, Any]] = None) -> str:
+    """
+    Process various types of requests and perform data processing.
+    
+    Args:
+        message (str): The main message or request description
+        data (Dict[str, Any], optional): Additional data to process
+        
+    Returns:
+        str: Processing result and response
+    """
+    try:
+        if data is None:
+            data = {}
+        
+        # Process the request based on message content
+        processed_data = {
+            "original_message": message,
+            "processed_at": datetime.now().isoformat(),
+            "service_version": "1.0.0",
+            "data_size": len(str(data)),
+            "processing_status": "success"
+        }
+        
+        # Add any additional processing logic here
+        if "analyze" in message.lower():
+            processed_data["analysis_type"] = "text_analysis"
+            processed_data["word_count"] = len(message.split())
+        
+        if "validate" in message.lower():
+            processed_data["validation_type"] = "data_validation"
+            processed_data["is_valid"] = True
+        
+        return json.dumps(processed_data, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error processing request: {str(e)}"
+
+@mcp.tool()
+async def get_service_info() -> str:
+    """
+    Get information about the request processing service.
+    
+    Returns:
+        str: Service information
+    """
+    info = {
+        "service_name": "RequestProcessor",
+        "version": "1.0.0",
+        "status": "running",
+        "capabilities": [
+            "request_processing",
+            "data_analysis", 
+            "text_validation",
+            "general_data_handling"
+        ],
+        "description": "A versatile request processing service that can handle various types of data and requests"
+    }
+    
+    return json.dumps(info, indent=2, ensure_ascii=False)
+
+@mcp.tool()
+async def validate_data(data: Dict[str, Any]) -> str:
+    """
+    Validate the structure and content of provided data.
+    
+    Args:
+        data (Dict[str, Any]): Data to validate
+        
+    Returns:
+        str: Validation results
+    """
+    try:
+        validation_result = {
+            "is_valid": True,
+            "validation_timestamp": datetime.now().isoformat(),
+            "data_type": type(data).__name__,
+            "data_keys": list(data.keys()) if isinstance(data, dict) else [],
+            "data_size": len(str(data)),
+            "issues": []
+        }
+        
+        # Basic validation logic
+        if not data:
+            validation_result["is_valid"] = False
+            validation_result["issues"].append("Data is empty")
+        
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if value is None:
+                    validation_result["issues"].append(f"Key '{key}' has null value")
+        
+        if validation_result["issues"]:
+            validation_result["is_valid"] = False
+        
+        return json.dumps(validation_result, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error during validation: {str(e)}"
+
+if __name__ == "__main__":
+    # Start the MCP server with stdio transport
+    mcp.run(transport="stdio") 

python-services/service1/requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn
+mcp
+fastmcp
+pydantic 

python-services/service2/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8000/health || exit 1
+
+# Run the service
+CMD ["python", "main.py"] 

python-services/service2/mcp_server.py

@@ -0,0 +1,148 @@
+from mcp.server.fastmcp import FastMCP
+from typing import Dict, Any, List, Optional
+import json
+from datetime import datetime
+import statistics
+
+# Initialize FastMCP server
+mcp = FastMCP(
+    "DataAnalyzer",  # Name of the MCP server
+    instructions="You are a data analysis assistant that can perform various types of data analysis, statistics, and data processing tasks.",
+    host="0.0.0.0",
+    port=8002,
+)
+
+@mcp.tool()
+async def analyze_data(input_data: Dict[str, Any], operation: str = "default") -> str:
+    """
+    Perform data analysis on the provided input data.
+    
+    Args:
+        input_data (Dict[str, Any]): Data to analyze
+        operation (str): Type of analysis to perform
+        
+    Returns:
+        str: Analysis results
+    """
+    try:
+        analysis_result = {
+            "input_size": len(str(input_data)),
+            "operation_type": operation,
+            "analysis_timestamp": datetime.now().isoformat(),
+            "data_summary": f"Processed {len(input_data)} items",
+            "analysis_results": {}
+        }
+        
+        # Perform different types of analysis based on operation
+        if operation == "statistics":
+            if isinstance(input_data, dict):
+                values = [v for v in input_data.values() if isinstance(v, (int, float))]
+                if values:
+                    analysis_result["analysis_results"] = {
+                        "count": len(values),
+                        "mean": statistics.mean(values),
+                        "median": statistics.median(values),
+                        "min": min(values),
+                        "max": max(values),
+                        "std_dev": statistics.stdev(values) if len(values) > 1 else 0
+                    }
+        
+        elif operation == "text_analysis":
+            text_content = str(input_data)
+            analysis_result["analysis_results"] = {
+                "character_count": len(text_content),
+                "word_count": len(text_content.split()),
+                "line_count": len(text_content.splitlines()),
+                "unique_words": len(set(text_content.lower().split()))
+            }
+        
+        elif operation == "structure_analysis":
+            analysis_result["analysis_results"] = {
+                "data_type": type(input_data).__name__,
+                "is_nested": any(isinstance(v, (dict, list)) for v in input_data.values()) if isinstance(input_data, dict) else False,
+                "key_types": {k: type(v).__name__ for k, v in input_data.items()} if isinstance(input_data, dict) else {},
+                "depth": _get_nesting_depth(input_data)
+            }
+        
+        return json.dumps(analysis_result, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error analyzing data: {str(e)}"
+
+@mcp.tool()
+async def get_data_statistics(data: List[float]) -> str:
+    """
+    Calculate comprehensive statistics for a list of numerical data.
+    
+    Args:
+        data (List[float]): List of numerical values
+        
+    Returns:
+        str: Statistical analysis results
+    """
+    try:
+        if not data:
+            return "Error: No data provided"
+        
+        if not all(isinstance(x, (int, float)) for x in data):
+            return "Error: All values must be numerical"
+        
+        stats = {
+            "count": len(data),
+            "sum": sum(data),
+            "mean": statistics.mean(data),
+            "median": statistics.median(data),
+            "min": min(data),
+            "max": max(data),
+            "range": max(data) - min(data),
+            "variance": statistics.variance(data) if len(data) > 1 else 0,
+            "std_dev": statistics.stdev(data) if len(data) > 1 else 0,
+            "quartiles": statistics.quantiles(data, n=4) if len(data) > 1 else []
+        }
+        
+        return json.dumps(stats, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error calculating statistics: {str(e)}"
+
+@mcp.tool()
+async def get_service_statistics() -> str:
+    """
+    Get statistics and information about the data analysis service.
+    
+    Returns:
+        str: Service statistics and information
+    """
+    stats = {
+        "service_name": "DataAnalyzer",
+        "version": "1.0.0",
+        "status": "running",
+        "port": 8002,
+        "endpoints": ["analyze_data", "get_data_statistics", "get_service_statistics"],
+        "capabilities": [
+            "statistical_analysis",
+            "text_analysis",
+            "structure_analysis",
+            "data_processing"
+        ],
+        "description": "A comprehensive data analysis service providing statistical calculations and data insights"
+    }
+    
+    return json.dumps(stats, indent=2, ensure_ascii=False)
+
+def _get_nesting_depth(obj, current_depth=0):
+    """Helper function to calculate nesting depth of data structures."""
+    if isinstance(obj, dict):
+        if not obj:
+            return current_depth
+        return max(_get_nesting_depth(v, current_depth + 1) for v in obj.values())
+    elif isinstance(obj, list):
+        if not obj:
+            return current_depth
+        return max(_get_nesting_depth(item, current_depth + 1) for item in obj)
+    else:
+        return current_depth
+
+if __name__ == "__main__":
+    # Start the MCP server with stdio transport
+    mcp.run(transport="stdio") 

python-services/service2/requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+mcp
+fastmcp
+pydantic
+statistics 

python-services/service3/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8000/health || exit 1
+
+# Run the service
+CMD ["python", "main.py"] 

python-services/service3/mcp_server.py

@@ -0,0 +1,229 @@
+from mcp.server.fastmcp import FastMCP
+from typing import List, Optional
+import json
+from datetime import datetime
+import math
+
+# Initialize FastMCP server
+mcp = FastMCP(
+    "MathComputer",  # Name of the MCP server
+    instructions="You are a mathematical computation assistant that can perform various mathematical operations and calculations.",
+    host="0.0.0.0",
+    port=8003,
+)
+
+@mcp.tool()
+async def compute_operation(numbers: List[float], operation: str = "sum") -> str:
+    """
+    Perform mathematical operations on a list of numbers.
+    
+    Args:
+        numbers (List[float]): List of numbers to operate on
+        operation (str): Mathematical operation to perform
+        
+    Returns:
+        str: Computation results
+    """
+    try:
+        if not numbers:
+            return "Error: Numbers list cannot be empty"
+        
+        if not all(isinstance(x, (int, float)) for x in numbers):
+            return "Error: All values must be numerical"
+        
+        result = 0
+        operation_details = {}
+        
+        if operation == "sum":
+            result = sum(numbers)
+            operation_details = {
+                "method": "sum", 
+                "count": len(numbers),
+                "formula": "sum(numbers)"
+            }
+        elif operation == "average":
+            result = sum(numbers) / len(numbers)
+            operation_details = {
+                "method": "average", 
+                "count": len(numbers),
+                "formula": "sum(numbers) / len(numbers)"
+            }
+        elif operation == "max":
+            result = max(numbers)
+            operation_details = {
+                "method": "max", 
+                "count": len(numbers),
+                "formula": "max(numbers)"
+            }
+        elif operation == "min":
+            result = min(numbers)
+            operation_details = {
+                "method": "min", 
+                "count": len(numbers),
+                "formula": "min(numbers)"
+            }
+        elif operation == "product":
+            result = math.prod(numbers)
+            operation_details = {
+                "method": "product", 
+                "count": len(numbers),
+                "formula": "math.prod(numbers)"
+            }
+        elif operation == "geometric_mean":
+            if any(x <= 0 for x in numbers):
+                return "Error: Geometric mean requires all positive numbers"
+            result = math.pow(math.prod(numbers), 1/len(numbers))
+            operation_details = {
+                "method": "geometric_mean", 
+                "count": len(numbers),
+                "formula": "pow(product, 1/n)"
+            }
+        elif operation == "harmonic_mean":
+            if any(x == 0 for x in numbers):
+                return "Error: Harmonic mean requires all non-zero numbers"
+            result = len(numbers) / sum(1/x for x in numbers)
+            operation_details = {
+                "method": "harmonic_mean", 
+                "count": len(numbers),
+                "formula": "n / sum(1/x)"
+            }
+        else:
+            return f"Error: Unsupported operation '{operation}'. Supported operations: sum, average, max, min, product, geometric_mean, harmonic_mean"
+        
+        computation_result = {
+            "status": "success",
+            "result": result,
+            "operation": operation,
+            "service_name": "MathComputer",
+            "details": operation_details,
+            "computation_timestamp": datetime.now().isoformat(),
+            "input_numbers": numbers,
+            "input_count": len(numbers)
+        }
+        
+        return json.dumps(computation_result, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error during computation: {str(e)}"
+
+@mcp.tool()
+async def get_supported_operations() -> str:
+    """
+    Get list of supported mathematical operations.
+    
+    Returns:
+        str: Supported operations and descriptions
+    """
+    operations_info = {
+        "service_name": "MathComputer",
+        "supported_operations": [
+            "sum", 
+            "average", 
+            "max", 
+            "min", 
+            "product", 
+            "geometric_mean", 
+            "harmonic_mean"
+        ],
+        "descriptions": {
+            "sum": "Calculate the sum of all numbers",
+            "average": "Calculate the arithmetic mean",
+            "max": "Find the maximum value",
+            "min": "Find the minimum value",
+            "product": "Calculate the product of all numbers",
+            "geometric_mean": "Calculate the geometric mean (requires positive numbers)",
+            "harmonic_mean": "Calculate the harmonic mean (requires non-zero numbers)"
+        },
+        "description": "Mathematical computation service with advanced statistical functions"
+    }
+    
+    return json.dumps(operations_info, indent=2, ensure_ascii=False)
+
+@mcp.tool()
+async def advanced_math_operations(operation: str, numbers: List[float], **kwargs) -> str:
+    """
+    Perform advanced mathematical operations.
+    
+    Args:
+        operation (str): Advanced operation to perform
+        numbers (List[float]): List of numbers
+        **kwargs: Additional parameters for specific operations
+        
+    Returns:
+        str: Advanced computation results
+    """
+    try:
+        if not numbers:
+            return "Error: Numbers list cannot be empty"
+        
+        if operation == "percentile":
+            percentile = kwargs.get("percentile", 50)
+            if not 0 <= percentile <= 100:
+                return "Error: Percentile must be between 0 and 100"
+            
+            sorted_numbers = sorted(numbers)
+            index = (percentile / 100) * (len(sorted_numbers) - 1)
+            if index.is_integer():
+                result = sorted_numbers[int(index)]
+            else:
+                lower = sorted_numbers[int(index)]
+                upper = sorted_numbers[int(index) + 1]
+                result = lower + (upper - lower) * (index - int(index))
+            
+            operation_details = {
+                "method": "percentile",
+                "percentile": percentile,
+                "count": len(numbers),
+                "formula": f"percentile_{percentile}(sorted_numbers)"
+            }
+            
+        elif operation == "standard_deviation":
+            if len(numbers) < 2:
+                return "Error: Standard deviation requires at least 2 numbers"
+            
+            mean = sum(numbers) / len(numbers)
+            variance = sum((x - mean) ** 2 for x in numbers) / (len(numbers) - 1)
+            result = math.sqrt(variance)
+            
+            operation_details = {
+                "method": "standard_deviation",
+                "count": len(numbers),
+                "formula": "sqrt(sum((x - mean)²) / (n-1))"
+            }
+            
+        elif operation == "variance":
+            if len(numbers) < 2:
+                return "Error: Variance requires at least 2 numbers"
+            
+            mean = sum(numbers) / len(numbers)
+            result = sum((x - mean) ** 2 for x in numbers) / (len(numbers) - 1)
+            
+            operation_details = {
+                "method": "variance",
+                "count": len(numbers),
+                "formula": "sum((x - mean)²) / (n-1)"
+            }
+            
+        else:
+            return f"Error: Unsupported advanced operation '{operation}'. Supported: percentile, standard_deviation, variance"
+        
+        computation_result = {
+            "status": "success",
+            "result": result,
+            "operation": operation,
+            "service_name": "MathComputer",
+            "details": operation_details,
+            "computation_timestamp": datetime.now().isoformat(),
+            "input_numbers": numbers,
+            "input_count": len(numbers),
+            "additional_params": kwargs
+        }
+        
+        return json.dumps(computation_result, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error during advanced computation: {str(e)}"
+
+if __name__ == "__main__":
+    # Start the MCP server with stdio transport
+    mcp.run(transport="stdio") 

python-services/service3/requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn
+mcp
+fastmcp
+pydantic 

requirements.txt

@@ -6,8 +6,10 @@ langchain-mcp-adapters==0.0.9
 langchain-openai>=0.3.11
 langgraph>=0.3.21
 mcp>=1.6.0
+fastmcp
 notebook>=7.3.3
 pymupdf>=1.25.4
 python-dotenv>=1.1.0
 streamlit>=1.44.1 
-nest-asyncio>=1.6.0
+nest-asyncio>=1.6.0
+fastapi

runtime.txt

@@ -1 +0,0 @@
-python: 3.12

utils.py

@@ -19,20 +19,20 @@ async def astream_graph(
     include_subgraphs: bool = False,
 ) -> Dict[str, Any]:
     """
-    LangGraph의 실행 결과를 비동기적으로 스트리밍하고 직접 출력하는 함수입니다.
+    A function that asynchronously streams and directly outputs the execution results of LangGraph.
 
     Args:
-        graph (CompiledStateGraph): 실행할 컴파일된 LangGraph 객체
-        inputs (dict): 그래프에 전달할 입력값 딕셔너리
-        config (Optional[RunnableConfig]): 실행 설정 (선택적)
-        node_names (List[str], optional): 출력할 노드 이름 목록. 기본값은 빈 리스트
-        callback (Optional[Callable], optional): 각 청크 처리를 위한 콜백 함수. 기본값은 None
-            콜백 함수는 {"node": str, "content": Any} 형태의 딕셔너리를 인자로 받습니다.
-        stream_mode (str, optional): 스트리밍 모드 ("messages" 또는 "updates"). 기본값은 "messages"
-        include_subgraphs (bool, optional): 서브그래프 포함 여부. 기본값은 False
+        graph (CompiledStateGraph): The compiled LangGraph object to execute
+        inputs (dict): Input dictionary to pass to the graph
+        config (Optional[RunnableConfig]): Execution configuration (optional)
+        node_names (List[str], optional): List of node names to output. Default is empty list
+        callback (Optional[Callable], optional): Callback function for processing each chunk. Default is None
+            The callback function receives a dictionary in the form {"node": str, "content": Any}.
+        stream_mode (str, optional): Streaming mode ("messages" or "updates"). Default is "messages"
+        include_subgraphs (bool, optional): Whether to include subgraphs. Default is False
 
     Returns:
-        Dict[str, Any]: 최종 결과 (선택적)
+        Dict[str, Any]: Final result (optional)
     """
     config = config or {}
     final_result = {}
@@ -53,53 +53,53 @@ async def astream_graph(
                 "metadata": metadata,
             }
 
-            # node_names가 비어있거나 현재 노드가 node_names에 있는 경우에만 처리
+            # Only process if node_names is empty or current node is in node_names
             if not node_names or curr_node in node_names:
-                # 콜백 함수가 있는 경우 실행
+                # Execute callback function if it exists
                 if callback:
                     result = callback({"node": curr_node, "content": chunk_msg})
                     if hasattr(result, "__await__"):
                         await result
-                # 콜백이 없는 경우 기본 출력
+                # Default output if no callback
                 else:
-                    # 노드가 변경된 경우에만 구분선 출력
+                    # Only output separator when node changes
                     if curr_node != prev_node:
                         print("\n" + "=" * 50)
                         print(f"🔄 Node: \033[1;36m{curr_node}\033[0m 🔄")
                         print("- " * 25)
 
-                    # Claude/Anthropic 모델의 토큰 청크 처리 - 항상 텍스트만 추출
+                    # Handle Claude/Anthropic model token chunks - always extract text only
                     if hasattr(chunk_msg, "content"):
-                        # 리스트 형태의 content (Anthropic/Claude 스타일)
+                        # List form content (Anthropic/Claude style)
                         if isinstance(chunk_msg.content, list):
                             for item in chunk_msg.content:
                                 if isinstance(item, dict) and "text" in item:
                                     print(item["text"], end="", flush=True)
-                        # 문자열 형태의 content
+                        # String form content
                         elif isinstance(chunk_msg.content, str):
                             print(chunk_msg.content, end="", flush=True)
-                    # 그 외 형태의 chunk_msg 처리
+                    # Handle other forms of chunk_msg
                     else:
                         print(chunk_msg, end="", flush=True)
 
                 prev_node = curr_node
 
     elif stream_mode == "updates":
-        # 에러 수정: 언패킹 방식 변경
-        # REACT 에이전트 등 일부 그래프에서는 단일 딕셔너리만 반환함
+        # Error fix: Change unpacking method
+        # Some graphs like REACT agents return only a single dictionary
         async for chunk in graph.astream(
             inputs, config, stream_mode=stream_mode, subgraphs=include_subgraphs
         ):
-            # 반환 형식에 따라 처리 방법 분기
+            # Branch processing method based on return format
             if isinstance(chunk, tuple) and len(chunk) == 2:
-                # 기존 예상 형식: (namespace, chunk_dict)
+                # Expected format: (namespace, chunk_dict)
                 namespace, node_chunks = chunk
             else:
-                # 단일 딕셔너리만 반환하는 경우 (REACT 에이전트 등)
-                namespace = []  # 빈 네임스페이스 (루트 그래프)
-                node_chunks = chunk  # chunk 자체가 노드 청크 딕셔너리
+                # Case where only single dictionary is returned (REACT agents, etc.)
+                namespace = []  # Empty namespace (root graph)
+                node_chunks = chunk  # chunk itself is the node chunk dictionary
 
-            # 딕셔너리인지 확인하고 항목 처리
+            # Check if it's a dictionary and process items
             if isinstance(node_chunks, dict):
                 for node_name, node_chunk in node_chunks.items():
                     final_result = {
@@ -108,28 +108,28 @@ async def astream_graph(
                         "namespace": namespace,
                     }
 
-                    # node_names가 비어있지 않은 경우에만 필터링
+                    # Only filter if node_names is not empty
                     if len(node_names) > 0 and node_name not in node_names:
                         continue
 
-                    # 콜백 함수가 있는 경우 실행
+                    # Execute callback function if it exists
                     if callback is not None:
                         result = callback({"node": node_name, "content": node_chunk})
                         if hasattr(result, "__await__"):
                             await result
-                    # 콜백이 없는 경우 기본 출력
+                    # Default output if no callback
                     else:
-                        # 노드가 변경된 경우에만 구분선 출력 (messages 모드와 동일하게)
+                        # Only output separator when node changes (same as messages mode)
                         if node_name != prev_node:
                             print("\n" + "=" * 50)
                             print(f"🔄 Node: \033[1;36m{node_name}\033[0m 🔄")
                             print("- " * 25)
 
-                        # 노드의 청크 데이터 출력 - 텍스트 중심으로 처리
+                        # Output node chunk data - process with text focus
                         if isinstance(node_chunk, dict):
                             for k, v in node_chunk.items():
                                 if isinstance(v, BaseMessage):
-                                    # BaseMessage의 content 속성이 텍스트나 리스트인 경우를 처리
+                                    # Handle cases where BaseMessage's content attribute is text or list
                                     if hasattr(v, "content"):
                                         if isinstance(v.content, list):
                                             for item in v.content:
@@ -190,16 +190,16 @@ async def astream_graph(
                             else:
                                 print(node_chunk, end="", flush=True)
 
-                        # 구분선을 여기서 출력하지 않음 (messages 모드와 동일하게)
+                        # Don't output separator here (same as messages mode)
 
                     prev_node = node_name
             else:
-                # 딕셔너리가 아닌 경우 전체 청크 출력
+                # Output entire chunk if not a dictionary
                 print("\n" + "=" * 50)
                 print(f"🔄 Raw output 🔄")
                 print("- " * 25)
                 print(node_chunks, end="", flush=True)
-                # 구분선을 여기서 출력하지 않음
+                # Don't output separator here
                 final_result = {"content": node_chunks}
 
     else:
@@ -207,7 +207,7 @@ async def astream_graph(
             f"Invalid stream_mode: {stream_mode}. Must be 'messages' or 'updates'."
         )
 
-    # 필요에 따라 최종 결과 반환
+    # Return final result as needed
     return final_result
 
 
@@ -220,19 +220,19 @@ async def ainvoke_graph(
     include_subgraphs: bool = True,
 ) -> Dict[str, Any]:
     """
-    LangGraph 앱의 실행 결과를 비동기적으로 스트리밍하여 출력하는 함수입니다.
+    A function that asynchronously streams and outputs the execution results of LangGraph apps.
 
     Args:
-        graph (CompiledStateGraph): 실행할 컴파일된 LangGraph 객체
-        inputs (dict): 그래프에 전달할 입력값 딕셔너리
-        config (Optional[RunnableConfig]): 실행 설정 (선택적)
-        node_names (List[str], optional): 출력할 노드 이름 목록. 기본값은 빈 리스트
-        callback (Optional[Callable], optional): 각 청크 처리를 위한 콜백 함수. 기본값은 None
-            콜백 함수는 {"node": str, "content": Any} 형태의 딕셔너리를 인자로 받습니다.
-        include_subgraphs (bool, optional): 서브그래프 포함 여부. 기본값은 True
+        graph (CompiledStateGraph): The compiled LangGraph object to execute
+        inputs (dict): Input dictionary to pass to the graph
+        config (Optional[RunnableConfig]): Execution configuration (optional)
+        node_names (List[str], optional): List of node names to output. Default is empty list
+        callback (Optional[Callable], optional): Callback function for processing each chunk. Default is None
+            The callback function receives a dictionary in the form {"node": str, "content": Any}.
+        include_subgraphs (bool, optional): Whether to include subgraphs. Default is True
 
     Returns:
-        Dict[str, Any]: 최종 결과 (마지막 노드의 출력)
+        Dict[str, Any]: Final result (last node's output)
     """
     config = config or {}
     final_result = {}
@@ -240,20 +240,20 @@ async def ainvoke_graph(
     def format_namespace(namespace):
         return namespace[-1].split(":")[0] if len(namespace) > 0 else "root graph"
 
-    # subgraphs 매개변수를 통해 서브그래프의 출력도 포함
+    # Include subgraph output through subgraphs parameter
     async for chunk in graph.astream(
         inputs, config, stream_mode="updates", subgraphs=include_subgraphs
     ):
-        # 반환 형식에 따라 처리 방법 분기
+        # Branch processing method based on return format
         if isinstance(chunk, tuple) and len(chunk) == 2:
-            # 기존 예상 형식: (namespace, chunk_dict)
+            # Expected format: (namespace, chunk_dict)
             namespace, node_chunks = chunk
         else:
-            # 단일 딕셔너리만 반환하는 경우 (REACT 에이전트 등)
-            namespace = []  # 빈 네임스페이스 (루트 그래프)
-            node_chunks = chunk  # chunk 자체가 노드 청크 딕셔너리
+            # Case where only single dictionary is returned (REACT agents, etc.)
+            namespace = []  # Empty namespace (root graph)
+            node_chunks = chunk  # chunk itself is the node chunk dictionary
 
-        # 딕셔너리인지 확인하고 항목 처리
+        # Check if it's a dictionary and process items
         if isinstance(node_chunks, dict):
             for node_name, node_chunk in node_chunks.items():
                 final_result = {
@@ -262,17 +262,17 @@ async def ainvoke_graph(
                     "namespace": namespace,
                 }
 
-                # node_names가 비어있지 않은 경우에만 필터링
+                # Only filter if node_names is not empty
                 if node_names and node_name not in node_names:
                     continue
 
-                # 콜백 함수가 있는 경우 실행
+                # Execute callback function if it exists
                 if callback is not None:
                     result = callback({"node": node_name, "content": node_chunk})
-                    # 코루틴인 경우 await
+                    # Await if it's a coroutine
                     if hasattr(result, "__await__"):
                         await result
-                # 콜백이 없는 경우 기본 출력
+                # Default output if no callback
                 else:
                     print("\n" + "=" * 50)
                     formatted_namespace = format_namespace(namespace)
@@ -284,7 +284,7 @@ async def ainvoke_graph(
                         )
                     print("- " * 25)
 
-                    # 노드의 청크 데이터 출력
+                    # Output node chunk data
                     if isinstance(node_chunk, dict):
                         for k, v in node_chunk.items():
                             if isinstance(v, BaseMessage):
@@ -310,7 +310,7 @@ async def ainvoke_graph(
                             print(node_chunk)
                     print("=" * 50)
         else:
-            # 딕셔너리가 아닌 경우 전체 청크 출력
+            # Output entire chunk if not a dictionary
             print("\n" + "=" * 50)
             print(f"🔄 Raw output 🔄")
             print("- " * 25)
@@ -318,5 +318,5 @@ async def ainvoke_graph(
             print("=" * 50)
             final_result = {"content": node_chunks}
 
-    # 최종 결과 반환
+    # Return final result
     return final_result