Using Context Repo with Claude, Cursor, and ChatGPT

The hardest part of using AI tooling in 2026 is not picking the best model. It is figuring out how the model knows what your project, team, or research is actually about. The answer for most people is to spread the same context across three or four clients (Claude for long-form thinking, Cursor for code, ChatGPT for everything in between) and accept the friction of re-uploading documents and re-pasting prompts every time you switch.

We built Context Repo to reduce that switching cost. One context repository, many compatible AI clients. This article walks through three workflows for humans and agents, each ending in the same place: one repo that the connected clients can read.

What one context repository across compatible clients looks like

Before the workflows, a quick mental model. A context repository is a single store for the prompts, documents, and collections you keep coming back to. Compatible AI clients connect to that store and read the items allowed by their credentials. Once an item is saved there, you do not need a separate copy for each connected client.

Rendering diagram

Three client surfaces, one hub, one library of prompts and documents. The Chrome extension is the capture path that feeds everything in from the open web. The rest of this article is what each of those arrows looks like in practice.

How Cursor connects to Context Repo

Picture a senior engineer running a feature branch in Cursor. They have a system prompt they spent a month tuning for code review, a folder of spec PDFs from the product team, and a set of architectural decision records they need the AI to consult before suggesting a refactor.

Without a context repository

The painful version of the workflow looks like this:

• Open the spec PDF in a separate window, paste relevant sections into Cursor's chat.
• Re-type the system prompt at the start of each session because it was never saved to a shared store.
• Hope the AI does not make a suggestion that contradicts an ADR nobody told it about.

The Context Repo version

1. Once, ahead of time, save the system prompt as a versioned template in the Context Repo dashboard. Tag it code-review. Drop the spec PDFs and ADRs into a collection called project-x.
2. Install the Context Repo MCP server in Cursor via the one-click cursor:// deeplink at contextrepo.com/mcp-server.
3. Generate an API key with prompts.read and documents.read. Collections share the document scopes, and keys cannot be restricted to one collection ID. Paste the key into Cursor's MCP config.

Now, when the engineer asks Cursor to review a diff, Cursor can call workspace-wide find_items to identify relevant prompts, documents, and collections. It can then call deep_search with the project-x collection ID to search document passages in that collection. The system prompt is fetched with read_prompt after discovery returns its ID. Nothing is re-pasted. Nothing is re-uploaded.

Why version history is the safety net

If the engineer tunes the prompt content and the next session goes off the rails, restore_prompt_version copies last week's snapshot into a new current version without a manual rebuild. Content updates create versions; title, description, and tag edits patch metadata in place.

How Claude Desktop and Claude.ai both reach the same repository

A different shape. A researcher running Claude.ai through the browser, working through a long-form analysis that touches five different domains over the course of a week. They have a folder of reference PDFs, a curated set of interview transcripts captured from various web sources, and a research protocol prompt they want Claude to follow at the start of every session.

Where the friction lives

• Upload the same five PDFs to every Claude conversation.
• Find the saved Claude project from two days ago, dig the protocol out of the system prompt field.
• Realize the interview transcript was in a different tab that Chrome closed last night.

The Context Repo version

1. Capture transcripts and articles using the Chrome extension at the Chrome Web Store. On ChatGPT and Claude, Save this chat extracts the visible conversation and submits it as a document. On an ordinary HTTP(S) page, Capture this page sends the URL through the Firecrawl-backed scrape endpoint, or Pick element submits selected page text directly. Signed-in content that Firecrawl cannot reach should use direct chat or element capture. Organize the saved document into a collection afterward when useful.
2. Upload the PDFs once through the dashboard. 75+ file formats process through LlamaIndex Cloud (the parsing service that converts uploads into clean text). The documents land as searchable, chunked artifacts with full version history.
3. Connect Claude.ai to Context Repo through its remote MCP integration. Paste https://contextrepo.com/mcp into the Claude.ai integrations panel and authenticate with OAuth. Claude Desktop uses the context-repo-mcp stdio bridge and JSON config on the MCP Server page. Both connections resolve to the same Context Repo account, subject to the authority of the OAuth token or API-key scopes.

The researcher can start a Claude session by explicitly asking it to read the protocol prompt. The host can call read_prompt and return the current stored version. When the analysis needs the interview from last Tuesday, the researcher can ask Claude to find it with find_items, then inspect relevant passages with deep_search. The host model decides which advertised tools to call; Context Repo does not invoke them automatically.

What changes day to day

• The protocol prompt is in one place and evolves with version history, not scattered across system-prompt fields in seven Claude projects.
• The reference library is captured-on-sight via the Chrome extension, not curated after the fact.
• Switching to Claude Desktop does not require re-uploading repository items. Both Claude clients can read from the same Context Repo account once each connection is configured.

Does ChatGPT have native Context Repo support?

Yes. A third shape, common in operations and product roles. Someone who uses ChatGPT as their primary AI client because it is already in their browser and they do not want a desktop install, but who has accumulated a backlog of go-to prompts and reference docs that ChatGPT has no good way to organize.

What the ChatGPT App actually does differently

The Context Repo version of this person's workflow looks slightly different because ChatGPT has a different integration surface than MCP-native clients:

1. Turn on Developer mode and add the Context Repo ChatGPT App from ChatGPT Plugins. The app connects directly to the hosted MCP server and exposes search and fetch in the shape expected by OpenAI Apps SDK Company Knowledge.
2. Capture pages with the Chrome extension while browsing. On chatgpt.com, Save this chat extracts the visible conversation. Ordinary HTTP(S) pages use Firecrawl-backed URL capture or direct element selection. You can add the resulting document to a collection afterward.
3. Use prompts by reference. Ask ChatGPT to find your code-review prompt. The app can search the repository, retrieve the matching item, and bring its content into the conversation.

What it looks like in conversation

The search tool returns citation-ready results. For a returned ID, fetch retrieves full prompt content, document content up to the REST response limit, or collection metadata plus up to 50 member items. Use Deep Search for targeted retrieval from large documents. Separately, the server can register a ui://search-results resource for find_items when its MCP Apps feature flag is enabled. Hosts that do not render that optional resource still receive normal text and structured tool results.

For the operator, the value is less about MCP plumbing and more about keeping selected context outside any one chat session. A prompt saved three weeks ago remains in Context Repo until you change or delete it, indexed by what it says rather than where you last used it.

Do I need separate API keys for each AI client?

No. One Context Repo account can have several OAuth connections and API keys pointing to the same repository.

OAuth gives every MCP host the same identity, so if you sign in with Google in Claude.ai and again in Cursor, both clients see the same prompts and documents under your user. API keys (the ones that start with gm_) are reusable across clients too. You can paste the same key into Cursor's MCP config and a custom Python script, and both will authenticate as you.

The clean pattern, especially if you work from more than one machine or integration, is one API key per installation with scoped permissions:

• laptop-readonly: prompts.read, documents.read
• desktop-agent: prompts.write, documents.write for a trusted local MCP bridge (write implies read)
• agent-script: documents.write for an ingestion job (also implies documents.read)

The four available API-key scopes are prompts.read, prompts.write, documents.read, and documents.write. Collection operations share the document scopes. These scopes apply by resource type, not by collection ID.

If a device walks off, you revoke its key from the dashboard. The other devices keep working. Permissions are stored on the API-key row itself, so the scope check happens at the moment of the call.

What if my AI client isn't on the supported list?

The Model Context Protocol is an open standard from Anthropic (modelcontextprotocol.io). A conformant client can connect if it supports Context Repo's Streamable HTTP and authentication path, or can run the context-repo-mcp v3 stdio bridge. Clients requesting text/event-stream receive SSE-framed responses; a compatibility adapter unframes responses for JSON-only clients.

The MCP Server page lists clients with first-party install paths:

• Cursor (one-click cursor:// deeplink)
• Claude Desktop (JSON config)
• Claude.ai (remote MCP integration)
• VS Code (one-click install)
• Windsurf, Factory, Goose, Continue, Cline, Open WebUI (mcp.json config)
• ChatGPT App (separate install path)

For another remote client, configure https://contextrepo.com/mcp with a supported OAuth or API-key flow. For a stdio-only host, use the page's JSON config for the context-repo-mcp v3 package and a scoped API key. Either path discovers the hosted tool inventory rather than requiring tool-by-tool configuration.

Where this clicks

The pattern across all three workflows is the same: the AI client is wherever you are most productive, and the context repository is the spine. The engineer in Cursor, the researcher in Claude, and the operator in ChatGPT are all reading from the same prompt store, document library, and collections. When you edit a prompt template, the next read in any client picks up the current version.

Some other places this pattern fits:

• A consultant rotating between three client engagements keeps each client's reference material in its own collection and passes that collection ID to document-only retrieval when appropriate. Collections help organize retrieval, but they are not API-key security boundaries.
• A founder bouncing between strategy work in Claude and code work in Cursor keeps the same product spec accessible from both, queried by intent.
• A team of one who is also a team of many (the same human acting as engineer, researcher, and operator over the course of a day) keeps every prompt and document in one repo and stops re-uploading anything.

We are pre-launch as of writing, so this is the product we built. The proof is in your own workflow, not in our marketing. The free 7-day trial is the right way to find out whether the friction-reduction is real for you specifically.

Connect your AI client to Context Repo

If you want to try this in a single afternoon, the path is exactly five steps:

1. Sign in and start your free trial. Open contextrepo.com and start the 7-day Pro or Pro Max trial. It enables the plan's features with that plan's storage and usage limits.
2. Save one prompt and upload one document. From the dashboard, save a system prompt you already use, then upload a reference document. Context Repo handles 75+ file formats through LlamaIndex Cloud and keeps version history for prompts and documents.
3. Install the MCP server in your AI client. Visit contextrepo.com/mcp-server and use the one-click Cursor deeplink, copy the JSON config for Claude Desktop, or add https://contextrepo.com/mcp to Claude.ai. For ChatGPT, turn on Developer mode, then add Context Repo from ChatGPT Plugins.
4. Authenticate once. Sign in with OAuth or paste an API key from the dashboard. Both authenticate the same account; an API key exposes only the resource types allowed by its scopes.
5. Run one query from the client. Ask the AI to find your saved prompt or search your document library. Remote clients and context-repo-mcp v3 stdio installs discover the current 29 hosted MCP tools, including find_items for this lookup. A returned match confirms that the connection works.

That is the loop. Everything else (collections, resource-scoped API keys, the Chrome extension, the ChatGPT App, the 29 hosted MCP tools, the 35 REST operations) is depth you add when you need it.

Where to read next

• What Is an AI Context Repo for Agents?. Category framing for the whole product line.
• Prompt and Document Management for AI Agents. The day-to-day mechanics of versions, variables, and 75+ file formats.
• How MCP Servers Connect AI Agents to Knowledge Bases. The protocol layer that makes every connection in this article work.
• Semantic Search and Deep Search: Two Retrieval Layers. How retrieval actually finds the right passage once your AI is connected.
• MCP Server install page. One-click installs for every supported client.
• Pricing. Plans and free trial.