MCP Server
dakera-mcp is the Model Context Protocol (MCP) server for Dakera. It gives an MCP client such as Claude Desktop, Claude Code, Cursor or Windsurf persistent memory, semantic search and knowledge graphs backed by your own Dakera server. This page covers installation, client configuration, tool profiles and the full tool reference.
The default core profile loads 14 tools (~3,500 tokens of tool schemas). Larger profiles expose up to 106 tools (about 21,600 tokens), and two meta-tools load individual tools on demand, so the context window stays small until you need more. dakera-mcp v0.12.3 is the current release and works with v0.12.3, v0.12.2, v0.12.1 and v0.12.0 servers (and v0.11.108, where the v0.12-only tools are hidden); its four document tools are listed only when the server reports document import (v0.12.3), and on an older server a direct call says it needs v0.12.3.
Current release@dakera-ai/dakera-mcp 0.12.3released 2026-10-22 · release train 0.12.3
- New tools:
dakera_import_document,dakera_document_status,dakera_list_documents,dakera_delete_document; recall results that are document chunks carry a citation. dakera_recallanddakera_recall_associatedreturn at mosttop_kranked results, with session context listed apart (neighborhood_mode).- Profiles:
all106 tools,power86,core14,admin34. The API key never reaches the logs.
npm install -g @dakera-ai/dakera-mcp@0.12.3 What changed → All current versions →
Watch it run: a real session on a clean machine. It installs dakera-mcp, registers it with Claude Code and checks the connection, then calls dakera_store and dakera_recall through a 47-line MCP client, so you can see what the tools return.
export DAKERA_API_URL=http://localhost:3000
export DAKERA_API_KEY=dk-mykey
npm install -g @dakera-ai/dakera-mcp
added 2 packages in 1s
npm notice
npm notice New major version of npm available! 10.9.4 -> 12.2.0
npm notice Changelog: https://github.com/npm/cli/releases/tag/v12.2.0
npm notice To update run: npm install -g npm@12.2.0
npm notice
curl -H "Authorization: Bearer $DAKERA_API_KEY" "$DAKERA_API_URL/v1/capabilities"
{"capabilities_version":2,"server_version":"0.12.2","api_versions":["v1"],"default_model":"bge-large","models":[{"name":"bge-large","aliases":["bge-large-en","bge-large-en-v1.5"],"dimension":1024,"max_seq_length":512,"effective_max_seq_length":512,"active":true,"modality":"text"},{"name":"minilm","aliases":["all-minilm … (4,630 more characters)
claude mcp add dakera -- dakera-mcp
Added stdio MCP server dakera with command: dakera-mcp to local config
File modified: /tmp/tmp.JhdjDplT8F/.claude.json [project: /tmp/tmp.JhdjDplT8F/my-project]
claude mcp list
dakera: dakera-mcp - ✔ Connected
cat > mcp-demo.mjs <<'EOF'
// A minimal MCP client: JSON-RPC 2.0 over stdio, one message per line.
import { spawn } from 'node:child_process';
const mcp = spawn('dakera-mcp', [], { stdio: ['pipe', 'pipe', 'ignore'] });
const pending = new Map();
let buf = '', nextId = 1;
mcp.stdout.on('data', (chunk) => {
buf += chunk;
for (let nl; (nl = buf.indexOf('\n')) >= 0; buf = buf.slice(nl + 1)) {
const line = buf.slice(0, nl).trim();
if (!line) continue;
const msg = JSON.parse(line);
pending.get(msg.id)?.(msg);
pending.delete(msg.id);
}
});
const send = (msg) => mcp.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n');
const call = (method, params) => new Promise((resolve) => {
const id = nextId++;
pending.set(id, resolve);
send({ id, method, params });
});
const tool = async (name, args) =>
JSON.parse((await call('tools/call', { name, arguments: args })).result.content[0].text);
const init = await call('initialize', {
protocolVersion: '2024-11-05',
capabilities: {},
clientInfo: { name: 'mcp-demo', version: '1.0.0' },
});
send({ method: 'notifications/initialized' });
console.log('server:', init.result.serverInfo.name, init.result.serverInfo.version);
const { result: { tools } } = await call('tools/list', {});
console.log(`tools/list: ${tools.length} tools`);
console.log(' ', tools.map((t) => t.name).join(', '));
for (const content of ['The user prefers dark mode', 'Deploys go out through GitHub Actions on Fridays']) {
const r = await tool('dakera_store', { agent_id: 'my-agent', content, importance: 0.8 });
console.log('dakera_store →', r.memory.id, JSON.stringify(r.memory.content));
}
const r = await tool('dakera_recall', { agent_id: 'my-agent', query: 'what theme does the user like?' });
for (const m of r.memories) {
console.log('dakera_recall →', m.score.toFixed(2), JSON.stringify(m.memory.content));
}
mcp.kill();
EOF
node mcp-demo.mjs
server: dakera-mcp 0.12.2
tools/list: 14 tools
dakera_store, dakera_recall, dakera_forget, dakera_batch_recall, dakera_batch_forget, dakera_search, dakera_session_start, dakera_session_end, dakera_knowledge_graph, dakera_fulltext_search, dakera_hybrid_search, dakera_extract, dakera_discover_tools, dakera_load_tools
dakera_store → mem_18df498a00a9e84e "The user prefers dark mode"
dakera_store → mem_18df498a0bc6bbdf "Deploys go out through GitHub Actions on Fridays"
dakera_recall → 0.60 "The user prefers dark mode"
dakera_recall → 0.00 "Deploys go out through GitHub Actions on Fridays"
Recorded on a shared 4-core Linux container with a Dakera server already running (started as in the Quick Start); Claude Code ran with an empty, isolated HOME; waits shortened.8 commands · 3.5 s real time
Quick start
You need a running Dakera server (see Quick Start) and its URL and API key.
1. Set your environment
dakera-mcp reads two environment variables (it takes no command-line flags):
| Variable | What it is | Example |
|---|---|---|
| DAKERA_API_URL | Address of your running Dakera server (default http://) | http:// or http://<SERVER_ |
| DAKERA_API_KEY | API key sent to the server (the root key or a scoped key) | dk-mykey |
Where is my server? If you started Dakera with
docker run -p 3000:3000 ... on a remote host, use http://<SERVER_IP>:3000. For a local dev machine, use http://localhost:3000. For Kubernetes with an ingress, use your ingress hostname.export DAKERA_API_URL=http://<YOUR_SERVER_IP>:3000
export DAKERA_API_KEY=<your-api-key>2. Install dakera-mcp
npm install -g @dakera-ai/dakera-mcp
# or run without installing:
npx @dakera-ai/dakera-mcpbrew install dakera-ai/tap/dakera-mcpcargo install dakera-mcpDon't have Rust? curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
docker run --rm -i \
-e DAKERA_API_URL=$DAKERA_API_URL \
-e DAKERA_API_KEY=$DAKERA_API_KEY \
ghcr.io/dakera-ai/dakera-mcp:latestFrom v0.12.0 the image is a static binary on distroless/static (about 14 MB, no shell or OS packages, runs as non-root uid 65532). Inside the container localhost is the container itself: point DAKERA_API_URL at http://host.docker.internal:3000 (on Linux add --add-host=host.docker.internal:host-gateway) or at the server's address on a shared Docker network.
3. Verify connectivity
Check that the server is reachable and accepts your key (any key with read scope can read the capabilities document):
curl -H "Authorization: Bearer $DAKERA_API_KEY" "$DAKERA_API_URL/v1/capabilities"
# 200 with a JSON document: URL and key are correct
# 401 / 403: check DAKERA_API_KEYOnce your client is connected (step 4), its MCP tool list shows the 14 core tools (dakera_store, dakera_recall, …).
4. Connect your AI client
Add Dakera to your client's MCP config. Replace placeholders with your actual values. For step-by-step client-specific guides: Cursor · Claude Desktop
// Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json
// Claude Code: .mcp.json (project), or run: claude mcp add dakera -e DAKERA_API_URL=http://<YOUR_SERVER_IP>:3000 -e DAKERA_API_KEY=<your-api-key> -- dakera-mcp
// Cursor: ~/.cursor/mcp.json
// Windsurf: ~/.codeium/windsurf/mcp_config.json
{
"mcpServers": {
"dakera": {
"command": "dakera-mcp",
"env": {
"DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3000",
"DAKERA_API_KEY": "<your-api-key>"
}
}
}
}Restart your client after editing. For Zed, use context_servers with a command.path key instead of mcpServers.
5. Test it
Ask your AI assistant: "Store a memory that I prefer dark mode" — it should call dakera_store and confirm the memory was saved.
Profiles & tool selection
The 106 tools are grouped into four profiles, so an agent pays the token cost only for the tools it loads. The default core profile covers day-to-day memory work. power and admin each add a separate set of tools to core; all is core + power + admin.
Which profile do I need?
| Your use case | Profile | Why |
|---|---|---|
| Day-to-day agent memory (store, recall, search) | core (default) | 14 tools, ~3,500 tokens — lean and fast |
| Knowledge graphs + entity extraction | power | Adds graph traversal, entity extraction, agent stats, memory policies, vector and text-index tools, agent creation, session touch, whoami and document import (86 tools) |
| Multi-tenant deployment with namespace isolation | admin | Core + namespaces, namespace keys, decay settings, audit, import/export (34 tools, ~6,850 tokens) |
| Custom embeddings + full API surface | all | Every tool: core + power + admin (106 tools, about 21,600 tokens) |
| Start small, add tools as needed | core + meta-tools | Use dakera_ + dakera_ to pull in extras on demand |
Setting your profile
# Option 1: Environment variable (recommended)
DAKERA_MCP_PROFILE=power # Options: core, power, admin, all
# Option 2: per request, in the tools/list params
{"profile": "power"}
# Option 3: Default — core (14 tools, ~3,500 tokens)Profile overview
Core Default
14 tools
Store, recall, search, sessions, knowledge graphs. Everything most agents need. ~3,500 tokens.
Power
86 tools
Core + graph traversal, entity extraction, feedback, agent stats, memory policies, vectors, full-text index, agent creation, session touch, whoami.
Admin
34 tools
Core + namespaces, namespace API keys, decay settings, audit log, import/export, vector bulk operations. ~6,850 tokens.
All
106 tools
Core + power + admin: every tool. About 21,600 tokens.
On-demand tool discovery
Instead of switching profiles, you can discover and load individual tools at runtime using the two meta-tools (always available in every profile):
# Step 1: Browse available tools by keyword or tier
dakera_discover_tools(tier="power")
# → returns tool names + descriptions (no schemas loaded, no token cost)
# Step 2: Load schemas for the tools you need
dakera_load_tools(tools=["dakera_consolidate", "dakera_agent_stats"])
# → returns full inputSchema for each tool — now callable in this session
# Step 3: Use the tool normally
dakera_consolidate(agent_id="my-agent", memory_ids=["mem_1", "mem_2"])Recommendation: Start with
core and load extras with dakera_discover_tools + dakera_load_tools. Switch to a larger profile when your agent uses non-core tools regularly.Core tools by workflow
The 14 core tools organized by what you're trying to do, not by implementation category.
Memory: store, find, and manage
The fundamental memory CRUD operations — store information, find it later, and clean up what you don't need.
dakera_store Core
Store a memory for an agent.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent identifier storing this memory |
| content | string | Yes | — | Memory text to store |
| importance | number | No | 0.5 | Score 0.0–1.0 for recall ranking and decay |
| tags | string[] | No | [] | Metadata tags for filtering |
| memory_type | string | No | episodic | One of: episodic, semantic, procedural, working |
| session_id | string | No | — | Associate this memory with an active session |
| expires_at | integer | No | — | Unix timestamp for hard-delete expiry |
dakera_recall Core
Semantic recall — returns the most relevant memories for a natural language query.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent to recall memories from |
| query | string | Yes | — | Natural language query text |
| top_k | integer | No | 5 | Number of results to return |
| min_importance | number | No | 0 | Minimum importance threshold |
| include_associated | boolean | No | false | Include knowledge-graph linked memories |
| since | string | No | — | ISO-8601 timestamp — only memories created after |
| until | string | No | — | ISO-8601 timestamp — only memories created before |
| neighborhood_mode | string | No | separate | separate, inline or off: session context comes back apart from the ranked results, in context_ (v0.12.3) |
Results come best first, ordered by rank_score on a v0.12.3 server; memories holds at most top_k results. Results that are document chunks carry a citation (title, pages, section).
dakera_search Core
Advanced memory search with tag, type, and importance filters.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent to search |
| query | string | Yes | — | Search query text |
| top_k | integer | No | 10 | Number of results |
| tags | string[] | No | — | Filter by tags (all must match) |
| memory_type | string | No | — | Filter by memory type |
dakera_batch_recall Core
Filter-based bulk recall without semantic search. Efficient for retrieving memories by tags, importance, or time range.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent to query |
| tags | string[] | No | — | All-match tag filter |
| min_importance | number | No | — | Minimum importance (inclusive) |
| max_importance | number | No | — | Maximum importance (inclusive) |
| created_after | integer | No | — | Unix timestamp lower bound |
| created_before | integer | No | — | Unix timestamp upper bound |
| memory_type | string | No | — | Filter by type |
| session_id | string | No | — | Only memories from this session |
dakera_forget Core
Delete specific memories by ID or tag filter.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent whose memories to delete |
| memory_ids | string[] | No | — | Specific memory IDs to delete |
| tags | string[] | No | — | Delete all memories matching these tags |
dakera_batch_forget Core
Bulk delete all memories matching filter predicates.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent whose memories to delete |
| tags | string[] | No | — | Tag filter (all must match) |
| min_importance | number | No | — | Minimum importance threshold |
| max_importance | number | No | — | Maximum importance threshold |
| created_after | integer | No | — | Unix timestamp lower bound |
| created_before | integer | No | — | Unix timestamp upper bound |
| memory_type | string | No | — | Filter by type |
| session_id | string | No | — | Only memories from this session |
Search: hybrid and full-text
Beyond semantic recall, Dakera offers BM25 keyword search and hybrid search that combines both approaches.
dakera_hybrid_search Core
Combined vector similarity + BM25 full-text search. Omit vector for BM25-only mode.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| namespace | string | Yes | — | Namespace to search in |
| text | string | Yes | — | Text query for full-text search |
| vector | number[] | No | — | Query vector (omit for BM25-only) |
| top_k | integer | No | 10 | Number of results |
| vector_weight | number | No | 0.5 | Weight for vector score (0.0–1.0); text weight is 1 − value |
| filter | object | No | — | Metadata filter |
| include_metadata | boolean | No | — | Return metadata with each result |
| include_vectors | boolean | No | — | Return vectors with each result |
dakera_fulltext_search Core
BM25 keyword search across indexed documents.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| namespace | string | Yes | — | Namespace to search |
| query | string | Yes | — | BM25 keyword query |
| top_k | integer | No | 10 | Number of results |
| filter | object | No | — | Metadata filter |
Sessions: group related memories
Sessions let you group memories from a single conversation or task, making it easy to recall context from a specific interaction.
dakera_session_start Core
Start a new session. Memories stored with the returned session_id are grouped together.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent starting the session |
| metadata | object | No | — | Arbitrary metadata (e.g. task type, user context) |
dakera_session_end Core
End an active session with an optional summary.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| session_id | string | Yes | — | Session to end |
| summary | string | No | — | Summary of what happened in this session |
Knowledge graphs
Build, traverse, and query relationship graphs between memories. Build graphs from embedding similarity, then traverse or export them.
dakera_knowledge_graph Core
Build a knowledge graph from a seed memory via embedding similarity.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| agent_id | string | Yes | — | Agent whose memories to graph |
| memory_id | string | Yes | — | Seed memory to start from |
| depth | integer | No | 2 | How many hops from the seed |
| min_similarity | number | No | 0.7 | Minimum similarity to create an edge |
dakera_extract Core
Extract structured info (entities, topics, key phrases, summary) from text.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| text | string | Yes | — | Text to extract from |
| namespace | string | No | — | Namespace context |
| entity_types | string[] | No | — | Entity types to extract |
| extractor_override | object | No | — | Per-request provider override (takes precedence over the namespace default) |
Meta-tools: discover and load
Always available in every profile. Use these to explore and dynamically load tools from higher tiers.
dakera_discover_tools Always
Browse the full tool catalog by keyword or tier. Returns names and descriptions without loading schemas.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| tier | string | No | — | Filter by tier: core, power, admin, meta, all |
| query | string | No | — | Keyword search across tool names/descriptions |
dakera_load_tools Always
Load full schemas for specific tools, making them callable in this session.
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| tools | string[] | Yes | — | Tool names to load (e.g. ["dakera_) |
Full tool reference by tier
The tools each profile adds to core, as listed by tools/list in dakera-mcp v0.12.3. Core tools are documented above. The all profile is core + power + admin (14 + 72 + 20 = 106 tools); it adds no tools of its own. v0.12.2 added three power tools (dakera_agent_create, dakera_session_touch, dakera_whoami) and pages tools/list 128 tools at a time, so the all profile fits on one page. v0.12.3 added four power tools for document import (dakera_import_document, dakera_document_status, dakera_list_documents, dakera_delete_document).
Power profile (86 tools: core + 72)
| Tool | Description | Key parameters |
|---|---|---|
dakera_ | Import a document as chunk memories of an agent that recall can cite: content as text, Markdown or HTML, or the attachment_ref of an uploaded PDF or DOCX; re-importing a document_id replaces the document (v0.12.3+) | agent_id, content or attachment_ref, title, document_id, wait_seconds |
dakera_ | The import job: Pending, Running (progress), Completed or Failed (v0.12.3+) | agent_id, job_id |
dakera_ | An agent's documents: id, title, media type, chunk count, size, pages (v0.12.3+) | agent_id, limit, cursor |
dakera_ | Delete a document with all its chunks (v0.12.3+) | agent_id, document_id |
dakera_ | Create an agent (its memory namespace) before its first memory; idempotent (created: false for an existing agent). Needs a v0.12.2 server; on an older one it answers that the first stored memory creates the agent | agent_id |
dakera_ | Keep a session open while the agent works without storing or recalling (servers end idle sessions after 4 h by default from v0.12.2); answers session_state and idle_ | session_id |
dakera_whoami | Show the API key this MCP server uses, as Dakera reads it: scope, namespaces (including p* prefix patterns), expires_at, inert_; call it when a tool gets 403 (v0.12.2+) | — |
dakera_wake_up | Load an agent's startup context in one call: its top memories ranked by importance and recency of use, with no query and no embedding; use it at the start of a run, before any recall | agent_id, top_n, … |
dakera_ | Merge a set of memories into a synthesized summary, de-duplicating overlap | agent_id, memory_ids |
dakera_ | Fetch one memory by ID | memory_id, agent_id |
dakera_ | Edit an existing memory's content, importance, or tags | memory_id, agent_id, … |
dakera_ | Semantic recall that expands results by following Knowledge Graph edges from each matched memory to its linked neighbors (1–3 hops) | agent_id, query, … |
dakera_ | Batch-update importance scores for multiple memories in a single call | agent_id, updates |
dakera_ | List sessions for an agent, newest first | agent_id, … |
dakera_ | Fetch the full record for a session: metadata, summary, timestamps, and memory count | session_id |
dakera_ | Return all memories stored under a specific session | session_id |
dakera_ | Return an agent's memory footprint: count, session count, approximate storage, and top tags | agent_id |
dakera_ | Paginate through all memories belonging to an agent, ordered by recency | agent_id, … |
dakera_ | List all sessions (active and closed) for an agent with timestamps and summaries | agent_id |
dakera_ | Combine 2+ memories into a synthesized semantic memory | agent_id, memory_ids, … |
dakera_ | Scan for duplicate or near-duplicate memories above a cosine similarity threshold and optionally merge them | agent_id, … |
dakera_ | Build a cross-agent similarity graph across agent memory stores | agent_ids, max_cross_edges, max_, min_importance, min_similarity |
dakera_ | Read the memory lifecycle policy for a namespace: TTL per type, decay curve, spaced-repetition, consolidation, and rate limits | namespace |
dakera_ | Update the memory lifecycle policy for a namespace | namespace, … |
dakera_ | Insert or replace vectors (by ID) in a namespace | namespace, vectors |
dakera_ | Remove specific vectors by ID | namespace, ids |
dakera_ | Run multiple similarity searches in one request, each with its own vector, top_k, and filter | namespace, queries |
dakera_ | Return the count of vectors in a namespace, optionally scoped by a metadata filter | namespace, … |
dakera_ | Paginate through all vectors with optional values and metadata | namespace, … |
dakera_ | Compute Count/Sum/Avg/Min/Max on metadata fields across vectors, with optional group-by | namespace, aggregate_by, … |
dakera_ | Search with weighted positive and negative vectors, optional MMR diversity and score threshold | namespace, positive_, … |
dakera_ | Upsert vectors in columnar form (parallel arrays of ids, vectors, attributes) | namespace, ids, vectors, … |
dakera_ | Return the query execution plan showing index selection, stages, and cost estimates | namespace, query_type (vector_search | full_text_search | hybrid_search | multi_vector | batch_query), … |
dakera_ | Pre-load a namespace (or specific vectors) into memory to reduce cold-start latency | namespace, … |
dakera_ | Flexible ranked retrieval using the rank_by DSL combining vector ANN, BM25, and attribute ordering | namespace, rank_by, … |
dakera_ | Query a namespace with natural language text — the server embeds the text and runs ANN similarity search | namespace, text, … |
dakera_ | Store text documents with automatic server-side embedding | namespace, documents, … |
dakera_ | Run multiple natural-language similarity searches in a single request, all embedded server-side | namespace, queries, … |
dakera_ | Add or replace documents in the BM25 index | namespace, documents |
dakera_ | Remove documents from the BM25 index by ID | namespace, ids |
dakera_ | Return BM25 index stats for a namespace: document count, unique term count, average document length | namespace |
dakera_ | Return AutoPilot configuration and last-cycle stats (memories deduped, consolidated, timestamps) | (none) |
dakera_ | Trigger an AutoPilot cycle immediately | action (dedup | consolidate | all) |
dakera_auto_tag | Extract typed entity spans from text using GLiNER NER and optional rule-based pre-pass (dates, URLs, emails, IPs) | content, … |
dakera_ | Enable or disable automatic GLiNER entity tagging at memory write time for a namespace, and set which entity types to extract | namespace, extract_, entity_types |
dakera_ | Get the current entity extraction configuration for a namespace — whether automatic tagging is enabled and which entity types are configured | namespace |
dakera_ | Retrieve entity tags extracted when a memory was written: type, value, and confidence score per entity | memory_id |
dakera_ | Traverse the memory knowledge graph via BFS to discover connected memories | agent_id, depth, edge_type, limit, memory_id, … |
dakera_ | Find the shortest path between two memory nodes, returning the ordered sequence of IDs and edge hops | from_id, to_id |
dakera_ | Create an explicit linked_by edge between two memories | memory_id, target_id, agent_id |
dakera_ | Export an agent's knowledge graph as JSON or GraphML (compatible with Gephi, yEd, Cytoscape) | agent_id, … |
dakera_ | Submit a feedback signal (upvote/downvote/flag) on a memory | agent_id, memory_id, signal (upvote | downvote | flag) |
dakera_ | Retrieve the feedback history for a memory: all upvote, downvote, and flag signals with timestamps | agent_id, memory_id |
dakera_ | Get aggregate feedback stats for an agent's memories: total upvotes, downvotes, flags, and the top-rated/most-flagged memories | agent_id |
dakera_ | Truth-Indeterminacy-Falsity reliability scores for a memory from its feedback history | memory_id, … |
dakera_ | Read the default extraction provider config for a namespace | namespace |
dakera_ | Set or update the default extraction provider for a namespace | namespace, provider (none | gliner | openai | anthropic | openrouter | ollama), … |
dakera_ | Named-entity extraction through the external GLiNER extraction service (returns labels, offsets, confidence) | content, agent_id, … |
dakera_ | Readiness probe (storage and models loaded) | (none) |
dakera_ | Liveness probe | (none) |
dakera_ | Prometheus-format server metrics | (none) |
dakera_ | List active and recent background jobs (backup, restore, migration, reindex) with status and progress | (none) |
dakera_get_job | Fetch status, progress, and result for a background job by UUID | job_id |
Admin profile (34 tools: core + 20)
| Tool | Description | Key parameters |
|---|---|---|
dakera_ | List all namespaces with dimensions, distance metrics, and vector counts | (none) |
dakera_ | Fetch a namespace's configuration and stats: dimensions, distance metric, vector count, and HNSW parameters | namespace |
dakera_ | Create a vector namespace with the specified dimension and distance metric | name, dimension, … |
dakera_ | Permanently delete a namespace and all of its vectors, full-text index, and metadata | namespace |
dakera_ | Idempotent create-or-update of a namespace | namespace, dimension, … |
dakera_ | Create a new API key scoped to a specific namespace with the given permission level (read/write/admin) | namespace, name, scope (read | write | admin), … |
dakera_ | List API keys with access to a namespace (metadata only, no raw values) | namespace |
dakera_ | Immediately revoke a namespace-scoped API key by ID | namespace, key_id |
dakera_ | Return request counts, last-used timestamp, and rate-limit status for a key | namespace, key_id |
dakera_ | Apply a metadata update to all vectors matching a filter | namespace, filter, update |
dakera_ | Delete all vectors matching a metadata filter | namespace, filter |
dakera_ | Read global memory-decay config: strategy, half-life hours, and minimum importance threshold | (none) |
dakera_ | Update memory-decay parameters at runtime without restarting the server | half_life_hours, min_importance, strategy (exponential | linear | step) |
dakera_ | Return cumulative decay stats: memories decayed/deleted, cycle count, and last-cycle timestamp | (none) |
dakera_ | Query the audit log of memory lifecycle events with optional filters by agent, event type, and time range (Unix ms) | agent_id, event_type, from, limit, to |
dakera_ | Export all memories for an agent as a portable payload (jsonl, csv, mem0, or zep) | agent_id, … |
dakera_ | Import memories from a JSONL, CSV, Mem0, or Zep payload | agent_id, data, … |
dakera_ | Rotate the at-rest encryption key for memory content | new_key, … |
Client guides: Cursor · Claude Desktop · Blog: How MCP works · Setup walkthrough · Real-world use cases
MCP server is running · your agent remembers
Claude and Cursor with persistent memory
The ~101 MB server binary handles storage, embeddings and recall on your own infrastructure, with no external API calls. Self-hosted is free and available now. Managed cloud is coming.