Mnemo

AI memory that forgets intelligently.
The first memory framework built on cognitive science.

Quick Start · Architecture · Core vs Pro · Website · API

Why Mnemo?

Every AI memory solution stores memories. Mnemo is the first to forget intelligently.

Humans don't remember everything equally — important memories consolidate, trivial ones fade, frequently recalled knowledge strengthens. Mnemo models this with:

• Weibull decay — stretched-exponential forgetting: exp(-(t/λ)^β) with tier-specific β
• Triple-path retrieval — Vector + BM25 + Knowledge Graph fused with RRF
• Three-layer contradiction detection — regex signal → LLM 5-class → dedup pipeline
• 10-stage retrieval pipeline — from preprocessing to context injection

The result: your AI agent's memory stays relevant instead of drowning in noise.

Mnemo vs Paid Competitors

Mnemo Core (free) already outperforms most $99+/mo paid solutions on retrieval quality.

Architecture

┌─────────────── Write Layer (6 channels) ───────────────┐
│  ① Hook realtime       ④ Daily archive extractor       │
│  ② Plugin SmartExtract ⑤ File watcher (fs.watch)       │
│  ③ L1 Distiller (cron) ⑥ Manual memory_store           │
└────────────────────────┬───────────────────────────────┘
                         ▼
              store.ts (dedup + contradiction L1)
                    ┌────┴────┐
                    ▼         ▼
                LanceDB    Graphiti/Neo4j
              (Vec + BM25)  (Knowledge Graph + WAL)

┌─────────────── Retrieval Layer (10 stages) ─────────────┐
│  S0  Preprocessing         S5  Min-score filter         │
│  S1  Resonance gate        S6  Cross-encoder rerank     │
│  S2  Multi-hop detection   S7  Weibull decay            │
│  S3  Triple-path parallel  S8  Hard cutoff + normalize  │
│      (Vector‖BM25‖Graph)   S9  MMR deduplication        │
│  S4  RRF fusion            S10 Session dedup + inject   │
└────────────────────────┬────────────────────────────────┘
                         ▼
                   Top-K → Agent Context

┌─────────────── Lifecycle Layer ─────────────────────────┐
│  Tier classification: Core (β=0.8) → Working (β=1.0)   │
│                        → Peripheral (β=1.3)             │
│  Weibull decay: exp(-(t/λ)^β)                          │
│  Access reinforcement (spaced repetition)               │
│  Emotional salience modulation (up to 1.5×)             │
│  Session reflection + overnight consolidation           │
└─────────────────────────────────────────────────────────┘

Quick Start

Option 1: Docker (recommended)

git clone https://github.com/Methux/mnemo.git
cd mnemo
cp .env.example .env     # add your API keys
docker compose up -d     # starts Neo4j + Graphiti + Dashboard

Dashboard at http://localhost:18800

Option 2: 100% Local ($0, no external API)

# Install Ollama models
ollama pull nomic-embed-text     # embedding
ollama pull qwen3:8b             # smart extraction LLM
ollama pull bge-reranker-v2-m3   # cross-encoder rerank

# Use local config
cp config/mnemo.local.example.json ~/.mnemo/mnemo.json
docker compose up -d   # Neo4j + Graphiti

Full Core functionality — embedding, extraction, rerank, graph — all running locally. Zero API cost.

Option 3: npm

npm install @mnemoai/core

import { createMnemo } from '@mnemoai/core';

const mnemo = await createMnemo({
  embedding: {
    provider: 'openai-compatible',
    apiKey: process.env.VOYAGE_API_KEY,
    baseURL: 'https://api.voyageai.com/v1',
    model: 'voyage-3-large',
    dimensions: 1024,
  },
  dbPath: './memory-db',
});

// Store a memory
await mnemo.store({
  text: 'User prefers dark mode and minimal UI',
  category: 'preference',
  importance: 0.8,
});

// Recall — automatically applies decay, rerank, MMR
const results = await mnemo.recall('UI preferences', { limit: 5 });

Option 4: Interactive Setup

npm run init    # guided wizard — generates config + .env

Option 5: OpenClaw Plugin

openclaw plugins install mnemo

Core vs Pro

Mnemo Core — Free, MIT License

The open-source foundation. Full retrieval engine, no restrictions.

Mnemo Pro — From $69/mo

Everything in Core, plus enterprise features:

# Activate Pro
export MNEMO_LICENSE_TOKEN="mnemo_your_token"
# Auto-activates on first run, binds to this machine

Pricing

Get Mnemo Pro →

API Configuration Guide

Mnemo requires external models for embedding, extraction, and reranking. You bring your own API keys — Mnemo does not proxy or bundle API costs. Choose a setup that fits your budget:

These are your own API costs, not Mnemo subscription fees. All setups use the same Core/Pro features — the difference is model quality.

• Local: Runs entirely offline via Ollama. Good enough to beat most paid competitors.
• Hybrid: Best quality-to-cost ratio. Recommended for most users.
• Cloud: Maximum extraction quality for high-volume production.

See config/mnemo.local.example.json for the $0 local setup, or config/mnemo.example.json for the cloud setup.

Cognitive Science

Mnemo's design maps directly to established memory research:

Tools

Documentation

• Architecture Deep Dive
• Configuration Reference
• Retrieval Pipeline
• Cognitive Science Model
• API Reference
• OpenClaw Integration

License

This project uses a dual-license model:

• MIT — Files marked SPDX-License-Identifier: MIT (Core features)
• Commercial — Files marked SPDX-License-Identifier: LicenseRef-Mnemo-Pro (Pro features)

See LICENSE and packages/pro/LICENSE for details.

Contributing

We welcome contributions to Mnemo Core (MIT-licensed files). See CONTRIBUTING.md.

Areas where we'd love help:

• Benchmark evaluation (LOCOMO, MemBench)
• New embedding provider adapters
• Retrieval pipeline optimizations
• Language-specific SDKs (Python, Go)
• Documentation and examples

_{Built with cognitive science, not hype.}