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., "@Tarigri Surgical MCP Server find stainless steel tissue forceps and quote me 100 units"
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.
A Model Context Protocol server for tarigrisurgical.com, a Sialkot (Pakistan) manufacturer of stainless steel surgical, dental, orthopedic and ENT instruments. It lets AI assistants search the wholesale catalog, price quantities and prepare an order request.
Built from qmmughal/mcp-server-template, upgraded to the high-level McpServer API (SDK 1.32).
Area | Status |
Transports | stdio (local, |
Protocol | Negotiated by the official TypeScript SDK (2025-06-18 and earlier) |
Tools | 6 tools, each with |
Errors | Tool failures return |
Resources | Static |
Prompts |
|
Server info |
|
Safety | Read-only; nothing is ordered or sent. stdout is reserved for JSON-RPC, logs go to stderr |
Testing | 24 tests, including protocol-level tests through a real MCP |
Not implemented | Authentication (public catalog data), sessions/SSE streams (stateless by design), sampling/elicitation (not needed) |
Related MCP server: MCP Catálogo Bioquímica.cl
Tool | Purpose |
| Filter by text, category, max price, best sellers |
| Full details for a SKU (price, MOQ, 50+/100+ tiers, material, size, URL) |
| The 8 categories with product counts |
| Indicative total for SKU + quantity lines; applies volume tiers, flags quantities below MOQ |
| Contact details, hours, buyer FAQ |
| Drafts the quotation request as text plus |
All prices are factory-direct wholesale USD, FOB Sialkot; shipping is quoted separately by Tarigri.
The site is a client-rendered SPA with no API, but it publishes its catalog as /data.js. The server fetches it, validates it with Zod, converts PKR prices to USD using the site's own rate, and caches it in memory (default 15 min, stale copy served if a refresh fails).
npm install
npm run build # dist/index.js (single bundled executable with shebang)
npm test
npm run inspect # opens the official MCP Inspector against the buildVariable | Default | Meaning |
|
| Site serving |
|
| Catalog cache lifetime |
|
| Logs go to stderr only |
|
| Pretty logs when running from source with tsx (not the bundle) |
The repo is Vercel-ready: api/mcp.ts is the function, /mcp is rewritten to it, and public/index.html is a landing page with copy-paste configs.
Vercel dashboard → Add New → Project → import qmmughal/tarigrisurgical-mcp-server (or run npx vercel login && npx vercel --prod).
Keep the defaults (vercel.json sets the framework and output directory). No env vars are required.
Optional: add a domain such as mcp.tarigrisurgical.com under Project → Domains.
Your endpoint is then https://<your-domain>/mcp. The endpoint is public and unauthenticated by design (it only exposes the public catalog). Add Vercel's WAF/rate limiting if you expect heavy traffic.
Replace <URL> with your Vercel endpoint (https://…/mcp). Until the package is published to npm, use the local node form with the absolute path to dist/index.js instead of npx.
Claude Code
claude mcp add --transport http tarigri-surgical <URL>
# or local: claude mcp add tarigri-surgical -- node /abs/path/dist/index.jsClaude Desktop: Settings → Connectors → Add custom connector with <URL>, or claude_desktop_config.json:
{ "mcpServers": { "tarigri-surgical": { "command": "node", "args": ["/abs/path/dist/index.js"] } } }Cursor (.cursor/mcp.json)
{ "mcpServers": { "tarigri-surgical": { "url": "<URL>" } } }VS Code / GitHub Copilot (.vscode/mcp.json)
{ "servers": { "tarigri-surgical": { "type": "http", "url": "<URL>" } } }Windsurf (~/.codeium/windsurf/mcp_config.json)
{ "mcpServers": { "tarigri-surgical": { "serverUrl": "<URL>" } } }Gemini CLI (~/.gemini/settings.json)
{ "mcpServers": { "tarigri-surgical": { "httpUrl": "<URL>" } } }Codex CLI (~/.codex/config.toml)
[mcp_servers.tarigri-surgical]
command = "node"
args = ["/abs/path/dist/index.js"]Any client that only supports stdio: npx -y mcp-remote <URL>.
data.js is evaluated in an empty node:vm context with a timeout, then schema-validated. vm is not a security sandbox, so only point TARIGRI_SITE_ORIGIN at a site you trust.
Product images on the site are illustrative; CE/ISO certificate numbers are not published, only "available on request". The server never claims more.
If the site changes the shape of data.js, validation fails with a clear error rather than returning bad data.
MIT
Draft a wholesale order request for Tarigri as email text plus ready-to-click mailto: and WhatsApp links. Nothing is sent; the user must open the link and send it themselves.
| Name | Required | Description | Default |
|---|---|---|---|
| items | Yes | ||
| notes | No | e.g. OEM/private label, CE/ISO documents, samples | |
| company | No | ||
| buyer_name | No | ||
| destination_country | No | Country the goods ship to; Tarigri quotes shipping per destination |
| Name | Required | Description |
|---|---|---|
| body | Yes | |
| sent | Yes | |
| mailto | Yes | |
| subject | Yes | |
| warnings | Yes | |
| Yes | ||
| indicativeSubtotalUsd | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety bar is lower; the description still adds real value by clarifying that no message is transmitted and that delivery is a manual user action via the generated links. It does not cover edge behavior such as what happens with unknown or out-of-catalog SKUs, but the send-boundary disclosure is the most important trait here.
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, zero filler, with the action and output format front-loaded and the send-safety caveat immediately after. Every clause 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?
An output schema exists, so the mailto/WhatsApp return format need not be detailed, and the read-only nature is covered. However, for a five-parameter composition tool with 40% schema coverage, the near-total silence on parameter meaning (especially the undifferentiated company/buyer_name fields) leaves gaps an agent must guess at.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 40%: 'company' and 'buyer_name' have no description at all, and the description contributes nothing about any of the five parameters, not even that 'items' drives the order lines or that 'destination_country' affects shipping quotes. Below 50% coverage, the description was expected to compensate and does not.
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?
States a specific verb and resource ('Draft a wholesale order request for Tarigri') and names the exact deliverables (email text, mailto: link, WhatsApp link). This is unmistakably distinct from siblings like estimate_quote or search_products, which retrieve data rather than compose a message.
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 sentence 'Nothing is sent; the user must open the link and send it themselves' implies the correct usage context (composing an inquiry for the user to dispatch), but there is no explicit statement of when to prefer this over estimate_quote for pricing questions or get_company_info for vetting Tarigri first. Usage is inferable rather than guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compute an indicative wholesale price for SKUs and quantities, applying volume tiers (50+/100+) and flagging quantities below MOQ. Excludes shipping; Tarigri issues the final quotation.
| Name | Required | Description | Default |
|---|---|---|---|
| items | Yes |
| Name | Required | Description |
|---|---|---|
| lines | Yes | |
| notes | Yes | |
| incoterm | Yes | |
| subtotalUsd | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds meaningful domain behavior beyond that: volume tiers at 50+/100+, MOQ flagging, shipping exclusion, and that final quotations come from Tarigri. It does not describe external-system interaction implied by openWorldHint, but the added domain context is substantial.
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, front-loaded with the core computation and followed by the key exclusions and final-quotation context. Every sentence earns its place with no redundant or filler wording.
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?
An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description provides the essential domain rules (tiers, MOQ, shipping exclusion, final quotation by Tarigri) but does not clarify external pricing-system behavior implied by openWorldHint or any edge cases around invalid SKUs.
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 context signals 0% schema description coverage, so the description must compensate. It identifies that items are SKUs and quantities and explains quantity-based volume tiers and MOQ flagging, but it does not describe the nested object structure, the maximum of 50 items, or the SKU format example beyond what the schema itself shows.
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?
States a specific verb (compute) and resource (indicative wholesale price) with clear scope: SKUs, quantities, volume tiers, MOQ flagging, shipping exclusion, and final quotation handled elsewhere. An agent can distinguish it from sibling tools like search_products or draft_inquiry without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for indicative pricing and notes it excludes shipping and that Tarigri issues the final quotation, but it does not explicitly say when to use this tool versus alternatives like draft_inquiry or search_products. Usage is implied rather than stated with clear when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tarigri Surgical contact details, business hours, ordering process, and buyer FAQ (MOQ, OEM, CE/ISO, markets, pricing).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| faq | Yes | |
| name | Yes | |
| Yes | ||
| hours | Yes | |
| phone | Yes | |
| tagline | Yes | |
| website | Yes | |
| location | Yes | |
| Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. The description contributes the substantive behavioral fact that this is a static informational lookup covering buyer-policy topics, but adds nothing about caching, freshness, or limits.
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 dense sentence with the resource front-loaded followed by a parenthetical topic list; every phrase maps to actual returned content. It is slightly fragmentary and omits a verb, but there is no padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return-value detail is correctly left out, and annotations cover safety. For a zero-argument read tool the description supplies enough topical scope for an agent to decide to call it, with only the sibling-routing question left open.
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 tool takes zero parameters, so there is nothing for the description to disambiguate beyond confirming the call is argument-free. Baseline 4 applies for a no-parameter tool.
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?
Names a specific resource (Tarigri Surgical company information) and enumerates the concrete content it returns: contact details, business hours, ordering process, and buyer FAQ topics. That enumeration implicitly separates it from the catalog-oriented siblings, though it never names them.
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?
Usage is implied rather than stated: an agent can infer this is the place to look for MOQ, OEM, certification, market and pricing-policy questions. There is no explicit when-to-use/when-not guidance, and 'pricing' overlaps with the sibling estimate_quote without any note on which to prefer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full details for one product by SKU: price, MOQ, volume tiers, material, size, description, URL.
| Name | Required | Description | Default |
|---|---|---|---|
| sku | Yes | Product SKU, e.g. NH-301 |
| Name | Required | Description |
|---|---|---|
| product | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety and repeatability profile is fully covered without the description. The description adds only the field list of the response, and says nothing about behavior when a SKU is unknown (error vs empty) or about freshness of pricing data — modest added value given the strong 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?
A single front-loaded sentence with the lookup key and returned fields, no preamble or filler. The trailing field enumeration is slightly redundant against the output schema, which keeps it just short of a 5.
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 one-parameter read tool with an output schema and full annotation coverage, this is nearly complete: the key, the scope and the returned content are all stated. Only the not-found behavior is left unaddressed, which is a minor gap at this complexity level.
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% and the single sku parameter already carries a format example ('NH-301'), so the schema does the work. The description only repeats 'by SKU' without adding lookup semantics such as case sensitivity or accepted SKU formats beyond the schema example.
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?
States a specific verb and resource — 'Get full details for one product by SKU' — and enumerates the fields returned (price, MOQ, volume tiers, material, size, description, URL). This clearly separates it from search_products and list_categories by scope (single product, keyed by SKU), though it never names those siblings explicitly.
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 phrase 'one product by SKU' implies this is the single-record lookup rather than a browse/search call, so the intended use is inferable. There is no explicit when-to-use or when-not-to-use guidance, and no routing to search_products or estimate_quote for the related tasks the siblings cover.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the product categories with descriptions and product counts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| categories | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so safety and repeatability are covered. The description adds that each category carries a description and a product count, but since an output schema exists that presumably documents these fields, the added value is modest. Nothing is said about auth or whether the list is 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?
A single short sentence with no filler, and the resource and returned fields are front-loaded. 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?
For a zero-parameter enumeration tool with rich read-only annotations and an output schema, the description covers what an agent needs in order to call it. It could only be improved by noting whether all categories are returned in one call or whether the result set is bounded.
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 tool takes zero parameters, which is the stated baseline of 4 when there is no parameter semantics to explain. The empty input schema is consistent with the description's 'list everything' framing.
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 pairs a specific verb ("List") with a specific resource ("product categories") and even previews the payload ("with descriptions and product counts"). It does not explicitly distinguish itself from siblings like search_products or get_product, but the operation is unambiguous on its own.
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 statement of when to use this tool versus search_products or any other sibling, nor any exclusion guidance. Because the tool takes zero parameters and performs a single obvious enumeration, the usage is strongly implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the Tarigri Surgical wholesale catalog (surgical, dental, orthopedic, ENT instruments). Prices are USD per unit, FOB Sialkot. All filters are optional.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 25) | |
| query | No | Free-text terms, e.g. 'needle holder' or 'sc-101' | |
| category | No | Category id or name (see list_categories) | |
| featured_only | No | Only best sellers | |
| max_unit_price_usd | No | Only products at or below this base unit price |
| Name | Required | Description |
|---|---|---|
| count | Yes | |
| currency | Yes | |
| incoterm | Yes | |
| products | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds real domain context beyond them — prices are USD per unit and FOB Sialkot — but says nothing about filter combination semantics (AND vs OR) or result ordering, which matter for a catalog search.
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 short sentences, front-loaded with the resource and scope, with no filler. The final 'All filters are optional' sentence is mildly redundant with the schema's required list but still useful to an agent planning an unfiltered call.
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?
An output schema exists, so return structure need not be explained, and the description covers catalog scope and price semantics. For a five-optional-parameter read-only search this is close to complete, with only filter-combination behavior unstated.
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 every parameter is already documented, including the query example and the 'see list_categories' hint for category. The description adds only the optionality note, which the schema's empty required list already conveys; baseline 3 applies.
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 gives a specific verb ('Search') and resource ('the Tarigri Surgical wholesale catalog'), plus a parenthetical scope of product lines (surgical, dental, orthopedic, ENT instruments). That is enough to separate it from get_product (single-item lookup) and list_categories, though no sibling is named explicitly.
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?
'All filters are optional' implies a no-argument call returns a broad listing and that filters can be combined, which is mild usage guidance. It never states when to prefer this over list_categories or get_product, nor any exclusion conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0draft_inquiryestimate_quoteget_company_infoget_productlist_categoriessearch_productsScored across 6 tools
Each tool has a clearly distinct role: category listing, product search, SKU detail, company info, quote estimation, and inquiry drafting. The only close pair is search_products and get_product, but their descriptions make the list-vs-single-SKU distinction clear.
All six tools follow a consistent snake_case verb_noun pattern: list_categories, search_products, get_company_info, get_product, estimate_quote, draft_inquiry. No mixed conventions or vague names.
Six tools are well-scoped for a wholesale catalog and inquiry workflow, with no filler or obviously missing companion tools. Each tool earns its place in the browse-to-inquiry path.
The set covers category discovery, product search, SKU-level details, company/ordering info, volume pricing estimates, and inquiry drafting with email/WhatsApp links. Direct order submission is explicitly out of scope, so no practical dead end remains for the stated purpose.
AI-agent product catalog: search, lookup & purchase routing over verified merchant data.
Merchant product catalogs for AI agents: price, availability, specs, variants, buy links. Read-only.
Cross-vendor B2B catalog for AI agents: search, compare, find equivalents, request a quote.
Company catalogs for AI agents: products, prices, availability. Search, read, or start one free.
