AI 编程助手的记忆机制设计：从短期上下文到长期记忆的演进之路

// 上下文优先级评估示意
const contextPriority = {
  'error_stack': 1.0,        // 调试错误，最高优先级
  'recent_changes': 0.9,     // 最近修改的代码
  'cursor_position': 0.85,   // 光标周围代码
  'current_file': 0.8,       // 当前编辑文件
  'related_files': 0.6,      // 相关依赖文件
  'project_config': 0.4,     // 项目配置文件
};

# 会话记忆管理示意
class SessionMemory:
    def __init__(self, max_tokens: int = 64000):
        self.max_tokens = max_tokens
        self.conversation_history = []
        self.key_info_pool = []
        self.current_context_size = 0

    def add_turn(self, user_msg: str, assistant_msg: str):
        turn_tokens = self._estimate_tokens(user_msg + assistant_msg)

        # 语义压缩检查
        if self.current_context_size + turn_tokens > self.max_tokens * 0.8:
            self._semantic_compress()

        # 关键信息提取
        key_info = self._extract_key_info(user_msg, assistant_msg)
        if key_info:
            self.key_info_pool.append(key_info)

        self.conversation_history.append({
            'user': user_msg,
            'assistant': assistant_msg,
            'key_info': key_info
        })
        self.current_context_size += turn_tokens

    def get_context_for_inference(self) -> str:
        # 优先返回关键信息池
        key_context = '\n'.join(self.key_info_pool)
        # 再补充最近的对话
        recent = self._get_recent_turns(max_tokens=30000)
        return f"关键信息:\n{key_context}\n\n最近对话:\n{recent}"

# 长期记忆检索示意
class ProjectMemory:
    def __init__(self, embedding_model):
        self.embedding_model = embedding_model
        self.memory_store = {
            'metadata': [],      # 项目元信息
            'decisions': [],      # 技术决策
            'patterns': [],      # 代码模式
            'knowledge': []       # 领域知识
        }

    def retrieve(self, query: str, top_k: int = 5) -> List[MemoryEntry]:
        query_embedding = self.embedding_model.encode(query)

        results = []
        for category, entries in self.memory_store.items():
            for entry in entries:
                similarity = self._cosine_similarity(
                    query_embedding,
                    entry['embedding']
                )
                results.append((similarity, entry, category))

        # 合并多类别结果，按相似度排序
        results.sort(key=lambda x: x[0], reverse=True)
        return results[:top_k]

    def store_decision(self, title: str, context: str, decision: str, rationale: str):
        entry = {
            'title': title,
            'context': context,
            'decision': decision,
            'rationale': rationale,
            'embedding': self.embedding_model.encode(f"{context} {decision}"),
            'created_at': datetime.now()
        }
        self.memory_store['decisions'].append(entry)

# 上下文路由示意
class ContextRouter:
    def route(self, query: str, session: SessionMemory, project: ProjectMemory):
        query_embedding = self.embedding_model.encode(query)

        # 即时上下文是否足够？
        if self._can_answer_instant(query, session.current_context):
            return ContextSource.IMMEDIATE

        # 会话记忆是否有相关信息？
        session_relevant = session.search_similar(query, threshold=0.7)
        if session_relevant and self._confidence_sufficient(session_relevant):
            return ContextSource.SESSION

        # 是否需要项目级记忆？
        project_relevant = project.retrieve(query, top_k=3)
        if project_relevant and any(r[0] > 0.8 for r in project_relevant):
            return ContextSource.PROJECT

        # 混合模式：组合多个来源
        return ContextSource.HYBRID