mcp-supermercados-cl

by NLACE-COM

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.4.7
Disambiguation4/5
Most tools have distinct purposes, but there is potential confusion between `find_opportunities` and `get_offers` (both deal with discounts) and between `build_cheapest_basket` and `compare_stores` (both compare across stores). However, descriptions clarify the differences.
Naming Consistency5/5
All tools follow a consistent `verb_noun` snake_case pattern (e.g., `search_products`, `get_cart`, `build_list`). No mixing of conventions.
Tool Count5/5
14 tools is appropriate for a grocery shopping assistant, covering search, product details, list building, price comparison, cart management, offers, and saved lists without being overwhelming.
Completeness5/5
The tool set covers the full shopping workflow: search, details, list optimization, price comparison, cart operations, offers, saved lists, and branch discovery. Missing explicit cart removal and list deletion, but these are minor gaps.
Average 4.4/5 across 14 of 14 tools scored. Lowest: 3.6/5.
See the Tool Scores section below for per-tool breakdowns.
- 5 of 5 community issues answered or closed in the last 6 months
- 53 commits in the last 12 weeks
- Last stable release on August 2, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the need for a logged-in session, direct JSON call, prohibition of DOM scraping, and that the server never handles credentials. This provides substantial behavioral context despite limited annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is adequately structured with purpose first, then instructions. However, it is somewhat verbose, mixing instructions with warnings. It could be more concise while retaining key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains the user workflow, expected input format, and normalization of output. It also warns against scraping. Given the tool's complexity (external session), it covers most contextual needs, though error handling and edge cases are absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for store, branchId, and rawLists. The description adds operational context (e.g., rawLists comes from a browserSnippet) but does not significantly deepen parameter meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns saved shopping lists normalized to { id, name, items[] }. It provides a specific verb and resource. However, it does not explicitly distinguish this tool from siblings like get_frequent_purchases, which could be a similar retrieval tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the required session and browser workflow, implying when to use it (when lists are needed). However, it lacks explicit when-not-to-use or comparison to alternative tools, leaving some ambiguity about exclusivity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses that it requires a logged-in session, uses a browser snippet, and warns against scraping React state or improvising selectors. It also states the server never handles credentials, adding important security context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is somewhat long but front-loaded with the main purpose. It includes necessary instructions, but some sentences could be more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (no output schema, 3 params), the description provides enough context: it explains the output format (normalized prices, DOM-extracted cards), the requirement for a session, and behavioral constraints. It is complete for an agent to use effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already explains parameters. The description adds value by explaining that the cards parameter comes from DOM extraction, but does not add significant new meaning beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns frequently purchased products with normalized prices and Jumbo Prime price. It distinguishes itself by being the base for building the user's actual purchase list, differentiating from siblings like get_saved_lists or build_list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context that it requires a session and uses a browser snippet, and its purpose is explained. However, it does not explicitly state when to use this tool versus alternatives like get_saved_lists 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It explains the two-step process (returning a snippet, then validating the result), the snippet's return format, and that the result must be passed back. No destructive actions are mentioned, which is appropriate for a 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph of about three sentences, efficiently covering the tool's purpose and mechanics. It could be more structured (e.g., separate usage notes), but it is concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (browser interaction, validation step), the description covers key aspects: getting the snippet, executing it, and passing back the result. No output schema exists, but the return format is described. It is sufficiently complete for correct agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds context: 'store' specifies the Cencosud chain (jumbo/santaisabel), and 'discovered' is the result of the browser snippet. The explanation of the flow enriches parameter understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool obtains the branch code (branchId) from the browser, avoiding the need to ask the user. It specifies the output (browserSnippet) and distinguishes itself from other tools that don't perform browser interaction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies using this tool when the branchId is needed and a browser snippet can be executed. It does not explicitly state when not to use it or name alternatives, but the context makes the usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavior. It lists return fields but doesn't mention side effects, auth requirements, or error handling. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the purpose and list key fields. Every sentence adds value, no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description covers all return fields and parameters adequately. Provides complete picture for a product detail tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds context: explains idOrUrl accepts URL, path, or slug; store enum values; branchId for local prices. Goes beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it gets complete product details, lists specific fields (price, listPrice, memberPrice, etc.), and distinguishes from search_products which returns URLs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says it's the only source for member price in phase 1 and that it accepts URLs from search_products. Implies it's for detailed product information but doesn't explicitly exclude other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full burden. It discloses return contents (current product and replacements with savings per unit), natural mode details (ingredients, nutritional seals), and store support. It omits rate limits or authentication, but the read-only nature is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph that efficiently conveys all key points: purpose, default behavior, optional mode, stores supported, and output. It is front-loaded with the main action. Could be slightly better structured (e.g., bullet points for modes) but is concise and complete.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately specifies return values (current product, replacements, savings per unit). Parameters are fully explained. It does not cover error cases or edge conditions, but for a simple suggestion tool, the information is sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds significant nuance: it explains the purpose of items (product name or search text), store enum values, branchId for local prices, and preferNatural's detailed behavior (more natural with similar price, includes ingredients). This enhances understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: to suggest convenient replacements for items within the same catalog. It specifies two modes (price-based and natural-preference) and differentiates from sibling tools like search_products and get_product.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on default usage (best price per unit) and alternative usage with preferNatural: true for natural alternatives. It lacks explicit exclusions or alternatives, but the context is sufficient for an agent to decide when to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behaviors: selection logic, returns per item (chosen product, alternatives, savings, total), handling of budget overflow, and the role of frequentCards. It could be more explicit about non-destructive nature, but overall is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively long but well-organized: it starts with the core functionality, then explains parameter behaviors in a logical order. Each sentence adds value, though minor redundancy could be trimmed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 7 parameters and no output schema, the description comprehensively covers all key aspects: item conversion, pricing, offers, stock, budget handling, frequent products, and branch-specific prices. It provides enough detail for an AI agent to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 7 parameters have descriptions in the schema (100% coverage). The description adds useful context beyond the schema, such as how frequentCards are used and how maxBudget triggers downgrades. This supplements the schema well.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it converts a natural language list into concrete products from the catalog, selecting by best price per unit and offers. This distinguishes it from sibling tools like search_products or get_offers, which have different scopes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context, such as using branchId for local prices and frequentCards to prioritize frequent purchases. It does not explicitly list when not to use the tool or alternatives among siblings, but the guidance is sufficient for typical scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It explains the tool is live diagnostic (read-only), checking responses and latency. It does not explicitly state it is non-destructive, but the diagnostic nature implicitly suggests no side effects. A small gap exists in not confirming it only observes, but for a 0-param tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loading the core action and then providing usage context. Every sentence earns its place with zero redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 0 parameters, no output schema, and the diagnostic nature, the description fully covers what the tool does and when to use it. It implies the output will list chain statuses and latency, which is sufficient context for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters and 100% coverage, so the baseline is 3. The description does not add parameter-specific meaning because there are none to describe. It mentions 'supported chains' but does not detail any input constraints, which is fine as there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Diagnóstico en vivo: qué cadenas soportadas están respondiendo ahora y con qué latencia.' This specifies a concrete verb ('diagnose'), resource ('supported chains'), and scope ('live status, latency'). It distinguishes from sibling tools like get_product or add_to_cart, which serve entirely different functions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises when to use the tool: 'Úsalo si otra tool falla, para distinguir un endpoint caído de un error de uso.' This provides clear guidance for the agent, stating that it is a diagnostic fallback to differentiate between a downed chain and a usage error.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility. It covers critical behaviors: the server does not handle credentials, the need for a logged-in browser tab, the two-step process, and that the action is reversible and not a purchase. This fully discloses the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively concise while conveying necessary steps and prerequisites. It is front-loaded with the main purpose. Minor redundancy (e.g., mentioning reversal twice) could be trimmed, but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is complex with a two-step flow. The description adequately explains the prerequisites (logged-in tab), the process (browserSnippet, rawCartResult), and the outcome (normalized cart or snippet). Given no output schema, it sufficiently describes return values. It could mention error handling, but still comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, providing a baseline of 3. The description adds value by explaining that skuId should use the 'id' field from search_products, that branchId is required, and that rawCartResult is the JSON response from PATCH/GET /cart. This goes beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool adds/updates products in the user's Jumbo cart. It uses specific verbs ('Agrega/actualiza') and resource ('productos en el carro de Jumbo'), distinguishes it from sibling tools like get_cart by noting it modifies the cart, and clarifies it is not a purchase.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use it (to add/update products) and provides essential context: the two-step flow (returns browserSnippet requiring a logged-in tab), the role of rawCartResult, and that the action is reversible. It does not explicitly mention alternatives or when not to use, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It discloses return fields, sorting, filtering, and availability on Jumbo. It does not mention side effects, but it is clearly a read operation. The description is transparent about what the tool does.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured paragraph of about 6 sentences. It front-loads the core purpose and ordering, then lists return fields, filtering, and specific usage hints. No superfluous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description lists return fields explicitly. It covers filtering, exclusion, primeOnly, store availability, and limit. It does not mention pagination beyond the limit parameter or error handling, but for a top-deals tool, the information is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds significant context beyond schema descriptions. For example, excludeIds is explained as 'lo que el usuario ya tiene en el carro o compra siempre', and minDiscountPct includes an example. The description also lists return fields not in schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it returns products with the highest discount and real stock, sorted by discount percentage, for recommending deals. It lists returned fields (discountPct, saving, memberSaving) and filtering options. The title 'Oportunidades del momento' reinforces a clear purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: use for finding best deals, with specific usage tips for excludeIds (to exclude user's current items) and primeOnly (exclusive offers). It implies when to use (for deals) but does not explicitly differentiate from sibling tools like get_offers. Nonetheless, the context is sufficient for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It describes the selection logic, return fields, default stores, and limitations. While it does not cover rate limits or authorization, the behavior is sufficiently transparent for a comparison tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph that conveys all necessary information. It is front-loaded with the main action, but could benefit from slightly better structure. Every sentence is informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema), the description covers the purpose, return fields, default behavior, limitations, and sibling differentiation comprehensively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds operational context beyond the schema, such as default store list and the requirement for tottus/lider to use browserHtml. With 100% schema coverage, the description provides useful semantic additions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool takes a list of items and selects the cheapest store per item, returning aggregated results. It distinguishes itself from siblings like add_to_cart by explicitly stating what it does not do (add to cart).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
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 (to find the cheapest basket across stores) and when not to (use add_to_cart for adding items to cart). It also mentions that for tottus/lider, browserHtml from search_products is needed, implying prerequisite steps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description carries full burden. It discloses that each chain resolves items independently, so cheapest may be different product/format; recommends using 'comparability' field and comparing by unit price. Also notes IP requirements and failure handling, revealing important behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph of about 5 sentences, front-loading the main purpose. Every sentence adds value, though slightly dense. Could be more structured but effectively concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers complexity: returns per-chain best match and total, notes comparability, IP requirements, default stores, and failure handling. No output schema, but description explains return values sufficiently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all parameters. The description adds minor context (example for items, default for stores, branchId purpose for Cencosud) but does not significantly expand beyond schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool estimates the total of a list across Chilean chains and identifies the cheapest among those with all products. It specifies the verb 'Estima' and resource 'cadenas chilenas', and distinguishes from siblings like 'build_list' by focusing on comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance: 'para el día a día conviene build_list con tu sesión' tells when to use an alternative. The 'IMPORTANTE' note advises on comparability and unit price. Mentions IP requirements for specific chains and that failures are reported, providing clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the discontinued primeOnly behavior and the actionable error, explains the price semantics, and clarifies filter scope. It does not mention pagination or response format, but the core behavioral traits are well-covered for a list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, each adding critical information: the core function and price definitions, filtering options and sibling pointer, and the discontinued flag. There is no redundancy or filler, and the most important details are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema and no annotations, the description covers the essential context: what an offer is, how to filter, which store is unsupported, and the deprecated parameter. It lacks explicit guidance on default behavior when branchId is omitted, but that is minor since the schema marks it optional. The description is sufficiently complete for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description goes beyond by providing concrete examples for category ('Despensa', 'Lácteos'), branchId ('jumboclj512'), and clarifying that primeOnly returns an error. It adds semantic value to the parameters, making the schema more actionable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists current supermarket offers, distinguishing between discounted price (`price`) and normal price (`listPrice`). It explicitly differentiates from sibling tools by noting that exact member pricing is obtained via get_product (`memberPrice`), and it clarifies the scope and filtering options. This is a specific verb+resource combination that stands apart from other tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: it names get_product as the alternative for member pricing, warns that primeOnly is discontinued, and notes that Santa Isabel has no offers collection yet. This tells the agent when to use this tool and when to use another, with concrete exclusions and alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description explains key behaviors: price fields (price, listPrice, unitPrice), currency (CLP), local vs national scope with branchId, store-specific IP requirements, and the browserHtml flow. It does not mention rate limits or caching, but covers most critical aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-organized, starting with purpose, then output fields, filters, sorting, and special notes. It is concise given the wealth of information, though slightly longer than ideal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description enumerates output fields and explains price behavior. It mentions pagination parameters but does not detail total results or next-page handling. It references a sibling tool and store-specific quirks, providing sufficient context for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds significant extra meaning: it explains the output fields, price semantics, sorting logic (price: cheapest first, unitPrice: best per unit), filter effects, and the browserHtml retry mechanism. This goes well beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches products in a Chilean supermarket catalog and returns enriched results. It distinguishes from the sibling tool `get_product` for specific product price, providing a clear boundary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use this tool for broad search and when to use `get_product` for a single product's price. Also notes store-specific requirements (e.g., residential IP for some chains) and provides a workflow for handling antibot with `browserHtml`.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that credentials are not seen by server ('El servidor no ve credenciales') and describes the two modes (normalize or return snippet). Lacks mention of rate limits or other side effects, but for a read-like tool with no annotations, this is above average.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single paragraph with important information front-loaded (purpose, workflow). Slightly dense due to embedded instructions but efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Describes output format explicitly despite no output schema. Addresses the full workflow and integration with browser snippet. With sibling tools, this provides sufficient context for correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds significant meaning beyond the input schema: explains store default and phase, rawCart source from GET /cart, branchId as sucursal. The description clarifies the workflow for each parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool normalizes the user's Jumbo cart into a specific format (items, subTotal, total, savings, primeSavings). It distinguishes from siblings like add_to_cart and get_product by focusing on cart normalization.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use: 'FLUJO RÁPIDO (una sola llamada)' with browser snippet, and when-not-to: 'NO extraigas el estado de React ni el DOM del carro a mano'. Also explains fallback behavior if rawCart is not provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-supermercados-cl MCP server](https://glama.ai/mcp/servers/NLACE-COM/mcp-supermercados-cl/badges/card.svg)](https://glama.ai/mcp/servers/NLACE-COM/mcp-supermercados-cl)

Score Badge

Copy to your README.md:

[![mcp-supermercados-cl MCP server](https://glama.ai/mcp/servers/NLACE-COM/mcp-supermercados-cl/badges/score.svg)](https://glama.ai/mcp/servers/NLACE-COM/mcp-supermercados-cl)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/NLACE-COM/mcp-supermercados-cl'

If you have feedback or need assistance with the MCP directory API, please join our Discord server