MCP 服务器，用于 Pepesto API — 让您的智能体能够将任何食谱（URL、纯文本或照片）转换为包含 26 家欧洲超市实时价格的匹配购物篮。该 MCP 涵盖了工作流程中 食谱 → 匹配购物车 的部分（解析 / 搜索 / 将配料映射到 SKU / 检查目录）；下单是单独的步骤 — 请参阅 结账实际发生在哪里。
添加到 claude_desktop_config.json：
{
"mcpServers": {
"pepesto": {
"command": "npx",
"args": ["-y", "@pepesto/pepesto-mcp"],
"env": { "PEPESTO_API_KEY": "pep_sk_…" }
}
}
}claude mcp add pepesto -e PEPESTO_API_KEY=pep_sk_… -- npx -y @pepesto/pepesto-mcpRelated MCP server: Swissgroceries MCP
从按需付费的积分包开始 — 请参阅 https://www.pepesto.com/pricing/。
通过调用 /link 并使用您在结账时使用的电子邮件来生成 API 密钥。该密钥仅返回一次 — 请立即保存。
curl -X POST https://s.pepesto.com/api/link \
-H "Content-Type: application/json" \
-d '{"email":"you@example.com"}'在您的环境中设置该密钥：
export PEPESTO_API_KEY=pep_sk_…工具 | 端点 | 描述 |
|
| 一次性食谱 → 匹配购物车，包含用于结账的 |
|
| 将 URL/文本/图片食谱解析为结构化配料 + |
|
| 搜索 Pepesto 的 100 万+ 食谱图谱。 |
|
| 将 |
|
| 超市的完整 SKU 转储。仅在明确请求时使用；请缓存结果。 |
|
| 检查剩余积分。免费。 |
该 MCP 在“带有价格的匹配购物车”处停止 — 请参阅 结账实际发生在哪里 以了解用户如何完成订单。/session、/checkout 和 /link 被特意排除在外；请参阅 路线图 了解计划内容。
最快的路径。一次工具调用即可返回匹配的购物车和结账链接。
用户： 使用 BBC Good Food 的玛格丽特披萨食谱来构建一个 Tesco 购物车，并添加气泡水和橄榄油。
助手： [使用
pepesto_oneshot，参数为content_urls、content_text、supermarket_domain: "tesco.com"]助手： 已在 Tesco 匹配购物车。结账链接：
<redirect_url>。
对于“帮我找点吃的”这类提示，智能体首先搜索 Pepesto 的食谱图谱，并返回带有价格的匹配产品。
用户： 帮我找一个两人份的纯素食意大利面食谱。
助手： [使用
pepesto_suggest，参数为query: "vegan pasta dinner for two"]助手： 三个选项：奶油腰果通心粉、柠檬蒜香意大利面、烤蔬菜通心粉。您想要哪一个？
用户： 选第一个。在 Coop (coop.ch) 购买。
助手： [使用
pepesto_products，参数为所选食谱的kg_token和supermarket_domain: "coop.ch"]助手： 在 Coop 匹配了 8 种配料 — 腰果 CHF 4.20，通心粉 CHF 1.95，... — 总计 CHF 18.40。
当用户已经有心仪的食谱 URL 或文本时。MCP 返回匹配的产品列表 — 如何处理它由您决定。
用户： 解析这个并列出配料：https://www.bbcgoodfood.com/recipes/pizza-margherita-4-easy-steps
助手： [使用
pepesto_parse，参数为recipe_url]助手： 4 步轻松制作玛格丽特披萨 — 8 种配料：强力面包粉、速效酵母，...
用户： 现在将它们匹配到 Sainsbury's 的产品。
助手： [使用
pepesto_products，参数为返回的kg_token和supermarket_domain: "sainsburys.co.uk"]助手： 在 Sainsbury's 匹配了 8 种配料 — 总计 £6.40。
通过 pepesto_products 在单次调用中处理多个 kg_token — Pepesto 会合并跨食谱的重复配料。
用户： 计划 5 个本周的生酮晚餐，并在 Delhaize 匹配它们。
助手： [使用
pepesto_suggest，参数为query: "keto dinner low carb high protein", num_to_fetch: 5]助手： 五个晚餐：牛排配羽衣甘蓝、三文鱼牛油果碗、西葫芦千层面、花椰菜烩饭、鸡肉凯撒沙拉。
用户： 构建一个涵盖整个星期的购物清单。
助手： [使用
pepesto_products，参数为所有五个kg_tokens和supermarket_domain: "delhaize.be"]助手： 合并匹配：24 种独特配料（部分在食谱间共享），在 Delhaize 估计总计 €68.40。
对每个市场运行相同的食谱通过 pepesto_products 并比较总价。
用户： 解析这个周日午餐食谱。
助手： [使用
pepesto_parse]助手： 收到：意大利周日午餐，12 种配料。
用户： 向我展示 Esselunga 和 Conad 的购物车，以便我进行比较。
助手： [使用
pepesto_products两次 —supermarket_domain: "spesaonline.esselunga.it"，然后是supermarket_domain: "spesaonline.conad.it"]助手： Esselunga：€34.20。Conad：€31.50。Conad 便宜 €2.70，主要是在意大利面和番茄上。
仅在明确请求时使用，并积极缓存 — 请参阅下方的 定价与最佳实践。
用户： 我正在构建一个价格比较仪表板。拉取完整的 Plus NL 目录。
助手： 提醒一下 —
pepesto_catalog是这里最昂贵的调用。我只会运行一次；您应该至少缓存结果一天。确认吗？用户： 是的。
助手： [使用
pepesto_catalog，参数为supermarket_domain: "plus.nl"]助手： 目录已转储：23 个类别中的 1,847 个 SKU。
# | 国家 | 超市 | 域名 / ID |
2 | 🇬🇧 GB | Sainsbury's | sainsburys.co.uk |
3 | 🇬🇧 GB | ASDA | asda.com |
4 | 🇬🇧 GB | Morrisons | groceries.morrisons.com |
5 | 🇬🇧 GB | Waitrose | waitrose.com |
1 | 🇬🇧 GB | Tesco | tesco.com |
6 | 🇳🇱 NL | Albert Heijn | ah.nl |
7 | 🇳🇱 NL | Jumbo | jumbo.com |
8 | 🇳🇱 NL | Plus NL | plus.nl |
9 | 🇩🇪 DE | Rewe | shop.rewe.de |
10 | 🇨🇭 CH | Coop CH | coop.ch |
11 | 🇨🇭 CH | Migros | migros.ch |
12 | 🇨🇭 CH | Farmy | farmy.ch |
13 | 🇨🇭 CH | Aldi CH | aldi-now.ch |
14 | 🇧🇪 BE | Colruyt | colruyt.be |
15 | 🇧🇪 BE | Delhaize | delhaize.be |
16 | 🇮🇪 IE | Tesco IE | tesco.ie |
17 | 🇮🇪 IE | SuperValu | shop.supervalu.ie |
18 | 🇮🇪 IE | Dunnes | dunnesstoresgrocery.com |
19 | 🇮🇹 IT | Esselunga | spesaonline.esselunga.it |
20 | 🇮🇹 IT | Conad | spesaonline.conad.it |
21 | 🇩🇰 DK | Nemlig | nemlig.com |
22 | 🇳🇴 NO | Meny | meny.no |
23 | 🇵🇱 PL | Frisco | frisco.pl |
24 | 🇵🇱 PL | Auchan PL | zakupy.auchan.pl |
25 | 🇧🇬 BG | Bulmag | bulmag.org |
26 | 🇧🇬 BG | eBag | ebag.bg |
需要此列表中没有的超市？联系 Pepesto。
此 MCP 在“带有价格的匹配购物车”处停止。它不会自动在超市网站上下单。完成购物有两种方式：
Pepesto 应用（推荐）。 在浏览器中打开 pepesto_oneshot 返回的 redirect_url，或者将 pepesto_products 中的匹配产品列表交给用户，让他们在 Pepesto 应用 中重新创建 — 那里有托管的结账流程，包括登录、购物篮审查和（部分市场）支付。
超市自己的网站。 用户可以获取 pepesto_products 中的匹配产品列表，并直接在 tesco.com / coop.ch 等网站上添加 SKU。速度较慢，但不需要 Pepesto 账户。
Pepesto 采用简单的按需付费积分制 — 您只需为您智能体实际使用的内容付费，且积分永不过期，因此充值后归您所有，直到用完为止。我们还为学生和早期团队提供折扣，如果是这种情况，请打个招呼。完整的单次调用定价和批量等级请访问 https://www.pepesto.com/pricing/。
充分利用每一点积分的几个小贴士：
pepesto_credits 是免费的 — 随时调用以快速读取余额。
pepesto_oneshot、pepesto_parse、pepesto_suggest 和 pepesto_products 是日常调用（匹配食谱、计划一周、比较购物篮），定价适合日常智能体使用。
pepesto_catalog 会对超市进行完整的 SKU 转储，是负担最重的调用。它是进行真实市场分析或价格比较仪表板的正确工具 — 只需为每个超市至少缓存结果一天。不确定是否需要它？告诉我们您的用例，我们通常会为您指出更便宜的路径。
计划跟进：
pepesto_session — 封装 /session，以便智能体可以从选定的 SKU 构建 Pepesto 端的结账会话。
pepesto_checkout — 封装 /checkout，即驱动超市自身网站（登录、添加到购物篮、提示输入验证码等）的逐步浏览器自动化循环。这是实现完全自主购物缺失的一环。
托管结账移交 — 将 Pepesto 应用深度链接作为结构化工具结果呈现（而不是纯文本），以便 MCP 客户端可以将其渲染为按钮而不是 URL。
如果其中任何一项能为您解除阻塞，请告诉我们 — 这将使它们在队列中提前。
git clone https://github.com/pepesto-solutions/pepesto-mcp.git
cd pepesto-mcp
npm install
npm run build
npm test
npm run test:coverage针对本地构建运行检查器：
PEPESTO_API_KEY=pep_sk_… npm run inspector本仓库中的 Pepesto MCP 服务器根据 MIT 许可证 授权。
Dump Pepesto's full indexed catalog for a supermarket (~1-2k SKUs of common cooking ingredients, with names, prices, images, IDs). Optionally pass a webhook_url to receive incremental updates on re-index. Use only when the user has explicitly asked for a catalog dump, market analysis, or storefront build; for normal recipe-to-cart flows use pepesto_oneshot or pepesto_products instead. Cache this query aggressively, no more than one call per day per supermarket is recommended. When presenting supermarket results the user, use the product key as (external) link to the supermarket product itself. Show image if available (json property image_url, don't search for external images, skip rendering the Pepesto image if the image has webp extesion)
| Name | Required | Description | Default |
|---|---|---|---|
| supermarket_domain | Yes | Supermarket domain or ID, e.g. 'coop.ch', 'tesco.com', 'ah.nl'. See README for the full list. | |
| webhook_url | No | URL to POST incremental catalog updates to. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses the optional webhook for incremental updates, caching advice, and image handling. Does not explicitly mention read-only nature or auth requirements, but covers key behaviors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is dense with useful information, front-loaded with purpose and core details. Slightly long but every sentence adds value. Could be slightly more concise, but well structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers return content (names, prices, images, IDs), caching, image handling, and presentation guidance. Lacks details on error handling or webhook format, but adequate for a dump tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. Description adds meaning: explains webhook_url is for incremental updates, and gives example for supermarket_domain. Adds value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool dumps the full catalog for a supermarket with specific details (1-2k SKUs, names, prices, images, IDs). It distinguishes from siblings by mentioning alternative tools for normal recipe-to-cart flows.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (catalog dump, market analysis, storefront build) and when not (use pepesto_oneshot or pepesto_products for normal flows). Also provides caching recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the remaining API credits on the configured Pepesto API key.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It clearly states the tool returns credits with no side effects, but lacks detail on error conditions (e.g., missing key). Still sufficient for simple read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no superfluous words. Every word contributes meaning. Perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return value. It states returns remaining credits, but lacks format (e.g., number, string). Adequate for simple tool but could be more precise.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has zero parameters, so schema coverage is 100%. Description adds no param info, which is appropriate. Baseline score of 4 applies as per guidelines.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool returns the remaining API credits, distinguishing it from sibling tools like catalog or oneshot. The verb 'Return' and resource 'remaining API credits' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. However, due to its specific function, usage is implied when checking API credits. Missing when-not-to-use or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One-shot: turn recipe URLs, free-form text, and/or an image into a ready-to-checkout cart for a chosen European supermarket. Returns a redirect_url that opens the Pepesto checkout UI for the user to verify and pay. Internally runs parse + products + session (not exposed to agents) with Pepesto's heuristics. Use this when you want the simplest end-to-end flow; use pepesto_parse + pepesto_products + session (not exposed to agents) for finer control.
| Name | Required | Description | Default |
|---|---|---|---|
| content_urls | No | Recipe URLs to parse and shop. | |
| content_text | No | Free-form shopping list or extra items to include. | |
| content_image | No | Base64-encoded recipe image. | |
| supermarket_domain | No | Supermarket domain or ID, e.g. 'coop.ch', 'tesco.com', 'ah.nl'. See README for the full list. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions internal steps (parse + products + session) and that it returns a redirect_url, but does not cover error handling, idempotency, authentication needs, or potential side effects beyond cart creation. While the core behavior is described, more detail would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, each serving a purpose: purpose, output, internal process, usage guidance. It is front-loaded with the main action and efficiently conveys all needed information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple input types, single output) and the lack of output schema or annotations, the description provides adequate context: what it does, what it returns, and when to use alternatives. However, it could be more complete by mentioning possible failure modes or prerequisites, but overall it is sufficient for agent decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All four parameters are described in the input schema (100% coverage). The description loosely maps inputs to parameters (recipe URLs, free-form text, image) and gives an example for supermarket_domain, but this adds only minor context beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: turning recipe URLs, free-form text, and/or an image into a ready-to-checkout cart for a European supermarket. It specifies the output (redirect_url) and distinguishes itself from siblings by noting it internally runs parse+products+session, and recommends pepesto_parse+pepesto_products for finer control.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool ('simplest end-to-end flow') and when to use alternatives ('pepesto_parse + pepesto_products + session for finer control'). This provides clear guidance for the agent to choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Parse a recipe from a URL, free-form text, or image into a structured object: title, ingredients, nutrition, instructions, and a KgToken you can pass to pepesto_products to build a real cart. Once the response is returned, show recipe title, image if available (json property image_url, don't search for external images, skip rendering the Pepesto image if the image has webp extesion), ingredients, steps, nutrition summary, allergens clearly marked, and portions/servings if available. Don't show kg_token, but mark and save it for the next steps (e.g., /products call).
| Name | Required | Description | Default |
|---|---|---|---|
| recipe_url | No | Publicly crawlable recipe URL. | |
| recipe_text | No | Free-form recipe text. | |
| recipe_image | No | Base64-encoded recipe image. | |
| locale | No | BCP 47 locale, e.g. 'en-GB', 'de-CH'. | |
| generate_image | No | Whether to generate a shareable image of the recipe. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description gives response handling instructions but does not disclose behavioral traits like authorization, rate limits, or error scenarios.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is verbose and includes agent instructions (show/hide fields) that could be separate; not concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Explains output fields and KgToken but lacks detail on when to use each input type and does not cover return structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%; description adds context linking input types to output but does not detail each parameter's usage comprehensively.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'Parse' and resource 'recipe', and enumerates output fields. However, no explicit differentiation from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Describes what to do after parsing (show fields, save kg_token) but lacks guidance on when to use this tool vs alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Turn a free-form shopping list into a deferred deep link to the Pepesto mobile app, returned as a redirect_url. This is a PUBLIC endpoint: it is FREE to the API client, needs no API key, and returns instantly. Parsing and product matching happen lazily, only after the user opens the link — and the USER (not the API client) is charged when they proceed to checkout in the app. If the app isn't installed, the user is sent to the app store first and the shopping list is preserved until the app opens. This is an end-user / agent-facing handoff (e.g. a person chatting in Claude Desktop who wants to finish shopping on their phone), not a developer-integration endpoint. Choose pepesto_predirect when the cost should fall on the end user and a deferred deep link is acceptable. Choose pepesto_oneshot instead when the client wants the basket matched up front (with prices) and is willing to pay for the matching. PRESENTATION (important): the tool's text output is ready-to-show Markdown — a single tappable, labeled link plus a one-line caption. Surface it to the user exactly as returned; do NOT also paste the long raw URL as plain text. You may add one short sentence telling them to open it on their phone (on a computer, opening it shows a QR code to scan).
| Name | Required | Description | Default |
|---|---|---|---|
| shopping_list | Yes | Free-form shopping list. May contain multiple newline-separated lines, e.g. '2 avocados\n1 loaf of bread\n500 g tomatoes'. | |
| locale | No | User's locale, e.g. 'de-DE'. Optional. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description comprehensively discloses behavioral traits: it is free, requires no API key, returns instantly, parsing occurs lazily after link opening, the user is charged (not the API client), and behavior when app is not installed (app store redirect with preserved list).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is lengthy but well-structured, front-loading the core function and then adding usage guidance, behavioral details, and presentation instructions. Every sentence adds value, though it could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description fully explains the return format (Markdown with a tappable link and caption) and instructs the agent on how to present it to the user. It also covers edge cases (app not installed) and provides a complete picture of the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both parameters. The description adds minimal extra semantic beyond schema, only noting that shopping_list can be multi-line and locale is optional. This is adequate given the high coverage, but does not significantly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: converting a free-form shopping list into a deferred deep link to the Pepesto mobile app. It specifies the key characteristics (free, public, no API key, lazy parsing) and distinguishes it from the sibling pepesto_oneshot tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool versus pepesto_oneshot, based on cost allocation and timing of basket matching. It also clarifies that this is an end-user/agent-facing handoff, not a developer-integration endpoint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Map one or more recipe KgTokens (and an optional manual shopping list) to concrete supermarket products with prices, images, or currency. Items are merged across recipes to reduce waste; multiple matches per ingredient let you (or the user) pick. Show product title, image if available (json property image_url, don't search for external images, skip rendering the Pepesto image if the image has webp extesion)product_id when available linking to an (external) supermarket page (open in a new tab), price, ProductClassification (is_bio, is_frozen, is_substitution) tags. PricePromotion shows if the item is currently on promotion and what's current promo_percentage
| Name | Required | Description | Default |
|---|---|---|---|
| recipe_kg_tokens | Yes | KgTokens from pepesto_parse or pepesto_suggest. | |
| supermarket_domain | Yes | Supermarket domain or ID, e.g. 'coop.ch', 'tesco.com', 'ah.nl'. See README for the full list. | |
| manual_shopping_list | No | Free-text extra items to add (e.g. 'milk, bananas, kitchen towel'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses key behavioral traits: merging items across recipes, multiple matches per ingredient for user selection, output fields (title, image, price, classification, promotion), and specific rendering instructions (skip webp images). However, it does not mention idempotency, rate limits, or authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph that covers all necessary details without excessive length. It could benefit from bullet points for output fields, but the information is front-loaded with the main purpose in the first sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description thoroughly explains the return values (title, image, product_id, price, classification, promotion) and the merging/user-picking behavior. It provides sufficient detail for an agent to understand the tool's function and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds only contextual behavior (merging, picking) but does not enhance parameter semantics beyond what the schema already provides (e.g., examples, source hints).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Map' and clearly states the resource transformation: KgTokens to supermarket products. It distinguishes itself from sibling tools that handle parsing (pepesto_parse) or suggestion (pepesto_suggest) by focusing on product mapping.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used after obtaining KgTokens from pepesto_parse or pepesto_suggest, but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Pepesto's recipe graph (1M+ recipes) by free-text query and optional filters (cuisine, dietary tags, ingredients to include/avoid, time, servings). Each result includes a KgToken you can pass to pepesto_products. Returned images are licensed for display in your app or website without attribution. Show recipe title, image if available (json property image_url, don't search for external images, skip rendering the Pepesto image if the image has webp extesion), ingredients, steps, nutrition summary, allergens clearly marked, and portions/servings if available. Don't show kg_token, but mark and save it for the next steps (e.g., /products call).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Free-text query that may include cuisine, dietary tags, ingredients to include or avoid, time constraints, and servings, e.g. 'vegan keto dinner low on carb for two'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that images are licensed for display, that kg_token should be saved for the next step, and provides display instructions. However, it does not mention whether the operation is read-only, auth needs, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long and includes instructions for how to handle results, which could be more concise. It mixes tool functionality with behavioral instructions for the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains what the output contains (title, image, ingredients, steps, nutrition, allergens, portions, kg_token) and provides instructions on not showing certain fields. It is fairly complete for a search tool but could be more structured.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only has one parameter 'query' with a description that already mentions free-text. The tool description adds some extra context about cuisine, dietary tags, etc., but does not add substantial meaning beyond the schema. Schema coverage is 100%, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches Pepesto's recipe graph by free-text query and optional filters, and mentions it returns results with various details. However, it does not differentiate from siblings like pepesto_catalog or pepesto_oneshot.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (searching recipes with filters) and hints at a workflow using the returned KgToken for pepesto_products. But it lacks explicit guidance on when not to use or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.7.0pepesto_predirectv1.6.0pepesto_catalogpepesto_creditspepesto_oneshotpepesto_parsepepesto_productspepesto_suggestScored across 7 tools
Each tool has a distinct role in the recipe-to-cart workflow, but pepesto_oneshot and pepesto_predirect both produce redirect URLs from free-form lists, and pepesto_parse/pepesto_suggest both return KgTokens with similar recipe presentation. The descriptions differentiate them well enough, so this is only a minor ambiguity.
All tools share the pepesto_ prefix, which is helpful, but the naming convention is mixed: some are action verbs (parse, suggest), some are resource nouns (credits, products, catalog), and some are coined terms (oneshot, predirect). The names are readable but not predictable from a single pattern.
Seven tools is well-scoped for the server's purpose. Each tool covers a distinct step or entry point in the recipe-to-cart workflow, with no obvious bloat or thinness.
The surface covers recipe discovery, parsing, product mapping, catalog access, and end-to-end checkout flows. The main gap is that no separate session/checkout tool is exposed for fine-grained flows after pepesto_products, though pepesto_oneshot covers the common end-to-end path.
Hosted MCP for e-commerce: live product catalog, stock, and pricing for AI agents.
Unlock the power of food transparency with our Open Food Facts MCP server. Easily look up any food
Hosted MCP server to manage a restaurant menu from AI agents - 39 tools over the DuckHub API.
MCP Server for an Agent Task Marketplace
