LangChain基础用法(三)

一、Agents智能代理

1、Agent概述

1.1 前面用Chains链来组合LLM调用,为什么还需要Agent?

Chain 是你写死的流程图,Agent 是模型现场画流程图。

两者不是“高级/低级”的关系,而是控制权归谁的问题。

在这里插入图片描述

1.2 什么是Agent?

Agent=LLM + 自主决策 + 【工具调用】

Agent的核心思想是:把LLM当做“大脑”,让它自己决定下一步做什么。

1.3 Agent核心组件

在这里插入图片描述

  • Planning(规划)

    在LangChain的工程实现中Planning并不是一个独立的物理组件,而是一种隐含在Agent运行机制和提示词中的能力。规划能力已经被融合在LLM的推理过程和Agent的执行引擎中。

    Planning在不同类型的Agent中以不同的方式体现:

    • ReAct 模式:让模型"想一步、做一步、看结果、再想"
    • Plan-and-Excute模式:先规划再执行

2、工具定义和使用

工具调用的本质是大模型的Funtion Calling能力。

LangChain提供了@tool装饰器,只要写一个普通的python函数,加上装饰器和类型注解,LangChain就会自动帮你:

  • 根据函数签名生成JSON Schema
  • 根据docstring生成工具描述
  • 处理参数的序列化和反序列化
from langchain.tools import tool

@tool	# 底层解析注解时,会将该函数对象封装到StructeredTool对象中(func=Callable[get_weather])

def get_weather(city: str, date: str)->str:
    """获取指定城市在指定日期的天气
    
    Args:
    	city: 城市名称,如“北京”、“上海”
    	date: 日期,格式为YYYY-MM-DD
    """
    # 实际项目中调用天气API, 这里用模拟数据
    return f"{city}在{date}天气多云,有下雨的可能性。"

# 底层框架帮你调用 函数对象进行invoke()
get_weather.invoke({city = "北京", date = "2027"})
  • Pydantic定义复杂参数

    from langchain.tools import tool
    from pydantic import BaseModel, Field
    
    # pydantic 格式化参数
    class GetWeatherArgs(BaseModel):
        """天气查询参数"""
        city: str = Field(description="城市名称,如'北京'、'上海'")
        date: str = Field(description="日期,格式为YYYY-MM-DD")
    
    @tool(args_schema=GetWeatherArgs)
    def get_weather(city: str, date: str)->str:
        """获取指定城市在指定日期的天气"""
        return f"{city}在{date}天气多云,有下雨的可能性。"
    
  • 构建Agent

    from langchain.agents import create_agent
    from langchain.chat_models import init_chat_model
    from langchain.tools import tool
    
    # ==== 第1步:初始化 LLM ====
    llm = init_chat_model(
        model="gpt-4o-mini",
        model_provider="openai",
    )
    
    # ==== 第2步:准备工具列表 ====
    @tool	# 底层解析注解时,会将该函数对象封装到StructeredTool对象中(func=Callable[get_weather])
    def get_weather(city: str, date: str)->str:
        """获取指定城市在指定日期的天气
        
        Args:
        	city: 城市名称,如“北京”、“上海”
        	date: 日期,格式为YYYY-MM-DD
        """
        # 实际项目中调用天气API, 这里用模拟数据
        return f"{city}在{date}天气多云,有下雨的可能性。"
    
    # 这里同时使用自定义工具和第三方工具
    from langchain_tavily import TavilySearch
    
    search = TavilySearch(max_results=5)  # 第三方搜索工具
    tools = [get_weather, search]         # 把所有工具放进列表
    
    # ==== 第3步:创建Agent ====
    agent = create_agent(
        model=llm,                         # 指定LLM作为大脑
        tools=tools,                       # 传入工具列表
        system_prompt="你是一个智能助手,请根据用户的需求调用合适的工具来帮助他们。",
    )
    
    # ==== 第4步:调用Agent (字典的key必须是messages) ====
    # 返回的也是dict  一次调用方式
    result = agent.invoke(
    	{"messages": 
         	[
                {
                    "role":"user", 
                    "content": "今天的北京天气怎么样?"
                }
        	]
        }
    )
    print(result["messages"][-1].content)
    
  • 调用方式

    • invoke(一次调用)

    • stream(流式调用)

      for step in agent.stream(
      	{"messages": 
           	[
                  {
                      "role":"user", 
                      "content": "今天的北京天气怎么样?"
                  }
          	]
          }
      )
      print(step, end="\n\n")
      
  • LangSmith调试

3、MCP工具接入

MCP 是"工具接入"的标准化协议——把"某个工具怎么暴露给模型"从"每个框架各写一遍"变成"写一次,谁都能用"。

业界常拿它类比 USB-C:以前每个外设一种接口,现在统一。这个类比准确,因为它解决的不是"能力"问题,而是接口碎片化问题。它统一了LLM与外部工具之间的通信方式。

3.1 MCP三层架构

在这里插入图片描述

在这里插入图片描述

3.2 MCP工作流程

当Agent通过MCP调用一个外部工具时,完整的流程是:

在这里插入图片描述

3.3 传输协议

在这里插入图片描述

  • 写一个MCP Server

    # server.py
    from mcp.server.fastmcp import FastMCP
    from pymilvus import MilvusClient
    
    mcp = FastMCP("rag-kb")
    client = MilvusClient(uri="http://localhost:19530")
    
    @mcp.tool()
    def search_kb(query: str, scope: str = "policy", top_k: int = 3) -> dict:
        """在企业知识库检索文档片段。
    
        适用:产品规则、流程规范、历史工单。
        不适用:实时数据、个人信息、通用常识。
        query 请用关键词组合,如 "退款 时效 规则"。
        """
        hits = client.search(
            collection_name="rag_kb",
            data=[embed(query)],
            limit=top_k,
            filter=f'doc_type == "{scope}"',
            output_fields=["text", "source"],
        )
        return {
            "count": len(hits),
            "results": [
                {"text": h["entity"]["text"][:800], "source": h["entity"]["source"]}
                for h in hits
            ],
        }
    
    @mcp.resource("kb://schema")
    def kb_schema() -> str:
        """知识库的字段说明,供应用直接塞进上下文"""
        return "字段: text(正文), source(来源), doc_type(policy/faq/ticket), updated_at(ISO日期)"
    
    if __name__ == "__main__":
        mcp.run(transport="stdio")
    

    MCP Server还支持暴露资源(Resource)和提示词模板(Prompt),不仅仅是工具tool

    # 资源:提供可读取的数据(类似GET接口)
    @mcp.resource("greeting://default")
    def get_greeting() -> str:
        """返回一条默认问候语"""
        return "Hello from MCP Server!"
    
    # 提示词模板:提供预定义的提示词
    @mcp.prompt()
    def greet_user(name: str, style: str = "friendly") -> str:
        """生成问候语的提示词"""
        styles = {
            "friendly": "写一句友善的问候",
            "formal": "写一句正式的问候",
            "casual": "写一句轻松的问候",
        }
        return f"为{name}{styles.get(style, styles['friendly'])}"
    
  • MCP Client直连

    import asyncio
    from mcp import ClientSession, StdioServerParameters
    from mcp.client.stdio import stdio_client
    
    async def main():
        params = StdioServerParameters(command="python", args=["server.py"])
    
        async with stdio_client(params) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
    
                # 1. 发现能力
                tools = await session.list_tools()
                print([t.name for t in tools.tools])
    
                resources = await session.list_resources()
                print([r.uri for r in resources.resources])
    
                # 2. 读 resource
                content = await session.read_resource("kb://schema")
                print(content.contents[0].text)
    
                # 3. 调 tool
                result = await session.call_tool("search_kb", {"query": "退款 时效"})
                print(result.content[0].text)
    
    asyncio.run(main())
    
  • 生产级写法

    from langchain_mcp_adapters.client import MultiServerMCPClient
    from langchain.agents import create_agent
    from langchain.chat_models import init_chat_model
    
    async def build_agent():
        mcp_client = MultiServerMCPClient({
            "rag": {
                "command": "python",
                "args": ["server.py"],
                "transport": "stdio",
            },
            "github": {
                "url": "https://mcp.example.com/github",
                "transport": "streamable_http",
                "headers": {"Authorization": f"Bearer {GITHUB_TOKEN}"},
            },
        })
    
        tools = await mcp_client.get_tools()   # 返回普通 BaseTool 列表
    
        return create_agent(
            model=init_chat_model("gpt-4o-mini", model_provider="openai"),
            tools=tools,
            system_prompt="你是企业助手,通过工具获取信息后回答。",
        )
    
    agent = await build_agent()
    

    关键:get_tools() 返回的东西和手写 @tool 完全等价。你上一轮那段 create_agent(model, tools, system_prompt) 的代码,把 tools 换成 MCP 来的就行,其他不动。

    小结:如果这套工具只服务一个 Agent,手写 @tool;要被第二个 Agent 用,就该抽成 MCP server 了。

4、Agent集成记忆机制

Checkpointer 是 LangGraph 的状态快照器:每执行完一个 super-step,就把整个 State 存一份,绑定 thread_id。它是"多轮对话 + 断点恢复 + 时间旅行"的底座。

但先说清一个最容易混的点——checkpointer 不是记忆系统。

在这里插入图片描述

from langgraph.checkpoint.memory import InMemorySaver

# 创建checkpointer(内存存储,程序重启后数据会丢失)
checkpointer = InMemorySaver()

# 创建Agent时传入checkpointer
agent = create_agent(
    model=llm,
    tools=tools,
    checkpointer=checkpointer,  # 就这一行
)

# 调用模型 thread_id 指定用户
result = agent.invoke(
	{"messages": ["user", "武汉有多少个火车站"]},
    config = {
        "configurable": {"thread_id": "user_张三"}
    }
)

  • 记忆的局限性
    • 消息太多,Token消耗剧增(费钱)
    • 超出模型上下文窗口大小(报错)

5、Agent集成中间件

Agent 中间件就是在"问模型、调工具"这条流水线上开的几个口子。你把压缩上下文、打码、审批、重试、记账这些杂事写成小关卡插进去,每个任务自动过一遍,不用改 Agent 本体,也不用每个工具重复写。关卡还能一层套一层,并且有权直接拦下不放行。

不使用中间件和使用中间件的Agent执行流程:

在这里插入图片描述

agent = create_agent(
	model = llm,
    tools = tools,
    checkpointer = checkpointer,
    middleware = [middleware_a, middleware_b], # 中间件列表
)

先给结论:真正每个项目都该配的只有三个——防死循环、危险操作审批、上下文压缩。其余按需。

  • ToolCallLimitMiddleware – 限制工具调用次数
  • HumanInTheLoopMiddleware – 危险操作人工审批
  • SummarizationMiddleware – 自动摘要

小结:

​ 必配三个:ToolCallLimit(防死循环)、Trace(可观测)、HumanInTheLoop(危险操作)。长会话加裁剪和摘要(SummarizationMiddleware ),外部依赖不稳加重试和 fallback,工具多加上工具筛选。其余按痛点加,别一次堆十个。

Logo

有“AI”的1024 = 2048,欢迎大家加入2048 AI社区

更多推荐