mcp server

decker

Deterministic market-state engine for trading agents — state, gate, coordinates, with receipts.

Description as published by the maintainer. Source

• version 1.10.0
• active

active — Most recent push to the repository was 2026-08-08.

What this server can do

12 functions, named and described by the server itself. Parameter names are shown because they say more about what a function does than its name usually does.

decker.close_position(symbol, close_fraction)

Axis③ (Order/Execution) — closes (or partially reduces) an existing position through DECKER'S OWN execution engine (see decker.place_order for what that means — same account-linkage requirement applies here for real positions). Unlike place_order, there is no crypto-6 restriction — this reduces risk, not adds it, so any symbol you actually hold (including HL-synthetic/KRX paper positions) can be closed. Mode is NOT chosen by the caller — this looks up whatever position(s) actually exist for the symbol (real via live exchange query, virtual via the paper ledger) and closes whichever are open; if both a real and a virtual position exist for the same symbol, both are closed and the response reports execution_mode as 'mixed'. No open position for the symbol = a clean not-found response, not an error — safe to call speculatively. Required: symbol.

decker.get_assembly(symbol)

Multi-timeframe optimal-path assembly per symbol (STRATEGY_LAYER §8): one deterministic machine verdict combining all live timeframes — direction, grade (aligned | structure+pullback | exhaustion-reversal), entry (now vs wait, with source TF), stop (risk stop), target (upper-TF target), RR, and a conditional switch coordinate on mixed structure. Upper TF supplies the target (slower = higher success), lower TF supplies the entry. This is the single judgment authority — narrate or filter it, do not re-decide coordinates. Omit symbol for all 14 universe symbols.

decker.get_market_state(symbol, timeframe)

Market State v0 — current engine structural state for a symbol/timeframe (latest evaluated bar, persisted engine emit read as-is, zero recompute). DOMAIN FRAME (why this engine exists): the market is read as a TARGET GAME — every coordinate comes from a *verified anchor* (a past level where a triggered move actually succeeded). The `game` block tells you the context that matters: game.status = forming_target (new anchor set, awaiting test) | testing_target (price is testing whether the declared target holds) | direction_resolved (game decided, price traveling); game.target = WHO is being judged (anchor id/phase/band); game.progress_dest = where price goes if the move proceeds (the opposing verified anchor to conquer); game.reverse_dest = where it goes if the move fails (the opposite house — also the stop logic's home); game.why_gate = full gate derivation chain; game.zt_regime = output canonicality (restored = deterministic delta lineage). action_gate alone (GO/WATCH/HOLD) is only a posture — the game context is the information. RAW CONTRACT: fields are engine-native vocabulary (c_state, hold_reason, R_* risk enums …), NOT customer-facing prose — for a human-language view use decker.get_view (with tf) or decker.get_reading. layer=STATE: this is a market-state reading, NOT a trade instruction. Absent fields are null (engine did not emit that axis — no filling). Before placing any order through any execution tool, check the intent with decker.validate_intent. Required: symbol, timeframe.

decker.get_positions

Axis③ (Order/Execution) — this user's actual exposure: real open futures positions (execution_mode=real, with live sl_price/tp_price), virtual (paper) open positions, and the last 10 closed round-trips per mode. This is what your money actually did, distinct from decker.get_signals (axis②, what the engine recommends) — use this before deciding whether to place another order (avoid duplicate/over-exposure) and to check current protective stop/target on a real position.

decker.get_reading(tf, symbol, include_tfs)

AI-synthesized market reading for a symbol/timeframe, in customer-facing language: current state description, directional bias scores, bidirectional break targets, MTF verdict per timeframe, and an execution hint (stance + long/short setups). Engine-native raw fields are NOT exposed here — use the REST raw contract (GET /public/reading) or decker.get_market_state for those. Required: symbol.

decker.get_signals(limit, symbols, timeframe, action_gate, min_progress)

Active trading signals for the current user (with Skill Overlay applied), in customer-facing shape: coordinates (entry/target/stop), decision (ENTER/WAIT/SKIP), action_gate posture (GO/WATCH/HOLD — a stance, not an order command), progress, MTF verdict, and a plain-language summary_ko line. risk_reward_ratio is computed on the DISPLAYED coordinates (after overlay). Signals are retained rather than cut when they age (turn-retention policy) — read freshness_state (open|aged) / age_bars / freshness_sec before treating an old PENDING row as current. Filtered by symbols / min_progress / action_gate. Before placing any order through any execution tool, check the intent with decker.validate_intent.

decker.get_state_timeline(limit, since, symbol, timeframe)

Market State v0 — per-bar state timeline for a symbol/timeframe (same schema as decker.get_market_state, except each item carries a SLIM `game` tag {status, target_id, zt_regime, provenance} instead of the full game block — read status transitions across bars to see how the target game unfolded (forming → testing → resolved/failed); ascending by bar_ts). Bars the engine did not emit are simply absent (honest gaps, no filling). Required: symbol, timeframe.

decker.get_user_skills

Trading skill catalog + currently active overlay for this user. Returns 3 base skills (conservative_v0/standard_v0/aggressive_v0) and the user's selected one.

decker.get_view(tf, symbol)

The engine's VIEW for a symbol — the same composed card the daily briefing sends (single composer, verbatim): overall verdict, big/main timeframe alignment, the current game narrative in plain language, coordinates (baseline ref_price / target / invalidation), 'at this price, this view', and recent self-scoring verdicts (receipts). layer=STATE_VIEW: a market-state reading, NOT a trade instruction. Prefer this over get_market_state when you want the interpreted view instead of raw engine fields. Before placing any order through any execution tool, check the intent with decker.validate_intent. Required: symbol.

decker.place_order(side, symbol, notional_usd)

Axis③ (Order/Execution) — unlike every other tool here, this one moves money. It places a market order through DECKER'S OWN execution engine (same path as the decker-ai.com chat trading UI, source='mcp') — it does NOT hand off to your own broker connection or exchange account; Decker executes using whatever exchange credentials this user has separately linked to their Decker account on the website. execution_mode (virtual|real) is NOT chosen by the caller — it is resolved server-side from this user's account settings (user_settings.execution_mode) AND the platform's real-trading kill switch; a real-money order requires both an explicit user opt-in AND role/tier eligibility (PRO/ENTERPRISE or admin) AND passing the tier's hard notional/leverage/daily-count caps (checked here before dispatch — violation blocks the order, does not downgrade it to virtual). The response always states which mode actually executed — treat 'virtual' in the response as authoritative even if you expected real. Restricted to the crypto-6 universe (BTCUSDT/ETHUSDT/SOLUSDT/BNBUSDT/XRPUSDT/DOGEUSDT) for this MCP path — HL-synthetic and KRX symbols are read-only via other tools. Call decker.validate_intent first to read the engine's current stance; this tool does not check it for you. Required: symbol, side, notional_usd.

decker.set_skill_overlay(skill_id)

Change active trading skill overlay for this user. Immediately affects all subsequent get_signals calls and downstream channels. Required: skill_id.

decker.validate_intent(side, symbol, timeframe, order_type)

Pre-trade gate check for a proposed order intent. Call this BEFORE placing any order through any execution tool (e.g. a broker MCP's review→place flow). Checks the intent (symbol + side) against Decker's deterministic market state: engine action_gate (GO/WATCH/HOLD — a transition posture, not an order command), current structural state, and the active signal's direction / invalidation (stop) coordinates. Returns a stance reading, NOT an approval or rejection: the vocabulary is the engine gate as-is plus a mechanical side_alignment (aligned/opposed vs the active signal's direction). covered=false means the engine does not emit state for this symbol — treat as unknown, not as HOLD. The order decision and responsibility remain with the calling agent/user. Every check is persisted to an auditable decision ledger (check_id). Required: symbol, side.

Last successful function declaration observed on 2026-08-13. Source: https://api.decker-ai.com/api/v1/mcp. We list what the server declared; we do not call any of these functions.

Endpoint status observed on 2026-08-13. Source: https://api.decker-ai.com/api/v1/mcp.

Signals

These are separate measurements of different things. They are deliberately not combined into one score, because a popularity number that mixes website traffic with saves and stars cannot be checked or acted on.

Where to get it

• Repository — https://github.com/gigshow/decker-ai
• Website — https://decker-ai.com/mcp
• Remote endpoint (streamable-http) — https://api.decker-ai.com/api/v1/mcp

Related, by what their authors tagged them

• MarketTrace agent-feed — last commit 2026-07-04, shares binance, crypto, hyperliquid
  Crypto perps data for AI agents: funding rates, open interest, liquidations, order book, CVD.
• io.github.0xSoftBoi/suwappu — last commit 2026-08-06, shares telegram-bot, trading-bot
  Cross-chain DEX for AI agents. Swap tokens across 7+ chains.
• com.bykaranteli/mcp — last commit 2026-08-06, shares binance, crypto
  Live crypto data: funding rates, funding arbitrage, OI pressure, Fear & Greed. Free, no API key.
• pmq (Polymarket CLOB V2) — last commit 2026-08-03, shares trading, trading-bot
  Production-proven Polymarket CLOB V2 trading and data. Fail-closed fills; keys stay local.
• com.cabal-hunter.api/cabal-hunter — last commit 2026-08-01, shares trading-bot
  Solana pre-trade safety for AI agents: cabal, bundle, dump, deployer & honeypot in one verdict.
• Cerebrus Pulse MCP — last commit 2026-04-18, shares crypto, hyperliquid, trading
  Real-time crypto intelligence: technical analysis, sentiment, and funding rates
• AlgoVault — Crypto Quant Trade Calls — last commit 2026-08-06, shares crypto, hyperliquid, trading
  The Brain Layer for AI Trading Agents — quant calls + cross-venue arb across perp venues via MCP.
• Dedicated Mac Mini AI Bot Setup — last commit 2026-06-07, shares openclaw, telegram-bot
  Read-only Mac mini AI operator setup offer with queue, pricing, and buyer-route tools.
• FlowCastle — last commit 2026-07-25, shares telegram-bot
  Build, edit, and deploy Telegram bots on FlowCastle's hosted visual flow platform.
• ARGUS-3 MCP Server — last commit 2026-08-06, shares telegram-bot
  ARGUS-3 stdio MCP with WARDEN firewall: argus_ask, argus_status, argus_capabilities.

These share tags the maintainers applied themselves, such as binance, crypto, hyperliquid, trading. Common tags like "mcp" or "ai" are ignored for this: agreeing with six hundred other projects is not a similarity.

This is not a recommendation and not a test result. It is a map of what the authors said their work is about.

How the author describes it

Topics the maintainer set on GitHub: ai, binance, crypto, decker, deckerai, harness, hyperliquid, krx-api, machine-learning, openclaw, polymarket-trade-bot, telegram-bot, trading, trading-bot.