Your Claude Code session knows your project inside out. Your teammate's Claude Code session knows nothing. Every morning, one of you re-explains the architecture, the conventions, the decisions you already made — to an AI that was there for all of it yesterday, just in someone else's session.
This is the setup guide for fixing that. By the end, your entire team's AI sessions — Claude, Cursor, Codex, whatever — will read and write to the same knowledge store. When your teammate commits a decision at 2am, your morning session already knows about it.
We're using Context Cloud, which is the only MCP memory server with shared team workspaces. The whole setup takes about 10 minutes.
Go to contextcloud.pro and sign up. You'll land on the onboarding flow, which walks you through connecting your first AI tool.
When you sign up, Context Cloud automatically creates a "Getting Started" knowledge base with 20 pre-embedded chunks that explain how the system works. Your AI can query this immediately to understand the tools it has access to.
Workspaces are how you scope knowledge. Think of them like repos — one workspace per project or service.
Click "New Workspace" from the home screen. Give it a name that matches your project ("Backend API", "Mobile App", whatever your team calls it). Each workspace gets its own set of knowledge bases, its own team members, and its own access controls.
Inside a workspace, you'll create knowledge bases. A knowledge base is a scoped collection of knowledge — you might have one for "Backend API" and another for "Infrastructure" within the same workspace. The AI handles routing between KBs based on what you're talking about.
Go to the Team tab in your workspace. Add teammates by email. They'll get an invite link via email, click it, create their account, and land directly in the shared workspace.
Roles matter here:
For most dev teams, everyone should be an Editor. The Owner is whoever created the workspace.
Context Cloud works with Claude (web, desktop, and Code), Cursor, Codex, and Windsurf. Here's the setup for each:
The simplest path. Go to Settings → Connectors → Add custom connector. Paste this URL:
https://api.contextcloud.pro/mcp/protocol
Sign in with your Context Cloud account when prompted. That's it — Claude now has access to your shared knowledge.
Add to your MCP config (usually ~/.claude/settings.json
or your project's .mcp.json
):
{
"mcpServers": {
"context-cloud": {
"url": "https://api.contextcloud.pro/mcp/protocol"
}
}
}
Add to your MCP settings:
{
"mcpServers": {
"context-cloud": {
"command": "npx",
"args": ["@contextcloud/mcp-client"],
"env": {
"CNTXT_API_KEY": "your-api-key-here"
}
}
}
}
Get your API key from the workspace Settings tab in the dashboard.
Go to Settings → MCP → Add Streamable HTTP server. Paste the URL:
https://api.contextcloud.pro/mcp/protocol
Authorize when prompted.
This is where it gets real. Open your AI tool and start working normally. When something important comes up — an architecture decision, a convention, a finding — tell your AI to save it.
Here's what that looks like in practice:
You: "We decided to use Postgres over MySQL because the client's DBA only supports Postgres. This is a hard constraint and won't change. Save this as a decision to our Backend API knowledge base."
Context Cloud extracts this as a typed decision
chunk with the rationale, timestamps it, attributes it to you, and stores it in the shared knowledge base. Your AI handles the extraction — you just talk normally and say "save this."
A few more examples of things worth committing:
The key thing to understand: you don't save everything. CLAUDE.md is for static instructions (linting rules, project structure). Context Cloud is for knowledge that emerges from work — decisions, findings, conventions that your team discovers along the way.
This is the moment that matters. Your teammate opens their AI tool — could be a completely different tool on a completely different machine. They ask about the project:
Teammate: "Check my memory — what do we know about the database setup?"
Context Cloud returns your decision with full attribution:
Decision(committed by you, yesterday at 11:34pm)
We decided to use Postgres over MySQL because the client's DBA only supports Postgres. This is a hard constraint and won't change.
Your teammate's AI session never saw your session. They might be using Cursor while you used Claude Code. But the knowledge transferred — with the original reasoning, the attribution, and the semantic type so the AI knows this is a settled decision, not a suggestion.
That's the core loop: commit structured knowledge from any tool, recall it from any tool, across the whole team.
Go to contextcloud.pro and open your workspace. The dashboard gives you visibility into everything your team's AI sessions have committed:
Knowledge Graph: A visual map of your knowledge bases and how chunks relate to each other. Nodes are sized by chunk count, colored by KB type (software, research, business). Click any node to see its contents.
List View: Every chunk in your workspace, filterable by KB, type, author, and date. You can edit, archive, or move chunks between KBs.
History: A timeline of every commit — who committed what, when, from which tool. This is your team's knowledge activity feed.
Documents: Upload files (PDFs, docs, markdown) that get chunked and embedded for recall alongside session-committed knowledge.
The dashboard is for curation, not for daily work. You work in your AI tool. You come to the dashboard when you want to see the big picture, clean up stale knowledge, or browse what your team has been learning.
This comes up a lot, so here's the mental model:
Commit to Context Cloud:
Keep in CLAUDE.md:
Don't commit:
The rule of thumb: if your teammate's AI should know this tomorrow, commit it. If it's only useful for the next five minutes, don't.
As your team's knowledge grows, you'll want multiple KBs within a workspace. Some patterns that work:
By service: "Backend API", "Mobile App", "Infrastructure", "Auth Service". Each maps to a part of your codebase. When someone asks about auth, the AI routes to the Auth Service KB.
By concern: "Architecture Decisions", "Conventions", "Sprint Context". Separates durable knowledge from temporal state.
By team scope: Start with a personal KB in your General workspace for things only relevant to you. When something should be shared, create or move it to a team workspace. Context Cloud supports promoting KBs from personal to team scope.
The AI handles routing between KBs automatically based on what you're talking about. You don't need to specify which KB to query — just ask your question and the retrieval system selects the right KBs using a two-layer approach: first the AI selects relevant KBs from the table of contents, then hybrid search (vector + BM25) finds the best chunks within those KBs.
If your team is using this daily, after a week you should have:
The thing that makes people stick is the first time they open a fresh session and don't have to re-explain their project. Once you feel that, going back to stateless sessions feels broken.
Context Cloud is an MCP memory server with shared team workspaces, typed knowledge chunks, role-based access, and cross-tool support for Claude, Cursor, and Codex. Free to use.
https://api.contextcloud.pro/mcp/protocol