leverage
Server Details
Leveraged-yield router on Morpho. List strategies, simulate, and build UNSIGNED txs.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.2/5 across 7 of 7 tools scored. Lowest: 3.6/5.
Each tool has a clearly distinct purpose: building transactions for opening vs managing positions, reading positions, prices, strategies, and simulation. No overlap in functionality.
All tool names consistently use snake_case with a verb_noun pattern (e.g., build_leverage_tx, get_positions, list_strategies), making the set predictable and easy to navigate.
Seven tools cover the core lifecycle of leveraged positions without being excessive. Each tool is justified for the server's purpose.
The set covers opening, managing, simulating, and reading positions, plus strategy and price data. Minor gap: no tool for historical actions beyond positions, but the non-custodial model limits this need.
Available Tools
7 toolsbuild_leverage_txBuild Leverage TransactionAInspect
Build the UNSIGNED transaction to open a leveraged position, for the given wallet to sign. Non-custodial: this server never signs, sends, or holds keys. The canonical output is the executable { approvals[], tx{to,data,value} } — sign and broadcast it directly (approvals first), plus the same position preview as simulate_leverage. meta.signingUrl is an optional one-click link for a human to sign in their own wallet. The embedded swap calldata is time-sensitive (see meta.expiresAt) — rebuild if stale.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | Yes | Amount of payToken in human units (e.g. '10000' for 10,000 USDC). | |
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. | |
| leverage | No | Target leverage, e.g. 3. Provide this OR desiredLtv. | |
| payToken | Yes | Address of the token you pay in. May be the collateral (opened directly) or any other token (zapped: swapped to collateral first). Native ETH = the zero address 0x0000…0000. | |
| slippage | No | Swap slippage as a ratio (0.005 = 0.5%). Default 0.005, capped at 0.01. | |
| desiredLtv | No | Target LTV percent, e.g. '66.67'. Provide this OR leverage. | |
| strategyId | Yes | Morpho market id of the strategy (from list_strategies / get_strategy). | |
| userAddress | Yes | The wallet address that will sign and send. Approvals and onBehalfOf are built for it. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses non-custodial nature, no signing/sending of keys, output structure (approvals, tx), and time-sensitive swap calldata. Annotations (readOnly: false, destructive: false) are consistent; description adds critical context.
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?
Single paragraph, front-loaded with main purpose, every sentence adds value. A bit dense but no redundant content.
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?
Without output schema, the description comprehensively explains output structure, time-sensitivity, and signing flow. Could mention error handling, but sufficient for the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed parameter descriptions. The description adds overall context but no individual parameter explanations beyond schema, fitting baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Build the UNSIGNED transaction to open a leveraged position', specifying verb and resource. Differentiates from siblings like simulate_leverage and build_manage_tx by detailing output and use case.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use when opening a leveraged position and needing the transaction for signing. Mentions time-sensitivity and alternative simulate_leverage for preview. Lacks explicit when-not but sufficiently guides.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
build_manage_txBuild Manage TransactionAInspect
Build the UNSIGNED transaction to adjust or close an OPEN position, for the given wallet to sign. Non-custodial (never signs/holds keys). Canonical output is the executable { approvals[], tx{to,data,value} } (sign/broadcast directly); meta.signingUrl is an optional link for a human to sign in their own wallet. Actions: 'close' (unwind fully), 'increase_leverage' (borrow to a higher LTV), 'add_collateral' (top up — pay in collateral or any token), 'remove_collateral' (withdraw), 'repay' (pay down debt; set full=true to clear it), 'borrow' (draw more loan token). Get the position id from get_positions. Swap calldata (close/increase/zap paths) is time-sensitive — see meta.expiresAt.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | On-chain position index, from get_positions (its `id`). | |
| full | No | repay only: clear the entire remaining debt. | |
| action | Yes | What to do to the position. | |
| amount | No | Human-units amount. Required for add_collateral/remove_collateral/repay/borrow. | |
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. | |
| leverage | No | increase_leverage: target leverage. Provide this OR desiredLtv. | |
| payToken | No | Token to pay in (add_collateral/repay). Collateral/loan = direct; any other = zapped. ETH = zero address. | |
| slippage | No | Swap slippage ratio (0.005 = 0.5%). Default 0.005, capped at 0.01. | |
| desiredLtv | No | increase_leverage: target LTV percent (e.g. '80'). Provide this OR leverage. | |
| userAddress | Yes | Wallet that owns the position and will sign. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond annotations by detailing non-custodial nature, output format (approvals[], tx, signingUrl), and time-sensitivity (meta.expiresAt). Annotations only indicate mutation and non-destructive intent, but the description adds crucial behavioral context without contradiction.
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 well-structured with a clear initial purpose, followed by key traits (non-custodial, output), actions list, and supplementary notes. It is dense but every sentence adds value, though slightly verbose for a concise tool definition.
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 10 parameters and no output schema, the description explains the output format and actions thoroughly. It omits detailed return structure from the tool's response, but the canonical output is described, making it sufficiently complete for an AI agent to understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with individual parameter descriptions, but the description adds value by summarizing actions, explaining the 'amount' requirement context, and clarifying 'payToken' behavior (zapping, zero address). This contextualization aids parameter understanding beyond the schema.
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 with a specific verb ('Build') and resource ('UNSIGNED transaction to adjust or close an OPEN position'). It distinguishes from sibling tool 'build_leverage_tx' (opening positions) by focusing on managing existing positions.
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 provides clear guidance on obtaining the position id from 'get_positions' and notes time-sensitive swap calldata. However, it does not explicitly exclude use for opening positions (which would be handled by sibling 'build_leverage_tx'), but the context is sufficient for proper selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_positionsGet PositionsARead-onlyInspect
Read a wallet's open/closed Spiral leverage positions from chain state (read-only). For each: collateral/loan, leveraged collateral, net equity, debt, current LTV vs liquidation LTV (with headroom), current leverage, net USD value, and current leveraged APY. No cost-basis / realized P&L (those need off-chain history). Newest first.
| Name | Required | Description | Default |
|---|---|---|---|
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. | |
| userAddress | Yes | Wallet address to read positions for. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true. The description adds value by detailing what fields are included (collateral/loan, leveraged collateral, etc.), ordering (newest first), and what is missing (cost-basis). This goes beyond the annotation.
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 sentences with no fluff. First sentence states purpose and read-only. Second lists output fields. Third clarifies limitations and ordering. 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?
Despite no output schema, the description explains return values (list of fields) and order. It also notes missing elements. For a read-only tool, this provides sufficient context for an agent to understand what data will be returned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with both parameters described. The description does not add new parameter details but provides context about the wallet address and output fields. Baseline 3 is appropriate as schema already covers input semantics.
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 it reads a wallet's open/closed Spiral leverage positions from chain state, specifying verb, resource, and scope. It distinguishes from sibling tools like build_leverage_tx or get_prices by focusing on position data.
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 usage for reading positions and explicitly mentions it does not include cost-basis/realized P&L, guiding that off-chain history is needed. However, it does not explicitly state when to use this tool vs alternatives, though context makes it clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pricesGet PricesARead-onlyInspect
Current USD prices for loan/collateral tokens (token address -> USD).
| Name | Required | Description | Default |
|---|---|---|---|
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, indicating no side effects. The description adds that it returns a mapping from token address to USD, which is useful. No further behavioral details are needed given the simplicity.
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, front-loaded sentence that conveys the essential purpose with zero wasted words. It 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?
With one optional parameter, no output schema, and a simple return type hinted in the description, the tool is adequately documented for a read operation. Minor missing details (e.g., data freshness) are acceptable given simplicity.
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 only parameter (chainId) is fully documented in the schema with 100% coverage. The description does not add additional meaning beyond the schema, meeting the baseline expectation for high schema coverage.
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 it provides current USD prices for loan/collateral tokens as a mapping from token address to USD. This verb+resource purpose is specific and distinguishes it from sibling tools like build_leverage_tx or get_positions.
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 fetching current prices, but does not explicitly state when to use it vs alternatives. However, since no other sibling tool provides prices, the usage context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_strategyGet StrategyARead-onlyInspect
Get one eligible strategy's full raw facts by its Morpho market id.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Morpho market id (0x followed by 64 hex chars). | |
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare 'readOnlyHint: true', so the agent knows it's non-destructive. The description adds 'full raw facts' and 'eligible strategy', but 'eligible' is vague and no details on response size or potential side effects. It adds some context beyond annotations but not extensive.
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?
Single sentence, concise and front-loaded with the core action. No wasted words. It efficiently communicates the tool's purpose.
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?
No output schema exists, yet the description only vaguely mentions 'full raw facts' without specifying what fields or structure to expect. For a simple read tool, this omission leaves agents uncertain about the response format. More detail on output would improve completeness.
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 the input schema already describes both parameters well. The description reinforces the 'id' parameter's purpose ('by its Morpho market id') but adds no meaning beyond the schema. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'get', the resource 'one eligible strategy's full raw facts', and the key identifier 'Morpho market id'. It distinguishes from siblings like 'list_strategies' (multiple strategies) and 'get_positions' (different resource).
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 when you have a specific market id and need full raw facts, but does not explicitly state when not to use it (e.g., for a list of strategies) or provide alternative tool names. Competent agents can infer, but explicit guidance is lacking.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_strategiesList StrategiesARead-onlyInspect
List eligible Spiral leveraged-yield strategies with raw risk facts (collateral/borrow APY, leverage ladder, oracle type, exit-liquidity, LTVs). Optionally filter by collateral category.
| Name | Required | Description | Default |
|---|---|---|---|
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. | |
| category | No | Filter by collateral category, e.g. 'stable', 'ETH', 'BTC', 'stable-PT'. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds value by listing the specific risk facts returned, providing useful behavioral context beyond the annotation.
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, front-loaded sentence that efficiently conveys the tool's purpose and key details with no wasted words.
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 output schema, the description compensates by enumerating the return fields. It is fairly complete for a list tool, though lacking details on pagination or ordering.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description adds minimal meaning beyond mentioning optional filtering by category; baseline score 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 clearly states the tool lists eligible strategies with specific risk facts, and it distinguishes from sibling tools like build_leverage_tx or get_strategy which serve different purposes.
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 getting an overview of strategies but lacks explicit guidance on when to use it versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
simulate_leverageSimulate LeverageARead-onlyInspect
Preview opening a leveraged position — deterministic, read-only, no wallet needed. Returns the resulting leverage, effective LTV, leveraged collateral, expected leveraged APY, price impact, the auto-selected execution path, flash-loan size, and (if the flash loan exceeds direct market liquidity) the public-allocator reallocation fee. Numbers move with market prices.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | Yes | Amount of payToken in human units (e.g. '10000' for 10,000 USDC). | |
| chainId | No | Chain to target. Supported: 1, 4663. Default: 1. | |
| leverage | No | Target leverage, e.g. 3. Provide this OR desiredLtv. | |
| payToken | Yes | Address of the token you pay in. May be the collateral (opened directly) or any other token (zapped: swapped to collateral first). Native ETH = the zero address 0x0000…0000. | |
| slippage | No | Swap slippage as a ratio (0.005 = 0.5%). Default 0.005, capped at 0.01. | |
| desiredLtv | No | Target LTV percent, e.g. '66.67'. Provide this OR leverage. | |
| strategyId | Yes | Morpho market id of the strategy (from list_strategies / get_strategy). |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint; description adds deterministic behavior, no wallet required, and enumerates all return fields with condition on reallocation fee. Full disclosure beyond annotations.
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 sentences, front-loaded with purpose, then enumerates outputs concisely. No redundant words.
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?
Complex tool with 7 parameters and no output schema, but description fully explains return values and behavior. Agents can understand when and what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so description has minimal need to explain parameters. Description focuses on outputs; no added meaning beyond schema. Baseline 3 is appropriate.
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 clearly states the tool simulates opening a leveraged position, is read-only, and deterministic. It differentiates from siblings like build_leverage_tx by noting no wallet needed. Specific verb 'Preview' and resource 'leverage position'.
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?
Explicitly says 'read-only, no wallet needed', implying use before execution. Does not explicitly name alternatives but sibling tool 'build_leverage_tx' provides contrast. Clear context but no exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
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
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!