MCP — AI assistant for your chart

Connect an AI assistant (Claude, or any program that speaks MCP or plain HTTP) to the chart you have open in Openview. It becomes a trading co-pilot. It reads your chart, analyses it across timeframes, finds setups, tests an idea on past data, sizes a trade, draws the plan on your chart, suggests alerts, reviews your journal, and can send a push to your phone when it finds something worth your attention.

You stay in control. The assistant cannot place a trade, and it cannot create an alert unless you give it an API key with the Alerts permission. It runs on your own computer, it talks only to the chart page you opened, and the two sensitive functions — your account data and phone alerts — stay off until you switch them on.

An honest note. No tool here can find a trade that is sure to win. The assistant gives you speed and discipline: the levels, the size, the past results with the losses included, and what would prove an idea wrong. The decision is yours.

What it can do

There are 35 tools. You do not call them yourself: you ask a question in plain words and the assistant picks the tools. Each row below shows one question you can ask.

Read your chart

The AI sees the same data you see. It reads; it changes nothing.

Tool	What it does	Ask, for example
`get_chart`	The chart you have open: symbol, timeframe, chart type, number of bars, the last bar and the visible date range.	“What am I looking at?”
`get_bars`	Price candles (open, high, low, close, volume) for any symbol and timeframe, up to 1500 bars. With no symbol it reads the open chart.	“Get the last 200 daily candles of ETH and tell me the biggest drop.”
`get_indicators`	Your moving averages with their current values, the RSI, and every indicator you added to the chart.	“Is price above or below my 200-day average?”
`get_technicals`	The Technicals verdict (Strong Buy … Strong Sell) with the score, the buy / sell / neutral counts and every single check. The numbers are the same as the Technicals panel.	“What does the Technicals panel say on the 4h?”
`get_screenshot`	A picture of the main chart, so the AI sees your drawings, candles and indicators the way you do.	“Look at my chart. Is my trend line drawn correctly?”
`list_drawings`	Every drawing on the chart, with a mark on the ones the AI added.	“Which lines on this chart are yours?”
`get_alerts`	The price alerts on the open symbol. Read-only.	“Which alerts do I have on BTC?”

Analyse

Work that takes you many clicks, done in one question.

Tool	What it does	Ask, for example
`get_technicals_mtf`	The Technicals verdict on several timeframes at once (default 15m, 1h, 4h, 1d, 1w; at most 6) and one line that says if they agree: “all bullish”, “mixed”, and so on. A timeframe that fails is listed, not hidden.	“Do the timeframes agree on SOL?”
`get_levels`	Support and resistance found from real turning points in the price. Each level has a touch count, and you get the nearest support, the nearest resistance, and the high and low of the previous period.	“Where are the key levels? Draw them.”
`get_derivatives`	For major exchange perpetuals: funding rate, time of the next funding, open interest and its 24-hour change. For a spot symbol it says so. There is no liquidation data.	“Is funding on BTC perp stretched?”
`backtest_rule`	Tests a simple rule on past bars and reports the honest result: number of trades, win rate, average win and loss, expectancy, profit factor, largest drawdown, and buy-and-hold for comparison. It warns you when the sample is too small. Trades fill at the next bar’s open, so the test cannot see the future.	“How did “buy when RSI crosses up through 30, sell at +6 % or −3 %” do on ETH 4h?”

Find setups

Let the AI look through the market for you.

Tool	What it does	Ask, for example
`get_watchlist`	Your watchlist: the active list, its groups, and one flat list of symbols.	“What is on my watchlist?”
`scan_watchlist`	Runs the Technicals verdict on up to 30 symbols and ranks them, strongest first. It scans your watchlist (or the symbols you name). It is not a scan of the whole market.	“Scan my watchlist on the 1d. Which three look strongest?”
`get_breakouts`	The Openview breakout report: ranked setups across crypto and stocks, each with a score and the reasons. You can filter by asset class and minimum score. The first call can take 20–30 seconds; after that it is kept for 5 minutes.	“Show me the 10 best breakout setups in crypto.”
`get_news`	The Openview news wall, newest and most important first (up to 50). It says when the feed is stale or partial.	“Any news today that could move Bitcoin?”
`get_events`	The economic calendar (up to 100 rows): what is due, when, how important, and whether the figure has arrived.	“Is there a high-impact event in the next 2 hours?”

Plan a trade

From an idea to numbers you can act on.

Tool	What it does	Ask, for example
`plan_trade`	You give entry, stop and target (or a reward-to-risk ratio), your account size and the percent you want to risk. You get the position size, the risk and reward in dollars, the reward-to-risk ratio and the win rate the plan needs to break even. With draw:true it puts a long / short position box on your chart. It is arithmetic only: it works with no chart open, and it refuses a plan that contradicts itself (for example a long with the target below the entry).	“Long BTC at 60,000, stop 58,500, target 64,000. I risk 1 % of $10,000. What size?”
`set_chart`	Changes the symbol and / or the timeframe of your open chart, so the AI can show you what it found. It does not work in grid mode or in replay. It changes nothing else.	“Open SOL on the 4h.”

Draw on the chart

Everything the AI draws has a tag, shows in the object tree, and Ctrl+Z removes it.

Tool	What it does	Ask, for example
`add_drawings`	Adds up to 40 drawings in one call (400 in total): horizontal lines, trend lines, rays, rectangles, Fibonacci retracement / extension / fan / time zones, channels, pitchforks, long and short position boxes, text, callouts, price labels, flags and more. Each can have a colour, a width, a dash style and a name.	“Draw the Fibonacci retracement of the last big swing.”
`remove_drawings`	Removes drawings the AI added — by id, or all of them. It cannot remove a drawing you made.	“Clear everything you drew.”
`add_indicators`	Adds up to 6 indicators in one call (10 in total) from the Indicators menu — for example EMA 200, RSI, Bollinger Bands or MACD — with your settings if you give them. They stay after a reload. It does not add Pine scripts, and it does not add the same indicator twice.	“Add the 50 and 200 EMA and RSI to my chart.”
`remove_indicators`	Removes indicators the AI added — by id, or all of them. It cannot remove an indicator you added.	“Remove the indicators you added.”

Suggest alerts (you approve)

The AI cannot create an alert. It can only suggest one, and you decide.

Tool	What it does	Ask, for example
`propose_alerts`	Suggests up to 10 price alerts on the open symbol (20 can wait at one time). They appear in the Alerts panel under “SUGGESTED BY AI”. Review opens the normal alert window, already filled in; the alert exists only after you press Create. Dismiss removes the suggestion. Suggestions stay on this device.	“Suggest alerts at my entry and my stop.”
`list_alert_proposals`	The suggestions that still wait for your answer.	“Which alert suggestions are still open?”

Your account (off until you switch it on)

Open Help (?) on the chart → AI assistant → “Let the AI read my portfolio and journal”. Until then both tools answer “off” and send no data.

Tool	What it does	Ask, for example
`get_portfolio`	The holdings of your active Wallet portfolio: symbol, amount, average buy price and cost basis, plus the total value the Wallet screen last saved (marked “not a live price”). A holding with no buy price is named, not counted as zero.	“How much of my portfolio is in one coin? Is that too much?”
`get_journal`	Statistics from your trade journal, closed trades only: win rate, net profit, expectancy per trade, profit factor, largest loss, longest losing streak, and the result by setup, symbol, side and weekday. The numbers match the Journal screen. It is read-only: the AI cannot add, change or delete a trade.	“Review my journal. Which setup loses me money?”

Your saved alerts and drawings (needs an API key)

Signed in, open Settings → API keys and create a key. You choose what it may do: Read, Draw and / or Alerts. These tools work with no chart open. Revoke the key in Settings and they stop at once.

Tool	What it does	Ask, for example
`account_whoami`	Checks the key: its name and what it may do.	“Does my Openview key work?”
`account_alerts`	The price alerts saved in your account, on every symbol or one. Alerts the AI made are marked.	“Which alerts do I have, on all my symbols?”
`account_drawings`	The symbols that have drawings, or the drawings on one symbol. Drawings the AI made are marked.	“What did I draw on ETH?”
`account_watchlists`	Your saved watchlists.	“What is on my watchlists?”
`account_add_alerts`	Creates real price alerts in your account (at most 10 at a time, 50 in total). They ring like your own alerts. Only with the Alerts permission.	“Set an alert on BTC at 70,000.”
`account_remove_alerts`	Removes alerts the AI made — by id, or all of them. It cannot remove an alert you made.	“Remove the alerts you made.”
`account_add_drawings`	Saves drawings to one symbol in your account. Your chart shows them when you go back to the tab or reload. Only with the Draw permission.	“Draw the weekly levels on my SOL chart.”
`account_remove_drawings`	Removes drawings the AI made on one symbol. It cannot remove a drawing you made.	“Clear what you drew on SOL.”

Reach you on your phone (off until you switch it on)

Open Help (?) on the chart → AI assistant → “Let the AI send alerts to my phone”.

Tool	What it does	Ask, for example
`notify_phone`	Sends one push to your phone when the AI finds a setup that passes every check you gave it. The push is titled “AI idea”, carries the entry, the stop, the target, the reason and what would prove the idea wrong, and ends with “Not a sure win.” A tap opens that symbol in the phone app. At most 1 per 10 minutes and 5 per day. It places no trade and creates no alert.	“Watch my list on the 4h. Tell my phone only if something passes every check.”

Ready-made workflows (prompts)

A prompt is a complete job in one command. In Claude Code, type /mcp__openview__morning_brief (and so on). A prompt is only text for the assistant: it gives it no power that the tools do not have.

Prompt	What you get
`morning_brief`	A two-minute start to the day: news, today’s events, the strongest and weakest names on your watchlist, the best breakout setups, and at most three things to watch.
`analyze_chart`	A full read of the open chart: the trend on each timeframe, key levels, derivatives data, a look at the picture — then it draws the 3–5 levels that matter.
`plan_a_trade`	Turns your idea into a sized plan with a position box on the chart, a backtest of the closest simple rule, and alert suggestions at the entry and the stop.
`review_journal`	A coach’s review of your journal: what makes money, what loses it, the repeated mistake, and one rule to try for the next 20 trades.
`find_setups`	The breakout report crossed with your watchlist, then checked across timeframes. “Nothing worth a trade today” is a valid answer.
`watch_for_setups`	One pass of a watch loop. It sends one phone push only when a symbol passes every check. Run it again and again with /loop.

What it can never do

Place, change or close a trade. There is no connection to any exchange or broker.
Create a price alert through the chart page. It can only suggest one there; you press Create. With an API key that has the Alerts permission, it can add alerts to your account (marked as made by the AI).
Change or delete a price alert that you made.
Write to your journal, or change your holdings, watchlists, indicators or settings. An API key can read your watchlists, never change them.
Delete or change a drawing that you made.
Run code, read files on your computer, or reach any part of the app outside the chart.
Work inside grid panels, embedded charts or the phone app’s chart.
Read your wallet or journal, or send a push, while the switch for it is off. Both are off by default.
Give liquidation data. There is no dependable free source, so the tool says so.
Promise a win. No setup is sure to win. Text such as “guaranteed” or “risk-free” is refused in a phone alert.

Why alerts are suggestions only. Alerts sync to the cloud and ring your phone. An alert made by an AI could keep firing with nothing on screen to remove it. So the assistant fills in the form, and you press Create. The one exception is an API key that you made with the Alerts permission: its alerts are marked as made by the AI, the AI can remove only those, and you can delete any of them in the Alerts panel.

Quick start

Start the bridge server — Node ≥ 18, nothing to install:
```
node mcp/server.mjs
```
It listens on http://127.0.0.1:8787 (your computer only) and also serves a copy of the chart.
Open the chart. Two ways:
- http://127.0.0.1:8787/ — the quickest. It connects by itself. This copy has no account, so there is no wallet, no journal and no phone alert.
- https://openview.site/index.html?agent=1 — your real chart, signed in. Use this one for get_portfolio, get_journal and notify_phone. Chrome asks one time for permission to reach your local network: allow it. Safari can block this connection; use Chrome, Edge or Firefox.
Add the MCP server to Claude Code:
```
claude mcp add openview -- node /absolute/path/to/openvieweb/mcp/server.mjs --mcp
```
Claude Desktop: add the same command under mcpServers in its config. --mcp starts its own HTTP server, or attaches to one already running on the port — start order does not matter. After an update, restart the server to get the new tools.
Optional: connect your account. Signed in, open Settings → API keys, create a key and tick what it may do. Settings then shows the full claude mcp add command with the key in it. Copy it, put in your path to mcp/server.mjs, and run it. The key shows only one time. Keep it secret, like a password.
Check the connection. On the chart, open Help (?). The “AI assistant” section shows ● Connected. The two switches are there too.
Ask for something. “Give me a morning brief.” · “Where are support and resistance? Draw them.” · “Do the 1h, 4h and 1d agree on ETH?” · “Plan a long at 2,500 with a stop under the last low, 1 % risk on $5,000, and draw it.” · “Test that rule on the last 1000 bars.” · “Suggest alerts at the entry and the stop.” · “Review my journal.” · “Clear everything you drew.”

Phone alerts — how they work

Open the chart at https://openview.site/index.html?agent=1 and sign in.
Sign in to the Openview phone app with the same account and allow notifications.
On the chart: Help (?) → AI assistant → switch on “Let the AI send alerts to my phone”.
Tell the assistant to watch. In Claude Code: /loop /mcp__openview__watch_for_setups. Each pass scans your watchlist and sends a push only when one symbol passes every check: a strong verdict, all timeframes in agreement, a real level for the stop, reward at least twice the risk, and no high-impact event in the next 2 hours.

Limits you should know. The assistant watches only while it runs — if you close it, nothing watches. The chart page must stay open. A setup that passes every check can still lose, so every push carries the stop and what would prove the idea wrong. For a price level that must ring with everything closed, use a normal Openview alert.

Backtest rules

A rule is a small, fixed form — not code. Entry needs all of its conditions; exit needs any one. At most 8 conditions and 1500 bars.

{
  "side": "long",                       // or "short"
  "entry": { "all": [ { "left": "rsi:14", "op": "crossUp", "right": 30 } ] },
  "exit":  { "any": [ { "left": "close",  "op": "<",       "right": "sma:50" } ] },
  "stop_pct": 3, "target_pct": 6, "max_bars": 40, "fee_pct": 0.1
}

Operators: < > <= >= crossUp crossDown. Values: open high low close volume, sma:N ema:N rsi:N atr:N cci:N mom:N adx:N, macd macd_signal macd_hist stoch_k stoch_d bb_upper bb_mid bb_lower, or a number. The indicator values come from the chart’s own functions, so they match what you see on screen. A past result does not predict the next trade.

REST API

The same functions over plain HTTP, from http://127.0.0.1:8787. Any language can use it.

GET    /api/health                         → { ok, appConnected, version }
GET    /api/chart
POST   /api/chart                          body: { symbol?, timeframe? }        (changes the open chart)
GET    /api/bars?symbol=&timeframe=&limit=
GET    /api/indicators
GET    /api/technicals?symbol=&timeframe=
GET    /api/technicals/mtf?symbol=&timeframes=1h,4h,1d
GET    /api/levels?symbol=&timeframe=&lookback=&max=
GET    /api/derivatives?symbol=
GET    /api/screenshot
GET    /api/watchlist
GET    /api/watchlist/scan?symbols=BTC-USD,ETH-USD&tf=1d
GET    /api/breakouts?limit=&assetClass=&minScore=
GET    /api/news?limit=
GET    /api/events?limit=
POST   /api/plan                           body: { entry, stop, target|rr, account_size?, risk_pct?, fee_pct?, draw? }
POST   /api/backtest                       body: { symbol?, timeframe?, bars?, rule }
GET    /api/alerts                         (read-only)
GET    /api/alerts/proposals
POST   /api/alerts/proposals               body: { alerts:[{price, op?, message?, reason?}] }   (suggestions only)
GET    /api/portfolio                      (needs the account switch)
GET    /api/journal?limit=                 (needs the account switch)
POST   /api/notify                         body: { symbol?, direction, entry?, stop, target?, reason, invalidation }
GET    /api/drawings
POST   /api/drawings                       body: { drawings:[{type, points:[{time,price}], color?, width?, dash?, text?, name?}] }
DELETE /api/drawings/<id>                  (AI-added drawings only)
DELETE /api/drawings?llm=1                 (clear all AI-added drawings)

Times are UNIX seconds. Timeframes: 1m 5m 15m 30m 1h 2h 4h 6h 12h 1d 1w 2w 1M 1Y (1M = month, 1m = minute). dash: 0 solid, 1 dashed, 2 dotted. When a switch is off, the answer is { available: false, reason } with status 200 — it is an answer, not an error.

Your privacy

The bridge runs on your computer. Openview does not see your questions or the answers.
What the assistant reads goes to the AI service you chose (for example Claude). That service’s privacy terms apply to it.
Wallet and journal data leave the page only after you switch that on, and only when the assistant asks. Switch it off and it stops at once.
The switches, the alert suggestions and the phone-alert count stay on this device. They do not sync to your account.
A phone push goes through Openview’s server to your own phones only. The chart page and the bridge never hold your sign-in.

Limits

The chart tools need the chart page open in a browser tab, in single-chart mode.
Each request to the page has 20 seconds. A cold 4h or weekly read can be slow the first time; ask again.
get_breakouts can take 20–30 seconds on the first call.
scan_watchlist: 30 symbols per call. get_bars and backtest_rule: 1500 bars.
Drawings: 40 per call, 400 in total. Alert suggestions: 10 per call, 20 waiting.
Phone alerts: 1 per 10 minutes, 5 per day, 300 characters.
Alert suggestions are for the open symbol only.
Derivatives data: major exchange perpetuals only. No liquidations.
The portfolio value is the last one the Wallet screen saved, not a live price.

Configuration

Env / setting	Default	Meaning
`OPENVIEW_PORT`	`8787`	Server port (page side: `localStorage.fv_agent_port`)
`OPENVIEW_TOKEN`	off	Optional shared secret. Every caller must send `X-OpenView-Token`. Give the chart page the same value in `localStorage.fv_agent_token` (it stays on this device)
`OPENVIEW_ALLOWED_ORIGINS`	none	Extra `https://` sites that may connect a chart page, comma-separated. `https://openview.site` is always allowed

Security

The bridge is local by design. It binds 127.0.0.1 only and checks the Host header (this blocks DNS rebinding). A browser caller must come from localhost or a file:// page. The one exception is the chart page on https://openview.site, and it may use only the page channel (/bridge/poll) — it cannot call /api/* or read files. All other sites get a 403.

The server and the page both hold a fixed list of commands: no eval, no file access, no settings. A backtest rule is a checked form, never code. Input is checked and capped, text from the AI is never treated as HTML, and the file server refuses dotfiles and .env*. The bridge in the page never runs inside embeds (grid panels or the phone WebView) and talks only to 127.0.0.1.

News, events and breakouts are fetched GET-only over fixed paths, with no credentials and no caller-supplied URL, so the bridge cannot be pointed at another host. A failure is reported as a plain “feed unavailable” — no stack traces or internal paths reach the AI.

Remaining risk, stated plainly. With the account switch on, the AI service you use sees your holdings and trade results. And text the AI reads (a news headline, a note) could try to steer it; that is why it cannot trade, cannot create alerts, and phone alerts are limited and off by default.

Troubleshooting

You see	Do this
“OpenView is not connected”	Open the chart page (step 2). On openview.site the address must end with `?agent=1`. Allow the local-network prompt in Chrome.
A new tool is missing, or “unknown endpoint”	An old server is still running. Stop it and start it again.
“Account data is off” / “Phone alerts are off”	Help (?) on the chart → AI assistant → switch it on.
The account is on, but there is “no account data at this address”	You opened the local copy. Open `https://openview.site/index.html?agent=1` and sign in.
A push says “no phone signed in to this account”	Sign in to the phone app with the same account and allow notifications.
401 on every call	`OPENVIEW_TOKEN` is set. Send the header, and put the same value in `localStorage.fv_agent_token` on the chart page.
`set_chart` is refused	Leave grid mode or replay first.

Open the live charts →