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 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.
Step 2: Create a workspace for your project
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.
Step 3: Invite your teammates
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:
Owner: full access, can invite/remove members, delete workspace
Editor: can read and write knowledge, manage KBs
Viewer: can read knowledge but not commit new chunks
For most dev teams, everyone should be an Editor. The Owner is whoever created the workspace.
Step 4: Connect your AI tool
Context Cloud works with Claude (web, desktop, and Code), Cursor, Codex, and Windsurf. Here's the setup for each:
Claude (web & desktop)
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.
Claude Code (CLI)
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"
}
}
}
Cursor / VS Code / Windsurf
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.
Codex
Go to Settings → MCP → Add Streamable HTTP server. Paste the URL:
https://api.contextcloud.pro/mcp/protocol
Authorize when prompted.
Step 5: Commit your first knowledge
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:
Decision: "We're using JWT in httpOnly cookies for auth — security team requirement, non-negotiable."
Convention: "All API routes use camelCase. Database columns use snake_case. No exceptions."
Finding: "The Stripe webhook fires twice on subscription changes — always check the idempotency key before processing."
State: "Auth module refactor is 70% done. Token validation extracted, middleware updated, tests pending."
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.
Step 6: Recall from your teammate's session
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.
Step 7: Browse the dashboard
Go to
SOCIAL SHARE CARD GENERATOR