Go-Docs MCP is a server providing 13 tools to read, search, analyze, and convert multi-format documents (PDF, TXT, MD, CSV, DOCX, and images) from a configured directory or URLs, with OCR support and smart caching.
Discover documents: List all documents with metadata (format, page count, size) and check supported formats with dependency installation status.
Read documents: Extract full text, specific pages, or page ranges from any supported format (read_document), or download and extract from a remote URL up to 50MB (read_url).
Summarize: Get a quick overview from the first 3 pages or ~100 lines of any document.
Search: Case-insensitive full-text search within a document, returning matches with surrounding context and approximate page numbers.
Analyze & Extract:
Retrieve metadata (title, author, creation/modification dates, page count, file size, PDF version)
Extract the table of contents / document outline (headings, bookmarks, numbered sections)
Extract tables as structured data, detecting various column delimiters
Extract embedded images as base64-encoded data (up to 10 per call)
OCR: Force OCR on scanned/image-based PDFs (requires tesseract + pdftoppm), or extract text from standalone image files (PNG, JPG, TIFF, BMP) with multi-language support.
Convert: Transform any supported document into clean Markdown format.
Install and Go. One command, single binary. Your AI reads any document — PDF, text, Markdown, DOCX, images.
MCP server for multi-format document access — read, search, extract images, OCR, and fetch documents from URLs via the Model Context Protocol. 13 tools, 6 formats, zero configuration.
go install github.com/drolosoft/go-docs-mcp@latest
# That's it. Single binary, starts in milliseconds.For a deeper look at why an MCP server beats a direct tool, see Why MCP?
Every other document MCP server handles one format — a PDF server for PDFs, a DOCX server for DOCX. You'd need three separate servers to read three formats.
Go-Docs MCP | Others | |
Single binary, no runtime | Yes | Need Node/Python |
| Yes | npm+deps or pip+venv |
Multi-format (6 types) | Yes | One format each |
Full-text search | Yes | Partial or none |
OCR (scanned PDFs + images) | Yes | Rare |
Image & table extraction | Yes | Partial |
Document outline | Yes | Rare |
Fetch from URL | Yes | Rare |
Dir-locked, read-only | Yes | Varies |
Smart caching | Yes | No |
Fully offline | Yes | Yes |
Go-Docs MCP reads them all from a single binary — fast, secure, and dependency-free at runtime.
Related MCP server: immich-photo-manager
Category | Tool | Description |
Discovery |
| List all documents with metadata (format, pages, size) |
Discovery |
| List supported formats and dependency status |
Reading |
| Full text, specific page, or page ranges from any format |
Reading |
| Download from URL and extract text (50MB max) |
Reading |
| First 3 pages as a quick overview |
Search |
| Case-insensitive full-text search with context |
Analysis |
| Title, author, dates, version, page count |
Analysis |
| Table of contents / bookmarks |
Analysis |
| Tables as structured data |
Analysis |
| Images as base64 (max 10 per call) |
OCR |
| Force OCR on scanned/image-based PDFs |
OCR |
| Extract text from PNG, JPG, TIFF via OCR |
Export |
| Convert any document to clean Markdown |
Highlights:
Fast — mtime-based in-memory caching avoids redundant extraction
Multi-format — PDF, TXT, MD, CSV, DOCX, and images from one server
OCR — automatic fallback to tesseract for scanned documents
Secure — directory-locked with path traversal prevention
Portable — works on macOS and Linux
Format | Dependencies | Notes |
poppler ( | Full support — text, images, metadata, OCR fallback | |
TXT, MD, CSV | None | Native, zero dependencies |
DOCX | pandoc (optional) | Word document extraction |
Images (PNG, JPG, TIFF) | tesseract (optional) | OCR text extraction |
Go 1.25+ (install)
poppler — required for PDF support
tesseract (optional) — enables OCR for scanned docs and images
pandoc (optional) — enables DOCX support
# macOS
brew install poppler
brew install tesseract # optional: OCR
brew install pandoc # optional: DOCX
# Debian/Ubuntu
apt install poppler-utils
apt install tesseract-ocr # optional: OCR
apt install pandoc # optional: DOCX
# Fedora/RHEL
dnf install poppler-utils
dnf install tesseract # optional: OCR
dnf install pandoc # optional: DOCXNote: TXT, MD, and CSV work out of the box with zero dependencies. Install only what you need.
go install github.com/drolosoft/go-docs-mcp@latestgit clone https://github.com/drolosoft/go-docs-mcp.git
cd go-docs-mcp
make build # produces ./go-docs-mcp
make install # installs to /usr/local/bin/Go-Docs MCP reads documents from a configured directory. Set DOCS_MCP_DIR to change it:
Variable | Default | Description |
|
| Directory containing documents to serve |
| (legacy alias) | Backward-compatible alias for |
Place your documents in the directory and the server finds them automatically. All supported formats are detected.
Add to your .claude/settings.json:
{
"mcpServers": {
"docs": {
"command": "go-docs-mcp",
"env": {
"DOCS_MCP_DIR": "/path/to/your/documents"
}
}
}
}Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"docs": {
"command": "/usr/local/bin/go-docs-mcp",
"env": {
"DOCS_MCP_DIR": "/path/to/your/documents"
}
}
}
}The server communicates over stdio using JSON-RPC 2.0:
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | go-docs-mcplist_documentsLists all documents in the configured directory with format detection.
Parameters: None
Example output:
[
{
"filename": "architecture-guide.pdf",
"format": "pdf",
"title": "architecture-guide",
"pages": 42,
"size_bytes": 1048576
},
{
"filename": "notes.md",
"format": "markdown",
"title": "notes",
"size_bytes": 4096
}
]list_formatsLists all supported document formats and their dependency status.
Parameters: None
read_documentReads the extracted text content of a document. Automatically falls back to OCR if the document is image-based/scanned and pdftotext returns empty text.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to read |
| number | No | Single page number (1-based). Omit for full text. |
| string | No | Page ranges, e.g. "1-5", "10", "1-3,7,10-12". Overrides |
Example input:
{
"filename": "architecture-guide.pdf",
"pages": "1-3,10-12"
}search_documentSearches within a document for lines matching a query. Returns matches with 2 lines of context and approximate page numbers.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to search |
| string | Yes | Search query (case-insensitive) |
Example output:
Found 3 matches for 'microservice' in architecture-guide.pdf:
--- Match 1 (page ~2, line 45) ---
The system is composed of several
> microservice components that communicate
via gRPC and message queues.get_document_summaryReturns the text from the first 3 pages of a document as a quick summary.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to summarize |
get_document_metadataReturns full document metadata.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to get metadata for |
Example output:
{
"title": "Architecture Guide",
"author": "Jane Doe",
"subject": "System Design",
"creator": "LaTeX",
"producer": "pdfTeX",
"creation_date": "Thu May 15 10:30:00 2025",
"modification_date": "Thu May 15 10:30:00 2025",
"pages": 42,
"file_size_bytes": 1048576,
"pdf_version": "1.5"
}get_document_outlineExtracts the document outline (table of contents / bookmarks) as a structured list.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to extract outline from |
extract_tablesExtracts tables from a document as structured data.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to extract tables from |
| number | No | Specific page to extract from. Omit for all pages. |
extract_imagesExtracts images from a document as base64-encoded data. Returns up to 10 images per call.
Parameters:
Name | Type | Required | Description |
| string | Yes | The document filename to extract images from |
| number | No | Specific page to extract from. Omit for all pages. |
Example output:
[
{
"page": 1,
"index": 0,
"format": "jpeg",
"width": 800,
"height": 600,
"data_base64": "/9j/4AAQSkZJRg..."
}
]read_urlDownloads a document from a URL and extracts its text content. Maximum file size: 50MB.
Parameters:
Name | Type | Required | Description |
| string | Yes | The URL of the document to download and read |
| string | No | Page ranges to extract, e.g. "1-5". Omit for full text. |
Example input:
{
"url": "https://example.com/report.pdf",
"pages": "1-3"
}ocr_documentForces OCR on a PDF document using tesseract. Useful for scanned/image-based PDFs or when pdftotext returns garbled text. Requires tesseract and pdftoppm.
Note:
read_documentalready auto-detects image-based PDFs and falls back to OCR. Useocr_documentwhen you want to force OCR regardless, or need to specify a non-English language.
Parameters:
Name | Type | Required | Description |
| string | Yes | The PDF filename to OCR |
| number | No | Specific page to OCR (1-based). Omit for all pages. |
| string | No | Tesseract language code (default: |
Example input:
{
"filename": "scanned-contract.pdf",
"page": 1,
"language": "spa"
}read_imageExtracts text from an image file using OCR. Supports PNG, JPG, and TIFF. Requires tesseract.
Parameters:
Name | Type | Required | Description |
| string | Yes | The image filename to read (PNG, JPG, TIFF) |
| string | No | Tesseract language code (default: |
Example input:
{
"filename": "receipt.png",
"language": "eng"
}Directory-locked — only files within DOCS_MCP_DIR are accessible
Path traversal prevention — filenames sanitized; ../ rejected
Extension filter — only supported formats served
Read-only — no write operations
URL downloads — 50MB limit, Content-Type validated, temp files cleaned immediately
make build # Build the binary
make test # Run tests with race detector
make clean # Remove build artifactsgo-docs-mcp/
main.go # MCP server setup, 12 tool registrations
internal/
pdf/
reader.go # Document extraction, caching, search, metadata, images, OCR
Makefile # Build targets
go.mod # Module definitionMIT - Copyright 2026 Drolosoft
Drolosoft — Tools we wish existed
Convert a document to clean Markdown format. Use this when you need structured, readable output from any document; for PDFs headings are detected and formatted, for TXT/CSV content is wrapped in code blocks, and MD files are returned as-is. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to convert |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only', but annotations set destructiveHint=true and readOnlyHint=false, creating a direct contradiction. This severely undermines an agent's ability to predict side effects, and the description fails to clarify actual behavior beyond the contradiction.
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 concise with two sentences, front-loading the purpose. The phrase 'Read-only' is redundant given the first sentence implies no modification, and contradicts annotations, but overall structure is efficient.
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?
The description explains behavior for multiple document types, which is helpful, but completely omits details about output format (beyond stating Markdown) and fails to resolve the behavioral contradiction. For a single-parameter tool, it is adequate but not thorough.
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 100%, so the baseline is 3. The description adds context about per-type handling but does not enhance parameter understanding beyond what the schema already provides.
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 clearly states the tool converts a document to clean Markdown format, specifying the verb, resource, and output format. It also distinguishes behavior for different input types, making it easy to differentiate from sibling 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 provides clear guidance on when to use the tool (for structured, readable output) and explains per-format handling. However, it lacks explicit exclusionary guidance or alternatives, which slightly reduces its utility.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract embedded images from a PDF as base64-encoded data, up to 10 per call. Use this when you need to retrieve figures, charts, or photos embedded in a PDF document. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to extract images from | |
| page | No | Optional page number to extract images from. If omitted, extracts from all pages. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description claims 'Read-only' but annotations set destructiveHint=true, a direct contradiction. No other behavioral details beyond the limit.
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?
Two concise sentences covering purpose and usage, no unnecessary words.
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?
No output schema, but description mentions format. Contradictory annotations reduce completeness. Adequate for a simple tool but missing error/limit details.
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 covers both parameters with descriptions, so description adds minimal value. The limit is mentioned but not linked to parameters.
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 clearly states the action (extract images), resource (PDF), output format (base64-encoded data), and a limit (up to 10 per call). It distinguishes from sibling tools like extract_tables.
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?
Specifies when to use (retrieve figures, charts, photos). Lacks explicit when-not or alternatives, but context is clear given sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract table-like structures from a document, detecting pipe-delimited, tab-delimited, and multi-space-delimited columns. Use this when you need structured tabular data from a PDF, CSV, or text file. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to extract tables from | |
| page | No | Optional page number for PDFs (1-based). If omitted, extracts from all pages. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only,' but annotations set readOnlyHint: false and destructiveHint: true, a direct contradiction. No other behavioral traits are disclosed, leaving the agent misinformed about side effects.
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?
Two sentences, front-loaded with main action, no redundant phrases. Every word is necessary.
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?
The tool has no output schema, but the description does not explain what is returned (e.g., JSON rows). Combined with the annotation contradiction, the agent lacks full context. For a simple 2-param tool, it's adequate but not complete.
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 100% with descriptions. The description adds value by explaining the delimiters detected and that page is optional, but the schema already covers parameter format. Baseline 3, plus one for extra context.
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 clearly states the tool extracts table-like structures, specifying pipe, tab, and multi-space delimiters. It stands out from siblings like read_document or convert_to_markdown by focusing on structured tabular data.
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 explicitly says 'Use this when you need structured tabular data from a PDF, CSV, or text file,' providing clear context. It does not mention when not to use or list alternatives, but the sibling list helps differentiate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get document metadata including title, author, dates, page count, and file size. Use this when you need document properties without reading its content; returns full PDF-specific fields (subject, creator, producer, version) for PDF files. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to get metadata for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description claims 'Read-only' but annotations have readOnlyHint=false and destructiveHint=true, indicating it may modify data. This is a direct contradiction, severely reducing transparency.
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?
Two concise sentences with no redundancy, efficiently conveying purpose, usage, and special PDF behavior.
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?
Despite listing returned fields and PDF specifics, the contradiction and missing output schema lead to incomplete context. The read-only claim misleads about behavioral impact.
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 covers 100% of parameter descriptions. The description does not add extra semantic value beyond the schema for the filename parameter.
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?
Clearly states verb 'Get', resource 'document metadata', and specific fields returned. Distinguishes from sibling tools like read_document by noting it gives properties without content.
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?
Explicitly says 'Use this when you need document properties without reading its content', providing clear context. However, it does not name alternative siblings explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract the heading structure and table of contents from a document. Use this to understand document organization before reading specific sections; detects numbered sections, ALL-CAPS headings, and markdown # headings. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to extract outline from |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only', but annotations set readOnlyHint: false and destructiveHint: true, which is a direct contradiction. This severely undermines transparency and trust.
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 sentences long, front-loaded with the primary action, and contains no unnecessary words. Every sentence adds value.
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 simple outline extraction tool with one parameter and no output schema, the description provides adequate context about return value (heading structure) and detection capabilities. However, the contradiction with annotations reduces completeness and introduces confusion.
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 100% coverage with a clear description for the single 'filename' parameter. The tool description adds details about detected heading styles but does not add meaning beyond the schema for the parameter itself, so a baseline score of 3 is appropriate.
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 clearly states the tool extracts heading structure and table of contents. It uses a specific verb ('Extract') and resource ('heading structure'), and is distinct from sibling tools like get_document_metadata or read_document.
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 says 'Use this to understand document organization before reading specific sections', providing clear guidance on when to use it. It does not explicitly mention when not to use or name alternatives, but the use case is well-defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a quick summary by extracting the first 3 pages or ~100 lines of a document. Use this to preview document content before deciding to read it in full. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to summarize |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only', but annotations set destructiveHint=true, creating a direct contradiction. No additional behavioral context is provided beyond the conflicting claim.
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 sentences and front-loaded, but the inclusion of 'Read-only' is misleading due to contradiction.
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 simple one-parameter tool, the description mostly suffices but lacks details about the summary format or behavior, and the contradiction undermines completeness.
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 100% and the description adds minimal extra meaning beyond the schema's description of the filename parameter.
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 clearly states the action (get a quick summary) and specifies the method (first 3 pages or ~100 lines), distinguishing it from siblings like get_document_metadata and read_document.
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 explicitly advises using this tool to preview content before deciding to read in full, implying when to use it and suggesting an alternative (read_document).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all documents in the configured directory with format detection and metadata (filename, pages, size). Use this to discover available documents before reading or searching. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only,' but annotations indicate readOnlyHint=false and destructiveHint=true, directly contradicting the description. This serious inconsistency undermines agent trust and proper tool selection.
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?
Two sentences efficiently convey the tool's purpose and usage context without extraneous information. Every word adds value.
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 simple list tool with no parameters and no output schema, the description covers purpose, scope, and usage context. However, it lacks explanation of 'format detection' and fails to reconcile the annotation contradiction.
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 no parameters, so the description does not need to add parameter information. The minimal description is adequate given the zero-parameter 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 clearly states 'List all documents in the configured directory with format detection and metadata (filename, pages, size).' It specifies the action (list), the resource (documents), and the scope (configured directory), effectively distinguishing it from sibling tools like read_document or search_document.
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 explicitly advises 'Use this to discover available documents before reading or searching.' This provides clear context for when to use the tool, though it does not explicitly mention when not to use it or list alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show all supported document formats and their dependency installation status. Use this to check which formats are available and diagnose missing dependencies. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only', but annotations set readOnlyHint=false and destructiveHint=true, creating a direct contradiction. The description does not disclose the actual behavioral traits beyond annotations, and instead contradicts them, which is highly misleading.
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 sentences with no wasted words. The first sentence states the main purpose, and the second provides usage context. It is well-structured and front-loaded.
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?
Without an output schema, the description should fully explain the return format and behavior. It covers formats and dependency status, but the behavioral claim contradicts annotations, so the description is incomplete and unreliable for an agent.
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 no parameters with 100% coverage, so the description does not need to add parameter meaning. The description explains what the output contains (formats and installation status), which is sufficient.
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 clearly states the tool shows all supported document formats and their dependency installation status, with a specific verb 'Show' and resource 'document formats'. It distinguishes itself from siblings like 'list_documents' by focusing on formats.
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 explicitly says 'Use this to check which formats are available and diagnose missing dependencies', providing clear when-to-use guidance. However, it does not mention when not to use or suggest alternatives, so it's not a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Force OCR text extraction on a PDF, bypassing normal text extraction. Use this when read_document returns garbled or empty text from a scanned PDF; requires tesseract and pdftoppm. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The PDF filename to OCR | |
| language | No | Tesseract language code (default: "eng"). Use "spa" for Spanish, "fra" for French, etc. Run 'tesseract --list-langs' to see available languages. | |
| page | No | Optional page number to OCR (1-based). If omitted, OCRs all pages. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only', but annotations set destructiveHint=true, which contradicts the claim. This contradiction undermines trust and provides no additional behavioral context beyond the misleading statement.
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 sentences with no wasted words. It is front-loaded with the core action and provides immediate guidance on usage context.
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?
While the description covers purpose and usage, it lacks information about the output format or return value. The annotation contradiction also reduces completeness. For a tool with only one required parameter and no output schema, more detail about what the tool returns would be helpful.
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 100% description coverage for all three parameters (filename, language, page). The description adds no extra parameter semantics; it only mentions system dependencies. Baseline 3 is appropriate as the schema already defines the parameters.
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 clearly states the tool performs OCR text extraction on a PDF, bypassing normal text extraction. It specifies the resource (PDF) and the action (Force OCR), and distinguishes it from read_document by describing when to use it.
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 explicitly says to use this tool when read_document returns garbled or empty text from a scanned PDF, providing clear context. It also mentions system dependencies (tesseract and pdftoppm), guiding the agent on prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read text content from a document with optional page selection. Use this when you need the raw text of a PDF, TXT, MD, CSV, or DOCX file; supports page ranges (e.g. "1-5", "1-3,7,10-12") and auto-OCR fallback for scanned PDFs. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to read | |
| page | No | Optional single page number to read (1-based). If omitted, returns full text. | |
| pages | No | Optional page ranges to read, e.g. "1-5", "10", "1-3,7,10-12". Overrides 'page' if both provided. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only' but annotations set readOnlyHint: false and destructiveHint: true, indicating possible side effects. This contradiction makes the behavioral description misleading and unreliable.
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 sentences, front-loading the purpose and optional selection, then providing additional context. Every sentence adds value; no wasted words.
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?
Despite covering basics, the contradiction with annotations undermines completeness. No output format info, though simple text is implied. With no output schema, description should clarify return structure.
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 100%, and the description adds meaning beyond schema by explaining page range syntax (e.g., '1-5') and auto-OCR fallback, which are not in parameter descriptions.
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 clearly states 'Read text content from a document' and lists supported formats (PDF, TXT, MD, CSV, DOCX), differentiating it from siblings like extract_images or extract_tables.
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?
Description advises 'Use this when you need the raw text of a...file' and mentions page ranges and auto-OCR, providing clear context for usage, though it doesn't explicitly state when not to use it or name alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract text from a standalone image file (PNG, JPG, TIFF, BMP) using OCR. Use this when you need to read text from an image rather than a document; supports multiple languages via tesseract. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The image filename to OCR (must be in the documents directory) | |
| language | No | Tesseract language code (default: "eng"). Use "spa" for Spanish, "fra" for French, etc. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description claims 'Read-only' but annotations indicate destructiveHint=true, which is a direct contradiction. No further behavioral details beyond annotations.
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?
Two sentences, no fluff, efficiently communicates core functionality and constraints.
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?
Adequate for a simple tool with full schema coverage, but the description-destructiveHint contradiction undermines completeness.
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 100%; description adds valuable context: filename must be in documents directory, language codes with examples (spa, fra) beyond the default.
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 clearly specifies the tool extracts text from standalone images (PNG, JPG, TIFF, BMP) using OCR, differentiating it from document-focused siblings like ocr_document.
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?
Explicitly states when to use ('when you need to read text from an image rather than a document') and mentions language support, but lacks explicit 'when not to use' statements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Download a document from a URL and extract its text content (max 50MB). Use this when the document is hosted online rather than in the local directory; supports PDF and plain text URLs. Read-only, downloads to a temporary file.
| Name | Required | Description | Default |
|---|---|---|---|
| pages | No | Optional page ranges to read, e.g. "1-5", "10", "1-3,7,10-12". If omitted, returns full text. | |
| url | Yes | The URL of the document to download and read |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description claims 'Read-only' while annotations set destructiveHint=true, a direct contradiction. Additionally, the temporary file download is not explained as a side effect.
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?
Two sentences with no wasted words. Action, constraints, and usage guidance are front-loaded.
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?
Explains result (text content) and constraints (max 50MB, supported types). Lacks error scenarios or output format, but sufficient for a simple retrieval tool.
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 100%, but description adds value by stating max file size and supported formats, which are not in schema. Adds context beyond 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?
Clearly states the verb 'Download and extract text content' from a URL, distinguishing from sibling tools that handle local documents.
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?
Explicitly tells when to use ('hosted online') and mentions supported types (PDF, plain text) and a max size (50MB). Lacks explicit alternative names but provides clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for text within a document and return matching lines with context and approximate page numbers. Use this when you need to find specific content without reading the entire document. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | The document filename to search | |
| query | Yes | The search query (case-insensitive) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description claims 'Read-only,' which contradicts annotations (destructiveHint: true). This is a critical inconsistency. No mention of potential side effects or required permissions beyond the contradiction.
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?
Three sentences: one for purpose, one for usage guidance, one for behavior. Efficient and front-loaded with no redundant information.
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?
Despite having only 2 parameters, the tool is a search operation with clear output description in text. However, the annotation contradiction undermines completeness; missing behavioral truth and no output schema information.
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?
Both parameters are fully described in the input schema (100% coverage), so the description adds no additional meaning beyond the schema. Baseline score of 3 appropriate.
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?
Description clearly states the verb 'Search', the resource 'document', and specifics about output ('matching lines with context and approximate page numbers'). It effectively distinguishes from siblings like read_document and get_document_summary.
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?
Description explicitly says 'Use this when you need to find specific content without reading the entire document,' providing clear when-to-use guidance. However, it lacks explicit alternatives or when-not-to-use indications, but context from sibling tools suffices.
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. Dates show when Glama detected each change.
v1.1.0convert_to_markdownv0.1.0extract_imagesextract_tablesget_document_metadataget_document_outlineget_document_summarylist_documentslist_formatsocr_documentread_documentread_imageread_urlsearch_documentEach tool has a clearly distinct purpose (e.g., reading, searching, extracting images/tables, OCR, listing, etc.). There is no overlap or ambiguity between tools.
All tool names follow a consistent verb_noun pattern in snake_case, such as list_documents, read_document, convert_to_markdown, etc. The naming is predictable and clear.
With 13 tools covering listing, reading, searching, extracting, and format support, the count feels well-scoped for a document processing server. No tool seems superfluous.
The tool set covers all essential read-only document operations: listing, metadata, outline, summary, full text reading, search, conversion, image/table extraction, OCR, URL import, and format listing. No obvious gaps.
Document-to-Markdown MCP server — convert PDF, Office and HTML into LLM-ready Markdown.
Hosted MCP server: convert PDFs to clean, LLM-ready Markdown with tables, formulas and OCR.
Go MCP server for GitLab: 2 dynamic tools reach 1000+ REST/GraphQL actions. Free/CE, no paid tier.
DocBase MCP server for AI agents
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/drolosoft/go-docs-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
