agent-memory-labs

🧠 Agentic Memory

https://github.com/jarmen423/agentic-memory

Multi-Domain Memory Layer for AI Agents

Agentic Memory gives AI agents persistent, searchable memory across four domains: code, git history, web research, and conversations — all stored in a unified Neo4j graph and exposed via MCP.

Core Value Prop: "Don't let your agent work from a blank slate. Give it memory."

---

✨ Features

---

🚀 Quick Start

Hosted managed beta

For the hosted path, create an account and API key before configuring the CLI:

1. Open https://agentmemorylabs.com/account.
2. Sign in with Google.
3. Enter your beta invite code, or join https://backend.agentmemorylabs.com/waitlist.
4. Create an account API key from the dashboard.
5. Install and log in with the global CLI:

pipx install agent-memory-labs
agent-memory login \
  --backend-url https://backend.agentmemorylabs.com \
  --api-key <your-account-api-key>

Then initialize a repository for managed use:

cd /path/to/your/repo
agent-memory init --managed
agent-memory index --managed

Current managed-indexing note: index --managed registers the repository with the hosted backend and binds it to your authenticated account_id. Full remote code ingestion is the next data-plane milestone.

Local/self-hosted

1. Install globally

# Recommended: Use pipx for isolated global installation
pipx install agent-memory-labs

# Or with uv tooling
uv tool install agent-memory-labs
uvx --from agent-memory-labs agent-memory --help

# Or use pip in a virtualenv
pip install agent-memory-labs

After a pipx install:

• agent-memory is available globally on that machine
• you install the CLI once, not once per repository
• each repository keeps its own local Agentic Memory config under .agentic-memory/

2. Initialize in any repository

cd /path/to/your/repo
agent-memory init

The interactive wizard will guide you through:

• Neo4j setup (local Docker, Aura cloud, or custom)
• Code embedding provider selection
• Gemini API key by default for code semantic search
• File extensions to index

By default, agent-memory init configures the code module to use gemini-embedding-2-preview so code memory stays aligned with the rest of the multimodal Agentic Memory system. If you want code memory completely separate, you can switch the code module to another text embedding provider such as OpenAI.

Multi-Repo Workflow

If a machine hosts more than one repository, the normal flow is still:

cd /path/to/repo-a
agent-memory init

cd /path/to/repo-b
agent-memory init

After that, Agentic Memory discovers the active repository from your current working directory. In practice that means:

• cd /path/to/repo-a && agent-memory index works against repo A
• cd /path/to/repo-b && agent-memory serve works against repo B
• you do not need --repo for normal day-to-day use once each repo is initialized

For no-flags multi-repo operation, store Agentic Memory credentials in the repo's own control directory:

• /path/to/repo/.agentic-memory/.env

Agentic Memory intentionally does not auto-load the repo root .env, because application-level env files often contain unrelated variables that can override memory configuration in surprising ways.

If you change the embedding model, dimensions, or task-format configuration and need fresh vectors for the whole repo, run:

agent-memory index --full

That clears only the current repo's code graph, then rebuilds it from source.

That's it! Your repository is now indexed and ready for AI agents.

Running Agentic Memory On This Repository

If you are working inside the agentic-memory repo itself, this checkout is already initialized through:

• D:\code\agentic-memory\.codememory\config.json

So you normally do not need to run agent-memory init again.

On this machine, the practical local flow is:

cd D:\code\agentic-memory
docker compose up -d neo4j
.\.venv-agentic-memory\Scripts\python.exe -m agentic_memory.cli status --json
.\.venv-agentic-memory\Scripts\python.exe -m agentic_memory.cli index --json

Why the commands use python -m agentic_memory.cli instead of agent-memory:

• the console script may not be on PATH
• the repo-local virtualenv path is explicit and avoids shell ambiguity

Current local config expectations for this repo:

• Neo4j: bolt://localhost:7687
• Neo4j user: neo4j
• Neo4j password: password
• code embedding provider: Gemini (gemini-embedding-2-preview)

If status fails before indexing starts, the most likely immediate cause is that Neo4j is not running locally yet.

---

📖 Usage

Code memory

# Setup/config for code memory in this repo
agent-memory init

# Show repository status and statistics
agent-memory status

# One-time structural code ingest (files, entities, imports)
agent-memory index

# Full repo rebuild after embedding-model or task-format changes
agent-memory index --full

# Continuous structural code ingest on file changes
agent-memory watch

# Experimental old repo-wide CALLS build
agent-memory build-calls

# JIT trace one function's likely execution neighborhood
agent-memory trace-execution src/app.py:run_checkout --json

# Start MCP server for AI agents
agent-memory serve

# Semantic search across code
agent-memory search "where is the auth logic?"

If the console script is not on PATH, use the module form instead:

.\.venv-agentic-memory\Scripts\python.exe -m agentic_memory.cli status --json
.\.venv-agentic-memory\Scripts\python.exe -m agentic_memory.cli index --json

Code-memory behavior model

The default code pipeline now stops after structural graph construction:

• Pass 1: structure scan and changed-file detection
• Pass 2: entities, chunks, and embeddings
• Pass 3: import graph construction

What it does not do by default:

• repo-wide CALLS reconstruction

Behavioral tracing is now handled just in time with:

• CLI: agent-memory trace-execution ...
• MCP: trace_execution_path(...)

The older repo-wide analyzer-backed CALLS flow is still available explicitly:

• CLI: agent-memory build-calls

Detailed explanation:

• docs/JIT_TRACING.md
• docs/PUBLIC_PLUGIN_SURFACES.md

Public plugin surfaces

Agentic Memory now supports a hosted remote-MCP plugin architecture for public AI surfaces. The publication model is:

• OpenAI / ChatGPT: OpenAI app review and publish, backed by the hosted OpenAI MCP surface
• Codex: distribution derived from the approved OpenAI app; .codex-plugin/plugin.json is the local preflight package
• Claude: Anthropic directory submission backed by the hosted Claude MCP surface
• OpenClaw: native package under packages/am-openclaw
• Hermes Agent: showcase memory-provider and context-engine plugins under packages/am-hermes

Default hosted/public MCP mounts:

• /mcp
• /mcp-openai
• /mcp-codex
• /mcp-claude

Internal/self-hosted full MCP mount:

• /mcp-full

Canonical publication/legal URLs:

• https://mcp.agentmemorylabs.com/publication/agentic-memory
• https://mcp.agentmemorylabs.com/publication/privacy
• https://mcp.agentmemorylabs.com/publication/terms
• https://mcp.agentmemorylabs.com/publication/support
• https://mcp.agentmemorylabs.com/publication/dpa

Publication packets:

• docs/publication/openai
• docs/publication/anthropic
• docs/publication/shared

For the public surface contract and auth details, see docs/PUBLIC_PLUGIN_SURFACES.md.

Web & research memory

# Setup/index repair for research memory
agent-memory web-init

# Actual ad hoc research ingest from a URL or PDF
agent-memory web-ingest https://example.com/paper.pdf

# Search research memory
agent-memory web-search "transformer attention mechanisms"

# Create future ingest triggers
agent-memory web-schedule --project my-project --query "LLM memory" --interval 24h

# Actual scheduled or ad hoc research ingest execution
agent-memory web-run-research --project my-project

Conversation memory

# Setup/index repair for conversation memory
agent-memory chat-init

# Actual conversation ingest
agent-memory chat-ingest /path/to/conversation.json

# Search past conversations
agent-memory chat-search "what did we decide about the auth flow?"

Optional learned reranking

Agentic Memory can optionally apply a shared learned reranking layer across code, research, and conversation search:

• first-stage retrieval still gathers candidates with the domain's normal dense / lexical / temporal logic
• reranking only reorders the candidate pool that survived those filters
• if the hosted reranker is disabled or unavailable, the system falls back to baseline ordering and records that fallback in retrieval provenance

The current hosted backend is Cohere Rerank v2. Configure it with:

AM_RERANK_ENABLED=true
AM_RERANK_PROVIDER=cohere
AM_RERANK_MODEL=rerank-v4.0-fast
COHERE_API_KEY=...

Optional per-domain candidate caps and timeout settings live in .env.example.

If you want a backup path for retryable provider failures, you can keep direct Cohere as primary and configure OpenRouter as a narrow failover:

AM_RERANK_FALLBACK_PROVIDER=openrouter
AM_RERANK_FALLBACK_MODEL=cohere/rerank-4-fast
OPENROUTER_API_KEY=...

The fallback is only used for retryable provider-side failures such as timeouts, HTTP 429, and 5xx responses.

Git graph (opt-in)

agent-memory git-init --repo /absolute/path/to/repo --mode local --full-history
agent-memory git-sync --repo /absolute/path/to/repo --incremental
agent-memory git-status --repo /absolute/path/to/repo --json

Git graph command details and rollout notes: docs/GIT_GRAPH.md

---

🧾 Tool-Use Annotation (Research)

Agentic Memory supports SQLite telemetry for MCP tool calls plus manual post-response labeling as prompted or unprompted.

agent-memory --prompted "check our auth"
agent-memory --unprompted "check our auth"

Full workflow and options: docs/TOOL_USE_ANNOTATION.md

---

🏗️ Architecture

┌──────────────────┐    ┌──────────────────┐    ┌──────────────────┐    ┌──────────────────┐
│  Code Repository │    │  Web / PDFs /    │    │  Conversation    │    │  Git Commits /   │
│  (file watcher)  │    │  Research Reports│    │  Logs            │    │  Blame / History │
└────────┬─────────┘    └────────┬─────────┘    └────────┬─────────┘    └────────┬─────────┘
         │                       │                        │                        │
         └───────────────────────┴────────────────────────┴────────────────────────┘
                                              │
                                    Ingestion Pipelines
                                              │
                                              ▼
                                       ┌──────────────┐
                                       │  Neo4j       │
                                       │  Memory Graph│
                                       └──────┬───────┘
                                              │
                                              ▼
┌─────────────────┐     MCP Protocol  ┌──────────────────┐
│   AI Agent /    │ <───────────────> │  MCP Server      │
│   Claude        │                   │  (Interface)     │
└─────────────────┘                   └──────────────────┘

Components

---

🔌 MCP Tools Available to AI Agents

Unified search

Code domain

Conversation domain

Research domain

Git domain (opt-in)

Note: Git-domain tools are part of the git graph rollout. If missing in your build, run agent-memory git-init first.

---

🗂️ Memory Domains

---

⏱️ Experimental Temporal GraphRAG

Phase 8 adds a shadow-mode temporal maintenance layer alongside the existing Neo4j graph:

• packages/am-temporal-kg/ — SpacetimeDB TypeScript module for temporal edge ingest, scheduled maintenance, and deterministic temporal retrieval
• packages/am-sync-neo4j/ — subscription worker that mirrors curated temporal rows back into Neo4j

This layer is additive. Existing retrieval paths remain unchanged until the later retrieval cutover phase.

---

🖥️ Full-Stack Local Flow

A unified search surface spans code, research, and conversation memory:

• MCP: search_all_memory(...)
• REST: GET /search/all

A local product control plane handles install and dogfood loops:

• CLI: agent-memory product-status, agent-memory product-repo-add, agent-memory product-integration-set, agent-memory product-component-set, agent-memory product-event-record
• REST: GET /product/status, POST /product/repos, POST /product/integrations, POST /product/components/{component}, POST /product/events, POST /product/onboarding
• Workflow: docs/PRODUCT_DOGFOODING.md

A lightweight local FastAPI app in desktop_shell/ provides a browser-based control plane:

python -m am_server.server
python -m desktop_shell --backend-url http://127.0.0.1:8765

Reference docs:

• docs/SETUP_FULL_STACK.md
• docs/MCP_TOOL_REFERENCE.md
• docs/PROVIDER_CONFIGURATION.md
• docs/research/RERANKERS_PRIMER.md
• docs/research/RERANKERS_CROSS_DOMAIN_USE_CASES.md
• docs/research/RERANKING_DECISION_MEMO.md
• docs/SPACETIMEDB_OPERATIONS.md
• docs/PRODUCT_DOGFOODING.md

---

✅ Integration Recommendation Policy

Current recommendation policy is explicit:

1. Recommended default: mcp_native integration for production reliability.
2. Optional path: skill_adapter workflow for shell/script-driven operators.
3. Promotion rule: skill_adapter becomes first-class only after parity evidence is captured versus mcp_native across success rate, latency, token cost, retries, and operator steps.

Reference docs and evaluation artifacts:

• docs/evaluation-decision.md
• evaluation/README.md
• evaluation/tasks/benchmark_tasks.json
• evaluation/schemas/benchmark_results.schema.json
• evaluation/skills/skill-adapter-workflow.md

---

🐳 Docker Setup (Neo4j)

# Start Neo4j
docker-compose up -d neo4j

# Neo4j will be available at:
# HTTP: http://localhost:7474
# Bolt: bolt://localhost:7687
# Username: neo4j
# Password: password (change this in production!)

Neo4j Aura (Cloud)

Get a free instance at neo4j.com/cloud/aura/

---

📁 Configuration

Per-repository configuration is stored in .agentic-memory/config.json:

{
  "neo4j": {
    "uri": "bolt://localhost:7687",
    "user": "neo4j",
    "password": "password"
  },
  "openai": {
    "api_key": "sk-..."
  },
  "indexing": {
    "ignore_dirs": ["node_modules", "__pycache__", ".git"],
    "extensions": [".py", ".js", ".ts", ".tsx", ".jsx"]
  }
}

Note: .agentic-memory/ is gitignored by default to prevent committing API keys.

---

🔌 MCP Integration

Claude Desktop

{
  "mcpServers": {
    "agentic-memory": {
      "command": "agent-memory",
      "args": ["serve", "--repo", "/absolute/path/to/your/project"]
    }
  }
}

Cursor IDE

{
  "mcpServers": {
    "agentic-memory": {
      "command": "agent-memory",
      "args": ["serve", "--repo", "/absolute/path/to/your/project", "--port", "8000"]
    }
  }
}

Windsurf

Add to your MCP configuration file.

Note: If your installed version does not support --repo, use your client's cwd setting or launch via a wrapper script: cd /absolute/path/to/project && agent-memory serve.

---

🔧 Installation from Source

git clone https://github.com/jarmen423/agentic-memory.git
cd agentic-memory
pip install -e .
agent-memory init

---

🧪 Development

pip install -e .
mypy src/agentic_memory
pytest

---

📝 License

MIT License - see LICENSE file for details.

---

🤝 Contributing

Contributions welcome! Please see TODO.md for the roadmap.

---

🙏 Acknowledgments

• Neo4j - Graph database with vector search
• Tree-sitter - Incremental parsing for code
• Google Gemini - Default embedding provider for multimodal memory alignment
• MCP (Model Context Protocol) - Standard interface for AI tools
• SpacetimeDB - Temporal graph layer