# Hydration Calculator MCP MCP > Hydration Calculator predicts dough texture and hydration percentage for bread, pizza, or focaccia. This MCP takes your flour and liquid weights—even when you mix in oils or eggs—to tell you exactly how wet your dough is; it then classifies the ideal baked good type and predicts its final texture. ## Overview - **Category:** baking - **Price:** Free - **Tags:** hydration, dough-science, baking, flour, texture ## Description Look, here's the thing: baking success always comes down to ratios. If you’re guessing at hydration levels, you risk a flop. You can’t just use simple water-to-flour percentages when you start adding ingredients like olive oil or eggs; those non-water liquids radically change the effective liquid weight. This MCP solves that problem by calculating your true dough consistency based on all component weights. It doesn't just give you a number, either; it cross-references that ratio with your flour and salt composition to tell you what kind of baked good—say, a rustic loaf or a flatbread—you’re actually making. The whole process is visible through Vinkius, letting your agent handle the complex calculations so you don't have to consult three different baking science flowcharts just to get started. ## Tools ### calculate_hydration Calculates the dough's hydration percentage from combined flour and liquid weights. ### classify_texture Predicts the final texture of the bake using the calculated hydration percentage and a profile name. ### determine_dough_type Identifies what kind of baked good is best suited for your flour and salt composition. ## Prompt Examples **Prompt:** ``` I have 100g of '00' flour, 75g of water, and 20g of olive oil. Can you calculate the hydration and predict the texture for a pizza? ``` **Response:** ``` First, using `calculate_hydration`, I found your effective liquid weight is 95g (75g water + 20g oil), giving you a hydration of [CALCULATED_HYDRATION]%. Next, running `determine_dough_type` confirmed this as 'Neapolitan Pizza Crust'. Finally, the `classify_texture` tool predicts your texture will be [PREDICTED_TEXTURE], with suitability notes: [SUITABILITY_NOTES]. ``` **Prompt:** ``` I'm making a rustic loaf. I used 450g of bread flour, 20g of salt, and 350g of water. What is the best texture profile? ``` **Response:** ``` Based on your ingredients (Bread Flour, 450g flour / 20g salt), `determine_dough_type` suggests a 'Rustic European Loaf' profile. The hydration calculated by `calculate_hydration` is [CALCULATED_HYDRATION]%. Therefore, the final classification from `classify_texture` is [PREDICTED_TEXTURE], suggesting you need to focus on [SUITABILITY_NOTES]. ``` **Prompt:** ``` I have a high hydration dough (85%) and confirmed the profile is Chapati. What should I expect? ``` **Response:** ``` Running `classify_texture` with 85% hydration and 'Chapati' profile, we get a result of [PREDICTED_TEXTURE] classification. The suitability notes advise that [SUITABILITY_NOTES]. This confirms the specific constraints needed for flatbreads. ``` ## Capabilities ### Determine Dough Wetness Calculates the accurate hydration percentage of a dough mixture using weights for all flours and liquids. ### Predict Final Texture Profile Classifies the expected texture by analyzing both the calculated hydration percentage and the intended baked good profile. ### Identify Suitable Dough Type Determines what kind of finished product, like a crust or loaf, is best suited for the specific blend of flour and salt you used. ## Use Cases ### Developing a new pizza line A food developer needs to know if their standard '00' flour/oil blend works for Neapolitan style. They prompt the agent with the weights, and the system runs `calculate_hydration` first; then it uses that output in `determine_dough_type` to confirm the pizza crust profile. ### Adjusting a rustic bread recipe A baker has 450g of flour and needs a specific texture, but they're unsure how much water is right. They use `calculate_hydration` to test different liquid amounts until the desired ratio is reached; then `classify_texture` confirms if it will yield that perfect 'rustic European loaf' profile. ### Troubleshooting a collapsed dough A baker notices their bread won't rise. They input all known ingredients and run the full analysis; the MCP identifies a hydration issue, telling them they need to adjust the liquid ratio significantly before trying again. ## Benefits - Pinpoint exact hydration: Use `calculate_hydration` to accurately determine liquid weight, even if you’re adding oils or eggs. You stop working with estimates and start using actual science. - Confirm the right bake type: Instead of guessing a recipe category, use `determine_dough_type` to instantly verify if your flour/salt mix is truly meant for rustic loaves or flatbreads. - Predict texture upfront: After calculating hydration, running `classify_texture` shows you what that dough will *feel* like when finished, preventing disappointing rises and collapses. - Cross-check complex recipes: Combine all three tools in a single prompt. You get the percentage, the profile, and the predicted final look—all from one place. - Save time on failures: Stop wasting ingredients. This MCP lets you validate your recipe ratios before you ever preheat the oven. ## How It Works The bottom line is: you input your raw ingredients and leave with three pieces of actionable data—the precise hydration %, the predicted texture, and the ideal final product category. 1. You provide your agent with all ingredient weights: the primary flours, the liquids (water, oil, etc.), and any additives like salt. 2. The MCP first calculates the effective hydration percentage; then, it uses that number alongside your ingredients to classify the expected texture. 3. Finally, you get back a confirmed dough type recommendation, which tells you if this mix is suited for pizza crusts, rustic loaves, or something else. ## Frequently Asked Questions **How does calculate_hydration work if I use oil instead of water?** It calculates the effective liquid weight by treating oils and other non-water liquids like water. It adjusts the hydration percentage accurately, so you don't have to manually correct for every component. **Do I need to know my profile name before using classify_texture?** Yes, running `classify_texture` requires both the calculated hydration percent and a specific profile name (like 'Pizza Crust' or 'Rustic Loaf') to give you an accurate texture prediction. **What does determine_dough_type tell me about my ingredients?** It reviews your flour and salt composition against known baking standards, telling you if the mixture is fundamentally suited for a bread base or something else entirely. It helps guide your entire recipe. **Can I use calculate_hydration to figure out my water content?** No. You must provide the weights of all ingredients, including liquids, so it can calculate the hydration percentage itself. The tool reads what you give it; it doesn't guess. **If I use `calculate_hydration`, what happens if I input weights that are zero or negative?** The tool will immediately throw an error. It requires positive weights for all ingredients, including flour and liquid components. You must provide valid, measurable quantities to get a calculation. **When using all three tools, what is the best sequence of calls to determine my dough profile?** Start by running `determine_dough_type` first; this sets the foundation. Then, use `calculate_hydration` with the specific weights, and finally, run `classify_texture` to get the full prediction. **If I change my primary flour type, how does `determine_dough_type` adjust its recommendations?** The tool analyzes the exact composition of the flour you provide. If you switch from bread flour to whole wheat, it automatically updates the recommended dough profile based on those new characteristics. **Does `classify_texture` have limitations if I try to calculate extremely high hydration percentages?** While the function accepts a wide range of inputs, excessively high or low ratios may result in a generic classification. For truly extreme mixes, manual expert review is always recommended.