Skip to main content
Glama
WhenYouAreStrange

goodbook-mcp

by WhenYouAreStrange
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript

Goodbook MCP Server

A modern Model Context Protocol (MCP) server that works exclusively with PDF files containing food service standards and preparation guidelines. Built following MCP best practices with robust input validation and error handling.

Overview

The Goodbook MCP server allows AI assistants to query and retrieve information from food service documentation, including:

  • Food preparation standards

  • Cooking guidelines and methods

  • Food safety information

  • Recipe standards

  • Hygiene and sanitation requirements

Related MCP server: MCP PDF Reader

Modern Architecture

This server follows current MCP best practices:

  • Zod input validation for all tool parameters

  • Proper STDIO usage with console.error for logging

  • Robust error handling with detailed error messages

  • Optimized tool definitions with automatic schema conversion

  • Comprehensive synonym support for Russian cooking terms

  • Clean separation of concerns between parsing, validation, and execution

Features

Available Tools

  1. search_food_standards: Search for specific food preparation standards, recipes, or cooking guidelines

  2. get_cooking_guidelines: Get cooking guidelines and standards for specific dishes or cooking methods

  3. list_sections: List all available sections in the food service standards document

  4. get_section_content: Get content from a specific section of the food standards document

  5. get_food_safety_info: Get food safety information and hygiene standards

  6. find_recipe_standards: Find standardized recipes and preparation methods for specific dishes

Installation

  1. Ensure you have Node.js 18+ installed

  2. Clone or download this project

  3. Install dependencies:

    npm install

  4. REQUIRED: Place your PDF file named menu.pdf in the root directory

Usage

Running the Server

npm start

The server will start and listen for MCP protocol messages via stdio.

Development Mode

npm run dev

This will start the server with auto-reload on file changes.

MCP Client Configuration

To use this server with an MCP-compatible client, add the following configuration:

Claude Desktop Configuration

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "goodbook": {
      "command": "node",
      "args": ["c:/указываем-полный-путь-к-файлу/mcp/src/index.js"],
      "env": {}
    }
  }
}

Other MCP Clients

Configure your MCP client to run:

node src/index.js

Tool Usage Examples

Search for Food Standards

Use the search_food_standards tool to find information about temperature requirements:
- query: "температура приготовления"
- section: (optional) specify a particular section

Get Cooking Guidelines

Use get_cooking_guidelines to get preparation methods:
- dish_type: "паста"
- section: (optional)

Food Safety Information

Use get_food_safety_info for safety guidelines:
- topic: "хранение мяса"

File Structure

goodbook-mcp-server/
├── src/
│   ├── index.js          # Main MCP server
│   ├── tools.js          # Tool implementations
│   └── pdf-parser.js     # PDF parsing logic
├── menu.pdf              # Source PDF document
├── package.json          # Project configuration
└── README.md            # This file

Requirements

  • Node.js 18.0.0 or higher

  • PDF document (menu.pdf) containing food service standards

  • MCP-compatible client (like Claude Desktop)

Error Handling

The server includes comprehensive error handling for:

  • PDF parsing failures

  • Missing sections

  • Invalid search queries

  • Tool execution errors

All errors are returned as structured responses to the MCP client.

Development

Adding New Tools

  1. Add tool definition to getToolDefinitions() in tools.js

  2. Implement handler method in GoodbookTools class

  3. Add case to handleTool() switch statement

Modifying PDF Parsing

Edit the PDFParser class in pdf-parser.js to:

  • Change section detection patterns

  • Modify content extraction logic

  • Add new search capabilities

License

MIT License

Support

For issues or questions, please check the error logs when running the server. The server outputs detailed logging information to help diagnose problems.

Available Tools

6 tools
find_recipe_standardsC

Find standardized recipes and preparation methods for specific dishes

ParametersJSON Schema
NameRequiredDescriptionDefault
dish_nameYesName of the dish to find recipe standards for
cuisine_typeNo

TDQS

C2.9/5.0
Behavior2/5

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 states the tool 'finds' information, implying a read-only operation, but doesn't address critical aspects like whether it requires authentication, has rate limits, returns structured data, or handles errors. This leaves significant gaps in understanding how the tool behaves.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple tool, though it could be slightly more informative without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

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 for a tool with two parameters. It doesn't explain what the tool returns (e.g., recipe details, preparation steps), how results are formatted, or any behavioral traits, making it inadequate for full contextual understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description implies parameters related to dishes but doesn't detail them beyond 'specific dishes'. With 50% schema description coverage (one parameter documented, one not), the description adds minimal value over the schema, which already documents 'dish_name' well. It doesn't compensate for the undocumented 'cuisine_type' parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

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 specific verbs ('find standardized recipes and preparation methods') and resources ('for specific dishes'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'search_food_standards' or 'get_cooking_guidelines', which might 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.

Usage Guidelines2/5

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. It doesn't mention any prerequisites, exclusions, or specific contexts for usage, leaving the agent to infer based on tool names alone without explicit direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_cooking_guidelinesC

Get cooking guidelines and standards for specific dishes or cooking methods

ParametersJSON Schema
NameRequiredDescriptionDefault
dish_typeYesType of dish or cooking method to get guidelines for
sectionNo

TDQS

C2.9/5.0
Behavior2/5

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 states the tool retrieves guidelines but offers no details on permissions, rate limits, response format, or potential side effects. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and clear, though it could benefit from additional structure or bullet points if more details were included.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (2 parameters, no output schema, no annotations), the description is incomplete. It lacks information on return values, error handling, and how parameters interact, making it insufficient for an agent to fully understand the tool's context and usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50%, with 'dish_type' documented but 'section' lacking a description. The tool description implies parameters relate to dishes or cooking methods, adding some context beyond the schema, but it doesn't fully compensate for the undocumented 'section' parameter or provide detailed semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

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 ('cooking guidelines and standards'), and specifies the target ('for specific dishes or cooking methods'). However, it doesn't explicitly differentiate from sibling tools like 'find_recipe_standards' or 'get_food_safety_info', which appear related but have distinct purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 sibling tools like 'find_recipe_standards' and 'get_food_safety_info' available, there is no indication of how this tool differs in context or when it should be preferred over others, leaving usage ambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_food_safety_infoC

Get food safety information and hygiene standards

ParametersJSON Schema
NameRequiredDescriptionDefault
topicYesSpecific food safety topic (temperature, storage, hygiene, etc.)

TDQS

C2.9/5.0
Behavior2/5

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 states the tool retrieves information but doesn't mention whether it's read-only, requires authentication, has rate limits, or what the output format might be. This is inadequate for a tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

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 insufficient. It doesn't explain what the tool returns, potential errors, or behavioral traits, leaving gaps in understanding for an AI agent despite the simple parameter schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'topic' parameter well-documented. The description adds no additional parameter details beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get') and the resource ('food safety information and hygiene standards'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'find_recipe_standards' or 'search_food_standards', which might overlap in domain.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 such as 'find_recipe_standards' or 'search_food_standards'. The description lacks context about specific use cases or exclusions, 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.

get_section_contentC

Get content from a specific section of the food standards document

ParametersJSON Schema
NameRequiredDescriptionDefault
section_nameYesName of the section to retrieve content from
limitYes

TDQS

C2.9/5.0
Behavior2/5

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 states the action ('Get content') but doesn't reveal any behavioral traits such as whether this is a read-only operation, potential rate limits, error conditions, or the format of returned content. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to parse quickly, though it could benefit from additional context for completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (2 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, usage guidelines, and parameter nuances, making it inadequate for an agent to fully understand how to invoke the tool correctly or interpret results, especially without an output schema to clarify return values.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50%, with 'section_name' documented but 'limit' lacking a description. The description adds minimal value beyond the schema by implying content retrieval but doesn't clarify parameter semantics, such as what 'section_name' refers to (e.g., exact match vs. substring) or how 'limit' affects results. It partially compensates but doesn't fully address the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Get') and resource ('content from a specific section of the food standards document'), making the purpose evident. However, it doesn't explicitly distinguish this tool from sibling tools like 'list_sections' or 'search_food_standards', which might also retrieve content or sections, leaving some ambiguity about its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. It doesn't mention prerequisites, such as needing to know the section name beforehand, or compare it to siblings like 'list_sections' for browsing sections or 'search_food_standards' for broader searches, leaving the agent without context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_sectionsB

List all available sections in the food service standards document

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior2/5

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 states the action ('List all available sections') but doesn't add context such as whether this is a read-only operation, if it requires authentication, rate limits, or what the output format might be. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that efficiently conveys the tool's purpose without any wasted words. It is front-loaded and appropriately sized for a simple tool, making it easy to parse and understand quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It states what the tool does but lacks behavioral context and usage guidelines, which are important even for simple tools to ensure correct invocation and integration with siblings.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose, which aligns with the baseline for zero parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('sections in the food service standards document'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_section_content' or 'search_food_standards', which might also involve sections, so it doesn't fully achieve sibling distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage based on the name alone, which is insufficient for optimal tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_food_standardsC

Search for specific food preparation standards, recipes, or cooking guidelines in the food service literature

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesSearch term or phrase to look for in the food standards document
sectionNo

TDQS

C2.9/5.0
Behavior2/5

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 states the tool 'searches' but doesn't describe what the search returns (e.g., list of results, full documents, snippets), whether it's paginated, if there are rate limits, or any authentication requirements. This leaves significant gaps for a search tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured (e.g., by explicitly mentioning parameters), but it avoids redundancy and wastes no words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations, no output schema, and incomplete parameter documentation (50% coverage), the description is insufficient. It doesn't explain what the tool returns, how results are formatted, or behavioral traits like search scope or limitations, making it inadequate for a search tool with multiple sibling alternatives.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (only 'query' has a description). The description mentions 'search for specific food preparation standards, recipes, or cooking guidelines', which adds context that the 'query' parameter should target these topics, but doesn't clarify the 'section' parameter (which has an empty description in the schema). This partially compensates but doesn't fully address the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

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 specific verbs ('search for') and resources ('food preparation standards, recipes, or cooking guidelines'), and identifies the source ('food service literature'). However, it doesn't explicitly differentiate from sibling tools like 'find_recipe_standards' or 'get_cooking_guidelines', which appear to have overlapping domains.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 sibling tools like 'find_recipe_standards', 'get_cooking_guidelines', and 'get_food_safety_info', there's no indication of how this tool differs in scope or context, leaving the agent to guess 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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 6 tool updates
    • First observedfind_recipe_standards
    • First observedget_cooking_guidelines
    • First observedget_food_safety_info
    • First observedget_section_content
    • First observedlist_sections
    • First observedsearch_food_standards
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.3/5.0

Scored across 6 tools

Disambiguation3/5

There is significant overlap between tools like find_recipe_standards, get_cooking_guidelines, and search_food_standards, which all seem to retrieve similar types of information about recipes, guidelines, and standards. However, the descriptions provide some differentiation, such as get_food_safety_info focusing on safety/hygiene and list_sections/get_section_content being more structural. The overlapping purposes could lead to confusion when selecting the right tool for a query.

Naming Consistency4/5

The tool names follow a consistent verb_noun pattern with snake_case throughout, such as find_recipe_standards and get_cooking_guidelines. All tools start with verbs like 'find', 'get', 'list', or 'search', which is predictable and readable. There are no deviations in naming conventions, making it easy to parse the tool set at a glance.

Tool Count5/5

With 6 tools, the count is well-scoped for a server focused on food service standards and recipes. This number is neither too thin nor too heavy, allowing for a focused set of operations without overwhelming an agent. Each tool appears to serve a distinct purpose within the domain, making the count appropriate for the server's apparent scope.

Completeness4/5

The tool set covers core operations for accessing food standards, recipes, safety info, and document structure, providing good coverage for retrieval and search within the domain. However, there are minor gaps, such as no tools for updating or managing standards (e.g., create or modify operations), which might limit agents in more dynamic workflows. Overall, it supports essential querying tasks effectively.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • PDF Reader MCP Server

    pablontiv
    F
    license
    A
    quality
    Not graded
    maintenance
    A Model Context Protocol server that extracts and processes content from PDF documents, providing text extraction, metadata retrieval, page-level processing, and PDF validation capabilities.
    4
    1
    -

  • MCP PDF Reader

    rturv
    A
    license
    A
    quality
    C
    maintenance
    A Model Context Protocol server that enables the extraction of text, metadata, and embedded images from PDF files. It provides tools for searching text with context, reading specific pages, and counting total pages within a document.
    7
    19 npm
    1
    MIT

  • @shuji-bonji/pdf-spec-mcp

    shuji-bonji
    A
    license
    A
    quality
    B
    maintenance
    An MCP (Model Context Protocol) server that provides structured access to ISO 32000 (PDF) specification documents. Enables LLMs to navigate, search, and analyze PDF specifications through well-defined tools.
    8
    34 npm
    2
    MIT

  • PDF MCP Server

    EricBoix
    F
    license
    Not graded
    quality
    D
    maintenance
    An MCP server that exposes PDF files as resources, page by page, over Streamable HTTP.
    -