The Automated Trading Stack

The Vision

Every evening at 23:00, while you are asleep, an autonomous AI agent wakes up. It connects to live market data feeds, scans over 8,000 tickers across US, European, and Asia-Pacific exchanges, runs multi-strategy screening algorithms, scores every candidate through a 6-dimensional quality filter, and delivers 3 meticulously researched trade recommendations to your Discord channel. By the time you check your phone in the morning, the work is done. All you need to do is decide whether to execute.

This is not a fantasy. This is what we have been running in production at DailyTickers since January 2026. The system has generated over 200 scanner reports, each containing 10 A+ setups, with a documented hit rate tracked through weekly retrospectives. And it is built entirely on tools that are available to any retail investor today: Claude Code, the Model Context Protocol (MCP), and a handful of well-configured servers.

The Problem With Manual Trading Research

If you are a retail trader doing your own research, your workflow probably looks something like this: you open TradingView, flip through a watchlist of 30-50 tickers, check RSI and MACD on each, maybe read some news, glance at earnings dates, and then try to synthesize all of that into a trade decision. On a good day, this takes 2-3 hours. On a busy day, you skip it entirely.

The problems with this approach are structural, not personal:

• Coverage is pathetically narrow. You cannot manually screen 8,000 tickers. So you miss opportunities in names you have never heard of. The best setups often come from obscure mid-caps that never make it to FinTwit.
• Analysis is inconsistent. Monday-you applies different criteria than Friday-you. Your emotional state, your recent P&L, whether you slept well — all of these introduce noise into your selection process.
• Multi-dimensional scoring is impossible at scale. Checking technicals is easy. But simultaneously evaluating technicals + fundamentals + social sentiment + sector rotation + macro regime + AI conviction for hundreds of candidates? That requires compute, not willpower.
• There is no feedback loop. Did your screening criteria actually produce profitable setups? Without systematic tracking, you are flying blind. You cannot improve what you do not measure.
• Opportunity cost is enormous. Those 2-3 hours could be spent on actual edge — studying market microstructure, backtesting strategies, or simply living your life.

What "Automated" Actually Means

Let us be precise about terminology, because "automated trading" means different things to different people:

• Automated execution (algo trading) = a bot places orders on your behalf. We are NOT building this. Automated execution requires brokerage API integration, real-time risk management, latency optimization, and regulatory compliance. That is a different (and much more dangerous) project.
• Automated research (what we are building) = an AI agent performs all the research, analysis, and scoring that a human analyst would do, and delivers structured trade recommendations. You make the final execution decision.

This distinction matters enormously. Our system is a research automation pipeline, not a trading bot. It replaces the analyst, not the trader. You retain full control over execution, sizing, and risk management. The AI handles the tedious, high-volume, multi-dimensional screening work that no human can do consistently at scale.

The End State

When you finish all 6 parts of this series, here is what your daily life as a trader will look like:

1. 23:00 — A cron job fires. Claude Code wakes up and begins its nightly scan.
2. 23:05 — The MCP Gateway returns market regime analysis (Risk-On, Risk-Off, Neutral, Transition).
3. 23:08 — Three parallel screener strategies run: oversold reversals, momentum breakouts, and mean-reversion setups. 150+ candidates identified.
4. 23:12 — Each candidate is scored across 6 layers. Only setups scoring 85+ make the first cut (typically 20-30).
5. 23:18 — AI re-ranking via DeepSeek analysis reduces the list to 10 A+ setups.
6. 23:22 — The top 3 A++ setups are packaged as Discord alerts with entry zones, stop losses, take-profit targets, and risk/reward ratios.
7. 23:25 — Discord notifications land on your phone. A full HTML report is committed to GitHub Pages for the permanent record.
8. 07:00 next day — You wake up, review the 3 recommendations over coffee, and decide which (if any) to execute at market open.

The entire pipeline takes less than 30 minutes and requires zero human intervention. Let us build it.

Architecture Overview

The system follows a classic ETL pattern — Extract, Transform, Load — with an AI agent at the center acting as the orchestrator. But unlike traditional ETL where each step is a discrete service, our entire pipeline is a single Claude Code session that makes tool calls through the Model Context Protocol.

The 30,000-Foot View

There are four major subsystems, each exposed to Claude Code as an MCP server:

Data Flow in Detail

Let us trace a single execution from trigger to delivery. Understanding this flow is essential before we start building, because every architectural decision serves a specific purpose in this chain.

Why MCP is the Key Enabler

The Model Context Protocol is what makes this entire architecture possible. Before MCP, connecting an LLM to external data sources required custom API wrappers, prompt engineering for tool calling, and fragile output parsing. MCP standardizes the interface: every data source, every action, every delivery mechanism exposes the same JSON-RPC protocol. Claude Code does not know (or care) whether it is talking to a market data API, a Discord webhook, or a Git repository. It just makes tool calls.

This has three profound implications for our architecture:

1. Composability. Adding a new data source (say, on-chain crypto data) means adding a new MCP server. Zero changes to the pipeline code, zero changes to the prompt. Claude Code discovers the new tools automatically.
2. Reliability. MCP servers handle their own retry logic, rate limiting, and error handling. The AI agent sees clean tool responses, not raw HTTP errors.
3. Testability. Each MCP server can be tested in isolation. You can mock the DailyTickers Gateway to run the pipeline on historical data for backtesting.

Architecture Constraints

Before we move on, it is important to document the deliberate constraints in this architecture, because they prevent common mistakes:

• No automated execution. The pipeline produces recommendations, not orders. There is no brokerage API integration. This is a research tool, not an algo trading system.
• Single-threaded execution. Claude Code runs as a single agent per pipeline invocation. We do not parallelize multiple scans — this ensures consistent reasoning and prevents race conditions in data collection.
• Append-only reporting. Every scan produces a new HTML report in a dated directory (scanner/YYYYMMDD/). We never overwrite historical reports. This creates an immutable audit trail.
• Human-in-the-loop on retrospectives. While daily scans are fully automated, weekly retrospectives (where we grade the scanner's performance) are triggered by the same bot but reviewed by a human before publishing adjustments to scoring weights.
• Conservative regime adaptation. In Risk-Off or Transition regimes, the system does not just change stock selection — it mandates minimum 20% allocation to hedges and shorts. This is hardcoded in the system prompt, not left to the AI's discretion.

The Tech Stack

Let us break down every component in the stack, what it does, and why we chose it. This is an opinionated stack — there are alternatives for every layer — but these components work together exceptionally well.

Why Not Use [Alternative X]?

Before someone says "you could just use a Python script with yfinance" — yes, you could. Here is why we do not:

The fundamental advantage of the Claude Code approach is that strategy changes are prompt changes, not code changes. When you want to add a new scoring dimension (say, options flow analysis), you add a paragraph to CLAUDE.md. You do not write new code, you do not deploy a new service, you do not update a database schema. The AI reads the new instructions and adapts its behavior on the next run.

This is a paradigm shift. Traditional quantitative systems require engineering effort proportional to the complexity of the strategy. AI-orchestrated systems require engineering effort proportional to the complexity of the data plumbing — and MCP already handles that.

The Full Stack Diagram

Component Versions

For reproducibility, here are the exact versions we run in production:

Claude Code CLI    : 1.0.17 (claude --version)
Claude Model       : claude-opus-4-6
Node.js            : v22.x LTS
MCP SDK            : @modelcontextprotocol/sdk 1.12.x
Discord.js         : 14.x
GitHub CLI (gh)    : 2.x
OS                 : macOS Sequoia 15.x / Ubuntu 24.04 LTS
Shell              : zsh (macOS) / bash (Linux)
Git                : 2.43+

A++ Selection Criteria

This is the heart of the system. Everything else — the MCP plumbing, the scheduling, the Discord delivery — is infrastructure. The scoring system is the actual edge. It determines what gets recommended and what gets filtered out. Getting this right is the difference between a system that produces noise and one that produces alpha.

Our scoring model evaluates every candidate across 6 independent dimensions. Each dimension produces a score from 0 to 100. The composite score is a weighted average, with weights that shift based on the current market regime. A candidate must score above 85 on the composite AND above the individual threshold on EVERY dimension to qualify as A+. The top 3 candidates by composite score are labeled A++.

Composite Score Calculation

The composite score is a weighted average that adapts to market regime. Here are the weight profiles:

{
  "Risk-On": {
    "technical": 0.25,
    "fundamental": 0.15,
    "social": 0.10,
    "sector": 0.20,
    "macro": 0.10,
    "ai_conviction": 0.20
  },
  "Risk-Off": {
    "technical": 0.30,
    "fundamental": 0.10,
    "social": 0.05,
    "sector": 0.15,
    "macro": 0.25,
    "ai_conviction": 0.15
  },
  "Neutral": {
    "technical": 0.25,
    "fundamental": 0.20,
    "social": 0.10,
    "sector": 0.15,
    "macro": 0.15,
    "ai_conviction": 0.15
  },
  "Transition": {
    "technical": 0.20,
    "fundamental": 0.15,
    "social": 0.05,
    "sector": 0.15,
    "macro": 0.30,
    "ai_conviction": 0.15
  }
}

Notice how the weights shift: in Risk-Off, macro weight jumps to 0.30 because fighting the macro trend is suicidal. In Risk-On, sector weight rises to 0.20 because riding the right sector wave amplifies returns. Social sentiment weight drops in Risk-Off because social media becomes unreliable in panics (too much noise).

From A+ to A++

The scoring system produces A+ setups (composite >= 85, all dimensions pass). But we go one step further to identify A++ — the absolute cream. The A++ designation requires:

1. Composite score >= 90 (not just 85)
2. No dimension below 75 (no weak links)
3. R:R >= 2:1 (the reward must be at least 2x the risk)
4. AI re-ranking confirmation (DeepSeek must independently rate the setup as "high conviction")
5. No upcoming binary event within 5 trading days (no earnings, FDA, FOMC directly ahead that could invalidate the thesis)

On any given night, the scanner might produce 10 A+ setups but only 2-3 A++ setups. Some nights produce zero A++. That is fine — we would rather miss a mediocre opportunity than recommend one. A++ is about precision, not recall.

Example Scoring Breakdown

To make this concrete, here is how a real A++ setup might score:

Composite Score: 0.25(92) + 0.15(88) + 0.10(78) + 0.20(85) + 0.10(90) + 0.20(91) = 23.0 + 13.2 + 7.8 + 17.0 + 9.0 + 18.2 = 88.2 (A+)

With all dimensions above 75 and R:R at 2.8:1, this qualifies as A++.

The Daily Pipeline Flow

Now let us trace the entire pipeline in chronological order, from the moment the cron fires to the moment Discord alerts land on your phone. This is the operational blueprint that Parts 2-6 will implement in detail.

tmux new-session -d -s scanner-20260305 \
  "cd /Users/marketwatchxyz/GolandProjects/articles && \
   claude -p 'scan du jour' \
   --model claude-opus-4-6 \
   2>&1 | tee /tmp/scanner-20260305.log"

previous_tickers = extract_tickers(last_scan)  # e.g., [AAPL, NVDA, GLD, ...]
new_candidates = score_and_rank(all_candidates)

# Enforce 70% freshness
fresh_count = 0
for candidate in new_candidates:
    if candidate.ticker in previous_tickers:
        candidate.score *= 0.7  # 30% penalty for repeat
    else:
        fresh_count += 1

# If fresh_count < 7, expand screening to find more unique names

Tool: mcp__dailytickers__RunAutoScreener
Parameters: {}

{
  "regime": {
    "current": "Risk-On",
    "confidence": 0.82,
    "vix": 14.2,
    "vix_trend": "declining",
    "breadth": {
      "above_200sma": 0.68,
      "advance_decline": 1.85,
      "new_highs_lows": 3.2
    },
    "yield_curve": {
      "2y10y_spread": 0.42,
      "trend": "steepening"
    },
    "sector_rotation": {
      "leading": ["XLK", "XLY", "XLC"],
      "lagging": ["XLU", "XLP", "XLRE"]
    }
  },
  "recommended_strategies": [
    "momentum_continuation",
    "breakout_volume",
    "oversold_quality"
  ],
  "candidates": [
    // ... initial candidate list
  ]
}

Tool: mcp__dailytickers__RunScreener
Parameters: {
  "dsl": "RSI(14) < 35 AND SMA(50) > SMA(200) AND Volume > SMA_Volume(20) * 1.5 AND MarketCap > 1B",
  "universe": "US_LARGE_MID"
}

Tool: mcp__dailytickers__RunScreener
Parameters: {
  "dsl": "Close > SMA(20) AND SMA(20) > SMA(50) AND RSI(14) BETWEEN 55 AND 75 AND ADX(14) > 25 AND Volume > SMA_Volume(20) * 1.2",
  "universe": "US_ALL"
}

Tool: mcp__dailytickers__RunScreener
Parameters: {
  "dsl": "Close > BB_Upper(20,2) AND Volume > SMA_Volume(20) * 2 AND ATR(14)/Close < 0.05",
  "universe": "US_ALL"
}

// European equities
Tool: mcp__dailytickers__RunScreener
Parameters: {
  "symbols": ["VGK","EWG","EWQ","EWU","SAP","ASML","BBVA","TTE","SIE","LVMHF"],
  "dsl": "RSI(14) < 40 OR (Close > SMA(20) AND ADX(14) > 20)"
}

// Asia-Pacific
Tool: mcp__dailytickers__RunScreener
Parameters: {
  "symbols": ["EWJ","EWY","EWH","FXI","MCHI"],
  "dsl": "RSI(14) < 40 OR (Close > SMA(20) AND ADX(14) > 20)"
}

// Thematic ETFs
Tool: mcp__dailytickers__RunScreener
Parameters: {
  "symbols": ["XLF","XLE","XLK","XLV","XLI","GLD","SLV","TLT","ARKK","ICLN"],
  "dsl": "RSI(14) < 35 OR (Close > SMA(20) AND Volume > SMA_Volume(20) * 1.3)"
}

Tool: mcp__dailytickers__QueryData
Parameters: {
  "symbols": ["AAPL", "NVDA", "TSLA", ...],  // top 30 candidates
  "types": [
    "quote",                    // Current price, volume, change
    "bars_daily",               // 90 days OHLCV
    "insider_transactions",     // Last 90 days insider buys/sells
    "sentiment_overall",        // Aggregated sentiment score
    "trading_signals",          // Technical signal summary
    "support_resistance",       // Key S/R levels
    "volume_profile",           // Volume at price distribution
    "stats",                    // Beta, avg volume, 52w range
    "analyst_actions",          // Recent upgrades/downgrades
    "financials",               // Latest quarterly financials
    "earnings_quarterly"        // EPS history and surprises
  ]
}

For each candidate:
  1. Technical Score
     - Count aligned signals from trading_signals + support_resistance
     - Check multi-timeframe confirmation (daily vs weekly)
     - Score: (aligned_signals / 8) * 100, with bonuses for rare confluences

  2. Fundamental Score
     - Extract EPS trend from earnings_quarterly
     - Check insider_transactions for net buying
     - Compare valuation metrics to sector medians from financials
     - Score: weighted aggregate of sub-scores

  3. Social Score
     - Parse sentiment_overall for bullish/bearish ratio
     - Check if sentiment is rising but below "euphoria" threshold
     - Score: alignment * magnitude * freshness

  4. Sector Score
     - Compare sector ETF performance vs SPY (5d, 20d)
     - Check if sector is in the "leading" list from regime analysis
     - Score: relative_strength * 100, capped at 100

  5. Macro Score
     - Is the setup type compatible with current regime?
     - Long momentum in Risk-On? Score = 95
     - Long momentum in Risk-Off? Score = 20 (auto-fail)
     - Score: compatibility * regime_confidence * 100

  6. AI Conviction
     - Synthesize all data points holistically
     - Check for red flags: upcoming earnings, FDA, FOMC
     - Estimate R:R from entry to S/R levels
     - Score: subjective assessment 0-100

  Composite = sum(weight_i * score_i) for i in dimensions
  Pass = composite >= 85 AND all individual scores >= threshold

Tool: mcp__dailytickers__LLMAnalysis
Parameters: {
  "query": "Rank these 20 setups by conviction. For each, provide:
    1. Conviction level (high/medium/low)
    2. Primary risk factor
    3. Optimal entry strategy (limit at support vs market)
    4. Position sizing suggestion (% of portfolio)
    Setups: [detailed data for each candidate]"
}

for each selected_setup:
  spot_price = QueryData(symbols=[setup.ticker], types=["quote"]).price
  entry_price = setup.entry_zone_midpoint

  deviation = abs(spot_price - entry_price) / spot_price
  if deviation > 0.10:
    REJECT setup  # Entry price too far from reality
    log("P0 FAIL: {ticker} spot={spot_price} entry={entry_price} dev={deviation}")

# Index the new report
node tools/add_card.js scanner/20260305/index.html

# Commit and push
git add scanner/20260305/ data/scanner.json data/search_data.js
git commit -m "feat: scanner 20260305 — Risk-On, 10 setups A+"
git push origin main

{
  "embeds": [{
    "title": "A++ SETUP: NVDA — Momentum Continuation",
    "color": 1089337,  // #10a569 (green)
    "fields": [
      { "name": "Entry Zone", "value": "$875 - $882", "inline": true },
      { "name": "Stop Loss", "value": "$848 (-3.5%)", "inline": true },
      { "name": "TP1 / TP2", "value": "$920 / $965", "inline": true },
      { "name": "R:R", "value": "2.4 : 1", "inline": true },
      { "name": "Score", "value": "91/100 (A++)", "inline": true },
      { "name": "Regime", "value": "Risk-On (82%)", "inline": true },
      { "name": "Thesis", "value": "Pullback to rising 21 EMA with volume contraction. 5 of 8 technical signals aligned. Insider buying $4.2M in last 30 days. AI datacenter capex cycle intact." },
      { "name": "Confirmations", "value": "1. Hold above $870 on daily close\n2. Volume expansion on next green day\n3. SOX index holds 5,200\n4. No VIX spike above 18" },
      { "name": "Invalidations", "value": "1. Daily close below $848 (stop)\n2. Sector rotation out of XLK\n3. Macro regime shift to Risk-Off\n4. Earnings pre-announcement" }
    ],
    "footer": {
      "text": "Full report: articles.dailytickers.com/scanner/20260305/"
    }
  }]
}

Tool: mcp__market-alerts__create_alert
Parameters: {
  "symbol": "NVDA",
  "condition": "price_between",
  "value": [875, 882],
  "message": "NVDA entering A++ entry zone ($875-$882). Scanner score: 91/100.",
  "channel": "#scanner-alerts",
  "expires": "2026-03-12T23:59:59Z"  // 7 day expiry
}

Pipeline Timing Summary

Project Setup

Let us get your environment set up. By the end of this section, you will have Claude Code installed, all three MCP servers configured, and you will run your first test scan. We will build the full pipeline in subsequent parts, but this foundation must be solid.

Prerequisites

You need the following installed before proceeding:

• Node.js 22+ — Required for Claude Code and MCP servers. Install via nvm install 22 or from nodejs.org.
• Git 2.43+ — Version control and GitHub Pages deployment. Install via your package manager.
• GitHub CLI (gh) — For checking deployment status. Install via brew install gh (macOS) or apt install gh (Linux).
• tmux — Terminal multiplexer for persistent sessions. Install via brew install tmux (macOS) or apt install tmux (Linux).
• An Anthropic API key — Sign up at console.anthropic.com. You need access to Claude Opus or Sonnet models.

Step 1: Install Claude Code

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version
# Expected: claude-code 1.0.x

# Authenticate (interactive — follow browser prompts)
claude auth login

# Test basic functionality
claude -p "What is 2 + 2?"
# Expected: "4" (or a more verbose response ending with 4)

Claude Code stores its configuration in ~/.claude/. The key files are:

• ~/.claude/config.json — Global settings (model, theme, permissions)
• ~/.claude/CLAUDE.md — Global system instructions (applied to all projects)
• ~/.claude/projects/ — Per-project memory files

Step 2: Configure MCP Servers

MCP servers are configured in ~/.claude/claude_desktop_config.json. This file tells Claude Code which MCP servers to connect to and how to start them. Here is the full configuration for our 3-server setup:

{
  "mcpServers": {
    "dailytickers": {
      "command": "node",
      "args": [
        "/path/to/dailytickers-mcp/dist/index.js"
      ],
      "env": {
        "MW_API_KEY": "your-dailytickers-api-key",
        "MW_BASE_URL": "https://api.dailytickers.com",
        "MW_CACHE_TTL": "60",
        "MW_MAX_CONCURRENT": "10",
        "MW_TIMEOUT": "30000"
      },
      "disabled": false
    },
    "market-alerts": {
      "command": "node",
      "args": [
        "/path/to/market-alerts-mcp/dist/index.js"
      ],
      "env": {
        "ALERTS_DB_PATH": "/path/to/alerts.db",
        "ALERTS_CHECK_INTERVAL": "60000",
        "DISCORD_WEBHOOK_URL": "https://discord.com/api/webhooks/xxx/yyy"
      },
      "disabled": false
    },
    "discord": {
      "command": "node",
      "args": [
        "/path/to/discord-mcp/dist/index.js"
      ],
      "env": {
        "DISCORD_TOKEN": "your-discord-bot-token",
        "DISCORD_DEFAULT_CHANNEL": "scanner-alerts",
        "DISCORD_GUILD_ID": "your-guild-id"
      },
      "disabled": false
    }
  }
}

Step 3: Configure the DailyTickers MCP Server

The DailyTickers MCP server is the data backbone of the pipeline. It exposes 58 data types through a unified QueryData interface. Here is how to set it up:

# Clone the MCP server
git clone https://github.com/dailytickers-xyz/dailytickers-mcp.git
cd dailytickers-mcp

# Install dependencies
npm install

# Build
npm run build

# Test the server locally (stdio mode)
echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node dist/index.js

# Expected: JSON response listing all available tools
# - GetMarketOverview
# - QueryData
# - RunAutoScreener
# - RunScreener
# - GetInstruments
# - LLMAnalysis
# - CalculateOptionsGreeks
# - AnalyzeOptionsStrategy
# - ... (20+ tools total)

The server configuration is controlled via environment variables. Here are the key ones:

Step 4: Set Up the Project Repository

Create the directory structure for your automated trading reports:

# Create the project
mkdir -p automated-trading-reports
cd automated-trading-reports
git init

# Create the directory structure
mkdir -p scanner/{retrospective}
mkdir -p daily
mkdir -p weekly
mkdir -p analyses
mkdir -p data
mkdir -p assets
mkdir -p tools

# Create the CNAME for GitHub Pages
echo "your-domain.xyz" > CNAME

# Initialize the data files
echo "[]" > data/scanner.json
echo "[]" > data/daily.json
echo "[]" > data/weekly.json
echo "[]" > data/analyses.json
echo "var searchData = [];" > data/search_data.js

Step 5: Create the CLAUDE.md System Prompt

The CLAUDE.md file is the brain of the operation. It contains all the instructions that Claude Code follows during automated runs. Here is a minimal skeleton to get started — the full version we use in production is 400+ lines:

# CLAUDE.md - Automated Trading Pipeline

## Project Overview
Automated trading research pipeline using Claude Code + MCP.
Publishes scanner reports, daily briefings, and ticker analyses.

## MCP Gateway
Available tools:
- `mcp__dailytickers__GetMarketOverview` — Full market snapshot
- `mcp__dailytickers__QueryData` — 58 data types
- `mcp__dailytickers__RunAutoScreener` — Regime-aware screening
- `mcp__dailytickers__RunScreener` — Custom DSL screening
- `mcp__dailytickers__GetInstruments` — Deep symbol analysis
- `mcp__dailytickers__LLMAnalysis` — DeepSeek second opinion

## Scanner Command ("scan du jour")

### Step 1: Read Retrospectives
Read ALL files in `scanner/retrospective/*/index.html`.
Extract: hit rates, flop tickers, strategy adjustments.

### Step 2: Read Previous Scan
Read the most recent `scanner/YYYYMMDD/index.html`.
Extract the 10 tickers for anti-doublon filter (70% new minimum).

### Step 3: Regime Detection
Call `RunAutoScreener` to detect market regime.
Regimes: Risk-On, Early Risk-On, Neutral, Transition,
         Early Risk-Off, Risk-Off.

### Step 4: Multi-Strategy Screening
Run 3 DSL strategies:
1. Oversold: RSI(14) < 35 AND SMA(50) > SMA(200) AND Volume spike
2. Momentum: Close > SMA(20) > SMA(50) AND RSI 55-75 AND ADX > 25
3. Breakout: Close > BB_Upper AND Volume > 2x average

Additional screens: EU (VGK, SAP, ASML...), APAC (EWJ, FXI...),
ETFs (XLF, GLD, TLT, ARKK...).

### Step 5: Scoring (6 Layers)
For top 30 candidates, score across:
1. Technical confluence (>= 4 signals)
2. Fundamental quality (>= 80/100)
3. Social sentiment (aligned with direction)
4. Sector trend (outperforming SPY)
5. Macro regime (compatible)
6. AI conviction (>= 85%)

Composite >= 85 = A+. Top 3 with >= 90 = A++.

### Step 6: Output
- Create `scanner/YYYYMMDD/index.html` (> 40KB)
- Run `node tools/add_card.js scanner/YYYYMMDD/index.html`
- Git add, commit, push
- Send top 3 A++ to Discord

### Constraints
- Geographic diversity: min 5 US + 2 EU + 1 APAC + 2 ETF
- Risk-Off: min 20% defensive setups
- Anti-doublon: min 70% new tickers vs previous scan
- P0 control: reject if entry price > 10% from spot

Step 6: First Test Run

With everything configured, let us run a minimal test to verify the pipeline works end-to-end:

# Navigate to your project directory
cd /path/to/automated-trading-reports

# Run a simple market overview query
claude -p "Call GetMarketOverview and summarize the current market regime in 3 sentences."

# Expected output: Something like:
# "The current market regime is Risk-On with 78% confidence.
#  VIX is at 15.3 and declining, with market breadth at 65%
#  above the 200-day SMA. Leading sectors are Technology and
#  Consumer Discretionary."

If this works, your MCP Gateway is correctly configured. Now test a more complex query:

# Test QueryData with multiple data types
claude -p "Query the following data for AAPL and NVDA: quote, trading_signals, support_resistance. \
For each ticker, tell me: current price, RSI(14), nearest support level, nearest resistance level, \
and whether you would consider it a buy, sell, or hold based purely on technicals."

If both tests pass, your data layer is operational. The next test is the full scanner — but we will build that properly in Parts 2-5 of this series.

Step 7: Configure the Discord Bot (Optional)

For automated scheduling, you need a Discord bot that can invoke Claude Code on a timer. Here is the minimal setup:

# Clone the Discord bot
git clone https://github.com/dailytickers-xyz/claude-discord-bot.git
cd claude-discord-bot

# Install dependencies
npm install

# Configure
cp .env.example .env
# Edit .env with your Discord bot token and channel IDs

{
  "schedules": [
    {
      "id": 1,
      "name": "Scanner Quotidien",
      "cron": "0 23 * * 1-5",
      "command": "cd /path/to/automated-trading-reports && claude -p 'scan du jour'",
      "channel": "scanner-alerts",
      "enabled": true,
      "description": "Nightly scanner — weekdays at 23:00"
    },
    {
      "id": 2,
      "name": "Daily Briefing",
      "cron": "0 7 * * *",
      "command": "cd /path/to/automated-trading-reports && claude -p 'analyse daily'",
      "channel": "daily-briefing",
      "enabled": true,
      "description": "Morning briefing — every day at 07:00"
    },
    {
      "id": 3,
      "name": "Weekly Report",
      "cron": "0 18 * * 0",
      "command": "cd /path/to/automated-trading-reports && claude -p 'nouvelle analyse weekly'",
      "channel": "weekly-reports",
      "enabled": true,
      "description": "Weekly market report — Sundays at 18:00"
    },
    {
      "id": 4,
      "name": "Scanner Retrospective",
      "cron": "0 23 * * 5",
      "command": "cd /path/to/automated-trading-reports && claude -p 'rétrospective scanner'",
      "channel": "scanner-alerts",
      "enabled": true,
      "description": "Weekly scanner review — Fridays at 23:00"
    }
  ]
}

# Start the Discord bot
npm start

# Or in a tmux session for persistence
tmux new-session -d -s discord-bot "cd /path/to/claude-discord-bot && npm start"

# Test: In Discord, type:
# > run #1
# This will manually trigger the Scanner task

Troubleshooting Common Setup Issues

Environment Verification Checklist

Run through this checklist before proceeding to Part 2:

# 1. Claude Code installed and authenticated
claude --version          # Should show 1.0.x
claude -p "hello"         # Should respond

# 2. MCP servers configured
claude -p "List all available MCP tools that contain 'market'"
# Should list: GetMarketOverview, QueryData, RunScreener, etc.

# 3. Market data accessible
claude -p "Call GetMarketOverview and tell me the current VIX level"
# Should return a VIX value (e.g., "VIX is at 14.8")

# 4. Git configured
git status                # Should show clean working tree
git remote -v             # Should show your GitHub remote

# 5. GitHub Pages deployed
gh api repos/{owner}/{repo}/pages
# Should show: "status": "built"

# 6. Directory structure correct
ls scanner/ daily/ weekly/ analyses/ data/ assets/ tools/
# All directories should exist

# 7. CLAUDE.md present
wc -l CLAUDE.md
# Should show 100+ lines (ideally 400+)

If all 7 checks pass, your environment is ready. You have the foundation for a fully automated trading research pipeline.

What's Next

In this first part, we established the vision, architecture, and foundation of the automated trading pipeline. You now understand:

• What we are building and why it is fundamentally different from traditional screening tools
• The 4-layer architecture: Trigger, Data (MCP), Analysis (Claude Code), Delivery (Discord + GitHub)
• The complete tech stack and why each component was chosen
• The 6-dimensional scoring model that separates A++ setups from noise
• The step-by-step daily pipeline flow from cron trigger to Discord delivery
• How to set up your environment with Claude Code, MCP servers, and the project structure

The Series Roadmap

Before You Move On

Make sure you have completed the following before starting Part 2:

1. Claude Code installed and authenticated (claude --version works)
2. MCP Gateway server configured and accessible (the GetMarketOverview test passes)
3. Project repository created with the correct directory structure
4. A starter CLAUDE.md in the project root
5. GitHub Pages configured for your repository

Part 2 will be deeply technical — we will explore every one of the 58 data types available through the MCP Gateway, learn how to compose complex queries, build real-time market regime detection, and understand the caching architecture that makes 50+ API calls per scan feasible. It is the data plumbing that makes everything else possible.

claude -p "Call RunAutoScreener to detect the current market regime. \
Then call RunScreener with this DSL: \
'RSI(14) < 35 AND SMA(50) > SMA(200) AND Volume > SMA_Volume(20) * 1.5' \
For the top 5 results, call QueryData with types quote,trading_signals. \
For each ticker, provide: name, price, RSI, and whether you think it is \
a genuine oversold reversal or a falling knife. Explain your reasoning."