Knowledge Base Cache Skill

Create a structured knowledge repository with layered architecture (hot/cold/warm) and intelligent context management.

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                     应用层 (Application)                     │
│                    Agent 核心                               │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│              工作记忆层 (Working Memory)                     │
│  • 上下文组装              • Token预算管理                   │
│  • 多源协调                • LRU缓存                         │
└─────────────┬───────────────────────────────────────────────┘
              │ 标准接口 KnowledgeSource
    ┌─────────┼─────────┐
    ▼         ▼         ▼ (预留)
┌───────┐ ┌───────┐ ┌───────┐
│  Hot  │ │  Cold │ │ Warm  │
│ Cache │ │Storage│ │Vector │
│ Layer │ │ Layer │ │ Layer │
└───┬───┘ └───┬───┘ └───┬───┘
    │         │         │
Context   Repository  Vector DB
 Cache     Files     (Future)

Three-Tier Architecture

What This Skill Does

1. Layered Knowledge Storage

   repository/
   ├── core/                    # Core components
   │   ├── __init__.py          # Standard interfaces
   │   └── working_memory.py    # Working Memory layer
   ├── adapters/                # Layer adapters
   │   ├── __init__.py
   │   ├── hot_cache_adapter.py
   │   ├── cold_storage_adapter.py
   │   └── warm_cache_adapter.py (reserved)
   ├── index.json               # Knowledge index
   ├── cache-state.json         # Cache status
   ├── skills/                  # Skill knowledge
   ├── docs/                    # Document knowledge
   └── scripts/
       ├── cache_manager.py     # Cache management
       └── cache_helper.py      # Helper utilities
   

2. Working Memory Layer

   • Unified interface for all knowledge sources
   • Automatic context assembly with token budgeting
   • LRU cache for repeated queries
   • Cross-tier result ranking

3. Context Caching (Hot Layer)

   • Full document caching via API
   • 90% cost reduction
   • 83% latency improvement

4. File-Based Storage (Cold Layer)

   • Keyword-based retrieval
   • Excerpt generation
   • No API costs

5. Auto-Refresh

   • Configures cron job for daily refresh
   • Keeps caches fresh without manual intervention

Quick Start

Step 1: Initialize Repository

# The repository structure is already created
# If not, run:
python scripts/init_knowledge_base.py

Step 2: Add Knowledge

Add markdown files to appropriate directories:

• repository/skills/

  - Skill documentation

• repository/docs/

  - General documentation

• repository/projects/

  - Project-specific knowledge

Step 3: Build Cache

cd repository

# Initialize index
python scripts/cache_manager.py init

# Build hot cache (Context Caching)
python scripts/cache_manager.py build

# Test the system
python test_phase1.py

Step 4: Use in Your Agent

Modern Approach (Recommended):

from repository.core.working_memory import WorkingMemoryManager

# Initialize once
wm = WorkingMemoryManager({
    'max_tokens': 6000,
    'allocation': {
        'system_prompt': 0.15,      # 15%
        'conversation': 0.25,        # 25%
        'retrieved_knowledge': 0.60  # 60%
    }
})

# Use in conversations
context = wm.query(
    user_query="How do I deploy?",
    system_prompt="You are an assistant...",
    conversation=history_messages
)

Legacy Approach:

from scripts.cache_helper import get_cache_headers, load_knowledge_context

# Get cache headers for API calls
headers = get_cache_headers()

# Load knowledge context
context = load_knowledge_context()

Step 5: Configure Auto-Refresh

# Add cron job for daily refresh
# Configure in your agent's cron system

Layer Details

🔥 Hot Cache Layer

Purpose: Store frequently accessed complete documents

When to Use:

• Reading full skill documentation
• API reference lookup
• Deployment guides

Implementation:

adapters/hot_cache_adapter.py

from adapters.hot_cache_adapter import HotCacheAdapter
from core import RetrievalQuery

hot = HotCacheAdapter()
result = hot.retrieve(RetrievalQuery(
    query="Docker deployment",
    context_budget=2000,
    top_k=3
))

❄️ Cold Storage Layer

Purpose: Keyword-based file retrieval with excerpt generation

When to Use:

• Browsing knowledge base
• Finding relevant files
• Low-cost retrieval

Implementation:

adapters/cold_storage_adapter.py

from adapters.cold_storage_adapter import ColdStorageAdapter
from core import RetrievalQuery

cold = ColdStorageAdapter()
result = cold.retrieve(RetrievalQuery(
    query="Docker deployment",
    context_budget=2000,
    top_k=5
))

🌡️ Warm Cache Layer (Planned)

Purpose: Semantic search with vector embeddings

When to Use:

• Precise Q&A
• Semantic similarity matching
• Large knowledge bases

Implementation: Reserved interface in

adapters/warm_cache_adapter.py

Working Memory Configuration

Token Budget Allocation

Default allocation (customizable):

Configuration Options

from repository.core.working_memory import WorkingMemoryManager
from repository.core import MemoryAllocation

wm = WorkingMemoryManager({
    'max_tokens': 8000,                    # Total context window
    'lru_cache_size': 10,                  # LRU cache size
    'allocation': {
        'system_prompt': 0.20,             # 20%
        'conversation': 0.20,              # 20%
        'retrieved_knowledge': 0.60        # 60%
    },
    'repo_path': 'repository'              # Repository path
})

Cache Management Commands

cache_manager.py init

cache_manager.py build

cache_manager.py status

cache_manager.py refresh

cache_manager.py stats

Testing Commands

# Run Phase 1 integration tests
cd repository
python test_phase1.py

# Test individual layers
python -c "from adapters.hot_cache_adapter import HotCacheAdapter; print(HotCacheAdapter().get_stats())"
python -c "from adapters.cold_storage_adapter import ColdStorageAdapter; print(ColdStorageAdapter().get_stats())"

Cost Benefits

Hot Layer (Context Cache)

Cold Layer (File Storage)

Working Memory Layer

Troubleshooting

Cache Not Working

# Check if caches are active
python scripts/cache_manager.py status

# Rebuild if needed
python scripts/cache_manager.py build

# Verify hot layer
python -c "from adapters.hot_cache_adapter import HotCacheAdapter; print(HotCacheAdapter().is_available())"

Working Memory Not Finding Knowledge

# Debug: Check registered sources
from repository.core.working_memory import WorkingMemoryManager

wm = WorkingMemoryManager()
print(wm.get_stats())

# Debug: Test individual layers
from adapters.hot_cache_adapter import HotCacheAdapter
from adapters.cold_storage_adapter import ColdStorageAdapter
from core import RetrievalQuery

hot = HotCacheAdapter()
cold = ColdStorageAdapter()

query = RetrievalQuery(query="test", context_budget=2000)
print("Hot:", hot.retrieve(query))
print("Cold:", cold.retrieve(query))

API Key Issues

Ensure API key is set in environment or config for hot layer. Cold layer works without API keys.

Path Issues

All paths in generated files are relative (workspace-relative) for portability.

Migration from v1

If you were using the old cache system:

1. Old way still works:

   cache_helper.py

   functions unchanged
2. New way recommended: Use

   WorkingMemoryManager

   for better control
3. Same repository structure: No migration needed

References

• Context Caching documentation
• Component architecture design