Agentic Product Protocol MCP Server
Integrates with Klarna's Agentic Product Protocol to provide structured product discovery, search, comparison, feed conversion, schema generation, and availability checking for AI shopping agents.
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., "@Agentic Product Protocol MCP Serversearch for organic chocolate bars"
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.
Agentic Product Protocol MCP Server
Klarna-style product discovery for AI shopping agents.
Makes product catalogs machine-readable so AI agents can search, compare, and purchase products programmatically — no screen scraping, no landing pages.
The Problem
Today's e-commerce is built for humans: landing pages, image carousels, "Add to Cart" buttons. AI shopping agents can't efficiently navigate this. They need structured product data — not HTML.
Klarna introduced the Agentic Product Protocol (December 2025) to solve exactly this: a standardized way for merchants to expose their product catalogs to AI agents. Think of it as RSS feeds, but for shopping.
Related MCP server: Nexbid
What This Server Does
This MCP server implements the core ideas of agentic product discovery:
Structured search results — not web pages, but clean JSON with name, price, nutrition, ratings
Product comparison — side-by-side structured comparison across multiple dimensions
Feed conversion — take any product feed (JSON, CSV, Open Food Facts) and normalize it into an agent-friendly schema
Schema generation — convert raw product data into the Agentic Product Protocol format
Availability checking — real-time product status in a machine-readable format
Uses Open Food Facts as a demo data source — works with any product feed.
Installation
pip install agentic-product-protocol-mcpOr with uvx (no install needed):
uvx agentic-product-protocol-mcpConfiguration
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"product-protocol": {
"command": "uvx",
"args": ["agentic-product-protocol-mcp"]
}
}
}Claude Code (CLI)
claude mcp add product-protocol -- uvx agentic-product-protocol-mcpTools
Tool | Description |
| Search products with structured results (name, nutrition, labels, stores) |
| Get full product data by barcode/ID |
| Side-by-side comparison of 2-5 products |
| Convert JSON/CSV/OFF feeds into normalized agent schema |
| Generate Agentic Product Protocol schema from raw data |
| Check product availability and store information |
Example Usage
Search for products:
"Search for organic chocolate bars"
Compare products:
"Compare these three chocolate bars: 3017620422003, 7622210449283, 7613034626844"
Convert a feed:
"Convert this Open Food Facts search into agent-friendly format: https://world.openfoodfacts.org/cgi/search.pl?search_terms=protein+bar&page_size=10"
Generate schema:
"Generate an agentic product schema for this product data: {name: 'Widget Pro', price: 29.99, category: 'Electronics'}"
Why Structured Feeds > Landing Pages
Landing Pages | Structured Feeds | |
Parsing | Screen scraping, fragile | Clean JSON, reliable |
Speed | Load page → parse DOM → extract | Single API call |
Accuracy | Layout changes break everything | Schema-validated |
Comparison | Manual extraction per site | Normalized across sources |
Agent UX | Built for human eyes | Built for agent consumption |
Data Source
This server uses Open Food Facts as its demo data source — a free, open, community-built database of food products from around the world. No API key required.
For production use, connect your own product feeds using the convert_feed tool with JSON or CSV format.
More MCP Servers by AiAgentKarl
Category | Servers |
🔗 Blockchain | |
🌍 Data | Weather · Germany · Agriculture · Space · Aviation · EU Companies |
🔒 Security | |
🤖 Agent Infra | Memory · Directory · Hub · Reputation |
🔬 Research |
License
MIT
Available Tools
6 toolscheck_availabilityA
Check real-time product availability and pricing.
Fetches current product data and returns availability status, store information, and last-updated timestamp.
Note: Open Food Facts is a community database — availability reflects reported store data, not real-time inventory.
Args: product_id: Product barcode/EAN to check
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses that availability is based on community-reported store data (not real-time inventory), which is a key behavioral trait. However, it omits other aspects like response format, error handling, or authentication needs.
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 concise with two short paragraphs and an Args section. It is front-loaded with the core purpose. No unnecessary sentences, but the Args line is somewhat redundant with the parameter description.
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 simple tool with one parameter and an existing output schema, the description covers the main functionality and data source limitation. It lists return elements (status, store, timestamp) but lacks explicit output schema details, which are presumably provided separately.
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 description adds 'Product barcode/EAN to check' for the single parameter, providing context beyond the schema's title. Despite 0% schema coverage, this adds meaningful semantics, though format constraints are missing.
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 verb ('Check'), resource ('product availability and pricing'), and scope. It differentiates from siblings like get_product_details and search_products by focusing on availability and pricing specifically.
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 does not mention exclusions or when not to use it, leaving the agent without comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_productsA
Side-by-side product comparison for AI agents.
Compares multiple products across key dimensions: nutrition, labels, environmental impact, and ingredients.
Args: product_ids: List of product barcodes to compare (2-5 products)
| Name | Required | Description | Default |
|---|---|---|---|
| product_ids | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully convey behavioral traits. It describes the comparison action and dimensions but omits details on error handling, authentication requirements, or whether the operation is read-only. It reveals the parameter constraint (2-5 products) but does not explain the return format, which is partly mitigated by the existence of an output schema.
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 extremely concise with no wasted words. It front-loads the core purpose, then lists key dimensions, and finally defines the argument. The structure is clear and easy to parse.
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 existence of an output schema, the description need not detail return values. It covers the main functionality well, but could provide slightly more context about expected behavior when ids are invalid or not found. Overall, it is sufficiently complete for a simple comparison 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?
The input schema provides minimal information (array of strings) with 0% description coverage. The description compensates fully by specifying that product_ids are 'product barcodes' and constraining them to '2-5 products', adding significant meaning beyond the schema. For a single parameter, this is excellent.
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 performs 'side-by-side product comparison' and lists specific dimensions (nutrition, labels, environmental impact, ingredients). It distinguishes itself from sibling tools like get_product_details (single product) and search_products (search) 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when comparing multiple products across dimensions, providing clear context. However, it lacks explicit when-not-to-use statements or references to alternative sibling tools for specific use cases, so it is not a perfect 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
convert_feedA
Convert a product feed URL into agent-friendly normalized schema.
Takes any product feed (JSON, CSV, Open Food Facts) and converts it into a standardized format that AI agents can easily consume.
Args: feed_url: URL to the product feed (JSON or CSV) format: Feed format — "openfoodfacts" (OFF search URL), "json" (generic JSON), or "csv" (CSV file)
| Name | Required | Description | Default |
|---|---|---|---|
| feed_url | Yes | ||
| format | No | openfoodfacts |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It states the output is a 'standardized format' but does not mention whether the operation is read-only, any side effects, or potential errors. Performance, rate limits, or state changes are not addressed.
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 extremely concise (three sentences and a bulleted Args list), front-loaded with the key purpose, and every sentence adds value. No wasted words.
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 that an output schema exists, the description does not need to explain return values. It covers input parameters and the conversion purpose. It is sufficient for a conversion tool, though it could mention possible errors or limitations.
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 has 0% description coverage in the schema itself, but the description compensates by explaining the feed_url as 'URL to the product feed' and format with its possible values and default, adding meaning beyond the bare schema properties.
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 product feed URL into a normalized schema. It specifies the verb 'convert', the resource 'product feed URL', and the outcome 'agent-friendly normalized schema', and distinguishes from siblings like generate_product_schema by focusing on external feeds.
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 mentions supported formats (JSON, CSV, Open Food Facts) but does not explicitly state when to use this tool versus alternatives like generate_product_schema. The guidance is implicit, lacking when-not-to-use or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_product_schemaA
Generate a standardized agent-readable product listing.
Takes raw product data and generates a structured schema following the Agentic Product Protocol concept — making products machine-readable for AI shopping agents.
The output schema includes:
Unique identification
Structured attributes (name, brand, category)
Pricing with currency
Availability status
Specifications and nutrition
Agent action hints (comparable, purchasable)
Args: product_data: Raw product data dict with fields like name, price, description, category, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| product_data | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses that the tool transforms raw data into a structured schema and lists output fields, implying no side effects. It is transparent enough for a simple generator.
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 well-structured with a clear one-liner, explanation, bullet list, and parameter detail. It is not overly verbose, though the bullet list could be slightly trimmed.
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 only one parameter, no annotations, and an output schema (referenced), the description fully explains the tool's operation, input requirements, and output structure, making it complete.
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 0%, but the description compensates by detailing the expected fields in 'product_data' (name, price, description, category). This adds meaningful context 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 generates a standardized agent-readable product listing from raw data, specifying the verb and resource. It implicitly distinguishes from siblings like 'check_availability' and 'search_products' by focusing on schema generation.
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 explains the tool's purpose but does not explicitly state when to use it versus alternatives or provide exclusions. It implies usage for creating machine-readable product schemas but lacks direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_product_detailsA
Get full structured product data by ID (barcode).
Returns complete product information including nutrition facts, ingredients, allergens, certifications, and environmental scores.
Args: product_id: Product barcode/EAN (e.g. "3017620422003" for Nutella)
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description implies read-only ('Get full structured product data') but does not explicitly state safety, idempotency, or side effects. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise: one-line purpose, return fields list, and parameter doc. No fluff, every sentence adds value.
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?
Has output schema and lists key return fields (nutrition, ingredients, allergens, etc.). Single parameter, low complexity. Missing guidance on when to use among siblings, but otherwise complete.
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 has 0% description coverage; description adds format (barcode/EAN) and an example, significantly clarifying the parameter beyond the schema's minimal 'Product Id'.
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 it retrieves full structured product data by barcode, specifying the resource (product) and operation (get). Example given. Distinct from siblings like search_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?
Implied usage when you have a product barcode, but no explicit when-to-use, when-not-to-use, or comparison with sibling tools like check_availability or search_products.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_productsA
Search products with agent-friendly structured results.
Returns normalized product data including name, categories, nutrition scores, labels, and availability information. Uses Open Food Facts as demo data source.
Args: query: Search term (e.g. "organic chocolate", "vegan protein") category: Optional category filter (e.g. "chocolates", "beverages") max_price: Optional maximum price filter (not available for OFF data) limit: Number of results to return (default 10, max 50)
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| category | No | ||
| max_price | No | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility. It discloses the max_price limitation and mentions normalized output structure, but omits rate limits, pagination details, or side effects. Adequate but not exhaustive.
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 concise (two short paragraphs) and well-structured: a summary sentence followed by a clear, bullet-like Args list. No redundant information.
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 annotations and the presence of an output schema (not shown), the description adequately covers input parameters and mentions the data source limitation. It lacks details on authentication, error handling, or pagination beyond limit, but is largely sufficient for a search 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?
The schema has 0% description coverage, but the tool description's Args section compensates fully by explaining each parameter with examples, defaults, and constraints (e.g., limit max 50, max_price not available for OFF). This adds significant meaning.
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 'Search products with agent-friendly structured results.' and enumerates the returned fields, making the purpose specific and distinct from siblings like get_product_details or compare_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?
The description provides search examples ('organic chocolate') and explains each parameter's role, including limitations ('not available for OFF data'). While it doesn't explicitly contrast with siblings, the context implies this is for broad keyword-based searches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.0- First observed
check_availability - First observed
compare_products - First observed
convert_feed - First observed
generate_product_schema - First observed
get_product_details - First observed
search_products
TDQS
Each tool has a distinct purpose: real-time availability, comparison, feed conversion, schema generation, detailed product info, and search. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern using underscores. Examples: check_availability, compare_products, search_products. No mixed styles.
With 6 tools, the server is well-scoped for its purpose. Each tool covers a core functionality without excess or deficiency.
The tool set covers the full lifecycle of product information retrieval: search, details, comparison, availability, schema generation, and feed ingestion. No obvious gaps for the domain.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
AI-agent product catalog: search, lookup & purchase routing over verified merchant data.
Product search for AI agents: Amazon + Shopify, cart-to-checkout buy path. Pay-per-call, no API key.
AI agent product discovery via open marketplace. Search, compare and discover advertiser products.
AI shopping gateway for product search, inventory, carts, and merchant-hosted checkout.
Related MCP Servers
- AlicenseAqualityBmaintenanceStructured product data from the open web — where platform APIs don't reach. Schema.org + AI extraction. Pay per call via Stripe MPP.2413Apache 2.0

Nexbidofficial
AlicenseNot gradedqualityDmaintenanceAgentic commerce infrastructure for AI agents. MCP-native product discovery, contextual ad matching, and purchase facilitation with European privacy compliance (nDSG/GDPR).MIT- AlicenseNot gradedqualityDmaintenanceAffiliate product search for AI agents. Indexes structured merchant feeds — real prices, live stock, affiliate links built in. Works with any MCP client.MIT

dentro MCPofficial
AlicenseAqualityDmaintenanceProvides structured commerce data for AI agents, enabling real-time product searches and brand discovery across 22,000+ DTC brands without scraping or hallucination.548MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/AiAgentKarl/agentic-product-protocol-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server