# Recipe Scaler MCP > Recipe Scaler instantly adjusts ingredient quantities for any number of servings. This MCP handles complex culinary math, ensuring proportions stay perfect while formatting measurements into usable kitchen units like '1 tbsp + 1 tsp'. Stop working with messy decimals and start cooking with accuracy. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** recipe, scaling, culinary, precision, kitchen, ingredients ## Description Baking or meal prep often means adjusting recipes on the fly. The Recipe Scaler connects your agent to a precision ingredient scaling engine built for kitchens. When you change the number of servings, this MCP ensures every proportion stays perfect. It handles all the difficult math behind recipe adjustment—from calculating massive changes in flour weight to figuring out how much sugar is needed if you go from two people to ten. The process automatically determines appropriate rounding increments for different units, making sure your measurements are accurate and practical for real-world cooking. Finally, it converts those raw decimal numbers into clear instructions, like '1 cup minus 2 teaspoons,' so you don't have to guess what that number means in the kitchen. You can trust this MCP to maintain the integrity of every recipe, giving you dependable results right from your Vinkius catalog connection. ## Tools ### format_culinary_units Converts raw decimal quantities into simple strings that are easy to measure in a kitchen setting. ### resolve_measurement_precision Calculates the necessary rounding increment for any specific unit, like grams or fluid ounces. ### scale_ingredients Adjusts every ingredient in a recipe accurately based on changes to the serving size. ## Prompt Examples **Prompt:** ``` Scale this recipe for 10 people: 2 servings, ingredients: [{name: 'flour', quantity: 500, unit: 'g'}, {name: 'sugar', quantity: 1, unit: 'cup'}] ``` **Response:** ``` Scaled ingredients for 10 servings: [{name: 'flour', quantity: 2500, unit: 'g'}, {name: 'sugar', quantity: 5, unit: 'cup'}] ``` **Prompt:** ``` How much sugar do I need if I scale a recipe from 2 to 3 servings, where the original amount was 1.5 tablespoons? ``` **Response:** ``` You will need 2.25 tablespoons of sugar. ``` **Prompt:** ``` Convert 0.75 tablespoons to a more practical measurement. ``` **Response:** ``` 0.75 tablespoons is equivalent to 2.25 teaspoons. ``` ## Capabilities ### Scale recipes by servings Adjusts all ingredient quantities correctly when changing the total number of people a recipe feeds. ### Determine unit precision Calculates the correct rounding increments for specific units (mass, volume) to keep measurements practical. ### Format cooking measurements Converts raw decimal numbers into clear, human-readable kitchen instructions. ## Use Cases ### Scaling for an event menu A catering manager needs to scale a signature bread dough recipe from 10 servings up to 300. They ask their agent to run the `scale_ingredients` tool, which returns all necessary ingredient weights and volumes perfectly scaled, saving hours of manual calculation. ### Adjusting for dietary constraints A baker needs to adapt a gluten-free recipe originally designed for 4 people down to just 1. They run the scaling tool, which not only reduces all ingredients but also ensures the measurements are easy enough to measure in a home kitchen. ### Standardizing test batches A food scientist must run a consistency trial on a sauce recipe that needs to be exactly 10x the original size. The MCP calculates the exact ingredient weights, ensuring the ratios are mathematically perfect for testing. ### Converting bulk ingredients You have raw measurements and need them converted into precise volume units. You ask your agent to run `format_culinary_units` on a decimal value (like 0.75 tbsp), getting back '2.25 teaspoons' instantly. ## Benefits - Stop guessing measurements. The system handles complex math so you don't end up with unusable decimals or fractions that are hard to measure accurately. - Maintain perfect proportions across huge batch sizes. Using the `scale_ingredients` tool, changing a recipe from 2 servings to 50 doesn't compromise flavor or structure. - Get crystal-clear instructions immediately. Instead of '1.37 tbsp,' you get readable directions like '1 tbsp + 1 tsp' thanks to unit formatting. - The system automatically handles precision using `resolve_measurement_precision`. It knows when to round and how, preventing mathematical errors that ruin a batch. - Save time in the kitchen. You eliminate the manual step of checking multiple conversion charts or doing complex mental math while you prep. ## How It Works The bottom line is: you input a recipe and a serving change; the system outputs perfectly measured, usable ingredients. 1. You provide the original recipe ingredients and specify the new number of servings you need. 2. The MCP engine first determines the correct rounding for each unit, then uses that data to scale all ingredient quantities proportionally. 3. Finally, it formats these scaled numbers into easy-to-measure culinary instructions, ready for your use. ## Frequently Asked Questions **How does Recipe Scaler handle ingredient scaling?** It uses the `scale_ingredients` tool to adjust every item in your list proportionally. You simply tell it the original recipe and the new number of servings, and it recalculates everything automatically. **What if my unit is grams? Does Recipe Scaler work with mass?** Yes, it does. The MCP uses `resolve_measurement_precision` to make sure that even weight measurements are rounded correctly and remain practical for kitchen use. **Can I convert a decimal measure using the Recipe Scaler MCP?** Absolutely. If you have a raw number like 0.75 tablespoons, the formatting tool converts it into simple measures like '2 teaspoons,' making it ready to use. **Does the Recipe Scaler need original serving info?** Yes, providing the starting serving count helps the MCP calculate ratios correctly. It ensures that when you scale up or down, the proportions stay intact and consistent with your initial recipe design.