LangChain与MCP的完美结合：langchain_mcp_adapters实践指南

lingding_cn

于 2025-04-20 09:35:17 发布

阅读量1.2k

点赞数 29

分类专栏： ai python mpc 文章标签： langchain 服务器 python mcp

本文链接：https://blog.csdn.net/lingding_cn/article/details/147360640

版权

python 同时被 3 个专栏收录

7 篇文章

订阅专栏

6 篇文章

订阅专栏

mpc

2 篇文章

订阅专栏

LangChain与MCP的完美结合：langchain_mcp_adapters实践指南

1. MCP简介

MCP（Model Context Protocol）是一种用于大型语言模型（LLM）与外部工具和资源进行通信的协议标准。它的设计目标是为AI模型提供一种标准化的方式来访问和操作外部世界的数据和功能。

1.1 MCP的核心特点

标准化通信接口：MCP定义了一套标准的通信格式和协议，使模型能够以一致的方式与各种外部系统交互。
工具和资源抽象：将外部功能抽象为"工具"（可执行的功能）和"资源"（可访问的数据），简化了模型与外部世界的交互。
上下文管理：维护模型与外部系统交互过程中的上下文信息，确保交互的连贯性。
安全性考虑：内置了权限控制和安全检查机制，防止未授权的访问和潜在的安全风险。
可扩展性：支持添加新的工具和资源，适应不断变化的需求。

1.2 MCP的工作原理

MCP的工作流程通常包括以下步骤：

服务注册：外部服务（如API、数据库等）注册为MCP服务器，提供工具和资源。
模型请求：AI模型通过MCP客户端发送请求，指定要使用的工具或访问的资源。
服务处理：MCP服务器接收请求，执行相应的操作，并返回结果。
结果整合：模型接收结果，并将其整合到自己的推理过程中。

2. LangChain简介

LangChain是一个用于开发基于大型语言模型（LLM）应用的框架，它提供了一系列工具和抽象，简化了LLM应用的开发过程。

2.1 LangChain的核心组件

Chains：将多个组件（如模型、提示词、工具等）链接在一起，形成复杂的处理流程。
Agents：能够根据用户输入和当前状态，动态决定使用哪些工具和执行哪些操作的智能代理。
Memory：管理对话历史和上下文信息，使模型能够记住之前的交互。
Tools：模型可以使用的外部功能，如搜索引擎、计算器、API等。
Document Loaders：从各种来源加载文档的组件。
Text Splitters：将长文本分割成适合模型处理的小块。
Embeddings：将文本转换为向量表示，用于语义搜索和相似度计算。
Vector Stores：存储和检索文本向量的数据库。

2.2 LangChain的优势

模块化设计：各组件可以独立使用，也可以组合成复杂的应用。
多模型支持：支持多种LLM，如OpenAI的GPT系列、Anthropic的Claude、Google的Gemini等。
丰富的集成：与众多外部服务和工具集成，扩展了模型的能力。
开源生态：活跃的开发者社区和丰富的文档资源。

3. langchain_mcp_adapters简介

langchain_mcp_adapters是一个连接LangChain和MCP的适配器库，它允许LangChain框架中的应用无缝地使用MCP服务提供的工具和资源。

3.1 langchain_mcp_adapters的作用

桥接LangChain和MCP：将MCP服务器提供的工具和资源转换为LangChain可用的格式。
简化集成过程：开发者无需深入了解MCP的内部实现，就能在LangChain应用中使用MCP服务。
统一接口：提供一致的接口，使得在LangChain中使用MCP服务与使用其他工具一样简单。
扩展LangChain能力：通过MCP，LangChain应用可以访问更多外部服务和资源。

3.2 langchain_mcp_adapters的核心组件

MCPToolAdapter：将MCP工具转换为LangChain工具。
MCPResourceAdapter：将MCP资源转换为LangChain可用的数据源。
MCPServerManager：管理与MCP服务器的连接和通信。
MCPChain：专门用于处理MCP工具和资源的Chain实现。

4. langchain_mcp_adapters使用详解

下面我们将详细介绍如何在实际项目中使用langchain_mcp_adapters，包括安装、配置、基本用法和高级应用。

4.1 安装和配置

首先，我们需要安装必要的依赖：

pip install langchain langchain_mcp_adapters

如果需要使用特定的LLM，还需要安装相应的依赖：

# 使用OpenAI模型
pip install openai

# 使用Anthropic模型
pip install anthropic

# 使用本地模型
pip install langchain-community

4.2 基本用法

4.2.1 连接MCP服务器

from langchain_mcp_adapters import MCPServerManager

# 初始化MCP服务器管理器
server_manager = MCPServerManager()

# 连接到MCP服务器
server = server_manager.connect_server(
    name="weather-server",
    url="http://localhost:8000"
)

# 查看可用的工具和资源
available_tools = server.list_tools()
available_resources = server.list_resources()

print(f"可用工具: {available_tools}")
print(f"可用资源: {available_resources}")

4.2.2 使用MCP工具

from langchain_mcp_adapters import MCPToolAdapter
from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

# 创建LLM
llm = ChatOpenAI(model="gpt-4")

# 创建MCP工具适配器
weather_tool = MCPToolAdapter(
    server_name="weather-server",
    tool_name="get_weather",
    description="获取指定城市的天气信息"
)

# 创建代理提示模板
prompt = PromptTemplate.from_template("""
你是一个有用的助手，可以回答用户的问题。
你可以使用以下工具：

{tools}

使用以下格式：

问题: 用户的问题
思考: 你应该思考如何解决这个问题
行动: 工具名称
行动输入: 工具的输入
观察: 工具的输出
思考: 我现在知道答案了
回答: 对用户问题的回答

问题: {input}
思考: 
""")

# 创建代理
agent = create_react_agent(llm, [weather_tool], prompt)
agent_executor = AgentExecutor(agent=agent, tools=[weather_tool], verbose=True)

# 执行代理
result = agent_executor.invoke({"input": "北京今天的天气怎么样？"})
print(result["output"])

4.2.3 访问MCP资源

from langchain_mcp_adapters import MCPResourceAdapter
from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

# 创建LLM
llm = ChatOpenAI(model="gpt-4")

# 创建MCP资源适配器
news_resource = MCPResourceAdapter(
    server_name="news-server",
    resource_uri="/api/latest_news",
    description="获取最新的新闻头条"
)

# 获取资源内容
news_content = news_resource.get_content()

# 创建提示模板
prompt = PromptTemplate.from_template("""
根据以下新闻内容，总结主要事件：

{news}

总结:
""")

# 创建链
chain = LLMChain(llm=llm, prompt=prompt)

# 执行链
result = chain.invoke({"news": news_content})
print(result["text"])

4.3 高级应用

4.3.1 创建自定义MCP服务器

如果需要创建自己的MCP服务器，可以使用以下代码：

from mcp_server_sdk import MCPServer, Tool, Resource

# 创建MCP服务器
server = MCPServer(name="custom-server")

# 定义工具函数
def calculate_sum(a: int, b: int) -> int:
    """计算两个数的和"""
    return a + b

# 注册工具
server.register_tool(
    name="sum_calculator",
    func=calculate_sum,
    description="计算两个整数的和",
    schema={
        "type": "object",
        "properties": {
            "a": {"type": "integer"},
            "b": {"type": "integer"}
        },
        "required": ["a", "b"]
    }
)

# 定义资源
server.register_resource(
    uri="/data/constants",
    content={
        "pi": 3.14159,
        "e": 2.71828,
        "golden_ratio": 1.61803
    },
    description="常用数学常数"
)

# 启动服务器
server.start(host="localhost", port=8001)

4.3.2 结合Agents和Chains使用MCP

from langchain_mcp_adapters import MCPToolAdapter, MCPResourceAdapter, MCPChain
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.tools import Tool

# 创建LLM
llm = ChatOpenAI(model="gpt-4")

# 创建MCP工具适配器
calculator_tool = MCPToolAdapter(
    server_name="custom-server",
    tool_name="sum_calculator",
    description="计算两个整数的和"
)

# 创建自定义工具
def search_database(query: str) -> str:
    """搜索数据库获取信息"""
    # 实际实现会连接到数据库
    return f"关于'{query}'的搜索结果：这是一些相关信息。"

search_tool = Tool(
    name="database_search",
    func=search_database,
    description="搜索数据库获取信息"
)

# 创建MCP资源适配器
constants_resource = MCPResourceAdapter(
    server_name="custom-server",
    resource_uri="/data/constants",
    description="常用数学常数"
)

# 获取资源内容
constants = constants_resource.get_content()

# 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个数学助手，可以帮助用户解决数学问题。你可以使用以下工具：{tools}"),
    ("user", "{input}")
])

# 创建代理
agent = create_openai_functions_agent(llm, [calculator_tool, search_tool], prompt)
agent_executor = AgentExecutor(agent=agent, tools=[calculator_tool, search_tool], verbose=True)

# 创建MCP链
mcp_chain = MCPChain(
    llm=llm,
    server_name="custom-server",
    prompt=ChatPromptTemplate.from_template("使用这些常数{constants}回答问题：{question}")
)

# 执行代理
result = agent_executor.invoke({"input": "计算5加7等于多少？"})
print(f"代理结果: {result['output']}")

# 执行链
chain_result = mcp_chain.invoke({
    "constants": constants,
    "question": "圆周率的值是多少？"
})
print(f"链结果: {chain_result['text']}")

4.3.3 处理异步操作

langchain_mcp_adapters也支持异步操作，适用于需要处理大量并发请求的场景：

import asyncio
from langchain_mcp_adapters import MCPToolAdapter, MCPServerManager
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

async def main():
    # 异步连接MCP服务器
    server_manager = MCPServerManager()
    server = await server_manager.aconnect_server(
        name="weather-server",
        url="http://localhost:8000"
    )
    
    # 创建LLM
    llm = ChatOpenAI(model="gpt-4")
    
    # 创建MCP工具适配器
    weather_tool = MCPToolAdapter(
        server_name="weather-server",
        tool_name="get_weather",
        description="获取指定城市的天气信息"
    )
    
    # 创建提示模板
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个天气助手，可以帮助用户查询天气信息。你可以使用以下工具：{tools}"),
        ("user", "{input}")
    ])
    
    # 创建代理
    agent = create_openai_functions_agent(llm, [weather_tool], prompt)
    agent_executor = AgentExecutor(agent=agent, tools=[weather_tool], verbose=True)
    
    # 异步执行多个查询
    tasks = [
        agent_executor.ainvoke({"input": "北京今天的天气怎么样？"}),
        agent_executor.ainvoke({"input": "上海今天的天气怎么样？"}),
        agent_executor.ainvoke({"input": "广州今天的天气怎么样？"})
    ]
    
    results = await asyncio.gather(*tasks)
    for i, result in enumerate(results):
        print(f"查询 {i+1} 结果: {result['output']}")

# 运行异步主函数
if __name__ == "__main__":
    asyncio.run(main())

4.4 实际案例：构建智能问答系统

下面是一个完整的案例，展示如何使用langchain_mcp_adapters构建一个智能问答系统：

from langchain_mcp_adapters import MCPToolAdapter, MCPResourceAdapter, MCPServerManager
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.memory import ConversationBufferMemory
from langchain.tools import Tool
from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse
import uvicorn
import json
import asyncio

# 创建FastAPI应用
app = FastAPI(title="智能问答系统")

# 初始化MCP服务器管理器
server_manager = MCPServerManager()

# 连接MCP服务器
weather_server = server_manager.connect_server(
    name="weather-server",
    url="http://localhost:8000"
)

news_server = server_manager.connect_server(
    name="news-server",
    url="http://localhost:8001"
)

# 创建MCP工具适配器
weather_tool = MCPToolAdapter(
    server_name="weather-server",
    tool_name="get_weather",
    description="获取指定城市的天气信息"
)

# 创建MCP资源适配器
news_resource = MCPResourceAdapter(
    server_name="news-server",
    resource_uri="/api/latest_news",
    description="获取最新的新闻头条"
)

# 创建自定义工具
def search_knowledge_base(query: str) -> str:
    """搜索知识库获取信息"""
    # 实际实现会连接到知识库
    return f"关于'{query}'的知识库搜索结果：这是一些相关信息。"

search_tool = Tool(
    name="knowledge_search",
    func=search_knowledge_base,
    description="搜索知识库获取信息"
)

# 创建LLM
llm = ChatOpenAI(model="gpt-4", streaming=True)

# 创建对话记忆
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个智能助手，可以回答用户的问题。
    你可以使用以下工具：
    {tools}
    
    你还可以访问最新的新闻信息。
    
    请根据用户的问题，选择合适的工具或资源来提供准确的回答。
    """),
    ("human", "{input}"),
    ("ai", "{chat_history}")
])

# 创建代理
agent = create_openai_functions_agent(llm, [weather_tool, search_tool], prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=[weather_tool, search_tool],
    memory=memory,
    verbose=True
)

# 定义API端点
@app.post("/chat")
async def chat(request: Request):
    data = await request.json()
    user_input = data.get("message", "")
    
    # 获取最新新闻
    news = news_resource.get_content()
    
    # 构建输入
    input_data = {
        "input": user_input,
        "news": news
    }
    
    # 创建流式响应
    async def generate_response():
        response = await agent_executor.ainvoke(input_data)
        yield json.dumps({"response": response["output"]})
    
    return StreamingResponse(generate_response(), media_type="application/json")

# 启动应用
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8080)

5. 最佳实践与注意事项

在使用langchain_mcp_adapters时，以下是一些最佳实践和注意事项：

5.1 性能优化

缓存结果：对于频繁访问的资源，考虑实现缓存机制。
批量处理：尽可能批量处理请求，减少网络往返。
异步操作：对于I/O密集型操作，使用异步API提高并发性能。

5.2 错误处理

from langchain_mcp_adapters import MCPToolAdapter
from langchain_mcp_adapters.exceptions import MCPServerError, MCPToolError

# 创建MCP工具适配器
weather_tool = MCPToolAdapter(
    server_name="weather-server",
    tool_name="get_weather",
    description="获取指定城市的天气信息"
)

# 错误处理
try:
    result = weather_tool.invoke({"city": "北京"})
    print(f"天气信息: {result}")
except MCPServerError as e:
    print(f"服务器错误: {e}")
except MCPToolError as e:
    print(f"工具执行错误: {e}")
except Exception as e:
    print(f"未知错误: {e}")