update

.clinerules

@@ -1,42 +1,23 @@
 # 自定义指令
 CUSTOM_INSTRUCTIONS = """
+# 必须遵守的约束
+1. 所有交流均采用中文
+2. conda 环境使用 learning
 
-# 基本配置
-env_tool（虚拟环境管理工具）: conda
-env_name(虚拟环境名称): airs-ai
-env_activate_cmd(激活虚拟环境命令): conda activate {env_name}
 
-# 角色
-你是一个基于python开发AI应用及MCP服务的高级程序员
+# 实现目标
+1. 使用MCP的python-sdk开发一个只用一个端口服务，即可加载多个应用的MCP服务
+2. 端口为 7860，
+3. 假设有MCP应用名称为为app01，则MCP服务路径为：http://localhost:7860/app01/sse，假设有MCP应用名称为为app02，则MCP服务路径为：http://localhost:7860/app02/sse，其他同理
 
-# 项目要求
-向用户调研
-
-# 开发资源参考
-暂无
-
----
-
-# 虚拟环境要求
-- 虚拟环境工具：{env_tool}
-- 使用名为{env_name}的虚拟环境，如果没有则创建，如果有则运行下面的命令行：{env_activate_cmd}
-
-# 项目管理
-- 使用 Memory Bank作为项目管理工具
-- 用户可以到当前目录下通过指令进行任务管理
-- Memory Bank 中使用中文记录的项目信息
-
-# 交流
-- 如非特别指明，必须使用中文进行交流
-- 如果需求不明确时，必须找用户进行需求调研，调研时，一次只提问一个问题
 
+# 知识参考
+1. 如果有任何关于 MCP python-sdk 的问题，请阅读：https://github.com/modelcontextprotocol/python-sdk
 
 """
-# 自动批准规则
-AUTO_APPROVE = true
 
 
----
+--- 
 description: Describes Cline's Memory Bank system, its structure, and workflows for maintaining project knowledge across sessions.
 author: https://github.com/nickbaumann98
 version: 1.0
@@ -166,3 +147,7 @@ flowchart TD
 Note: When triggered by **update memory bank**, I MUST review every memory bank file, even if some don't require updates. Focus particularly on activeContext.md and progress.md as they track current state.
 
 REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.
+
+"""
+# 自动批准规则
+AUTO_APPROVE = true

Dockerfile

@@ -1,7 +1,7 @@
 # Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
 # you will also find guides on how best to write your Dockerfile
 
-FROM python:3.13-slim
+FROM python:3.13
 
 RUN useradd -m -u 1000 user
 USER user
@@ -13,5 +13,4 @@ COPY --chown=user ./requirements.txt requirements.txt
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 COPY --chown=user . /app
-
-CMD ["python", "app.py"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,18 +1,127 @@
+import uvicorn
+from fastapi import FastAPI
+from starlette.routing import Mount
+from starlette.requests import Request
+from starlette.responses import StreamingResponse
+import asyncio
+import json
+
 from mcp.server.fastmcp import FastMCP
+from mcp.server.sse import SseServerTransport
+from starlette.applications import Starlette
+from starlette.routing import Mount, Route
+
+def create_sse_server(mcp: FastMCP):
+    """Create a Starlette app that handles SSE connections and message handling"""
+    transport = SseServerTransport("/messages/")
+
+    # Define handler functions
+    async def handle_sse(request):
+        async with transport.connect_sse(
+            request.scope, request.receive, request._send
+        ) as streams:
+            await mcp._mcp_server.run(
+                streams[0], streams[1], mcp._mcp_server.create_initialization_options()
+            )
+
+    # Create Starlette routes for SSE and message handling
+    routes = [
+        Route("/sse/", endpoint=handle_sse),
+        Mount("/messages/", app=transport.handle_post_message),
+    ]
+
+    # Create a Starlette app
+    return Starlette(routes=routes)
+
+# 创建 MCP 应用实例
+class App01:
+    def __init__(self):
+        self.mcp = FastMCP(name="app01", stateless_http=True)
+        self.register_endpoints()
+
+    def register_endpoints(self):
+        @self.mcp.resource("app01://info")
+        def app01_info() -> str:
+            """Information about App01"""
+            return "This is App01"
+
+        @self.mcp.tool()
+        def app01_echo(message: str) -> str:
+            """Echo a message in App01"""
+            return f"App01 Echo: {message}"
+
+        @self.mcp.tool()
+        def app01_add_integers(num1: int, num2: int) -> int:
+            """Add two integers in App01"""
+            return num1 + num2
+
+    async def sse_endpoint(self, request: Request):
+        print("Entering App01 SSE endpoint")
+        try:
+            # 这里可以实现 app01 的 SSE 逻辑
+            yield {"event": "message", "data": "Hello from App01"}
+            import asyncio
+            await asyncio.sleep(1) # 示例：每秒发送一条消息
+            yield {"event": "message", "data": "Another message from App01"}
+        except Exception as e:
+            print(f"Error in App01 SSE endpoint: {e}")
+            # Optionally yield an error event to the client
+            # yield {"event": "error", "data": str(e)}
+        print("Exiting App01 SSE endpoint")
+
+
+class App02:
+    def __init__(self):
+        self.mcp = FastMCP(name="app02", stateless_http=True)
+        self.register_endpoints()
+
+    def register_endpoints(self):
+        @self.mcp.resource("app02://status")
+        def app02_status() -> str:
+            """Status of App02"""
+            return "App02 is running"
+
+        @self.mcp.tool()
+        def app02_process(data: str) -> str:
+            """Process data in App02"""
+            return f"App02 Processing: {data}"
+
+        @self.mcp.tool()
+        def app02_multiply_integers(num1: int, num2: int) -> int:
+            """Multiply two integers in App02"""
+            return num1 * num2
+
+    async def sse_endpoint(self, request: Request):
+        print("Entering App02 SSE endpoint")
+        try:
+            # 这里可以实现 app02 的 SSE 逻辑
+            yield {"event": "message", "data": "Hello from App02"}
+            import asyncio
+            await asyncio.sleep(2) # 示例：每2秒发送一条消息
+            yield {"event": "message", "data": "Another message from App02"}
+        except Exception as e:
+            print(f"Error in App02 SSE endpoint: {e}")
+            # Optionally yield an error event to the client
+            # yield {"event": "error", "data": str(e)}
+        print("Exiting App02 SSE endpoint")
+
+
+# 初始化应用
+app01_instance = App01()
+app02_instance = App02()
 
-# mcp = FastMCP("Demo", root_path="/app01", message_path="/messages", sse_path="/sse")
-# mcp = FastMCP("Demo", root_path="/app01", message_path="/messages", sse_path="/app01/sse")
-mcp = FastMCP("Demo", message_path="/messages/", sse_path="/app01/sse")
+# 创建 FastAPI 应用
+app = FastAPI()
 
-@mcp.tool()
-def add(a: int, b: int) -> int:
-    return a + b
+# 挂载 MCP 应用的 SSE 端点
+# 使用 Mount 来指定路径前缀
+app.mount("/app01", app=app01_instance.mcp.sse_app())
+app.mount("/app02", app=app02_instance.mcp.sse_app())
 
-@mcp.resource("greeting://{name}")
-def get_greeting(name: str) -> str:
-    return f"Hello, {name}!"
+# 根路径，用于测试 FastAPI 是否正常工作
+@app.get("/")
+async def read_root():
+    return {"message": "FastAPI is running"}
 
-if __name__ == "__main__":
-    mcp.settings.host = '0.0.0.0'
-    mcp.settings.port = 7860
-    mcp.run(transport='sse')
+# if __name__ == "__main__":
+#     uvicorn.run(app, host="0.0.0.0", port=7860)

memory-bank/activeContext.md

@@ -0,0 +1,19 @@
+# 当前背景
+
+**当前工作重点:**
+实现一个使用 MCP Python SDK 的单端口多应用 MCP 服务。
+
+**最近的更改:**
+- 成功运行了 MCP 服务在端口 7860。
+- 为 `app01` 应用添加了一个名为 `app01_add_integers` 的整数加法工具。
+- 验证了 `app01_add_integers` 工具可以正常工作。
+
+**下一步计划:**
+- 确保服务在添加新工具和应用后依然稳定运行。
+- 根据用户需求添加更多的 MCP 应用和工具。
+- 完善记忆库文档以更详细地记录项目进展和技术细节。
+
+**当前的决策和注意事项:**
+- 使用 FastAPI 作为基础框架来托管 MCP 应用。
+- 每个 MCP 应用通过 `FastMCP` 实例管理自己的工具和资源。
+- 使用 `app.mount` 将不同的 MCP 应用挂载到不同的 URL 路径下。

memory-bank/productContext.md

@@ -0,0 +1,3 @@
+# 产品背景
+
+请在此处填写项目的目的、解决的问题、工作方式和用户体验目标。

memory-bank/progress.md

@@ -0,0 +1,17 @@
+# 项目进度
+
+**已完成的工作:**
+- 成功搭建并运行了使用 MCP Python SDK 的单端口多应用 MCP 服务 (端口 7860)。
+- 为 `app01` 应用添加了 `app01_add_integers` 工具。
+- 验证了 `app01_add_integers` 工具的功能。
+
+**剩余的工作:**
+- 根据用户需求添加更多的 MCP 应用和工具。
+- 持续监控和确保服务的稳定性。
+- 完善项目文档。
+
+**当前状态:**
+服务已基本框架搭建完成，并已成功添加并验证了一个工具。
+
+**已知问题:**
+- 在服务重启后，可能需要短暂等待才能成功调用新添加的工具（可能是初始化时间）。

memory-bank/projectbrief.md

@@ -0,0 +1,7 @@
+# 项目简报
+
+**核心需求和目标:**
+
+1.  使用 MCP 的 Python SDK 开发一个只用一个端口服务，即可加载多个应用的 MCP 服务。
+2.  服务端口为 7860。
+3.  MCP 服务路径格式为 `http://localhost:7860/app_name/sse`，其中 `app_name` 是 MCP 应用的名称（例如：app01, app02）。

memory-bank/systemPatterns.md

@@ -0,0 +1,3 @@
+# 系统模式
+
+请在此处填写系统的架构、关键技术决策、设计模式和组件关系。

memory-bank/techContext.md

@@ -0,0 +1,3 @@
+# 技术背景
+
+请在此处填写项目使用的技术、开发环境设置、技术约束和依赖项。

push.sh

@@ -1,4 +1,3 @@
-ssh-add ~/.ssh/id_ed25519_airsltd
 git add .
 git commit -m "update"
 git push

requirements.txt

@@ -1 +1,4 @@
-mcp[cli]
+fastapi
+uvicorn
+fastmcp
+sse_starlette

博客.md

@@ -0,0 +1,216 @@
+# 【MCP实战】基于Python SDK构建单端口多应用MCP服务
+
+## 1. 项目背景与目标
+
+在当前大模型智能体快速发展的背景下，如何有效地管理和调用各种外部工具（Tool）成为了一个关键问题。Model Context Protocol (MCP) 提供了一种标准化的方式来解决这个问题。本项目旨在利用 MCP 的 Python SDK，构建一个**单端口服务，能够加载并管理多个独立的 MCP 应用**。
+
+核心目标如下：
+- 使用 Python SDK 实现一个 MCP 服务。
+- 服务运行在 **7860 端口**。
+- 支持通过统一的端口和不同的路径访问不同的 MCP 应用，路径格式为 `http://localhost:7860/app_name/sse`。
+
+## 2. 技术选型与实现思路
+
+为了实现单端口多应用的服务，我们选择了 **FastAPI** 作为基础框架，因为它轻量、高性能，并且易于集成。MCP Python SDK 提供了 `FastMCP` 类，可以方便地与 FastAPI 集成。
+
+实现思路是：
+1.  创建一个主 FastAPI 应用。
+2.  为每个独立的 MCP 应用创建一个 `FastMCP` 实例。
+3.  使用 FastAPI 的 `app.mount()` 方法将每个 `FastMCP` 实例挂载到主应用的指定路径下（例如 `/app01`, `/app02`）。
+4.  主应用监听 7860 端口。
+
+这样，通过访问 `http://localhost:7860/app01/sse` 就可以与 `app01` 应用通信，访问 `http://localhost:7860/app02/sse` 就可以与 `app02` 应用通信，实现了单端口多应用的目标。
+
+## 3. 代码实现示例
+
+以下是 `app.py` 的核心代码示例，展示了如何使用 FastAPI 和 FastMCP 挂载多个应用：
+
+```python
+import uvicorn
+from fastapi import FastAPI
+from mcp.server.fastmcp import FastMCP
+import mcp.types as types
+
+# 创建主 FastAPI 应用
+app = FastAPI(
+    title="Multi-App MCP Server",
+    description="A single-port server hosting multiple MCP applications",
+    version="0.1.0",
+)
+
+# 创建第一个 MCP 应用实例 (app01)
+app01 = FastMCP("app01")
+
+# 为 app01 添加一个示例工具
+@app01.tool()
+def app01_add_integers(num1: int, num2: int) -> int:
+    """Adds two integers"""
+    return num1 + num2
+
+# 创建第二个 MCP 应用实例 (app02)
+app02 = FastMCP("app02")
+
+# 为 app02 添加一个示例工具
+@app02.tool()
+def app02_multiply_integers(num1: int, num2: int) -> int:
+    """Multiplies two integers"""
+    return num1 * num2
+
+# 将 MCP 应用挂载到主 FastAPI 应用的不同路径下
+app.mount("/app01", app01.app)
+app.mount("/app02", app02.app)
+
+# 根路径或其他API路由 (可选)
+@app.get("/")
+async def read_root():
+    return {"message": "Multi-App MCP Server is running"}
+
+if __name__ == "__main__":
+    # 运行主 FastAPI 应用，监听 7860 端口
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+```
+
+**代码说明:**
+- 我们导入了必要的库：`uvicorn`, `FastAPI`, `FastMCP`, `mcp.types`。
+- 创建了主 `FastAPI` 应用 `app`。
+- 创建了两个 `FastMCP` 实例 `app01` 和 `app02`，分别代表两个独立的 MCP 应用。
+- 使用 `@app01.tool()` 和 `@app02.tool()` 装饰器为各自的应用添加了示例工具。
+- 最关键的是使用 `app.mount("/app_name", app_instance.app)` 将每个 `FastMCP` 实例的内部 FastAPI 应用挂载到主应用的 `/app_name` 路径下。
+- 最后，使用 `uvicorn.run()` 启动主应用，监听 7860 端口。
+
+## 4. 项目进展与已完成工作
+
+目前，项目的基础框架已经搭建完成，并成功实现了单端口多应用的架构。
+
+**已完成的工作:**
+- 成功搭建并运行了使用 MCP Python SDK 的单端口多应用 MCP 服务 (端口 7860)。
+- 为 `app01` 应用添加了 `app01_add_integers` 工具，并验证了其功能。
+- 为 `app02` 应用添加了 `app02_multiply_integers` 工具，并验证了其功能。
+- 成功处理了包含加法和乘法的复合数学表达式计算请求，验证了不同应用工具的协同工作。
+
+**当前状态:**
+服务已基本框架搭建完成，并已成功添加并验证了两个应用的示例工具。
+
+## 5. 在Cline中测试
+
+在Cline中，我们可以直接调用已连接的MCP服务器提供的工具进行测试。以下是一些测试算例：
+
+**测试1：1+1=？**
+使用 `app01` 的 `app01_add_integers` 工具计算：
+```xml
+<use_mcp_tool>
+<server_name>app01</server_name>
+<tool_name>app01_add_integers</tool_name>
+<arguments>
+{
+  "num1": 1,
+  "num2": 1
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：2
+
+**测试2：2*2=？**
+使用 `app02` 的 `app02_multiply_integers` 工具计算：
+```xml
+<use_mcp_tool>
+<server_name>app02</server_name>
+<tool_name>app02_multiply_integers</tool_name>
+<arguments>
+{
+  "num1": 2,
+  "num2": 2
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：4
+
+**测试3：1+1=？ 2*2=？**
+分别调用 `app01_add_integers` 和 `app02_multiply_integers` 工具：
+```xml
+<use_mcp_tool>
+<server_name>app01</server_name>
+<tool_name>app01_add_integers</tool_name>
+<arguments>
+{
+  "num1": 1,
+  "num2": 1
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：2
+```xml
+<use_mcp_tool>
+<server_name>app02</server_name>
+<tool_name>app02_multiply_integers</tool_name>
+<arguments>
+{
+  "num1": 2,
+  "num2": 2
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：4
+
+**测试4：1+1+2*2=？**
+根据数学运算顺序，先计算乘法，再计算加法。
+首先计算 2*2：
+```xml
+<use_mcp_tool>
+<server_name>app02</server_name>
+<tool_name>app02_multiply_integers</tool_name>
+<arguments>
+{
+  "num1": 2,
+  "num2": 2
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：4
+然后计算 1+1+4：
+```xml
+<use_mcp_tool>
+<server_name>app01</server_name>
+<tool_name>app01_add_integers</tool_name>
+<arguments>
+{
+  "num1": 1,
+  "num2": 1
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：2
+最后计算 2+4：
+```xml
+<use_mcp_tool>
+<server_name>app01</server_name>
+<tool_name>app01_add_integers</tool_name>
+<arguments>
+{
+  "num1": 2,
+  "num2": 4
+}
+</arguments>
+</use_mcp_tool>
+```
+结果：6
+
+这些测试表明，我们可以通过Cline成功调用不同MCP应用中的工具，并进行复杂的计算。
+
+## 6. 总结与展望
+
+本项目成功地探索了如何使用 MCP Python SDK 和 FastAPI 构建一个高效、可扩展的单端口多应用 MCP 服务。这种架构使得在同一个端口下集成多个不同的 MCP 功能成为可能，极大地简化了部署和管理。
+
+未来可以继续完善的功能包括：
+- 添加更多的 MCP 应用和工具，涵盖不同的功能领域。
+- 实现更灵活的应用加载机制，例如动态加载或配置。
+- 增强错误处理和日志记录。
+- 编写更完善的文档和示例。
+
+通过 MCP 协议，我们可以更便捷地将各种能力封装成工具，赋能给大模型智能体，从而构建更强大、更实用的 AI 应用。