langchain-fundamentals

使用 `create_agent()`、中间件模式以及 `@tool` 装饰器 / `tool()` 函数构建生产级 Agent。创建 LangChain Agent 时，必须使用 create_agent()，并通过中间件实现自定义流程。所有其他替代方案都已过时。

<create_agent>

使用 create_agent 创建 Agent

create_agent() 是构建 Agent 的推荐方式。它负责处理 Agent 循环、工具执行和状态管理。

Agent 配置选项

参数	用途	示例
model	要使用的大模型	"anthropic:claude-sonnet-4-5" 或模型实例
tools	工具列表	[search, calculator]
system_prompt / systemPrompt	Agent 指令	"You are a helpful assistant"
checkpointer	状态持久化	MemorySaver()
middleware	处理钩子	[HumanInTheLoopMiddleware]（Python）/ [humanInTheLoopMiddleware({...})]（TypeScript）
</create_agent>

```python from langchain.agents import create_agent from langchain_core.tools import tool

@tool def get_weather(location: str) -> str: """Get current weather for a location.

Args:
    location: City name
"""
return f"Weather in {location}: Sunny, 72F"

agent = create_agent( model="anthropic:claude-sonnet-4-5", tools=[get_weather], system_prompt="You are a helpful assistant." )

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

</python>
<typescript>
```typescript
import { createAgent } from "langchain";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const getWeather = tool(
  async ({ location }) => `Weather in ${location}: Sunny, 72F`,
  {
    name: "get_weather",
    description: "Get current weather for a location.",
    schema: z.object({ location: z.string().describe("City name") }),
  }
);

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [getWeather],
  systemPrompt: "You are a helpful assistant.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "What's the weather in Paris?" }],
});
console.log(result.messages[result.messages.length - 1].content);

添加 MemorySaver 检查点，以便在多次调用之间保留对话状态。 ```python from langchain.agents import create_agent from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

agent = create_agent( model="anthropic:claude-sonnet-4-5", tools=[search], checkpointer=checkpointer, )

config = {"configurable": {"thread_id": "user-123"}} agent.invoke({"messages": [{"role": "user", "content": "My name is Alice"}]}, config=config) result = agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}, config=config)

Agent remembers: "Your name is Alice"

</python>
<typescript>
添加 MemorySaver 检查点，以便在多次调用之间保留对话状态。
```typescript
import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const checkpointer = new MemorySaver();

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [search],
  checkpointer,
});

const config = { configurable: { thread_id: "user-123" } };
await agent.invoke({ messages: [{ role: "user", content: "My name is Alice" }] }, config);
const result = await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] }, config);
// Agent remembers: "Your name is Alice"

## 定义工具

工具是 Agent 可以调用的函数。使用 @tool 装饰器（Python）或 tool() 函数（TypeScript）。

```python from langchain_core.tools import tool

@tool def calculate(expression: str) -> str: """Evaluate a mathematical expression.

Args:
    expression: Math expression like "2 + 2" or "10 * 5"
"""
return str(eval(expression))

</python>
<typescript>
```typescript
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const calculate = tool(
  async ({ expression }) => String(eval(expression)),
  {
    name: "calculate",
    description: "Evaluate a mathematical expression.",
    schema: z.object({
      expression: z.string().describe("Math expression like '2 + 2' or '10 * 5'"),
    }),
  }
);

## 用于控制 Agent 的中间件

中间件会拦截 Agent 循环，以添加人工审批、错误处理、日志记录等功能。要构建生产级 Agent，必须深入理解中间件——审批工作流请使用 HumanInTheLoopMiddleware（Python）/ humanInTheLoopMiddleware（TypeScript），自定义钩子请使用 @wrap_tool_call（Python）/ createMiddleware（TypeScript）。

关键导入：

from langchain.agents.middleware import HumanInTheLoopMiddleware, wrap_tool_call

import { humanInTheLoopMiddleware, createMiddleware } from "langchain";

关键模式：

• HITL：middleware=[HumanInTheLoopMiddleware(interrupt_on={"dangerous_tool": True})] — 需要 checkpointer + thread_id
• 中断后恢复：agent.invoke(Command(resume={"decisions": [{"type": "approve"}]}), config=config)
• 自定义中间件：@wrap_tool_call 装饰器（Python）或 createMiddleware({ wrapToolCall: ... })（TypeScript）

<structured_output>

结构化输出

使用 response_format 或 with_structured_output() 获取经过类型校验和验证的 Agent 响应。

```python from langchain.agents import create_agent from pydantic import BaseModel, Field

class ContactInfo(BaseModel): name: str email: str phone: str = Field(description="Phone number with area code")

Option 1: Agent with structured output

agent = create_agent(model="gpt-4.1", tools=[search], response_format=ContactInfo) result = agent.invoke({"messages": [{"role": "user", "content": "Find contact for John"}]}) print(result["structured_response"]) # ContactInfo(name='John', ...)

Option 2: Model-level structured output (no agent needed)

from langchain_openai import ChatOpenAI model = ChatOpenAI(model="gpt-4.1") structured_model = model.with_structured_output(ContactInfo) response = structured_model.invoke("Extract: John, [email protected], 555-1234")

ContactInfo(name='John', email='[email protected]', phone='555-1234')

</python>
<typescript>
```typescript
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const ContactInfo = z.object({
  name: z.string(),
  email: z.string().email(),
  phone: z.string().describe("Phone number with area code"),
});

// Model-level structured output
const model = new ChatOpenAI({ model: "gpt-4.1" });
const structuredModel = model.withStructuredOutput(ContactInfo);
const response = await structuredModel.invoke("Extract: John, [email protected], 555-1234");
// { name: 'John', email: '[email protected]', phone: '555-1234' }

<model_config>

模型配置

create_agent 接受模型字符串（"anthropic:claude-sonnet-4-5"、"openai:gpt-4.1"）或用于自定义设置的模型实例：

from langchain_anthropic import ChatAnthropic
agent = create_agent(model=ChatAnthropic(model="claude-sonnet-4-5", temperature=0), tools=[...])

</model_config>

清晰的描述有助于 Agent 判断何时使用每个工具。 ```python # WRONG: Vague or missing description @tool def bad_tool(input: str) -> str: """Does stuff.""" return "result"

CORRECT: Clear, specific description with Args

@tool def search(query: str) -> str: """Search the web for current information about a topic.

Use this when you need recent data or facts.

Args:
    query: The search query (2-10 words recommended)
"""
return web_search(query)

</python>
<typescript>
清晰的描述有助于 Agent 判断何时使用每个工具。
```typescript
// WRONG: Vague description
const badTool = tool(async ({ input }) => "result", {
  name: "bad_tool",
  description: "Does stuff.", // Too vague!
  schema: z.object({ input: z.string() }),
});

// CORRECT: Clear, specific description
const search = tool(async ({ query }) => webSearch(query), {
  name: "search",
  description: "Search the web for current information about a topic. Use this when you need recent data or facts.",
  schema: z.object({
    query: z.string().describe("The search query (2-10 words recommended)"),
  }),
});

添加检查点和 thread_id，以便在多次调用之间保留对话记忆。 ```python # WRONG: No persistence - agent forgets between calls agent = create_agent(model="anthropic:claude-sonnet-4-5", tools=[search]) agent.invoke({"messages": [{"role": "user", "content": "I'm Bob"}]}) agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}) # Agent doesn't remember!

CORRECT: Add checkpointer and thread_id

from langgraph.checkpoint.memory import MemorySaver

agent = create_agent( model="anthropic:claude-sonnet-4-5", tools=[search], checkpointer=MemorySaver(), ) config = {"configurable": {"thread_id": "session-1"}} agent.invoke({"messages": [{"role": "user", "content": "I'm Bob"}]}, config=config) agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}, config=config)

Agent remembers: "Your name is Bob"

</python>
<typescript>
添加检查点和 thread_id，以便在多次调用之间保留对话记忆。
```typescript
// WRONG: No persistence
const agent = createAgent({ model: "anthropic:claude-sonnet-4-5", tools: [search] });
await agent.invoke({ messages: [{ role: "user", content: "I'm Bob" }] });
await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] });
// Agent doesn't remember!

// CORRECT: Add checkpointer and thread_id
import { MemorySaver } from "@langchain/langgraph";

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [search],
  checkpointer: new MemorySaver(),
});
const config = { configurable: { thread_id: "session-1" } };
await agent.invoke({ messages: [{ role: "user", content: "I'm Bob" }] }, config);
await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] }, config);
// Agent remembers: "Your name is Bob"

在 invoke 配置中设置 recursion_limit，以防止 Agent 循环失控。 ```python # WRONG: No iteration limit - could loop forever result = agent.invoke({"messages": [("user", "Do research")]})

CORRECT: Set recursion_limit in config

result = agent.invoke( {"messages": [("user", "Do research")]}, config={"recursion_limit": 10}, # Stop after 10 steps )

</python>
<typescript>
在 invoke 配置中设置 recursionLimit，以防止 Agent 循环失控。
```typescript
// WRONG: No iteration limit
const result = await agent.invoke({ messages: [["user", "Do research"]] });

// CORRECT: Set recursionLimit in config
const result = await agent.invoke(
  { messages: [["user", "Do research"]] },
  { recursionLimit: 10 }, // Stop after 10 steps
);

从结果中访问 messages 数组，而不是直接访问 result.content。 ```python # WRONG: Trying to access result.content directly result = agent.invoke({"messages": [{"role": "user", "content": "Hello"}]}) print(result.content) # AttributeError!

CORRECT: Access messages from result dict

result = agent.invoke({"messages": [{"role": "user", "content": "Hello"}]}) print(result["messages"][-1].content) # Last message content

</python>
<typescript>
从结果中访问 messages 数组，而不是直接访问 result.content。
```typescript
// WRONG: Trying to access result.content directly
const result = await agent.invoke({ messages: [{ role: "user", content: "Hello" }] });
console.log(result.content); // undefined!

// CORRECT: Access messages from result object
const result = await agent.invoke({ messages: [{ role: "user", content: "Hello" }] });
console.log(result.messages[result.messages.length - 1].content); // Last message content