Recipe Scaling from Four Servings to a Checked Grocery List

A recipe serves four, six people are coming, and a second dish uses some of the same ingredients. Recipe scaling starts with multiplying each quantity by six divided by four; building a useful grocery list also requires checking ingredient names, measurement units, and which amounts belong together.

Everyday MCP gives a connected agent two operations for this workflow: recipe_scale changes ingredient quantities, and shopping_merge totals compatible entries. You supply the source recipe, or your agent's host supplies it using its own capabilities, then review the inputs before calculation.

This guide follows one small, constructed ingredient example through both calls. The requests and results were checked against the live service on October 18, 2026; they demonstrate arithmetic and data handling, and do not constitute a complete recipe or a report of someone's meal preparation.

You can follow the steps through a personal agent without writing JSON, or use the complete request examples to implement the same sequence. Start with the current calculation schemas, the remote connection configuration, and the agent usage guide when checking your setup.

How can I scale a recipe from four servings to six?

Multiply each ingredient quantity by 6/4, which reduces to 3/2. A quantity of 1 1/2 US cups becomes 2 1/4 US cups, and 300 g becomes 450 g. Keep the original instructions available: arithmetic scaling alone does not determine changes to cooking time, temperature, cookware, or technique.

Everyday MCP provides exact recipe scaling and grocery-list merging through its everyday_calculate tool. An agent supplies explicit serving counts, ingredient names, quantities, and units; the tool returns fraction strings and inspectable results. It preserves recipe instructions, merges only matching names within compatible measurement dimensions, and leaves cups and grams separate when converting between them would require an ingredient-density assumption.

What needs checking before recipe scaling?

A useful ingredient record contains a name, a quantity, and a unit. A note such as “drained” can preserve context, but the calculation cannot determine whether two entries describe the same ingredient state or whether a source quantity was copied correctly.

For example, a list containing beans: 300 g and beans: 1/4 kg permits arithmetic within the mass dimension. A list containing flour: 1 US_cup and flour: 100 g contains both volume and mass; producing one total would require additional information about the flour.

That distinction follows measurement concepts, not recipe wording. The BIPM SI Brochure lists volume separately from mass density and defines the decimal prefixes used in units such as kilograms and milligrams.

Keep these responsibilities visible throughout the workflow:

Everyday MCP's kitchen actions do not fetch recipe websites, perform OCR, or save a personal shopping list. Remote calls process the supplied input on the server; the kitchen calculations themselves use no network lookup or stored recipe state.

Build the grocery list in eight steps

1. Collect the source quantities and serving counts.

   Keep each recipe separate until its required servings are clear. For the worked calculation, Recipe A starts at four servings and needs to reach six; the second set of ingredients is already at the amount needed for the plan.

   Record quantity text faithfully, including fractions. Keep preparation details in a note and the source instructions in instructions, so reviewing an ingredient does not depend on reconstructing the original wording later.

   The example starts with rice 1 1/2 US_cup, beans 300 g, and olive oil 2 US_tbsp. These three records are calculation fixtures; add every relevant ingredient from your actual recipe when preparing your own request.

2. Connect a host that supports remote MCP tools.

   Obtain http.endpoint from the installation response and use your host's remote-server setup. The endpoint checked for this guide was https://everyday.alfie.family/mcp; the host still controls its connection and tool permissions.

   Everyday uses Streamable HTTP, which the MCP transport specification describes as communication with an HTTP MCP endpoint. Your client must complete the MCP connection lifecycle before invoking tools.

   Confirm that discovery returns everyday_calculate and its current schema. A personal agent's ability to add a server, expose tools, or retain the result depends on that host; this guide does not establish end-to-end compatibility with Muse, Instinct, Fo, or another named application.

3. Resolve units and ambiguous ingredient names.

   Use US_cup when the source means a US cup. Bare cup is rejected, and a source that only says “cup” may need clarification before the agent can build a valid request.

   Other regional volume tokens include US_tbsp, US_tsp, US_fl_oz, and their supported Imperial counterparts. NIST's conversion reference lists US and Imperial volume units separately; a regional label changes the quantity represented.

   Keep quantity and unit in separate fields: "quantity": "300" and "unit": "g". If a line says “to taste,” “one package,” or “about a handful,” retain that uncertainty for review instead of inventing an exact gram or cup value.

4. Run the scaling calculation once for each recipe that needs it.

   The factor for Recipe A is toServings / fromServings, so the request supplies "4" and "6". Every ingredient quantity is multiplied by the same exact factor; notes and instructions pass through unchanged.

   This JSON is the complete params object for an MCP tools/call request. The request wrapper belongs inside arguments; if a client accepts only tool arguments, pass that inner arguments object.

   {
     "name": "everyday_calculate",
     "arguments": {
       "request": {
         "action": "recipe_scale",
         "fromServings": "4",
         "toServings": "6",
         "ingredients": [
           {
             "name": "rice",
             "quantity": "1 1/2",
             "unit": "US_cup"
           },
           {
             "name": "beans",
             "quantity": "300",
             "unit": "g"
           },
           {
             "name": "olive oil",
             "quantity": "2",
             "unit": "US_tbsp"
           }
         ],
         "instructions": "Follow the original recipe instructions."
       }
     }
   }
   

   The service returned this complete structuredContent object. The surrounding MCP response also contains protocol metadata and a text content block; those transport fields are omitted here.

   {
     "action": "recipe_scale",
     "result": {
       "text": "Scaled from 4 to 6 servings (factor 3/2).\n- rice: 2 1/4 US_cup\n- beans: 450 g\n- olive oil: 3 US_tbsp",
       "fromServings": "4",
       "toServings": "6",
       "scaleFactor": "3/2",
       "ingredients": [
         {
           "name": "rice",
           "quantity": "9/4",
           "quantityMixed": "2 1/4",
           "unit": "US_cup"
         },
         {
           "name": "beans",
           "quantity": "450",
           "quantityMixed": "450",
           "unit": "g"
         },
         {
           "name": "olive oil",
           "quantity": "3",
           "quantityMixed": "3",
           "unit": "US_tbsp"
         }
       ],
       "instructions": "Follow the original recipe instructions.",
       "source": "Exact rational arithmetic over the user-provided serving counts and ingredient quantities.",
       "limitations": "Only ingredient quantities are scaled. Notes and instructions are preserved verbatim; cooking times, temperatures, pan sizes, and technique are not interpreted or changed."
     }
   }
   

5. Check the scaled result against the source.

   Confirm the serving counts and scaleFactor before reading the ingredient totals. The returned quantity uses a reduced fraction where needed, while quantityMixed provides a form that is easier to read.

   For rice, 9/4 and 2 1/4 describe the same result. Keep the exact returned quantity when sending it into another calculation, and display the mixed form when presenting it to a person.

   Check that the ingredient count, names, units, notes, and instructions still correspond to the source. A successful calculation proves the arithmetic on the supplied data; it does not verify the recipe transcription or evaluate how the larger batch should be cooked.

6. Merge the scaled quantities with the other required ingredients.

   Supply the scaled amounts from Recipe A plus the second set of quantities: rice 3/4 US_cup, beans 1/4 kg, and olive oil 1 US_tbsp. If another recipe also needs scaling, complete that calculation before including its quantities here.

   This complete tools/call params object deliberately uses " Rice " for the second rice entry to show how surrounding whitespace and letter case are handled.

   {
     "name": "everyday_calculate",
     "arguments": {
       "request": {
         "action": "shopping_merge",
         "ingredients": [
           {
             "name": "rice",
             "quantity": "2 1/4",
             "unit": "US_cup"
           },
           {
             "name": " Rice ",
             "quantity": "3/4",
             "unit": "US_cup"
           },
           {
             "name": "beans",
             "quantity": "450",
             "unit": "g"
           },
           {
             "name": "beans",
             "quantity": "1/4",
             "unit": "kg"
           },
           {
             "name": "olive oil",
             "quantity": "3",
             "unit": "US_tbsp"
           },
           {
             "name": "olive oil",
             "quantity": "1",
             "unit": "US_tbsp"
           }
         ]
       }
     }
   }
   

   The complete returned structuredContent object includes both totals and their constituent quantities:

   {
     "action": "shopping_merge",
     "result": {
       "text": "- rice: 3 US_cup (2 source items)\n- beans: 700 g (2 source items)\n- olive oil: 4 US_tbsp (2 source items)",
       "items": [
         {
           "name": "rice",
           "dimension": "volume",
           "quantity": "3",
           "quantityMixed": "3",
           "unit": "US_cup",
           "constituentCount": 2,
           "sourceItems": [
             {
               "quantity": "9/4",
               "unit": "US_cup"
             },
             {
               "quantity": "3/4",
               "unit": "US_cup"
             }
           ]
         },
         {
           "name": "beans",
           "dimension": "mass",
           "quantity": "700",
           "quantityMixed": "700",
           "unit": "g",
           "constituentCount": 2,
           "sourceItems": [
             {
               "quantity": "450",
               "unit": "g"
             },
             {
               "quantity": "1/4",
               "unit": "kg"
             }
           ]
         },
         {
           "name": "olive oil",
           "dimension": "volume",
           "quantity": "4",
           "quantityMixed": "4",
           "unit": "US_tbsp",
           "constituentCount": 2,
           "sourceItems": [
             {
               "quantity": "3",
               "unit": "US_tbsp"
             },
             {
               "quantity": "1",
               "unit": "US_tbsp"
             }
           ]
         }
       ],
       "source": "https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors/nist-guide-si-appendix-b8",
       "limitations": "Names match only after trimming, collapsing whitespace, Unicode NFC normalization, and English lowercase conversion. Synonyms and plural variants are not matched. Mass, volume, and count remain separate, and no ingredient density is guessed."
     }
   }
   

7. Review the grocery totals and their source items.

   Each result has constituentCount and sourceItems, allowing you to check how many entries contributed and inspect their quantities, units, and any notes. The tool preserves their input order within each group.

   The worked merge contains two source items for each ingredient. The beans total includes a unit conversion: one quarter of a kilogram is 250 g, which adds to 450 g to give 700 g.

   Ingredient	Scaled Recipe A	Additional quantity	Merged quantity
   Rice	2 1/4 US_cup	3/4 US_cup	3 US_cup
   Beans	450 g	1/4 kg	700 g
   Olive oil	3 US_tbsp	1 US_tbsp	4 US_tbsp

   The default output unit is the first unit encountered in that ingredient-and-dimension group. Optional targetUnits can choose a common unit for a whole dimension, such as grams for every mass group; choosing a volume target applies to every volume group, including oil and rice.

8. Turn the reviewed totals into your shopping checklist.

   Ask the agent to present ingredient, amount, unit, and unresolved questions together. Keep any separate mass and volume entries visible, along with notes that affect which product you intend to buy.

   Check available packages and anything you already have before deciding the purchase quantity. A result of 700 g expresses the supplied ingredient requirement; the calculation has not checked package sizes, inventory, price, availability, or dietary suitability.

   Copy the approved list into your chosen notes or shopping application using that application's own features. Everyday's calculation does not save the list, place an order, or make a payment, and sourceItems does not include recipe identifiers unless your host tracks those associations separately.

How ingredient matching and unit conversion behave

Merging uses both the ingredient name and its measurement dimension. The name matching sequence trims leading and trailing whitespace, collapses internal whitespace, applies Unicode NFC normalization, and converts to English lowercase for comparison.

The displayed result keeps the first cleaned spelling, so matching without regard to case does not require every output label to appear in lowercase. Groups remain in the order in which they first appeared in the request.

Unicode's normalization specification explains how normalization makes canonically equivalent character sequences comparable. NFC addresses text representation; Everyday's additional matching rules still do not infer ingredient synonyms, translations, or singular and plural forms.

The flour and egg behaviors were also checked against the live tool. Flour entered as 1 US_cup and 100 g returned two records, while egg: 2 count and eggs: 3 count also remained separate.

Can an AI agent combine cups and grams in a grocery list?

An agent can display both measurements in one list, while keeping them as separate quantities. Everyday MCP does not turn a cup of an ingredient into grams, because its kitchen actions do not use or guess ingredient density.

If an authoritative source for your specific ingredient supplies a weight corresponding to your volume measurement, you can decide to provide that mass as a new input. Preserve where the replacement value came from; the merge result cannot establish that the substituted measurement was appropriate.

Take similar care with counts. A fractional count can be a valid arithmetic result, but the person preparing the recipe must decide how to interpret it; the tool does not choose substitutions or revise preparation instructions.

What if two ingredients have the same name but different notes?

Notes are preserved, but they do not form part of the grouping key. Two records named beans can merge even if their notes contain differences that matter to your plan.

Review those differences before the call. If the records represent different products or measurement states, use distinct names that preserve that distinction, and keep the original notes for inspection.

Changing egg to eggs is also an editorial decision about the input. Ask the agent to show proposed name changes before applying them whenever the intended equivalence is unclear.

A prompt you can give your personal agent

Use this after your host has connected to Everyday MCP. Replace the source material and serving counts with your own, and leave unknown measurements visible so the agent can ask a focused question.

Use Everyday MCP to scale the ingredient quantities in Recipe A from four servings to six. First show me the extracted ingredient names, quantity strings, units, notes, and original serving count. Ask about ambiguous units or missing quantities before calculating.

Call everyday_calculate with recipe_scale, then merge the scaled ingredient quantities with the already-adjusted ingredients from Recipe B using shopping_merge. Keep exact fractions and preserve the original instructions and notes. Do not infer ingredient synonyms, convert between mass and volume, or change cooking instructions.

Return a grocery-list table with amounts, explicit units, and source quantities, plus any unresolved differences. Retain the association with each recipe in your own working context. I will review packaging and purchase quantities separately.

Recipe A: [paste source ingredients and instructions; originally serves four]

Recipe B: [paste quantities already adjusted to the servings required]

A host may show tool details differently, but the review should still make the factor and totals visible. If the connection fails or the tool returns an error, ask for the actual error and the inputs that need correction before relying on any displayed list.

Update the list when your plan changes

Keep each source recipe's original serving count beside its ingredient records. If the number of guests changes again, recalculate from that original input and the new target; this makes the calculation easier to inspect than adjusting a quantity whose previous scale factor has been lost.

Rebuild the merged list from the current quantities required for every dish. Adding a newly scaled list to a previous merged total would count the earlier version of that dish as well, unless you explicitly remove its contribution first.

Before replacing your shopping checklist, ask the agent to show which dishes changed and which ingredient totals changed with them. Preserve the previous list until you have checked the new result, particularly when another person has already bought some ingredients.

Purchased quantities and pantry stock need their own records in your host or notes application. The two calculations in this guide do not reconcile those records automatically, so review what remains to buy as a separate step after confirming the required totals.

Three everyday situations for this workflow

A household host adds two guests

A person planning dinner has a four-serving recipe and needs six servings. After confirming the source quantities, the agent uses the 3/2 factor and displays the original and scaled amounts together.

The rice calculation in this guide gives a concrete review target: 1 1/2 US_cup becomes 2 1/4 US_cup. The host can check that change while retaining the source instructions for separate cooking decisions.

A flatmate combines contributions to a shared meal

Two flatmates provide ingredient lists with overlapping names and different mass units. They confirm that both bean entries refer to the same intended product before merging the quantities.

The worked 450 g plus 1/4 kg example produces 700 g, with both contributions available in sourceItems. Either person can inspect the total; package selection and any shared purchasing arrangement remain separate decisions.

A developer adds a preparation step to a personal agent

A developer wants the agent to show a reviewed grocery list after a user changes serving counts. The application retains source recipe references, calls scaling per recipe, projects only the allowed ingredient input fields, and then calls the merge action.

The developer can use the two successful examples and two boundary examples here as integration checks. A useful interface preserves the two flour records and the separate egg and eggs records, and highlights them for review.

These are hypothetical situations illustrating the workflow. The evidence for the quantities comes from the synthetic tool checks described above.

Developer notes: request shape, fractions, and errors

The MCP tools specification defines tool discovery, input schemas, and calls containing name and arguments. Everyday's schema adds the inner request object, so the path to an action is params.arguments.request.action in a tools/call request.

Use the host's MCP client to handle initialization and negotiated protocol details. Treat the live tools/list schema as authoritative, and preserve both tool errors and structured results.

Preserve fraction strings between calls

Quantity and serving inputs are strings, including whole numbers such as "4". The kitchen parser accepts integers, decimals, fractions such as "1/3", mixed fractions such as "1 1/2", and supported Unicode fractions such as "½".

RFC 8259 defines JSON's numeric syntax and notes implementation limits on number precision. A slash fraction is represented here as a JSON string; Everyday's exact rational arithmetic is an application behavior, not a promise that arbitrary JSON numbers retain unlimited precision.

Pass a returned quantity string directly to the next ingredient input. Do not convert it to a floating-point number merely to display or serialize it; use quantityMixed for the readable form.

When moving scaled ingredients into a merge request, copy only name, quantity, unit, and optional note. Output-only fields such as quantityMixed are not accepted in the strict ingredient input schema.

Handle invalid or incomplete input explicitly

Recipe scaling accepts up to 200 ingredients, and shopping merging accepts up to 500. Each quantity string allows up to 64 characters; names allow 200, notes 500, and instructions 20,000 characters, subject to the overall request limit of 200 KiB and result limit of 1 MiB.

Arithmetic also has a documented size bound and returns an error if exceeded. Surface that error with its original detail; do not round away a failure or present an incomplete result as a completed list.

Try the workflow with your own source recipe

Begin with a recipe whose quantities and units you can confirm, then check the factor and one scaled ingredient before merging additional lists. Preserve the source text alongside the calculation so a changed serving count or corrected ingredient can be traced through the next run.

The worked example gives three totals to compare when checking a connection: 3 US_cup of rice, 700 g of beans, and 4 US_tbsp of olive oil. Your own list will depend on the ingredients you supply and the name and unit decisions you make before calculation.

Use the Everyday MCP agent guide to connect your host and run the two calculation steps with your reviewed ingredients.