loremem-ai 1.0.5

Persistent AI memory for LLMs and AI agents. Local-first. Learns from every interaction.

           

1. Install

pip install loremem-ai

That's it. Python 3.9+. Includes sentence-transformers for semantic search.

2. Use

from lore_memory import Memory

m = Memory()
m.store("I live in Amsterdam and work at Google")
m.store("I love Python and hate Java")

m.query("where do I work?")  #> Google (conf=0.867)

m.store("I moved to Berlin")
m.query("where do I live?")  #> Berlin — Amsterdam auto-superseded

3. Connect to your AI tool

One config. Works with Claude, Cursor, Windsurf, or any MCP client.

{
  "mcpServers": {
    "lore-memory": {
      "command": "python3",
      "args": ["/path/to/lore-memory/mcp/server.py"]
    }
  }
}

Tool	Where to put it
Claude Desktop	~/Library/Application Support/Claude/claude_desktop_config.json
Claude Code	.mcp.json in project root
Cursor	.cursor/mcp.json in project root
Windsurf	~/.codeium/windsurf/mcp_config.json

Your AI now remembers everything across conversations.

Why LoreMem

Local-First SQLite + sentence-transformers. No API keys. No cloud. No cost.	Grammar Extraction Parses by sentence structure. No regex. No dictionaries. No LLM.	Self-Learning 7 retrieval channels adapt via feedback and Hebbian learning.
Fast Sub-50ms at 10K facts. ~20ms at 1K. No network calls.	User Isolation Separate database per user. Zero data leakage.	Offline Everything local. No telemetry. Your data never leaves.

	LoreMem	Cloud alternatives
Requires LLM	No	Yes
Cost	Free	$19–249/mo
Works offline	Yes	No
Extraction	Grammar-based	LLM-dependent
Self-learning	7 mechanisms	Limited
User isolation	Physical (file-per-user)	API-level

How It Works

Grammar extraction

7-channel retrieval

Adaptive improvement

Store — text in, structured facts out

  "I live in Amsterdam and work at Google"
           │                        │
           ▼                        ▼
   (user, live_in, Amsterdam)    (user, work_at, Google)

Parses English by grammar position. No verb dictionaries, no regex, no LLM. Raw text is always FTS5-indexed as a fallback.

Recall — 7 scoring channels, fused into one ranked result

Channel	What it does
Semantic	Cosine similarity (embeddings)
Keyword	BM25-style term overlap (FTS5)
Temporal	Exponential recency decay
Belief	Bayesian posterior (evidence + contradictions)
Frequency	Log-scaled access count
Graph	Spreading activation, 3-hop
Resonance	Co-activation frequency

Weights adapt automatically through feedback.

Learn — gets better the more you use it

m.feedback(results[0].id, helpful=True)   # adapt channel weights
m.consolidate()                           # decay + replay + archive

Mechanism	Effect
Adaptive weights	Channels shift toward what works
Hebbian synapses	Co-retrieved facts strengthen links
Memory replay	Active memories resist decay
Ebbinghaus forgetting	Unused facts fade over time
Contradiction resolution	New facts supersede old ones

Benchmarks

_{Actual runs on Apple M-series, Python 3.9. Reproduce: python benchmarks/lore_bench.py}

Test Suite — 138 tests Capability Pass Correction chains 10/10 Negation & retraction 5/8 Memory decay 5/5 Self-learning 2/2 User isolation 100/100 Grammar extraction 10/10 Scale & latency 3/3 Overall 135/138

Latency — per operation Facts stored Recall p50 Write 100 14ms 8.4ms 1,000 21ms 7.9ms 5,000 33ms 7.7ms 10,000 50ms 7.6ms Hash embeddings. Real embeddings add ~7ms/write.

[!NOTE] Negation detection (62%) is a known limitation. Phrases like "I can't stand X" and "I stopped doing X" are not yet reliably parsed.

API Reference

Core API

m = Memory(user_id="alice", org_id="acme", data_dir="~/.lore-memory")

m.store(text, scope="private")         # Store from natural language
m.query(query, limit=10)               # 7-channel retrieval
m.forget(memory_id=...)                # Delete by ID
m.forget(subject="alice")              # Delete by subject
m.forget_all()                         # Purge all user data
m.close()                              # Persist and close

Advanced API

m.store_triple("alice", "works_at", "Google", confidence=0.9)
m.profile()                            # All facts by predicate
m.profile_compact(max_tokens=200)      # Token-budgeted LLM context
m.feedback(memory_id, helpful=True)    # Drive adaptive learning
m.consolidate()                        # Decay + replay + archive
m.stats()                              # Memory counts by scope

Context manager

with Memory(user_id="alice") as m:
    m.store("I live in Amsterdam")
    results = m.query("where do I live?")

Custom embeddings

from sentence_transformers import SentenceTransformer
model = SentenceTransformer("all-MiniLM-L6-v2")

m = Memory(user_id="alice", embedding_dims=384, embed_fn=model.encode)

Multi-user isolation

alice = Memory(user_id="alice")
bob   = Memory(user_id="bob")

alice.store("I work at Google")
bob.query("where does alice work?")  #> [] — fully isolated

Shared org memories:

alice = Memory(user_id="alice", org_id="acme")
alice.store("Our mission is to democratize AI", scope="shared")

bob = Memory(user_id="bob", org_id="acme")
bob.query("what is our mission?")  #> Returns shared memory

CLI

lore store "I work at Google"
lore query "where do I work?"
lore list
lore stats
lore forget --id <id>
lore serve --port 8420     # REST API
lore mcp                   # MCP server

REST API

pip install loremem-ai[api]
lore serve --port 8420

# Store
curl -X POST localhost:8420/memory \
  -H "Content-Type: application/json" \
  -d '{"user_id":"alice","text":"I prefer dark mode"}'

# Query
curl "localhost:8420/memory?user_id=alice&query=preferences"

Docker

docker build -t loremem -f docker/Dockerfile .
docker run -p 8420:8000 -v lore_data:/data loremem

Contributing

Contributions welcome. See CONTRIBUTING.md.

git clone https://github.com/loreMemory/loreMemory.git && cd loreMemory
pip install -e ".[dev]" && pytest tests/ -v

Security  ·  Changelog  ·  License

MIT — free for personal and commercial use.