介绍

Agent将语言模型与工具结合，以创建能够推理任务、决定使用哪些工具并迭代地寻求解决方案的系统

只要给Agent绑定一些工具，并为工具增加一些描述，Agent就会自动根据需要去调用这些工具，不需要外部代码参与

Agent会遵循以下步骤，主要是一个循环：思考(model)->行动(自动调用工具)->观察(工具调用结果)->思考(model)，最终响应结果

核心组件

模型(Model)

静态模型

方式1：这种方式的模型是没法进行配置的

from langchain.agents import create_agent

agent = create_agent(
    "gpt-5",
    tools=tools
)

方式2：可配置模型，比如使用Chat模型，以ChatOpenAI为例，更多可查看 https://docs.langchain.com/oss/python/integrations/chat

需要先安装包

uv add langchain-openai

代码如下，更多配置参数可查看文档：https://docs.langchain.com/oss/python/langchain/models#parameters

或者看源码，将在下一章节详细讲解

import os
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool

@tool
def get_weather_for_location(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

model = ChatOpenAI(
    model="qwen3-max",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key=os.environ.get("CHAT_OPENAI_API_KEY"),
    streaming=True,
    temperature=0.5,
    timeout=10,
    max_tokens=1000
)

agent = create_agent(model, tools=[get_weather_for_location])

动态模型

动态模型根据当前状态和上下文在运行时被选择。这会使得路由逻辑更加复杂，可以实现成本优化。

需要一个使用@wrap_model_call装饰器装饰的中间件来实现

此处有两个模型，默认使用本地的模型，当消息列表（包括用户和AI）大于10的时候，使用百炼的模型

import tools.local_tools
from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse

import models.models

basic_model = models.models.get_model("local")
advanced_model = models.models.get_model("bailian")

@wrap_model_call
def dynamic_model_selection(request: ModelRequest, handler) -> ModelResponse:
    """Choose model based on conversation complexity."""
    message_count = len(request.state["messages"])

    if message_count > 10:
        # Use an advanced model for longer conversations
        model = advanced_model
    else:
        model = basic_model

    return handler(request.override(model=model))

agent = create_agent(
    model=basic_model,  # Default model
    tools=tools.local_tools.get_tools(),
    middleware=[dynamic_model_selection]
)

调用(Invocation)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}
)

还可支持流式响应stream

for chunk in agent.stream({
    "messages": [{"role": "user", "content": "Search for AI news and summarize the findings"}]
}, stream_mode="values"):
    # Each chunk contains the full state at that point
    latest_message = chunk["messages"][-1]
    if latest_message.content:
        print(f"Agent: {latest_message.content}")
    elif latest_message.tool_calls:
        print(f"Calling tools: {[tc['name'] for tc in latest_message.tool_calls]}")

结构化输出(Structured output)

from pydantic import BaseModel
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy


class ContactInfo(BaseModel):
    name: str
    email: str
    phone: str

agent = create_agent(
    model="gpt-4o-mini",
    tools=[search_tool],
    response_format=ToolStrategy(ContactInfo)
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "Extract contact info from: John Doe, john@example.com, (555) 123-4567"}]
})

result["structured_response"]
# ContactInfo(name='John Doe', email='john@example.com', phone='(555) 123-4567')

记忆

有两种方式：middleware（推荐），在create_agent中使用state_schema

1. Via middleware (preferred)
2. Via state_schema on create_agent

middleware

from langchain.agents import AgentState
from langchain.agents.middleware import AgentMiddleware
from typing import Any


class CustomState(AgentState):
    user_preferences: dict

class CustomMiddleware(AgentMiddleware):
    state_schema = CustomState
    tools = [tool1, tool2]

    def before_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        ...

agent = create_agent(
    model,
    tools=tools,
    middleware=[CustomMiddleware()]
)

# The agent can now track additional state beyond messages
result = agent.invoke({
    "messages": [{"role": "user", "content": "I prefer technical explanations"}],
    "user_preferences": {"style": "technical", "verbosity": "detailed"},
})