Shopify Insights MCP
Provides actionable business insights for Shopify stores, including sales summaries with period-over-period comparisons, product performance ranking, inventory alerts (out-of-stock, low stock, overstock), trending products, customer segmentation, order alerts for delayed fulfillment, and fulfillment metrics.
Click on "Deploy 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., "@Shopify Insights MCPHow are sales this month compared to last month?"
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.
Shopify Insights MCP
MCP Server for Shopify that delivers actionable business insights — comparisons, alerts, and recommendations, not just numbers.
Demo
https://github.com/user-attachments/assets/4541bf2d-8974-4944-b3cb-4b8597d071cf
Related MCP server: Shopify MCP Server
Why This Exists
Existing Shopify MCP servers return raw data. Shopify Insights MCP answers "what does it mean?" and "what should I do?":
Other MCPs | Shopify Insights MCP |
"You have $45,000 in sales" | "You have $45,000, 12% less than last month" |
"List of 50 products" | "5 products have critical stock and high demand" |
"10 pending orders" | "3 orders have been unfulfilled for 5+ days" |
Stack
TypeScript + MCP SDK (
@modelcontextprotocol/sdk)Shopify Admin API (GraphQL)
Zod for input validation
Transport: stdio
Installation
Option A: npm (recommended)
npm install -g shopify-insights-mcp
shopify-insights-mcp initThe init command will guide you through connecting your Shopify store and generate the Claude Desktop configuration.
Option B: From source
git clone https://github.com/VenticinqueMauro/shopify-insights-mcp.git
cd shopify-insights-mcp
npm install
npm run build
npm run setup # Guided configurationShopify App Requirements
You need a Custom App with these scopes:
read_orders,read_products,read_customers
Create one at: Shopify Admin > Settings > Apps and sales channels > Develop apps
Build & Run
npm run build # Compile TypeScript → dist/
npm start # Run the MCP server (stdio)
npm run setup # Guided setup wizard
npm run inspector # Open MCP Inspector for debuggingUsage with Claude Desktop
Quick setup (via npx)
{
"mcpServers": {
"shopify-insights": {
"command": "npx",
"args": ["-y", "shopify-insights-mcp"],
"env": {
"SHOPIFY_SHOP_DOMAIN": "your-store.myshopify.com",
"SHOPIFY_ACCESS_TOKEN": "shpat_your_token"
}
}
}
}Local install
{
"mcpServers": {
"shopify-insights": {
"command": "node",
"args": ["/path/to/shopify-insights-mcp/dist/index.js"],
"env": {
"SHOPIFY_SHOP_DOMAIN": "your-store.myshopify.com",
"SHOPIFY_ACCESS_TOKEN": "shpat_your_token"
}
}
}
}Run
shopify-insights-mcp initto generate this config automatically.
Then ask Claude things like:
"How are sales this month compared to last month?"
"Which products are trending up?"
"Are there any orders that need urgent attention?"
"How are my customers segmented?"
Configuration
Required Environment Variables
Variable | Description |
| Your store domain (e.g., |
| Admin API access token (starts with |
Optional Environment Variables
Variable | Default | Description |
| Auto-detected from store | IANA timezone override (e.g., |
|
| Shopify Admin API version |
|
| Maximum records fetched per tool call. Increase for large stores |
Tools (10)
Sales & Revenue
Tool | Description |
| Sales summary with period-over-period comparison. Revenue, orders, AOV, units sold |
| Side-by-side comparison of two custom date ranges |
| Revenue broken down by product, vendor, or product type |
Products & Inventory
Tool | Description |
| Product ranking by revenue, units sold, or order count |
| Stock alerts: out-of-stock, low stock, overstock detection |
| Trending products (rising/falling) vs. previous period |
Customers
Tool | Description |
| Automatic segmentation: VIP, Loyal, Returning, New, Inactive |
| Customer ranking by total spend or order count |
Operations
Tool | Description |
| Orders needing attention: delayed fulfillment, financial issues, high-value pending |
| Operational metrics: fulfillment rate, financial status, health score |
Architecture
src/
├── index.ts # Entry point
├── server.ts # Tool registration & request handler
├── shopify/
│ ├── auth.ts # Credentials from env vars
│ ├── client.ts # GraphQL wrapper
│ └── queries/ # Orders, products, customers queries
├── tools/
│ ├── sales/ # 3 sales tools
│ ├── products/ # 3 product tools
│ ├── customers/ # 2 customer tools
│ └── operations/ # 2 operations tools
├── analytics/
│ ├── comparisons.ts # Change calculation (%, direction)
│ ├── insights.ts # Automatic insight generation
│ └── recommendations.ts # Actionable recommendations
├── types/
│ └── shopify.ts # Shared GraphQL types
└── utils/
├── dates.ts # Period handling & date formatting
├── formatting.ts # Currency, percentage, number formatting
└── errors.ts # Standard error handlingExample Output
📊 SALES SUMMARY - THIS MONTH
CURRENT METRICS:
• Revenue: $1,245,000.00
• Orders: 234
• Avg Order Value: $5,320.51
• Units Sold: 892
VS. PREVIOUS MONTH:
• Revenue: +18.0% (+$190,000.00)
• Orders: +12.0% (+25)
• Avg Order Value: +5.4% (+$272.00)
💡 INSIGHTS:
• 📈 Revenue grew 18.0% compared to the previous period.
• 🛒 Order volume increased 12.0% (+25 orders).
📋 RECOMMENDATIONS:
• 🚀 Leverage the positive momentum by increasing investment in top-performing channels.
• 📦 Ensure sufficient stock to sustain demand growth.Testing
# Run unit tests
npm test
# Manual test via JSON-RPC over stdio
export $(grep -v '^#' .env | xargs)
echo '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_sales_summary","arguments":{"period":"month"}}}' | node dist/index.js
# Or use MCP Inspector
npm run inspectorContributing
Contributions are welcome! Feel free to open issues or submit pull requests.
License
MIT
Available Tools
10 toolsget_customer_segmentsA
Segment customers into VIP, Loyal, Returning, New, and Inactive based on order history and spending. Shows distribution and average spend per segment.
| Name | Required | Description | Default |
|---|---|---|---|
| period | No | Period to determine activity (default: month) | month |
| endDate | No | End date (only for custom period) | |
| startDate | No | Start date (only for custom period) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior itself. It does state the analytical output (distribution and average spend per segment) and implies a read-only reporting operation, but it does not explain segment thresholds, period semantics beyond the schema, or any side effects. This is adequate but not rich.
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 filler, with the core purpose front-loaded and the output summarized immediately. The segment list is compact yet informative.
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 report-style tool with no required parameters, the description names the returned aggregate outputs (distribution and average spend) and the schema documents the optional parameters. It does not specify exact output structure or segment-rule thresholds, but an agent has enough to invoke it 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 100%, with all three parameters (period, endDate, startDate) already described, including the period enum and default. The description adds no parameter-specific meaning, so the baseline 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?
The description names a specific action (segment), a clear resource (customers), and enumerates the resulting segment types (VIP, Loyal, Returning, New, Inactive) along with the basis (order history and spending). This clearly distinguishes it from sibling analytics tools such as get_revenue_breakdown or get_inventory_alerts.
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 makes the tool's context clear: an agent should use it when customer segmentation by purchasing behavior is needed and to see segment distribution and average spend. It does not explicitly contrast with get_top_customers or state when not to use it, but the purpose is specific enough to imply correct routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fulfillment_metricsB
Get operational metrics: fulfillment status breakdown, financial status distribution, average order value by status, and operational health indicators.
| Name | Required | Description | Default |
|---|---|---|---|
| period | Yes | Time period to analyze | |
| endDate | No | End date — only required when period is "custom" | |
| startDate | No | Start date — only required when period is "custom" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It signals a safe read-only aggregation through 'Get' and enumerates computed metrics, but it does not mention permissions, date-range semantics, or aggregation details. This is adequate but thin for a tool with zero annotation coverage.
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 front-loaded sentence, starting with the core action and resource and then providing a compact enumeration of metric categories. Every phrase earns its place with no filler or 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?
The tool is simple and its parameters are fully described in the schema, but there is no output schema and no annotation context. The description lists return categories but omits when to prefer this tool over sibling metrics tools and does not clarify the return structure beyond high-level categories. Adequate for a straightforward call, but several contextual gaps remain.
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 already documents all three parameters with 100% coverage, so the baseline is 3. The description adds no parameter-specific meaning beyond mentioning metrics that relate to status, and there is no schema gap requiring compensation.
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 identifies a read operation for operational metrics and itemizes what it returns: fulfillment status, financial status, average order value by status, and health indicators. It does not explicitly contrast with sibling sales/revenue tools, leaving some overlap ambiguity, so it is clear but not fully differentiated.
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 is given about when to use this tool instead of get_sales_summary, get_revenue_breakdown, or other siblings. The description only states what the tool returns, leaving the agent to infer the triggering scenario. This is effectively no usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_inventory_alertsA
Check inventory levels across all products. Identifies out-of-stock and low-stock variants that need attention.
| Name | Required | Description | Default |
|---|---|---|---|
| low_stock_threshold | No | Units at or below this number are considered low stock (default: 5) | |
| include_out_of_stock | No | Include variants with zero inventory (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the general purpose but is ambiguous about whether it returns all product inventory levels or only filtered alert rows, and it does not mention output format, pagination, or read-only guarantees.
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, front-loaded with the resource and intent. Every word contributes meaning, and there is no redundant restating of the tool name or schema details.
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?
The tool is simple with two optional self-documenting parameters and no output schema, but the description leaves some ambiguity about whether output includes every product or only problematic variants. It is adequate for basic invocation but not fully complete for predicting the return shape.
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 provides 100% coverage of both parameters with clear descriptions and defaults, so the description does not need to add much. It does not explain how low_stock_threshold and include_out_of_stock map to the alerting behavior, but the schema already handles that sufficiently.
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 identifies a specific resource (inventory levels) and the operation (checking/identifying out-of-stock and low-stock variants). The phrase 'across all products' gives scope, and the inventory-specific focus clearly distinguishes it from sibling tools like get_sales_comparison or get_order_alerts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for monitoring inventory and finding variants that need attention, which gives a sense of when to use it. However, it does not explicitly state when not to use it or name any alternatives, leaving usage decisions to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_order_alertsA
Identify orders that require immediate attention: unfulfilled orders older than N days, financially problematic orders (refunded, voided), and high-value pending orders.
| Name | Required | Description | Default |
|---|---|---|---|
| lookbackDays | No | How many days back to look for orders (default: 30) | |
| highValueThreshold | No | Minimum order amount to flag as high-value pending (default: 50000) | |
| pendingDaysThreshold | No | Days since order was placed to flag as delayed (default: 3) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description conveys the selection criteria and implies a read-only 'identify' behavior, which is useful since no annotations are provided. It does not, however, describe what the output looks like, whether alerts are aggregated or itemized, or any limitations such as pagination or data recency, leaving meaningful transparency gaps.
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 front-loads the primary purpose and then lists the three alert categories. It contains no filler or redundant wording and remains 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?
For a read-only alert tool, the description covers the main selection categories, but the absence of an output schema means it should have explained what the tool returns (list, counts, order IDs, etc.). The relationship between lookbackDays and the alert categories is also left implicit, so an agent has to infer some behavior from parameter names and siblings.
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 three parameters are documented in the schema with descriptions and defaults, and the description's references to 'N days' and 'high-value pending' map loosely to those parameters. The description adds little beyond the schema, so the 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?
The description uses a specific verb ('Identify') and a specific resource ('orders that require immediate attention'), and elaborates with concrete alert categories (unfulfilled, refunded/voided, high-value pending). This clearly distinguishes it from sibling tools like get_inventory_alerts or get_sales_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: when you need to surface orders needing attention. However, it does not explicitly state when not to use it or point to alternative tools for related queries, so the guidance is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_product_performanceA
Rank products by revenue, units sold, or order count for a given period. Shows detailed per-product metrics including AOV and share of total.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top products to show (default: 10) | |
| period | Yes | Time period | |
| endDate | No | End date (only for custom period) | |
| sort_by | No | Metric to sort by (default: revenue) | revenue |
| startDate | No | Start date (only for custom period) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description conveys the main behavior: the tool ranks products and shows per-product metrics like AOV and share of total. With no annotations provided, the description carries the burden of disclosure; it clearly indicates a read-style reporting behavior but does not mention pagination, data recency, or any potential side effects. This is adequate but not rich.
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 two concise sentences with no wasted words. It front-loads the primary purpose and then states the key output metrics, making it efficient for an agent to scan and understand quickly.
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 moderately complex reporting tool with no output schema, the description covers the core purpose and some return metrics but leaves the full output structure undefined. The schema covers parameter details, and the description plus schema are likely sufficient for basic invocation, but there are gaps around full return fields and any constraints on the ranking behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters and their defaults. The description adds some interpretive value by mentioning revenue, units sold, order count, AOV, and share of total, which maps to the sort_by enum and expected output, but it does not add meaningful semantics 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 identifies a specific action ('Rank products'), the resource ('products'), the ranking dimensions ('revenue, units sold, or order count'), and a time scope ('for a given period'). It does not explicitly contrast with sibling tools like get_trending_products, but the described output is distinct enough to be recognizable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: when an agent needs a ranked list of top products by revenue, units, or orders for a period. It does not provide explicit when-to-use versus when-not-to-use guidance or mention any alternative tool, leaving routing decisions somewhat to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_revenue_breakdownC
Break down revenue by product, vendor, or product type for a given period.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top results to show (default: 10) | |
| period | Yes | Time period | |
| endDate | No | End date — only required when period is "custom" | |
| dimension | No | Dimension to group by (default: product) | product |
| startDate | No | Start date — only required when period is "custom" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior, but it only restates the tool's grouping and period parameters. It does not mention that results are limited to top N, whether revenue is summed/sorted, how custom date ranges behave, or whether the operation is read-only. The schema covers parameter mechanics, but the description adds no behavioral context beyond the function name.
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?
A single sentence, front-loaded with the action verb and key grouping dimensions, with no redundant or filler wording. Every word contributes to the core meaning.
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?
The description is too sparse for a reporting tool with 5 parameters, a custom-period workflow, and multiple closely related siblings. It does not explain the output shape, the top-N limiting behavior, when custom start/end dates are needed, or how to choose among sibling sales/revenue tools. The full behavior is left to inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-level meaning. It does align 'product, vendor, or product type' with the dimension enum, but it does not clarify custom-date requirements or the top-results behavior beyond what the schema already states.
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 names a specific action ('break down'), a resource ('revenue'), and the grouping dimensions (product, vendor, product type), which clearly communicates the tool's function. It does not explicitly contrast with sibling tools like get_sales_summary or get_sales_comparison, but the dimension-focused wording is distinctive enough for an agent to infer its purpose.
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?
There is no guidance on when to use this tool versus alternatives such as get_sales_comparison, get_product_performance, or get_sales_summary. The description implies the use case for revenue breakdowns, but it does not state exclusions, prerequisites, or conditions that would route an agent to a sibling tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_sales_comparisonB
Compare sales metrics between two explicit date ranges side by side.
| Name | Required | Description | Default |
|---|---|---|---|
| period1End | Yes | End date for period 1 | |
| period2End | Yes | End date for period 2 | |
| period1Label | No | Label for period 1 (default: "Period 1") | |
| period1Start | Yes | Start date for period 1 | |
| period2Label | No | Label for period 2 (default: "Period 2") | |
| period2Start | Yes | Start date for period 2 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the behavioral burden. 'Compare sales metrics' implies a read-only reporting behavior, but the description does not disclose return format, aggregation level, or handling of edge cases like overlapping date ranges. It is not misleading, but it is thin.
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?
A single sentence with no filler, front-loading the core verb and resource before the scoping detail. Every word contributes to understanding the tool's purpose.
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?
The tool has no output schema and no annotations, so the description should provide more context about what 'sales metrics' means and what the comparison result looks like. It does not state whether differences, percentages, or absolute values are returned, leaving an agent to guess the output shape.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already fully documented. The description adds no meaningful parameter semantics beyond framing the dates as two comparison periods, which matches the baseline for high schema 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 uses a specific verb ('Compare'), a clear resource ('sales metrics'), and a defining scope ('between two explicit date ranges'). It is clearly distinct from siblings like get_sales_summary or get_revenue_breakdown, though it does not explicitly name an alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for side-by-side comparison of two periods, but it does not state when to prefer it over siblings or mention any exclusions. There is no explicit when-to-use guidance beyond the obvious comparison scenario.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_sales_summaryB
Get a sales summary with revenue, orders, and AOV. Optionally compare with previous period.
| Name | Required | Description | Default |
|---|---|---|---|
| period | Yes | Time period | |
| endDate | No | End date — only required when period is "custom" | |
| startDate | No | Start date — only required when period is "custom" | |
| compareWithPrevious | No | Compare with previous period |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It names returned metrics but does not explain how comparison is represented, whether comparison output is included by default, or any other behavior around aggregation, date handling, or response structure.
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 very concise and front-loaded. Both sentences are useful, with the core purpose stated first and the optional comparison behavior stated second. There is no filler or 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?
The description is adequate for a simple summary tool, especially with full parameter schema coverage. However, without annotations or an output schema, it could be more complete by clarifying comparison output behavior and how this tool relates to get_sales_comparison.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters effectively. The description adds minimal semantic value beyond naming output metrics, but it does not need to compensate because parameter meanings are already explicit in 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 gets a sales summary with specific metrics (revenue, orders, AOV). It is distinguishable from siblings by its focus on summary metrics, though it does not explicitly differentiate itself from get_sales_comparison, especially since it also mentions optional 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?
No guidance is given about when to use this tool versus alternatives like get_sales_comparison or get_revenue_breakdown. The optional comparison behavior creates ambiguity with the dedicated comparison sibling, and there is no explicit routing or exclusion noted.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_top_customersB
Rank customers by total spend or order count. Identifies VIP customers and spending patterns.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top customers to show (default: 10) | |
| sort_by | No | Metric to rank by (default: total_spent) | total_spent |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It discloses that the tool ranks customers by spend or order count and surfaces VIP customers, which implies a read-only aggregation. However, it does not describe the output shape, any limits, or whether it includes customer identifiers. Still, the behavior is mostly predictable from the name and 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?
Two short sentences with the main action first and no filler. The second sentence adds a small insight about the tool's purpose without bloating the description. This is an efficient, front-loaded structure.
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 read tool with two optional params, the description is mostly adequate. However, the absence of any statement about return values or how 'VIP' is defined leaves some ambiguity. It also does not distinguish from neighboring customer tools, which matters when no output schema 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%, so the description need not re-document parameters. It does directly map 'total spend' and 'order count' to the sort_by enum, reinforcing the parameter semantics. No additional format or syntax details are provided, but none are necessary given 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 uses a specific verb ('Rank') with a clear resource ('customers') and identifies the two ranking dimensions (total spend, order count). It is distinct from sibling get_* tools by focusing on top customers rather than segments, alerts, or summaries. The phrase 'Identifies VIP customers' adds marketing flavor but does not obscure the core purpose.
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?
There is no explicit guidance on when to prefer this tool over siblings like get_customer_segments or get_sales_summary. The description does not mention any exclusions or conditions, leaving the agent to infer use cases from the tool name alone. This is a significant gap given the large sibling set.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trending_productsA
Identify trending products by comparing sales between the current period and the previous one. Shows growth rates, rising stars, and declining products.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of products to show (default: 10) | |
| period | No | Period to analyze (compares current vs previous) | week |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It explains the comparison logic and the kinds of insights returned, which is useful. It does not mention the output structure, pagination, or any assumptions about how periods are calculated, but for a read-only analysis tool the core behavior is conveyed.
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 two sentences with no filler. It front-loads the core purpose and then lists the output categories, making it easy for an agent to scan and understand quickly.
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 two optional parameters and no output schema, the description covers the main behavior and output categories well. It could be more complete by describing the return format or clarifying period boundaries, but nothing essential is missing for selecting and invoking the 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 description coverage is 100%, so the parameters are already well documented in the schema. The description adds no new parameter-level meaning beyond reinforcing that the period parameter compares current to previous, which the schema already states. 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 identifies what the tool does: identify trending products by comparing current versus previous sales periods, and it names the outputs (growth rates, rising stars, declining products). It is distinct from siblings like get_sales_comparison and get_product_performance, though it does not explicitly name an alternative.
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 intended use case is implied: use it when you need to surface products that are trending or declining based on period-over-period sales. However, it offers no explicit guidance about when to choose this tool over related siblings such as get_product_performance or get_sales_comparison.
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.
10 tool updates
v1.1.0- First observed
get_customer_segments - First observed
get_fulfillment_metrics - First observed
get_inventory_alerts - First observed
get_order_alerts - First observed
get_product_performance - First observed
get_revenue_breakdown - First observed
get_sales_comparison - First observed
get_sales_summary - First observed
get_top_customers - First observed
get_trending_products
TDQS
Scored across 10 tools
Most tools target distinct analytical questions, but there is meaningful overlap: get_sales_comparison and get_sales_summary both support period comparison, and get_product_performance, get_trending_products, and get_revenue_breakdown all examine product sales from different angles. The descriptions help, but an agent could still hesitate between these related tools.
Every tool follows the same get_<metric> snake_case pattern with clear noun phrases. The naming is entirely predictable and consistent across all ten tools.
Ten tools is a well-scoped size for a Shopify insights server. Each tool covers a meaningful analytical area without unnecessary bloat or redundancy.
The tool surface covers core merchant insights across sales, revenue, products, inventory, customers, orders, and fulfillment. It lacks direct raw order or product list retrieval, but those are outside the apparent read-only insights purpose, so the gaps are minor.
Maintenance
Related MCP Connectors
Ask questions across Shopify, Klaviyo, GA4 and 20+ e-commerce sources in plain English.
Run storefronts, listings, orders, content, fulfillment, and analytics through AI.
Commerce intelligence for AI agents. Diagnose drop-offs, fix checkouts, optimize pricing.
Shopify App Store intelligence: keyword ranks, competitors, reviews, revenue. Free tier.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables e-commerce shop owners to query their business data using natural language through local AI models. Provides secure, privacy-focused access to sales reports, inventory management, customer analytics, and order data without sending sensitive information to external services.-
- AlicenseAqualityDmaintenanceProvides AI assistants with real-time access to Shopify store analytics, sales data, and inventory through ShopifyQL and the Admin GraphQL API. It enables users to query store performance, customer metrics, and marketing insights using natural language.13MIT
- AlicenseAqualityCmaintenanceEnables AI assistants to forecast revenue and demand for Shopify stores using Google's TimesFM model. Provides tools for revenue forecasting, demand analysis, promotion analysis, and anomaly detection.71MIT

Presso MCP Serverofficial
AlicenseNot gradedqualityDmaintenanceConnects e-commerce and marketing data sources like Shopify, GA4, Google Ads, and Meta Ads to AI assistants, enabling natural language queries about store performance, ad campaigns, and customer behavior.7 npm2MIT