ArcRift — Persistent Memory for AI Coding Tools
Your AI forgets everything between sessions. ArcRift fixes that.
Memory saved in a browser chat is instantly available in your coding tool, and vice versa.
A local-first memory layer that captures your conversations, builds a searchable knowledge graph, and automatically injects the right context into every new prompt — no cloud, no subscriptions, no re-explaining yourself.
Browser Extension: Claude · ChatGPT · Gemini · DeepSeek · Grok · Copilot · Mistral
MCP (AI Coding Tools): Claude Code · Cursor · Windsurf · Claude Desktop
https://github.com/user-attachments/assets/f77a865a-cee9-4f7c-b0fa-4fb4d1cee7be
The Demo only showcases the main function of ArcRift, there are a lot of features for you to Explore!
One Command Setup
npx arcrift-setup
The Problem
You are deep in a complex project. You have had 30 conversations with Claude about your auth flow, database schema, and deployment strategy. You open a new chat — and it is all gone. You spend 10 minutes re-explaining context you have already covered, and the AI gives you advice that contradicts decisions you made two weeks ago.
ArcRift stops the cycle. It captures your AI conversations, extracts structured facts into a knowledge graph, embeds them as searchable vectors, and automatically prepends the most relevant context to every new prompt — before you even finish typing.
Table of Contents
- One Command Setup
- The Problem
- Installation
- Usage Guide
- System Requirements
- Key Features
- Architecture
- Quality-of-Life Details
- How It Works
- How the Two Modes Work
- Performance Benchmarks
- Privacy and Security
- Comparison with Alternatives
- What's New in v1.6.3
- Documentation
- Contributing
- License
Installation
For Users (The Easy Way)
[!IMPORTANT] ArcRift is a powerful AI developer tool. Before installing the
.exe, you must have Node.js and Ollama installed on your computer to run the backend and local AI models. If you don't have these, use the Developer (One-Command Setup) below to automatically install them!
- Head over to the Releases page.
- Download the latest
ArcRift_Installer.exe(or your OS equivalent). - Double-click the installer to install ArcRift on your machine.
- Launch ArcRift from your Start menu! The app will live entirely in your system tray and run seamlessly in the background.
For Developers (Building from Source)
If you want to modify the code, build the project yourself, or use the MCP Tools:
1. One-Command Setup (All Platforms)
npx arcrift-setup
copy .env.example .env
This clones the repo, checks dependencies, pulls Ollama models, installs packages, builds the backend, and sets up the env file.
2. Launching the Development Server To launch the native desktop application in dev mode:
npm run dev:desktop
or
cd dashboard
npm run dev
cd backend
npm run dev
This will start the backend seamlessly in the background and open the native ArcRift dashboard. When you close the window, it will minimize to your system tray. You can fully quit ArcRift from the tray menu.
Web Extension Setup
The extension requires the ArcRift backend to be running. If you have the ArcRift Desktop App running in your system tray, you are already good to go!
Step 1 — Install the Extension
For Google Chrome / Edge / Brave:
- Download the Chrome
.zipfile from the GitHub Releases page. - Extract the
.zipfile to a permanent folder on your computer. - Open
chrome://extensions - Enable Developer mode (top-right toggle)
- Click Load unpacked and select the folder you just extracted.
- The ArcRift icon will appear in your toolbar!
For Mozilla Firefox:
- Download the officially signed
.xpifile from the GitHub Releases page. - Simply drag and drop the
.xpifile directly into your open Firefox window. - Click Add when prompted. It will be installed permanently!
Step 2 — Use it
Navigate to Claude, ChatGPT, Gemini, DeepSeek, Grok, Copilot, or Mistral. Click the ArcRift popup, enter a project name, and click Save Chat. Auto-connect activates immediately.
MCP Server Setup
The MCP server runs as a separate process and communicates with AI coding tools over stdio. The backend does not need to be running as an HTTP server — the MCP server initializes its own storage connection.
Step 1 — Build the backend
cd backend
npm install
npm run build
This produces backend/dist/mcp/server.js.
Step 2 — Generate your config (easiest)
cd backend
npm run mcp:config
This prints a pre-formatted JSON block with absolute paths resolved for your machine. Copy it directly into your tool's config file.
Step 3 — Add to your AI tool
Claude Desktop — %APPDATA%\Claude\claude_desktop_config.json (Windows) or ~/.claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"arcrift": {
"command": "node",
"args": ["C:/path/to/ARCRIFT/backend/dist/mcp/server.js"]
}
}
}
Claude Code — run in your project directory:
claude mcp add ArcRift node /path/to/ARCRIFT/backend/dist/mcp/server.js
Cursor — create .cursor/mcp.json in your project root:
{
"mcpServers": {
"arcrift": {
"command": "node",
"args": ["/path/to/ARCRIFT/backend/dist/mcp/server.js"]
}
}
}
Windsurf — create .windsurf/mcp.json in your project root:
{
"mcpServers": {
"arcrift": {
"command": "node",
"args": ["/path/to/ARCRIFT/backend/dist/mcp/server.js"]
}
}
}
Use forward slashes in all paths, even on Windows. Restart your AI tool after editing the config.
Step 4 — Set the storage mode
The MCP server reads backend/.env. Make sure it contains:
ARCRIFT_STORAGE_MODE=sqlite
OLLAMA_URL=http://localhost:11434
Ollama must be running for the MCP server to generate embeddings and extract knowledge graph triples.
Running Both Together
When running the browser extension and MCP server together, they share the same ArcRift.db database. No extra configuration is needed.
- Start the HTTP backend:
start.bator./start.sh - Load the extension in Chrome (it talks to
http://localhost:3001) - Your AI coding tool starts the MCP server automatically when you open a project
Memory saved via the extension is immediately available in recall_context, and memory stored via store_memory appears in the dashboard history. They are the same database.
The HTTP backend and MCP server both use WAL mode on SQLite, which allows them to read and write concurrently without locking each other out.
Usage Guide
Using the Browser Extension
Saving a conversation:
- Have a conversation on any supported platform
- Click the ArcRift icon in your browser toolbar
- Enter a project name (e.g.
AuthService,MyApp-Backend) - Click Save Chat
ArcRift scrubs PII, chunks the text, embeds it locally with Ollama, and sends it to the backend. The UI confirms success in under 5 seconds. Background indexing (sentence-level embeddings, knowledge graph extraction) continues asynchronously.
Auto-connect:
Once a session is saved and activated, ArcRift intercepts every prompt you type on that platform. Before the request is sent, it queries the backend for relevant context and prepends the top results. You do not need to do anything — just type normally.
To pause: click the ArcRift popup and hit Pause. The badge dims. Click again to resume.
New chat detection:
When you click "New Chat" on ChatGPT, Claude.ai, or Gemini, ArcRift detects the URL or DOM change and resets the active session. The next Save will start a fresh project, and context from the previous session will not bleed in.
Classic inject:
For a one-time context push without enabling auto-connect, click Inject Context in the popup. ArcRift pastes the knowledge graph summary directly into the chat input field. You review it and send manually.
Using the MCP Tools
Once connected, your coding agent has access to seven ArcRift tools. A typical session looks like this:
At session start — recall project memory:
Use recall_context with prompt: "implementing JWT refresh token rotation"
and project: "AuthService"
After completing work — save decisions:
Use store_memory with content: "We implemented refresh token rotation using
Redis for token invalidation. The key insight was using a sliding expiry window
of 15 minutes for access tokens and 7 days for refresh tokens." and project: "AuthService"
Finding something from a different project:
Use search_memory with query: "rate limiting strategy"
Getting an overview before starting:
Use get_project_summary for project: "AuthService"
Auto-detecting the current project:
Use identify_active_project with path: "/Users/me/code/auth-service"
Correcting outdated information:
Use prune_memory with prompt: "Redis rate limiting" and project: "AuthService"
Dashboard
Open http://localhost:3001 while the backend is running.
System Requirements
SQLite mode is the recommended default. The installer detects Docker automatically and sets SQLite mode if Docker is not available.
Prerequisites
Key Features
Core Retrieval Engine
Extension Quality-of-Life
MCP Tool Quality-of-Life
Infrastructure
Architecture
ARCRIFT/
├── backend/
│ ├── src/
│ │ ├── mcp/ MCP server and seven tool implementations
│ │ ├── routes/ REST API (chat, rag, session, jobs)
│ │ ├── services/ Storage bridge, SQLite engine, vector store,
│ │ │ graph store, embeddings, job queue, extractor
│ │ ├── middleware/ Rate limiting, sanitization, CORS
│ │ └── utils/ Logger, privacy scrubber
│ └── scripts/ Benchmarking, stress testing, maintenance tools
├── dashboard/ React 19 + D3.js + Vite — built to dashboard/dist/
├── extension/
│ ├── src/
│ │ ├── platform/ Multi-strategy DOM resolver
│ │ ├── platforms/ claude, chatgpt, gemini, deepseek, grok, copilot, mistral
│ │ ├── content.ts DOM scraping, prompt interception, auto-connect
│ │ └── background.ts Service worker, backend proxy
│ └── popup/ Popup UI and controls
├── reports/ Benchmark and audit outputs
├── .env.example Configuration template
├── docker-compose.yml Full Docker profile
├── install.bat / .sh First-time setup
└── start.bat / .sh Daily launcher
Ports
Tech Stack
Quality-of-Life Details
These are the smaller decisions that make the system faster and more reliable in practice.
Instant save, deep index later. When you click Save, only the chunk-level embeddings are computed synchronously (1–2 embeddings). Sentence-level embeddings (20–40 embeddings per conversation) are offloaded to a background job. The UI confirms success immediately; the deep index catches up within seconds.
Delete-then-insert for vector updates. SQLite virtual tables do not support UPDATE on vector columns. ArcRift uses a delete-then-insert pattern to avoid UNIQUE constraint errors when re-saving a conversation.
Prefix keyword matching. FTS5 queries use wildcard suffixes (encrypt* matches encryption, encrypted, encryptor). This significantly improves recall for technical terms where the exact suffix varies.
Threshold set at 0.30, not 0.45. Surgical trimming allows a lower similarity threshold. Even if a chunk is only loosely related, if the matching sentences are precise, the noise penalty is near zero.
History-aware fallback. If a query is detected as a history-seeking question ("what did we talk about", "what was decided"), the trimmer falls back to the first three sentences of the chunk rather than returning nothing.
5-character minimum sentence filter. The sentence splitter ignores fragments shorter than 5 characters. This prevents code snippets and punctuation artifacts from polluting the sentence index.
WAL mode on all writes. SQLite is opened in WAL mode on startup. The MCP server, HTTP backend, and dashboard can all read and write concurrently without database lock errors.
Ghost job recovery. On startup, any jobs stuck in PROCESSING from a previous crash are reset to PENDING automatically. No manual intervention needed after an unclean shutdown.
CORS locked to localhost. The backend only accepts requests from localhost origins. External requests are rejected before they reach any route handler.
How It Works
SAVE
Browser scrapes conversation → FNV-1a dedup check
→ PII scrub (API keys, JWTs, emails, IPs → [REDACTED])
→ POST to backend
STORAGE (two parallel tracks)
Vector Track Graph Track
Sliding window chunker Text sent to Ollama llama3.1:8b
300 words, 80-word overlap (Groq as fallback)
Embeds with nomic-embed-text Extracts subject-relation-object triples
Stores in SQLite vec0 Stores in SQLite facts table
Background: sentence-level Background: stores after chunk embedding
embedding job queued
RECALL (on every prompt or tool call)
Query → HyDE (generate hypothetical answer → embed both)
→ Sentence vector search (top 100, filter by session)
→ Chunk vector search (top 20, filter by session)
→ FTS5 keyword search (prefix match, filter by session)
→ Fuse results, score, deduplicate
→ Surgical trim (keep only matching sentences from each chunk)
→ sanitizeChunks() (scan for injection patterns → redact)
→ wrapInContextBlock() (lean text header)
→ Prepend to prompt
How the Two Modes Work
ArcRift has two complementary modes that share the same memory store. You can use one, the other, or both at the same time.
Mode 1 — Browser Extension (Web)
The extension lives inside Chrome and works on any AI chat website. When you save a conversation, it scrapes the page, scrubs PII, chunks and embeds the text locally, and sends it to the ArcRift backend. On every subsequent prompt you type, the extension intercepts the input, queries the backend for relevant context, and prepends it to your message automatically — before the request hits the AI.
Best for: Claude, ChatGPT, Gemini, DeepSeek, Grok, Microsoft Copilot, and Mistral web interfaces.
Mode 2 — MCP Server (Coding Tools)
The MCP server exposes ArcRift as a set of tools that coding agents can call directly. Instead of intercepting DOM events, the AI tool calls recall_context at the start of a session to pull in relevant memory, and store_memory after completing work to save decisions and context for future sessions.
Best for: Claude Code, Cursor, Windsurf — anywhere you write code with an AI coding agent.
Shared Memory
Both modes write to and read from the same backend database. A conversation you save via the browser extension is immediately available to recall_context in your coding tool, and vice versa. They are two interfaces into one unified knowledge base.
Performance Benchmarks
Every release is stress-tested across four independent audits. All results are reproducible using the scripts in backend/scripts/.
Web Context Engine (Browser Extension)
Scale: 1,000 chunks (~300,000 words) | Needles: 20 facts | Queries: 60 phrasings
Engine contribution across 54 successful recalls:
The 6 misses were all on degenerate "Context on X?" queries with no semantic content. All natural-language and rephrased queries passed.
Full report: reports/benchmark_web.md
MCP Context Engine (Coding Tools)
Scale: 10 facts across real project memory | Queries: 30 (3 phrasings each) | TopN: 6
Engine contribution across 27 successful recalls:
The 3 misses were all on highly rephrased semantic queries with no shared keywords. Standard and lowercase phrasings passed in every case.
Full report: reports/benchmark_mcp.md
MCP Project Isolation Audit
Scale: 10 simultaneous projects | Checks: Store + own-recall + cross-leak per project
Each project's vector space and knowledge graph is strictly siloed via sessionId constraints. Aggressive cleanup logic purges both IDs and Names between runs to prevent identity drift.
Full report: reports/mcp_stress_test.md
Knowledge Graph Stress Audit
Scale: 1,200+ nodes, 1,087 triples in a single session
Graph structure: 5 major hubs (40+ edges each), 15 intermediate clusters, 400 mesh entities, 100 isolated standalone facts.
Full report: reports/graph_stress_test.md
Privacy and Security
ArcRift was designed with a local-first philosophy from the ground up. Your conversations never leave your machine unless you explicitly configure a cloud LLM.
See SECURITY.md for the full threat model and vulnerability reporting policy.
Comparison with Alternatives
While tools like Mem0, Zep, and Letta focus heavily on providing memory APIs for agent developers, ArcRift is built directly for end-users and human-in-the-loop workflows.
What's New in v1.6.3
This release brings full cross-browser support to ArcRift and patches a critical context injection bug.
- Mozilla Firefox Support: ArcRift is now fully compatible with Firefox! The extension build pipeline generates independent Chrome and Firefox packages, and we have fully automated the Mozilla Add-ons signing pipeline so signed
.xpiextensions are attached to every release. - RAG Hallucination Fix: We caught a bug where out-of-context chats were injecting irrelevant project memory because the vector DB returned the top closest matches no matter how semantically distant they actually were. The retrieval pipeline now enforces a strict 50% relevance threshold.
(Note: If you were testing v1.6.1 locally, all core desktop app updates remain the same in this release).
See CHANGELOG.md for the full history.
Documentation
Contributing
Bug fixes, new platform support, UI improvements, and test coverage are all welcome.
Contributing Guide · Code of Conduct
Good first issues: good first issue
License
MIT — see LICENSE.
Stop re-explaining yourself. Give your AI the memory it should have had from day one.
Built by Eshaan Nair