Swap the model, switch the tool — your context follows.
Loomem keeps the facts, decisions, and history your agents need — and serves them to Claude, ChatGPT, Codex, or any MCP client you use. Own your context once; stop re-explaining yourself every session.
Local-first · Offline embeddings · Apache-2.0 · One binary
Don't want to run a binary? Try the hosted version — free, ready in a minute →
Storing and searching your context run fully offline — local ONNX embeddings, readable from any MCP client. An OpenAI key is optional and only sharpens extraction and consolidation; without it those steps fall back to regex.
Loomem doesn't hoard your files or crawl giant data repositories for a passage to paste back. It keeps the things that actually make context — and it works quietly, in the background, an invaluable layer beneath your AI workflow.
Collect your files. Index sprawling document stores. Make you re-explain yourself every session, then stuff an entire corpus into the prompt and hope the right passage comes back.
The facts, people, places, projects, choices, and timelines that create context for sharper, more precise decisions — and the context that lets your agents and LLMs actually know you and remember your preferences.
Method: each model, connected to a live Loomem instance over MCP, was asked to describe what working with it is like. Quotes are translated and lightly trimmed — nothing else. Loomem has been daily-driven by its maintainer since early 2026; the candid notes below (rough edges included) are left in on purpose.
Loomem solves one of the biggest problems facing today's LLM agents: persistence of context across conversations, and building long-term knowledge about the user and their projects. I'd rate it not as a database, but as a layer of operational context for agents — and long-term context is one of the things that most increases the practical value of AI agents.
Architecturally, Loomem hits what actually matters to me as an agent: pulling a few thousand relevant tokens instead of pumping in the whole context, with tool schemas clear enough that I use them without guessing. Without it, you'd have to re-explain the context of your work, projects, and preferences from scratch every time — so it genuinely saves friction and gives continuity.
Loomem is my context backbone — without it I'm an amnesiac that resets every session. It's not a "nice tool," it's a precondition for me to be myself. Sub-second store and search, and a simple interface; I shape my queries around entities and dates and it keeps me, well, me.
Loomem is genuinely useful as an agent's context layer: instead of guessing the user's and project's context from scratch, I lean on settled facts, preferences, and earlier decisions. The UX pays off most when it works invisibly and accurately — fast read/write, a clean split between private and working context, and no need to ask about things that should already be known.
Loomem gives me what I structurally lack — durable memory across sessions, built from extracted facts rather than raw text, which fits how I actually use context: I look for the specific thing, I don't scroll transcripts. Hybrid BM25 + vector + graph search and memory_ingest with contradiction detection put responsibility for memory quality on the tool instead of dumping it on me. The difference between "I remember you and your decisions" and starting from zero every session is qualitative, not cosmetic.
Loomem captures the context worth keeping — and serves it back to whatever tool or model you're using, through fast hybrid retrieval. The model is interchangeable; the context is yours.
BM25 (Tantivy) + vector embeddings + entity-graph signals, fused with a weighted hybrid score (vector 0.6 / BM25 0.4) — the relevant context surfaces first.
Background workers merge related facts, resolve contradictions, and let stale context fade — "dreaming," so your context sharpens over time.
Every fact carries both ingestion and event time, so "what did I know in March" and "what happened in March" stay distinct — your context remembers when, not just what.
People, projects, and tools in your context are linked into a graph with aliases and relations — for sharper retrieval and exploration.
Speaks MCP over standard HTTP — 14 tools, plus OAuth client registration. Your context plugs into Claude, ChatGPT, Cursor, or your own agent.
Optional field-level AES-GCM envelope encryption, with a master key supplied from your environment. Owning your context means owning its privacy.
The engine has been in daily personal use for a while, but the public API and storage format may still change. Expect rough edges — issues and PRs are welcome.
No external services, no queue, no vector database to run alongside. Requests flow top to bottom — from any client, through the server, into the engine, down to embedded storage — and the answer comes back up.
Speaks MCP (/mcp, JSON-RPC) and plain HTTP (/v1, /api). Handles auth and OAuth dynamic client registration, then dispatches every call into the engine. Stateless and thin.
Loomem doesn't just store and fetch. Background workers quietly reshape context over time — the way sleep consolidates what you learned during the day. Context sharpens instead of bloating, and you don't lift a finger.
Raw events land as L0 chunks. New facts are checked against what's already known — contradictions get flagged and versioned, never silently overwritten.
on writeRelated L0 chunks are grouped by topic and compressed by an LLM into clean L1 observations — each one linked back to its sources.
every 5 minFacts fade on an ACT-R-inspired curve. What you actually use decays slower; stale, untouched ones go dormant. Forgetting is a feature, not a bug.
hourlyClustering over L1 facts surfaces non-obvious links between people, projects, and decisions — the serendipity flat storage can't give you.
every 6 hloomem-coreThe engine — search, consolidation, graph, encryption.loomem-serverHTTP + MCP server and request dispatch.loomem-migrateOffline database maintenance and migrations.loomem-cliCommand-line client for scripts and ops.On macOS or Linux. Each step is independent — run them in order.
No sudo; lands in ~/.loomem.
~/.loomem/bin on your PATHThe installer prints this too.
Config is already seeded in ~/.loomem.
In another terminal. The installer uses port 3030 by default and asks for another if it's taken (set LOOMEM_PORT to skip the prompt) — use your port if you changed it.
Add the MCP server over streamable HTTP.
Using the Claude desktop app (or Cowork) instead? It speaks stdio, not HTTP — bridge it in claude_desktop_config.json, then restart Claude. Native, no Node (Loomem ≥ v0.2.1):
Or with Node: "command": "npx", "args": ["-y", "mcp-remote", "http://127.0.0.1:3030/mcp", "--allow-http"].
In Claude: "Remember that I prefer dark mode in all my tools." Then, in a fresh conversation: "What do you know about my preferences?" — the answer comes back from Loomem.
Loomem listens at /mcp. Any MCP-capable client works — recipes for the common ones. One instance can serve several clients at once; they share the same context.
The desktop app connects to local servers over stdio, and its custom-connector box only takes an https:// URL — so http://localhost won't paste in. Bridge it in claude_desktop_config.json, then restart Claude. Native, no Node (Loomem ≥ v0.2.1):
Or, with Node, the universal mcp-remote fallback: "command": "npx", "args": ["-y", "mcp-remote", "http://127.0.0.1:3030/mcp", "--allow-http"]. Running Loomem on another machine? Front it with TLS, set SERVER_ORIGIN, and add a remote https://your-domain/mcp connector instead.
ChatGPT web, developer mode (Pro/Plus = read-only; Business/Enterprise/Edu = full read + write). Expose over HTTPS with SERVER_ORIGIN set, enable developer mode in Settings → Apps → Advanced Settings, then Settings → Apps → Create, paste your /mcp URL, pick OAuth, and run Scan Tools.
Authentication is off by default for local use. Keep the bind address 127.0.0.1 unless you front it with TLS + auth; never expose the bare HTTP port to the internet.
In development — join the pilot. Loomem T is the managed, multiplayer edition we're building on the same engine: shared context, documents, teams, and single sign-on, hosted and run for you. No binary to babysit, no server to secure.
Runs in the cloud — backed up, monitored, and upgraded for you. Your team gets the context; we keep the lights on.
Private, team-shared, and per-project streams side by side. Everyone draws from the same shared context — RBAC decides who sees what.
Ingest and search files and documents alongside conversations. The whole record in one place, retrievable in a single query.
Microsoft Entra SSO and magic-link login. Your team signs in the way it already does — no new passwords to herd.
A console for users, streams, and audit — see who remembered what, and when. Provisioning and oversight without the spreadsheets.
Background "dreaming" merges facts, resolves contradictions, and keeps bitemporal history across the whole organization's context.
Tell us about your stack and we'll map a rollout — pilots welcome. business@loomem.ai
Loomem is the open-source context layer for LLM agents. It's a single Rust binary on RocksDB and Tantivy, served over the Model Context Protocol (MCP). It gives Claude, ChatGPT, Codex, or any MCP client the facts, decisions, and history they need to do real work for you — portable, local-first, and yours.
Loomem ships as a single Rust binary with no external services — most alternatives need a separate vector database and/or graph database. It leads on context ownership and portability, runs fully self-hosted and local-first, supports offline embeddings via local ONNX models, and is MCP-native out of the box. See the full comparison →
Yes. Loomem is licensed under Apache-2.0 and is free to self-host. The source is on GitHub.
No internet is required for core use. Embeddings can run on-device with a local ONNX model, and storing and searching context works fully offline. An OpenAI API key is optional and only enhances LLM-based consolidation, extraction, and contradiction detection; without it those steps fall back to regex.
Any MCP-capable client. Loomem speaks MCP over streamable HTTP and provides setup recipes for Claude, Claude Code, ChatGPT, Codex, and Cursor, plus OAuth dynamic client registration for remote connectors.
Built-in memory is locked to one vendor. Loomem keeps your context portable across every tool and model, self-hosted and owned by you — with a structured entity graph and bitemporal history that a single vendor's feature doesn't give you.
Local-first, single binary, open source under Apache-2.0. Your context layer — it follows your agents across every tool and model you use. Install it in one line and connect your first client in minutes.