基于MCP协议的LLM-Agent数据流转与业务实现详解

阿湯哥2025-12-20 19:54

基于MCP协议的LLM-Agent数据流转与业务实现详解

🎯 引言

MCP (Model Context Protocol) 不仅仅是一个简单的工具调用协议，更是连接大语言模型(LLM)与外部世界的重要桥梁。本文将深入分析在基于MCP协议的AI Agent系统中，数据如何在用户 、LLM 、MCP Client 、MCP Server之间流转，并详细说明哪些功能可以通过框架实现，哪些需要根据具体业务进行定制开发。

🏗️ 完整系统架构

LLM-MCP集成架构图

复制代码 
┌─────────────────────────────────────────────────────────────────────────┐
│                        AI Agent 完整生态系统                            │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐ │
│  │    用户     │    │     LLM     │    │ MCP Client  │    │ MCP Server  │ │
│  │   (User)    │    │  (Claude/   │    │ (AI Agent)  │    │ (Tools &    │ │
│  │             │    │   GPT-4)    │    │             │    │ Resources)  │ │
│  └─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘ │
│         │                   │                   │                   │     │
│         │ 1.自然语言请求     │                   │                   │     │
│         ├──────────────────►│                   │                   │     │
│         │                   │ 2.工具发现&选择    │                   │     │
│         │                   ├──────────────────►│                   │     │
│         │                   │                   │ 3.工具调用        │     │
│         │                   │                   ├──────────────────►│     │
│         │                   │                   │                   │     │
│         │                   │                   │ 4.执行结果        │     │
│         │                   │                   │◄──────────────────┤     │
│         │                   │ 5.结果整合&推理    │                   │     │
│         │                   │◄──────────────────┤                   │     │
│         │ 6.最终回复        │                   │                   │     │
│         │◄──────────────────┤                   │                   │     │
│         │                   │                   │                   │     │
│  ┌─────────────────────────────────────────────────────────────────────┐ │
│  │                        数据流转层                                   │ │
│  │                                                                     │ │
│  │  框架实现部分:                    业务实现部分:                     │ │
│  │  • JSON-RPC通信协议              • 工具业务逻辑                     │ │
│  │  • 连接管理                      • 资源访问策略                     │ │
│  │  • 消息序列化/反序列化           • 权限控制规则                     │ │
│  │  • 错误处理                      • 数据转换逻辑                     │ │
│  │  • 会话状态管理                  • LLM提示工程                      │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘

🔄 数据流转详细分析

阶段1: 用户请求到LLM推理

1.1 用户输入处理 (业务实现)
python 复制代码 
class UserRequestProcessor:
    """用户请求处理器 - 业务实现部分"""
    
    def __init__(self, llm_client, mcp_client):
        self.llm_client = llm_client
        self.mcp_client = mcp_client
        self.context_manager = ConversationContextManager()
    
    async def process_user_input(self, user_input: str, session_id: str) -> str:
        """
        处理用户输入 - 需要业务定制
        
        业务实现要点:
        1. 用户意图识别
        2. 上下文管理
        3. 安全过滤
        4. 个性化处理
        """
        # 1. 获取会话上下文 (业务逻辑)
        context = await self.context_manager.get_context(session_id)
        
        # 2. 用户输入预处理 (业务逻辑)
        processed_input = await self._preprocess_input(user_input, context)
        
        # 3. 构建LLM提示 (业务逻辑)
        llm_prompt = await self._build_llm_prompt(processed_input, context)
        
        # 4. 调用LLM进行推理
        return await self._invoke_llm_with_tools(llm_prompt, session_id)
    
    async def _preprocess_input(self, user_input: str, context: dict) -> str:
        """用户输入预处理 - 业务定制"""
        # 敏感信息过滤
        filtered_input = self._filter_sensitive_content(user_input)
        
        # 意图识别
        intent = await self._detect_user_intent(filtered_input)
        
        # 上下文相关性分析
        contextual_input = self._enhance_with_context(filtered_input, context)
        
        return {
            "original": user_input,
            "filtered": filtered_input,
            "intent": intent,
            "contextual": contextual_input
        }
    
    async def _build_llm_prompt(self, processed_input: dict, context: dict) -> str:
        """构建LLM提示 - 业务定制"""
        # 这是业务实现的核心部分
        prompt_template = """
        你是一个智能助手，可以使用以下工具来帮助用户:
        
        可用工具:
        {available_tools}
        
        对话历史:
        {conversation_history}
        
        用户请求: {user_request}
        用户意图: {user_intent}
        
        请分析用户需求，选择合适的工具，并提供帮助。
        """
        
        # 获取可用工具列表
        available_tools = await self.mcp_client.get_available_tools_description()
        
        return prompt_template.format(
            available_tools=available_tools,
            conversation_history=context.get("history", ""),
            user_request=processed_input["contextual"],
            user_intent=processed_input["intent"]
        )
1.2 LLM推理与工具选择 (框架+业务实现)
python 复制代码 
class LLMToolIntegration:
    """LLM与工具集成 - 框架+业务实现"""
    
    def __init__(self, llm_client, mcp_client):
        self.llm_client = llm_client  # 框架提供
        self.mcp_client = mcp_client  # 框架提供
        self.tool_selector = ToolSelector()  # 业务实现
    
    async def invoke_llm_with_tools(self, prompt: str, session_id: str) -> str:
        """
        LLM工具调用集成
        
        框架实现: LLM API调用、MCP通信协议
        业务实现: 工具选择策略、结果处理逻辑
        """
        
        # 1. 获取可用工具 (框架实现)
        available_tools = await self.mcp_client.list_all_tools()
        
        # 2. 构建工具描述给LLM (业务实现)
        tools_for_llm = self._format_tools_for_llm(available_tools)
        
        # 3. LLM推理 (框架实现)
        llm_response = await self.llm_client.chat_completion(
            messages=[{"role": "user", "content": prompt}],
            tools=tools_for_llm,
            tool_choice="auto"
        )
        
        # 4. 处理LLM响应 (业务实现)
        return await self._process_llm_response(llm_response, session_id)
    
    def _format_tools_for_llm(self, mcp_tools: List[Tool]) -> List[dict]:
        """
        将MCP工具格式转换为LLM API格式 - 业务实现
        
        这里需要根据具体LLM API格式进行转换
        """
        llm_tools = []
        
        for tool in mcp_tools:
            # 转换为OpenAI函数调用格式
            llm_tool = {
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.inputSchema
                }
            }
            llm_tools.append(llm_tool)
        
        return llm_tools
    
    async def _process_llm_response(self, llm_response, session_id: str) -> str:
        """处理LLM响应 - 业务实现"""
        
        if llm_response.tool_calls:
            # LLM选择了工具调用
            tool_results = []
            
            for tool_call in llm_response.tool_calls:
                # 执行工具调用
                result = await self._execute_tool_call(tool_call)
                tool_results.append(result)
            
            # 将工具结果返回给LLM进行最终整合
            return await self._llm_integrate_results(
                llm_response.content, 
                tool_results, 
                session_id
            )
        else:
            # LLM直接回复，无需工具调用
            return llm_response.content

阶段2: MCP Client到MCP Server的工具调用

2.1 工具调用执行 (框架实现为主)
python 复制代码 
class MCPToolExecutor:
    """MCP工具执行器 - 主要由框架实现"""
    
    def __init__(self):
        self.server_connections = {}  # 框架管理
        self.tool_registry = {}       # 框架管理
        self.execution_monitor = ExecutionMonitor()  # 业务监控
    
    async def execute_tool_call(self, tool_call) -> dict:
        """
        执行工具调用
        
        框架实现: 连接管理、消息传输、协议处理
        业务实现: 参数验证、结果处理、监控记录
        """
        
        tool_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        
        # 1. 工具路由 (框架实现)
        server_name = self._route_tool_to_server(tool_name)
        session = self.server_connections[server_name]
        
        # 2. 参数预处理 (业务实现)
        processed_args = await self._preprocess_arguments(
            tool_name, arguments
        )
        
        # 3. 执行工具调用 (框架实现)
        try:
            # 框架负责JSON-RPC通信
            result = await session.call_tool(tool_name, processed_args)
            
            # 4. 结果后处理 (业务实现)
            processed_result = await self._postprocess_result(
                tool_name, result, arguments
            )
            
            # 5. 监控记录 (业务实现)
            await self.execution_monitor.record_execution(
                tool_name, arguments, processed_result, success=True
            )
            
            return processed_result
            
        except Exception as e:
            # 错误处理 (框架+业务实现)
            await self.execution_monitor.record_execution(
                tool_name, arguments, str(e), success=False
            )
            
            return self._handle_tool_error(tool_name, e)
    
    def _route_tool_to_server(self, tool_name: str) -> str:
        """工具路由 - 框架实现"""
        # 框架维护工具到服务器的映射关系
        return self.tool_registry.get(tool_name, {}).get("server")
    
    async def _preprocess_arguments(self, tool_name: str, arguments: dict) -> dict:
        """参数预处理 - 业务实现"""
        # 业务相关的参数验证和转换
        
        if tool_name == "database_query":
            # 数据库查询参数安全检查
            return self._sanitize_sql_parameters(arguments)
        
        elif tool_name == "file_read":
            # 文件路径安全检查
            return self._validate_file_path(arguments)
        
        elif tool_name == "api_call":
            # API调用参数处理
            return self._prepare_api_parameters(arguments)
        
        return arguments
    
    async def _postprocess_result(self, tool_name: str, result, original_args: dict) -> dict:
        """结果后处理 - 业务实现"""
        # 业务相关的结果处理和格式化
        
        base_result = {
            "tool_name": tool_name,
            "success": True,
            "content": result.content[0].text if result.content else "",
            "metadata": {
                "execution_time": time.time(),
                "server_info": result.get("server_info", {})
            }
        }
        
        # 根据工具类型进行特殊处理
        if tool_name == "database_query":
            base_result["data"] = self._format_database_result(result)
        
        elif tool_name == "file_read":
            base_result["file_info"] = self._extract_file_metadata(result)
        
        return base_result
2.2 MCP Server业务逻辑实现
python 复制代码 
class BusinessMCPServer:
    """业务MCP服务器 - 完全业务实现"""
    
    def __init__(self, business_config):
        self.server = Server("business-server")  # 框架提供
        self.business_config = business_config   # 业务配置
        self.database = DatabaseManager()       # 业务组件
        self.file_manager = FileManager()       # 业务组件
        self.api_client = APIClient()           # 业务组件
        
        # 注册业务工具
        self._register_business_tools()
    
    def _register_business_tools(self):
        """注册业务工具 - 完全业务实现"""
        
        @self.server.list_tools()
        async def handle_list_tools() -> List[Tool]:
            """定义业务工具 - 业务实现"""
            return [
                # 数据库工具
                Tool(
                    name="query_customer_info",
                    description="查询客户信息",
                    inputSchema={
                        "type": "object",
                        "properties": {
                            "customer_id": {"type": "string"},
                            "fields": {
                                "type": "array",
                                "items": {"type": "string"},
                                "default": ["name", "email", "phone"]
                            }
                        },
                        "required": ["customer_id"]
                    }
                ),
                
                # 业务流程工具
                Tool(
                    name="create_service_order",
                    description="创建服务订单",
                    inputSchema={
                        "type": "object",
                        "properties": {
                            "customer_id": {"type": "string"},
                            "service_type": {"type": "string"},
                            "priority": {"type": "string", "enum": ["low", "medium", "high"]},
                            "description": {"type": "string"}
                        },
                        "required": ["customer_id", "service_type"]
                    }
                ),
                
                # 外部API工具
                Tool(
                    name="send_notification",
                    description="发送通知消息",
                    inputSchema={
                        "type": "object",
                        "properties": {
                            "recipient": {"type": "string"},
                            "message": {"type": "string"},
                            "channel": {"type": "string", "enum": ["email", "sms", "push"]}
                        },
                        "required": ["recipient", "message", "channel"]
                    }
                )
            ]
        
        @self.server.call_tool()
        async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
            """处理工具调用 - 业务实现"""
            
            try:
                if name == "query_customer_info":
                    return await self._query_customer_info(arguments)
                
                elif name == "create_service_order":
                    return await self._create_service_order(arguments)
                
                elif name == "send_notification":
                    return await self._send_notification(arguments)
                
                else:
                    raise ValueError(f"未知工具: {name}")
                    
            except Exception as e:
                return [TextContent(
                    type="text", 
                    text=f"工具执行失败: {str(e)}"
                )]
    
    async def _query_customer_info(self, args: dict) -> List[TextContent]:
        """查询客户信息 - 业务实现"""
        
        customer_id = args["customer_id"]
        fields = args.get("fields", ["name", "email", "phone"])
        
        # 1. 权限检查 (业务逻辑)
        if not await self._check_customer_access_permission(customer_id):
            raise PermissionError("无权限访问该客户信息")
        
        # 2. 数据库查询 (业务逻辑)
        customer_data = await self.database.query_customer(customer_id, fields)
        
        if not customer_data:
            return [TextContent(
                type="text",
                text=f"未找到客户ID: {customer_id}"
            )]
        
        # 3. 数据格式化 (业务逻辑)
        formatted_info = self._format_customer_info(customer_data, fields)
        
        return [TextContent(
            type="text",
            text=f"客户信息查询结果:\n{formatted_info}"
        )]
    
    async def _create_service_order(self, args: dict) -> List[TextContent]:
        """创建服务订单 - 业务实现"""
        
        # 1. 业务规则验证
        validation_result = await self._validate_order_creation(args)
        if not validation_result.is_valid:
            raise ValueError(validation_result.error_message)
        
        # 2. 订单创建
        order_data = {
            "customer_id": args["customer_id"],
            "service_type": args["service_type"],
            "priority": args.get("priority", "medium"),
            "description": args.get("description", ""),
            "status": "pending",
            "created_at": datetime.now(),
            "order_id": self._generate_order_id()
        }
        
        # 3. 数据库操作
        order_id = await self.database.create_order(order_data)
        
        # 4. 后续业务流程
        await self._trigger_order_workflow(order_id)
        
        return [TextContent(
            type="text",
            text=f"服务订单创建成功\n订单ID: {order_id}\n状态: 待处理"
        )]
    
    async def _send_notification(self, args: dict) -> List[TextContent]:
        """发送通知 - 业务实现"""
        
        recipient = args["recipient"]
        message = args["message"]
        channel = args["channel"]
        
        # 1. 通知渠道验证
        if not await self._validate_notification_channel(recipient, channel):
            raise ValueError(f"无效的通知渠道: {channel}")
        
        # 2. 消息内容处理
        processed_message = await self._process_message_content(message)
        
        # 3. 发送通知
        notification_id = await self.api_client.send_notification(
            recipient=recipient,
            message=processed_message,
            channel=channel
        )
        
        # 4. 记录通知日志
        await self._log_notification(notification_id, args)
        
        return [TextContent(
            type="text",
            text=f"通知发送成功\n通知ID: {notification_id}\n渠道: {channel}"
        )]

阶段3: 结果整合与用户反馈

3.1 LLM结果整合 (业务实现)
python 复制代码 
class ResultIntegrator:
    """结果整合器 - 业务实现"""
    
    def __init__(self, llm_client):
        self.llm_client = llm_client
        self.result_formatter = ResultFormatter()
    
    async def integrate_tool_results(
        self, 
        original_query: str,
        tool_results: List[dict],
        conversation_context: dict
    ) -> str:
        """
        整合工具执行结果 - 业务实现
        
        这是业务逻辑的核心部分，需要根据具体业务需求定制
        """
        
        # 1. 结果预处理
        processed_results = []
        for result in tool_results:
            processed = await self._process_single_result(result)
            processed_results.append(processed)
        
        # 2. 构建整合提示
        integration_prompt = self._build_integration_prompt(
            original_query, processed_results, conversation_context
        )
        
        # 3. LLM整合推理
        integrated_response = await self.llm_client.chat_completion(
            messages=[{"role": "user", "content": integration_prompt}],
            temperature=0.3  # 降低随机性，提高一致性
        )
        
        # 4. 最终格式化
        final_response = await self.result_formatter.format_final_response(
            integrated_response.content,
            processed_results,
            conversation_context
        )
        
        return final_response
    
    def _build_integration_prompt(
        self, 
        original_query: str, 
        results: List[dict], 
        context: dict
    ) -> str:
        """构建整合提示 - 业务定制"""
        
        prompt = f"""
        用户原始问题: {original_query}
        
        工具执行结果:
        """
        
        for i, result in enumerate(results, 1):
            prompt += f"""
        工具 {i}: {result['tool_name']}
        执行状态: {'成功' if result['success'] else '失败'}
        结果内容: {result['content']}
        """
        
        prompt += f"""
        
        对话上下文: {context.get('summary', '无')}
        
        请基于以上工具执行结果，为用户提供准确、有用的回复。
        要求:
        1. 整合所有相关信息
        2. 突出重要结果
        3. 如有错误，说明原因和建议
        4. 保持专业和友好的语调
        """
        
        return prompt

class ResultFormatter:
    """结果格式化器 - 业务实现"""
    
    async def format_final_response(
        self, 
        llm_response: str, 
        tool_results: List[dict],
        context: dict
    ) -> str:
        """格式化最终响应 - 业务定制"""
        
        # 1. 基础响应格式化
        formatted_response = self._format_base_response(llm_response)
        
        # 2. 添加数据摘要 (如果有结构化数据)
        if self._has_structured_data(tool_results):
            data_summary = self._create_data_summary(tool_results)
            formatted_response += f"\n\n📊 数据摘要:\n{data_summary}"
        
        # 3. 添加操作建议 (基于业务逻辑)
        suggestions = self._generate_action_suggestions(tool_results, context)
        if suggestions:
            formatted_response += f"\n\n💡 建议操作:\n{suggestions}"
        
        # 4. 添加相关链接或后续步骤
        next_steps = self._suggest_next_steps(tool_results, context)
        if next_steps:
            formatted_response += f"\n\n🔄 后续步骤:\n{next_steps}"
        
        return formatted_response

🔧 框架vs业务实现分工详解

框架实现部分 (可复用组件)

1. 通信协议层 (完全框架实现)
python 复制代码 
# 这些都由MCP框架提供，开发者无需实现

class MCPFrameworkComponents:
    """MCP框架提供的组件"""
    
    # 1. JSON-RPC通信
    class JSONRPCTransport:
        """JSON-RPC 2.0协议实现"""
        async def send_request(self, method: str, params: dict) -> dict:
            # 框架实现: 消息序列化、网络传输、错误处理
            pass
    
    # 2. 连接管理
    class ConnectionManager:
        """连接生命周期管理"""
        async def establish_connection(self, server_config: dict) -> ClientSession:
            # 框架实现: 进程启动、连接建立、心跳检测
            pass
    
    # 3. 会话状态管理
    class SessionManager:
        """会话状态维护"""
        async def initialize_session(self) -> None:
            # 框架实现: 协议握手、能力协商、状态同步
            pass
    
    # 4. 消息路由
    class MessageRouter:
        """消息路由和分发"""
        async def route_message(self, message: dict) -> dict:
            # 框架实现: 消息分类、路由选择、负载均衡
            pass
2. 基础工具抽象 (框架提供基类)
python 复制代码 
from abc import ABC, abstractmethod

class BaseMCPTool(ABC):
    """工具基类 - 框架提供"""
    
    def __init__(self, name: str, description: str, schema: dict):
        self.name = name
        self.description = description  
        self.schema = schema
    
    @abstractmethod
    async def execute(self, arguments: dict) -> dict:
        """工具执行方法 - 业务实现"""
        pass
    
    async def validate_arguments(self, arguments: dict) -> bool:
        """参数验证 - 框架实现"""
        # 框架提供JSON Schema验证
        from jsonschema import validate
        validate(instance=arguments, schema=self.schema)
        return True
    
    async def handle_error(self, error: Exception) -> dict:
        """错误处理 - 框架实现"""
        return {
            "success": False,
            "error": str(error),
            "error_type": type(error).__name__
        }

class BaseResourceProvider(ABC):
    """资源提供者基类 - 框架提供"""
    
    @abstractmethod
    async def list_resources(self) -> List[Resource]:
        """列出资源 - 业务实现"""
        pass
    
    @abstractmethod  
    async def read_resource(self, uri: str) -> str:
        """读取资源 - 业务实现"""
        pass
    
    async def validate_uri(self, uri: str) -> bool:
        """URI验证 - 框架实现"""
        # 框架提供URI格式验证
        pass

业务实现部分 (需要定制开发)

1. 工具业务逻辑 (完全业务实现)
python 复制代码 
class CustomerServiceTools:
    """客服业务工具 - 完全业务实现"""
    
    def __init__(self, crm_client, ticket_system, knowledge_base):
        self.crm = crm_client           # 业务系统集成
        self.tickets = ticket_system    # 业务系统集成  
        self.kb = knowledge_base        # 业务系统集成
    
    async def search_customer_history(self, customer_id: str) -> dict:
        """搜索客户历史 - 业务逻辑"""
        
        # 1. 多系统数据聚合 (业务逻辑)
        customer_data = await self.crm.get_customer(customer_id)
        ticket_history = await self.tickets.get_customer_tickets(customer_id)
        interaction_log = await self.kb.get_interaction_history(customer_id)
        
        # 2. 数据关联和分析 (业务逻辑)
        analysis = self._analyze_customer_pattern(
            customer_data, ticket_history, interaction_log
        )
        
        # 3. 业务规则应用 (业务逻辑)
        recommendations = self._generate_service_recommendations(analysis)
        
        return {
            "customer_profile": customer_data,
            "service_history": ticket_history,
            "behavior_analysis": analysis,
            "recommendations": recommendations
        }
    
    async def create_support_ticket(self, ticket_data: dict) -> dict:
        """创建支持工单 - 业务逻辑"""
        
        # 1. 业务规则验证
        validation = await self._validate_ticket_creation(ticket_data)
        if not validation.is_valid:
            raise ValueError(validation.errors)
        
        # 2. 自动分类和优先级 (业务逻辑)
        category = await self._auto_categorize_ticket(ticket_data["description"])
        priority = await self._calculate_priority(ticket_data, category)
        
        # 3. 智能路由 (业务逻辑)
        assigned_agent = await self._route_to_agent(category, priority)
        
        # 4. 工单创建
        ticket = await self.tickets.create_ticket({
            **ticket_data,
            "category": category,
            "priority": priority,
            "assigned_to": assigned_agent,
            "status": "open"
        })
        
        # 5. 后续流程触发 (业务逻辑)
        await self._trigger_notification_workflow(ticket)
        
        return ticket
    
    def _analyze_customer_pattern(self, customer, tickets, interactions) -> dict:
        """客户行为模式分析 - 业务算法"""
        
        # 这里包含具体的业务分析逻辑
        # 例如: 问题频率分析、满意度趋势、产品使用模式等
        
        return {
            "issue_frequency": self._calculate_issue_frequency(tickets),
            "satisfaction_trend": self._analyze_satisfaction(interactions),
            "product_usage": self._analyze_product_usage(customer, tickets),
            "risk_level": self._assess_churn_risk(customer, tickets, interactions)
        }
2. LLM提示工程 (完全业务实现)
python 复制代码 
class BusinessPromptEngine:
    """业务提示工程 - 完全业务实现"""
    
    def __init__(self, domain_knowledge, style_guide):
        self.domain_knowledge = domain_knowledge
        self.style_guide = style_guide
    
    def build_customer_service_prompt(
        self, 
        customer_query: str, 
        customer_context: dict,
        available_tools: List[str]
    ) -> str:
        """构建客服场景提示 - 业务定制"""
        
        prompt = f"""
        你是一个专业的客服AI助手，专门处理{self.domain_knowledge.business_domain}相关的客户咨询。
        
        客户背景:
        - 客户ID: {customer_context.get('customer_id', '未知')}
        - 客户等级: {customer_context.get('tier', '普通')}
        - 历史问题: {customer_context.get('recent_issues', '无')}
        - 产品使用情况: {customer_context.get('product_usage', '未知')}
        
        当前咨询: {customer_query}
        
        可用工具: {', '.join(available_tools)}
        
        服务准则:
        1. {self.style_guide.tone} - 保持专业友好的语调
        2. {self.style_guide.accuracy} - 确保信息准确性
        3. {self.style_guide.efficiency} - 高效解决问题
        4. {self.style_guide.empathy} - 展现同理心
        
        请分析客户需求，选择合适的工具，提供准确有效的帮助。
        """
        
        return prompt
    
    def build_sales_support_prompt(
        self, 
        sales_query: str, 
        lead_context: dict,
        available_tools: List[str]
    ) -> str:
        """构建销售支持提示 - 业务定制"""
        
        prompt = f"""
        你是一个销售支持AI助手，帮助销售团队更好地服务潜在客户。
        
        潜在客户信息:
        - 公司: {lead_context.get('company', '未知')}
        - 行业: {lead_context.get('industry', '未知')}
        - 规模: {lead_context.get('company_size', '未知')}
        - 需求阶段: {lead_context.get('stage', '初期了解')}
        
        销售询问: {sales_query}
        
        可用工具: {', '.join(available_tools)}
        
        销售策略:
        1. 需求挖掘 - 深入了解客户真实需求
        2. 价值匹配 - 突出产品价值与客户需求的匹配
        3. 异议处理 - 预判并准备应对常见异议
        4. 推进转化 - 适时推进销售流程
        
        请基于客户信息和销售询问，提供专业的销售建议和支持。
        """
        
        return prompt
3. 数据处理与转换 (业务实现)
python 复制代码 
class BusinessDataProcessor:
    """业务数据处理器 - 业务实现"""
    
    def __init__(self, data_schema, business_rules):
        self.schema = data_schema
        self.rules = business_rules
    
    async def process_customer_data(self, raw_data: dict) -> dict:
        """处理客户数据 - 业务逻辑"""
        
        # 1. 数据清洗 (业务规则)
        cleaned_data = self._clean_customer_data(raw_data)
        
        # 2. 数据增强 (业务逻辑)
        enriched_data = await self._enrich_customer_data(cleaned_data)
        
        # 3. 隐私保护 (业务规则)
        protected_data = self._apply_privacy_rules(enriched_data)
        
        # 4. 格式标准化 (业务标准)
        standardized_data = self._standardize_format(protected_data)
        
        return standardized_data
    
    def _clean_customer_data(self, data: dict) -> dict:
        """数据清洗 - 业务规则"""
        
        cleaned = {}
        
        # 电话号码标准化
        if "phone" in data:
            cleaned["phone"] = self._normalize_phone_number(data["phone"])
        
        # 邮箱验证和标准化
        if "email" in data:
            cleaned["email"] = self._validate_and_normalize_email(data["email"])
        
        # 地址标准化
        if "address" in data:
            cleaned["address"] = self._standardize_address(data["address"])
        
        # 业务特定字段处理
        if "customer_type" in data:
            cleaned["customer_type"] = self._normalize_customer_type(data["customer_type"])
        
        return cleaned
    
    async def _enrich_customer_data(self, data: dict) -> dict:
        """数据增强 - 业务逻辑"""
        
        enriched = data.copy()
        
        # 1. 外部数据源补充
        if "company" in data:
            company_info = await self._fetch_company_info(data["company"])
            enriched["company_details"] = company_info
        
        # 2. 历史数据关联
        if "customer_id" in data:
            history = await self._get_customer_history(data["customer_id"])
            enriched["interaction_history"] = history
        
        # 3. 风险评估
        risk_score = await self._calculate_risk_score(data)
        enriched["risk_assessment"] = risk_score
        
        return enriched

📊 实际业务场景示例

场景1: 智能客服系统

python 复制代码 
class IntelligentCustomerService:
    """智能客服系统 - 完整业务实现"""
    
    def __init__(self):
        # 框架组件
        self.mcp_client = MCPClient()
        self.llm_client = LLMClient("claude-3-sonnet")
        
        # 业务组件
        self.crm_system = CRMSystem()
        self.knowledge_base = KnowledgeBase()
        self.ticket_system = TicketSystem()
        
        # 业务配置
        self.service_config = CustomerServiceConfig()
    
    async def handle_customer_inquiry(self, customer_id: str, inquiry: str) -> str:
        """处理客户咨询 - 业务流程"""
        
        # 1. 客户上下文获取 (业务逻辑)
        customer_context = await self._build_customer_context(customer_id)
        
        # 2. 意图识别和分类 (业务逻辑)
        inquiry_analysis = await self._analyze_inquiry(inquiry, customer_context)
        
        # 3. 构建LLM提示 (业务逻辑)
        prompt = self._build_service_prompt(inquiry, customer_context, inquiry_analysis)
        
        # 4. LLM推理和工具调用 (框架+业务)
        response = await self._process_with_llm_and_tools(prompt)
        
        # 5. 服务质量检查 (业务逻辑)
        quality_check = await self._validate_service_quality(response, inquiry_analysis)
        
        # 6. 后续流程触发 (业务逻辑)
        await self._trigger_followup_actions(customer_id, inquiry, response)
        
        return response
    
    async def _build_customer_context(self, customer_id: str) -> dict:
        """构建客户上下文 - 业务逻辑"""
        
        # 并行获取多源数据
        customer_profile, recent_tickets, interaction_history = await asyncio.gather(
            self.crm_system.get_customer_profile(customer_id),
            self.ticket_system.get_recent_tickets(customer_id, limit=5),
            self.knowledge_base.get_interaction_history(customer_id, days=30)
        )
        
        # 数据聚合和分析
        context = {
            "profile": customer_profile,
            "recent_issues": self._summarize_recent_issues(recent_tickets),
            "satisfaction_trend": self._analyze_satisfaction_trend(interaction_history),
            "preferred_channels": self._identify_preferred_channels(interaction_history),
            "escalation_history": self._check_escalation_history(recent_tickets)
        }
        
        return context
    
    async def _process_with_llm_and_tools(self, prompt: str) -> str:
        """LLM处理和工具调用 - 框架+业务"""
        
        # 获取可用工具 (框架)
        available_tools = await self.mcp_client.list_tools()
        
        # LLM推理 (框架)
        llm_response = await self.llm_client.chat_completion(
            messages=[{"role": "user", "content": prompt}],
            tools=self._format_tools_for_llm(available_tools),
            tool_choice="auto"
        )
        
        # 工具调用处理 (框架+业务)
        if llm_response.tool_calls:
            tool_results = []
            for tool_call in llm_response.tool_calls:
                # 工具执行 (框架)
                result = await self.mcp_client.execute_tool(
                    tool_call.function.name,
                    json.loads(tool_call.function.arguments)
                )
                
                # 结果处理 (业务)
                processed_result = await self._process_tool_result(
                    tool_call.function.name, result
                )
                tool_results.append(processed_result)
            
            # 结果整合 (业务)
            final_response = await self._integrate_service_results(
                llm_response.content, tool_results
            )
        else:
            final_response = llm_response.content
        
        return final_response

场景2: 销售助手系统

python 复制代码 
class SalesAssistantSystem:
    """销售助手系统 - 业务实现"""
    
    async def support_sales_process(self, sales_rep_id: str, query: str) -> str:
        """支持销售流程 - 业务逻辑"""
        
        # 1. 销售上下文构建
        sales_context = await self._build_sales_context(sales_rep_id)
        
        # 2. 查询分析
        query_analysis = await self._analyze_sales_query(query, sales_context)
        
        # 3. 动态工具选择 (业务逻辑)
        relevant_tools = self._select_sales_tools(query_analysis)
        
        # 4. LLM处理
        response = await self._process_sales_query(query, sales_context, relevant_tools)
        
        return response
    
    def _select_sales_tools(self, query_analysis: dict) -> List[str]:
        """选择销售工具 - 业务逻辑"""
        
        tools = []
        
        if query_analysis["intent"] == "lead_research":
            tools.extend(["search_company_info", "get_industry_insights", "find_competitors"])
        
        elif query_analysis["intent"] == "proposal_generation":
            tools.extend(["get_pricing_info", "find_case_studies", "generate_proposal_template"])
        
        elif query_analysis["intent"] == "objection_handling":
            tools.extend(["search_objection_responses", "get_competitive_analysis"])
        
        elif query_analysis["intent"] == "follow_up":
            tools.extend(["schedule_meeting", "send_email_template", "update_crm"])
        
        return tools

🎯 开发指南与最佳实践

框架选择与配置

python 复制代码 
# 1. 框架依赖配置
# requirements.txt
"""
mcp>=1.0.0                    # MCP框架核心
openai>=1.0.0                 # LLM API客户端
anthropic>=0.8.0              # Claude API客户端
pydantic>=2.0.0               # 数据验证
asyncio-mqtt>=0.11.0          # 消息队列(可选)
redis>=4.0.0                  # 缓存和会话存储(可选)
"""

# 2. 框架初始化配置
class FrameworkConfig:
    """框架配置 - 标准化配置"""
    
    MCP_SERVERS = {
        "file-server": {
            "command": "python",
            "args": ["servers/file_server.py"],
            "capabilities": ["tools", "resources"]
        },
        "database-server": {
            "command": "python", 
            "args": ["servers/db_server.py"],
            "capabilities": ["tools"]
        }
    }
    
    LLM_CONFIG = {
        "provider": "anthropic",  # or "openai"
        "model": "claude-3-sonnet-20240229",
        "temperature": 0.3,
        "max_tokens": 4096
    }

业务实现模板

python 复制代码 
class BusinessImplementationTemplate:
    """业务实现模板 - 开发指南"""
    
    def __init__(self):
        # 1. 框架组件初始化 (标准化)
        self.mcp_client = MCPClient()
        self.llm_client = LLMClient(config=LLM_CONFIG)
        
        # 2. 业务组件初始化 (定制化)
        self.business_systems = self._init_business_systems()
        self.domain_knowledge = self._load_domain_knowledge()
        self.business_rules = self._load_business_rules()
    
    def _init_business_systems(self) -> dict:
        """初始化业务系统 - 完全定制"""
        return {
            "crm": YourCRMSystem(),
            "erp": YourERPSystem(), 
            "knowledge_base": YourKnowledgeBase(),
            # 添加其他业务系统
        }
    
    def _load_domain_knowledge(self) -> DomainKnowledge:
        """加载领域知识 - 完全定制"""
        # 加载行业知识、产品信息、业务流程等
        pass
    
    def _load_business_rules(self) -> BusinessRules:
        """加载业务规则 - 完全定制"""
        # 加载权限规则、数据处理规则、工作流规则等
        pass
    
    async def implement_business_tool(self, tool_name: str) -> BaseMCPTool:
        """实现业务工具 - 定制开发"""
        
        class CustomBusinessTool(BaseMCPTool):
            
            async def execute(self, arguments: dict) -> dict:
                # 1. 参数预处理 (业务逻辑)
                processed_args = await self._preprocess_arguments(arguments)
                
                # 2. 业务逻辑执行 (完全定制)
                result = await self._execute_business_logic(processed_args)
                
                # 3. 结果后处理 (业务逻辑)
                formatted_result = await self._format_result(result)
                
                return formatted_result
            
            async def _execute_business_logic(self, args: dict) -> dict:
                """执行业务逻辑 - 需要实现"""
                # 这里实现具体的业务逻辑
                # 例如: 数据库操作、API调用、文件处理等
                pass
        
        return CustomBusinessTool(tool_name, description, schema)

📈 性能优化与监控

数据流转性能优化

python 复制代码 
class PerformanceOptimizer:
    """性能优化器 - 框架+业务实现"""
    
    def __init__(self):
        # 框架提供的优化组件
        self.connection_pool = ConnectionPool(max_size=20)
        self.result_cache = ResultCache(ttl=300)
        
        # 业务优化组件
        self.query_optimizer = BusinessQueryOptimizer()
        self.data_prefetcher = DataPrefetcher()
    
    async def optimize_tool_execution(self, tool_name: str, args: dict) -> dict:
        """优化工具执行 - 业务逻辑"""
        
        # 1. 缓存检查 (框架)
        cache_key = self._generate_cache_key(tool_name, args)
        cached_result = await self.result_cache.get(cache_key)
        if cached_result:
            return cached_result
        
        # 2. 查询优化 (业务)
        optimized_args = await self.query_optimizer.optimize(tool_name, args)
        
        # 3. 数据预取 (业务)
        await self.data_prefetcher.prefetch_related_data(tool_name, optimized_args)
        
        # 4. 并行执行 (框架+业务)
        result = await self._execute_with_parallelization(tool_name, optimized_args)
        
        # 5. 结果缓存 (框架)
        await self.result_cache.set(cache_key, result)
        
        return result

class MonitoringSystem:
    """监控系统 - 业务实现"""
    
    async def monitor_data_flow(self, flow_id: str, stage: str, data: dict):
        """监控数据流转 - 业务定制"""
        
        metrics = {
            "flow_id": flow_id,
            "stage": stage,
            "timestamp": time.time(),
            "data_size": len(str(data)),
            "processing_time": self._calculate_processing_time(flow_id, stage)
        }
        
        # 业务指标记录
        await self._record_business_metrics(metrics)
        
        # 异常检测
        if self._detect_anomaly(metrics):
            await self._trigger_alert(flow_id, stage, metrics)

🎉 总结

基于MCP协议的LLM-Agent系统中，数据流转涉及用户、LLM、MCP Client和MCP Server四个核心组件。理解框架实现与业务实现的分工对于高效开发至关重要:

框架实现 (开箱即用)

  • 通信协议: JSON-RPC 2.0、连接管理、消息路由
  • 基础抽象: 工具基类、资源基类、错误处理
  • LLM集成: API调用、响应解析、工具格式转换

业务实现 (需要定制)

  • 工具业务逻辑: 具体功能实现、数据处理、业务规则
  • LLM提示工程: 领域知识、对话策略、结果整合
  • 数据流转控制: 参数预处理、结果后处理、性能优化

开发建议

  1. 充分利用框架: 专注业务逻辑，避免重复造轮子
  2. 模块化设计: 清晰分离框架代码和业务代码
  3. 渐进式开发: 先实现核心功能，再优化性能和用户体验
  4. 监控和测试: 建立完善的监控体系和测试流程

通过合理的架构设计和分工，开发者可以快速构建出功能强大、性能优异的LLM-Agent系统。

相关推荐
职业码农NO.13 小时前
智能体推理范式: Plan-and-Execute（规划与执行）
人工智能·python·数据分析·系统架构·知识图谱·agent·集成学习
阿湯哥3 小时前
MCP协议核心概念与通信机制
ai·mcp
CoderJia程序员甲4 小时前
GitHub 热榜项目 - 日榜(2025-12-19)
ai·开源·llm·github
许泽宇的技术分享6 小时前
解密Anthropic的MCP Inspector：从协议调试到AI应用开发的全栈架构之旅
人工智能·架构·typescript·mcp·ai开发工具
骚戴7 小时前
n1n：从替代LiteLLM Proxy自建网关到企业级统一架构的进阶之路
人工智能·python·大模型·llm·gateway·api
谷哥的小弟9 小时前
Spring Framework源码解析——RequestContext
java·后端·spring·框架·源码
KG_LLM图谱增强大模型11 小时前
【102页最新综述】AI智能体时代的记忆系统：形式、功能与知识图谱长记忆动态机制全景解析
大数据·人工智能·agent
iFlow_AI11 小时前
知识驱动开发：用iFlow工作流构建本地知识库
前端·ai·rag·mcp·iflow·iflow cli·iflowcli
小时前端11 小时前
谁说 AI 历史会话必须存后端？IndexedDB方案完美翻盘
前端·agent·indexeddb
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04sqli-labs靶场通关笔记：第18-19关 HTTP头部注入05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07BongoCat - 跨平台键盘猫动画工具08jdk21下载、安装（Windows、Linux、macOS）09RedissonClient的配置解析10Labelme从安装到标注：零基础完整指南