摘要
Context Engineering领域正在经历飞速发展！这篇文章带你看看最前沿的技术方向：从自动上下文管理、智能路由，到分层上下文架构，再到可能颠覆Transformer的新架构（Mamba、RWKV）。不管你是想了解趋势还是想走在技术前沿，这篇文章都能给你一些启发。
先聊聊：为什么Context Engineering这么火？
2025-2026年的技术背景
如果你在2023年问：“怎么让AI更好地理解上下文？” 大多数人的回答是：“调一调prompt呗”
但到了2025年，大家发现：
光调prompt不够了！上下文工程已经变成了一个系统性问题，需要架构级的解决方案。
原因很简单：
- 上下文窗口越来越大：从8K到1M token，但”中间丢失”问题依然存在
- 成本压力：上下文越长，费用越高，缓存和压缩成了刚需
- 多模态时代：文本、代码、图片、视频需要统一的上下文处理
- Agent时代：AI需要长期记忆、跨会话理解
Context Engineering已经从”调prompt的小技巧”变成了AI应用的核心基础设施。
一、Automatic Context Management（自动上下文管理）
ACM是什么？
传统方式下，上下文管理需要开发者手动设计：
用户 → 写prompt → 手动塞上下文 → LLM → 固定输出
ACM让这个过程自动化：
用户 → ACM系统自动决策 → LLM
│
├── 决定包含什么上下文？
├── 决定怎么组织？
├── 决定压缩多少？
└── 决定存到哪里？
ACM的核心思想
想象一个超级智能的秘书：
当你走进办公室：
秘书自动做了这些事情：
1. "你今天约了张总，先查查上次和张总的会议纪要"
2. "你要做Q3报告，先看看Q1、Q2的数据"
3. "哦对了，你之前说想了解AI趋势，我把最新的报告也找来了"
——这就是ACM想实现的效果！
ACM的实现架构
class AutomaticContextManager:
"""自动上下文管理器"""
def __init__(
self,
llm_client,
memory_store,
embedding_model
):
self.llm = llm_client
self.memory = memory_store
self.embedding = embedding_model
def manage_context(
self,
user_input: str,
session_id: str
) -> dict:
"""
自动管理上下文的核心逻辑
"""
# 1️⃣ 分析任务类型
task_analysis = self._analyze_task(user_input)
# 2️⃣ 决定策略
strategy = self._decide_strategy(task_analysis)
# 3️⃣ 收集相关上下文
contexts = self._collect_contexts(user_input, strategy)
# 4️⃣ 决定是否压缩
if self._needs_compression(contexts, strategy):
contexts = self._compress_contexts(contexts, strategy)
# 5️⃣ 决定是否存储（记住这次对话）
if strategy.get('should_remember'):
self._store_in_memory(user_input, contexts, session_id)
return {
'contexts': contexts,
'strategy': strategy,
'task_type': task_analysis['type'],
'compression_applied': self._needs_compression(contexts, strategy)
}
def _analyze_task(self, user_input: str) -> dict:
"""分析任务类型和上下文需求"""
prompt = f"""分析以下用户输入，确定其任务类型和上下文需求。
输入：{user_input}
分析维度：
1. 任务类型：
- factual：事实查询
- creative：创意写作
- reasoning：逻辑推理
- conversation：日常对话
2. 上下文依赖度：高/中/低
3. 需要的历史深度：短期/中期/长期
4. 是否需要专业知识
请用JSON格式输出分析结果"""
result = self.llm.generate(prompt)
return json.loads(result)
def _decide_strategy(self, task_analysis: dict) -> dict:
"""根据任务类型决定处理策略"""
strategies = {
'factual': {
'context_window': 'focused', # 聚焦在相关事实上
'compression': 'aggressive', # 可以激进压缩
'should_remember': True, # 记住事实
'retrieval_weight': 0.8 # 检索权重高
},
'creative': {
'context_window': 'broad', # 更宽泛的上下文
'compression': 'light', # 轻度压缩
'should_remember': False, # 不需要记忆
'retrieval_weight': 0.3
},
'reasoning': {
'context_window': 'complete', # 需要完整上下文
'compression': 'minimal', # 最小压缩
'should_remember': True,
'retrieval_weight': 0.5
},
'conversation': {
'context_window': 'recent', # 最近对话
'compression': 'moderate', # 中等压缩
'should_remember': True,
'retrieval_weight': 0.2
}
}
task_type = task_analysis.get('type', 'conversation')
return strategies.get(task_type, strategies['conversation'])自适应压缩：根据任务调整压缩程度
class AdaptiveCompressor:
"""自适应压缩器"""
def __init__(self, llm_client):
self.llm = llm_client
# 不同的压缩级别
self.compression_models = {
'light': LightCompressor(), # 保留80%内容
'moderate': ModerateCompressor(), # 保留50%内容
'aggressive': AggressiveCompressor() # 保留20%内容
}
def compress_adaptive(
self,
contexts: list,
task_type: str,
available_tokens: int
) -> list:
"""
根据任务类型自适应压缩
"""
# 选择压缩级别
compression_map = {
'factual': 'aggressive', # 事实查询可以激进压缩
'reasoning': 'light', # 推理需要轻度压缩
'creative': 'light',
'conversation': 'moderate'
}
compression_level = compression_map.get(task_type, 'moderate')
compressor = self.compression_models[compression_level]
# 逐个压缩
compressed = []
for ctx in contexts:
ctx_tokens = self._estimate_tokens(ctx)
if ctx_tokens <= available_tokens:
compressed.append(ctx) # 不需要压缩
else:
target_ratio = available_tokens / ctx_tokens
compressed.append(compressor.compress(ctx, target_ratio))
return compressed二、Context Routing（上下文路由）
Context Routing是什么？
Context Routing的灵感来自网络路由——
在网络中，数据包会根据目的地自动选择最佳路径。
在Context Routing中，上下文会根据其类型和内容自动选择最佳处理路径。
路由的基本概念
┌─────────────────────────────────────────────────────────┐
│ Context Router │
├─────────────────────────────────────────────────────────┤
│ │
│ 收到内容 → 分析类型 → 选择路由 │
│ │ │
│ ┌─────────┼─────────┬──────────┐ │
│ ↓ ↓ ↓ ↓ │
│ [事实类] [个人类] [会话类] [系统类] │
│ │ │ │ │ │
│ 知识库 用户画像 短期窗口 指令处理 │
│ 检索 存储 缓存 直接使用 │
│ │
└─────────────────────────────────────────────────────────┘
路由器的实现
class ContextRouter:
"""上下文路由器"""
def __init__(self):
# 定义路由规则
self.routing_rules = {
'factual': {
'path': 'retrieval', # 知识库检索
'compression': 'high',
'storage': 'knowledge_base'
},
'personal': {
'path': 'memory', # 个人记忆
'compression': 'low',
'storage': 'user_profile'
},
'session': {
'path': 'window', # 短期窗口
'compression': 'minimal',
'storage': 'session_cache'
},
'system': {
'path': 'instruction', # 指令处理
'compression': 'none',
'storage': 'system_prompt'
}
}
def route(self, content: str, content_type: str = None) -> dict:
"""路由内容"""
# 自动检测内容类型
if content_type is None:
content_type = self._detect_content_type(content)
routing = self.routing_rules.get(
content_type,
self.routing_rules['session']
)
return {
'content': content,
'type': content_type,
'path': routing['path'],
'compression': routing['compression'],
'storage': routing['storage']
}
def _detect_content_type(self, content: str) -> str:
"""自动检测内容类型"""
# 简单规则
if any(kw in content for kw in ['记住', '我的名字', '偏好', '我喜欢']):
return 'personal'
elif any(kw in content for kw in ['什么是', '定义', '如何', '哪个']):
return 'factual'
elif '你是一个' in content or '你应当' in content:
return 'system'
else:
return 'session'动态上下文选择
class DynamicContextSelector:
"""动态上下文选择器"""
def __init__(
self,
embedding_model,
attention_scorer
):
self.embedding = embedding_model
self.attention_scorer = attention_scorer
def select(
self,
query: str,
candidates: list,
budget_tokens: int,
strategy: str = "weighted"
) -> list:
"""
动态选择上下文
strategy:
- 'greedy': 贪心选择最高相关的
- 'weighted': 考虑相关性和重要性
- 'diverse': 确保多样性
"""
if strategy == "greedy":
return self._greedy_select(query, candidates, budget_tokens)
elif strategy == "weighted":
return self._weighted_select(query, candidates, budget_tokens)
else:
return self._diverse_select(query, candidates, budget_tokens)
def _greedy_select(
self,
query: str,
candidates: list,
budget_tokens: int
) -> list:
"""贪心选择：只选最相关的"""
query_emb = self.embedding.encode(query)
# 按相关性排序
scored = []
for c in candidates:
c_emb = self.embedding.encode(c['content'])
score = self._cosine_similarity(query_emb, c_emb)
scored.append((score, c))
scored.sort(key=lambda x: x[0], reverse=True)
# 贪心选择
selected = []
current_tokens = 0
for score, c in scored:
c_tokens = c.get('token_count', self._estimate_tokens(c['content']))
if current_tokens + c_tokens <= budget_tokens:
selected.append(c)
current_tokens += c_tokens
return selected
def _diverse_select(
self,
query: str,
candidates: list,
budget_tokens: int
) -> list:
"""
多样性选择：不仅看相关性，还看多样性
避免选到一堆相似的内容
"""
query_emb = self.embedding.encode(query)
# 先按相关性排序
scored = []
for c in candidates:
relevance = self._cosine_similarity(
query_emb,
self.embedding.encode(c['content'])
)
scored.append((relevance, c))
scored.sort(key=lambda x: x[0], reverse=True)
top_k = scored[:min(20, len(scored))] # 取top 20
# 多样性选择
selected = []
current_tokens = 0
for relevance, c in top_k:
c_tokens = c.get('token_count', self._estimate_tokens(c['content']))
if current_tokens + c_tokens > budget_tokens:
continue
# 检查与已选内容的多样性
is_diverse = True
for s in selected:
sim = self._cosine_similarity(
self.embedding.encode(c['content']),
self.embedding.encode(s['content'])
)
if sim > 0.9: # 太相似了，跳过
is_diverse = False
break
if is_diverse or len(selected) < 3: # 至少选3个
selected.append(c)
current_tokens += c_tokens
return selected
@staticmethod
def _cosine_similarity(a, b):
dot = sum(x * y for x, y in zip(a, b))
norm_a = sum(x * x for x in a) ** 0.5
norm_b = sum(x * x for x in b) ** 0.5
return dot / (norm_a * norm_b + 1e-8)三、Hierarchical Context（分层上下文）
为什么要分层？
想象人脑的记忆系统：
短期记忆：当前正在想的事情（容量有限，7±2个信息块）
中期记忆：最近发生的事（容量中等）
长期记忆：过去的经历、常识（容量无限）
LLM也需要类似的分层机制来高效管理上下文。
分层架构设计
┌─────────────────────────────────────────────────────────────┐
│ 分层上下文架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ L3: 全局层 (Global) │
│ 包含： │
│ - 跨会话的领域知识 │
│ - 用户的长期偏好 │
│ - 通用常识和背景 │
│ 示例："用户是Python开发者，喜欢简洁的代码风格" │
│ │
│ L2: 会话层 (Session) │
│ 包含： │
│ - 当前会话的历史对话 │
│ - 进行中的任务上下文 │
│ - 临时的重要信息 │
│ 示例："用户正在实现用户登录功能，目前遇到token过期问题" │
│ │
│ L1: 实时层 (Real-time) │
│ 包含： │
│ - 当前用户的输入 │
│ - 活跃的思考焦点 │
│ - 即时需要的参考信息 │
│ │
└─────────────────────────────────────────────────────────────┘
分层上下文管理器实现
class HierarchicalContextManager:
"""分层上下文管理器"""
def __init__(self):
self.global_layer = GlobalContextStore() # 长期记忆
self.session_layer = SessionContextStore() # 会话记忆
self.realtime_layer = {} # 实时缓存
def get_context(
self,
query: str,
session_id: str,
config: dict = None
) -> str:
"""
获取分层上下文
可以指定要包含哪些层
"""
if config is None:
config = self._get_default_config()
context_parts = []
# 1. 实时层
if config.get('include_realtime', True):
realtime = self.realtime_layer.get(session_id, [])
context_parts.extend(realtime)
# 2. 会话层
if config.get('include_session', True):
session_context = self.session_layer.get(session_id)
if session_context:
context_parts.append(f"[会话上下文]\n{session_context}")
# 3. 全局层
if config.get('include_global', True):
global_context = self.global_layer.get_relevant(query)
if global_context:
context_parts.append(f"[用户背景]\n{global_context}")
return "\n\n".join(context_parts)
def update_context(
self,
session_id: str,
content: str,
layer: str = 'session'
):
"""更新指定层"""
if layer == 'session':
self.session_layer.add(session_id, content)
elif layer == 'global':
self.global_layer.add(content)
elif layer == 'realtime':
if session_id not in self.realtime_layer:
self.realtime_layer[session_id] = []
self.realtime_layer[session_id].append(content)
def _get_default_config(self) -> dict:
"""获取默认配置"""
return {
'include_realtime': True,
'include_session': True,
'include_global': True,
'max_tokens': {
'realtime': 2000,
'session': 8000,
'global': 5000
}
}四、Memory-Augmented LM（记忆增强语言模型）
从”鹦鹉”到”有记忆的朋友”
传统LLM像个金鱼——每次对话都是全新的开始：
用户：我是小明，我喜欢Python
AI：好的小明，很高兴认识你
用户：我的名字是什么？
AI：抱歉，我不知道
Memory-Augmented LM让AI有了”记忆”，能跨会话记住用户：
用户：我是小明，我喜欢Python
AI：好的小明，很高兴认识你！
用户：我的名字是什么？
AI：你叫小明，你还喜欢Python编程
记忆增强系统架构
class MemoryAugmentedLM:
"""记忆增强语言模型"""
def __init__(
self,
llm_client,
memory_store,
controller
):
self.llm = llm_client
self.memory = memory_store
self.controller = controller # 记忆控制器
def generate_with_memory(
self,
query: str,
session_id: str
) -> str:
"""带记忆的生成"""
# 1️⃣ 从记忆中检索相关内容
relevant_memories = self.memory.retrieve(query, session_id)
# 2️⃣ 决定读取哪些记忆
selected_memories = self.controller.select_read(
query,
relevant_memories
)
# 3️⃣ 构建提示
prompt = self._build_prompt(query, selected_memories)
# 4️⃣ 生成回复
response = self.llm.generate(prompt)
# 5️⃣ 决定是否写入新记忆
if self.controller.should_write(response, session_id):
self.memory.write(response, session_id)
return response
def _build_prompt(self, query: str, memories: list) -> str:
"""构建带记忆的提示"""
if not memories:
return query
memory_text = "\n".join([f"- {m['content']}" for m in memories])
return f"""[用户历史记忆]
{memory_text}
[当前问题]
{query}
请基于以上记忆回答问题。如果记忆中有相关信息，请结合使用。"""
def learn_from_feedback(
self,
query: str,
response: str,
feedback: dict,
session_id: str
):
"""从反馈中学习，更新记忆"""
# 更新记忆权重
self.memory.update_weights(
query,
response,
feedback,
session_id
)
# 如果反馈负面，修正相关记忆
if feedback.get('rating', 0) < 3: # 假设1-5分
self._revise_memory(query, response, feedback, session_id)神经记忆模块
class NeuralMemoryModule:
"""
神经记忆模块
模拟人脑记忆的：写入、读取、强化、遗忘
"""
def __init__(self, embedding_dim: int = 768):
self.embedding_dim = embedding_dim
self.memory_keys = [] # 记忆的key向量
self.memory_values = [] # 记忆的内容
self.memory_strengths = [] # 记忆强度（用得越多越强）
def write(
self,
key: str,
value: str,
strength: float = 1.0
):
"""写入记忆"""
self.memory_keys.append(key)
self.memory_values.append(value)
self.memory_strengths.append(strength)
def read(self, query: str, top_k: int = 5) -> list:
"""读取相关记忆"""
results = []
for i, key in enumerate(self.memory_keys):
# 简单的关键词匹配（实际可用向量相似度）
overlap = len(set(key.split()) & set(query.split()))
if overlap > 0:
results.append({
'content': self.memory_values[i],
'strength': self.memory_strengths[i],
'relevance': overlap / len(key.split())
})
# 按 记忆强度 × 相关性 排序
results.sort(key=lambda x: x['strength'] * x['relevance'], reverse=True)
return results[:top_k]
def update_strength(self, index: int, delta: float):
"""更新记忆强度"""
if 0 <= index < len(self.memory_strengths):
self.memory_strengths[index] += delta
# 限制范围：0.1 ~ 2.0
self.memory_strengths[index] = max(0.1, min(2.0,
self.memory_strengths[index]))五、State Space Models（状态空间模型）
SSM是什么？为什么要了解它？
Transformer统治AI江湖已经7年了，但它的致命弱点是：
O(n²)的时间复杂度 —— 序列越长，计算量爆炸式增长
State Space Models（SSM）提供了一种新思路：O(n)的线性复杂度！
| 指标 | Transformer | SSM |
|---|---|---|
| 时间复杂度 | O(n²) | O(n) |
| 空间复杂度 | O(n²) | O(n) |
| 1000长度 | 1,000,000次计算 | 1,000次计算 |
| 10000长度 | 100,000,000次计算 | 10,000次计算 |
SSM的基本原理
状态空间模型来自控制系统理论：
┌──────────────────────────────────────────────────────────┐
│ 状态空间模型 │
├──────────────────────────────────────────────────────────┤
│ │
│ 输入 u(t) ──→ [ 状态更新 ] ──→ 输出 y(t) │
│ │ │
│ ↓ │
│ 状态 x(t) │
│ │
│ 核心方程： │
│ x(t+1) = Ax(t) + Bu(t) ← 状态转移 │
│ y(t) = Cx(t) + Du(t) ← 输出计算 │
│ │
│ 其中： │
│ - A: 状态转移矩阵 │
│ - B: 输入矩阵 │
│ - C: 输出矩阵 │
│ - D: 直连矩阵 │
│ │
└──────────────────────────────────────────────────────────┘
Mamba：选择性状态空间模型
Mamba是2023-2024年最火热的SSM架构，核心创新是选择性机制：
class MambaBlock:
"""
Mamba的核心思想
传统SSM：A、B、C矩阵是固定的
Mamba：A、B、C矩阵由输入决定（选择性）
这样模型可以"选择"关注哪些信息，忽略哪些
"""
def __init__(
self,
d_model: int,
d_state: int = 16,
d_conv: int = 4,
expand: int = 2
):
self.d_model = d_model
self.d_state = d_state
d_inner = d_model * expand
# 投影层
self.in_proj = nn.Linear(d_model, d_inner * 2)
# SSM参数投影（这是关键！）
# 传统SSM这些是固定参数
# Mamba中，这些由输入决定
self.x_proj = nn.Linear(d_inner, d_state * 2 + 1)
self.dt_proj = nn.Linear(d_state, d_inner)
# A矩阵初始化
self.A_log = nn.Parameter(torch.randn(d_state, d_model))
def forward(self, x: torch.Tensor) -> torch.Tensor:
"""Mamba前向传播"""
batch, seq_len, d = x.shape
# 输入投影
xz = self.in_proj(x)
x_inner, z = xz.chunk(2, dim=-1)
# 卷积处理局部信息
x_conv = self.conv(x_inner.transpose(1, 2)).transpose(1, 2)
x_conv = F.silu(x_conv)
# 🔥 关键：SSM参数由输入决定（选择性）
x_dbl = self.x_proj(x_conv)
dt, B, C = x_dbl.split([self.d_state, self.d_state, self.d_state], dim=-1)
dt = self.dt_proj(dt)
# 选择性扫描
y = self.selective_scan(x_conv, dt, self.A_log, B, C, z)
# 门控
y = y * F.silu(z)
return self.out_proj(y)RWKV：循环Transformer
RWKV（Receptance Weighted Key Value）是个有趣的混合架构：
结合了RNN的线性复杂度和Transformer的强大能力
class RWKVBlock:
"""
RWKV核心特性
1. 线性注意力（O(n)复杂度）
2. 可以并行训练（不像传统RNN）
3. 高效推理
4. 保持长期依赖
核心公式：
wkv = Σ_i( exp(-(i-t+1)*decay) * value_i ) / Σ_i( exp(-(i-t+1)*decay) )
rwkv = sigmoid(receptance) * wkv
"""
def __init__(self, d_model: int):
self.d_model = d_model
# 时间衰减参数
self.time_decay = nn.Parameter(torch.zeros(d_model))
self.time_first = nn.Parameter(torch.zeros(d_model))
# 投影
self.key = nn.Linear(d_model, d_model)
self.value = nn.Linear(d_model, d_model)
self.receptance = nn.Linear(d_model, d_model)
self.output = nn.Linear(d_model, d_model)
def forward(self, x: torch.Tensor, state=None) -> tuple:
"""
RWKV前向传播
相比Transformer：
- 不需要计算完整的注意力矩阵
- 用递归方式计算，O(n)复杂度
"""
B, T, C = x.shape
# 投影
k = self.key(x)
v = self.value(x)
r = torch.sigmoid(self.receptance(x))
# WKV计算（核心创新）
wkv = self._compute_wkv(k, v)
# 输出
rwkv = r * wkv
output = self.output(rwkv)
return output, None # 简化state处理SSM vs Transformer 对比
| 特性 | Transformer | SSM (Mamba/RWKV) |
|---|---|---|
| 时间复杂度 | O(n²) | O(n) |
| 空间复杂度 | O(n²) | O(n) |
| 100K序列 | 显存爆炸 | 轻松处理 |
| 长期依赖 | 受限于位置编码 | 自然保持 |
| 并行训练 | 完全并行 | 几乎完全并行 |
| 推理速度 | 慢 | 快 |
| 上下文学习 | 强 | 较弱（但增强中） |
| 硬件效率 | 中等 | 高 |
六、未来展望：1-5年趋势预测
短期趋势（1-2年）
-
上下文窗口继续扩大
- 百万token将成为主流
- 千万token可能出现
- 但”Lost in Middle”问题不会自动消失
-
更智能的压缩
- 基于语义理解而非规则
- 任务感知的自适应压缩
- 保留关键推理链
-
上下文缓存成为标配
- 硬件层面的缓存支持
- 自动识别可缓存内容
- 成本大幅下降
-
多模态统一上下文
- 文本、代码、图片、视频统一处理
- 跨模态的注意力机制
中期趋势（3-5年）
-
自适应上下文
- 模型自动学习最优上下文策略
- 不再需要手动设计
- 根据任务动态调整
-
外部记忆整合
- 像人脑一样的长期记忆
- 可学习的记忆系统
- 跨会话、跨设备同步
-
SSM与Transformer深度融合
- 结合两者优点
- 可能是下一代基础架构
长期愿景
┌─────────────────────────────────────────────────────────────┐
│ 理想上下文系统 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户意图 ──→ 智能理解 ──→ 最优上下文 ──→ 高效推理 │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ 长期记忆 短期窗口 │
│ │ │ │
│ ┌─────┴─────┐ ┌───┴───┐ │
│ │ │ │ │ │
│ 知识图谱 个人记忆 会话历史 实时信息 │
│ │
│ 特点：上下文像人脑一样自然、高效、个性化 │
│ │
└─────────────────────────────────────────────────────────────┘
一图总结
┌─────────────────────────────────────────────────────────────┐
│ Context Engineering 前沿技术全景图 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 🔮 自动上下文管理 (ACM) │
│ ├─ 任务分析 → 策略选择 → 自动执行 │
│ └─ 减少人工干预，智能适配 │
│ │
│ 🛤️ 上下文路由 (Routing) │
│ ├─ 事实类 → 知识库检索 │
│ ├─ 个人类 → 用户画像存储 │
│ └─ 会话类 → 短期窗口缓存 │
│ │
│ 🏗️ 分层上下文 (Hierarchical) │
│ ├─ 全局层：长期知识、用户偏好 │
│ ├─ 会话层：当前任务、历史对话 │
│ └─ 实时层：当前输入、活跃焦点 │
│ │
│ 🧠 记忆增强 (Memory-Augmented) │
│ ├─ 跨会话记住用户信息 │
│ ├─ 从反馈中学习 │
│ └─ 神经记忆模块 │
│ │
│ ⚡ 状态空间模型 (SSM) │
│ ├─ Mamba：选择性状态空间 │
│ ├─ RWKV：循环Transformer │
│ └─ O(n)复杂度 vs Transformer O(n²) │
│ │
│ 📈 未来趋势 │
│ ├─ 窗口继续扩大，但"Lost in Middle"仍需解决 │
│ ├─ 自适应上下文成为标配 │
│ └─ SSM可能颠覆Transformer │
│ │
└─────────────────────────────────────────────────────────────┘
相关主题
- 上下文窗口深度解析 - 窗口限制的核心问题
- 上下文压缩技术 - 压缩策略详解
- Long Context Model详解 - 长上下文模型技术
- 对话历史管理 - 会话层上下文处理
参考文献
- Gu, A., et al. (2021). Efficiently Modeling Long Sequences with Structured State Spaces. NeurIPS.
- Dao, T., et al. (2023). Hungry Hungry Hippos: Towards Language Modeling with State Space Models. ICLR.
- Peng, B., et al. (2023). RWKV: Reinventing RNNs for the Transformer Era. ACL.
- Liu, H., et al. (2024). Mixture-of-Experts Meets Instruction Tuning. arXiv.
- Anthropic (2024). Claude 3.5 System Card.
- Zhu, D., et al. (2024). State Space Models for Language Modeling: A Survey. arXiv.