Skip to main content
Glama
valetdotdev

recipe-mcp

by valetdotdev
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

Recipe MCP Server

An MCP (Model Context Protocol) server that provides AI-powered recipe generation and transformation tools. Generate personalized recipes based on dietary preferences, transform existing recipes to meet nutritional goals, and more.

Features

  • 🍳 Generate Recipes - Create custom recipes from natural language descriptions

  • 🔄 Transform Recipes - Modify existing recipes (make vegan, adjust calories, etc.)

  • 🥗 Dietary Support - Handle allergies, restrictions, and food preferences

  • 📊 Nutrition Goals - Target specific calorie and protein requirements

  • 🆓 Open Access - No API key required (rate limited)

Related MCP server: Recipe Finder AI MCP

Installation

For Claude Desktop

  1. Install the MCP server:

npm install -g @cookwith/recipe-mcp

  1. Add to your Claude Desktop configuration:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

    • Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "recipe-mcp": {
      "command": "npx",
      "args": ["@cookwith/recipe-mcp"],
      "env": {
        "COOKWITH_API_URL": "https://cookwith.co"
      }
    }
  }
}

  1. Restart Claude Desktop

For Development

# Clone the repository
git clone https://github.com/cookwith/recipe-mcp.git
cd recipe-mcp

# Install dependencies
npm install

# Run in development mode
npm run dev

Usage Examples

Generate a Recipe

// In Claude Desktop, you can say:
"Generate a healthy Mediterranean pasta dish with lots of vegetables"

// The tool will be called with:
{
  "prompt": "A healthy Mediterranean pasta dish with lots of vegetables",
  "dietaryRestrictions": ["vegetarian"],
  "calories": "450",
  "servings": 4
}

Transform a Recipe

// After generating or providing a recipe:
"Make this recipe vegan and reduce the calories by 200"

// The tool will be called with:
{
  "recipe": { /* existing recipe object */ },
  "instructions": "Make this vegan and reduce calories by 200",
  "calories": "350"
}

Tools

generate_recipe

Generate a new recipe based on natural language instructions.

Parameters:

  • prompt (string, required) - Natural language description

  • dietaryRestrictions (string[], optional) - e.g., ["vegetarian", "gluten-free"]

  • allergies (string[], optional) - Ingredients to avoid

  • dislikes (string[], optional) - Foods to exclude

  • calories (string, optional) - Target calories per serving

  • protein (string, optional) - Target protein in grams

  • servings (number, optional) - Number of servings (1-20, default: 4)

transform_recipe

Transform an existing recipe based on instructions.

Parameters:

  • recipe (object, required) - The recipe to transform

  • instructions (string, required) - How to modify the recipe

  • calories (string, optional) - New target calories

  • protein (string, optional) - New target protein

  • servings (number, optional) - New number of servings

Rate Limits

The public API has the following rate limits:

  • Anonymous Access: 20 requests per hour per IP address

  • No authentication required

  • Retry-After header provided when limit exceeded

Recipe Object Format

interface Recipe {
  title: string;
  description: string;
  ingredients: string[];      // e.g., ["2 cups flour", "1 tsp salt"]
  instructions: string[];      // Step-by-step instructions
  servings: number;
  prepTime?: number;          // Minutes
  cookTime?: number;          // Minutes
  totalTime?: number;         // Minutes
  cuisine?: string;           // e.g., "Italian", "Mexican"
  course?: string;            // e.g., "main", "dessert"
  difficulty?: string;        // e.g., "easy", "medium", "hard"
  calories?: number;          // Per serving
  protein?: number;           // Grams per serving
  carbs?: number;            // Grams per serving
  fat?: number;              // Grams per serving
  fiber?: number;            // Grams per serving
  sugar?: number;            // Grams per serving
  sodium?: number;           // Milligrams per serving
}

Configuration

Environment Variables

Custom API Endpoint

For development or self-hosted instances:

export COOKWITH_API_URL=http://localhost:3000
npx @cookwith/recipe-mcp

Examples

Basic Recipe Generation

// Request
{
  "prompt": "Quick and easy chicken stir-fry"
}

// Response
{
  "title": "Quick Chicken Stir-Fry",
  "description": "A delicious and speedy chicken stir-fry...",
  "ingredients": [
    "2 chicken breasts, sliced",
    "2 cups mixed vegetables",
    "3 tbsp soy sauce",
    // ...
  ],
  "instructions": [
    "Heat oil in a large wok or skillet",
    "Add chicken and cook until golden",
    // ...
  ],
  "servings": 4,
  "prepTime": 10,
  "cookTime": 15,
  "calories": 320,
  "protein": 28
}

Recipe Transformation

// Request
{
  "recipe": {
    "title": "Classic Beef Lasagna",
    "ingredients": ["1 lb ground beef", "ricotta cheese", ...],
    // ... full recipe
  },
  "instructions": "Make this vegetarian and lower in calories"
}

// Response
{
  "title": "Vegetarian Light Lasagna",
  "description": "A healthier vegetarian version...",
  "ingredients": [
    "2 cups chopped mushrooms",
    "1 cup low-fat ricotta",
    // ... transformed ingredients
  ],
  // ... rest of transformed recipe
}

Troubleshooting

Rate Limit Errors

If you receive a 429 error, you've exceeded the rate limit. Wait for the time specified in the retryAfter field before making another request.

Connection Issues

Ensure your internet connection is stable and the API endpoint is accessible.

Invalid Parameters

Check that your parameters match the expected format and constraints (e.g., servings between 1-20).

Contributing

Contributions are welcome! Please see our Contributing Guide for details.

License

MIT License - see LICENSE file for details.

Support

Powered By

Available Tools

2 tools
generate_recipeA

Generate a new recipe based on natural language instructions and dietary preferences

ParametersJSON Schema
NameRequiredDescriptionDefault
promptYesNatural language description of the desired recipe
proteinNoTarget protein in grams per serving (e.g., '30')
caloriesNoTarget calories per serving (e.g., '500')
dislikesNoFoods the user doesn't like
servingsNoNumber of servings (1-20, default: 4)
allergiesNoIngredients to avoid due to allergies
dietaryRestrictionsNoDietary restrictions (e.g., vegetarian, vegan, gluten-free)

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully disclose behavioral traits. It only states the tool generates a recipe, without mentioning return format, dependencies, side effects, or error conditions. This is a significant transparency gap.

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 concise sentence that clearly states the tool's function. No wasted 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?

With no output schema and no annotations, the description should provide more context about return values and limitations. It only states the tool generates a recipe, leaving the agent unaware of output structure and other behavioral details. The sibling tool adds a need for distinguishing guidance, which is absent.

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 schema provides complete descriptions for all 7 parameters, so the description doesn't need to explain them. The description's mention of 'natural language instructions and dietary preferences' adds a high-level summary but no additional semantics beyond the schema.

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

Purpose5/5

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

The description clearly states the tool generates a new recipe, using a specific verb and resource. It distinguishes from the sibling 'transform_recipe' by implying creation rather than modification.

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

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly indicates the tool is for generating new recipes from user preferences, providing clear usage context. It does not explicitly mention alternatives or exclusions, but the sibling name 'transform_recipe' helps distinguish, so no explicit guidance is required.

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

transform_recipeB

Transform an existing recipe based on instructions (e.g., make it vegan, adjust calories, change servings)

ParametersJSON Schema
NameRequiredDescriptionDefault
recipeYesThe recipe to transform
proteinNoNew target protein in grams per serving
caloriesNoNew target calories per serving
servingsNoNew number of servings
instructionsYesInstructions for how to transform the recipe

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It states 'transform' but does not clarify whether the original recipe is modified, a new one is returned, or how unspecified fields are handled. This is a significant gap.

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 sentence, front-loaded with the core action, and includes useful examples without unnecessary detail.

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?

With a complex nested recipe schema and no output schema, the description should explain what the transformed result looks like or whether original fields are preserved. The absence of return behavior leaves the tool incomplete.

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 coverage is 100%, so descriptions for all parameters are already present. The tool description adds a few examples but 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.

Purpose5/5

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

The description clearly states the tool transforms an existing recipe using instructions, with concrete examples (vegan, calories, servings). This distinguishes it from the sibling tool generate_recipe, which creates new recipes.

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

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use when you have an existing recipe to modify, and examples show typical scenarios. However, it does not explicitly mention when not to use it or compare against generate_recipe.

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. Dates show when Glama detected each change.

  1. 2 tool updatesv1.0.3
    • First observedgenerate_recipe
    • First observedtransform_recipe
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.6/5.0
Disambiguation5/5

generate_recipe creates a new recipe, while transform_recipe modifies an existing one. The semantic boundary is clear, with no overlap in purpose.

Naming Consistency5/5

Both tools follow a consistent verb_noun pattern: generate_recipe and transform_recipe. The verbs are distinct and the object is uniform.

Tool Count3/5

With only two tools, the server feels thin for a recipe domain. While the scope could be narrowly focused on generation, the count is borderline.

Completeness2/5

transform_recipe requires an existing recipe, but there is no tool to retrieve or list recipes. This is a significant gap that leaves agents unable to obtain the input needed for transformation.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • HowToCook-MCP Server

    worryzyy
    A
    license
    A
    quality
    D
    maintenance
    An MCP server that transforms AI assistants into personal chefs by providing recipe recommendations and meal planning features based on the HowToCook repository.
    5
    5,676
    766
    ISC

  • @mealmastery/mcp-server

    MealMasteryAI
    A
    license
    Not graded
    quality
    F
    maintenance
    MCP server for MealMastery AI meal planning that enables users to manage meal plans, recipes, and grocery lists through natural language conversation with AI agents like Claude.
    90
    MIT

Latest Blog Posts

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/valetdotdev/recipe-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server