Docs / Integrations

MCP server

Connect your coding agent to REEZN over the Model Context Protocol.

Setting it up

REEZN exposes an MCP endpoint at /mcp that lets a coding agent pull approved blueprints, norms, and feature status without leaving your terminal or editor. By default every tool is a read-only lookup; organizations on the Business plan can also opt a token into writing to their knowledge base, covered below. The endpoint itself is available on the Team plan and higher.

The endpoint speaks MCP Streamable HTTP: stateless, POST-only, authenticated with a bearer token rather than an interactive login, so any client with HTTP + custom-header support can connect.

An org admin opens Settings → API & MCP and creates a token, optionally scoping it to specific projects and setting an expiry.
The token is shown exactly once, in the form rzn_...your token.... Copy it now and treat it like a password: anyone who has it can act as your organization through the endpoint. If you lose it, revoke it and create a new one.
Configure your coding agent to send it as an Authorization: Bearer header on every request to https://reezn.io/mcp, using whichever of the setups below matches your client.

A token can be revoked at any time from Settings → API & MCP. A revoked or expired token fails every request with a 401, so rotating a leaked token takes effect immediately.

Tokens are read-only by default. Ticking “Allow knowledge graph writes” when creating a token also lets agents add and merge concepts in your knowledge base (Business plan). Treat a token with that box checked with extra care, and scope and expire it tightly.

Claude Code

Claude Code has a built-in remote HTTP transport, so a single command is enough.

claude mcp add --transport http reezn https://reezn.io/mcp --header "Authorization: Bearer rzn_...your token..."

Adding --scope project instead writes the same configuration into a project-local .mcp.json you can commit for your team (with the token substituted per teammate, never committed as a literal value):

.mcp.json

{
  "mcpServers": {
    "reezn": {
      "type": "http",
      "url": "https://reezn.io/mcp",
      "headers": {
        "Authorization": "Bearer rzn_...your token..."
      }
    }
  }
}

OpenAI Codex

Codex CLI supports a remote HTTP server directly in its config file, reading the bearer token from an environment variable rather than storing it inline.

~/.codex/config.toml

[mcp_servers.reezn]
url = "https://reezn.io/mcp"
bearer_token_env_var = "REEZN_MCP_TOKEN"

Export the token in the environment Codex runs in before starting a session, for example export REEZN_MCP_TOKEN="rzn_...your token..." in your shell profile.

Cursor

Add the server to Cursor’s global or project MCP configuration.

~/.cursor/mcp.json

{
  "mcpServers": {
    "reezn": {
      "url": "https://reezn.io/mcp",
      "headers": {
        "Authorization": "Bearer rzn_...your token..."
      }
    }
  }
}

VS Code (GitHub Copilot)

VS Code reads MCP servers from a workspace configuration file, and recommends prompting for a secret like this token via an inputs entry rather than hardcoding it.

.vscode/mcp.json

{
  "servers": {
    "reezn": {
      "type": "http",
      "url": "https://reezn.io/mcp",
      "headers": {
        "Authorization": "Bearer ${input:reezn-token}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "reezn-token",
      "description": "REEZN API token",
      "password": true
    }
  ]
}

VS Code prompts for the token the first time the server starts and stores it securely rather than writing it into the file.

Gemini CLI

Gemini CLI reads MCP servers from its settings file, using httpUrl for a remote Streamable HTTP server.

~/.gemini/settings.json

{
  "mcpServers": {
    "reezn": {
      "httpUrl": "https://reezn.io/mcp",
      "headers": {
        "Authorization": "Bearer rzn_...your token..."
      }
    }
  }
}

Available methods

Every tool is scoped to the projects the token was created for. Six tools are always available:

list_projects(): No arguments. Lists the projects visible to this token.
list_features(projectId?, status?, query?): Lists features, optionally filtered to a project, a lifecycle status, or a text search over the title.
get_feature(featureId): Returns a feature’s definition, current status, services, and version.
get_blueprint(featureId, service?): Returns the implementation hand-off pack for a feature: implementation instructions, the approved REASONS canvas, acceptance criteria, and the strategic analysis. Available only once every canvas on the feature is approved, from the Approved status onward. Pass service to select one service on a multi-service feature.
list_norms(projectId?): Lists the org’s norms, optionally scoped to a project, the same standards injected into generation.
get_feature_status(featureId): Returns just a feature’s current lifecycle status, a lightweight check for polling.

Knowledge base methods

Business-plan organizations also expose their knowledge base over MCP: the org’s curated map of domain concepts, features, and how they relate. A coding agent can query it to ground its work in your established vocabulary, and, with a token scoped for writes, record the new concepts it introduces as it delivers a feature. The knowledge base is organization-wide, so these methods are not narrowed by a token’s project scoping; if that matters for a given integration, use a read-only token.

search_knowledge(query): Searches the knowledge base for concepts relevant to a query, finding related concepts even when they don’t share your search words.
get_knowledge_entity(name): Returns everything the knowledge base holds about a single named concept: its description, alternate names, and what it connects to.
get_knowledge_neighbors(name): Returns the concepts directly connected to a named concept, for exploring outward from something you already know.
find_knowledge_connection(from, to): Returns the strongest chain of connections between two concepts, useful for understanding how a change to one might reach the other.
check_knowledge_novelty(name): Checks whether a concept by that name already exists before you introduce it, so near-duplicates fold into the existing concept instead of forking it. Run this before add_knowledge.

Write access is opt-in per token (see the setup steps above). With a suitably scoped token, two further tools are available:

add_knowledge(entities[], relations[]): Adds concepts and the connections between them to the knowledge base, up to 30 concepts and 40 connections per call. Adding an existing concept enriches it rather than duplicating it, but calling check_knowledge_novelty first is the more reliable way to avoid near-duplicates.
merge_knowledge_entities(from, into): Merges a duplicate concept into the canonical one you point it at; the duplicate’s name is kept as an alternate name so existing references still resolve.

Errors and how to solve them

401 - missing, malformed, invalid, or revoked token: Check that the Authorization header is exactly Authorization: Bearer rzn_..., with no extra quoting or truncation, and that the token hasn’t been revoked. Create a new token in Settings → API & MCP if you’re unsure.
401 - expired token: The token’s optional expiry has passed. Create a new one in Settings → API & MCP; expiry can’t be extended on an existing token.
403 - plan: The organization is on the Free plan. MCP access requires the Team plan or higher; upgrade from Billing.
429 - rate limited: The token exceeded 120 requests per minute. Back off and retry after a short wait; the limit is per token, so a second token doesn’t share the same budget.
405, or the connection fails outright: The endpoint only accepts MCP Streamable HTTP POST requests. Confirm your client is configured with an http (or streamable-http) transport type, not SSE and not stdio, and that it’s pointed at /mcp.
"blueprints unlock once every canvas is approved": get_blueprint was called on a feature that hasn’t reached Approved yet. Finish the outstanding canvas reviews first, or call get_feature_status to check where it stands.
"not accessible with this token": The token is scoped to specific projects and this feature belongs to one outside that scope. Use a token whose scope includes the project, or an unscoped token.
"not found": The id passed to the tool doesn’t match a feature, project, or service the token can see. Double-check the id, and confirm it wasn’t deleted or archived.
"this token can’t write to the knowledge base": add_knowledge or merge_knowledge_entities was called with a token that wasn’t created with “Allow knowledge graph writes” checked. Create a new token with that box checked, or use an existing one that has it.
Knowledge base tools don’t appear at all: Knowledge base methods only appear for organizations on the Business plan. On other plans, only the six always-available tools are listed.