@romaco/mcp
OfficialThis MCP server lets an AI agent fetch market data, run technical analysis, generate trade theses, and control a live romaco-charts chart.
Load OHLCV candles from Yahoo Finance or raw arrays, with caching and provenance.
One-command setup: load data, apply a preset, and run analysis.
Run headless analysis: market summary, trend, support/resistance, RSI/MACD, volatility, and patterns.
Generate actionable trade theses and ranked multi-symbol comparisons.
Find support/resistance via K-means and Volume Profile (POC/VAH/VAL).
Detect classical and harmonic chart patterns with targets/invalidations.
Calculate risk-based position size, R/R, and breakeven win rate.
Control a live chart: add/remove indicators, draw templates, add/remove/clear alerts, zoom, reset view, go to timestamp, list panes.
Capture chart snapshots as base64 images for vision models (gated).
Annotate theses or draw detected patterns on the chart after approval.
Open simulated paper positions with stop-loss/take-profit.
Read chart context, visible candles, and indicator values (compressed by default; raw gated).
List drawing templates and pane IDs.
Provides integration with Polygon.io as a data source for market data, offering access to stocks, options, forex, and cryptocurrency data (planned for v1.1).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@romaco/mcp analyze AAPL daily"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@romaco/mcp
MCP server for romaco-charts. Control your trading chart from Claude, Cursor, or any MCP-compatible AI agent.
npx @romaco/mcp
Philosophy
Romaco MCP is compression-first. Tools return features and decisions, not raw OHLCV. Most default tool payloads stay under 2 KB; romaco_analyze_market is the deliberate exception at 2.4–4.1 KB across the eight recorded 400-bar fixtures. Large payloads such as snapshots, visible-candle arrays, and all-bar indicator series are gated behind acknowledgeHighTokenCost: true. Full raw chart-state export is disabled until an explicitly authorized host contract exists.
The rule: code computes; the agent queries and interprets. RSI, levels, and last price come from structured tool output. This reduces unsupported numeric claims; it cannot prevent an agent from misquoting evidence or reaching a wrong thesis. Grounding data is not grounding the conclusion. Compression also preserves more context than returning a large raw OHLCV dump by default.
Cost table
Tool | Default | Gated raw (with |
| 2.4–4.1 KB on recorded 400-bar fixtures | — |
| <2 KB computed bull/bear debate + verdict + setup | — |
| <500 B | — |
| <2 KB (trimmed hits) | full hits with anchor |
| <5 KB (setup log + summary) | — |
| <200 B ack | — |
| <1 KB | — |
| ~4.5 KB static catalog | — |
| <1 KB | — |
| ~1 KB snapshot | disabled; returns |
| <1 KB range summary | ~70 KB raw OHLCV |
| <500 B last/prev/delta/state | ~10 KB per-bar series |
| error (must ack) | 300–800 KB base64 image |
| <2 KB structured preview/challenge or receipt | — |
Other | <1 KB structured result or ack | — |
Related MCP server: tradingview-mcp
30-second start
# 1. Install
npm install -g @romaco/mcp
# 2. Wire it into Claude Code (run from your project root)
cat > .mcp.json <<'EOF'
{ "mcpServers": { "romaco": { "command": "romaco-mcp" } } }
EOFThen start Claude Code and prompt:
Use
romaco_setup_chartto analyze AAPL daily with thetrend_analysispreset.
That's it. The MCP server fetches yfinance data (with disk cache + cookie/crumb handshake), runs full technical analysis, and returns a compressed MarketSummary. No API key required; the cache reduces repeated upstream requests, but Yahoo can still rate-limit traffic and the server reports that failure explicitly.
Live chart control (optional)
To let Claude drive a real chart — drawings, indicators, alerts visible in your browser — mount <McpBridge /> next to your TradingTerminal:
import { TradingTerminal, McpBridge, type TradingTerminalRef } from 'romaco-charts/react';
import { useRef } from 'react';
function App() {
const ref = useRef<TradingTerminalRef | null>(null);
const bridgeToken = getBridgeTokenFromRuntime();
return (
<>
<TradingTerminal ref={ref} data={candles} symbol="AAPL" />
<McpBridge chartRef={ref} security={{ mode: 'paired', token: bridgeToken }} />
</>
);
}See examples/pro-volatility-scanner for a complete setup. With <McpBridge /> mounted, the chart-bridge tools (add_indicator, add_drawing, add_alert, capture_snapshot, …) become available. Atomic thesis/pattern annotation additionally requires the host action documented in Chart bridge compatibility; older hosts fail closed instead of falling back to sequential drawing writes. romaco_annotate also uses a two-step, one-time confirmation challenge: its first call performs zero writes and returns APPROVAL_REQUIRED; retry only after the user approves the exact analysisId.
Data cache
Every successful yfinance fetch is cached to ~/.romaco/cache/ with per-timeframe TTL (1m→1min, 1h→1h, 1d→24h, …). A grid of N widgets requesting the same symbol triggers one upstream fetch. Wipe the cache anytime with rm -rf ~/.romaco/cache, or override the location with ROMACO_CACHE_DIR=/tmp/cache.
Dataset output separates fetchedAt (upstream fetch completion) from servedAt (this request) and cacheHit. TTL uses the original fetchedAt; old cache files without acquisition time are refetched. For raw input, fetchedAt means when MCP accepted the supplied candles, not when the external market published them. Legacy session snapshots may report servedAt/cacheHit as null.
Each dataset also carries provenance (version 1):
datasetHash:sha256:of the source, symbol, timeframe and OHLCV values. Identical data gives the same hash.asOf: the information cut-off (fetchedAt); nothing after it is in the dataset.lastBar: the last bar's open time (observedAt), the latest time it can close (availableAt, bar open plus one interval), andcomplete: falsewhen that time is afterasOf, meaning the bar may still be forming.coverage: bar count, first and last bar open times, and bars with zero volume (Yahoo reports missing volume as zero).priceAdjustmentissplitsforyfinance(Yahoo chart prices are split-adjusted, not dividend-adjusted) andunknownforraw.vintageisnull: neither source publishes data vintages, so later revisions cannot be identified.
romaco_thesis, romaco_thesis_batch and romaco_detect_patterns return dataProvenance (datasetHash, asOf) for the exact dataset each result was computed from. All *At provenance times are milliseconds since epoch, UTC.
Missing data is reported, not filled in
No volume: POC, VAH and VAL are
nullwithvolume_status: "insufficient"when fewer than half of the candles report a positive volume. Yahoo reports missing volume as 0, so FX pairs and some indices land here. Support and resistance still come from price.Too few candles: RSI needs 15 candles, ATR 15, Bollinger Bands 20 and MACD 38. Below that, the readings are
nulland their state isinsufficient_data, instead of RSI 50 or ATR 0.Thesis:
romaco_thesisstands aside below 38 candles, with a note that says why. It never uses a missing POC as a bullish or bearish factor, or as a stop or target.Visible candles:
romaco_get_visible_candlesreportsvolume: nullwhen no visible candle has volume.avgis taken over the candles that report volume (bars_with_volume).
What it does
Exposes 20+ MCP tools in two categories:
Headless tools — work without a browser, load data and run analysis server-side:
romaco_setup_chart— one-command setup: load + preset + analyze (recommended first call)romaco_load_candles— fetch OHLCV from Yahoo Finance (free) or pass your own arrayromaco_analyze_market— full technical analysis: trend, S/R levels, RSI/MACD/divergences, volatility, patternsromaco_thesis— computed bull/bear debate → verdict (long/short/stand_aside) + uncalibrated evidence score + entry/stop/target setup; stands aside when R/R fails its geometry thresholdromaco_thesis_batch— multi-symbol heuristic ranking;score = R/R × confidencefor valid setups (otherwise zero), neither win probability nor expected returnromaco_find_levels— support/resistance via K-means + Volume Profile (POC/VAH/VAL)romaco_detect_patterns— H&S, double top/bottom, triangles, flagsromaco_calculate_position_size— pure-math risk-based position sizing with R/R + breakeven win-rateromaco_list_templates— catalog of drawing templates (trendline, fib, channels, …)
Chart-bridge tools — control a live Romaco chart in the browser:
romaco_add_indicator— EMA, RSI, MACD, Bollinger, ATR, 29+ indicatorsromaco_add_drawing— agent-owned trendlines, Fibonacci, lines, channels, rectangles; omitted group defaults toromaco-mcp/manualromaco_add_alert— price alerts with direction (above/below/cross)romaco_clear_alerts— preview, approve, then remove exact alert IDs from one chart; never sends global clearromaco_capture_snapshot— PNG/JPEG base64 for vision LLMsromaco_open_paper_position— approval-gated simulated long/short with SL/TP and deterministic process-local idempotencyromaco_get_chart_context— concise live chart state; raw chart export is disabledromaco_get_visible_candles— OHLCV in current viewportromaco_set_zoom/romaco_reset_view— zoom controlromaco_clear_drawings— preview, approve, then remove onlyromaco-mcp/*groups; user drawings stay intactromaco_list_panes— enumerate main + subpanel panes (e.g. RSI subpanel id)romaco_get_indicator_values— read computed indicator series (by id or name)romaco_go_to_timestamp— scrub viewport to a given timestampromaco_annotate— atomically draw one exact thesis after a scoped, one-time confirmation challenge
Install
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"romaco": {
"command": "npx",
"args": ["-y", "@romaco/mcp"]
}
}
}Restart Claude Desktop.
Claude Code
claude mcp add romaco -- npx -y @romaco/mcpOr add to your project's .mcp.json:
{
"mcpServers": {
"romaco": {
"command": "npx",
"args": ["-y", "@romaco/mcp"]
}
}
}Cursor / other MCP clients
Any client that supports stdio MCP servers works. Point it at npx @romaco/mcp.
Usage
Headless analysis (no browser needed)
Load 500 candles of AAPL 1h from yfinance, then analyze the market.Claude will call:
romaco_load_candles→ fetches from Yahoo Financeromaco_analyze_market→ returns a compressed MarketSummary (2.4–4.1 KB on the recorded 400-bar fixture suite)romaco_find_levels→ S/R zones, POC, VAH, VALReasons over the features → tells you what it sees
Live chart control (with browser)
Add <McpBridge /> to your chart app:
import { TradingTerminal, McpBridge } from 'romaco-charts/react';
function App() {
const ref = useRef(null);
const bridgeToken = getBridgeTokenFromRuntime();
return (
<>
<TradingTerminal ref={ref} symbol="AAPL" timeframe="1h" datafeed={myDatafeed} />
<McpBridge chartRef={ref} security={{ mode: 'paired', token: bridgeToken }} />
</>
);
}Then from Claude:
Add EMA 20 and RSI 14 to the chart, draw a Fibonacci from the last swing low to swing high,
and capture a snapshot so I can see it.romaco_annotate, romaco_clear_drawings, romaco_clear_alerts, and
romaco_open_paper_position use two-step confirmation. First call returns a
scoped token and performs zero chart writes. MCP rejects missing, expired,
wrong-scope, and replayed tokens. Agent/client must send token only after
explicit user approval. Token proves completion of protocol; by itself it
cannot cryptographically prove human intent and never bypasses chart host's
actionPolicy.
Drawing clear scope binds exact chart identity plus current Romaco-managed group
plan. It never sends global clearDrawings; each reserved romaco-mcp/* group
is replaced with empty desired state, leaving user and unrelated groups intact.
Alert clear scope binds exact chart identity plus current stable alert IDs. It
never sends global clearAlerts; each approved alert is removed by ID with host
identity policy. Alert-plan drift consumes the token and performs zero writes.
Paper positions are visual simulation only: no broker, real order, or money.
Caller supplies stable idempotencyKey. Same completed key/payload returns same
stored receipt without another chart write; changed payload gets
IDEMPOTENCY_CONFLICT. Ambiguous bridge failure marks key indeterminate and
blocks automatic retry until user inspects chart state, reconciles outcome, and
uses a new key with fresh approval. Journal is memory-only for MCP process;
restart/crash does not provide durable exactly-once execution.
Evaluation status
npm run eval:offline validates 28 declared scenarios and currently executes 24
deterministic MCP conformance workflows; 4 remain explicitly planned. Reported
success rate uses executed runnable workflows as denominator and always reports
planned work plus concrete blockers separately. Runnable failures or missing runnable workflow/grader
implementations exit non-zero. Numeric agent-final-answer grading remains planned;
current evidence-conformance checks structured tool evidence, not model prose.
Data sources
Source | Auth | Coverage |
| None (default) | Stocks, ETFs, crypto, FX, indices — delayed data |
| None | Pass your own OHLCV array inline |
Bring your own key (BYOK) — Coming in v1.1: Alpaca, Polygon.io, FMP.
Configuration
Option | Default | How to set |
WebSocket port |
|
|
|
|
|
| (none) | Canonical base64url encoding of exactly 32 random bytes |
| (empty) | Reserved. Does not authorize or trigger candle egress today. |
| (unused) | Reserved for a future explicitly authorized remote-adapter contract. |
| (localhost + | Comma-separated exact HTTP(S) origins for |
| (off) | Set exactly |
Bridge security: paired v2 mutually authenticates server and browser with
HMAC-SHA-256 before chart traffic. Token never crosses WebSocket. Generate one
once, configure MCP process, inject same value into <McpBridge /> at runtime:
node -e "console.log(require('node:crypto').randomBytes(32).toString('base64url'))"
ROMACO_MCP_BRIDGE_AUTH=required \
ROMACO_MCP_BRIDGE_TOKEN="<generated-token>" \
ROMACO_MCP_ALLOWED_ORIGINS="https://myapp.com" \
npx @romaco/mcpNever put token in source, public bundle, URL, logs, or browser storage. Use
in-memory input for current page lifetime. auto selects paired v2 with valid
token; no token keeps legacy v1 with warning. Malformed configured token
disables only chart bridge. required never falls back to v1.
Legacy compatibility is unauthenticated and is not secure by default. Production
deployments should use required plus paired McpBridge; enable legacy only as
an explicit migration step.
Listener binds 127.0.0.1; exact origins add defense in depth. In paired mode,
localhost pages still need pairing token. Browser-to-server frames above 8 MiB
are rejected before JSON parsing, leaving more than 10x headroom over typical
documented chart snapshots. Frames are not encrypted. Never expose listener
remotely; use authenticated TLS gateway for non-loopback deployments.
# Custom port
npx @romaco/mcp --port 3200
# Or via env
ROMACO_MCP_PORT=3200 npx @romaco/mcpSet the same port in <McpBridge port={3200} />.
Local execution and remote egress
Current tools compute analysis locally in src/compression. Setting
ROMACO_TOKEN or ROMACO_API_URL does not authorize transmission of candles
to a remote analysis service. When a token is present, romaco_thesis returns a
structured REMOTE_EGRESS_DISABLED warning and uses the local artifact unless an
already validated gateway artifact was injected through an authorized host path.
A future remote adapter must add explicit authorization, validated boundary schemas, transport security, trace propagation, and user-facing egress docs before it can become callable. No automatic network fallback exists today.
Example prompts
Institutional analysis:
"Load TSLA 4h from yfinance, analyze the market, find key levels, detect any chart patterns, then draw the Fibonacci retracement of the last swing on the chart and add an alert at the 0.618 level."
Conditional automation:
"Load AAPL 15m, run full analysis. If RSI shows bullish divergence and price is near a support level, open a paper long 100 shares with stop loss at the VAL of the Volume Profile."
Pattern scanner:
"Load SPY 1d and detect patterns. For any head & shoulders found, tell me the target price and invalidation level."
Requirements
Node.js >= 20
For chart-bridge tools: romaco-charts >= 1.0.3 with
<McpBridge />in your app. Older versions do not report the chart timeframe, so MCP refuses every chart write against them.
Links
Available Tools
27 toolsromaco_add_alertB
Add a price alert on the chart. Triggered alerts are shown visually. Use romaco_get_chart_context to see existing alerts.
Inputs: price (required), note, direction.
romaco_add_drawingA
Draw a technical-analysis shape on the chart. Romaco-charts ships 33 templates: trendline, horizontalLine, horizontalRay, verticalLine, verticalSegment, verticalRay, parallelChannel, rectangle, brush, path, fibRetracement, fibExtension, fibCircle, fibSpiral, fibFan, longPosition, shortPosition, dateRange, ruler, volumeProfile, text, elliottWave, elliottWave3, elliottWave8, elliottWaveAny, circle, triangle, arrow, parallelogram, abcd, xabcd, gannBox, priceAlert. Required point counts vary per template (use romaco_list_templates to discover them). style, paneId, and groupId are optional. Use romaco_get_visible_candles to fetch real timestamps and prices for the anchor points. To draw inside an indicator subpanel (e.g. a horizontal line at RSI=70 inside the RSI pane), pass paneId from romaco_list_panes.
Inputs: points (required), drawingType (required), label, style, +2 more.
romaco_add_indicatorA
Add a technical indicator to the chart. Examples: EMA with period 20, RSI with period 14, MACD with params [12, 26, 9], BOLL (Bollinger Bands) with period 20. Params are positional numbers specific to each indicator type.
Inputs: indicatorType (required), params.
romaco_analyze_marketA
Run full technical analysis on the currently loaded candle data and return a compressed MarketSummary. Includes trend (direction + strength), piecewise linear price action, support/resistance levels (clustering), momentum (RSI, MACD, divergences), volatility (ATR, Bollinger Bands), and detected patterns (H&S, double top/bottom, triangles, flags). Call romaco_load_candles first. Returns ~500 tokens of structured features instead of raw OHLCV. With a ROMACO_TOKEN (Pro), this is computed server-side when available, with automatic fallback to local compute.
Inputs: no named parameters.
romaco_annotateA
Annotate the latest locally-computed trade thesis on the user's browser chart with VISUAL HIERARCHY: support/resistance and the detected pattern are drawn FAINT (gray, dashed/dotted, low opacity) as context; the entry zone is a soft band; entry/stop/target are the BOLD action (longPosition/shortPosition with built-in reward/risk). Honest guard: if the verdict is stand_aside it draws ONLY context and never invents an entry/stop/target. Re-running replaces the previous annotation (group 'romaco-thesis') and leaves the user's own drawings untouched. Call this ONLY after the user accepts the offer to draw. Requires mounted and candles loaded (romaco_setup_chart or romaco_load_candles).
Inputs: no named parameters.
romaco_calculate_position_sizeA
Calculate position size based on account risk management rules. Given account size, risk percentage, entry price, and stop loss — returns exact shares/contracts to trade, total risk in dollars, position value, and risk/reward ratio if target is provided. Pure math — no data source or browser needed.
Inputs: riskPct (required), stopLoss (required), entryPrice (required), accountSize (required), +2 more.
romaco_capture_snapshotA
Capture the current chart as a base64 image for vision-enabled models. Cost: 300–800 KB per image (PNG, lossless) or 100–300 KB (JPEG). Gated. Set acknowledgeHighTokenCost:true to receive the image. Without it the tool returns an error explaining the cost. Only opt in when the USER explicitly asked for a visual snapshot — e.g. to share, to confirm placement, or to feed a vision LLM.
Inputs: format, acknowledgeHighTokenCost.
romaco_clear_alertsA
Remove all price alerts from the chart.
Inputs: no named parameters.
romaco_clear_drawingsA
Remove all drawings from the chart (trendlines, Fibonacci retracements, horizontal lines, rectangles, channels, annotations). Cannot be undone.
Inputs: no named parameters.
romaco_detect_patternsA
Scan the currently loaded candle data for classical chart patterns: Head & Shoulders (and inverse), Double/Triple Top/Bottom (M/W — ATR-gated alignment + depth, no range-chop false positives), Ascending/Descending/Symmetric Triangles, Bull/Bear Flags, Parallel Channels (up/down/flat — strict gates: parallel fit, 5+ touches, close containment), Rising/Falling Wedges, Cup & Handle, Rounding Bottom (parabolic basin, no handle required), unfilled momentum Gaps (≥0.5×ATR, gap_up/gap_down), and Fibonacci harmonics: ABCD, Gartley, Bat, Butterfly, Crab (strict ratio gates ±0.05 — the math fits or no pattern is reported). Each hit returns kind, confidence (0..1), target_price, invalidation_price, and anchor_count. Zombie patterns are discarded: if any candle after a pattern completed already breached its invalidation level or tagged its target, the setup is consumed and never reported — even when the current price drifted back into the live band. Cost: compressed by default (<2 KB). Set acknowledgeHighTokenCost:true to receive the full anchor points[] for each hit (≈3× larger). Call romaco_load_candles first. To draw a detected pattern on the chart, offer romaco_draw_pattern.
Inputs: acknowledgeHighTokenCost.
romaco_draw_patternA
Draw the GEOMETRY of a detected chart pattern on the user's browser chart: head & shoulders neckline + silhouette, double top/bottom extremes + trigger line, triangle border trendlines, flag polyline — plus faint dotted target/invalidation levels when the pattern projects them. Patterns are re-detected from the loaded candles (deterministic math, never agent-supplied geometry) and only RECENT patterns qualify — if none match, nothing is drawn and that is the honest answer. Each pattern family owns one drawing group, so re-drawing a family replaces it atomically and the user's own drawings are never touched. Offer this after romaco_detect_patterns or romaco_thesis finds something; call it ONLY after the user accepts. Requires mounted and candles loaded (romaco_load_candles), with the SAME symbol/range on the chart.
Inputs: kind, rank.
romaco_find_levelsA
Find key support and resistance price levels for the currently loaded candle data using 1D K-means clustering on swing extremes, plus Volume Profile (POC, VAH, VAL). Returns up to 3 support levels (below current price) and 3 resistance levels (above), each with touch count, strength (0..1, touch-count × recency), and last-test timestamp. Call romaco_load_candles first.
Inputs: no named parameters.
romaco_get_chart_contextA
Get a compressed snapshot of the romaco chart state: last price, pane list, indicator/drawing/alert counts, visible range, zoom, render backend. Cost: compressed by default (~1 KB). Set acknowledgeHighTokenCost:true to receive the raw chart context (≈80 KB including all visible candles, every drawing with its points, full indicator params, and capability registries). Only opt in to the raw payload when the user has explicitly asked for it.
Inputs: acknowledgeHighTokenCost.
romaco_get_indicator_valuesA
Read the current state of an indicator on the chart: last value, previous value, delta, and a per-indicator state classification (RSI: oversold/neutral/overbought; MACD: bull_cross/bear_cross/bullish/bearish; BOLL: squeeze/expansion/neutral; default: rising/falling/flat). Cost: compressed by default (<500 B). Set acknowledgeHighTokenCost:true to receive every bar of every series (~10 KB at 500 candles, scales linearly). Only opt in to raw series when the user explicitly asked for bar-by-bar values (e.g. for custom backtesting).
Inputs: indicatorId, indicatorName, acknowledgeHighTokenCost.
romaco_get_visible_candlesA
Summarize the OHLCV candles currently visible in the chart viewport: count, first/last candle, OHLC range, volume stats, percent change, ATR approximation. Cost: compressed by default (<1 KB). Set acknowledgeHighTokenCost:true to receive the raw OHLCV array (≈70 KB for a 360-candle viewport). Only opt in to the raw array when the user explicitly asked for raw candles (e.g. for custom indicator math). For analysis, prefer romaco_analyze_market.
Inputs: acknowledgeHighTokenCost.
romaco_go_to_timestampA
Move the chart viewport (or replay cursor if in replay mode) to a specific timestamp. Use this to revisit historical setups or scrub through past patterns. Timestamp is in milliseconds.
Inputs: timestamp (required).
romaco_list_panesA
List the chart panes: the main candlestick pane plus every indicator subpanel. Each pane returns its id, the indicators it hosts, and a short alias (e.g. "rsi"). Use the id as paneId on romaco_add_drawing to anchor a drawing inside that pane.
Inputs: no named parameters.
romaco_list_templatesA
List every drawing template available in romaco-charts, with category and required point count. Use this BEFORE romaco_add_drawing to choose a valid drawingType and know how many anchor points it expects.
Inputs: no named parameters.
romaco_load_candlesA
Load OHLCV candle data from a data source. Once loaded, the data persists in the MCP session and is used by all subsequent analysis tools (analyze_market, find_levels, detect_patterns). Default source is "yfinance" (free, no auth). Use "raw" to pass your own candle array.
Inputs: source (required), symbol (required), timeframe (required), lookback, +1 more.
romaco_open_paper_positionA
Open a simulated (paper) trading position at the current market price. No real money involved. Positions are shown visually on the chart as entry markers.
Inputs: side (required), quantity (required), stopLoss, takeProfit.
romaco_remove_alertA
Remove a specific price alert from the chart. Use romaco_get_chart_context to see existing alerts and their price/direction.
Inputs: price (required), direction.
romaco_remove_indicatorA
Remove a technical indicator from the chart by type. Use romaco_get_chart_context to see active indicators.
Inputs: indicatorType (required).
romaco_reset_viewA
Reset the chart view to auto-fit all available data. Use after zooming or panning to return to the default overview.
Inputs: no named parameters.
romaco_setup_chartA
One-command chart setup: loads OHLCV data, runs full market analysis, and (if browser is connected) applies a professional indicator preset to the chart. Available presets: trend_analysis, scalping, swing_trading, institutional, momentum, clean. Works headless too — returns MarketSummary even without a connected browser. This is the recommended first tool to call for any analysis session.
Inputs: symbol (required), preset, source, lookback, +2 more.
romaco_set_zoomA
Zoom the chart in or out. Each call zooms by the given factor (default 1.5x). Call multiple times for more zoom. Use romaco_reset_view to return to default fit.
Inputs: direction (required), factor.
romaco_thesisA
Produce an actionable trade thesis for the currently loaded candles: a computed bull/bear debate (every point derived from real features, not guessed), a verdict (long / short / stand_aside) with confidence, and a concrete setup (entry, stop, target, reward/risk) plus invalidation. Stands aside when there is no clean setup at acceptable R/R — it will not manufacture a signal. Call romaco_load_candles or romaco_setup_chart first. Returns <2 KB. With a ROMACO_TOKEN (Pro), an enhanced server-side thesis is used when available, with automatic fallback to the local synthesis. After stating the verdict, OFFER to draw it on the user's chart and ASK first (e.g. "Want me to draw this setup on your chart so you can judge it yourself?") — do not call romaco_annotate automatically. Always end your response with: "⚠️ Not investment advice — educational purposes only."
Inputs: no named parameters.
romaco_thesis_batchA
Analyze multiple tickers in one call, compare their trade setups, and return a ranked table sorted by R/R × confidence (best setup first). Fetches OHLCV data for each symbol via yfinance (free), runs a deterministic bull/bear thesis (no LLM, no hallucination) for each, then ranks them. After returning the table, OFFER to draw the top-ranked setup on the user's chart: "Draw the [SYMBOL] setup on your chart? (Recommended)" — if the user accepts, call romaco_setup_chart then romaco_annotate. The top-ranked symbol is automatically loaded into session so romaco_annotate runs immediately. Always end your response with: "⚠️ Not investment advice — educational purposes only."
Inputs: symbols (required), lookback, timeframe.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 27 tools
Each tool has a clearly distinct purpose: data loading, analysis, pattern detection, drawing, annotations, indicator management, alerts, paper trading, etc. There is no ambiguity between tools.
All tools follow the 'romaco_' prefix with a verb_noun pattern (e.g., add_alert, load_candles, detect_patterns), making the naming highly predictable and consistent.
27 tools is slightly above the typical well-scoped range (3-15) but justified by the complexity of trading analysis and charting. Each tool earns its place, though the count is heavy.
The tool surface covers the full lifecycle of chart analysis: data loading, market analysis, pattern detection, indicator management, drawing, alerts, paper trading, and thesis generation. No obvious gaps for the stated purpose.
Maintenance
Related MCP Connectors
Trading MCP server for AI agents, with live market data, account reads and controlled execution.
MCP server for OpenMM — exposes market data, account, trading, and strategy tools to AI agents
Official Intrinio MCP server. US stock prices, options and fundamentals for AI agents.
MCP server exposing the Backtest360 engine API as tools for AI agents.
Related MCP Servers
- AlicenseBqualityAmaintenanceMCP server that lets AI agents directly control and interact with the TradingView desktop app via 88 chart-control tools, enabling automated chart reading, Pine Script compilation, strategy optimization, and replay control.11344 npm61MIT
- AlicenseAqualityDmaintenanceA type-safe MCP server that enables AI agents to control TradingView Desktop via Chrome DevTools Protocol, allowing chart state reading, symbol/timeframe changes, and OHLCV data fetching.111MIT
- AlicenseAqualityBmaintenanceMCP server for the FLOX trading framework. About 30 tools to run backtests, scaffold strategies, validate for lookahead bias, compute indicators, place orders, and query PnL from Claude/Cursor.38945 PyPI231MIT
- AlicenseAqualityDmaintenanceAn MCP server that lets Claude analyze your TradingView charts by reading the window and taking screenshots, with no write tools or trade execution.51MIT