设计与 UI
memory-management
Design and operate memory systems for long-running AI agents. Covers context window optimization, summarization strategies, vector-based retrieval, episodic memory, memory consolidation, and garbage collection for production agent systems.
cosmicstack-labs · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add cosmicstack-labs/mercury-agent-skills --skill memory-management技能说明
name: memory-management description: 'Design and operate memory systems for long-running AI agents. Covers context window optimization, summarization strategies, vector-based retrieval, episodic memory, memory consolidation, and garbage collection for production agent systems.' metadata: author: cosmicstack-labs version: 1.0.0 category: ai-ml tags: - memory-management - context-window - vector-database - summarization - rag - long-running-agents - memory-consolidation
Memory Management for Long-Running Agents
Overview
Long-running agents face a fundamental problem: they can't remember everything, but forgetting the wrong thing breaks their usefulness. This skill covers memory architectures that balance context retention, token budget, and retrieval accuracy for agents that run for hours, days, or continuously.
Core Concepts
The Memory Problem
| Issue | Symptom | Cost |
|---|---|---|
| Context Overflow | Agent forgets early instructions | Task failure, incoherent responses |
| Token Bloat | Every message keeps growing | 10x+ cost increase per task |
| Memory Pollution | Irrelevant memories distract agent | Hallucination, off-target responses |
| Stale Memories | Outdated information used as fact | Incorrect decisions |
| Memory Leaks | Unused data accumulates unbounded | Crash from OOM, endless context |
Memory Tiers
| Tier | Storage | Capacity | Access Speed | Cost | Best For |
|---|---|---|---|---|---|
| L1 — Working | In-context (LLM window) | 8K-200K tokens | Instant | $$$ | Current task, immediate context |
| L2 — Recent | Sliding window buffer | ~2K turns | < 10ms | $$ | Recent conversation history |
| L3 — Episodic | Event log / timeseries | Millions of events | < 50ms | $ | Past actions, outcomes, decisions |
| L4 — Semantic | Vector database | Unlimited | < 100ms | $ | Knowledge, facts, relationships |
| L5 — Archival | Object storage | Unlimited | > 1s | $ | Backups, compliance, audit |
Step-by-Step Implementation
Step 1: Build a Tiered Memory System
from dataclasses import dataclass, field
from typing import Optional
import json
import time
@dataclass
class MemoryEntry:
content: str
timestamp: float = None
importance: float = 0.5 # 0.0 (trivial) to 1.0 (critical)
tags: list[str] = field(default_factory=list)
token_count: int = 0
def __post_init__(self):
if self.timestamp is None:
self.timestamp = time.time()
class TieredMemory:
"""Multi-tier memory with automatic promotion and demotion."""
def __init__(self, llm, vector_store, max_context_tokens: int = 8000):
self.llm = llm
self.vector_store = vector_store
self.max_context_tokens = max_context_tokens
# L1: Working context (in-memory)
self.working_memory: list[MemoryEntry] = []
self.current_tokens = 0
# L2: Recent history buffer
self.recent_buffer: list[MemoryEntry] = []
self.buffer_size = 50
# L3: Episodic memory
self.episodes: list[MemoryEntry] = []
# L4: Semantic memory (vector DB)
# Initialized externally
async def remember(self, content: str, importance: float = 0.5,
tags: list[str] = None):
"""Store a new memory across tiers."""
entry = MemoryEntry(
content=content,
importance=importance,
tags=tags or [],
token_count=self._count_tokens(content)
)
# Always add to working memory
self.working_memory.append(entry)
self.current_tokens += entry.token_count
# If important, store in episodic + semantic
if importance > 0.7:
self.episodes.append(entry)
await self.vector_store.store(entry)
# Trim if needed
await self._trim_working_memory()
Step 2: Implement Context Window Management
class ContextManager:
"""Optimize what stays in the context window."""
def __init__(self, tiered_memory: TieredMemory,
summarizer, max_tokens: int = 8000):
self.memory = tiered_memory
self.summarizer = summarizer
self.max_tokens = max_tokens
self.reserved_tokens = 2000 # Reserve for new input/output
async def build_context(self, task: str, top_k: int = 5) -> list[dict]:
"""Build the optimal context for a task."""
available_tokens = self.max_tokens - self.reserved_tokens
# 1. Start with high-importance working memory
context = []
tokens_used = 0
working = sorted(
self.memory.working_memory,
key=lambda e: e.importance,
reverse=True
)
for entry in working:
if tokens_used + entry.token_count > available_tokens:
break
context.append({"role": "system", "content": entry.content})
tokens_used += entry.token_count
# 2. Add semantically relevant memories
relevant = await self.memory.vector_store.search(task, k=top_k)
for mem in relevant:
if tokens_used + mem.token_count > available_tokens:
break
context.append({"role": "system", "content": mem.content})
tokens_used += mem.token_count
# 3. If we had to drop items, add a summary
if len(context) < len(working):
summary = await self._get_summary()
context.insert(0, {"role": "system",
"content": f"[Summary of earlier context]: {summary}"})
return context
async def _get_summary(self) -> str:
"""Summarize what was excluded from context."""
excluded =
阅读完整来源 ↗