Connect Claude to 7 Tools for Financial Research and Paper Trading

The 7 GitHub Repos That Turn Claude Into a Hedge Fund

Setup guide + prompt pack

Everything from the video, in the order it appears. All seven are free. Two need paid keys for full features (noted where they apply). All install instructions are copied from each repo's own README as of 16 September 2026 - if something has changed, the README wins.

Before you start, read this once: none of these tools make money on their own. TradingAgents and AI Hedge Fund both say in their own READMEs that they are research and education tools and do not trade. Anything that touches a broker in this guide stays on a paper account. This is not financial advice.

What you need installed first

You only need what's listed under the repos you actually want. But if you want all seven:

Keys you'll be asked for

The fastest route: one prompt for Claude Code

Paste this into a fresh Claude Code session. It installs the three MCPs and the two Python apps, asks you for each key when it needs it, and gives you a pass/fail table at the end. Fincept and Daily Stock Analysis are set up in a browser, not Claude Code - they're at the bottom of this guide.

I'm setting up five tools from a YouTube video. Work in ~/trading-repos, one folder per tool. For each, read the README on GitHub first and follow its install instructions exactly. When you need an API key, stop and ask me - don't guess or skip. Install one at a time and don't move on until the smoke test passes. If one fails twice, log the error and move on.

1. Alpaca MCP - https://github.com/alpacahq/alpaca-mcp-server
   Register it with `claude mcp add alpaca --scope user --transport stdio uvx alpaca-mcp-server --env ALPACA_API_KEY=... --env ALPACA_SECRET_KEY=...` using my PAPER keys. Leave ALPACA_PAPER_TRADE at its default (true). Never configure live trading. Smoke test: show my paper account balance.

2. OpenBB MCP - https://github.com/OpenBB-finance/OpenBB
   Install the openbb-mcp-server package and register it with Claude Code at user scope over stdio using uvx (the README on PyPI has the exact args). Use free data providers only - yfinance ships with it. Smoke test: pull the last 5 daily closes for BTC-USD.

3. TradingView MCP - https://github.com/tradesdontlie/tradingview-mcp
   Clone it, run npm install, add it to my Claude Code MCP config at ~/.claude/.mcp.json, and launch TradingView Desktop with the debug port using the script for my OS. TradingView Desktop is installed. Smoke test: tv_health_check.

4. TradingAgents - https://github.com/TauricResearch/TradingAgents
   Clone into its own folder with a Python 3.12 virtual environment, `pip install .`, set ANTHROPIC_API_KEY. Smoke test: run the `tradingagents` CLI on BTC-USD, today's date, all four analysts, shallow depth, Anthropic as provider, and show me the final decision.

5. AI Hedge Fund - https://github.com/virattt/ai-hedge-fund
   `pipx install aihf`. It asks for a Financial Datasets key and an Anthropic key on first run - ask me for both. Smoke test: run `aihf`, build a fund on NVDA and COIN with all investor strategies, save it as ~/.hedge-fund/mandates/demo.yaml, and run one cycle.

At the end, give me a table: tool, PASS/FAIL, what the smoke test returned, and one example prompt I can run for each.

If you'd rather do them one at a time, each section below has its own steps and its own prompt.

1. OpenBB - the data desk

Repo: https://github.com/OpenBB-finance/OpenBB Stars: ~73,000 · Licence: AGPL-3.0 · Cost: free (some data providers need their own keys)

What it does OpenBB is an open-source data platform that pulls stocks, crypto, options, ETFs, macro and economic data from dozens of providers into one interface. Bloomberg does the same job for around $25,000 a year. The MCP server sits on top so Claude can call any of those data functions in plain English. Before this, Claude answered market questions from memory; after it, Claude goes and gets the number.

One thing to know: the open-source package is the data layer. The dashboard in OpenBB's screenshots is "OpenBB Workspace", a separate paid product. You don't need it for anything here.

Setup (Claude Code)

The MCP is a separate package. Register it once at user scope and Claude Code will launch it when needed:

claude mcp add openbb-mcp --scope user --transport stdio -- uvx --from openbb-mcp-server --with openbb openbb-mcp --transport stdio

Verify with /mcp inside Claude Code. Prices come through yfinance with no key. For US macro series (Treasury yields, CPI, unemployment) get a free FRED key at https://fred.stlouisfed.org/docs/api/api_key.html and set it via obb.user.credentials.fred_api_key - or just use the ETF proxies below.

Setup (Claude Desktop)

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "openbb-mcp": {
      "command": "uvx",
      "args": ["--from", "openbb-mcp-server", "--with", "openbb", "openbb-mcp", "--transport", "stdio"]
    }
  }
}

Prompts to try

Cross-asset read (the one from the video):

Using OpenBB, pull the last 30 days of daily closes for BTC-USD, ETH-USD, SPY, QQQ, GLD, UUP (dollar) and TLT (long bonds).

Give me a table with each one's 30-day return and its correlation to BTC over the period.

Then in one paragraph: is BTC trading like a risk asset, a gold proxy, or its own thing right now - and what's the one macro number to watch this week.

Cite the data provider and timestamp for every figure. If you can't fetch something, say so - don't fill it from memory.

Options positioning:

Using OpenBB, pull the options chain for MSTR for the nearest monthly expiry. Show the five strikes with the highest open interest on each side, the put/call ratio, and where the max-pain strike sits. One paragraph on what the options market is positioned for.

ETF look-through:

Using OpenBB, pull the current holdings of IBIT and the top institutional holders of COIN. Who's the largest holder of each, and has their position changed in the last two quarterly filings?

2. TradingView MCP - the chart reader

Repo: https://github.com/tradesdontlie/tradingview-mcp Stars: ~6,000 · Licence: see repo · Cost: free (requires TradingView Desktop with a paid plan)

What it does A community-built bridge - not an official TradingView product - that connects Claude Code to the TradingView Desktop app running on your machine. Claude can then do what you do with a mouse: open symbols, change timeframes, read candles and indicators, draw zones and lines, add native indicators, set alerts, and step through Bar Replay. It talks to the app through the Chrome DevTools Protocol, the same debugging interface built into VS Code, Slack and Discord. It never touches TradingView's servers and cannot place broker trades.

Two honest caveats from the repo itself: it uses undocumented internals that can break when TradingView updates, and TradingView's terms restrict automated use - read the Disclaimer in the README and decide for yourself.

Requirements: TradingView Desktop (not the browser version), a paid TradingView plan for live data, Node.js 18+, Claude Code.

Setup

The README's own one-line prompt for Claude Code:

Install the TradingView MCP server. Clone https://github.com/tradesdontlie/tradingview-mcp.git, run npm install, add it to my MCP config at ~/.claude/.mcp.json, and launch TradingView with the debug port. Then verify the connection with tv_health_check.

Or manually:

git clone https://github.com/tradesdontlie/tradingview-mcp.git
cd tradingview-mcp
npm install

Launch TradingView with the debug port (it must be running this way every time you use the MCP):

• Mac: ./scripts/launch_tv_debug_mac.sh
• Windows: scripts\launch_tv_debug.bat
• Linux: ./scripts/launch_tv_debug_linux.sh

Add to ~/.claude/.mcp.json (replace the path with your real one):

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

Verify by asking Claude: Use tv_health_check to verify TradingView is connected

Prompts to try

Draw the levels (from the video):

Use the TradingView MCP bridge to open BINANCE:BTCUSDT in a separate layout called "Claude Demo." Preserve my original layout.

Review six months of daily price action, then finish on the four-hour chart showing the last 60 days. Draw the three strongest support/resistance zones based on repeated reactions and meaningful swing points. Use narrow, translucent zones: teal for support, muted red for resistance and amber for a pivotal level. Label each with its prices and supporting timeframe.

Keep the chart clean and readable. Inspect the finished result and fix any clutter. Explain the most important level, why it matters and what would invalidate your reading in three sentences.

Check the levels against volume (from the video):

On the BTC four-hour chart, add TradingView's native Visible Range Volume Profile for the last 60 days, using a 70% value area.

Put the profile on the right with subdued colours, a gold point of control (POC), and distinct value-area high (VAH) and low (VAL) lines. Read their actual prices from the native indicator and add clear labels without covering the candles.

Explain whether volume supports or challenges the zones, and whether price is above, inside or below value. If the native indicator or exact values aren't accessible, state the limitation; don't estimate them or build a replacement.

The morning sweep:

Read every symbol in my watchlist on the daily. For each: trend direction, where price sits against the 20 and 50 EMA, and whether it's coiling or extended.

Rank by cleanest setup. Give me the top 3 only. For each: the level it needs to reclaim or lose, and the level that invalidates it.

If a read is ambiguous, say "no setup" - don't force one.

The second opinion:

Read my current chart including my drawings and indicators. I'm looking at a long here. Build the strongest case that I'm wrong, using specific levels and indicator readings on this chart, not general market commentary. End with the one price that proves the bear case right.

3. Fincept Terminal - the $30k terminal

Repo: https://github.com/Fincept-Corporation/FinceptTerminal Stars: ~32,000 · Licence: AGPL-3.0 (free edition) · Cost: free; you pay your own LLM bills

What it does A native desktop application built to look and feel like a professional terminal: screeners, multi-asset analytics (DCF, portfolio optimisation, VaR/Sharpe, derivatives pricing, an 18-module QuantLib suite), 100+ data connectors (FRED, IMF, World Bank, Polygon, Kraken, Yahoo Finance), a paper-trading engine, 16 broker integrations, a visual automation editor, MCP tools, and a global-intelligence desk with maritime tracking and geopolitical mapping. On top of that sit 37 AI agents - trader and investor personas plus economic and geopolitics agents. You bring your own LLM key; Anthropic is supported alongside OpenAI, Gemini, Groq, DeepSeek, OpenRouter and Ollama.

Two things to know: the free build charges nothing itself, but every agent call bills your key per token. And the multi-agent "research teams" are in the paid Enterprise edition - the free build gives you the single agents.

Setup

This is the only one that needs no terminal. Download the installer for your OS from the Releases page: https://github.com/Fincept-Corporation/FinceptTerminal/releases

Current release is v4.5.0 with builds for Windows x64, macOS Apple Silicon, and Linux (AppImage, .deb, .rpm). Run the installer, open the app, go to the AI settings, paste your Anthropic key, pick a model.

Prompts to try (inside Fincept's agent chat)

Geopolitics desk - the one nothing else in this list can do:

Run the geopolitics agent on the current Middle East situation. Pull the maritime view for the Strait of Hormuz and current oil, DXY and BTC prices from the data connectors.

Give me: what's changed in the last seven days, what it means for oil first and risk assets second, and what a de-escalation versus escalation would do to BTC over the next month. Three bullets each, with the numbers you pulled.

Investor screen:

Screen the S&P 500 the way Warren Buffett would. Filter for at least ten years of consistent earnings, return on equity above 15% for five years, low debt to equity, and a moat you can name in one sentence. Give me the five that pass today, what you'd pay versus where they trade, and which one you'd actually buy at today's price. If none clear the bar, say so.

DCF with workings:

Run a DCF on COIN using your model. Show me the assumptions you used for growth, margin and discount rate, the implied price, and how far it is from the current price. Then tell me which single assumption the valuation is most sensitive to.

4. Daily Stock Analysis - runs while you sleep

Repo: https://github.com/ZhuLinsen/daily_stock_analysis English README: https://github.com/ZhuLinsen/daily_stock_analysis/blob/main/docs/README_EN.md Stars: ~65,000 · Cost: free (runs on GitHub's servers)

What it does Every weekday it takes your watchlist, pulls quotes, technicals, news and fundamentals for each ticker, runs it all through an LLM, and produces a decision dashboard: a buy/watch/sell verdict per stock, a score out of 100, trend, entry and exit levels, risk alerts, catalysts and an action checklist. Then it pushes that report to Telegram, Discord, Slack, email, WeChat or Feishu. Covers US, Hong Kong, Japan, Korea, Taiwan and China A-shares. It runs on GitHub Actions, so there's nothing to host and nothing to pay.

The README is Chinese-first - use the English link above. The levels it prints are an LLM's read of the data, not a model; treat them as a starting point.

Setup (in a browser, about 10 minutes)

1. Fork the repo. Click Fork at https://github.com/ZhuLinsen/daily_stock_analysis
2. Make a Telegram bot. Message @BotFather on Telegram, send /newbot, follow the prompts, copy the token. Then message your new bot once, and get your chat ID from https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates (look for "chat":{"id":...}).
3. Add secrets. In your fork: Settings → Secrets and variables → Actions → New repository secret. Add these exact names:

1. Enable Actions. Actions tab → "I understand my workflows, go ahead and enable them."
2. Test it. Actions → Daily Stock Analysis → Run workflow. Check Telegram.

By default it runs every weekday at 18:00 Beijing time and skips non-trading days. To change the time, edit the cron in .github/workflows/.

What you'll receive (from the README's sample):

🎯 Decision Dashboard
Analyzed 3 stocks | 🟢 Buy:0 🟡 Watch:2 🔴 Sell:1

📊 Summary
🟡 NVDA: Watch | Score 65 | Bullish
🟡 COIN: Watch | Score 48 | Range-bound
🔴 MSTR: Sell | Score 35 | Bearish

🚨 Risk Alerts / ✨ Positive Catalysts ...

Ways to use it

• Watchlist report every morning - the default.
• Run it on demand: python main.py --stocks AAPL,NVDA,COIN locally.
• Market review mode: python main.py --market-review for a broad market read instead of single names.

5. TradingAgents - the research floor

Repo: https://github.com/TauricResearch/TradingAgents Stars: ~107,000 · Licence: Apache-2.0 · Cost: free; you pay your own LLM tokens

What it does A multi-agent framework from Tauric Research, built on LangGraph, that copies the org chart of a trading firm. Four analyst agents each own a lane - fundamentals, sentiment, news, technicals. Their reports go to a bull researcher and a bear researcher who argue across several rounds. A trader agent reads the debate and makes a call. A risk team (aggressive, conservative, neutral) reviews it, and a portfolio manager approves or rejects. Every step is a separate model call with the previous output as context, so you can read the whole reasoning chain. It supports Claude (Sonnet 5 and Fable 5 as of v0.3.1) and uses free Yahoo Finance data by default. It produces a decision, not a trade - there's no broker connection.

Two runs on the same ticker can differ. The README says so; it's an LLM research tool, not a deterministic signal.

Setup

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
python3.12 -m venv .venv && source .venv/bin/activate    # Windows: .venv\Scripts\activate
pip install .
export ANTHROPIC_API_KEY=your_key                          # Windows: set ANTHROPIC_API_KEY=your_key
tradingagents

The CLI walks you through a menu: ticker, date, analysts, research depth, LLM provider, models. Pick BTC-USD, today, all four analysts, Anthropic, and start with Shallow depth (fastest and cheapest). Crypto tickers use the -USD suffix; any market Yahoo Finance covers works (AAPL, 0700.HK, BHP.AX).

Every run appends to ~/.tradingagents/memory/trading_memory.md. On the next run for the same ticker it fetches the realised return since last time and writes a reflection into the portfolio manager's context - so it learns from its own calls.

Prompts to try

Give Claude Code this to get a fully labelled run (from the video):

In the TradingAgents folder, write research_floor.py using TradingAgentsGraph.

Config: llm_provider "anthropic", deep_think_llm and quick_think_llm set to the Claude models listed in tradingagents/default_config.py (use the strongest for deep, a faster one for quick), all four analysts on, max_debate_rounds 3, max_risk_discuss_rounds 2, debug True.

Run it on BTC-USD for today. As each stage finishes, print it under a clear header: Market Analyst, Sentiment Analyst, News Analyst, Fundamentals Analyst, Bull Case (round by round), Bear Case (round by round), Research Manager, Trader, Risk Team (each round), Portfolio Manager.

At the end print a five-line summary: verdict, conviction, strongest bull point, strongest bear point, and what would flip the decision. Save the full output to ./reports/BTC-USD-<date>.md, then run it.

Compare two tickers:

Run TradingAgents on ETH-USD and SOL-USD for today at medium depth. Give me both portfolio manager verdicts side by side, and tell me which one the bear researcher had the stronger case against and why.

The memory callback (run the day after your first BTC run):

Run TradingAgents on BTC-USD again for today. Before the portfolio manager decides, show me the reflection it wrote about yesterday's call and the realised return since. Then the new verdict.

6. AI Hedge Fund - the investment committee

Repo: https://github.com/virattt/ai-hedge-fund Stars: ~63,000 · Licence: MIT · Cost: free software; needs a paid Financial Datasets key (~$20)

What it does Built by virattt, one of the best-known indie builders in this space. It gives you agents modelled on named investors - Buffett, Munger, Burry, Ackman, Cathie Wood, Druckenmiller, Lynch, Graham, Fisher and more - each with that investor's philosophy encoded as instructions. In 2026 it was rebuilt around a fund: you build one (pick stocks, strategies, capital, rebalance cadence), run cycles where every investor votes on every stock with a signal, confidence and reasoning, and backtest it to draw an equity curve against a benchmark. Its own README says it's educational and does not trade.

Setup

pipx install aihf          # or: uv tool install aihf
aihf

It asks for two keys the first time it needs them and saves them to ~/.hedge-fund/.env: a Financial Datasets key (https://financialdatasets.ai) and an Anthropic key. Nothing else to configure.

aihf with no arguments opens the interactive app. Build a fund - pick tickers, pick every investor strategy, set $100,000 capital, monthly rebalance - and it saves a mandate file to ~/.hedge-fund/mandates/. Then:

# run one cycle - every investor votes on every stock
aihf ~/.hedge-fund/mandates/your-fund.yaml --tickers NVDA,COIN,MSTR,PLTR,TSLA

# backtest the same fund over history
aihf ~/.hedge-fund/mandates/your-fund.yaml --tickers NVDA,COIN,MSTR,PLTR,TSLA --backtest

The cycle prints JSON to stdout with a short summary to stderr.

Prompts to try (for Claude Code, after aihf is installed)

The disagreement table:

Run my mandate at ~/.hedge-fund/mandates/your-fund.yaml on NVDA,COIN,MSTR,PLTR,TSLA and capture the JSON. Render it as a table: rows are tickers, columns are each investor's signal and confidence, plus the final decision per ticker. Under it, list the three biggest disagreements - one investor strongly bullish, another strongly bearish on the same stock - with each side's one-line reasoning.

The backtest read:

Run the same mandate with --backtest. Tell me final return versus the benchmark, max drawdown, the worst month, and which investor's signals contributed most to the winners and the losers.

Two funds, one question:

Build a second mandate with only the value investors (Buffett, Munger, Graham) and a third with only the growth investors (Wood, Lynch, Fisher). Backtest both on the same five tickers and show me the two equity curves side by side with the benchmark.

7. Alpaca MCP - and now it trades

Repo: https://github.com/alpacahq/alpaca-mcp-server Stars: ~1,000 (official Alpaca product) · Cost: free paper-trading account

What it does Alpaca is a US-regulated, API-first broker for stocks, ETFs, crypto and options. Every account comes with a paper-trading twin: same data, same order types, same fills, fake money. This is Alpaca's own MCP server, so Claude can check balances and positions, pull quotes and bars, place, modify and cancel orders, and manage watchlists through conversation. Paper trading is the default (ALPACA_PAPER_TRADE=true). Keep it there.

Requirements: Python 3.10+, uv, a free Alpaca paper account.

Setup

1. Create a free paper account and get your keys: https://app.alpaca.markets/paper/dashboard/overview
2. Register with Claude Code (from the README):

claude mcp add alpaca --scope user --transport stdio uvx alpaca-mcp-server \
  --env ALPACA_API_KEY=your_alpaca_api_key \
  --env ALPACA_SECRET_KEY=your_alpaca_secret_key

Verify with /mcp inside Claude Code.

For Claude Desktop, add to claude_desktop_config.json:

{
  "mcpServers": {
    "alpaca": {
      "command": "uvx",
      "args": ["alpaca-mcp-server"],
      "env": {
        "ALPACA_API_KEY": "your_alpaca_api_key",
        "ALPACA_SECRET_KEY": "your_alpaca_secret_key"
      }
    }
  }
}

Optional safety rail: to make Claude read-only, add "ALPACA_TOOLSETS": "stock-data,crypto-data" to the env block. See the README's Toolset Filtering section for the full list.

Prompts to try

The paper trade (from the video):

Show my paper account balance and open positions. Then place a paper buy for 10 shares of NVDA at market and confirm the fill.

Bracket order:

On my paper account, buy 5 shares of COIN with a stop loss 5% below entry and a take profit 10% above. Show me the three orders it creates before submitting, then submit.

Close the loop with TradingAgents:

Read ./reports/BTC-USD-<date>.md from my TradingAgents run. If the portfolio manager's verdict was Buy, place a paper order for $500 of BTC/USD on my Alpaca account and confirm the fill. If it was Sell or Hold, do nothing and tell me why.

Safety notes, once

• Everything that touches a broker in this guide is on a paper account. Don't point an LLM at a live account.
• Never paste a private key or a live broker secret into a chat. The MCPs above take keys through config or environment variables, not through the conversation.
• The TradingView bridge uses undocumented app internals and may conflict with TradingView's terms. Read the README's disclaimer.
• Every agent call to Anthropic bills your key. Start with shallow research depth and short backtests until you know what a run costs.
• None of this is financial advice. It's software.