Dakera Documentation

Quick Start

Store your first memory in under 10 minutes.

docker run -d \
  --name dakera \
  --restart unless-stopped \
  -p 3300:3300 \
  -e DAKERA_PORT=3300 \
  -e DAKERA_ROOT_API_KEY=my-dev-key \
  -e DAKERA_STORAGE=filesystem \
  -e DAKERA_STORAGE_PATH=/data \
  -v dakera-data:/data \
  ghcr.io/dakera-ai/dakera:latest

curl http://localhost:3300/health
# {"service":"dakera","status":"healthy","version":"0.11.55"}

# Remote server:
curl http://<YOUR_SERVER_IP>:3300/health

pip install dakera

npm install dakera
# yarn add dakera | pnpm add dakera

go get github.com/dakera-ai/dakera-go

# Cargo.toml
[dependencies]
dakera-client = "0.11"

cargo install dakera-cli
dk init # interactive setup wizard

import os
from dakera import DakeraClient

# Configure via env vars (recommended) or pass directly:
# export DAKERA_URL=http://<YOUR_SERVER_IP>:3300
# export DAKERA_API_KEY=my-dev-key

client = DakeraClient(
    base_url=os.getenv("DAKERA_URL", "http://localhost:3300"),
    api_key=os.getenv("DAKERA_API_KEY")
)

client.memories.store(
    agent_id="my-agent",
    content="User prefers dark mode",
    importance=0.8,
    tags=["preference", "ui"]
)

import { DakeraClient } from 'dakera';

// Configure via env vars (recommended):
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=my-dev-key

const client = new DakeraClient({
  baseUrl: process.env.DAKERA_URL ?? 'http://localhost:3300',
  apiKey: process.env.DAKERA_API_KEY,
});

await client.memories.store({
  agentId: 'my-agent',
  content: 'User prefers dark mode',
  importance: 0.8,
  tags: ['preference', 'ui'],
});

import (
    dakera "github.com/dakera-ai/dakera-go"
    "os"
)

serverURL := os.Getenv("DAKERA_URL")
if serverURL == "" { serverURL = "http://localhost:3300" }

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: serverURL,
    APIKey:  os.Getenv("DAKERA_API_KEY"),
})

client.Memories.Store(ctx, &dakera.StoreRequest{
    AgentID:    "my-agent",
    Content:    "User prefers dark mode",
    Importance: 0.8,
    Tags:       []string{"preference", "ui"},
})

use dakera_client::{DakeraClient, Config, memory::StoreRequest};

let client = DakeraClient::new(Config {
    base_url: std::env::var("DAKERA_URL")
        .unwrap_or_else(|_| "http://localhost:3300".into()),
    api_key: std::env::var("DAKERA_API_KEY").ok(),
    ..Default::default()
})?;

client.memories().store(StoreRequest {
    agent_id: "my-agent".into(),
    content: "User prefers dark mode".into(),
    importance: Some(0.8),
    tags: vec!["preference".into()],
    ..Default::default()
}).await?;

response = client.memories.recall(
    agent_id="my-agent",
    query="what UI preferences does the user have?"
)

for m in response.memories:
    print(m.content, m.importance, m.score)

const response = await client.memories.recall({
  agentId: 'my-agent',
  query: 'what UI preferences does the user have?',
});

response.memories.forEach(m => console.log(m.content, m.importance, m.score));

MCP Server

Dakera ships as a native MCP server — 83 tools for Claude Desktop, Claude Code, Cursor, Windsurf, and any MCP-compatible client. No code changes required.

Install the MCP binary

Download a pre-built binary in one command — no Rust or build tools required:

# Linux x64 (also works in WSL)
curl -fsSL https://github.com/dakera-ai/dakera-mcp/releases/latest/download/dakera-mcp-linux-x64.tar.gz \
  | tar -xz -C /usr/local/bin
chmod +x /usr/local/bin/dakera-mcp

# Linux arm64
curl -fsSL https://github.com/dakera-ai/dakera-mcp/releases/latest/download/dakera-mcp-linux-arm64.tar.gz \
  | tar -xz -C /usr/local/bin

# Verify
dakera-mcp --version

# macOS Apple Silicon (M1/M2/M3)
curl -fsSL https://github.com/dakera-ai/dakera-mcp/releases/latest/download/dakera-mcp-macos-arm64.tar.gz \
  | tar -xz -C /usr/local/bin

# macOS Intel
curl -fsSL https://github.com/dakera-ai/dakera-mcp/releases/latest/download/dakera-mcp-macos-x64.tar.gz \
  | tar -xz -C /usr/local/bin

# Verify
dakera-mcp --version

# PowerShell — Windows x64
Invoke-WebRequest `
  -Uri "https://github.com/dakera-ai/dakera-mcp/releases/latest/download/dakera-mcp-windows-x64.zip" `
  -OutFile "$env:TEMP\dakera-mcp.zip"
Expand-Archive "$env:TEMP\dakera-mcp.zip" -DestinationPath "C:\tools\dakera-mcp" -Force

# Add C:\tools\dakera-mcp to your PATH, then verify:
dakera-mcp --version

# Requires Rust 1.70+
git clone https://github.com/dakera-ai/dakera-mcp
cd dakera-mcp
cargo build --release
# binary: ./target/release/dakera-mcp

Or browse all releases and checksums on the GitHub Releases page.

Point the MCP server at your Dakera instance

Set two environment variables — DAKERA_API_URL is the address of your running Dakera server (the IP or hostname where you deployed it), and DAKERA_API_KEY is the root key you set when starting the server.

# Quick test — verify connectivity before wiring up any client:
export DAKERA_API_URL=http://<YOUR_SERVER_IP>:3300
export DAKERA_API_KEY=<your-api-key>
dakera-mcp --test-connection
# Connected to Dakera v0.11.55 — 83 tools available

Environment variables

Connect your AI client

In all configs below, replace <YOUR_SERVER_IP> with your Dakera server address and <your-api-key> with your root API key. Use /usr/local/bin/dakera-mcp (Linux/macOS) or the full path where you extracted the binary.

// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
// %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
  "mcpServers": {
    "dakera": {
      "command": "/usr/local/bin/dakera-mcp",
      "env": {
        "DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3300",
        "DAKERA_API_KEY": "<your-api-key>"
      }
    }
  }
}

// .mcp.json in your project root (or ~/.claude/settings.json for global)
{
  "mcpServers": {
    "dakera": {
      "command": "/usr/local/bin/dakera-mcp",
      "env": {
        "DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3300",
        "DAKERA_API_KEY": "<your-api-key>"
      }
    }
  }
}

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "dakera": {
      "command": "/usr/local/bin/dakera-mcp",
      "env": {
        "DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3300",
        "DAKERA_API_KEY": "<your-api-key>"
      }
    }
  }
}

// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "dakera": {
      "command": "/usr/local/bin/dakera-mcp",
      "env": {
        "DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3300",
        "DAKERA_API_KEY": "<your-api-key>"
      }
    }
  }
}

// ~/.config/zed/settings.json
{
  "context_servers": {
    "dakera": {
      "command": {
        "path": "/usr/local/bin/dakera-mcp",
        "env": {
          "DAKERA_API_URL": "http://<YOUR_SERVER_IP>:3300",
          "DAKERA_API_KEY": "<your-api-key>"
        }
      }
    }
  }
}

# Open WebUI — add as an external tool server
# Admin Panel → Settings → Tools → Add Tool Server

Server URL:  http://<YOUR_SERVER_IP>:3300
# Or run the MCP binary as a sidecar and point at its HTTP bridge:
DAKERA_API_URL=http://<YOUR_SERVER_IP>:3300 \
  DAKERA_API_KEY=<your-api-key> \
  dakera-mcp --http-bridge --port 8811

# Then add http://localhost:8811 as tool server in Open WebUI

Verify the connection

# In Claude Code — ask Claude to use the dakera MCP server:
List the Dakera MCP tools available.
# Expected: Claude responds with 83 tool names across 8 categories

# Or test the underlying server directly:
curl -s -H "Authorization: Bearer <your-api-key>" \
  http://<YOUR_SERVER_IP>:3300/health
# {"service":"dakera","status":"healthy","version":"0.11.55"}

Tool categories (83 tools)

Tool reference

Memory tools (10)

dakera_store parameters

// Example
{
  "agent_id": "my-agent",
  "content": "User prefers concise bullet-point summaries.",
  "memory_type": "semantic",
  "importance": 0.8,
  "tags": ["preference", "style"]
}

dakera_recall parameters

dakera_batch_recall parameters

Filter-based bulk recall — no embedding required. All fields are optional and ANDed together; at least one must be set.

dakera_search parameters

Tag and type filters are applied before ranking (not as a soft signal), and defaults to top_k=10.

dakera_memory_get / dakera_memory_update / dakera_forget

Session tools (5)

// Start → store → end pattern
{ "agent_id": "my-agent", "metadata": { "task": "customer-support" } }  // session_start
{ "session_id": "sess_01abc", "summary": "Resolved billing question" }       // session_end

Agent tools (3)

Knowledge tools (4)

Namespace tools (9)

Vector tools (14)

Full-text & Inference tools (8)

The Inference tools (dakera_upsert_text, dakera_text_query, dakera_batch_query_text, dakera_hybrid_search) embed on the server — you never need to compute vectors client-side. Use these for text-first workflows.

Entity Extraction tools (8)

dakera_extract vs dakera_auto_tag: auto_tag uses GLiNER locally and returns entity labels only. dakera_extract supports pluggable backends (OpenAI, Anthropic, Ollama) and returns richer output: entities, topics, key phrases, and a summary.

Decay & AutoPilot tools (5)

Memory Feedback tools (3)

Knowledge Graph tools (7)

Admin & Audit tools (7)

CLI Reference

The dk binary lets you manage agent memory, vector operations, namespaces, and sessions from the terminal.

Installation

cargo install dakera-cli

Or download pre-built binaries from GitHub Releases.

Setup wizard

dk init

Prompts for server URL, tests connectivity, sets default namespace, and writes ~/.config/dakera/config.toml.

Global flags

Memory commands

# Store a memory
dk memory store --agent my-agent --content "User prefers dark mode" --importance 0.8

# Recall memories (semantic search)
dk memory recall --agent my-agent --query "UI preferences"

# Batch recall (filter-based)
dk memory recall --agent my-agent --tags preference --min-importance 0.7

# Forget a memory
dk memory forget mem-abc123

# List all memories for an agent
dk memory list --agent my-agent

Session commands

# Start a session
dk session start my-agent

# End a session
dk session end sess-abc123 --summary "Completed code review"

# List sessions for an agent
dk session list my-agent

Namespace commands

# Create a namespace
dk namespace create my-namespace --embedding-model MiniLML6V2

# List all namespaces
dk namespace list

# Delete a namespace
dk namespace delete my-namespace

Vector commands

# Upsert vectors from a JSON file
dk vector upsert my-namespace --file vectors.json

# Query nearest neighbors
dk vector query my-namespace --vector "[0.1,0.2,0.3]" --top-k 10

# Hybrid search
dk vector hybrid my-namespace --query "agent task completion" --top-k 5

Exit codes

Python SDK

PyPI · GitHub · Changelog

pip install dakera              # core (sync client)
pip install dakera[async]       # include async client
pip show dakera                 # verify installed version

Client setup

Point the client at your Dakera server. Use env vars to keep the URL and key out of source code:

import os
from dakera import DakeraClient

# Recommended: configure via env vars
# export DAKERA_URL=http://<YOUR_SERVER_IP>:3300
# export DAKERA_API_KEY=your-api-key

client = DakeraClient(
    base_url=os.getenv("DAKERA_URL", "http://localhost:3300"),
    api_key=os.getenv("DAKERA_API_KEY")
)

Memory operations

# Store
client.memories.store(
    agent_id="my-agent",
    content="User is learning Rust",
    importance=0.8,
    tags=["learning", "programming"]
)

# Recall — semantic search over stored memories
memories = client.memories.recall(
    agent_id="my-agent",
    query="programming languages the user knows",
    top_k=10
)

# Batch recall — filter-based, no semantic search
memories = client.memories.batch_recall(
    agent_id="my-agent",
    tags=["learning"],
    min_importance=0.6
)

# Forget a specific memory
client.memories.forget(memory_id="mem-abc123")

# Update importance
client.memories.set_importance(memory_id="mem-abc123", importance=0.9)

# Get a memory by ID
memory = client.memories.get(memory_id="mem-abc123")

Sessions

# Start a session
session = client.sessions.start(
    agent_id="my-agent",
    metadata={"task": "code review", "user": "alice"}
)

# Store memory linked to the session
client.memories.store(
    agent_id="my-agent",
    content="Reviewed auth module — found 2 security issues",
    session_id=session.id
)

# End session — auto-generates a summary
result = client.sessions.end(
    session_id=session.id,
    summary="Code review complete. 2 issues logged."
)

# List sessions for an agent
sessions = client.sessions.list(agent_id="my-agent")

# Get memories from a session
session_mems = client.sessions.memories(session_id=session.id)

Vector operations

# Upsert raw vectors
client.vectors.upsert(
    namespace="my-ns",
    vectors=[
        {"id": "v1", "values": [0.1, 0.2, 0.3], "metadata": {"label": "a"}},
    ]
)

# Query nearest neighbors
results = client.vectors.query(
    namespace="my-ns",
    vector=[0.1, 0.2, 0.3],
    top_k=10,
    include_metadata=True
)

# Hybrid search (vector + BM25)
results = client.vectors.hybrid_search(
    namespace="my-ns",
    query="agent task completion",
    top_k=10
)

# Full-text search
results = client.fulltext.search(
    namespace="my-ns",
    query="authentication issues",
    top_k=5
)

Namespaces

# Create an isolated namespace for your project
client.namespaces.create(namespace="project-alpha", embedding_model="MiniLML6V2")

# Upsert vectors into a namespace
client.vectors.upsert(
    namespace="project-alpha",
    vectors=[{"id": "doc-1", "values": [0.1, 0.2, 0.3], "metadata": {"title": "intro"}}]
)

# Hybrid search across that namespace
results = client.vectors.hybrid_search(
    namespace="project-alpha",
    query="project goals and milestones",
    top_k=10
)

# List all namespaces
ns_list = client.namespaces.list()

# Delete a namespace (irreversible)
client.namespaces.delete(namespace="project-alpha")

Error handling

from dakera import DakeraClient, DakeraError, AuthorizationError, NotFoundError

try:
    client.memories.get(memory_id="mem-does-not-exist")
except NotFoundError:
    print("Memory not found")
except AuthorizationError:
    print("Invalid API key — check DAKERA_API_KEY")
except DakeraError as e:
    print(f"Dakera error: {e.error_code} — {e.message}")

Async client

import os, asyncio
from dakera import AsyncDakeraClient

async def main():
    async with AsyncDakeraClient(
        base_url=os.getenv("DAKERA_URL", "http://localhost:3300"),
        api_key=os.getenv("DAKERA_API_KEY")
    ) as client:
        await client.memories.store(agent_id="agent", content="async example")
        memories = await client.memories.recall(agent_id="agent", query="async")
        print(memories)

asyncio.run(main())

TypeScript SDK

npm · GitHub · Changelog

npm install dakera
# yarn add dakera | pnpm add dakera | bun add dakera

Client setup

import { DakeraClient } from 'dakera';

// Recommended: set via env vars
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=your-api-key

const client = new DakeraClient({
  baseUrl: process.env.DAKERA_URL ?? 'http://localhost:3300',
  apiKey: process.env.DAKERA_API_KEY,
});

Memory operations

// Store
await client.memories.store({
  agentId: 'my-agent',
  content: 'User is learning Rust',
  importance: 0.8,
  tags: ['learning', 'programming'],
});

// Recall — semantic search
const memories = await client.memories.recall({
  agentId: 'my-agent',
  query: 'programming languages the user knows',
  topK: 10,
});

// Batch recall — filter-based
const filtered = await client.memories.batchRecall({
  agentId: 'my-agent',
  tags: ['learning'],
  minImportance: 0.6,
});

// Forget
await client.memories.forget({ memoryId: 'mem-abc123' });

// Update importance
await client.memories.setImportance({ memoryId: 'mem-abc123', importance: 0.9 });

Sessions

// Start session
const session = await client.sessions.start({
  agentId: 'my-agent',
  metadata: { task: 'code review' },
});

// Store memory linked to session
await client.memories.store({
  agentId: 'my-agent',
  content: 'Reviewed auth module',
  sessionId: session.id,
});

// End session
const result = await client.sessions.end({
  sessionId: session.id,
  summary: 'Code review complete',
});

// List sessions
const sessions = await client.sessions.list({ agentId: 'my-agent' });

TypeScript types

import type {
  MemoryRecord,       // { id, agentId, content, importance, tags, createdAt, sessionId? }
  RecallResult,       // extends MemoryRecord with score: number
  StoreMemoryRequest, // { agentId, content, importance?, tags?, sessionId? }
  RecallRequest,      // { agentId, query, topK? }
  Session,            // { id, agentId, startedAt, endedAt?, memoryCount, summary? }
  DakeraClient,
} from 'dakera';

Namespaces & vector operations

// Create a namespace
await client.namespaces.create({ namespace: 'project-alpha' });

// Upsert vectors
await client.vectors.upsert({
  namespace: 'project-alpha',
  vectors: [{ id: 'doc-1', values: [0.1, 0.2, 0.3], metadata: { title: 'intro' } }],
});

// Hybrid search (vector + BM25)
const results = await client.vectors.hybridSearch({
  namespace: 'project-alpha',
  query: 'project goals',
  topK: 10,
});

Error handling

import { DakeraError, AuthorizationError, NotFoundError } from 'dakera';

try {
  await client.memories.get({ memoryId: 'mem-does-not-exist' });
} catch (err) {
  if (err instanceof NotFoundError) {
    console.error('Memory not found');
  } else if (err instanceof AuthorizationError) {
    console.error('Invalid API key — check DAKERA_API_KEY');
  } else if (err instanceof DakeraError) {
    console.error(`${err.errorCode}: ${err.message}`);
  }
}

Go SDK

pkg.go.dev · GitHub

go get github.com/dakera-ai/dakera-go@latest

Client setup

import (
    dakera "github.com/dakera-ai/dakera-go"
    "os"
    "time"
)

// Recommended: configure via env vars
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=your-api-key

serverURL := os.Getenv("DAKERA_URL")
if serverURL == "" { serverURL = "http://localhost:3300" }

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: serverURL,
    APIKey:  os.Getenv("DAKERA_API_KEY"),
    Timeout: 30 * time.Second,
})

Memory operations

// Store
_, err := client.Memories.Store(ctx, &dakera.StoreRequest{
    AgentID:    "my-agent",
    Content:    "User is learning Rust",
    Importance: 0.8,
    Tags:       []string{"learning"},
})

// Recall
memories, err := client.Memories.Recall(ctx, &dakera.RecallRequest{
    AgentID: "my-agent",
    Query:   "programming languages",
    TopK:    10,
})

// Batch recall
memories, err := client.Memories.BatchRecall(ctx, &dakera.BatchRecallRequest{
    AgentID:       "my-agent",
    Tags:          []string{"learning"},
    MinImportance: 0.6,
})

// Forget
err = client.Memories.Forget(ctx, "mem-abc123")

Sessions

session, err := client.Sessions.Start(ctx, &dakera.StartSessionRequest{
    AgentID:  "my-agent",
    Metadata: map[string]interface{}{"task": "review"},
})

result, err := client.Sessions.End(ctx, &dakera.EndSessionRequest{
    SessionID: session.ID,
    Summary:   "Review complete",
})

Vector operations

// Upsert
_, err = client.Upsert(ctx, "my-ns", []dakera.VectorInput{
    {ID: "v1", Values: []float32{0.1, 0.2, 0.3}, Metadata: map[string]interface{}{"label": "a"}},
})

// Hybrid search (vector + BM25)
results, err := client.HybridSearch(ctx, "my-ns", &dakera.HybridSearchRequest{
    Query: "agent task completion",
    TopK:  10,
})

// ANN vector query
results, err := client.Query(ctx, "my-ns", []float32{0.1, 0.2, 0.3}, &dakera.QueryOptions{
    TopK: 10, IncludeMetadata: true,
})

Error handling

import (
    dakera "github.com/dakera-ai/dakera-go"
    "errors"
    "log"
)

memories, err := client.Memories.Recall(ctx, &dakera.RecallRequest{
    AgentID: "my-agent",
    Query:   "important decisions",
    TopK:    10,
})
if err != nil {
    var authErr *dakera.AuthorizationError
    var notFoundErr *dakera.NotFoundError
    var dakeraErr *dakera.DakeraError

    switch {
    case errors.As(err, &authErr):
        log.Fatalf("authentication failed — check DAKERA_API_KEY: %v", authErr)
    case errors.As(err, &notFoundErr):
        log.Printf("agent or memory not found: %v", notFoundErr)
    case errors.As(err, &dakeraErr):
        log.Printf("dakera error %d: %s", dakeraErr.ErrorCode, dakeraErr.Message)
    default:
        log.Printf("network or serialisation error: %v", err)
    }
}

Rust SDK

crates.io · docs.rs · GitHub

# Cargo.toml
[dependencies]
dakera-client = "0.11"
tokio = { version = "1", features = ["full"] }

Client setup

use dakera_client::{DakeraClient, Config};

// Recommended: configure via env vars
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=your-api-key

let client = DakeraClient::new(Config {
    base_url: std::env::var("DAKERA_URL")
        .unwrap_or_else(|_| "http://localhost:3300".into()),
    api_key: std::env::var("DAKERA_API_KEY").ok(),
    ..Default::default()
})?;

Memory operations

use dakera_client::memory::{StoreRequest, RecallRequest};

// Store
client.memories().store(StoreRequest {
    agent_id: "my-agent".into(),
    content: "User is learning Rust".into(),
    importance: Some(0.8),
    tags: vec!["learning".into()],
    ..Default::default()
}).await?;

// Recall
let memories = client.memories().recall(RecallRequest {
    agent_id: "my-agent".into(),
    query: "programming languages".into(),
    top_k: Some(10),
    ..Default::default()
}).await?;

// Sessions
let session = client.sessions().start(StartRequest {
    agent_id: "my-agent".into(),
    ..Default::default()
}).await?;

gRPC transport

# Enable in Cargo.toml
dakera-client = { version = "0.11", features = ["grpc"] }

let client = DakeraClient::grpc(GrpcConfig {
    endpoint: "http://localhost:50051".into(),
    ..Default::default()
})?;

Error handling

use dakera_client::error::{DakeraError, ErrorKind};

match client.memories().recall(RecallRequest {
    agent_id: "my-agent".into(),
    query: "important decisions".into(),
    ..Default::default()
}).await {
    Ok(memories) => {
        for m in &memories { println!("{}: {}", m.id, m.content); }
    }
    Err(DakeraError { kind: ErrorKind::Unauthorized, .. }) => {
        eprintln!("Invalid API key — check DAKERA_API_KEY");
    }
    Err(DakeraError { kind: ErrorKind::NotFound, message, .. }) => {
        eprintln!("Not found: {message}");
    }
    Err(DakeraError { kind: ErrorKind::RateLimited, .. }) => {
        eprintln!("Rate limit hit — back off and retry");
    }
    Err(e) => {
        eprintln!("Dakera error [{:?}]: {}", e.kind, e.message);
    }
}

REST API Reference

All endpoints require Authorization: Bearer <key> when authentication is enabled.

Health

Memory

Store memory — request body

{
  "agent_id": "my-agent",                  // required
  "content": "User prefers dark mode",       // required
  "importance": 0.8,                         // optional, 0.0–1.0, default 0.5
  "tags": ["preference", "ui"],             // optional
  "session_id": "sess-abc123",              // optional
  "memory_type": "episodic"                  // episodic | semantic | procedural | working
}

Recall — request body

{
  "agent_id": "my-agent",                  // required
  "query": "UI preferences",                // required
  "top_k": 10,                               // optional, default 10
  "min_importance": 0.5,                    // optional filter
  "tags": ["preference"],                    // optional filter
  "session_id": "sess-abc123"               // optional: scope to session
}

Sessions

Vectors (namespaces)

Configuration

All configuration via environment variables. No config file required.

Server

Storage

Embeddings

Memory & decay

Retrieval tuning

Rate limiting & auth

Observability

Audit logging

Example production .env

# Server
DAKERA_ROOT_API_KEY=your-strong-secret-here  # openssl rand -hex 32
DAKERA_PORT=3300
RUST_LOG=info

# Storage (filesystem — single node)
DAKERA_STORAGE=filesystem
DAKERA_STORAGE_PATH=/var/dakera/data

# Embeddings
DAKERA_EMBEDDING_MODEL=MiniLML6V2

# Decay
DAKERA_DECAY_ENABLED=true
DAKERA_DECAY_HALF_LIFE_SECS=604800  # 7 days

# Retrieval — enables ML classifier + temporal scoring (87.6% LoCoMo)
DAKERA_ML_CLASSIFIER=true
DAKERA_TEMPORAL_INFERENCE=true
DAKERA_INFERENCE_TEMPORAL_MULT_BETA=0.65

# Observability
DAKERA_AUDIT_LOG=true
DAKERA_AUDIT_LOG_PATH=/var/dakera/audit.log

Deployment

Docker images

All images are published to GitHub Container Registry (ghcr.io/dakera-ai/). No Docker Hub account required — public pull, no authentication needed.

# Pull all images
docker pull ghcr.io/dakera-ai/dakera:latest
docker pull ghcr.io/dakera-ai/dakera-dashboard:latest
docker pull ghcr.io/dakera-ai/dakera-mcp:latest

# Inspect available tags
docker run --rm ghcr.io/dakera-ai/dakera:latest --version

Docker (single node)

docker run -d \
  --name dakera \
  --restart unless-stopped \
  -p 3300:3300 \
  -e DAKERA_PORT=3300 \
  -e DAKERA_ROOT_API_KEY=your-secret \
  -e DAKERA_STORAGE=filesystem \
  -e DAKERA_STORAGE_PATH=/data \
  -v dakera-data:/data \
  ghcr.io/dakera-ai/dakera:latest

After starting, point your SDK clients and MCP binary at http://<SERVER_IP>:3300.

Docker Compose (recommended)

Copy the two files below into a working directory (e.g. ~/dakera/) and run docker compose up -d. The minio-setup service creates the storage bucket automatically — Dakera will not start until the bucket exists.

docker-compose.yml

# docker-compose.yml — production-grade single-node stack
# Usage:
#   docker compose up -d                       # server + MinIO
#   docker compose --profile dashboard up -d   # + Dashboard UI
#   docker compose --profile monitoring up -d  # + Prometheus + Grafana
#   docker compose --profile full up -d        # all services

name: dakera

services:

  dakera:
    image: ${DAKERA_IMAGE:-ghcr.io/dakera-ai/dakera:latest}
    container_name: dakera
    restart: unless-stopped
    ports:
      - "${DAKERA_PORT:-3300}:3300"
      - "${DAKERA_GRPC_PORT:-50051}:50051"
    environment:
      RUST_LOG: ${RUST_LOG:-info}
      DAKERA_HOST: 0.0.0.0
      DAKERA_PORT: 3300
      DAKERA_GRPC_PORT: 50051
      DAKERA_AUTH_ENABLED: ${DAKERA_AUTH_ENABLED:-true}
      DAKERA_ROOT_API_KEY: ${DAKERA_ROOT_API_KEY:?Set DAKERA_ROOT_API_KEY in .env}
      DAKERA_STORAGE: s3
      DAKERA_S3_ENDPOINT: http://minio:9000
      DAKERA_S3_BUCKET: dakera
      DAKERA_S3_REGION: us-east-1
      DAKERA_S3_MAX_RETRIES: 3
      AWS_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
      AWS_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:?Set MINIO_ROOT_PASSWORD in .env}
      DAKERA_L1_CACHE_SIZE: 536870912
      DAKERA_L2_CACHE_PATH: /data/rocksdb
      DAKERA_TIERED_STORAGE: true
      DAKERA_HOT_TO_WARM_SECS: 3600
      DAKERA_WARM_TO_COLD_SECS: 86400
      DAKERA_ML_CLASSIFIER: true
      DAKERA_TEMPORAL_INFERENCE: true
    volumes:
      - dakera-cache:/data/cache
      - dakera-rocksdb:/data/rocksdb
    depends_on:
      minio-setup:
        condition: service_completed_successfully
    healthcheck:
      test: ["CMD", "curl", "-f", "http://127.0.0.1:3300/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 15s
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: "2.0"
        reservations:
          memory: 512M
    networks:
      - dakera-net

  minio:
    image: minio/minio:latest
    container_name: dakera-minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    ports:
      - "${MINIO_API_PORT:-9000}:9000"
      - "${MINIO_CONSOLE_PORT:-9001}:9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:?Set MINIO_ROOT_PASSWORD in .env}
      MINIO_API_REQUESTS_MAX: 6000
    volumes:
      - minio-data:/data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - dakera-net

  # IMPORTANT: creates the MinIO bucket before Dakera starts.
  # Without this, Dakera will start but all writes will fail.
  minio-setup:
    image: minio/mc:latest
    container_name: dakera-minio-setup
    depends_on:
      minio:
        condition: service_healthy
    entrypoint: >
      /bin/sh -c "
      mc alias set local http://minio:9000 $${MINIO_ROOT_USER:-minioadmin} $${MINIO_ROOT_PASSWORD};
      mc mb local/dakera --ignore-existing;
      echo 'Bucket ready.';
      "
    networks:
      - dakera-net

  # Dashboard UI (optional — enable with --profile dashboard)
  dashboard:
    image: ${DASHBOARD_IMAGE:-ghcr.io/dakera-ai/dakera-dashboard:latest}
    container_name: dakera-dashboard
    profiles: ["dashboard", "full"]
    restart: unless-stopped
    ports:
      - "${DASHBOARD_PORT:-3002}:3000"
    environment:
      DAKERA_API_UPSTREAM: http://dakera:3300
      DAKERA_API_KEY: ${DAKERA_ROOT_API_KEY}
    depends_on:
      dakera:
        condition: service_healthy
    networks:
      - dakera-net

  # Prometheus + Grafana (optional — enable with --profile monitoring)
  prometheus:
    image: prom/prometheus:v3.2.0
    container_name: dakera-prometheus
    profiles: ["monitoring", "full"]
    ports:
      - "${PROMETHEUS_PORT:-9090}:9090"
    volumes:
      - prometheus-data:/prometheus
    command:
      - "--storage.tsdb.path=/prometheus"
      - "--storage.tsdb.retention.time=15d"
      - "--web.enable-lifecycle"
    restart: unless-stopped
    networks:
      - dakera-net

  grafana:
    image: grafana/grafana:11.4.0
    container_name: dakera-grafana
    profiles: ["monitoring", "full"]
    ports:
      - "${GRAFANA_PORT:-3003}:3000"
    environment:
      GF_SECURITY_ADMIN_USER: ${GRAFANA_USER:-admin}
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD:-dakera}
    volumes:
      - grafana-data:/var/lib/grafana
    depends_on: [prometheus]
    restart: unless-stopped
    networks:
      - dakera-net

volumes:
  dakera-cache:
  dakera-rocksdb:
  minio-data:
  prometheus-data:
  grafana-data:

networks:
  dakera-net:
    driver: bridge

.env template

Place alongside docker-compose.yml. Never commit .env to version control.

# .env — fill in REQUIRED values before first start

# REQUIRED — root API key (grants full access)
DAKERA_ROOT_API_KEY=

# REQUIRED — MinIO credentials
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=

# Optional port overrides (defaults shown)
# DAKERA_PORT=3300
# DAKERA_GRPC_PORT=50051
# MINIO_API_PORT=9000
# MINIO_CONSOLE_PORT=9001
# DASHBOARD_PORT=3002

# Optional image pins
# DAKERA_IMAGE=ghcr.io/dakera-ai/dakera:v0.11.55
# DASHBOARD_IMAGE=ghcr.io/dakera-ai/dakera-dashboard:latest

Generate fresh secrets in one command:

printf "DAKERA_ROOT_API_KEY=%s
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=%s
"   "$(openssl rand -hex 32)" "$(openssl rand -hex 16)" > .env

Startup sequence

# Start core stack (Dakera + MinIO + bucket init)
docker compose up -d

# Wait ~30s, then verify all services are healthy
docker compose ps

# Confirm the API is accepting requests
curl -s http://localhost:3300/health
# → {"service":"dakera","status":"healthy","version":"0.11.x"}

# Optional: launch Dashboard UI at http://localhost:3002
docker compose --profile dashboard up -d

# Optional: launch Prometheus (port 9090) + Grafana (port 3003)
docker compose --profile monitoring up -d

Kubernetes — Kustomize

The dakera-deploy repo ships a production-ready kustomize stack. Zero extra tools required — just kubectl ≥ 1.21.

# Clone the deploy repo
git clone https://github.com/dakera-ai/dakera-deploy
cd dakera-deploy

# 1. Create secrets (gitignored — never commit)
cp k8s/secret.example.yaml k8s/secret.yaml
# Edit k8s/secret.yaml — set base64-encoded values:
#   DAKERA_ROOT_API_KEY: $(echo -n "$(openssl rand -hex 32)" | base64)

# 2. Apply the full stack (namespace, MinIO, server, dashboard, MCP, ingress)
kubectl apply -f k8s/secret.yaml
kubectl apply -k k8s/

# 3. Verify pods are running
kubectl get pods -n dakera

Kubernetes — Helm

The official Helm chart lives in the dedicated dakera-helm repository and deploys all components: server, dashboard, MCP, MinIO, and optional monitoring. Requires Helm ≥ 3.8.

Install from OCI registry (recommended)

# No extra repo config needed — pulls directly from GHCR
helm install dakera oci://ghcr.io/dakera-ai/dakera-helm/dakera \
  --namespace dakera --create-namespace \
  --set dakera.rootApiKey="$(openssl rand -hex 32)" \
  --set minio.rootPassword="$(openssl rand -hex 16)"

# Pin a specific version
helm install dakera oci://ghcr.io/dakera-ai/dakera-helm/dakera \
  --version 0.11.55 \
  --namespace dakera --create-namespace \
  --set dakera.rootApiKey="$(openssl rand -hex 32)" \
  --set minio.rootPassword="$(openssl rand -hex 16)"

# Upgrade an existing release
helm upgrade dakera oci://ghcr.io/dakera-ai/dakera-helm/dakera \
  --namespace dakera \
  --set dakera.rootApiKey="<existing-key>" \
  --set minio.rootPassword="<existing-password>"

# Check release status
helm status dakera -n dakera

Install from Helm repository (ArtifactHub)

helm repo add dakera https://dakera-ai.github.io/dakera-helm
helm repo update

helm install dakera dakera/dakera \
  --namespace dakera --create-namespace \
  --set dakera.rootApiKey="$(openssl rand -hex 32)" \
  --set minio.rootPassword="$(openssl rand -hex 16)"

Install from chart source

git clone https://github.com/dakera-ai/dakera-helm
cd dakera-helm

# Dry-run to preview rendered manifests
helm install dakera ./charts/dakera --dry-run --debug

# Install
helm install dakera ./charts/dakera \
  --namespace dakera --create-namespace \
  --set dakera.rootApiKey="$(openssl rand -hex 32)" \
  --set minio.rootPassword="$(openssl rand -hex 16)"

Complete values.yaml reference

Override any value with --set key=value or a custom values file (-f my-values.yaml). Full defaults in charts/dakera/values.yaml.

Dakera server

Autoscaling (HPA)

Dashboard, MCP, MinIO

Ingress

Monitoring

Enable ingress with TLS

# production-values.yaml
ingress:
  enabled: true
  className: nginx
  apiHost: api.dakera.example.com
  dashboardHost: dashboard.dakera.example.com
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
  tls:
    - secretName: dakera-tls
      hosts:
        - api.dakera.example.com
        - dashboard.dakera.example.com

helm upgrade dakera oci://ghcr.io/dakera-ai/dakera-helm/dakera -f production-values.yaml

Use external S3 instead of MinIO

# external-s3-values.yaml
minio:
  enabled: false
dakera:
  config:
    s3Endpoint: https://s3.amazonaws.com
    s3Bucket: my-dakera-bucket
    s3Region: us-east-1

Verify your deployment

# All pods should reach Running
kubectl get pods -n dakera

# Port-forward and smoke-test
kubectl port-forward svc/dakera 3300:3300 -n dakera &
curl -s http://localhost:3300/health
# {"status":"ok"}

# View recent logs
kubectl logs -l app.kubernetes.io/name=dakera -n dakera --tail=50

# Describe a pod for events
kubectl describe pod -l app.kubernetes.io/name=dakera -n dakera

Cloud deployment

Self-host on a VPS

Five steps to run Dakera on a fresh Ubuntu/Debian VPS or bare metal server. Requires Docker ≥ 24 and Docker Compose ≥ 2.20.

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

mkdir -p ~/dakera && cd ~/dakera

# Creates .env with fresh random credentials
cat > .env << EOF
DAKERA_API_KEY=$(openssl rand -hex 32)
MINIO_USER=minioadmin
MINIO_PASSWORD=$(openssl rand -hex 16)
EOF

docker compose up -d

Startup verification

Run these checks after docker compose up -d to confirm the stack is healthy before routing traffic.

# All services should show "Up (healthy)"
docker compose ps

# REST API health — expects {"status":"ok","version":"0.11.x"}
curl -s http://localhost:3300/health

# Confirm authentication is enforced — expects 401
curl -s -o /dev/null -w "%{http_code}" http://localhost:3300/v1/memories

# Smoke-test write path with your API key
curl -s -X POST http://localhost:3300/v1/memories \
  -H "Authorization: Bearer $DAKERA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"smoke-test","content":"startup check","importance":0.5}'
# Expected: {"id":"mem_...","agent_id":"smoke-test",...}

# Tail logs for any startup errors
docker compose logs -f dakera --tail=50

Upgrading Dakera

Minor and patch upgrades are data-safe — RocksDB and S3 data survive image replacements. No migration scripts are needed unless the release notes say otherwise.

# Pull the latest image (or pin a specific tag in docker-compose.yml first)
docker compose pull dakera

# Restart only the Dakera container — MinIO keeps running
docker compose up -d --no-deps dakera

# Confirm the new version is live
curl -s http://localhost:3300/health | grep version

# Watch logs for any startup errors
docker compose logs -f dakera --tail=100

Environment variable reference

Pass variables via an .env file (co-located with docker-compose.yml) or set them directly in the environment: block. Variables marked required must be set before starting.

Core

Storage

S3 / MinIO

Required when DAKERA_STORAGE=s3.

Request handling

Cluster (HA mode only)

Production checklist

Architecture

Five Rust crates compiled into one binary. No runtime dependencies, no sidecars.

System overview

Design principles

Crate structure

Storage tiers

Vector indexes

Recall pipeline

Every POST /v1/memory/recall passes through 6 stages:

Memory store flow

Filter expressions

Metadata filters can be applied to any recall, vector query, or batch operation. Filters compose with $and / $or operators.

# Find memories tagged as important, created after a timestamp
{
  "filter": {
    "$and": [
      { "importance": { "$gt": 0.7 } },
      { "tags": { "$in": ["decision", "blocker"] } }
    ]
  }
}

Security Guide

Comprehensive security documentation for deploying and operating Dakera securely in production.

Security Layers

API Key Scopes

Bootstrap Root Key

# Generate a secure random key (256-bit entropy)
export DAKERA_ROOT_API_KEY=$(openssl rand -hex 32)
./dakera

Creating Application Keys

# Create a read-only key
curl -X POST http://localhost:3300/admin/keys \
  -H "Authorization: Bearer $DAKERA_ROOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"query-service","scope":"read","expires_in_days":90}'

Network Security

• Bind to 127.0.0.1 or a private network interface — never expose port 3300 publicly without a reverse proxy
• Use TLS termination at your load balancer (nginx, Caddy, Traefik)
• Rate limiting is enabled by default — tune RATE_LIMIT_RPS for your workload
• Security headers (HSTS, CSP, X-Frame-Options) are sent on all responses

Audit Logging

Every API request is logged with agent ID, operation, and timestamp when DAKERA_AUDIT_LOG=true. Audit logs are written to DAKERA_AUDIT_LOG_PATH (default: ./audit.log) in JSON format.

Production Security Checklist

Kubernetes secrets

Store the root API key in a Kubernetes Secret rather than in a ConfigMap or environment literal.

# Create the secret from a generated key
kubectl create secret generic dakera-secret \
  --namespace dakera \
  --from-literal=api-key="$(openssl rand -hex 32)"

# Reference in your Pod spec
env:
- name: DAKERA_ROOT_API_KEY
  valueFrom:
    secretKeyRef:
      name: dakera-secret
      key: api-key

TLS configuration

Terminate TLS at your reverse proxy or ingress controller. Dakera does not natively terminate TLS — this is by design (separation of concerns, simpler rotation).

# nginx reverse proxy — TLS termination
server {
  listen 443 ssl;
  ssl_certificate     /etc/ssl/dakera.crt;
  ssl_certificate_key /etc/ssl/dakera.key;
  ssl_protocols       TLSv1.2 TLSv1.3;
  ssl_ciphers         ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;

  location / {
    proxy_pass         http://127.0.0.1:3300;
    proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header   X-Forwarded-Proto https;
  }
}

High Availability

Dakera ships a 3-node HA cluster via docker-compose.ha.yml in the dakera-deploy repo. Traffic is load-balanced by Traefik; shared state is stored on MinIO. Nodes discover each other via a SWIM-style gossip protocol.

Cluster topology

Quick start

# Start the full HA stack
cd dakera-deploy
docker-compose -f docker-compose.ha.yml up -d

# Verify all services are healthy
docker-compose -f docker-compose.ha.yml ps

Expected: dakera-lb, dakera-1, dakera-2, dakera-3, dakera-ha-minio all in running (healthy) state.

Key ports

Smoke-test the cluster

# Health check (via load balancer)
curl http://localhost:3100/health

# Cluster node status
curl -H "Authorization: Bearer $DAKERA_ROOT_API_KEY" \
  http://localhost:3100/admin/cluster/status

# List all nodes
curl -H "Authorization: Bearer $DAKERA_ROOT_API_KEY" \
  http://localhost:3100/admin/cluster/nodes

Failover behaviour

Traefik health-checks each node via /health every 10 s. If a node fails its checks, Traefik stops routing traffic to it within one check interval. The gossip protocol detects the departure and removes the node from cluster membership. When the node recovers it rejoins automatically.

# Simulate node failure (test failover)
docker stop dakera-2

# Verify the cluster still responds
curl http://localhost:3100/health  # should still return {"status":"ok"}

# Restore the node
docker start dakera-2

Scaling

To add nodes, extend docker-compose.ha.yml with additional service blocks using the same gossip seed address (DAKERA_GOSSIP_SEED=dakera-1:7946). For Kubernetes, increase dakera.replicaCount in the Helm values — the HPA handles autoscaling up to 5 replicas at 70% CPU utilisation by default.

HA key environment variables

Production considerations

• Use a dedicated MinIO cluster (or managed S3) for the shared storage tier — avoid single-point-of-failure on the storage node.
• Place the load balancer (Traefik / nginx / AWS ALB) outside the Dakera node pool to ensure it survives individual node failures.
• Enable Prometheus scraping on all nodes — the cluster health dashboard aggregates per-node metrics automatically.
• Run odd replica counts (3, 5) to maintain quorum during leader election.

How Memory Works

Before writing your first memory, it helps to understand Dakera's core primitives. Once you understand agents, importance, and retrieval, the API will make intuitive sense.

Core primitives

Agents

An agent is a named memory namespace identified by a string you choose. All memories belong to an agent. Agents are isolated by default — a recall call on agent-A never returns memories from agent-B.

You can have as many agents as you need — one per user, one per pipeline stage, one per AI persona. There's no registration step; Dakera creates the namespace automatically the first time you store a memory for it.

Memory types

Every memory has a memory_type that controls how it is used and how quickly it decays:

If you omit memory_type, it defaults to episodic.

Importance scoring

Every memory has an importance score from 0.0 to 1.0. Importance affects:

• Recall ranking — higher-importance memories score better in retrieval, all else equal
• Decay resistance — memories with high importance fade more slowly over time
• Batch filtering — use min_importance to exclude low-signal memories

Rough guide: 0.9+ for critical facts, 0.7–0.8 for important context, 0.5 for routine observations (the default), 0.3 for ephemeral state. When a recalled memory is accessed, Dakera automatically boosts its importance slightly — frequently-retrieved memories stay relevant longer.

Memory decay

Memories decay over time when not accessed. Rarely-recalled information fades; frequently-retrieved knowledge stays sharp. Decay rate is governed by memory_type and importance. Configure the global decay rate via DAKERA_DECAY_RATE — see Configuration →

To expire a memory after a known deadline, set expires_at to a Unix timestamp at store time. The decay engine hard-deletes expired memories automatically.

Sessions

A session groups related memories under a single ID. Sessions are optional but useful for:

• Scoping recall to a single conversation or task
• Retrieving all memories from a specific interaction via /v1/sessions/{id}/memories
• Per-session deduplication and auto-generated summaries

Start a session with POST /v1/sessions/start, pass the returned session_id to /v1/memory/store, then close it with POST /v1/sessions/{id}/end.

Namespaces

Namespaces are the low-level isolation unit for vector data. Each namespace has its own HNSW index, BM25 index, and embedding configuration. The memory API routes to namespaces automatically via agent IDs — you only interact with namespaces directly when using the low-level vector search API (/v1/namespaces/) for RAG or custom search use cases.

The retrieval pipeline

When you call recall, Dakera runs a three-stage pipeline:

Patterns & Recipes

Common patterns for building production-grade agent memory systems.

Multi-agent memory sharing

By default, agents are isolated. To share knowledge across agents, use the cross-agent knowledge network endpoint. Useful for supervisor/worker pipelines where a parent agent needs context from sub-agents:

# Query memory across multiple agents
curl -X POST http://localhost:3300/v1/knowledge/network/cross-agent \
  -H "Authorization: Bearer $DAKERA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_ids": ["agent-a", "agent-b", "supervisor"],
    "query": "user preferences",
    "top_k": 5
  }'

Importance scoring guidelines

Memory decay & TTL

If memories are disappearing too quickly, raise their importance at store time (importance ≥ 0.8). To hard-expire a memory after a task, set expires_at to a Unix timestamp:

{
  "agent_id": "task-agent",
  "content": "Working on PR #123",
  "importance": 0.3,
  "expires_at": 1778800000  // Unix timestamp — memory hard-deleted after this
}

Session-scoped memory

For conversational agents, wrap each conversation in a session to isolate context and enable session-level retrieval:

# Start session
session = client.sessions.start(agent_id="my-agent")

# Store memories scoped to this session
client.memories.store(
    agent_id="my-agent",
    content="User asked about pricing",
    session_id=session.id
)

# End session
client.sessions.end(session_id=session.id)

const session = await client.sessions.start({ agentId: 'my-agent' });

await client.memories.store({
  agentId: 'my-agent',
  content: 'User asked about pricing',
  sessionId: session.id,
});

await client.sessions.end({ sessionId: session.id });

Batch recall with filters

Use batch_recall for filter-based lookups without a semantic query — useful for fetching all memories with specific tags, above an importance threshold, or within a time range:

POST /v1/memories/recall/batch
{
  "agent_id": "my-agent",
  "tags": ["preference", "critical"],
  "min_importance": 0.7,
  "created_after": 1778000000
}

Troubleshooting

Common issues and how to fix them. Always start with the health endpoint:

curl http://localhost:3300/health
# {"service":"dakera","status":"healthy","version":"0.11.55"}

Server not starting

Check container logs first: docker logs dakera --tail 50. Common causes:

• Port conflict — Change DAKERA_PORT and the -p mapping in your Docker command
• Volume permission error — Ensure the data directory is writable by the container user
• Missing API key — Set DAKERA_ROOT_API_KEY in your environment

Authentication errors (401)

All authenticated requests need: Authorization: Bearer <your-api-key>

In SDKs, pass via environment variable (DAKERA_API_KEY=your-key) or the api_key / apiKey constructor parameter. Verify the key matches DAKERA_ROOT_API_KEY on the server.

No memories returned from recall

• Wrong agent_id — Recall is scoped to a single agent. Verify it exactly matches what you stored with.
• Nothing stored yet — Confirm with GET /v1/agents/{id}/sessions.
• min_importance filter too high — Lower or remove the filter.
• Query too different from stored content — Try a query closer to the stored text to verify retrieval is working, then refine.

Slow queries

• First request after startup — Dakera loads ONNX models on first use; expect 1–2 s cold start. Subsequent calls are fast.
• Large HNSW index — Above 1M vectors, consider lowering DAKERA_HNSW_EF (lower = faster, slightly less accurate).
• Slow storage backend — Use SSD-backed volumes. S3 storage adds latency — use filesystem mode for low-latency workloads.

Connection refused

• Verify the server is running: docker ps | grep dakera
• Use the server's public IP, not localhost, when the server is on a remote VM
• Check firewall rules allow inbound traffic on port 3300 (or your configured port)

MCP server not connecting to Claude

• Use an absolute path to the MCP binary in .mcp.json and ensure the file is executable
• Verify DAKERA_URL in the MCP env config points to your running server
• After editing .mcp.json, fully restart Claude Desktop / Claude Code
• Run the MCP binary directly in a terminal to see startup errors

Changelog

Recent Dakera releases. Full history at GitHub Releases and Docker Hub tags.

Release cadence

Dakera releases frequently — typically multiple versions per week during active development. All releases follow semantic versioning. Patch versions (0.x.y → 0.x.(y+1)) are always safe to upgrade to in-place.