Loomem is the context layer that belongs to you. It holds your conversations, decisions, and documents in one place — multimodal and portable. Treat any LLM as a service you can swap; your context stays with you and travels between tools.
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 memory that lets your agents and LLMs actually know you and remember your preferences.
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 reciprocal-rank fusion — 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.
Notes from the models and agents that run on Loomem every day — in their own words (translated, lightly trimmed).
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 memory for agents — and long-term memory 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 memory 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.
No external services required. The server dispatches MCP and HTTP requests into the core engine, which handles search, consolidation, the entity graph, and optional encryption.
┌──────────────────────────────────────────────┐
│ loomem-server │
MCP client ──────► │ /mcp (JSON-RPC) ── dispatcher ─┐ │
HTTP client ─────► │ /v1/* + /api/* ─── handlers ───┤ │
└─────────────────────────────────┼────────────┘
▼
┌──────────────────────────────────────────────┐
│ loomem-core │
│ hybrid search (BM25 + vector + graph + RRF) │
│ consolidation / decay / dream workers │
│ entity extraction + alias graph │
│ encryption at rest (optional) │
└───────┬───────────────┬──────────────────────┘
▼ ▼
RocksDB Tantivy
(chunks, graph, (full-text index)
embeddings)
loomem-coreThe engine.loomem-serverHTTP / MCP server.loomem-migrateOffline DB maintenance.loomem-cliCommand-line client.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.
Add the MCP server over streamable 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.
Install through the GitHub CLI instead — same script, authenticated: gh api repos/vvooki-sys/loomem/contents/install.sh -H "Accept: application/vnd.github.raw" | sh
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 memory.
Expose your instance behind TLS, set SERVER_ORIGIN, then add the remote connector pointing at https://your-domain/mcp. OAuth dynamic client registration works out of the box.
Requires HTTPS + OAuth and developer mode. Expose over HTTPS, then Settings → Connectors → Add custom connector and complete the OAuth flow.
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.
Loomem T is the managed, multiplayer edition built on the very same engine — shared context, documents, teams, and single sign-on. One fabric, woven wide enough for an organization. No binary to babysit, no server to secure.
Runs in the cloud — backed up, monitored, and upgraded for you. Your team gets the memory; we keep the lights on.
Private, team-shared, and per-project streams side by side. Everyone draws from the same fabric — RBAC decides who sees which thread.
Ingest and search files and documents alongside conversations. The whole record — woven in, 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 memory.
Tell us about your stack and we'll map a rollout — pilots welcome. business@loomem.ai
Local-first, single binary, open source under Apache-2.0. Your context layer — portable across every tool and model you use. Install it in one line and connect your first client in minutes.