1. 上下文工程：多代理系统的核心架构设计
在大语言模型（LLM）和代理（Agent）系统快速发展的今天，我们越来越清晰地认识到：决定一个代理系统成败的关键，往往不是模型本身的参数规模，而是如何有效地管理和组织上下文信息。就像人类在复杂任务中需要合理利用工作记忆和外部工具一样，AI代理也需要精心设计的上下文管理策略才能发挥最大效能。
我在过去两年参与构建了多个基于LLM的代理系统，从最初的简单问答机器人到复杂的多代理协作平台，深刻体会到上下文工程（Context Engineering）的重要性。一个典型的案例是，我们曾花费三周时间优化一个客服代理的提示词（prompt），但性能提升不到10%；而当我们重构了它的上下文管理策略后，问题解决率直接提升了45%。这种差距让我意识到，上下文工程才是构建生产级AI系统的关键技能。
2. 上下文工程的核心概念解析
2.1 从提示工程到上下文工程
早期的LLM应用主要依赖提示工程（Prompt Engineering）——通过精心设计的提示词来引导模型行为。但随着应用场景复杂化，特别是当系统需要处理多轮对话、工具调用和外部数据集成时，单纯依赖静态提示词就显得力不从心了。
上下文工程与提示工程的关键区别在于：
- 动态性：上下文需要根据对话状态、工具返回结果等实时调整
- 系统性：涉及记忆管理、工具调度、信息过滤等多个子系统协同
- 结构化：不同类型的信息（指令、示例、数据等）需要分层组织
2.2 上下文窗口的本质与限制
我们可以用计算机架构来类比理解上下文窗口：
- LLM核心：相当于CPU，负责信息处理
- 上下文窗口：相当于RAM，是模型的工作记忆区
- 外部存储：相当于硬盘，用于长期信息保存
当前主流模型的上下文窗口虽然已经扩展到128K甚至更多token，但仍然面临三个根本限制：
- 性能衰减：实验表明，模型对上下文中间位置信息的处理能力明显弱于开头和结尾
- 成本增长：计算复杂度通常与上下文长度呈平方关系（O(n²)）
- 干扰效应：无关信息过多会导致模型注意力分散
3. 上下文工程的四大核心策略
3.1 写入策略：构建代理的记忆系统
写入策略的核心是将关键信息持久化到上下文窗口之外，需要时再按需读取。这类似于人类使用笔记本记录重要事项的方式。
典型实现方案：
python复制class AgentMemory:
def __init__(self):
self.short_term = {} # 会话内记忆
self.long_term = VectorStore() # 长期记忆存储
def write(self, key, value, ttl=None):
if ttl: # 短期记忆
self.short_term[key] = (value, time.time() + ttl)
else: # 长期记忆
self.long_term.add_document(key, value)
def read(self, query, n=3):
# 先从短期记忆查找
results = []
for k, (v, exp) in self.short_term.items():
if exp > time.time() and query in k:
results.append(v)
# 长期记忆检索
results.extend(self.long_term.search(query, k=n))
return results
实践经验：
- 为不同记忆类型设置合理的TTL（Time-To-Live）
- 高频访问的信息应缓存在短期记忆中
- 定期对长期记忆进行去重和摘要
3.2 选择策略：精准的信息检索机制
选择策略决定了哪些信息应该被加载到当前上下文中。好的选择机制应该像专业的图书管理员，能快速找到最相关的参考资料。
信息检索的三种主要方式：
-
基于关键词的检索：适合结构化数据
python复制def keyword_search(query, docs): return [d for d in docs if query.lower() in d.lower()] -
向量语义检索：适合非结构化文本
python复制from sentence_transformers import SentenceTransformer encoder = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2') def vector_search(query, docs, top_k=3): q_emb = encoder.encode(query) doc_emb = encoder.encode(docs) scores = q_emb @ doc_emb.T return np.argsort(scores)[-top_k:] -
混合检索：结合两者优势
python复制def hybrid_search(query, docs, alpha=0.7): key_results = keyword_search(query, docs) vec_results = vector_search(query, docs) # 加权融合 return sorted(list(set(key_results + vec_results)), key=lambda x: alpha*x[1] + (1-alpha)*x[2])
性能对比（实测数据）：
| 检索方式 | 准确率 | 延迟(ms) | 适合场景 |
|---|---|---|---|
| 关键词 | 58% | 12 | 结构化数据 |
| 向量 | 72% | 85 | 非结构化文本 |
| 混合 | 81% | 63 | 综合场景 |
3.3 压缩策略：信息的精炼与提纯
当必须使用长上下文时，压缩策略可以帮助我们保留关键信息。常见的压缩技术包括：
摘要压缩示例：
python复制from transformers import pipeline
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
def summarize_text(text, max_length=150):
if len(text.split()) < 100: # 过短不压缩
return text
return summarizer(text, max_length=max_length, min_length=30, do_sample=False)[0]['summary_text']
结构化修剪技术：
- 基于重要性的句子级修剪
- 对话历史的回合筛选
- 工具响应的字段提取
重要提示：压缩过程会丢失信息，建议保留原始数据的存储位置，以便需要时重新检索。
3.4 隔离策略：上下文的模块化管理
对于复杂任务，将不同功能的上下文隔离在不同模块中可以有效降低复杂度。常见的隔离模式包括：
-
流水线隔离：
mermaid复制graph LR A[输入解析] --> B[信息检索] B --> C[工具调用] C --> D[响应生成] -
多代理隔离：
python复制class SpecialistAgent: def __init__(self, role, tools): self.role = role self.tools = tools self.memory = AgentMemory() def run(self, task): # 只加载与角色相关的上下文 context = self.memory.read(f"{self.role} {task}") return generate_response(context, task) -
沙盒隔离：
python复制def safe_execute(code): # 在受限环境中执行代码 restricted_globals = {'__builtins__': None} local_vars = {} try: exec(code, restricted_globals, local_vars) return local_vars.get('result', None) except Exception as e: return f"Error: {str(e)}"
4. 多代理系统的上下文架构设计
4.1 单代理 vs 多代理的权衡
根据我们的实践经验，决策时应考虑以下因素：
| 考虑因素 | 单代理方案 | 多代理方案 |
|---|---|---|
| 开发复杂度 | 低 | 高 |
| 上下文管理 | 集中式 | 分布式 |
| 计算成本 | 通常较低 | 可能高3-15倍 |
| 任务并行性 | 有限 | 优秀 |
| 协调难度 | 无 | 需要额外机制 |
| 适合场景 | 线性任务 | 可并行子任务 |
4.2 多代理上下文设计模式
模式1：主从架构
python复制class MasterAgent:
def delegate(self, task):
# 任务分解
subtasks = self.analyze(task)
# 创建 specialist agents
workers = [SpecialistAgent(t) for t in subtasks]
# 并行执行
results = parallel_execute(workers)
# 结果整合
return self.synthesize(results)
模式2：民主议会架构
python复制class Parliament:
def discuss(self, topic):
agents = [Researcher(), Analyst(), Critic()]
context = SharedMemory(topic)
for round in range(3): # 讨论轮次
for agent in agents:
agent.contribute(context)
return context.consensus()
模式3：黑板架构
python复制class Blackboard:
def __init__(self):
self.state = {}
self.subscribers = []
def update(self, key, value):
self.state[key] = value
for sub in self.subscribers:
sub.notify(key, value)
class KnowledgeWorker:
def __init__(self, bb):
self.blackboard = bb
bb.subscribe(self)
def notify(self, key, value):
if key in self.expertise:
self.process(value)
4.3 多代理系统的上下文同步
实现高效同步的关键技术：
-
增量式更新：
python复制def sync_context(agent, updates): current = agent.get_context() diff = compute_diff(current, updates) if diff.size < 0.5 * current.size: # 只同步差异部分 agent.apply_diff(diff) -
版本控制：
python复制class VersionedContext: def __init__(self): self.versions = [] self.current = {} def commit(self, changes): self.versions.append(self.current.copy()) self.current.update(changes) def rollback(self, steps=1): if len(self.versions) >= steps: self.current = self.versions[-steps].copy() self.versions = self.versions[:-steps] -
冲突解决策略：
- 时间戳优先
- 角色优先级
- 人工干预机制
5. 上下文工程的实践案例
5.1 案例1：智能客服系统的上下文优化
问题场景：
- 客户问题涉及多步骤处理
- 需要查询多个后端系统
- 对话可能持续多轮
解决方案架构：
code复制Context Manager
├── Session State
├── Conversation History (压缩版)
├── User Profile
├── Product DB Cache
└── API Call Results
性能提升：
- 平均响应时间减少40%
- 问题解决率从58%提升至82%
- 上下文token用量降低35%
5.2 案例2：数据分析代理的多代理实现
系统组成：
- Parser Agent：理解用户需求
- DataFetcher：从数据库获取数据
- Analyst：执行分析任务
- Visualizer：生成图表
上下文流设计：
- 用户请求首先由Parser处理，生成结构化查询
- 查询被分发到DataFetcher，结果存入共享上下文
- Analyst从上下文中读取数据，执行分析
- Visualizer获取分析结果，生成可视化
关键优化点：
- 为每个代理设置上下文过滤器
- 分析中间结果采用二进制格式存储
- 最终展示时才转换为自然语言
6. 上下文工程的工具与框架
6.1 LangChain的核心功能解析
上下文管理组件：
python复制from langchain.memory import (
ConversationBufferMemory,
VectorStoreRetrieverMemory,
CombinedMemory
)
# 构建复合记忆系统
memory = CombinedMemory(memories=[
ConversationBufferMemory(
memory_key="chat_history",
input_key="human_input"
),
VectorStoreRetrieverMemory(
retriever=vectorstore.as_retriever(),
memory_key="doc_memory"
)
])
使用模式：
python复制from langchain.agents import AgentExecutor
from langchain.agents import Tool
tools = [
Tool(
name="Search",
func=search_tool,
description="用于搜索最新信息"
)
]
agent = AgentExecutor.from_agent_and_tools(
agent=llm_agent,
tools=tools,
memory=memory,
verbose=True
)
6.2 自定义上下文处理管道
典型处理流程：
python复制def context_pipeline(user_input, context):
# 步骤1：上下文清理
cleaned = clean_context(context)
# 步骤2：信息检索增强
retrieved = retrieve_relevant_info(user_input, cleaned)
# 步骤3：动态提示构建
prompt = build_dynamic_prompt(
user_input,
context=retrieved,
examples=get_few_shot_examples(user_input)
)
# 步骤4：响应生成
response = generate_with_llm(prompt)
# 步骤5：上下文更新
update_context(context, {
'last_input': user_input,
'last_response': response,
'retrieved_info': retrieved
})
return response
6.3 上下文监控与调试
关键监控指标：
- 上下文长度随时间变化
- 信息检索命中率
- 工具调用准确率
- 记忆存取频率
- 压缩率与信息损失
调试技巧：
- 保存关键步骤的上下文快照
- 可视化注意力模式
- 进行A/B测试不同策略
- 设置上下文回滚点
7. 上下文工程的未来发展方向
7.1 自适应上下文窗口
新兴的研究方向是让模型能够动态调整其"注意力窗口"的大小和位置，而不是固定地处理整个上下文。这类似于人类阅读时可以根据需要跳转到特定段落。
实验性实现：
python复制class AdaptiveAttention(nn.Module):
def __init__(self, model_dim, max_ctx):
super().__init__()
self.window = nn.Parameter(torch.ones(max_ctx))
self.offset = nn.Parameter(torch.zeros(1))
def forward(self, x):
# 计算动态窗口
window = torch.sigmoid(self.window)
offset = torch.sigmoid(self.offset) * len(x)
# 应用窗口化注意力
weights = self.compute_attention(x)
masked = weights * window.roll(offset.int().item())
return masked @ x
7.2 上下文感知的模型架构
新一代模型架构开始将上下文管理作为核心设计考量：
-
分层上下文处理：
- 本地上下文（最近几轮对话）
- 会话上下文（当前对话主题）
- 全局上下文（用户画像、产品知识等）
-
混合记忆系统：
python复制class HybridMemoryModel(nn.Module): def __init__(self): super().__init__() self.sensory = SensoryMemory() # 原始输入 self.working = WorkingMemory() # 当前处理 self.long_term = LongTermMemory() # 知识存储 def forward(self, x): # 信息处理流程 sensed = self.sensory(x) recalled = self.long_term.recall(sensed) processed = self.working.process(sensed + recalled) self.long_term.store(processed) return processed
7.3 上下文优化的新兴技术
-
神经缓存机制：
- 自动识别和缓存高频使用信息
- 实现亚线性时间复杂度的上下文访问
-
差分上下文编码：
- 只编码相对于之前上下文的变化部分
- 大幅减少冗余信息传输
-
基于内容的上下文路由：
python复制def route_context(query, contexts): # 计算内容相关性 scores = [similarity(query, ctx) for ctx in contexts] # 选择最相关的子集 return [c for _, c in sorted(zip(scores, contexts))[-3:]]
在构建生产级AI系统时，精心设计的上下文架构往往比单纯追求模型规模更能带来实质性的性能提升。随着技术的发展，上下文工程正在从一门艺术逐渐转变为可测量、可优化的工程学科。对于AI工程师来说，掌握这些上下文管理技术将成为构建可靠、高效代理系统的关键能力。