Dmoera MCP Server

dMoERA Creator Studio — MCP Server

Build, backtest, and deploy crypto trading strategies using any MCP-compatible AI agent (Claude, Cursor, Windsurf, Devin, Copilot, etc.).

What it does

The dMoERA MCP server exposes the dMoERA Creator API as Model Context Protocol tools. Your AI agent can:

• Discover trading domains, data feeds, and market regimes
• Inspect existing bots and their live performance metrics
• Backtest strategy code in a sandboxed environment
• Submit strategies for full 7-stage validation and live deployment
• Manage personal hedge funds — create funds, add your own bots, activate Manager Mode
• Monitor tournament status, Tag Team leaderboards, and Vault allocation
• Track fund positions, trades, P&L, analytics, and immutable report cards

This is a thin API client — it talks to a running dMoERA backend via HTTP. No internal dMoERA code is required.

Installation

Prerequisites

• Python 3.11+
• The mcp Python package (pip install mcp)
• A running dMoERA backend (or connect to the public instance)

Setup

git clone https://github.com/CacheCarti/dmoera-mcp.git
cd dmoera-mcp
pip install -r requirements.txt

MCP Configuration

Add this standard MCP configuration to Claude Desktop, Cursor, Windsurf, or another MCP client:

{
  "mcpServers": {
    "dmoera-creator": {
      "command": "python",
      "args": ["/absolute/path/to/dmoera-mcp/mcp_creator_server.py"],
      "env": {
        "DMOERA_API_URL": "https://dmoera.xyz",
        "DMOERA_API_KEY": "your_optional_personal_access_token"
      }
    }
  }
}

The API key is optional for public market data and discovery tools. Create a Personal Access Token at dmoera.xyz under Settings → API Keys to backtest, submit, fork, open-source, or delist strategies. Never commit your token.

Remote clients can connect through the Streamable HTTP endpoint:

https://dmoera.xyz/mcp

Tools (44 total)

Discovery & Market Data

Strategy Development

Marketplace & Tournaments

Fund Management (personal funds — own bots only)

Personal funds can only contain the authenticated user's own bots. Use list_my_bots to see eligible strategies.

Tag Team (daily paper trading competition)

Vault (regime-aware allocation)

Resources

• creator-api://docs — Full strategy contract documentation
• creator-api://strategy-template — Copy-pasteable strategy template

Example Usage

Ask your AI agent:

"List all trading domains on dMoERA, then backtest a simple RSI mean-reversion strategy for ETH/USDC."

The agent will call list_domains, inspect the available markets, then call sandbox_backtest with strategy code it generates. You can iterate:

"The Sharpe is too low. Try adding a volatility filter — only trade when ATR is above its 20-period average."

"Submit this strategy to the ETH/USDC domain."

The agent calls submit_strategy, which runs the full 7-stage validation pipeline. If it passes, the strategy enters the live Arena and competes for tournament payouts.

Hedge Fund Management

"Create a personal hedge fund called 'Alpha Seeker' with a standard risk preset. Then list my eligible bots."

The agent calls create_fund, then list_my_bots to show which of your strategies can be added to the roster.

"Add my momentum ETH bot with 30% weight and my scalper BTC bot with 20% weight, then activate the fund."

The agent calls add_bot_to_fund twice, update_fund_weights, then activate_fund to start the personal router.

"How's the fund doing? Show me the analytics and latest report card."

The agent calls get_fund_analytics and get_fund_report_card.

Strategy Contract

Strategies subclass Strategy and implement on_bar(self, ctx) -> Signal. See the creator-api://docs resource for the full contract.

class MyStrategy(Strategy):
    METADATA = {
        "name": "SMA Crossover",
        "domain": "eth_usdc",
        "declared_sl_bps": 150.0,
        "declared_tp_bps": 300.0,
        "declared_hold_seconds": 3600,
        "warmup_bars": 20,
        "required_features": [],
    }

    def on_bar(self, ctx):
        closes = ctx.closes(lookback=20)
        if len(closes) < 20:
            return None
        fast = sum(closes[-5:]) / 5
        slow = sum(closes) / 20
        if fast > slow:
            return ctx.signal(
                direction=SignalDirection.LONG,
                confidence=0.7,
                stop_loss_bps=150.0,
                take_profit_bps=300.0,
                horizon_seconds=3600,
            )
        return None

Hedge Fund System

Personal hedge funds (Manager Mode) let you build a portfolio of your own bots:

1. Create a fund with a risk preset (prudent, standard, opportunistic, unrestricted)
2. Add your own bots to the roster with allocation weights
3. Set risk caps — max allocation per bot, per domain, regime veto
4. Activate Manager Mode to deploy capital across the roster
5. Monitor PnL, swap bots as needed, adjust weights
6. Generate immutable report cards for track record
7. Close the fund to return all capital to your wallet

The personal router replaces the main platform router while Manager Mode is active, giving you full control over which bots trade and how much capital they get. Personal funds can never contain another user's bots.

Tag Team System

Tag Team is a standalone daily paper-trading competition, separate from the main router and tournaments:

• Start: Pick a Co-Pilot template (momentum, scalper, etc.) → get $10,000 paper capital
• Capital split: 70% human ($7,000), 30% Co-Pilot bot ($3,000)
• Manual trades: 20 max per day, leverage 1-20x
• Bot deploy: After 3 closed manual trades, deploy the Co-Pilot
• Scoring: Need 5+ human trades AND 5+ bot trades to qualify
• End: At UTC midnight, all open positions close at market price
• Next day: Fresh $10k, but bot params carry over (trained settings persist)

Tiers: Rookie (0) → Apprentice (10) → Trader (50) → Veteran (150) → Expert (500) → Master (1000+), based on total trades across all sessions.

Tournament System

Bots compete in 3-day tournament rounds. Scoring is based on the bot's own performance:

• 50% risk-adjusted (rolling Sharpe ratio)
• 30% total return (log-scaled bps)
• 20% consistency (win rate × trade volume)

Top 3 per domain win USDT from the reward pool. No user following needed to qualify — your bot competes on its own metrics.

Links

• Platform: dmoera.xyz
• GitHub: github.com/CacheCarti/dmoera-mcp
• Twitter: @dMoERAHQ
• Discord: discord.gg/gXWDjDdQv

License

MIT