TitanStore Commerce MCP
Server Details
MCP commerce surface for compute credits, API keys, GPU instances, and cloud storage.
- Status
- Healthy
- Uptime
- 99.6% over 38 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- Fish-Tacos/sati-commerce-demo
- GitHub Stars
- 0
TDQS
Scored across 5 tools
Each tool has a distinct purpose in the purchase flow: searching products, getting details, adding to cart, checking out, and confirming payment. No overlap in functionality.
All tool names follow a clear verb_noun pattern in snake_case (e.g., add_to_cart, get_product). Even 'checkout' is a standard verb that fits the pattern.
Five tools cover the core e-commerce workflow without redundancy. The number is appropriate for the server's purpose of handling basic store operations.
The set covers the essential purchase lifecycle from search to payment confirmation. Minor gaps like cart modification or order history are absent but not critical for a basic store.
Available Tools
5 toolsadd_to_cartAInspect
Add a TitanStore product to your cart and receive a cart token. Requires a valid SKU. Returns cart_token needed for checkout.
| Name | Required | Description | Default |
|---|---|---|---|
| sku | Yes | ||
| quantity | 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 burden. It discloses the prerequisite (valid SKU) and return value (cart_token), but does not explain side effects (e.g., whether it overwrites the cart), auth requirements, or error handling. This is adequate but lacks depth.
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, front-loaded with the main purpose, and contains no extraneous information. 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?
Given the output schema exists, the description focuses on input and outcome. It explains the cart token needed for checkout, connecting to sibling tools. It could mention that quantity is optional, but overall is sufficient for a simple add-to-cart operation.
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 0%, so the description must compensate. It explains the 'sku' parameter by stating it must be valid, but does not mention 'quantity' (which has a default). This adds partial clarity but leaves a gap.
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 'Add a TitanStore product to your cart and receive a cart token', which specifies the action (add) and resource (cart). It also distinguishes from siblings like checkout and search_products by focusing on adding items before checkout.
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 'Requires a valid SKU', which provides a prerequisite. However, it does not explicitly state when to use this tool versus alternatives like checkout or search_products, leaving some guidance implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
checkoutAInspect
Initiate checkout for a cart. Provide cart_token from add_to_cart and a billing email. Returns a payment_token required to complete the purchase.
| Name | Required | Description | Default |
|---|---|---|---|
| Yes | |||
| cart_token | Yes |
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 the full burden. It discloses the action (initiating checkout), the prerequisite (cart_token from add_to_cart), the need for a billing email, and the output (payment_token). This provides some behavioral context, but it does not mention potential side effects (e.g., payment holds, cart state changes) or permission requirements, so it is only minimally transparent.
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, front-loaded with the primary action. Every word contributes: the first sentence states the purpose, the second explains inputs and output. There is no redundancy or filler, making it appropriately concise.
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 (two string parameters, no nested objects, output schema present). The description covers the essential flow: inputs, source of cart_token, and the returned payment_token. It could mention error conditions or explicitly connect to confirm_payment, but given the low complexity and existing output schema, it is largely 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?
The input schema provides only field names and types with no descriptions. The description compensates by adding semantics: cart_token is sourced from add_to_cart, and email is specifically a billing email. This makes both parameters meaningful and clarifies their purpose, though it stops short of specifying formats or validation rules.
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 initiates checkout for a cart, specifies the required inputs (cart_token from add_to_cart and a billing email), and mentions the output (payment_token). This distinct verb+resource+flow makes it easy to differentiate from sibling tools like add_to_cart, confirm_payment, get_product, and 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?
The description gives contextual guidance by instructing to provide the cart_token from add_to_cart, implying it should be used after cart building. It also notes the payment_token is required to complete the purchase, indicating a follow-up step. However, it does not explicitly name alternatives or say when not to use this tool, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
confirm_paymentAInspect
Confirm payment using a payment_token from checkout and a cc_token (credit card token). Completes the TitanStore purchase and returns an order confirmation.
| Name | Required | Description | Default |
|---|---|---|---|
| cc_token | Yes | ||
| payment_token | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description states the main effect (completes purchase and returns order confirmation) but lacks details on side effects (e.g., irreversible charge), error conditions, idempotency, or rate limits. Since no annotations are provided, the description carries the full burden, which is only partially met.
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 long (20 words), front-loaded with the key action, and contains no redundant information. Every word earns its place.
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 tool's simplicity (2 required params, no nested objects) and the presence of an output schema (which likely details the return value), the description covers the essential purpose and output. It could mention idempotency or error scenarios for completeness, but it is largely adequate.
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?
With 0% schema description coverage, the description adds meaningful context by explaining that payment_token comes from checkout and cc_token is a credit card token. It does not provide format or constraints, but the added context significantly improves understanding.
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 verb 'confirm payment', specifies the resource (payment using tokens from checkout), and indicates it completes a purchase and returns an order confirmation. It distinguishes itself from siblings like 'checkout' and 'add_to_cart'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used after obtaining payment_token and cc_token from checkout, but it does not explicitly provide when-to-use or when-not-to-use guidance, nor does it mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_productAInspect
Retrieve full details for a TitanStore product by SKU. Example SKUs: TS-001, TS-002, TS-003, TS-004, TS-005.
| Name | Required | Description | Default |
|---|---|---|---|
| sku | 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 says 'Retrieve full details' but does not disclose read-only nature, auth requirements, or what 'full details' entails beyond what output schema provides.
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, first states purpose, second provides examples. No extraneous content, 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?
Simple tool with output schema; description covers core functionality and examples. Lacks mention of error cases or data freshness, but adequate for basic retrieval.
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%, so description must compensate. It adds meaning with examples (TS-001, etc.) clarifying the SKU format, though does not specify constraints like pattern or length.
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?
Clearly states the action ('Retrieve full details') and resource ('a TitanStore product'), distinguishes from siblings like search_products by specifying retrieval by SKU.
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?
Implies usage when a specific SKU is known, but does not explicitly contrast with search_products or provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_productsAInspect
Search TitanStore product catalog. Returns matching compute credits, API keys, storage, GPU instances, and support plans. Filter by category: compute, api_access, storage, gpu, support.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| category | No |
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 but lacks details on side effects, pagination, rate limits, or ordering. Minimal behavioral disclosure beyond stating it returns matches.
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?
Three concise, front-loaded sentences. No filler. Purpose, returns, and filter options clearly stated in minimal space.
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?
Covers basic search function and filter, but lacks details on query syntax, result ordering, pagination, or default behavior. Output schema exists but its content is unknown; description does not address these 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 coverage is 0%. Description lists possible values for category parameter (compute, api_access, etc.), adding value beyond schema. However, it does not describe the query parameter meaning or format, leaving it ambiguous.
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?
Clearly states verb 'Search' and resource 'TitanStore product catalog'. Lists specific return types (compute credits, API keys, etc.) and filter options, distinguishing it from siblings like get_product (single product) and add_to_cart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for querying the catalog, but no explicit guidance on when to use alternatives like get_product or add_to_cart. Does not mention when not to use.
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.
5 tool updates
- First observed
add_to_cart - First observed
checkout - First observed
confirm_payment - First observed
get_product - First observed
search_products
Related MCP Connectors
Massed Compute MCP — GPU inventory, VM lifecycle, billing, SSH keys, and setup recipes.
Discover and pay for APIs with USDC credits. No wallet, no gas, MCP-native marketplace.
GPU cloud platform — create, manage, and monitor instances, snapshots, SSH keys, and billing.
Connect MCP clients to 2,000+ AI models without managing provider API keys.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables MCP-compatible clients to generate and upscale AI images, videos, music, and sound effects, manage generation jobs, access model catalogs, and track credits.2MIT

meshive-mcpofficial
AlicenseNot gradedqualityBmaintenanceEnables MCP-capable agents to manage Meshive GPU Cloud resources, including account, workspaces, pods, storage, GPUs, templates, serverless deployments, tasks, assets, machines, and billing history.Apache 2.0- AlicenseAqualityBmaintenanceMCP server for securely discovering, pricing, renting, connecting, and releasing GPU compute instances from AI Galaxy with budget checks and two-phase approval.8MIT
- AlicenseBqualityBmaintenanceEnables AI agents to submit GPU job requests, select eligible workers, track execution, and retrieve results via MCP.1421MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.