深入浅出 AgentScope 2.0：打造你的 AI 智能体军团（上篇）
·
一、开篇：AI 智能体时代已经到来
1.1 从 ChatGPT 到 AI Agent
还记得 2022 年底 ChatGPT 刚发布时的震撼吗？那时候，我们惊叹于大语言模型（Large Language Model，简称 LLM）能够流畅地回答问题、写代码、创作文章。但很快，人们发现了一个问题：LLM 只能「说话」，不能「做事」。
举个例子：
用户：帮我订一张明天从北京到上海的机票
ChatGPT：我可以帮你查询航班信息，但我无法直接预订机票。
你可以访问携程、去哪儿等平台进行预订...这就是传统 LLM 的局限性——它只能生成文本，无法执行实际操作。
AI Agent（AI 智能体） 的出现，彻底改变了这一切。
1.2 什么是 AI Agent？
Agent（智能体） 这个词来自人工智能领域，指的是能够感知环境、做出决策、执行动作的自主实体。
用大白话说：Agent = LLM + 工具调用能力 + 自主决策能力
让我们用一个生活化的类比来理解：
| 概念 | 类比 | 能力 |
|---|---|---|
| LLM（大语言模型） | 一个博学多才的顾问 | 能回答问题、提供建议，但无法执行操作 |
| Tool（工具） | 各种实用工具（电话、电脑、车钥匙） | 能执行具体操作，但需要有人使用 |
| Agent（智能体） | 一个全能的私人助理 | 能理解需求、选择合适的工具、自主完成任务 |
Agent 的核心能力
一个完整的 AI Agent 通常具备以下能力：
- 推理能力（Reasoning）：分析问题，制定计划
- 工具调用能力（Tool Use）：调用外部工具完成任务
- 记忆能力（Memory）：记住历史对话和上下文
- 规划能力（Planning）：分解复杂任务，规划执行步骤
- 自主决策能力（Autonomy）：在人类监督下自主行动
1.3 Agent 的工作原理：ReAct 模式
目前最主流的 Agent 工作模式是 ReAct（Reasoning + Acting），即「推理-行动」循环。
┌─────────────────────────────────────────────────────────────┐
│ ReAct 工作流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户输入：「帮我查一下北京明天的天气，如果下雨提醒我带伞」 │
│ │
│ ┌──────────────┐ │
│ │ 推理阶段 │ 思考：用户想知道天气，我需要调用天气API │
│ │ (Reasoning) │ │
│ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ 行动阶段 │ 调用工具：weather_api("北京", "明天") │
│ │ (Acting) │ │
│ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ 观察阶段 │ 获取结果：明天北京有中雨，气温18-22℃ │
│ │ (Observing) │ │
│ └──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ 推理阶段 │ 思考：确实下雨，需要提醒用户带伞 │
│ │ (Reasoning) │ │
│ └──────────────┘ │
│ │ │
│ ▼ │
│ 最终回复：「明天北京有中雨，气温18-22℃，记得带伞哦！」 │
│ │
└─────────────────────────────────────────────────────────────┘这个「推理 → 行动 → 观察 → 再推理」的循环，就是 Agent 的核心工作方式。
二、认识 AgentScope 2.0
2.1 AgentScope 是什么？
AgentScope 是阿里巴巴开源的一款生产就绪、易于使用的 AI 智能体框架。它于 2024 年首次发布，2026 年 5 月发布了重大更新的 2.0 版本。
用一句话概括：AgentScope 是一个帮你快速构建 AI Agent 应用的 Python 框架。
2.2 为什么选择 AgentScope？
市面上已经有不少 Agent 框架，比如 LangChain、AutoGPT、CrewAI 等。为什么还要选择 AgentScope？
优势一：简单易用
5 分钟上手——这不是夸张，是 AgentScope 的设计目标。
对比一下其他框架的代码量：
# 使用 LangChain 创建一个简单的 Agent
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")
def search(query):
return "搜索结果..."
tools = [
Tool(
name="Search",
func=search,
description="搜索工具"
)
]
agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
result = agent.run("帮我搜索一下Python教程")# 使用 AgentScope 创建同样的 Agent
from agentscope.agent import Agent
from agentscope.tool import Toolkit, Bash
from agentscope.model import OpenAIChatModel
agent = Agent(
name="助手",
system_prompt="你是一个有帮助的助手",
model=OpenAIChatModel(model="gpt-4"),
toolkit=Toolkit(tools=[Bash()]),
)
result = await agent.reply(UserMsg("用户", "帮我搜索一下Python教程"))可以看到，AgentScope 的代码更加简洁直观。
优势二：生产就绪
AgentScope 不仅仅是一个实验性框架，它从设计之初就考虑了生产环境的需求：
| 特性 | 说明 |
|---|---|
| 多租户支持 | 一个服务实例可以服务多个用户/组织 |
| 多会话管理 | 支持用户同时进行多个对话 |
| OpenTelemetry 集成 | 内置可观测性支持 |
| 多种部署方式 | 本地、云端 Serverless、Kubernetes 集群 |
| 权限控制 | 细粒度的工具调用权限管理 |
优势三：丰富的生态系统
AgentScope 提供了丰富的内置组件：
- 内置工具：Bash、Grep、Glob、Read、Write、Edit 等
- 模型支持：OpenAI、Anthropic、DashScope（阿里云）、Gemini、DeepSeek、Ollama 等
- 协议支持：MCP（Model Context Protocol）、A2A（Agent-to-Agent）
- 中间件系统：可扩展的钩子机制
2.3 AgentScope 的设计哲学
AgentScope 2.0 的设计有一个核心理念：
为日益自主的大语言模型而设计。我们的方法是充分发挥模型的推理与工具调用能力，而不是用严格的提示词和固化的编排方式来束缚它们。
这句话怎么理解？
传统的 Agent 框架往往需要你：
- 编写复杂的提示词模板
- 定义严格的工具调用流程
- 手动管理 Agent 之间的协作
而 AgentScope 的思路是：
- 让模型自己决定何时调用工具
- 让模型自己规划任务步骤
- 提供灵活的消息中心（MsgHub）让 Agent 自由协作
2.4 AgentScope 的架构
AgentScope 采用模块化的架构设计：
┌─────────────────────────────────────────────────────────────┐
│ AgentScope 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 应用层 (Application) │ │
│ │ 你的 Agent 应用、Web UI、API 服务 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Agent 层 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Agent 1 │ │ Agent 2 │ │ Agent N │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 核心组件层 │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │ Tool │ │ Model │ │Memory │ │ Event │ │ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 基础设施层 │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │Workspace│ │Permission│ │Middleware│ │OTel │ │ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘三、核心概念详解
3.1 Agent（智能体）
Agent 是 AgentScope 的核心概念，代表一个能够自主执行任务的 AI 实体。
Agent 的组成要素
一个 Agent 由以下要素组成：
from agentscope.agent import Agent
from agentscope.model import OpenAIChatModel
from agentscope.tool import Toolkit
agent = Agent(
name="Friday", # 名称：Agent 的标识
system_prompt="你是一个有帮助的助手", # 系统提示词：定义 Agent 的角色和行为
model=OpenAIChatModel(...), # 模型：Agent 的「大脑」
toolkit=Toolkit(tools=[...]), # 工具集：Agent 可以使用的工具
middlewares=[...], # 中间件：扩展 Agent 行为
state=AgentState(), # 状态：Agent 的记忆和上下文
)Agent 的核心方法
Agent 提供两个核心方法：
| 方法 | 说明 | 返回类型 |
|---|---|---|
reply() |
同步回复，返回最终结果 | Msg |
reply_stream() |
流式回复，实时返回事件 | AsyncGenerator[AgentEvent] |
示例：同步回复
result = await agent.reply(UserMsg("Tony", "你好！"))
print(result.content)示例：流式回复
async for event in agent.reply_stream(UserMsg("Tony", "你好！")):
match event.type:
case EventType.TEXT_BLOCK_DELTA:
print(event.delta, end="", flush=True)
case EventType.TOOL_CALL_START:
print(f"\n[调用工具: {event.tool_name}]")3.2 Tool（工具）
Tool（工具） 是 Agent 与外部世界交互的桥梁。通过工具，Agent 可以执行各种操作：搜索网络、读写文件、调用 API 等。
AgentScope 的内置工具
AgentScope 提供了一系列开箱即用的内置工具：
| 工具名 | 功能 | 使用场景 |
|---|---|---|
Bash |
执行 Shell 命令 | 运行脚本、系统操作 |
Read |
读取文件内容 | 查看代码、读取配置 |
Write |
写入文件 | 创建文件、保存数据 |
Edit |
编辑文件 | 修改代码、更新配置 |
Grep |
搜索文件内容 | 代码搜索、日志分析 |
Glob |
查找文件 | 文件发现、项目遍历 |
使用工具集（Toolkit）
Toolkit 是工具的容器，用于管理和注册工具：
from agentscope.tool import Toolkit, Bash, Read, Write, Edit
toolkit = Toolkit(
tools=[
Bash(),
Read(),
Write(),
Edit(),
]
)
agent = Agent(
name="代码助手",
system_prompt="你是一个编程助手",
model=OpenAIChatModel(...),
toolkit=toolkit,
)自定义工具
你可以通过 FunctionTool 创建自定义工具：
from agentscope.tool import FunctionTool
def get_weather(city: str, date: str = "今天") -> str:
"""
获取指定城市的天气信息。
参数:
city: 城市名称，如"北京"、"上海"
date: 日期，默认为"今天"
返回:
天气信息字符串
"""
# 这里是模拟数据，实际应用中应该调用真实的天气 API
weather_data = {
"北京": {"今天": "晴，18-25℃", "明天": "多云，16-23℃"},
"上海": {"今天": "小雨，20-26℃", "明天": "阴，19-25℃"},
}
return weather_data.get(city, {}).get(date, "暂无数据")
# 创建工具
weather_tool = FunctionTool(get_weather)
# 添加到工具集
toolkit = Toolkit(tools=[weather_tool])重要说明：工具函数的文档字符串（docstring） 非常重要，Agent 会通过阅读文档字符串来理解工具的用途和参数。
3.3 Message（消息）
Message（消息） 是 Agent 与用户、Agent 与 Agent 之间通信的基本单位。
消息类型
AgentScope 定义了多种消息类型：
| 类型 | 类名 | 说明 |
|---|---|---|
| 用户消息 | UserMsg |
来自用户的消息 |
| 助手消息 | AssistantMsg |
Agent 生成的回复 |
| 系统消息 | SystemMsg |
系统级指令 |
创建消息
from agentscope.message import UserMsg, AssistantMsg, SystemMsg
# 用户消息
user_msg = UserMsg(
name="Tony", # 发送者名称
content="你好，请介绍一下你自己" # 消息内容
)
# 助手消息
assistant_msg = AssistantMsg(
name="Friday",
content="你好！我是 Friday，你的 AI 助手..."
)
# 系统消息
system_msg = SystemMsg(
name="system",
content="你是一个有帮助的 AI 助手"
)消息内容块（Content Block）
消息的内容不仅仅是简单的文本，还可以包含多种类型的内容块：
| 内容块类型 | 类名 | 说明 |
|---|---|---|
| 文本块 | TextBlock |
普通文本内容 |
| 思考块 | ThinkingBlock |
Agent 的推理过程 |
| 工具调用块 | ToolCallBlock |
调用工具的请求 |
| 工具结果块 | ToolResultBlock |
工具执行的返回结果 |
| 数据块 | DataBlock |
结构化数据（如图片、文件） |
示例：包含工具调用的消息
from agentscope.message import AssistantMsg, TextBlock, ToolCallBlock
msg = AssistantMsg(
name="Friday",
content=[
TextBlock(text="我来帮你查询天气信息。"),
ToolCallBlock(
id="call_123",
name="get_weather",
arguments={"city": "北京", "date": "今天"}
)
]
)3.4 Event（事件）
Event（事件） 是 AgentScope 实现流式响应的核心机制。当 Agent 执行任务时，会发出各种事件，让外部程序能够实时了解 Agent 的状态。
事件类型
AgentScope 定义了丰富的事件类型：
| 事件类型 | 说明 |
|---|---|
ReplyStartEvent |
Agent 开始回复 |
ReplyEndEvent |
Agent 回复结束 |
ModelCallStartEvent |
开始调用模型 |
ModelCallEndEvent |
模型调用结束 |
TextBlockStartEvent |
文本块开始 |
TextBlockDeltaEvent |
文本块增量更新（流式输出） |
TextBlockEndEvent |
文本块结束 |
ToolCallStartEvent |
开始调用工具 |
ToolCallEndEvent |
工具调用结束 |
ToolResultStartEvent |
工具结果开始 |
ToolResultEndEvent |
工具结果结束 |
ThinkingBlockStartEvent |
思考块开始 |
ThinkingBlockEndEvent |
思考块结束 |
处理事件流
from agentscope.event import EventType
async for event in agent.reply_stream(user_msg):
match event.type:
case EventType.REPLY_START:
print("=== Agent 开始回复 ===")
case EventType.TEXT_BLOCK_START:
print("\n[文本输出开始]")
case EventType.TEXT_BLOCK_DELTA:
# 流式打印文本
print(event.delta, end="", flush=True)
case EventType.TEXT_BLOCK_END:
print("\n[文本输出结束]")
case EventType.TOOL_CALL_START:
print(f"\n[调用工具: {event.tool_name}]")
print(f"参数: {event.arguments}")
case EventType.TOOL_RESULT_START:
print("[工具执行结果]")
case EventType.TOOL_RESULT_TEXT_DELTA:
print(event.delta, end="")
case EventType.REPLY_END:
print("\n=== Agent 回复结束 ===")3.5 Model（模型）
Model（模型） 是 Agent 的「大脑」，负责理解输入、生成输出、做出决策。
支持的模型
AgentScope 支持多种主流 LLM 服务：
| 模型类 | 服务商 | 说明 |
|---|---|---|
OpenAIChatModel |
OpenAI | GPT-4、GPT-3.5 等 |
AnthropicChatModel |
Anthropic | Claude 系列 |
DashScopeChatModel |
阿里云 | 通义千问系列 |
GeminiChatModel |
Gemini 系列 | |
DeepSeekChatModel |
DeepSeek | DeepSeek 系列 |
OllamaChatModel |
Ollama | 本地模型 |
XAIChatModel |
xAI | Grok 系列 |
MoonshotChatModel |
Moonshot | Kimi 系列 |
配置模型
示例：使用 OpenAI 模型
from agentscope.model import OpenAIChatModel
from agentscope.credential import OpenAICredential
model = OpenAIChatModel(
credential=OpenAICredential(
api_key="your-api-key",
),
model="gpt-4o",
)示例：使用阿里云 DashScope 模型
from agentscope.model import DashScopeChatModel
from agentscope.credential import DashScopeCredential
import os
model = DashScopeChatModel(
credential=DashScopeCredential(
api_key=os.environ["DASHSCOPE_API_KEY"]
),
model="qwen3.6-plus", # 通义千问
)示例：使用本地 Ollama 模型
from agentscope.model import OllamaChatModel
model = OllamaChatModel(
model="llama3",
base_url="http://localhost:11434", # Ollama 默认地址
)3.6 State（状态）
State（状态） 用于保存 Agent 的运行时状态，包括对话历史、记忆、权限上下文等。
from agentscope.state import AgentState
state = AgentState(
context=[], # 对话上下文
summary=None, # 上下文压缩后的摘要
permission_context=None, # 权限上下文
)
agent = Agent(
name="助手",
system_prompt="...",
model=model,
state=state, # 传入状态
)3.7 Middleware（中间件）
Middleware（中间件） 是一种扩展 Agent 行为的机制，可以在不修改 Agent 源代码的情况下，添加自定义逻辑。
中间件的钩子点
AgentScope 提供了多个钩子点：
| 钩子点 | 说明 |
|---|---|
on_reply |
Agent 回复前后 |
on_reasoning |
Agent 推理前后 |
on_acting |
Agent 执行动作前后 |
on_model_call |
模型调用前后 |
on_system_prompt |
获取系统提示词时 |
自定义中间件示例
from agentscope.middleware import MiddlewareBase
class LoggingMiddleware(MiddlewareBase):
"""日志记录中间件"""
async def on_reply(self, context, next_handler):
print(f"[日志] Agent 开始回复")
result = await next_handler(context)
print(f"[日志] Agent 回复完成")
return result
async def on_model_call(self, context, next_handler):
print(f"[日志] 开始调用模型")
result = await next_handler(context)
print(f"[日志] 模型调用完成，消耗 {result.usage.total_tokens} tokens")
return result
# 使用中间件
agent = Agent(
name="助手",
system_prompt="...",
model=model,
middlewares=[LoggingMiddleware()],
)四、快速上手：5 分钟创建你的第一个 Agent
4.1 环境准备
系统要求
- Python 3.11 或更高版本
- pip 或 uv 包管理器
安装 AgentScope
方式一：从 PyPI 安装（推荐）
# 使用 pip
pip install agentscope
# 或使用 uv（更快）
uv pip install agentscope方式二：从源码安装
# 克隆仓库
git clone https://github.com/agentscope-ai/agentscope.git
# 进入目录
cd agentscope
# 安装
pip install -e .4.2 第一个 Agent：Hello AgentScope
让我们创建一个最简单的 Agent——一个能和你对话的 AI 助手。
import asyncio
import os
from agentscope.agent import Agent
from agentscope.model import DashScopeChatModel
from agentscope.credential import DashScopeCredential
from agentscope.message import UserMsg
async def main():
# 创建 Agent
agent = Agent(
name="Friday",
system_prompt="你是一个友好、有帮助的 AI 助手，名叫 Friday。",
model=DashScopeChatModel(
credential=DashScopeCredential(
api_key=os.environ["DASHSCOPE_API_KEY"]
),
model="qwen3.6-plus",
),
)
# 发送消息并获取回复
result = await agent.reply(
UserMsg("Tony", "你好！请介绍一下你自己。")
)
print(f"Friday: {result.content}")
asyncio.run(main())运行结果：
Friday: 你好！我是 Friday，你的 AI 助手。我可以帮助你回答问题、
提供建议、进行对话。有什么我可以帮助你的吗？4.3 添加工具：让 Agent 能「做事」
现在，让我们给 Agent 添加一些工具，让它能够执行实际操作。
import asyncio
import os
from agentscope.agent import Agent
from agentscope.model import DashScopeChatModel
from agentscope.credential import DashScopeCredential
from agentscope.message import UserMsg
from agentscope.tool import Toolkit, Bash, Read, Write
from agentscope.event import EventType
async def main():
agent = Agent(
name="Friday",
system_prompt="你是一个编程助手，可以帮助用户进行编程任务。",
model=DashScopeChatModel(
credential=DashScopeCredential(
api_key=os.environ["DASHSCOPE_API_KEY"]
),
model="qwen3.6-plus",
),
toolkit=Toolkit(
tools=[
Bash(), # 执行 Shell 命令
Read(), # 读取文件
Write(), # 写入文件
]
),
)
# 流式输出
async for event in agent.reply_stream(
UserMsg("Tony", "请创建一个名为 hello.py 的 Python 文件，内容是打印 Hello World")
):
match event.type:
case EventType.TEXT_BLOCK_DELTA:
print(event.delta, end="", flush=True)
case EventType.TOOL_CALL_START:
print(f"\n[调用工具: {event.tool_name}]")
case EventType.TOOL_RESULT_TEXT_DELTA:
print(f"结果: {event.delta}")
asyncio.run(main())运行结果：
[调用工具: Write]
结果: 文件 hello.py 已创建
好的，我已经创建了一个名为 hello.py 的 Python 文件，
内容如下：
```python
print("Hello World")你可以通过运行 python hello.py 来执行它。
### 4.4 流式输出：实时看到 Agent 的思考过程
AgentScope 的流式输出不仅能让你实时看到文本，还能看到 Agent 的「思考过程」。
```python
import asyncio
import os
from agentscope.agent import Agent
from agentscope.model import DashScopeChatModel
from agentscope.credential import DashScopeCredential
from agentscope.message import UserMsg
from agentscope.tool import Toolkit, Bash
from agentscope.event import EventType
async def main():
agent = Agent(
name="Friday",
system_prompt="你是一个有帮助的助手。",
model=DashScopeChatModel(
credential=DashScopeCredential(
api_key=os.environ["DASHSCOPE_API_KEY"]
),
model="qwen3.6-plus",
),
toolkit=Toolkit(tools=[Bash()]),
)
print("=== 开始对话 ===\n")
async for event in agent.reply_stream(
UserMsg("Tony", "列出当前目录下的所有 Python 文件")
):
match event.type:
case EventType.REPLY_START:
print("[Agent 开始处理]\n")
case EventType.THINKING_BLOCK_START:
print("[思考中...]\n")
case EventType.THINKING_BLOCK_DELTA:
print(event.delta, end="", flush=True)
case EventType.THINKING_BLOCK_END:
print("\n[思考结束]\n")
case EventType.TEXT_BLOCK_START:
print("[回复]\n")
case EventType.TEXT_BLOCK_DELTA:
print(event.delta, end="", flush=True)
case EventType.TEXT_BLOCK_END:
print()
case EventType.TOOL_CALL_START:
print(f"\n[执行命令: {event.arguments.get('command', '')}]")
case EventType.TOOL_RESULT_TEXT_DELTA:
print(event.delta)
case EventType.REPLY_END:
print("\n[处理完成]")
asyncio.run(main())五、深入理解：Agent 的工作流程
5.1 Agent 的生命周期
当你调用 agent.reply() 或 agent.reply_stream() 时，Agent 会经历以下阶段：
┌─────────────────────────────────────────────────────────────┐
│ Agent 生命周期 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 接收输入 │
│ │ │
│ ▼ │
│ 2. 准备上下文 │
│ │ - 加载系统提示词 │
│ │ - 加载对话历史 │
│ │ - 加载工具定义 │
│ ▼ │
│ 3. 推理循环 (ReAct Loop) │
│ │ │
│ │ ┌────────────────────────────────┐ │
│ │ │ a. 调用模型 │ │
│ │ │ b. 解析模型输出 │ │
│ │ │ c. 如果需要调用工具 → 执行工具 │ │
│ │ │ d. 如果任务完成 → 生成回复 │ │
│ │ │ e. 否则 → 继续推理循环 │ │
│ │ └────────────────────────────────┘ │
│ │ │
│ ▼ │
│ 4. 生成最终回复 │
│ │ │
│ ▼ │
│ 5. 更新状态 │
│ - 保存对话历史 │
│ - 更新记忆 │
│ │
└─────────────────────────────────────────────────────────────┘5.2 ReAct 配置
你可以通过 ReActConfig 来配置 Agent 的推理-行动循环：
from agentscope.agent import Agent, ReActConfig
react_config = ReActConfig(
max_iters=10, # 最大迭代次数
verbose=True, # 是否输出详细日志
)
agent = Agent(
name="助手",
system_prompt="...",
model=model,
react_config=react_config,
)5.3 上下文压缩
当对话历史过长时，AgentScope 可以自动压缩上下文，避免超出模型的上下文长度限制：
from agentscope.agent import Agent, ContextConfig
context_config = ContextConfig(
trigger_ratio=0.8, # 当上下文达到模型容量的 80% 时触发压缩
reserve_ratio=0.2, # 保留 20% 的最近对话
compression_prompt="请总结以下对话的关键信息：",
)
agent = Agent(
name="助手",
system_prompt="...",
model=model,
context_config=context_config,
)
# 手动触发压缩
await agent.compress_context()（上篇完，请继续阅读下篇）
下篇将涵盖：
- 多 Agent 协作：消息中心（MsgHub）
- 工具开发详解
- 权限控制与安全
- 生产部署：Agent Service
- 最佳实践与常见问题
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
1
0- 0
已为社区贡献32条内容
所有评论(0)