@sbynode-ux
基本情報
Ask n0brains first. Your agent submits a planned trade (asset, side, entry, stop, leverage) and gets back a graded A–F conditions assessment from live market data — positioning crowding, event risk inside the horizon, liquidation clusters, market regime. 28 tools including win-ra
以下の設定を使って、このサーバーを MCP 対応クライアントに追加してください。
{
"mcpServers": {
"n0brains": {
"url": "https://api.n0brains.com/mcp",
"headers": {
"X-API-Key": "YOUR_API_KEY"
}
}
}
}[RAW FEED — engine inputs, NOT trade calls] List active n0brains signals with optional filters. Filters: asset (e.g. 'ETH'), signal_type (whale|sentiment|listing|regulatory|macro|macro_pulse|liquidation|funding|hack|price|other), direction (bullish|bearish|neutral), urgency (high|medium|low), min_confidence, min_score, limit (1-100, default 20), offset. Each signal includes historical_edge, paired_inverse, signal_latency_secs, priced_in_*, calibration_inverted_in_cell. CONFIDENCE CONTRACT: confidence = calibrated empirical win-probability estimate (binned per signal_type), NOT raw model output; when confidence is null, confidence_suppressed_reason says why; confidence_status is one of calibrated|floor_demoted_at_emit|suppressed_anti_predictive|demoted_anti_predictive_type. Transform emitters (whale_position leaderboard fade) carry observed_direction/observed_behavior/model_transform/predicted_direction so the raw observation is never lost. Most rows carry action_hint=ignore — engine inputs, not calls; read historical_edge (cell win_rate) before echoing any direction. For tradeable output use get_actionable_signals.
[RAW FEED — detail] Fetch a single signal by ID with full enrichment (historical_edge, paired_inverse, latency, priced_in fields). Returns 404 semantics via tool error if signal not found.
[MONITORING] Polling alternative to the /stream WebSocket. Returns active signals with timestamp > `since_timestamp` (unix epoch seconds). Use the returned server_timestamp as the next call's since_timestamp to walk forward without gaps. Hard limit 100 per call.
[RAW FEED — detail+context] Composite call: signal + same-asset S/R levels + active macro bias. Saves 2-3 round trips. Returns a dict (not a typed model — the composite shape varies).
[DRILL-DOWN — history rhymes] Semantic similarity search across the signal corpus: give a coin and/or a free-text query (q), get the k most similar past signals ranked by embedding cosine similarity — 'have we seen this setup before and what did it look like'. k = 1-20 (default 5). Provide at least one of coin / q. Mirrors REST /signals/similar. Pro. Analytical, not advice.
[TRUTH ANCHOR] THE canonical current price (live exchange mid) for a coin — the single source of truth every other n0brains tool's spot/current_price should agree with. Returns {coin, price, source, age_secs, ts}. Use this to sanity-check any analytic payload: if a tool's spot disagrees materially with this, that tool's price is stale and its read should be discounted. Free tier. Public data, not financial advice.
[TRUTH ANCHOR] Batch canonical prices for several coins in one call. coins = comma-separated symbols, e.g. 'BTC,ETH,SOL' (max 50). Returns {prices:{SYM:price}, missing:[...], source, age_secs}.
[DRILL-DOWN] Support/resistance levels for a coin (e.g. 'BTC', 'ETH', 'SOL'). Reads from levels_engine + Hyperliquid mids. Levels are detected on THREE timeframes — 15m (3 days back), 4h (90 days) and 1d (2 years) — and every level carries its `timeframe`, `distance_pct` and zone band. `nearest_resistance`/`nearest_support` are the immediate intraday levels (within ~5% of spot) and are often fractions of a percent away; for swing structure read `structure.resistance` / `structure.support`, which are the 4h/1d levels out to 35% from spot, strongest first. A level merged across tiers lists the confirming timeframes in `confirmed_by`. Same data as REST /levels/{coin}.
[CONTEXT] Current macro bias (regime, BTC/ETH bias + conviction, calendar risks). Mirrors REST /macro current snapshot. Honesty overlay applied: fields marked uncalibrated, insufficient-data flags surfaced.
[CONTEXT] Active signals whose direction AGREES with the current macro bias (conviction ≥ 0.6). Uses the same rule the internal pipeline uses to boost confidence x1.12 (vs CONFLICTS, which dampens x0.88). macro and macro_pulse signal types are excluded (they ARE the macro). Optional asset filter.
[RECEIPTS] Backtest performance over last N days (1-365, default 30). Same data as REST /performance. Note: no asset filter — performance is aggregated across all assets. Performance is the live forward-return record by signal type. DENOMINATOR CONTRACT — every block (overall, by_signal_type, by_coin, by_source) carries total/wins/partials/losses/expired/settled/win_rate. `total` counts signals emitted, settled or NOT: most expire unsettled, so wins/total is not a win rate and ranks lanes backwards. `win` = full take-profit only; a partial is not a loss. Rank on win_rate (wins/settled) or avg_pnl. `win_rate` is null when settled=0 — that is 'not yet measurable', NOT zero. For the gated per-type verdict with confidence intervals and the tradeable badge, use get_proof instead.
[DRILL-DOWN] Latest TradFi market open prices for BTC/ETH/SOL across sessions. Source: watchers.market_opening_watcher.get_latest_opens(). Same data as REST /market-opens.
[START HERE — 'find me a trade'] Signals the production trade-gate itself marked actionable (action_hint=trade_signal — the engine's per-(type,direction) proven verdict), age ≤ max_age_min. Skips anti-predictive cells. Also returns swing_outlooks: labeled days-scale reads from cells proven at 7-30d horizons, each with its proven horizon and a suggested hold — NOT intraday trades. Pass min_score / min_confidence only if you want additional numeric bars on top of the engine verdict. When the result is empty, the `context` block points to rank_trades / get_trade_plan — a signal-gate miss does not mean no setup exists (positioning/levels setups aren't signal-driven). ALWAYS check `has_trade_signal` (true only when a real intraday trade cleared the gate) and render `reads` — a single array that is NEVER empty when any read exists: it holds the gate-passed trade signals, or, when none cleared, the strongest context read + swing outlooks, each tagged `kind` and `actionable`. `signals` stays strictly gate-passed; items in `reads` with actionable=false are NOT trades. Next: grade any candidate with check_trade; rank_trades when nothing cleared the gate.
[RECEIPTS] Cells from cell_stats.json with inverse_flagged=true. These are (signal_type × direction × regime) buckets where the empirical win-rate is below the inverse_thresholds floor with sufficient sample. Signals in these cells get calibration_inverted_in_cell=true and have confidence nulled in customer-facing serialization.
[META] Liveness + lightweight pipeline stats: uptime, signals in last 1h, current macro regime, classifier backlog. Mirrors REST GET /health with extra context. Pro-gated (per tools/call rule) — use REST /health for unauthenticated liveness.
[META] Your own API usage: total calls, per-day series and top endpoints over period '7d' or '30d'. Use it to budget calls — free tier check_trade is 3/day (get_check_history shows the remaining count). Mirrors REST /usage. Private to your account.
[DRILL-DOWN] Liquidation map for a coin (e.g. 'BTC', 'ETH'), binned into price clusters — the same feed that powers positioning's liq_magnet and market_state's target/invalidation. Shows long/short imbalance per zone (long_usd vs short_usd per bucket), nearest dense cluster below and above price, and top zones by notional. PROVENANCE VARIES BY COIN — always read the returned `observed` / `modeled` / `method` fields before describing the data. BTC, ETH and HIP-3 tokenized stocks/metals/indices have a DEX book, so their maps are OBSERVED per-position liquidation prices (Hyperliquid + GMX). Coins with no DEX book (XRP, SOL, DOGE, most alts) return a MODELED estimate built from aggregate CEX open interest and calibrated leverage tiers — real zones, but an estimate, and its long/short totals are symmetric by construction. Same data as REST /liqmap/{coin}.
[DRILL-DOWN] Return-correlation + beta of a coin to BTC and ETH over a 7d window of 15m log returns, plus its most/least correlated peers. Descriptive statistic (correlation is not causation). Same data as REST /correlation/{coin}.
[CONTEXT] Altseason/rotation read: is capital rotating INTO alts (altseason) or back to BTC (risk-off)? rotation_score in [-1,1] from relative-strength breadth + correlation trend. Breadth is a PROXY, not true BTC dominance. Uncalibrated heuristic. Same data as REST /rotation.
[DRILL-DOWN] Options analytics for a coin (BTC or ETH): ATM implied vol, skew (put-call IV proxy — the fear gauge), IV term structure, put/call OI ratio, and max-pain, from public Deribit data. Positive skew = downside hedging/fear; term_structure slope > 0 = contango. Descriptive positioning, not prediction. Same data as REST /options/{coin}.
[DRILL-DOWN] Aggregate sentiment for a coin: net directional lean (confidence-weighted, recency-decayed), chatter volume + velocity (is it accelerating?), and contributing sources, over 24h. Coverage is CURATED high-edge authors — what the tracked smart-money voices lean, NOT mass social volume. Same data as REST /sentiment/{coin}.
[DRILL-DOWN] Mindshare leaderboard: each asset's share of crypto attention across n0brains' sources over the window, ranked, with velocity (rising / falling / emerging). The edge is a coin's attention ACCELERATING before price moves. Directional proxy over n0brains sources, NOT a market-wide social-firehose absolute. Same data as REST /mindshare.
[DRILL-DOWN] One coin's mindshare: its attention share %, rank, and velocity vs the prior window (rising/falling/stable/emerging). Same data as REST /mindshare/{coin}.
[START HERE — coin snapshot] Unified whole-system snapshot for one coin: current price, per-coin market-state consensus (proven-voter directional read), nearest support/resistance levels, liq-map target/invalidation, and the shared macro regime (deterministic FRED composite anchor + LLM read + any divergence). One call instead of stitching get_macro + get_market_state + get_levels. Drill down only if needed: get_positioning (who is crowded), get_indicators (momentum+Fib), get_liquidation_map (magnets), get_options (vol). Pro tier. Measured + AI data, not advice.
[DRILL-DOWN — prose brief] LLM-written 'state of <coin>' in markdown: joins the headline consensus, macro composite, levels, technical indicators and flow context into one readable analysis you can quote to a user directly (the narrative layer over get_state; the structured payload rides along in `data`). Cached 15 min server-side. Mirrors REST /state/{coin}/brief. Pro. AI-generated synthesis, not advice.
[DRILL-DOWN] Technical indicators for a coin (e.g. 'BTC', 'ETH', 'SOL', 'XRP'): RSI(14), MACD, SMA/EMA (20/50/200 + 200-week), Stochastic, and FIBONACCI retracement levels (90-day swing). Returns daily + weekly timeframes plus a plain-language read. Same data as REST /indicators/{coin}. Use for momentum + Fib confluence with get_levels.
[STEP 2 — plan one coin] Assembled trade plan for one coin: direction, entry, strongest target, stop, risk/reward, sizing hint, options context (put/call + skew), and warnings (max-pain timing against the trade, entry near a liq cluster). Mirrors GET /plan/{coin}. Analytical, not advice.
[STEP 2 — pick the coin] Cross-asset ranking: assembled trade plans for the given coins sorted by setup_score (best first) — answers 'which coin is the better trade right now?'. coins = comma-separated (default BTC,ETH,SOL). Mirrors GET /rank. Analytical, not advice.
[CONTEXT — market overview] Market-wide risk-appetite read: risk-on / risk-off / squeeze from a blend of the macro composite, cross-sectional breadth, funding regime and vol. Answers 'do conditions favor risk right now?'. Mirrors REST /regime. Descriptive, uncalibrated, not financial advice. One-call morning brief incl. this block: get_market_brief.
[CONTEXT] Net cross-asset liquidity map: Fed net liquidity, stablecoin dry-powder, total perp OI, liquidation pressure, net taker flow. Answers 'where is liquidity?'. Mirrors REST /liquidity. Descriptive, not advice.
[CONTEXT] Cross-asset flows: crypto rotation, crypto-vs-tradfi OI split, institutional posture (ETF flow / COT / 13F, descriptive). Answers 'where are funds going and is the market buying something other than crypto?'. Mirrors REST /flows. ETF flow is proven non-predictive. Not advice.
[RECEIPTS — experimental] Emergent edge discovery: corroboration class-combinations mined from the shadow ledger vs realized forward returns, ranked by measured edge (honesty-gated, both-halves). Surfaces patterns nobody hand-coded. status=accruing until the ledger fills (~60-90d). Candidate, not advice.
[TIMING] Scheduled macro + earnings calendar — the 'knows WHEN' feed. Upcoming high-impact US macro releases (CPI, NFP, FOMC, PPI, GDP) and tracked single-name earnings (NVDA, TSLA, MSFT, +) with consensus/previous, and actual + surprise once printed. Args: days_back (0-90, default 7), days_ahead (0-60, default 14), event_class ('macro'|'earnings', optional). Same data as REST /calendar. Context for timing/regime, not a direction call.
[RECEIPTS] Per-non-crypto-asset-class forward-return scoreboard (asset_class = stock | index | metal | commodity). Measured on that class's own rows + baseline (stock excess vs SP500; index/metal/commodity absolute). Intel-only: the tradeable badge is informational, non-crypto is not auto-traded yet. status=accruing until a (type,direction) reaches the min sample. Same data as REST /proof?asset_class=. For the crypto board use get_performance or REST /proof. Not financial advice.
[RECEIPTS] The full public forward-return proof board — richer than get_performance: per-signal-type measured post-signal performance with the proven-gate `tradeable` badges, plus the SWING boards. Args: asset_class (stock|index|metal|commodity — same as get_asset_class_proof) OR horizon ('7d'|'14d'|'30d' for the swing-horizon boards, measurement-only, never badged tradeable). Omit both for the default 24h crypto board. Same data as REST /proof and n0brains.com/proof. Measured, not advice.
[CONTEXT] Nearest historical market-state analogs to right now: k-NN over the cross-asset state (SPX/NDX momentum, VIX level + term structure, DXY, yield curve) with what SPX/NDX/BTC actually did over the following 1d/5d (median, quartiles, hit-rate) per analog and in aggregate. k = 3-25 (default 12), episode-separated. Same data as REST /analogs. Conditioning context, NOT a prediction.
[TIMING] Upcoming scheduled macro releases + earnings joined with each event's MEASURED historical reaction distribution (event-study library, grouped by surprise sign): 'CPI prints Thursday — the last N hot prints moved SPX/BTC X%'. history=null until a cell accrues (the library earns its conditionals, it never manufactures them). Same data as REST /event-outlook. Not a direction call.
[DRILL-DOWN — who is crowded] Positioning thesis for one coin: who is crowded and which way. Combines funding-rate crowding (30d z-score), taker CVD buy/sell dominance (2h + 24h), open-interest-vs-price divergence (new longs / short-covering / new shorts / capitulation), options put-call + skew + max-pain TREND (BTC/ETH/XRP/SOL), nearest liquidation magnets above/below with notional, and whale stance (fade-corrected) into a single net positioning bias in [-1,1] with plain-English reasoning per component, per-line data freshness, and a coverage grade (full/partial/thin — how many of the 8 legs actually contributed, so a thin-coverage score cannot read like a full one). Use INSTEAD of manually combining get_liquidation_map + get_options + funding. Mirrors REST /positioning/{coin}. Conditioning context, not financial advice.
[DRILL-DOWN] Long/short positioning for one coin from REAL data, mode picked by the asset's primary source: DEX price-point buckets (Hyperliquid+GMX, BTC/ETH-style), CFTC COT (metals/oil/indices), or exchange long/short ratios (alts). Returns latest buckets {price, long_usd, short_usd}, totals + long_pct + ls_ratio, the accumulated trend over `days` (1-90, default 7), and funding + OI-by-venue context. Complements get_positioning (the 8-leg synthesis) with the raw who-is-long-where view. Mirrors REST /charts/long-short/{coin}. Analytical, not advice.
[START HERE — 'vet my trade'] Ask n0brains First: graded pre-trade conditions assessment for a proposed trade. Give asset + side (long/short); optionally entry, stop, target, leverage, horizon_hours (default 24). Returns grade A..F with flags (positioning crowding, scheduled event risk inside the horizon, liquidation distance vs realized daily volatility, stop inside noise range, proven-edge conflicts, late entry), supporting factors, and falsifiers to watch. Grades are logged and resolved at horizon; cross-grade performance stays withheld until the deployed weekly truth gate clears. Pair with get_positioning (who is crowded) + get_event_outlook (scheduled risk inside the horizon) for the full vet. Analytical, not advice.
[RECEIPTS — your own] Your past check_trade assessments WITH resolved outcomes: each row is the trade as you submitted it, the grade it got, and (once the horizon passed) the side-adjusted result with stop-touch honored. This is your personal calibration on the CHECKS you asked for (the journal covers trades you actually took). Free tier also gets free_checks_remaining_today. Mirrors REST /checks/history (last 50). Analytical, not advice.
[META] The asset universe check_trade / get_trade_plan / get_levels can price: Hyperliquid perp coins + tokenized HIP-3 stocks/metals/indices. Call once instead of discovering support by error. Contract: count === len(assets); `degraded: true` means the list is INCOMPLETE/STALE — do not treat it as the universe, do not cache it, retry later; no `degraded` key means healthy. Mirrors REST /check/assets (shared cache).
[JOURNAL] Log a REAL trade entry into your private n0brains journal the moment it fills. Give asset + side (long/short); optionally entry (defaults to live price), stop, target, size_usd, leverage, thesis (why you took it). n0brains snapshots full entry conditions automatically (grade, flags, positioning, regime — an internal check_trade) so nothing needs hand-transcribing. HISTORICAL backfill: pass opened_at (epoch seconds of the real fill) + explicit entry; the entry grade is then taken from YOUR check_trade nearest the fill (±6h, same asset+side) — the read you actually got at the time, never re-graded on today's tape; no matched check = ungraded. Close with close_trade; read back with get_journal. Returns trade_id + the entry assessment. Journal is private to your account. Pro.
[JOURNAL] Close a journal trade by trade_id (from log_trade or get_journal). Optionally exit_price (defaults to live price) and note (exit reasoning). n0brains resolves the outcome from real candles over the held window: return %, R multiple vs your initial stop, MAE/MFE (worst drawdown / best unrealized gain while open), and whether your stop or target level actually traded. HISTORICAL backfill: pass closed_at (epoch seconds of the real exit) + explicit exit_price. Pro.
[JOURNAL] Amend an OPEN journal trade by trade_id: move your stop or target, fix size_usd / leverage / thesis. A stop MOVE changes only the current stop (what the watchdog and close-time touch scan use); realized R stays measured against your INITIAL stop, so trailing to breakeven can't inflate R. To fix a genuine fat-finger in the original entry or stop, also pass correct_entry=true — that resets the R basis (disclosed in the response). asset/side can't be amended — void and re-log for that. Pro.
[JOURNAL] Void a mis-logged journal trade by trade_id (wrong asset, duplicate, fat-finger) with an optional reason. Soft-delete: the trade is removed from your stats and the default journal view but retained and recoverable (get_journal status='void' lists voided trades). Voiding a CLOSED trade removes its outcome from your calibration — disclosed in the response. Use this for entries that never should have existed; use close_trade for real trades that ended. Pro.
[JOURNAL] Read your private trade journal. status=open|closed|void|all (default all shows open+closed; void is hidden unless asked), limit for history (default 20). Open trades include live unrealized PnL/R and a warning if your stop level has traded since entry. Closed trades include resolved outcomes (ret %, R, MAE/MFE). stats block = personal calibration: win rate and realized R per n0brains entry grade — where your entries were actually good. Pro.
[READ FIRST] The routing guide for every n0brains tool: which tool answers which intent (find a trade / vet a trade / coin snapshot / market brief / monitoring) and how to interpret the honesty fields (action_hint, historical_edge, n_eff, calibration). Call this once if you are unsure which tool to use — it replaces trial-and-error over the 40-tool catalog. Static text, no market data, free tier.
[START HERE — market overview] One-call morning brief: market regime (risk appetite), liquidity read, high-impact events next 72h, the engine's actionable reads (has_trade_signal + reads[]), and cross-asset trade-plan ranking — compact projections of get_market_regime / get_liquidity_map / get_economic_calendar / get_actionable_signals / rank_trades, assembled server-side. Optional coin arg scopes the actionable reads to that coin and adds it to the ranked set (ranking stays setup_score-sorted). Drill into any block with the underlying tool. Descriptive + engine verdicts; uncalibrated blocks labeled; not financial advice.
[FORENSICS] Trust / scam-risk screen for a token: resolves the ticker to a contract via DexScreener, then checks GoPlus Security for honeypot behavior, mint function, high taxes, and insider concentration. Run this BEFORE taking any alt-coin signal seriously — a bullish read on a honeypot is worthless. Mirrors REST /trust/{coin}. Analytical data only, not financial advice.
[FORENSICS] Manipulation-risk analysis for one asset: composite manipulation score, coordinated-pump probability, fake-engagement risk, liquidation-cascade detection. Richer than the per-signal manipulation_score field — this is the full standalone read. Mirrors REST /manipulation/{coin}. Analytical, not advice.
[FORENSICS] Narrative heatmap for one asset: signal momentum, velocity, decay, manipulation probability and directional conviction across 1h / 4h / 24h windows — is the story building or dying? Complements get_mindshare_coin (attention share) with time-structure. Mirrors REST /narrative/{coin}. Analytical, not advice.
n0brains is a hosted Model Context Protocol (MCP) server that provides audited crypto market intelligence for AI agents. It delivers conditions assessments of trade ideas using data not visible on price charts, graded A–F, with every verdict publicly logged and scored.
Nothing to install. Point your MCP client to https://api.n0brains.com/mcp/ with an API key sent via X-API-Key or Authorization: Bearer header. A free API key can be obtained at n0brains.com/signup. A quick smoke test is available via curl.
check_trade tool grades trade ideas A–F using six hidden data dimensionsThe server offers 33 tools including `check_trade`, `list_signals`, `get_signal`, `get_signals_since`, `get_levels`, `get_market_opens`, `get_performance`, `get_asset_class_proof`, `get_tier_performance`, `get_market_regime`, `get_macro`, `get_economic_calendar`, and `health`. The free tier exposes 13 of these.
No. The server is hosted remotely. You only need an MCP client capable of Streamable HTTP. Older clients can bridge via `mcp-remote`.
Free keys get 13 tools (including `check_trade` limited to 3/day), 15‑minute delayed signals, and a rate limit of 60 requests per minute. Pro tier removes those limits and adds real‑time signals.
No. Conditions assessments are analytical, not financial advice. n0brains publishes its full track record—wins, losses, and demoted signal types—at n0brains.com/proof. Past performance does not guarantee future results.
Every verdict from `check_trade` is logged when issued and resolved at its horizon against real prices. Grade calibration (whether A‑grades actually beat F‑grades) is publicly posted on /proof.
Open-source Node.js FHIR MCP server with SMART Backend Services, metadata-aware search/CRUD tools, compact responses, FHIRPath filtering, safe pagination, audit events, and terminology lookup.
The system of record for AI-written software. A persistent graph of entities, relationships, changes, and provenance, so humans and AI agents see what a change touches before it merges. Beside Git today.
Catch intent conflicts before code conflicts. The open-source coordination protocol for coding agents, built above Git.
The Datris Data Platform - Open Source Version
Let your agents read, send and react to email autonomously, without human involvement
コメント