ArcRift MCP
Local memory for agents: decisions from browser chats reach Claude Code, Cursor and Windsurf through MCP
- 246 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The extension reads conversation text on Claude, ChatGPT, Gemini and other sites and prepends found context to your prompts
- The backend stores chat content in a local SQLite file, and secret scrubbing relies on patterns and may miss a nonstandard key
- The prune_memory tool deletes facts and chunks from memory
Install
- Works in
Manual install
npx arcrift-setupThe script clones the repository, checks dependencies, pulls Ollama models, installs packages, builds the backend and creates `.env`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The extension reads conversation text on Claude, ChatGPT, Gemini and other sites and prepends found context to your prompts
- The backend stores chat content in a local SQLite file, and secret scrubbing relies on patterns and may miss a nonstandard key
- The prune_memory tool deletes facts and chunks from memory
This is third-party code. Review the repository files before installing.
What it does
ArcRift keeps project context on your computer and hands it to agents. A browser extension takes a copy of a conversation in Claude, ChatGPT, Gemini, DeepSeek, Grok, Copilot or Mistral, scrubs API keys, JWTs, emails and IP addresses from it and sends it to a local backend. The backend splits the text into chunks, computes embeddings through Ollama, extracts subject-relation-object facts and stores everything in a single SQLite file with a knowledge graph. The MCP server gives agents seven tools: `recall_context` fetches relevant project chunks, `store_memory` saves text or a transcript, `search_memory` searches across all projects, `list_projects` lists projects, `get_project_summary` builds a graph summary, `identify_active_project` detects the project from a path, and `prune_memory` removes outdated facts. The browser extension and the MCP server share one database, so a decision saved from a chat shows up in `recall_context`, and an entry from `store_memory` is visible in the dashboard at `http://localhost:3001`. With auto-connect on, the extension also prepends the found context to every new prompt on the chat site.
Who it is for. Developers who discuss architecture with chat bots in the browser and write code in Claude Code or Cursor and are tired of retelling the context.
Good fit when
- Thirty conversations about auth and the database schema sit in web chats, and the agent in the editor knows nothing about them
- A new Claude Code session starts with `recall_context` for the project so past decisions are not retold
- An outdated fact, say about rate limits, must be erased from memory without deleting the whole project
- Data must not go to the cloud, and memory has to live in a single local SQLite file
Not a fit when
- The computer has under 2 GB of memory with no room for Ollama and its models: local embeddings will not run
- A shared team memory on a server is needed: ArcRift keeps the database local to one user
- A notes file in the repository is enough: running a backend, an extension and Ollama for that is excessive
Example request
Call recall_context for the AuthService project with the query "refresh token rotation" and continue the implementation following past decisionsMCP
- Transport
- stdio
- Authentication
- not required
Environment variables
ARCRIFT_STORAGE_MODErequired- Storage mode: sqlite replaces all Docker services with a single ArcRift.db file.
OLLAMA_URLrequired- Address of local Ollama, http://localhost:11434 by default, for embeddings and fact extraction.
Limitations
- Node.js 20 and newer and Ollama for embeddings and fact extraction are required, with 2 GB of memory and 3 GB of disk in SQLite mode. Groq with a free key serves as a fallback if Ollama is slow.
- The MCP server is built from source (`npm run build` in `backend`), and the agent config gets the absolute path to `server.js`.
- The extension needs a running backend. In Chrome it is installed from an archive in developer mode, in Firefox from a signed `.xpi`.
- The ready installer in the README is an .exe file, and on other systems you install through `npx arcrift-setup`.
How to disable. Remove the server from the agent config: in Claude Code run `claude mcp remove ArcRift`, in Cursor and Windsurf drop the `arcrift` entry from `mcp.json`. Disable the extension at `chrome://extensions`, and delete the `ArcRift.db` file to erase the database.
FAQ
How do I connect ArcRift to Claude Code?
Build the backend and run `claude mcp add ArcRift node /path/to/ARCRIFT/backend/dist/mcp/server.js` in the project directory. `npm run mcp:config` in `backend` prints a ready block with absolute paths.
Do requests go to the cloud?
No, embeddings and fact extraction run through local Ollama, the database is a SQLite file and the backend CORS is limited to localhost. Cloud Groq is connected only as a fallback.
Can I do without the browser extension?
Yes, the MCP server runs on its own and opens the database itself. Memory is then filled through `store_memory` from the agent.
How do I remove a wrong fact from memory?
Call `prune_memory` with a description of the fact and the project name, for example "Redis rate limiting". The tool deletes the matching facts and chunks, and the rest of the project stays.
What does the dashboard on port 3001 show?
Open `http://localhost:3001` with the backend running: the Graph, History, Chat and Job Queue tabs show the knowledge graph, extracted facts, saved conversations and background indexing jobs.
Discussion
No questions or reviews yet.
Related
MCP serversLocal memory for agents: stores conversations and project files verbatim and retrieves them with semantic search over MCP
Long-term memory for agents: a remote MCP server, plugins for Claude Code, Cursor and Codex, and an API for your own apps
Local persistent memory for coding agents: hooks record every session, and Claude Code, Codex or Cursor recall past decisions through 54 MCP tools
Self-hosted long-term memory for agents: semantic search, a knowledge graph and autonomous consolidation over MCP and a REST API
Membase keeps one shared memory for AI agents that Claude Code, Cursor and Codex read through MCP, an SDK or the membase command
An MCP server that keeps project decisions in Redis or Valkey and brings them back in new sessions and after compaction.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| ArcRift (this card) | no | not required | 246 | |
| Claude-Mem | no | 114,119 | a memory plugin for the agent's own sessions; here conversations from browser web chats are copied as well | |
| Basic Memory | no | not required | 4,509 | memory in local Markdown files with a link graph; here a SQLite database and an extension for browser chats |
README in short
The README explains the lost-context problem and installs ArcRift with one command. Then come installation of the desktop app, the extension and the MCP server for four clients, usage examples of the tools and the dashboard on port 3001. Further down are system requirements, search features, architecture, the data flow, quality measurements and a comparison with alternatives.