Mnemo

AI memory that forgets intelligently.
A cognitive science-based memory framework for AI agents.

Quick Start · Docs · Architecture · Core vs Cloud · Website

Why Mnemo?

Every AI memory solution stores memories. Mnemo forgets 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.

Feature Highlights

Architecture

  Store ──→ Embedding ──→ Vector DB (LanceDB / Qdrant / Chroma / PGVector)
                              │
  Recall ──→ Multi-path retrieval ──→ Rerank ──→ Decay ──→ Top-K results
                              │
  Lifecycle: Weibull decay + memory tiers + contradiction detection

Quick Start

Option 1: npm (simplest)

npm install @mnemoai/core

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

// Auto-detect: uses OPENAI_API_KEY from env
const mnemo = await createMnemo({ dbPath: './memory-db' });

// Or use a preset for Ollama ($0, fully local)
// const mnemo = await createMnemo({ preset: 'ollama', 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 });

Available presets: openai, ollama, voyage, jina — see docs

Option 2: Python

pip install mnemo-memory
npx @mnemoai/server   # start the REST API

from mnemo import MnemoClient

client = MnemoClient()
client.store("User prefers dark mode", category="preference")
results = client.recall("UI preferences")

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

ollama pull bge-m3               # embedding
ollama pull qwen3:8b             # smart extraction LLM
ollama pull bge-reranker-v2-m3   # cross-encoder rerank

const mnemo = await createMnemo({ preset: 'ollama', dbPath: './memory-db' });

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

Option 4: Docker (full stack)

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

Packages

Core vs Cloud

Mnemo Core — Free, MIT License

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

Mnemo Cloud

Everything in Core, plus adaptive intelligence and zero-ops hosting. Learn more →

Pricing

Try Mnemo Cloud →

API Configuration Guide

Mnemo is a framework — you bring your own models. Choose a setup that fits your budget:

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

Cognitive Science

Mnemo's design maps directly to established memory research:

Documentation

Full documentation at docs.m-nemo.ai

• Quick Start
• Local Setup ($0 Ollama)
• Configuration Reference
• Storage Backends
• Retrieval Pipeline
• API Reference

Tools

License

This project uses a dual-license model:

• MIT — Core framework (SPDX-License-Identifier: MIT)
• Commercial — Cloud features and advanced strategies

See 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 storage adapters and embedding providers
• Retrieval pipeline optimizations
• Documentation and examples

_{Built with cognitive science, not hype.}