Memory

Memory lets agents remember past conversations, user preferences, and context across sessions.

A subset of Memory is now callable directly over MCP — see MCP Memory Tools.

Replaces the deprecated auto_save="name" kwarg — see Legacy Agent Parameters.

Grow memory autonomously

With self_improve="background" and memory=True, the same guarded post-turn review that autonomously grows skills can also autonomously persist durable facts and preferences via store_memory — off the hot path, with zero cost to reply latency and zero context pollution during the live turn. See Self-Improving Agents.

from praisonaiagents import Agent

agent = Agent(
    name="Assistant",
    instructions="You are a helpful personal assistant.",
    memory=True,  # memory is isolated per instance — pass user_id="…" to share/persist across runs
)

agent.start("My name is Alice and I prefer concise answers.")

The user shares preferences in chat; the agent recalls them in later sessions via the configured memory backend.

Breaking change: backend no longer accepts redis/postgres/valkey.MemoryConfig(backend="redis"), backend="postgres", and backend="valkey" now raise a ValueError instead of silently substituting a local file store. Earlier releases accepted these values but stored data locally — so any code that “worked” was already not reaching Redis/Postgres.Valid backends: file, sqlite, chroma, mem0, mongodb, dakera, in_memory.Two supported ways to use Redis / Postgres:

Recommended — pass a live db() store:

from praisonaiagents import Agent, MemoryConfig
from praisonaiagents.db import db

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory=MemoryConfig(db=db(state_url="redis://localhost:6379/0")),
)

db is imported from praisonaiagents.db, not from praisonaiagents — the top-level name is the module, not the factory.

Advanced — register a custom adapter:

from praisonaiagents.memory.adapters import register_memory_adapter

register_memory_adapter("redis", MyRedisAdapter)
agent = Agent(memory=MemoryConfig(backend="redis"))  # now accepted

See Redis persistence for the full db(state_url=...) guide.

Quick Start

Level 1 — Bool (simplest)

Turn on memory with a single flag — the agent remembers across turns using the default file backend.

from praisonaiagents import Agent

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory=True,  # memory is isolated per instance — pass user_id="…" to share/persist across runs
)
agent.start("Remember that I work in software engineering.")

memory=True and memory="file" are truly zero-dependency — the agent skips importing the heavier Memory module on this path, so Agent(memory=True) starts as fast as an agent with no memory. Heavier backends (sqlite, chroma, mem0, mongodb, dakera, or learn=True) load their dependencies lazily and raise a friendly ImportError if the praisonaiagents[memory] extra isn’t installed.

Level 2 — String (pick a backend)

Pass a backend name to choose where memories are stored.

from praisonaiagents import Agent

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory="sqlite",
)
agent.start("Remember that I prefer concise answers.")

Level 3 — Config class (full control)

Use MemoryConfig to scope memory per user and auto-extract facts.

from praisonaiagents import Agent, MemoryConfig

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory=MemoryConfig(
        backend="sqlite",
        user_id="alice",
        auto_memory=True,
    ),
)
agent.start("What do you know about my preferences?")

Level 4 — Config with continuous learning

Add LearnConfig to build a long-term persona alongside session memory.

from praisonaiagents import Agent, MemoryConfig, LearnConfig

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory=MemoryConfig(
        backend="sqlite",
        user_id="alice",
        learn=LearnConfig(persona=True, insights=True, mode="agentic"),
    ),
)
agent.start("I always want answers formatted as bullet points.")

How It Works

Phase	What happens
1. Store	Each conversation turn is saved to the memory backend
2. Retrieve	Relevant past context is recalled before responding
3. Respond	Agent answers with full historical context available

Turn on prefetch=True on MemoryConfig to have relevant long-term memories injected into the system prompt at the start of every turn — no explicit recall() call required.

Which Backend to Choose?

Configuration Options

Full list of options, types, and defaults — MemoryConfig

The most common options at a glance:

Option	Type	Default	Description
`backend`	`str`	`"file"`	Storage backend: `file`, `sqlite`, `chroma`, `mem0`, `mongodb`, `dakera`, `in_memory`. Aliases: `chromadb`/`rag` → `chroma`, `none` → `in_memory`.
`user_id`	`str \| None`	`None`	User identifier for scoped memory. Leaving it `None` now yields a per-instance `agent-<uuid>` id (not a shared `"default"`) — set it to share/persist across runs
`auto_memory`	`bool`	`False`	Auto-extract and store key facts
`learn`	`bool \| LearnConfig \| None`	`None`	Enable continuous learning
`history`	`bool`	`False`	Auto-inject session history into context
`prefetch`	`bool`	`False`	Opt-in: at turn start, recall long-term memories relevant to the user prompt and inject them into the system context
`prefetch_limit`	`int`	`5`	Max number of memories injected per turn
`prefetch_token_budget`	`int`	`512`	Estimated-token cap for the injected memory block (truncated with `…` if exceeded)

Turn on prefetch=True on MemoryConfig to have relevant long-term memories injected into the system prompt at the start of every turn — no explicit recall() call required. See Memory Prefetch for the full guide.

Common Patterns

Pattern 1 — User-scoped memory

from praisonaiagents import Agent, MemoryConfig

agent = Agent(
    instructions="You are a personal assistant.",
    memory=MemoryConfig(user_id="user_alice", backend="sqlite"),
)
response = agent.start("What have I told you about my work preferences?")
print(response)

Pattern 2 — History injection for conversation continuity

from praisonaiagents import Agent, MemoryConfig

agent = Agent(
    instructions="You are a support agent.",
    memory=MemoryConfig(history=True, history_limit=5),
)
agent.start("Continue from where we left off.")

Default sessions are workspace-scoped — the same agent name in a different project is a different session. See Where sessions live for details and the PRAISONAI_GLOBAL_SESSIONS opt-out.

Pattern 3 — Recalled context at turn start

from praisonaiagents import Agent, MemoryConfig

writer = Agent(
    name="writer",
    instructions="Store user facts.",
    memory=MemoryConfig(backend="file", user_id="alice"),
)
writer.memory.remember("User prefers metric units and dark mode.")

reader = Agent(
    name="reader",
    instructions="Answer using recalled context.",
    memory=MemoryConfig(
        backend="file",
        user_id="alice",
        prefetch=True,          # inject long-term memories at turn start
        prefetch_limit=5,
        prefetch_token_budget=512,
    ),
)

reader.start("What are my UI preferences?")

The agent sees a ## Recalled memories block in its system prompt before the first model call — no extra tool call needed.

Quick API — `remember`, `recall`, `forget`

Three verbs give you explicit control over long-term facts — store, look up, and delete. An agent with memory=True exposes its memory instance directly, so you can store and recall facts on demand.

from praisonaiagents import Agent

agent = Agent(
    name="Note Taker",
    instructions="Save and recall project facts on request.",
    memory=True,
)

# The agent's memory instance is available directly
agent.memory.remember("Sprint 42 ships on Friday")
matches = agent.memory.recall("When does sprint 42 ship?")

Use Memory() standalone in a plain script — no config, no agent required.

from praisonaiagents.memory import Memory

mem = Memory()  # no config needed — uses local SQLite
mem.remember("API rate limit is 1000 req/min")
for m in mem.recall("rate limit"):
    print(m["text"])
mem.forget(query="rate limit")

Parameters

Method	Parameter	Type	Default	Description
`Memory()`	`config`	`dict \| None`	`None`	Backend config. Optional — omit for the default local backend.
`Memory()`	`verbose`	`int`	`0`	Verbosity level.
`remember`	`content`	`str`	(required)	Fact to store in long-term memory.
`remember`	`metadata`	`dict \| None`	`None`	Keyword-only. Extra metadata stored with the record.
`remember` (returns)	—	`str`	—	The generated memory id.
`recall`	`query`	`str`	(required)	Search string.
`recall`	`limit`	`int`	`5`	Keyword-only. Max results returned.
`recall` (returns)	—	`list[dict]`	—	Matching records, each with at least a `text` field.
`forget`	`memory_id`	`str \| None`	`None`	Keyword-only. Delete by exact id.
`forget`	`query`	`str \| None`	`None`	Keyword-only. Delete long-term records matching this query.
`forget` (returns)	—	`int`	—	Count of records deleted.

remember() and recall() operate on long-term memory only, and forget(query=...) is scoped to long-term memory to match. forget() requires exactly one of memory_id or query — passing neither, both, or an empty query raises ValueError.

Which memory API?

Interaction flow

Best Practices

Always set user_id when you want memory to persist or be shared

As of PraisonAI PR #3614, Agent(memory=True) without a user_id generates a fresh per-instance identifier (agent-<uuid>) and logs a warning. Memory is isolated per Agent object by default — safe, but not what you want if you re-create the agent between requests and expect it to remember the last conversation.Pass user_id="alice" (or "tenant-42", "project-climate", etc.) to opt into a shared / persistent store that survives across processes.

Use auto_memory for fact extraction

Enable auto_memory=True to have the agent automatically identify and store important facts from each conversation — names, preferences, decisions — without extra code.

Combine memory with learning

Set learn=True inside MemoryConfig to enable continuous learning alongside session memory. This gives agents both short-term context (memory) and long-term pattern recognition (learn).

Backend scaling path

Start with file, move to sqlite when you need durability, then mongodb (or chroma for vector search) when you deploy multiple agent instances that share memory. For Redis or Postgres, use memory=MemoryConfig(db=db(state_url="redis://...")) or db(database_url="postgresql://...") — see Redis persistence.

Choose remember/recall for facts, memory=True for conversation history

Agent(memory=True) auto-captures every conversation turn. remember() / recall() / forget() give you explicit control for fact storage — use them for structured knowledge you want to look up later. Both share the same long-term store when the agent’s memory instance is used.

Learn

Learn — continuous learning from conversations

Knowledge

Knowledge — add documents and URLs as agent knowledge

Memory Flush on Compaction

Preserve facts before compaction — save durable facts before older messages are dropped

Getting Started

Install

Core Concepts

Guides

Features

Models

Databases

Observability

Telemetry & Analytics

Knowledge

RAG

Persistence

Tools

Other Features

Developers

Configuration

Best Practices

Getting Started (No Code)

Memory

Grow memory autonomously

Quick Start

How It Works

Which Backend to Choose?

Configuration Options

Common Patterns

Pattern 1 — User-scoped memory

Pattern 2 — History injection for conversation continuity

Pattern 3 — Recalled context at turn start

Quick API — `remember`, `recall`, `forget`

Parameters

Which memory API?

Interaction flow

Best Practices

Learn

Knowledge

Memory Flush on Compaction

​Grow memory autonomously

​Quick Start

​How It Works

​Which Backend to Choose?

​Configuration Options

​Common Patterns

​Pattern 1 — User-scoped memory

​Pattern 2 — History injection for conversation continuity

​Pattern 3 — Recalled context at turn start

​Quick API — remember, recall, forget

​Parameters

​Which memory API?

​Interaction flow

​Best Practices

​Related

Learn

Knowledge

Memory Flush on Compaction

Grow memory autonomously

Quick Start

How It Works

Which Backend to Choose?

Configuration Options

Common Patterns

Pattern 1 — User-scoped memory

Pattern 2 — History injection for conversation continuity

Pattern 3 — Recalled context at turn start

Quick API — `remember`, `recall`, `forget`

Parameters

Which memory API?

Interaction flow

Best Practices

Related