运维Agent的记忆系统设计：短期工作记忆与长期知识库的协同架构与一致性保障

一、运维Agent为什么需要记忆系统

在AIOps的演进路径中，运维Agent正从简单的"告警响应机器人"走向具备持续学习和自主决策能力的智能化运维助手。这个过程的核心瓶颈不再是模型推理能力——GPT-4级别的大模型在理解告警内容和给出处置建议方面已经展现出足够的能力——而是记忆系统。一个没有记忆的Agent每一次交互都是"从零开始"，它记不住5分钟前刚分析过的同一个故障、记不住上个月类似场景的处理经验、记不住某个数据库实例的特殊配置参数。

运维场景对记忆系统有独特要求。首先，运维知识具有强时效性，一个昨天还能正常执行的操作手册今天可能因为配置变更而失效，这就要求记忆系统必须维护知识版本的时间戳和有效性判断。其次，运维操作具有高风险性，错误的内存信息可能导致Agent给出危险的处置建议，因此记忆系统需要保证信息的精确性和可信度。最后，运维Agent通常需要访问多个数据源——CMDB配置库、历史故障案例库、操作Runbook、实时监控指标——这些构成了一个多维异构的知识体系，需要统一的信息检索和一致性维护机制。

二、记忆系统的双层架构设计

我们将运维Agent的记忆系统设计为双层架构：短期工作记忆（Working Memory）负责当前故障诊断会话的上下文管理，长期知识库（Long-term Knowledge Base）负责持久化的结构化知识和经验积累。

graph TB
    subgraph Agent推理层
        A[运维Agent<br/>大模型推理引擎]
    end
    
    subgraph 短期工作记忆 Working Memory
        B1[当前会话上下文<br/>告警信息/诊断步骤/中间结论]
        B2[临时工具调用记录<br/>kubectl/PromQL/日志搜索结果]
        B3[会话状态向量<br/>Embedding表示当前上下文]
        B4[TTL自动过期<br/>会话结束30分钟后清除]
    end
    
    subgraph 信息检索层
        C[混合检索引擎<br/>Vector Search + BM25]
    end
    
    subgraph 长期知识库 Long-term Knowledge
        D1[历史故障案例库<br/>200+条结构化案例<br/>按故障类型/服务/组件索引]
        D2[运维知识图谱<br/>服务拓扑/配置依赖<br/>变更关联关系]
        D3[操作Runbook库<br/>200+个标准操作流程<br/>按服务/场景分类]
        D4[CMDB配置快照<br/>服务配置/中间件参数<br/>按时间版本管理]
    end
    
    subgraph 记忆写入管道
        E1[会话总结器<br/>故障诊断完成后<br/>自动生成案例摘要]
        E2[人工审核接口<br/>SRE审核后入库]
        E3[知识版本管理<br/>Git-based版本控制]
    end
    
    A <-->|实时读写| B1
    A <-->|检索增强| C
    B1 --> B2
    B1 --> B3
    C --> D1
    C --> D2
    C --> D3
    C --> D4
    B1 -->|会话结束后归档| E1
    E1 --> E2
    E2 --> E3
    E3 --> D1
    E3 --> D4
    B1 -.->|TTL过期| B4

短期工作记忆的设计类似于操作系统的虚拟内存——为Agent的当前诊断会话提供一个有限容量但高速可用的上下文空间。它包括三个组成部分：当前会话的告警信息和诊断步骤（类似进程的栈帧）、工具调用的返回结果缓存（类似TLB缓存）、以及通过向量化表示的多轮交互上下文（类似页表映射）。工作记忆严格限制在单个会话的生命周期内，会话结束后30分钟自动清除，防止不同故障之间的信息污染。

长期知识库的设计借鉴了向量数据库与关系型数据库的混合存储模式。历史故障案例存储在向量数据库中（如Milvus/PGVector），每条案例以结构化JSON格式保存，包含故障类型、涉及服务、根因分析、处理步骤、处理结果等字段。案例的文本内容通过Embedding模型向量化后存储，支持基于语义相似度的检索。运维知识图谱存储在图数据库中（如Neo4j），节点包括服务、中间件、配置项，边包括依赖关系、配置关联和变更影响关系。操作Runbook以Markdown格式存储在Git仓库中，实现版本追溯和协作审核。

三、记忆检索与一致性保障机制

当运维Agent接收到一条新的告警时，检索流程分为三个阶段。第一阶段是快速语义匹配：将告警标题、受影响的服务和异常指标进行向量化，在历史案例库中检索Top-5相似案例，作为Agent推理的参考资料。第二阶段是拓扑关联分析：从知识图谱中查询受影响服务的上下游依赖关系，判断是否有已知的故障传播路径。第三阶段是Runbook匹配：根据故障类型和服务名称检索对应的标准操作流程。

检索的精度依赖于Embedding模型的质量和索引策略。在运维场景中，通用的Embedding模型（如text-embedding-3-small）对技术术语的向量化表现往往不够精确。需要使用运维领域的语料（故障报告、RFC文档、操作手册）对Embedding模型进行微调，使"connection pool exhaustion"、"线程池耗尽"和"JDBC连接池满"被映射到相近的向量空间中。

一致性保障是记忆系统中最具挑战性的问题。当一位SRE对某个Runbook进行更新后，Agent的记忆检索必须能够获取最新版本的操作流程，而不能停留在旧版本的记忆中。解决方案是为每条知识维护一个版本号和时间戳字段，Agent在检索知识时除了返回内容外，还返回版本号和最后更新时间的元数据。Agent的推理引擎在生成处置建议时，需要标注所引用知识的版本号，如果知识版本过期（如超过24小时未更新且CMDB中的关联配置发生了变更），则降低该知识的置信度权重。

四、记忆写入与知识滚雪球效应

记忆系统的价值不仅在于检索，更在于持续的知识积累。当一个故障诊断会话完成后，记忆写入管道会自动触发以下流程：会话总结器提取诊断过程中的关键信息（原始告警、排查步骤、根因定位、处置操作、恢复时间），按照预定义的模板生成故障案例摘要。这份摘要进入人工审核队列，由当值SRE审核确认后正式入库。同时，如果诊断过程中发现了新的服务依赖关系或配置关联，这些信息会被更新到知识图谱中。

这个写入流程形成了一个正向的"知识滚雪球"效应——每处理一次故障，历史案例库就增加一条经过验证的案例，Agent在下次遇到相似问题时就能给出更精准的建议。统计显示，在运行3个月、积累200余条案例后，Agent在Top-3命中率（即Agent推荐的前3个根因中包含实际根因）从最初的31%提升至67%。这种持续改进的特性是传统Rule-based告警系统所无法比拟的。

"""
运维Agent记忆系统核心模块
实现工作记忆管理、知识检索和记忆写入
"""

import time
import hashlib
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, field
import numpy as np

@dataclass
class WorkingMemoryEntry:
    """工作记忆条目：当前诊断会话中的一条信息"""
    entry_id: str
    content: str
    entry_type: str  # alert/metric/log/tool_result/hypothesis
    timestamp: float = field(default_factory=time.time)
    relevance_score: float = 1.0
    ttl_seconds: int = 1800  # 30分钟过期

@dataclass
class KnowledgeEntry:
    """长期知识库条目"""
    entry_id: str
    knowledge_type: str  # case/runbook/graph_node/cmdb_config
    content: Dict[str, Any]
    embedding_vector: Optional[List[float]] = None
    version: int = 1
    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
    updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
    verified_by: Optional[str] = None
    confidence: float = 0.8

class MemorySystem:
    """运维Agent记忆系统主控制器"""
    
    def __init__(self, 
                 session_id: str,
                 vector_store_url: str = "http://milvus:19530",
                 graph_db_url: str = "bolt://neo4j:7687"):
        self.session_id = session_id
        self.vector_store_url = vector_store_url
        self.graph_db_url = graph_db_url
        
        # 工作记忆：会话级别的短期存储（内存中）
        self.working_memory: Dict[str, WorkingMemoryEntry] = {}
        
        # 工作记忆访问记录：追踪哪些记忆被频繁访问
        self.memory_access_count: Dict[str, int] = {}
        
        # 长期知识缓存：会话内避免重复检索
        self.knowledge_cache: Dict[str, KnowledgeEntry] = {}
        
        # Embedding模型客户端（用于文本向量化）
        self.embedder = self._init_embedder()
    
    def add_to_working_memory(self, 
                              content: str, 
                              entry_type: str) -> str:
        """向工作记忆中添加一条新信息"""
        # 生成唯一ID
        raw_key = f"{self.session_id}:{content[:50]}:{time.time()}"
        entry_id = hashlib.md5(raw_key.encode()).hexdigest()[:12]
        
        entry = WorkingMemoryEntry(
            entry_id=entry_id,
            content=content,
            entry_type=entry_type,
        )
        self.working_memory[entry_id] = entry
        
        # 自动清理过期条目
        self._cleanup_expired_entries()
        
        # 如果工作记忆过大（超过200条），清理低相关性条目
        if len(self.working_memory) > 200:
            self._evict_low_relevance(keep_top=100)
        
        return entry_id
    
    def retrieve_from_working_memory(self, 
                                     query: str, 
                                     top_k: int = 10) -> List[str]:
        """从工作记忆中检索相关条目（基于关键词匹配）"""
        query_terms = set(query.lower().split())
        
        scored_entries = []
        for entry_id, entry in self.working_memory.items():
            # 简单TF匹配得分
            content_lower = entry.content.lower()
            score = sum(1 for term in query_terms if term in content_lower)
            if score > 0:
                scored_entries.append((entry_id, score))
                self.memory_access_count[entry_id] = (
                    self.memory_access_count.get(entry_id, 0) + 1
                )
        
        # 按得分排序
        scored_entries.sort(key=lambda x: x[1], reverse=True)
        return [eid for eid, _ in scored_entries[:top_k]]
    
    def search_long_term_knowledge(self, 
                                   query: str, 
                                   knowledge_type: str = "case",
                                   top_k: int = 5) -> List[KnowledgeEntry]:
        """
        从长期知识库中检索相关知识
        
        Args:
            query: 检索查询文本（告警标题、故障描述等）
            knowledge_type: 知识类型过滤
            top_k: 返回Top-K结果
        """
        try:
            # 步骤1: 将查询文本向量化
            query_vector = self.embedder.encode(query)
            
            # 步骤2: 在Milvus向量数据库中执行ANN检索
            results = self._vector_search(
                collection_name=f"ops_knowledge_{knowledge_type}",
                query_vector=query_vector,
                top_k=top_k,
                # 过滤条件：置信度>0.6的已验证知识
                filter_expr="confidence > 0.6 and verified_by is not null"
            )
            
            # 步骤3: 验证知识的时效性
            validated_results = []
            for result in results:
                entry = KnowledgeEntry(**result["entity"])
                
                # 时效性检查：超过30天未更新的知识降低置信度
                updated_time = datetime.fromisoformat(entry.updated_at)
                days_stale = (datetime.now() - updated_time).days
                if days_stale > 30:
                    entry.confidence *= max(0.3, 1.0 - (days_stale - 30) * 0.01)
                
                # CMDB关联一致性检查
                if entry.knowledge_type == "cmdb_config":
                    is_valid = self._verify_cmdb_consistency(entry)
                    if not is_valid:
                        entry.confidence *= 0.5
                        print(f"CMDB配置可能过期: {entry.entry_id}")
                
                validated_results.append(entry)
            
            # 缓存检索结果
            for entry in validated_results:
                cache_key = f"{knowledge_type}:{entry.entry_id}"
                self.knowledge_cache[cache_key] = entry
            
            return validated_results
            
        except Exception as e:
            print(f"长期知识检索失败: {e}，使用缓存知识")
            return self._fallback_knowledge_search(query, knowledge_type)
    
    def write_to_long_term_memory(self, 
                                  session_summary: Dict[str, Any]) -> bool:
        """
        将诊断会话的总结写入长期知识库
        
        Args:
            session_summary: 会话总结，包含故障类型、根因、处理步骤等
        """
        try:
            # 生成结构化的案例条目
            case_entry = {
                "session_id": self.session_id,
                "incident_type": session_summary.get("incident_type", "unknown"),
                "affected_services": session_summary.get("affected_services", []),
                "root_cause": session_summary.get("root_cause", ""),
                "diagnosis_steps": session_summary.get("diagnosis_steps", []),
                "resolution_steps": session_summary.get("resolution_steps", []),
                "resolution_time_minutes": session_summary.get("resolution_time", 0),
                "severity": session_summary.get("severity", "P2"),
                "tags": session_summary.get("tags", []),
                "lessons_learned": session_summary.get("lessons_learned", ""),
            }
            
            # 构建检索优化的文本
            searchable_text = f"""
故障类型: {case_entry['incident_type']}
影响服务: {', '.join(case_entry['affected_services'])}
根因: {case_entry['root_cause']}
处理摘要: {'; '.join(case_entry['resolution_steps'])}
经验教训: {case_entry['lessons_learned']}
"""
            
            # 向量化
            embedding = self.embedder.encode(searchable_text)
            
            # 生成条目
            entry = KnowledgeEntry(
                entry_id=f"case_{datetime.now().strftime('%Y%m%d%H%M%S')}_{self.session_id[:8]}",
                knowledge_type="case",
                content=case_entry,
                embedding_vector=embedding.tolist(),
                confidence=0.85,  # 会话阶段先给较高初始置信度
            )
            
            # 写入向量数据库
            self._insert_to_vector_store("ops_knowledge_case", entry)
            
            # 同时更新知识图谱：添加新的服务依赖关系
            if session_summary.get("new_dependencies"):
                self._update_knowledge_graph(
                    session_summary["new_dependencies"]
                )
            
            print(f"成功写入案例到长期知识库: {entry.entry_id}")
            return True
            
        except Exception as e:
            print(f"写入长期知识库失败: {e}")
            return False
    
    def _cleanup_expired_entries(self):
        """清理过期的工作记忆条目"""
        now = time.time()
        expired = [
            eid for eid, entry in self.working_memory.items()
            if now - entry.timestamp > entry.ttl_seconds
        ]
        for eid in expired:
            del self.working_memory[eid]
        if expired:
            print(f"清理了 {len(expired)} 条过期工作记忆")
    
    def _evict_low_relevance(self, keep_top: int = 100):
        """驱逐低相关性条目（LRU策略）"""
        sorted_entries = sorted(
            self.memory_access_count.items(), 
            key=lambda x: x[1]
        )
        to_remove = sorted_entries[:max(0, len(sorted_entries) - keep_top)]
        for entry_id, _ in to_remove:
            if entry_id in self.working_memory:
                del self.working_memory[entry_id]
                self.memory_access_count.pop(entry_id, None)
    
    def _verify_cmdb_consistency(self, entry: KnowledgeEntry) -> bool:
        """验证CMDB配置与知识条目的一致性"""
        # 实际实现中查询CMDB API比较当前配置与知识条目中的配置
        # 简化：返回True
        return True
    
    def _vector_search(self, collection_name, query_vector, top_k, filter_expr):
        """Milvus向量检索（简化实现）"""
        # 实际使用 pymilvus 或 milvus-client
        return []
    
    def _fallback_knowledge_search(self, query, knowledge_type):
        """降级检索方案"""
        return [entry for entry in self.knowledge_cache.values() 
                if entry.knowledge_type == knowledge_type]
    
    def _init_embedder(self):
        """初始化Embedding模型"""
        # 实际使用sentence-transformers加载微调模型
        class DummyEmbedder:
            def encode(self, text):
                return np.zeros(768)
        return DummyEmbedder()
    
    def _insert_to_vector_store(self, collection_name, entry):
        """写入向量数据库"""
        pass
    
    def _update_knowledge_graph(self, dependencies):
        """更新知识图谱"""
        pass

五、总结

运维Agent的记忆系统是其从辅助工具进化为智能化助手的关键基础设施。通过短期工作记忆与长期知识库的双层架构，Agent能够在单次会话中保持上下文连贯性，同时在跨会话的维度上持续积累和利用运维知识。向量检索与知识图谱的混合检索策略兼顾了语义相似性和结构关联性，版本管理与时效性检查机制保障了知识的准确性和可信度。

记忆系统设计的核心理念是"利用每一次故障处理进行学习"。每一次成功的诊断和处置都不应只是解决一个孤立的问题，而应该转化为可被未来复用的知识资产。当一个组织积累的故障案例达到数百条规模时，记忆系统的价值将从"辅助检索"升级为"主动预防"——系统能够基于历史模式识别出即将出现的故障征兆，在故障真正发生前发出预警。这是运维Agent从"反应式"走向"预测式"的关键跃迁，而支撑这一跃迁的基石，正是设计良好的记忆系统架构。