Power your agent
पब्लिशर की अपनी कमांड। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
docker run -i --rm ghcr.io/dakera-ai/dakera-mcp:0.12.3Claude Code में लोकल कमांड के लिए इंस्टॉल लिंक नहीं है। नीचे दी गई कमांड कॉपी करें और टर्मिनल में चलाएँ।
claude mcp add dakera-ai-dakera-mcp -- docker run -i --rm ghcr.io/dakera-ai/dakera-mcp:0.12.3टर्मिनल में चलाएँ।
{ "mcpServers": { "dakera-ai-dakera-mcp": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/dakera-ai/dakera-mcp:0.12.3" ] } }}claude_desktop_config.json
रिमोट 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.
लॉन्चMCP server for Dakera AI. Gives any MCP-compatible AI agent persistent, queryable memory — with smart token management built in.
Works with Claude, Claude Code, and any MCP-compatible framework.
Part of Dakera AI — the memory engine for AI agents.
The Dakera memory engine scores 88.2% Recall@20 on LoCoMo (1,536 evaluated questions · LLM-judged retrieval recall) — benchmark details
Starting every agent session with 60+ tool schemas wastes ~15K tokens before you write a single message. dakera-mcp solves this with hybrid tool exposure:
dakera_discover_tools and dakera_load_tools to fetch additional tool schemas only when you need themToken figures are estimates (JSON bytes / 3). The attachment tools below count in power and all,
but only appear while the connected server has the feature on (see Dakera v0.12).
# In your agent: discover what's available
dakera_discover_tools(tier="power")
→ returns names + descriptions, no schemas loaded
# Load schemas for the tools you want
dakera_load_tools(tools=["dakera_consolidate", "dakera_agent_stats"])
→ returns full inputSchema for each tool
The profile controls which tools appear in tools/list. Three ways to set it:
1. Per-request (in tools/list params):
{"profile": "power"}
2. Environment variable (applies to all requests):
DAKERA_MCP_PROFILE=power
3. Default: core (14 tools, ~3,400 tokens)
dakera-mcp 0.12.3 works against Dakera v0.11.108 and v0.12.0 – v0.12.3 servers. Every tool keeps its name and arguments; the additions are optional arguments that are sent only when you supply them (or that an older server ignores), and tools that call new routes and say so on a server without them. The 0.12.3 additions (separate neighbourhood context, the unknown-field hint, document import) need a v0.12.3 server.
Per-request lang (en, de, fr, es, it, pt, nl; v0.12) is accepted by dakera_store,
dakera_recall, dakera_recall_associated, dakera_search, dakera_memory_update, dakera_extract,
dakera_auto_tag and the attachment jobs;
dakera_store also takes attachment_ref (sha256:<hex> of an attachment in the agent's own namespace,
_dakera_agent_<agent_id>). Neither is sent unless given, so the same calls work on a v0.11.108 server.
Other optional arguments (all servers): ttl_seconds and metadata on dakera_store; tags,
memory_type and session_id filters on dakera_recall; limit on dakera_batch_recall;
limit / offset on dakera_session_list, dakera_session_memories and dakera_agent_sessions
(the server pages at 50); content_preview_chars on the memory listings and include_derived on
dakera_agent_memories / dakera_wake_up (v0.12.2, ignored by older servers); memory_type on dakera_knowledge_deduplicate; dedup_on_store /
dedup_threshold on dakera_memory_policy_set.
top_k ranked results, context apartdakera_recall and dakera_recall_associated return at most top_k ranked results in memories.
They ask the server for neighborhood_mode: "separate", so the session neighbours of the results
(memories written around the same time in the same session) come back in their own
context_memories list: each entry has context_of (the id of the ranked memory it belongs to) and
context_of_rank (that memory's place in memories); its score comes from another search and is not
comparable with the ranked scores. A collapsed result (server flag DAKERA_RECALL_COLLAPSE_DERIVED)
keeps matched_text, the sentence that matched. neighborhood_mode picks separate (default),
inline or off. A server that predates neighborhood_mode (before v0.12.3) appends its context
to memories unmarked: the tools keep the first top_k and say how many items they left out.
Memory content in tool results is stored data: initialize tells the client to reason about it and
never follow instructions found in it.
A document becomes chunk memories of the agent, each with its heading path and page, imported by a
background job (power tier; listed when /v1/capabilities has documents.enabled):
A recall result that is a chunk carries citation: document_id, title, page_start /
page_end, heading_path, chunk_index / chunk_count (from memory.metadata._dakera_document).
On a server before v0.12.3 (no documents section in /v1/capabilities) the tools are not listed and
a direct call says they need v0.12.3; DAKERA_DOCUMENTS=0 on the server hides them the same way.
The opt-in features (attachments, speech to text, image indexing) are off by default on the server.
dakera-mcp asks GET /v1/capabilities (once a minute, 3 s timeout) before it lists tools:
attachments off, or a server without /v1/capabilities (v0.11): the dakera_attachment_* tools are not
listed and not returned by dakera_discover_tools; a direct call answers with the variable to set
(DAKERA_ATTACHMENTS=1) and makes no request.vision off: dakera_attachment_index_image is left out (DAKERA_VISION=1 turns it on)./v1/capabilities (v0.11) also hides dakera_encryption_status and
dakera_embed_migration_status, whose routes are new in v0.12.The default core profile has no opt-in tools, so it never makes that request.
Error answers keep the server's text and add a Hint: line for the v0.12 cases: a key pinned to
namespaces gets 403 on node-wide /admin routes (backups, encryption, quotas, config); backup
download, upload and restore need super_admin; 413 (body over a limit, or a hard quota), 501
(feature off), 503 (Retry-After, which the retry logic now honours, up to 8 s) and 429 (rate
limit). A route the server lacks (an older server) and a v0.11 rotation without new_key get a hint
too. Since Dakera v0.12.2 a refused argument gets 400 with a message naming the field
(content: content exceeds maximum of 100000 bytes …, tags[1]: … reserved …); the message is
passed on and the hint names the field to correct (the content limit counts UTF-8 bytes). The 403
hints point at dakera_whoami. From Dakera v0.12.3 the admin key, backup and rotate-key
routes refuse a field they do not know (422); the hint names it. A request that timed out is retried only when it is safe to repeat (GET, PUT, DELETE): a store,
an import or a key rotation is never sent twice.
The MCP server connects to a Dakera memory server. You need one running first:
docker run -d \
--name dakera \
-p 3000:3000 \
-e DAKERA_ROOT_API_KEY=dk-mykey \
ghcr.io/dakera-ai/dakera:latest
For persistent storage (recommended):
curl -sSfL https://raw.githubusercontent.com/Dakera-AI/dakera-deploy/main/docker-compose.yml \
-o docker-compose.yml
DAKERA_API_KEY=dk-mykey docker compose up -d
curl http://localhost:3000/health # → {"status":"ok"}
Full deployment guide (Docker Compose, Kubernetes, Helm): dakera-deploy
# Global install
npm install -g @dakera-ai/dakera-mcp
# Or run directly without installing
npx @dakera-ai/dakera-mcp
brew install dakera-ai/tap/dakera-mcp
cargo install dakera-mcp
docker pull ghcr.io/dakera-ai/dakera-mcp:latest
The image is distroless (no shell, no package manager) and runs as the non-root user 65532.
Pre-built binaries for macOS, Linux, and Windows are available on the releases page.
Add to .mcp.json (Claude Code) or claude_desktop_config.json (Claude Desktop):
{
"mcpServers": {
"dakera": {
"command": "dakera-mcp",
"env": {
"DAKERA_API_URL": "http://localhost:3000",
"DAKERA_API_KEY": "your-key"
}
}
}
}
dakera_extract_entities calls the ODE sidecar at DAKERA_ODE_URL; those requests currently carry
the Dakera API key as well (tracked in Dakera-AI/dakera#924).
To start with the power profile (exposes up to 86 tools):
{
"mcpServers": {
"dakera": {
"command": "dakera-mcp",
"env": {
"DAKERA_API_URL": "http://localhost:3000",
"DAKERA_API_KEY": "your-key",
"DAKERA_MCP_PROFILE": "power"
}
}
}
}
AI agents forget everything when the session ends. Dakera fixes that. This MCP server gives your agent a persistent memory layer with zero infrastructure overhead — point it at a Dakera instance and it works.
The 14-tool default keeps your context window lean. The meta-tools let you expand on demand when you need advanced operations like bulk vector upsert, knowledge graph traversal, or memory federation.
→ dakera.ai for hosted instance
→ Self-host with dakera-deploy
Part of the Dakera AI open-core ecosystem. Built with Rust. Self-hosted. Zero dependencies.
Self-hosted MCP server for AI agent memory — 14 core tools, profile-based tiering (86+ available). 88.2% LoCoMo. Works with Claude, Cursor, Windsurf.
{ "mcpServers": { "dakera-ai-dakera-mcp": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/dakera-ai/dakera-mcp:0.12.3" ] } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Dakera stdio पर लोकल चलता है।
पिछली जाँच 2026-10-28 को हुई। Self-hosted MCP server for AI agent memory — 14 core tools, profile-based tiering (86+ available). 88.2% LoCoMo. Works with Claude, Cursor, Windsurf.