Dakera Memory - PraisonAI

Dakera gives your agent decay-weighted memory that fades stale context and keeps fresh, important facts on top.

from praisonaiagents import Agent

agent = Agent(
    name="assistant",
    instructions="Remember what the user tells you across sessions.",
    memory={
        "provider": "dakera",
        "config": {
            "url": "http://localhost:3000",
            "api_key": "dk-...",
            "agent_id": "my-agent",
        },
    },
)
agent.start("Remember that my favourite colour is teal")

Later chats can recall the fact — Dakera weights it by importance and decays older memories.

Quick Start

Install

pip install "praisonaiagents[dakera]"

This installs dakera>=0.12.8. Alternatively, pip install dakera installs the SDK on its own.Run the Dakera server locally with Docker Compose — see dakera-ai/dakera-deploy for the compose file. The default port is 3000, matching the adapter default.

Configure with environment variables

export DAKERA_URL="http://localhost:3000"
export DAKERA_API_KEY="dk-..."
export DAKERA_AGENT_ID="my-agent"

from praisonaiagents import Agent

agent = Agent(
    name="assistant",
    instructions="Remember what the user tells you across sessions.",
    memory="dakera",
)
agent.start("Remember that my favourite colour is teal")

Configure with a dict

from praisonaiagents import Agent

agent = Agent(
    name="assistant",
    instructions="Remember what the user tells you across sessions.",
    memory={
        "provider": "dakera",
        "config": {
            "url": "http://localhost:3000",
            "api_key": "dk-...",
            "agent_id": "my-agent",
            "default_importance": 0.6,
        },
    },
)
agent.start("Remember that my favourite colour is teal")

How It Works

Dakera stores memories with an importance score and timestamps them. Over time, memories decay — so stale context stops competing with fresh, relevant facts.

Memory Tiers

PraisonAI maps its two memory tiers onto distinct Dakera memory_type values:

PraisonAI tier	Default Dakera `memory_type`	Override config key	Description
short-term (`store_short_term` / `search_short_term`)	`"working"`	`short_term_type`	Recency-heavy scratch context, reset frequently
long-term (`store_long_term` / `search_long_term`)	`"episodic"`	`long_term_type`	Durable knowledge, persists across sessions

Unlike Mem0 or ChromaDB, Dakera has a first-class memory_type field — so the two tiers never collapse.

Configuration Options

Option	Type	Default	Env fallback	Description
`url` (alias `base_url`)	`str`	`"http://localhost:3000"`	`DAKERA_URL` → `DAKERA_API_URL`	Dakera server URL
`api_key`	`str`	`None`	`DAKERA_API_KEY`	API key for the Dakera server
`agent_id`	`str`	`"praisonai"`	`DAKERA_AGENT_ID`	Namespaces this agent’s memories
`short_term_type`	`str`	`"working"`	—	Dakera `memory_type` for the short-term tier
`long_term_type`	`str`	`"episodic"`	—	Dakera `memory_type` for the long-term tier
`default_importance`	`float`	`0.5`	—	Importance score when a store call does not supply one

Env fallback chain for URL: DAKERA_URL → DAKERA_API_URL → "http://localhost:3000". Precedence: config dict > env var > hard default. Config dict values always win.

Reserved metadata keys

These keys are lifted out of metadata and promoted to Dakera fields. Explicit kwargs win over metadata values:

Key	Dakera field
`importance`	Importance score
`session_id`	Session scope
`tags`	Memory tags

Reserved keys are stripped from metadata before storage so they never leak into the payload.

Environment variables only

Env-var-only form

export DAKERA_URL="http://localhost:3000"
export DAKERA_API_KEY="dk-..."
export DAKERA_AGENT_ID="my-agent"

from praisonaiagents import Agent

agent = Agent(name="Assistant", memory="dakera")

Precedence Ladder

# Level 1: String (simplest — uses env vars for URL/key/agent_id)
agent = Agent(memory="dakera")

# Level 2: Dict (recommended — inline config)
agent = Agent(
    memory={
        "provider": "dakera",
        "config": {
            "url": "http://localhost:3000",
            "api_key": "dk-...",
            "agent_id": "my-agent",
        },
    }
)

Do not invent a DakeraConfig dataclass, a Dakera(...) instance form, or a Bool / Array level — none exist in the SDK. The supported forms are: memory="dakera" (env-var driven), memory={"provider": "dakera", "config": {...}} (nested), or a flat dict of config keys (memory={"url": "...", "api_key": "..."}).

Store, Search, Delete & Reset

Storing memories

from praisonaiagents import Memory

memory = Memory(config={"provider": "dakera", "config": {"agent_id": "my-agent"}})

# Short-term (working memory)
memory.store_short_term(
    "User is asking about Python today",
    metadata={"session_id": "sess-1"},
)

# Long-term with explicit importance
memory.store_long_term(
    "User prefers dark mode",
    importance=0.9,
    tags=["preference", "ui"],
)

importance, session_id, and tags can be passed as top-level kwargs or inside the metadata dict — kwargs always win. metadata is the container, not a promoted field.

Searching memories

# Search short-term
results = memory.search_short_term("Python", limit=5)

# Search long-term, filtering by importance
results = memory.search_long_term("colour preference", limit=5, min_importance=0.7)

# Each result has this shape:
# {"id": str, "text": str, "metadata": dict, "score": float | None, "memory_type": str | None}

Retrieving all memories

# Uses Dakera's batch_recall — no embedding required
all_memories = memory.get_all_memories(limit=1000)

Deleting memories

Dakera is one of the only providers that supports DeletableMemoryProtocol and ResettableMemoryProtocol — mem0, ChromaDB, and MongoDB do not implement these optional protocols.

# Delete by id — returns True on success, False on failure (logs warning)
deleted = memory.delete_memory("mem-id-123")

# Delete multiple — returns count deleted
count = memory.delete_memories(["mem-id-1", "mem-id-2", "mem-id-3"])

Resetting tiers

# Clear all working (short-term) memory for this agent — scoped by memory_type
memory.reset_short_term()

# Clear all episodic (long-term) memory for this agent
# Does NOT wipe short-term memory
memory.reset_long_term()

Common Patterns

Namespace per user / tenant

from praisonaiagents import Agent

user_agent = Agent(
    name="assistant",
    memory={
        "provider": "dakera",
        "config": {
            "url": "http://localhost:3000",
            "agent_id": "user-alice",
        },
    },
)

Different agent_ids on the same Dakera server keep memories fully isolated.

Overriding tier mapping for custom Dakera types

If your Dakera server is configured with custom memory types, override the defaults.

from praisonaiagents import Agent

agent = Agent(
    name="assistant",
    memory={
        "provider": "dakera",
        "config": {
            "url": "http://localhost:3000",
            "api_key": "dk-...",
            "agent_id": "my-agent",
            "long_term_type": "semantic",
        },
    },
)

Boost recall for high-signal facts

from praisonaiagents import Memory

memory = Memory(config={"provider": "dakera"})

memory.store_long_term(
    "User's payment method is Visa ending 4242",
    importance=0.9,
)

Higher importance scores surface this fact ahead of lower-scored memories when Dakera ranks results.

Filter recall by minimum importance

results = memory.search_long_term(
    "payment details",
    limit=5,
    min_importance=0.7,
)

Best Practices

Set agent_id per agent (or per user)

Each agent or user should have a unique agent_id so memories don’t cross-read. One Dakera server can host many namespaced agents.

Use default_importance to bias new stores

Set default_importance in config to bias all new stores without repeating it on every call. Pass explicit importance only on the highest-signal facts.

Keep working resets frequent, episodic resets rare

Reset working (short-term) memory at the end of each session or task. Avoid resetting episodic (long-term) memory unless you intentionally want to wipe all durable knowledge — this matches how Dakera’s decay is tuned.

Prefer env vars in production

Use DAKERA_URL, DAKERA_API_KEY, and DAKERA_AGENT_ID so credentials don’t appear in source code or version control.

Deploying Dakera

Dakera is a self-hosted memory server. The quickest way to run it is with Docker Compose via dakera-ai/dakera-deploy. The default compose port is 3000, which matches the adapter’s default http://localhost:3000, so no URL config is needed for local development.

Memory Configuration

Provider strings, MemoryConfig, and backend overview.

Custom Memory Adapters

MongoDB Memory

Document-backed memory with optional Atlas Vector Search.

Memory Overview

Memory system overview and quickstart.

Memory Storage

All supported database backends.

​Quick Start

​How It Works

​Memory Tiers

​Configuration Options

​Reserved metadata keys

​Environment variables only

​Precedence Ladder

​Store, Search, Delete & Reset

​Storing memories

​Searching memories

​Retrieving all memories

​Deleting memories

​Resetting tiers

​Common Patterns

​Namespace per user / tenant

​Overriding tier mapping for custom Dakera types

​Boost recall for high-signal facts

​Filter recall by minimum importance

​Best Practices

​Deploying Dakera

​Related

Memory Configuration

Custom Memory Adapters

MongoDB Memory

Memory Overview

Memory Storage

Quick Start

How It Works

Memory Tiers

Configuration Options

Reserved metadata keys

Environment variables only

Precedence Ladder

Store, Search, Delete & Reset

Storing memories

Searching memories

Retrieving all memories

Deleting memories

Resetting tiers

Common Patterns

Namespace per user / tenant

Overriding tier mapping for custom Dakera types

Boost recall for high-signal facts

Filter recall by minimum importance

Best Practices

Deploying Dakera

Related