MCP server for interacting with Shopify stores via the ShopifyAPI
This server defines only 2 tools with basic parameter schemas and minimal descriptions. Both tools have action-verb names (get-product-list, get-customer-list) which is correct, but descriptions are minimal (22-23 characters) and parameters lack critical information like ranges, defaults, and validation. No output schemas are documented. Error handling is generic, the try/catch wraps the entire handler and returns a single TextContent with error strings, offering no recovery guidance. The tool definitions ARE explicitly visible in the source (via @server.list_tools() decorator), so they are not inferred. However, parameter descriptions are missing entirely from the schema objects (only 'limit' is described in the property definition, but lacks explanation of what limit does, whether it has bounds, or what default behavior is). Critical issues: (1) Parameters lack descriptions explaining their purpose and constraints; (2) No output schema documentation; (3) Generic error messages with no recovery hints; (4) No input validation documented; (5) Tool descriptions are under the 34-character baseline minimum for effective LLM selection.
Get a list of customers from the Shopify store
Get a list of products from the Shopify store
Parameter descriptions are missing. The 'limit' parameter in both tools has a description in the inputSchema ('Maximum number of products to return (default: 10)'), but this is insufficiently specific. No minimum/maximum bounds are declared, no explanation of behavior when limit is exceeded, and no guidance on typical values. Per the rubric baseline, 100% of A+ tools have descriptions for ALL parameters; this has only minimal inline documentation.
Tool descriptions are too short (22-23 characters) and lack guidance on when to use each tool. 'Get a list of products from the Shopify store' is borderline; 'Get a list of customers from the Shopify store' is similarly generic. Neither explains WHEN to call this tool vs another, what prerequisites exist (e.g., authentication), or what the response structure contains.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | F | 41 | 2026-07-28+ | v2 |
| 2026-03-09 | F | 40 | - | v1 |
No output schema documentation. The source code defines @server.call_tool() which returns list[types.TextContent | types.ImageContent | types.EmbeddedResource], but the tool registration (in handle_list_tools) does NOT include an outputSchema field. LLMs cannot infer what fields to expect in the returned text (e.g., is it CSV, JSON, markdown?). Per the rubric critical check: 'Document the output schema. LLMs need to know what fields to expect so they can plan downstream tool calls.' 100% of A+ tools have documented return types.
Error handling provides no recovery guidance. The try/catch in handle_call_tool catches all exceptions and returns a generic 'Error executing tool: {str(e)}' message. Per the rubric critical check: 'Error responses must tell the LLM what to do next.' Examples: if Shopify auth fails, the error should suggest checking credentials; if limit is invalid, it should explain valid range; if products are empty, it should suggest alternative searches. Currently, the LLM receives no actionable guidance.
No input validation or constraint documentation. The code calls int(arguments.get('limit', 10)) without bounds checking. Per the rubric: 'Specify minimum and maximum for numeric parameters (e.g. page_size 1 - 100, days 1 - 365). Unbounded numbers let LLMs pass absurd values.' There is no validation that limit > 0, no upper bound (an LLM could request limit=1000000), and no documentation of expected range in the schema or description.
Credentials exposed to environment without server-level validation. The init_shopify() function reads SHOPIFY_SHOP_URL, SHOPIFY_API_KEY, SHOPIFY_PASSWORD, SHOPIFY_ACCESS_TOKEN from environment. While this is not a tool parameter (good), the function raises a ValueError if any are missing, but this error is caught by the generic handler and returned as TextContent. The LLM sees only 'Error executing tool: Missing required Shopify credentials...', it cannot retry or self-correct. Additionally, the credentials are revalidated on every tool call, which is inefficient.
No pagination support for large result sets. Both tools accept a 'limit' parameter but do not document pagination (offset, page, cursor). Per the rubric critical check: 'Tools returning lists should accept page/offset and limit parameters and return a total count or next_cursor. Without pagination, large results blow the context window.' If a Shopify store has thousands of products, this tool will be forced to cap results (currently silent) or risk context overflow.
No response structure documented or validated. The tool calls format_product() and format_customer() which return plain text strings joined by newlines and a '---' separator. This is unstructured and requires the LLM to parse text to extract individual fields (title, id, price, email, etc.). Per the rubric: 'Return structured objects with typed fields. Free-text responses require the LLM to parse unstructured output, which is error-prone and wastes tokens.' A proper response should be JSON with typed fields (products: [{id, title, vendor, price, status}]).