LangChain 中文文档

外观

本指南使用 create_agent 和 Deep Agents 中间件，从基本原理出发构建一个数据分析智能体。

create_agent 和 create_deep_agent 都能让你对工具、记忆等进行细粒度控制。两者之间的主要区别在于，Deep Agents 内置了一系列常用功能，例如规划、文件系统工具和子智能体。如果 Deep Agents 的默认 harness（智能体框架）不满足你的需求，本指南将向你展示如何从 create_agent 入手，逐步组装这个框架，让你清楚了解每个组件增加了什么，并只替换你的用例所需的部分。

按照本指南构建一个能够实现以下功能的智能体：

  1. 接受 CSV 文件进行分析
  2. 在隔离沙箱中编写并执行 Python 代码
  3. 将可视化工作委托给专门的子智能体
  4. 从技能文件中加载数据分析模式

最终的完整栈与 create_deep_agent 默认组装的内容一致。

你将学到什么 ​

每一步都会为同一个数据分析智能体增加一项能力：

步骤缺少它的后果你要添加的内容
最小智能体—基线循环：模型 + 工具，无框架
沙箱 + 文件系统智能体无法读取 CSV 或运行 Python隔离的后端 + 文件和执行工具
摘要长时间会话触及上下文限制自动压缩历史记录
技能领域规则使系统提示词变得臃肿通过渐进式披露按需获取专业知识
子智能体图表迭代挤占主线程隔离的工作进程 + 并行委托

环境准备 ​

安装包 ​

安装本教程所需的包：

bash
pip install deepagents langsmith
bash
npm install deepagents langsmith

设置 LangSmith API 密钥 ​

本教程使用 LangSmithSandbox，它通过 SandboxClient 预置沙箱。该客户端使用你环境中的 LANGSMITH_API_KEY 向 LangSmith 进行身份验证，因此运行本教程需要 API 密钥。配置 LangSmith 还能让你查看智能体运行时发生情况的追踪。

  1. 注册免费账户。你可以使用 Google、GitHub 或邮箱。
  2. 在 Settings → API Keys 中创建 API 密钥。
  3. 导出 LangSmith API 密钥：
bash
export LANGSMITH_API_KEY=...
  1. 启用追踪，以便在逐步添加每个组件时检查工具调用、中间件步骤和子智能体委托：
bash
export LANGSMITH_TRACING=true

添加模型提供商 API 密钥 ​

导出你在代码示例中使用的模型提供商的 API 密钥。例如：

bash
export ANTHROPIC_API_KEY=...

构建智能体 ​

创建最小智能体 ​

数据分析智能体需要的不仅仅是对话循环，但首先从基线开始：只有模型和一个循环。

使用 create_agent 并指定你想使用的模型：

python
from langchain.agents import create_agent

agent = create_agent("anthropic:claude-sonnet-4-6", tools=[])
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [],
});
ts
import { createAgent } from "langchain";

let agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [],
});

这可以运行，但智能体没有文件系统，也没有执行代码的途径。如果你让它分析 CSV，它只能根据提示词猜测。接下来的步骤将添加真实的文件访问和代码执行能力。

添加沙箱后端 ​

要高效分析数据，智能体需要在文件上运行代码。这需要两样东西：

  • 一个隔离的沙箱，智能体可以在此放置文件并在文件上运行代码，同时不会让智能体访问你的宿主机。

  • 一个后端，它使用 FilesystemMiddleware 提供用于操作沙箱的文件系统工具（read_file、write_file、edit_file、delete、glob、grep）。由于 LangSmithSandbox 后端实现了沙箱协议，FilesystemMiddleware 还会添加 execute 工具，让智能体可以运行 shell 命令。

  • 一个后端，它使用 FilesystemMiddleware 提供用于操作沙箱的文件系统工具（read_file、write_file、edit_file、delete、glob、grep）。由于 LangSmithSandbox 后端实现了沙箱协议，FilesystemMiddleware 还会添加 execute 工具，让智能体可以运行 shell 命令。

LangSmithSandbox 是文件存放和命令运行的地方。FilesystemMiddleware 负责将该环境以工具的形式暴露给模型。如果之后更换后端，同一个中间件也可以与其他后端配合使用。

LangSmithSandbox 为智能体提供一个隔离环境，其中包含文件系统和一个用于运行 shell 命令的 execute 工具。有了它，智能体可以安装包、编写脚本并运行它们，而无需接触宿主机。要从自定义镜像启动而不是默认运行时，请向 create_sandbox() 传入 snapshot_name 或 snapshot_id；参见沙箱快照。

LangSmithSandbox 为智能体提供一个隔离环境，其中包含文件系统和一个用于运行 shell 命令的 execute 工具。有了它，智能体可以安装包、编写脚本并运行它们，而无需接触宿主机。要从自定义镜像启动而不是默认运行时，请向 LangSmithSandbox.create() 传入 snapshotId；参见沙箱快照。

用包含 FilesystemMiddleware 的智能体替换上一步创建的智能体：

python
from langchain.agents import create_agent
from deepagents.backends.langsmith import LangSmithSandbox
from deepagents.middleware import FilesystemMiddleware
from langsmith.sandbox import SandboxClient

client = SandboxClient()
sandbox = None
sandbox = client.create_sandbox(name="langchain-docs", snapshot_name="docs-test-ci")
backend = LangSmithSandbox(sandbox=sandbox)

agent = create_agent(
    "anthropic:claude-sonnet-4-6",
    tools=[],
    middleware=[FilesystemMiddleware(backend=backend)],
)
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});
ts
import { createFilesystemMiddleware, LangSmithSandbox } from "deepagents";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "langchain-docs",
  snapshotName: "docs-test-ci",
});
const backend = new LangSmithSandbox({ sandbox });

agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [],
  middleware: [createFilesystemMiddleware({ backend })],
});

沙箱文件系统与你的电脑是分开的。在调用智能体之前，你必须先把你需要的文件上传到沙箱中：

python
import csv
import io

rows = [
    ["Date", "Product", "Units", "Revenue"],
    ["2025-08-01", "Widget A", 10, 250],
    ["2025-08-02", "Widget B", 5, 125],
    ["2025-08-03", "Widget A", 7, 175],
    ["2025-08-04", "Widget C", 3, 90],
]
buf = io.StringIO()
csv.writer(buf).writerows(rows)
backend.upload_files([("/sales.csv", buf.getvalue().encode())])

upload_stream = agent.stream_events(
    {
        "messages": [
            {
                "role": "user",
                "content": (
                    "Read /sales.csv and summarize total revenue by product in one "
                    "sentence. Do not run shell commands."
                ),
            }
        ]
    },
    version="v3",
    config={"recursion_limit": 8},
)
for item in upload_stream.messages:
    print(item.text)
upload_stream.output
ts
const rows = [
  ["Date", "Product", "Units", "Revenue"],
  ["2025-08-01", "Widget A", "10", "250"],
  ["2025-08-02", "Widget B", "5", "125"],
  ["2025-08-03", "Widget A", "7", "175"],
  ["2025-08-04", "Widget C", "3", "90"],
];

const csv = rows.map((row) => row.join(",")).join("\n");
const encoder = new TextEncoder();
await backend.uploadFiles([["/sales.csv", encoder.encode(csv)]]);

const uploadStream = await agent.streamEvents(
  {
    messages: [
      {
        role: "user",
        content:
          "Read /sales.csv and summarize total revenue by product in one sentence. Do not run shell commands.",
      },
    ],
  },
  { version: "v3", recursionLimit: 8 },
);

await Promise.all([
  (async () => {
    for await (const message of uploadStream.messages) {
      console.log(await message.text);
    }
  })(),
  uploadStream.output,
]);

INFO

使用 LangSmithSandbox 时，上传路径必须是绝对的 POSIX 路径（例如 /sales.csv）。诸如 sales.csv 之类的相对路径会被以 invalid_path 拒绝，文件不会写入沙箱。

将前面步骤的代码合并到一个脚本中并运行它：

bash
python analyze_sales.py
bash
npx tsx analyze-sales.ts

首次运行时，LangSmith 会预置一个沙箱（这可能需要几秒钟）。脚本会上传 sales.csv，流式输出智能体的运行过程，并在助手消息到达时打印出来。你应该会看到对示例销售数据的分析：产品级收入、哪些小部件销量最高，以及简要的趋势说明。具体措辞因模型运行而异。

在 LangSmith 中打开这次运行，观察智能体在回复之前如何使用文件系统工具（read_file，以及如果它在沙箱中运行 Python 的话还有 execute）。

添加上下文管理 ​

完成步骤 2 后，每个工具结果都会保留在消息历史中。真实的分析会话（多个图表、失败的脚本、大量的 read_file 输出）很快就会占满上下文窗口。

SummarizationMiddleware 会在历史记录过于庞大时压缩较早的轮次，因此智能体可以持续工作，无需你手动裁剪消息。这一点在首次询问 sales.csv 时不太重要，而在"现在按产品分组并绘制月度趋势图"之类的后续问题上更为重要。

将 SummarizationMiddleware 添加到中间件列表中，更新步骤 2 中的智能体：

python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="google_genai:gemini-3.6-flash"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="openai:gpt-5.5"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="anthropic:claude-sonnet-4-6"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="openrouter:z-ai/glm-5.2"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="fireworks:accounts/fireworks/models/glm-5p2"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="baseten:zai-org/GLM-5.2"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
python
from deepagents.middleware import FilesystemMiddleware, SummarizationMiddleware

model="ollama:north-mini-code-1.0"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
    ],
)
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "google-genai:gemini-3.6-flash",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});
ts
import { createSummarizationMiddleware } from "deepagents";

agent = createAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({
      model: "openai:gpt-4.1",
      backend,
    }),
  ],
});

运行一个多轮会话以查看摘要的实际效果。在初始分析之后，提出能触发更多文件读取或脚本运行的后续问题。在 LangSmith 中，留意后续模型调用之前的摘要步骤。更多信息请参见上下文工程。

添加技能 ​

技能 提供了一种通过渐进式披露在需要时按需向智能体提供领域知识的方法。技能可以包含多步工作流、规则和惯例。将这类信息放在技能中后，默认情况下不会将其添加到系统提示词中，从而确保 token 只会在任务需要该技能中的信息时才被使用。

智能体启动时，只会看到每个技能的轻量级元数据。当某个任务需要技能时，智能体会按需加载完整的技能文件。

在技能目录中创建一个技能文件：

skills/
  pandas-patterns/
    SKILL.md
markdown
---
name: pandas-patterns
description: Common pandas and matplotlib patterns for data analysis and visualization
---

## Data loading
Use `pd.read_csv()` for CSV files. Always check `df.info()` and `df.describe()` first.

## Visualization
Use `matplotlib` for bar charts, `seaborn` for statistical plots.
Save figures with `plt.savefig("output.png", dpi=150, bbox_inches="tight")`.

## Reporting
Write a markdown summary to `report.md` alongside any generated charts.

这个技能包含关于应该如何进行可视化的信息。

使用 LangSmithSandbox 时，技能路径会在沙箱文件系统上解析，而不是在你的本地机器上解析。在配置 SkillsMiddleware 之前，先上传你的本地 skills/ 目录：

python
from pathlib import Path

skills_dir = (Path(__file__).resolve().parent / "skills").resolve()
skill_files: list[tuple[str, bytes]] = []
for path in sorted(skills_dir.rglob("*")):
    if not path.is_file():
        continue
    rel = path.resolve().relative_to(skills_dir)
    skill_files.append((f"/skills/{rel.as_posix()}", path.read_bytes()))
backend.upload_files(skill_files)
ts
import { readFileSync, readdirSync, statSync } from "node:fs";
import { join, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";

const skillsDir = resolve(
  fileURLToPath(new URL(".", import.meta.url)),
  "skills",
);
const skillFiles: Array<[string, Uint8Array]> = [];

function collectSkillFiles(dir: string): void {
  for (const entry of readdirSync(dir)) {
    const fullPath = join(dir, entry);
    if (statSync(fullPath).isDirectory()) {
      collectSkillFiles(fullPath);
    } else {
      const rel = relative(skillsDir, fullPath).replace(/\\/g, "/");
      skillFiles.push([`/skills/${rel}`, readFileSync(fullPath)]);
    }
  }
}

collectSkillFiles(skillsDir);
await backend.uploadFiles(skillFiles);

然后通过添加 SkillsMiddleware 来创建包含你的技能的智能体：

python
from deepagents.middleware import FilesystemMiddleware, SkillsMiddleware, SummarizationMiddleware

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
        SkillsMiddleware(backend=backend, sources=["/skills/"]),
    ],
)
ts
import { createSkillsMiddleware } from "deepagents";

let model = "openai:gpt-4.1";

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
  ],
});

你可以尝试这样的提示词："使用我们的 pandas 模式分析 sales.csv"。智能体在需要绘图或报告指导时会加载该技能。如果你提出一个不需要该技能的其他问题，智能体不会加载它。

添加可视化子智能体 ​

有些任务会产生大量的中间输出（脚本草稿、失败的运行、文件读取），如果都保存在同一个线程中，会挤占主智能体的上下文。子智能体 在它自己的上下文窗口中运行，因此主管只能看到最终结果，而不是过程中的每一次工具调用。这能让主分析保持专注，并为后续问题留出空间。

使用子智能体合理的例子之一是图表生成。绘制图表往往意味着在图形就绪之前反复迭代 Python 脚本、安装包、阅读错误输出。下面的 visualizer 子智能体可以在隔离环境中处理这些工作，同时主智能体继续规划和分析。借助 TodoListMiddleware，主智能体还可以并行委托图表工作，而不是阻塞在每张图上。

添加 TodoListMiddleware 和 SubAgentMiddleware，更新步骤 4 中的智能体：

python
from deepagents import SubAgent
from deepagents.middleware import (
    FilesystemMiddleware,
    SkillsMiddleware,
    SubAgentMiddleware,
    SummarizationMiddleware,
)
from langchain.agents.middleware import TodoListMiddleware

visualizer: SubAgent = {
    "name": "visualizer",
    "description": "Generates charts and visualizations from data files in the sandbox.",
    "system_prompt": "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
    "tools": [],
    "model": "anthropic:claude-sonnet-4-6",
}

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
        SkillsMiddleware(backend=backend, sources=["/skills/"]),
        TodoListMiddleware(),
        SubAgentMiddleware(backend=backend, subagents=[visualizer]),
    ],
)
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "google-genai:gemini-3.6-flash",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "openai:gpt-5.5",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "anthropic:claude-sonnet-4-6",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "openrouter:openrouter:z-ai/glm-5.2",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "fireworks:accounts/fireworks/models/glm-5p2",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "baseten:zai-org/GLM-5.2",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});
ts
import { todoListMiddleware } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";

const visualizer: SubAgent = {
  name: "visualizer",
  description:
    "Generates charts and visualizations from data files in the sandbox.",
  systemPrompt:
    "You are a data visualization specialist. Write Python scripts using matplotlib and seaborn. Save all figures as PNG files.",
  tools: [],
  model: "ollama:north-mini-code-1.0",
};

agent = createAgent({
  model,
  tools: [],
  middleware: [
    createFilesystemMiddleware({ backend }),
    createSummarizationMiddleware({ model, backend }),
    createSkillsMiddleware({ backend, sources: ["/skills/"] }),
    todoListMiddleware(),
    createSubAgentMiddleware({
      defaultModel: model,
      defaultTools: [],
      subagents: [visualizer],
    }),
  ],
});

尝试这样的提示词："分析 sales.csv，然后按产品创建收入条形图"。主智能体负责分析和规划，并通过 task 工具将图表生成委托给 visualizer 子智能体。

如果你在环境准备中启用了追踪，请在 LangSmith 中打开这次运行。你应该会看到对 visualizer 的 task 调用、一个带有自己工具循环的独立子运行，以及返回给主管的简短结果。

你构建了什么 ​

你使用以下中间件构建了一个定制智能体：

中间件它添加了什么
FilesystemMiddleware + LangSmithSandbox隔离的文件系统 + execute 工具
SummarizationMiddleware自动压缩上下文
SkillsMiddleware按需加载领域知识
TodoListMiddleware + SubAgentMiddleware并行可视化子智能体

这与 create_deep_agent 的基础相同：手动组装，这样你可以精确控制包含哪些内容。

这与 createDeepAgent 的基础相同：手动组装，这样你可以精确控制包含哪些内容。

可能性不止于此：请参阅预置中间件了解可组合功能的完整列表，并参阅 create_agent 参考文档了解所有配置选项。

要使用预组装版本，请参阅定制 Deep Agents。要查看使用 create_deep_agent 的完整数据分析示例，请参阅数据分析。

要使用预组装版本，请参阅定制 Deep Agents。要查看使用 createDeepAgent 的完整数据分析示例，请参阅数据分析。