CSPR[dot]trade MCP

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: transaction-building tools (build_*), data retrieval tools (get_*), and a submission tool (submit_transaction). The descriptions clearly differentiate between constructing transactions, fetching information, and submitting signed transactions.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout: all start with either 'build_' or 'get_' except 'submit_transaction', which still follows the same convention. This predictability makes it easy for agents to understand the action each tool performs.
Tool Count5/5
With 13 tools, the count is well-scoped for a DeFi trading platform, covering core operations like swapping, liquidity management, data queries, and transaction submission. Each tool earns its place without redundancy or obvious omissions.
Completeness5/5
The toolset provides complete coverage for the DeFi trading domain: it supports full swap and liquidity workflows (quote, build, submit), comprehensive data access (tokens, pairs, history, positions), and utility functions (impermanent loss, currencies). No significant gaps are apparent for typical agent tasks.
Average 3.2/5 across 13 of 13 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- Last stable release on April 28, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure but fails to specify read-only safety, result ordering (chronological?), supported time ranges, or pagination behavior (cursor vs offset). 'History' implies historical data but lacks specifics on data availability or immutability.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The four-word description is extremely brief with no wasted words, achieving high density. However, for a tool with four parameters including pagination controls, this brevity results in underspecification rather than efficient communication of essential operational details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the DeFi context with filtering and pagination complexity, and lacking both annotations and output schema, the description is incomplete. It omits return structure, default pagination limits, time range constraints, and sorting behavior—all critical for a history query tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (page and page_size lack descriptions). The description makes no mention of pagination or filtering capabilities, failing to compensate for schema gaps. It adds no context for the 'pair' parameter format or expected public_key behavior beyond the schema's existing 'hex' and 'contract package hash' notes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the basic action (Get) and resource (swap transaction history), but lacks specificity about the domain (DEX/DeFi) and does not differentiate from sibling query tools like get_liquidity_positions or get_pairs. It minimally expands the tool name without detailing scope or data sources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance provided on when to use this tool versus alternatives (e.g., get_pairs for current state vs historical swaps), nor does it explain the optional filtering pattern (all parameters are optional per schema). The pagination mechanism (page, page_size) is present but entirely undocumented.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'unsigned' to indicate non-execution, but fails to describe what the transaction does (burns LP tokens, returns underlying assets), the output format, or security considerations like slippage protection.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The single sentence is efficiently structured and front-loaded with the action. However, for a complex DeFi operation with no output schema and no annotations, it may be overly terse rather than appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of liquidity removal (financial operation with impermanent loss risks, multi-step transaction flow) and absence of output schema, the description is incomplete. It omits the transaction lifecycle, output payload structure, and economic effects of the operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage, documenting all 5 parameters including constraints (percentage 1-100). The description adds no additional semantic context beyond the schema, which warrants the baseline score for well-documented schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Build') and resource ('remove-liquidity transaction'), and includes 'unsigned' which distinguishes it from the sibling 'submit_transaction'. It clearly differentiates from 'build_add_liquidity' and 'build_swap' through the specific operation name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While 'unsigned' hints that signing and submission happen elsewhere, there is no explicit guidance on the required workflow (build → sign → submit), when to use this versus 'build_swap', or prerequisites like existing liquidity positions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden of behavioral disclosure. Fails to state this is a read-only calculation (though implied by 'get_' prefix), does not describe calculation methodology (current price ratio vs. entry price), return value format (percentage, absolute value, ratio), or performance characteristics. Critical gaps for a financial calculation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no redundancy. Efficiently states core purpose. However, extreme brevity results in underspecification for a financial calculation tool—conciseness here reflects minimalism rather than optimal information density.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Inadequate for tool complexity. No output schema exists, yet description doesn't hint at return structure. For a DeFi financial calculation involving impermanent loss, fails to explain what the calculation represents (divergence loss vs. holding), units, or interpretation guidance. Relies entirely on input schema and domain knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both account_public_key and pair are documented), establishing baseline 3. Description adds no parameter context (does not explain that account_public_key + pair identify the specific position, nor clarifies 'pair contract package hash' format requirements). But schema descriptions suffice for basic understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States specific verb (calculate) and resource (impermanent loss for a liquidity position). Clear enough to distinguish from sibling tools like get_liquidity_positions (which retrieves position data) and build_add_liquidity (which creates positions). However, lacks explicit scope clarification that this computes a specific financial metric rather than retrieving stored data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. Does not mention prerequisites (e.g., that a liquidity position must exist for the account/pair combination) or when to use get_liquidity_positions instead. No mention of typical workflow (e.g., call get_liquidity_positions first to verify position exists).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Zero annotations provided, so description bears full disclosure burden. It states the action but fails to indicate this is read-only/safe, doesn't describe return structure, pagination, or whether the currency parameter filters vs prices the results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely brief at 7 words, but front-loaded with verb and no filler. However, the extreme brevity contributes to under-specification in other dimensions—it leaves value on the table rather than being appropriately-sized for a tool with 12 siblings.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Minimally viable for a 2-parameter read operation with good schema coverage. Lacks behavioral richness expected given the financial context ( cryptocurrency/DeFi) and the complexity implied by siblings like build_swap and get_impermanent_loss.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with explicit descriptions for both account_public_key and currency. The description mentions 'account' which loosely maps to the required parameter, but adds no syntax details, format examples, or semantic relationships between the two params.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource construction ('Get liquidity positions'), and 'for an account' scopes it to user-specific holdings. However, it does not explicitly differentiate from siblings like get_impermanent_loss or get_swap_history which may also require account context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to use this read operation versus the build_add_liquidity/build_remove_liquidity siblings, nor when to prefer get_impermanent_loss for analysis. No prerequisites or conditions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. While it mentions 'reserves and pricing data' (output content), it omits critical behavioral traits: pagination is required (page/page_size exist but behavior isn't described), no indication of real-time vs cached data, and no safety hints (read-only assumed but not stated).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, efficiently front-loaded with action verb. However, extreme brevity is insufficient for a zero-annotation, 5-parameter tool requiring pagination awareness. One additional sentence on differentiation from get_pair_details or pagination behavior would improve utility without sacrificing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Names the API domain (CSPR.trade) and data returned, satisfying basic needs. Gaps remain: no pagination explanation despite page params, no output schema hints beyond 'reserves/pricing', and no contrast with singular 'get_pair_details'. Acceptable but minimal for the complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 60% (3/5 params described). Description mentions 'pricing data' which provides semantic context for the 'currency' parameter, but offers no guidance on 'order_by' or 'order_direction' enums (reserves vs timestamp sorting logic). Baseline 3 appropriate for medium coverage without full compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'List' and resource 'trading pairs on CSPR.trade'. Effectively distinguishes from transaction-building siblings (build_*, submit_transaction) and other getters like get_tokens. However, fails to explicitly differentiate from sibling 'get_pair_details' (singular vs plural), which could cause selection ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this bulk list view versus 'get_pair_details' for specific pair queries. No mention of pagination workflow or when to provide currency parameter. Users must infer usage from parameter schema alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden of behavioral disclosure. 'Get' implies read-only but doesn't explicitly confirm this, nor does it mention caching, rate limits, or response size. Fails to disclose what 'detailed' encompasses.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with action and resource. No redundancy or wasted words. Appropriate length for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Minimal but adequate for a simple 2-parameter read tool. Lacks output specification (no output schema exists), but 'detailed information' hints at comprehensive data. Sufficient for agent selection though richer context on return values would help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with both parameters well-documented in the schema ('Pair contract package hash', 'Fiat currency code'). Description adds no parameter-specific guidance, meeting the baseline for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb ('Get') and resource ('trading pair'), and 'specific' distinguishes from sibling 'get_pairs'. However, 'detailed information' is vague and doesn't specify what data is returned (e.g., reserves, prices, metadata).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to use this versus 'get_pairs' (to discover pairs) or 'get_quote' (for pricing). Doesn't mention that 'pair' parameter requires a contract hash likely obtained from 'get_pairs' first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. While 'List' implies read-only, description does not explicitly confirm safety, idempotency, or what the return structure contains (pagination, token metadata fields, etc.). Only behavioral hint is the optional pricing functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single 10-word sentence that is front-loaded with action and scope. Zero redundant text; every word serves the definition. Appropriate length for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a single-parameter listing tool with complete schema coverage. However, lacks description of return values (no output schema exists to compensate), rate limits, or pagination behavior that would help the agent handle the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear description of currency parameter. Description mentions 'optional fiat pricing' which aligns with schema but adds minimal semantic value beyond what schema already documents ('Omit for no fiat prices'). Baseline 3 appropriate for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'List' and specific resource 'tradable tokens on CSPR.trade'. Platform-specific naming helps distinguish from get_currencies (likely returns fiat codes), though explicit differentiation between these siblings would strengthen it further.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use versus get_currencies or get_pairs. Mentions 'optional fiat pricing' which implies parameter usage, but lacks explicit when-to-use/when-not-to-use recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Correctly discloses that the output is 'unsigned', indicating the tool constructs but does not execute or submit the transaction. However, with no annotations provided, the description carries the full burden and omits key behavioral context: it does not state that the transaction requires subsequent signing, potential token approval prerequisites, or that the operation is non-destructive/read-only until submission.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise single sentence with zero redundancy. However, given the domain complexity (DeFi liquidity operations with 9 parameters and no annotations), the brevity leaves critical workflow context unmentioned, slightly hurting its utility.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Factually complete for a transaction-building tool with full schema coverage, but minimal given the complexity. Lacks explanation of the broader transaction lifecycle, approval requirements, and relationship to sibling tools that would prevent user errors in a multi-step DeFi workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, all 9 parameters are adequately documented in the schema itself. The description adds no supplementary parameter semantics (e.g., explaining human-readable vs raw formats, or the relationship between token_a and token_b), warranting the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Provides a specific verb (Build) and resource (unsigned add-liquidity transaction) with clear scope (for a token pair). Implicitly distinguishes from siblings like submit_transaction (unsigned vs submitted) and build_remove_liquidity (add vs remove), though it does not explicitly name alternative tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Lacks explicit guidance on when to use this versus build_swap or the prerequisite workflow. Critical DeFi context missing: it does not mention that token approvals (via build_approve_token) are typically required before adding liquidity, nor does it explain the build → sign → submit lifecycle implied by 'unsigned'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. While it states submission occurs via RPC to the Casper network, it lacks critical blockchain-specific context: irreversibility, gas fees, confirmation waiting, synchronous vs asynchronous behavior, or error scenarios.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, efficient sentence with zero waste. Front-loaded with the action ('Submit'), followed by object and method. Every phrase earns its place by specifying what, how, and where.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple 1-parameter schema with complete coverage, the description adequately covers the basic invocation contract. However, for a blockchain mutation tool without output schema or annotations, it omits important operational context like return values or confirmation behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, establishing a baseline of 3. The description mentions 'signed transaction' which semantically aligns with the 'signed_deploy_json' parameter, but adds no specific details about JSON format or file path requirements beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description provides a specific action (Submit), resource (signed transaction), and target (Casper network via node RPC). It clearly distinguishes from sibling 'build_' tools (which construct transactions) and 'get_' tools (which query data) by focusing on the final submission step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The term 'signed transaction' implies prerequisites (you must sign first), suggesting this follows the 'build_' sibling tools. However, there is no explicit guidance on when to use this versus alternatives, or workflow steps mentioned in the text.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Mentions 'unsigned' which is critical behavioral info (transaction requires signing before submission), and notes the spender default. Missing: gas costs, that this is a write operation, whether approval is additive or replacement, and the prerequisite relationship to swapping.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste. Front-loaded action ('Build an unsigned...') followed by default parameter context. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 100% schema coverage and no output schema, description adequately explains the operation. However, given this is a transaction builder with no annotations, it should mention the output is a transaction to be signed/submitted via submit_transaction sibling, or explain the 'unsigned' nature in workflow context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with clear descriptions. Description adds valuable semantic context beyond schema by specifying the spender 'defaults to the CSPR.trade router'—default values and domain context not present in the schema itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear specific verb ('Build') and resource ('unsigned token approval transaction'). The 'token approval' specificity distinguishes it from sibling build_swap/build_add_liquidity tools. CSPR.trade router reference provides domain context, though it could explicitly state this is for ERC-20/Casper token standards.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implied usage context by mentioning 'CSPR.trade router' as the default spender, suggesting this is for DEX interactions. However, lacks explicit guidance on when to use (e.g., 'call before build_swap if token lacks allowance') or when not to use (e.g., if already approved).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses output contents ('amounts, price impact, and routing path') which compensates for the missing output schema. However, it lacks explicit confirmation that this is read-only, doesn't mention cache duration, liquidity failure modes, or rate limiting.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences with zero waste. First sentence establishes purpose; second sentence discloses return value structure. Front-loaded and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description usefully specifies what the tool returns (amounts, price impact, routing). With 100% input schema coverage and clear purpose, it is complete enough for invocation, though it could note error conditions (e.g., insufficient liquidity) or auth requirements.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all four parameters (token_in, token_out, amount, type). The description adds minimal semantic context beyond the schema ('trading between two tokens'), meeting the baseline expectation for well-documented schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb 'Get' with resource 'swap quote' and clearly indicates this retrieves pricing/routing information for trading. While it implies distinction from execution tools like 'build_swap' through the term 'quote', it does not explicitly name siblings or explicitly state this is a read-only simulation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'price impact' and 'routing path', suggesting it should be used to evaluate trade feasibility before execution. However, it lacks explicit guidance such as 'Use before build_swap' or conditions like 'Use when you need to know slippage tolerance'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It discloses 'unsigned' nature (no state change yet), output format ('deploy JSON'), and bonus output ('human-readable summary'). However, misses critical behavioral context: that this doesn't submit to blockchain, approval mechanics via token_in_balance, error conditions (slippage), or that returned JSON requires subsequent signing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. First sentence states core purpose immediately. Second sentence describes outputs. Every word earns its place; properly front-loaded with no redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 100% schema coverage, the description adequately covers the return values (compensating for no output schema). However, for a complex DeFi tool with 8 parameters involving slippage, deadlines, and approvals, the description lacks workflow context (e.g., that approval may be needed first, or that this is step 1 of 2 in swap execution).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline score applies. Description provides high-level context ('swap transaction') that helps interpret parameter relationships, but doesn't add syntax, format details, or parameter-specific guidance beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear specific verb ('Build') + resource ('unsigned swap transaction') + scope. Distinguishes from siblings: vs 'get_quote' (this builds executable tx), vs 'submit_transaction' (this returns unsigned for external signing), vs 'build_add_liquidity' (different operation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage context via 'for external signing', suggesting use when handling signing outside the tool. However, lacks explicit 'when to use vs alternatives' (e.g., 'use submit_transaction instead to auto-submit') or workflow prerequisites (e.g., 'call get_quote first').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. 'List' implies read-only behavior, but description omits return format details, pagination behavior, or whether results are cached/static.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action verb. Every word serves purpose: verb (List), resource (supported fiat currencies), context (for price display). No waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Appropriate for a zero-parameter list tool. While no output schema exists, the description sufficiently communicates the tool's scope for its complexity level. Minor gap: doesn't describe return value structure (e.g., array of currency codes).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters present, which per rules sets a baseline of 4. Description correctly avoids inventing parameters that don't exist in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Excellent clarity: 'List' is a specific verb, 'supported fiat currencies' defines the resource precisely, and 'for price display' clarifies the contextual purpose. It clearly distinguishes from sibling get_tokens (crypto) by specifying 'fiat'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implied usage context ('for price display') indicating when to use it, but lacks explicit guidance on when NOT to use it or alternatives (e.g., no mention of get_tokens for crypto assets).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![cspr-trade-mcp MCP server](https://glama.ai/mcp/servers/make-software/cspr-trade-mcp/badges/card.svg)](https://glama.ai/mcp/servers/make-software/cspr-trade-mcp)

Score Badge

Copy to your README.md:

[![cspr-trade-mcp MCP server](https://glama.ai/mcp/servers/make-software/cspr-trade-mcp/badges/score.svg)](https://glama.ai/mcp/servers/make-software/cspr-trade-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/make-software/cspr-trade-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server