工程方法论 | 超越Prompt工程的下一层抽象—## 为什么Prompt工程不够用了2026年“Prompt工程这个词已经开始显得有点过时——不是因为提示词不重要而是因为我们遇到的问题已经远比怎么写好一句话复杂得多。真实的AI应用挑战往往是- Agent执行多步骤任务时中途忘了早期的指令- 同一个Prompt在不同上下文下效果差异巨大- 上下文窗口用完了但任务还没完成- 不同来源的信息塞进同一个上下文互相污染这些问题的根本不是Prompt写得不好而是上下文管理出了问题。Context Engineering上下文工程就是专门解决这类问题的工程学科系统化地设计、构建、维护和优化发送给LLM的上下文。—## 上下文的构成要素一个完整的LLM上下文包含以下要素┌──────────────────────────────────────────────┐│ 上下文窗口 │├──────────────────────────────────────────────┤│ System Prompt (系统指令) ││ - 角色定义 ││ - 行为约束 ││ - 输出格式要求 │├──────────────────────────────────────────────┤│ Retrieved Context (检索上下文) ││ - RAG检索结果 ││ - 相关文档 ││ - 工具执行结果 │├──────────────────────────────────────────────┤│ Conversation History (对话历史) ││ - 之前轮次的问题与回答 ││ - 已完成的步骤 │├──────────────────────────────────────────────┤│ Current Input (当前输入) ││ - 用户消息 ││ - 当前任务描述 │└──────────────────────────────────────────────┘每个要素都有其优化空间Context Engineering就是系统化地优化整体。—## 核心技术一上下文压缩当可用信息超过窗口限制时需要智能压缩### 方案A摘要压缩pythonclass ContextCompressor: 上下文压缩器 def __init__(self, llm_client, target_tokens: int 2000): self.llm llm_client self.target_tokens target_tokens async def compress_documents( self, query: str, documents: list[str], ) - str: 将多个文档压缩为与查询相关的摘要 combined \n\n---\n\n.join(documents) response await self.llm.chat.completions.create( modelgpt-4o-mini, # 用cheap model做压缩 messages[{ role: user, content: f请提取以下文档中与问题{query}最相关的信息压缩为简洁的上下文约{self.target_tokens // 4}字保留关键数据、结论和具体细节去除重复和不相关内容{combined}直接输出压缩后的内容不需要解释。 }] ) return response.choices[0].message.content async def compress_history( self, history: list[dict], keep_recent: int 5 ) - tuple[str, list[dict]]: 压缩对话历史摘要旧对话 保留近期对话 if len(history) keep_recent * 2: return , history old_history history[:-keep_recent * 2] recent_history history[-keep_recent * 2:] # 压缩旧对话 formatted_old \n.join([ f{msg[role]}: {msg[content]} for msg in old_history ]) response await self.llm.chat.completions.create( modelgpt-4o-mini, messages[{ role: user, content: f将以下对话历史压缩为简洁摘要保留关键决策、用户偏好和重要信息{formatted_old}用[对话摘要]开头简洁陈述关键内容。 }] ) summary response.choices[0].message.content return summary, recent_history### 方案B选择性截断Selective Pruningpythonclass ContextPruner: 基于相关性的上下文裁剪 def __init__(self, embedding_model): self.embed embedding_model async def prune_documents( self, query: str, chunks: list[dict], max_tokens: int 4000, min_relevance: float 0.6 ) - list[dict]: 裁剪不相关的文档块 # 计算每个块与查询的相关性 query_embedding await self.embed(query) scored_chunks [] for chunk in chunks: chunk_embedding await self.embed(chunk[text]) similarity cosine_similarity(query_embedding, chunk_embedding) scored_chunks.append((similarity, chunk)) # 按相关性排序过滤低于阈值的 scored_chunks.sort(keylambda x: x[0], reverseTrue) selected [] total_tokens 0 for score, chunk in scored_chunks: if score min_relevance: break chunk_tokens len(chunk[text]) // 4 # 粗略估算 if total_tokens chunk_tokens max_tokens: break selected.append(chunk) total_tokens chunk_tokens return selected—## 核心技术二上下文注入策略不同类型的信息有最优的注入位置pythonclass ContextBuilder: 结构化上下文构建器 def build_system_prompt( self, role: str, constraints: list[str], output_format: str None, examples: list[dict] None ) - str: 构建系统提示词 parts [f# 角色\n{role}] if constraints: parts.append(# 行为约束\n \n.join(f- {c} for c in constraints)) if output_format: parts.append(f# 输出格式\n{output_format}) if examples: example_text \n\n.join([ f示例{i1}\n输入{e[input]}\n输出{e[output]} for i, e in enumerate(examples) ]) parts.append(f# 示例\n{example_text}) return \n\n.join(parts) def build_rag_context( self, retrieved_docs: list[dict], query: str ) - str: 格式化RAG检索结果 if not retrieved_docs: return context_parts [# 参考资料\n以下是与问题相关的参考信息\n] for i, doc in enumerate(retrieved_docs, 1): source doc.get(source, 未知来源) text doc.get(text, ) context_parts.append(f[资料{i}] 来源{source}\n{text}) context_parts.append( \n请基于以上参考资料回答问题。 如果资料中没有相关信息请明确说明。 ) return \n\n.join(context_parts) def assemble_messages( self, system_prompt: str, rag_context: str, history_summary: str, recent_history: list[dict], current_query: str ) - list[dict]: 组装完整的messages列表 messages [] # 系统提示词 system_content system_prompt if rag_context: system_content f\n\n{rag_context} if history_summary: system_content f\n\n# 之前对话摘要\n{history_summary} messages.append({role: system, content: system_content}) # 对话历史 messages.extend(recent_history) # 当前查询 messages.append({role: user, content: current_query}) return messages—## 核心技术三上下文隔离当多个任务共享同一个Agent时需要隔离不同任务的上下文防止污染”pythonclass IsolatedContextManager: 上下文隔离管理器 def __init__(self): self._contexts: dict[str, list] {} self._metadata: dict[str, dict] {} def create_context(self, context_id: str, metadata: dict None) - str: 创建新的隔离上下文 self._contexts[context_id] [] self._metadata[context_id] metadata or {} return context_id def add_message(self, context_id: str, role: str, content: str): 向特定上下文添加消息 if context_id not in self._contexts: raise ValueError(f上下文 {context_id} 不存在) self._contexts[context_id].append({ role: role, content: content, timestamp: datetime.now().isoformat() }) def get_messages(self, context_id: str, include_metadata_as_system: bool True) - list[dict]: 获取特定上下文的消息列表 messages [] if include_metadata_as_system and self._metadata.get(context_id): meta self._metadata[context_id] system_parts [] if task in meta: system_parts.append(f当前任务{meta[task]}) if constraints in meta: system_parts.append(约束 .join(meta[constraints])) if system_parts: messages.append({ role: system, content: \n.join(system_parts) }) messages.extend([ {role: m[role], content: m[content]} for m in self._contexts[context_id] ]) return messages def fork_context(self, parent_id: str, child_id: str): 从父上下文创建子上下文共享历史但独立发展 parent_messages self._contexts.get(parent_id, []).copy() self._contexts[child_id] parent_messages self._metadata[child_id] self._metadata.get(parent_id, {}).copy() def merge_context(self, source_id: str, target_id: str, summary_only: bool True): 将源上下文的结果合并到目标上下文 source_messages self._contexts.get(source_id, []) if summary_only: # 只合并摘要不合并完整历史 last_assistant_msg next( (m for m in reversed(source_messages) if m[role] assistant), None ) if last_assistant_msg: self.add_message( target_id, system, f[子任务结果] {last_assistant_msg[content]} ) else: self._contexts[target_id].extend(source_messages)—## 核心技术四动态上下文调度根据任务类型动态选择最优的上下文构建策略pythonfrom enum import Enumfrom typing import Protocolclass TaskType(Enum): SIMPLE_QA simple_qa # 简单问答 MULTI_STEP multi_step # 多步骤推理 CODE_GENERATION code # 代码生成 DOCUMENT_ANALYSIS doc_analysis # 文档分析 CREATIVE creative # 创意写作class ContextStrategy(Protocol): async def build(self, query: str, state: dict) - list[dict]: ...class ContextScheduler: 上下文调度器根据任务类型选择策略 def __init__(self, strategies: dict[TaskType, ContextStrategy]): self.strategies strategies self.classifier TaskClassifier() async def build_context(self, query: str, state: dict) - list[dict]: 自动识别任务类型并选择最优策略 task_type await self.classifier.classify(query) strategy self.strategies.get(task_type) if not strategy: strategy self.strategies[TaskType.SIMPLE_QA] # 默认策略 return await strategy.build(query, state)class TaskClassifier: 任务类型分类器 async def classify(self, query: str) - TaskType: 快速分类任务类型用小模型 # 基于规则的快速分类延迟更低 if any(kw in query for kw in [写代码, 实现, def , function]): return TaskType.CODE_GENERATION if any(kw in query for kw in [分析这篇, 总结文档, 提取]): return TaskType.DOCUMENT_ANALYSIS if ? not in query and not in query: return TaskType.CREATIVE # 复杂情况用LLM分类 return TaskType.SIMPLE_QA—## 上下文工程的评估指标| 指标 | 定义 | 测量方法 ||------|------|---------|| 上下文利用率 | 上下文中有多少内容真正影响了回答 | Attention分析/消融测试 || 指令遵从率 | 系统提示中的约束被遵守的比例 | 规则检查LLM评估 || 上下文污染率 | 不相关信息导致回答偏移的概率 | 对照实验 || 压缩信息保留率 | 压缩后关键信息的保留程度 | 关键点提取对比 |—## 总结Context Engineering是2026年AI工程师的核心技能之一。关键实践1.分层构建系统提示、检索上下文、对话历史、当前输入各司其职2.主动压缩超窗口时优先压缩而非截断保留信息密度3.按需注入不同任务类型使用不同的上下文策略4.严格隔离多任务场景下防止上下文污染5.持续度量建立上下文质量的评估指标体系把上下文当作系统工程来做而不是随意拼接字符串是AI应用走向成熟的标志。