Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@posokanei-mcp search for olive oil"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Unofficial read-only MCP server for supermarket product and price data from PosoKanei.
This server lets MCP-compatible clients ask questions such as:
Search for supermarket products by name.
Look up a product by barcode.
Compare current retailer prices for a product.
Compare a small shopping basket across retailers.
Browse product categories and retailers.
Early open-source version. The implementation uses public, undocumented endpoints used by the PosoKanei web app. Keep requests modest and cache-friendly.
This project is not affiliated with, endorsed by, or operated by PosoKanei, gov.gr, or any Greek public authority.
Related MCP server: mcp-plu-upc
Add it to your MCP client configuration:
{
"mcpServers": {
"posokanei": {
"command": "npx",
"args": ["-y", "posokanei-mcp"]
}
}
}For local development:
{
"mcpServers": {
"posokanei": {
"command": "node",
"args": ["/absolute/path/to/posokanei-mcp/dist/index.js"]
}
}
}Build first:
npm install
npm run buildTool | Purpose |
| Search products by text. |
| Get details and retailer prices for a product id. |
| Find product prices by EAN/GTIN barcode. |
| List category products, sorted by unit price by default. |
| Return a simplified category tree. |
| List known retailers. |
| Fetch product detail with history when available. |
| Fetch comparable/competitor product data when available. |
| Compare a small basket across retailers. |
| Return high-level dataset stats. |
Optional environment variables:
Variable | Default | Purpose |
|
| API base URL. |
|
| In-memory cache TTL. |
|
| Minimum delay between outbound API requests. |
|
| Request timeout. |
npm install
npm run typecheck
npm testThe test suite mocks the PosoKanei API. It should not require live network access.
MIT
Compare a small shopping basket across retailers. Items can be product ids, barcodes, or search queries. Query matching uses the first search result.
| Name | Required | Description | Default |
|---|---|---|---|
| items | Yes | Basket items. Prefer productId or barcode when possible for accuracy. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. It discloses that query matching uses the first search result, but does not mention read-only nature or other behavioral traits. Adequate but incomplete.
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?
Two sentences, no fluff. Front-loaded with purpose. Could improve by separating item types and behavior more clearly, but overall efficient.
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 and description does not explain what the comparison result contains (e.g., prices, retailers). Missing essential context for an agent to understand return value. Schema provides item limits but description lacks outcome details.
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 description inside schema suggesting preference for productId/barcode. Main description reiterates item types but adds no new parameter semantics beyond the schema. Baseline score.
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?
Clear verb 'Compare' and resource 'shopping basket'. Distinct from sibling tools like search_products or compare_competitors. Also specifies allowable item types (product id, barcode, search query).
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 allowable item types and matching behavior, but does not explicitly state when to use this tool versus alternatives (e.g., compare_competitors). Lacks when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get competitor or comparable product data for one product id when available.
| Name | Required | Description | Default |
|---|---|---|---|
| retailer | No | Optional retailer id to anchor comparison. | |
| productId | Yes | PosoKanei product id. | |
| includeTax | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It does not disclose whether the tool is read-only, what happens if no competitor data is available, error handling, or authentication requirements. The phrase 'when available' hints at conditional results but lacks detail.
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 wasted words. Front-loaded with verb and resource. Could be considered too brief but structurally efficient.
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, and description omits return format, data fields, and behavior when data is unavailable. For a tool that returns competitor data, more context is needed for an agent to handle responses correctly.
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 67% (2 of 3 parameters have descriptions). The description adds no extra meaning beyond the schema: it references 'one product id' which matches the required productId parameter, but does not clarify the role of retailer or includeTax.
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 action ('Get') and resource ('competitor or comparable product data'), and specifies it is for a single product id. It is distinct from siblings like 'compare_basket' which handles multiple products, and 'get_product' which returns single product details.
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. It mentions 'when available' but does not specify conditions or suggest other tools for different needs (e.g., search_products for searching, compare_basket for multiple products).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get product details including price history when available from PosoKanei.
| Name | Required | Description | Default |
|---|---|---|---|
| countries | No | GR | |
| priceType | No | price | |
| productId | Yes | PosoKanei product id. | |
| includeTax | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It notes price history 'when available,' but omits details on data freshness, rate limits, error handling, or what happens when history is unavailable. This is insufficient.
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, efficient sentence with no redundancy. While concise, it could be expanded slightly to improve clarity without becoming verbose.
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?
For a tool with 4 parameters, no output schema, and no annotations, the description is too minimal. It lacks details on return format, error responses, or the conditions under which price history is available, leaving significant gaps.
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 only 25% (only productId described), and the description adds no parameter details. It fails to compensate for the low coverage, leaving the agent without guidance on countries, priceType, or includeTax.
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 retrieves product details and price history from PosoKanei, which matches the tool's name and distinguishes it from siblings like get_product. However, it could be more precise about focusing on price history rather than general details.
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 no guidance on when to use this tool versus alternatives such as get_product, search_products, or compare_competitors. It lacks explicit context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details and retailer prices for one PosoKanei product id.
| Name | Required | Description | Default |
|---|---|---|---|
| countries | No | Country code list accepted by the API. Defaults to GR. | GR |
| productId | Yes | PosoKanei product id. | |
| includeTax | No | Include tax in displayed prices. | |
| sortRetailers | No | Retailer price sort order. | asc |
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 does not disclose side effects, auth requirements, rate limits, or that it is a read-only operation. The description only states what it does, not 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that conveys the essential purpose without waste. It is front-loaded and each word contributes to understanding.
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?
With no output schema and no annotations, the description is too minimal. It doesn't explain what 'details' includes, the format of retailer prices, or pagination. For a parameter count of 4 and no output schema, more context is needed.
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 clear descriptions for all parameters. The tool description adds no further meaning beyond the schema, 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 retrieves details and retailer prices for a single product ID, which is specific and distinguishes it from sibling tools like search_products that handle multiple products.
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 guidance on when to use vs. alternatives like lookup_barcode or get_price_history. The description implies usage when you have a product ID but does not specify prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get high-level PosoKanei dataset stats.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description is the sole source. It does not disclose return format, performance implications, or any constraints. For a simple tool, basic transparency about output structure is missing.
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?
Extremely concise single sentence, little waste. However, lacks structure such as breaking down what 'high-level stats' means.
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 and no annotations, the description is too vague. It doesn't specify what the stats include (e.g., counts, trends), leaving the agent uncertain about the tool's 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?
No parameters exist, and schema description coverage is 100%. The description adds no parameter info because none is needed; baseline for zero parameters 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 uses a clear verb ('Get') and identifies the resource ('high-level PosoKanei dataset stats'). It distinguishes from siblings like search_products by implying aggregate statistics, though 'high-level' is somewhat vague.
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. The context suggests it provides overview data, but no when-not-to or direct sibling comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List PosoKanei product categories. The default response is simplified because the full tree is very large.
| Name | Required | Description | Default |
|---|---|---|---|
| maxDepth | No | Maximum category tree depth to return. | |
| maxItems | No | Maximum category nodes to return. | |
| includeCounts | No | ||
| includeHidden | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description partially discloses behavior by noting the full tree is large and the default response is simplified. No other traits (auth, rate limits) are mentioned.
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?
Two short sentences, no filler. The key information about simplified default is front-loaded.
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?
Adequately describes purpose and a behavioral trait, but lacks details about the output structure, pagination, or how parameters affect the result. Missing output schema increases the burden.
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 50%; descriptions for 'includeCounts' and 'includeHidden' are missing. The description adds no parameter information, failing to compensate for the low coverage.
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 lists product categories and adds context about a simplified default response due to tree size. However, it does not differentiate from sibling tools like 'list_products_by_category'.
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 use for browsing categories but offers no explicit guidance on when to use this tool vs alternatives, nor any when-not-to-use conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List products in a PosoKanei category id, sorted by unit price by default.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | ||
| sortBy | No | unit_price | |
| category | Yes | Category id from list_categories. | |
| pageSize | No | ||
| sortOrder | No | asc | |
| isInternational | No | Filter international comparison products when set. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It mentions default sorting by unit price but omits details about pagination, sort order, filtering, return format, or any destructive/read behaviors. The description is too sparse for an agent to understand the tool's full behavior.
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 one short sentence, which is concise, but it is not fully grammatical and could be better structured. It conveys the core purpose without extraneous detail.
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?
With 6 parameters, no output schema, no annotations, and only 33% schema description coverage, the description is severely incomplete. It lacks essential information about pagination, filtering, return values, and parameter interactions.
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 only 33% (2 of 6 parameters have descriptions). The tool description adds the default sorting behavior but does not explain other parameters like page, pageSize, sortOrder, or isInternational. This is a marginal improvement over the 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 lists products for a PosoKanei category id and mentions default sorting by unit price. It distinguishes from siblings like 'list_categories' and 'search_products', but the phrasing 'in a category id' is slightly awkward.
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 guidance on when to use this tool versus alternatives (e.g., search_products). The prerequisite of obtaining a category id from list_categories is implied only in the schema description, not in the tool description itself.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List retailers known to PosoKanei.
| Name | Required | Description | Default |
|---|---|---|---|
| countries | No | Country filter. Use 'all' or 'GR'. | all |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must fully disclose behavior. It fails to mention data freshness, pagination, rate limits, or output format, offering only the basic listing action.
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, concise sentence that immediately states the purpose. Every word earns its place, with no 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?
Despite the tool's simplicity, the lack of output schema and annotations leaves significant gaps. The description does not clarify what information retailers contain (e.g., IDs, names) or if additional filtering exists.
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% for the single parameter 'countries', which is fully described in the schema. The tool description adds no extra meaning beyond the schema, meeting the baseline of 3.
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 'List retailers known to PosoKanei.' It uses a specific verb (list) and resource (retailers), and is distinct from sibling tools which focus on products, stats, and barcodes.
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 no guidance on when to use this tool versus alternatives. It does not mention exclusions or preferred contexts, leaving the agent without direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find a product by EAN/GTIN barcode and return current supermarket prices.
| Name | Required | Description | Default |
|---|---|---|---|
| barcode | Yes | 8, 12, or 13 digit barcode. | |
| countries | No | Country code list accepted by the API. Defaults to GR. | GR |
| includeTax | No | Include tax in displayed prices. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only states purpose and output; no mention of read-only nature, authentication, rate limits, or error handling (e.g., invalid barcode).
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 directly stating purpose and output. No excess words, front-loaded with key action.
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?
Tool has 3 parameters and no output schema, yet description omits details like what constitutes 'current prices,' multiple retailers, response format, or failure scenarios. Minimal completeness for a lookup 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% with descriptions for all 3 parameters. Description adds no extra meaning beyond the schema's parameter descriptions, so baseline score of 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?
Description clearly states 'Find a product by EAN/GTIN barcode and return current supermarket prices,' specifying the verb, resource, and output, effectively distinguishing from siblings like search_products (text-based) or get_product (likely by ID).
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 guidance on when to use vs. alternatives (e.g., search_products for name queries, get_product for product ID). Context signals show many sibling tools, but description offers no differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search PosoKanei supermarket products by Greek or English product text. Returns current price summaries and retailer prices.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Result page. | |
| query | Yes | Product search text, for example 'γάλα' or 'feta'. | |
| sortBy | No | Sort field. | name |
| pageSize | No | Results per page. Capped at 50. | |
| sortOrder | No | Sort order. | asc |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It mentions output includes price summaries and retailer prices, but does not disclose pagination behavior, whether searches are across all retailers, or if results are real-time. More transparency would be beneficial.
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?
Two concise sentences with no wasted words. The first sentence states the action and input, the second states output. Perfectly front-loaded and efficient.
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 full schema parameter descriptions, no output schema, and moderate complexity, the description is mostly complete. It could mention pagination behavior or that it searches across all retailers, but it's not critically missing.
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 5 parameters have schema descriptions, so baseline is 3. The description adds value by clarifying the query parameter accepts Greek or English text, and mentions outputs that give context to sortBy options (price, unit_price). This goes beyond the 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 searches PosoKanei supermarket products by Greek or English text, and returns price summaries and retailer prices. This verb+resource+scope combination distinguishes it from siblings like get_product (single product) and lookup_barcode (by barcode).
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 usage for text-based product search, but does not explicitly state when to use this tool vs alternatives (e.g., list_products_by_category for category browsing, lookup_barcode for barcode input). No exclusions or prerequisites are mentioned.
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.
v0.1.1compare_basketcompare_competitorsget_price_historyget_productget_statslist_categorieslist_products_by_categorylist_retailerslookup_barcodesearch_productsScored across 10 tools
All tools have clearly distinct purposes: search by text, ID, barcode, category, list categories, retailers, stats, price history, competitor comparison, and basket comparison. No overlapping functionality.
All tool names follow a consistent verb_noun pattern in snake_case (search_products, get_product, lookup_barcode, list_categories, compare_basket, etc.).
10 tools is well-scoped for a supermarket product and pricing database, covering the essential operations without excess or deficiency.
The tool set covers the main use cases (search, browse categories, barcode lookup, price history, competitor comparison, basket comparison). Minor gaps like retailer-specific filtering or trending data exist but do not hinder core functionality.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Read-only shopping decisions, product search, offers, and price history for Greece.
MCP server for real-time product search by barcode (EAN, UPC, GTIN) or keyword on ean-search.org
Federated commerce search across independent WooCommerce merchants. Keyless, read-only MCP server.
Unlock the power of food transparency with our Open Food Facts MCP server. Easily look up any food
