🧠 Memory vs Knowledge

The AI Memory Platform draws a sharp line between memory and knowledge. Understanding the distinction is key to using the platform effectively and designing new providers.

← Back to Academy 🔌 See Providers →

💾

Memory

Ephemeral & dynamic — changes with every interaction
Tied to a specific user, session, or agent
Time-sensitive — recency and recency-weighted importance
Recorded automatically by the platform during interactions
Scored by confidence and importance before storage
Can be updated, deleted, or expired over time
Stored in operational backends (Mem0, Honcho, InMemory)

📚

Knowledge

Static & curated — authored and maintained deliberately
Shared across users, sessions, and agents
Long-lived — changes infrequently via explicit updates
Written and reviewed by humans or automated curation
Trusted at face value — no confidence scoring needed
Appended to, but never deleted without explicit action
Stored in structured backends (Obsidian vault, Skills)

🔍 How the Platform Separates Concerns

🔵 Memory Providers

Memory providers implement the MemoryProvider ABC. They handle data that is personal, session-specific, and dynamic. Every memory is evaluated by the Policy Engine first — low-confidence memories are discarded before they reach the provider. Memories are scored, ranked, and can be queried by recency, relevance, or importance.

Memory providers in the platform:

• InMemory — gold standard, reference implementation
• Mem0 — PostgreSQL-backed HTTP memory service
• Honcho — backend memory service for persistent storage
• Archive — cold storage for infrequently accessed memories

🟢 Knowledge Providers

Knowledge providers implement the KnowledgeProvider ABC. They handle curated, long-lived information that is shared across the system. Knowledge does not go through confidence scoring — it is trusted by definition. It is queried alongside memories during context building but is never automatically expired or deleted.

Knowledge providers in the platform:

• Obsidian — markdown vault as a knowledge graph
• Skills — agent capabilities and procedural knowledge (JSON)

🔄 How They Combine: Context Building

When a query comes in, the Context Builder queries ALL registered providers — both memory and knowledge — in parallel. It merges the results, ranks them by a unified relevance score, and applies a token budget. The final response includes metadata showing which memories and which knowledge entries were used, along with the trace_id for full auditability.

context.build(query)
  ├── parallel query ALL providers
  │   ├── 💾 InMemory   (memory)   ──→ memories
  │   ├── 💾 Mem0       (memory)   ──→ memories
  │   ├── 💾 Honcho     (memory)   ──→ memories
  │   ├── 💾 Archive    (memory)   ──→ memories
  │   ├── 📚 Obsidian   (knowledge)──→ knowledge
  │   └── 📚 Skills     (knowledge)──→ knowledge
  │
  └── merge → rank by score → apply token budget
       └── return ContextObject + explainability

🎯 When to Use Memory vs Knowledge

Use Memory when…

✓Remembering a user's last conversation topic
✓Tracking session-specific preferences
✓Recording agent actions for audit trails
✓Storing temporary state that may be updated
✓Learning from user feedback over time

Use Knowledge when…

✓Documenting system architecture and ADRs
✓Storing API reference and code patterns
✓Maintaining agent skill definitions
✓Holding curated reference data
✓Preserving information that must never expire

📊 Provider Contract Hierarchy

┌─────────────────────────────────────────────────┐
│              🧩 Provider ABC                      │
│  (Abstract Base Class — defines contract)         │
└────────────────────┬────────────────────────────┘
                     │
         ┌───────────┴───────────┐
         ▼                       ▼
┌─────────────────┐   ┌──────────────────────┐
│ 💾 MemoryProvider│   │ 📚 KnowledgeProvider  │
│                 │   │                      │
│ • store()       │   │ • query()            │
│ • query()       │   │ • get()              │
│ • get()         │   │ • delete()           │
│ • delete()      │   │                      │
│ • count()       │   │ (no confidence score) │
└────────┬────────┘   └──────────┬───────────┘
         │                       │
         ▼                       ▼
┌─────────────────┐   ┌──────────────────────┐
│ InMemory        │   │ Obsidian             │
│ Mem0            │   │ Skills               │
│ Honcho          │   │                      │
│ Archive         │   │                      │
│ Mock (gold std) │   │                      │
└─────────────────┘   └──────────────────────┘

🔗 Related Resources

🏛️

Architecture

System design and component model

🔌

Provider Overview

All providers compared side-by-side

🎯

Philosophy

Design principles behind the platform

📋

ADR-0001

Why the Memory Platform exists