"""MCP插件管理API""" from fastapi import APIRouter, HTTPException, Depends, Query, Request from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select from typing import List, Optional from datetime import datetime from app.database import get_db from app.models.mcp_plugin import MCPPlugin from app.schemas.mcp_plugin import ( MCPPluginCreate, MCPPluginSimpleCreate, MCPPluginUpdate, MCPPluginResponse, MCPToolCall, MCPTestResult ) import json from app.user_manager import User from app.mcp.registry import mcp_registry from app.logger import get_logger from app.services.ai_service import create_user_ai_service from app.models.settings import Settings as UserSettings logger = get_logger(__name__) router = APIRouter(prefix="/mcp/plugins", tags=["MCP插件管理"]) def require_login(request: Request) -> User: """依赖：要求用户已登录""" if not hasattr(request.state, "user") or not request.state.user: raise HTTPException(status_code=401, detail="需要登录") return request.state.user @router.get("", response_model=List[MCPPluginResponse]) async def list_plugins( enabled_only: bool = Query(False, description="只返回启用的插件"), category: Optional[str] = Query(None, description="按分类筛选"), user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 获取用户的所有MCP插件 """ query = select(MCPPlugin).where(MCPPlugin.user_id == user.user_id) if enabled_only: query = query.where(MCPPlugin.enabled == True) if category: query = query.where(MCPPlugin.category == category) query = query.order_by(MCPPlugin.sort_order, MCPPlugin.created_at) result = await db.execute(query) plugins = result.scalars().all() logger.info(f"用户 {user.user_id} 查询插件列表，共 {len(plugins)} 个") return plugins @router.post("", response_model=MCPPluginResponse) async def create_plugin( data: MCPPluginCreate, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 创建新的MCP插件 """ # 检查插件名是否已存在 result = await db.execute( select(MCPPlugin).where( MCPPlugin.user_id == user.user_id, MCPPlugin.plugin_name == data.plugin_name ) ) existing = result.scalar_one_or_none() if existing: raise HTTPException(status_code=400, detail=f"插件名已存在: {data.plugin_name}") # 创建插件数据 plugin_data = data.model_dump() # 如果没有提供display_name，使用plugin_name作为默认值 if not plugin_data.get("display_name"): plugin_data["display_name"] = plugin_data["plugin_name"] # 创建插件 plugin = MCPPlugin( user_id=user.user_id, **plugin_data ) db.add(plugin) await db.commit() await db.refresh(plugin) # 如果启用，加载到注册表 if plugin.enabled: success = await mcp_registry.load_plugin(plugin) if success: plugin.status = "active" else: plugin.status = "error" plugin.last_error = "加载失败" await db.commit() await db.refresh(plugin) logger.info(f"用户 {user.user_id} 创建插件: {plugin.plugin_name}") return plugin @router.post("/simple", response_model=MCPPluginResponse) async def create_plugin_simple( data: MCPPluginSimpleCreate, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 通过标准MCP配置JSON创建或更新插件（简化版） 接受格式： { "config_json": '{"mcpServers": {"exa": {"type": "http", "url": "...", "headers": {}}}}', "category": "search" } 自动从mcpServers中提取插件名称（取第一个键） 如果插件已存在，则更新；否则创建新插件 """ try: # 解析配置JSON config = json.loads(data.config_json) # 验证格式 if "mcpServers" not in config: raise HTTPException(status_code=400, detail="配置JSON必须包含mcpServers字段") servers = config["mcpServers"] if not servers or len(servers) == 0: raise HTTPException(status_code=400, detail="mcpServers不能为空") # 自动提取第一个插件名称 plugin_name = list(servers.keys())[0] server_config = servers[plugin_name] logger.info(f"从配置中提取插件名称: {plugin_name}") # 提取配置 server_type = server_config.get("type", "http") if server_type not in ["http", "stdio"]: raise HTTPException(status_code=400, detail=f"不支持的服务器类型: {server_type}") # 检查插件名是否已存在 result = await db.execute( select(MCPPlugin).where( MCPPlugin.user_id == user.user_id, MCPPlugin.plugin_name == plugin_name ) ) existing = result.scalar_one_or_none() # 构建插件数据 plugin_data = { "plugin_name": plugin_name, "display_name": plugin_name, "plugin_type": server_type, "enabled": data.enabled, "category": data.category, "sort_order": 0 } if server_type == "http": plugin_data["server_url"] = server_config.get("url") plugin_data["headers"] = server_config.get("headers", {}) if not plugin_data["server_url"]: raise HTTPException(status_code=400, detail="HTTP类型插件必须提供url字段") elif server_type == "stdio": plugin_data["command"] = server_config.get("command") plugin_data["args"] = server_config.get("args", []) plugin_data["env"] = server_config.get("env", {}) if not plugin_data["command"]: raise HTTPException(status_code=400, detail="Stdio类型插件必须提供command字段") if existing: # 更新现有插件 logger.info(f"插件 {plugin_name} 已存在，执行更新操作") # 先卸载旧插件 if existing.enabled: await mcp_registry.unload_plugin(user.user_id, existing.plugin_name) # 更新字段 for key, value in plugin_data.items(): setattr(existing, key, value) plugin = existing await db.commit() await db.refresh(plugin) # 如果启用，重新加载 if plugin.enabled: success = await mcp_registry.load_plugin(plugin) if success: plugin.status = "active" plugin.last_error = None else: plugin.status = "error" plugin.last_error = "加载失败" await db.commit() await db.refresh(plugin) logger.info(f"用户 {user.user_id} 更新插件: {plugin_name}") else: # 创建新插件 plugin = MCPPlugin( user_id=user.user_id, **plugin_data ) db.add(plugin) await db.commit() await db.refresh(plugin) # 如果启用，加载到注册表 if plugin.enabled: success = await mcp_registry.load_plugin(plugin) if success: plugin.status = "active" else: plugin.status = "error" plugin.last_error = "加载失败" await db.commit() await db.refresh(plugin) logger.info(f"用户 {user.user_id} 通过简化配置创建插件: {plugin_name}") return plugin except json.JSONDecodeError as e: raise HTTPException(status_code=400, detail=f"配置JSON格式错误: {str(e)}") except HTTPException: raise except Exception as e: logger.error(f"创建插件失败: {str(e)}") raise HTTPException(status_code=500, detail=f"创建插件失败: {str(e)}") @router.get("/{plugin_id}", response_model=MCPPluginResponse) async def get_plugin( plugin_id: str, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 获取插件详情 """ result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") return plugin @router.put("/{plugin_id}", response_model=MCPPluginResponse) async def update_plugin( plugin_id: str, data: MCPPluginUpdate, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 更新插件配置 """ result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") # 更新字段 update_data = data.model_dump(exclude_unset=True) for key, value in update_data.items(): setattr(plugin, key, value) await db.commit() await db.refresh(plugin) # 如果插件已启用，重新加载 if plugin.enabled: await mcp_registry.reload_plugin(plugin) logger.info(f"用户 {user.user_id} 更新插件: {plugin.plugin_name}") return plugin @router.delete("/{plugin_id}") async def delete_plugin( plugin_id: str, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 删除插件 """ result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") # 从注册表卸载 await mcp_registry.unload_plugin(user.user_id, plugin.plugin_name) # 删除数据库记录 await db.delete(plugin) await db.commit() logger.info(f"用户 {user.user_id} 删除插件: {plugin.plugin_name}") return {"message": "插件已删除", "plugin_name": plugin.plugin_name} @router.post("/{plugin_id}/toggle", response_model=MCPPluginResponse) async def toggle_plugin( plugin_id: str, enabled: bool = Query(..., description="启用或禁用"), user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 启用或禁用插件 """ result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") plugin.enabled = enabled if enabled: # 启用：加载到注册表 success = await mcp_registry.load_plugin(plugin) if success: plugin.status = "active" plugin.last_error = None else: plugin.status = "error" plugin.last_error = "加载失败" else: # 禁用：从注册表卸载 await mcp_registry.unload_plugin(user.user_id, plugin.plugin_name) plugin.status = "inactive" await db.commit() await db.refresh(plugin) action = "启用" if enabled else "禁用" logger.info(f"用户 {user.user_id} {action}插件: {plugin.plugin_name}") return plugin @router.post("/{plugin_id}/test", response_model=MCPTestResult) async def test_plugin( plugin_id: str, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 测试插件连接并调用工具验证功能 测试流程: 1. 测试MCP服务器连接 2. 获取工具列表 3. 自动选择一个工具进行实际调用测试 4. 返回完整测试结果 """ import time result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") if not plugin.enabled: return MCPTestResult( success=False, message="插件未启用", error="请先启用插件", suggestions=["点击开关按钮启用插件"] ) start_time = time.time() try: # 1. 确保插件已加载 if not mcp_registry.get_client(user.user_id, plugin.plugin_name): success = await mcp_registry.load_plugin(plugin) if not success: return MCPTestResult( success=False, message="插件加载失败", error="无法创建MCP客户端", suggestions=["请检查插件配置", "请确认服务器URL正确"] ) # 2. 测试连接并获取工具列表 test_result = await mcp_registry.test_plugin(user.user_id, plugin.plugin_name) if not test_result["success"]: plugin.status = "error" plugin.last_error = test_result.get("error", "连接测试失败") plugin.last_test_at = datetime.now() await db.commit() return MCPTestResult(**test_result) tools = test_result.get("tools", []) if not tools: plugin.status = "error" plugin.last_error = "插件没有提供任何工具" plugin.last_test_at = datetime.now() await db.commit() return MCPTestResult( success=False, message="插件没有提供任何工具", error="工具列表为空", response_time_ms=test_result.get("response_time_ms"), suggestions=["请检查插件配置", "请确认MCP服务器正常运行"] ) # 3. 使用AI智能选择工具并生成测试参数 logger.info(f"使用AI分析工具并生成测试计划...") # 获取用户的AI设置 settings_result = await db.execute( select(UserSettings).where(UserSettings.user_id == user.user_id) ) user_settings = settings_result.scalar_one_or_none() if not user_settings or not user_settings.api_key: # 如果没有AI配置，回退到简单测试 logger.warning("用户未配置AI服务，使用简单连接测试") plugin.status = "active" plugin.last_error = None plugin.last_test_at = datetime.now() plugin.tools = tools await db.commit() return MCPTestResult( success=True, message=f"✅ 连接测试成功（未配置AI，跳过工具调用测试）", response_time_ms=test_result.get("response_time_ms"), tools_count=len(tools), suggestions=[ f"连接测试: 成功", f"可用工具数: {len(tools)}", "提示: 配置AI服务后可进行智能工具调用测试" ] ) # 使用AI的标准Function Calling机制选择工具 ai_service = create_user_ai_service( api_provider=user_settings.api_provider, api_key=user_settings.api_key, api_base_url=user_settings.api_base_url, model_name=user_settings.llm_model, temperature=0.3, max_tokens=1000 ) # 将MCP工具格式转换为OpenAI Function Calling格式 openai_tools = [] for tool in tools: openai_tool = { "type": "function", "function": { "name": tool["name"], "description": tool.get("description", ""), } } # 将 inputSchema 转换为 parameters if "inputSchema" in tool: openai_tool["function"]["parameters"] = tool["inputSchema"] openai_tools.append(openai_tool) logger.info(f"转换了 {len(openai_tools)} 个MCP工具为OpenAI格式") logger.info(f"工具列表: {[t['function']['name'] for t in openai_tools]}") # 使用标准的Function Calling，将转换后的工具传递给AI prompt = f"""你是MCP插件测试助手，需要测试插件 '{plugin.plugin_name}' 的功能。 请选择一个合适的工具进行测试，优先选择搜索、查询类工具。 生成真实有效的测试参数（例如搜索"人工智能最新进展"而不是"test"）。 现在开始测试这个插件。""" system_prompt = "你是专业的API测试工具。当给定工具列表时，选择一个工具并使用合适的参数调用它。" # 调用AI的Function Calling logger.info(f"📞 准备调用AI Function Calling") logger.info(f" - Provider: {user_settings.api_provider}") logger.info(f" - Model: {user_settings.llm_model}") logger.info(f" - Tools count: {len(openai_tools)}") logger.debug(f" - Tools: {json.dumps(openai_tools, ensure_ascii=False, indent=2)}") ai_response = await ai_service.generate_text( prompt=prompt, system_prompt=system_prompt, tools=openai_tools, # 传递转换后的OpenAI格式工具 tool_choice="required" # 要求AI必须选择一个工具 ) logger.info(f"📥 收到AI响应") logger.info(f" - Response keys: {list(ai_response.keys())}") logger.debug(f" - Full response: {json.dumps(ai_response, ensure_ascii=False, indent=2)}") # 检查AI是否请求调用工具 if not ai_response.get("tool_calls"): # AI未调用工具，记录详细信息 logger.error(f"❌ AI未返回工具调用") logger.error(f" - Response: {ai_response}") logger.error(f" - Content: {ai_response.get('content', 'N/A')}") logger.error(f" - Finish reason: {ai_response.get('finish_reason', 'N/A')}") plugin.status = "error" plugin.last_error = "AI未返回工具调用请求" plugin.last_test_at = datetime.now() await db.commit() return MCPTestResult( success=False, message="❌ AI Function Calling失败", error=f"AI未返回工具调用请求。响应: {ai_response.get('content', 'N/A')[:200]}", tools_count=len(tools), suggestions=[ "请确认使用的AI模型支持Function Calling", "OpenAI: 需要gpt-4, gpt-3.5-turbo等模型", "Anthropic: 需要claude-3系列模型", f"当前Provider: {user_settings.api_provider}", f"当前模型: {user_settings.llm_model}", f"AI返回内容: {ai_response.get('content', 'N/A')[:100]}" ] ) # 获取第一个工具调用 tool_call = ai_response["tool_calls"][0] function = tool_call["function"] tool_name = function["name"] test_arguments = function["arguments"] # AI返回的arguments可能是JSON字符串，需要解析 if isinstance(test_arguments, str): try: test_arguments = json.loads(test_arguments) logger.info(f"✅ 解析AI返回的JSON字符串参数") except json.JSONDecodeError as e: logger.error(f"❌ 解析AI参数失败: {e}") return MCPTestResult( success=False, message="❌ AI返回的参数格式错误", error=f"无法解析参数JSON: {str(e)}", tools_count=len(tools), suggestions=["AI返回的参数不是有效的JSON格式"] ) logger.info(f"🤖 AI通过Function Calling选择的工具: {tool_name}") logger.info(f"📝 AI生成的参数: {test_arguments}") logger.info(f"📝 参数类型: {type(test_arguments).__name__}") # 4. 使用AI选择的工具和参数调用MCP工具 call_start = time.time() try: tool_result = await mcp_registry.call_tool( user.user_id, plugin.plugin_name, tool_name, test_arguments ) call_end = time.time() call_time = round((call_end - call_start) * 1000, 2) total_time = round((call_end - start_time) * 1000, 2) # 6. 测试成功，更新插件状态 plugin.status = "active" plugin.last_error = None plugin.last_test_at = datetime.now() plugin.tools = tools # 缓存工具列表 await db.commit() # 格式化工具结果用于显示 result_str = str(tool_result) # 如果结果太长，截取前800字符 if len(result_str) > 800: result_preview = result_str[:800] + "\n...(结果已截断，完整结果请查看日志)" else: result_preview = result_str return MCPTestResult( success=True, message=f"✅ Function Calling测试成功！工具 '{tool_name}' 调用正常", response_time_ms=total_time, tools_count=len(tools), suggestions=[ f"🤖 AI (Function Calling) 选择: {tool_name}", f"📝 AI生成的参数: {json.dumps(test_arguments, ensure_ascii=False)}", f"⏱️ 调用耗时: {call_time}ms", f"📊 返回结果:\n{result_preview}" ] ) except Exception as call_error: call_end = time.time() total_time = round((call_end - start_time) * 1000, 2) logger.warning(f"工具调用失败: {tool_name}, 错误: {call_error}") # 工具调用失败,但连接成功 plugin.status = "active" # 仍标记为active,因为连接是成功的 plugin.last_error = f"工具调用测试失败: {str(call_error)}" plugin.last_test_at = datetime.now() plugin.tools = tools await db.commit() return MCPTestResult( success=True, # 连接成功就算测试通过 message=f"⚠️ 连接成功，但工具调用失败", response_time_ms=total_time, tools_count=len(tools), error=f"工具 '{tool_name}' 调用失败: {str(call_error)}", suggestions=[ f"✅ 连接测试: 成功", f"❌ 工具调用测试: 失败", f"🤖 AI (Function Calling) 选择: {tool_name}", f"📝 AI生成的参数: {json.dumps(test_arguments, ensure_ascii=False)}", f"❌ 错误: {str(call_error)}", "💡 可能原因: API Key无效、参数错误或服务限制" ] ) except Exception as e: end_time = time.time() total_time = round((end_time - start_time) * 1000, 2) logger.error(f"测试插件失败: {plugin.plugin_name}, 错误: {e}") plugin.status = "error" plugin.last_error = str(e) plugin.last_test_at = datetime.now() await db.commit() return MCPTestResult( success=False, message="❌ 测试失败", response_time_ms=total_time, error=str(e), error_type=type(e).__name__, suggestions=["请检查服务器是否在线", "请确认配置正确", "请检查API Key是否有效"] ) def _build_test_arguments(tool_name: str, input_schema: dict, plugin_name: str) -> dict: """ 根据工具schema智能构造测试参数 Args: tool_name: 工具名称 input_schema: 输入schema plugin_name: 插件名称 Returns: 测试参数字典 """ # 针对常见MCP工具的默认测试参数 test_cases = { # Exa搜索工具 "search": { "query": "AI technology", "num_results": 3 }, "search_and_contents": { "query": "artificial intelligence", "num_results": 2 }, # Brave搜索 "brave_web_search": { "query": "AI news", "count": 3 }, # Filesystem工具 "read_file": { "path": "README.md" }, "list_directory": { "path": "." }, } # 如果有针对特定工具的测试用例，使用它 if tool_name in test_cases: logger.info(f"使用预定义测试参数: {test_cases[tool_name]}") return test_cases[tool_name] # 否则根据schema自动构造 properties = input_schema.get("properties", {}) required = input_schema.get("required", []) test_args = {} for prop_name, prop_schema in properties.items(): # 只填充必需的参数 if prop_name not in required: continue prop_type = prop_schema.get("type", "string") # 根据参数名称和类型猜测合适的测试值 if "query" in prop_name.lower() or "search" in prop_name.lower(): test_args[prop_name] = "test query" elif "url" in prop_name.lower(): test_args[prop_name] = "https://example.com" elif "path" in prop_name.lower(): test_args[prop_name] = "." elif "count" in prop_name.lower() or "limit" in prop_name.lower() or "num" in prop_name.lower(): test_args[prop_name] = 3 elif prop_type == "string": test_args[prop_name] = "test" elif prop_type == "number" or prop_type == "integer": test_args[prop_name] = 1 elif prop_type == "boolean": test_args[prop_name] = True elif prop_type == "array": test_args[prop_name] = [] elif prop_type == "object": test_args[prop_name] = {} logger.info(f"自动构造测试参数: {test_args}") return test_args @router.get("/{plugin_id}/tools") async def get_plugin_tools( plugin_id: str, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 获取插件提供的工具列表 """ result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") if not plugin.enabled: raise HTTPException(status_code=400, detail="插件未启用") try: tools = await mcp_registry.get_plugin_tools(user.user_id, plugin.plugin_name) # 更新缓存 plugin.tools = tools await db.commit() return { "plugin_name": plugin.plugin_name, "tools": tools, "count": len(tools) } except Exception as e: logger.error(f"获取工具列表失败: {plugin.plugin_name}, 错误: {e}") raise HTTPException(status_code=500, detail=f"获取工具列表失败: {str(e)}") @router.post("/call") async def call_mcp_tool( data: MCPToolCall, user: User = Depends(require_login), db: AsyncSession = Depends(get_db) ): """ 调用MCP工具 """ # 获取插件 result = await db.execute( select(MCPPlugin).where( MCPPlugin.id == data.plugin_id, MCPPlugin.user_id == user.user_id ) ) plugin = result.scalar_one_or_none() if not plugin: raise HTTPException(status_code=404, detail="插件不存在") if not plugin.enabled: raise HTTPException(status_code=400, detail="插件未启用") try: # 调用工具 result = await mcp_registry.call_tool( user.user_id, plugin.plugin_name, data.tool_name, data.arguments ) return { "success": True, "plugin_name": plugin.plugin_name, "tool_name": data.tool_name, "result": result } except Exception as e: logger.error(f"调用工具失败: {plugin.plugin_name}.{data.tool_name}, 错误: {e}") raise HTTPException(status_code=500, detail=f"工具调用失败: {str(e)}")