Clearlot
Server Details
Specified RFQ tape. Free search and quote. Missed specs stay. Merchant checkout.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- clarkthomas/clearlot
- GitHub Stars
- 0
Available Tools
8 toolscover_intentAInspect
Attach a posted offer to a buy intent. No deposits. No order placement.
| Name | Required | Description | Default |
|---|---|---|---|
| offer_id | Yes | ||
| intent_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the disclosure burden and does add useful negative behavioral context: no deposits are created and no order is placed. However, it does not disclose whether the attachment is reversible or idempotent, what state changes occur to the offer or intent, or whether any permissions or preconditions beyond 'posted' apply.
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 declarative sentences front-load the core action and then add two precise exclusions. Every sentence earns its place; there is no filler, repetition, or irrelevant detail.
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 two-parameter mutation, the core action and side-effect negatives are present and likely sufficient for basic invocation. Yet with no annotations and no output schema, the description still leaves out observable behavior such as return value, idempotence, and failure cases like a non-posted offer, making it only minimally viable.
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 only bare string names with 0% description coverage, but the description's 'posted offer' and 'buy intent' map naturally to offer_id and intent_id and imply a posted-status precondition. It adds no further constraints, formatting, or relationship details, but the two-parameter shape is simple enough for an agent to infer the mapping.
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 verb 'Attach' plus the object 'posted offer' and target 'buy intent' identifies a specific operation. The exclusions 'No deposits. No order placement.' further distinguish it from commerce-related siblings like open_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 gives the exact scenario for use: attaching an existing posted offer to a buy intent. The 'No deposits. No order placement.' clauses serve as implicit when-not guidance, signaling this is not a checkout or payment step, though alternative tools are not named explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_quoteCInspect
Free live quote. Mixes vendor offers and catalog. Every spec is written to the demand tape. Does not place orders.
| Name | Required | Description | Default |
|---|---|---|---|
| mpn | No | ||
| spec | No | ||
| deadline | No | ||
| quantity | No | ||
| intent_id | No | ||
| max_price_usd | No | ||
| ship_to_country | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It partially succeeds by noting a side effect ('Every spec is written to the demand tape') and a non-action ('Does not place orders'). However, it does not explain whether the quote is persisted, how the demand tape is used, whether the operation is idempotent, or any rate/authorization constraints.
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 compact at four short sentences with the main idea 'Free live quote' front-loaded. Every sentence is brief, but the 'demand tape' phrase is cryptic and not immediately meaningful. Overall, it is efficient and avoids 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?
For a tool with 7 parameters, no output schema, and no annotations, the description is considerably incomplete. It does not explain return values, parameter formats, or usage conditions, and the only behavioral side effect mentioned is the vague 'demand tape' write. The description leaves too many operational details unspecified.
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 by explaining key parameters, but it only mentions 'spec' generically. None of the seven parameters (mpn, spec, deadline, quantity, intent_id, max_price_usd, ship_to_country) are described. The description adds virtually no parameter-level meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as providing a 'Free live quote' that 'Mixes vendor offers and catalog', which conveys the core purpose of getting a quote. It also distinguishes itself from order placement with 'Does not place orders.' However, the phrase 'Every spec is written to the demand tape' introduces unexplained jargon, slightly reducing clarity.
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 no explicit guidance on when to use this tool versus alternatives, nor does it name any sibling tool. 'Does not place orders' is an exclusion, but it does not tell the agent when to invoke get_quote rather than search_supply, post_intent, or open_checkout. Usage context is only implied through 'live quote'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_demandAInspect
Read clustered hashes with intent, offer, search, and miss counts. Signal only. Not a fill.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| spec_hash | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the behavioral burden. It clearly marks the operation as read-only ('Read') and clarifies there is no side effect ('Signal only. Not a fill.'). This is strong transparency for a simple query tool, though it does not discuss auth, data freshness, or rate 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?
The description is extremely compact with no filler. The core action is front-loaded, and each short phrase adds value: the read purpose, the data included, the signal-only nature, and the non-fill exclusion. Every sentence 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 no annotations, no output schema, and 0% parameter coverage, the description is too terse to be fully actionable. An agent still has to guess what spec_hash represents, how limit behaves, and what the response shape looks like. The core purpose is clear, but important invocation details are missing.
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 for limit and spec_hash, but it defines neither. 'Clustered hashes' hints at what spec_hash might refer to, but the expected format and the meaning of limit are left to inference. This is only partial compensation for the lack of schema documentation.
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?
Starts with the specific verb 'Read' and identifies the resource ('clustered hashes') plus the data returned (intent, offer, search, and miss counts). 'Signal only. Not a fill.' explicitly separates it from fill/cover operations among its siblings. An agent can tell what the tool does without needing the 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 'Not a fill' phrase provides a useful exclusion, implying this is for reading demand signals rather than executing or covering orders. However, no alternative tool is named directly, and there is no explicit statement of when to choose this over search_supply, get_quote, or cover_intent. Usage context is mostly 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.
open_checkoutAInspect
Return merchant product/checkout URL for a quote. Does not complete payment.
| Name | Required | Description | Default |
|---|---|---|---|
| quote_id | Yes | ||
| offer_index | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does disclose one key behavior—'Does not complete payment'—preventing misuse as a payment tool. However, it does not state whether opening a checkout creates a session, reserves inventory, or requires special permissions, so operational side effects remain opaque.
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 with the main action front-loaded and the critical non-payment clarification appended. No filler or repetition.
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 tool with no annotations and no output schema, the description is too sparse: it omits the meaning of offer_index, the shape of the returned URL, and any prerequisites or side effects. An agent calling this tool correctly would need more context than provided.
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 explain the parameters. It aligns 'quote' with quote_id but says nothing about offer_index, its optionality, or how it modifies the returned URL. An agent cannot reliably decide whether or how to set offer_index.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('Return') and resource ('merchant product/checkout URL') tied to a quote, and explicitly states what it does not do ('Does not complete payment'), making its purpose unambiguous and distinct from siblings such as get_quote or post_offer.
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 'for a quote' implies this tool is used when a quote exists and a checkout URL is needed, but it names no sibling alternatives or when-not-to-use conditions, leaving the agent to infer the decision boundary among the eight sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
open_poolCInspect
Cluster intents by spec hash. No deposits.
| Name | Required | Description | Default |
|---|---|---|---|
| intent_id | Yes | ||
| min_quantity | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, but it only says no deposits are involved. It does not disclose side effects, permissions, failure modes, or what happens to intents after clustering, leaving the agent to guess.
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 short with no filler, and the core purpose is front-loaded. The 'No deposits' fragment is elliptical but earns its place; the main flaw is under-specification rather than wordiness.
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 no annotations and no output schema, the description must cover safety and return semantics, but it mentions neither. The minimal purpose statement is a good start yet insufficient for reliable invocation without guessing.
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%, and the description does not explain intent_id or min_quantity. The property names carry some inherent meaning, but the description adds nothing beyond those names.
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 concrete operation—cluster intents by spec hash—and adds a useful constraint, 'No deposits.' It is not a tautology, so an agent can infer the tool's core behavior, though it does not explicitly differentiate from siblings like open_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?
No guidance is given on when to choose open_pool over its siblings, and no alternatives are named. 'No deposits' hints at a boundary but does not state a selection rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
post_intentCInspect
Record a buy intent. Free. Does not charge or hold funds.
| Name | Required | Description | Default |
|---|---|---|---|
| mpn | No | ||
| spec | Yes | ||
| agent_id | No | ||
| deadline | Yes | ||
| quantity | Yes | ||
| vertical | No | ||
| max_price_usd | Yes | ||
| ship_to_country | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral disclosure burden. It does usefully state that the tool is free and does not charge or hold funds, which is important given the financial-looking parameters. However, it does not disclose other relevant behaviors such as whether the intent is publicly visible, whether authentication is required, or whether any follow-up action is triggered.
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 short and front-loaded with the core action. The 'does not charge or hold funds' clarification is valuable, though 'Free' and 'does not charge' are somewhat redundant. It is appropriately concise but perhaps too terse for the tool's complexity.
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 8 parameters, 5 required, no parameter descriptions, no output schema, and no annotations, this description is insufficient for an agent to confidently invoke the tool correctly. The agent is left to guess formats for fields like deadline, max_price_usd, and ship_to_country, and cannot tell how this tool relates to sibling tools.
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% and the description provides no meaning for any of the 8 parameters, including required fields like spec, quantity, max_price_usd, ship_to_country, and deadline. The description does nothing to compensate for the lack of schema descriptions.
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 action ('Record') and the resource ('a buy intent'), which is specific and understandable. It also implies a buyer-side action that contrasts with 'post_offer', though it does not explicitly distinguish itself from 'cover_intent' or other siblings.
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 no guidance on when to use this tool versus alternatives like 'post_offer', 'cover_intent', or 'open_checkout'. There is no mention of prerequisites, typical scenarios, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
post_offerCInspect
Record a vendor ask against a spec hash. Free. No inventory held here. Merchant stays merchant of record.
| Name | Required | Description | Default |
|---|---|---|---|
| mpn | No | ||
| firm | No | ||
| spec | Yes | ||
| agent_id | No | ||
| quantity | Yes | ||
| vertical | No | ||
| lead_days | No | ||
| expires_at | No | ||
| merchant_url | Yes | ||
| unit_price_usd | Yes | ||
| merchant_domain | No | ||
| ships_to_country | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Because no annotations are provided, the description carries full responsibility for behavioral disclosure. It does add meaningful context with 'Free. No inventory held here. Merchant stays merchant of record,' clarifying cost, fulfillment scope, and commercial role. However it omits important behaviors such as authentication, idempotency, persistence guarantees, or side effects beyond recording.
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 brief and front-loaded, with the core action first followed by three short constraint phrases. Every sentence adds some contextual value, though some phrasing is cryptic. The compactness works in its favor, but it sacrifices clarity needed for a complex tool.
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 tool with 12 parameters, 5 required, no output schema, and no annotations, the description is far too thin to provide adequate context. It gives the high-level purpose and a few constraints but does not explain required inputs, return behavior, or how this tool fits into the overall offer/intent workflow. An agent would still face significant uncertainty when trying to call 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 description coverage is 0%, so the description must compensate by explaining parameter meaning. It only hints at the 'spec' parameter through 'against a spec hash' and loosely implies price/quantity via 'vendor ask,' but none of the 12 parameters are actually described. This is not enough for an agent to confidently fill in required fields like merchant_url, ships_to_country, or unit_price_usd.
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 states a specific action and resource: 'Record a vendor ask against a spec hash.' This clearly communicates the tool's primary function and suggests a vendor-side offer action, which helps differentiate it from buyer-oriented siblings like post_intent. However, it does not explicitly name or contrast siblings, so it stops short of full differentiation.
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 vendor asks and not inventory holding, but it gives no explicit when-to-use or when-not-to-use guidance and does not reference any sibling tool. An agent would have to infer the correct context from the tool name and sibling list rather than from actual routing instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_supplyCInspect
Free supply scan. Every query is written to the demand tape. Misses become implicit intents.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | ||
| ship_to_country | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It notably discloses a non-obvious side effect: every query is written to a 'demand tape' and misses become 'implicit intents.' This is valuable because the name suggests a read-only search, but the description warns of persistent side effects. However, it omits other behavioral details such as auth needs, rate limits, or return payload.
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 short and front-loaded, but the first sentence is a slogan ('Free supply scan') rather than a specification, and the second uses unexplained jargon ('demand tape', 'implicit intents'). It is concise but sacrifices clarity.
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 no output schema, no annotations, and three undocumented parameters, the description leaves major gaps: return format, parameter semantics, error behavior, and operational constraints. It does mention the crucial side effect, which prevents a score of 1, but it is far from complete for safe and correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the description adds no meaning for 'query', 'ship_to_country', or 'limit'. An agent is left to guess that 'query' is free text, 'ship_to_country' is a destination, and 'limit' caps results — none of this is stated.
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 identifies the resource ('supply') and a generic action ('scan'), but this mostly restates the tool name. It never explicitly states what the scan returns or what problem it solves, and it lacks enough specificity to distinguish search_supply from siblings like list_demand or post_offer.
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 for when to use this tool versus its siblings. There is no decision rule, no mention of alternatives, and no prerequisites. The agent must infer the appropriate context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
- First observed
cover_intent - First observed
get_quote - First observed
list_demand - First observed
open_checkout - First observed
open_pool - First observed
post_intent - First observed
post_offer - First observed
search_supply
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Search surplus and overstock inventory, request bulk quotes, and check out.
Search the public Xavio catalog and create firm checkout quotes.
Provider-neutral, read-only commerce preflight with UCP/ACP checkout evidence. Never orders.
Search real parts with datasheet-provenance specs, check compatibility and compose priced BOMs.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceAI quoting agent for electronics distributors. RFQ in, quote out via MCP tools.MIT
- AlicenseNot gradedqualityDmaintenanceEnables HVAC equipment Request for Quote (RFQ) management via MCP, allowing users to submit RFQs, check status, and compare quotes from distributors.2MIT
- AlicenseNot gradedqualityCmaintenanceMCP commerce surface for refurbished datacenter hardware — GPU rigs, server racks, drive arrays, and network gear, with x402 agent-payment discovery.MIT
- AlicenseAqualityCmaintenanceMAP (Maraventano Agent Protocol). One MCP server with three subtractive parts — Merchant Key (read any product URL into one CleanRead), Atlas (publish your own catalog by reading yourself), Provisions (wallet curriculum), Teacher, not butler: never signs, pays, or holds keys.2358-
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Most tools target distinct workflow stages, but get_quote and search_supply both scan supply and write to the demand tape, and list_demand and open_pool both center on demand clusters. post_intent could also be confused with search_supply's implicit-intent side effect. Descriptions help, but some misselection risk remains.
All tool names follow a consistent lowercase verb_noun pattern: post_intent, post_offer, get_quote, list_demand, open_checkout, search_supply. Repeated verbs like post and open are paired with different clear objects, keeping the pattern predictable.
Eight tools is well-scoped for a pre-transaction demand/supply matching and checkout server. Each tool covers a meaningful stage without unnecessary duplication. The count feels intentional and complete for the stated domain.
The server covers the core pre-transaction lifecycle: recording intents and offers, covering intents, quoting, supply scanning, demand visibility, and checkout URL generation. There are no explicit update/delete/cancel operations, but the descriptions repeatedly scope out deposits, orders, and payment, so those omissions appear deliberate.