---
source: CrewKit integrations
url: https://crewkit.io/integrations/mcp.md
title: "CrewKit MCP server"
description: "Any MCP-capable agent can search your project memory, read conventions and write work notes back through CrewKit."
---


## What the CrewKit MCP server exposes

`crewkit mcp serve` is a stdio MCP server that turns a project's institutional
memory into tools an agent can call mid-session. Nine tools ship today:

| Tool | What it does |
|------|--------------|
| `search_project_context` | Hybrid lexical and semantic search over project memory: uploaded docs, meeting transcripts, captured Slack messages, Drive imports and indexed past sessions |
| `find_prior_work` | Find past conversations where someone already worked on something similar |
| `get_active_work` | Open conversations and claimed blueprint tasks right now, grouped by user |
| `get_conventions` | The playbook conventions that apply to this project's stack |
| `get_blueprint_state` | The active blueprint: progress, epics, task statuses and the caller's assigned tasks |
| `save_state` | Save a session handoff as your rolling personal save state |
| `load_state` | Load a save state: your personal handoff, or the most recent team digest |
| `share_update` | Broadcast a short, milestone-level update so teammates' sessions avoid overlapping work |
| `add_note` | Write one durable, org-readable note into project memory — a decision and why, or a constraint the team must not rediscover. The agent must get your approval first |

## Before you start

- **The CrewKit CLI**, installed and authenticated with `crewkit auth login`.
  Signed out, tool calls return an actionable error rather than failing quietly.
- **The acceptable-use policy, accepted** by the signed-in user. Until it is,
  tool calls return an actionable error — and the check fails closed, so an
  unreachable policy endpoint refuses the call.
- **A project** that the CLI can resolve, normally from the working directory's
  git remote.
- **An MCP-capable client.** Sessions launched with `crewkit code` register the
  server automatically — there is nothing to configure for those.

## Add the server to your agent

For any other client, register the server by hand:

```json
{
  "mcpServers": {
    "crewkit": {
      "command": "crewkit",
      "args": ["mcp", "serve"]
    }
  }
}
```

When the git remote cannot answer which project this is, name it explicitly:

```bash
crewkit mcp serve --org <org-id> --project <project-id>
```

The `CREWKIT_ORG_ID` and `CREWKIT_PROJECT_ID` environment variables are the
equivalent. The server implements MCP 2026-07-28 — stateless lifecycle,
`server/discover` — and stays compatible with clients speaking 2025-11-25 and
earlier through the standard `initialize` handshake.

## What an agent can read

Project memory is the artifact store: PRDs, meeting transcripts,
Google Drive imports, captured Slack and email, and every analyzed conversation,
all indexed together. `search_project_context` runs over that set
in plain language rather than by keyword, and `find_prior_work` narrows the same
index to the sessions where the work actually happened — the difference between
"there is a document about this" and "here is the conversation that solved it".

`get_conventions` returns the governing rules rather than the documents — a
category, a key, the text and its anti-patterns, from the playbooks your
organization subscribes to and the project is assigned.
`get_active_work` and `get_blueprint_state` cover the present tense: who is in
which conversation, which blueprint tasks are claimed, what the plan says.

See [Artifacts](/docs/artifacts) and [Playbooks](/docs/playbooks).

## What an agent can write

Four tools write back. `save_state` stores a session handoff as your rolling
personal save state — the agent is instructed to show it to you for approval
before saving — and `load_state` reads it back, or reads the most recent team
digest instead. `share_update` broadcasts a short milestone-level update that
teammates' sessions can see, which is how two people avoid starting the same
piece of work in parallel. `add_note` is the durable one: a single approved
note — a decision and its rationale, a constraint — indexed and readable by
everyone in the organization. Those three writers are all left out of the
pre-approved permission allow-list, so each one prompts.

Save states are also reachable from the CLI:

```bash
crewkit save-state ls
crewkit save-state show personal
crewkit save-state show team
crewkit save-state rm <id>
```

## Permissions and scope

Everything the server serves is scoped to one organization and one project,
resolved from the git remote or the explicit `--org` and `--project` overrides.
Authentication is the CLI login, so an agent sees exactly what the signed-in
user's account is entitled to see.

Two gates narrow that further. Slack messages and email captured for a project
are not injectable context on arrival: they wait in the Inbox until a human
approves them. And sessions marked sensitive or
private are excluded from cross-session discovery, so they never surface through
`find_prior_work`. Separately, how much session content is captured at all is an
organization-level setting: full, metadata only, or disabled.

## What this does not do yet

- **Stdio only.** The transport is `crewkit mcp serve` over stdio; there is no
  HTTP or remote-hosted endpoint.
- **Limited writes to project memory.** `add_note` writes a single approved
  note, and only from a session launched by `crewkit code` — a hand-registered
  client gets an error. Uploading a document, importing from Drive or approving
  an Inbox item stay dashboard actions, not tools.
- **Blueprint state is read-only here.** `get_blueprint_state` reports progress
  and task status; claiming or completing a task is
  `crewkit blueprint start` / `crewkit blueprint complete` in the CLI.
- **Project resolution needs a git remote** or an explicit override; outside a
  matching repository, the server cannot guess.

For the sessions where these tools are registered for you, see
[CrewKit for Claude Code](/integrations/claude-code).