Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Delora MCP get a cross-chain quote for 100 USDC from Ethereum to Arbitrum"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP (Model Context Protocol) server for the Delora API: cross-chain quotes, supported chains, tokens, and tools.
npm installRelated MCP server: Relay Protocol MCP Server
Copy env.example to .env and adjust:
Variable | Description | Default |
| Delora API base URL |
|
| Optional API key forwarded to Delora API as | unset |
|
|
|
| HTTP server port (when |
|
| HTTP bind address |
|
When DELORA_API_KEY is set, the MCP server forwards it to Delora API as the x-api-key header. In HTTP mode, the server also accepts incoming x-api-key or Authorization: Bearer ... headers and forwards the resolved key upstream. For HTTP requests, incoming headers take priority over DELORA_API_KEY. For stdio, DELORA_API_KEY remains the way to provide the key.
Stdio (default) — for Cursor/IDE MCP over stdio:
npm run dev
# or
npm run build && npm startHTTP — for streamable HTTP (e.g. behind a reverse proxy):
npm run dev:http
# or
npm run build && npm run start:httpServer listens on http://0.0.0.0:3000/mcp.
Stdio:
{
"mcpServers": {
"delora": {
"command": "node",
"args": ["/path/to/delora-mcp/dist/index.js"]
}
}
}Streamable HTTP (e.g. after deploying to https://mcp.delora.build):
{
"mcpServers": {
"delora": {
"url": "https://mcp.delora.build/mcp",
"transport": "streamable-http",
"headers": {
"x-api-key": "YOUR_API_KEY"
}
}
}
}You can also use Authorization: Bearer YOUR_API_KEY instead of x-api-key when your MCP client supports custom HTTP headers.
Build and run:
docker build -t delora-mcp .
docker run -p 3000:3000 -e MCP_TRANSPORT=http delora-mcpFor production behind a domain (e.g. mcp.delora.build): run the container with MCP_TRANSPORT=http and put nginx/traefik (or another reverse proxy) in front with HTTPS; then use the URL https://mcp.delora.build/mcp with streamable-http in Cursor.
Delora API — base URL for all /v1/* endpoints (quotes, chains, tokens, tools, token).
Tool | Description |
| Returns this guide (call first for workflow). |
| GET /v1/quotes — cross-chain quote. |
| GET /v1/chains — supported chains. |
| GET /v1/tools — available tools. |
| GET /v1/tokens — supported tokens. |
| GET /v1/token — single token by chain + token. |
List supported chains. Optionally filter by chainTypes (e.g. EVM,SVM).
| Name | Required | Description | Default |
|---|---|---|---|
| chainTypes | No | Comma-separated chain types, e.g. EVM,SVM |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. 'List' indicates a read-only operation, but no details are provided about response format, pagination, permissions, or side effects. It adds minimal context beyond the obvious non-destructive nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the core purpose and mention the filter. Every word earns its place; no fluff or 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 simple list tool with one optional parameter and no output schema, the description is sufficient: it states what is listed and that filtering is possible. It does not elaborate on possible chainTypes values beyond the schema example, but the tool's simplicity does not demand more.
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% (chainTypes is described as comma-separated chain types with an example). The description adds no new meaning; it repeats the schema's example (EVM,SVM). Baseline 3 applies because the schema fully explains the parameter.
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 ('List') and the resource ('supported chains'), making the tool's purpose unambiguous. It is distinct from sibling tools that operate on other resource types like tokens or quotes. The optional filter is mentioned as a secondary feature.
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 (call to list chains, optionally filter by chainTypes) but does not explicitly state when to choose this tool over alternatives or provide exclusions. No sibling differentiation is stated, though the resource name inherently separates it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
CALL THIS FIRST. Returns the guide for Delora MCP: how to get quotes, chains, tokens, tools…
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey safety and behavior. 'Returns the guide' implies a read-only, safe operation, but it doesn't add details about response format, size, or potential side effects. For a simple parameterless tool, this is adequate but not rich.
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 immediately conveys the key action ('CALL THIS FIRST') and the tool's purpose. No filler words or 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 simple guide tool with no parameters and no output schema, the description is sufficiently complete. It states the tool's purpose and scope, though the trailing ellipsis is slightly informal and could be more explicit about what the guide contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is fully declarative. The description doesn't need to explain parameters, and the 'CALL THIS FIRST' hint compensates for any lack of schema-level context. Baseline 4 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 tool returns the guide for Delora MCP and outlines what it covers (quotes, chains, tokens, tools). It distinguishes itself from sibling tools by positioning itself as the orientation resource, not the specific data-fetching tool.
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 explicit directive 'CALL THIS FIRST' provides clear when-to-use guidance, informing the agent to invoke this tool before any sibling tools. This is a strong usage signal that differentiates it from alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a cross-chain quote: best route, output amount, calldata, gas. Use get_chains and get_tokens first to resolve chain IDs and token addresses.
| Name | Required | Description | Default |
|---|---|---|---|
| originChainId | Yes | Origin chain ID (e.g. 1 for Ethereum, 42161 for Arbitrum) | |
| destinationChainId | Yes | Destination chain ID | |
| amount | Yes | Amount in smallest units (wei/smallest decimals) | |
| originCurrency | Yes | Token address on origin chain; use 0x0... for native currency | |
| destinationCurrency | Yes | Token address on destination chain; use 0x0... for native | |
| senderAddress | No | Sender wallet address | |
| receiverAddress | No | Receiver wallet address | |
| integrator | No | Integrator identifier | |
| fee | No | Fee 0–0.1 (only with integrator) | |
| slippage | No | Slippage tolerance 0–1 (e.g. 0.005 for 0.5%) |
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 indicates this generates a quote (not an execution), but it does not explicitly state that no transaction is executed, nor does it disclose error handling, rate limits, or other behavioral traits. The outputs listed are useful, but the mutation/read-only nature is implicit rather than explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first defines the purpose and outputs, the second gives a prerequisite. It is front-loaded, free of redundancy, and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 10 parameters and no output schema, the description lists the key return elements (route, amount, calldata, gas) and a prerequisite. Missing are notes on how the calldata should be used, optional parameter implications, or possible failure modes, but the core context is sufficient for initial 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 provides 100% coverage with detailed descriptions for all 10 parameters, so the schema handles the parameter semantics. The description adds minimal extra value beyond referencing chain/token resolution, which is already implied by the parameter names and descriptions. 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?
The description clearly states the tool obtains a cross-chain quote with specific outputs: best route, output amount, calldata, and gas. This is a specific verb+resource with concrete deliverables, distinguishing it from sibling tools like get_chains and get_tokens.
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?
It explicitly instructs the agent to call get_chains and get_tokens first to resolve chain IDs and token addresses, providing clear sequential context. It does not mention when to avoid this tool or mention alternatives, but the prerequisite guidance is actionable and relevant.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a single token by chain and token address/symbol.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Chain ID or chain identifier | |
| token | Yes | Token address or symbol |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description carries the full burden of disclosing behavior. It only says 'get', which implies a read operation, but does not mention response format, potential errors, or any special handling such as symbol ambiguity or case sensitivity.
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, clear sentence that is front-loaded with the core action. 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?
The tool is relatively simple with two parameters and no output schema. The description is sufficient to understand the basic operation, but the lack of output details and behavioral nuance leaves some gaps, especially with no annotations to fill in.
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 already describes both parameters (chain, token) with 100% coverage. The description's remark 'by chain and token address/symbol' adds no additional meaning beyond what the schema provides.
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 retrieves a single token by chain and address/symbol, with the word 'single' distinguishing it from the sibling get_tokens. However, it does not explicitly name the alternative tool or explain the 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?
No guidance is provided on when to use this tool versus alternatives like get_tokens. The singular/plural distinction is implied but not stated explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List supported tokens. Optionally filter by chains and/or chainTypes.
| Name | Required | Description | Default |
|---|---|---|---|
| chains | No | Comma-separated chain IDs or identifiers | |
| chainTypes | No | Chain types, e.g. EVM,SVM |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description is the sole source. 'List' implies a read-only operation, but the description does not disclose the output format, possible pagination, or any side effects. It is acceptable but not rich in behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence, front-loaded with the verb 'List', and no unnecessary words. It is concise and to the point.
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 list tool, this is mostly complete: it states the purpose and optional filters. However, with no output schema or annotations, it does not clarify the return format or any potential limits, leaving some ambiguity for the agent.
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 already provides 100% coverage for both parameters, including descriptions of format and examples. The description's mention of filters adds no extra meaning beyond what the schema already conveys.
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 uses a specific verb ('List') and resource ('supported tokens'), clearly indicating the action and object. It also mentions optional filters, distinguishing it from siblings like get_token (singular) and get_chains.
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 states that filtering is optional, which gives some usage context, but it does not explicitly compare this tool with alternatives like get_token or get_chains, nor does it mention when this tool should be preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available tools (e.g. bridges, DEXes). Optionally filter by chains (comma-separated).
| Name | Required | Description | Default |
|---|---|---|---|
| chains | No | Comma-separated chain IDs or identifiers |
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 indicates a read-only listing action but does not mention authentication requirements, rate limits, pagination, or behavior when no chains are specified. The only added behavioral detail is the filter format.
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 clearly states the main purpose and adds a valuable filtering option. No wasted words; every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional parameter, no output schema), the description covers the essential usage. It could explicitly state that omitting chains lists all tools, but that is reasonably implied by 'Optionally filter'. The examples of bridges and DEXes further clarify the scope.
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 already documents the 'chains' parameter with 100% coverage, including the comma-separated format. The description essentially repeats this information ('comma-separated') without adding new semantics, so it meets the baseline but does not exceed it.
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 available tools, with specific examples (bridges, DEXes) that distinguish it from sibling tools like get_tokens. The optional chain filter adds scope, making the purpose unambiguous.
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 listing tools with optional filtering by chains, but does not explicitly state when to use it over alternatives or when not to use it. It provides contextual usage (comma-separated chains) but lacks exclusions or explicit sibling comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.5get_chainsget_instructionsget_quoteget_tokenget_tokensget_toolsScored across 6 tools
Each tool targets a distinct resource: chains, instructions, quote, token, tokens, tools. No overlapping purposes, clear differentiation.
All tools follow a consistent 'get_' prefix with singular or plural nouns (get_chains, get_instructions, get_quote, get_token, get_tokens, get_tools). Predictable pattern.
6 tools is well-scoped for a cross-chain quote server. Covers discovery, guidance, and quote retrieval without being excessive or too few.
The set covers all necessary operations: listing chains, tokens, and tools; retrieving a specific token; getting a quote; and providing instructions. No obvious gaps for its stated purpose.
Cross-network DeFi API data, AMM analytics, and SDK docs for 17+ networks.
Doc search, intent & cross-chain swaps, limit orders, portfolio, spot prices, gas & all APIs.
Token swaps and honeypot/rug checks for AI agents on 8 chains, paid per-call in USDC via x402.
17-model LLM gateway + 350+ data/KYB/sanctions tools. Pay-per-call USDC via x402, no API key.
