A guide to the workspace, the bridge pipeline, the memory key, the MCP server tools, and the REST API.
ContextBridge has four surfaces:
The workspace keeps your chats in tabs, one tab per chat. It runs in your browser: files and pasted text are read there and never uploaded.
/api/c/<id>?format=json and returns the chat to your browser..jsonl files in ~/.claude/projects. The folder is hidden: in the file picker press Cmd+Shift+. to show it, or in Finder use Go to Folder (Cmd+Shift+G).You said:, ChatGPT said:, User: or Claude: split it into messages when both sides speak; otherwise it becomes one message.Formats are detected from the content, not the file name. Inside a .zip only chat files are read, so other files in an export are skipped. Links from Claude, Gemini, Grok, Perplexity, DeepSeek, Copilot or Meta AI are never fetched: export the chat or copy and paste it instead.
Each import is matched to an earlier one by its source (the share id, conversation id, session id, or a hash of pasted text), then compared message by message:
Pasted text only matches an identical paste. Pasting a longer version of the same chat adds it as a new chat; import its share link or export instead to get only the new messages.
Undo last import puts the workspace back the way it was before that import.
Every imported chat starts as Temporary and expires 30 days after you last opened it. An expired chat is removed from this browser the next time you open the workspace. Save a chat to keep it until you discard it. Saving also asks the browser to keep the site's storage; if the browser refuses, it may still clear site data when space runs low. Discard asks first, removes the chat from this browser only, and can be undone for a few seconds. The original chat in its own AI app is never touched.
Continue in copies the chat as one ready prompt: a short instruction, the sources, and every message labelled with its AI and role, inside a block marked as shared data rather than instructions. For ChatGPT, Claude, Gemini, Perplexity, Grok, DeepSeek, Microsoft Copilot and Le Chat it also opens that app in a new tab, where you paste the prompt as your first message; the other app is never filled in for you. For Claude Code and Cursor it copies the prompt only. You can also download the chat as Markdown or the prompt as a .txt file. Each option shows the prompt size, and chats over 100,000 characters get a warning, because many apps cut long pastes; attach the prompt .txt file instead, since it tells the next AI to treat the chat as data, not instructions.
Workspace chats are stored in this browser's IndexedDB, in a database named contextbridge. They are not on our server and do not follow you to another browser or device. Export everything downloads a backup file you can import anywhere. Clearing site data, or a private window closing, removes them. The only workspace data that passes through our server is a link import: the server fetches that one chat from ChatGPT, or reads the stored bridge, and sends it back. A fetched ChatGPT chat is kept in a short in-memory cache (about 10 minutes) for repeat requests and is not saved; a workspace import uses a copy at most about 15 seconds old, so a re-import sees new messages.
[ share link / capture / add_memory ]
|
v
[ ContextBridge server ]
fetch -> decode -> store (temporary)
|
+-------+--------+
v v
[ conversation ] [ embedding index, per memory key ]
| |
v v
website / API /memory search
MCP search_memoryWhen you paste a share link, ContextBridge runs a deterministic pipeline:
id.add_memory with your key for that.There are no accounts. Memory is scoped by a key you create in the browser on the Memory page (format cbk_ plus 43 random characters). The server stores only the SHA-256 hash of the key as a namespace on each memory entry; it never stores or logs the key itself. Every list, search and index call is limited to that namespace, so one key can never see another key's memories. Keep the key safe: it cannot be recovered, and anyone holding it can read those memories.
Send the key on every memory request, either way works:
Authorization: Bearer cbk_... # or x-contextbridge-key: cbk_...
Without a valid key, GET /api/memory and POST /api/memory/search answer 401 with a JSON message pointing you to https://contextbridge.in/memory. POST /api/ingest still creates the bridge without a key but indexes it into memory only when a valid key is sent; its response says which with indexed: true | false.
Every conversation saved with a key is embedded using Xenova/all-MiniLM-L6-v2, an 80 MB ONNX model that runs inside the server process. No OpenAI key, no external embedding API; the model files are downloaded once per server instance.
Embeddings are stored next to the conversation and searched by cosine similarity inside your namespace. The Memory page gives you a live search UI; search_memory exposes the same index to any MCP agent that has your key.
POST /api/memory/search
Authorization: Bearer cbk_...
{ "query": "useEffect infinite loop", "limit": 6 }
-> { results: [{ convId, title, source, role, text, score }] }
GET /api/memory
Authorization: Bearer cbk_...
-> { memories: [{ convId, title, source, turns, indexedAt }] } # your namespace onlyThe Model Context Protocol (MCP) is an open standard for connecting AI apps to external tools. The ContextBridge MCP server runs on your own computer over stdio and calls the contextbridge.in API; there is no hosted MCP endpoint yet.
The package is not on npm. It ships as a tarball from this site (version 0.2.0) and npx installs it straight from the URL. The package is MIT licensed and its source is inside the package.
# run it once by hand
npx -y https://contextbridge.in/downloads/contextbridge-mcp-0.2.0.tgz
# tarball
https://contextbridge.in/downloads/contextbridge-mcp-0.2.0.tgz
# or in your MCP client config:
{
"mcpServers": {
"contextbridge": {
"command": "npx",
"args": [
"-y",
"https://contextbridge.in/downloads/contextbridge-mcp-0.2.0.tgz"
],
"env": {
"CONTEXTBRIDGE_URL": "https://contextbridge.in",
"CONTEXTBRIDGE_KEY": "cbk_..."
}
}
}
}CONTEXTBRIDGE_URL is optional and defaults to the hosted site. CONTEXTBRIDGE_KEY is optional too: set it to a key from the Memory page so the memory tools work on your own memories. Without it the bridge tools still work and the memory tools refuse with a message explaining how to create a key.
5 tools available today:
bridge_share_link(url, format?): fetch and decode a ChatGPT share link into portable context. Returns an agent capsule by default.get_context(id, format?): return an already-bridged conversation in the format you ask for (md / json / txt / agent).search_memory(query, limit?): semantically search the conversations saved under your key. Returns ranked turns with similarity scores.add_memory(content, title?, source?): save a plain-text note into your memory namespace. Useful for capturing decisions or context without a share link. The note is also published as a bridge page that anyone holding its link can open.list_memories(): list the conversations and notes saved under your key.See the Connect page for per-app setup steps.
All endpoints are CORS-open so browser-based agents can call them directly.
# bridge: read a conversation
GET /api/c/{id}?format=md|json|txt|agent[&download=1]
# ingest: push any conversation in (key optional; indexed into memory only with a key)
POST /api/ingest
Authorization: Bearer cbk_... (optional)
{ source, title, turns: [{ role, text, media? }] }
-> { id, url, turns, media, indexed }
# memory: search by meaning (key required, 401 without one)
POST /api/memory/search
Authorization: Bearer cbk_...
{ query: string, limit?: number }
# memory: list your namespace (key required, 401 without one)
GET /api/memory
Authorization: Bearer cbk_...Images uploaded into a chat are stored by the provider behind opaque pointers with no public URL. The bridge therefore carries image references (position, dimensions, a link to the original) rather than raw bytes. The bookmarklet on the Capture page runs in your browser where images are already loaded: images with plain public links are carried across as links, and images from ChatGPT's private file store are kept as size-only tiles that link back to the original conversation. Bridge pages show media as links and never load remote images on their own.
Share-link bridging is stateless: the share link is the source of truth and the page is decoded on demand. Bridges created through ingest (capture, add_memory) and all memory entries live in temporary storage on the hosted server, unless a storage bucket is configured for a deployment. Temporary storage is cleared whenever the server instance is recycled, so bridge links and memories can expire at any time. Do not treat a bridge link as a permanent archive; keep the export if you need it. We do not sell or share your conversations; the processors listed in the privacy policy handle data for us.