Agent Memory

Persistent semantic memory for AI agents with intelligent decision-making.

🚀 Created by: TheProdSDE

---

The problem

Most AI memory systems retrieve and inject past context into every prompt. This leads to wasted tokens, inconsistent responses, and agents that blindly replay stale or wrong answers.

Agent Memory adds a decision layer:

flowchart TD
    A[User Query] --> B[Resolve Memory]
    B --> C[Decision Engine]
    C -->|High confidence match| D[🔄 Replay — return stored answer]
    C -->|Moderate match| E[📋 Restore — inject as context]
    C -->|Needs validation| F[✅ Verify — validate before reuse]
    C -->|No match| G[❌ None — answer from scratch]

    style D fill:#0d47a1,color:#fff
    style E fill:#e65100,color:#fff
    style F fill:#1b5e20,color:#fff
    style G fill:#b71c1c,color:#fff

Every resolve() returns an explicit action with a scored, explainable rationale — not just a retrieved chunk. Adversarial eval: 25/25 (100%) on trap queries — see benchmarks.

---

When to use it — real use cases

Where Agent Memory saves real money

A GPT-4o call costs ~$0.005. A support agent handling 50,000 queries/day with 70% repeat rate:

• Without memory: 50,000 × $0.005 = $250/day
• With Agent Memory: 15,000 LLM calls + cache misses = $75/day
• Saving: ~ $175/day (~$64k/year)
• Savings can depends on how much query are repeated and similar to the previous questions.

A REPLAY costs ~0.05ms of in-process computation. An LLM call takes 300–2,000ms and costs tokens.

Is it right for your use case?

Good fit:

• Agent answers the same or similar questions across sessions
• You have fact-sensitive answers that can go stale (prices, limits, policies)
• Multiple agents or services share a knowledge base
• You need audit trails — knowing which memory answered and why

Not the right tool:

• Document RAG over a corpus of files → use a vector database for that
• Replacing your application's source-of-truth database
• Agents that never repeat similar queries

---

Features at a glance

→ Full feature reference: docs/features.md

---

Performance

All numbers are measured — no projections. Charts generated from real benchmark runs.

Latency at scale (diverse unique content, no LRU cache)

Key insight: latency scales with match count per query, not total store size. A 1M-entry store with diverse unique memories performs near the 10K numbers.

Tuning levers (all measured — shipped by default)

Points on the Pareto frontier above cannot improve latency without increasing implementation effort. LRU cache and Bloom filter are on the frontier — they ship by default.

Seeding throughput

→ Full methodology, charts, and tuning guide: docs/stress-testing.md

---

When to use it

Use Agent Memory when:

• You want an agent to remember past interactions without injecting all of them into every prompt
• You need explicit control over when memory is used (replay exact answers vs inject as context vs verify first)
• You have different memory trust levels (user preferences vs potentially-stale facts vs tool outputs)
• Multiple processes, services, or agents share the same memory store
• You need audit trails — every replay is traceable to a specific stored entry with a score breakdown

Don't use it for:

• Document RAG (search over a corpus of files) — use a vector database for that; Agent Memory stores query→answer experiences
• A replacement for your database — it stores transient agent knowledge, not your application's source-of-truth data

---

Quick Start

pip install agent-memory-sdk

from agent_memory import Memory, MemoryAction

memory = Memory(persist_dir=".agent_memory")

# Store once after a good answer
memory.remember(
    "How do I reset my password?",
    "Go to Settings → Security → Reset Password.",
    type="conversation", tags=["auth"],
)

# Decide before every LLM call
decision = memory.resolve("How do I reset my password?")

if decision.action == MemoryAction.REPLAY:
    return decision.response          # exact match — no LLM call needed

if decision.action == MemoryAction.RESTORE:
    context = memory.format_restore_context(decision)
    return call_llm(query, system_extra=context)

# VERIFY or NONE — validate or answer fresh

→ Full integration pattern and API reference: docs/usage.md

---

Local Setup

Option 1 — SQLite (zero dependencies, recommended to start)

pip install agent-memory-sdk

# Store something
agent-memory remember "How do I reset my password?" \
  "Go to Settings → Security → Reset Password." \
  --type conversation --tags auth,faq

# Ask it back
agent-memory resolve "I forgot my password"
# ✅ REPLAY  confidence: 0.87
# matched: "How do I reset my password?"  stored: 2026-01-01  reused 1×
# response: Go to Settings → Security → Reset Password.

# See what's stored
agent-memory stats

Option 2 — Redis or Postgres backend

# Spin up the services
docker compose -f docker-compose.dev.yml up -d

# Install the backend extra
pip install "agent-memory-sdk[redis]"      # or [postgres]

# Use it
agent-memory --backend redis remember "API limit" "1000 req/min" --type fact
agent-memory --backend redis resolve "What is the rate limit?"

Option 3 — Streamlit dashboard (visual exploration)

pip install "agent-memory-sdk[dashboard]"

# Seed demo data (optional)
python scripts/seed_demo.py --data-dir .agent_memory

# Open the dashboard
AGENT_MEMORY_DIR=.agent_memory agent-memory-dashboard
# → http://localhost:8501

Option 4 — Development / from source

git clone https://github.com/TheProdSDE/agent-memory-sdk.git
cd agent-memory-sdk
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
make test          # run all tests
make check         # lint + type check

---

Dashboard

An interactive Streamlit dashboard for exploring memories, testing the resolve sandbox, and monitoring stats.

pip install "agent-memory-sdk[dashboard]"
AGENT_MEMORY_DIR=.agent_memory agent-memory-dashboard   # → http://localhost:8501

# Seed demo data (optional — run only when you want it)
python scripts/seed_demo.py --data-dir .agent_memory

---

MCP Server

Agent Memory is published on the MCP Registry — install it in any MCP-compatible client with zero manual setup.

Add to your MCP client

Cursor — add to .cursor/mcp.json in your project, or ~/.cursor/mcp.json globally:

{
  "mcpServers": {
    "agent-memory": {
      "command": "uvx",
      "args": ["agent-memory-sdk"]
    }
  }
}

Claude Desktop — add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "agent-memory": {
      "command": "uvx",
      "args": ["agent-memory-sdk"]
    }
  }
}

Claude Code — add to .claude/settings.json in your project:

{
  "mcpServers": {
    "agent-memory": {
      "command": "uvx",
      "args": ["agent-memory-sdk"]
    }
  }
}

uvx installs the package on first run — no pip install needed.

Custom storage location

{
  "mcpServers": {
    "agent-memory": {
      "command": "uvx",
      "args": ["agent-memory-sdk"],
      "env": {
        "AGENT_MEMORY_DIR": "/path/to/your/memory",
        "AGENT_MEMORY_COLLECTION": "my_project"
      }
    }
  }
}

Tools exposed

→ Full MCP setup guide and Docker config: docs/mcp.md

---

Integrations

agent-memory-sdk is the core — every integration delegates to Memory.

→ Setup instructions and code snippets for each: examples/README.md

---

Tech Stack

No API keys required — everything runs locally.

---

Documentation

---

Status & Roadmap

All planned features through v0.5.0 are shipped. Track what's next on the GitHub Project →

→ docs/roadmap.md

Release

Tag-triggered, fully CI-gated: git tag v0.x.y && git push origin v0.x.y

→ docs/release.md

---

Contributing

See CONTRIBUTING.md for dev setup, test commands, and the PR checklist.

---

License

MIT — see LICENSE.

---

Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: theprodsde@gmail.com

---

Agent Memory helps agents decide: Replay → Restore → Verify → Ignore

Built with ❤️ by TheProdSDE

mcp-name: io.github.theprodsde/agent-memory