Modes A / B / C

Mnemosyne’s optional accelerators are organised into three modes. They are strictly additive — you can always switch up or down without losing data.

Mode A — FTS-only

The minimal configuration. PostgreSQL only. No embedding provider, no Redis, no LLM extraction.

• ✅ Writes facts, decisions, episodes, entities.
• ✅ Bitemporal model intact.
• ✅ RLS multi-tenant.
• ✅ Recall via text_lemmatized full-text search.
• ✅ All cognitive primitives are stored, even if not embedded.
• ❌ No semantic similarity, no vector search.
• ❌ No automatic extraction from session transcripts.

This mode is useful on its own. An agent with full-text recall is already better than no memory. We support it as a first-class option, not a fallback.

mnemosyne:
  image: ghcr.io/lucasmailland/mnemosyne-server:latest
  environment:
    DATABASE_URL: postgres://mnemo:mnemo@postgres:5432/mnemo
    MNEMO_KEY: mns_live_xxx
    # That's it. No other env vars required.

Mode B — Vector recall

Add an embedding provider. PostgreSQL + an embedder of your choice.

• ✅ Everything in Mode A.
• ✅ pgvector HNSW for semantic recall.
• ✅ Hybrid blending of FTS + cosine.
• ✅ Composition engine (works on either mode but better with vectors).
• ❌ No LLM extraction. You still write facts explicitly.

The embedder is bring-your-own. Mnemosyne ships adapters for OpenAI, Voyage, Cohere and Ollama (local). Or you can pass any function that turns text into a vector.

mnemosyne:
  environment:
    DATABASE_URL: postgres://...
    MNEMO_KEY: mns_live_xxx
    MNEMO_EMBED_PROVIDER: openai          # or voyage / cohere / ollama / custom
    MNEMO_EMBED_API_KEY: sk-...
    MNEMO_EMBED_MODEL: text-embedding-3-small

If you’d rather wire the embedder programmatically (BYO key, your code):

createMnemoClient({
  storage,
  embedder: createOpenAIEmbedder({ apiKey: process.env.OPENAI_KEY }),
});

Mode C — Full cognitive

The whole stack. PostgreSQL + embedder + LLM provider + Redis hot tier + telemetry.

• ✅ Everything in Mode B.
• ✅ LLM extraction (session collapse, fact distillation, CoT cache).
• ✅ Redis hot tier (Tier 1 of the recall cascade).
• ✅ Procedural memory and prompt evolution.
• ✅ Predictive anticipation.
• ✅ Full OpenTelemetry export.

This is what you’d run as a hosted multi-tenant service.

mnemosyne:
  environment:
    DATABASE_URL: postgres://...
    REDIS_URL: redis://...
    MNEMO_KEY: mns_live_xxx
    MNEMO_EMBED_PROVIDER: openai
    MNEMO_EMBED_API_KEY: sk-...
    MNEMO_LLM_PROVIDER: anthropic
    MNEMO_LLM_API_KEY: sk-ant-...
    OTEL_EXPORTER_OTLP_ENDPOINT: http://otel-collector:4317

Switching modes

You can switch up at any time:

• A → B: add the embedder, run the embedding backfill script, recall starts blending vectors with FTS.
• B → C: add Redis, the hot tier rebuilds itself within an hour as the ACT-R cron warms.

Switching down is also safe. If you remove the embedder, Mnemosyne falls back to FTS-only. The vectors stay in the database and resume the moment you re-enable.