LLM驱动的多Agent系统 - MCP协议工具发现实现

一个完全由LLM决策驱动的多智能体系统，实现了真正的MCP协议工具发现机制，支持SSE流式响应和动态Agent协作。

🎯 系统设计要求

核心原则

完全动态发现: 所有工具和能力通过运行时发现，零硬编码
LLM决策驱动: 工具选择和使用完全由LLM智能决策
MCP协议标准: 遵循Model Context Protocol标准进行工具集成
A2A协议统一: 所有专业Agent使用统一的A2A协议
SSE实时流式: 支持Server-Sent Events实时响应
配置文件驱动: 通过mcp_servers.json动态配置MCP服务器

禁止硬编码

❌ 不允许硬编码任何工具映射
❌ 不允许硬编码任何工具执行逻辑
❌ 不允许硬编码任何Agent或MCP服务器列表
❌ 不允许在Agent代码中写死其他Agent或MCP相关内容
✅ 必须通过发现机制获得所有能力信息
✅ 必须通过LLM决策选择和使用工具

🏗️ 系统架构

核心组件

┌─────────────────────────────────────────────────────────────┐
│                    LLM-Driven Common Agent                 │
│  ┌─────────────────┐  ┌──────────────────┐  ┌─────────────┐│
│  │   LLM Decision  │  │  MCP Protocol    │  │  A2A Agent  ││
│  │     Engine      │  │     Client       │  │  Discovery  ││
│  └─────────────────┘  └──────────────────┘  └─────────────┘│
└─────────────────────────────────────────────────────────────┘
                               │
                    ┌──────────┼──────────┐
                    │          │          │
        ┌───────────▼─┐    ┌───▼────┐   ┌─▼──────────────┐
        │ User Research│    │UI/UX   │   │Product Manager │
        │   Agent      │    │Designer│   │    Agent       │
        │   (A2A)      │    │(A2A)   │   │    (A2A)       │
        └──────────────┘    └────────┘   └────────────────┘
                               │
        ┌──────────────────────┼──────────────────────┐
        │                     │                      │
    ┌───▼────┐        ┌───────▼──┐           ┌──────▼──┐
    │ fetch  │        │filesystem│           │   git   │
    │  MCP   │        │   MCP    │    ...    │   MCP   │
    │ Server │        │  Server  │           │ Server  │
    └────────┘        └──────────┘           └─────────┘

1. LLM驱动的通用Agent (`common-agent/`)

LLM决策引擎: 基于DeepSeek V3的智能决策
MCP协议客户端: 真正的JSON-RPC 2.0 MCP通信
A2A Agent发现: 动态发现和协调专业Agent
SSE流式响应: 实时任务执行反馈
任务协调中心: 统一的任务分发和结果整合

2. 专业Agent (`specialist-agents/`)

用户调研Agent: 市场分析、用户调研、竞品分析、可用性测试
UI设计师Agent: 线框图设计、设计系统架构、UX优化分析
产品经理Agent: 需求分析、功能优先级、路线图规划
统一A2A协议: 所有Agent使用相同的@agent和@skill装饰器

3. MCP工具生态 (`config/mcp_servers.json`)

网络工具: fetch (HTTP请求、API调用)
文件系统: filesystem (文件读写、目录操作)
版本控制: git (Git仓库操作)
数据库: postgres (数据库查询)
集成工具: figma, github, discord, notion

✨ 核心特性

🔍 真正的MCP协议工具发现

通过tools/list端点动态发现工具
JSON-RPC 2.0标准通信协议
异步MCP服务器进程管理
工具元数据缓存和管理

🧠 LLM决策驱动

完全由LLM分析任务需求
智能选择最适合的工具和Agent
动态生成执行计划
无预设的硬编码逻辑

🌊 SSE实时流式响应

实时LLM分析进度反馈
逐步执行计划展示
Agent调用实时状态
完整任务执行流程追踪

🔗 A2A协议统一

标准化的Agent通信协议
动态能力发现机制
@skill装饰器声明技能
HTTP端点标准化

📦 配置驱动架构

mcp_servers.json驱动MCP配置
system.yaml系统配置
环境变量支持
零硬编码依赖

🚀 快速开始

1. 环境准备

# 克隆项目
git clone <repo-url>
cd AgentProjects2

# 安装Python依赖
pip install -r requirements.txt

# 配置LLM API密钥

2. 配置MCP服务器

编辑 config/mcp_servers.json:

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "description": "Fetch web content and APIs"
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
      "description": "Local file system access"
    }
  }
}

3. 启动系统

# 启动完整的多Agent系统
python3 start_multi_agent_system.py

系统将启动：

Common Agent (端口 8000)
User Research Agent (端口 8001)
Product Manager Agent (端口 8002)
UI Designer Agent (端口 8003)

4. 测试系统

# 发送任务请求 (普通响应)
curl -X POST http://localhost:8000/task \
     -H "Content-Type: application/json" \
     -d '{"description": "帮我分析竞品的用户界面设计"}'

# 发送任务请求 (SSE流式响应)
curl -X POST http://localhost:8000/task \
     -H "Content-Type: application/json" \
     -H "Accept: text/event-stream" \
     -d '{"description": "使用MCP工具读取项目文件"}'

# 检查系统状态
curl http://localhost:8000/status

🧪 测试过程

功能测试

1. 系统启动测试

✅ UI Designer Agent 启动成功 (PID: 59624)
✅ User Research Agent 启动成功 (PID: 59630)  
✅ Product Manager Agent 启动成功 (PID: 59636)
✅ LLM-Driven Common Agent 启动成功 (PID: 59642)
✅ 真实多Agent系统启动成功！4 个Agent正在运行

2. Agent发现测试

🔍 系统发现信息:
🎯 LLM客户端状态: ready
🔧 MCP服务器: 8 个
👥 发现的Agents: 2 个
   ✅ user_research_agent - 协议: a2a - 能力: 4 个
   ✅ ui_designer_agent - 协议: a2a - 能力: 4 个

3. MCP协议测试

📦 MCP协议客户端加载成功
🔧 客户端类型: MCPProtocolClient
📋 支持的功能:
   - JSON-RPC 2.0通信
   - MCP服务器进程管理  
   - 动态工具发现(list_tools)
   - 工具调用(call_tool)

4. 配置文件测试

✅ 发现 8 个配置的MCP服务器:
   🔧 fetch: uvx - Fetch web content and APIs
   🔧 filesystem: npx - Local file system access
   🔧 git: uvx - Git repository operations
   🔧 postgres: uvx - PostgreSQL database access
   🔧 discord: docker - Discord integration
   🔧 figma: uvx - Figma design tools
   🔧 github: docker - GitHub repository access
   🔧 notion: docker - Notion workspace integration

5. SSE流式测试

📨 data: {"event": "task_started", "task_id": "task_0"}
📨 data: {"event": "llm_analysis_started", "task_id": "task_0"}
📨 data: {"event": "llm_analysis_progress", "chunk": "分析中..."}
📨 data: {"event": "execution_plan", "plan": {...}}

📚 技术实现细节

MCP协议客户端 (`common-agent/src/mcp/mcp_protocol_client.py`)

class MCPProtocolClient:
    """真正的MCP协议客户端"""
    
    async def discover_tools(self, server_name: str, server_config: Dict) -> List[Dict]:
        """通过MCP协议发现服务器的工具列表"""
        # 1. 启动MCP服务器进程
        # 2. 发送initialize握手  
        # 3. 调用tools/list发现工具
        # 4. 缓存工具元数据
    
    async def call_tool(self, server_name: str, tool_name: str, arguments: Dict) -> Dict:
        """通过MCP协议调用工具"""
        # 发送tools/call请求执行工具

LLM决策引擎 (`common-agent/src/common_agent_llm_driven.py`)

async def process_task_with_llm_stream(self, task_id: str, task_data: Dict):
    """LLM驱动的任务处理 - SSE流式"""
    
    # 1. 构建系统上下文（可用Agents + MCP工具）
    system_context = await self._build_system_context()
    
    # 2. LLM分析任务并制定执行计划
    async for chunk in self.llm_client.stream_message(analysis_prompt):
        yield {"event": "llm_analysis_progress", "chunk": chunk}
    
    # 3. 根据LLM决策执行计划
    async for event in self._execute_llm_plan_stream(task_id, llm_decision):
        yield event

A2A Agent实现 (`specialist-agents/*/a2a_agent.py`)

@agent(
    agent_id="user_research_agent",
    name="User Research Specialist", 
    description="专业用户调研和市场分析Agent",
    version="1.0.0"
)
class UserResearchAgent:
    
    @skill(
        skill_id="conduct_user_research",
        name="User Research Study",
        description="设计和执行用户调研",
        tags=["user-research", "usability-testing"]
    )
    async def conduct_user_research(self, request: Dict[str, Any]) -> Dict[str, Any]:
        # 执行用户调研任务

动态工具发现 (`common-agent/src/mcp/simple_mcp_loader.py`)

async def _discover_tools_via_mcp_protocol(self, server_name: str, server_config: Dict) -> List[str]:
    """通过MCP协议动态发现工具 - 真正的实现"""
    
    from .mcp_protocol_client import mcp_client
    
    # 通过MCP协议发现工具
    tools = await mcp_client.discover_tools(server_name, server_config)
    
    # 提取工具名称列表
    tool_names = [tool.get('name', '') for tool in tools if tool.get('name')]
    
    return tool_names

🔧 配置文件

MCP服务器配置 (`config/mcp_servers.json`)

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "description": "Fetch web content and APIs"
    },
    "filesystem": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-filesystem", ".", "src/", "docs/"],
      "description": "Local file system access"
    },
    "figma": {
      "command": "uvx",
      "args": ["mcp-server-figma"],
      "env": {
        "FIGMA_ACCESS_TOKEN": "${FIGMA_ACCESS_TOKEN}"
      },
      "description": "Figma design tools"
    }
  }
}

系统配置 (`config/system.yaml`)

# Agent发现和配置现在完全动态化
# 所有Agent通过A2A协议在运行时发现
# 所有MCP工具通过协议动态发现
# LLM根据发现的能力进行决策

llm:
  provider: "siliconflow"
  model: "deepseek-ai/DeepSeek-V3"
  api_key: "${SILICONFLOW_API_KEY}"
  base_url: "https://api.siliconflow.cn/v1"

🎯 API接口

Common Agent接口

任务提交

POST /task
Content-Type: application/json

{
  "description": "任务描述",
  "type": "general" 
}

SSE流式任务提交

POST /task
Content-Type: application/json
Accept: text/event-stream

{
  "description": "任务描述"
}

响应流:

data: {"event": "task_started", "task_id": "task_0"}
data: {"event": "llm_analysis_progress", "chunk": "分析中..."}
data: {"event": "execution_plan", "plan": {...}}
data: {"event": "agent_call", "agent": "ui_designer", "status": "calling"}
data: {"event": "task_completed", "result": {...}}

系统状态

GET /status

Response:
{
  "status": "healthy",
  "llm_ready": true,
  "mcp_servers": 8,
  "discovered_agents": {
    "user_research_agent": {
      "endpoint": "http://localhost:8001",
      "capabilities": [...]
    }
  }
}

专业Agent接口 (A2A协议)

Agent信息

GET /a2a/agent.json

Response:
{
  "agent_id": "user_research_agent",
  "name": "User Research Specialist",
  "description": "专业用户调研和市场分析Agent",
  "version": "1.0.0",
  "skills": [...]
}

技能调用

POST /a2a/skills/{skill_id}
Content-Type: application/json

{
  "request": {...}
}

🔍 故障排除

🏆 实现成就

✅ 完全实现的功能

🔧 MCPProtocolClient: 真正的MCP协议客户端
📦 mcp_servers.json配置: 8个服务器动态加载
🔍 tools/list工具发现: 真正的MCP协议发现
⚡ tools/call工具调用: 真正的MCP协议调用
🌊 SSE流式响应: 实时任务执行反馈
🧠 LLM决策驱动: 智能工具选择和使用
🤖 A2A协议统一: 所有Agent使用相同标准

✅ 完全移除的硬编码

❌ 删除了所有硬编码工具映射
❌ 删除了所有硬编码工具执行逻辑
❌ 删除了所有硬编码MCP服务器假设
❌ 删除了所有静态capabilities配置
✅ 实现了100%动态发现和调用

✅ 架构优势

🔄 完全异步: 异步MCP协议通信
🎯 标准兼容: JSON-RPC 2.0标准实现
🚀 进程管理: 进程级MCP服务器管理
📊 实时监控: 实时工具发现和状态监控
🧠 智能决策: LLM驱动的智能工具选择
🌊 流式体验: SSE实时反馈用户体验

📞 联系与支持

这个项目展示了如何构建一个真正动态、智能的多Agent系统，完全遵循MCP协议标准，实现了零硬编码的工具发现和调用机制。

核心亮点:

🎯 真正的MCP协议实现 - 不是模拟，是真正的JSON-RPC 2.0通信
🧠 LLM完全决策 - 工具选择和使用完全由AI决定
🚫 零硬编码 - 所有能力都是运行时动态发现的
🌊 实时流式 - SSE提供流畅的用户体验
🔗 标准协议 - A2A和MCP协议的标准实现

🚀 MCP协议工具发现系统 - 让AI真正自主地发现和使用工具！

Name		Name	Last commit message	Last commit date
Latest commit History 6 Commits
common-agent		common-agent
config		config
docs		docs
shared		shared
specialist-agents		specialist-agents
.env.example		.env.example
.gitignore		.gitignore
README.md		README.md
README_REFACTORED.md		README_REFACTORED.md
e2e_integration_test.py		e2e_integration_test.py
real_multi_agent_system_test.py		real_multi_agent_system_test.py
requirements.txt		requirements.txt
requirements_py39.txt		requirements_py39.txt
start_multi_agent_system.py		start_multi_agent_system.py
test_real_agents_integration.py		test_real_agents_integration.py
web_ui.html		web_ui.html

jobop/AgentProjects2

Folders and files

Latest commit

History

Repository files navigation