Directmedia MCP
This MCP server gives agents access to local Directmedia "Digitale Bibliothek" CD-ROM volumes: discovery, metadata, table-of-contents navigation, decoded full-text reading/search, and EPUB export.
Configure the library —
set_library_path(path)points the server at your local Digitale Bibliothek folder.Browse the collection —
list_volumes()enumerates all volumes (DBxxx, DBSKxx, DBSOxx) with metadata.Inspect a volume —
get_volume_info(volume_id)returns metadata and file inventory;analyze_volume_structure(volume_id)gives a file-format overview.Navigate contents —
get_navigation_tree(volume_id)returns the table of contents/structure.Read text —
get_text_content(volume_id, start_pos, length)extracts decoded book text from a starting record position.Search text —
search_text(query, volume_id?, limit)does substring matching across one volume or all volumes.Export e-books —
convert_volume_to_epub_file(volume_id, output_dir)converts a single volume to EPUB;batch_convert_to_epub(output_dir, volume_ids?)does several or all.Note: the README also advertises a
textgridtool for public-domain texts, but it is not present in this schema.
Integrates with a local Ollama instance (default port 11434) to power the 'Ask the library' chat feature: a local LLM answers questions using passages retrieved from semantically indexed volumes, with citations linking back to the reader.
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., "@Directmedia MCPsearch for Nietzsche quotes in the philosophy volume"
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.
Directmedia MCP
Status (2026-10-12):
TEXT.DKIdecoded. Book text is extracted from 72 of 73 text volumes; 2,281,483 of 2,281,484 records pass the full-library gate, and spot checks against TextGrid's independent transcription match at 98%. Tables of contents link to pages in 72 volumes, and the webapp is a working alternative Digibib reader (library, contents, paged reading, ranked full-text search). Still open: the TOC page map of the two largest volumes (DB050, DB125), the Russian volume DB006's character mapping, and the originalINDEX.*search files.
📖 Installation Guide — quick start, manual setup, and troubleshooting
FastMCP server aimed at giving agents access to the Directmedia Publishing "Digitale Bibliothek" CD-ROM/DVD collection.
What this wraps
The Digitale Bibliothek was Directmedia Publishing's German e-book series (1990s-2000s): ~100+ volumes of literature,
philosophy and reference works, read with the proprietary Digibib5.exe reader. Each volume stores its content in
undocumented binary files (TEXT.DKI, TREE.DKI, INDEX.*, ...).
The public-domain part of the same corpus lives on today as the zeno.org online library, which TextGrid licensed and converted to TEI XML (see Public-domain texts without the CDs).
Related MCP server: librarian
Current state (honest)
Area | State |
Volume discovery ( | Works on a local library folder |
| Decoded: titles for all volumes, page links for 72 (not DB050/DB125) |
| Decoded (format spec); 72/73 volumes, DB006 (Russian) needs a font map |
| Real text, paged by record (about one printed page), with print page numbers and source file |
| Real text, but a linear scan; slow across the biggest volumes |
EPUB export | Real text, one EPUB per volume (not yet split into works) |
| Not analysed |
An earlier version of this README claimed text extraction worked when it did not. The loose reverse_engineer_*.py /
*huffman*.py scripts in the repo root are from that failed attempt and are kept only for reference.
How TEXT.DKI was cracked
TEXT.DKI is not compressed. Earlier attempts treated the ~400 KB offset table at the start of the file as packed
data. The records behind it are byte-coded token streams: words in CP1252, spacing, line breaks, layout and metadata
tokens. The exact token sizes came from Digibib5.exe itself: Ghidra headless decompilation of the line scanner
(FUN_00614bb4) led to an int32 size table at VA 0x00763554. With that table, every record of every volume parses
to its exact boundary. Full spec: docs/DKI_FORMAT.md. Re-run the gate any time:
uv run python scripts/dki_gate.py "L:\Multimedia Files\Written Word\Digitale Bibliothek"Public-domain texts without the CDs
If you only need public-domain works, you do not need to crack DKI at all:
zeno.org — the online library derived from the same corpus.
TextGrid Repository — Digitale Bibliothek — the zeno.org corpus as TEI XML (literature ~690 authors, philosophy ~250 authors, plus smaller collections). Annotated data and metadata are CC-BY 3.0, plain texts are public domain; credit "TextGrid".
Bulk download (texts only, ~390 MB):
https://textgridlab.org/download/digitale-bibliothek/literatur-nur-texte-2.zipPer-object export:
https://textgridlab.org/1.0/aggregator/{text|epub}/textgrid:<id>
Copyrighted CD content (lexika such as Killy, editorial commentary, modern translations) is not on TextGrid. For that you need the CDs and the DKI decoder. TextGrid's Digibib project covers the literature collection (Lessing, Goethe, Busch...); philosophers such as Kant or Nietzsche are not in it.
The textgrid tool searches, reads and exports these editions without the CDs.
MCP tools
Tool | Purpose |
| Point the server at the local Digitale Bibliothek folder |
| Enumerate volumes (DBxxx, DBSKxx, DBSOxx) |
| Volume metadata and file inventory |
| File-format overview of a volume |
| Table of contents one level at a time; each entry has its start |
| Substring search over decoded text; |
| Decoded text from record |
| One EPUB per volume from decoded text |
| Same, for several volumes |
| Public-domain editions from TextGrid: |
Quick start
git clone https://github.com/sandraschi/directmedia-mcp
cd directmedia-mcp
just # list recipes
just bootstrap # install dependencies
just serve # start the MCP serverClaude Desktop (claude_desktop_config.json):
"mcpServers": {
"directmedia-mcp": {
"command": "uv",
"args": ["--directory", "D:/Dev/repos/directmedia-mcp", "run", "directmedia-mcp"]
}
}Run directly with a library path:
uv run directmedia-mcp --library-path "L:\Multimedia Files\Written Word\Digitale Bibliothek"Volume file layout (per volume, Data\)
File | Role | Decoded? |
| Book body text | No |
| Table of contents (titles / page map) | Yes, except the large-tree map layout |
| Search indices | No |
| Cross-references | No |
| Abbreviation registry | No |
| Media | Standard formats, not wired up |
Webapp
An alternative Digibib reader in web_sota/: frontend on port 10826, backend API on 10827. Start with
web_sota\start.ps1 (set DIRECTMEDIA_LIBRARY_PATH, or the library path in Settings).
Library: all volumes, with search, filter, sort and pagination.
Volume: contents tree (expand lazily, click to read), search-index build with progress, EPUB export.
Reader (
/read/<volume>/<page>): one printed page at a time, with a breadcrumb showing where you are in the work, page jump, ← → keys, print-edition page numbers, highlighted search terms and adjustable font size.Search: ranked full-text search (SQLite FTS5) over indexed volumes, with highlighted snippets that link into the reader. Words combine with AND,
"quotes"make a phrase,word*matches a prefix. Each volume is indexed once on demand (Lessing about 2 s, Philosophie about 25 s) into%LOCALAPPDATA%\directmedia-mcp\index, orDIRECTMEDIA_INDEX_DIR.Semantic search (Search page, "Semantic" mode): finds passages by meaning, not exact words. For example, "unglückliche Liebe, die im Selbstmord endet" works without knowing the title. Results show the matching works first, then the closest passages. Each volume needs its semantic index built once from its volume page (about 90 passages/s on CPU; Goethe takes about 7 minutes).
Ask the library (chat button, bottom right): a local LLM (LM Studio on :1234 or Ollama on :11434) answers from passages retrieved from your semantically indexed volumes. Answers cite sources as [1], [2]..., and the citations link to the page in the reader. Untick "Answer from my library" for a plain chat.
REST API for the reader: /api/v1/reader/{volumes, volumes/<id>/toc, volumes/<id>/records/<n>, search, index, semantic/search, semantic/index}; chat: /api/llm/{providers, chat}.
Semantic search stack (deviation from the fleet RAG default)
LanceDB + FastEmbed as in standards/ai-rag-2026.md, with two documented deviations because the corpus is German:
Setting | Fleet default | Here | Why |
Embedding model |
|
| The English model cannot handle German. In a benchmark on DB004 (Goethe), MiniLM found Faust and the Italienische Reise for thematic queries at ~45 pages/s. |
Chunking | 1000 / 200 chars | 600 / 120 chars | MiniLM reads only ~128 tokens. |
Override the model with DIRECTMEDIA_EMBED_MODEL; indexes built with another model show as "stale". Indexes live in
%LOCALAPPDATA%\directmedia-mcp\index\semantic.
Legal
This tool is for interoperability and preservation with CD-ROMs you legally own. Directmedia content remains under its original copyright; do not redistribute extracted text from copyrighted volumes. Public-domain texts via TextGrid are subject to TextGrid's terms (CC-BY 3.0 for annotated data, credit "TextGrid").
License
MIT — see LICENSE.
Available Tools
9 toolsanalyze_volume_structureC
Analyze the file structure and format of a volume
| Name | Required | Description | Default |
|---|---|---|---|
| volume_id | Yes | Volume ID to analyze |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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 only states the action ('Analyze') without confirming read-only semantics, side effects, or what the analysis yields. The tool appears non-destructive by inference only, not by disclosure.
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?
A single clean sentence with zero waste and the action front-loaded. It is concise, though minimal to the point of being terse.
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?
With only one fully-covered parameter and an output schema present, the structural requirements are met. However, the description does not clarify what 'analyze' produces relative to the get_* siblings or when it is the right choice, which is a meaningful gap given no annotations exist.
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 100% — the single parameter volume_id is already documented as 'Volume ID to analyze' in the schema. The description adds no additional meaning beyond that, so the baseline of 3 applies.
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 states a specific verb ('Analyze') and resource ('file structure and format of a volume'), giving a clear purpose. However, it does not differentiate from siblings like get_volume_info or get_navigation_tree, which could overlap conceptually with volume structure and info.
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?
No guidance is given on when to use this tool versus alternatives such as get_volume_info or get_navigation_tree. There are no conditions, exclusions, or references to sibling tools, leaving the agent to guess which of several overlapping tools to pick.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
batch_convert_to_epubC
Convert multiple Directmedia volumes to EPUB format
| Name | Required | Description | Default |
|---|---|---|---|
| output_dir | Yes | Directory where EPUB files will be created | |
| volume_ids | No | Optional list of specific volume IDs to convert (converts all if None) |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the action without revealing side effects, error behaviors, or dependencies. It doesn't mention whether it overwrites files, requires a prior setup, or what happens if volume_ids is null. This is essentially a tautology of the tool's name with no additional behavioral context.
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 a single, concise sentence that gets straight to the point. It is front-loaded with the action and has no unnecessary filler. However, it could be considered too minimal, as it omits useful details, but for conciseness alone it is efficient and well-structured.
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 batch operation with two parameters and existing sibling tools like set_library_path and convert_volume_to_epub_file, the description is incomplete. It doesn't explain the relationship to these siblings, any required setup, or what happens when volume_ids is omitted. Even with an output schema, the agent lacks critical context about prerequisites and behavior.
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 schema description coverage is 100%, so the parameters are fully documented in the input schema. The description adds no additional meaning about the parameters, such as how volume_ids interacts with output_dir or any constraints. Since the schema already covers the semantics, the baseline 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 action (convert), the resource (multiple Directmedia volumes), and the output format (EPUB). It implicitly distinguishes from the sibling convert_volume_to_epub_file by the word 'multiple', but it doesn't explicitly name the alternative. This is a clear and specific purpose, though not perfect at differentiating siblings.
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 no guidance on when to use this tool versus the single-volume conversion tool or any other alternative. It doesn't mention prerequisites like setting the library path, nor does it specify conditions for batch vs. single conversion. There is no exclusion or alternative mention, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
convert_volume_to_epub_fileB
Convert a Directmedia volume to EPUB format for e-book readers
| Name | Required | Description | Default |
|---|---|---|---|
| volume_id | Yes | Volume identifier (e.g., 'DB002') | |
| output_dir | Yes | Directory where EPUB file will be created |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does not mention side effects like file creation/overwrite, required permissions, or failure conditions. It only states the conversion action, leaving the agent to infer the behavior.
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 a single, focused sentence that front-loads the action and avoids redundancy. It is concise and to the point with 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?
For a simple two-parameter conversion tool, the description is adequate but lacks context about the batch alternative and potential prerequisites. It also does not mention any error scenarios, though the output schema exists. Overall, it is minimally complete but missing some operational context.
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 schema covers both parameters with descriptions (volume_id and output_dir), so the baseline is 3. The description adds no additional semantic meaning beyond what the schema already provides, such as format constraints or directory requirements.
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 states a clear verb ('Convert') and resource ('Directmedia volume to EPUB format'), which makes the purpose unambiguous. However, it does not explicitly differentiate from the sibling 'batch_convert_to_epub' tool, relying on the name to imply single-volume conversion.
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?
No guidance is given on when to use this tool versus batch_convert_to_epub or any prerequisites such as setting the library path (via set_library_path). The description only states what it does, not when to choose it over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_text_contentC
Extract text content from a volume
| Name | Required | Description | Default |
|---|---|---|---|
| length | No | Number of characters to extract | |
| start_pos | No | Starting position in the text database | |
| volume_id | Yes | Volume ID to extract from |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description does not disclose side effects, permissions, error handling, or the nature of the operation (e.g., read-only). It gives no insight into behavior beyond the basic extraction action.
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 a single, concise sentence that directly conveys the tool's purpose without unnecessary words or repetitions. It is well-structured and easy to parse.
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 is simple with one required parameter and two optional ones, and the description covers the basic function. However, it lacks usage context, output expectations, and transparency about side effects or errors, leaving some gaps for an agent deciding when and how to use it.
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 already includes descriptions for all three parameters, so the tool description adds no extra meaning. The parameter descriptions are minimal but sufficient, and the description does not elaborate on their interplay or edge cases.
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's function with a specific verb ('Extract') and resource ('text content from a volume'), which distinguishes it from siblings like get_volume_info or search_text.
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 no guidance on when to use this tool versus alternatives such as search_text or get_volume_info. It lacks any contextual cues or explicit conditions for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_volume_infoB
Get detailed information about a specific volume
| Name | Required | Description | Default |
|---|---|---|---|
| volume_id | Yes | Volume ID (e.g., 'DB002', 'DB003') |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. While 'Get' implies a read operation, it does not explicitly state it is non-destructive, nor does it describe the return structure, potential errors, or any side effects. This is a significant gap for a tool with no annotation safety cues.
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 a single, front-loaded sentence that efficiently communicates the core purpose. There is no wasted language, and it is immediately understandable.
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 simplicity (one parameter) and the existence of an output schema (not shown but indicated), the description is largely sufficient. An agent can infer that it returns detailed information for a given volume. It lacks explicit mention of how to obtain the volume_id (e.g., via list_volumes), but this is a minor omission for a straightforward get operation.
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% for the single parameter 'volume_id', with an example provided in the schema. The tool description adds no additional semantic context beyond what the schema already states, so the 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 states a clear action ('Get') and a specific resource ('detailed information about a specific volume'). It distinguishes from the sibling 'list_volumes' (which lists volumes) by focusing on a single volume's details. However, it does not specify what 'detailed information' entails, which could be ambiguous for an agent.
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 no guidance on when to use this tool versus alternatives like 'list_volumes' or 'search_text'. It does not mention prerequisites (e.g., knowing the volume ID) or any exclusions. The agent is left to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_volumesA
List all available Directmedia volumes/bände
Returns a list of all volumes in the Digitale Bibliothek collection with metadata about each volume.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the action and output, but doesn't mention any prerequisites (e.g., setting the library path) or potential side effects. This is a significant gap given the sibling set_library_path.
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-loaded with the primary action, and contains no unnecessary filler. It efficiently communicates the tool's purpose.
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 parameterless list tool, the description is adequate but lacks mention of prerequisites like set_library_path and provides vague metadata information. The output schema could compensate, but it's not included in the description.
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 tool has zero parameters, so there is nothing to describe. The schema coverage is 100% trivially, and the description doesn't need to add parameter semantics. Baseline 4 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's function: listing all Directmedia volumes. The phrase 'List all available' is specific and distinguishes it from sibling tools like get_volume_info which targets a single volume.
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 implies when to use this tool (when you need an overview of all volumes), but it doesn't explicitly mention alternatives or when not to use it. It provides clear context without exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_textC
Search for text across volumes
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return | |
| query | Yes | Search query (supports basic text matching) | |
| volume_id | No | Optional volume ID to search in (searches all if None) |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Search for text across volumes' without mentioning return format, case sensitivity, pagination, or any limitations. This leaves significant uncertainty about what the agent will get back.
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 a single sentence with no waste, but it is so brief that it borders on under-specification rather than efficient conciseness. It conveys the core action but omits useful context that would fit in a few more 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 having an output schema, the tool lacks any behavioral context such as search semantics, result ordering, or performance notes. For a search tool with three parameters, this is notably incomplete—an agent cannot predict how the query is interpreted or what the results will look like beyond the schema.
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 100%, so all parameters are documented in the input schema. The tool description adds no additional meaning beyond what the schema provides, so a baseline of 3 is appropriate. It doesn't clarify things like how 'query' is matched (e.g., exact vs. fuzzy).
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 states a clear verb and resource ('Search for text across volumes'), distinguishing it from siblings like get_text_content and list_volumes. It is specific enough that an agent can tell this is the full-text search tool, though it doesn't mention scope like metadata vs. 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?
No guidance is given on when to use this tool versus alternatives. For example, there is no note about whether this should be used instead of get_text_content for retrieving specific content, or how it relates to volume navigation. An agent has to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
set_library_pathB
Set the path to the Digitale Bibliothek collection
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Full path to the "Digitale Bibliothek" directory |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior itself. 'Set' implies a mutation, but there is no information on persistence, side effects, required permissions, or whether it validates the path. The description adds almost nothing beyond the action itself.
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 a single, short sentence with no wasted words. It is appropriately concise for a simple setter, though it could include a bit more context without bloat. Structure is fine and front-loaded with the action.
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 role as a configuration setter among read/convert tools, the description should explain when to use it (e.g., before querying volumes) and any effects. An output schema exists but the description still lacks necessary context about persistence or prerequisites. Completeness is low for the tool's purpose.
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% (the single parameter has a full description). The description adds no additional meaning beyond the schema; it merely restates the action. Baseline 3 is appropriate because the schema already documents the parameter fully.
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 clear verb 'Set' with a specific resource 'path to the Digitale Bibliothek collection'. It is unambiguous and distinct from sibling tools, which are all about reading, searching, or converting volumes. No other tool sets a path, so it is easily 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?
No guidance is given on when to use this tool versus alternatives, nor any prerequisites or ordering. For instance, it does not mention that the path should be set before using other tools, or that it is a configuration step. The description is purely declarative without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
9 tool updates
v0.1.0-alpha.0- First observed
analyze_volume_structure - First observed
batch_convert_to_epub - First observed
convert_volume_to_epub_file - First observed
get_navigation_tree - First observed
get_text_content - First observed
get_volume_info - First observed
list_volumes - First observed
search_text - First observed
set_library_path
TDQS
Scored across 9 tools
Most tools are clearly distinct: list_volumes enumerates all volumes while get_volume_info targets a single one; search_text finds passages and get_text_content extracts full content. The only minor overlap is between get_navigation_tree and analyze_volume_structure, but descriptions indicate different kinds of structure (user-facing navigation vs. technical file format).
All tool names follow a consistent snake_case verb_noun pattern, e.g., list_volumes, get_volume_info, search_text, get_navigation_tree. The batch conversion tool (batch_convert_to_epub) is a minor variation but still fits the overall convention. No mixed casing or unpredictable verb usage.
Nine tools is well within the ideal range for a domain-specific server. Each tool maps to a clear need: discovery, metadata, search, text retrieval, structure, configuration, and conversion. The set is compact but not sparse, with no redundant tools.
The set covers the full workflow for a digital library server: list and inspect volumes, search and read content, navigate structure, set the library path, and convert to EPUB including batch conversion. Since the domain is a read-only archive, CRUD operations like update/delete are not missing—they are out of scope.
Maintenance
Related MCP Connectors
Complete classical & world literature — search + cite exact passages, facing sources, 50+ languages.
Multi-engine scholarly research server for search, traversal, full text, and reading lists.
Academic literature search, retrieval, and private library management on top of OpenAlex.
Federated search of books and papers, BibTeX/RIS citations, open-access retrieval and reading.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables search and reading of Project Gutenberg books with tools for searching by title/author/subject and fetching word-range slices of book text.MIT
- AlicenseAqualityCmaintenanceEnables browsing, searching, and quote verification of a local ebook library via MCP, providing deterministic RAG with no embeddings or network.625 PyPI2MIT
- AlicenseNot gradedqualityBmaintenanceProvides tools to read and compare scripture text from local Paratext project folders, enabling natural-language queries for verses, chapters, books, and cross-project comparisons.01ISC
- AlicenseNot gradedqualityBmaintenanceEnables searching and reading a library of PDF books page by page, and verifying whether a quote appears on its cited page.6 npmISC