ḾÇÞ šéŕṽéŕ

ķàþî éẋþöšéš îţš ƒöŕḿàţ-àŵàŕé çöñţéñţ éñĝîñé àš àñ ḾÇÞ (Ḿöđéļ Çöñţéẋţ Þŕöţöçöļ) šéŕṽéŕ. Àñ àššîšţàñţ çöññéçţéđ ţö îţ çàñ ŕéàđ ţĥé çöñţéñţ îñšîđé à .docx, à ĴŠÖÑ çàţàļöĝ öŕ à Ḿàŕķđöŵñ ƒîļé, àšķ ŵĥàţ ţĥé þŕöĵéçţ'š öŵñ çöñţéẋţ šàýš àƃöüţ à þĥŕàšé, éđîţ ţĥé çöñţéñţ, ṽéŕîƒý îţ àĝàîñšţ ţĥé þŕöĵéçţ'š çĥéçķš, àñđ ŵŕîţé îţ ƃàçķ ƃýţé-ƒöŕ-ƃýţé. Éàçĥ šţéþ îš à šţŕüçţüŕéđ ţööļ çàļļ, šö ţĥé àššîšţàñţ ñéṽéŕ éđîţš ţĥé ƒîļé'š ƃýţéš đîŕéçţļý.

Ƒöŕ ţĥé àĝéñţ-šķîļļš þàţĥ (Çļàüđé Çöđé çàļļîñĝ ţĥé kapi ÇĻÎ), šéé Üšé ţĥé Ķàþî Àĝéñţ Šķîļļš. Ţĥé ţŵö çàñ ƃé üšéđ ţöĝéţĥéŕ.

:::îñƒö Ĝéñéŕàţéđ ƒŕöḿ ţĥé šéŕṽéŕ Ţĥé ţàƃļéš ƃéļöŵ àŕé ĝéñéŕàţéđ ƃý çöññéçţîñĝ ţö à ŕéàļ kapi mcp šéŕṽéŕ àñđ àšķîñĝ îţ ƒöŕ îţš ţööļš àñđ îţš ŕéšöüŕçéš. À ÇÎ đŕîƒţ ĝàţé ƒàîļš ţĥé ƃüîļđ îƒ ţĥéý šţöþ ḿàţçĥîñĝ ţĥé ƃîñàŕý. :::

Ǫüîçķ Šţàŕţ

Šţàŕţ ţĥé ḾÇÞ šéŕṽéŕ:

kapi mcp

Ţĥîš ļàüñçĥéš à ĴŠÖÑ-ŔÞÇ šéŕṽéŕ öñ šţđîö. Ýöü đöñ'ţ ŕüñ îţ ḿàñüàļļý; ýöüŕ ÀÎ ţööļ šţàŕţš îţ àš à šüƃþŕöçéšš. Ŵîţĥ ñö ƒļàĝš îţ šéŕṽéš ţĥé ŵŕîţîñĝ šéţ; --tools ñàḿéš öţĥéŕš.

Šéţüþ

Çļàüđé Đéšķţöþ

Àđđ ţö ýöüŕ Çļàüđé Đéšķţöþ çöñƒîĝ (~/Library/Application Support/Claude/claude_desktop_config.json öñ ḿàçÖŠ, %APPDATA%\Claude\claude_desktop_config.json öñ Ŵîñđöŵš):

{
  "mcpServers": {
    "kapi": {
      "command": "kapi",
      "args": ["mcp"]
    }
  }
}

Ŕéšţàŕţ Çļàüđé Đéšķţöþ. Ķàþî ţööļš ŵîļļ àþþéàŕ îñ ţĥé ţööļ þîçķéŕ.

Çļàüđé Çöđé

Àđđ ţö ýöüŕ þŕöĵéçţ'š .mcp.json ƒîļé (öŕ çŕéàţé îţ àţ ţĥé ŕéþöšîţöŕý ŕööţ):

{
  "mcpServers": {
    "kapi": {
      "command": "kapi",
      "args": ["mcp"]
    }
  }
}

Çļàüđé Çöđé ŵîļļ àüţöḿàţîçàļļý đîšçöṽéŕ àñđ çöññéçţ ţö ţĥé ķàþî ḾÇÞ šéŕṽéŕ.

ṼŠ Çöđé (ĜîţĤüƃ Çöþîļöţ / Çöþîļöţ Çĥàţ)

Àđđ ţö ýöüŕ ṼŠ Çöđé šéţţîñĝš (.vscode/settings.json öŕ üšéŕ šéţţîñĝš):

{
  "mcp": {
    "servers": {
      "kapi": {
        "command": "kapi",
        "args": ["mcp"]
      }
    }
  }
}

Öŕ àđđ ţö .vscode/mcp.json îñ ýöüŕ þŕöĵéçţ:

{
  "servers": {
    "kapi": {
      "command": "kapi",
      "args": ["mcp"]
    }
  }
}

Çüŕšöŕ

Àđđ ţö ýöüŕ Çüŕšöŕ ḾÇÞ çöñƒîĝ (~/.cursor/mcp.json):

{
  "mcpServers": {
    "kapi": {
      "command": "kapi",
      "args": ["mcp"]
    }
  }
}

Ŵîñđšüŕƒ

Àđđ ţö ýöüŕ Ŵîñđšüŕƒ ḾÇÞ çöñƒîĝ (~/.windsurf/mcp.json):

{
  "mcpServers": {
    "kapi": {
      "command": "kapi",
      "args": ["mcp"]
    }
  }
}

:::ţîþ ΃ kapi îš ñöţ îñ ýöüŕ $PATH, üšé ţĥé ƒüļļ þàţĥ ţö ţĥé ƃîñàŕý (é.ĝ. /usr/local/bin/kapi öŕ $HOME/go/bin/kapi). :::

Àṽàîļàƃļé ţööļš

kapi mcp šéŕṽéš ţööļš îñ ñàḿéđ šéţš. Àñ àššîšţàñţ ŕéàđš éṽéŕý ţööļ đéšçŕîþţîöñ îţ îš öƒƒéŕéđ àñđ çĥööšéš àḿöñĝ ţĥéḿ, šö à šéŕṽéŕ öƒƒéŕš ţĥé šéţš îţš ŵöŕķ ñééđš. --tools ţàķéš à çöḿḿà-šéþàŕàţéđ ļîšţ, àñđ à ñàḿé ţĥàţ îš ñöţ à šéţ îš ŕéƒüšéđ ŵîţĥ ţĥé ļîšţ öƒ šéţš:

kapi mcp                               # the writing set
kapi mcp --tools writing,translation   # writing, plus the loop that fills target languages
kapi mcp --tools all                   # every set

ŵŕîţîñĝ îš ţĥé đéƒàüļţ: ţĥé context:// ŕéšöüŕçéš àñđ ţĥéšé 8 ţööļš, ŵĥîçĥ àšķ ŵĥàţ àþþļîéš, ŕéçöŕđ ŵĥàţ ţĥé àššîšţàñţ ñöţîçéš, ŕéàđ àñđ éđîţ à ƒîļé'š ƃļöçķš ŵîţĥ îţš šţŕüçţüŕé ķéþţ, àñđ çĥéçķ ŵĥàţ îţ çĥàñĝéđ.

Ţööļ	Ŵĥàţ îţ đöéš
apply_edits	Apply a kapi.change/v1 change set: the one write verb. Each content operation addresses one edition of one block with at, the ref read_blocks reports, and carries if_match, the rev you read. Several operations may name one block, each with the rev you read. set_content replaces the text (keep the <x id="…"/> placeholders; with if_match "absent" and an edition it creates that translation, which is how a translation's file is written), replace_text changes part of it by find (placeholder text, as read_blocks shows it), by start and end, or by range, set_attribute changes an inline code's attribute such as a link's href (code, name, value), mark wraps text in a new code such as fmt:bold, and remove_edition drops a translation. A plural or select branch is the operation's path. In a JSON, YAML or ARB catalog, insert_block adds a key (doc, name, after or before, and its text per language in editions) and delete_block removes one with its translations (at, and if_match mapping the catalog's own language to the rev you read). describe_format says which operations a format supports. A refused change set writes nothing: an edition that moved since you read it is refused as stale with its current revision and text, an edit that drops, invents or unbalances an inline code or flattens a plural is refused as guard, an edit that introduces a failing term or voice finding is refused as gate_failed with the findings (rewrite the wording they name and resend; only a person can override), and every other operation reports not_applied. Each refusal carries a code and the field at fault: re-read, fix the operation and resend. Status partial means some of it landed: a write interrupted after some documents were written (docs says which), or a store operation refused after the content was written, which carries its error. Re-read the documents before you send more. mode preview computes and checks the change set and returns a diff per document without writing. A source edit lists the translations it made stale under invalidates. Every operation is recorded as yours, the calling agent's, in this server's session. Writing a term, a content-memory pair or a recipe field and deciding a review are a person's: those operations are refused as not_permitted. Record a term rule as a suggestion with context_note, with from and to for wording you changed. Each document's findings say what the commit check found on the edit; run check_file after a native write, or for what the commit check does not run.
check_file	Check a file you changed against the voice and terms in force at its location, in any format kapi reads (Markdown, JSON, Word, XLIFF and more). Run it on every file you changed and fix what it reports before you say the work is done. To check only what a change touched, pass diff, diff_against (a git revision), staged, or diff_range (A..B). Returns a kapi.check/v2 report: findings, and which analyzers covered the content. A pass is not semantic approval.
context_note	Record what you noticed about how this project writes, as soon as you notice it, including what your own text does not use: a product, feature or plan name as written, the spelling variety, or a word chosen over a common alternative. For a name or word, pass `term` with the form the files use and `instead_of` with the form they avoid: the split form of a one-word name, the other spelling, or the other word. kapi adds the spacing, hyphen and case variants. Say anything else, such as the spelling variety, in `text`. Give `path` and `quote` from a file that was there before you started. Leave alone, with no note, a word the files write more than one way, an interface label, and wording taken from your task. When the person changes your wording, pass `from` (what you wrote), `to` (what they wrote) and `path`, and set `suggest` to also suggest the rule it implies. To take back a note of your own recorded wrongly, pass its id in `withdraw`. Every note is a suggestion: checks report it, none fails on it, and it holds only where you saw it until a person decides about it in review.
context_read	Read everything that applies to one file: the voice in full, the words to use and to avoid, the old names that stay correct there, and what has been suggested but not yet established. kapi's section of AGENTS.md and CLAUDE.md states the same rules, so call this for a file no section covers or when you need the full answer. `path` is project-relative, e.g. `docs/guide.md`, or `profile/<name>` for a named profile. Set `comments` before writing a comment in a source file: the answer is then for the file's comments. The same text the context://<path> resource returns.
context_search	Ask what this project says about one word or phrase: what it is called here, whether it is discouraged and what to say instead, and wording the project has already approved. For everything that applies to a file, call context_read instead. An empty answer means nothing is recorded about the word; if the files always write it one way, record that with context_note, and leave it alone, with no note, if they write it more than one way. `attention` says what a person must act on, such as context files nobody has imported.
context_session_summary	Report what this session recorded with context_note, and what the hooks' check runs found in it (the edit hook's run on each edited file, and the Stop hook's ship gates): `checked` runs, the `failing` findings the runs left, the `caught` findings and the `files` the session edited. A finding is caught when a hook run reported it and the next run on the same file no longer found it. The hook records its runs under the assistant host's session id. Without `session`, it summarizes the session with the project's latest check run, or the session that recorded last when none ran a check, and names it in `chosen`. Call it only if you recorded a note, and end your report with what it says, including the command a person reviews the session with.
describe_format	Say what apply_edits can do in a format: whether the format keeps a document's translations in one file or one per file, and for each content operation what it accepts (the content forms of set_content, the code types a writer can create, the attributes set_attribute can change per code type), or null where the format refuses the operation as unsupported. Name a format, or a document to describe the format kapi reads it in. apply_edits' input schema gives each operation's fields; on the command line, kapi apply --schema OP prints one operation's schema.
read_blocks	Read a document's blocks, a page at a time: the read leg of apply_edits. Each block carries ref (doc, block and edition) to copy into an operation's at, rev to send as its if_match, and text with inline codes as <x id="…"/> placeholders, which an edit keeps. codes lists each code by the id its placeholder shows, with its type and attributes; structures lists each plural or select with the path that reaches a branch and the branch's text; editions lists the block's translations with their revision, text and status; ops lists the operations the block accepts. A page holds up to limit blocks: pass next back as cursor for the following page. A cursor from a document that changed since is refused as stale; read it again from the start. Reads the document as apply_edits writes it, through the format and configuration the project binds.

çöñţéñţ ŵöŕķš öñ çöñţéñţ đîŕéçţļý:

Ţööļ	Ŵĥàţ îţ đöéš
check_text	Check a draft snippet with deterministic content rules. Before drafting, read the context://<project-relative-path> resource for the applicable guidance. Supply context_path to check with that destination's voice and terms; without it, project guidance is not resolved. Explicit profile_pack/profile_file are available only without context_path. Returns a kapi.check/v2 Report with findings, analyzer coverage and configuration warnings, which never change pass; pass is not semantic approval. After saving edits, use check_file to verify the actual file.
detect_format	Detect the file format from a file path based on its extension
redact	Replace sensitive spans with protected placeholders before processing
term-check	Terminology Check
voice_check	Score text against a voice profile using deterministic vocabulary rules; returns a 0-100 compliance score and findings
voice_rewrite	Rewrite text to comply with a voice profile by substituting forbidden/competitor terms (deterministic, offline). A rule that names no replacement, and a match on an inflected form of a term, are left in place and listed under skipped with the term, its list, severity and reason; rewrite those by hand and verify with voice_check.

ţŕàñšļàţîöñ ŕüñš ţĥé ļööþ ţĥàţ ƒîļļš ţàŕĝéţ ļàñĝüàĝéš:

Ţööļ	Ŵĥàţ îţ đöéš
stats	Size files before processing them. Reports per-file and total content metrics: blocks (translatable and not), words, characters (with and without spaces, plus the unique-character inventory), segments when available, and a by-role breakdown. Works on any supported format (Word, PowerPoint, JSON, XLIFF, Markdown, HTML, …) and returns the same JSON `kapi stats --json` emits.
translate	Translate content with an LLM or machine-translation provider (select an engine, then a provider)
up	Bring a kapi project up to date against its ship gates: re-extract drifted sources, run the default flow (content memory reuse then AI translate) over every target language, concurrently per language, loop until every gated locale is shippable or waits for review, and run the project's bound checks each pass. In a project connected to a Bowrain server the run happens there (push, converge on the org's keys and shared content memory, pull the results); pass local to run the loop on this machine instead. Never fails on pending target work: blocks waiting for review are reported, not thrown. Returns the structured result (per-locale standing, locales waiting for review, materialized files). Use up_plan first to see the pending work and token estimate.
up_plan	Dry-run the catch-up work for a kapi project: per (collection, locale), the blocks missing a target, exact-content-memory leverage, the remaining AI work, and a rough token estimate. No provider calls, nothing written. The pre-flight for the up tool.

ŕéṽîéŵ îš ţĥé ŕéṽîéŵ ǫüéüé àñđ ţĥé ŕéṽîéŵ þîçţüŕé öƒ öñé ƃļöçķ, ŵîţĥ apply_edits ƒŕöḿ ţĥé ŵŕîţîñĝ šéţ, ŵĥîçĥ ŕéçöŕđš à þŕé-ŕéṽîéŵ:

Ţööļ	Ŵĥàţ îţ đöéš
review_block	Read one block's review picture: ref and rev, the reference and revision of the edition under review, and the block itself, under block: source and target text, ladder status, the last recorded decision (with identity), and the context the decision is made in: the point governing the file (voice guidance, term rules, coordinates), the blocks before and after it as run sequences, the prior approved version and the content-memory match with its wording, the check findings with their run anchors, and the AI pre-review score. Address it with the ref a review_queue row carries, or a ref read_blocks reports with the translation's edition. A block in the project's source language is read from its source file and returns its authoring rung with no target half. To record a pre-review, send apply_edits a decide operation with at set to ref, if_match set to rev, outcome advise, a score from 0 to 100 and your reasons: it is bound to the wording you read, a later edit drops it, and it never approves the block.
review_queue	List the review queue: every block awaiting a person, each with ref, the reference review_block reads it by ({doc, block, edition}: the source document, the block key and the translation's language; no edition for a source block). One queue holds every language, the project's source language among them: a translated block not yet approved is one row, and a source block held below the project's translate_after level is another, marked `isSource`. The result also carries `languages`, the pending count per language. Filter with language, locale and/or collection. Read-only, derived from the content files and the project state store; blocks annotated by an AI pre-review carry their score. Lean by design: call review_block for a block's context (the point governing it, its neighbourhood, its prior version, its findings).

Þŕöĵéçţ šçöþîñĝ àþþļîéš öñ ţöþ. Šţàŕţéđ îñšîđé à ķàþî þŕöĵéçţ (đîšçöṽéŕéđ ƃý à ĝîţ-šţýļé üþŵàŕđ ŵàļķ, éẋàçţļý àš ţĥé ÇĻÎ đîšçöṽéŕš îţ), ţĥé ţööļ šéţ îš ñàŕŕöŵéđ ţö ţĥé šöüŕçéš ţĥé ŕéçîþé đéçļàŕéš àñđ ţĥé þŕöĵéçţ'š ƒîŕšţ ţàŕĝéţ ļàñĝüàĝé ƃéçöḿéš ţĥé đéƒàüļţ ƒöŕ ţĥé ţŕàñšļàţîñĝ ţööļš.

Ţööļš ƒŕöḿ îñšţàļļéđ þļüĝîñš

Àñ îñšţàļļéđ þļüĝîñ àđđš îţš öŵñ ţööļš ţö ţĥîš šüŕƒàçé. kapi mcp šţàŕţš éàçĥ þļüĝîñ'š šéŕṽéŕ öñçé þéŕ šéššîöñ àñđ þàššéš çàļļš ţĥŕöüĝĥ, šö ţĥé ţööļš à þļüĝîñ ƃŕîñĝš àñšŵéŕ öñ ţĥé šàḿé çöññéçţîöñ ţĥàţ šéŕṽéš ţĥé ļööþ ṽéŕƃš. Çöñƒîĝüŕé öñé ḾÇÞ šéŕṽéŕ, ñöţ öñé þéŕ þļüĝîñ.

À þļüĝîñ çöñţŕîƃüţéš ţĥé ţööļš îţš ḿàñîƒéšţ đéçļàŕéš. À þļüĝîñ ţĥàţ îš ñöţ îñšţàļļéđ àđđš ñöţĥîñĝ, öñé ţĥàţ ƒàîļš ţö šţàŕţ îš ļéƒţ öƒƒ ŵîţĥ à ñöţé öñ šţđéŕŕ ŵĥîļé ţĥé ŕéšţ öƒ ţĥé šüŕƒàçé ķééþš ŵöŕķîñĝ, àñđ à þļüĝîñ ţööļ ŵĥöšé ñàḿé ķàþî àļŕéàđý üšéš îš šķîþþéđ šö ţĥé ķàþî ţööļ ķééþš ţĥé ñàḿé.

Ŵîđéñîñĝ ţĥé šüŕƒàçé

Ţŵö ƒļàĝš öñ kapi mcp àđđ ţööļš ñö šéţ ĥöļđš, ƒöŕ đéƃüĝĝîñĝ àñđ ƒöŕ çàļļéŕš ŵĥö ŕéàļļý àŕé àššéḿƃļîñĝ à þîþéļîñé ƃý ĥàñđ:

• kapi mcp --all-tools àđđš éṽéŕý ÇĻÎ-ṽîšîƃļé þŕöçéššîñĝ ţööļ, þļüš ţĥé ļîšţîñĝ ṽéŕƃš: case-transform, create-target, diff-leverage, dnt-check, encoding-detect, entity-extract, inline-codes-remove, list_formats, list_tools, media-refine, placeholder-check, pseudo-translate, pseudo_translate, qa, recycle, remove-target, review, search-replace, segmentation, term-extract, translate-after, unredact, voice-check, voice-infer, whitespace-correct, xml-validation.
• kapi mcp --all-flows àđđš ţĥé ƒļöŵ-ŕüññîñĝ ṽéŕƃš: list_flows, run_flow.
• kapi mcp --all šéŕṽéš éṽéŕý šéţ àñđ àđđš ƃöţĥ.

Ţŵö ţööļš àŕé ŵîţĥĥéļđ ƒŕöḿ éṽéŕý šüŕƒàçé, îñçļüđîñĝ ţĥé ŵîđéñéđ öñéš: external-command àñđ script ŕüñ àŕƃîţŕàŕý çöḿḿàñđš àñđ ĴàṽàŠçŕîþţ, ŵĥîçĥ îš à đéŕéñţ çļàšš öƒ đéçîšîöñ ƒŕöḿ "šĥöŵ ḿé éṽéŕý ţööļ". Ƃöţĥ ŕéḿàîñ àṽàîļàƃļé ţĥŕöüĝĥ kapi exec.

Àṽàîļàƃļé ŕéšöüŕçéš

Ŕéţŕîéṽàļ çöḿéš îñ ţŵö šĥàþéš, à ţööļ àñđ à ŕéšöüŕçé. Àšķîñĝ ŵĥàţ à ŵöŕđ ḿéàñš îš à çàļļ ŵîţĥ àŕĝüḿéñţš, šö îţ îš ţĥé context_search ţööļ. Àšķîñĝ ŵĥàţ àþþļîéš àţ à ļöçàţîöñ îš ŕéàđîñĝ šöḿéţĥîñĝ ţĥàţ àļŕéàđý éẋîšţš àţ àñ àđđŕéšš, šö îţ îš à ŕéšöüŕçé:

Àđđŕéšš	Ŕéñđéŕš àš	Ŵĥàţ îţ àñšŵéŕš
context://profile/{name}{?format,project}	text/markdown	What applies when you write at one place: the voice, the words to use and to avoid, and what has been suggested but not yet established. kapi's section of AGENTS.md and CLAUDE.md states the same rules, so read it for a file no section covers or for the full answer. An answer with nothing recorded says so. Returns markdown; append `?format=json` for the structured answer, which also names the point, the project and the revision that answered. Names a profile instead of a file, e.g. `context://profile/marketing`.
context://{+path}{?format,project,comments}	text/markdown	What applies when you write at one place: the voice, the words to use and to avoid, and what has been suggested but not yet established. kapi's section of AGENTS.md and CLAUDE.md states the same rules, so read it for a file no section covers or for the full answer. An answer with nothing recorded says so. Returns markdown; append `?format=json` for the structured answer, which also names the point, the project and the revision that answered. The path is project-relative, e.g. `context://docs/guide.md`; `?project=<path>` reads another project.

Ţĥé ţŵö àđđŕéššéš àŕé öñé þŕîḿîţîṽé. À þàţĥ àñšŵéŕš ŵĥàţ àþþļîéš ĥéŕé; à þŕöƒîļé ñàḿé àñšŵéŕš ţĥé šàḿé ǫüéšţîöñ ƒöŕ à çàļļéŕ ŵîţĥ ñö ƒîļé îñ ĥàñđ (àñ àđ-ĥöç ŕüñ, öŕ à šţàŕţéŕ þàçķ). Ţĥé ḿàŕķđöŵñ îš ţĥé ƃŕîéƒ à ŵŕîţéŕ ŕéàđš: ţĥé ṽöîçé, öñé ļîšţ öƒ ŵöŕđš ţö üšé àñđ ţö àṽöîđ, àñđ ŵĥàţ ĥàš ƃééñ šüĝĝéšţéđ ƃüţ ñöţ ýéţ éšţàƃļîšĥéđ, àš kapi context <path> þŕîñţš îţ. Ţĥé ĴŠÖÑ àđđš ţĥé þöîñţ ţĥé ļöçàţîöñ ŕéšöļṽéđ ţö, ţĥé ƒüļļ ṽöîçé ĝüîđé, ţĥé ţéŕḿš, ţĥé ĝöṽéŕñàñçé ŵîñđöŵš àñđ ţĥé þŕöṽéñàñçé.

Ţĥé suggestions ļîšţ îš ŕéþöŕţéđ àþàŕţ ƒŕöḿ éṽéŕýţĥîñĝ îñ ƒöŕçé. Éàçĥ éñţŕý çàŕŕîéš îţš šţàţüš, suggested öŕ contested (ŵîţĥ contested_by ñàḿîñĝ ţĥé öţĥéŕ šîđé), ţĥé ŕüļé öŕ ñöţé îţ šţàţéš, ŵĥö šüĝĝéšţéđ îţ, îñ ŵĥîçĥ šéššîöñ àñđ ţĥé éṽîđéñçé ƃéĥîñđ îţ, ŵîţĥ ţĥé öþéŕàţîöñ îđ à þéŕšöñ ķééþš îţ ƃý. À çĥéçķ ŕéþöŕţš éṽéŕý šüĝĝéšţîöñ àñđ ƒàîļš öñ ñöñé öƒ ţĥéḿ.

Ţĥé šéŕṽéŕ öƒƒéŕš ţĥéšé àđđŕéššéš àš ŕéšöüŕçé ţéḿþļàţéš, àñđ ḿàñý çļîéñţš ļîšţ ñö ŕéšöüŕçéš ƒŕöḿ à ţéḿþļàţé, šö àñ àššîšţàñţ ţĥéŕé çàññöţ đîšçöṽéŕ ţĥéḿ öñ îţš öŵñ. context_read ŕéţüŕñš éẋàçţļý ţĥé šàḿé ţéẋţ àš à ţööļ, ţĥé šéŕṽéŕ'š îñšţŕüçţîöñš ñàḿé ţĥé àđđŕéšš, àñđ kapi context <path> þŕîñţš ţĥé šàḿé ţéẋţ ƒöŕ àñ àššîšţàñţ ţĥàţ çàñ ŕüñ à šĥéļļ çöḿḿàñđ.

Ţĥé ŕéñđéŕîñĝ îš à þŕöþéŕţý öƒ ţĥé ŕéàđ. ?format=json ŕéţüŕñš ţĥé šàḿé àñšŵéŕ àš application/json (ţĥé đöçüḿéñţ kapi context <path> --json þŕîñţš) àñđ éṽéŕýţĥîñĝ éļšé ŕéţüŕñš text/markdown. Àñ üñŕéçöĝñîšéđ ƒöŕḿàţ îš ŕéƒüšéđ, šö à þŕöĝŕàḿ ñéṽéŕ ŕéçéîṽéš þŕöšé îţ çàññöţ þàŕšé.

context://docs/guide.md                # markdown, for a model to read
context://docs/guide.md?format=json    # the same answer, for a program
context://profile/marketing            # a named profile, no location needed

Ţĥé ÇĻÎ ĥàļƒ îš kapi context <path>, ŵĥîçĥ çàļļš ţĥé šàḿé ĥöšţ ƒüñçţîöñ àñđ þŕîñţš ţĥé šàḿé ḿàŕķđöŵñ. À çöñƒöŕḿàñçé ţéšţ ĥöļđš ţĥé ţŵö šüŕƒàçéš ţö ţĥé šàḿé àñšŵéŕ.

Éẋàḿþļé çöñṽéŕšàţîöñš

"Ĥöŵ ḿàñý ŵöŕđš ñééđ ţŕàñšļàţîñĝ?"

Ĥöŵ ḿàñý ţŕàñšļàţàƃļé ŵöŕđš àŕé îñ src/locales/en.json?

Ţĥé àššîšţàñţ çàļļš stats ŵîţĥ ţĥé ƒîļé þàţĥ àñđ ŕéţüŕñš à šţŕüçţüŕéđ àñšŵéŕ ŵîţĥ ŵöŕđ, ƃļöçķ, çĥàŕàçţéŕ, àñđ šéĝḿéñţ çöüñţš.

"Ŵĥàţ đö ŵé çàļļ ţĥîš ĥéŕé?"

Κ "šîĝñ-îñ" ţĥé ţéŕḿ ŵé üšé, àñđ ĥöŵ đö ŵé šàý îţ îñ Ƒŕéñçĥ?

Ţĥé àššîšţàñţ çàļļš context_search. Öñé ǫüéšţîöñ ŕéàçĥéš éṽéŕý šţöŕé ţĥé þŕöĵéçţ ƃîñđš (îţš ţéŕḿš, îţš çöñţéñţ ḿéḿöŕý, îţš ṽöîçé þŕöƒîļé) àñđ ţĥé àñšŵéŕ šàýš ŵĥàţ ţĥé þŕöĵéçţ çàļļš ţĥé ţĥîñĝ, ŵĥéţĥéŕ îţ îš đîšçöüŕàĝéđ àñđ ŵĥàţ ţö šàý îñšţéàđ, àñđ àñý ŵöŕđîñĝ àļŕéàđý àþþŕöṽéđ. Àšķîñĝ ƃéƒöŕé ŵŕîţîñĝ îš çĥéàþéŕ ţĥàñ ļéàŕñîñĝ ţĥé šàḿé ƒàçţ ƒŕöḿ à ƒàîļîñĝ çĥéçķ àƒţéŕŵàŕđš.

Éṽéŕý àñšŵéŕ çàŕŕîéš notes, àñđ ţĥé ƒîŕšţ öƒ ţĥéḿ šàýš ŵĥéţĥéŕ ţĥé çöñţéẋţ, ţĥé ţéŕḿš öŕ ţĥé đéçîšîöñš ḿöṽéđ šîñçé ţĥîš šéššîöñ ļàšţ ŕéàđ ţĥéḿ. Ŵĥàţ à þéŕšöñ ḿüšţ àçţ öñ, šüçĥ àš à çĥéçķöüţ ŵĥöšé çöñţéẋţ ñöƃöđý ĥàš îḿþöŕţéđ, îš àļšö îñ attention, àñđ îţ îš ţĥé þàŕţ öƒ ţĥé ñöţéš ţĥé ţéẋţ àñšŵéŕ šĥöŵš. Ţĥé çöḿþàŕîšöñ îš àĝàîñšţ ŵĥàţ ţĥé þŕöĵéçţ ļàšţ öƃšéŕṽéđ öƒ îţš šéŕṽéŕ, ĥéļđ öñ đîšķ, šö îţ çöšţš à šḿàļļ ƒîļé ŕéàđ àñđ ñö ŕöüñđ ţŕîþ, àñđ îţ ŕéþöŕţš ŕàţĥéŕ ţĥàñ ŕéšöļṽéš: àñ àššîšţàñţ ţöļđ ţĥé ţéŕḿš ḿöṽéđ àšķš àĝàîñ ƃéƒöŕé çöñţîñüîñĝ, ƃéçàüšé ţĥé ŵöŕđîñĝ îţ ĥàđ šéţţļéđ öñ ŵàš çĥöšéñ àĝàîñšţ à çöñţéẋţ ţĥàţ ĥàš šîñçé çĥàñĝéđ.

"Šĥöŵ ḿé ţĥé çöñţéñţ öƒ ţĥîš ƒîļé"

Šĥöŵ ḿé ţĥé ţŕàñšļàţàƃļé šţŕîñĝš îñ messages.json

Ţĥé àššîšţàñţ çàļļš read_blocks ŵîţĥ ţĥé đöçüḿéñţ'š þàţĥ àñđ ŕéţüŕñš à þàĝé öƒ ƃļöçķš: éàçĥ ƃļöçķ'š ŕéƒéŕéñçé àñđ ŕéṽîšîöñ, îţš ţéẋţ ŵîţĥ îñļîñé çöđéš àš <x id="…"/> þļàçéĥöļđéŕš, ţĥé çöđéš àñđ ţĥéîŕ àţţŕîƃüţéš, àñđ ţĥé öþéŕàţîöñš ţĥé ƃļöçķ àççéþţš.

"Éđîţ ţĥé çöñţéñţ, ţĥéñ çĥéçķ îţ"

Ţîĝĥţéñ ţĥé îñţŕö þàŕàĝŕàþĥ îñ report.docx, ķééþîñĝ îţ öñ ƃŕàñđ

Ţĥé àššîšţàñţ ŕéàđš ţĥé ƃļöçķš ŵîţĥ read_blocks, ŕéŵŕîţéš ţĥé ţéẋţ îţšéļƒ (ñö šéçöñđ ḿöđéļ), àñđ šéñđš à çĥàñĝé šéţ ţĥŕöüĝĥ apply_edits: öñé replace_text öŕ set_content öþéŕàţîöñ þéŕ ƃļöçķ, àđđŕéššéđ ƃý ţĥé ref ţĥé ŕéàđ ŕéþöŕţéđ àñđ ĝüàŕđéđ ƃý îţš rev. ķàþî ŵŕîţéš îţ ţĥŕöüĝĥ ţĥé ƒöŕḿàţ'š ŵŕîţéŕ, ķééþîñĝ ţĥé đöçüḿéñţ'š šţŕüçţüŕé àñđ îñļîñé çöđéš, ţĥéñ ţĥé àššîšţàñţ çàļļš check_file ţö çöñƒîŕḿ ţĥé ĝàţé þàššéš, ļööþîñĝ üñţîļ îţ đöéš.

"Çàţçĥ ţĥé þŕöĵéçţ üþ"

Ŵĥàţ ţŕàñšļàţîöñ ŵöŕķ îš öüţšţàñđîñĝ, àñđ ĥöŵ ḿüçĥ ŵöüļđ îţ çöšţ?

Ţĥé àššîšţàñţ çàļļš up_plan, à đŕý ŕüñ ŕéþöŕţîñĝ, þéŕ çöļļéçţîöñ àñđ ļöçàļé, ţĥé ƃļöçķš ḿîššîñĝ à ţàŕĝéţ, ţĥé çöñţéñţ-ḿéḿöŕý ļéṽéŕàĝé, ţĥé ŕéḿàîñîñĝ ÀÎ ŵöŕķ àñđ à ŕöüĝĥ ţöķéñ éšţîḿàţé. Ñöţĥîñĝ îš ŵŕîţţéñ àñđ ñö þŕöṽîđéŕ îš çàļļéđ. up ţĥéñ đöéš ţĥé ŵöŕķ: ŕé-éẋţŕàçţ ŵĥàţ đŕîƒţéđ, ŕéüšé ţĥé çöñţéñţ ḿéḿöŕý, ţŕàñšļàţé ţĥé ŕéšţ, ŕüñ ţĥé þŕöĵéçţ'š çĥéçķš, àñđ ļööþ üñţîļ éṽéŕý ĝàţéđ ļöçàļé îš šĥîþþàƃļé öŕ ŵàîţš ƒöŕ ŕéṽîéŵ.

"Ŕéṽîéŵ ţĥîš ţŕàñšļàţîöñ"

Šĥöŵ ḿé ţĥé Ƒŕéñçĥ ƃļöçķš ŵàîţîñĝ ƒöŕ ŕéṽîéŵ, àñđ þŕé-ŕéṽîéŵ ţĥéḿ ƒöŕ ḿé

Ţĥé àššîšţàñţ çàļļš review_queue, ŕéàđš éàçĥ çàñđîđàţé ŵîţĥ review_block üšîñĝ ţĥé ref îţš ŕöŵ çàŕŕîéš (ţĥé ŕéšüļţ ĥöļđš ţĥé ƃļöçķ'š ţéẋţ, šţàţüš àñđ ŕéṽîéŵ çöñţéẋţ üñđéŕ block), àñđ ŕéçöŕđš à þŕé-ŕéṽîéŵ ţĥŕöüĝĥ apply_edits: à decide öþéŕàţîöñ àţ ţĥàţ ref, ŵîţĥ if_match šéţ ţö ţĥé rev review_block ŕéţüŕñéđ, öüţçöḿé advise, à šçöŕé ƒŕöḿ 0 ţö 100 àñđ îţš ŕéàšöñš. Ţĥé þŕé-ŕéṽîéŵ îš ƃöüñđ ţö ţĥé ŵöŕđîñĝ ţĥé àššîšţàñţ ŕéàđ àñđ ŕéçöŕđéđ üñđéŕ ţĥé îđéñţîţý agent/<client>, šö à ļàţéŕ éđîţ đŕöþš îţ. Îţ đéçîđéš ñöţĥîñĝ: ţĥé ƃļöçķ šţàýš îñ ţĥé ǫüéüé üñţîļ à þéŕšöñ àþþŕöṽéš öŕ ŕéĵéçţš îţ, àñđ àñ àššîšţàñţ'š establish îš ŕéƒüšéđ.

review_queue ŕéţüŕñš öñé ǫüéüé àçŕöšš ţĥé þŕöĵéçţ'š ļàñĝüàĝéš. Éàçĥ ŕöŵ çàŕŕîéš language àñđ, ŵĥéñ ţĥàţ ļàñĝüàĝé îš ţĥé þŕöĵéçţ'š šöüŕçé, isSource: true àñđ à status öñ ţĥé àüţĥöŕîñĝ ļàđđéŕ; languages çöüñţš ţĥé þéñđîñĝ ƃļöçķš þéŕ ļàñĝüàĝé, šö àñ àššîšţàñţ çàñ ñàŕŕöŵ ŵîţĥ ţĥé language àŕĝüḿéñţ ţö öñé ţĥàţ ĥàš ŵöŕķ. review_block ŕéàđš à šöüŕçé-ļàñĝüàĝé ƃļöçķ ţĥé šàḿé ŵàý îţ ŕéàđš à ţŕàñšļàţîöñ, ƒŕöḿ ţĥé šöüŕçé ƒîļé, àñđ ŕéţüŕñš îţš þöîñţ àñđ ñéîĝĥƃöüŕĥööđ ŵîţĥ ñö ţàŕĝéţ ĥàļƒ.

Ţööļ ŕéƒéŕéñçé

çöñţéẋţ_ŕéàđ

Ŕéàđ éṽéŕýţĥîñĝ ţĥàţ àþþļîéš ţö öñé ƒîļé: ţĥé ṽöîçé îñ ƒüļļ, ţĥé ŵöŕđš ţö üšé àñđ ţö àṽöîđ, ţĥé öļđ ñàḿéš ţĥàţ šţàý çöŕŕéçţ ţĥéŕé, àñđ ŵĥàţ ĥàš ƃééñ šüĝĝéšţéđ ƃüţ ñöţ ýéţ éšţàƃļîšĥéđ. ķàþî'š šéçţîöñ öƒ AGENTS.md àñđ CLAUDE.md šţàţéš ţĥé šàḿé ŕüļéš, ŵĥîçĥ àñ àššîšţàñţ ļöàđš ŵîţĥöüţ à çàļļ (ŕüļéš ƒîļéš), šö àñ àššîšţàñţ çàļļš ţĥîš ƒöŕ à ƒîļé ñö šéçţîöñ çöṽéŕš, öŕ ŵĥéñ îţ ñééđš ţĥé ƒüļļ àñšŵéŕ. Îţ ŕéţüŕñš éẋàçţļý ţĥé ţéẋţ ţĥé context://<path> ŕéšöüŕçé ŕéţüŕñš, ƒöŕ à çļîéñţ ţĥàţ ļîšţš ñö ŕéšöüŕçéš ƒŕöḿ à ţéḿþļàţé. path îš þŕöĵéçţ-ŕéļàţîṽé, öŕ profile/<name> ƒöŕ à ñàḿéđ þŕöƒîļé; comments àñšŵéŕš ƒöŕ ţĥé çöḿḿéñţš îñ ţĥé ƒîļé îñšţéàđ öƒ îţš çöñţéñţ.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
path	string	ýéš	the project-relative file you are about to write, or profile/<name>
comments	boolean	ñö	answer for the comments in the file rather than its content
format	string	ñö	markdown (default) or json
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)

çöñţéẋţ_šéàŕçĥ

À ŵöŕđ šöḿéƃöđý ĥàš šüĝĝéšţéđ à ŕüļé öŕ à ñöţé àƃöüţ çöḿéš ƃàçķ üñđéŕ suggestions, àþàŕţ ƒŕöḿ ţĥé ţéŕḿš îñ ƒöŕçé.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
query	string	ýéš	the word or phrase to ask about
limit	integer	ñö	max results per group (default 10)
locale	string	ñö	narrow results to one language (e.g. en, fr)
memory	string	ñö	path to a standalone content memory (default: the project's own store)
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
terms	string	ñö	path to a standalone terms store (default: the project's own store)

çöñţéẋţ_ñöţé

Ŕéçöŕđ ŵĥàţ ţĥé ƒîļéš đö éṽéŕý ţîḿé, öŕ ŵĥàţ ţĥé þéŕšöñ çĥàñĝéđ. Üšé text ƒöŕ à ñöţé, öŕ term àñđ instead_of ƒöŕ à šüĝĝéšţéđ ţéŕḿ ŕüļé: ķàþî àđđš ţĥé šþàçîñĝ, ĥýþĥéñ àñđ çàšé ṽàŕîàñţš öƒ à çöḿþöüñđ, šö Quickcast îñšţéàđ öƒ Quick cast àļšö àṽöîđš Quick-cast àñđ QuickCast. Ţĥé ļöŵéŕ-çàšé šþéļļîñĝ îš ñéṽéŕ àđđéđ; ñàḿé îţ îñ instead_of ŵĥéñ ţĥé þŕöĵéçţ àṽöîđš îţ. Ƒöŕ ŵöŕđîñĝ ţĥé þéŕšöñ çĥàñĝéđ, þàšš from, to àñđ path; suggest àļšö ŕéçöŕđš ţĥé ŕüļé ţĥé çĥàñĝé îḿþļîéš. À ţéŕḿ ŕüļé àñđ à çĥàñĝé ñééđ path. Þàšš withdraw ŵîţĥ àñ îđ ţĥîš šéššîöñ ŕéçöŕđéđ ţö ţàķé ţĥàţ ñöţé ƃàçķ; à þéŕšöñ ĥàñđļéš éšţàƃļîšĥéđ ŕüļéš àñđ ñöţéš ƒŕöḿ öţĥéŕ šéššîöñš.

Ţĥé ŕéšüļţ îš à šüĝĝéšţîöñ: éṽéŕý çĥéçķ ŕéþöŕţš îţ, àñđ ñöñé ƒàîļš öñ îţ üñţîļ à þéŕšöñ ķééþš îţ îñ kapi context review. Îţ ĥöļđš öñļý ŵĥéŕé ţĥé àššîšţàñţ šàŵ îţ, ţĥé þàŕţ öƒ ţĥé þŕöĵéçţ path ƃéļöñĝš ţö, üñţîļ à þéŕšöñ àþþļîéš îţ ḿöŕé ŵîđéļý. Îţ îš ţĥé šàḿé ŕéçöŕđîñĝ àš kapi context note öñ ţĥé çöḿḿàñđ ļîñé.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
advisory	boolean	ñö	with suggest: the rule should only report once a person keeps it; unset, a kept rule fails a check
block	string	ñö	the ref.block that read_blocks or kapi inspect reports
from	string	ñö	for a change a person made: the wording that was there
instead_of	array	ñö	forms the project avoids for term, e.g. Quick cast; spacing, hyphen and case variants are added for you
path	string	ñö	the project-relative file you saw it in, or the person changed it in
point	object	ñö	narrows where the note holds, axis to value, within the point the file it was seen in sits at, such as market set to no; it may narrow and never widen
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
quote	string	ñö	the wording you saw, quoted from the file
suggest	boolean	ñö	with from and to: also record the rule the change implies, so the next use of the old wording is reported
term	string	ñö	the form this project uses for a name or word, e.g. Quickcast
text	string	ñö	the fact, in one sentence, in your own words
to	string	ñö	for a change a person made: the wording that replaced it
valid_from	string	ñö	the note holds from this date (2006-01-02) or RFC3339 instant on
valid_to	string	ñö	the note holds until this date (2006-01-02) or RFC3339 instant, not including it
why	string	ñö	what the person said about the change, or what was wrong with the note withdrawn
withdraw	string	ñö	the id of a note this session recorded wrongly, to take it back

çöñţéẋţ_šéššîöñ_šüḿḿàŕý

Àñ àššîšţàñţ çàļļš îţ öñļý àƒţéŕ îţ ŕéçöŕđéđ à ñöţé. Îţ ŕéţüŕñš ŵĥàţ ţĥîš šéššîöñ ŕéçöŕđéđ àñđ ŵĥàţ ƃéçàḿé öƒ îţ, çöüñţéđ àš observed, corrected, suggested, contested, established, withdrawn, dropped àñđ reset, ŵîţĥ ţĥé šéñţéñçé ţö éñđ à ţàšķ ŕéþöŕţ öñ. Ţĥé ŕéþöŕţ éñđš ŵîţĥ ţĥé kapi context review --session <id> çöḿḿàñđ à þéŕšöñ ŕéṽîéŵš ţĥé šéššîöñ'š šüĝĝéšţîöñš ŵîţĥ.

Îţ àļšö ŕéţüŕñš ŵĥàţ ţĥé ĥööķš' çĥéçķ ŕüñš ƒöüñđ îñ ţĥé šéššîöñ: ţĥé éđîţ ĥööķ'š ŕüñ öñ éàçĥ ƒîļé àñ éđîţ ŵŕöţé, àñđ ţĥé Šţöþ ĥööķ'š ŕüñ öƒ ţĥé šĥîþ ĝàţéš:

Ƒîéļđ	Çöüñţš
checked	ţĥé ŕüñš ţĥé ĥööķš ŕéçöŕđéđ
failing	ţĥé ƒàîļîñĝ ƒîñđîñĝš ţĥé ŕüñš ļéƒţ, éàçĥ ƒîļé àš ţĥé ļàţéšţ ŕüñ ţĥàţ çĥéçķéđ îţ ƒöüñđ îţ
caught	ţĥé ƒîñđîñĝš à ŕüñ ŕéþöŕţéđ ţĥàţ ţĥé ñéẋţ ŕüñ öñ ţĥé šàḿé ƒîļé ñö ļöñĝéŕ ƒöüñđ
files	ţĥé ƒîļéš ţĥé šéššîöñ'š ţüŕñš éđîţéđ

Éàçĥ ƒîéļđ îš þŕéšéñţ àţ žéŕö, šö checked: 0 ḿéàñš ñö ŕüñ ŵàš ŕéçöŕđéđ. Éàçĥ ĥööķ ŕéçöŕđš à ŕüñ üñđéŕ ţĥé àššîšţàñţ ĥöšţ'š šéššîöñ îđ, àñđ ţĥé ḾÇÞ šéŕṽéŕ ŕéçöŕđš à ñöţé üñđéŕ îţš öŵñ.

Ŵîţĥöüţ session, ţĥé ţööļ šüḿḿàŕîžéš ţĥé šéššîöñ ŵĥöšé ļàţéšţ çĥéçķ ŕüñ îš ţĥé þŕöĵéçţ'š ḿöšţ ŕéçéñţ, šö à ñöţé ŵŕîţţéñ àƒţéŕ à ĥööķ ŕüñ ļéàṽéš ţĥé ŕüñ'š öüţçöḿéš îñ ṽîéŵ. Ŵĥéñ ñö šéššîöñ ĥöļđš à çĥéçķ ŕüñ, îţ šüḿḿàŕîžéš ţĥé šéššîöñ ţĥàţ ŕéçöŕđéđ ļàšţ. chosen ñàḿéš ţĥé šéššîöñ, ţĥé ŕüļé ţĥàţ àþþļîéđ àñđ ŵĥéñ ţĥé šéššîöñ ļàšţ ŕéçöŕđéđ. Ŵĥéñ ţĥé ļöĝ ĥöļđš ñö šéššîöñ'š öþéŕàţîöñš, ţĥé àñšŵéŕ îš öñé ļîñé îñ report šàýîñĝ ţĥàţ ţĥé éđîţ ĥööķ ŕéçöŕđš öñé éàçĥ ţîḿé îţ çĥéçķš àñ éđîţéđ ƒîļé, àñđ ţĥé Šţöþ ĥööķ éàçĥ ţîḿé îţ ŕüñš ţĥé þŕöĵéçţ'š çĥéçķš. Þàšš session ţö ŕéàđ àñöţĥéŕ šéššîöñ.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
session	string	ñö	the session to summarize (default: the latest session with a check run, named in chosen)

Ķééþîñĝ, đŕöþþîñĝ, ŵîđéñîñĝ, ŕéšéţţîñĝ àñđ šýñçîñĝ àŕé ŕéšéŕṽéđ ƒöŕ þéöþļé, ţĥŕöüĝĥ kapi context review, reset àñđ sync öŕ Ķàþî Đéšķţöþ, àñđ àŕé éẋçļüđéđ ƒŕöḿ ţĥé ḾÇÞ ţööļš. Šéé Ĝŕöŵîñĝ çöñţéẋţ.

ŕéàđ_ƃļöçķš

Ŕéàđ à đöçüḿéñţ'š ƃļöçķš, à þàĝé àţ à ţîḿé. Éàçĥ ƃļöçķ çàŕŕîéš ref, ţĥé ŕéƒéŕéñçé àñ öþéŕàţîöñ ñàḿéš (doc, block àñđ, ƒöŕ à ţŕàñšļàţîöñ, edition), àñđ rev, ţĥé ŕéṽîšîöñ öƒ ţĥé éđîţîöñ ţĥé ŕéàđ šĥöŵéđ, ŵĥîçĥ àñ öþéŕàţîöñ šéñđš àš if_match. text ĥöļđš ţĥé çöñţéñţ ŵîţĥ îñļîñé çöđéš àš <x id="…"/> þļàçéĥöļđéŕš, ŵĥîçĥ àñ éđîţ ķééþš; codes ñàḿéš ŵĥàţ éàçĥ þļàçéĥöļđéŕ šţàñđš ƒöŕ, àñđ structures ļîšţš ţĥé ƃŕàñçĥéš öƒ à þļüŕàļ öŕ à šéļéçţ ŵîţĥ ţĥé path ţĥàţ ŕéàçĥéš éàçĥ. Þàšš next ƃàçķ àš cursor ƒöŕ ţĥé ƒöļļöŵîñĝ þàĝé. Îñšîđé à þŕöĵéçţ, doc îš à þàţĥ ŕéļàţîṽé ţö ţĥé þŕöĵéçţ'š ŕööţ, àñđ ţĥé ƒîļé öƒ à ţŕàñšļàţîöñ ŕéàđš ţĥàţ éđîţîöñ öƒ îţš šöüŕçé. Ţĥé ƒöŕḿàţ îš ţĥé öñé ţĥé þŕöĵéçţ'š ŕéçîþé ƃîñđš ţö ţĥé ƒîļé, öŕ ţĥé öñé ķàþî đéţéçţš, àñđ apply_edits ŵŕîţéš ţĥé ƒîļé îñ ţĥé šàḿé ƒöŕḿàţ. À šöüŕçé çöđé ƒîļé ŵĥöšé çöḿḿéñţš ķàþî çĥéçķš îš ŕéƒüšéđ àš unsupported ŵîţĥ ţĥé çàþàƃîļîţý comment: éđîţ à çöḿḿéñţ îñ ţĥé ƒîļé îţšéļƒ, ţĥéñ ŕüñ check_file öñ îţ.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
doc	string	ýéš	the document: a path inside the project, relative to its root or absolute, or outside a project a path under the server's working directory; container!entry names an archive member; the file of a translation reads that edition of its source
blocks	array	ñö	only these blocks, by the block key a read reports; empty reads every block
cursor	string	ñö	continue a read: the next value of the page before
editions	array	ñö	translations kept in files of their own to show beside each block, such as fr or de; the editions the document holds itself are always shown
limit	integer	ñö	the most blocks a page holds (default 100, at most 1000)
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)

àþþļý_éđîţš

Ţĥé ŵŕîţé ṽéŕƃ. apply_edits ţàķéš à kapi.change/v1 çĥàñĝé šéţ, ţĥé çöñţŕàçţ éṽéŕý ķàþî šüŕƒàçé šéñđš (É-09), þļüš ţĥé þéŕ-çàļļ project.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
ops	array	ýéš	the operations, applied in order; a position names the content as read, and an empty list changes nothing. Several operations may name one block, each sending the rev you read, since every if_match is checked against the content the change set began with
evidence	array	ñö	where the wording behind the change was seen
gate	string	ñö	enforce (the default): a failing finding the change introduces refuses it; report: the change lands with its findings
mode	string	ñö	apply (the default), or preview: compute and check, write nothing
note	string	ñö	one line a person reads in history and review
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
require_basis	boolean	ñö	refuse a derived-edition write whose authoritative edition moved since it was read
schema	string	ñö

Öþéŕàţîöñ	Ŵĥàţ îţ çĥàñĝéš
set_content	àñ éđîţîöñ'š ŵĥöļé ţéẋţ, ķééþîñĝ îţš þļàçéĥöļđéŕš; ŵîţĥ if_match: "absent" àñđ àñ edition, îţ çŕéàţéš ţĥàţ ţŕàñšļàţîöñ, àđđîñĝ îţš ķéý ţö à ĴŠÖÑ, ÝÀḾĻ öŕ ÀŔƂ ţŕàñšļàţîöñ ƒîļé ţĥàţ ļàçķš îţ
replace_text	þàŕţ öƒ ţĥé ţéẋţ, ñàḿéđ ƃý find (ţĥé ţéẋţ àš à ŕéàđ šĥöŵš îţ, à <x id="…"/> þļàçéĥöļđéŕ ñàḿîñĝ à çöđé), ƃý start àñđ end, öŕ ƃý range; à path ñàḿéš ţĥé þļüŕàļ ƒöŕḿ öŕ šéļéçţ çàšé îţ îš îñ
remove_edition	đŕöþš à ţŕàñšļàţîöñ: ƒŕöḿ à ƃîļîñĝüàļ ƒîļé šüçĥ àš ÞÖ, öŕ ŵîţĥ îţš ķéý ƒŕöḿ à ĴŠÖÑ, ÝÀḾĻ öŕ ÀŔƂ ţŕàñšļàţîöñ ƒîļé
insert_block	àđđš à ķéý ţö à ĴŠÖÑ, ÝÀḾĻ öŕ ÀŔƂ çàţàļöĝ, ŵîţĥ îţš ţéẋţ îñ éàçĥ ļàñĝüàĝé
delete_block	ŕéḿöṽéš à ķéý ƒŕöḿ šüçĥ à çàţàļöĝ àñđ ƒŕöḿ éàçĥ ţŕàñšļàţîöñ'š ƒîļé
decide	à þŕé-ŕéṽîéŵ: öüţçöḿé advise, ŵîţĥ à šçöŕé àñđ ŕéàšöñš

describe_format ļîšţš ŵĥàţ éàçĥ ƒöŕḿàţ šüþþöŕţš; àñ öþéŕàţîöñ ţĥé ƒöŕḿàţ ŕéƒüšéš îš ŕéƒüšéđ àš unsupported àñđ ŵŕîţéš ñöţĥîñĝ.

{
  "note": "Name the handbook",
  "ops": [
    {
      "op": "replace_text",
      "at": { "doc": "docs/guide.html", "block": "p" },
      "if_match": "r:3f9a1c0e7b2d4a55",
      "edits": [{ "find": "shop guide", "text": "handbook" }]
    }
  ]
}

À ŕéƒüšéđ çĥàñĝé šéţ ŵŕîţéš ñöţĥîñĝ. Àñ éđîţîöñ ţĥàţ çĥàñĝéđ šîñçé îţ ŵàš ŕéàđ îš ŕéƒüšéđ àš stale, àñđ ţĥé ŕéƒüšàļ çàŕŕîéš îţš çüŕŕéñţ ŕéṽîšîöñ àñđ ţéẋţ, šö ţĥé àššîšţàñţ çàñ ŕéƃàšé ŵîţĥöüţ àñöţĥéŕ ŕéàđ. Àñ éđîţ ţĥàţ đŕöþš, îñṽéñţš öŕ üñƃàļàñçéš àñ îñļîñé çöđé, öŕ ƒļàţţéñš à þļüŕàļ öŕ šéļéçţ, îš ŕéƒüšéđ àš guard. À ŕéƒéŕéñçé ţĥàţ ñàḿéš ñö ƃļöçķ îš not_found, àñđ šö îš à find ţĥàţ ḿàţçĥéš ñöţĥîñĝ, ŵîţĥ ţĥé ţéẋţ îţ šéàŕçĥéđ. À ƃļöçķ ţĥé ƒöŕḿàţ ŕéàđš àš ñöţ ţŕàñšļàţàƃļé, šüçĥ àš à çöđé ƃļöçķ, îš unsupported. Éàçĥ đöçüḿéñţ îñ docs çàŕŕîéš ţĥé ƒîñđîñĝš ţĥé éđîţ îñţŕöđüçéđ, ƒàîļîñĝ öŕ ñöţ, àñ éḿþţý ļîšţ ŵĥéñ ţĥé çĥéçķ ƒöüñđ ñöţĥîñĝ; à ƒàîļîñĝ öñé ŕéƒüšéš ţĥé çĥàñĝé àš gate_failed, àñđ ţĥé ƒîñđîñĝ ñàḿéš ţĥé ŵöŕđîñĝ à ţéŕḿ ŕüļé àšķš ƒöŕ. Éṽéŕý öţĥéŕ öþéŕàţîöñ öƒ à ŕéƒüšéđ çĥàñĝé šéţ ŕéþöŕţš not_applied, àñđ ţĥé ŕéšüļţ îš àñ éŕŕöŕ. Ţĥé šţàţüš partial îš àñ éŕŕöŕ ţöö: šöḿé öƒ ţĥé çĥàñĝé šéţ ļàñđéđ. Éîţĥéŕ à ŵŕîţé šţöþþéđ àƒţéŕ šöḿé ƒîļéš ŵéŕé ŵŕîţţéñ, àñđ docs ñàḿéš ţĥéḿ, öŕ ţĥé çöñţéñţ ŵàš ŵŕîţţéñ àñđ à đéçîšîöñ ŕéçöŕđéđ àƒţéŕ îţ ŵàš ŕéƒüšéđ, àñđ ţĥàţ öþéŕàţîöñ çàŕŕîéš ţĥé éŕŕöŕ. Ţĥé àššîšţàñţ ŕéàđš ţĥé đöçüḿéñţš àĝàîñ ƃéƒöŕé îţ šéñđš ḿöŕé. mode: "preview" çöḿþüţéš ţĥé ŕéšüļţ àñđ à đ þéŕ đöçüḿéñţ àñđ ŵŕîţéš ñöţĥîñĝ. À šöüŕçé éđîţ ļîšţš ţĥé ţŕàñšļàţîöñš îţ ḿàđé šţàļé üñđéŕ invalidates.

apply_edits šéñđš éṽéŕý çĥàñĝé šéţ àš ţĥé çàļļîñĝ àĝéñţ îñ ţĥé šéŕṽéŕ'š šéššîöñ; à çĥàñĝé šéţ ĥàš ñö ƒîéļđ ţĥàţ ñàḿéš îţš šéñđéŕ. Ŵŕîţîñĝ à ţéŕḿ, à çöñţéñţ-ḿéḿöŕý þàîŕ öŕ à ƒîéļđ öƒ kapi.yaml îš à þéŕšöñ'š đéçîšîöñ, šö à çĥàñĝé šéţ ĥöļđîñĝ à term, memory öŕ recipe öþéŕàţîöñ, àñ if_match öƒ * öŕ gate: "report" îš ŕéƒüšéđ àš not_permitted àñđ ŵŕîţéš ñöţĥîñĝ. Ţĥé àššîšţàñţ ŕéçöŕđš à ţéŕḿ ŕüļé àš à šüĝĝéšţîöñ ŵîţĥ context_note, ŵîţĥ from àñđ to ƒöŕ ŵöŕđîñĝ îţ çĥàñĝéđ, àñđ à þéŕšöñ ķééþš îţ. À ŕéṽîéŵ đéçîšîöñ îš à þéŕšöñ'š ţöö: àñ àššîšţàñţ'š decide ţàķéš öñļý ţĥé öüţçöḿé advise, ŵîţĥ ţĥé šçöŕé îţ ĝîṽéš. À þéŕšöñ šéñđš ţĥé šàḿé öþéŕàţîöñš ŵîţĥ kapi apply îñ à ţéŕḿîñàļ.

đéšçŕîƃé_ƒöŕḿàţ

Ŵĥàţ apply_edits çàñ đö îñ à ƒöŕḿàţ: ŵĥéţĥéŕ ţĥé ƒöŕḿàţ ķééþš à đöçüḿéñţ'š ţŕàñšļàţîöñš îñ öñé ƒîļé (in-file) öŕ öñé þéŕ ƒîļé (one-per-file), àñđ ƒöŕ éàçĥ öþéŕàţîöñ ŵĥàţ îţ àççéþţš, öŕ null ŵĥéŕé ţĥé ƒöŕḿàţ ŕéƒüšéš îţ.

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
doc	string	ñö	a document, to describe the format kapi reads it in; give this or format
format	string	ñö	a format name, such as html, markdown or po
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)

çĥéçķ_ƒîļé

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
diff	string	ñö	unified diff text (git diff output); only the content blocks it touches are checked
diff_against	string	ñö	git revision to diff the working tree against, read-only, with untracked files as added; only the content blocks changed are checked
diff_range	string	ñö	two commits as A..B, or A...B for the change B made since its merge base with A; each file is read from B and nothing from the working tree; only the content blocks changed are checked
dnt	array	ñö	do-not-translate terms that must survive verbatim into the target
file	string	ñö	path to the file whose content should be checked; with diff, diff_against, staged or diff_range it narrows the scope to this file, and may be omitted
forbid	array	ñö	regex that must NOT appear in the content
max_chars	integer	ñö	flag content longer than this many characters (0 = off)
max_words	integer	ñö	flag content with more than this many words (0 = off)
profile_file	string	ñö	explicit voice override loaded from YAML; bypasses the file-scoped project voice and channel; omit to use project guidance
profile_pack	string	ñö	explicit voice override; omitting profile_pack and profile_file preserves the file-scoped project voice and channel
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
require	array	ñö	regex that MUST appear in the content
staged	boolean	ñö	check the changes staged for commit: the index diffed against HEAD, with each file read from the index, leaving out unstaged edits and untracked files; only the content blocks changed are checked
target	string	ñö	translated target file to check against the source (enables the bilingual source-against-target checks)
target_lang	string	ñö	locale of the target file (e.g. de)
validate	string	ñö	reader structure/encoding validation: off|report|strict (report folds structure.*/encoding.* findings into the report; strict also fails on a Major+ structure/encoding problem). Default off.

çĥéçķ_ţéẋţ

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
text	string	ýéš	the text to verify
context_path	string	ñö	project-relative destination whose voice and terms govern this draft; may not exist yet; requires a project; cannot combine with profile_pack or profile_file
forbid	array	ñö	regex that must NOT appear in the content
max_chars	integer	ñö	flag content longer than this many characters (0 = off)
max_words	integer	ñö	flag content with more than this many words (0 = off)
profile_file	string	ñö	path to a voice profile YAML
profile_pack	string	ñö	built-in profile pack to check vocabulary against (e.g. marketing-blog)
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)
require	array	ñö	regex that MUST appear in the content

šţàţš

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
files	array	ýéš	paths of the files to summarize
format	string	ñö	input format override applied to every file (default: auto-detect by extension/content)

üþ_þļàñ

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
no_checks	boolean	ñö	plan the run up makes with no_checks: a language that only fails the project's bound checks gets no pass, so the plan prices none for it
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)

üþ

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
jobs	integer	ñö	how many languages to catch up concurrently per pass (0 = project default, else 4)
local	boolean	ñö	in a server-connected project, run the loop on this machine and push the results, instead of running it on the server
materialize	boolean	ñö	after the loop, write the target-language files for every shippable locale (overrides the recipe's materialize policy)
no_checks	boolean	ñö	skip the project's bound checks inside the loop (failing blocks then count as translated)
passes	integer	ñö	maximum reconciliation passes (0 = loop until up to date or waiting for review; 1 = single pass)
project	string	ñö	the project this call acts on: its kapi.yaml recipe, its root directory, or any path inside it (default: the project the MCP server started in)

đéţéçţ_ƒöŕḿàţ

Þàŕàḿéţéŕ	Ţýþé	Ŕéǫüîŕéđ	Đéšçŕîþţîöñ
path	string	ýéš	File path to detect format from

Ĥöŵ îţ ŵöŕķš

Ķàþî ḾÇÞ üšéš ţĥé šàḿé ḿàçĥîñéŕý àš ţĥé ÇĻÎ çöḿḿàñđš: ţĥé ƒöŕḿàţ ŕéĝîšţŕý ƒöŕ đéţéçţîöñ, ţĥé éẋéçüţöŕ ƒöŕ ƒļöŵ öŕçĥéšţŕàţîöñ, àñđ ţĥé šàḿé ƃüîļţ-îñ ţööļš. Ţĥé ḾÇÞ šéŕṽéŕ éẋþöšéš ţĥéḿ àš ţýþéđ, đîšçöṽéŕàƃļé ţööļš öṽéŕ ţĥé Ḿöđéļ Çöñţéẋţ Þŕöţöçöļ šţđîö ţŕàñšþöŕţ.

Ñö šéŕṽéŕ þŕöçéšš, þöŕţš, öŕ àüţĥéñţîçàţîöñ ñééđéđ. Ýöüŕ ÀÎ ţööļ ļàüñçĥéš kapi mcp àš à çĥîļđ þŕöçéšš, çöḿḿüñîçàţéš öṽéŕ šţđîñ/šţđöüţ, àñđ šĥüţš îţ đöŵñ ŵĥéñ ţĥé šéššîöñ éñđš.

:::ñöţé Ḿöšţ ţööļš ĥéŕé àŕé ŕüļé-ƃàšéđ àñđ ñééđ ñö ÀÞÎ ķéý: context_search, check_text, check_file, voice_check, voice_rewrite, stats, read_blocks, apply_edits, describe_format, ţĥé çöñţéẋţ ŵŕîţé ţööļš àñđ ţĥé ŕéṽîéŵ ţööļš àļļ ŕüñ öƒƒļîñé. Ţĥé öñéš ţĥàţ ŕéàçĥ à ļàñĝüàĝé ḿöđéļ (translate, àñđ up ŵĥéñ ţĥéŕé îš ŵöŕķ ţĥé çöñţéñţ ḿéḿöŕý çàññöţ çöṽéŕ) ñééđ à þŕöṽîđéŕ çŕéđéñţîàļ, ŵĥîçĥ ţĥéý ŕéàđ ƒŕöḿ ţĥé šàḿé çŕéđéñţîàļ šţöŕé ţĥé ÇĻÎ üšéš (kapi credentials add). :::

Ŕéļàţéđ

• Üšé ţĥé Ķàþî Àĝéñţ Šķîļļš: ţĥé àĝéñţ-šķîļļš þàţĥ.
• Ķàþî ÇĻÎ ĝüîđéš
• Çöñţéẋţ ŕéţŕîéṽàļ: ŵĥý öñé ǫüéšţîöñ ŕéàçĥéš éṽéŕý šţöŕé.
• Çöḿḿàñđ ŕéƒéŕéñçé