What you know
has always been yours.
Your Palace of Co‑Intelligence
The context
layer.
Every session, the context resets. The decision you worked through, the thread worth following, the 2am insight, gone. Your AI starts fresh. loci doesn't. Every conversation, kept close. Locally, privately, permanently yours. A memory-mapped workspace for AI agents, MCP rooms, and local LLMs. Works in your IDE, on your desktop, with any local or remote LLM. The palace grows as you build inside it. Local-first. MCP-native. Keypair-signed. Zero cloud dependency. Sovereignty stack integration: Nostr, Nym, Ollama, Goose. Your memory, your schema, your terms.
A regular user who chats with AI tools and wants their work to stick. Local index, full-text search, private. No config. No cloud. No re-explaining yourself from scratch every session.
A technically curious builder, gamer, or power user. Run a single curl one-liner to wire loci into Claude Desktop (or your favourite MCP-aware client). Optional Tauri palace app for the full RPG view. Works with local or remote LLMs.
A developer or researcher who wants full control over the context layer. git clone + inspect the MCP server, config, and primitives. Ollama local inference (nomic-embed-text, zero API keys) and MCP plugin for Goose, Continue.dev, and Claude Code are both shipped. Nostr keypair identity in progress, see the roadmap.
The apps you use don't store your knowledge.
They store it for you.
Notion holds your notes. ChatGPT holds your context. Apple holds your memory. They're all landlords, your thinking lives in their architecture, retrievable at their pleasure, gone when you leave. The knowledge you build with AI is yours. It just doesn't live where you live. Yet.
loci inverts this. The index runs in your browser. The search lives on your machine. The palace belongs to the person who builds it.
The palace turns your AI from a tool into something that stays with you. Reads your rooms. Knows your crystals. Every session starts exactly where the last ended, no re-explaining, no rebuilding from scratch. Your AI grows wiser as the palace does.
A room is a named context space, Dev, Design, Research. Each has a soul file your AI reads before it speaks. The room holds what happened here before: the decisions, the patterns, the things that should never need explaining again.
Every room has a CLAUDE.md, the briefing file your AI reads at the start of every session. Two sentences or twenty. It answers: what is this room for, and what must never be forgotten here? Write it once. Let it grow.
A crystal is a fact established once, never re-derived. The decision you keep explaining from scratch every session. Write it in the room's soul file, it becomes part of the palace. Your AI never asks again.
The garden holds open questions growing across sessions. Not tasks, not features, genuine inquiries you're moving toward slowly, across many sessions. A garden plant is something you tend. The garden remembers.
New projects are fragile. The hatchery is the palace's incubator, a room without pressure, for ideas that aren't ready to be named. Prototype. Explore. Fail fast in the dark. When something matures, graduate it to the palace proper.
Local LLMs, MCP-native rooms, remote agents. The palace exposes your rooms as tools your IDE can call. Every room becomes a live context source for any agent in your stack. The palace serves every conjuration.
Shared rooms. Shared crystals. When a teammate opens the Design room they inherit the same accumulated context, not just your notes, but the living memory of every session held there. Co-intelligence that travels between minds.
Every session logged. Every decision preserved. The chronicle is the palace's long memory, not just what you know now, but how you came to know it. Navigate back through your thinking. The palace remembers what you forget.
Full-text search across all your AI chat history. Find that conversation from six months ago in seconds. Every conversation anchored in spatial memory. Navigate your knowledge like rooms in a palace, each locus a persistent node of thought. Persistent context across sessions. Retrieval is O(log n). Semantic indexing optional.
Automatically group conversations by topic, project, or date. Your ideas stay connected, even across different AI tools. Each room is a fully configured MCP workspace. Dev room, Design room, Research room, each with its own tools, memory, and agent context. First-class MCP server support. Compose rooms as namespaced tool collections. Expose or isolate contexts as needed.
Claude, ChatGPT, Gemini, local models, loci works alongside all of them. Switch tools without losing your history. Runs local LLMs, connects remote agents, orchestrates multi-step workflows. The palace serves every conjuration. Provider-agnostic. Swap LLM backends via config. Local-first, cloud-optional. Your data stays yours.
loci remembers what you already figured out. Link back to past insights instead of rebuilding context from scratch every session. A living room for growing ideas. Seeds become concepts, concepts become loci. The garden grows quietly between sessions, return to find it richer than you left it. Rooms are namespaced scopes. Dev context stays in Dev. Research stays in Research. Explicit boundary control per session.
Everything runs in your browser. Your conversations never touch a server. No account, no telemetry, no cloud. Your memory, yours. Where new projects incubate. Prototype, experiment, fail fast in an isolated room. When an idea matures, promote it to the palace proper. Export context as portable JSON. Version-controlled. Diff-able across time. Composable into larger pipelines.
The palace distils your best thinking into crystals, reusable, quotable, linkable knowledge nodes. Extract once, reference everywhere.
Keep it close. loci desktop · Tauri v2
loci for Desktop is your palace on your machine. The Tauri app boots into your ~/.loci/ directory, rooms configured, crystals loaded, agents connected. It lives in your system tray. When you open your IDE, loci is already there. Not a browser tab. Not a cloud sync. A local memory hub that runs while you work. Native Tauri v2 shell wrapping the loci WebView frontend. Gives the renderer OS-level file system access. Manages ~/.loci/ bootstrap on first run. Exposes MCP server via local HTTP. System tray entry point for ⌘K search overlay.
The onboarding runs like a dungeon. Each step is a room. Enter the Palace, configure your rooms, summon your first LLM, expose the MCP server. Complete the setup and your palace is live. The quest doesn't end, it continues with every session. Every room you add is a new wing. Every crystal you extract is loot.
Runs local. No account. No cloud. Runs local. No account. No cloud. Runs local. No account. No cloud.
We built loci because the best AI conversations kept vanishing. A breakthrough insight at 2am, searched for a week later, gone. Re-explaining the same context to the same AI, session after session. Your thinking was happening, just nowhere permanent. loci is the fix: a local memory layer that makes your AI conversations actually yours, fully searchable, never leaving your device.
The memory palace is one of the oldest techniques for thought: a place for everything, everything in its place. loci applies this to co-intelligence. A room is a persistent workspace, Dev, Design, Research, not a single conversation. Conversations happen inside rooms, accumulating context over time. What crystallises from that work becomes a locus: a fixed point in the palace, a node your memory navigates back to. The palace grows as you build inside it. Your thinking becomes architecture.
loci is a context persistence primitive. It solves the stateless session problem for LLM-native workflows, not by adding a cloud layer, but by treating your local machine as the canonical context store. No accounts. No sync. Architecture documented at docs.loci.garden.
{
"version": "0.6.0",
"tier": "wizard", // "eli5" | "wizard" | "llmage"
"index": {
"auto_sync": true,
"sync_interval": "5m",
"full_text": true,
"semantic": false
},
"llm": {
"provider": "local", // "local" | "claude" | "openai"
"endpoint": "http://localhost:11434",
"model": "llama3"
},
"mcp": {
"expose_rooms": ["dev", "research", "design"],
"port": 3721
}
}
{
"loci": {
"url": "http://localhost:3721",
"transport": "http"
}
}
- Any AI tool you already use (Claude, ChatGPT, etc.) A working LLM endpoint, local or remote node >= 18 or python >= 3.10
- About 20 minutes to set things up 20 minutes + the step-by-step guide MCP-compatible client (Claude Code, Zed, Cursor)
- A browser (that's it!) A local LLM or Claude API key (for full palace mode) git + config.json (provided)
-
1
Add to your browser or download the installer Claim Your First Room clone + configure
Download the app. Local index, no account, no cloud. Get running in under 10 minutes. Open Claude Desktop (or your MCP client). The one-liner below writes a backup-protected config entry that loci satisfies as soon as the desktop app is running.
git clone https://github.com/huximaxi/loci && cd loci/desktop && cat .mcp.json -
2
Connect your AI chats Configure Your MCP Endpoint wire MCP server
loci reads your chat history from Claude, ChatGPT, and others, locally, in your browser. Nothing leaves your device. No account, no sync, no cloud. Point loci at your local LLM or API key. Your palace connects to the conjuration engine of your choice. Add loci to your
mcp_serversconfig. Restart your IDE client. -
3
Search anything you've said Walk the Palace invoke + verify
Press ⌘K and search. Find any conversation, any answer, any idea, instantly. Your AI memory, finally yours. Navigate your rooms, recall your loci, summon your agents. The palace grows with every session.
@loci search "your query", verify context window is populated before your first run.
curl -fsSL https://loci.garden/install/wizard.sh | bash
Prefer the GUI? Grab the Tauri palace app below (open beta) or build from source: github.com/huximaxi/loci.
{
"loci_dir": "~/.loci",
"llm": { "provider": "local", "endpoint": "http://localhost:11434" },
"mcp": { "expose_rooms": ["dev", "research"] },
"index": { "semantic": false, "sync_interval": "5m" }
}