Provides grammar and language checking through a local LanguageTool instance, returning findings with paragraph and offset anchors for generated documents.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Vellum Run full_report on the generated employee_handbook.docx and flag any formatting issues."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that inspects generated documents (
.docx,
Built against the 2026-07-28 MCP specification. See docs/architecture.md
for the full design rationale.
Document-generation skills produce .docx/.pptx/.pdf output, but nothing
automatically verifies the result is well-formed: heading levels can be
skipped, fonts can be inconsistent, spacing can drift, grammar errors pass
through silently. Vellum is a verification layer, not a generator.
Related MCP server: mcp-server-docx
The server extracts facts. The model makes judgments.
Vellum never says "this is wrong." It says "here is what is actually true, and here is what is statistically anomalous relative to the rest of the document." Deciding whether a given value is appropriate for a line's role in the document (title vs. caption vs. body) is semantic judgment that stays with the calling model, which has the document's full context — the server does not, and should not try to.
Tool | Purpose |
| Heading hierarchy, TOC consistency, numbering, captions |
| Per-paragraph resolved font/size/weight/spacing (full style-inheritance chain resolved) + outlier flags |
| Per-character coordinates, baseline spacing, margin/indent consistency, font inventory, substitution detection, intra-line collision flags |
| LanguageTool findings with paragraph/offset anchors |
| Flags filename tokens (company/role/version/date) absent from the document body |
| Runs all applicable checks, returns a |
Every tool returns structured facts plus anomaly flags — never a verdict.
Every tool accepts the document either as a filesystem path or as
inline content_base64 (with filename required alongside it) — useful
when a document only exists in the conversation (e.g. uploaded directly in
a chat interface) rather than saved to disk first. Exactly one of the two
input forms must be given.
All six tools (check_docx_structure, check_docx_typography, check_pdf_layout,
check_language, check_filename_consistency, full_report) are fully
implemented, unit-tested, and validated against a golden set of fixtures with
known planted defects. The full MCP surface — resources, prompts, elicitation,
cache hints, OAuth 2.1 resource-server auth for the HTTP transport, and correct
error semantics — is built and tested (163+ tests passing). See
docs/architecture.md and PROGRESS.md
for the detailed build history and current open items. Packaging/publication
(Phase 7) is in progress — not yet released to PyPI.
git clone https://github.com/Nasser9892/vellum-mcp.git
cd vellum-mcp
pip install -e ".[dev]"Requires a local LanguageTool instance for
check_language — see docs/architecture.md for setup.
Add to your MCP client config (see examples/claude_desktop_config.json):
{
"mcpServers": {
"vellum": {
"command": "vellum-mcp"
}
}
}pip install -e ".[dev]"
pytest # unit + integration tests
mcp dev src/vellum_mcp/server.py # run under MCP InspectorGolden-set fixtures (sample .docx/.pdf files with deliberately planted
defects) live in golden_set/. All checks are validated against these
before being trusted — see docs/architecture.md for the discipline.
Validated against MCP Inspector (mcp dev src/vellum_mcp/server.py) and
tested against two real MCP clients: Claude Desktop
(examples/claude_desktop_config.json) and Cursor (~/.cursor/mcp.json,
same {"mcpServers": {"vellum": {"command": "vellum-mcp"}}} shape).
All primitives: tools, resources, prompts (not tools-only)
Stateless core — no reliance on Mcp-Session-Id
Elicitation via MRTR (InputRequiredResult / inputRequests / inputResponses)
OAuth 2.1 resource-server posture for the HTTP transport (RFC 9728, RFC 8707, RFC 9207; CIMD over deprecated DCR)
Tasks extension (io.modelcontextprotocol/tasks) for long-running analysis
Correct error codes (-32602 for not-found, -32020 for header-bound violations)
No use of deprecated roots/sampling/logging primitives
MIT — see LICENSE.
Extract structural facts from a .docx file: heading hierarchy, TOC consistency, header/footer consistency, page-numbering-field presence, orphaned/empty styles, list-numbering restarts, and image/table caption presence + sequencing. Returns facts and anomaly flags only — never a verdict on correctness (see the server's global instructions).
Accepts the document either as a filesystem path OR as inline
content_base64 (with filename required alongside it) —
useful when the .docx only exists in the conversation (e.g. a
file uploaded directly in chat) rather than saved to disk.
Exactly one of the two input forms must be given.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| lists | Yes | |
| format | Yes | |
| styles | Yes | |
| captions | Yes | |
| headings | Yes | |
| page_numbering | Yes | |
| headers_footers | Yes | |
| heading_hierarchy | Yes | |
| table_of_contents | Yes | |
| table_of_contents_flags | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden and does so well. It states that the tool returns only facts and anomaly flags, never a verdict, and it discloses the input-mode constraint that exactly one of path or content_base64 must be provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place: purpose and scope, output limitation, and input alternatives with the exclusivity constraint. The main purpose is front-loaded, and the structure makes the tool's contract easy to understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists and no annotations are present, the description supplies all essential invocation context: what is analyzed, what is returned, how the document can be supplied, and which input combinations are valid. It is complete enough for an agent to select and call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate — and it does. It explains the meaning and relationship of all three parameters: path as a filesystem location, content_base64 as inline document content, and filename as required when inline content is used. It also communicates the critical exclusivity rule.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Extract structural facts from a .docx file', then enumerates the exact structural dimensions checked. This clearly distinguishes the tool from siblings like check_docx_typography and check_pdf_layout, which target different concerns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes clear context for when the tool is appropriate: structural analysis of .docx files, and explicitly notes that it never renders a correctness verdict. It does not name alternative tools or give explicit when-not-to-use conditions, but the scoping to structural facts and .docx inputs makes the selection context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Per-paragraph resolved font/size/weight (full style-chain resolved, with provenance per property) plus flags for paragraphs whose resolved combination is statistically unique in the document, and for paragraphs whose runs don't all resolve to the same combination. Facts and anomaly flags only — never a verdict on what formatting should be (see the server's global instructions).
Accepts the document either as a filesystem path OR as inline
content_base64 (with filename required alongside it) — for
a .docx that only exists in the conversation rather than saved
to disk. Exactly one of the two input forms must be given.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| flags | Yes | |
| format | Yes | |
| paragraphs | Yes | |
| combo_frequency | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It discloses that the tool performs style-chain resolution with provenance, returns only facts/anomaly flags, never gives formatting verdicts, and validates exactly one input form. It does not discuss error behavior or file-access limitations, but it covers the core behavior well.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two dense paragraphs with no filler. The first sentence immediately communicates the tool's output and resolution behavior, and the second paragraph covers input modes and constraints efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description does not need to enumerate return fields. It covers parameter semantics, input exclusivity, scope, and behavioral boundaries. The only meaningful gap is the lack of explicit sibling-based usage routing, which is partly addressed by the clear 'never a verdict' scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% property descriptions, so the description must compensate. It effectively explains all three parameters: path as filesystem input, content_base64 as conversation-only inline input, and filename as required alongside base64. It also enforces the exclusive-OR constraint that the schema alone does not express.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: it checks per-paragraph resolved font/size/weight in a .docx and emits anomaly flags. It is clearly distinguished from siblings like check_docx_structure and full_report by stating it returns facts and anomaly flags, never a verdict.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear invocation constraints: path OR content_base64, exactly one required, filename required with base64. However, it never explicitly says when an agent should choose this tool over its siblings, and the only comparison to alternatives is implicit through the scope declaration.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tokenizes the filename (stripping extension, separators, common document-type stopwords, and — heuristically — the document owner's own leading First/Last name tokens), then flags any remaining proper-noun-like token that doesn't appear anywhere in the extracted document text. Facts only: presence or absence — never a verdict on whether a mismatch is intentional (brief §3, §4.4).
Accepts the document either as a filesystem path OR as inline
content_base64 (with filename required alongside it — this
is exactly the name that gets tokenized, so pass the file's
real name here, not a placeholder). Exactly one of the two
input forms must be given.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| flags | Yes | |
| format | Yes | |
| checked_tokens | Yes | |
| filename_tokens | Yes | |
| assumed_personal_name_tokens | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden, and it delivers: it discloses heuristic owner-token stripping, stopword removal, facts-only output with no verdict, and the exact meaning of the filename parameter. This is far more transparent than typical tool definitions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-structured: first the algorithm and behavioral contract, then the input contract. Every sentence adds necessary information, and the references to §3 and §4.4 are compact without being filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity, three parameters, and an output schema, the description is complete enough for correct invocation. It explains what is analyzed, how inputs are provided, and what the tool will and will not conclude.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and no parameters are required in the schema, so the description must compensate. It clearly explains that path and content_base64 are mutually exclusive, that filename is mandatory alongside content_base64, and that filename is the actual tokenized name, not a placeholder.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is highly specific: tokenize the filename, strip extension/separators/stopwords/owner-name tokens, then flag proper-noun-like tokens absent from the document text. This clearly differentiates it from sibling tools like check_docx_structure, check_language, or check_pdf_layout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The input-mode rules are explicit: pass either a filesystem path or inline content_base64 with a real filename, and exactly one form must be given. However, it gives no guidance on when to choose this tool versus its siblings, and it names no alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Grammar/spelling/punctuation/style findings via a local
LanguageTool instance, with paragraph/offset anchors so the
model can locate and fix issues precisely. If lang isn't
given and the language can't be auto-detected with confidence,
asks the client which language it is (MRTR elicitation) rather
than guessing. Facts and LanguageTool's own suggestions only —
never a rewritten "corrected" version of the text.
Accepts exactly one of: a filesystem path, raw text, or
inline content_base64 (with filename required alongside it)
for a .docx/.pdf that only exists in the conversation rather
than saved to disk.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | ||
| path | No | ||
| text | No | ||
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| flags | No | |
| format | Yes | |
| findings | Yes | |
| language | Yes | |
| finding_count | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden and succeeds. It discloses the local LanguageTool dependency, the elicitation behavior when lang is uncertain, the strict input exclusivity, and the boundary that it only returns facts and suggestions, never a rewritten corrected version. This gives the agent accurate expectations beyond a bare read/write label.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The core purpose is front-loaded, and every subsequent sentence adds operational value: language auto-detection behavior, output constraints, and input-format requirements. There is no tautology or filler, and the length is appropriate for a 5-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no annotations, and an existing output schema, the description appropriately covers input exclusivity, filename coupling, language elicitation, and output scope while leaving return details to the output schema. Minor omissions such as supported file types for path/text and the meaning of the MRTR acronym keep it from being perfect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is the only source of parameter meaning. It explains all five parameters: lang has fallback/elicitation behavior, path is a filesystem path, text is raw text, content_base64 is inline file content, and filename is required alongside content_base64. Minor gaps remain, such as accepted file types for path/text and lang format conventions, but the compensation is strong overall.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific scope — grammar/spelling/punctuation/style findings — and identifies the mechanism (local LanguageTool) and the anchor-based precision benefit. Sibling tools focus on structure, typography, PDF layout, and filename consistency, so this tool is clearly differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives strong invocation constraints: exactly one of path, text, or content_base64 must be supplied, and filename is required with content_base64. However, it does not explicitly state when to choose this tool over siblings or name alternatives; selection is left to inference from the sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Per-character font/size/coordinates, computed baseline spacing, margin/indent consistency, font inventory, declared-vs-embedded font substitution detection, and intra-line horizontal collision flags (tab-stop-overflow signature). Facts and anomaly flags only — never a verdict on correctness (see the server's global instructions).
Accepts the document either as a filesystem path OR as inline
content_base64 (with filename required alongside it) — for
a .pdf that only exists in the conversation rather than saved
to disk. Exactly one of the two input forms must be given.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| flags | Yes | |
| format | Yes | |
| margins | Yes | |
| line_count | Yes | |
| page_count | Yes | |
| font_inventory | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly states that the tool returns 'facts and anomaly flags only — never a verdict on correctness', which is a key behavioral trait. It also discloses the input-modality constraint (exactly one form). While it doesn't state side effects (e.g., file modification), the tool is clearly read-only by nature, and the description covers the main behavioral nuance an agent needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but not wasteful. It front-loads the tool's analysis features, then clarifies the output nature, then details input requirements. Every sentence contributes value. It's slightly longer than necessary but the information is tightly packed. A score of 4 reflects that it is efficient without being minimal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity and the existence of an output schema (which covers return values), the description provides all necessary context: what the tool analyzes, its non-verdict nature, and the exact input forms. It even includes domain-specific details like 'tab-stop-overflow signature'. Nothing an agent needs to invoke it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description fully compensates by explaining the relationship between parameters: path vs. content_base64, the requirement that filename accompanies content_base64, and the rationale for inline content. This adds meaning far beyond the bare schema, which only lists names. The agent can correctly choose and combine parameters based on this description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb context ('Per-character font/size/coordinates, computed baseline spacing...') and a specific resource (PDF layout analysis), listing concrete features that distinguish it from siblings like check_docx_structure or check_language. It unambiguously states what the tool does and clearly separates it from the other document-analysis tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear input conditions: exactly one of 'path' or 'content_base64' must be provided, and 'filename' is required with inline content. This is explicit usage guidance for the parameters. It does not name alternatives or state when not to use this tool, but the purpose is specific enough that an agent can infer it's for PDF layout checks. Context on when to use inline content (file only in conversation) is provided, which is useful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Runs every applicable check for the document (format auto-
detected from the file extension: .docx or .pdf) and returns an
aggregated report as a report://{file_id} resource URI, plus an
inline summary. profile selects a subset: "full" (default,
every applicable check) or "typography_only" (just the format's
typography/layout check — check_docx_typography for .docx,
check_pdf_layout for .pdf). The full persisted report can be
re-read later via the returned URI without re-running analysis
(brief §5.1/§5.2). Facts and anomaly flags only, aggregated
from each check's own output — never a merged verdict (brief
§3, see the server's global instructions).
Accepts the document either as a filesystem path OR as inline
content_base64 (with filename required alongside it) — for
a file that only exists in the conversation rather than saved
to disk. Exactly one of the two input forms must be given.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | ||
| profile | No | full | |
| filename | No | ||
| content_base64 | No |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| format | Yes | |
| profile | Yes | |
| checks_run | Yes | |
| flag_count | Yes | |
| report_uri | Yes | |
| flags_summary | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden and does so thoroughly. It reveals that results are 'facts and anomaly flags only, aggregated from each check's own output — never a merged verdict,' that the report is persisted and re-readable via the returned URI, and that format detection is based on file extension (.docx or .pdf). This goes well beyond a simple command summary.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than average, but it is dense and front-loaded: the primary purpose and output are stated first, followed by profile selection, then input forms. Every sentence contributes meaningful operational detail. The references to brief §5.1/§5.2 and the server's global instructions add useful pointers, though they make the description slightly less self-contained than it could be.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with four parameters, no annotations, and an output schema already present, the description covers everything an agent needs to call it correctly: input alternatives and constraints, profile semantics, format detection, aggregation behavior, and post-call re-reading via the URI. No critical operational aspect is left unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain every parameter, and it does. It defines `path` as a filesystem path, explains `content_base64` as inline content requiring `filename` alongside it, states the exact cardinality constraint ('Exactly one of the two input forms must be given'), and enumerates both `profile` values with their meanings and defaults. This fully compensates for the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Runs every applicable check') and names the resource ('the document') and the exact output shape ('aggregated report as a report://{file_id} resource URI, plus an inline summary'). It clearly distinguishes itself from the sibling check tools by being the aggregate that runs all applicable checks, not a single check.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use guidance: 'full' profile runs every applicable check, while 'typography_only' selects the format-specific typography/layout check, naming the sibling tools check_docx_typography and check_pdf_layout. It also precisely states the two accepted input forms (path OR content_base64+filename) and the 'exactly one' requirement, leaving no ambiguity about how to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0check_docx_structurecheck_docx_typographycheck_filename_consistencycheck_languagecheck_pdf_layoutfull_reportScored across 6 tools
Each check targets a clearly distinct concern: DOCX structure, DOCX typography, PDF layout, language, filename consistency, and the aggregated report. The only potentially overlapping tool, full_report, is explicitly an aggregator rather than a separate analysis, so an agent can reliably select the right tool.
Five of the six tools follow a consistent check_<target>_<aspect> pattern, making the set highly predictable. The one deviation is full_report, which breaks the check_ prefix but is still descriptive and unlikely to confuse.
Six tools is a well-scoped size for a document-inspection server. Each tool covers a distinct aspect of analysis with no redundant or extraneous additions.
The tool set covers the major inspection needs for DOCX and PDF documents: structure, typography/layout, language, filename consistency, and a full aggregated report. Since the server is explicitly analysis-only and returns facts rather than edits, there are no obvious missing operations within its stated purpose.
Preflight QA for AI-agent deliverables with structured verdicts and repair guidance.
Free mechanical checks for AI text: unnamed counts, dangling references, bad arithmetic, misquotes.
Fact-checks generated content against your sources of truth showing what to trust, change, & verify.
Signed PASS/WARN/FAIL QA receipts for AI-generated JSON, ZIP, PDF, and DOCX deliverables.
