Directmedia MCP
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
📖 Installation Guide — quick start, manual setup, and troubleshooting
FastMCP 3.1.0+ server for accessing Directmedia Publishing "Digitale Bibliothek" - TEXT EXTRACTION WORKING!
Quick Start
git clone https://github.com/sandraschi/directmedia-mcp
cd directmedia-mcp
justThis opens an interactive dashboard showing all available commands. Run just bootstrap to install dependencies, then just serve or just dev to start.
Manual Setup
If you don't have just installed:
Related MCP server: docpack MCP Server
Overview
The Directmedia Publishing "Digitale Bibliothek" was a pioneering German electronic book collection from the 1990s, containing extensive German literature and world literature. This MCP server provides programmatic access to these classic digital books.
BREAKTHROUGH: Text Extraction Working!
MISSION ACCOMPLISHED: We successfully reversed the Directmedia TEXT.DKI format!
Discovery: TEXT.DKI files contain structured binary records, not compressed data
Decompressor: Working Python implementation extracts readable German text
Access: 101 volumes of 1990s literature now programmatically accessible
Preservation: Digital cultural heritage unlocked for modern use
What was thought to be "compression" was actually a structured record format with 2-byte length headers!
Collection Status
101 volumes discovered (DB002-DB161, DBSK01-DBSK05, DBSO01-DBSO28)
~14GB total content across all volumes
Proprietary binary format from 1990s German publishing
Latin-1 encoding with special characters for German texts
Legal Requirement
You must legally purchase the Directmedia CD-ROMs to use this tool. See Legal Notice section below.
Sample Volumes
Volume ID | Title | Size | Content Type |
DB002 | Philosophie von Platon bis Nietzsche | 389MB | Philosophy |
DB003 | Geschichte der Philosophie | 113MB | Philosophy History |
DB004 | Goethe | 360MB | Literature + Audio |
DB005 | Lessing | 149MB | Literature |
DB007 | Heine | 226MB | Literature |
DB009 | Killy Literaturlexikon | 137MB | Reference |
DB011 | Marx/Engels | 117MB | Political Philosophy |
Collection Analysis
101 volumes discovered with ~50GB total content:
DB002-DB061: Main literature collection (philosophy, literature, history)
DBSK01-DBSK05: Schnellkurs (crash courses)
DBSO01-DBSO28: Sonderausgaben (special editions)
File Format Structure
Each volume uses a proprietary binary format:
Core Files (Data/):
TEXT.DKI: Main text database (structured binary records)
TREE.DK*: Navigation tree (table of contents)
INDEX.*: Multiple search indices (HTX, PLX, SHX, SWX, TTX, WLX)
LINKS.*: Hyperlinks and cross-references
SIGEL.DAT: Abbreviations/signatures registry
Media Files:
IMAGES/: BMP illustrations and diagrams
WAVS/: Audio files (readings, lectures)
TABLES/: Specialized content tables
Quick Start
Prerequisites
Python 3.11+
Access to Directmedia "Digitale Bibliothek" collection
FastMCP 3.1.0+
Installation
Prerequisites
uv installed (RECOMMENDED)
Python 3.12+
Quick Start
Run immediately via uvx:
uvx directmedia-mcpClaude Desktop Integration
Add to your claude_desktop_config.json:
"mcpServers": {
"directmedia-mcp": {
"command": "uv",
"args": ["--directory", "D:/Dev/repos/directmedia-mcp", "run", "directmedia-mcp"]
}
}Basic Usage
from directmedia_mcp import DirectmediaLibrary
# Initialize library
lib = DirectmediaLibrary(r"L:\Multimedia Files\Written Word\Digitale Bibliothek")
# List all volumes
volumes = lib.list_volumes()
print(f"Found {len(volumes)} volumes")
# Search for content
results = lib.search_text("Nietzsche", "DB002") # Philosophy volume
# Extract text
content = lib.get_text_content("DB002", 0, 1000)MCP Server Usage
# Start MCP server
python -m directmedia_mcp.server --library-path "L:\Multimedia Files\Written Word\Digitale Bibliothek"
# Or run directly
directmedia-mcp --library-path "L:\Multimedia Files\Written Word\Digitale Bibliothek"MCP Tools
Library Management
set_library_path(path)- Configure library locationlist_volumes()- List all available volumesget_volume_info(volume_id)- Get volume metadata
Content Access
search_text(query, volume_id, limit)- Search across volumesget_text_content(volume_id, start_pos, length)- Extract textget_navigation_tree(volume_id)- Get table of contents
EPUB Conversion NEW
convert_volume_to_epub_file(volume_id, output_dir)- Convert single volume to EPUBbatch_convert_to_epub(output_dir, volume_ids)- Convert multiple volumes to EPUB
Analysis
analyze_volume_structure(volume_id)- File format analysis
Volume Overview
Volume ID | Title | Size | Content Type |
DB002 | Philosophie von Platon bis Nietzsche | 267MB | Philosophy |
DB003 | Geschichte der Philosophie | 180MB | Philosophy |
DB004 | Goethe | 150MB | Literature + Audio |
DB005 | Lessing | 75MB | Literature |
... | ... | ... | ... |
Technical Details
Binary Format Analysis
TEXT.DKI Structure:
Header: 256 bytes with section offset table
Content: Structured binary records (not compressed!)
Each record: 2-byte length + 1-byte type + text content
TREE.DK Structure:*
DKA: Navigation tree with entry counts and offsets
DKI: Tree structure data
INDEX Files:
HTX: Hypertext index for navigation
PLX: Plaintext index for full-text search
SHX/SWX: Specialized search indices
TTX: Title index
WLX: Word list index
Known Limitations
Proprietary Format: No official documentation available
Advanced Features: Some INDEX and TREE.DK* structures still being analyzed
Encoding: Primarily Latin-1 with some UTF-8 elements
Media Content: Images and audio files not yet processed
Recent Achievements
TEXT.DKI Decompression: Successfully reversed structured binary record format
Text Extraction: Working decompressor extracts readable German text
EPUB Conversion: Convert volumes to modern e-book format
MCP Integration: Full programmatic access via FastMCP server
Volume Management: Complete 101-volume library access
TREE.DKI Navigation: Table of contents successfully parsed
EPUB Conversion Feature
Convert extracted Directmedia text content into modern EPUB format for e-book readers!
What It Does
Extracts readable text from Directmedia
.DKIfilesFormats content with proper HTML structure and CSS styling
Creates valid EPUB 3.0 files compatible with all e-book readers
Preserves German text encoding and special characters
Adds metadata including title, author, and volume information
EPUB Features
Proper Structure: Mimetype, container.xml, OPF package, navigation
German Typography: Optimized for German text with proper quotes and spacing
Responsive Design: CSS styling that works on all devices
Table of Contents: Navigation structure for easy browsing
Metadata: Complete Dublin Core metadata for library management
Usage Examples
Convert single volume:
# Via MCP tool
convert_volume_to_epub_file("DB002", "./epub_output")Batch convert multiple volumes:
# Via MCP tool
batch_convert_to_epub("./epub_library", ["DB002", "DB003", "DB004"])Output Example
epub_output/
Goethe - Faust.epub # Volume DB004
Heine - Buch der Lieder.epub # Volume DB007
... (more volumes)EPUB Reader Compatibility
Calibre (recommended for library management)
Apple Books (iOS/macOS)
Google Play Books
Kindle (via conversion)
Adobe Digital Editions
All major e-book readers
Future Enhancements
Complete INDEX file parsing for full-text search
TREE.DK* advanced structure decoding
Cross-volume search optimization
Image extraction and processing
Audio file handling
Contributing
This is a research project to preserve and provide access to classic digital literature. Contributions welcome for:
Binary format analysis
Decompression algorithms
Search optimization
Documentation improvements
Legal Notice & Copyright
Important: Legal Use Required
This software tool is designed to work with legally purchased copies of Directmedia Publishing's "Digitale Bibliothek" CD-ROM collection. You must own legitimate copies of the CD-ROMs to use this tool legally.
Where to Purchase
Directmedia Publishing still operates and offers their complete collection:
Official Website: https://www.directmedia-publishing.de/
Product: "Digitale Bibliothek" (Complete 101-volume collection)
Format: Available as digital downloads and physical media
Languages: German literature and philosophy collections
Copyright Notice
Copyright: Directmedia Publishing GmbH
Content: All text, images, and multimedia content remain copyrighted
Usage: Personal, educational, and research use permitted with legal copies
Redistribution: Not permitted without explicit permission
Disclaimer
This tool is provided for educational and research purposes to access legally obtained digital content. The authors are not responsible for misuse of this software. Ensure you comply with all applicable copyright laws in your jurisdiction.
Pirated or illegally obtained content is not supported and may violate copyright law.
🛡️ Industrial Quality Stack
This project adheres to SOTA 14.1 industrial standards for high-fidelity agentic orchestration:
Python (Core): Ruff for linting and formatting. Zero-tolerance for
printstatements in core handlers (T201).Webapp (UI): Biome for sub-millisecond linting. Strict
noConsoleLogenforcement.Protocol Compliance: Hardened
stdout/stderrisolation to ensure crash-resistant JSON-RPC communication.Automation: Justfile recipes for all fleet operations (
just lint,just fix,just dev).Security: Automated audits via
banditandsafety.
License
MIT License - see LICENSE file for details.
Acknowledgments
Directmedia Publishing for pioneering electronic literature in the 1990s
The German digital humanities community
FastMCP framework for MCP implementation
Webapp Dashboard
This MCP server includes a free, premium web interface for monitoring and control. By default, the web dashboard runs on port 10826. (Assigned ports: 10826 (Web dashboard frontend), 10827 (Web dashboard backend (API)))
To start the webapp:
Navigate to the
webapp(orweb,frontend) directory.Run
start.bat(Windows) or./start.ps1(PowerShell).Open
http://localhost:10826in your browser.
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
- AlicenseAqualityDmaintenanceSemantic search over 4.6 million text chunks from 20,000+ classical philosophy and humanities works (pre-1928). Covers Aristotle, Plato, Kant, Hegel, Nietzsche and hundreds more. Multilingual: English, German, Latin, French, Italian, Greek, Russian.31MIT
- AlicenseNot gradedqualityDmaintenanceEnables querying and exploring a bundled knowledge base through tools for manifest, table of contents, node retrieval, and full-text search.10 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables search and reading of Project Gutenberg books with tools for searching by title/author/subject and fetching word-range slices of book text.MIT
- AlicenseAqualityBmaintenanceMCP server and CLI for full-text search of the Deutsches Zeitungsportal (German newspaper collection), enabling querying ~33.8 million digitized pages with Solr syntax, date/title/place filters, and snippet highlights.3Apache 2.0