mrkeyoor.comAsk

vxcn/mcd-kcal-pickertested 17 Nov 2026commit 7e48543

mcd-kcal-picker review

Use mcd-kcal-picker as a small McDonald's China MCP integration example if you can work with Chinese documentation and inspect its food inputs and selection code.

  • Safety failed
  • Build 1 s
5 sto install
  • 35 packages
Dev Toolsevaluationupdated 17 Nov 2026
+0 / 4dstars / 7d

mcd-kcal-picker is an independently developed Python Skill for selecting McDonald's China food combinations against a calorie target and ceiling. Its README documents a sample-data demo and a live nutrition-data route through MCP.

Verdict

Use mcd-kcal-picker as a small McDonald's China MCP integration example if you can work with Chinese documentation and inspect its food inputs and selection code. Our sandbox installed it in 5 seconds and completed its build step in 1 second. Skip it if your requirement is worldwide menus, ordering or demonstrated live meal-selection accuracy.

mcd-kcal-picker infographic: select McDonald's China foods against a calorie target, plus our test result and who it suits
Tested 17 November 2026: the source install took 5 s and the build 1 s.

We ran it

Lab card: what happened when we ran mcd-kcal-picker
Lab card from our sandbox run
Screenshot of mcd-kcal-picker (github.com/vxcn/mcd-kcal-picker)
github.com/vxcn/mcd-kcal-picker
Install✓ · 5s35 packages · 38 MB
Build✓ · 1s
Testsn/ano test script
Known vulns0(pip-audit)
Repo8 files~371 lines of source · 0 MB · 0 CI workflows

Answers from our run

Does mcd-kcal-picker build from source?

Dependencies installed in 5 seconds (35 packages), and the build succeeded in 1 seconds. We cloned commit 7e48543 into a clean Debian container with 3 CPUs and no project-specific setup.

Does mcd-kcal-picker have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does mcd-kcal-picker have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use mcd-kcal-picker?

People seeking worldwide menus or restaurant ordering.

What are the alternatives to mcd-kcal-picker?

mcd-meal-mate, mcd-advisor. Use mcd-kcal-picker as a small McDonald's China MCP integration example if you can work with Chinese documentation and inspect its food inputs and selection code.

Setup4/5Our source checkout installed in 5 s and built in 1 s with 35 dependencies, but we did not run a README task.Editor’s note: Installation and build completed, but token acquisition and a complete live selection workflow lack observed results.
Docs4/5The README has an install section (“快速开始”) and a usage section (“使用示例”); we did not run its quickstart ourselves, and the README is mostly in Chinese, not English.Editor’s note: The supplied Chinese README documents commands, but full workflow accuracy and English onboarding were not assessed.
Community3/5Last push on 2026-10-24 and 156 stars.Editor’s note: The supplied metadata records zero open issues and PRs; no support exchanges were sampled to assess response quality.
Maturity1/5No tagged GitHub release, repository created 2026-10-24 and no licence file GitHub recognises.Editor’s note: The evidence contains setup results but no passing test-suite result, completed live meal selection or sustained-operation assessment.

How we score

Who it’s for

Developers studying a small read-only commercial MCP integration.
Technically comfortable McDonald's China customers who can obtain their own MCP token and inspect the selected foods.
Readers interested in separating nutrition-data retrieval from deterministic selection.

Who it’s NOT for

People seeking worldwide menus or restaurant ordering.
People who need ingredient-level allergy assessment or personalized nutrition advice.
Teams requiring demonstrated live meal-selection accuracy before adoption.

Setup reality

Our November 17, 2026 sandbox run at commit 7e48543 installed successfully in 5 seconds and completed its build step in 1 second. The harness recorded 35 dependencies and 38 MB on disk. Tests were skipped because there was no tests script or target; pip-audit reported 0 known vulnerabilities.

The README documents a token-free sample-data demo. Live mode uses MCD_MCP_TOKEN and separate nutrition-fetch and selection commands. The repository scan found 0 CI workflows, no Dockerfile and no tests directory. A separate hands-on attempt failed its safety step because its harness required a Compose file.

The configured sandbox had 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. Runtime-version confirmation, live authentication and completed meal selection belong to the evidence gaps described in the final section.

Our sandbox installed mcd-kcal-picker in 5 seconds and completed its build step in 1 second at commit 7e48543. The project is most useful to developers studying a small McDonald's China MCP integration and technically comfortable readers exploring calorie-bounded selection. People seeking worldwide menus or restaurant ordering should choose something else. The separate hands-on attempt stopped at a Compose requirement before meal selection.

What you can do with mcd-kcal-picker

mcd-kcal-picker documents selecting a McDonald's China food combination near a target while respecting a separate calorie ceiling. The project README presents it as an independently developed contest entry. Its architecture gives MCP the nutrition-data retrieval task and Python the arithmetic and combination selection. The documented division makes the calculation available for inspection instead of asking a language model to add the calories itself.

The README example supplies a target of 600 kcal and a ceiling of 700 kcal. Those figures are command inputs, rather than a meal result from our run. The documented output includes each selected food, its calories, the combined calorie total, protein, fat, carbohydrates and sodium. This is a selector for a supplied food list: the target and ceiling come from the person invoking the script.

The author also documents a sample-data route and a live-data route. That distinction gives a new reader a sensible order of work: understand the sample command, inspect the selection logic, then arrange access to the official nutrition service. Someone studying MCP can focus on how retrieved information becomes a concrete calculation; someone choosing lunch must also pay attention to the foods and serving information entering that calculation.

What people use mcd-kcal-picker for

The README names calorie-conscious diners, commercial MCP learners and developers studying Skill structure as intended users. These are the author's stated audiences. HotRepo's overview explicitly identifies the README as its source, so its description is best read as an explanation of the intended workflow. The primary documentation gives the clearest account of what each reader can examine.

Intended reader Documented task Source
Someone controlling one meal's calories Supply a target and ceiling, then inspect the selected combination README target users and examples
A developer learning commercial MCP integration Fetch nutrition information before running a deterministic selector README workflow
A developer studying Agent Skills Examine SKILL.md, scripts and the documented organization README directory structure

The common thread is a small workflow with visible inputs and outputs. Developers can study retrieval separately from selection, while diners can see which foods contribute to the returned total. That separation is the practical reason to examine this repository. It also explains the extra work compared with a consumer-facing interface: the documented live route involves a token, a saved food response and another command.

What happened when we ran it

Our November 17, 2026 sandbox run at commit 7e48543 completed installation in 5 seconds and its build step in 1 second. The harness recorded 35 dependencies occupying 38 MB. These are our repository-check measurements. Separately, the hands-on safety step failed because none of the Compose filenames required by that harness existed.

Repository check Our recorded result What to take from it
Install Succeeded in 5 seconds The recorded installation step completed
Build Succeeded in 1 second The recorded build step completed
Tests No tests script or target; skipped The harness skipped this step
Dependencies 35 recorded; 38 MB on disk Recorded sandbox installation footprint
pip-audit 0 known vulnerabilities Recorded dependency-audit outcome
Repository signals 0 CI workflow files, no Dockerfile, no tests directory Recorded repository scan

The configured sandbox had 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. The scan recorded 8 files, approximately 371 source lines and a rounded checkout size of 0 MB. The harness JSON records a total of 8 seconds. These figures describe the recorded environment and checks; the installation footprint and rounded checkout size refer to different measurements.

The safety error names compose.yaml, compose.yml, docker-compose.yaml and docker-compose.yml as missing. Its wording calls the repository unsafe under a rule requiring a Compose file. The run summary, however, says it deployed the project's own Docker Compose on November 17, 2026 with every port bound to 127.0.0.1. The detailed missing-file failure takes precedence over that conflicting summary. The teardown record says cleanup completed successfully.

Where people get stuck: live data needs a token

Live mode requires MCD_MCP_TOKEN and two commands: one to fetch nutrition information and another to select foods from the saved response. The README tells readers to obtain their own token through the McDonald's MCP platform and set it privately in their terminal. The sample-data demo provides a separate starting point for readers who first want to examine the command structure.

Obstacle Documented route Decision consequence
You have no MCP token Use demo mode or obtain your own token Start with sample data or arrange live-service access
The picker needs food data Fetch list-nutrition-foods to a file first Keep retrieval and selection as separate steps
You want to exclude a text attribute Use the avoid option, demonstrated with 辣 Match the names or tags present in the food data
You want current availability Consult official channels Check availability separately from selection

The following commands reproduce the README's live workflow after MCD_MCP_TOKEN has been set privately. The first saves the nutrition response to /tmp/foods.json; the second reads that file and requests a combination near 600 kcal with a 700 kcal ceiling. The example contains no token value, and the README directs readers to keep credentials out of files and public messages.

python3 scripts/mcp_client.py --tool list-nutrition-foods --out /tmp/foods.json
python3 scripts/pick.py --foods /tmp/foods.json --target 600 --max 700

The README's token-free command uses examples/demo_foods.json. It explicitly labels that file as sample data for working through the flow. Keep that identity attached to any output from this route: the command below selects against the bundled example file, while the preceding workflow selects against the response saved by the MCP client. Both examples are documentation transcriptions.

python3 scripts/pick.py --demo --target 600 --max 700

The selection code counts items rather than meal roles

The supplied picker implementation selects combinations containing two to four items and ranks candidates by calorie distance, proximity to three items and total calories. In scripts/pick.py, the candidate condition checks item count and the accumulated total. The normalized food records contain names, calories, nutrient values and tags. The selection function contains no main, side or drink requirement.

That source-level distinction matters because the README describes a meal comprising a main, snack and drink. A calorie-bounded combination is the implementation's concrete selection rule. Readers should inspect the chosen foods as well as the total when deciding whether the combination suits their lunch. The code's arithmetic objective and a person's idea of a suitable meal are separate selection criteria.

The avoid option filters matching text in names and tags. The documented example uses 辣, the Chinese term for spicy, with a 500 kcal target and 550 kcal ceiling. The implementation also rounds each food's calorie value to an integer and substitutes zero for missing parsed nutrient values. Those details help explain what the displayed totals mean: they are sums of the normalized records processed by the script.

The documented MCP scope is read-only

The README restricts this project to list-nutrition-foods and excludes ordering, coupon claims, lotteries and points redemption. It says the project neither collects nor saves the MCP token and receives it through an environment variable. These are the author's documented operating boundaries. They explain why this repository is a focused nutrition-data example rather than a general assistant for a McDonald's account.

The same README describes scripts/mcp_client.py as a minimal Streamable HTTP MCP client and scripts/pick.py as a deterministic selector, both without third-party dependencies. Our harness separately recorded 35 dependencies in its installed environment. Those statements describe different things: the author's description of the scripts and the harness's installation inventory. The concrete audit result is that pip-audit reported 0 known vulnerabilities in the recorded run.

Chinese documentation and GitHub facts shape the support decision

The supplied README is in Chinese, and the November 17, 2026 GitHub metadata records Python as the repository language and 156 stars. That metadata also records 0 open issues and PRs and a last push at 2026-10-24T15:03:32Z. These facts describe the repository snapshot. For an English-speaking reader, the Chinese setup instructions and exclusion examples are a practical part of evaluating the project.

The supplied discovery pages describe growth differently. The Mid or Real comparison lists zero stars gained over seven days, while GitNova says its full seven-day window is unavailable. A missing observation window and a numerical zero are different records. For this review's decision, the repository's documented workflow and our recorded setup results are more useful than either growth presentation.

mcd-kcal-picker vs alternatives

mcd-meal-mate documents three food combinations shaped by store menus, budget, calorie limits and protein goals; mcd-advisor documents comparing purchase methods for already chosen foods. Their meal-mate README and advisor README therefore answer different questions from this picker's calorie-target workflow. Choose the question first: selecting foods and choosing how to purchase a fixed meal are different tasks.

Candidate Supported distinction When it deserves your attention
mcd-kcal-picker A target and ceiling drive one selected combination You want a narrow nutrition-fetch and selection example
xanthichi/mcd-meal-mate Its README describes three combinations using budget, calories and protein goals You want those constraints to shape food selection
wenboxia/mcd-advisor Its README describes official price checks for the same chosen foods You already know the foods and want to compare purchase methods
headmaster247/mcvalue-mate The supplied comparison contains opinion scores and public counters Treat that page as a discovery reference

The meal-mate README distinguishes its browser demonstration, which uses a desensitized menu snapshot, from its live MCP route requiring the repository's Node service. Advisor likewise distinguishes its recorded browser data from live price checks. Those documented routes matter when choosing what to explore next. The supplied advisor comparison and mcvalue-mate comparison explicitly label their verdicts as opinions and declare neither side a winner.

What the other reviews get wrong

McDonald's supplied statement acknowledges incorrect calorie displays for some app products and directs readers to its website. That company statement conflicts with the general calorie guide's unconditional claim that app and website information is consistent and current. The useful correction is specific: the two displays have not always matched. Readers should retain the source and market attached to any nutrition figure.

The research synthesis also records the guide's claims of flawless customization and constant freshness. The official US nutrition disclosure instead describes standard formulations and serving sizes, average ingredient values and a January 2022 qualification. Its warning about shared preparation also matters to people reading calorie tools as dietary guidance. These are statements about the US disclosure, with its own market and qualification.

HotRepo's coverage needs a different reading: it explicitly says its overview was written from the project's README. That makes it useful for discovery and documented intent. The implementation extract and our setup measurements supply other kinds of evidence. Keeping those sources identifiable lets readers distinguish what the author promises, what the code checks and what the lab actually recorded.

FAQ

mcd-kcal-picker accepts a calorie target and ceiling rather than calculating either from personal health information. The questions below come from the supplied research synthesis and are answered using the picker documentation or the official nutrition disclosure. For this repository, the useful distinction is between selecting listed foods, interpreting published nutrition values and deciding whether the resulting combination meets a person's needs.

How accurate is the McDonald's Nutrition Calculator?

McDonald's US disclosure says its nutrition information uses standard formulations, serving sizes and average ingredient values. The supplied picker code rounds food calories before summing them. Read a returned total as a calculation over those input records. The official disclosure explains its published figures, while the selector's implementation explains how this repository processes food values.

How can I find calories for a custom McDonald's order?

This repository documents selecting listed foods, and its avoid option filters names and tags. The command examples provide a target, ceiling and food-data source. For an ingredient change, start with official item information for the relevant market and customization. Excluding a matching food record is a different operation from recalculating that food's recipe after removing an ingredient.

Are the calories in the McDonald's app the same as on the website?

McDonald's supplied statement reports incorrect calorie displays for some app products and directs readers to McDonalds.com. That is a concrete reason to retain the source of a figure when comparing displays. In this repository's documented live workflow, the input comes from list-nutrition-foods and is saved to a file before the picker reads it.

Do McDonald's calories vary by country?

mcd-kcal-picker targets McDonald's China, while the supplied official nutrition disclosure concerns McDonald's USA. Keep those market labels attached to the information you use. The README directs readers to official channels for item information and availability. A food name alone is an insufficient reason to replace a returned China food record with a value from another market.

How are McDonald's nutrition values determined?

McDonald's US disclosure identifies accredited laboratory testing, published resources and supplier information as sources for its website's nutrition information. It also describes standard product formulations and serving sizes. The picker performs another task: it retrieves food records through the documented MCP tool, normalizes supported fields and adds the values associated with the selected foods.

Is the calculator's allergen information completely reliable?

McDonald's US disclosure warns that shared preparation areas, equipment and utensils can allow contact with allergens. The picker implements a name-and-tag text filter. A request to avoid a matching word therefore changes the candidate food records; it does not perform an ingredient or kitchen-contact assessment. Use the official ingredient information and the disclosure's advice for dietary questions.

Can the McDonald's calculator help me lose weight?

mcd-kcal-picker selects against a calorie target supplied by the user. Its author expressly states that the output is for reference and does not constitute medical, nutrition or other professional advice. The practical function documented here is comparing a selected combination with a numerical boundary, rather than choosing a personal calorie allowance or treatment goal.

Is there a nutrition calculator for McDonald's McCafé drinks?

This picker's food candidates come from the supplied nutrition records. For a particular McCafé drink, inspect whether that item and its nutrition values appear in the data being processed. The supplied community question asks about a drinks calculator; the repository's documented route is the general nutrition-list tool followed by the same target-and-ceiling selection command.

Where can I find sodium information for McDonald's sweet treats?

The README says the picker reports combined sodium alongside calories, protein, fat and carbohydrates. For a particular sweet treat, inspect the official item information and its corresponding input record. The implementation parses supported sodium fields and sums selected records, so understanding the individual food entries is more useful than reading the combined total as an item catalog.

How does a meal planner differ from MyFitnessPal or Cronometer?

mcd-kcal-picker's documented task is to choose a combination from food records using a calorie target and ceiling. That defines the role to compare with any other tool: food selection under supplied constraints. Its README documents MCP retrieval and a local script, so those are the concrete functions an interested reader can compare against their own requirements.

Can I save or share a generated meal plan?

The picker prints the selected items and totals, and its implementation includes a --json flag for structured output. That gives a developer a documented representation to inspect or handle with other tools. Keep the data source and calorie inputs alongside any copied result so another reader can understand whether it came from sample data or a fetched response.

Does a meal planner's calorie target account for exercise that day?

mcd-kcal-picker takes --target and --max as integer command inputs. Its documented examples supply those numbers directly, including 600 kcal and 700 kcal. The person invoking the command chooses the boundaries. The selector then compares food combinations against those inputs, which is the relevant behavior when deciding how to incorporate it into a broader planning workflow.

What we have not tested yet

The supplied run establishes installation and build completion, while the separate hands-on record stops at the Compose safety requirement. We did not execute the reproduced README commands or complete a meal-selection exercise in this correction. Token application, successful authentication, a current nutrition response, exact exclusion results, impossible-cap behavior and known-answer nutrient totals remain outside the demonstrated runtime evidence. The pack contains no screenshot records or successful user-run account filling those gaps.

The code and README extracts are separate from the commit-specific harness record; their exact correspondence to commit 7e48543 is not established by the supplied evidence. The image label also leaves actual runtime and operating-system versions unresolved without raw toolchain logs. No latest-release result was verified in the supplied evidence. The null release field cannot support the original assertion that a release endpoint returned 404.

No measured alternative comparison covers setup effort, menu coverage, meal quality, correctness or performance on larger food lists and higher ceilings. The conflicting growth records also remain unresolved. The supplied extracts do not substantiate the external planner's screenshot-sharing advice, regeneration behavior, exercise multiplier or MyFitnessPal/Cronometer comparison. The FAQ therefore answers those questions through the picker's documented inputs and output. US nutrition disclosures and the app statement do not demonstrate a defect in the China MCP.

Reuse permissions remain unresolved: the overview reports no declared license and the supplied repository metadata has no recognized license. The dependency audit is not a credential-handling audit, and the text filter supplies no allergen guarantee. Rendered layout, automatic related links, recommendation modules and template content also remain untested. The next useful runtime record would pair an authenticated food response with exact picker inputs, the returned combination and a manual check of its totals.

Alternatives

ProjectWhat it isPick it when
mcd-meal-mate gh↗Its README describes three combinations using store menus, budget, calorie limits and protein goals.Consider it when budget and protein goals should shape food selection alongside calories.
mcd-advisorIts README describes comparing ways to buy the same chosen foods using official price checks.Consider it when you already know what to eat and want to compare ways to buy that meal.

What people are saying

  1. [velocity-scout] vxcn/mcd-kcal-picker

Sources

  1. Project README
  2. Selection implementation
  3. HotRepo overview
  4. McDonald's nutrition disclosure
  5. mcd-meal-mate
  6. mcd-advisor

More dev tools reviews