Brewers almanack
Brewers Almanack is a brewing knowledge MCP server providing AI assistants with comprehensive brewing data across beer styles, ingredients, off-flavours, water chemistry, recipes, and food pairings.
πΊ Search Beer Styles (
search_styles): Search 85 BJCP beer styles by name, category, or characteristics β returns vital statistics, overall impressions, typical ingredients, and commercial examples.πΏ Search Brewing Ingredients (
search_ingredients): Look up hops, malts, yeasts, and adjuncts by name, type, or characteristic β returns details like alpha acids, colour, attenuation, and flavour profiles.π¬ Diagnose Off-Flavours (
diagnose_off_flavour): Identify what went wrong from taste or aroma descriptions β returns the likely compound, root causes, prevention steps, detection threshold, and styles where the flavour may be acceptable.π§ Match Water Profiles (
match_water_profile): Find brewing water profiles by city name or beer style β returns mineral composition (Ca, Mg, Na, Cl, SO4, HCO3) and style recommendations.π Suggest Recipes (
suggest_recipe): Generate a complete beer recipe for a target style β returns grain bill, hop schedule, yeast selection, water profile, and process parameters (with configurable batch size in litres).π½οΈ Pairing Guide (
pairing_guide): Get beer and food pairing suggestions by beer style or dish name β returns matches with complement, contrast, and cleanse principles explained.
Ask your AI assistant about beer styles, diagnose off-flavours, build recipes, match water profiles, and pair food (all backed by real brewing data, not hallucinations).
6 tools. Zero config. Works with every MCP-compatible IDE.
Install
npx -y brewers-almanackNo API keys, no network dependencies. All brewing data is embedded.
Add to your IDE
claude mcp add brewers-almanack -- npx -y brewers-almanackAdd to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%/Claude/claude_desktop_config.json (Windows):
{
"mcpServers": {
"brewers-almanack": {
"command": "npx",
"args": ["-y", "brewers-almanack"]
}
}
}Add to .cursor/mcp.json:
{
"mcpServers": {
"brewers-almanack": {
"command": "npx",
"args": ["-y", "brewers-almanack"]
}
}
}Add to .vscode/mcp.json:
{
"servers": {
"brewers-almanack": {
"command": "npx",
"args": ["-y", "brewers-almanack"]
}
}
}Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"brewers-almanack": {
"command": "npx",
"args": ["-y", "brewers-almanack"]
}
}
}Add to settings.json:
{
"context_servers": {
"brewers-almanack": {
"command": {
"path": "npx",
"args": ["-y", "brewers-almanack"]
}
}
}
}Related MCP server: Aindreyway MCP Codex Keeper
Tools
Tool | Description |
| Search 85 BJCP beer styles by name, category, or characteristics. Returns vital statistics, overall impression, ingredients, and commercial examples. |
| Search hops, malts, yeasts, and adjuncts by name, type, or characteristic. Filter by category or search across all. |
| Identify off-flavours from taste or aroma descriptions. Returns the likely compound, causes, prevention steps, and styles where it may be acceptable. |
| Find brewing water profiles by city name or beer style. Returns mineral composition (Ca, Mg, Na, Cl, SO4, HCO3) and style recommendations. |
| Generate a recipe for a target beer style. Returns grain bill, hop schedule, yeast selection, water profile, and process parameters. |
| Beer and food pairing suggestions. Search by beer style or dish name. Returns matches with complement, contrast, and cleanse principles. |
Example Conversations
"What hops work in a Belgian Dubbel?"
Searches ingredients for hops that complement Belgian styles, returning varieties like Styrian Goldings and Saaz with alpha acid ranges, aromas, and substitutes.
"My beer tastes like butter, what went wrong?"
Diagnoses diacetyl: identifies the compound, explains causes (incomplete fermentation, premature racking), and gives prevention steps (diacetyl rest, healthy yeast pitch).
"Suggest a recipe for a West Coast IPA"
Builds a complete recipe: pale malt base with crystal malt, Centennial/Cascade hop schedule with dry hop additions, American ale yeast, and a Burton-style water profile.
"What food pairs well with a stout?"
Returns pairing suggestions (oysters, chocolate desserts, grilled meats) with principles explaining why each pairing works (complement, contrast, or cleanse).
Data Sources
Dataset | Records | Source | Licence / Basis |
Beer styles | 85 | MIT; BJCP attribution | |
Hops | 113 | MIT | |
Malts | 38 | Compiled from published maltster spec sheets | Factual data |
Yeasts | 33 | Compiled from published yeast lab spec sheets | Factual data |
Adjuncts | 21 | Compiled from brewing literature | Factual data |
Water profiles | 20 | Compiled from brewing literature | Factual data |
Off-flavours | 25 | Compiled from brewing science literature | Factual data |
Food pairings | 23 | Compiled from Cicerone curriculum and pairing guides | Factual data |
Roadmap
See ROADMAP.md for planned features: brewing calculators, recipe intelligence, BeerXML/BeerJSON integration, and a brewing journal.
Contributing
Contributions are welcome, especially data contributions. More hop varieties, yeast strains, regional water profiles, and food pairings make the server more useful for everyone.
git clone https://github.com/gregario/brewers-almanack.git
cd brewers-almanack
npm install
npm run build
npm test # 73 testsRunning locally
claude mcp add brewers-almanack-dev -- node /path/to/brewers-almanack/dist/index.jsSee ROADMAP.md for areas where contributions are most needed.
Licence
Available Tools
11 toolscalculate_ibuCalculate IBUA
Calculate International Bitterness Units using the Tinseth formula. Accepts batch volume, original gravity, and a list of hop additions with weight, alpha acid percentage, and boil time.
| Name | Required | Description | Default |
|---|---|---|---|
| hop_additions | Yes | List of hop additions | |
| original_gravity | Yes | Original gravity (e.g. 1.065) | |
| batch_volume_litres | Yes | Final batch volume in litres |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavior. It mentions the formula but does not explain limitations (e.g., does it handle dry hops? What is the output format?). Lacks transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundant words. Front-loaded with purpose and key inputs. Efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a calculation tool with clear inputs and no output schema. However, does not explain return value or behavior for edge cases (e.g., zero boil time). Missing some context but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so each parameter is described well in the schema. The description adds context (Tinseth formula) but does not elaborate on parameter specifics beyond what schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it calculates IBU using Tinseth formula and lists required inputs (batch volume, OG, hop additions). Distinct from sibling tools which involve water, faults, pairings, etc.
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?
Implied usage for IBU calculation, but no explicit guidance on when to choose this over alternatives, or when not to use it. Siblings are distinct, so some implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
calculate_water_additionsCalculate Water AdditionsB
Calculate mineral salt additions needed to adjust brewing water from a source profile to a target profile. Supports named profiles or custom ion values.
| Name | Required | Description | Default |
|---|---|---|---|
| source_sodium | No | Source sodium (ppm) | |
| target_sodium | No | Target sodium (ppm) | |
| volume_litres | Yes | Water volume in litres | |
| source_calcium | No | Source calcium (ppm) | |
| source_profile | No | Named source water profile (e.g. 'Reverse Osmosis', 'Dublin') | |
| source_sulfate | No | Source sulfate (ppm) | |
| target_calcium | No | Target calcium (ppm) | |
| target_profile | No | Named target water profile (e.g. 'Burton-on-Trent', 'Pilsen') | |
| target_sulfate | No | Target sulfate (ppm) | |
| source_chloride | No | Source chloride (ppm) | |
| target_chloride | No | Target chloride (ppm) | |
| source_magnesium | No | Source magnesium (ppm) | |
| target_magnesium | No | Target magnesium (ppm) | |
| source_bicarbonate | No | Source bicarbonate (ppm) | |
| target_bicarbonate | No | Target bicarbonate (ppm) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It mentions support for named profiles or custom ion values, but does not describe the output format, return values, or any constraints like the required volume parameter. This leaves significant ambiguity about tool 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?
Two concise sentences: first states purpose, second adds key capability. No wasted words, front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 15 parameters and no output schema, the description is minimal. It does not explain how to combine named profiles with custom values, does not mention that volume_litres is required, and provides no examples. The tool is complex but the description is not sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, baseline 3. The description adds value by clarifying that parameters can be supplied via named profiles or custom ion values, which is not obvious from the schema alone. This helps the agent understand how to use the many parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Calculate mineral salt additions needed to adjust brewing water from a source profile to a target profile.' This is a specific verb and resource, but it does not explicitly distinguish from the sibling tool 'match_water_profile'. However, the focus on calculating additions is clear.
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 usage when adjusting water profiles ('needed to adjust'), but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives like 'match_water_profile'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_geb_stockCheck GEB StockA
Check GetErBrewed.com custom kit builder inventory for ingredient availability and pricing. Data is updated weekly. If an item is out of stock, suggests substitutions.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Ingredient to search for (e.g. 'Citra', 'Maris Otter', 'US-05') | |
| category | No | Filter by category (e.g. 'T90 Hops', 'Base Malt', 'Dried Yeast') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior fully. It mentions weekly data updates and substitution suggestions, but lacks details on pricing output, authentication needs, rate limits, or error handling. The description does not specify the response format or what happens when an ingredient is not found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences. The first sentence immediately states the purpose, and the second adds key details about data freshness and substitution behavior. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with two parameters and no output schema, the description covers the basic purpose and behavior. However, it does not describe the output format or what happens when a query returns no results. Given the lack of output schema, more detail on return structure 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?
Schema coverage is 100%, so baseline is 3. The description adds context about ingredient availability and pricing but does not add semantic meaning beyond the schema descriptions for query and category. Parameters are well-documented in schema, so description adds minimal extra value.
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 'Check' and the resource 'GetErBrewed.com custom kit builder inventory for ingredient availability and pricing.' It distinguishes from sibling tools like search_ingredients by specifying the website and including stock checking and substitution suggestions.
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 usage for checking stock and getting substitutions but does not explicitly state when to use this tool versus alternatives like suggest_substitution or search_ingredients. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
diagnose_off_flavourDiagnose Off-FlavourA
Diagnose beer off-flavours from taste or aroma descriptions. Returns the likely compound, causes, prevention steps, detection threshold, and styles where it may be acceptable.
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | Taste or aroma description of the off-flavour |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explicitly lists what is returned (likely compound, causes, prevention, threshold, acceptable styles), providing good transparency about behavior and output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: one for action, one for output. No wasted words; every sentence is informative and direct.
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 single-parameter tool with no output schema, the description is adequately completeβcovers purpose, input, and output. Missing any limitations or error handling, but not critical for this 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?
Schema description coverage is 100%, so the parameter is well-defined. The description adds value by explaining the output context, linking the input to specific return fields.
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 verb 'Diagnose' combined with 'beer off-flavours' is specific and clear. The tool's purpose is distinct from sibling tools like match_water_profile, pairing_guide, etc., which focus on different aspects of brewing.
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 explicit when-to-use or when-not-to-use guidance is provided. The description implies usage from taste/aroma descriptions but doesn't exclude vague inputs or offer alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
match_water_profileMatch Water ProfileA
Find brewing water profiles by city name or beer style. Returns mineral composition (Ca, Mg, Na, Cl, SO4, HCO3) and style recommendations.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | City name or beer style to find water profile for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description discloses the tool returns mineral composition and style recommendations. It implies a read-only lookup without side effects, which is sufficient for this type of tool.
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?
Single sentence efficiently conveys purpose, input, and output. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup with one parameter and no output schema, the description adequately explains functionality and return content. Could mention format or multiple results, but not essential.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one parameter clearly documented. The description reinforces that 'query' accepts city name or beer style, adding context beyond the schema by mentioning the output composition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it finds brewing water profiles by city or beer style, and returns mineral composition and style recommendations. Distinct from sibling tools which cover off-flavors, pairings, ingredients, styles, and recipes.
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?
Implicitly guides usage: when you need water profile information based on city or style. No exclusion criteria or alternatives mentioned, but context from sibling tools makes it clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pairing_guidePairing GuideA
Get beer and food pairing suggestions. Search by beer style or dish name. Returns pairing matches with complement, contrast, and cleanse principles.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Beer style or dish name to find pairings for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses that results include complement, contrast, and cleanse principles, but does not mention any side effects, permissions, or safety (though it's a read operation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose, no filler. Each sentence adds essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description is sufficient. It explains input, output, and the three pairing principles.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter description already stating 'Beer style or dish name'. The tool description adds little beyond that, though it mentions the three pairing principles not in the schema. Baseline of 3 applies due to high schema 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?
Clear verb 'get' with specific resource 'beer and food pairing suggestions'. Defines input types (beer style or dish name) and output (pairing matches with principles). Distinguishes from sibling tools like search_styles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description clearly states the tool's purpose for finding pairings, implying when to use it. However, it does not explicitly mention when not to use it or provide alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
review_recipeReview RecipeA
Review a beer recipe against BJCP style guidelines. Checks OG, FG, IBU, SRM, and ABV against the style's vital statistics and returns a scorecard.
| Name | Required | Description | Default |
|---|---|---|---|
| fg | Yes | Final gravity (e.g. 1.012) | |
| og | Yes | Original gravity (e.g. 1.065) | |
| abv | Yes | Alcohol by volume percentage | |
| ibu | Yes | International Bitterness Units | |
| srm | Yes | Standard Reference Method (colour) | |
| style | Yes | Target beer style to check against (e.g. 'American IPA', 'Black IPA') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the tool checks and returns a scorecard, suggesting a read-only operation. However, it does not disclose whether it requires specific permissions, data sources, or any limitations (e.g., only predefined styles).
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 core action and details. Every word contributes value with no 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 the schema covers all parameters and the tool has no output schema, the description adequately explains input and output format. It could optionally mention the scorecard's structure but is complete enough for a review tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with each parameter described. The description lists the parameters but adds no additional meaning beyond what the schema provides. Baseline 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 it reviews a beer recipe against BJCP style guidelines, specifying the exact metrics (OG, FG, IBU, SRM, ABV) and the output (scorecard). This distinguishes it from siblings like search_styles or calculate_ibu.
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 using this tool when you have a recipe and want to evaluate it against a style. It lists the checks performed and the result. However, no explicit when-not-to-use or alternative tools are mentioned, but the context among siblings provides adequate clarity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_ingredientsSearch Brewing IngredientsA
Search brewing ingredients (hops, malts, yeasts, adjuncts) by name, type, or characteristic. Returns detailed properties like alpha acids, colour, attenuation, and flavour profiles.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Ingredient name, type, or characteristic to search for | |
| category | No | Category of ingredient to search within | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description details that the tool returns properties like alpha acids and colour, implying a read operation, but does not explicitly state it is non-destructive or mention rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words, and front-loaded with the core action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, parameters, and key output details. Lacks mention of pagination or result count, but is sufficient for a straightforward search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both parameters. The description adds examples of return properties but mostly restates schema info, so baseline 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 explicitly states the tool searches brewing ingredients, listing specific subtypes (hops, malts, etc.), which clearly distinguishes it from siblings like search_styles.
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 indicates it is for searching ingredients by name/type/characteristic, providing context for when to use it, but it lacks explicit exclusions or direct comparisons to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_stylesSearch Beer StylesA
Search BJCP beer styles by name, category, or characteristics. Returns vital statistics, overall impression, typical ingredients, and commercial examples.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Style name, category, or characteristic to search for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose important behavioral traits such as whether the search is case-sensitive, supports partial matches, or has any rate limits. It only states what it returns, not 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 concise with two sentences, front-loading the purpose and then listing the returns. Every sentence adds value without unnecessary detail.
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 search tool with one parameter and no output schema, the description adequately covers the input and output. It lacks details on edge cases (e.g., no results), but is sufficient for typical 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?
The schema provides a description for the query parameter, and the tool description reiterates that it can be a name, category, or characteristic. Since schema coverage is 100%, the description adds minimal extra value beyond confirming the search criteria.
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 ('Search BJCP beer styles') and the criteria (name, category, characteristics), and lists the returned information. It is distinct from sibling tools which focus on off-flavors, water profiles, pairings, ingredients, and recipes.
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 usage for looking up beer styles, but does not explicitly state when to use this tool versus alternatives like search_ingredients or pairing_guide. No exclusions or context cues are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
suggest_recipeSuggest RecipeA
Suggest a beer recipe for a target style. Returns grain bill, hop schedule, yeast selection, and process parameters.
| Name | Required | Description | Default |
|---|---|---|---|
| style | Yes | Target beer style for the recipe | |
| batch_size_litres | No | Batch size in litres |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool 'suggests' (non-mutating) and lists outputs, but lacks details on prerequisites, side effects, or deterministic behavior. Adequate but not exceptional.
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?
Single sentence, front-loaded with purpose, no redundant words. Efficiently communicates the tool's function and outputs.
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 tool with 2 parameters and no output schema, the description covers the returned components well. It could mention the default for batch_size_litres, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with both parameters described. The description does not add additional meaning beyond the schema; it merely restates 'target style' and 'batch size.' Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Suggest a beer recipe for a target style.' It specifies the outputs (grain bill, hop schedule, etc.) and distinguishes it from sibling tools like 'search_styles' or 'search_ingredients' which serve different purposes.
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 usage (when you want a recipe suggestion) but does not explicitly state when not to use it or provide alternative tools. Given siblings are distinct, an agent may infer correctly, but no explicit guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
suggest_substitutionSuggest Ingredient SubstitutionA
Find substitutes for a brewing ingredient (hop, malt, or yeast). Suggests alternatives with similar characteristics, showing key properties for comparison.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | Role in recipe for context (e.g. 'bittering', 'aroma', 'base', 'specialty') | |
| style | No | Target beer style for context (e.g. 'American IPA', 'Stout') | |
| ingredient | Yes | Name of the ingredient to find substitutes for (e.g. 'Citra', 'Maris Otter', 'US-05') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the tool's basic behavior (finding substitutes, showing properties) but lacks deeper behavioral details such as data sources, number of alternatives, or any limitations. No contradictions with absent annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action, 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?
The description covers the basic purpose but lacks detail on output format (e.g., what key properties are shown). With no output schema, more completeness would be beneficial.
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 baseline is 3. The description adds some context (ingredient types) but does not significantly enhance parameter understanding beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds substitutes for brewing ingredients (hop, malt, or yeast) and suggests alternatives with similar characteristics, distinguishing it from siblings like search_ingredients or suggest_recipe.
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 use for substitution needs but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool targets a distinct aspect of brewing: calculations, recipe management, ingredient lookup, style guidelines, off-flavor diagnosis, food pairing, and stock checking. No two tools have overlapping purposes.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., calculate_ibu, search_styles, suggest_recipe), making it easy to infer each tool's function.
With 11 tools, the server covers the core needs of a brewing almanac without being overwhelming. Each tool has a clear role and justifies its inclusion.
The tool set covers major brewing domains (recipe creation, evaluation, ingredient info, water chemistry, troubleshooting, pairing), but lacks tools for mash pH calculations or fermentation management, which are minor gaps for a general almanac.
Maintenance
Related MCP Connectors
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
MCP server exposing Kettle Logic insight articles & industry guidance as tools + resources.
Hosted MCP server for live public-data APIs and Skills for AI agents.
Official remote MCP server for Archivist AI TTRPG campaign memory: characters, sessions, and more.
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that enables AI-powered recipe generation and transformation using natural language, supporting dietary restrictions, allergies, and nutritional goals.222MIT
- AlicenseAqualityDmaintenanceAn intelligent MCP server that serves as a guardian of development knowledge, providing AI assistants with curated access to latest documentation and best practices.4666MIT
- AlicenseNot gradedqualityBmaintenanceA local MCP server that gives AI coding assistants retrieval access to your personal knowledge base of books, standards, and docs, grounding their answers in sources you trust.MIT
- AlicenseNot gradedqualityBmaintenanceMCP server for BrewPage, a free no-signup hosting service. Lets AI agents publish HTML, Markdown, JSON, files, or a full multi-file static site and get a public URL instantly via a REST API.2Apache 2.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/gregario/brewers-almanack'
If you have feedback or need assistance with the MCP directory API, please join our Discord server