Power your agent
การติดตั้งจากผู้เผยแพร่ ไม่ใช่เอนด์พอยต์ของ PlugMCP
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดBuilt from production: extracted from a real system running 30+ concurrent AI agents at a digital agency. Not a prototype — every feature exists because something broke in production.
Before: "Who is Alice?" (every single session)
After: Agent starts with: "Alice — Lead Engineer at Acme, prefers async,
last discussed the API migration on Feb 12"
MCP-native — designed for MCP-compatible clients. Tested configs included for Claude Code, Cursor, Windsurf, and Cline. Battle-tested daily with Claude Code (30+ agents in production). PRs and issue reports welcome!
Other memory solutions exist (Mem0, Zep/Graphiti, LangMem). Here's what makes agent-recall different:
pyyaml + click. MCP and Anthropic SDK are optional extras.┌─────────────────────────────────────────────────────────────────────┐
│ SESSION 1 │
│ │
│ You: "Alice from Acme called. She wants the API done by Friday." │
│ │ │
│ ▼ │
│ Agent saves automatically via MCP tools: │
│ create_entities: Alice (person), Acme (client) │
│ add_observations: "wants API done by Friday" │
│ create_relations: Alice → works_at → Acme │
│ │ │
│ ▼ │
│ Stored in local SQLite ─────► ~/.agent-recall/frames.db │
└─────────────────────────────────────────────────────────────────────┘
│
(session ends)
│
┌─────────────────────────────────────────────────────────────────────┐
│ SESSION 2 │
│ │
│ Agent starts and receives a briefing: │
│ "Alice (Lead Engineer, Acme) — wants API done by Friday. │
│ Acme is a client. Last discussed Feb 12." │
│ │ │
│ ▼ │
│ Agent already knows who Alice is, what's urgent, and what to do. │
└─────────────────────────────────────────────────────────────────────┘
Why does the agent save facts automatically? The MCP server includes behavioral instructions that tell the agent to proactively save people, decisions, and context as it encounters them. No special prompting needed — the agent receives these instructions when it connects to the memory server.
pip install 'agent-recall[mcp]'
agent-recall init
This creates the SQLite database at ~/.agent-recall/frames.db.
agent-recall[mcp]installs with MCP server support. Usepip install agent-recallif you only need the Python API/CLI.
This gives your agent the memory tools (create_entities, add_observations, search_nodes, etc.) and the instructions to use them proactively.
Add to .mcp.json in your project root:
{
"mcpServers": {
"memory": {
"command": "python3",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
Add to .cursor/mcp.json:
{
"mcpServers": {
"memory": {
"command": "python3",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"memory": {
"command": "python3",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
Add to cline_mcp_settings.json:
{
"mcpServers": {
"memory": {
"command": "python3",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
Hooks make the agent receive its memory briefing at the start of every session, and keep caches fresh after writes. This step is optional but strongly recommended for Claude Code users.
Add to .claude/settings.json (project or global):
{
"hooks": {
"SessionStart": [
{
"hooks": [
{
"type": "command",
"command": "agent-recall-session-start"
}
]
}
],
"PostToolUse": [
{
"matcher": "mcp__memory__.*",
"hooks": [
{
"type": "command",
"command": "agent-recall-post-tool-use"
}
]
}
]
}
}
Other editors: Hooks are Claude Code-specific. For other clients, use the CLI (
agent-recall generate) or Python API to generate and serve briefings.
Start a new session with your agent and look for:
create_entities, search_nodes)Get a working memory system in 3 minutes:
# Install
pip install 'agent-recall[mcp]'
# Initialize the database
agent-recall init
# Set your agent identity
export AGENT_RECALL_SLUG=my-project
# Add to your .mcp.json (Claude Code example)
cat > .mcp.json << 'EOF'
{
"mcpServers": {
"memory": {
"command": "python3",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
EOF
# Start Claude Code — memory tools are now available!
# The agent can create_entities, add_observations, search_nodes, etc.
# Generate an AI briefing from stored knowledge
agent-recall generate my-project
That's it! Your agent now has persistent memory across sessions. The MCP server exposes 9 tools for reading and writing the knowledge graph. See Configuration for customization options.
Here's the full lifecycle:
1. CONNECT
Agent connects to MCP server
└─► Server sends instructions: "Proactively save people, decisions, facts..."
└─► Agent receives 9 memory tools with descriptions explaining when to use each
2. SAVE (during conversation)
Agent encounters important information
└─► search_nodes("Alice") — check if entity exists
└─► create_entities([{...}]) — create if new
└─► add_observations([{...}]) — add facts to existing entity
└─► create_relations([{...}]) — link entities together
All stored in ~/.agent-recall/frames.db (SQLite, scoped per project)
3. NOTIFY (PostToolUse hook, Claude Code only)
After each memory write
└─► Marks affected agent caches as stale
└─► Regenerates Obsidian vault files (if configured)
4. BRIEFING (SessionStart hook or CLI)
Next session starts
└─► Reads cached AI briefing (if fresh)
└─► Or assembles raw context from database
└─► Or generates new briefing via LLM (if stale + adaptive mode)
└─► Injects into agent's system prompt
5. AGENT KNOWS
Agent starts with structured context:
└─► Key people, their roles, preferences
└─► Current tasks, blockers, deadlines
└─► Recent decisions and their rationale
Not a flat key-value store. Memory is scoped — the same person can have different roles in different projects:
Alice:
role (global) = "Engineer"
role (acme) = "Lead Engineer" ← Agent working on Acme sees this
role (beta-corp) = "Consultant" ← Agent working on Beta sees this
Scoping keeps context clean across projects and prevents data from leaking between workstreams.
Raw data dumps don't work. Thousands of facts is noise, not context.
agent-recall uses an LLM to summarize what matters into a structured briefing:
Raw (what's in the database):
147 slots across 34 entities, 89 observations, 23 relations...
Briefing (what the agent actually sees):
## Key People
- Alice (Lead Engineer, Acme) — prefers async, owns the API migration
- Bob (PM) — on vacation until Feb 20
## Current Tasks
- API migration: blocked on auth module (Alice working on it)
- Dashboard redesign: waiting for Bob's review
## Recent Decisions
- Team agreed to use GraphQL on Feb 10 call
- Next client meeting: Feb 19
Generate briefings via CLI (agent-recall generate my-agent) or let the SessionStart hook handle it automatically.
Built for systems with multiple agents sharing one knowledge base but seeing different slices:
global → acme-agency → client-a (client-a sees: global + acme + client-a)
→ client-b (client-b sees: global + acme + client-b)
→ personal → side-project (side-project sees: global + personal + side-project)
Each agent reads and writes within its scope chain. The MCP server enforces this automatically.
When one agent saves new facts, caches for affected agents are marked stale. Next time those agents start a session, their briefings regenerate automatically.
For a single agent with defaults, no config file is needed. By default, agent-recall auto-discovers project files (CLAUDE.md, README.md, .cursorrules, .windsurfrules) in the current directory and includes them in the data sent to the LLM for briefing generation. This means new agents get useful briefings from day one, even with an empty database. Disable with auto_discover: false in the briefing config.
For multiple agents or custom settings, create memory.yaml in your project root or ~/.agent-recall/memory.yaml:
# Database location (default: ~/.agent-recall/frames.db)
db_path: ~/.agent-recall/frames.db
cache_dir: ~/.agent-recall/context_cache
# Scope hierarchy — which agents see which data
hierarchy:
acme-agency:
- client-a
- client-b
# Tier 0 = no context injection, Tier 2 = full
tiers:
0: [infra-bot]
2: [acme-agency, client-a, client-b]
# AI briefing settings
briefing:
backend: cli # "cli" = claude -p (free on subscription), "api" = Anthropic SDK (needs API key)
model: opus # LLM model for generating briefings
timeout: 300 # LLM timeout in seconds
adaptive: true # Auto-regenerate stale caches
min_cache_age: 1800 # Minimum 30 min between regenerations
# Per-agent overrides
agents:
coordinator:
model: opus
output_budget: 12000
dashboard:
model: haiku
template: system
Environment variables:
AI briefings need an LLM to generate summaries. Two built-in backends:
Switch in memory.yaml:
briefing:
backend: api # uses Anthropic SDK instead of claude CLI
model: opus
For other providers, pass a callable matching (prompt, model, timeout) -> str:
from agent_recall import generate_briefing, LLMResult
def my_llm(prompt: str, model: str, timeout: int) -> LLMResult:
result = call_my_api(prompt, model)
return LLMResult(text=result.text, input_tokens=result.usage.input,
output_tokens=result.usage.output)
generate_briefing("my-agent", llm_caller=my_llm, force=True)
Full examples: OpenAI | Anthropic SDK | Ollama
By default, briefing generation uses the claude CLI (claude -p --model <model>). If you don't use Claude, pass your own llm_caller.
agent-recall init # Create database
agent-recall status # Database stats
agent-recall set Alice role Engineer # Set slot (existing entity)
agent-recall set Alice role Engineer --type person # Create new entity + set slot
agent-recall get Alice role # Get slot value
agent-recall entity Alice # Show entity details + observations
agent-recall entity Alice --scope global --scope acme # Scoped slot resolution
agent-recall entity Alice --json # JSON output
agent-recall list # List all entities
agent-recall list --type person # Filter by type
agent-recall search "engineer" # Search entities
agent-recall history Alice role # Bitemporal slot history
agent-recall log Alice "Joined the team" # Add log entry
agent-recall log Alice "Update" --author human # Log with custom author
agent-recall logs Alice # Show log entries
agent-recall generate my-agent --force # Generate AI briefing
agent-recall refresh --force # Refresh all briefings
agent-recall observe Alice "Prefers async" # Add observation to entity
agent-recall delete Alice # Delete entity
agent-recall templates # List briefing templates
agent-recall rename-scope old-name new-name # Migrate data between scopes
from agent_recall import MemoryStore, ScopedView
with MemoryStore() as store:
# Create entities
alice = store.resolve_entity("Alice", "person")
acme = store.resolve_entity("Acme Corp", "client")
# Scoped slots — same key, different values per scope
store.set_slot(alice, "role", "Engineer", scope="global")
store.set_slot(alice, "role", "Lead Engineer", scope="acme")
store.add_observation(alice, "Prefers async communication", scope="acme")
store.add_relation(alice, acme, "works_at")
# Scoped view — local overrides parent
view = ScopedView(store, ["global", "acme"])
entity = view.get_entity("Alice")
print(entity["slots"]["role"]) # "Lead Engineer" (acme overrides global)
# Search across all entities
results = store.search("engineer")
print(results) # [{"name": "Alice", "type": "person", ...}]
# Bitemporal history — see all past values
store.set_slot(alice, "role", "Staff Engineer", scope="acme")
history = store.get_slot_history(alice, "role")
# Returns: all values with valid_from/valid_to timestamps
# Atomic operations
with store.transaction():
bob = store.resolve_entity("Bob", "person")
store.set_slot(bob, "role", "PM")
store.add_relation(bob, acme, "works_at")
See examples/quickstart.py for a runnable version.
The MCP server includes instructions that tell the agent to proactively save. If it's not working:
create_entities, search_nodes etc. as available toolspython3 -m agent_recall.mcp_server should start without errorsagent-recall status should show entitiescli backend needs Claude Code installed (claude -p). If you don't use Claude, configure the api backend with ANTHROPIC_API_KEY, or pass your own llm_caller (see LLM Backend)agent-recall generate my-agent --forcels ~/.agent-recall/context_cache/On Windows, Python is usually python not python3. Update your MCP config:
{
"mcpServers": {
"memory": {
"command": "python",
"args": ["-m", "agent_recall.mcp_server"]
}
}
}
agent-recall was extracted from a live system managing real client projects at a digital agency — 30+ agents, 15+ clients, hundreds of scoped facts.
Why specific features exist:
They can work together: use auto-memory for quick preferences and agent-recall for structured knowledge that spans agents and sessions.
git clone https://github.com/mnardit/agent-recall.git
cd agent-recall
pip install -e ".[dev]"
pytest
388 tests covering store, config, hierarchy, context assembly, AI briefings, vault generation, hooks, dedup, MCP bridge, FTS search, and migrations.
See CONTRIBUTING.md for guidelines.
MIT
Persistent memory for AI coding agents. SQLite-backed knowledge graph with MCP server.
เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Agent Recall ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 Persistent memory for AI coding agents. SQLite-backed knowledge graph with MCP server.