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., "@Calibre MCP Server Find all books about machine learning and summarize the first chapter of the top result."
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.
This MCP server bridges the gap between AI agents and your Calibre ebook libraries. It enables agents to interact with your collection as a dynamic knowledge base, allowing them to search, manage, and read your digital libraries. Unlike other MCP servers it can also allow an AI agent to update library metadata and contents if a library's permissions are set to allow it.
Advanced Search: Query libraries using book metadata or perform full-text content searches.
Metadata Management: View and update metadata (titles, authors, tags, ratings, etc.) for any book.
Library Maintenance: Add new titles to your collection or remove existing ones.
Format Conversion: Leverage Calibre’s powerful conversion engine to switch between ebook formats (e.g., PDF to EPUB) on the fly.
Direct Reading: Search and read the text content of a book directly into the agent's context window for analysis, summarization, or Q&A.
Granular Permissions: Define strict access controls per library, including read-only modes and field-level write restrictions.
Related MCP server: Calibre MCP Server
Calibre: Must be installed on the host system. This server utilizes calibre-debug to execute worker processes.
Concurrency Note: Calibre does not support concurrent access to a single library. Do not point an agent to a library currently being used by the Calibre desktop application or other calibre processes to avoid database corruption. Setting a worker_timeout can reduce the risk of this happening accidentally, but don't rely on that to protect your libraries. Be aware of what you're doing.
The server is configured via a JSON file. Since JSON does not support comments, use the structure below as a template.
config.json)JSON
{
"libraries": {
"default": {
"path": "d:/ebooks/main_library",
"description": "The primary research library containing technical manuals.",
"default": true,
"permissions": {
"read": ["title", "authors", "tags", "rating", "comments"],
"write": ["tags", "rating", "comments"],
"delete": false,
"convert": true
},
"import": {
"allowed_paths": ["d:/downloads/ebook_imports"],
"allow_delete_source": false
},
"export": {
"allowed_paths": ["d:/ebook_exports"s],
"allow_overwrite_destination": false
},
"worker_timeout": 300
}
},
"port": 8000,
"enable_worker_logging": false,
"expose_resources_via_tools": true,
"log_level": "warning"
}Each library is identified by a unique text key and can have its own separate configuration values:
Key | Description |
| Absolute path to the Calibre library (where |
| Free-form context provided to the agent explaining what this library contains or what its purpose is. |
| If |
| Set to |
| List of metadata fields the agent is allowed to modify, |
| Boolean. If |
| Boolean. Allows the agent to add new formats to a book record by converting existing ones. If |
| A whitelist of directories from which the agent can import new files. |
| If |
| A whitelist of directories the agent can export book files to. |
| If |
| An integer in seconds. This specific library's |
There are also several top-level configuration settings that apply to the MCP server as a whole:
Key | Description |
| The port the server is exposed on. |
| Each Calibre library has its own |
| For efficiency, the |
| Sets what minimum level of logging message will be recorded in |
| Some older MCP clients don't understand the "resources" type that this server exposes, for example to allow the agent to read the contents of the |
You can run this MCP server using uvx, which will seamlessly download and run the latest version from GitHub without needing a manual installation.
First, install uv if you haven't already.
Then, point to your configuration file with the CALIBREMCP_CONFIGPATH environment variable in your MCP clients configuration. For example:
JSON
{
"mcpServers": {
"calibre": {
"command": "uvx",
"args": [
"--from",
"github.com/FaceDeer/calibre_full_mcp_server",
"calibre-full-mcp"
],
"env": {
"CALIBREMCP_CONFIGPATH": "<full path to your config.json>"
}
}
}
}(Note: If you have cloned the repository locally and wish to run from your local copy, you can replace "github.com/FaceDeer/calibre_full_mcp_server" with the <full path to your local repository directory>.)
This should allow you to easily switch library configurations as needed for different agents by selecting which configuration to point CALIBREMCP_CONFIGPATH at.
Calibre libraries often contain internal metadata that can clutter an agent's context window. It is highly recommended to use a specific list for read permissions. Only expose fields the agent actually needs (e.g., title, author, tags, comments).
Custom Fields: If you use custom columns in Calibre, you must include the # prefix (e.g., #my_custom_field).
Series: Every series field has a corresponding series_index. Ensure both are included in your permissions list if you want the agent to see or manage book order within a series.
Descriptions: The server passes custom field "descriptions" to the agent. Use these in Calibre to give the agent hints on how to use specific custom columns. For example if you create a custom field for a book's "age rating"" you could use the description to explain what the values of that field represent.
If your agent does not yet support the @mcp.resources standard, set expose_resources_via_tools to true. This will expose dedicated tools that allow the agent to fetch files via standard tool calls.
If you are building a Docker image for this server, it is recommended to pre-download the necessary NLTK models during the build phase to avoid runtime downloads and slow startup.
You can use the provided setup script for this purpose:
# Inside your Dockerfile
RUN calibre-full-mcp-setupThis will download the punkt and punkt_tab models into the image.
For a deep dive into how this server manages worker processes and interacts with the Calibre database, please refer to the Architecture Documentation.
Full-Text Search for a string. Returns a list of hits that include a book_id and a short snippet of text containing an example of the search string's use in that book.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| library_name | No |
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 mentions the return format (list of hits with book_id and snippet) but lacks details on permissions, rate limits, pagination, or error handling. For a search tool with zero annotation coverage, this leaves significant gaps in understanding its operational 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 concise and front-loaded, consisting of two sentences that efficiently convey the core functionality and output. There is no wasted language, making it easy for an agent to parse quickly.
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 lack of annotations and output schema, the description is incomplete. It explains the return format but misses behavioral aspects like search scope, performance hints, or error cases. For a tool with 2 parameters and no structured support, more context is needed to guide effective usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter descriptions. The tool description does not mention any parameters explicitly, failing to compensate for the coverage gap. However, with only 2 parameters (one required, one optional with a default), the baseline is moderate as the schema structure is simple, but no value is added beyond the 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 the tool's purpose: 'Full-Text Search for a string' specifies the verb and resource, and 'Returns a list of hits that include a book_id and a short snippet of text' explains the output. It distinguishes from siblings like 'search_book_content' by focusing on full-text search across books rather than content within a specific book, though the distinction could be more explicit.
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 provided on when to use this tool versus alternatives like 'search_book_content' or 'search_books'. The description implies usage for finding text snippets across books but does not specify contexts, exclusions, or prerequisites, leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve text content of a book. limit: Maximum number of characters to return (default 30,000). offset: Character offset to start reading from. sentence_aware: If True, adjusts the limit to the nearest sentence boundary.
| Name | Required | Description | Default |
|---|---|---|---|
| book_id | Yes | ||
| limit | No | ||
| offset | No | ||
| sentence_aware | No | ||
| library_name | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions a 'limit' parameter with a default and 'sentence_aware' behavior, but doesn't disclose critical behavioral traits: whether this is a read-only operation, potential rate limits, authentication needs, error conditions, or what happens if book_id is invalid. For a tool with 5 parameters and no annotations, this is insufficient.
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 extremely concise—four sentences total, with the first stating the purpose and the next three explaining key parameters. Every sentence adds value, and it's front-loaded with the core function. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain the return format (e.g., text structure, error responses), doesn't cover all parameters, and lacks behavioral context. For a content retrieval tool with multiple parameters, this leaves significant gaps for an AI 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?
Schema description coverage is 0%, so the description must compensate. It explains three parameters (limit, offset, sentence_aware) with some semantics (e.g., 'adjusts to nearest sentence boundary'), but doesn't cover 'book_id' (required) or 'library_name'. Since it documents 3 of 5 parameters partially, it adds value but doesn't fully compensate for the schema gap.
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 verb 'Retrieve' and resource 'text content of a book', making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'get_book_details' or 'search_book_content', which likely retrieve different aspects of books. The purpose is clear but lacks sibling distinction.
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. With siblings like 'get_book_details' (likely metadata) and 'search_book_content' (likely search within content), there's no indication of when this retrieval tool is appropriate versus those. No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed metadata for a book. fields: an optional list of metadata fields to return (e.g. ["title", "rating", "#genre"]). If not provided, returns all fields.
| Name | Required | Description | Default |
|---|---|---|---|
| book_id | Yes | ||
| fields | No | ||
| library_name | No |
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 mentions that the tool returns metadata, but doesn't specify permissions required, rate limits, error handling, or the format of the returned data (e.g., JSON structure). For a read operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves in practice.
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 and front-loaded, starting with the core purpose in the first sentence. The second sentence efficiently explains the 'fields' parameter. There's no wasted text, making it easy to parse quickly, though it could be slightly more structured with bullet points or clearer separation of ideas.
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 complexity (3 parameters, no annotations, no output schema), the description is incomplete. It covers the tool's purpose and one parameter but misses details on behavior, usage context, and the other parameters. For a tool that retrieves metadata, more information on what metadata is available, error cases, or example outputs would be beneficial to fully guide 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 description adds some meaning for the 'fields' parameter by explaining it as 'an optional list of metadata fields to return' with examples, which is helpful since schema description coverage is 0%. However, it doesn't address the 'book_id' (required) or 'library_name' parameters, leaving their purposes unclear. With 3 parameters and low schema coverage, the description partially compensates but not 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 clearly states the tool's purpose: 'Get detailed metadata for a book.' It specifies the verb ('Get') and resource ('detailed metadata for a book'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from siblings like 'get_book_content' or 'search_books', which might also retrieve book information but with different scopes or methods.
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. With siblings like 'get_book_content' (likely for content retrieval), 'search_books' (likely for searching), and 'get_field_values' (possibly for specific fields), there's no indication of when this tool is preferred, such as for comprehensive metadata versus filtered results or other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get unique values and their counts for a specific metadata field. Useful for building facets (e.g. list of all tags or authors). field_name: The name of the field. book_ids: Optional list of book IDs to restrict the search to. value_filter: Optional regex to filter values. limit: Max number of values to return (default 50). offset: Offset for pagination.
| Name | Required | Description | Default |
|---|---|---|---|
| field_name | No | ||
| book_ids | No | ||
| value_filter | No | ||
| limit | No | ||
| offset | No | ||
| library_name | No |
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. It describes the core functionality well but doesn't mention important behavioral aspects like whether this is a read-only operation, potential performance implications for large datasets, or what happens with invalid field names. The description adds value by explaining the facet-building use case but misses key operational details.
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 perfectly structured - a clear purpose statement followed by parameter explanations. Every sentence earns its place, with no wasted words. The front-loaded purpose statement immediately communicates the tool's function, followed by essential parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, no annotations, and no output schema, the description does a good job with parameters but lacks information about return format, error conditions, or performance characteristics. It's complete enough for basic understanding but misses important contextual details an agent would need for robust implementation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by providing clear semantic explanations for all 6 parameters. Each parameter is described with its purpose and constraints (e.g., 'Optional list of book IDs to restrict the search to', 'Optional regex to filter values', 'Max number of values to return (default 50)'), adding significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('unique values and their counts for a specific metadata field'), distinguishing it from siblings like search or content retrieval tools. It explicitly mentions the use case for 'building facets' which helps differentiate its analytical function from data-fetching 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 clear context for when to use this tool ('Useful for building facets'), but doesn't explicitly state when not to use it or name specific alternatives among the sibling tools. It implies usage for metadata analysis rather than content retrieval, but lacks explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the schema of the library, including standard and custom columns. Useful for understanding available metadata fields for search and update.
| Name | Required | Description | Default |
|---|---|---|---|
| library_name | No |
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 mentions the tool is 'useful for understanding available metadata fields,' which implies a read-only, informational operation, but doesn't explicitly state behavioral traits like whether it requires authentication, has rate limits, returns structured data, or handles errors. For a tool with no annotations, this leaves significant gaps in understanding how it behaves.
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 appropriately sized and front-loaded: the first sentence states the core purpose, and the second adds practical context without redundancy. Both sentences earn their place by providing essential information efficiently, with zero waste.
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 low complexity (1 optional parameter, no output schema, no annotations), the description is somewhat complete but has gaps. It explains what the tool does and its utility, but without annotations or output schema, it should ideally cover more behavioral aspects (e.g., return format, error handling). The description is adequate for basic understanding but could be more comprehensive for a tool that might return complex schema data.
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 1 parameter with 0% description coverage, and the tool description doesn't mention any parameters. Since schema_description_coverage is low (<50%), the description should compensate but doesn't add any parameter information. However, with 0 parameters effectively (since 'library_name' has a default of null and is not required), the baseline is 4, but the description doesn't clarify the optionality or purpose of 'library_name', so it's scored lower at 3 for missing this nuance.
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 purpose: 'Get the schema of the library, including standard and custom columns.' This specifies the verb ('Get') and resource ('schema of the library') with additional detail about content ('standard and custom columns'). However, it doesn't explicitly differentiate this from sibling tools like 'get_field_values' or 'search_books', which might also involve library metadata.
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 implied usage guidance: 'Useful for understanding available metadata fields for search and update.' This suggests when to use it (to understand metadata for search/update operations) but doesn't explicitly state when not to use it or name alternatives among sibling tools. For example, it doesn't clarify if this should be used instead of 'get_field_values' for schema information.
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 book. Returns a list of hits with text snippets. hit_limit: Max number of hits to return (default 10). offset: Offset for pagination of hits.
| Name | Required | Description | Default |
|---|---|---|---|
| book_id | Yes | ||
| query | Yes | ||
| hit_limit | No | ||
| offset | No | ||
| library_name | No |
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. It mentions the return format ('list of hits with text snippets') and pagination behavior via offset, but lacks critical details like authentication requirements, rate limits, error conditions, or whether this is a read-only operation. For a search tool with 5 parameters, this is insufficient.
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 appropriately concise with three sentences that each serve a purpose: stating the core functionality, describing the return format, and explaining two parameters. However, the structure could be improved by front-loading the most critical information about all parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters, 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'library_name' does, doesn't clarify the relationship between 'book_id' and 'library_name', and provides minimal behavioral context. The agent would struggle to use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate but only partially does so. It explains 'hit_limit' and 'offset' parameters, but doesn't mention 'book_id', 'query', or 'library_name' at all. The three undocumented parameters remain unexplained, leaving significant gaps in understanding.
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 searches for text within a book and returns hits with snippets, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'search_books' or 'fts_search', which likely have overlapping functionality.
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 provided on when to use this tool versus alternatives like 'search_books' or 'fts_search'. The description only states what the tool does, not when it's appropriate or what distinguishes it from similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for books matching a metadata query. If query is not provided, lists all books. Supports pagination by the limit and offset parameters: limit determines how many results to show (default 50), offset sets the starting point for the results (default 0). fields: Optional list of metadata fields to return (e.g. ["title", "rating", "#genre"]). Returns all if not provided. text_field_limit: Optional max length for text fields in the returned metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| limit | No | ||
| offset | No | ||
| fields | No | ||
| text_field_limit | No | ||
| library_name | No |
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. It adds useful context about pagination behavior (limit/offset defaults), fallback behavior when query is missing, and metadata field filtering. However, it doesn't cover important aspects like rate limits, authentication needs, error conditions, or what the response structure looks like (e.g., format of returned results).
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 appropriately sized and front-loaded, starting with the core purpose. Each sentence adds specific value: query behavior, pagination details, field selection, and text field limits. There's minimal redundancy, though the structure could be slightly more organized with bullet points or clearer separation of concepts.
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 complexity (6 parameters, no annotations, no output schema), the description provides adequate coverage for most parameters and basic behavior. However, it lacks details about the response format, error handling, and the undocumented 'library_name' parameter. For a search tool with multiple siblings, more guidance on tool selection would improve 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?
With 0% schema description coverage for 6 parameters, the description compensates well by explaining 5 out of 6 parameters: query (with fallback behavior), limit and offset (pagination with defaults), fields (optional metadata selection), and text_field_limit (max length for text fields). Only 'library_name' is undocumented, leaving a minor gap in coverage.
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 purpose as 'Search for books matching a metadata query' with the verb 'search' and resource 'books', making it immediately understandable. It distinguishes from siblings like 'get_book_details' (specific book) and 'search_book_content' (content search), though it doesn't explicitly name these alternatives.
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 some usage context by stating 'If query is not provided, lists all books,' which helps understand the tool's behavior with missing parameters. However, it doesn't explicitly guide when to use this tool versus alternatives like 'fts_search' or 'search_book_content,' leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0fts_searchget_book_contentget_book_detailsget_field_valuesget_library_schemasearch_book_contentsearch_booksScored across 7 tools
Most tools have distinct purposes, but there is some overlap between 'fts_search' and 'search_book_content', which both search text within books, potentially causing confusion. However, their descriptions clarify that 'fts_search' is for full-text search across the library while 'search_book_content' is for searching within a specific book, which helps mitigate ambiguity.
All tool names follow a consistent snake_case pattern with clear verb_noun structures, such as 'get_book_details', 'search_books', and 'get_field_values'. This predictability makes it easy for agents to understand and use the tools without confusion.
With 7 tools, the server is well-scoped for managing a Calibre library, covering essential operations like searching, retrieving content, and metadata management. Each tool serves a clear purpose without being overly sparse or bloated.
The tool set provides strong coverage for reading and searching a Calibre library, including metadata, content, and schema operations. A minor gap exists in the lack of update or delete tools for books or metadata, but this is reasonable if the server is focused on querying rather than modification.
The media memory layer for AI agents and their humans. Your AI client gets 29 tools to search your collection, add items, update ratings, preview music, and find patterns across everything you've read, watched, and listened to.
Media memory for AI agents and their humans: books, movies, music, shows, anime, podcasts, games.
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.
