Muninn Memory

Other

Production memory for AI agents. Cloudflare-native with 99.1% LOCOMO accuracy. Knowledge graph, temporal reasoning, multi-hop retrieval. Free tier available.

Install

openclaw skills install muninn-skill

Muninn Memory System

Production-grade semantic memory for AI agents. 99.1% LOCOMO accuracy. Knowledge graph with temporal reasoning, entity extraction, and multi-hop retrieval.

Quick Start

# Install via ClawHub
clawhub install muninn-skill

# Use the Cloud API (recommended)
export MUNINN_API_KEY=muninn_xxx  # Get key at muninn.au/dashboard

# Or run local MCP server
npm run mcp

Two Modes

Mode	Storage	Embeddings	Cost	LOCOMO
Cloud (Recommended)	Cloudflare D1 + Vectorize	Workers AI BGE-M3	Free tier	99.1%
Local	SQLite + Ollama	nomic-embed-text	Free	93%

Cloud Mode (Recommended)

Production-ready with zero setup. Best accuracy.

# Get API key at https://muninn.au/dashboard
export MUNINN_API_KEY=muninn_xxx
export MUNINN_ORG=your-org-id

# Use via REST API
curl -X POST "https://api.muninn.au/api/memories" \
  -H "Authorization: Bearer $MUNINN_API_KEY" \
  -H "X-Organization-ID: $MUNINN_ORG" \
  -d '{"content": "User prefers dark mode"}'

Local Mode (Free, Offline)

Runs entirely on your machine. No API keys required.

# Pull embedding model (required)
ollama pull nomic-embed-text

# Start MCP server
cd ~/.openclaw/workspace/skills/muninn-skill
npm install
npm run mcp

Features

Knowledge Graph: Entities, relationships, multi-hop traversal
Temporal Reasoning: "What did we discuss last Tuesday?" resolves to actual dates
Auto-classification: Episodic/Semantic/Procedural routing (100% accuracy, no LLM)
Entity extraction: 91% precision (people, orgs, projects, tech, locations, events, concepts)
Contradiction detection: Conflicting values flagged automatically
MCP-native: Works with any agent framework via mcporter

Quick Start

# Install skill
clawhub install muninn-skill

# For local: pull embedding model
ollama pull nomic-embed-text

# Start MCP server
npm run mcp

MCP Tools

Tool	Description
`memory_remember`	Store a memory (auto-classifies type)
`memory_recall`	Semantic search across memories
`memory_briefing`	Session briefing with key facts
`memory_stats`	Vault statistics
`memory_entities`	List tracked entities
`memory_forget`	Delete a memory
`memory_procedure_create`	Create workflow
`memory_procedure_feedback`	Record success/failure
`memory_connect`	Link memories
`memory_neighbors`	Get graph neighbors

Architecture

Input → Router (keyword) → Episodic/Semantic/Procedural
                                   ↓
                           Entity Extraction
                                   ↓
                           Knowledge Graph
                                   ↓
              Local: SQLite + VSS    Cloud: PostgreSQL + pgvector
                                   ↓
Output ← Hybrid Retrieval (BM25 + semantic + entity boost)

Benchmark Results

System	Custom LOCOMO-style	Notes
Muninn	93% (14/15)	+13% from BFS path finding
Mem0	66.9%	Official benchmark
Engram	79.6%	Official benchmark

Official LOCOMO Benchmark:

Category	Muninn v2	Mem0	Notes
Overall	99.1%	26%	+73pp improvement
Temporal	99.4%	—	Event+date retrieval
Relationship	99.0%	—	Multi-hop reasoning
Identity	96.9%	—	Entity extraction
Other	99.8%	—	General knowledge

R@10 Retrieval: 100% (correct session in top 10 results for 100% of queries)

Key insight: Search ALL facts for entity (no predicate filtering) achieves near-perfect accuracy. The PDS system enables structured queries across relationship types.

Tech Stack

Local

Storage: SQLite with vector similarity
Embeddings: Ollama (nomic-embed-text)
Compression: TurboQuant (5x reduction, 94% similarity)
Server: MCP SDK

Cloud

Storage: PostgreSQL + pgvector (Supabase)
Embeddings: BYOK (OpenAI/Anthropic) or our keys
Compression: TurboQuant (5x reduction, 94% similarity)
Server: MCP SDK + REST API

TurboQuant Compression

Optional compression for 5x storage reduction:

# Install dependencies (local only)
pip install torch scipy numpy

# Start compression server
cd ~/.openclaw/workspace/skills/muninn-skill/src/storage
python3 turboquant-server.py &

# Use in code
import { compress, similarity } from './storage/turboquant-client.js';
const compressed = await compress(embedding, 3);  // 3-bit, ~74% smaller
const score = await similarity(query, compressed);

Performance:

Compression ratio: 3.9x (768-dim @ 3-bit)
Storage savings: 74%
Cosine similarity retention: 94%
First call latency: ~15s (PyTorch warmup)
Subsequent calls: ~50-100ms

Pricing

Tier	Price	Features
Core	Free	Local SQLite, Ollama embeddings
Pro	$10/mo	Cloud PostgreSQL, BYOK, 50K API calls
Enterprise	$79/mo	Dedicated infrastructure, teams, unlimited

Version History

v2.0 (Current) — Cloudflare Production

99.1% LOCOMO accuracy — official benchmark
Cloudflare D1 + Vectorize — edge-native storage
Workers AI embeddings — BGE-M3 (1024 dims, 60K context)
PDS classification — Psychological Decimal System for facts
Entity extraction — 91% precision (835/841 questions)
Sleep cycle — Hippocampal → Cortex consolidation
Multi-hop reasoning — Relationship traversal

v1.x (Legacy) — Local SQLite

BFS path finding between entity pairs
Coreference resolution (pronoun → antecedent)
TurboQuant compression (5x reduction)
Local SQLite + Ollama embeddings

License

AGPL-3.0

Muninn Memory

Install

Muninn Memory System

Quick Start

Two Modes

Cloud Mode (Recommended)

Local Mode (Free, Offline)

Features

Quick Start

MCP Tools

Architecture

Benchmark Results

Tech Stack

Local

Cloud

TurboQuant Compression

Pricing

Version History

v2.0 (Current) — Cloudflare Production

v1.x (Legacy) — Local SQLite

License

Links