🚀 AURA MCP Server

Bridge LLMs with AURA API and EVM for on-chain intelligence

A modular Model Context Protocol (MCP) server that enables Claude & ChatGPT to interact with AdEx AURA for DeFi portfolio analysis, yield opportunities, and automated trading strategies.

🌟 Features

🔗 MCP Commands

portfolio.getBalance - Get wallet balance across chains
portfolio.getPositions - Get DeFi positions and health factors
operations.scanOpportunities - Scan for yield and airdrop opportunities
strategy.propose - Propose DCA or liquidation guard strategies
strategy.backtest - Backtest strategy performance
transaction.simulate - Simulate transaction execution
transaction.execute - Execute transactions with guard validation
guard.setRules - Configure risk management rules
report.get - Get trading history and PnL
system.health - Check system status

🛡️ Guard Engine

Risk Management: Max slippage, gas limits, health factors
Route Protection: Allowed DEXes, blocked tokens/protocols
Emergency Stop: Instant transaction blocking
Dynamic Rules: Per-user customizable guardrails

💰 x402 Paywall

On-chain payment verification
Per-request monetization
USDC/USDT payment support
Invoice generation and tracking

🔌 Strategy Plugins

DCA Event-Aware: Dollar-cost averaging with market event detection
Liquidation Guard: Automated position protection

🚀 Quick Start

Installation

git clone https://github.com/aura-mcp/server.git cd aura-mcp-server npm install

Configuration

cp .env.example .env # Edit .env with your configuration

Development

# Start development server npm run dev # Run tests npm test # Build for production npm run build

Production

# Build and start npm run build npm start

⚙️ Configuration

Environment Variables

# AURA Configuration AURA_API_URL=https://api.aura.adex.network AURA_API_KEY=your_aura_api_key # RPC Endpoints RPC_ETHEREUM=https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY RPC_BASE=https://mainnet.base.org RPC_ARBITRUM=https://arb1.arbitrum.io/rpc # x402 Payment X402_RECEIVER=0xYourWalletAddress X402_ASSET=USDC # Server MCP_SERVER_PORT=3000 NODE_ENV=production

📖 Usage Examples

Portfolio Analysis

// Get wallet balance const balance = await mcpClient.call('portfolio.getBalance', { address: '0x69bfD720Dd188B8BB04C4b4D24442D3c15576D10', chain: 'ethereum' }); // Get DeFi positions const positions = await mcpClient.call('portfolio.getPositions', { address: '0x69bfD720Dd188B8BB04C4b4D24442D3c15576D10' });

Strategy Proposal

// DCA Event-Aware Strategy const strategy = await mcpClient.call('strategy.propose', { intent: 'dca_event_aware', params: { asset: 'ETH', budgetUsd: 200, cadence: '2x/week', eventRules: { pauseOnUnlock: true, maxGasGwei: 25, boostOnDrawdownPct: 3 } }, address: '0x69bfD720Dd188B8BB04C4b4D24442D3c15576D10' });

Transaction Execution

// Simulate transaction const simulation = await mcpClient.call('transaction.simulate', { intentId: 'dca_event_aware_123', txParams: { to: '0x1234...', value: '100000000000000000', gasLimit: '150000' } }); // Execute if simulation passes if (simulation.ok) { const execution = await mcpClient.call('transaction.execute', { intentId: 'dca_event_aware_123', txParams: simulation.txParams }); }

🏗️ Architecture

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Claude/ChatGPT│ │ AURA MCP Server│ │ AURA API/SDK │ │ │◄──►│ │◄──►│ │ │ - Tool Calls │ │ - MCP Protocol │ │ - Portfolio │ │ - Responses │ │ - Guard Engine │ │ - Strategies │ │ - Context │ │ - x402 Paywall │ │ - Analytics │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌─────────────────┐ │ EVM Chains │ │ │ │ - Ethereum │ │ - Base │ │ - Arbitrum │ │ - Polygon │ └─────────────────┘

🧪 Testing

# Run all tests npm test # Run with coverage npm test -- --coverage # Run specific test npm test -- --testNamePattern="Guard Engine"

🚀 Deployment

Vercel

npm i -g vercel vercel --prod

Railway

npm i -g @railway/cli railway login railway up

Docker

docker build -t aura-mcp-server . docker run -p 3000:3000 aura-mcp-server

📊 Performance

Response Time: < 2s for portfolio analysis
Throughput: 100+ requests/minute
Uptime: 99.9% SLA
Security: Guard engine protection

🔒 Security

Input validation with Zod schemas
Guard engine risk management
x402 payment verification
Rate limiting and DDoS protection
Encrypted environment variables

🤝 Contributing

Fork the repository
Create feature branch (git checkout -b feature/amazing-feature)
Commit changes (git commit -m 'Add amazing feature')
Push to branch (git push origin feature/amazing-feature)
Open Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🏆 Hackathon Submission

Project: AURA MCP Server
Event: AdEx AURA Hackathon
Deadline: October 22, 2025
Status: ✅ Ready for submission

Demo Links

Live Demo: https://aura-mcp-hackathon.vercel.app
Video Demo: https://youtube.com/watch?v=your-demo-video
GitHub: https://github.com/aura-mcp/server

Key Features Demonstrated

✅ Portfolio analysis across multiple chains
✅ DCA Event-Aware strategy automation
✅ Liquidation guard protection
✅ x402 paywall monetization
✅ Guard engine risk management
✅ Real-time transaction simulation

📞 Support

Documentation: docs.aura-mcp.dev
Issues: GitHub Issues
Discord: AURA Community
Email: support@aura-mcp.dev

Built with ❤️ for the AURA community

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Enables Claude and ChatGPT to interact with AdEx AURA API for DeFi portfolio analysis, yield opportunity scanning, and automated trading strategy execution across multiple EVM chains. Includes risk management guardrails and on-chain payment verification.

AURA MCP Server