mcp_tv — TradingView MCP with order execution

Fork of tradingview-mcp-jackson (itself built on tradingview-mcp). Czech guide: README_CZ.md. The upstream documentation follows after the mcp_tv sections.

Added in mcp_tv: order execution with money management

Orders go to the broker connected in TradingView's Trading Panel (Paper Trading by default — live accounts are refused unless you opt in). Each tool does the whole flow in one call: account check → money management → guards → send → verify → audit log.

Config — trading.json in the repo root (overridden by ~/.tradingview-mcp/trading.json):

{
  "risk_usdt": 100, "max_risk_usdt": 500, "rr": 2,
  "sl_atr_mult": 0.5, "atr_length": 14, "pivot_length": 3,
  "fee_rate": 0.0002, "slippage_rate": 0.0002, "allow_live": false,
  "leverage": { "enabled": true, "min": 10, "max": 50, "vol_mult": 3, "sl_mult": 2, "maintenance_margin": 0.005 },
  "t3": { "fast": 8, "slow": 21, "factor": 0.7 },
  "trailing": { "activate_r": 1, "t3_exit": true, "trail_atr_mult": 1.0, "min_gap_atr": 0.25, "min_step_atr": 0.1, "breakeven": true, "switch_chart": true, "bars_source": "bybit", "atr_timeframe": "5" },
  "auto": { "min_score": 65, "min_bias": 0.35, "bars": 400 }
}

Leverage — chosen per order from the last hour's range (Bybit 1m klines): the target keeps the isolated liquidation distance ≈ 1/L − maintenance beyond vol_mult×1h range and sl_mult×stop distance, clamped to 10–50×. The order is refused only if even the minimum leverage would liquidate closer than sl_mult×stop. Leverage never changes the risk (qty is sized from the stop), only margin and liquidation price. It is applied via setLeverage where the broker supports it; TradingView Paper Trading does not, so the account leverage stays in effect there.

Safety

• Non-demo accounts are refused unless "allow_live": true or TV_ALLOW_LIVE_TRADING=1.

• Risk above max_risk_usdt is refused; adding to an existing position requires allow_add.

• Every action is appended to ~/.tradingview-mcp/orders/YYYY-MM-DD.jsonl; the submit intent is logged before sending. Never retry a failed order_place without checking order_status.

• ATR and swings are computed from the chart's current timeframe. Positions on other symbols are read by briefly switching the chart (disable with switch_chart: false / --no-switch).

Windows Store build of TradingView — tv_launch does not find the Store (Appx) install. Use scripts/launch-tv-cdp.ps1: it locates the package via Get-AppxPackage, kills running instances (single-instance lock) and starts TradingView with --remote-debugging-port=9222.

autoorder is a rule-based playbook, not a guarantee of profitability — it has not been backtested; validate it with --dry-run / Paper Trading first.

Unit tests: node --test tests/trading.test.js tests/autotrade.test.js.

Related MCP server: TradingView MCP Jackson

Guide: using mcp_tv with an AI assistant (Claude Code)

🇨🇿 Czech version: README_CZ.md

The idea: TradingView Desktop runs on your PC, this MCP server talks to it over the Chrome DevTools Protocol (CDP), and the AI assistant (Claude Code, Claude Desktop or any MCP client) calls the server's tools. You talk to the AI in plain language ("autoorder BTC", "trail my positions", "what orders are open?") and it picks the tools.

1. Install

git clone https://github.com/mkajnar/mcp_tv.git
cd mcp_tv
npm install

Requirements: Node.js 18+, TradingView Desktop (a subscription with real-time data is recommended), Trading Panel connected to Paper Trading (default, safe).

2. Start TradingView with CDP (port 9222)

• Windows Store (Appx) build: powershell -ExecutionPolicy Bypass -File scripts/launch-tv-cdp.ps1

• Classic install / macOS / Linux: ask the AI to call tv_launch, or start TradingView with --remote-debugging-port=9222.

Check: http://localhost:9222/json/version must answer. In TradingView open a chart and connect the Trading Panel to Paper Trading.

3. Register the MCP server in your AI client

Claude Code — .mcp.json in your project (or claude mcp add):

{
  "mcpServers": {
    "tradingview": {
      "command": "node",
      "args": ["C:/path/to/mcp_tv/src/server.js"]
    }
  }
}

Claude Desktop — the same block in claude_desktop_config.json.

Restart the client (in Claude Code run /mcp → reconnect). Ask: "run tv_health_check" — it should report the connected chart.

Optional: pre-approve the trading tools in .claude/settings.local.json so the AI does not ask every time:

{ "permissions": { "allow": [
  "mcp__tradingview__order_place", "mcp__tradingview__order_status", "mcp__tradingview__order_cancel",
  "mcp__tradingview__position_close", "mcp__tradingview__position_set_brackets",
  "mcp__tradingview__positions_trail", "mcp__tradingview__autoorder"
] } }

4. Configure money management

Edit trading.json (repo root) or ~/.tradingview-mcp/trading.json (overrides). Key values:

5. Talk to the AI — example prompts

Tips:

• Use full tickers (BYBIT:BTCUSDT.P) — short names can resolve to another exchange.

• Tell the AI whether you want screenshots; autoorder accepts screenshot=false.

• autoorder skips a symbol that already has a position or a pending entry — cancel first if you want a new plan.

• While autoorder loops, don't click symbols in TradingView; the chart may jump to a symbol whose order just filled (autoorder retries 3× and then skips).

6. Run the trailing stop in the background

The AI only acts when you talk to it. To protect profit continuously, run the trail loop as a separate process:

node src/cli/index.js order trail --watch 5

Windows (hidden, with log):

Start-Process node -ArgumentList "src/cli/index.js","order","trail","--watch","5" -WorkingDirectory C:\path\to\mcp_tv -WindowStyle Hidden -RedirectStandardOutput "$HOME\.tradingview-mcp\trail.log" -RedirectStandardError "$HOME\.tradingview-mcp\trail.err.log"

It prints one JSON line per position per tick (skip / move / t3_exit). Restart it after changing the code or trading.json.

7. The same without the AI (CLI)

node src/cli/index.js order status
node src/cli/index.js order place sell --risk 100 --dry-run
node src/cli/index.js order auto BYBIT:BTCUSDT.P --no-screenshot [--dry-run]
node src/cli/index.js order trail --watch 5
node src/cli/index.js order cancel

8. How autoorder decides (short)

1. Top-down bias from 1D/1h/15m/5m/1m (weights .30/.30/.20/.15/.05); needs |bias| ≥ min_bias, 1h and 15m must agree.

2. T3 gate: 15m T3 FAST/SLOW must agree with the direction; a fresh 5m counter-cross = WAIT.

3. Order type: market (pullback into value + 1m or T3 trigger), limit (extended → EMA20 pullback), stop (5m compression breakout / above trigger bars).

4. Structural SL behind the 5m swing (± 0.5 ATR); refused if too wide (> 3 ATR 15m) or too tight (min_sl_pct, max_cost_share).

5. Needs ≥ rr·R room to the next 1h/15m/daily level and a confluence score ≥ min_score.

6. Sends via order_place (money management, leverage 10–50× from 1h volatility, verification, audit log).

Pine indicator with T3 (optional)

pine/milan_macd_rsi_swings.pine — "MKA Multi" (RSI, MACD, swings, T3 FAST/SLOW with T3 L / T3 S / exit signals and alerts, same T3 settings as autoorder). Load it via the AI: "open the Pine editor, set this source and compile" (pine_set_source, pine_smart_compile) or paste it into TradingView's Pine Editor.

Jev AI decisions (optional, on/off)

Jev AI (POST /v1/systemone, model typesafe/jev-1.13) can take over the decisions: which way and which order type to enter, and whether to hold, tighten or close an open position. The rules still compute stops, sizing, leverage and every guard.

• Setup: put JEV_API_KEY=... in .env in the repo root (gitignored; optional JEV_API_BASE_URL, JEV_MODEL, JEV_TIMEOUT, JEV_MAX_RETRIES). The key is never logged or returned.

• On/off: say "turn Jev on" (jev_toggle enabled=true), CLI tv order jev on|off|status, or trading.json → "jev": { "enabled": true }. Per call: autoorder jev=true|false, CLI --jev / --no-jev.

• Entries (autoorder): the state (per-timeframe indicators, T3, swings, last 20 OHLCV bars of 1D/1h/15m/5m/1m, quote and the rules' opinion) goes to Jev with two questions: action (choice: long/short × market/limit/stop, or wait) and setup_quality (score 1–5). A trade is placed only if action confidence ≥ jev.entry_threshold (0.6) and quality ≥ jev.min_quality (3). The entry price for the chosen type, the structural SL, the too-wide/too-tight guards and ≥ rr·R room are rule-based; then order_place (money management).

• Exits (trail loop): when jev.exits is on, every open position is asked exit_action (hold / tighten / close) at most once per jev.exit_interval_s (60 s). close needs confidence ≥ jev.exit_threshold (0.75); tighten moves the SL to at least break-even (never loosens). The ATR trail and T3 exit still run as the safety net.

• Failures: retries with backoff on 429/5xx/timeouts, a circuit breaker (3 failures → 10 min pause, immediately on 401/402). With jev.fallback: "rules" (default) autoorder then uses the rule playbook; "wait" skips the trade.

• Every Jev answer (action, confidence, probabilities, credits) is written to the audit log and returned under jev in the result. The full request (model, state, questions) and response of every call is logged to ~/.tradingview-mcp/jev/YYYY-MM-DD.jsonl (key scrubbed).

• jev.rules_hint (default false): when true, the rules engine's own decision is added to the state as a second opinion; off = Jev judges independently.

9. Logs and troubleshooting

• Audit log: ~/.tradingview-mcp/orders/YYYY-MM-DD.jsonl (decisions, intents, fills, trail moves).

• "CDP not reachable" → TradingView was not started with port 9222.

• New code not used by the AI → /mcp reconnect in Claude Code.

• "Chart did not switch" → the symbol does not exist on TradingView or the chart jumped; rerun it.

• Paper Trading ignores leverage changes via API; the computed leverage is reported only.

⚠️ This is a tool, not financial advice. The playbook is not backtested — use Paper Trading and dry_run first.

TradingView MCP Jackson (upstream documentation)

If you found this from the YouTube video — welcome. This is the improved fork. Everything you need is below.

Built on top of the original tradingview-mcp by @tradesdontlie. Full credit to them for the foundation. This fork adds a morning brief workflow, a rules config, and fixes the launch bug on TradingView Desktop v2.14+.

What's New in This Fork

One-Shot Setup

Paste this into Claude Code and it will handle everything:

Set up TradingView MCP Jackson for me. 
Clone https://github.com/LewisWJackson/tradingview-mcp-jackson.git to ~/tradingview-mcp-jackson, run npm install, then add it to my MCP config at ~/.claude/.mcp.json (merge with any existing servers, don't overwrite them). 
The config block is: { "mcpServers": { "tradingview": { "command": "node", "args": ["/Users/YOUR_USERNAME/tradingview-mcp-jackson/src/server.js"] } } } — replace YOUR_USERNAME with my actual username.
Then copy rules.example.json to rules.json and open it so I can fill in my trading rules.
Finally restart and verify with tv_health_check.

Or follow the manual steps below.

Prerequisites

• TradingView Desktop app (paid subscription required for real-time data)

• Node.js 18+

• Claude Code (for MCP tools) or any terminal (for CLI)

• macOS, Windows, or Linux

Quick Start

1. Clone and install

git clone https://github.com/LewisWJackson/tradingview-mcp-jackson.git ~/tradingview-mcp-jackson
cd ~/tradingview-mcp-jackson
npm install

2. Set up your rules

cp rules.example.json rules.json

Open rules.json and fill in:

• Your watchlist (symbols to scan each morning)

• Your bias criteria (what makes something bullish/bearish/neutral for you)

• Your risk rules (the rules you want Claude to check before every session)

3. Launch TradingView with CDP

TradingView must be running with the debug port enabled.

Mac:

./scripts/launch_tv_debug_mac.sh

Windows:

scripts\launch_tv_debug.bat

Linux:

./scripts/launch_tv_debug_linux.sh

Or use the MCP tool after setup: "Use tv_launch to start TradingView in debug mode"

4. Add to Claude Code

Add to ~/.claude/.mcp.json (merge with any existing servers):

{
  "mcpServers": {
    "tradingview": {
      "command": "node",
      "args": ["/Users/YOUR_USERNAME/tradingview-mcp-jackson/src/server.js"]
    }
  }
}

Replace YOUR_USERNAME with your actual username. On Mac: echo $USER to check.

5. Verify

Restart Claude Code, then ask: "Use tv_health_check to verify TradingView is connected"

6. Run your first morning brief

Ask Claude: "Run morning_brief and give me my session bias"

Or from the terminal:

npm link  # install tv CLI globally (one time)
tv brief

Morning Brief Workflow

This is the feature that turns this from a toolkit into a daily habit.

Before every session:

1. TradingView is open (launched with debug port)

2. Run: tv brief in your terminal (or ask Claude: "run morning_brief")

3. Claude scans every symbol in your watchlist, reads your indicator values, applies your rules.json criteria, and prints:

BTCUSD  | BIAS: Bearish  | KEY LEVEL: 94,200  | WATCH: RSI crossing 50 on 4H
ETHUSD  | BIAS: Neutral  | KEY LEVEL: 3,180   | WATCH: Ribbon direction on daily
SOLUSD  | BIAS: Bullish  | KEY LEVEL: 178.50  | WATCH: Hold above 20 EMA

Overall: Cautious session. BTC leading bearish, SOL the exception — watch for divergence.

4. Save it: "save this brief" (uses session_save)

5. Next morning, compare: "get yesterday's session" (uses session_get)

What This Tool Does

• Morning brief — scan watchlist, read indicators, apply your rules, print session bias

• Pine Script development — write, inject, compile, debug scripts with AI

• Chart navigation — change symbols, timeframes, zoom to dates, add/remove indicators

• Visual analysis — read indicator values, price levels, drawn levels from custom indicators

• Draw on charts — trend lines, horizontal levels, rectangles, text

• Manage alerts — create, list, delete price alerts

• Replay practice — step through historical bars, practice entries and exits with P&L tracking

• Screenshots — capture chart state

• Multi-pane layouts — 2x2, 3x1 grids with different symbols per pane

• Stream data — JSONL output from your live chart for monitoring scripts

• CLI access — every tool is also a tv command, pipe-friendly JSON output

How Claude Knows Which Tool to Use

Claude reads CLAUDE.md automatically when working in this project. It contains the full decision tree.

Tool Reference (81 MCP tools)

Morning Brief (new in this fork)

Chart Reading

Custom Indicator Data (Pine Drawings)

Read line.new(), label.new(), table.new(), box.new() output from any visible Pine indicator.

Always use study_filter to target a specific indicator: study_filter: "MyIndicator".

Chart Control

Pine Script Development

Replay Mode

Multi-Pane, Alerts, Drawings, UI

CLI Commands

tv brief                           # run morning brief
tv session get                     # get today's saved brief
tv session save --brief "..."      # save a brief

tv status                          # check connection
tv quote                           # current price
tv symbol BTCUSD                   # change symbol
tv ohlcv --summary                 # price summary
tv screenshot -r chart             # capture chart
tv pine compile                    # compile Pine Script
tv pane layout 2x2                 # 4-chart grid
tv stream quote | jq '.close'      # monitor price ticks

Full command list: tv --help

Troubleshooting

Architecture

Claude Code  ←→  MCP Server (stdio)  ←→  CDP (port 9222)  ←→  TradingView Desktop (Electron)

• 78 original tools + 3 morning brief tools = 81 MCP tools total

• Transport: MCP over stdio + CLI (tv command)

• Connection: Chrome DevTools Protocol on localhost:9222

• No external network calls — everything runs locally

• Zero extra dependencies beyond the original

Credits

This fork is built on tradingview-mcp by @tradesdontlie. The original tool is the foundation — go star their repo.

Disclaimer

This project is provided for personal, educational, and research purposes only.

This tool uses the Chrome DevTools Protocol (CDP), a standard debugging interface built into all Chromium-based applications. It does not reverse engineer any proprietary TradingView protocol, connect to TradingView's servers, or bypass any access controls. The debug port must be explicitly enabled by the user via a standard Chromium command-line flag.

By using this software you agree that:

1. You are solely responsible for ensuring your use complies with TradingView's Terms of Use and all applicable laws.

2. This tool accesses undocumented internal TradingView APIs that may change at any time.

3. This tool must not be used to redistribute, resell, or commercially exploit TradingView's market data.

4. The authors are not responsible for any account bans, suspensions, or other consequences.

Use at your own risk.

License

MIT — see LICENSE. Applies to source code only, not to TradingView's software, data, or trademarks.