第26章 MCP与其他技术栈的结合
前言
本章是第四部分的收官之作。我们将探讨如何将MCP与Agent系统、检索增强生成（RAG）、模型微调、工作流编排、多模态处理等前沿技术栈相结合，构建更加智能、灵活、强大的AI系统。
26.1 MCP + Agent：自主决策系统
26.1.1 Agent-MCP架构
graph TB
A["用户意图"] --> B["Agent决策引擎"]
B --> C["感知模块"]
B --> D["规划模块"]
B --> E["执行模块"]
C --> C1["MCP工具"]
C --> C2["环境感知"]
D --> D1["任务规划"]
D --> D2["资源分配"]
E --> E1["MCP执行"]
E --> E2["反馈收集"]
E2 --> B
E1 --> F["执行结果"]
26.1.2 Agent-MCP实现
from typing import Dict, List, Optional, Any
from dataclasses import dataclass
from datetime import datetime
from enum import Enum
class AgentState(Enum):
"""Agent状态"""
IDLE = "idle"
THINKING = "thinking"
ACTING = "acting"
OBSERVING = "observing"
DONE = "done"
@dataclass
class Action:
"""动作"""
tool: str
params: Dict[str, Any]
reason: str
class ReActAgent:
"""ReAct Agent（Reasoning + Acting）"""
def __init__(self, mcp_client, model_client):
"""
初始化Agent
Args:
mcp_client: MCP客户端
model_client: 模型客户端
"""
self.mcp_client = mcp_client
self.model = model_client
self.state = AgentState.IDLE
self.history = []
self.max_steps = 10
async def think(self, observation: str) -> str:
"""
思考
Args:
observation: 观察结果
Returns:
思考内容
"""
prompt = f"""
根据观察结果进行推理：
观察：{observation}
请分析现状并制定下一步行动。
"""
response = await self.model.generate(prompt)
return response
async def plan_action(self, thought: str) -> Optional[Action]:
"""
规划动作
Args:
thought: 思考内容
Returns:
动作
"""
# 从思考内容中解析动作
action_prompt = f"""
基于以下思考，确定要执行的工具：
{thought}
返回JSON格式：{{"tool": "...", "params": {{...}}, "reason": "..."}}
"""
response = await self.model.generate(action_prompt)
try:
import json
action_data = json.loads(response)
return Action(
tool=action_data["tool"],
params=action_data["params"],
reason=action_data["reason"]
)
except:
return None
async def act(self, action: Action) -> Dict[str, Any]:
"""
执行动作
Args:
action: 动作
Returns:
执行结果
"""
self.state = AgentState.ACTING
try:
result = await self.mcp_client.call_tool(
action.tool,
action.params
)
return {
"status": "success",
"tool": action.tool,
"result": result,
"reason": action.reason
}
except Exception as e:
return {
"status": "error",
"tool": action.tool,
"error": str(e),
"reason": action.reason
}
async def run(self, goal: str) -> Dict[str, Any]:
"""
运行Agent
Args:
goal: 目标
Returns:
执行结果
"""
self.state = AgentState.THINKING
observation = f"任务：{goal}"
for step in range(self.max_steps):
# 思考
thought = await self.think(observation)
self.history.append({"type": "thought", "content": thought})
# 规划动作
action = await self.plan_action(thought)
if not action:
break
self.history.append({
"type": "action",
"content": action.reason,
"tool": action.tool
})
# 执行动作
result = await self.act(action)
self.history.append({"type": "observation", "content": result})
# 检查是否完成
if result["status"] == "error" or step == self.max_steps - 1:
break
observation = str(result)
self.state = AgentState.DONE
return {
"goal": goal,
"steps": len(self.history),
"status": "completed",
"history": self.history
}
26.2 MCP + RAG：检索增强生成
26.2.1 RAG-MCP集成
class VectorStore:
"""向量存储"""
def __init__(self):
self.embeddings: Dict[str, List[float]] = {}
self.documents: Dict[str, str] = {}
def add_document(self, doc_id: str, content: str,
embedding: List[float]):
"""添加文档"""
self.documents[doc_id] = content
self.embeddings[doc_id] = embedding
def search(self, query_embedding: List[float],
top_k: int = 5) -> List[tuple]:
"""
向量搜索
Args:
query_embedding: 查询向量
top_k: 返回数量
Returns:
相关文档列表
"""
import math
scores = []
for doc_id, embedding in self.embeddings.items():
# 计算余弦相似度
dot_product = sum(a * b for a, b in zip(query_embedding, embedding))
magnitude1 = math.sqrt(sum(a * a for a in query_embedding))
magnitude2 = math.sqrt(sum(a * a for a in embedding))
if magnitude1 > 0 and magnitude2 > 0:
similarity = dot_product / (magnitude1 * magnitude2)
scores.append((doc_id, similarity, self.documents[doc_id]))
# 按相似度排序
scores.sort(key=lambda x: x[1], reverse=True)
return scores[:top_k]
class RAGSystem:
"""RAG系统"""
def __init__(self, mcp_client, model_client):
"""
初始化RAG系统
Args:
mcp_client: MCP客户端
model_client: 模型客户端
"""
self.mcp_client = mcp_client
self.model = model_client
self.vector_store = VectorStore()
async def retrieve(self, query: str) -> List[str]:
"""
检索相关文档
Args:
query: 查询
Returns:
相关文档
"""
# 获取查询向量
query_embedding = await self.model.embed(query)
# 搜索
results = self.vector_store.search(query_embedding, top_k=5)
return [doc for _, _, doc in results]
async def augment_and_generate(self, query: str) -> str:
"""
增强检索和生成
Args:
query: 查询
Returns:
生成结果
"""
# 检索相关文档
documents = await self.retrieve(query)
# 构建增强提示
context = "\n".join(documents)
augmented_prompt = f"""
基于以下文档上下文回答问题：
上下文：
{context}
问题：{query}
请基于上下文提供详细答案。
"""
# 生成
response = await self.model.generate(augmented_prompt)
return response
async def retrieve_from_mcp(self, query: str) -> List[str]:
"""
从MCP源检索
Args:
query: 查询
Returns:
检索结果
"""
result = await self.mcp_client.call_tool(
"search_documents",
{"query": query}
)
return result.get("documents", [])
26.3 MCP + 微调：性能优化
26.3.1 微调工作流
class FineTuningPipeline:
"""微调管道"""
def __init__(self, mcp_client, model_client):
"""
初始化微调管道
Args:
mcp_client: MCP客户端
model_client: 模型客户端
"""
self.mcp_client = mcp_client
self.model = model_client
self.training_data = []
self.metrics = {}
async def collect_training_data(self) -> List[Dict]:
"""
从MCP收集训练数据
Returns:
训练数据
"""
# 从MCP工具获取数据
data = await self.mcp_client.call_tool(
"get_training_data",
{"limit": 1000}
)
return data.get("samples", [])
async def prepare_dataset(self, raw_data: List[Dict]) -> List[Dict]:
"""
准备数据集
Args:
raw_data: 原始数据
Returns:
处理后的数据
"""
prepared = []
for sample in raw_data:
prepared.append({
"instruction": sample.get("instruction"),
"input": sample.get("input", ""),
"output": sample.get("output"),
"category": sample.get("category", "general")
})
return prepared
async def fine_tune(self, dataset: List[Dict]) -> Dict:
"""
执行微调
Args:
dataset: 数据集
Returns:
微调结果
"""
from datetime import datetime
start_time = datetime.now()
# 微调配置
config = {
"model": "base_model",
"epochs": 3,
"batch_size": 32,
"learning_rate": 1e-4,
"dataset_size": len(dataset)
}
# 模拟微调过程
result = {
"status": "completed",
"config": config,
"training_time_seconds": (datetime.now() - start_time).total_seconds(),
"metrics": {
"final_loss": 0.15,
"accuracy": 0.92,
"f1_score": 0.89
}
}
return result
async def evaluate(self, model_path: str) -> Dict:
"""
评估模型
Args:
model_path: 模型路径
Returns:
评估结果
"""
# 从MCP获取测试数据
test_data = await self.mcp_client.call_tool(
"get_test_data",
{"limit": 100}
)
return {
"model": model_path,
"test_samples": len(test_data.get("samples", [])),
"metrics": {
"accuracy": 0.91,
"precision": 0.93,
"recall": 0.89,
"f1": 0.91
}
}
26.4 MCP + 工作流：流程自动化
26.4.1 工作流编排
class WorkflowOrchestrator:
"""工作流编排器"""
def __init__(self, mcp_client):
"""初始化"""
self.mcp_client = mcp_client
self.workflows: Dict[str, Dict] = {}
self.executions: List[Dict] = []
def define_workflow(self, name: str, steps: List[Dict]) -> bool:
"""
定义工作流
Args:
name: 工作流名称
steps: 步骤列表
Returns:
是否成功
"""
self.workflows[name] = {
"name": name,
"steps": steps,
"created_at": datetime.now().isoformat()
}
return True
async def execute_workflow(self, workflow_name: str,
inputs: Dict) -> Dict:
"""
执行工作流
Args:
workflow_name: 工作流名称
inputs: 输入参数
Returns:
执行结果
"""
if workflow_name not in self.workflows:
return {"error": "Workflow not found"}
workflow = self.workflows[workflow_name]
steps = workflow["steps"]
current_output = inputs
execution_log = []
for step in steps:
step_name = step.get("name")
tool = step.get("tool")
params_template = step.get("params", {})
# 替换参数中的占位符
params = self._resolve_params(params_template, current_output)
# 执行MCP工具
try:
result = await self.mcp_client.call_tool(tool, params)
execution_log.append({
"step": step_name,
"status": "success",
"result": result
})
current_output = result
except Exception as e:
execution_log.append({
"step": step_name,
"status": "error",
"error": str(e)
})
break
execution = {
"workflow": workflow_name,
"status": "completed",
"steps": len(execution_log),
"execution_log": execution_log,
"final_output": current_output,
"executed_at": datetime.now().isoformat()
}
self.executions.append(execution)
return execution
def _resolve_params(self, template: Dict, context: Dict) -> Dict:
"""解析参数模板"""
resolved = {}
for key, value in template.items():
if isinstance(value, str) and value.startswith("$."):
# 从上下文获取
path = value[2:]
resolved[key] = context.get(path, value)
else:
resolved[key] = value
return resolved
26.5 MCP + 多模态：扩展表达能力
26.5.1 多模态处理
class MultimodalProcessor:
"""多模态处理器"""
def __init__(self, mcp_client, vision_model, audio_model):
"""初始化"""
self.mcp_client = mcp_client
self.vision_model = vision_model
self.audio_model = audio_model
async def process_image(self, image_path: str) -> Dict:
"""
处理图像
Args:
image_path: 图像路径
Returns:
处理结果
"""
# 通过MCP获取图像
image_data = await self.mcp_client.call_tool(
"get_image",
{"path": image_path}
)
# 进行视觉分析
analysis = await self.vision_model.analyze(image_data)
return {
"image": image_path,
"objects_detected": analysis.get("objects", []),
"description": analysis.get("description", ""),
"text_extracted": analysis.get("text", "")
}
async def process_audio(self, audio_path: str) -> Dict:
"""
处理音频
Args:
audio_path: 音频路径
Returns:
处理结果
"""
# 通过MCP获取音频
audio_data = await self.mcp_client.call_tool(
"get_audio",
{"path": audio_path}
)
# 进行音频分析
result = await self.audio_model.transcribe(audio_data)
return {
"audio": audio_path,
"transcription": result.get("text", ""),
"language": result.get("language", "unknown"),
"confidence": result.get("confidence", 0.0)
}
async def generate_multimodal_response(self,
text: str,
images: List[str] = None,
audio: str = None) -> Dict:
"""
生成多模态响应
Args:
text: 文本
images: 图像列表
audio: 音频路径
Returns:
多模态响应
"""
context_parts = []
# 处理文本
context_parts.append(f"文本：{text}")
# 处理图像
if images:
for image_path in images:
image_analysis = await self.process_image(image_path)
context_parts.append(
f"图像分析：{image_analysis['description']}"
)
# 处理音频
if audio:
audio_analysis = await self.process_audio(audio)
context_parts.append(
f"音频转录：{audio_analysis['transcription']}"
)
# 生成综合响应
combined_context = "\n".join(context_parts)
return {
"modalities": {
"text": bool(text),
"images": bool(images),
"audio": bool(audio)
},
"combined_context": combined_context,
"processed_at": datetime.now().isoformat()
}
本章总结
| 关键点 | 说明 |
|---|---|
| Agent系统 | ReAct框架、感知-规划-执行循环 |
| RAG集成 | 向量检索、文档增强、上下文注入 |
| 微调优化 | 数据收集、模型调优、性能评估 |
| 工作流编排 | 步骤定义、参数传递、错误处理 |
| 多模态 | 图像、音频、文本的融合处理 |
常见问题
Q1: Agent如何与MCP协作？ A: Agent通过思考-规划-动作循环调用MCP工具，形成自主决策系统。
Q2: RAG如何提升生成质量？ A: 检索相关文档作为上下文注入，使模型基于真实知识生成。
Q3: 如何针对特定场景微调模型？ A: 从MCP收集领域数据，经过数据准备后进行监督微调。
Q4: 工作流如何处理复杂业务流程？ A: 定义步骤序列，通过参数传递实现步骤间协作。
Q5: 多模态处理有什么优势？ A: 结合多种信息源进行综合分析，提升理解深度和准确性。
第四部分完成！ 🎉 继续前往第五部分——项目实战篇！
