AURA MCP Server

How to use

You interact with the server through an MCP client to perform actions like parsing swap intents, obtaining best-rate quotes, preparing and executing trades, and analyzing portfolios. Use the HTTP MCP endpoint for multi-client web integration or run a local MCP process for desktop-style integrations. The server also supports real-time strategies, risk guards, and payment workflows, so you can automate DeFi operations with confidence.

Typical usage patterns include: parsing a natural language swap request, requesting a best-quote route across supported chains, preparing a transaction with necessary allowances, and then signing and submitting the transaction. You can also fetch cross-chain balances, inspect DeFi positions, scan for airdrops or liquidation risks, propose AI-driven investment strategies, and backtest those strategies against historical data.

How to install

Prerequisites you need on your machine or deployment environment are Node.js 18 or newer, an AURA API Key, and Git. Ensure your environment is configured to run web servers or local MCP components as you prefer.

# Clone the MCP server repository
git clone https://github.com/aura-mcp/server.git
cd aura-mcp-server

# Install dependencies
npm install

# Prepare environment
cp env.example .env
# Edit .env and add your AURA_API_KEY

Configuration and environment

Set your AURA API key and optional endpoints in the environment. The server expects AURA_API_KEY and can accept a custom AURA API URL if needed.

# Example environment variables
AURA_API_KEY=your_aura_api_key_here
# Optional
AURA_API_URL=https://aura.adex.network
MCP_SERVER_PORT=5000
NODE_ENV=production

Integration with LLMs

Connect popular language models to the MCP server using native MCP endpoints. You can run the server behind standard HTTP APIs or over standard input/output streams for local integrations. Use the provided MCP endpoint to enable real-time bidirectional communication and tool calls between the model and DeFi actions.

Deployment and runtime

You can deploy the MCP server to a hosting platform or run it locally. The server supports standard deployment flows and uses environment variables for sensitive information like your AURA API Key.

# Production build and start
npm run build
npm start
```

```bash
# For development server (HTTP API for web integration)
npm run dev

# For MCP-specific runtime (Claude Desktop integration)
npm run dev:mcp

Security and guardrails

The server includes input validation, a guard engine for risk management, and on-chain signing in the browser to avoid exposing private keys. It also provides on-chain payment verification and rate limiting to protect against abuse.

Testing and performance

You can run the test suite to verify functionality and coverage. Performance targets include sub-second swap quotes, multi-second portfolio analyses, and rapid backtests for strategies.

# Run tests
npm test

# Run with coverage
npm test -- --coverage

# Watch mode
npm run test:watch

API and endpoints overview

The MCP server exposes a set of tool endpoints for swap, portfolio, operations, and strategy actions. Interactions are exposed over HTTP endpoints as part of the MCP protocol.

For example, you can parse a swap intent, request a quote, prepare a transaction, and execute a signed swap. You can also fetch balances, positions, scan opportunities, propose strategies, and backtest those strategies.

Notes on MCP endpoints and usage

There are two primary ways to connect: an HTTP MCP endpoint for remote clients and a local stdio setup for direct desktop integrations. Make sure your client uses the correct endpoint and passes the required environment variables.

swap.parse

Parse natural language swap intents into structured swap parameters

swap.quote

Obtain a swap quote with the best route across supported DEXes and chains

swap.prepare

Prepare a swap transaction, including allowances and routing data

swap.execute

Execute a signed swap transaction on-chain

portfolio.getBalance

Query cross-chain wallet balances for a given address and chain

portfolio.getPositions

Retrieve DeFi positions with health factors across protocols

ops.scanOpportunities

Scan for opportunities such as airdrops or liquidations with parameters

strategy.propose

Propose AI-powered DeFi strategies (e.g., DCA, rotation) with parameters

strategy.backtest

Backtest a proposed strategy over a lookback period

transaction.simulate

Simulate a transaction to estimate results without on-chain execution

transaction.execute

Execute a previously prepared transaction or intent

guard.setRules

Configure guard rails and risk rules for per-user protection