Integrations12 min read·

Using Context Repo with Claude, Cursor, and ChatGPT

How a single context repository travels across Cursor, Claude Desktop, Claude.ai, and ChatGPT. Real workflows for the engineer, the researcher, and the operator, plus the Chrome extension that feeds all three.

By Context Repo Team

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 so that switch costs nothing. One context repository, every AI client. This article walks through three workflows for humans and agents, each ending in the same place: one repo, every client.

What "one context repository, every AI client" actually 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. Your AI clients connect to that store and read from it directly. No more pasting, uploading, or remembering where you last saved a useful page.

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 (Cursor lost it).
  • 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 scoped to prompts.read, documents.read, collections.read on the project-x collection. Paste it into Cursor's MCP config.

Now, when the engineer asks Cursor to review a diff, Cursor calls find_items (which searches across prompts, documents, and collections in one call) with the diff context. It pulls the relevant ADR passages with deep_search (which jumps to the exact passage inside a long document), and grounds its suggestions in real project history. The system prompt is fetched by name with read_prompt. Nothing is re-pasted. Nothing is re-uploaded.

Why version history is the safety net

If the engineer tunes the prompt and the next session goes off the rails, restore_prompt_version rolls the prompt back to last week's version without a manual rebuild. Every edit creates a new version. The history is automatic.

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 straight off the web using the Chrome extension at the Chrome Web Store. One click on any tab (chatgpt.com, claude.ai, an arXiv paper, an internal wiki) and the page becomes a Context Repo document in the chosen collection.
  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. Same identity, same data. Claude Desktop uses the one-click install badge on the MCP Server page and reads from the exact same store.

Now the researcher starts every Claude session by asking it to read the protocol prompt. Claude calls read_prompt, gets the latest version, and proceeds. When the analysis needs the interview from last Tuesday, the researcher asks Claude to find it. Claude calls find_items in semantic mode, ranks the candidate documents, picks the right one, and pulls the relevant passages with deep_search.

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 for a longer session is a no-op. Both Claude clients read from the same context repository, with one identity.

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. Install the Context Repo ChatGPT App via the ChatGPT App Store. The App is built on the OpenAI Apps SDK (the way ChatGPT extends itself with rich in-conversation components) and connects directly to the same MCP server.
  2. Capture pages with the Chrome extension while browsing. The extension works on every site, including chatgpt.com, so saving a useful exchange straight into a Context Repo collection is one click.
  3. Use prompts by reference. Ask ChatGPT "find my code-review prompt" and the App calls find_items with the prompts filter, renders the result widget, and one click pulls the template body into the conversation.

What it looks like in conversation

When ChatGPT calls find_items, the Context Repo App returns a styled HTML widget right inside the chat: titled cards with snippets, click-throughs, and a visible match count. Other tool calls (creating a prompt, opening a specific document) return as standard text responses. The widget is reserved for the search surface, because that is where a visual layout actually helps.

For the operator, the value is less about MCP plumbing and more about ChatGPT finally having a memory that survives session boundaries. The prompt you wrote three weeks ago is still there, in the same place, indexed by what it says rather than where you last saved it.

Do I need separate API keys for each AI client?

No. One Context Repo account, one set of credentials, one context 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, is one API key per device with scoped permissions:

  • laptop-readonly: prompts.read, documents.read, collections.read
  • desktop-full: full read + write scopes for the dashboard machine
  • agent-script: documents.write only for an ingestion job

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?

Any MCP-compatible client works. The Model Context Protocol is an open standard from Anthropic (modelcontextprotocol.io), and the Context Repo server is standard JSON-RPC over streamable HTTP (the modern MCP transport that travels over a normal web connection, no special networking needed). Older clients that send Accept: text/event-stream still work because the server detects the request type and adapts.

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

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

For anything else, the manual JSON config is on the same page: the MCP endpoint URL (https://contextrepo.com/mcp), an API key, and you are in. The server identifies itself as mcp-typescript server on vercel v0.1.0 on the initialize handshake, so any conformant client can discover the 28 tools without 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, the same document library, and the same collection scope. When you edit a shared prompt template, the next read in any client picks up the new version.

Some other places this pattern fits:

  • A consultant rotating between three client engagements keeps each client's reference material in its own collection, scopes the API key per laptop, and never accidentally surfaces client-A research while working on client-B.
  • 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 3-day Pro 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 the Pro trial. Open contextrepo.com and start the 3-day free Pro trial. The trial unlocks the full feature set.
  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 stores everything with version history.
  3. Install the MCP server in your AI client. Visit contextrepo.com/mcp-server and click the one-click badge for Cursor or Claude Desktop, or paste https://contextrepo.com/mcp into the Claude.ai integrations panel. For ChatGPT, install the Context Repo App from the ChatGPT App Store.
  4. Authenticate once. Sign in with OAuth or paste an API key from the dashboard. Both routes resolve to the same identity and the same content.
  5. Run one query from the client. Ask the AI to find your saved prompt or search your document library. The client lists the 28 available MCP tools, calls find_items behind the scenes, and returns matching items. Confirmation that the connection works.

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