> Falconer site index for agents: https://falconer.com/llms.txt. HTML version of this page: https://falconer.com/guides/falconer-mcp/

# Falconer MCP

> Give Claude Code, Cursor, and any MCP-compatible tool read and write access to your Falconer knowledge base. Search docs, create specs, update runbooks, and save postmortems — all from your coding agent, with every session leaving the knowledge layer better than it found it.

- Date: 2026-05-19
- Tags: ai-agents, documentation, developer-productivity, product

---
Every new session with Claude Code or Cursor starts from zero. The model sees your code. It doesn't know what it means to your team.

Agents write more code than ever, often without the context that makes it correct. You get drift, misaligned implementations, and a slow pile-up of decisions your agents never saw.

Falconer MCP is a Model Context Protocol server that gives Claude web, Claude Code, Codex CLI, Cursor, and other MCP clients read and write access to your Falconer knowledge base.

## What it does

Once connected, the agent gets the same Falconer your team uses in the app, grouped into tools it can call on its own:

| Tool group | What the agent can do |
| --- | --- |
| Search and ask | Hybrid keyword and semantic search with `search`, fetch a doc by ID, title or URL with `read`, and get cited answers from workspace knowledge with `ask_falcon` |
| Write and edit | Create docs from Markdown, make targeted changes with `replace_document_content`, `insert_document_content`, `delete_document_content` and `apply_document_edits`, replace a whole doc with `overwrite`, and archive with `delete` |
| Organize | Browse the navigation, create and move folders and docs, manage Spaces, publish private docs into company navigation, and update sharing |
| Review and history | Read and write comments, list and restore numbered revisions, set reviewers and document status |
| Knowledge Health | List findings, read the evidence, and mark them fixed or dismissed |
| Repositories and docs sites | Bind folders to GitHub repositories with two-way sync, resolve sync conflicts, and build and publish public docs sites |
| Connected tools | Search code, pull requests, issues, Slack threads and meeting notes, file issues in Linear and GitHub, manage Google Calendar events and draft Gmail emails, when those integrations are connected |
| Account | List your organizations and read or change settings |

The agent calls these on its own when it needs them. See the [MCP tools reference](https://falconer.com/docs/mcp-and-cli/tools-reference/) for every tool and its inputs.

## Read and write

Most MCP integrations are read-only, which only gets you halfway.

Read-only means the agent pulls context and generates output, but that output disappears into a chat window. The knowledge base never improves. Docs stay stale. The next query starts from the same degraded baseline.

Falconer's MCP reads and writes. When your agent creates a postmortem, drafts a spec, or updates a runbook, that output lands back in Falconer: versioned, searchable, and available to the next human or agent who needs it. Every workflow run makes the knowledge layer better, not just the output of one session.

A read-only knowledge MCP works like a search engine. Reading and writing turns it into something that compounds: every session leaves the knowledge base in better shape than it found it.

## Use cases

Workflows that aren't possible with a standard coding agent:

**Implement from a spec.** Paste a Falconer doc link into Claude Code. The agent fetches the full spec and starts building, with no copy-pasting and no context gaps.

**Keep runbooks in sync.** Ask Claude Code to update a Falconer doc when a config or service name changes in the codebase. The doc and the code stay aligned.

**Turn a session into a doc.** Ask the agent to summarize what you just built and save it as a Falconer document. Unless you name a folder or Space, it lands in your private section, where you can review it and publish it when ready.

**Ask about the codebase in plain English.** From Cursor or Claude Code, ask "what's our auth pattern?" and get an answer grounded in your actual architecture docs, not the model's training data.

**Create a postmortem mid-incident.** Draft and save a postmortem from the current context. It's saved and shareable before the incident even closes.

## How it compares

|  | Falconer | Notion | Confluence | GitHub |
| --- | --- | --- | --- | --- |
| Hybrid semantic + keyword search | Yes | Partial | No | No |
| Purpose-built for engineering org knowledge | Yes | No | No | No |
| Knowledge Health findings available to agents | Yes | No | No | No |
| Detects doc/code drift and proposes updates | Yes | No | No | No |

Hybrid search means an agent finds the right doc from a fuzzy or natural-language query, not just an exact title match. Notion's MCP runs over workspace search, which gets partway there. Confluence and GitHub match on keywords and titles.

Notion and Confluence expose large, general-purpose data models built to cover every workspace use case. That surface area adds token overhead and structural noise for an agent that only needs to read and write engineering docs. Falconer's tools are built around documents: targeted edits by block, numbered revisions, comments and placement in your navigation.

The row that matters most is the last one. The other three tools index whatever content already exists and leave it alone. Falconer watches for drift between docs and code: it detects when a merged PR affects a document and proposes an update. A search-layer MCP keeps your agent fed. Falconer keeps the knowledge base itself from going stale.

## Setup

Falconer MCP connects through:

```text
https://falconer.com/api/mcp
```

Your MCP client opens Falconer OAuth in your browser. No API key is needed.

**Claude web**

[Add to Claude web](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Falconer&connectorUrl=https%3A%2F%2Ffalconer.com%2Fapi%2Fmcp), then connect the Falconer connector and sign in when Claude asks for authorization.

**Claude Code**

```
claude mcp add --transport http --scope user --client-id falconer-claude-code --callback-port 49152 "falconer" "https://falconer.com/api/mcp"
```

Then run `/mcp` in Claude Code and complete the browser sign-in flow.

**Codex CLI**

```
codex mcp add falconer --url "https://falconer.com/api/mcp" --oauth-client-id falconer-codex-cli --oauth-resource "https://falconer.com/api/mcp"
```

**Cursor app**

[Add to Cursor app](cursor://anysphere.cursor-deeplink/mcp/install?name=Falconer&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vZmFsY29uZXIuY29tL2FwaS9tY3AifQ%3D%3D), then connect the Falconer server and sign in when Cursor asks for authorization.

For manual setup, create or update `.cursor/mcp.json` in your project:

```json
{
  "mcpServers": {
    "Falconer": {
      "type": "http",
      "url": "https://falconer.com/api/mcp"
    }
  }
}
```

**Cursor Agent**

[Open Cursor Agent](https://cursor.com/agents), add a new MCP server named `Falconer`, use `https://falconer.com/api/mcp` as the server URL, then click **Login** to start the Falconer OAuth flow.

For full setup steps, see [Connect MCP](https://falconer.com/docs/mcp-and-cli/connect/).

**Verify.** Ask your client to list your Falconer organizations with `list_organizations`, or search Falconer for a known document.

## FAQ

**Can the agent publish docs to the org knowledge base directly?** Yes, with your permissions. `create` puts a new doc in your private section unless you name a folder or Space, and `publish_document` moves a private doc into company navigation. The agent acts as you, so it can only write where you can, and every change is recorded as a numbered revision you can review or restore.

**What docs can the agent access?** The same docs you can open in Falconer: company docs, Spaces and docs shared with you, and your own private docs. The MCP server signs in as you and never widens your access.

**Does this work with other MCP clients?** Use a client that supports HTTP MCP. If your client is not listed above, configure it with Falconer's MCP endpoint: `https://falconer.com/api/mcp`.

---

## Related documentation

- [Connect MCP](https://falconer.com/docs/mcp-and-cli/connect/)
- [MCP tools reference](https://falconer.com/docs/mcp-and-cli/tools-reference/)
