charieswei
/
TradingAgents
mirror of https://github.com/TauricResearch/TradingAgents.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2 from Aitous/feature/discovery-enhancements 

Feature/discovery enhancements
This commit is contained in:
Aitous 2026-02-11 22:12:06 -08:00 committed by GitHub
parent 2376fc74a1 f4aceef857
commit 9442de7868
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
168 changed files with 33742 additions and 4181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
.devcontainer/devcontainer.json Normal file
View File

@ -0,0 +1,33 @@
{
"name": "Python 3",
// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
"image": "mcr.microsoft.com/devcontainers/python:1-3.11-bookworm",
"customizations": {
"codespaces": {
"openFiles": [
"README.md",
"tradingagents/ui/dashboard.py"
]
},
"vscode": {
"settings": {},
"extensions": [
"ms-python.python",
"ms-python.vscode-pylance"
]
}
},
"updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
"postAttachCommand": {
"server": "streamlit run tradingagents/ui/dashboard.py --server.enableCORS false --server.enableXsrfProtection false"
},
"portsAttributes": {
"8501": {
"label": "Application",
"onAutoForward": "openPreview"
}
},
"forwardPorts": [
8501
]
}

11
.env.example
View File

@ -6,3 +6,14 @@ TWITTER_API_SECRET=your_twitter_api_secret
TWITTER_ACCESS_TOKEN=your_twitter_access_token
TWITTER_ACCESS_TOKEN_SECRET=your_twitter_access_token_secret
TWITTER_BEARER_TOKEN=your_twitter_bearer_token
# New Discovery Data Sources (Phase 1)
# Tradier API - Options Activity Detection (Free sandbox tier available)
# Get your API key at: https://developer.tradier.com/getting_started
TRADIER_API_KEY=your_tradier_api_key_here
TRADIER_BASE_URL=https://sandbox.tradier.com
# Financial Modeling Prep API - Short Interest & Analyst Data
# Free tier available, Premium recommended ($15/month)
# Get your API key at: https://financialmodelingprep.com/developer/docs
FMP_API_KEY=your_fmp_api_key_here

37
.githooks/pre-commit Executable file
View File

@ -0,0 +1,37 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(git rev-parse --show-toplevel)"
cd "$ROOT_DIR"
echo "Running pre-commit checks..."
# Run black formatter (auto-fix)
if python - <<'PY'
import importlib.util
raise SystemExit(0 if importlib.util.find_spec("black") else 1)
PY
then
echo "🎨 Running black formatter..."
python -m black tradingagents/ cli/ scripts/ --quiet
else
echo "⚠️ black not installed; skipping formatting."
fi
# Run ruff linter (auto-fix, but don't fail on warnings)
if python - <<'PY'
import importlib.util
raise SystemExit(0 if importlib.util.find_spec("ruff") else 1)
PY
then
echo "🔍 Running ruff linter..."
python -m ruff check tradingagents/ cli/ scripts/ --fix --exit-zero
else
echo "⚠️ ruff not installed; skipping linting."
fi
# CRITICAL: Check for syntax errors (this will fail the commit)
echo "🐍 Checking for syntax errors..."
python -m compileall -q tradingagents cli scripts
echo "✅ Pre-commit checks passed!"

120
.github/workflows/daily-discovery.yml vendored Normal file
View File

@ -0,0 +1,120 @@
name: Daily Discovery
on:
schedule:
# 8:30 AM ET (13:30 UTC) on weekdays
- cron: "30 13 * * 1-5"
workflow_dispatch:
# Manual trigger with optional overrides
inputs:
date:
description: "Analysis date (YYYY-MM-DD, blank = today)"
required: false
default: ""
provider:
description: "LLM provider"
required: false
default: "google"
type: choice
options:
- google
- openai
- anthropic
env:
PYTHON_VERSION: "3.10"
jobs:
discovery:
runs-on: ubuntu-latest
environment: TradingAgent
timeout-minutes: 30
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: ${{ env.PYTHON_VERSION }}
cache: pip
- name: Install dependencies
run: |
pip install --upgrade pip
pip install -e .
- name: Determine analysis date
id: date
run: |
if [ -n "${{ github.event.inputs.date }}" ]; then
echo "analysis_date=${{ github.event.inputs.date }}" >> "$GITHUB_OUTPUT"
else
echo "analysis_date=$(date -u +%Y-%m-%d)" >> "$GITHUB_OUTPUT"
fi
- name: Run discovery pipeline
env:
# LLM keys (set whichever provider you use)
GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
# Data source keys
FINNHUB_API_KEY: ${{ secrets.FINNHUB_API_KEY }}
ALPHA_VANTAGE_API_KEY: ${{ secrets.ALPHA_VANTAGE_API_KEY }}
FMP_API_KEY: ${{ secrets.FMP_API_KEY }}
REDDIT_CLIENT_ID: ${{ secrets.REDDIT_CLIENT_ID }}
REDDIT_CLIENT_SECRET: ${{ secrets.REDDIT_CLIENT_SECRET }}
TRADIER_API_KEY: ${{ secrets.TRADIER_API_KEY }}
run: |
python scripts/run_daily_discovery.py \
--date "${{ steps.date.outputs.analysis_date }}" \
--no-update-positions
- name: Commit recommendations to repo
run: |
git config user.name "github-actions[bot]"
git config user.email "github-actions[bot]@users.noreply.github.com"
# Stage new/updated recommendation files
git add data/recommendations/ || true
git add results/ || true
# Only commit if there are changes
if git diff --cached --quiet; then
echo "No new recommendations to commit"
else
git commit -m "chore: daily discovery ${{ steps.date.outputs.analysis_date }}"
git push
fi
- name: Update positions
if: success()
env:
FINNHUB_API_KEY: ${{ secrets.FINNHUB_API_KEY }}
run: |
python scripts/update_positions.py
- name: Commit position updates
if: success()
run: |
git config user.name "github-actions[bot]"
git config user.email "github-actions[bot]@users.noreply.github.com"
git add data/recommendations/ || true
if git diff --cached --quiet; then
echo "No position updates"
else
git commit -m "chore: update positions ${{ steps.date.outputs.analysis_date }}"
git push
fi
- name: Upload results as artifact
if: always()
uses: actions/upload-artifact@v4
with:
name: discovery-${{ steps.date.outputs.analysis_date }}
path: |
data/recommendations/${{ steps.date.outputs.analysis_date }}*.json
results/discovery/${{ steps.date.outputs.analysis_date }}/
retention-days: 30

2
.gitignore vendored
View File

@ -9,3 +9,5 @@ eval_results/
eval_data/
*.egg-info/
.env
memory_db/
.worktrees/

7
.streamlit/config.toml Normal file
View File

@ -0,0 +1,7 @@
[theme]
base = "dark"
primaryColor = "#22c55e"
backgroundColor = "#0a0e17"
secondaryBackgroundColor = "#111827"
textColor = "#e2e8f0"
font = "monospace"

166
CONCURRENT_EXECUTION.md Normal file
View File

@ -0,0 +1,166 @@
# Concurrent Scanner Execution
## Overview
Implemented concurrent scanner execution using Python's `ThreadPoolExecutor` to improve discovery pipeline performance by 25-30%.
## Performance Results
```
Concurrent (8 workers): 42-43 seconds
Sequential (1 worker): 54-56 seconds
Improvement: 25-30% faster ⚡
```
## Configuration
Add to your config or use defaults in `default_config.py`:
```python
"scanner_execution": {
"concurrent": True, # Enable parallel execution
"max_workers": 8, # Max concurrent scanner threads
"timeout_seconds": 30, # Per-scanner timeout
}
```
## How It Works
### Thread Pool Execution
1. **Scanner Preparation**: All enabled scanners are instantiated and validated
2. **Concurrent Dispatch**: Scanners submitted to ThreadPoolExecutor
3. **State Isolation**: Each scanner gets a copy of state (thread-safe)
4. **Result Collection**: Candidates collected as scanners complete
5. **Log Merging**: Tool logs merged back into main state
### Timeout Handling
```python
# Per-scanner timeout (not global timeout)
for future in as_completed(future_to_scanner):
try:
result = future.result(timeout=timeout_seconds)
# Process result
except TimeoutError:
# Scanner timed out, continue with others
logger.warning(f"Scanner {name} timed out")
```
**Key insight**: Using per-scanner timeout instead of global timeout means slow scanners don't block the entire batch.
### Error Isolation
```python
def run_scanner(scanner_info):
try:
candidates = scanner.scan_with_validation(state_copy)
return (name, pipeline, candidates, None)
except Exception as e:
# Return error, don't raise
return (name, pipeline, [], str(e))
```
**Key insight**: Each scanner runs in isolation. One failure doesn't stop others.
## Why ThreadPoolExecutor?
### I/O-Bound Operations
Scanners spend most time waiting for:
- API responses (Reddit, Finnhub, Alpha Vantage)
- Network requests (news, fundamentals)
- Database queries
CPU time is minimal compared to I/O waits.
### GIL Not a Problem
Python's Global Interpreter Lock (GIL) doesn't affect I/O-bound code because:
1. Threads release GIL during I/O operations
2. Multiple threads can wait on I/O concurrently
3. Only one thread executes Python bytecode at a time (but that's fast)
### State Management
```python
# Thread-safe pattern
scanner_state = state.copy() # Each thread gets copy
scanner.scan(scanner_state) # No race conditions
# Merge results after completion
state["tool_logs"].extend(scanner_state["tool_logs"])
```
**Key insight**: Copying state dict is cheap (<1ms) compared to API latency (5-10s).
## Testing
Run comprehensive tests:
```bash
# Full test suite
python tests/test_concurrent_scanners.py
# Quick verification
python verify_concurrent_execution.py
```
Test coverage:
- ✅ Concurrent execution works
- ✅ Sequential fallback when disabled
- ✅ Timeout handling (graceful degradation)
- ✅ Error isolation (one failure doesn't stop others)
- ✅ Same candidates found in both modes
## Disabling Concurrent Execution
Set `concurrent: False` to revert to sequential execution:
```python
config["discovery"]["scanner_execution"]["concurrent"] = False
```
Useful for:
- Debugging individual scanners
- Environments with limited resources
- Rate limit testing
## Performance Tips
1. **Optimal Worker Count**: 8 workers balances parallelism with resource usage
- Too few: Underutilized (scanners wait in queue)
- Too many: Thread overhead, potential rate limiting
2. **Timeout Configuration**: 30s per scanner is reasonable
- Too short: Legitimate slow scanners timeout
- Too long: Keeps slow scanners running unnecessarily
3. **Enable for Production**: Always use concurrent mode unless debugging
## Monitoring
Concurrent execution logs scanner completion:
```
Running 8 scanners concurrently (max 8 workers)...
✓ market_movers: 10 candidates
✓ insider_buying: 20 candidates
⏱️ slow_scanner: timeout after 30s
⚠️ broken_scanner: HTTP 500 error
✓ volume_accumulation: 2 candidates
```
## Next Steps
Remaining performance optimizations:
1. **Rate Limiting**: Add exponential backoff for API calls
2. **TTL Caching**: Time-based cache for expensive operations
3. **Circuit Breaker**: Auto-disable consistently failing scanners
## Implementation Files
- `tradingagents/default_config.py` - Configuration
- `tradingagents/graph/discovery_graph.py` - Execution logic
- `tests/test_concurrent_scanners.py` - Test suite
- `verify_concurrent_execution.py` - Quick verification

583
cli/main.py
View File

File diff suppressed because it is too large Load Diff

2
cli/models.py
View File

@ -1,6 +1,4 @@
from enum import Enum
from typing import List, Optional, Dict
from pydantic import BaseModel
class AnalystType(str, Enum):

82
cli/utils.py
View File

@ -1,7 +1,11 @@
from typing import List
import questionary
from typing import List, Optional, Tuple, Dict
from cli.models import AnalystType
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
ANALYST_ORDER = [
("Market Analyst", AnalystType.MARKET),
@ -68,9 +72,7 @@ def select_analysts() -> List[AnalystType]:
"""Select analysts using an interactive checkbox."""
choices = questionary.checkbox(
"Select Your [Analysts Team]:",
choices=[
questionary.Choice(display, value=value) for display, value in ANALYST_ORDER
],
choices=[questionary.Choice(display, value=value) for display, value in ANALYST_ORDER],
instruction="\n- Press Space to select/unselect analysts\n- Press 'a' to select/unselect all\n- Press Enter when done",
validate=lambda x: len(x) > 0 or "You must select at least one analyst.",
style=questionary.Style(
@ -102,9 +104,7 @@ def select_research_depth() -> int:
choice = questionary.select(
"Select Your [Research Depth]:",
choices=[
questionary.Choice(display, value=value) for display, value in DEPTH_OPTIONS
],
choices=[questionary.Choice(display, value=value) for display, value in DEPTH_OPTIONS],
instruction="\n- Use arrow keys to navigate\n- Press Enter to select",
style=questionary.Style(
[
@ -128,34 +128,51 @@ def select_shallow_thinking_agent(provider) -> str:
# Define shallow thinking llm engine options with their corresponding model names
SHALLOW_AGENT_OPTIONS = {
"openai": [
("GPT-5 - Latest OpenAI flagship model", "gpt-5"),
("GPT-4o-mini - Fast and efficient for quick tasks", "gpt-4o-mini"),
("GPT-4.1-nano - Ultra-lightweight model for basic operations", "gpt-4.1-nano"),
("GPT-4.1-mini - Compact model with good performance", "gpt-4.1-mini"),
("GPT-4o - Standard model with solid capabilities", "gpt-4o"),
],
"anthropic": [
("Claude Haiku 3.5 - Fast inference and standard capabilities", "claude-3-5-haiku-latest"),
(
"Claude Haiku 3.5 - Fast inference and standard capabilities",
"claude-3-5-haiku-latest",
),
("Claude Sonnet 3.5 - Highly capable standard model", "claude-3-5-sonnet-latest"),
("Claude Sonnet 3.7 - Exceptional hybrid reasoning and agentic capabilities", "claude-3-7-sonnet-latest"),
(
"Claude Sonnet 3.7 - Exceptional hybrid reasoning and agentic capabilities",
"claude-3-7-sonnet-latest",
),
("Claude Sonnet 4 - High performance and excellent reasoning", "claude-sonnet-4-0"),
],
"google": [
("Gemini 2.0 Flash-Lite - Cost efficiency and low latency", "gemini-2.0-flash-lite"),
("Gemini 2.0 Flash - Next generation features, speed, and thinking", "gemini-2.0-flash"),
(
"Gemini 2.0 Flash - Next generation features, speed, and thinking",
"gemini-2.0-flash",
),
("Gemini 2.5 Flash-Lite - Ultra-fast and cost-effective", "gemini-2.5-flash-lite"),
("Gemini 2.5 Flash - Adaptive thinking, cost efficiency", "gemini-2.5-flash"),
("Gemini 2.5 Pro - Most capable Gemini model", "gemini-2.5-pro"),
("Gemini 3.0 Pro Preview - Next generation preview", "gemini-3-pro-preview"),
("Gemini 3.0 Flash Preview - Latest generation preview", "gemini-3-flash-preview"),
],
"openrouter": [
("Meta: Llama 4 Scout", "meta-llama/llama-4-scout:free"),
("Meta: Llama 3.3 8B Instruct - A lightweight and ultra-fast variant of Llama 3.3 70B", "meta-llama/llama-3.3-8b-instruct:free"),
("google/gemini-2.0-flash-exp:free - Gemini Flash 2.0 offers a significantly faster time to first token", "google/gemini-2.0-flash-exp:free"),
(
"Meta: Llama 3.3 8B Instruct - A lightweight and ultra-fast variant of Llama 3.3 70B",
"meta-llama/llama-3.3-8b-instruct:free",
),
(
"google/gemini-2.0-flash-exp:free - Gemini Flash 2.0 offers a significantly faster time to first token",
"google/gemini-2.0-flash-exp:free",
),
],
"ollama": [
("llama3.1 local", "llama3.1"),
("llama3.2 local", "llama3.2"),
]
],
}
choice = questionary.select(
@ -175,9 +192,7 @@ def select_shallow_thinking_agent(provider) -> str:
).ask()
if choice is None:
console.print(
"\n[red]No shallow thinking llm engine selected. Exiting...[/red]"
)
console.print("\n[red]No shallow thinking llm engine selected. Exiting...[/red]")
exit(1)
return choice
@ -189,6 +204,7 @@ def select_deep_thinking_agent(provider) -> str:
# Define deep thinking llm engine options with their corresponding model names
DEEP_AGENT_OPTIONS = {
"openai": [
("GPT-5 - Latest OpenAI flagship model", "gpt-5"),
("GPT-4.1-nano - Ultra-lightweight model for basic operations", "gpt-4.1-nano"),
("GPT-4.1-mini - Compact model with good performance", "gpt-4.1-mini"),
("GPT-4o - Standard model with solid capabilities", "gpt-4o"),
@ -198,28 +214,44 @@ def select_deep_thinking_agent(provider) -> str:
("o1 - Premier reasoning and problem-solving model", "o1"),
],
"anthropic": [
("Claude Haiku 3.5 - Fast inference and standard capabilities", "claude-3-5-haiku-latest"),
(
"Claude Haiku 3.5 - Fast inference and standard capabilities",
"claude-3-5-haiku-latest",
),
("Claude Sonnet 3.5 - Highly capable standard model", "claude-3-5-sonnet-latest"),
("Claude Sonnet 3.7 - Exceptional hybrid reasoning and agentic capabilities", "claude-3-7-sonnet-latest"),
(
"Claude Sonnet 3.7 - Exceptional hybrid reasoning and agentic capabilities",
"claude-3-7-sonnet-latest",
),
("Claude Sonnet 4 - High performance and excellent reasoning", "claude-sonnet-4-0"),
("Claude Opus 4 - Most powerful Anthropic model", " claude-opus-4-0"),
],
"google": [
("Gemini 2.0 Flash-Lite - Cost efficiency and low latency", "gemini-2.0-flash-lite"),
("Gemini 2.0 Flash - Next generation features, speed, and thinking", "gemini-2.0-flash"),
(
"Gemini 2.0 Flash - Next generation features, speed, and thinking",
"gemini-2.0-flash",
),
("Gemini 2.5 Flash-Lite - Ultra-fast and cost-effective", "gemini-2.5-flash-lite"),
("Gemini 2.5 Flash - Adaptive thinking, cost efficiency", "gemini-2.5-flash"),
("Gemini 2.5 Pro - Most capable Gemini model", "gemini-2.5-pro"),
("Gemini 3.0 Pro Preview - Next generation preview", "gemini-3-pro-preview"),
("Gemini 3.0 Flash Preview - Latest generation preview", "gemini-3-flash-preview"),
],
"openrouter": [
("DeepSeek V3 - a 685B-parameter, mixture-of-experts model", "deepseek/deepseek-chat-v3-0324:free"),
("Deepseek - latest iteration of the flagship chat model family from the DeepSeek team.", "deepseek/deepseek-chat-v3-0324:free"),
(
"DeepSeek V3 - a 685B-parameter, mixture-of-experts model",
"deepseek/deepseek-chat-v3-0324:free",
),
(
"Deepseek - latest iteration of the flagship chat model family from the DeepSeek team.",
"deepseek/deepseek-chat-v3-0324:free",
),
],
"ollama": [
("llama3.1 local", "llama3.1"),
("qwen3", "qwen3"),
]
],
}
choice = questionary.select(
@ -244,6 +276,7 @@ def select_deep_thinking_agent(provider) -> str:
return choice
def select_llm_provider() -> tuple[str, str]:
"""Select the OpenAI api url using interactive selection."""
# Define OpenAI api options with their corresponding endpoints
@ -258,8 +291,7 @@ def select_llm_provider() -> tuple[str, str]:
choice = questionary.select(
"Select your LLM Provider:",
choices=[
questionary.Choice(display, value=(display, value))
for display, value in BASE_URLS
questionary.Choice(display, value=(display, value)) for display, value in BASE_URLS
],
instruction="\n- Use arrow keys to navigate\n- Press Enter to select",
style=questionary.Style(
@ -276,6 +308,6 @@ def select_llm_provider() -> tuple[str, str]:
exit(1)
display_name, url = choice
print(f"You selected: {display_name}\tURL: {url}")
logger.info(f"You selected: {display_name}\tURL: {url}")
return display_name, url

116
data/recommendations/2026-01-25.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-25",
"llm_provider": "google",
"recommendations": [
{
"ticker": "META",
"rank": 1,
"strategy_match": "Momentum/Hype",
"final_score": 9.4,
"confidence": 8,
"reason": "META shows strong momentum driven by AI strategy optimism, global Threads ads rollout, and a new AI lab. Jefferies raised its price target to $910, reflecting undervaluation and AI progress. Technicals are bullish with a MACD crossover and price above the 20 EMA, along with rising OBV and institutional buying (VWAP). Options flow is highly bullish, with unusual call activity at $880, $835, and $1000 strikes for the Jan 30 expiry. Upcoming earnings on Jan 28 could be a significant catalyst. However, significant insider selling ($25M+) is a notable red flag. Actionable insight: Consider a long position targeting $700-720 post-earnings, with a stop-loss at $630 to manage risk from insider selling and potential earnings volatility.",
"entry_price": 658.760009765625,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "APLD",
"rank": 2,
"strategy_match": "Momentum/Hype / Short Squeeze",
"final_score": 8.8,
"confidence": 8,
"reason": "APLD presents a compelling momentum and short squeeze opportunity. The company announced groundbreaking for Delta Forge 1, a 430MW AI data center, causing a 10% stock surge. Fundamentals show extremely strong quarterly revenue growth (250% YOY), despite negative EPS. Technicals are robust with a strong uptrend, price above all key moving averages, and a bullish MACD crossover. Short interest is extremely high at 29.7% of float, making it ripe for a squeeze. Options activity shows extremely bullish call volume and unusual call activity at several high strikes. Insider selling ($17M+) and bearish OBV divergence are notable risks. Actionable insight: Monitor for continued upward momentum, targeting $40-45, with a tight stop at $34 due to high volatility and insider selling.",
"entry_price": 37.689998626708984,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "FCX",
"rank": 3,
"strategy_match": "Momentum/Hype",
"final_score": 8.5,
"confidence": 8,
"reason": "Freeport-McMoRan (FCX) exhibits strong momentum driven by positive news and robust technicals. The stock surged following a strong Q3 2025 earnings beat, reaching a 52-week high. Analyst upgrades from HSBC ($69 target) and Wall Street Zen confirm a positive outlook, citing strong copper demand. Technical indicators show a strong uptrend, with price significantly above 50 and 200 SMAs, high RSI, and rising OBV. Unusual call activity at $69, $75, $63, and $60 strikes suggests bullish institutional positioning. Insider selling ($1.8M+) is a minor concern, but overall sentiment is bullish. Actionable insight: Look for entry on minor pullbacks towards $58-59, targeting a breakout above the 52-week high of $62.13 towards the $65-69 analyst targets, with a stop-loss at $56.",
"entry_price": 60.40999984741211,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "ANAB",
"rank": 4,
"strategy_match": "Momentum/Hype / Short Squeeze",
"final_score": 8.0,
"confidence": 8,
"reason": "AnaptysBio (ANAB) shows strong potential for a short squeeze combined with momentum. Barclays recently upgraded its price target to $78 with an 'Overweight' rating, indicating significant upside. The stock is in a strong uptrend, trading above its 50 and 200 SMAs with rising OBV. Crucially, short interest is extremely high at 35.25% of the float, and options open interest is very bullish (P/C OI ratio 0.015), suggesting institutional long positioning. While quarterly revenue growth is very strong (1.543 YOY), the company has negative EPS and ongoing insider selling ($6.7M+). Actionable insight: This is a high-risk, high-reward short squeeze play. Consider a long entry on strength above $48, targeting $55-60, with a stop-loss at $44 to mitigate fundamental and insider-selling risks.",
"entry_price": 47.540000915527344,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "ABCB",
"rank": 5,
"strategy_match": "Momentum/Hype",
"final_score": 8.0,
"confidence": 7,
"reason": "Ameris Bancorp (ABCB) displays strong momentum, reaching a new 52-week high of $82.33. The company announced a $200M share repurchase program, signaling confidence and commitment to shareholder value. Technically, ABCB is in a strong uptrend, with price well above its 50 and 200 SMAs and rising OBV. Options activity, despite low volume, shows bullish sentiment with a low Put/Call Volume Ratio (0.333) and Open Interest Ratio (0.228). Fundamentals are solid with a low P/E (13.94) and moderate revenue/earnings growth. Upcoming Q4 earnings on Jan 29 could provide further catalysts. Actionable insight: Monitor for a breakout above the 52-week high ($83.64), targeting $85-90, with a stop-loss at $78.50, anticipating positive earnings sentiment and continued buybacks.",
"entry_price": 80.44000244140625,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "SAIC",
"rank": 6,
"strategy_match": "Insider Play",
"final_score": 6.9,
"confidence": 7,
"reason": "Science Applications International Corp. (SAIC) shows a strong insider buying signal, with 5 purchases totaling over $336K, including a $200K purchase by the CFO. This insider confidence aligns with a significant $1.4B U.S. Air Force contract win, a key positive catalyst. Technically, the stock is in an uptrend, trading above its 50 and 200 SMAs with rising OBV, despite a recent bearish MACD crossover. Options open interest is bullish (P/C OI 0.683), although volume is bearish. Fundamentals show a low P/E (14.08), but revenue and earnings growth have been weak. High debt (Debt/Equity 175.0) is a risk. Actionable insight: Consider a long position on dips toward $108-109, targeting the analyst target of $117.56, with a stop-loss at $104, capitalizing on insider confidence and the new contract.",
"entry_price": 110.13999938964844,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "PYPL",
"rank": 7,
"strategy_match": "Contrarian Value",
"final_score": 6.7,
"confidence": 7,
"reason": "PayPal (PYPL) presents a contrarian value opportunity, trading near its 52-week low ($55.015) after a significant YTD decline in 2025. Fundamentals are attractive with a low P/E (11.37) and Forward P/E (9.84), and strong quarterly earnings growth (31.3% YOY). Strategic initiatives like the Google partnership and a $15B buyback program provide potential long-term tailwinds. Technicals show a bullish MACD crossover and bullish OBV divergence (accumulation), suggesting a potential reversal despite a strong downtrend. Options volume is bullish, with unusual call activity at various strikes. However, significant insider selling ($2.4M+) and negative price action are concerns. Actionable insight: Consider accumulating shares on dips towards $55, targeting a recovery to $65-70, with a stop-loss at $53, ahead of earnings in two weeks.",
"entry_price": 56.619998931884766,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "ORRF",
"rank": 8,
"strategy_match": "Contrarian Value",
"final_score": 6.4,
"confidence": 6,
"reason": "Orrstown Financial Services (ORRF) offers a potential contrarian value play, having recently experienced a 2% drop that analysts suggest could be a low-risk entry. Fundamentals are strong with a low P/E (9.21), good Price/Book (1.23), and strong quarterly revenue growth (26.9% YOY). The company also has a decent dividend yield (2.98%) with a history of growth. Technically, ORRF is in a strong uptrend, trading above its 50 and 200 SMAs, with bullish OBV divergence. Insider buying, though minimal ($10K+ by one director), adds a slight positive signal ahead of Q4 earnings on Jan 27. Options activity is too sparse to draw strong conclusions. Actionable insight: A long position could be considered on strength above $36.50, targeting $39-41, with a stop-loss at $34.50, betting on a positive earnings surprise and fundamental undervaluation.",
"entry_price": 36.20000076293945,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "NWBI",
"rank": 9,
"strategy_match": "Insider Play",
"final_score": 5.7,
"confidence": 6,
"reason": "Northwest Bancshares (NWBI) shows bullish insider activity with 6 purchases totaling over $131K, including a $48K purchase by a Director. This insider confidence aligns with attractive valuation metrics like a low P/E (14.36) and Price/Book ratio (<1), along with a high dividend yield (6.41%). Technically, NWBI is in a strong uptrend, having experienced a Golden Cross, and trades above its 50 and 200 SMAs with rising OBV. Upcoming Q4 earnings on Jan 26 are anticipated to show positive EPS and revenue growth. However, options flow is bearish (P/C Volume 2.426, OI 3.04), and quarterly earnings growth has been very weak (-92.3% YOY). Actionable insight: Monitor closely post-earnings. If results are positive, consider a long entry above $12.50, targeting $13.50-14, with a stop-loss at $11.80, acknowledging the conflicting options signals.",
"entry_price": 12.489999771118164,
"discovery_date": "2026-01-25",
"status": "open"
},
{
"ticker": "BGS",
"rank": 10,
"strategy_match": "Momentum/Hype / Short Squeeze",
"final_score": 5.6,
"confidence": 7,
"reason": "B&G Foods (BGS) presents a high-risk, high-reward opportunity due to extremely high short interest (26.63% of float) and a recent positive acquisition catalyst. The acquisition of Del Monte's broth/stock division is expected to enhance EPS and EBITDA. Technicals show a strong uptrend, with price above its 50 and 200 SMAs, and bullish MACD and Stochastic crossovers. Options open interest is bullish (P/C OI 0.485). However, fundamentals are very weak with negative EPS, negative profit margin, and extremely high debt (Debt/Equity 440.24). Analyst consensus is 'Sell,' and there is insider selling ($84K+). The OBV shows bearish divergence, indicating distribution. Actionable insight: This is a speculative short squeeze play. Consider a small, highly risk-managed long position on strength above $4.50, targeting $5.00-5.50, with a tight stop-loss at $4.10 due to significant fundamental risks and bearish technical divergence.",
"entry_price": 4.409999847412109,
"discovery_date": "2026-01-25",
"status": "open"
}
]
}

116
data/recommendations/2026-01-26.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-26",
"llm_provider": "google",
"recommendations": [
{
"ticker": "GME",
"rank": 1,
"strategy_match": "Insider Play",
"final_score": 11.5,
"confidence": 9,
"reason": "Highest conviction setup. CEO Ryan Cohen purchased $21.3M worth of stock on Jan 21, coupled with director buying. This aligns with store closure efficiency news. Options flow is flashing an extreme bullish signal with a Put/Call ratio of 0.11 (heavy call skew), suggesting institutional positioning for a move higher. Technicals show RSI at 64 with price holding above 200 SMA.",
"entry_price": 24.010000228881836,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "BKR",
"rank": 2,
"strategy_match": "Momentum",
"final_score": 11.0,
"confidence": 9,
"reason": "Fresh breakout to 52-week highs following a Q4 earnings beat ($0.78 vs $0.67 est). Technicals confirm a 'Upper Bollinger Band Walk,' indicating strong momentum. Options activity is incredibly bullish with a P/C ratio of 0.209, confirming the post-earnings drift thesis. Analysts maintain a $56+ target, which price is now testing.",
"entry_price": 56.290000915527344,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "VIAV",
"rank": 3,
"strategy_match": "Momentum",
"final_score": 10.0,
"confidence": 8,
"reason": "Stock hit 52-week high ($19.78) ahead of Jan 28 earnings. B. Riley raised PT to $22. Options flow is heavily skewed bullish with a P/C volume ratio of just 0.12, suggesting smart money is positioning for a beat or raised guidance. Technical trend is strong (Price > 20/50/200 SMAs).",
"entry_price": 19.920000076293945,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "APLD",
"rank": 4,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 8,
"reason": "Recent groundbreaking on 430MW AI data center and analyst upgrade to 'Strong Buy'. Options volume shows P/C ratio of 0.495, confirming bullish sentiment. Technicals show an 8.5% daily jump and price significantly above moving averages. Note: High volatility (ATR $3.26) requires wider stops.",
"entry_price": 36.18000030517578,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "AMZN",
"rank": 5,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 9,
"reason": "Multiple analyst upgrades (Wells Fargo PT $301, Roth PT $295) citing AWS acceleration. Layoff news typically viewed as margin-positive by Wall Street. Options flow confirms the bullish thesis with a P/C ratio of 0.449. Price is consolidating near highs, setting up for a potential breakout toward $250.",
"entry_price": 238.4199981689453,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "DDOG",
"rank": 6,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 8,
"reason": "Technical breakout featuring a Golden Cross and bullish engulfing pattern. Stifel upgraded to Buy with $160 target. Options flow supports the move with a low P/C ratio of 0.30. The 9.3% 5-day change indicates strong accumulation ahead of earnings.",
"entry_price": 136.63999938964844,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "SLV",
"rank": 7,
"strategy_match": "Momentum",
"final_score": 9.0,
"confidence": 7,
"reason": "Strong social momentum (Reddit threads regarding tariffs and inflation hedging) and breakout to new highs. Driven by tariff threats against Canada/Korea. Caution advised as RSI is 76 (Overbought), but the trend is undeniably strong. Options flow is neutral/mixed, suggesting some profit-taking at these levels.",
"entry_price": 98.33999633789062,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "NVDA",
"rank": 8,
"strategy_match": "Momentum",
"final_score": 9.0,
"confidence": 8,
"reason": "Approval to sell H20 chips in China removes a major overhang, outweighing the 15% revenue share fee. Options flow is bullish (P/C 0.63). Insider selling is a slight drag, but the catalyst is strong enough to drive near-term momentum. Support at $180 holds.",
"entry_price": 186.47000122070312,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "DHR",
"rank": 9,
"strategy_match": "Momentum",
"final_score": 9.0,
"confidence": 8,
"reason": "Goldman Sachs and Wells Fargo raised price targets ($270/$240). While price dipped slightly recently (-2%), the options flow is aggressively bullish with a P/C ratio of 0.175, indicating institutional accumulation during the dip.",
"entry_price": 236.7100067138672,
"discovery_date": "2026-01-26",
"status": "open"
},
{
"ticker": "STLD",
"rank": 10,
"strategy_match": "Contrarian Value",
"final_score": 8.5,
"confidence": 7,
"reason": "Despite lowered guidance for Q4, the stock is up 4.4% in 5 days with strong technicals (Bullish MACD). Options traders are betting on a beat or looking past Q4 weakness, evidenced by a bullish P/C ratio of 0.43. Strong backlog supports 2026 outlook.",
"entry_price": 173.32000732421875,
"discovery_date": "2026-01-26",
"status": "open"
}
]
}

116
data/recommendations/2026-01-27.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-27",
"llm_provider": "google",
"recommendations": [
{
"ticker": "META",
"rank": 1,
"strategy_match": "Momentum",
"final_score": 9.2,
"confidence": 9,
"reason": "Strong momentum driven by an aggressive AI strategy, positive analyst upgrades (Jefferies target $910), and significant social media buzz around earnings (Jan 28) and new monetization efforts (premium subscriptions, Threads ads). Technicals show a clear bullish trend, breaking out from a recent low, with price above key moving averages and bullish MACD crossover. Bullish options volume (P/C 0.56) confirms positive sentiment. Entry around $660-670, stop below $640 (50-SMA). Anticipate post-earnings volatility.",
"entry_price": 672.969970703125,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "GLW",
"rank": 2,
"strategy_match": "Momentum",
"final_score": 7.8,
"confidence": 8,
"reason": "Major positive catalyst with a new $6 billion Meta order for AI data centers, leading to a 16% stock surge. Technicals show a strong uptrend with all key moving averages confirming bullish momentum and price near 52-week highs ($113.99). Unusual options activity shows significant bullish institutional interest for near-term calls ($115, $111 strikes expiring Jan 30). Entry on a dip to $105-107, stop below $96.64 (recent high, also upper Bollinger Band).",
"entry_price": 109.73999786376953,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "SLV",
"rank": 3,
"strategy_match": "Momentum",
"final_score": 7.7,
"confidence": 8,
"reason": "Driven by strong silver prices (surged >150%) due to supply deficits and industrial demand, with SLV posting a 208% annual return and hitting a 52-week high. Technicals show a very strong uptrend with price far above all key moving averages. Options activity shows a recent large-volume call spread, confirming bullish momentum. However, the ETF is significantly overbought (RSI 79.4, Stochastic), and some Reddit sentiment indicates bearish bets, posing a risk of a pullback. Entry on a dip to $92-95 (near 23.6% Fib support) with a stop below $88.",
"entry_price": 101.58999633789062,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "FFIV",
"rank": 4,
"strategy_match": "Momentum",
"final_score": 6.9,
"confidence": 7,
"reason": "Strong earnings beat and positive guidance, coupled with an analyst upgrade by JPMorgan to 'Overweight' with a $345 target. Technicals show a short-term bullish trend (price above 50-SMA $253.73, rising OBV, price above 20-EMA $263.91 and VWAP). Bullish options flow confirms positive sentiment (P/C 0.479). However, significant insider selling ($8.4M) is a red flag. Entry on pullback to $265-268 (near 20-EMA/VWAP), with a stop below $253 (50-SMA).",
"entry_price": 270.42999267578125,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "TRX",
"rank": 5,
"strategy_match": "Momentum",
"final_score": 6.6,
"confidence": 8,
"reason": "Extremely strong momentum driven by record Q1 revenue ($25.12M, doubled YoY), 100% unhedged gold exposure benefiting from rising gold prices, and a massive surge in call option volume (5,352% increase). Technicals show a parabolic uptrend, but the stock is significantly overbought (RSI 79.8, 141% above upper Bollinger band), suggesting a potential pullback. Entry on pullback to $1.25-1.30 (near 23.6% Fib support) with a stop below $1.20 (upper Bollinger band).",
"entry_price": 1.5199999809265137,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "TXN",
"rank": 6,
"strategy_match": "Momentum",
"final_score": 6.0,
"confidence": 7,
"reason": "Strong technical uptrend with price above all key moving averages (50-SMA $177.28, 200-SMA $181.35, 20-EMA $188.06, VWAP $188.03), strong ADX (44.5), and bullish RSI/MACD. Positive news regarding a 16-year forecast. Bullish options volume (P/C 0.635). However, significant insider selling ($1.7M) and mixed analyst target adjustments (Susquehanna lowered, Barclays raised) introduce caution. Entry around $190-192 (near 20-EMA) with a stop below $185 (support below 23.6% Fib).",
"entry_price": 196.6300048828125,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "KLAC",
"rank": 7,
"strategy_match": "Momentum",
"final_score": 5.8,
"confidence": 7,
"reason": "Strong technical uptrend, outperforming the market, with price well above key moving averages (50-SMA $1276.50, 200-SMA $1103.85) and positive RSI (67.2). Strong fundamentals with solid revenue (13.0% YoY) and earnings growth (20.8% YoY). Upcoming earnings expected to be positive. However, substantial insider selling ($15.7M, including $12.9M by CEO) and neutral options activity are cautionary signals. Entry on pullback to $1450-1480 (near 23.6% Fib support) with a stop below $1400 (20-EMA).",
"entry_price": 1616.3299560546875,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "KKR",
"rank": 8,
"strategy_match": "Contrarian Value",
"final_score": 5.8,
"confidence": 6,
"reason": "Strong fundamentals with good revenue (13.2% YoY) and earnings growth (40.6% YoY). Technicals show the stock is oversold (RSI 33.2) and at the lower Bollinger band, indicating a potential bounce. However, the overall trend is a strong downtrend, and bearish options volume (P/C 1.704) contradicts a bullish reversal play. The Nestle news is not a direct catalyst for KKR's stock price. Entry on confirmation of bounce from $112-115 support, stop below $110.",
"entry_price": 116.0,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "HOLO",
"rank": 9,
"strategy_match": "Contrarian Value",
"final_score": 5.3,
"confidence": 6,
"reason": "The core thesis is deep undervaluation (P/B 0.1, trading at 10% of NAV based on liquid assets). Technicals show it's at the lower Bollinger band with bullish OBV divergence, suggesting a potential bounce from oversold conditions. However, there's no insider or options data to confirm sentiment, and the stock exhibits high volatility and a weak overall trend (ADX 7.6). This is a speculative value play. Entry near $2.57 (52-week low/Fib support) with a stop below $2.50.",
"entry_price": 2.75,
"discovery_date": "2026-01-27",
"status": "open"
},
{
"ticker": "VYMI",
"rank": 10,
"strategy_match": "Momentum",
"final_score": 5.2,
"confidence": 6,
"reason": "Strong technical uptrend, outperforming VXUS, and a high dividend yield (369%) make it attractive for income-focused investors in a 'risk-on' international rotation. However, it's significantly overbought (RSI 76.9, Stochastic) and at the upper Bollinger band, suggesting a potential pullback. Institutional activity is mixed (some buying, some selling). Entry on a pullback to $91-92 (near 20-EMA) with a stop below $89 (50-SMA).",
"entry_price": 95.98999786376953,
"discovery_date": "2026-01-27",
"status": "open"
}
]
}

116
data/recommendations/2026-01-28.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-28",
"llm_provider": "google",
"recommendations": [
{
"ticker": "HYMC",
"rank": 1,
"strategy_match": "Insider Play",
"final_score": 10.5,
"confidence": 9,
"reason": "Exceptional insider strength with 10% owner Eric Sprott purchasing an aggregate of $84.9M over 3 months, including $5M on Jan 28. High-grade silver intercepts at the Nevada mine serve as a massive fundamental catalyst. Technicals show a very strong uptrend (ADX 67.9) with price 151% above the 50-SMA. Strategy: Momentum trade with entry at $51.50, targeting $60 resistance, with a tight stop at $47.50 (1.5x ATR).",
"entry_price": 51.689998626708984,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "META",
"rank": 2,
"strategy_match": "Momentum",
"final_score": 10.3,
"confidence": 10,
"reason": "Q4 earnings beat with $59.89B revenue and aggressive 2026 guidance. Social sentiment is highly positive following AI spend updates. MACD bullish crossover confirmed on Jan 28. Options flow is decisively bullish with a volume P/C ratio of 0.588 and unusual call activity at the $785 Jan 30 strikes (9.06x Vol/OI). Strategy: Buy on current strength targeting $710 (Fib high), stop at $645.",
"entry_price": 668.72998046875,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "MIRM",
"rank": 3,
"strategy_match": "Insider Play",
"final_score": 10.0,
"confidence": 9,
"reason": "Following the Bluejay Therapeutics acquisition, Director Heron Patrick bought $8.9M in stock. Analysts (HC Wainwright) raised the target to $130 (28% upside). Technicals are in a strong uptrend with price above 20 EMA and a RSI of 77.5 indicating high demand. Strategy: Entry at $100.85, targeting $130, with a stop at $93.40 (1.5x ATR).",
"entry_price": 100.8499984741211,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "LRCX",
"rank": 4,
"strategy_match": "Momentum",
"final_score": 9.6,
"confidence": 9,
"reason": "Fiscal Q2 revenue of $5.34B with record operating margins driven by AI data center demand. Bullish MACD crossover on Jan 28 and technical breakout above the 50-SMA (+33.4% position). Analyst sentiment is 73.7% bullish. Strategy: Ride semiconductor equipment tailwinds toward $265 target, stop loss at $223.",
"entry_price": 239.5800018310547,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "AMAT",
"rank": 5,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 8,
"reason": "Upgraded by Mizuho and Deutsche Bank on accelerating wafer equipment spending. Technicals show a strong uptrend with a Golden Cross (50-SMA crossing 200-SMA) and MACD bullish crossover. Options volume P/C ratio is 0.698, confirming call-side dominance. Strategy: Enter on pullbacks to $330, targeting $360 resistance, stop at $315.",
"entry_price": 336.75,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "WDC",
"rank": 6,
"strategy_match": "Momentum",
"final_score": 9.3,
"confidence": 8,
"reason": "AI-driven memory shortage is improving margins, pushing shares to all-time highs. RSI 73.1 indicates overbought conditions but strong ADX (57.8) suggests trend persistence. Options activity shows massive unusual call volume at $285 Feb 6 strikes (220x OI). Strategy: Momentum play targeting $300 ahead of earnings, stop loss at $231.",
"entry_price": 279.70001220703125,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "WRB",
"rank": 7,
"strategy_match": "Insider Play",
"final_score": 9.2,
"confidence": 9,
"reason": "Mitsui Sumitomo Insurance (10% owner) has purchased an aggregate of $413.5M in the last 3 months, including $69M recently. Q4 results beat revenue forecasts. While technicals are in a downtrend, the sheer scale of insider accumulation suggests a fundamental floor. Strategy: Value-entry at $67.67, targeting $78 (52-week high), stop at $64.50.",
"entry_price": 67.66999816894531,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "VIAV",
"rank": 8,
"strategy_match": "Momentum",
"final_score": 8.3,
"confidence": 8,
"reason": "Earnings reported at the high end of guidance with an upbeat Q3 outlook. Technicals show a strong uptrend and price 11.4% above VWAP. Options flow is highly bullish with a volume P/C ratio of 0.071 and heavy call volume at $24 Feb strikes (16.8x OI). Strategy: Entry at $21, target $24, stop at $19.47.",
"entry_price": 21.030000686645508,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "VSAT",
"rank": 9,
"strategy_match": "Momentum",
"final_score": 8.3,
"confidence": 8,
"reason": "Needham Buy rating and $45 target based on Viasat-3 satellite deployment which will triple global capacity. Strong technical uptrend (price +41% from 200-SMA). Unusual options activity at $42 Feb 20 calls (17.7x Vol/OI). Strategy: Ride breakout above 52-week high toward $55, stop at $41.",
"entry_price": 47.58000183105469,
"discovery_date": "2026-01-28",
"status": "open"
},
{
"ticker": "INTC",
"rank": 10,
"strategy_match": "Momentum",
"final_score": 8.2,
"confidence": 7,
"reason": "Shares jumped 11% on reports of Apple/Nvidia foundry interest for 2028. CFO David Zinsner purchased $250k in stock at $42.50 to signal a dip-buy opportunity. Bullish options positioning (OI P/C 0.688) confirms market confidence in the pivot. Strategy: Long position at $48.78, target $54.60, stop at $43.70.",
"entry_price": 48.779998779296875,
"discovery_date": "2026-01-28",
"status": "open"
}
]
}

116
data/recommendations/2026-01-29.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-29",
"llm_provider": "google",
"recommendations": [
{
"ticker": "APLD",
"rank": 1,
"strategy_match": "Momentum",
"final_score": 10.5,
"confidence": 9,
"reason": "Extreme growth profile with 250% revenue growth YoY. Nvidia's $2B investment in anchor tenant CoreWeave effectively de-risks the Ellendale campus project. Technicals show a strong uptrend above 50 SMA with a bullish MACD crossover. Options activity is highly favorable with a Put/Call volume ratio of 0.325, indicating institutional accumulation. Strategy: Enter on pullbacks to $36.78 support with a target of $45.",
"entry_price": 38.06999969482422,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "AAPL",
"rank": 2,
"strategy_match": "Momentum",
"final_score": 10.4,
"confidence": 9,
"reason": "Reported record Q1 revenue of $143.8B with a bullish MACD crossover indicating shifting momentum. Acquisition rumors of AI startup Q.ai provide a catalyst for Siri enhancement. Options flow is bullish with a P/C ratio of 0.63 and strong institutional positioning. Strategy: Bullish breakout play toward $287 analyst target; stop-loss at $248.",
"entry_price": 258.2799987792969,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "UA",
"rank": 3,
"strategy_match": "Insider Play",
"final_score": 10.2,
"confidence": 8,
"reason": "Significant insider buying from V. Prem Watsa ($16.4M) and a total of over $90M in purchases this quarter shows extreme conviction. ADX of 62 indicates an incredibly strong trend. Options P/C ratio of 0.117 confirms bullish sentiment. Strategy: Follow insider lead for a move back toward $7.76 high; entry at $5.90, stop at $5.35.",
"entry_price": 5.929999828338623,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "MCHP",
"rank": 4,
"strategy_match": "Momentum",
"final_score": 10.0,
"confidence": 8,
"reason": "Fresh analyst upgrade from Investing.com paired with a confirmed Golden Cross (50 SMA crossing 200 SMA). Company launched new 3-nm switches for AI data centers. Put/Call ratio of 0.13 is exceptionally bullish. RSI is overbought (73.4), suggesting a brief consolidation before the Feb 5 earnings. Strategy: Long position at $78-80 range targeting $95.",
"entry_price": 79.36000061035156,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "INTC",
"rank": 5,
"strategy_match": "Momentum",
"final_score": 9.8,
"confidence": 8,
"reason": "Recent 11% jump on rumors of 2028 foundry partnerships with Apple and Nvidia. Bullish insider activity from the CFO ($250k purchase) signals manufacturing confidence. Options flow confirms the bias with a P/C ratio of 0.655. Strategy: Momentum trade toward $54 resistance; tight stop at $44.03 (ATR based).",
"entry_price": 48.65999984741211,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "USAR",
"rank": 6,
"strategy_match": "Momentum",
"final_score": 9.6,
"confidence": 8,
"reason": "Closing of $1.5B PIPE and CHIPS program LOI ($1.6B) provide multi-year funding runway for rare earth production. Technicals show very strong trend strength (ADX 55.5). Options P/C ratio of 0.382 indicates heavy call buying. Strategy: Target $37.20 analyst consensus with trailing stop under the 20 EMA ($20.08).",
"entry_price": 22.06999969482422,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "LTRX",
"rank": 7,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 7,
"reason": "Announced high-impact AI drone partnership for defense. Extremely low Put/Call ratio (0.024) suggests speculative call buying ahead of Feb 5 earnings. Technicals show a strong uptrend above all major EMAs. Strategy: Speculative earnings play targeting $9.00; stop-loss at 50 SMA ($5.79).",
"entry_price": 6.800000190734863,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "KLAC",
"rank": 8,
"strategy_match": "Momentum",
"final_score": 9.1,
"confidence": 8,
"reason": "Crushed Q2 estimates with 17% growth driven by AI packaging demand. Strong guidance issued for the next quarter. Strong uptrend verified by OBV and VWAP. RSI is high (72.5), but momentum is supported by yielding management dominance. Strategy: Buy on confirmation of support at $1620; target $1800.",
"entry_price": 1684.7099609375,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "AMD",
"rank": 9,
"strategy_match": "Momentum",
"final_score": 9.0,
"confidence": 8,
"reason": "Upgraded ahead of earnings due to MI308 chip demand and AI accelerator licenses. ADX of 39.6 indicates a solid trend. Options OI shows bullish long-term positioning. Insider selling is a minor concern (-0.1 modifier offset). Strategy: Play the earnings run-up to $267 resistance; stop at $237.",
"entry_price": 252.17999267578125,
"discovery_date": "2026-01-29",
"status": "open"
},
{
"ticker": "THM",
"rank": 10,
"strategy_match": "Insider Play",
"final_score": 8.5,
"confidence": 7,
"reason": "Paulson & Co. increased stake via a $40M purchase in a recent $115M financing round. Technicals show an extreme move (+26% in 5 days) and RSI is overbought (78.6). High institutional support (53.8%) provides floor. Strategy: Wait for mean reversion toward $2.55 (VWAP) before entering; target $3.65.",
"entry_price": 2.990000009536743,
"discovery_date": "2026-01-29",
"status": "open"
}
]
}

116
data/recommendations/2026-01-30.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-30",
"llm_provider": "google",
"recommendations": [
{
"ticker": "META",
"rank": 1,
"strategy_match": "Momentum",
"final_score": 11.0,
"confidence": 9,
"reason": "Explosive Q4 earnings beat ($8.88 EPS vs expected) paired with a massive $6B AI infrastructure deal with Corning. Technicals show a bullish MACD crossover and a strong break above the 200-SMA. Options flow is highly supportive with a Volume P/C ratio of 0.548 and unusual activity at the $717.50 strike. Target $790 with a stop at $705.",
"entry_price": 718.7100219726562,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "INOD",
"rank": 2,
"strategy_match": "Momentum",
"final_score": 10.3,
"confidence": 8,
"reason": "Strategic partnership with Palantir Technologies for AI training data is a transformational catalyst. Technical indicators show a bullish stochastic crossover and price action holding above the 20 EMA. Options volume is heavily skewed toward calls (P/C 0.305) with high IV suggesting a volatility squeeze. Target $75 near-term with a tight stop at $56.",
"entry_price": 56.5,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "USAR",
"rank": 3,
"strategy_match": "Insider Play",
"final_score": 9.8,
"confidence": 8,
"reason": "Chairman Michael Blitzer purchased $2.14M in shares directly following a $1.6B LOI for federal funding under the CHIPS Act. While volatile, the ADX of 49.2 indicates a very strong trend developing. Options volume P/C ratio of 0.342 confirms bullish sentiment. Entry near $22.50, targeting $35, stop at $17.50.",
"entry_price": 22.950000762939453,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "CSCO",
"rank": 4,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 9,
"reason": "Upgraded to a $100 price target by Evercore ISI on the back of a new AI-driven networking hardware refresh cycle. Bullish MACD crossover confirmed on January 30. Options positioning is significantly bullish with a P/C volume ratio of 0.431 and heavy interest in $79 calls. Target $85-90 with a stop at $75.",
"entry_price": 78.58000183105469,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "ALGM",
"rank": 5,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 8,
"reason": "Reported record data center sales and strong automotive growth. TD Cowen raised target to $45. Despite an overbought RSI of 76.6, the ADX of 47 suggests trend durability. Extremely bullish options flow with a 0.116 volume P/C ratio confirms institutional accumulation. Target $44, stop at $35.",
"entry_price": 37.064998626708984,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "NVDA",
"rank": 6,
"strategy_match": "Momentum",
"final_score": 9.5,
"confidence": 9,
"reason": "Strong sector sentiment following record earnings from peers and a fresh bullish MACD crossover. Price remains above the 50 and 200 SMA. Options volume P/C ratio of 0.617 remains bullish with high open interest supporting a move toward $210 resistance. Entry near $192, stop at $180.",
"entry_price": 192.41000366210938,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "UA",
"rank": 7,
"strategy_match": "Insider Play",
"final_score": 9.5,
"confidence": 8,
"reason": "Prem Watsa (Fairfax) significantly increased his position by $16.4M in January. The stock shows a very strong trend (ADX 56.2) and is trading above the 20, 50, and 200 EMA. This turnaround play is gaining momentum ahead of February results. Target $7.50, stop at $5.30.",
"entry_price": 5.989999771118164,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "WS",
"rank": 8,
"strategy_match": "Momentum",
"final_score": 9.0,
"confidence": 7,
"reason": "Director Scott Kelly bought $273k in shares as the company integrates its $2.4B Kl\u00f6ckner acquisition. Bullish MACD crossover and price above 20 EMA signal continued upside. Volume divergence suggests accumulation. Target $47 based on analyst targets, stop at $37.",
"entry_price": 39.91999816894531,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "WDC",
"rank": 9,
"strategy_match": "Momentum",
"final_score": 8.7,
"confidence": 8,
"reason": "Q2 earnings beat driven by booming AI storage demand. Despite a 9.8% pullback today, technicals remain in a strong uptrend above the 50 SMA. Bullish volume P/C ratio of 0.53 suggests the dip is being bought by institutional traders. Target recovery to $280, stop at $220.",
"entry_price": 248.30999755859375,
"discovery_date": "2026-01-30",
"status": "open"
},
{
"ticker": "AVGO",
"rank": 10,
"strategy_match": "Contrarian Value",
"final_score": 8.5,
"confidence": 8,
"reason": "Upgraded by Wells Fargo as a core AI infrastructure provider. While the technical trend is currently weak, the options volume P/C ratio of 0.572 shows heavy institutional call buying at near-term strikes ($335-$342). Target recovery to $370, stop at $310.",
"entry_price": 331.6199951171875,
"discovery_date": "2026-01-30",
"status": "open"
}
]
}

116
data/recommendations/2026-01-31.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-01-31",
"llm_provider": "google",
"recommendations": [
{
"ticker": "ACRV",
"rank": 1,
"strategy_match": "short_squeeze",
"final_score": 95,
"confidence": 8,
"reason": "Extreme short interest of 63% combined with positive Phase 2b clinical trial results creates a massive asymmetric risk/reward. The recent technical correction to the $1.79 level presents a prime entry point for a violent short-covering rally triggered by any positive volume catalyst.",
"entry_price": 1.7899999618530273,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "CHTR",
"rank": 2,
"strategy_match": "early_accumulation",
"final_score": 92,
"confidence": 9,
"reason": "Strong Q4 EPS beat and aggressive mobile line growth have triggered an institutional accumulation phase. Technicals show a fresh bullish MACD crossover and a clean break above the 50-day SMA, indicating a sustained momentum move over the next week.",
"entry_price": 206.1199951171875,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "LTRX",
"rank": 3,
"strategy_match": "pre_earnings_accumulation",
"final_score": 89,
"confidence": 9,
"reason": "Strong pre-earnings accumulation with volume at 2.63x average ahead of its Feb 4 report. The strategic partnership with Safe Pro Group for AI-powered defense drones positions the company within a high-growth sector, supported by a 90% bullish analyst consensus.",
"entry_price": 6.639999866485596,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "FN",
"rank": 4,
"strategy_match": "earnings_play",
"final_score": 87,
"confidence": 8,
"reason": "As a key manufacturing partner for Nvidia's optical packaging, Fabrinet is seeing significant price target increases ($540-$600) ahead of its Feb 2 earnings. Technicals show a strong uptrend above all major moving averages and a rising VWAP indicating institutional support.",
"entry_price": 489.44000244140625,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "RMBS",
"rank": 5,
"strategy_match": "earnings_play",
"final_score": 85,
"confidence": 8,
"reason": "Institutional buyers like Mirae Asset are aggressively building positions ahead of the Feb 2 earnings. The company is a direct beneficiary of the AI-driven demand for high bandwidth memory, and the current pullback from recent highs offers a high-probability entry for an earnings gap-up.",
"entry_price": 113.83000183105469,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "PLTR",
"rank": 6,
"strategy_match": "earnings_play",
"final_score": 83,
"confidence": 7,
"reason": "Technically oversold (RSI 25.3) and trading at the lower Bollinger Band, Palantir is primed for a significant mean-reversion bounce ahead of its Feb 2 earnings. Massive open interest in calls suggests speculative traders are betting on an AI-driven revenue surprise.",
"entry_price": 146.58999633789062,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "MRVL",
"rank": 7,
"strategy_match": "analyst_upgrade",
"final_score": 81,
"confidence": 8,
"reason": "FTC approval for the Celestial AI acquisition is a major fundamental catalyst that hasn't been priced in due to recent market volatility. Analyst price targets remain significantly higher at $117, suggesting a 48% upside from current levels as order visibility for custom silicon improves.",
"entry_price": 78.91999816894531,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "YSS",
"rank": 8,
"strategy_match": "ipo_opportunity",
"final_score": 79,
"confidence": 7,
"reason": "This fresh IPO is a prime 'discovery' play in the defense-tech space, supported by a $642 million backlog and an upsized offering. Space-infrastructure assets are seeing high demand as national security priorities shift toward satellite constellations.",
"entry_price": 33.95000076293945,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "AMZN",
"rank": 9,
"strategy_match": "analyst_upgrade",
"final_score": 77,
"confidence": 9,
"reason": "Recent layoffs and a 'cultural reset' toward AI efficiency are highly favored by institutional investors. With 95% bullish analyst sentiment and a price target of $296, the stock is positioned as a safe-haven growth play during broader market uncertainty.",
"entry_price": 239.3000030517578,
"discovery_date": "2026-01-31",
"status": "open"
},
{
"ticker": "SNDK",
"rank": 10,
"strategy_match": "social_hype",
"final_score": 75,
"confidence": 6,
"reason": "Blowout earnings and a global NAND flash shortage are driving violent momentum in this low-float name. Despite overbought technicals, momentum-chasing strategies typically favor such high-velocity moves until a stock split or secondary offering is announced.",
"entry_price": 576.25,
"discovery_date": "2026-01-31",
"status": "open"
}
]
}

116
data/recommendations/2026-02-01.json Normal file
View File

@ -0,0 +1,116 @@
{
"date": "2026-02-01",
"llm_provider": "google",
"recommendations": [
{
"ticker": "ACRV",
"rank": 1,
"strategy_match": "Insider Play",
"final_score": 95,
"confidence": 9,
"reason": "The CEO purchased 49,000 shares in mid-January, which, combined with an extremely high short interest of 63.0%, creates a textbook short squeeze setup. Upcoming Phase 2b data presentations provide a near-term fundamental catalyst to potentially ignite this volatility.",
"entry_price": 1.7899999618530273,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "RTX",
"rank": 2,
"strategy_match": "Earnings Play",
"final_score": 92,
"confidence": 9,
"reason": "RTX reports earnings on Feb 2, supported by a record $251 billion backlog and positive 2026 guidance. The stock is in a strong uptrend, trading above its 20 and 50-day moving averages, with recent news resolving liability concerns.",
"entry_price": 200.92999267578125,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "IBM",
"rank": 3,
"strategy_match": "Momentum",
"final_score": 90,
"confidence": 9,
"reason": "Shares are breaking out near decade-highs driven by a generative AI book of business exceeding $12.5 billion. Technical indicators show a bullish MACD crossover and strong trend strength (ADX rising), signaling continued momentum.",
"entry_price": 306.70001220703125,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "GME",
"rank": 4,
"strategy_match": "Insider Play",
"final_score": 88,
"confidence": 8,
"reason": "CEO Ryan Cohen recently purchased 1 million shares, a massive vote of confidence that establishes a psychological floor. Technicals show a bullish divergence in on-balance volume, indicating accumulation despite recent price consolidation.",
"entry_price": 23.8799991607666,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "INTC",
"rank": 5,
"strategy_match": "Insider Play",
"final_score": 87,
"confidence": 8,
"reason": "Recent insider buying by the CFO aligns with a strong 1-year uptrend and positive sentiment around domestic manufacturing. The stock maintains a 'Strong Uptrend' technical status, trading well above its 50 and 200-day moving averages.",
"entry_price": 46.470001220703125,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "SMCI",
"rank": 6,
"strategy_match": "Earnings Play",
"final_score": 86,
"confidence": 8,
"reason": "Reporting earnings on Feb 3 with expectations of 84% revenue growth, the stock is primed for volatility. With 17-18% short interest and recent analyst upgrades, a positive report could trigger a sharp squeeze.",
"entry_price": 29.110000610351562,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "PLTR",
"rank": 7,
"strategy_match": "Earnings Play",
"final_score": 85,
"confidence": 8,
"reason": "Set to report earnings on Feb 2 with projected 62.8% revenue growth. The stock is currently oversold (RSI ~25), presenting an asymmetric opportunity for a bounce if results validate its AI platform's expansion.",
"entry_price": 146.58999633789062,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "WDC",
"rank": 8,
"strategy_match": "Momentum",
"final_score": 84,
"confidence": 8,
"reason": "Received a fresh 'Buy' upgrade following strong Q2 earnings and is positioned as a key beneficiary of AI storage demand. Technicals show a very strong trend (ADX 55+) with price holding above key moving averages.",
"entry_price": 250.22999572753906,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "FFAI",
"rank": 9,
"strategy_match": "News Catalyst",
"final_score": 83,
"confidence": 8,
"reason": "Sales for its new AI robotics product begin Feb 4, providing a definitive near-term catalyst. BlackRock's increased stake and recent regulatory certification support the momentum in this high-volatility play.",
"entry_price": 1.0399999618530273,
"discovery_date": "2026-02-01",
"status": "open"
},
{
"ticker": "LBRDA",
"rank": 10,
"strategy_match": "Volume Accumulation",
"final_score": 82,
"confidence": 8,
"reason": "Displaying unusual volume (2.9x average) and a bullish MACD crossover, signaling accumulation ahead of earnings. The stock has rallied 7.79% recently, breaking out from lows with improving sentiment.",
"entry_price": 48.02000045776367,
"discovery_date": "2026-02-01",
"status": "open"
}
]
}

171
data/recommendations/2026-02-02.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-02",
"llm_provider": "google",
"recommendations": [
{
"ticker": "ACRV",
"rank": 1,
"strategy_match": "short_squeeze",
"final_score": 96,
"confidence": 9,
"reason": "Extreme short interest of 63% creates a massive squeeze risk as the company prepares to present late-breaking Phase 2b clinical data for its lead oncology candidate ACR-368. Sentiment is further bolstered by recent CEO and CFO insider buying in mid-January, providing a significant floor and asymmetric upside.",
"entry_price": 1.809999942779541,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "PLTR",
"rank": 2,
"strategy_match": "earnings_play",
"final_score": 94,
"confidence": 9,
"reason": "Exceptional Q4 results showing 70% revenue growth and bullish 2026 guidance are currently overshadowed by a technical oversold condition (RSI 25.3). The rapid adoption of the AIP platform and bullish revenue projections of $7.2B make this a prime candidate for a massive technical bounce as the market digests the fundamental beat.",
"entry_price": 147.75999450683594,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "ATO",
"rank": 3,
"strategy_match": "pre_earnings_accumulation",
"final_score": 91,
"confidence": 8,
"reason": "Demonstrating classic pre-earnings accumulation with volume at 2.16x average and a bullish OBV divergence ahead of the February 3 earnings report. Analysts remain optimistic about the modernization program and high EPS estimate of $2.44, suggesting institutional positioning for a beat.",
"entry_price": 166.52000427246094,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "LTRX",
"rank": 4,
"strategy_match": "pre_earnings_accumulation",
"final_score": 90,
"confidence": 8,
"reason": "Strong accumulation signals with volume at 2.3x average and a recent 4.5% price lift ahead of its February 4 earnings. The strategic partnership with Safe Pro Group for AI-powered defense drones provides a high-growth thematic catalyst for the upcoming results.",
"entry_price": 6.800000190734863,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "IP",
"rank": 5,
"strategy_match": "insider_buying",
"final_score": 89,
"confidence": 8,
"reason": "The CEO's significant purchase of 50,000 shares (valued at approximately $2M) on January 30 provides a strong vote of confidence. Coupled with a recent Wells Fargo upgrade and the company's plan to split into two independent entities, the stock shows strong technical support at the 50 SMA.",
"entry_price": 40.689998626708984,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "CR",
"rank": 6,
"strategy_match": "insider_buying",
"final_score": 88,
"confidence": 8,
"reason": "Following a Q4 earnings beat and dividend hike, multiple directors made large open-market purchases. This insider activity, combined with a 12.9% drop in the last 5 days, presents an asymmetric entry point as technicals signal a recovery toward the $219 analyst target.",
"entry_price": 185.27000427246094,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "TWST",
"rank": 7,
"strategy_match": "earnings_play",
"final_score": 87,
"confidence": 8,
"reason": "Reported record Q1 revenue and raised full-year guidance to $435M-$440M. The company's reiteration of its adjusted EBITDA breakeven target by late 2026 serves as a significant fundamental pivot that has not yet been fully reflected in the current price action.",
"entry_price": 46.810001373291016,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "AB",
"rank": 8,
"strategy_match": "pre_earnings_accumulation",
"final_score": 86,
"confidence": 8,
"reason": "Trading in a strong uptrend with volume 2.33x the average ahead of the February 5 earnings report. High institutional interest, including increasing stakes from major banks, suggests high expectations for its Q4 results and yield stability.",
"entry_price": 41.880001068115234,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "AI",
"rank": 9,
"strategy_match": "short_squeeze",
"final_score": 84,
"confidence": 7,
"reason": "Technical oversold conditions (RSI 29.9) and high short interest (31.4%) are colliding with rumors of a potential merger with Automation Anywhere. An 89% jump in federal bookings suggests underlying fundamental improvements that could trigger a violent short-covering rally.",
"entry_price": 10.920000076293945,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "APLD",
"rank": 10,
"strategy_match": "short_squeeze",
"final_score": 83,
"confidence": 7,
"reason": "With a $16B backlog and a massive $5B lease agreement with a U.S. hyperscaler, the company is fundamentally well-positioned. High short interest (33.6%) and strong Q2 revenue growth make it a top candidate for a momentum squeeze as it scales AI capacity.",
"entry_price": 34.79999923706055,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "DOCN",
"rank": 11,
"strategy_match": "analyst_upgrade",
"final_score": 82,
"confidence": 7,
"reason": "Recently upgraded following the strategic hire of an Oracle veteran as CPTO and an AMD collaboration to double AI capacity. Unusual bullish options flow (P/C ratio 0.311) indicates high-conviction betting on upcoming earnings momentum.",
"entry_price": 59.810001373291016,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "CEG",
"rank": 12,
"strategy_match": "analyst_upgrade",
"final_score": 81,
"confidence": 7,
"reason": "Shares are deeply oversold with an RSI of 30.0, sitting near its lower Bollinger Band. As a top 'Nuclear-AI' play with recent regulatory approvals for upgrades, this represents a high-probability mean reversion opportunity with an analyst target of $402.",
"entry_price": 270.8800048828125,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "ORCL",
"rank": 13,
"strategy_match": "news_catalyst",
"final_score": 80,
"confidence": 7,
"reason": "The announcement of a $50B capital raise to fund massive AI cloud expansion caused an intraday dip to an RSI of 31.4 (oversold). Historically, such aggressive expansion to meet backlog demand (as seen in its recent news) precedes high institutional accumulation at these support levels.",
"entry_price": 160.05999755859375,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "RTX",
"rank": 14,
"strategy_match": "earnings_play",
"final_score": 79,
"confidence": 7,
"reason": "Following an EPS beat and multiple analyst price target hikes, the stock is riding strong momentum backed by a massive $260B backlog. High volume on call options ($205 strike) suggests a near-term move past its current 52-week highs.",
"entry_price": 201.08999633789062,
"discovery_date": "2026-02-02",
"status": "open"
},
{
"ticker": "WWD",
"rank": 15,
"strategy_match": "earnings_play",
"final_score": 78,
"confidence": 7,
"reason": "Exceptional Q1 results with a 29% sales surge and a significant EPS guidance hike to $8.20-$8.60. Management's confidence in the aerospace segment creates a fundamental tailwind that should overcome short-term technical resistance.",
"entry_price": 327.25,
"discovery_date": "2026-02-02",
"status": "open"
}
]
}

171
data/recommendations/2026-02-03.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-03",
"llm_provider": "google",
"recommendations": [
{
"ticker": "SMCI",
"rank": 1,
"strategy_match": "momentum",
"final_score": 95,
"confidence": 9,
"reason": "SMCI is experiencing significant momentum, with news directly mentioning its AI server sales driving a 120% revenue increase. Despite a bearish technical outlook with price below the 50 SMA, the strong fundamental growth and record revenue reported in its latest earnings indicate strong underlying business performance.",
"entry_price": 29.670000076293945,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "NVDA",
"rank": 2,
"strategy_match": "momentum",
"final_score": 92,
"confidence": 8,
"reason": "NVIDIA is a key player in AI, with strong analyst sentiment and bullish options activity. While news mentions scrutiny over its AI chip supply chain, its robust fundamentals, including significant revenue growth, and its position above the 50 SMA suggest continued upward potential.",
"entry_price": 180.33999633789062,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AMAT",
"rank": 3,
"strategy_match": "analyst_upgrade",
"final_score": 90,
"confidence": 8,
"reason": "AMAT has received an analyst upgrade and shows strong upward momentum, trading above its 50 SMA. The company's strong fundamentals, including significant revenue and earnings growth, coupled with bullish options activity, support a positive outlook.",
"entry_price": 318.6700134277344,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "LRCX",
"rank": 4,
"strategy_match": "analyst_upgrade",
"final_score": 88,
"confidence": 8,
"reason": "LRCX has seen an analyst upgrade and exhibits a very strong uptrend with its price well above the 50 SMA. The company's fundamentals show robust growth in revenue and earnings, and its bullish options sentiment further strengthens its investment case.",
"entry_price": 230.10000610351562,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AMD",
"rank": 5,
"strategy_match": "social_hype",
"final_score": 85,
"confidence": 7,
"reason": "AMD reported strong Q4 earnings driven by AI demand, and despite some insider selling, its positive analyst sentiment and upward trend above the 50 SMA make it a compelling pick. The social hype around AI continues to benefit AMD.",
"entry_price": 242.11000061035156,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "CSCO",
"rank": 6,
"strategy_match": "undiscovered_dd",
"final_score": 82,
"confidence": 7,
"reason": "CSCO's recent AI summit and focus on high-margin software and security services, combined with strong upward technicals (above 50 SMA and strong trend), position it well. The 'undiscovered DD' strategy match and bullish options flow suggest potential upside.",
"entry_price": 83.11000061035156,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AKAM",
"rank": 7,
"strategy_match": "momentum",
"final_score": 80,
"confidence": 6,
"reason": "AKAM is described as a 'quiet cloud veteran suddenly looks like a growth story again,' indicating positive underlying sentiment. Its strong uptrend, price above 50 SMA, and bullish MACD support this, despite some recent insider selling and bearish options volume.",
"entry_price": 91.79000091552734,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "SIMO",
"rank": 8,
"strategy_match": "undiscovered_dd",
"final_score": 78,
"confidence": 7,
"reason": "SIMO has strong uptrend technicals, trading above its 50 SMA with a high RSI. The 'undiscovered DD' strategy and strong analyst buy ratings suggest potential for further upside, despite a slight bearish MACD signal.",
"entry_price": 120.41999816894531,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AB",
"rank": 9,
"strategy_match": "pre_earnings_accumulation",
"final_score": 75,
"confidence": 6,
"reason": "AB shows bullish technicals with its price above the 50 SMA and a bullish OBV divergence indicating accumulation. The 'pre-earnings accumulation' strategy, coupled with strong analyst buy ratings, suggests a positive outlook heading into earnings.",
"entry_price": 41.36000061035156,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AEIS",
"rank": 10,
"strategy_match": "pre_earnings_accumulation",
"final_score": 72,
"confidence": 6,
"reason": "AEIS is showing signs of pre-earnings accumulation with higher than average volume and a price above the 50 SMA. Despite a bearish OBV divergence, the strong analyst sentiment and bullish technicals make it a candidate for short-term gains.",
"entry_price": 263.0299987792969,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "LUMN",
"rank": 11,
"strategy_match": "news_catalyst",
"final_score": 70,
"confidence": 5,
"reason": "LUMN reported strong earnings and debt reduction, with news highlighting significant new contracts. Its strong uptrend and price above the 50 SMA are positive indicators, although analyst sentiment is mixed.",
"entry_price": 8.460000038146973,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "INMD",
"rank": 12,
"strategy_match": "earnings_play",
"final_score": 68,
"confidence": 5,
"reason": "INMD shows strong bullish technicals, trading above its 50 SMA with a bullish MACD crossover and high RSI. The 'earnings play' strategy and positive analyst sentiment suggest potential for a short-term upward move.",
"entry_price": 15.899999618530273,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "FFIV",
"rank": 13,
"strategy_match": "momentum",
"final_score": 65,
"confidence": 5,
"reason": "FFIV exhibits positive momentum with a bullish MACD crossover and price above the 50 SMA. While there is significant insider selling and a bearish analyst sentiment, the strong uptrend and bullish options activity warrant consideration.",
"entry_price": 274.6300048828125,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "RRR",
"rank": 14,
"strategy_match": "earnings_play",
"final_score": 62,
"confidence": 4,
"reason": "RRR shows strong uptrend technicals with its price above the 50 SMA and positive OBV trend. The 'earnings play' strategy and high analyst buy ratings suggest potential for short-term gains, despite bearish options activity.",
"entry_price": 63.459999084472656,
"discovery_date": "2026-02-03",
"status": "open"
},
{
"ticker": "AAPL",
"rank": 15,
"strategy_match": "momentum",
"final_score": 60,
"confidence": 4,
"reason": "AAPL has strong uptrend technicals, trading above its 50 SMA with bullish MACD and options flow. Despite reaching its upper Bollinger Band, indicating potential reversal, the overall positive sentiment and consistent performance make it a viable option.",
"entry_price": 269.4800109863281,
"discovery_date": "2026-02-03",
"status": "open"
}
]
}

171
data/recommendations/2026-02-04.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-04",
"llm_provider": "google",
"recommendations": [
{
"ticker": "AXL",
"rank": 1,
"strategy_match": "short_squeeze",
"final_score": 96,
"confidence": 10,
"reason": "This is a textbook short squeeze setup triggering now, with 33.0% short interest and a +5.2% intraday move. Extremely unusual bullish options activity (P/C ratio 0.019) combined with a strong technical uptrend confirms aggressive buying pressure.",
"entry_price": 8.835000038146973,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "AAP",
"rank": 2,
"strategy_match": "short_squeeze",
"final_score": 95,
"confidence": 9,
"reason": "High squeeze potential with 33.9% short interest and a +5.3% intraday surge. Technicals show a bullish MACD crossover and price reclaiming the 20 EMA, signaling a strong reversal and momentum shift.",
"entry_price": 53.834999084472656,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "RYN",
"rank": 3,
"strategy_match": "pre_earnings_accumulation",
"final_score": 93,
"confidence": 9,
"reason": "Classic pre-earnings accumulation pattern with volume running 2.28x average and unusual bullish options flow (P/C 0.169). Rising On-Balance Volume (OBV) indicates smart money positioning ahead of the Feb 11 report.",
"entry_price": 22.80500030517578,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "LLY",
"rank": 4,
"strategy_match": "earnings_momentum",
"final_score": 91,
"confidence": 9,
"reason": "Reported a significant earnings beat ($7.54 vs $6.67) and raised guidance, driving a +2.5% intraday move. Bullish divergence in OBV suggests accumulation despite recent price consolidation, setting the stage for a breakout.",
"entry_price": 1100.3299560546875,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "HON",
"rank": 5,
"strategy_match": "momentum_options",
"final_score": 89,
"confidence": 9,
"reason": "Strong momentum signaled by a 'Golden Cross' technical setup and a MACD bullish crossover. Unusual bullish options flow (P/C 0.255) supports the uptrend, indicating institutional confidence in further upside.",
"entry_price": 236.21499633789062,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "DELL",
"rank": 6,
"strategy_match": "analyst_upgrade",
"final_score": 88,
"confidence": 8,
"reason": "Fresh analyst upgrade combined with a MACD bullish crossover signals a trend reversal. Unusual bullish options flow (P/C 0.344) and positive intraday action confirm immediate buyer interest.",
"entry_price": 119.63500213623047,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "ADBE",
"rank": 7,
"strategy_match": "oversold_reversal",
"final_score": 87,
"confidence": 8,
"reason": "Deeply oversold conditions (RSI 23.4) have triggered a sharp mean-reversion bounce, with shares up +4.4% intraday. Bollinger Band positioning suggests the sell-off has exhausted, presenting a high risk/reward entry.",
"entry_price": 278.9100036621094,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "HPE",
"rank": 8,
"strategy_match": "analyst_upgrade",
"final_score": 86,
"confidence": 8,
"reason": "Analyst upgrade catalyzed a +3.8% intraday move and a MACD bullish crossover. While the long-term trend is down, this momentum shift indicates a strong short-term recovery play.",
"entry_price": 22.645099639892578,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "KO",
"rank": 9,
"strategy_match": "momentum_options",
"final_score": 85,
"confidence": 8,
"reason": "Defensive momentum play with unusual bullish options flow (P/C 0.196). A recent MACD bullish crossover and rising OBV confirm a strong uptrend backed by volume.",
"entry_price": 77.70999908447266,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "ADP",
"rank": 10,
"strategy_match": "earnings_reversal",
"final_score": 84,
"confidence": 8,
"reason": "Stock is heavily oversold (RSI 26.0) despite an earnings beat ($2.62 vs estimates). The discrepancy between strong fundamentals and depressed price creates a prime setup for a mean-reversion bounce.",
"entry_price": 236.90499877929688,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "BWA",
"rank": 11,
"strategy_match": "earnings_play",
"final_score": 83,
"confidence": 8,
"reason": "Strong uptrend leading into Feb 11 earnings, supported by bullish options flow (P/C 0.344). Technicals remain bullish with price holding above the 20 EMA and rising VWAP.",
"entry_price": 50.13999938964844,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "ACHC",
"rank": 12,
"strategy_match": "short_squeeze",
"final_score": 82,
"confidence": 7,
"reason": "High short interest (28.3%) combined with a MACD bullish crossover and unusually bullish options activity (P/C 0.504). Technical reversal signals suggest short sellers may be forced to cover.",
"entry_price": 13.84000015258789,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "MCD",
"rank": 13,
"strategy_match": "earnings_momentum",
"final_score": 81,
"confidence": 8,
"reason": "Robust technical strength with a MACD bullish crossover and price above 20/50/200 SMAs. Momentum is building into the Feb 11 earnings report, supported by rising OBV.",
"entry_price": 325.6925048828125,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "SMCI",
"rank": 14,
"strategy_match": "earnings_growth",
"final_score": 80,
"confidence": 7,
"reason": "Reported massive 123% revenue growth, signaling fundamental strength despite a broken chart. Bullish options volume (P/C 0.454) suggests traders are betting on a recovery rally from these levels.",
"entry_price": 32.88159942626953,
"discovery_date": "2026-02-04",
"status": "open"
},
{
"ticker": "EA",
"rank": 15,
"strategy_match": "earnings_reversal",
"final_score": 79,
"confidence": 7,
"reason": "Reported strong Q3 revenue, yet stock is oversold (RSI 24.3). This divergence between positive news and negative price action presents a buying opportunity near the lower Bollinger Band.",
"entry_price": 198.91000366210938,
"discovery_date": "2026-02-04",
"status": "open"
}
]
}

171
data/recommendations/2026-02-05.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-05",
"llm_provider": "google",
"recommendations": [
{
"ticker": "GME",
"rank": 1,
"strategy_match": "momentum",
"final_score": 94,
"confidence": 9,
"reason": "Massive $21M insider purchase by CEO Ryan Cohen on Jan 21 serves as a major vote of confidence. Technicals show a 'Very Strong' trend with an ADX of 50.7 and rising On-Balance Volume, indicating sustained accumulation.",
"entry_price": 24.690000534057617,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "IP",
"rank": 2,
"strategy_match": "momentum",
"final_score": 92,
"confidence": 9,
"reason": "Recent insider purchases totaling ~$3M by the CEO and Directors signal strong internal conviction. The stock is staging a breakout with a 6.25% daily gain, confirmed by rising OBV and price holding above all major Moving Averages.",
"entry_price": 44.369998931884766,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "LPG",
"rank": 3,
"strategy_match": "momentum",
"final_score": 90,
"confidence": 8,
"reason": "Earnings Before Market Open (BMO) catalyst today aligns with a Bullish Divergence in OBV. The stock maintains a 'Strong Uptrend' and is trading above its 20-day EMA and VWAP, suggesting institutional accumulation.",
"entry_price": 30.059999465942383,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "POST",
"rank": 4,
"strategy_match": "momentum",
"final_score": 88,
"confidence": 8,
"reason": "Fresh earnings beat and raised guidance provide a fundamental tailwind. Technicals confirm momentum with a Bullish MACD crossover and price action holding firmly above the 50-day SMA.",
"entry_price": 104.41000366210938,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "TCBI",
"rank": 5,
"strategy_match": "momentum",
"final_score": 87,
"confidence": 8,
"reason": "Insider buying by the CEO and Directors complements a 'Strong Uptrend' technical rating. A Bullish MACD crossover and price performance above the VWAP indicate continued buyer strength.",
"entry_price": 103.5,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "AB",
"rank": 6,
"strategy_match": "momentum",
"final_score": 85,
"confidence": 8,
"reason": "Earnings catalyst today is supported by bullish options volume (Put/Call ratio 0.081). The stock is in a confirmed uptrend, trading above the 50 SMA and 200 SMA with rising momentum.",
"entry_price": 42.36000061035156,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "ROK",
"rank": 7,
"strategy_match": "momentum",
"final_score": 84,
"confidence": 7,
"reason": "Strong Q1 earnings beat and raised guidance drive the bullish thesis. A MACD bullish crossover confirms upward momentum, although the price is near the upper Bollinger Band which may invite volatility.",
"entry_price": 406.70001220703125,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "TSLA",
"rank": 8,
"strategy_match": "momentum",
"final_score": 80,
"confidence": 7,
"reason": "Potential asymmetric bounce play as price hits the Lower Bollinger Band. Despite the downtrend, a Bullish Divergence in OBV and high Reddit interest suggest potential for a sharp reversal.",
"entry_price": 397.2099914550781,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "PECO",
"rank": 9,
"strategy_match": "momentum",
"final_score": 79,
"confidence": 7,
"reason": "Earnings After Market Close (AMC) catalyst combined with a 'Strong Uptrend'. Bullish MACD crossover and rising OBV signal accumulation into the event, though RSI is nearing overbought levels.",
"entry_price": 37.81999969482422,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "STE",
"rank": 10,
"strategy_match": "momentum",
"final_score": 78,
"confidence": 7,
"reason": "Unusual volume accumulation detected alongside a 'Strong Uptrend'. A bullish stochastic crossover suggests short-term momentum is recovering despite the recent mixed earnings reaction.",
"entry_price": 243.80999755859375,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "NTRS",
"rank": 11,
"strategy_match": "momentum",
"final_score": 76,
"confidence": 7,
"reason": "Insider purchasing signals confidence in the ongoing 'Strong Uptrend'. The stock is trading well above its 200 SMA and VWAP, indicating sustained institutional support.",
"entry_price": 147.47999572753906,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "MANE",
"rank": 12,
"strategy_match": "momentum",
"final_score": 75,
"confidence": 6,
"reason": "Massive $43M insider purchase provides a strong conviction backdrop. While current technicals are sideways, the bullish stochastic crossover indicates a potential bounce from support levels.",
"entry_price": 37.15999984741211,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "WEX",
"rank": 13,
"strategy_match": "momentum",
"final_score": 72,
"confidence": 6,
"reason": "Earnings beat and raised guidance provide a catalyst for reversal. Unusual bullish options flow (Calls > Puts) suggests traders are positioning for a recovery despite current technical weakness.",
"entry_price": 148.5399932861328,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "UDMY",
"rank": 14,
"strategy_match": "momentum",
"final_score": 68,
"confidence": 5,
"reason": "High-risk earnings play with Bullish Divergence in OBV. A stochastic crossover from oversold levels suggests potential for a sharp volatility-driven move post-earnings.",
"entry_price": 4.690000057220459,
"discovery_date": "2026-02-05",
"status": "open"
},
{
"ticker": "CR",
"rank": 15,
"strategy_match": "momentum",
"final_score": 65,
"confidence": 5,
"reason": "Identified insider buying interest serves as a potential floor. Bullish stochastic crossover indicates the stock may be oversold and due for a technical mean reversion.",
"entry_price": 187.77999877929688,
"discovery_date": "2026-02-05",
"status": "open"
}
]
}

171
data/recommendations/2026-02-06.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-06",
"llm_provider": "google",
"recommendations": [
{
"ticker": "GME",
"rank": 1,
"strategy_match": "momentum",
"final_score": 96,
"confidence": 10,
"reason": "CEO Ryan Cohen recently purchased ~$21M worth of stock, a massive vote of confidence that aligns with Reddit-driven short squeeze narratives. Technicals show an uptrend with the price above the 20 EMA, and bullish options flow supports further upside.",
"entry_price": 24.93000030517578,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "LIFE",
"rank": 2,
"strategy_match": "insider_buying",
"final_score": 94,
"confidence": 9,
"reason": "The stock is trading with an extreme RSI of 10.0 (oversold), and an intraday bounce of +8.6% suggests a reversal is underway. Recent insider purchasing provides a fundamental floor and validation for a mean-reversion trade.",
"entry_price": 12.289999961853027,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "MSFT",
"rank": 3,
"strategy_match": "options_flow",
"final_score": 92,
"confidence": 9,
"reason": "RSI is at 24.6 (oversold), a rare occurrence for this blue-chip, while price touches the lower Bollinger Band. Unusual bullish options activity and a low Put/Call ratio suggest institutional positioning for a technical bounce.",
"entry_price": 394.7300109863281,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "TSLA",
"rank": 4,
"strategy_match": "options_flow",
"final_score": 90,
"confidence": 9,
"reason": "Trading at the lower Bollinger Band with a bullish intraday move of +2.6% indicates strong support. Unusual options activity with 9 strikes showing bullish flow reinforces the setup for a momentum rebound.",
"entry_price": 410.4100036621094,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "AAPL",
"rank": 5,
"strategy_match": "momentum",
"final_score": 89,
"confidence": 9,
"reason": "Stock is in a strong uptrend with a bullish MACD crossover and RSI at 67. Unusual options flow with a low Put/Call ratio of 0.44 confirms strong institutional momentum favoring a breakout.",
"entry_price": 279.0199890136719,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "POET",
"rank": 6,
"strategy_match": "options_flow",
"final_score": 88,
"confidence": 8,
"reason": "Extremely bullish options flow with a Put/Call ratio of 0.158 and 3 unusual call strikes highlights aggressive speculation. Combined with Reddit due diligence and a +4.1% intraday move, this presents a high-risk, high-reward squeeze setup.",
"entry_price": 5.569900035858154,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "MANE",
"rank": 7,
"strategy_match": "insider_buying",
"final_score": 87,
"confidence": 8,
"reason": "Technical indicators show an RSI of 0.0, indicating the stock is mathematically bottomed out and due for a reaction. Recent insider buying adds a crucial layer of confidence to this extreme mean-reversion opportunity.",
"entry_price": 35.709999084472656,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "ABT",
"rank": 8,
"strategy_match": "insider_buying",
"final_score": 86,
"confidence": 8,
"reason": "The CEO purchased ~$2M in stock, a significant vote of confidence. With the RSI at 32 approaching oversold territory, this insider accumulation signals a strong potential bottoming formation.",
"entry_price": 109.41999816894531,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "AN",
"rank": 9,
"strategy_match": "earnings_calendar",
"final_score": 85,
"confidence": 8,
"reason": "Intraday price action is up +9.4% coincident with an earnings release, indicating a very positive market reaction. Bullish divergence in On-Balance Volume (OBV) prior to this move suggests accumulation.",
"entry_price": 220.76499938964844,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "CBOE",
"rank": 10,
"strategy_match": "earnings_calendar",
"final_score": 84,
"confidence": 8,
"reason": "Strong uptrend confirmed by rising OBV and price above the 50 SMA. Earnings catalyst combined with unusual bullish options flow (P/C ratio 0.533) supports continued momentum.",
"entry_price": 271.44000244140625,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "PM",
"rank": 11,
"strategy_match": "earnings_calendar",
"final_score": 83,
"confidence": 8,
"reason": "Momentum is strong with a bullish MACD crossover and rising OBV. Trading intraday +3.1% on earnings day suggests the market is rewarding their results, favoring a short-term trend continuation.",
"entry_price": 185.42999267578125,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "NVDA",
"rank": 12,
"strategy_match": "options_flow",
"final_score": 82,
"confidence": 7,
"reason": "Price is at the lower Bollinger Band, often a signal for a technical bounce. Despite insider selling, options flow remains bullish (P/C 0.67) and volume is high, supporting a tactical rebound.",
"entry_price": 182.40069580078125,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "NTRS",
"rank": 13,
"strategy_match": "momentum",
"final_score": 81,
"confidence": 7,
"reason": "Stock is in a strong uptrend above the 50 SMA with bullish divergence in OBV, indicating accumulation. Insider buying from a Director further supports the bullish thesis despite some mixed analyst sentiment.",
"entry_price": 150.97999572753906,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "PATH",
"rank": 14,
"strategy_match": "momentum",
"final_score": 80,
"confidence": 7,
"reason": "RSI is oversold at 30.4, and unusual call activity (5 strikes) suggests traders are betting on a bounce. Reddit attention adds a layer of retail hype potential, though insider selling requires caution.",
"entry_price": 12.345000267028809,
"discovery_date": "2026-02-06",
"status": "open"
},
{
"ticker": "GOOGL",
"rank": 15,
"strategy_match": "options_flow",
"final_score": 79,
"confidence": 7,
"reason": "Maintains a strong uptrend well above the 200 SMA. Unusual options activity is present, and while momentum has cooled slightly, the technical structure remains bullish for a swing trade.",
"entry_price": 322.0899963378906,
"discovery_date": "2026-02-06",
"status": "open"
}
]
}

171
data/recommendations/2026-02-09.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-09",
"llm_provider": "google",
"recommendations": [
{
"ticker": "GME",
"rank": 1,
"strategy_match": "momentum",
"final_score": 92,
"confidence": 9,
"reason": "GameStop presents a high-conviction setup driven by substantial insider buying, specifically Ryan Cohen's recent $21M purchase. With a high short interest of 16.1% and a 'Predicted: WIN' signal from the ML model, the stock is primed for a squeeze. Technicals confirm strength with an ADX of 52.5 indicating a very strong trend, and the RSI at 62 allows room for further upside. The alignment of insider conviction and retail momentum makes this the top asymmetric opportunity.",
"entry_price": 24.639999389648438,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "NVAX",
"rank": 2,
"strategy_match": "momentum",
"final_score": 88,
"confidence": 8,
"reason": "Novavax carries an exceptionally high short interest of 32.9%, creating a powder keg for a short squeeze. The technical picture is bullish with a recent Golden Cross (50 SMA crossing above 200 SMA) and the stock holding a strong uptrend. The ML model supports this trade with a 50.5% win probability. Risk is managed by the clear technical support levels near the moving averages.",
"entry_price": 8.699999809265137,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "CRM",
"rank": 3,
"strategy_match": "momentum",
"final_score": 85,
"confidence": 8,
"reason": "Salesforce represents a classic mean reversion play, currently trading at deeply oversold levels with an RSI of 21.9. The ML model assigns it a high win probability of 53.2%, suggesting the selling pressure is exhausted. Despite recent headwinds, the technical extension to the downside offers a favorable risk/reward for a snap-back rally within the 7-day window.",
"entry_price": 194.02999877929688,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "WRB",
"rank": 4,
"strategy_match": "insider_buying",
"final_score": 84,
"confidence": 8,
"reason": "Institutional insider buying is the primary driver here, with Mitsui Sumitomo accumulating over $300M in stock recently. This level of capital commitment signals extreme confidence in the company's valuation. Technicals corroborate this view with a bullish MACD crossover, making it a strong candidate for continued upside independent of broader market noise.",
"entry_price": 69.25,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "TDOC",
"rank": 5,
"strategy_match": "momentum",
"final_score": 82,
"confidence": 7,
"reason": "Teladoc combines high short interest (15.6%) with oversold technical conditions (RSI 27.3), creating a setup for a sharp relief rally. The stock is trading near the lower Bollinger Band, often a precursor to a bounce. The ML model's 51.6% win probability confirms the statistical edge for a short-term reversal.",
"entry_price": 4.980000019073486,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "CZR",
"rank": 6,
"strategy_match": "momentum",
"final_score": 81,
"confidence": 7,
"reason": "Caesars shows a bullish divergence in On-Balance Volume, indicating smart money accumulation despite recent price weakness. With a high short interest of 19.9% and a 51.7% ML win probability, the stock is poised for a squeeze. Trading near the lower Bollinger Band provides a clear entry point with defined risk.",
"entry_price": 20.649999618530273,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "WOOF",
"rank": 7,
"strategy_match": "momentum",
"final_score": 80,
"confidence": 7,
"reason": "Petco is another strong squeeze candidate with 16.6% short interest and bullish OBV divergence. The stock is heavily oversold (RSI 38.9) and sitting at the lower Bollinger Band. The ML model predicts a win (51.6%), suggesting the negative sentiment is priced in and a bounce is likely.",
"entry_price": 2.549999952316284,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "UWMC",
"rank": 8,
"strategy_match": "momentum",
"final_score": 79,
"confidence": 7,
"reason": "UWM Holdings is trading at its lower Bollinger Band, a technical level that often acts as dynamic support. With 15.7% short interest and a 51.5% ML win probability, the setup favors a bounce. The high dividend yield also acts as a floor for the stock price at these levels.",
"entry_price": 4.630000114440918,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "OGN",
"rank": 9,
"strategy_match": "momentum",
"final_score": 78,
"confidence": 7,
"reason": "Organon exhibits positive pre-earnings momentum and is currently holding above its 50-day moving average. The ML model gives it a 50.9% win probability, indicating a favorable reaction to upcoming events. The risk/reward is attractive as the stock consolidates before the potential catalyst.",
"entry_price": 7.909999847412109,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "PMN",
"rank": 10,
"strategy_match": "insider_buying",
"final_score": 76,
"confidence": 6,
"reason": "A significant $11M insider purchase provides a strong vote of confidence in the company's pipeline. Technically, the stock shows bullish divergence in OBV, suggesting accumulation is occurring under the surface. This creates an asymmetric opportunity where insider conviction could drive a rapid repricing.",
"entry_price": 13.050000190734863,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "AVXL",
"rank": 11,
"strategy_match": "earnings_calendar",
"final_score": 75,
"confidence": 6,
"reason": "With earnings scheduled for today and a high short interest of 23.1%, AVXL is a high-volatility event play. Any positive news could trigger a massive short covering rally. The stock's recent intraday strength (+6.8%) suggests some market participants are positioning for an upside surprise.",
"entry_price": 4.349999904632568,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "ASTS",
"rank": 12,
"strategy_match": "momentum",
"final_score": 74,
"confidence": 6,
"reason": "ASTS remains in a strong uptrend, trading well above its 50-day SMA. The high short interest of 18.5% keeps the squeeze potential alive, especially given the stock's popularity and volatility. Despite a cautious ML signal, the trend strength and market enthusiasm make it a viable momentum trade.",
"entry_price": 102.12000274658203,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "POET",
"rank": 13,
"strategy_match": "momentum",
"final_score": 72,
"confidence": 6,
"reason": "POET is showing explosive intraday momentum, up significantly, which often attracts further speculative volume. Stochastic indicators are oversold, suggesting the rally has room to run in the short term. The volatility here allows for quick percentage gains if the momentum sustains.",
"entry_price": 6.210000038146973,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "RYAN",
"rank": 14,
"strategy_match": "momentum",
"final_score": 70,
"confidence": 6,
"reason": "The significant intraday drop of nearly 8% has pushed RYAN into deep oversold territory, creating a mean reversion opportunity. The ML model maintains a bullish outlook (predicted WIN) despite the price action, suggesting the sell-off may be an overreaction that will correct quickly.",
"entry_price": 43.779998779296875,
"discovery_date": "2026-02-09",
"status": "open"
},
{
"ticker": "AVR",
"rank": 15,
"strategy_match": "insider_buying",
"final_score": 68,
"confidence": 5,
"reason": "AVR benefits from the confluence of a strong technical uptrend and insider buying activity. The stock is trading above its 50-day SMA, indicating sustained demand. This structural strength, backed by insider accumulation, offers a solid floor for a continued move higher.",
"entry_price": 5.610000133514404,
"discovery_date": "2026-02-09",
"status": "open"
}
]
}

171
data/recommendations/2026-02-10.json Normal file
View File

@ -0,0 +1,171 @@
{
"date": "2026-02-10",
"llm_provider": "google",
"recommendations": [
{
"ticker": "GME",
"rank": 1,
"strategy_match": "momentum",
"final_score": 45,
"confidence": 10,
"reason": "GameStop leads the list with a high Quantitative Score of 45 and a robust ML Win Probability of 52.6%. The setup is primed for a squeeze with 16.1% short interest and significant recent insider buying, notably a $21 million purchase by CEO Ryan Cohen. Options sentiment is strongly bullish with a Put/Call ratio of 0.248, suggesting traders are positioning for upside. Technically, the stock is in an uptrend above its 200 SMA, and the convergence of retail momentum and insider conviction offers an asymmetric risk/reward profile.",
"entry_price": 24.889999389648438,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "AVR",
"rank": 2,
"strategy_match": "momentum",
"final_score": 40,
"confidence": 8,
"reason": "Anteris Technologies aligns with the high-win-rate 'Insider Buying' strategy, featuring $28.75 million in recent insider purchases. The stock carries a high Quantitative Score of 40 and shows highly unusual bullish options activity with a Put/Call ratio of just 0.007. Trading above its 50 SMA, the stock displays technical resilience despite recent volatility. The combination of heavy institutional accumulation and aggressive options betting supports a strong short-term bounce thesis.",
"entry_price": 5.829999923706055,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "PEGA",
"rank": 3,
"strategy_match": "momentum",
"final_score": 30,
"confidence": 9,
"reason": "Pegasystems is a compelling earnings play with an ML Win Probability of 48.4% and an exceptionally strong ADX trend reading of 67.1. With earnings scheduled for today, the stock's oversold Stochastic reading suggests potential for a sharp mean-reversion rally if results exceed depressed expectations. While the longer-term trend is down, the immediate catalyst and high win probability make this a viable tactical trade. Volatility is elevated, allowing for the targeted >5% return within the 7-day window.",
"entry_price": 42.525001525878906,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "BLKB",
"rank": 4,
"strategy_match": "momentum",
"final_score": 30,
"confidence": 9,
"reason": "Blackbaud presents a deep value/reversion opportunity heading into earnings today, backed by an ML Win Probability of 48.4%. The stock is significantly oversold with an RSI of 29.5, yet shows bullish divergence in On-Balance Volume, indicating underlying accumulation. Options volume heavily favors calls (P/C 0.446), suggesting market participants anticipate a post-earnings recovery. The trade targets a snapback from extreme oversold conditions triggered by the earnings event.",
"entry_price": 49.790000915527344,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "INMD",
"rank": 5,
"strategy_match": "momentum",
"final_score": 15,
"confidence": 8,
"reason": "InMode enters its earnings release today with a supportive technical structure, including a Golden Cross (50 SMA above 200 SMA) and a price holding above the 20 EMA. The ML model predicts a win with 47.2% probability, and the company maintains a healthy financial position with a Current Ratio of 9.75. Despite a recent pullback, the alignment of earnings volatility and a confirmed uptrend creates a favorable setup for a momentum breakout. Risk is managed by the stock's strong balance sheet.",
"entry_price": 15.300000190734863,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "TMC",
"rank": 6,
"strategy_match": "momentum",
"final_score": 35,
"confidence": 8,
"reason": "TMC is a high-volatility momentum play driven by retail sentiment and Reddit due diligence, supported by a 45.5% ML Win Probability. The stock has a high short interest of 10.7% and bullish options flow (P/C ratio 0.208), creating the conditions for a potential squeeze. Technicals show a bullish Stochastic crossover, and the high ATR of 12.3% ensures sufficient volatility to hit profit targets quickly. The catalyst is continued speculative interest and short covering.",
"entry_price": 6.460000038146973,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "DDOG",
"rank": 7,
"strategy_match": "volume_accumulation",
"final_score": 30,
"confidence": 8,
"reason": "Datadog is flagged for Volume Accumulation, a strategy with a historical 100% win rate, coinciding with its earnings release today. The ML Win Probability is solid at 43.6%, and the stock exhibits a bullish divergence in On-Balance Volume despite recent price weakness. Options sentiment is constructive with more call volume than puts. This setup suggests 'smart money' positioning ahead of the binary earnings event, offering a strong risk/reward for a reversal.",
"entry_price": 131.63499450683594,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "PATH",
"rank": 8,
"strategy_match": "momentum",
"final_score": 35,
"confidence": 7,
"reason": "UiPath is a prime short squeeze candidate with 15.6% short interest and highly unusual bullish options activity (Put/Call ratio of 0.111). The ML model predicts a 43.9% win probability, and Reddit due diligence is fueling retail interest. While the stock is in a downtrend, the rising On-Balance Volume indicates accumulation. The trade thesis relies on a rapid repricing event driven by options gamma exposure and short covering.",
"entry_price": 13.074999809265137,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "PMN",
"rank": 9,
"strategy_match": "momentum",
"final_score": 20,
"confidence": 7,
"reason": "ProMIS Neurosciences benefits from significant recent insider buying totaling over $11 million, a strong signal of internal confidence. The ML model assigns a 43.8% probability of a win, and the stock is trading above its 20 EMA, indicating short-term strength. With extremely high volatility (ATR >11%), the stock is capable of making the required >5% move rapidly. The investment case is built on following insider conviction in a high-beta biotech asset.",
"entry_price": 13.550000190734863,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "IGV",
"rank": 10,
"strategy_match": "momentum",
"final_score": 25,
"confidence": 7,
"reason": "IGV offers a diversified way to play the potential rebound in the software sector, backed by a 42.3% ML Win Probability. The ETF is currently oversold with a Stochastic reading below 20, often a precursor to a technical bounce. Options flows are bullish, and the strong trend strength (ADX 63.9) suggests the sector remains active. This trade captures the broader momentum recovery thesis with lower single-stock risk.",
"entry_price": 86.29499816894531,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "POET",
"rank": 11,
"strategy_match": "momentum",
"final_score": 35,
"confidence": 7,
"reason": "POET Technologies is a high-volatility momentum play (ATR >10%) with a 41.1% ML Win Probability. The stock is the subject of Reddit due diligence and shows a bullish options Put/Call ratio of 0.224. Despite a downtrend, a recent bullish stochastic crossover signals potential for a relief rally. The thesis rests on speculative retail interest and high volatility driving a short-term price spike.",
"entry_price": 6.114999771118164,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "ASTS",
"rank": 12,
"strategy_match": "momentum",
"final_score": 35,
"confidence": 7,
"reason": "AST SpaceMobile remains a favorite among momentum traders with 18.5% short interest and a strong long-term uptrend. The stock is trading well above major moving averages, and the ML model gives it a 40.5% chance of success. Options volume is call-heavy, supporting a bullish outlook. The trade targets a continuation of the volatility-driven uptrend, aided by potential short covering.",
"entry_price": 99.80999755859375,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "APH",
"rank": 13,
"strategy_match": "momentum",
"final_score": 20,
"confidence": 7,
"reason": "Amphenol represents a high-quality momentum play, confirmed by insider buying and a strong technical uptrend. The stock is trading above both its 50 and 200 SMAs and recently flashed a Golden Cross signal. With an ML Win Probability of 41.1%, it offers a favorable balance of probability and trend stability. The catalyst is the continued institutional support indicated by price action relative to VWAP.",
"entry_price": 145.18910217285156,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "META",
"rank": 14,
"strategy_match": "momentum",
"final_score": 10,
"confidence": 6,
"reason": "Meta Platforms is predicted to WIN by the ML model (39.6%) and maintains a solid technical uptrend, holding above its 20 EMA and VWAP. Despite some insider selling, the fundamental backdrop of revenue growth and profitability remains a tailwind. Options positioning is constructive, and the stock is not overbought. This trade is a bet on large-cap tech resilience and continued momentum.",
"entry_price": 671.3660278320312,
"discovery_date": "2026-02-10",
"status": "open"
},
{
"ticker": "WRB",
"rank": 15,
"strategy_match": "momentum",
"final_score": 25,
"confidence": 6,
"reason": "W. R. Berkley makes the list primarily due to massive insider buying totaling over $308 million, aligning with a historically high-win-rate strategy. The stock is in a technical uptrend and trading above its 20 EMA. While the ML prediction is neutral, the sheer scale of insider conviction provides a strong floor and potential upside catalyst. The trade follows the 'smart money' signal in a stable insurance play.",
"entry_price": 69.02999877929688,
"discovery_date": "2026-02-10",
"status": "open"
}
]
}

3658
data/recommendations/performance_database.json Normal file
View File

File diff suppressed because it is too large Load Diff

299
data/recommendations/statistics.json Normal file
View File

@ -0,0 +1,299 @@
{
"total_recommendations": 200,
"by_strategy": {
"momentum": {
"count": 92,
"wins_1d": 47,
"losses_1d": 45,
"wins_7d": 25,
"losses_7d": 23,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0.32,
"avg_return_7d": 0.71,
"avg_return_30d": 0,
"win_rate_1d": 51.1,
"win_rate_7d": 52.1
},
"volume_accumulation": {
"count": 2,
"wins_1d": 1,
"losses_1d": 1,
"wins_7d": 1,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 7.41,
"avg_return_7d": 19.7,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 100.0
},
"insider_buying": {
"count": 25,
"wins_1d": 15,
"losses_1d": 6,
"wins_7d": 10,
"losses_7d": 5,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0.84,
"avg_return_7d": 0.18,
"avg_return_30d": 0,
"win_rate_1d": 71.4,
"win_rate_7d": 66.7
},
"options_flow": {
"count": 11,
"wins_1d": 4,
"losses_1d": 1,
"wins_7d": 0,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 3.09,
"avg_return_7d": 0,
"avg_return_30d": 0,
"win_rate_1d": 80.0
},
"earnings_calendar": {
"count": 20,
"wins_1d": 6,
"losses_1d": 11,
"wins_7d": 5,
"losses_7d": 8,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -0.23,
"avg_return_7d": 2.79,
"avg_return_30d": 0,
"win_rate_1d": 35.3,
"win_rate_7d": 38.5
},
"contrarian_value": {
"count": 6,
"wins_1d": 3,
"losses_1d": 3,
"wins_7d": 3,
"losses_7d": 3,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -4.91,
"avg_return_7d": -4.91,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 50.0
},
"news_catalyst": {
"count": 3,
"wins_1d": 0,
"losses_1d": 3,
"wins_7d": 0,
"losses_7d": 3,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -13.55,
"avg_return_7d": -13.55,
"avg_return_30d": 0,
"win_rate_1d": 0.0,
"win_rate_7d": 0.0
},
"short_squeeze": {
"count": 10,
"wins_1d": 5,
"losses_1d": 5,
"wins_7d": 6,
"losses_7d": 4,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0.56,
"avg_return_7d": 2.15,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 60.0
},
"early_accumulation": {
"count": 1,
"wins_1d": 1,
"losses_1d": 0,
"wins_7d": 1,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 20.41,
"avg_return_7d": 20.41,
"avg_return_30d": 0,
"win_rate_1d": 100.0,
"win_rate_7d": 100.0
},
"pre_earnings_accumulation": {
"count": 7,
"wins_1d": 2,
"losses_1d": 5,
"wins_7d": 2,
"losses_7d": 5,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -2.0,
"avg_return_7d": -1.94,
"avg_return_30d": 0,
"win_rate_1d": 28.6,
"win_rate_7d": 28.6
},
"analyst_upgrade": {
"count": 8,
"wins_1d": 6,
"losses_1d": 2,
"wins_7d": 6,
"losses_7d": 2,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 1.32,
"avg_return_7d": 0.99,
"avg_return_30d": 0,
"win_rate_1d": 75.0,
"win_rate_7d": 75.0
},
"ipo_opportunity": {
"count": 1,
"wins_1d": 0,
"losses_1d": 1,
"wins_7d": 0,
"losses_7d": 1,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -19.2,
"avg_return_7d": -19.2,
"avg_return_30d": 0,
"win_rate_1d": 0.0,
"win_rate_7d": 0.0
},
"social_hype": {
"count": 2,
"wins_1d": 0,
"losses_1d": 2,
"wins_7d": 0,
"losses_7d": 2,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -8.9,
"avg_return_7d": -8.9,
"avg_return_30d": 0,
"win_rate_1d": 0.0,
"win_rate_7d": 0.0
},
"undiscovered_dd": {
"count": 2,
"wins_1d": 2,
"losses_1d": 0,
"wins_7d": 2,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 6.44,
"avg_return_7d": 6.44,
"avg_return_30d": 0,
"win_rate_1d": 100.0,
"win_rate_7d": 100.0
},
"earnings_momentum": {
"count": 2,
"wins_1d": 1,
"losses_1d": 1,
"wins_7d": 0,
"losses_7d": 2,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -3.38,
"avg_return_7d": -3.85,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 0.0
},
"momentum_options": {
"count": 2,
"wins_1d": 1,
"losses_1d": 1,
"wins_7d": 2,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0.93,
"avg_return_7d": 2.27,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 100.0
},
"oversold_reversal": {
"count": 1,
"wins_1d": 0,
"losses_1d": 1,
"wins_7d": 0,
"losses_7d": 1,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -5.11,
"avg_return_7d": -7.41,
"avg_return_30d": 0,
"win_rate_1d": 0.0,
"win_rate_7d": 0.0
},
"earnings_reversal": {
"count": 2,
"wins_1d": 1,
"losses_1d": 1,
"wins_7d": 1,
"losses_7d": 1,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": -1.47,
"avg_return_7d": -2.82,
"avg_return_30d": 0,
"win_rate_1d": 50.0,
"win_rate_7d": 50.0
},
"earnings_growth": {
"count": 1,
"wins_1d": 1,
"losses_1d": 0,
"wins_7d": 0,
"losses_7d": 1,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 1.36,
"avg_return_7d": -1.94,
"avg_return_30d": 0,
"win_rate_1d": 100.0,
"win_rate_7d": 0.0
},
"reddit_dd": {
"count": 2,
"wins_1d": 0,
"losses_1d": 0,
"wins_7d": 0,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0,
"avg_return_7d": 0,
"avg_return_30d": 0
}
},
"overall_1d": {
"count": 185,
"wins": 96,
"avg_return": -0.05,
"win_rate": 51.9
},
"overall_7d": {
"count": 125,
"wins": 64,
"avg_return": 0.13,
"win_rate": 51.2
},
"overall_30d": {
"count": 0,
"wins": 0,
"avg_return": 0
}
}

592
data/tickers.txt Normal file
View File

@ -0,0 +1,592 @@
AA
AAL
AAP
AAPL
ABBV
ABT
ACGL
ACN
ADBE
ADM
ADP
ADSK
AEE
AEP
AES
AFL
AIV
AKAM
ALB
ALGN
ALK
ALL
AMAT
AMD
AME
AMGN
AMT
AMZN
ANF
AON
AOS
APA
APD
APH
ARE
ATKR
ATO
AVB
AVGO
AVY
AWK
AXON
AXP
AZO
BA
BAC
BAX
BBWI
BBY
BEN
BF-B
BIIB
BIO
BK
BKNG
BKR
BLK
BLMN
BMY
BNTX
BR
BRK-B
BRO
BRT
BRX
BSX
BWA
BXP
C
CAG
CAH
CARR
CAT
CAVA
CB
CBOE
CBRE
CCL
CDNS
CE
CEG
CF
CFG
CHTR
CI
CINF
CL
CLB
CLF
CLH
CLX
CMA
CMC
CMCSA
CME
CMG
CMI
CMS
CNC
CNP
COF
COIN
COMP
COO
COP
COST
CPB
CPRT
CPT
CRL
CRM
CRWD
CSCO
CSGP
CSX
CTAS
CTRA
CTSH
CTVA
CUBE
CURV
CVNA
CVS
CVX
CWH
CWK
CZR
D
DAL
DD
DDOG
DE
DG
DGX
DHI
DHR
DIN
DINO
DIS
DKS
DLR
DLTR
DOV
DPZ
DQ
DRI
DT
DTE
DUK
DVA
DVN
DXCM
EA
EBAY
ECL
ED
EFX
EG
EIX
EL
ELV
EMN
EMR
ENPH
ENTG
EOG
EPAM
EQH
EQIX
EQR
EQT
ES
ESS
ESTC
ETN
ETR
ETSY
EVH
EVRG
EWBC
EXAS
EXC
EXPD
EXPE
EXPI
F
FANG
FAST
FBNC
FCNCA
FCX
FDS
FDX
FE
FFIV
FHI
FIS
FISV
FITB
FIVE
FIVN
FMC
FNB
FNF
FOX
FOXA
FRT
FSLR
FTI
FTNT
FTV
FWRD
G
GATX
GD
GE
GEHC
GEN
GILD
GIS
GL
GM
GNRC
GOOG
GOOGL
GPC
GPN
GRMN
GS
GSHD
GTLS
HAL
HAS
HBAN
HBI
HCA
HD
HIG
HII
HLT
HOG
HOLX
HOMB
HON
HOOD
HPE
HRL
HSIC
HST
HSY
HUM
HWM
HXL
IBM
ICE
IDXX
IEX
IFF
ILMN
INCY
INTC
INVH
IP
IPG
IQV
IR
IRM
ISRG
IT
IVZ
JACK
JBHT
JBL
JCI
JKHY
JLL
JNJ
JPM
K
KDP
KEY
KHC
KIM
KLAC
KMB
KMI
KMX
KNX
KO
KR
KRC
L
LAD
LAMR
LBRDA
LBRDK
LCID
LDOS
LEN
LFUS
LHX
LIN
LLY
LMT
LNC
LNT
LPLA
LRCX
LUMN
LUV
LVS
LYB
LYV
MA
MAA
MAR
MAS
MAT
MCHP
MCK
MCO
MDB
MDLZ
MDT
MELI
MET
META
MGM
MHK
MKC
MKTX
MLI
MMI
MMM
MNST
MO
MOH
MOS
MPC
MPWR
MRK
MRNA
MRVL
MS
MSCI
MSFT
MSI
MT
MTB
MTCH
MTD
MTRX
MUR
NCLH
NDAQ
NEE
NEM
NET
NFLX
NI
NKE
NOC
NOV
NRG
NSC
NTAP
NTRS
NUE
NVAX
NVDA
NVR
NVST
NXPI
O
ODFL
OGN
OI
OKTA
OMC
OMCL
ON
ONB
ONON
OPEN
ORCL
ORLY
OTIS
OVV
OXY
PAG
PAYC
PAYX
PCAR
PCG
PEG
PENN
PEP
PFE
PG
PGR
PH
PHM
PII
PKG
PLD
PLTR
PM
PNC
PNR
PODD
POOL
PPG
PPL
PRGO
PSA
PSX
PTC
PVH
PWR
PYPL
PZZA
QCOM
QLYS
QRVO
RBLX
RCL
REG
REGN
REIT
RELX
RGA
RHI
RIO
RIVN
RJF
RKT
RL
RMD
RNR
ROL
ROP
ROST
RRC
RS
RSG
RTX
RVLV
RXO
RYAN
SAIC
SBAC
SBUX
SCI
SEE
SHAK
SJM
SLB
SLGN
SMCI
SNA
SNPS
SO
SPG
SPGI
SRE
STE
STLD
STT
STX
STZ
SWK
SWKS
SYF
SYK
SYY
T
TAP
TCBI
TCOM
TDG
TDOC
TDY
TEAM
TECH
TEL
TENB
TER
TFC
TFX
TGT
TJX
TKO
TMO
TNDM
TOL
TOST
TPG
TRGP
TRV
TSCO
TSLA
TSN
TT
TTD
TTWO
TXN
TXT
TYL
U
UAL
UDR
UHS
ULTA
UNH
UNP
UPS
URI
USB
USFD
UTHR
UWMC
V
VALE
VEEV
VFC
VICI
VLO
VMC
VMI
VNO
VNT
VOD
VRM
VRNS
VRSK
VRSN
VRTX
VSAT
VST
VTR
VTRS
VTYX
VZ
W
WAB
WAL
WAT
WBD
WBS
WCC
WDAY
WDC
WEC
WELL
WEN
WEX
WFC
WHR
WING
WLK
WM
WMB
WMT
WOLF
WOOF
WOR
WPC
WRB
WSM
WSO
WTFC
WTM
WTRG
WTS
WWD
WY
WYNN
XEL
XOM
XPO
XYL
YELP
YETI
YUM
Z
ZBH
ZBRA
ZION
ZM
ZS
ZTS
ZWS

1013
docs/plans/2026-02-05-modular-pipeline-architecture.md Normal file
View File

File diff suppressed because it is too large Load Diff

1269
docs/plans/2026-02-05-volume-analysis-enhancements-design.md Normal file
View File

File diff suppressed because it is too large Load Diff

44
docs/plans/2026-02-09-ml-win-probability-model.md Normal file
View File

@ -0,0 +1,44 @@
# ML Win Probability Model — TabPFN + Triple-Barrier
## Overview
Add an ML model that predicts win probability for each discovery candidate.
- **Training data**: Universe-wide historical simulation (~375K labeled samples)
- **Model**: TabPFN (foundation model for tabular data) with LightGBM fallback
- **Labels**: Triple-barrier method (+5% profit, -3% stop loss, 7-day timeout)
- **Integration**: Adds `ml_win_probability` field during enrichment
## Components
### 1. Feature Engineering (`tradingagents/ml/feature_engineering.py`)
Shared feature extraction used by both training and inference.
20 features computed locally from OHLCV via stockstats + pandas.
### 2. Dataset Builder (`scripts/build_ml_dataset.py`)
- Fetches OHLCV for ~500 stocks × 3 years
- Computes features locally (no API calls for indicators)
- Applies triple-barrier labels
- Outputs `data/ml/training_dataset.parquet`
### 3. Model Trainer (`scripts/train_ml_model.py`)
- Time-based train/validation split
- TabPFN or LightGBM training
- Walk-forward evaluation
- Outputs `data/ml/tabpfn_model.pkl` + `data/ml/metrics.json`
### 4. Pipeline Integration
- `tradingagents/ml/predictor.py` — model loading + inference
- `tradingagents/dataflows/discovery/filter.py` — call predictor during enrichment
- `tradingagents/dataflows/discovery/ranker.py` — surface in LLM prompt
## Triple-Barrier Labels
```
+1 (WIN): Price hits +5% within 7 trading days
-1 (LOSS): Price hits -3% within 7 trading days
0 (TIMEOUT): Neither barrier hit
```
## Features (20)
All computed locally from OHLCV — zero API calls for indicators.
rsi_14, macd, macd_signal, macd_hist, atr_pct, bb_width_pct, bb_position,
adx, mfi, stoch_k, volume_ratio_5d, volume_ratio_20d, return_1d, return_5d,
return_20d, sma50_distance, sma200_distance, high_low_range, gap_pct, log_market_cap

11
main.py
View File

@ -1,11 +1,14 @@
from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG
from dotenv import load_dotenv
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.utils.logger import get_logger
# Load environment variables from .env file
load_dotenv()
logger = get_logger(__name__)
# Create a custom config
config = DEFAULT_CONFIG.copy()
config["deep_think_llm"] = "gpt-4o-mini" # Use a different model
@ -25,7 +28,7 @@ ta = TradingAgentsGraph(debug=True, config=config)
# forward propagate
_, decision = ta.propagate("NVDA", "2024-05-10")
print(decision)
logger.info(decision)
# Memorize mistakes and reflect
# ta.reflect_and_remember(1000) # parameter is the position returns

38
pyproject.toml
View File

@ -12,6 +12,7 @@ dependencies = [
"eodhd>=1.0.32",
"feedparser>=6.0.11",
"finnhub-python>=2.4.23",
"google-genai>=1.60.0",
"grip>=4.6.2",
"langchain-anthropic>=0.3.15",
"langchain-experimental>=0.3.4",
@ -23,13 +24,50 @@ dependencies = [
"praw>=7.8.1",
"pytz>=2025.2",
"questionary>=2.1.0",
"rapidfuzz>=3.14.3",
"redis>=6.2.0",
"requests>=2.32.4",
"rich>=14.0.0",
"plotext>=5.2.8",
"plotille>=5.0.0",
"setuptools>=80.9.0",
"stockstats>=0.6.5",
"tavily>=1.1.0",
"tqdm>=4.67.1",
"tushare>=1.4.21",
"typing-extensions>=4.14.0",
"yfinance>=0.2.63",
"streamlit>=1.40.0",
"plotly>=5.18.0",
"lightgbm>=4.6.0",
"tabpfn>=2.1.3",
]
[dependency-groups]
dev = [
"black>=24.0.0",
"ruff>=0.8.0",
"pytest>=8.0.0",
]
[tool.black]
line-length = 100
target-version = ['py310']
include = '\.pyi?$'
[tool.ruff]
line-length = 100
target-version = "py310"
[tool.ruff.lint]
select = [
"E", # pycodestyle errors
"W", # pycodestyle warnings
"F", # pyflakes
"I", # isort
"B", # flake8-bugbear
"C4", # flake8-comprehensions
]
ignore = [
"E501", # line too long (handled by black)
]

5
requirements.txt
View File

@ -1,3 +1,4 @@
-e .
typing-extensions
langchain-openai
langchain-experimental
@ -25,3 +26,7 @@ questionary
langchain_anthropic
langchain-google-genai
tweepy
plotext
plotille
streamlit>=1.40.0
plotly>=5.18.0

355
scripts/analyze_insider_transactions.py Normal file
View File

@ -0,0 +1,355 @@
#!/usr/bin/env python3
"""
Insider Transactions Aggregation Script
Aggregates insider transactions by:
- Position (CEO, CFO, Director, etc.)
- Year
- Transaction Type (Sale, Purchase, Gift, Grant/Exercise)
Usage:
python scripts/analyze_insider_transactions.py AAPL
python scripts/analyze_insider_transactions.py TSLA NVDA MSFT
python scripts/analyze_insider_transactions.py AAPL --csv # Save to CSV
"""
import os
import sys
from datetime import datetime
from pathlib import Path
import pandas as pd
import yfinance as yf
sys.path.insert(0, str(Path(__file__).parent.parent))
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def classify_transaction(text):
"""Classify transaction type based on text description."""
if pd.isna(text) or text == "":
return "Grant/Exercise"
text_lower = str(text).lower()
if "sale" in text_lower:
return "Sale"
elif "purchase" in text_lower or "buy" in text_lower:
return "Purchase"
elif "gift" in text_lower:
return "Gift"
else:
return "Other"
def analyze_insider_transactions(ticker: str, save_csv: bool = False, output_dir: str = None):
"""Analyze and aggregate insider transactions for a given ticker.
Args:
ticker: Stock ticker symbol
save_csv: Whether to save results to CSV files
output_dir: Directory to save CSV files (default: current directory)
Returns:
Dictionary with DataFrames: 'by_position', 'yearly', 'sentiment'
"""
logger.info(f"\n{'='*80}")
logger.info(f"INSIDER TRANSACTIONS ANALYSIS: {ticker.upper()}")
logger.info(f"{'='*80}")
result = {"by_position": None, "by_person": None, "yearly": None, "sentiment": None}
try:
ticker_obj = yf.Ticker(ticker.upper())
data = ticker_obj.insider_transactions
if data is None or data.empty:
logger.warning(f"No insider transaction data found for {ticker}")
return result
# Parse transaction type and year
data["Transaction"] = data["Text"].apply(classify_transaction)
data["Year"] = pd.to_datetime(data["Start Date"]).dt.year
# ============================================================
# BY POSITION, YEAR, TRANSACTION TYPE
# ============================================================
logger.info("\n## BY POSITION\n")
agg = (
data.groupby(["Position", "Year", "Transaction"])
.agg({"Shares": "sum", "Value": "sum"})
.reset_index()
)
agg["Ticker"] = ticker.upper()
result["by_position"] = agg
for position in sorted(agg["Position"].unique()):
logger.info(f"\n### {position}")
logger.info("-" * 50)
pos_data = agg[agg["Position"] == position].sort_values(
["Year", "Transaction"], ascending=[False, True]
)
for _, row in pos_data.iterrows():
value_str = (
f"${row['Value']:>15,.0f}"
if pd.notna(row["Value"]) and row["Value"] > 0
else f"{'N/A':>16}"
)
logger.info(
f" {row['Year']} | {row['Transaction']:15} | {row['Shares']:>12,.0f} shares | {value_str}"
)
# ============================================================
# BY INSIDER
# ============================================================
logger.info(f"\n\n{'='*80}")
logger.info("INSIDER TRANSACTIONS BY PERSON")
logger.info(f"{'='*80}")
insider_col = "Insider"
if insider_col not in data.columns and "Name" in data.columns:
insider_col = "Name"
if insider_col in data.columns:
agg_person = (
data.groupby([insider_col, "Position", "Year", "Transaction"])
.agg({"Shares": "sum", "Value": "sum"})
.reset_index()
)
agg_person["Ticker"] = ticker.upper()
result["by_person"] = agg_person
for person in sorted(agg_person[insider_col].unique()):
logger.info(f"\n### {str(person)}")
logger.info("-" * 50)
p_data = agg_person[agg_person[insider_col] == person].sort_values(
["Year", "Transaction"], ascending=[False, True]
)
for _, row in p_data.iterrows():
value_str = (
f"${row['Value']:>15,.0f}"
if pd.notna(row["Value"]) and row["Value"] > 0
else f"{'N/A':>16}"
)
pos_str = str(row["Position"])[:25]
logger.info(
f" {row['Year']} | {pos_str:25} | {row['Transaction']:15} | {row['Shares']:>12,.0f} shares | {value_str}"
)
else:
logger.warning(
f"Warning: Could not find 'Insider' or 'Name' column in data. Columns: {data.columns.tolist()}"
)
# ============================================================
# YEARLY SUMMARY
# ============================================================
logger.info(f"\n\n{'='*80}")
logger.info("YEARLY SUMMARY BY TRANSACTION TYPE")
logger.info(f"{'='*80}")
yearly = (
data.groupby(["Year", "Transaction"])
.agg({"Shares": "sum", "Value": "sum"})
.reset_index()
)
yearly["Ticker"] = ticker.upper()
result["yearly"] = yearly
for year in sorted(yearly["Year"].unique(), reverse=True):
logger.info(f"\n{year}:")
year_data = yearly[yearly["Year"] == year].sort_values("Transaction")
for _, row in year_data.iterrows():
value_str = (
f"${row['Value']:>15,.0f}"
if pd.notna(row["Value"]) and row["Value"] > 0
else f"{'N/A':>16}"
)
logger.info(
f" {row['Transaction']:15} | {row['Shares']:>12,.0f} shares | {value_str}"
)
# ============================================================
# OVERALL SENTIMENT
# ============================================================
logger.info(f"\n\n{'='*80}")
logger.info("INSIDER SENTIMENT SUMMARY")
logger.info(f"{'='*80}\n")
total_sales = data[data["Transaction"] == "Sale"]["Value"].sum()
total_purchases = data[data["Transaction"] == "Purchase"]["Value"].sum()
sales_count = len(data[data["Transaction"] == "Sale"])
purchases_count = len(data[data["Transaction"] == "Purchase"])
net_value = total_purchases - total_sales
# Determine sentiment
if total_purchases > total_sales:
sentiment = "BULLISH"
elif total_sales > total_purchases * 2:
sentiment = "BEARISH"
elif total_sales > total_purchases:
sentiment = "SLIGHTLY_BEARISH"
else:
sentiment = "NEUTRAL"
result["sentiment"] = pd.DataFrame(
[
{
"Ticker": ticker.upper(),
"Total_Sales_Count": sales_count,
"Total_Sales_Value": total_sales,
"Total_Purchases_Count": purchases_count,
"Total_Purchases_Value": total_purchases,
"Net_Value": net_value,
"Sentiment": sentiment,
}
]
)
logger.info(f"Total Sales: {sales_count:>5} transactions | ${total_sales:>15,.0f}")
logger.info(
f"Total Purchases: {purchases_count:>5} transactions | ${total_purchases:>15,.0f}"
)
if sentiment == "BULLISH":
logger.info(f"\n⚡ BULLISH: Insiders are net BUYERS (${net_value:,.0f} net buying)")
elif sentiment == "BEARISH":
logger.info(
f"\n⚠️ BEARISH: Significant insider SELLING (${-net_value:,.0f} net selling)"
)
elif sentiment == "SLIGHTLY_BEARISH":
logger.info(
f"\n⚠️ SLIGHTLY BEARISH: More selling than buying (${-net_value:,.0f} net selling)"
)
else:
logger.info("\n📊 NEUTRAL: Balanced insider activity")
# Save to CSV if requested
if save_csv:
if output_dir is None:
output_dir = os.getcwd()
os.makedirs(output_dir, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
# Save by position
by_pos_file = os.path.join(
output_dir, f"insider_by_position_{ticker.upper()}_{timestamp}.csv"
)
agg.to_csv(by_pos_file, index=False)
logger.info(f"\n📁 Saved: {by_pos_file}")
# Save by person
if result["by_person"] is not None:
by_person_file = os.path.join(
output_dir, f"insider_by_person_{ticker.upper()}_{timestamp}.csv"
)
result["by_person"].to_csv(by_person_file, index=False)
logger.info(f"📁 Saved: {by_person_file}")
# Save yearly summary
yearly_file = os.path.join(
output_dir, f"insider_yearly_{ticker.upper()}_{timestamp}.csv"
)
yearly.to_csv(yearly_file, index=False)
logger.info(f"📁 Saved: {yearly_file}")
# Save sentiment summary
sentiment_file = os.path.join(
output_dir, f"insider_sentiment_{ticker.upper()}_{timestamp}.csv"
)
result["sentiment"].to_csv(sentiment_file, index=False)
logger.info(f"📁 Saved: {sentiment_file}")
except Exception as e:
logger.error(f"Error analyzing {ticker}: {str(e)}")
return result
if __name__ == "__main__":
if len(sys.argv) < 2:
logger.info(
"Usage: python analyze_insider_transactions.py TICKER [TICKER2 ...] [--csv] [--output-dir DIR]"
)
logger.info("Example: python analyze_insider_transactions.py AAPL TSLA NVDA")
logger.info(" python analyze_insider_transactions.py AAPL --csv")
logger.info(
" python analyze_insider_transactions.py AAPL --csv --output-dir ./output"
)
sys.exit(1)
# Parse arguments
args = sys.argv[1:]
save_csv = "--csv" in args
output_dir = None
if "--output-dir" in args:
idx = args.index("--output-dir")
if idx + 1 < len(args):
output_dir = args[idx + 1]
args = args[:idx] + args[idx + 2 :]
else:
logger.error("Error: --output-dir requires a directory path")
sys.exit(1)
if save_csv:
args.remove("--csv")
tickers = [t for t in args if not t.startswith("--")]
# Collect all results for combined CSV
all_by_position = []
all_by_person = []
all_yearly = []
all_sentiment = []
for ticker in tickers:
result = analyze_insider_transactions(ticker, save_csv=save_csv, output_dir=output_dir)
if result["by_position"] is not None:
all_by_position.append(result["by_position"])
if result["by_person"] is not None:
all_by_person.append(result["by_person"])
if result["yearly"] is not None:
all_yearly.append(result["yearly"])
if result["sentiment"] is not None:
all_sentiment.append(result["sentiment"])
# If multiple tickers and CSV mode, also save combined files
if save_csv and len(tickers) > 1:
if output_dir is None:
output_dir = os.getcwd()
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
if all_by_position:
combined_pos = pd.concat(all_by_position, ignore_index=True)
combined_pos_file = os.path.join(
output_dir, f"insider_by_position_combined_{timestamp}.csv"
)
combined_pos.to_csv(combined_pos_file, index=False)
logger.info(f"\n📁 Combined: {combined_pos_file}")
if all_by_person:
combined_person = pd.concat(all_by_person, ignore_index=True)
combined_person_file = os.path.join(
output_dir, f"insider_by_person_combined_{timestamp}.csv"
)
combined_person.to_csv(combined_person_file, index=False)
logger.info(f"📁 Combined: {combined_person_file}")
if all_yearly:
combined_yearly = pd.concat(all_yearly, ignore_index=True)
combined_yearly_file = os.path.join(
output_dir, f"insider_yearly_combined_{timestamp}.csv"
)
combined_yearly.to_csv(combined_yearly_file, index=False)
logger.info(f"📁 Combined: {combined_yearly_file}")
if all_sentiment:
combined_sentiment = pd.concat(all_sentiment, ignore_index=True)
combined_sentiment_file = os.path.join(
output_dir, f"insider_sentiment_combined_{timestamp}.csv"
)
combined_sentiment.to_csv(combined_sentiment_file, index=False)
logger.info(f"📁 Combined: {combined_sentiment_file}")

99
scripts/build_historical_memories.py
View File

@ -11,18 +11,23 @@ Usage:
python scripts/build_historical_memories.py
"""
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.agents.utils.historical_memory_builder import HistoricalMemoryBuilder
import pickle
from datetime import datetime, timedelta
from tradingagents.agents.utils.historical_memory_builder import HistoricalMemoryBuilder
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def main():
print("""
logger.info("""
╔══════════════════════════════════════════════════════════════╗
║ TradingAgents - Historical Memory Builder ║
╚══════════════════════════════════════════════════════════════╝
@ -30,25 +35,34 @@ def main():
# Configuration
tickers = [
"AAPL", "GOOGL", "MSFT", "NVDA", "TSLA", # Tech
"JPM", "BAC", "GS", # Finance
"XOM", "CVX", # Energy
"JNJ", "PFE", # Healthcare
"WMT", "AMZN" # Retail
"AAPL",
"GOOGL",
"MSFT",
"NVDA",
"TSLA", # Tech
"JPM",
"BAC",
"GS", # Finance
"XOM",
"CVX", # Energy
"JNJ",
"PFE", # Healthcare
"WMT",
"AMZN", # Retail
]
# Date range - last 2 years
end_date = datetime.now()
start_date = end_date - timedelta(days=730) # 2 years
print(f"Tickers: {', '.join(tickers)}")
print(f"Period: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
print(f"Lookforward: 7 days (1 week returns)")
print(f"Sample interval: 30 days (monthly)\n")
logger.info(f"Tickers: {', '.join(tickers)}")
logger.info(f"Period: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
logger.info("Lookforward: 7 days (1 week returns)")
logger.info("Sample interval: 30 days (monthly)\n")
proceed = input("Proceed with memory building? (y/n): ")
if proceed.lower() != 'y':
print("Aborted.")
if proceed.lower() != "y":
logger.info("Aborted.")
return
# Build memories
@ -59,7 +73,7 @@ def main():
start_date=start_date.strftime("%Y-%m-%d"),
end_date=end_date.strftime("%Y-%m-%d"),
lookforward_days=7,
interval_days=30
interval_days=30,
)
# Save to disk
@ -74,39 +88,36 @@ def main():
# Save the ChromaDB collection data
# Note: ChromaDB doesn't serialize well, so we extract the data
collection = memory.situation_collection
data = {
"documents": [],
"metadatas": [],
"embeddings": [],
"ids": []
}
# Get all items from collection
results = collection.get(include=["documents", "metadatas", "embeddings"])
with open(filename, 'wb') as f:
pickle.dump({
"documents": results["documents"],
"metadatas": results["metadatas"],
"embeddings": results["embeddings"],
"ids": results["ids"],
"created_at": timestamp,
"tickers": tickers,
"config": {
"start_date": start_date.strftime("%Y-%m-%d"),
"end_date": end_date.strftime("%Y-%m-%d"),
"lookforward_days": 7,
"interval_days": 30
}
}, f)
with open(filename, "wb") as f:
pickle.dump(
{
"documents": results["documents"],
"metadatas": results["metadatas"],
"embeddings": results["embeddings"],
"ids": results["ids"],
"created_at": timestamp,
"tickers": tickers,
"config": {
"start_date": start_date.strftime("%Y-%m-%d"),
"end_date": end_date.strftime("%Y-%m-%d"),
"lookforward_days": 7,
"interval_days": 30,
},
},
f,
)
print(f"✅ Saved {agent_type} memory to {filename}")
logger.info(f"✅ Saved {agent_type} memory to {filename}")
print(f"\n🎉 Memory building complete!")
print(f" Memories saved to: {memory_dir}")
print(f"\n📝 To use these memories, update DEFAULT_CONFIG with:")
print(f' "memory_dir": "{memory_dir}"')
print(f' "load_historical_memories": True')
logger.info("\n🎉 Memory building complete!")
logger.info(f" Memories saved to: {memory_dir}")
logger.info("\n📝 To use these memories, update DEFAULT_CONFIG with:")
logger.info(f' "memory_dir": "{memory_dir}"')
logger.info(' "load_historical_memories": True')
if __name__ == "__main__":

468
scripts/build_ml_dataset.py Normal file
View File

@ -0,0 +1,468 @@
#!/usr/bin/env python3
"""Build ML training dataset from historical OHLCV data.
Fetches price data for a universe of liquid stocks, computes features
locally via stockstats, and applies triple-barrier labels.
Usage:
python scripts/build_ml_dataset.py
python scripts/build_ml_dataset.py --stocks 100 --years 2
python scripts/build_ml_dataset.py --ticker-file data/tickers_top50.txt
"""
from __future__ import annotations
import argparse
import os
import sys
import time
from pathlib import Path
import pandas as pd
# Add project root to path
project_root = str(Path(__file__).resolve().parent.parent)
if project_root not in sys.path:
sys.path.insert(0, project_root)
from tradingagents.ml.feature_engineering import (
FEATURE_COLUMNS,
MIN_HISTORY_ROWS,
apply_triple_barrier_labels,
compute_features_bulk,
)
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
# Default universe: S&P 500 most liquid by volume (top ~200)
# Can be overridden via --ticker-file
DEFAULT_TICKERS = [
# Mega-cap tech
"AAPL",
"MSFT",
"GOOGL",
"AMZN",
"NVDA",
"META",
"TSLA",
"AVGO",
"ORCL",
"CRM",
"AMD",
"INTC",
"CSCO",
"ADBE",
"NFLX",
"QCOM",
"TXN",
"AMAT",
"MU",
"LRCX",
"KLAC",
"MRVL",
"SNPS",
"CDNS",
"PANW",
"CRWD",
"FTNT",
"NOW",
"UBER",
"ABNB",
# Financials
"JPM",
"BAC",
"WFC",
"GS",
"MS",
"C",
"SCHW",
"BLK",
"AXP",
"USB",
"PNC",
"TFC",
"COF",
"BK",
"STT",
"FITB",
"HBAN",
"RF",
"CFG",
"KEY",
# Healthcare
"UNH",
"JNJ",
"LLY",
"PFE",
"ABBV",
"MRK",
"TMO",
"ABT",
"DHR",
"BMY",
"AMGN",
"GILD",
"ISRG",
"VRTX",
"REGN",
"MDT",
"SYK",
"BSX",
"EW",
"ZTS",
# Consumer
"WMT",
"PG",
"KO",
"PEP",
"COST",
"MCD",
"NKE",
"SBUX",
"TGT",
"LOW",
"HD",
"TJX",
"ROST",
"DG",
"DLTR",
"EL",
"CL",
"KMB",
"GIS",
"K",
# Energy
"XOM",
"CVX",
"COP",
"EOG",
"SLB",
"MPC",
"PSX",
"VLO",
"OXY",
"DVN",
"HAL",
"FANG",
"HES",
"BKR",
"KMI",
"WMB",
"OKE",
"ET",
"TRGP",
"LNG",
# Industrials
"CAT",
"DE",
"UNP",
"UPS",
"HON",
"RTX",
"BA",
"LMT",
"GD",
"NOC",
"GE",
"MMM",
"EMR",
"ITW",
"PH",
"ROK",
"ETN",
"SWK",
"CMI",
"PCAR",
# Materials & Utilities
"LIN",
"APD",
"ECL",
"SHW",
"DD",
"NEM",
"FCX",
"VMC",
"MLM",
"NUE",
"NEE",
"DUK",
"SO",
"D",
"AEP",
"EXC",
"SRE",
"XEL",
"WEC",
"ES",
# REITs & Telecom
"AMT",
"PLD",
"CCI",
"EQIX",
"SPG",
"O",
"PSA",
"DLR",
"WELL",
"AVB",
"T",
"VZ",
"TMUS",
"CHTR",
"CMCSA",
# High-volatility / popular retail
"COIN",
"MARA",
"RIOT",
"PLTR",
"SOFI",
"HOOD",
"RBLX",
"SNAP",
"PINS",
"SQ",
"SHOP",
"SE",
"ROKU",
"DKNG",
"PENN",
"WYNN",
"MGM",
"LVS",
"DASH",
"TTD",
# Biotech
"MRNA",
"BNTX",
"BIIB",
"SGEN",
"ALNY",
"BMRN",
"EXAS",
"DXCM",
"HZNP",
"INCY",
]
OUTPUT_DIR = Path("data/ml")
def fetch_ohlcv(ticker: str, start: str, end: str) -> pd.DataFrame:
"""Fetch OHLCV data for a single ticker via yfinance."""
from tradingagents.dataflows.y_finance import download_history
df = download_history(
ticker,
start=start,
end=end,
multi_level_index=False,
progress=False,
auto_adjust=True,
)
if df.empty:
return df
df = df.reset_index()
return df
def get_market_cap(ticker: str) -> float | None:
"""Get current market cap for a ticker (snapshot — used as static feature)."""
try:
import yfinance as yf
info = yf.Ticker(ticker).info
return info.get("marketCap")
except Exception:
return None
def process_ticker(
ticker: str,
start: str,
end: str,
profit_target: float,
stop_loss: float,
max_holding_days: int,
market_cap: float | None = None,
) -> pd.DataFrame | None:
"""Process a single ticker: fetch data, compute features, apply labels."""
try:
ohlcv = fetch_ohlcv(ticker, start, end)
if ohlcv.empty or len(ohlcv) < MIN_HISTORY_ROWS + max_holding_days:
logger.debug(f"{ticker}: insufficient data ({len(ohlcv)} rows), skipping")
return None
# Compute features
features = compute_features_bulk(ohlcv, market_cap=market_cap)
if features.empty:
logger.debug(f"{ticker}: feature computation failed, skipping")
return None
# Compute triple-barrier labels
close = ohlcv.set_index("Date")["Close"] if "Date" in ohlcv.columns else ohlcv["Close"]
if isinstance(close.index, pd.DatetimeIndex):
pass
else:
close.index = pd.to_datetime(close.index)
labels = apply_triple_barrier_labels(
close,
profit_target=profit_target,
stop_loss=stop_loss,
max_holding_days=max_holding_days,
)
# Align features and labels by date
combined = features.join(labels, how="inner")
# Drop rows with NaN features or labels
combined = combined.dropna(subset=["label"] + FEATURE_COLUMNS)
if combined.empty:
logger.debug(f"{ticker}: no valid rows after alignment, skipping")
return None
# Add metadata columns
combined["ticker"] = ticker
combined["date"] = combined.index
logger.info(
f"{ticker}: {len(combined)} samples "
f"(WIN={int((combined['label'] == 1).sum())}, "
f"LOSS={int((combined['label'] == -1).sum())}, "
f"TIMEOUT={int((combined['label'] == 0).sum())})"
)
return combined
except Exception as e:
logger.warning(f"{ticker}: error processing — {e}")
return None
def build_dataset(
tickers: list[str],
start: str = "2022-01-01",
end: str = "2025-12-31",
profit_target: float = 0.05,
stop_loss: float = 0.03,
max_holding_days: int = 7,
) -> pd.DataFrame:
"""Build the full training dataset across all tickers."""
all_data = []
total = len(tickers)
logger.info(f"Building ML dataset: {total} tickers, {start} to {end}")
logger.info(
f"Triple-barrier: +{profit_target*100:.0f}% profit, "
f"-{stop_loss*100:.0f}% stop, {max_holding_days}d timeout"
)
# Batch-fetch market caps
logger.info("Fetching market caps...")
market_caps = {}
for ticker in tickers:
market_caps[ticker] = get_market_cap(ticker)
time.sleep(0.05) # rate limit courtesy
for i, ticker in enumerate(tickers):
logger.info(f"[{i+1}/{total}] Processing {ticker}...")
result = process_ticker(
ticker=ticker,
start=start,
end=end,
profit_target=profit_target,
stop_loss=stop_loss,
max_holding_days=max_holding_days,
market_cap=market_caps.get(ticker),
)
if result is not None:
all_data.append(result)
# Brief pause between tickers to be polite to yfinance
if (i + 1) % 50 == 0:
logger.info(f"Progress: {i+1}/{total} tickers processed, pausing 2s...")
time.sleep(2)
if not all_data:
logger.error("No data collected — check tickers and date range")
return pd.DataFrame()
dataset = pd.concat(all_data, ignore_index=True)
logger.info(f"\n{'='*60}")
logger.info(f"Dataset built: {len(dataset)} total samples from {len(all_data)} tickers")
logger.info("Label distribution:")
logger.info(
f" WIN (+1): {int((dataset['label'] == 1).sum()):>7} ({(dataset['label'] == 1).mean()*100:.1f}%)"
)
logger.info(
f" LOSS (-1): {int((dataset['label'] == -1).sum()):>7} ({(dataset['label'] == -1).mean()*100:.1f}%)"
)
logger.info(
f" TIMEOUT: {int((dataset['label'] == 0).sum()):>7} ({(dataset['label'] == 0).mean()*100:.1f}%)"
)
logger.info(f"Features: {len(FEATURE_COLUMNS)}")
logger.info(f"{'='*60}")
return dataset
def main():
parser = argparse.ArgumentParser(description="Build ML training dataset")
parser.add_argument(
"--stocks", type=int, default=None, help="Limit to N stocks from default universe"
)
parser.add_argument(
"--ticker-file", type=str, default=None, help="File with tickers (one per line)"
)
parser.add_argument("--start", type=str, default="2022-01-01", help="Start date (YYYY-MM-DD)")
parser.add_argument("--end", type=str, default="2025-12-31", help="End date (YYYY-MM-DD)")
parser.add_argument(
"--profit-target", type=float, default=0.05, help="Profit target fraction (default: 0.05)"
)
parser.add_argument(
"--stop-loss", type=float, default=0.03, help="Stop loss fraction (default: 0.03)"
)
parser.add_argument("--holding-days", type=int, default=7, help="Max holding days (default: 7)")
parser.add_argument("--output", type=str, default=None, help="Output parquet path")
args = parser.parse_args()
# Determine ticker list
if args.ticker_file:
with open(args.ticker_file) as f:
tickers = [
line.strip().upper() for line in f if line.strip() and not line.startswith("#")
]
logger.info(f"Loaded {len(tickers)} tickers from {args.ticker_file}")
else:
tickers = DEFAULT_TICKERS
if args.stocks:
tickers = tickers[: args.stocks]
# Build dataset
dataset = build_dataset(
tickers=tickers,
start=args.start,
end=args.end,
profit_target=args.profit_target,
stop_loss=args.stop_loss,
max_holding_days=args.holding_days,
)
if dataset.empty:
logger.error("Empty dataset — aborting")
sys.exit(1)
# Save
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
output_path = args.output or str(OUTPUT_DIR / "training_dataset.parquet")
dataset.to_parquet(output_path, index=False)
logger.info(f"Saved dataset to {output_path} ({os.path.getsize(output_path) / 1e6:.1f} MB)")
if __name__ == "__main__":
main()

159
scripts/build_strategy_specific_memories.py
View File

@ -9,41 +9,77 @@ This script creates memory sets optimized for:
- Long-term investing (90-day horizon, quarterly samples)
"""
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.agents.utils.historical_memory_builder import HistoricalMemoryBuilder
import pickle
from datetime import datetime, timedelta
from tradingagents.agents.utils.historical_memory_builder import HistoricalMemoryBuilder
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
# Strategy configurations
STRATEGIES = {
"day_trading": {
"lookforward_days": 1, # Next day returns
"interval_days": 1, # Sample daily
"lookforward_days": 1, # Next day returns
"interval_days": 1, # Sample daily
"description": "Day Trading - Capture intraday momentum and next-day moves",
"tickers": ["SPY", "QQQ", "AAPL", "TSLA", "NVDA", "AMD", "AMZN"], # High volume
},
"swing_trading": {
"lookforward_days": 7, # Weekly returns
"interval_days": 7, # Sample weekly
"lookforward_days": 7, # Weekly returns
"interval_days": 7, # Sample weekly
"description": "Swing Trading - Capture week-long trends and momentum",
"tickers": ["AAPL", "GOOGL", "MSFT", "NVDA", "TSLA", "META", "AMZN", "AMD", "NFLX"],
"tickers": [
"AAPL",
"GOOGL",
"MSFT",
"NVDA",
"TSLA",
"META",
"AMZN",
"AMD",
"NFLX",
],
},
"position_trading": {
"lookforward_days": 30, # Monthly returns
"interval_days": 30, # Sample monthly
"lookforward_days": 30, # Monthly returns
"interval_days": 30, # Sample monthly
"description": "Position Trading - Capture monthly trends and fundamentals",
"tickers": ["AAPL", "GOOGL", "MSFT", "NVDA", "TSLA", "JPM", "BAC", "XOM", "JNJ", "WMT"],
"tickers": [
"AAPL",
"GOOGL",
"MSFT",
"NVDA",
"TSLA",
"JPM",
"BAC",
"XOM",
"JNJ",
"WMT",
],
},
"long_term_investing": {
"lookforward_days": 90, # Quarterly returns
"interval_days": 90, # Sample quarterly
"lookforward_days": 90, # Quarterly returns
"interval_days": 90, # Sample quarterly
"description": "Long-term Investing - Capture fundamental value and trends",
"tickers": ["AAPL", "GOOGL", "MSFT", "BRK.B", "JPM", "JNJ", "PG", "KO", "DIS", "V"],
"tickers": [
"AAPL",
"GOOGL",
"MSFT",
"BRK.B",
"JPM",
"JNJ",
"PG",
"KO",
"DIS",
"V",
],
},
}
@ -53,7 +89,7 @@ def build_strategy_memories(strategy_name: str, config: dict):
strategy = STRATEGIES[strategy_name]
print(f"""
logger.info(f"""
╔══════════════════════════════════════════════════════════════╗
║ Building Memories: {strategy_name.upper().replace('_', ' ')}
╚══════════════════════════════════════════════════════════════╝
@ -72,11 +108,11 @@ Tickers: {', '.join(strategy['tickers'])}
builder = HistoricalMemoryBuilder(DEFAULT_CONFIG)
memories = builder.populate_agent_memories(
tickers=strategy['tickers'],
tickers=strategy["tickers"],
start_date=start_date.strftime("%Y-%m-%d"),
end_date=end_date.strftime("%Y-%m-%d"),
lookforward_days=strategy['lookforward_days'],
interval_days=strategy['interval_days']
lookforward_days=strategy["lookforward_days"],
interval_days=strategy["interval_days"],
)
# Save to disk
@ -92,33 +128,36 @@ Tickers: {', '.join(strategy['tickers'])}
collection = memory.situation_collection
results = collection.get(include=["documents", "metadatas", "embeddings"])
with open(filename, 'wb') as f:
pickle.dump({
"documents": results["documents"],
"metadatas": results["metadatas"],
"embeddings": results["embeddings"],
"ids": results["ids"],
"created_at": timestamp,
"strategy": strategy_name,
"tickers": strategy['tickers'],
"config": {
"start_date": start_date.strftime("%Y-%m-%d"),
"end_date": end_date.strftime("%Y-%m-%d"),
"lookforward_days": strategy['lookforward_days'],
"interval_days": strategy['interval_days']
}
}, f)
with open(filename, "wb") as f:
pickle.dump(
{
"documents": results["documents"],
"metadatas": results["metadatas"],
"embeddings": results["embeddings"],
"ids": results["ids"],
"created_at": timestamp,
"strategy": strategy_name,
"tickers": strategy["tickers"],
"config": {
"start_date": start_date.strftime("%Y-%m-%d"),
"end_date": end_date.strftime("%Y-%m-%d"),
"lookforward_days": strategy["lookforward_days"],
"interval_days": strategy["interval_days"],
},
},
f,
)
print(f"✅ Saved {agent_type} memory to {filename}")
logger.info(f"✅ Saved {agent_type} memory to {filename}")
print(f"\n🎉 {strategy_name.replace('_', ' ').title()} memories complete!")
print(f" Saved to: {memory_dir}\n")
logger.info(f"\n🎉 {strategy_name.replace('_', ' ').title()} memories complete!")
logger.info(f" Saved to: {memory_dir}\n")
return memory_dir
def main():
print("""
logger.info("""
╔══════════════════════════════════════════════════════════════╗
║ TradingAgents - Strategy-Specific Memory Builder ║
╚══════════════════════════════════════════════════════════════╝
@ -131,29 +170,31 @@ This script builds optimized memories for different trading styles:
4. Long-term - 90-day returns, quarterly samples
""")
print("Available strategies:")
logger.info("Available strategies:")
for i, (name, config) in enumerate(STRATEGIES.items(), 1):
print(f" {i}. {name.replace('_', ' ').title()}")
print(f" {config['description']}")
print(f" Horizon: {config['lookforward_days']} days, Interval: {config['interval_days']} days\n")
logger.info(f" {i}. {name.replace('_', ' ').title()}")
logger.info(f" {config['description']}")
logger.info(
f" Horizon: {config['lookforward_days']} days, Interval: {config['interval_days']} days\n"
)
choice = input("Choose strategy (1-4, or 'all' for all strategies): ").strip()
if choice.lower() == 'all':
if choice.lower() == "all":
strategies_to_build = list(STRATEGIES.keys())
else:
try:
idx = int(choice) - 1
strategies_to_build = [list(STRATEGIES.keys())[idx]]
except (ValueError, IndexError):
print("Invalid choice. Exiting.")
logger.error("Invalid choice. Exiting.")
return
print(f"\nWill build memories for: {', '.join(strategies_to_build)}")
logger.info(f"\nWill build memories for: {', '.join(strategies_to_build)}")
proceed = input("Proceed? (y/n): ")
if proceed.lower() != 'y':
print("Aborted.")
if proceed.lower() != "y":
logger.info("Aborted.")
return
# Build memories for each selected strategy
@ -163,19 +204,19 @@ This script builds optimized memories for different trading styles:
results[strategy_name] = memory_dir
# Print summary
print("\n" + "="*70)
print("📊 MEMORY BUILDING COMPLETE")
print("="*70)
logger.info("\n" + "=" * 70)
logger.info("📊 MEMORY BUILDING COMPLETE")
logger.info("=" * 70)
for strategy_name, memory_dir in results.items():
print(f"\n{strategy_name.replace('_', ' ').title()}:")
print(f" Location: {memory_dir}")
print(f" Config to use:")
print(f' "memory_dir": "{memory_dir}"')
print(f' "load_historical_memories": True')
logger.info(f"\n{strategy_name.replace('_', ' ').title()}:")
logger.info(f" Location: {memory_dir}")
logger.info(" Config to use:")
logger.info(f' "memory_dir": "{memory_dir}"')
logger.info(' "load_historical_memories": True')
print("\n" + "="*70)
print("\n💡 TIP: To use a specific strategy's memories, update your config:")
print("""
logger.info("\n" + "=" * 70)
logger.info("\n💡 TIP: To use a specific strategy's memories, update your config:")
logger.info("""
config = DEFAULT_CONFIG.copy()
config["memory_dir"] = "data/memories/swing_trading" # or your strategy
config["load_historical_memories"] = True

9
scripts/install_git_hooks.sh Executable file
View File

@ -0,0 +1,9 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(git rev-parse --show-toplevel)"
git config core.hooksPath "$ROOT_DIR/.githooks"
chmod +x "$ROOT_DIR/.githooks/pre-commit"
echo "Git hooks installed (core.hooksPath -> .githooks)."

146
scripts/run_daily_discovery.py Executable file
View File

@ -0,0 +1,146 @@
#!/usr/bin/env python3
"""
Daily Discovery Runner — non-interactive script for cron/launchd scheduling.
Runs the full discovery pipeline (scan → filter → rank), saves recommendations,
and updates position tracking. Designed to run before market open (~8:30 AM ET).
Usage:
python scripts/run_daily_discovery.py # Uses defaults
python scripts/run_daily_discovery.py --date 2026-02-12 # Specific date
python scripts/run_daily_discovery.py --provider google # Override LLM provider
Scheduling (macOS launchd):
See the companion plist at scripts/com.tradingagents.discovery.plist
Scheduling (cron):
30 13 * * 1-5 cd /path/to/TradingAgents && .venv/bin/python scripts/run_daily_discovery.py >> logs/discovery_cron.log 2>&1
(13:30 UTC = 8:30 AM ET, weekdays only)
"""
import argparse
import json
import os
import sys
from datetime import datetime
from pathlib import Path
# Ensure project root is on sys.path
ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
os.chdir(ROOT)
from tradingagents.dataflows.config import set_config
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.graph.discovery_graph import DiscoveryGraph
from tradingagents.utils.logger import get_logger
logger = get_logger("daily_discovery")
def parse_args():
parser = argparse.ArgumentParser(description="Run daily discovery pipeline")
parser.add_argument(
"--date",
default=datetime.now().strftime("%Y-%m-%d"),
help="Analysis date (YYYY-MM-DD), defaults to today",
)
parser.add_argument(
"--provider",
default=None,
help="LLM provider override (openai, google, anthropic)",
)
parser.add_argument(
"--shallow-model",
default=None,
help="Override quick_think_llm model name",
)
parser.add_argument(
"--deep-model",
default=None,
help="Override deep_think_llm model name",
)
parser.add_argument(
"--update-positions",
action="store_true",
default=True,
help="Update position tracking after discovery (default: True)",
)
parser.add_argument(
"--no-update-positions",
action="store_false",
dest="update_positions",
)
return parser.parse_args()
def run_discovery(args):
"""Run the discovery pipeline with the given arguments."""
config = DEFAULT_CONFIG.copy()
# Apply overrides
if args.provider:
config["llm_provider"] = args.provider.lower()
if args.shallow_model:
config["quick_think_llm"] = args.shallow_model
if args.deep_model:
config["deep_think_llm"] = args.deep_model
set_config(config)
# Create results directory
run_timestamp = datetime.now().strftime("%H_%M_%S")
results_dir = Path(config["results_dir"]) / "discovery" / args.date / f"run_{run_timestamp}"
results_dir.mkdir(parents=True, exist_ok=True)
config["discovery_run_dir"] = str(results_dir)
logger.info(f"Starting daily discovery for {args.date}")
logger.info(
f"Provider: {config['llm_provider']} | "
f"Shallow: {config['quick_think_llm']} | "
f"Deep: {config['deep_think_llm']}"
)
# Run discovery
graph = DiscoveryGraph(config=config)
result = graph.run(trade_date=args.date)
final_ranking = result.get("final_ranking", "No ranking available")
logger.info(f"Discovery complete. Results saved to {results_dir}")
return result
def update_positions():
"""Run position updates after discovery."""
try:
from scripts.update_positions import main as update_main
logger.info("Updating position tracking...")
update_main()
except Exception as e:
logger.error(f"Position update failed: {e}")
def main():
args = parse_args()
logger.info("=" * 60)
logger.info(f"DAILY DISCOVERY RUN — {datetime.now().isoformat()}")
logger.info("=" * 60)
try:
result = run_discovery(args)
if args.update_positions:
update_positions()
logger.info("Daily discovery completed successfully")
except Exception as e:
logger.error(f"Discovery failed: {e}", exc_info=True)
sys.exit(1)
if __name__ == "__main__":
main()

173
scripts/scan_reddit_dd.py Executable file
View File

@ -0,0 +1,173 @@
#!/usr/bin/env python3
"""
Standalone Reddit DD Scanner
Scans Reddit for undiscovered high-quality Due Diligence posts and generates a markdown report.
Usage:
python scripts/scan_reddit_dd.py [--hours HOURS] [--limit LIMIT] [--output FILE]
Examples:
python scripts/scan_reddit_dd.py
python scripts/scan_reddit_dd.py --hours 48 --limit 150
python scripts/scan_reddit_dd.py --output reports/reddit_dd_2024_01_15.md
"""
import argparse
import os
import sys
from datetime import datetime
from pathlib import Path
from dotenv import load_dotenv
from tradingagents.utils.logger import get_logger
load_dotenv()
# Add parent directory to path
sys.path.insert(0, str(Path(__file__).parent.parent))
logger = get_logger(__name__)
from langchain_openai import ChatOpenAI
from tradingagents.dataflows.reddit_api import get_reddit_undiscovered_dd
def main():
parser = argparse.ArgumentParser(description="Scan Reddit for high-quality DD posts")
parser.add_argument("--hours", type=int, default=72, help="Hours to look back (default: 72)")
parser.add_argument(
"--limit", type=int, default=100, help="Number of posts to scan (default: 100)"
)
parser.add_argument(
"--top", type=int, default=15, help="Number of top DD to include (default: 15)"
)
parser.add_argument(
"--output",
type=str,
help="Output markdown file (default: reports/reddit_dd_YYYY_MM_DD.md)",
)
parser.add_argument(
"--min-score", type=int, default=55, help="Minimum quality score (default: 55)"
)
parser.add_argument(
"--model",
type=str,
default="gpt-4o-mini",
help="LLM model to use (default: gpt-4o-mini)",
)
parser.add_argument("--temperature", type=float, default=0, help="LLM temperature (default: 0)")
parser.add_argument(
"--comments",
type=int,
default=10,
help="Number of top comments to include (default: 10)",
)
args = parser.parse_args()
# Setup output file
if args.output:
output_file = args.output
else:
# Create reports directory if it doesn't exist
reports_dir = Path(__file__).parent.parent / "reports"
reports_dir.mkdir(exist_ok=True)
timestamp = datetime.now().strftime("%Y_%m_%d_%H%M")
output_file = reports_dir / f"reddit_dd_{timestamp}.md"
logger.info("=" * 70)
logger.info("📊 REDDIT DD SCANNER")
logger.info("=" * 70)
logger.info(f"Lookback: {args.hours} hours")
logger.info(f"Scan limit: {args.limit} posts")
logger.info(f"Top results: {args.top}")
logger.info(f"Min quality score: {args.min_score}")
logger.info(f"LLM model: {args.model}")
logger.info(f"Temperature: {args.temperature}")
logger.info(f"Output: {output_file}")
logger.info("=" * 70)
logger.info("")
# Initialize LLM
logger.info("Initializing LLM...")
llm = ChatOpenAI(
model=args.model,
temperature=args.temperature,
api_key=os.getenv("OPENAI_API_KEY"),
)
# Scan Reddit
logger.info(f"\n🔍 Scanning Reddit (last {args.hours} hours)...\n")
dd_report = get_reddit_undiscovered_dd(
lookback_hours=args.hours,
scan_limit=args.limit,
top_n=args.top,
num_comments=args.comments,
llm_evaluator=llm,
)
# Add header with metadata
header = f"""# 📊 Reddit DD Scanner Report
**Generated:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
**Lookback Period:** {args.hours} hours
**Posts Scanned:** {args.limit}
**Minimum Quality Score:** {args.min_score}/100
---
"""
full_report = header + dd_report
# Save to file
with open(output_file, "w") as f:
f.write(full_report)
logger.info("\n" + "=" * 70)
logger.info(f"✅ Report saved to: {output_file}")
logger.info("=" * 70)
# Print summary
logger.info("\n📈 SUMMARY:")
# Count quality posts by parsing the report
import re
quality_match = re.search(r"\*\*High Quality:\*\* (\d+) DD posts", dd_report)
scanned_match = re.search(r"\*\*Scanned:\*\* (\d+) posts", dd_report)
if scanned_match and quality_match:
scanned = int(scanned_match.group(1))
quality = int(quality_match.group(1))
logger.info(f" • Posts scanned: {scanned}")
logger.info(f" • Quality DD found: {quality}")
if scanned > 0:
logger.info(f" • Quality rate: {(quality/scanned)*100:.1f}%")
# Extract tickers
ticker_matches = re.findall(r"\*\*Ticker:\*\* \$([A-Z]+)", dd_report)
if ticker_matches:
unique_tickers = list(set(ticker_matches))
logger.info(f" • Tickers mentioned: {', '.join(['$' + t for t in unique_tickers])}")
logger.info("")
logger.info("💡 TIP: Review the report and investigate promising opportunities!")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
logger.warning("\n\n⚠️ Scan interrupted by user")
sys.exit(1)
except Exception as e:
logger.error(f"\n❌ Error: {str(e)}")
import traceback
traceback.print_exc()
sys.exit(1)

275
scripts/track_recommendation_performance.py Normal file
View File

@ -0,0 +1,275 @@
#!/usr/bin/env python3
"""
Daily Performance Tracker
Tracks the performance of historical recommendations and updates the database.
Run this daily (via cron or manually) to monitor how recommendations perform over time.
Usage:
python scripts/track_recommendation_performance.py
Cron example (runs daily at 5pm after market close):
0 17 * * 1-5 cd /path/to/TradingAgents && python scripts/track_recommendation_performance.py
"""
import glob
import json
import os
import sys
from datetime import datetime
from typing import Any, Dict, List
# Add parent directory to path
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from tradingagents.dataflows.y_finance import get_stock_price
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def load_recommendations() -> List[Dict[str, Any]]:
"""Load all historical recommendations, preferring the performance database.
The performance database preserves accumulated return data (return_1d,
return_7d, win_1d, etc.) across runs. Raw date files are only used to
pick up new recommendations not yet in the database.
"""
recommendations_dir = "data/recommendations"
if not os.path.exists(recommendations_dir):
logger.warning(f"No recommendations directory found at {recommendations_dir}")
return []
# Step 1: Load existing accumulated data from the performance database
existing: Dict[str, Dict[str, Any]] = {}
db_path = os.path.join(recommendations_dir, "performance_database.json")
if os.path.exists(db_path):
try:
with open(db_path, "r") as f:
db = json.load(f)
for recs in db.get("recommendations_by_date", {}).values():
if isinstance(recs, list):
for rec in recs:
key = f"{rec.get('ticker')}|{rec.get('discovery_date')}"
existing[key] = rec
logger.info(f"Loaded {len(existing)} records from performance database")
except Exception as e:
logger.error(f"Error loading performance database: {e}")
# Step 2: Scan raw date files for any new recommendations
new_count = 0
for filepath in glob.glob(os.path.join(recommendations_dir, "*.json")):
basename = os.path.basename(filepath)
if basename in ("performance_database.json", "statistics.json"):
continue
try:
with open(filepath, "r") as f:
data = json.load(f)
recs = data.get("recommendations", [])
run_date = data.get("date", basename.replace(".json", ""))
for rec in recs:
rec["discovery_date"] = run_date
key = f"{rec.get('ticker')}|{run_date}"
if key not in existing:
existing[key] = rec
new_count += 1
except Exception as e:
logger.error(f"Error loading {filepath}: {e}")
if new_count:
logger.info(f"Merged {new_count} new recommendations from raw files")
return list(existing.values())
def _parse_price(raw) -> float | None:
"""Extract a numeric price from get_stock_price output.
The function may return a float directly or a markdown string like
"**Current Price**: $123.45". Handle both cases.
"""
if raw is None:
return None
if isinstance(raw, (int, float)):
return float(raw)
import re
m = re.search(r"\$([0-9,.]+)", str(raw))
return float(m.group(1).replace(",", "")) if m else None
def update_performance(recommendations: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
"""Update performance metrics for all recommendations."""
today = datetime.now().strftime("%Y-%m-%d")
for rec in recommendations:
ticker = rec.get("ticker")
discovery_date = rec.get("discovery_date")
entry_price = rec.get("entry_price")
if not all([ticker, discovery_date, entry_price]):
continue
if rec.get("status") == "closed":
continue
try:
current_price = _parse_price(get_stock_price(ticker, curr_date=today))
if current_price is None:
logger.warning(f"Could not get price for {ticker}")
continue
rec_date = datetime.strptime(discovery_date, "%Y-%m-%d")
days_held = (datetime.now() - rec_date).days
return_pct = ((current_price - entry_price) / entry_price) * 100
rec["current_price"] = current_price
rec["return_pct"] = round(return_pct, 2)
rec["days_held"] = days_held
rec["last_updated"] = today
# Capture milestone returns (only once per milestone)
if days_held >= 1 and "return_1d" not in rec:
rec["return_1d"] = round(return_pct, 2)
rec["win_1d"] = return_pct > 0
if days_held >= 7 and "return_7d" not in rec:
rec["return_7d"] = round(return_pct, 2)
rec["win_7d"] = return_pct > 0
if days_held >= 30 and "return_30d" not in rec:
rec["return_30d"] = round(return_pct, 2)
rec["win_30d"] = return_pct > 0
rec["status"] = "closed"
logger.info(
f"✓ {ticker}: Entry ${entry_price:.2f} → Current ${current_price:.2f} ({return_pct:+.1f}%) [{days_held}d]"
)
except Exception as e:
logger.error(f"✗ Error tracking {ticker}: {e}")
return recommendations
def save_performance_database(recommendations: List[Dict[str, Any]]):
"""Save the updated performance database."""
db_path = "data/recommendations/performance_database.json"
# Group by discovery date for organized storage
by_date = {}
for rec in recommendations:
date = rec.get("discovery_date", "unknown")
if date not in by_date:
by_date[date] = []
by_date[date].append(rec)
database = {
"last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"total_recommendations": len(recommendations),
"recommendations_by_date": by_date,
}
with open(db_path, "w") as f:
json.dump(database, f, indent=2)
logger.info(f"\n💾 Saved performance database to {db_path}")
def calculate_statistics(recommendations: List[Dict[str, Any]]) -> Dict[str, Any]:
"""Calculate aggregate statistics from historical performance.
Delegates to DiscoveryAnalytics.calculate_statistics so there is a single
source of truth for strategy normalization and metric calculation.
"""
from tradingagents.dataflows.discovery.analytics import DiscoveryAnalytics
analytics = DiscoveryAnalytics()
return analytics.calculate_statistics(recommendations)
def print_statistics(stats: Dict[str, Any]):
"""Print formatted statistics report."""
logger.info("\n" + "=" * 60)
logger.info("RECOMMENDATION PERFORMANCE STATISTICS")
logger.info("=" * 60)
logger.info(f"\nTotal Recommendations Tracked: {stats['total_recommendations']}")
# Overall stats
logger.info("\n📊 OVERALL PERFORMANCE")
logger.info("-" * 60)
if stats["overall_7d"]["count"] > 0:
logger.info("7-Day Performance:")
logger.info(f" • Tracked: {stats['overall_7d']['count']} recommendations")
logger.info(f" • Win Rate: {stats['overall_7d']['win_rate']}%")
logger.info(f" • Avg Return: {stats['overall_7d']['avg_return']:+.2f}%")
if stats["overall_30d"]["count"] > 0:
logger.info("\n30-Day Performance:")
logger.info(f" • Tracked: {stats['overall_30d']['count']} recommendations")
logger.info(f" • Win Rate: {stats['overall_30d']['win_rate']}%")
logger.info(f" • Avg Return: {stats['overall_30d']['avg_return']:+.2f}%")
# By strategy
if stats["by_strategy"]:
logger.info("\n📈 PERFORMANCE BY STRATEGY")
logger.info("-" * 60)
# Sort by win rate (if available)
sorted_strategies = sorted(
stats["by_strategy"].items(), key=lambda x: x[1].get("win_rate_7d", 0), reverse=True
)
for strategy, data in sorted_strategies:
logger.info(f"\n{strategy}:")
logger.info(f" • Total: {data['count']} recommendations")
if data.get("win_rate_7d"):
logger.info(
f" • 7-Day Win Rate: {data['win_rate_7d']}% ({data['wins_7d']}W/{data['losses_7d']}L)"
)
if data.get("win_rate_30d"):
logger.info(
f" • 30-Day Win Rate: {data['win_rate_30d']}% ({data['wins_30d']}W/{data['losses_30d']}L)"
)
def main():
"""Main execution function."""
logger.info("🔍 Loading historical recommendations...")
recommendations = load_recommendations()
if not recommendations:
logger.warning("No recommendations found to track.")
return
logger.info(f"Found {len(recommendations)} total recommendations")
# Filter to only track open positions (not closed after 30 days)
open_recs = [r for r in recommendations if r.get("status") != "closed"]
logger.info(f"Tracking {len(open_recs)} open positions...")
logger.info("\n📊 Updating performance metrics...\n")
updated_recs = update_performance(recommendations)
logger.info("\n📈 Calculating statistics...")
stats = calculate_statistics(updated_recs)
print_statistics(stats)
save_performance_database(updated_recs)
# Also save stats separately
stats_path = "data/recommendations/statistics.json"
with open(stats_path, "w") as f:
json.dump(stats, f, indent=2)
logger.info(f"💾 Saved statistics to {stats_path}")
logger.info("\n✅ Performance tracking complete!")
if __name__ == "__main__":
main()

407
scripts/train_ml_model.py Normal file
View File

@ -0,0 +1,407 @@
#!/usr/bin/env python3
"""Train ML model on the generated dataset.
Supports TabPFN (recommended, requires GPU or API) and LightGBM (fallback).
Uses time-based train/validation split to prevent data leakage.
Usage:
python scripts/train_ml_model.py
python scripts/train_ml_model.py --model lightgbm
python scripts/train_ml_model.py --model tabpfn --dataset data/ml/training_dataset.parquet
python scripts/train_ml_model.py --max-train-samples 5000
"""
from __future__ import annotations
import argparse
import json
import os
import sys
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.metrics import (
accuracy_score,
classification_report,
confusion_matrix,
)
# Add project root to path
project_root = str(Path(__file__).resolve().parent.parent)
if project_root not in sys.path:
sys.path.insert(0, project_root)
from tradingagents.ml.feature_engineering import FEATURE_COLUMNS
from tradingagents.ml.predictor import LGBMWrapper, MLPredictor
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
DATA_DIR = Path("data/ml")
LABEL_NAMES = {-1: "LOSS", 0: "TIMEOUT", 1: "WIN"}
def load_dataset(path: str) -> pd.DataFrame:
"""Load and validate the training dataset."""
df = pd.read_parquet(path)
logger.info(f"Loaded {len(df)} samples from {path}")
# Validate columns
missing = [c for c in FEATURE_COLUMNS if c not in df.columns]
if missing:
raise ValueError(f"Missing feature columns: {missing}")
if "label" not in df.columns:
raise ValueError("Missing 'label' column")
if "date" not in df.columns:
raise ValueError("Missing 'date' column")
# Show label distribution
for label, name in LABEL_NAMES.items():
count = (df["label"] == label).sum()
pct = count / len(df) * 100
logger.info(f" {name:>7} ({label:+d}): {count:>7} ({pct:.1f}%)")
return df
def time_split(
df: pd.DataFrame,
val_start: str = "2024-07-01",
max_train_samples: int | None = None,
) -> tuple:
"""Split dataset by time — train on older data, validate on newer."""
df["date"] = pd.to_datetime(df["date"])
val_start_dt = pd.Timestamp(val_start)
train = df[df["date"] < val_start_dt].copy()
val = df[df["date"] >= val_start_dt].copy()
if max_train_samples is not None and len(train) > max_train_samples:
train = train.sort_values("date").tail(max_train_samples)
logger.info(
f"Limiting training samples to most recent {max_train_samples} " f"before {val_start}"
)
logger.info(f"Time-based split at {val_start}:")
logger.info(
f" Train: {len(train)} samples ({train['date'].min().date()} to {train['date'].max().date()})"
)
logger.info(
f" Val: {len(val)} samples ({val['date'].min().date()} to {val['date'].max().date()})"
)
X_train = train[FEATURE_COLUMNS].values
y_train = train["label"].values.astype(int)
X_val = val[FEATURE_COLUMNS].values
y_val = val["label"].values.astype(int)
return X_train, y_train, X_val, y_val
def train_tabpfn(X_train, y_train, X_val, y_val):
"""Train using TabPFN foundation model."""
try:
from tabpfn import TabPFNClassifier
except ImportError:
logger.error("TabPFN not installed. Install with: pip install tabpfn")
logger.error("Falling back to LightGBM...")
return train_lightgbm(X_train, y_train, X_val, y_val)
logger.info("Training TabPFN classifier...")
# TabPFN handles NaN values natively
# For large datasets, subsample training data (TabPFN works best with <10K samples)
max_train = 10_000
if len(X_train) > max_train:
logger.info(f"Subsampling training data: {len(X_train)} → {max_train}")
idx = np.random.RandomState(42).choice(len(X_train), max_train, replace=False)
X_train_sub = X_train[idx]
y_train_sub = y_train[idx]
else:
X_train_sub = X_train
y_train_sub = y_train
try:
clf = TabPFNClassifier()
clf.fit(X_train_sub, y_train_sub)
return clf, "tabpfn"
except Exception as e:
logger.error(f"TabPFN training failed: {e}")
logger.error("Falling back to LightGBM...")
return train_lightgbm(X_train, y_train, X_val, y_val)
def train_lightgbm(X_train, y_train, X_val, y_val):
"""Train using LightGBM (fallback when TabPFN unavailable)."""
try:
import lightgbm as lgb
except ImportError:
logger.error("LightGBM not installed. Install with: pip install lightgbm")
sys.exit(1)
logger.info("Training LightGBM classifier...")
# Remap labels: {-1, 0, 1} → {0, 1, 2} for LightGBM
y_train_mapped = y_train + 1 # -1→0, 0→1, 1→2
y_val_mapped = y_val + 1
# Compute class weights to handle imbalanced labels
from collections import Counter
class_counts = Counter(y_train_mapped)
total = len(y_train_mapped)
n_classes = len(class_counts)
class_weight = {c: total / (n_classes * count) for c, count in class_counts.items()}
sample_weights = np.array([class_weight[y] for y in y_train_mapped])
train_data = lgb.Dataset(
X_train, label=y_train_mapped, weight=sample_weights, feature_name=FEATURE_COLUMNS
)
val_data = lgb.Dataset(
X_val, label=y_val_mapped, feature_name=FEATURE_COLUMNS, reference=train_data
)
params = {
"objective": "multiclass",
"num_class": 3,
"metric": "multi_logloss",
# Lower LR + more rounds = smoother learning on noisy data
"learning_rate": 0.01,
# More capacity to find feature interactions
"num_leaves": 63,
"max_depth": 8,
"min_child_samples": 100,
# Aggressive subsampling to reduce overfitting on noise
"subsample": 0.7,
"subsample_freq": 1,
"colsample_bytree": 0.7,
# Stronger regularization for financial data
"reg_alpha": 1.0,
"reg_lambda": 1.0,
"min_gain_to_split": 0.01,
"path_smooth": 1.0,
"verbose": -1,
"seed": 42,
}
callbacks = [
lgb.log_evaluation(period=100),
lgb.early_stopping(stopping_rounds=100),
]
booster = lgb.train(
params,
train_data,
num_boost_round=2000,
valid_sets=[val_data],
callbacks=callbacks,
)
# Wrap in sklearn-compatible interface
clf = LGBMWrapper(booster, y_train)
return clf, "lightgbm"
def evaluate(model, X_val, y_val, model_type: str) -> dict:
"""Evaluate model and return metrics dict."""
if isinstance(X_val, np.ndarray):
X_df = pd.DataFrame(X_val, columns=FEATURE_COLUMNS)
else:
X_df = X_val
y_pred = model.predict(X_df)
probas = model.predict_proba(X_df)
accuracy = accuracy_score(y_val, y_pred)
report = classification_report(
y_val,
y_pred,
target_names=["LOSS (-1)", "TIMEOUT (0)", "WIN (+1)"],
output_dict=True,
)
cm = confusion_matrix(y_val, y_pred)
# Win-class specific metrics
win_mask = y_val == 1
if win_mask.sum() > 0:
win_probs = probas[win_mask]
win_col_idx = list(model.classes_).index(1)
avg_win_prob_for_actual_wins = float(win_probs[:, win_col_idx].mean())
else:
avg_win_prob_for_actual_wins = 0.0
# High-confidence win precision
win_col_idx = list(model.classes_).index(1)
high_conf_mask = probas[:, win_col_idx] >= 0.6
if high_conf_mask.sum() > 0:
high_conf_precision = float((y_val[high_conf_mask] == 1).mean())
high_conf_count = int(high_conf_mask.sum())
else:
high_conf_precision = 0.0
high_conf_count = 0
# Calibration analysis: do higher P(WIN) quintiles actually win more?
win_probs_all = probas[:, win_col_idx]
quintile_labels = pd.qcut(win_probs_all, q=5, labels=False, duplicates="drop")
calibration = {}
for q in sorted(set(quintile_labels)):
mask = quintile_labels == q
q_probs = win_probs_all[mask]
q_actual_win_rate = float((y_val[mask] == 1).mean())
q_actual_loss_rate = float((y_val[mask] == -1).mean())
calibration[f"Q{q+1}"] = {
"mean_predicted_win_prob": round(float(q_probs.mean()), 4),
"actual_win_rate": round(q_actual_win_rate, 4),
"actual_loss_rate": round(q_actual_loss_rate, 4),
"count": int(mask.sum()),
}
# Top decile (top 10% by P(WIN)) — most actionable metric
top_decile_threshold = np.percentile(win_probs_all, 90)
top_decile_mask = win_probs_all >= top_decile_threshold
top_decile_win_rate = (
float((y_val[top_decile_mask] == 1).mean()) if top_decile_mask.sum() > 0 else 0.0
)
top_decile_loss_rate = (
float((y_val[top_decile_mask] == -1).mean()) if top_decile_mask.sum() > 0 else 0.0
)
metrics = {
"model_type": model_type,
"accuracy": round(accuracy, 4),
"per_class": {
k: {kk: round(vv, 4) for kk, vv in v.items()}
for k, v in report.items()
if isinstance(v, dict)
},
"confusion_matrix": cm.tolist(),
"avg_win_prob_for_actual_wins": round(avg_win_prob_for_actual_wins, 4),
"high_confidence_win_precision": round(high_conf_precision, 4),
"high_confidence_win_count": high_conf_count,
"calibration_quintiles": calibration,
"top_decile_win_rate": round(top_decile_win_rate, 4),
"top_decile_loss_rate": round(top_decile_loss_rate, 4),
"top_decile_threshold": round(float(top_decile_threshold), 4),
"top_decile_count": int(top_decile_mask.sum()),
"val_samples": len(y_val),
}
# Print summary
logger.info(f"\n{'='*60}")
logger.info(f"Model: {model_type}")
logger.info(f"Overall Accuracy: {accuracy:.1%}")
logger.info("\nPer-class metrics:")
logger.info(f"{'':>15} {'Precision':>10} {'Recall':>10} {'F1':>10} {'Support':>10}")
for label, name in [(-1, "LOSS"), (0, "TIMEOUT"), (1, "WIN")]:
key = f"{name} ({label:+d})"
if key in report:
r = report[key]
logger.info(
f"{name:>15} {r['precision']:>10.3f} {r['recall']:>10.3f} {r['f1-score']:>10.3f} {r['support']:>10.0f}"
)
logger.info("\nConfusion Matrix (rows=actual, cols=predicted):")
logger.info(f"{'':>10} {'LOSS':>8} {'TIMEOUT':>8} {'WIN':>8}")
for i, name in enumerate(["LOSS", "TIMEOUT", "WIN"]):
logger.info(f"{name:>10} {cm[i][0]:>8} {cm[i][1]:>8} {cm[i][2]:>8}")
logger.info("\nWin-class insights:")
logger.info(f" Avg P(WIN) for actual winners: {avg_win_prob_for_actual_wins:.1%}")
logger.info(
f" High-confidence (>60%) precision: {high_conf_precision:.1%} ({high_conf_count} samples)"
)
logger.info("\nCalibration (does higher P(WIN) = more actual wins?):")
logger.info(
f"{'Quintile':>10} {'Avg P(WIN)':>12} {'Actual WIN%':>12} {'Actual LOSS%':>13} {'Count':>8}"
)
for q_name, q_data in calibration.items():
logger.info(
f"{q_name:>10} {q_data['mean_predicted_win_prob']:>12.1%} "
f"{q_data['actual_win_rate']:>12.1%} {q_data['actual_loss_rate']:>13.1%} "
f"{q_data['count']:>8}"
)
logger.info("\nTop decile (top 10% by P(WIN)):")
logger.info(f" Threshold: P(WIN) >= {top_decile_threshold:.1%}")
logger.info(
f" Actual win rate: {top_decile_win_rate:.1%} ({int(top_decile_mask.sum())} samples)"
)
logger.info(f" Actual loss rate: {top_decile_loss_rate:.1%}")
baseline_win = float((y_val == 1).mean())
logger.info(f" Baseline win rate: {baseline_win:.1%}")
if baseline_win > 0:
logger.info(f" Lift over baseline: {top_decile_win_rate / baseline_win:.2f}x")
logger.info(f"{'='*60}")
return metrics
def main():
parser = argparse.ArgumentParser(description="Train ML model for win probability")
parser.add_argument("--dataset", type=str, default="data/ml/training_dataset.parquet")
parser.add_argument(
"--model",
type=str,
choices=["tabpfn", "lightgbm", "auto"],
default="auto",
help="Model type (auto tries TabPFN first, falls back to LightGBM)",
)
parser.add_argument(
"--val-start",
type=str,
default="2024-07-01",
help="Validation split date (default: 2024-07-01)",
)
parser.add_argument(
"--max-train-samples",
type=int,
default=None,
help="Limit training samples to the most recent N before val-start",
)
parser.add_argument("--output-dir", type=str, default="data/ml")
args = parser.parse_args()
if args.max_train_samples is not None and args.max_train_samples <= 0:
logger.error("--max-train-samples must be a positive integer")
sys.exit(1)
# Load dataset
df = load_dataset(args.dataset)
# Split
X_train, y_train, X_val, y_val = time_split(
df,
val_start=args.val_start,
max_train_samples=args.max_train_samples,
)
if len(X_val) == 0:
logger.error(f"No validation data after {args.val_start} — adjust --val-start")
sys.exit(1)
# Train
if args.model == "tabpfn" or args.model == "auto":
model, model_type = train_tabpfn(X_train, y_train, X_val, y_val)
else:
model, model_type = train_lightgbm(X_train, y_train, X_val, y_val)
# Evaluate
metrics = evaluate(model, X_val, y_val, model_type)
# Save model
predictor = MLPredictor(model=model, feature_columns=FEATURE_COLUMNS, model_type=model_type)
model_path = predictor.save(args.output_dir)
logger.info(f"Model saved to {model_path}")
# Save metrics
metrics_path = os.path.join(args.output_dir, "metrics.json")
with open(metrics_path, "w") as f:
json.dump(metrics, f, indent=2)
logger.info(f"Metrics saved to {metrics_path}")
if __name__ == "__main__":
main()

39
scripts/update_delisted_tickers.sh Executable file
View File

@ -0,0 +1,39 @@
#!/bin/bash
# Script to extract consistently failing tickers from the delisted cache
# These are candidates for adding to PERMANENTLY_DELISTED after manual verification
CACHE_FILE="data/delisted_cache.json"
REVIEW_FILE="data/delisted_review.txt"
echo "Analyzing delisted cache for consistently failing tickers..."
if [ ! -f "$CACHE_FILE" ]; then
echo "No delisted cache found at $CACHE_FILE"
echo "Run discovery flow at least once to populate the cache."
exit 0
fi
# Check if jq is installed
if ! command -v jq &> /dev/null; then
echo "Error: jq is required but not installed."
echo "Install it with: brew install jq (macOS) or apt-get install jq (Linux)"
exit 1
fi
# Extract tickers with high fail counts (3+ failures across multiple days)
echo ""
echo "Tickers that have failed 3+ times:"
echo "=================================="
jq -r 'to_entries[] | select(.value.fail_count >= 3) | "\(.key): \(.value.fail_count) failures across \(.value.fail_dates | length) days - \(.value.reason)"' "$CACHE_FILE"
echo ""
echo "---"
echo "Review the tickers above and verify their status using:"
echo " 1. Yahoo Finance: https://finance.yahoo.com/quote/TICKER"
echo " 2. SEC EDGAR: https://www.sec.gov/cgi-bin/browse-edgar"
echo " 3. Google search: 'TICKER stock delisted'"
echo ""
echo "For CONFIRMED permanent delistings, add them to PERMANENTLY_DELISTED in:"
echo " tradingagents/graph/discovery_graph.py"
echo ""
echo "Detailed review list has been exported to: $REVIEW_FILE"

203
scripts/update_positions.py Executable file
View File

@ -0,0 +1,203 @@
#!/usr/bin/env python3
"""
Position Updater Script
This script:
1. Fetches current prices for all open positions
2. Updates positions with latest price data
3. Calculates return % for each position
4. Can be run manually or via cron for continuous monitoring
Usage:
python scripts/update_positions.py
"""
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
from datetime import datetime
import yfinance as yf
from tradingagents.dataflows.discovery.performance.position_tracker import PositionTracker
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def fetch_current_prices(tickers):
"""
Fetch current prices for given tickers using yfinance.
Handles both single and multiple tickers with appropriate error handling.
Args:
tickers: List of ticker symbols
Returns:
Dictionary mapping ticker to current price (or None if fetch failed)
"""
prices = {}
if not tickers:
return prices
# Try to download all tickers at once for efficiency
try:
if len(tickers) == 1:
# Single ticker - yfinance returns Series instead of DataFrame
ticker = tickers[0]
data = yf.download(
ticker,
period="1d",
progress=False,
auto_adjust=True,
)
if not data.empty:
# For single ticker with period='1d', get the latest close
prices[ticker] = float(data["Close"].iloc[-1])
else:
logger.warning(f"Could not fetch data for {ticker}")
prices[ticker] = None
else:
# Multiple tickers - yfinance returns DataFrame with MultiIndex
data = yf.download(
tickers,
period="1d",
progress=False,
auto_adjust=True,
)
if not data.empty:
# Get the latest close for each ticker
if len(tickers) > 1:
for ticker in tickers:
if ticker in data.columns:
close_price = data[ticker]["Close"]
if not close_price.empty:
prices[ticker] = float(close_price.iloc[-1])
else:
prices[ticker] = None
else:
prices[ticker] = None
else:
# Edge case: single ticker in batch download
if "Close" in data.columns:
prices[tickers[0]] = float(data["Close"].iloc[-1])
else:
prices[tickers[0]] = None
else:
for ticker in tickers:
prices[ticker] = None
except Exception as e:
logger.warning(f"Batch download failed: {e}")
# Fall back to per-ticker download
for ticker in tickers:
try:
data = yf.download(
ticker,
period="1d",
progress=False,
auto_adjust=True,
)
if not data.empty:
prices[ticker] = float(data["Close"].iloc[-1])
else:
prices[ticker] = None
except Exception as e:
logger.error(f"Failed to fetch price for {ticker}: {e}")
prices[ticker] = None
return prices
def main():
"""
Main function to update all open positions with current prices.
Process:
1. Initialize PositionTracker
2. Load all open positions
3. Get unique tickers
4. Fetch current prices via yfinance
5. Update each position with new price
6. Save updated positions
7. Print progress messages
"""
logger.info("""
╔══════════════════════════════════════════════════════════════╗
║ TradingAgents - Position Updater ║
╚══════════════════════════════════════════════════════════════╝""".strip())
# Initialize position tracker
tracker = PositionTracker(data_dir="data")
# Load all open positions
logger.info("📂 Loading open positions...")
positions = tracker.load_all_open_positions()
if not positions:
logger.info("✅ No open positions to update.")
return
logger.info(f"✅ Found {len(positions)} open position(s)")
# Get unique tickers
tickers = list({pos["ticker"] for pos in positions})
logger.info(f"📊 Fetching current prices for {len(tickers)} unique ticker(s)...")
logger.info(f"Tickers: {', '.join(sorted(tickers))}")
# Fetch current prices
prices = fetch_current_prices(tickers)
# Update positions and track results
updated_count = 0
failed_count = 0
for position in positions:
ticker = position["ticker"]
current_price = prices.get(ticker)
if current_price is None:
logger.error(f"{ticker}: Failed to fetch price - position not updated")
failed_count += 1
continue
# Update position with new price
entry_price = position["entry_price"]
return_pct = ((current_price - entry_price) / entry_price) * 100
# Update the position
position = tracker.update_position_price(position, current_price)
# Save the updated position
tracker.save_position(position)
# Log progress
return_symbol = "📈" if return_pct >= 0 else "📉"
logger.info(
f"{return_symbol} {ticker:6} | Price: ${current_price:8.2f} | Return: {return_pct:+7.2f}%"
)
updated_count += 1
# Summary
logger.info("=" * 60)
logger.info("✅ Update Summary:")
logger.info(f"Updated: {updated_count}/{len(positions)} positions")
logger.info(f"Failed: {failed_count}/{len(positions)} positions")
logger.info(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
logger.info("=" * 60)
if updated_count > 0:
logger.info("🎉 Position update complete!")
else:
logger.warning("No positions were successfully updated.")
if __name__ == "__main__":
main()

305
scripts/update_ticker_database.py Normal file
View File

@ -0,0 +1,305 @@
#!/usr/bin/env python3
"""
Ticker Database Updater
Maintains and augments the ticker list in data/tickers.txt
Usage:
python scripts/update_ticker_database.py [OPTIONS]
Examples:
# Validate and clean existing list
python scripts/update_ticker_database.py --validate
# Add specific tickers
python scripts/update_ticker_database.py --add NVDA,PLTR,HOOD
# Fetch latest from Alpha Vantage
python scripts/update_ticker_database.py --fetch-alphavantage
"""
import argparse
import os
import sys
from pathlib import Path
from typing import Set
import requests
from dotenv import load_dotenv
from tradingagents.utils.logger import get_logger
load_dotenv()
sys.path.insert(0, str(Path(__file__).parent.parent))
logger = get_logger(__name__)
class TickerDatabaseUpdater:
def __init__(self, ticker_file: str = "data/tickers.txt"):
self.ticker_file = ticker_file
self.tickers: Set[str] = set()
self.added_count = 0
self.removed_count = 0
def load_tickers(self) -> Set[str]:
"""Load existing tickers from file."""
logger.info(f"📖 Loading tickers from {self.ticker_file}...")
try:
with open(self.ticker_file, "r") as f:
for line in f:
symbol = line.strip()
if symbol and symbol.isalpha():
self.tickers.add(symbol.upper())
logger.info(f" ✓ Loaded {len(self.tickers)} tickers")
return self.tickers
except FileNotFoundError:
logger.info(" ℹ️ File not found, starting fresh")
return set()
except Exception as e:
logger.warning(f" ⚠️ Error loading: {str(e)}")
return set()
def add_tickers(self, new_tickers: list):
"""Add new tickers to the database."""
logger.info(f"\n➕ Adding tickers: {', '.join(new_tickers)}")
for ticker in new_tickers:
ticker = ticker.strip().upper()
if ticker and ticker.isalpha():
if ticker not in self.tickers:
self.tickers.add(ticker)
self.added_count += 1
logger.info(f" ✓ Added {ticker}")
else:
logger.info(f" ℹ️ {ticker} already exists")
def validate_and_clean(self, remove_warrants=False, remove_preferred=False):
"""Validate tickers and remove invalid ones."""
logger.info(f"\n🔍 Validating {len(self.tickers)} tickers...")
invalid = set()
for ticker in self.tickers:
# Remove if not alphabetic or too long
if not ticker.isalpha() or len(ticker) > 5 or len(ticker) < 1:
invalid.add(ticker)
continue
# Optionally remove warrants (ending in W)
if remove_warrants and ticker.endswith("W") and len(ticker) > 1:
invalid.add(ticker)
continue
# Optionally remove preferred shares (ending in P after checking it's not a regular stock)
if remove_preferred and ticker.endswith("P") and len(ticker) > 1:
invalid.add(ticker)
if invalid:
logger.warning(f" ⚠️ Found {len(invalid)} problematic tickers")
# Categorize for reporting
warrants = [t for t in invalid if t.endswith("W")]
preferred = [t for t in invalid if t.endswith("P")]
other_invalid = [t for t in invalid if not (t.endswith("W") or t.endswith("P"))]
if warrants and remove_warrants:
logger.info(f" Warrants (ending in W): {len(warrants)}")
if preferred and remove_preferred:
logger.info(f" Preferred shares (ending in P): {len(preferred)}")
if other_invalid:
logger.info(f" Other invalid: {len(other_invalid)}")
for ticker in list(other_invalid)[:10]:
logger.debug(f" - {ticker}")
if len(other_invalid) > 10:
logger.debug(f" ... and {len(other_invalid) - 10} more")
for ticker in invalid:
self.tickers.remove(ticker)
self.removed_count += 1
else:
logger.info(" ✓ All tickers valid")
def fetch_from_alphavantage(self):
"""Fetch tickers from Alpha Vantage LISTING_STATUS endpoint."""
logger.info("\n📥 Fetching from Alpha Vantage...")
api_key = os.getenv("ALPHA_VANTAGE_API_KEY")
if not api_key or "placeholder" in api_key:
logger.warning(" ⚠️ ALPHA_VANTAGE_API_KEY not configured")
logger.info(" 💡 Set in .env file to use this feature")
return
try:
url = f"https://www.alphavantage.co/query?function=LISTING_STATUS&apikey={api_key}"
logger.info(" Downloading listing data...")
response = requests.get(url, timeout=60)
if response.status_code != 200:
logger.error(f" ❌ Failed: HTTP {response.status_code}")
return
# Parse CSV response
lines = response.text.strip().split("\n")
if len(lines) < 2:
logger.error(" ❌ Invalid response format")
return
header = lines[0].split(",")
logger.debug(f" Columns: {', '.join(header)}")
# Find symbol and status columns
try:
symbol_idx = header.index("symbol")
status_idx = header.index("status")
except ValueError:
# Try without quotes
symbol_idx = 0 # Usually first column
status_idx = None
initial_count = len(self.tickers)
for line in lines[1:]:
parts = line.split(",")
if len(parts) > symbol_idx:
symbol = parts[symbol_idx].strip().strip('"')
# Check if active (if status column exists)
if status_idx and len(parts) > status_idx:
status = parts[status_idx].strip().strip('"')
if status != "Active":
continue
# Only add alphabetic symbols
if symbol and symbol.isalpha() and len(symbol) <= 5:
self.tickers.add(symbol.upper())
new_count = len(self.tickers) - initial_count
self.added_count += new_count
logger.info(f" ✓ Added {new_count} new tickers from Alpha Vantage")
except Exception as e:
logger.error(f" ❌ Error: {str(e)}")
def save_tickers(self):
"""Save tickers back to file (sorted)."""
output_path = Path(self.ticker_file)
output_path.parent.mkdir(parents=True, exist_ok=True)
sorted_tickers = sorted(self.tickers)
with open(output_path, "w") as f:
for symbol in sorted_tickers:
f.write(f"{symbol}\n")
logger.info(f"\n✅ Saved {len(sorted_tickers)} tickers to: {self.ticker_file}")
def print_summary(self):
"""Print summary."""
logger.info("\n" + "=" * 70)
logger.info("📊 SUMMARY")
logger.info("=" * 70)
logger.info(f"Total Tickers: {len(self.tickers):,}")
if self.added_count > 0:
logger.info(f"Added: {self.added_count}")
if self.removed_count > 0:
logger.info(f"Removed: {self.removed_count}")
logger.info("=" * 70 + "\n")
def main():
parser = argparse.ArgumentParser(description="Update and maintain ticker database")
parser.add_argument(
"--file",
type=str,
default="data/tickers.txt",
help="Ticker file path (default: data/tickers.txt)",
)
parser.add_argument(
"--add", type=str, help="Comma-separated list of tickers to add (e.g., NVDA,PLTR,HOOD)"
)
parser.add_argument(
"--validate", action="store_true", help="Validate and clean existing tickers"
)
parser.add_argument(
"--remove-warrants",
action="store_true",
help="Remove warrants (tickers ending in W) during validation",
)
parser.add_argument(
"--remove-preferred",
action="store_true",
help="Remove preferred shares (tickers ending in P) during validation",
)
parser.add_argument(
"--fetch-alphavantage", action="store_true", help="Fetch latest tickers from Alpha Vantage"
)
args = parser.parse_args()
logger.info("=" * 70)
logger.info("🔄 TICKER DATABASE UPDATER")
logger.info("=" * 70)
logger.info(f"File: {args.file}")
logger.info("=" * 70 + "\n")
updater = TickerDatabaseUpdater(args.file)
# Load existing tickers
updater.load_tickers()
# Perform requested operations
if args.add:
new_tickers = [t.strip() for t in args.add.split(",")]
updater.add_tickers(new_tickers)
if args.validate or args.remove_warrants or args.remove_preferred:
updater.validate_and_clean(
remove_warrants=args.remove_warrants, remove_preferred=args.remove_preferred
)
if args.fetch_alphavantage:
updater.fetch_from_alphavantage()
# If no operations specified, just validate
if not (
args.add
or args.validate
or args.remove_warrants
or args.remove_preferred
or args.fetch_alphavantage
):
logger.info("No operations specified. Use --help for options.")
logger.info("\nRunning basic validation...")
updater.validate_and_clean(remove_warrants=False, remove_preferred=False)
# Save if any changes were made
if updater.added_count > 0 or updater.removed_count > 0:
updater.save_tickers()
else:
logger.info("\nℹ️ No changes made")
# Print summary
updater.print_summary()
logger.info("💡 Usage examples:")
logger.info(" python scripts/update_ticker_database.py --add NVDA,PLTR")
logger.info(" python scripts/update_ticker_database.py --validate")
logger.info(" python scripts/update_ticker_database.py --remove-warrants")
logger.info(" python scripts/update_ticker_database.py --fetch-alphavantage\n")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
logger.warning("\n\n⚠️ Interrupted by user")
sys.exit(1)
except Exception as e:
logger.error(f"\n❌ Error: {str(e)}")
import traceback
traceback.print_exc()
sys.exit(1)

2
setup.py
View File

@ -2,7 +2,7 @@
Setup script for the TradingAgents package.
"""
from setuptools import setup, find_packages
from setuptools import find_packages, setup
setup(
name="tradingagents",

11
streamlit_app.py Normal file
View File

@ -0,0 +1,11 @@
import sys
from pathlib import Path
# Ensure repo root is on sys.path for imports when running on Streamlit Cloud
ROOT = Path(__file__).resolve().parent
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from tradingagents.ui.dashboard import main
main()

42
tests/conftest.py Normal file
View File

@ -0,0 +1,42 @@
import os
from unittest.mock import patch
import pytest
from tradingagents.config import Config
@pytest.fixture
def mock_env_vars():
"""Mock environment variables for testing."""
with patch.dict(os.environ, {
"OPENAI_API_KEY": "test-openai-key",
"ALPHA_VANTAGE_API_KEY": "test-alpha-key",
"FINNHUB_API_KEY": "test-finnhub-key",
"TRADIER_API_KEY": "test-tradier-key",
"GOOGLE_API_KEY": "test-google-key",
"REDDIT_CLIENT_ID": "test-reddit-id",
"REDDIT_CLIENT_SECRET": "test-reddit-secret",
"TWITTER_BEARER_TOKEN": "test-twitter-token"
}, clear=True):
yield
@pytest.fixture
def mock_config(mock_env_vars):
"""Return a Config instance with mocked env vars."""
# Reset singleton
Config._instance = None
return Config()
@pytest.fixture
def sample_stock_data():
"""Return a sample DataFrame for technical analysis."""
import pandas as pd
data = {
"close": [100, 102, 101, 103, 105, 108, 110, 109, 112, 115],
"high": [105, 106, 105, 107, 108, 112, 115, 113, 116, 118],
"low": [95, 98, 99, 100, 102, 105, 108, 106, 108, 111],
"volume": [1000] * 10
}
return pd.DataFrame(data)

45
tests/dataflows/test_news_scanner.py Normal file
View File

@ -0,0 +1,45 @@
from unittest.mock import patch
import pytest
from tradingagents.dataflows.news_semantic_scanner import NewsSemanticScanner
class TestNewsSemanticScanner:
@pytest.fixture
def scanner(self, mock_config):
# Allow instantiation by mocking __init__ dependencies if needed?
# The class uses OpenAI in init.
with patch('tradingagents.dataflows.news_semantic_scanner.OpenAI') as MockOpenAI:
scanner = NewsSemanticScanner(config=mock_config)
return scanner
def test_filter_by_time(self, scanner):
from datetime import datetime
# Test data
news = [
{"published_at": "2025-01-01T12:00:00Z", "title": "Old News"},
{"published_at": datetime.now().isoformat(), "title": "New News"}
]
# We need to set scanner.cutoff_time manually or check its logic
# current logic sets it to now - lookback
# This is a bit tricky without mocking datetime or adjusting cutoff,
# so let's trust the logic for now or do a simple structural test.
assert hasattr(scanner, "scan_news")
@patch('tradingagents.dataflows.news_semantic_scanner.NewsSemanticScanner._fetch_openai_news')
def test_scan_news_aggregates(self, mock_fetch_openai, scanner):
mock_fetch_openai.return_value = [{"title": "OpenAI News", "importance": 8}]
# Configure to only use openai
scanner.news_sources = ["openai"]
result = scanner.scan_news()
assert len(result) == 1
assert result[0]["title"] == "OpenAI News"

31
tests/dataflows/test_technical_analyst.py Normal file
View File

@ -0,0 +1,31 @@
import pandas as pd
from stockstats import wrap
from tradingagents.dataflows.technical_analyst import TechnicalAnalyst
def test_technical_analyst_report_generation(sample_stock_data):
df = wrap(sample_stock_data)
current_price = 115.0
analyst = TechnicalAnalyst(df, current_price)
report = analyst.generate_report("TEST", "2025-01-01")
assert "# Technical Analysis for TEST" in report
assert "**Current Price:** $115.00" in report
assert "## Price Action" in report
assert "Daily Change" in report
assert "## RSI" in report
assert "## MACD" in report
def test_technical_analyst_empty_data():
empty_df = pd.DataFrame()
# It might raise an error or handle it, usually logic handles standard DF but let's check
# The class expects columns, so let's pass empty with columns
df = pd.DataFrame(columns=["close", "high", "low", "volume"])
# Wrapping empty might fail or produce empty wrapped
# Our TechnicalAnalyst assumes valid data somewhat, but we should make sure it doesn't just crash blindly
# Actually, y_finance.py checks for empty before calling, so the class itself assumes data.
pass

25
tests/quick_ticker_test.py Normal file
View File

@ -0,0 +1,25 @@
"""
Quick ticker matcher validation
"""
from tradingagents.dataflows.discovery.ticker_matcher import match_company_to_ticker, load_ticker_universe
# Load universe
print("Loading ticker universe...")
universe = load_ticker_universe()
print(f"Loaded {len(universe)} tickers\n")
# Test cases
tests = [
("Apple Inc", "AAPL"),
("MICROSOFT CORP", "MSFT"),
("Amazon.com, Inc.", "AMZN"),
("TESLA INC", "TSLA"),
("META PLATFORMS INC", "META"),
("NVIDIA CORPORATION", "NVDA"),
]
print("Testing ticker matching:")
for company, expected in tests:
result = match_company_to_ticker(company)
status = "✓" if result and result.startswith(expected[:3]) else "✗"
print(f"{status} '{company}' -> {result} (expected {expected})")

165
tests/test_concurrent_scanners.py Normal file
View File

@ -0,0 +1,165 @@
"""Test concurrent scanner execution."""
import time
import copy
from unittest.mock import MagicMock, patch
from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.graph.discovery_graph import DiscoveryGraph
def test_concurrent_execution():
"""Test that concurrent execution runs scanners in parallel."""
# Get config with concurrent execution enabled
config = copy.deepcopy(DEFAULT_CONFIG)
config["discovery"]["scanner_execution"] = {
"concurrent": True,
"max_workers": 4,
"timeout_seconds": 30,
}
# Create discovery graph
graph = DiscoveryGraph(config)
# Create initial state
state = {
"trade_date": "2026-02-05",
"tickers": [],
"filtered_tickers": [],
"final_ranking": "",
"status": "initialized",
"tool_logs": [],
}
# Run scanner node with timing
print("\n=== Testing Concurrent Scanner Execution ===")
start = time.time()
result = graph.scanner_node(state)
elapsed = time.time() - start
# Verify results
print(f"\n✓ Execution time: {elapsed:.2f}s")
print(f"✓ Found {len(result['tickers'])} unique tickers")
print(f"✓ Found {len(result['candidate_metadata'])} candidates")
print(f"✓ Tool logs: {len(result['tool_logs'])} entries")
# Check that we got results
assert len(result['tickers']) > 0, "Should find at least some tickers"
assert len(result['candidate_metadata']) > 0, "Should find candidates"
assert result['status'] == 'scanned', "Status should be scanned"
print("\n✅ Concurrent execution test passed!")
return result
def test_sequential_fallback():
"""Test that sequential execution works when concurrent is disabled."""
# Get config with concurrent execution disabled
config = copy.deepcopy(DEFAULT_CONFIG)
config["discovery"]["scanner_execution"] = {
"concurrent": False,
"max_workers": 1,
"timeout_seconds": 30,
}
# Create discovery graph
graph = DiscoveryGraph(config)
# Create initial state
state = {
"trade_date": "2026-02-05",
"tickers": [],
"filtered_tickers": [],
"final_ranking": "",
"status": "initialized",
"tool_logs": [],
}
# Run scanner node with timing
print("\n=== Testing Sequential Scanner Execution ===")
start = time.time()
result = graph.scanner_node(state)
elapsed = time.time() - start
# Verify results
print(f"\n✓ Execution time: {elapsed:.2f}s")
print(f"✓ Found {len(result['tickers'])} unique tickers")
print(f"✓ Found {len(result['candidate_metadata'])} candidates")
# Check that we got results
assert len(result['tickers']) > 0, "Should find at least some tickers"
assert len(result['candidate_metadata']) > 0, "Should find candidates"
assert result['status'] == 'scanned', "Status should be scanned"
print("\n✅ Sequential execution test passed!")
return result
def test_timeout_handling():
"""Test that scanner timeout is enforced."""
# Get config with very short timeout
config = copy.deepcopy(DEFAULT_CONFIG)
config["discovery"]["scanner_execution"] = {
"concurrent": True,
"max_workers": 4,
"timeout_seconds": 1, # Very short timeout
}
# Create discovery graph
graph = DiscoveryGraph(config)
# Create initial state
state = {
"trade_date": "2026-02-05",
"tickers": [],
"filtered_tickers": [],
"final_ranking": "",
"status": "initialized",
"tool_logs": [],
}
# Run scanner node - some scanners may timeout
print("\n=== Testing Timeout Handling (1s timeout) ===")
start = time.time()
result = graph.scanner_node(state)
elapsed = time.time() - start
# Verify results (may be partial due to timeouts)
print(f"\n✓ Execution time: {elapsed:.2f}s")
print(f"✓ Found {len(result['tickers'])} tickers (some scanners may have timed out)")
print(f"✓ Status: {result['status']}")
# Should still complete even with timeouts
assert result['status'] == 'scanned', "Status should be scanned even with timeouts"
print("\n✅ Timeout handling test passed!")
return result
if __name__ == "__main__":
# Run tests
print("\n" + "="*60)
print("Testing Scanner Concurrent Execution")
print("="*60)
try:
# Test 1: Concurrent execution
result1 = test_concurrent_execution()
# Test 2: Sequential fallback
result2 = test_sequential_fallback()
# Test 3: Timeout handling
result3 = test_timeout_handling()
print("\n" + "="*60)
print("✅ All tests passed!")
print("="*60)
except Exception as e:
print(f"\n❌ Test failed: {e}")
import traceback
traceback.print_exc()
raise

42
tests/test_config.py Normal file
View File

@ -0,0 +1,42 @@
import os
from unittest.mock import patch
import pytest
from tradingagents.config import Config
class TestConfig:
def test_singleton(self):
Config._instance = None
c1 = Config()
c2 = Config()
assert c1 is c2
def test_validate_key_success(self, mock_env_vars):
Config._instance = None
config = Config()
key = config.validate_key("openai_api_key", "OpenAI")
assert key == "test-openai-key"
def test_validate_key_failure(self):
Config._instance = None
with patch.dict(os.environ, {}, clear=True):
config = Config()
with pytest.raises(ValueError) as excinfo:
config.validate_key("openai_api_key", "OpenAI")
assert "OpenAI API Key not found" in str(excinfo.value)
def test_get_method(self):
Config._instance = None
config = Config()
# Test getting real property
with patch.dict(os.environ, {"OPENAI_API_KEY": "test-key"}):
assert config.get("openai_api_key") == "test-key"
# Test getting default value
assert config.get("results_dir") == "./results"
# Test fallback to provided default
assert config.get("non_existent_key", "default") == "default"

249
tests/test_discovery_refactor.py Normal file
View File

@ -0,0 +1,249 @@
#!/usr/bin/env python3
"""
Test script to verify DiscoveryGraph refactoring.
Tests: LLM Factory, TraditionalScanner, CandidateFilter, CandidateRanker
"""
import os
import sys
from pathlib import Path
# Add project root to path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))
def test_llm_factory():
"""Test LLM factory initialization."""
print("\n=== Testing LLM Factory ===")
try:
from tradingagents.utils.llm_factory import create_llms
# Mock API key
os.environ.setdefault("OPENAI_API_KEY", "sk-test-key")
config = {
"llm_provider": "openai",
"deep_think_llm": "gpt-4",
"quick_think_llm": "gpt-3.5-turbo"
}
deep_llm, quick_llm = create_llms(config)
assert deep_llm is not None, "Deep LLM should be initialized"
assert quick_llm is not None, "Quick LLM should be initialized"
print("✅ LLM Factory: Successfully creates LLMs")
return True
except Exception as e:
print(f"❌ LLM Factory: Failed - {e}")
return False
def test_traditional_scanner():
"""Test TraditionalScanner class."""
print("\n=== Testing TraditionalScanner ===")
try:
from unittest.mock import MagicMock
from tradingagents.dataflows.discovery.scanners import TraditionalScanner
config = {"discovery": {}}
mock_llm = MagicMock()
mock_executor = MagicMock()
scanner = TraditionalScanner(config, mock_llm, mock_executor)
assert hasattr(scanner, 'scan'), "Scanner should have scan method"
assert scanner.execute_tool == mock_executor, "Should store executor"
print("✅ TraditionalScanner: Successfully initialized")
return True
except Exception as e:
print(f"❌ TraditionalScanner: Failed - {e}")
import traceback
traceback.print_exc()
return False
def test_candidate_filter():
"""Test CandidateFilter class."""
print("\n=== Testing CandidateFilter ===")
try:
from unittest.mock import MagicMock
from tradingagents.dataflows.discovery.filter import CandidateFilter
config = {"discovery": {}}
mock_executor = MagicMock()
filter_obj = CandidateFilter(config, mock_executor)
assert hasattr(filter_obj, 'filter'), "Filter should have filter method"
assert filter_obj.execute_tool == mock_executor, "Should store executor"
print("✅ CandidateFilter: Successfully initialized")
return True
except Exception as e:
print(f"❌ CandidateFilter: Failed - {e}")
import traceback
traceback.print_exc()
return False
def test_candidate_ranker():
"""Test CandidateRanker class."""
print("\n=== Testing CandidateRanker ===")
try:
from unittest.mock import MagicMock
from tradingagents.dataflows.discovery.ranker import CandidateRanker
config = {"discovery": {}}
mock_llm = MagicMock()
mock_analytics = MagicMock()
ranker = CandidateRanker(config, mock_llm, mock_analytics)
assert hasattr(ranker, 'rank'), "Ranker should have rank method"
assert ranker.llm == mock_llm, "Should store LLM"
print("✅ CandidateRanker: Successfully initialized")
return True
except Exception as e:
print(f"❌ CandidateRanker: Failed - {e}")
import traceback
traceback.print_exc()
return False
def test_discovery_graph_import():
"""Test that DiscoveryGraph still imports correctly."""
print("\n=== Testing DiscoveryGraph Import ===")
try:
from tradingagents.graph.discovery_graph import DiscoveryGraph
# Mock API key
os.environ.setdefault("OPENAI_API_KEY", "sk-test-key")
config = {
"llm_provider": "openai",
"deep_think_llm": "gpt-4",
"quick_think_llm": "gpt-3.5-turbo",
"backend_url": "https://api.openai.com/v1",
"discovery": {}
}
graph = DiscoveryGraph(config=config)
assert hasattr(graph, 'deep_thinking_llm'), "Should have deep LLM"
assert hasattr(graph, 'quick_thinking_llm'), "Should have quick LLM"
assert hasattr(graph, 'analytics'), "Should have analytics"
assert hasattr(graph, 'graph'), "Should have graph"
print("✅ DiscoveryGraph: Successfully initialized with refactored components")
return True
except Exception as e:
print(f"❌ DiscoveryGraph: Failed - {e}")
import traceback
traceback.print_exc()
return False
def test_trading_graph_import():
"""Test that TradingAgentsGraph still imports correctly."""
print("\n=== Testing TradingAgentsGraph Import ===")
try:
from tradingagents.graph.trading_graph import TradingAgentsGraph
# Mock API key
os.environ.setdefault("OPENAI_API_KEY", "sk-test-key")
config = {
"llm_provider": "openai",
"deep_think_llm": "gpt-4",
"quick_think_llm": "gpt-3.5-turbo",
"project_dir": str(project_root),
"enable_memory": False
}
graph = TradingAgentsGraph(config=config)
assert hasattr(graph, 'deep_thinking_llm'), "Should have deep LLM"
assert hasattr(graph, 'quick_thinking_llm'), "Should have quick LLM"
print("✅ TradingAgentsGraph: Successfully initialized with LLM factory")
return True
except Exception as e:
print(f"❌ TradingAgentsGraph: Failed - {e}")
import traceback
traceback.print_exc()
return False
def test_utils():
"""Test utility functions."""
print("\n=== Testing Utilities ===")
try:
from tradingagents.dataflows.discovery.utils import (
extract_technical_summary,
is_valid_ticker,
)
# Test ticker validation
assert is_valid_ticker("AAPL") == True, "AAPL should be valid"
assert is_valid_ticker("AAPL.WS") == False, "Warrant should be invalid"
assert is_valid_ticker("AAPL-RT") == False, "Rights should be invalid"
# Test technical summary extraction
tech_report = "RSI Value: 45.5"
summary = extract_technical_summary(tech_report)
assert "RSI:45" in summary or "RSI:46" in summary, "Should extract RSI"
print("✅ Utils: All utility functions work correctly")
return True
except Exception as e:
print(f"❌ Utils: Failed - {e}")
import traceback
traceback.print_exc()
return False
def main():
"""Run all tests."""
print("=" * 60)
print("DISCOVERY GRAPH REFACTORING VERIFICATION")
print("=" * 60)
results = []
# Run all tests
results.append(("LLM Factory", test_llm_factory()))
results.append(("Traditional Scanner", test_traditional_scanner()))
results.append(("Candidate Filter", test_candidate_filter()))
results.append(("Candidate Ranker", test_candidate_ranker()))
results.append(("Utils", test_utils()))
results.append(("DiscoveryGraph", test_discovery_graph_import()))
results.append(("TradingAgentsGraph", test_trading_graph_import()))
# Summary
print("\n" + "=" * 60)
print("SUMMARY")
print("=" * 60)
passed = sum(1 for _, result in results if result)
total = len(results)
for name, result in results:
status = "✅ PASS" if result else "❌ FAIL"
print(f"{status}: {name}")
print(f"\n{passed}/{total} tests passed")
if passed == total:
print("\n🎉 All refactoring tests passed!")
return 0
else:
print(f"\n⚠️ {total - passed} test(s) failed")
return 1
if __name__ == "__main__":
sys.exit(main())

159
tests/test_sec_13f_refactor.py Normal file
View File

@ -0,0 +1,159 @@
#!/usr/bin/env python3
"""
Test SEC 13F Parser with Ticker Matching
This script tests the refactored SEC 13F parser to verify:
1. Ticker matcher module loads successfully
2. Fuzzy matching works correctly
3. SEC 13F parsing integrates with ticker matcher
"""
import sys
from pathlib import Path
# Add project root to path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))
print("=" * 60)
print("Testing SEC 13F Parser Refactor")
print("=" * 60)
# Test 1: Ticker Matcher Module
print("\n[1/3] Testing Ticker Matcher Module...")
try:
from tradingagents.dataflows.discovery.ticker_matcher import (
match_company_to_ticker,
load_ticker_universe,
get_match_confidence,
)
# Load universe
universe = load_ticker_universe()
print(f"✓ Loaded {len(universe)} tickers")
# Test exact matches
test_cases = [
("Apple Inc", "AAPL"),
("MICROSOFT CORP", "MSFT"),
("Amazon.com, Inc.", "AMZN"),
("Alphabet Inc", "GOOGL"), # or GOOG
("TESLA INC", "TSLA"),
("META PLATFORMS INC", "META"),
("NVIDIA CORPORATION", "NVDA"),
("Berkshire Hathaway Inc", "BRK.B"), # or BRK.A
]
passed = 0
for company, expected_prefix in test_cases:
result = match_company_to_ticker(company)
if result and result.startswith(expected_prefix[:3]):
passed += 1
print(f" ✓ '{company}' -> {result}")
else:
print(f" ✗ '{company}' -> {result} (expected {expected_prefix})")
print(f"\nPassed {passed}/{len(test_cases)} exact match tests")
# Test fuzzy matching
print("\nTesting fuzzy matching...")
fuzzy_cases = [
"APPLE COMPUTER INC",
"Microsoft Corporation",
"Amazon Com Inc",
"Tesla Motors",
]
for company in fuzzy_cases:
result = match_company_to_ticker(company, min_confidence=70.0)
confidence = get_match_confidence(company, result) if result else 0
print(f" '{company}' -> {result} (confidence: {confidence:.1f})")
print("✓ Ticker matcher working correctly")
except Exception as e:
print(f"✗ Error testing ticker matcher: {e}")
import traceback
traceback.print_exc()
sys.exit(1)
# Test 2: SEC 13F Integration
print("\n[2/3] Testing SEC 13F Integration...")
try:
from tradingagents.dataflows.sec_13f import get_recent_13f_changes
print("Fetching recent 13F filings (this may take 30-60 seconds)...")
results = get_recent_13f_changes(
days_lookback=14, # Last 2 weeks
min_position_value=50, # $50M+
notable_only=False,
top_n=10,
return_structured=True,
)
if results:
print(f"\n✓ Found {len(results)} institutional holdings")
print("\nTop 5 holdings:")
print(f"{'Issuer':<40} {'Ticker':<8} {'Institutions':<12} {'Match Method'}")
print("-" * 80)
for i, r in enumerate(results[:5]):
issuer = r['issuer'][:38]
ticker = r.get('ticker', 'N/A')
inst_count = r.get('institution_count', 0)
match_method = r.get('match_method', 'unknown')
print(f"{issuer:<40} {ticker:<8} {inst_count:<12} {match_method}")
# Calculate match statistics
fuzzy_matches = sum(1 for r in results if r.get('match_method') == 'fuzzy')
regex_matches = sum(1 for r in results if r.get('match_method') == 'regex')
unmatched = sum(1 for r in results if r.get('match_method') == 'unmatched')
print(f"\nMatch Statistics:")
print(f" Fuzzy matches: {fuzzy_matches}/{len(results)} ({100*fuzzy_matches/len(results):.1f}%)")
print(f" Regex fallback: {regex_matches}/{len(results)} ({100*regex_matches/len(results):.1f}%)")
print(f" Unmatched: {unmatched}/{len(results)} ({100*unmatched/len(results):.1f}%)")
if fuzzy_matches > 0:
print("\n✓ SEC 13F parser successfully using ticker matcher!")
else:
print("\n⚠ Warning: No fuzzy matches found, matcher may not be integrated")
else:
print("⚠ No results found (may be weekend/no recent filings)")
except Exception as e:
print(f"✗ Error testing SEC 13F integration: {e}")
import traceback
traceback.print_exc()
# Don't exit, this might fail due to network issues
# Test 3: Scanner Interface
print("\n[3/3] Testing Scanner Interface...")
try:
from tradingagents.dataflows.sec_13f import scan_13f_changes
config = {
"discovery": {
"13f_lookback_days": 7,
"13f_min_position_value": 25,
}
}
candidates = scan_13f_changes(config)
if candidates:
print(f"✓ Scanner returned {len(candidates)} candidates")
print(f"\nSample candidates:")
for c in candidates[:3]:
print(f" {c['ticker']}: {c['context']} [{c['priority']}]")
else:
print("⚠ Scanner returned no candidates (may be normal)")
except Exception as e:
print(f"✗ Error testing scanner interface: {e}")
import traceback
traceback.print_exc()
print("\n" + "=" * 60)
print("Testing Complete!")
print("=" * 60)

27
tests/utils/test_logger.py Normal file
View File

@ -0,0 +1,27 @@
import logging
from io import StringIO
from tradingagents.utils.logger import get_logger
def test_logger_formatting():
# Capture stdout
capture = StringIO()
handler = logging.StreamHandler(capture)
handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
logger = get_logger("test_logger_unit")
logger.setLevel(logging.INFO)
# Remove existing handlers to avoid cluttering output or double logging
for h in logger.handlers[:]:
logger.removeHandler(h)
logger.addHandler(handler)
logger.info("Test Info")
logger.error("Test Error")
output = capture.getvalue()
print(f"Captured: {output}") # For debugging
assert "INFO: Test Info" in output
assert "ERROR: Test Error" in output

73
tests/verify_refactor.py Normal file
View File

@ -0,0 +1,73 @@
import os
import shutil
import sys
from unittest.mock import MagicMock
# Add project root to path
sys.path.append(os.getcwd())
from tradingagents.dataflows.discovery.scanners import TraditionalScanner
from tradingagents.graph.discovery_graph import DiscoveryGraph
def test_graph_init_with_factory():
print("Testing DiscoveryGraph initialization with LLM Factory...")
config = {
"llm_provider": "openai",
"deep_think_llm": "gpt-4-turbo",
"quick_think_llm": "gpt-3.5-turbo",
"backend_url": "https://api.openai.com/v1",
"discovery": {},
"results_dir": "tests/temp_results"
}
# Mock API key so factory works
if not os.getenv("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = "sk-mock-key"
try:
graph = DiscoveryGraph(config=config)
assert hasattr(graph, 'deep_thinking_llm')
assert hasattr(graph, 'quick_thinking_llm')
assert graph.deep_thinking_llm is not None
print("✅ DiscoveryGraph initialized LLMs via Factory")
except Exception as e:
print(f"❌ DiscoveryGraph initialization failed: {e}")
def test_traditional_scanner_init():
print("Testing TraditionalScanner initialization...")
config = {"discovery": {}}
mock_llm = MagicMock()
mock_executor = MagicMock()
try:
scanner = TraditionalScanner(config, mock_llm, mock_executor)
assert scanner.execute_tool == mock_executor
print("✅ TraditionalScanner initialized")
# Test scan (mocking tools)
mock_executor.return_value = {"valid": ["AAPL"], "invalid": []}
state = {"trade_date": "2023-10-27"}
# We expect some errors printed because we didn't mock everything perfect,
# but it shouldn't crash.
print(" Running scan (expecting some print errors due to missing tools)...")
candidates = scanner.scan(state)
print(f" Scan returned {len(candidates)} candidates")
print("✅ TraditionalScanner scan() ran without crash")
except Exception as e:
print(f"❌ TraditionalScanner failed: {e}")
def cleanup():
if os.path.exists("tests/temp_results"):
shutil.rmtree("tests/temp_results")
if __name__ == "__main__":
try:
test_graph_init_with_factory()
test_traditional_scanner_init()
print("\nAll checks passed!")
finally:
cleanup()

1753
tools_testing.ipynb
View File

File diff suppressed because one or more lines are too long

5
tradingagents/__init__.py Normal file
View File

@ -0,0 +1,5 @@
"""
TradingAgents: Multi-Agents LLM Financial Trading Framework
"""
__version__ = "0.1.0"

15
tradingagents/agents/__init__.py
View File

@ -1,23 +1,18 @@
from .utils.agent_utils import create_msg_delete
from .utils.agent_states import AgentState, InvestDebateState, RiskDebateState
from .utils.memory import FinancialSituationMemory
from .analysts.fundamentals_analyst import create_fundamentals_analyst
from .analysts.market_analyst import create_market_analyst
from .analysts.news_analyst import create_news_analyst
from .analysts.social_media_analyst import create_social_media_analyst
from .managers.research_manager import create_research_manager
from .managers.risk_manager import create_risk_manager
from .researchers.bear_researcher import create_bear_researcher
from .researchers.bull_researcher import create_bull_researcher
from .risk_mgmt.aggresive_debator import create_risky_debator
from .risk_mgmt.conservative_debator import create_safe_debator
from .risk_mgmt.neutral_debator import create_neutral_debator
from .managers.research_manager import create_research_manager
from .managers.risk_manager import create_risk_manager
from .trader.trader import create_trader
from .utils.agent_states import AgentState, InvestDebateState, RiskDebateState
from .utils.agent_utils import create_msg_delete
from .utils.memory import FinancialSituationMemory
__all__ = [
"FinancialSituationMemory",

72
tradingagents/agents/analysts/fundamentals_analyst.py
View File

@ -1,21 +1,12 @@
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import time
import json
from tradingagents.tools.generator import get_agent_tools
from tradingagents.dataflows.config import get_config
from tradingagents.agents.utils.agent_utils import create_analyst_node
from tradingagents.agents.utils.prompt_templates import get_date_awareness_section
def create_fundamentals_analyst(llm):
def fundamentals_analyst_node(state):
current_date = state["trade_date"]
ticker = state["company_of_interest"]
company_name = state["company_of_interest"]
def _build_prompt(ticker, current_date):
return f"""You are a Fundamental Analyst assessing {ticker}'s financial health with SHORT-TERM trading relevance.
tools = get_agent_tools("fundamentals")
system_message = """You are a Fundamental Analyst assessing {ticker}'s financial health with SHORT-TERM trading relevance.
**Analysis Date:** {current_date}
{get_date_awareness_section(current_date)}
## YOUR MISSION
Identify fundamental strengths/weaknesses and any SHORT-TERM catalysts hidden in the financials.
@ -35,6 +26,21 @@ Look for:
- Cash flow changes (improving = strength, deteriorating = risk)
- Valuation extremes (very cheap or very expensive vs. sector)
## COMPARISON FRAMEWORK
When assessing metrics, always compare:
- **Historical:** vs. same company 1 year ago, 2 years ago
- **Sector:** vs. sector median/average (use get_fundamentals for sector data)
- **Peers:** vs. top 3-5 competitors in same industry
Example: "P/E of 15 vs sector median of 25 = 40% discount, but vs. company's 5-year average of 12 = 25% premium"
## SHORT-TERM RELEVANCE CHECKLIST
For each fundamental metric, ask:
- [ ] Does this affect next earnings report? (revenue trend, margin trend)
- [ ] Is there a catalyst in next 2 weeks? (guidance change, product launch)
- [ ] Is valuation extreme enough to trigger mean reversion? (very cheap/expensive)
- [ ] Does balance sheet support/risk short-term trade? (cash runway, debt maturity)
## OUTPUT STRUCTURE (MANDATORY)
### Financial Scorecard
@ -72,40 +78,4 @@ Look for:
Date: {current_date} | Ticker: {ticker}"""
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You are a helpful AI assistant, collaborating with other assistants."
" Use the provided tools to progress towards answering the question."
" If you are unable to fully answer, that's OK; another assistant with different tools"
" will help where you left off. Execute what you can to make progress."
" If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable,"
" prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop."
" You have access to the following tools: {tool_names}.\n{system_message}"
"For your reference, the current date is {current_date}. The company we want to look at is {ticker}",
),
MessagesPlaceholder(variable_name="messages"),
]
)
prompt = prompt.partial(system_message=system_message)
prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))
prompt = prompt.partial(current_date=current_date)
prompt = prompt.partial(ticker=ticker)
chain = prompt | llm.bind_tools(tools)
result = chain.invoke(state["messages"])
report = ""
if len(result.tool_calls) == 0:
report = result.content
return {
"messages": [result],
"fundamentals_report": report,
}
return fundamentals_analyst_node
return create_analyst_node(llm, "fundamentals", "fundamentals_report", _build_prompt)

73
tradingagents/agents/analysts/market_analyst.py
View File

@ -1,32 +1,15 @@
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import time
import json
from tradingagents.tools.generator import get_agent_tools
from tradingagents.dataflows.config import get_config
from tradingagents.agents.utils.agent_utils import create_analyst_node
from tradingagents.agents.utils.prompt_templates import get_date_awareness_section
def create_market_analyst(llm):
def market_analyst_node(state):
current_date = state["trade_date"]
ticker = state["company_of_interest"]
company_name = state["company_of_interest"]
tools = get_agent_tools("market")
system_message = """You are a Market Technical Analyst specializing in identifying actionable short-term trading signals through technical indicators.
def _build_prompt(ticker, current_date):
return f"""You are a Market Technical Analyst specializing in identifying actionable short-term trading signals through technical indicators.
## YOUR MISSION
Analyze {ticker}'s technical setup and identify the 3-5 most relevant trading signals for short-term opportunities (days to weeks, not months).
## CRITICAL: DATE AWARENESS
**Current Analysis Date:** {current_date}
**Instructions:**
- Treat {current_date} as "TODAY" for all calculations.
- "Last 6 months" means 6 months ending on {current_date}.
- "Last week" means the 7 days ending on {current_date}.
- Do NOT use 2024 or 2025 unless {current_date} is actually in that year.
- When calling tools, ensure date parameters are relative to {current_date}.
{get_date_awareness_section(current_date)}
## INDICATOR SELECTION FRAMEWORK
@ -84,9 +67,13 @@ For each signal:
| MACD | +2.1 | Bullish | Momentum strong | 1-2 weeks |
| 50 SMA | $145 | Support | Trend intact if held | Ongoing |
## CRITICAL: TOOL USAGE
- ✅ DO call `get_indicators(symbol=ticker, curr_date=current_date)` ONCE
→ This returns ALL indicators (RSI, MACD, Bollinger Bands, ATR, etc.) in one call
- ❌ DO NOT try to pass `indicator="rsi"` parameter - the tool doesn't support that
- ❌ DO NOT call get_indicators multiple times - one call gives you everything
## CRITICAL RULES
- ❌ DO NOT try to pass specific indicators: `indicator="rsi"` (the tool gives you everything at once)
- ✅ DO call `get_indicators(symbol=ticker, curr_date=current_date)` once to get all data
- ❌ DO NOT say "trends are mixed" without specific examples
- ✅ DO provide concrete signals with specific price levels and timeframes
- ❌ DO NOT select redundant indicators (e.g., both close_50_sma and close_200_sma)
@ -102,40 +89,4 @@ Available Indicators:
Current date: {current_date} | Ticker: {ticker}"""
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You are a helpful AI assistant, collaborating with other assistants."
" Use the provided tools to progress towards answering the question."
" If you are unable to fully answer, that's OK; another assistant with different tools"
" will help where you left off. Execute what you can to make progress."
" If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable,"
" prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop."
" You have access to the following tools: {tool_names}.\n{system_message}"
"For your reference, the current date is {current_date}. The company we want to look at is {ticker}",
),
MessagesPlaceholder(variable_name="messages"),
]
)
prompt = prompt.partial(system_message=system_message)
prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))
prompt = prompt.partial(current_date=current_date)
prompt = prompt.partial(ticker=ticker)
chain = prompt | llm.bind_tools(tools)
result = chain.invoke(state["messages"])
report = ""
if len(result.tool_calls) == 0:
report = result.content
return {
"messages": [result],
"market_report": report,
}
return market_analyst_node
return create_analyst_node(llm, "market", "market_report", _build_prompt)

62
tradingagents/agents/analysts/news_analyst.py
View File

@ -1,21 +1,12 @@
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import time
import json
from tradingagents.tools.generator import get_agent_tools
from tradingagents.dataflows.config import get_config
from tradingagents.agents.utils.agent_utils import create_analyst_node
from tradingagents.agents.utils.prompt_templates import get_date_awareness_section
def create_news_analyst(llm):
def news_analyst_node(state):
current_date = state["trade_date"]
ticker = state["company_of_interest"]
from tradingagents.tools.generator import get_agent_tools
def _build_prompt(ticker, current_date):
return f"""You are a News Intelligence Analyst finding SHORT-TERM catalysts for {ticker}.
tools = get_agent_tools("news")
system_message = """You are a News Intelligence Analyst finding SHORT-TERM catalysts for {ticker}.
**Analysis Date:** {current_date}
{get_date_awareness_section(current_date)}
## YOUR MISSION
Identify material catalysts and risks that could impact {ticker} over the NEXT 1-2 WEEKS.
@ -39,7 +30,11 @@ For each:
- **Date:** [When]
- **Impact:** [Stock reaction so far]
- **Forward Look:** [Why this matters for next 1-2 weeks]
- **Priced In?:** [Fully/Partially/Not Yet]
- **Priced-In Assessment:**
- **Event Date:** [When it happened]
- **Price Reaction:** [Stock moved X% on event day]
- **Current Price vs Event Price:** [Is it still elevated or back to pre-event?]
- **Conclusion:** [Fully Priced In / Partially Priced In / Not Yet Priced In]
- **Confidence:** [High/Med/Low]
### Key Risks (Bearish - max 4)
@ -70,39 +65,4 @@ For each:
Date: {current_date} | Ticker: {ticker}"""
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You are a helpful AI assistant, collaborating with other assistants."
" Use the provided tools to progress towards answering the question."
" If you are unable to fully answer, that's OK; another assistant with different tools"
" will help where you left off. Execute what you can to make progress."
" If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable,"
" prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop."
" You have access to the following tools: {tool_names}.\n{system_message}"
"For your reference, the current date is {current_date}. We are looking at the company {ticker}",
),
MessagesPlaceholder(variable_name="messages"),
]
)
prompt = prompt.partial(system_message=system_message)
prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))
prompt = prompt.partial(current_date=current_date)
prompt = prompt.partial(ticker=ticker)
chain = prompt | llm.bind_tools(tools)
result = chain.invoke(state["messages"])
report = ""
if len(result.tool_calls) == 0:
report = result.content
return {
"messages": [result],
"news_report": report,
}
return news_analyst_node
return create_analyst_node(llm, "news", "news_report", _build_prompt)

69
tradingagents/agents/analysts/social_media_analyst.py
View File

@ -1,21 +1,12 @@
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import time
import json
from tradingagents.tools.generator import get_agent_tools
from tradingagents.dataflows.config import get_config
from tradingagents.agents.utils.agent_utils import create_analyst_node
from tradingagents.agents.utils.prompt_templates import get_date_awareness_section
def create_social_media_analyst(llm):
def social_media_analyst_node(state):
current_date = state["trade_date"]
ticker = state["company_of_interest"]
company_name = state["company_of_interest"]
def _build_prompt(ticker, current_date):
return f"""You are a Social Sentiment Analyst tracking {ticker}'s retail momentum for SHORT-TERM signals.
tools = get_agent_tools("social")
system_message = """You are a Social Sentiment Analyst tracking {ticker}'s retail momentum for SHORT-TERM signals.
**Analysis Date:** {current_date}
{get_date_awareness_section(current_date)}
## YOUR MISSION
QUANTIFY social sentiment and identify sentiment SHIFTS that could drive short-term price action.
@ -27,6 +18,18 @@ QUANTIFY social sentiment and identify sentiment SHIFTS that could drive short-t
- Change: Improving or deteriorating?
- Quality: Data-backed or speculation?
## SOURCE CREDIBILITY WEIGHTING
When aggregating sentiment, weight sources by credibility:
- **High Weight (0.8-1.0):** Verified DD posts with data, institutional tweets with track record
- **Medium Weight (0.5-0.7):** General Reddit discussions, stock-specific forums
- **Low Weight (0.2-0.4):** Meme posts, unverified rumors, low-engagement posts
**Example Calculation:**
- 10 high-weight bullish posts (0.9) = 9 bullish points
- 20 medium-weight neutral posts (0.6) = 12 neutral points
- 5 low-weight bearish posts (0.3) = 1.5 bearish points
- **Net Sentiment:** (9 - 1.5) / (9 + 12 + 1.5) = 33% bullish
## OUTPUT STRUCTURE (MANDATORY)
### Sentiment Summary
@ -60,40 +63,4 @@ QUANTIFY social sentiment and identify sentiment SHIFTS that could drive short-t
Date: {current_date} | Ticker: {ticker}"""
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You are a helpful AI assistant, collaborating with other assistants."
" Use the provided tools to progress towards answering the question."
" If you are unable to fully answer, that's OK; another assistant with different tools"
" will help where you left off. Execute what you can to make progress."
" If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable,"
" prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop."
" You have access to the following tools: {tool_names}.\n{system_message}"
"For your reference, the current date is {current_date}. The current company we want to analyze is {ticker}",
),
MessagesPlaceholder(variable_name="messages"),
]
)
prompt = prompt.partial(system_message=system_message)
prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))
prompt = prompt.partial(current_date=current_date)
prompt = prompt.partial(ticker=ticker)
chain = prompt | llm.bind_tools(tools)
result = chain.invoke(state["messages"])
report = ""
if len(result.tool_calls) == 0:
report = result.content
return {
"messages": [result],
"sentiment_report": report,
}
return social_media_analyst_node
return create_analyst_node(llm, "social", "sentiment_report", _build_prompt)

152
tradingagents/agents/managers/research_manager.py
View File

@ -1,5 +1,5 @@
import time
import json
from tradingagents.agents.utils.agent_utils import format_memory_context
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_research_manager(llm, memory):
@ -12,128 +12,56 @@ def create_research_manager(llm, memory):
investment_debate_state = state["investment_debate_state"]
curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
past_memory_str = format_memory_context(memory, state)
if memory:
past_memories = memory.get_memories(curr_situation, n_matches=2)
else:
past_memories = []
prompt = (
f"""You are the Trade Judge for {state["company_of_interest"]}. Decide if there is a SHORT-TERM edge to trade this stock (1-2 weeks).
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact, no correlation talk).
- Base claims on the provided reports and debate arguments (avoid inventing external macro narratives).
- Output must be either BUY (go long) or SELL (go short/avoid). If the edge is unclear, pick the less-bad side and set conviction to Low.
if past_memories:
past_memory_str = "### Past Lessons Applied\\n**Reflections from Similar Situations:**\\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\\n\\n"
past_memory_str += "\\n\\n**How I'm Using These Lessons:**\\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\\n"
past_memory_str += "- [Impact on current conviction level]\\n"
else:
past_memory_str = "" # Don't include placeholder when no memories
## DECISION FRAMEWORK (Simple)
Score each direction 0-10 based on evidence quality and tradeability in the next 5-14 days:
- Long Edge Score (0-10)
- Short Edge Score (0-10)
prompt = f"""You are the Portfolio Manager judging the Bull vs Bear debate. Make a definitive SHORT-TERM decision: BUY, SELL, or HOLD (rare).
## YOUR MISSION
Analyze the debate objectively and make a decisive SHORT-TERM (1-2 week) trading decision backed by evidence.
## DECISION FRAMEWORK
### Score Each Side (0-10)
Evaluate both Bull and Bear arguments:
**Bull Score:**
- Evidence Strength: [0-10] (hard data vs speculation)
- Logic: [0-10] (sound reasoning?)
- Short-Term Relevance: [0-10] (matters in 1-2 weeks?)
- **Total Bull: [X]/30**
**Bear Score:**
- Evidence Strength: [0-10] (hard data vs speculation)
- Logic: [0-10] (sound reasoning?)
- Short-Term Relevance: [0-10] (matters in 1-2 weeks?)
- **Total Bear: [X]/30**
### Decision Matrix
**BUY if:**
- Bull score > Bear score by 3+ points
- Clear short-term catalyst (next 1-2 weeks)
- Risk/reward ratio >2:1
- Technical setup supports entry
- Past lessons don't show pattern failure
**SELL if:**
- Bear score > Bull score by 3+ points
- Significant near-term risks
- Catalyst already priced in
- Risk/reward ratio <1:1
- Technical breakdown evident
**HOLD if (ALL must apply - should be RARE):**
- Scores within 2 points (truly balanced)
- Major catalyst imminent (1-3 days away)
- Waiting provides significant option value
- Current position is optimal
Choose the direction with the higher score. If tied, choose BUY.
## OUTPUT STRUCTURE (MANDATORY)
### Debate Scorecard
| Criterion | Bull | Bear | Winner |
|-----------|------|------|--------|
| Evidence | [X]/10 | [Y]/10 | [Bull/Bear] |
| Logic | [X]/10 | [Y]/10 | [Bull/Bear] |
| Short-Term | [X]/10 | [Y]/10 | [Bull/Bear] |
| **TOTAL** | **[X]** | **[Y]** | **[Winner] +[Diff]** |
### Decision Summary
**DECISION: BUY / SELL / HOLD**
### Decision
**DECISION: BUY** or **SELL** (choose exactly one)
**Conviction: High / Medium / Low**
**Time Horizon: [X] days (typically 5-14 days)**
**Recommended Position Size: [X]% of capital**
**Time Horizon: [X] days**
### Winning Arguments
- **Bull's Strongest:** [Quote best Bull point if buying]
- **Bear's Strongest:** [Quote best Bear point even if buying - acknowledge risk]
- **Decisive Factor:** [What tipped the scale]
### Trade Setup (Specific)
- Entry: [price/condition]
- Stop: [price] ([%] risk)
- Target: [price] ([%] reward)
- Risk/Reward: [ratio]
- Invalidation: [what would prove you wrong]
- Catalyst / Timing: [next 1-2 weeks drivers]
### Investment Plan for Trader
**Execution Strategy:**
- Entry: [When and at what price]
- Stop Loss: [Specific level and % risk]
- Target: [Specific level and % gain]
- Risk/Reward: [Ratio]
- Time Limit: [Max holding period]
### Why This Should Work
- [3 bullets max: data-backed reasons]
**If BUY:**
- Why Bull won the debate
- Key catalyst timeline
- Exit strategy (both profit and loss)
**If SELL:**
- Why Bear won the debate
- Key risk timeline
- When to reassess
**If HOLD (rare):**
- Why waiting is optimal
- What event we're waiting for (date)
- Decision trigger (when to reassess)
## QUALITY RULES
- ✅ Be decisive (avoid fence-sitting)
- ✅ Score objectively with numbers
- ✅ Quote specific arguments from debate
- ✅ Focus on 1-2 week horizon
- ✅ Learn from past mistakes
- ❌ Don't default to HOLD to avoid deciding
- ❌ Don't ignore strong opposing arguments
- ❌ Don't make long-term arguments
""" + (f"""
### What Could Break It
- [2 bullets max: key risks]
"""
+ (
f"""
## PAST LESSONS
Here are reflections on past mistakes - apply these lessons:
{past_memory_str}
**Learning Check:** How are you adjusting based on these past situations?
""" if past_memory_str else "") + f"""
"""
if past_memory_str
else ""
)
+ f"""
---
**DEBATE TO JUDGE:**
@ -144,20 +72,22 @@ Technical: {market_research_report}
Sentiment: {sentiment_report}
News: {news_report}
Fundamentals: {fundamentals_report}"""
)
response = llm.invoke(prompt)
response_text = parse_llm_response(response.content)
new_investment_debate_state = {
"judge_decision": response.content,
"judge_decision": response_text,
"history": investment_debate_state.get("history", ""),
"bear_history": investment_debate_state.get("bear_history", ""),
"bull_history": investment_debate_state.get("bull_history", ""),
"current_response": response.content,
"current_response": response_text,
"count": investment_debate_state["count"],
}
return {
"investment_debate_state": new_investment_debate_state,
"investment_plan": response.content,
"investment_plan": response_text,
}
return research_manager_node

173
tradingagents/agents/managers/risk_manager.py
View File

@ -1,5 +1,5 @@
import time
import json
from tradingagents.agents.utils.agent_utils import format_memory_context
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_risk_manager(llm, memory):
@ -11,145 +11,59 @@ def create_risk_manager(llm, memory):
risk_debate_state = state["risk_debate_state"]
market_research_report = state["market_report"]
news_report = state["news_report"]
fundamentals_report = state["news_report"]
fundamentals_report = state["fundamentals_report"]
sentiment_report = state["sentiment_report"]
trader_plan = state["investment_plan"]
trader_plan = state.get("trader_investment_plan") or state.get("investment_plan", "")
curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
past_memory_str = format_memory_context(memory, state)
if memory:
past_memories = memory.get_memories(curr_situation, n_matches=2)
else:
past_memories = []
prompt = (
f"""You are the Final Trade Decider for {company_name}. Make the final SHORT-TERM call (5-14 days) based on the risk debate and the provided data.
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact, no correlation analysis).
- Base your decision on the provided reports and debate arguments only.
- Output a clean, actionable trade setup: entry, stop, target, and invalidation.
if past_memories:
past_memory_str = "### Past Lessons Applied\\n**Reflections from Similar Situations:**\\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\\n\\n"
past_memory_str += "\\n\\n**How I'm Using These Lessons:**\\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\\n"
past_memory_str += "- [Impact on current conviction level]\\n"
else:
past_memory_str = "" # Don't include placeholder when no memories
prompt = f"""You are the Chief Risk Officer making the FINAL decision on position sizing and execution for {company_name}.
## YOUR MISSION
Evaluate the 3-way risk debate (Risky/Neutral/Conservative) and finalize the SHORT-TERM trade plan with optimal position sizing.
## DECISION FRAMEWORK
### Score Each Perspective (0-10)
Rate how well each analyst's arguments apply to THIS specific situation:
**Risky Analyst Score:**
- Opportunity Assessment: [0-10] (how big is the opportunity?)
- Risk/Reward Math: [0-10] (is aggressive sizing justified?)
- Short-Term Conviction: [0-10] (high probability in 1-2 weeks?)
- **Total Risky: [X]/30**
**Neutral Analyst Score:**
- Balance: [0-10] (acknowledges both sides fairly?)
- Pragmatism: [0-10] (is moderate sizing wise?)
- Risk Mitigation: [0-10] (does hedging make sense?)
- **Total Neutral: [X]/30**
**Conservative Analyst Score:**
- Risk Identification: [0-10] (are the risks real?)
- Downside Protection: [0-10] (is caution warranted?)
- Opportunity Cost: [0-10] (is this the best use of capital?)
- **Total Conservative: [X]/30**
### Position Sizing Matrix
**Large Position (8-12% of capital):**
- High conviction (Research Manager scored Bull 25+ or Bear 25+)
- Clear short-term catalyst (1-5 days away)
- Risk/reward >3:1
- Risky score >24/30 AND Conservative score <18/30
- Past lessons support aggressive sizing
**Medium Position (4-7% of capital):**
- Medium conviction
- Catalyst in 5-14 days
- Risk/reward 2:1 to 3:1
- Neutral score highest OR scores balanced
- Standard risk management sufficient
**Small Position (1-3% of capital):**
- Lower conviction but interesting setup
- Uncertain timing
- Risk/reward 1.5:1 to 2:1
- Conservative score >24/30 OR high uncertainty
- Exploratory position
**NO POSITION (0%):**
- Conservative score >25/30 AND Risky score <15/30
- Risk/reward <1.5:1
- No clear catalyst
- Past lessons show pattern failure
- Better opportunities available
## DECISION FRAMEWORK (Simple)
Pick one:
- **BUY** if the upside path is clearer than the downside and the trade has a definable stop/target with reasonable risk/reward.
- **SELL** if downside path is clearer than the upside and the trade has a definable stop/target.
If evidence is contradictory, still choose BUY or SELL and set conviction to Low.
## OUTPUT STRUCTURE (MANDATORY)
### Risk Assessment Scorecard
| Perspective | Opportunity | Risk Mgmt | Conviction | Total | Winner |
|-------------|-------------|-----------|------------|-------|--------|
| Risky | [X]/10 | [Y]/10 | [Z]/10 | **[A]/30** | - |
| Neutral | [X]/10 | [Y]/10 | [Z]/10 | **[B]/30** | - |
| Conservative | [X]/10 | [Y]/10 | [Z]/10 | **[C]/30** | **✓** |
### Final Decision
**DECISION: BUY / SELL / HOLD**
**Position Size: [X]% of capital**
**Risk Level: High / Medium / Low**
**DECISION: BUY** or **SELL** (choose exactly one)
**Conviction: High / Medium / Low**
**Time Horizon: [X] days**
### Execution Plan (Refined from Trader's Original Plan)
### Execution
- Entry: [price/condition]
- Stop: [price] ([%] risk)
- Target: [price] ([%] reward)
- Risk/Reward: [ratio]
- Invalidation: [what would prove you wrong]
- Catalyst / Timing: [what should move it in next 1-2 weeks]
**Original Trader Recommendation:**
{trader_plan}
### Rationale
- [3 bullets max: strongest data-backed reasons]
**Risk-Adjusted Execution:**
- Position Size: [X]% (vs Trader's [Y]%)
- Entry: [Price/Market] (timing adjustment if needed)
- Stop Loss: $[X] ([Y]% max loss = $[Z] on portfolio)
- Target: $[A] ([B]% gain = $[C] on portfolio)
- Time Limit: [X] days max hold
- Risk/Reward: [Ratio]
**Adjustments Made:**
- [What changed from trader's plan and why]
- [Risk controls added]
- [Position sizing rationale]
### Winning Arguments
- **Most Compelling:** "[Quote best argument]"
- **Key Risk Acknowledged:** "[Quote main concern even if proceeding]"
- **Decisive Factor:** [What determined position size]
### Portfolio Impact
- **Max Loss:** $[X] ([Y]% of portfolio) if stopped out
- **Expected Gain:** $[A] ([B]% of portfolio) if target hit
- **Break-Even:** [Days until trade costs outweigh benefit]
## QUALITY RULES
- ✅ Size position to match conviction level
- ✅ Quote specific analyst arguments
- ✅ Calculate exact dollar risk on portfolio
- ✅ Adjust trader's plan with clear rationale
- ✅ Learn from past sizing mistakes
- ❌ Don't use medium position as default
- ❌ Don't ignore Conservative warnings if valid
- ❌ Don't size based on hope, only conviction
""" + (f"""
### Key Risks
- [2 bullets max: main ways it fails]
"""
+ (
f"""
## PAST LESSONS - CRITICAL
Review past mistakes to avoid repeating sizing errors:
Review past mistakes to avoid repeating trade-setup errors:
{past_memory_str}
**Self-Check:** Have similar setups failed before? What was the sizing mistake?
""" if past_memory_str else "") + f"""
**Self-Check:** Have similar setups failed before? What was the key mistake (timing, catalyst read, or stop placement)?
"""
if past_memory_str
else ""
)
+ f"""
---
**RISK DEBATE TO JUDGE:**
@ -160,13 +74,14 @@ Technical: {market_research_report}
Sentiment: {sentiment_report}
News: {news_report}
Fundamentals: {fundamentals_report}
**REMEMBER:** Position sizing is your PRIMARY tool for risk management. When uncertain, go smaller. When conviction is high AND risks are managed, go bigger."""
"""
)
response = llm.invoke(prompt)
response_text = parse_llm_response(response.content)
new_risk_debate_state = {
"judge_decision": response.content,
"judge_decision": response_text,
"history": risk_debate_state["history"],
"risky_history": risk_debate_state["risky_history"],
"safe_history": risk_debate_state["safe_history"],
@ -180,7 +95,7 @@ Fundamentals: {fundamentals_report}
return {
"risk_debate_state": new_risk_debate_state,
"final_trade_decision": response.content,
"final_trade_decision": response_text,
}
return risk_manager_node

45
tradingagents/agents/researchers/bear_researcher.py
View File

@ -1,6 +1,5 @@
from langchain_core.messages import AIMessage
import time
import json
from tradingagents.agents.utils.agent_utils import format_memory_context
from tradingagents.agents.utils.llm_utils import create_and_invoke_chain, parse_llm_response
def create_bear_researcher(llm, memory):
@ -15,23 +14,7 @@ def create_bear_researcher(llm, memory):
news_report = state["news_report"]
fundamentals_report = state["fundamentals_report"]
curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
if memory:
past_memories = memory.get_memories(curr_situation, n_matches=2)
else:
past_memories = []
if past_memories:
past_memory_str = "### Past Lessons Applied\n**Reflections from Similar Situations:**\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\n\n"
past_memory_str += "\n\n**How I'm Using These Lessons:**\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\n"
past_memory_str += "- [Impact on current conviction level]\n"
else:
past_memory_str = ""
past_memory_str = format_memory_context(memory, state)
prompt = f"""You are the Bear Analyst making the case for SHORT-TERM SELL/AVOID (1-2 weeks).
@ -49,12 +32,15 @@ For each:
- **Evidence:** [Specific data - numbers, dates]
- **Short-Term Impact:** [Impact in next 1-2 weeks]
- **Probability:** [High/Med/Low]
- **Strength Score:** [1-10] (10 = very strong, 5 = moderate, 1 = weak)
- **Confidence:** [High/Med/Low] based on data quality
### Bull Rebuttals
For EACH Bull claim:
- **Bull Says:** "[Quote]"
- **Counter:** [Why they're wrong]
- **Flaw:** [Weakness in their logic]
- **Rebuttal Strength:** [Strong/Moderate/Weak] - does your counter fully address their claim?
### Strengths I Acknowledge
- [1-2 legitimate Bull points]
@ -84,14 +70,27 @@ Fundamentals: {fundamentals_report}
**DEBATE:**
History: {history}
Last Bull: {current_response}
""" + (
f"""
## PAST LESSONS APPLICATION (Review BEFORE making arguments)
{past_memory_str}
**LESSONS:** {past_memory_str}
**For each relevant past lesson:**
1. **Similar Situation:** [What was similar?]
2. **What Went Wrong/Right:** [Specific outcome]
3. **How I'm Adjusting:** [Specific change to current argument based on lesson]
4. **Impact on Conviction:** [Increases/Decreases/No change to conviction level]
Apply lessons: How are you adjusting?"""
if past_memory_str
else ""
)
response = llm.invoke(prompt)
response = create_and_invoke_chain(llm, [], prompt, [])
argument = f"Bear Analyst: {response.content}"
response_text = parse_llm_response(response.content)
argument = f"Bear Analyst: {response_text}"
new_investment_debate_state = {
"history": history + "\n" + argument,

49
tradingagents/agents/researchers/bull_researcher.py
View File

@ -1,6 +1,5 @@
from langchain_core.messages import AIMessage
import time
import json
from tradingagents.agents.utils.agent_utils import format_memory_context
from tradingagents.agents.utils.llm_utils import create_and_invoke_chain, parse_llm_response
def create_bull_researcher(llm, memory):
@ -15,23 +14,7 @@ def create_bull_researcher(llm, memory):
news_report = state["news_report"]
fundamentals_report = state["fundamentals_report"]
curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
if memory:
past_memories = memory.get_memories(curr_situation, n_matches=2)
else:
past_memories = []
if past_memories:
past_memory_str = "### Past Lessons Applied\\n**Reflections from Similar Situations:**\\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\\n\\n"
past_memory_str += "\\n\\n**How I'm Using These Lessons:**\\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\\n"
past_memory_str += "- [Impact on current conviction level]\\n"
else:
past_memory_str = "" # Don't include placeholder when no memories
past_memory_str = format_memory_context(memory, state)
prompt = f"""You are the Bull Analyst making the case for a SHORT-TERM BUY (1-2 weeks).
@ -48,12 +31,15 @@ For each:
- **Point:** [Bullish argument]
- **Evidence:** [Specific data - numbers, dates]
- **Short-Term Relevance:** [Impact in next 1-2 weeks]
- **Strength Score:** [1-10] (10 = very strong, 5 = moderate, 1 = weak)
- **Confidence:** [High/Med/Low] based on data quality
### Bear Rebuttals
For EACH Bear concern:
- **Bear Says:** "[Quote]"
- **Counter:** [Data-driven refutation]
- **Why Wrong:** [Flaw in their logic]
- **Rebuttal Strength:** [Strong/Moderate/Weak] - does your counter fully address their concern?
### Risks I Acknowledge
- [1-2 legitimate risks]
@ -83,14 +69,27 @@ Fundamentals: {fundamentals_report}
**DEBATE:**
History: {history}
Last Bear: {current_response}
""" + (f"""
**LESSONS:** {past_memory_str}
""" + (
f"""
## PAST LESSONS APPLICATION (Review BEFORE making arguments)
{past_memory_str}
Apply past lessons: How are you adjusting based on similar situations?""" if past_memory_str else "")
**For each relevant past lesson:**
1. **Similar Situation:** [What was similar?]
2. **What Went Wrong/Right:** [Specific outcome]
3. **How I'm Adjusting:** [Specific change to current argument based on lesson]
4. **Impact on Conviction:** [Increases/Decreases/No change to conviction level]
response = llm.invoke(prompt)
Apply past lessons: How are you adjusting based on similar situations?"""
if past_memory_str
else ""
)
argument = f"Bull Analyst: {response.content}"
response = create_and_invoke_chain(llm, [], prompt, [])
response_text = parse_llm_response(response.content)
argument = f"Bull Analyst: {response_text}"
new_investment_debate_state = {
"history": history + "\n" + argument,

100
tradingagents/agents/risk_mgmt/aggresive_debator.py
View File

@ -1,12 +1,11 @@
import time
import json
from tradingagents.agents.utils.agent_utils import update_risk_debate_state
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_risky_debator(llm):
def risky_node(state) -> dict:
risk_debate_state = state["risk_debate_state"]
history = risk_debate_state.get("history", "")
risky_history = risk_debate_state.get("risky_history", "")
current_safe_response = risk_debate_state.get("current_safe_response", "")
current_neutral_response = risk_debate_state.get("current_neutral_response", "")
@ -18,73 +17,36 @@ def create_risky_debator(llm):
trader_decision = state["trader_investment_plan"]
prompt = f"""You are the Aggressive Risk Analyst advocating for MAXIMUM position sizing to capture this SHORT-TERM opportunity.
prompt = f"""You are the Aggressive Trade Reviewer. Your job is to push for taking the trade if there is a short-term edge (5-14 days).
## YOUR MISSION
Make the case for a LARGE position (8-12% of capital) using quantified expected value math and aggressive short-term arguments.
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact).
- Use ONLY the provided reports and the trader plan as evidence.
- Focus on the upside path: what must happen for this to work, and how to structure the trade to capture it.
## ARGUMENT FRAMEWORK
## OUTPUT STRUCTURE (MANDATORY)
### Expected Value Calculation
**Position the Math:**
- Probability of Success: [X]% (based on data)
- Potential Gain: [Y]%
- Probability of Failure: [Z]%
- Potential Loss: [W]%
- **Expected Value: ([X]% × [Y]%) - ([Z]% × [W]%) = [EV]%**
### Stance
State whether you agree with the Trader's direction (BUY/SELL) or flip it (no HOLD).
If EV is positive and >3%, argue for aggressive sizing.
### Best-Case Setup
- Entry: [price/condition]
- Stop: [price] ([%] risk)
- Target: [price] ([%] reward)
- Risk/Reward: [ratio]
### Structure Your Case
### Why This Can Work Soon
- [3 bullets max: catalyst + technical + sentiment/news/fundamentals, all from provided data]
**1. Opportunity Size (Why Go Big)**
- **Upside:** [Specific % gain potential]
- **Catalyst Strength:** [Why catalyst is powerful]
- **Time Sensitivity:** [Why we must act NOW, not wait]
- **Edge:** [What others are missing]
**2. Risk/Reward Math**
- Best Case: [X]% gain in [Y] days
- Base Case: [A]% gain in [B] days
- Stop Loss: [C]% (tight control)
- **Risk/Reward Ratio: [Ratio] (>3:1 ideal)**
**3. Counter Conservative Points**
For EACH concern the Safe Analyst raised:
- **Safe Says:** "[Quote their concern]"
- **Why They're Wrong:** [Data refutation]
- **Reality:** [The actual probability is lower than they claim]
**4. Counter Neutral Points**
- **Neutral Says:** "[Quote their moderation]"
- **Why Moderate Sizing Loses:** [Opportunity cost argument]
- **Math:** [Show that 4% position vs 10% position makes huge difference]
## QUALITY RULES
- ✅ USE NUMBERS: "70% probability, 25% upside = +17.5% EV"
- ✅ Quote specific counterarguments from others
- ✅ Show time sensitivity (catalyst in X days)
- ✅ Acknowledge risks but show they're manageable
- ❌ Don't ignore legitimate concerns
- ❌ Don't exaggerate without data
- ❌ Don't argue for recklessness, argue for calculated aggression
## POSITION SIZING ADVOCACY
**Push for 8-12% position if:**
- Expected value >5%
- Risk/reward >3:1
- Catalyst within 5 days
- Technical setup is optimal
**Argue against conservative sizing:**
"A 2% position on a 25% expected gain opportunity is leaving money on the table. If we're right, we make 0.5% on the portfolio. If we size at 10%, we make 2.5%. That's 5X the profit for the same analysis work."
### Counters (Brief)
- Respond to the Safe and Neutral critiques with 1-2 data-backed points each.
---
**TRADER'S PLAN:**
{trader_decision}
**YOUR TASK:** Argue why this plan should be executed with MAXIMUM conviction sizing.
**YOUR TASK:** Argue why this plan should be executed with conviction and clear triggers.
**MARKET DATA:**
- Technical: {market_research_report}
@ -101,26 +63,12 @@ For EACH concern the Safe Analyst raised:
**NEUTRAL ARGUMENT:**
{current_neutral_response}
**If no other arguments yet:** Present your bullish case with expected value math."""
**If no other arguments yet:** Present your strongest case for why this trade can work soon, using only the provided data."""
response = llm.invoke(prompt)
response_text = parse_llm_response(response.content)
argument = f"Risky Analyst: {response_text}"
argument = f"Risky Analyst: {response.content}"
new_risk_debate_state = {
"history": history + "\n" + argument,
"risky_history": risky_history + "\n" + argument,
"safe_history": risk_debate_state.get("safe_history", ""),
"neutral_history": risk_debate_state.get("neutral_history", ""),
"latest_speaker": "Risky",
"current_risky_response": argument,
"current_safe_response": risk_debate_state.get("current_safe_response", ""),
"current_neutral_response": risk_debate_state.get(
"current_neutral_response", ""
),
"count": risk_debate_state["count"] + 1,
}
return {"risk_debate_state": new_risk_debate_state}
return {"risk_debate_state": update_risk_debate_state(risk_debate_state, argument, "Risky")}
return risky_node

116
tradingagents/agents/risk_mgmt/conservative_debator.py
View File

@ -1,13 +1,11 @@
from langchain_core.messages import AIMessage
import time
import json
from tradingagents.agents.utils.agent_utils import update_risk_debate_state
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_safe_debator(llm):
def safe_node(state) -> dict:
risk_debate_state = state["risk_debate_state"]
history = risk_debate_state.get("history", "")
safe_history = risk_debate_state.get("safe_history", "")
current_risky_response = risk_debate_state.get("current_risky_response", "")
current_neutral_response = risk_debate_state.get("current_neutral_response", "")
@ -19,85 +17,37 @@ def create_safe_debator(llm):
trader_decision = state["trader_investment_plan"]
prompt = f"""You are the Conservative Risk Analyst advocating for MINIMAL position sizing or NO POSITION to protect capital.
prompt = f"""You are the Risk Audit Reviewer. Your job is to find the fastest ways this trade fails (5-14 days) and tighten the setup if possible.
## YOUR MISSION
Make the case for a SMALL position (1-3% of capital) or NO POSITION (0%) using quantified downside scenarios and risk-first arguments.
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact).
- Use ONLY the provided reports and trader plan as evidence.
- You are not required to be conservative; you are required to be precise about invalidation and risk.
## ARGUMENT FRAMEWORK
## OUTPUT STRUCTURE (MANDATORY)
### Downside Scenario Analysis
**Quantify the Risks:**
- Probability of Loss: [X]% (realistic assessment)
- Maximum Loss: [Y]% (if wrong)
- Hidden Risks: [List 2-3 risks others missed]
- **Expected Loss: [X]% × [Y]% = [Z]%**
### Stance
Choose BUY or SELL (no HOLD). If the setup looks poor, still pick the less-bad side and be specific about invalidation and the fastest failure modes.
If downside risk is high, argue for minimal or no sizing.
### Failure Modes (Top 3)
- [1] [Risk] → [what would we see in price/news/data?]
- [2] ...
- [3] ...
### Structure Your Case
### Invalidation & Risk Controls
- Invalidation trigger: [specific]
- Stop improvement (if needed): [price/logic]
- Timing risk: [what catalyst could flip this]
**1. Risk Identification (Why Go Small/Avoid)**
- **Primary Risk:** [Most likely way this fails]
- **Probability:** [X]% chance of [Y]% loss
- **Timing Risk:** [Catalyst could disappoint or delay]
- **Hidden Dangers:** [What the market hasn't priced in yet]
**2. Downside Scenarios**
**Worst Case:** [X]% loss in [Y] days if [catalyst fails]
**Base Case:** [A]% loss if [thesis partially wrong]
**Best Case (even if right):** [B]% gain isn't worth the risk
**Risk/Reward Ratio:** [Ratio] (if <2:1, too risky)
**3. Counter Aggressive Points**
For EACH claim the Risky Analyst made:
- **Risky Says:** "[Quote their optimism]"
- **What They're Missing:** [Risk they ignored]
- **Reality Check:** [Actual probability is lower/risk is higher]
- **Data:** [Cite specific evidence of risk]
**4. Counter Neutral Points**
- **Neutral Says:** "[Quote their moderate view]"
- **Why Even Moderate Sizing Is Risky:** [Show overlooked risks]
- **Better Alternatives:** [Other opportunities with better risk/reward]
### Recommend Alternative Actions
**Instead of this trade:**
- Wait for [specific trigger] to reduce risk
- Size at 1-2% instead of 5-10% (limit damage if wrong)
- Skip entirely and preserve capital for better opportunity
- Hedge with [specific strategy] to reduce downside
## QUALITY RULES
- ✅ QUANTIFY RISKS: "40% chance of -15% loss = -6% expected loss"
- ✅ Quote specific aggressive claims and refute with data
- ✅ Identify overlooked risks (macro, technical, fundamental)
- ✅ Provide specific triggers that would change your view
- ❌ Don't be fearful without evidence
- ❌ Don't ignore legitimate opportunities
- ❌ Don't argue against all action, argue for prudent sizing
## POSITION SIZING ADVOCACY
**Argue for NO POSITION (0%) if:**
- Risk/reward <1.5:1
- Downside probability >40%
- No clear catalyst or catalyst already priced in
- Better opportunities available
**Argue for SMALL POSITION (1-3%) if:**
- Setup is interesting but uncertain
- Risks are manageable with tight stop
- Exploratory trade to learn
**Argue against aggressive sizing:**
"Even if the Risky Analyst is right about 25% upside, the 40% chance of -15% loss means expected value is negative. A 10% position could lose us 1.5% of the portfolio. That's three good trades' worth of profit."
### Response to Aggressive/Neutral (Brief)
- [1-2 bullets total]
---
**TRADER'S PLAN:**
{trader_decision}
**YOUR TASK:** Identify the risks others are missing and argue for minimal or no position.
**YOUR TASK:** Identify the risks others are missing and tighten the trade with clear invalidation.
**MARKET DATA:**
- Technical: {market_research_report}
@ -114,28 +64,12 @@ For EACH claim the Risky Analyst made:
**NEUTRAL ARGUMENT:**
{current_neutral_response}
**If no other arguments yet:** Present your bearish case with downside scenario analysis."""
**If no other arguments yet:** Identify trade invalidation and the key risks using only the provided data."""
response = llm.invoke(prompt)
response_text = parse_llm_response(response.content)
argument = f"Safe Analyst: {response_text}"
argument = f"Safe Analyst: {response.content}"
new_risk_debate_state = {
"history": history + "\n" + argument,
"risky_history": risk_debate_state.get("risky_history", ""),
"safe_history": safe_history + "\n" + argument,
"neutral_history": risk_debate_state.get("neutral_history", ""),
"latest_speaker": "Safe",
"current_risky_response": risk_debate_state.get(
"current_risky_response", ""
),
"current_safe_response": argument,
"current_neutral_response": risk_debate_state.get(
"current_neutral_response", ""
),
"count": risk_debate_state["count"] + 1,
}
return {"risk_debate_state": new_risk_debate_state}
return {"risk_debate_state": update_risk_debate_state(risk_debate_state, argument, "Safe")}
return safe_node

113
tradingagents/agents/risk_mgmt/neutral_debator.py
View File

@ -1,12 +1,11 @@
import time
import json
from tradingagents.agents.utils.agent_utils import update_risk_debate_state
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_neutral_debator(llm):
def neutral_node(state) -> dict:
risk_debate_state = state["risk_debate_state"]
history = risk_debate_state.get("history", "")
neutral_history = risk_debate_state.get("neutral_history", "")
current_risky_response = risk_debate_state.get("current_risky_response", "")
current_safe_response = risk_debate_state.get("current_safe_response", "")
@ -18,84 +17,36 @@ def create_neutral_debator(llm):
trader_decision = state["trader_investment_plan"]
prompt = f"""You are the Neutral Risk Analyst advocating for BALANCED position sizing (4-7% of capital) that optimizes risk-adjusted returns.
prompt = f"""You are the Neutral Trade Reviewer. Your job is to sanity-check the trade with a realistic base case (5-14 days).
## YOUR MISSION
Make the case for a MEDIUM position that captures upside while controlling downside, using probabilistic analysis and balanced arguments.
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact).
- Use ONLY the provided reports and the trader plan as evidence.
- Focus on what is most likely to happen next and whether the setup is actually tradeable (clear entry/stop/target).
## ARGUMENT FRAMEWORK
## OUTPUT STRUCTURE (MANDATORY)
### Probabilistic Analysis
**Balance the Probabilities:**
- Bull Case Probability: [X]%
- Bear Case Probability: [Y]%
- Neutral Case Probability: [Z]%
- **Most Likely Outcome:** [Describe scenario with highest probability]
- **Expected Value:** [Calculate using all scenarios]
### Stance
Choose BUY or SELL (no HOLD). If the edge is unclear, pick the less-bad side and keep the reasoning explicit.
### Structure Your Case
### Base-Case Setup
- Entry: [price/condition]
- Stop: [price] ([%] risk)
- Target: [price] ([%] reward)
- Risk/Reward: [ratio]
**1. Balanced Assessment**
- **Opportunity Recognition:** [What's real about the bull case]
- **Risk Recognition:** [What's valid about the bear case]
- **Optimal Sizing:** [Why 4-7% captures both]
- **Middle Ground:** [The scenario both extremes are missing]
### Base-Case View
- Most likely outcome in 5-14 days: [up / down / range]
- Why: [2 bullets max, data-backed]
**2. Probabilistic Scenarios**
**Bull Scenario (30% probability):** [X]% gain
**Base Scenario (50% probability):** [Y]% gain/loss
**Bear Scenario (20% probability):** [Z]% loss
**Expected Value:** (30% × [X]%) + (50% × [Y]%) + (20% × [Z]%) = [EV]%
If EV is positive but uncertain, argue for medium sizing.
**3. Counter Aggressive Analyst**
- **Risky Says:** "[Quote excessive optimism]"
- **Valid Point:** [What they're right about]
- **Overreach:** [Where they exaggerate or ignore risks]
- **Better Sizing:** "I agree opportunity exists, but 8-12% is too much given [specific risk]. 5-6% captures upside with better risk control."
**4. Counter Conservative Analyst**
- **Safe Says:** "[Quote excessive caution]"
- **Valid Point:** [What risk they correctly identified]
- **Overreach:** [Where they're too pessimistic or missing opportunity]
- **Better Sizing:** "I agree risks exist, but 1-3% or 0% misses a real opportunity. 5-6% with tight stop manages risk while participating."
### Middle Path Justification
**Why Medium Sizing (4-7%) Is Optimal:**
- Captures meaningful gains if thesis is right (5% position × 20% gain = 1% portfolio gain)
- Limits damage if thesis is wrong (5% position × 10% loss with stop = 0.5% portfolio loss)
- Risk/reward ratio: [Calculate ratio]
- Allows for flexibility (can add if thesis strengthens, cut if it weakens)
## QUALITY RULES
- ✅ BALANCE MATH: Show expected value across scenarios
- ✅ Acknowledge valid points from BOTH sides
- ✅ Explain why extremes (0% or 12%) are suboptimal
- ✅ Propose specific sizing (e.g., "5.5% position")
- ❌ Don't fence-sit without conviction
- ❌ Don't ignore either bull or bear case
- ❌ Don't default to moderate sizing without justification
## POSITION SIZING ADVOCACY
**Argue for MEDIUM POSITION (4-7%) if:**
- Expected value is positive but moderate (+2% to +5%)
- Risk/reward ratio is 2:1 to 3:1
- Uncertainty is manageable with stops
- Catalyst timing is medium-term (5-14 days)
**Respond to Extremes:**
**If Risky pushes 10%:** "The 10% sizing assumes 70%+ success probability, but realistically it's 50-60%. At 5-6%, we still make meaningful gains if right but don't overexpose if wrong."
**If Safe pushes 0-2%:** "The risks are real but manageable. A 1% position makes only 0.2% on the portfolio even if we're right. That's not enough return for the analysis effort. 5% with a tight stop is prudent."
### Adjustments
- [1-2 concrete improvements to entry/stop/target or timing]
---
**TRADER'S PLAN:**
{trader_decision}
**YOUR TASK:** Find the balanced position size that maximizes risk-adjusted returns.
**MARKET DATA:**
- Technical: {market_research_report}
- Sentiment: {sentiment_report}
@ -108,29 +59,17 @@ If EV is positive but uncertain, argue for medium sizing.
**AGGRESSIVE ARGUMENT:**
{current_risky_response}
**CONSERVATIVE ARGUMENT:**
**SAFE ARGUMENT:**
{current_safe_response}
**If no other arguments yet:** Present your balanced case with probabilistic scenarios."""
**If no other arguments yet:** Provide a simple base-case view using only the provided data."""
response = llm.invoke(prompt)
response_text = parse_llm_response(response.content)
argument = f"Neutral Analyst: {response_text}"
argument = f"Neutral Analyst: {response.content}"
new_risk_debate_state = {
"history": history + "\n" + argument,
"risky_history": risk_debate_state.get("risky_history", ""),
"safe_history": risk_debate_state.get("safe_history", ""),
"neutral_history": neutral_history + "\n" + argument,
"latest_speaker": "Neutral",
"current_risky_response": risk_debate_state.get(
"current_risky_response", ""
),
"current_safe_response": risk_debate_state.get("current_safe_response", ""),
"current_neutral_response": argument,
"count": risk_debate_state["count"] + 1,
return {
"risk_debate_state": update_risk_debate_state(risk_debate_state, argument, "Neutral")
}
return {"risk_debate_state": new_risk_debate_state}
return neutral_node

122
tradingagents/agents/trader/trader.py
View File

@ -1,6 +1,7 @@
import functools
import time
import json
from tradingagents.agents.utils.agent_utils import format_memory_context
from tradingagents.agents.utils.llm_utils import parse_llm_response
def create_trader(llm, memory):
@ -12,121 +13,64 @@ def create_trader(llm, memory):
news_report = state["news_report"]
fundamentals_report = state["fundamentals_report"]
curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
if memory:
past_memories = memory.get_memories(curr_situation, n_matches=2)
else:
past_memories = []
if past_memories:
past_memory_str = "### Past Lessons Applied\\n**Reflections from Similar Situations:**\\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\\n\\n"
past_memory_str += "\\n\\n**How I'm Using These Lessons:**\\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\\n"
past_memory_str += "- [Impact on current conviction level]\\n"
else:
past_memory_str = "" # Don't include placeholder when no memories
past_memory_str = format_memory_context(memory, state)
context = {
"role": "user",
"content": f"Based on a comprehensive analysis by a team of analysts, here is an investment plan tailored for {company_name}. This plan incorporates insights from current technical market trends, macroeconomic indicators, and social media sentiment. Use this plan as a foundation for evaluating your next trading decision.\n\nProposed Investment Plan: {investment_plan}\n\nLeverage these insights to make an informed and strategic decision.",
"content": (
f"Use the analysts' reports and the judged plan below to craft a SIMPLE short-term trade setup "
f"for {company_name}. Focus on whether a single trade can make money in the next 5-14 days.\n\n"
f"Judged Plan:\n{investment_plan}"
),
}
messages = [
{
"role": "system",
"content": f"""You are the Lead Trader making the final SHORT-TERM trading decision on {company_name}.
"content": f"""You are the Lead Trader making a SIMPLE short-term trade call on {company_name} (5-14 days).
## YOUR RESPONSIBILITIES
1. **Validate the Plan:** Review for logic, data support, and risks
2. **Add Trading Details:** Entry price, position size, stop loss, targets
3. **Apply Past Lessons:** Learn from history (see reflections below)
4. **Make Final Call:** Clear BUY/HOLD/SELL with execution plan
## CORE RULES (CRITICAL)
- Evaluate this ticker IN ISOLATION (no portfolio sizing, no portfolio impact).
- Use ONLY the provided reports/plan for evidence (do not invent outside data).
- Your output should help a trader answer: "Can this trade make money soon, and where do I enter/exit?"
- You must output BUY or SELL (no HOLD). If unsure, pick the better-defined setup and set Conviction to Low.
## IMPORTANT: DECISION HIERARCHY
Your decision will be reviewed by the Risk Manager who may:
- Reduce position size if risks are high
- Override to NO POSITION if risks outweigh opportunity
- Adjust stop-loss levels for better risk management
## OUTPUT STRUCTURE (MANDATORY)
Make your best recommendation - the Risk Manager will apply final risk controls.
## SHORT-TERM TRADING CRITERIA (1-2 week horizon)
**BUY if:**
- Clear catalyst in next 5-10 days
- Technical setup favorable (not overextended)
- Risk/reward ratio >2:1
- Specific entry and stop loss levels identified
**SELL if:**
- Catalyst played out (news priced in, earnings passed)
- Technical breakdown or trend reversal
- Risk/reward deteriorated
- Better opportunities available
**HOLD if (rare, needs strong justification):**
- Major catalyst imminent (1-3 days away)
- Current position is optimal
- Waiting provides option value
## OUTPUT STRUCTURE (MANDATORY SECTIONS)
### Decision Summary
**DECISION: BUY / SELL / HOLD**
### Decision
**DECISION: BUY** or **SELL** (choose exactly one)
**Conviction: High / Medium / Low**
**Position Size: [X]% of capital**
**Time Horizon: [Y] days**
**Time Horizon: [X] days**
### Plan Evaluation
**What I Agree With:** [Key strengths from the plan]
**What I'm Concerned About:** [Gaps or risks in the plan]
**My Adjustments:** [How I'm modifying based on trading experience]
### Trade Setup
- Entry: [price/condition]
- Stop: [price] ([%] risk)
- Target: [price] ([%] reward)
- Risk/Reward: [ratio]
- Invalidation: [what would prove the thesis wrong]
- Catalyst / Timing: [what should move the stock in the next 1-2 weeks]
### Trade Execution Details
### Why
- [3 bullets max, data-backed]
**If BUY:**
- Entry: $[X] (or market)
- Size: [Y]% portfolio
- Stop Loss: $[A] ([B]% risk)
- Target: $[C] ([D]% gain)
- Horizon: [E] days
- Risk/Reward: [Ratio]
**If SELL:**
- Exit: $[X] (or market)
- Timing: [When/how to exit]
- Re-entry: [What would change my mind]
**If HOLD:**
- Why: [Specific justification]
- BUY trigger: [Event/price]
- SELL trigger: [Event/price]
- Review: [When to reassess]
### Risks
- [2 bullets max, data-backed]
{past_memory_str}
### Risk Management
- Max Loss: $[X] or [Y]%
- What Invalidates Thesis: [Specific condition]
- Portfolio Impact: [Effect on overall risk]
---
**FINAL TRANSACTION PROPOSAL: BUY/HOLD/SELL**
End with clear decision statement.""",
**FINAL TRANSACTION PROPOSAL: BUY/SELL**""",
},
context,
]
result = llm.invoke(messages)
trader_plan = parse_llm_response(result.content)
return {
"messages": [result],
"trader_investment_plan": result.content,
"trader_investment_plan": trader_plan,
"sender": name,
}

52
tradingagents/agents/utils/agent_states.py
View File

@ -1,20 +1,15 @@
from typing import Annotated, Sequence
from datetime import date, timedelta, datetime
from typing_extensions import TypedDict, Optional
from langchain_openai import ChatOpenAI
from typing import Annotated
from langgraph.graph import MessagesState
from typing_extensions import TypedDict
from tradingagents.agents import *
from langgraph.prebuilt import ToolNode
from langgraph.graph import END, StateGraph, START, MessagesState
# Researcher team state
class InvestDebateState(TypedDict):
bull_history: Annotated[
str, "Bullish Conversation history"
] # Bullish Conversation history
bear_history: Annotated[
str, "Bearish Conversation history"
] # Bullish Conversation history
bull_history: Annotated[str, "Bullish Conversation history"] # Bullish Conversation history
bear_history: Annotated[str, "Bearish Conversation history"] # Bullish Conversation history
history: Annotated[str, "Conversation history"] # Conversation history
current_response: Annotated[str, "Latest response"] # Last response
judge_decision: Annotated[str, "Final judge decision"] # Last response
@ -23,23 +18,13 @@ class InvestDebateState(TypedDict):
# Risk management team state
class RiskDebateState(TypedDict):
risky_history: Annotated[
str, "Risky Agent's Conversation history"
] # Conversation history
safe_history: Annotated[
str, "Safe Agent's Conversation history"
] # Conversation history
neutral_history: Annotated[
str, "Neutral Agent's Conversation history"
] # Conversation history
risky_history: Annotated[str, "Risky Agent's Conversation history"] # Conversation history
safe_history: Annotated[str, "Safe Agent's Conversation history"] # Conversation history
neutral_history: Annotated[str, "Neutral Agent's Conversation history"] # Conversation history
history: Annotated[str, "Conversation history"] # Conversation history
latest_speaker: Annotated[str, "Analyst that spoke last"]
current_risky_response: Annotated[
str, "Latest response by the risky analyst"
] # Last response
current_safe_response: Annotated[
str, "Latest response by the safe analyst"
] # Last response
current_risky_response: Annotated[str, "Latest response by the risky analyst"] # Last response
current_safe_response: Annotated[str, "Latest response by the safe analyst"] # Last response
current_neutral_response: Annotated[
str, "Latest response by the neutral analyst"
] # Last response
@ -56,9 +41,7 @@ class AgentState(MessagesState):
# research step
market_report: Annotated[str, "Report from the Market Analyst"]
sentiment_report: Annotated[str, "Report from the Social Media Analyst"]
news_report: Annotated[
str, "Report from the News Researcher of current world affairs"
]
news_report: Annotated[str, "Report from the News Researcher of current world affairs"]
fundamentals_report: Annotated[str, "Report from the Fundamentals Researcher"]
# researcher team discussion step
@ -70,9 +53,7 @@ class AgentState(MessagesState):
trader_investment_plan: Annotated[str, "Plan generated by the Trader"]
# risk management team discussion step
risk_debate_state: Annotated[
RiskDebateState, "Current state of the debate on evaluating risk"
]
risk_debate_state: Annotated[RiskDebateState, "Current state of the debate on evaluating risk"]
final_trade_decision: Annotated[str, "Final decision made by the Risk Analysts"]
@ -84,5 +65,6 @@ class DiscoveryState(TypedDict):
opportunities: Annotated[list[dict], "List of final opportunities with rationale"]
final_ranking: Annotated[str, "Final ranking from LLM"]
status: Annotated[str, "Current status of discovery"]
tool_logs: Annotated[list[dict], "Detailed logs of all tool calls across all nodes (scanner, filter, deep_dive)"]
tool_logs: Annotated[
list[dict], "Detailed logs of all tool calls across all nodes (scanner, filter, deep_dive)"
]

100
tradingagents/agents/utils/agent_utils.py
View File

@ -1,7 +1,13 @@
from typing import Any, Callable, Dict
from langchain_core.messages import HumanMessage, RemoveMessage
# Import all tools from the new registry-based system
from tradingagents.tools.generator import ALL_TOOLS
from tradingagents.agents.utils.llm_utils import (
create_and_invoke_chain,
parse_llm_response,
)
from tradingagents.agents.utils.prompt_templates import format_analyst_prompt
from tradingagents.tools.generator import ALL_TOOLS, get_agent_tools
# Re-export tools for backward compatibility
get_stock_data = ALL_TOOLS["get_stock_data"]
@ -20,6 +26,7 @@ get_insider_transactions = ALL_TOOLS["get_insider_transactions"]
# Legacy alias for backward compatibility
validate_ticker_tool = validate_ticker
def create_msg_delete():
def delete_messages(state):
"""Clear messages and add placeholder for Anthropic compatibility"""
@ -36,4 +43,93 @@ def create_msg_delete():
return delete_messages
def format_memory_context(memory: Any, state: Dict[str, Any], n_matches: int = 2) -> str:
"""Fetch and format past memories into a prompt section.
Returns the formatted memory string, or "" if no memories available.
Identical logic previously duplicated across 5 agent files.
"""
reports = (
state["market_report"],
state["sentiment_report"],
state["news_report"],
state["fundamentals_report"],
)
curr_situation = "\n\n".join(reports)
if not memory:
return ""
past_memories = memory.get_memories(curr_situation, n_matches=n_matches)
if not past_memories:
return ""
past_memory_str = "### Past Lessons Applied\\n**Reflections from Similar Situations:**\\n"
for i, rec in enumerate(past_memories, 1):
past_memory_str += rec["recommendation"] + "\\n\\n"
past_memory_str += "\\n\\n**How I'm Using These Lessons:**\\n"
past_memory_str += "- [Specific adjustment based on past mistake/success]\\n"
past_memory_str += "- [Impact on current conviction level]\\n"
return past_memory_str
def update_risk_debate_state(
debate_state: Dict[str, Any], argument: str, role: str
) -> Dict[str, Any]:
"""Build updated risk debate state after a debator speaks.
Args:
debate_state: Current risk_debate_state dict.
argument: The formatted argument string (e.g. "Safe Analyst: ...").
role: One of "Safe", "Risky", "Neutral".
"""
role_key = role.lower() # "safe", "risky", "neutral"
new_state = {
"history": debate_state.get("history", "") + "\n" + argument,
"risky_history": debate_state.get("risky_history", ""),
"safe_history": debate_state.get("safe_history", ""),
"neutral_history": debate_state.get("neutral_history", ""),
"latest_speaker": role,
"current_risky_response": debate_state.get("current_risky_response", ""),
"current_safe_response": debate_state.get("current_safe_response", ""),
"current_neutral_response": debate_state.get("current_neutral_response", ""),
"count": debate_state["count"] + 1,
}
# Append to the speaker's own history and set their current response
new_state[f"{role_key}_history"] = debate_state.get(f"{role_key}_history", "") + "\n" + argument
new_state[f"current_{role_key}_response"] = argument
return new_state
def create_analyst_node(
llm: Any,
tool_group: str,
output_key: str,
prompt_builder: Callable[[str, str], str],
) -> Callable:
"""Factory for analyst graph nodes.
Args:
llm: The LLM to use.
tool_group: Tool group name for ``get_agent_tools`` (e.g. "fundamentals").
output_key: State key for the report (e.g. "fundamentals_report").
prompt_builder: ``(ticker, current_date) -> system_message`` callable.
"""
def analyst_node(state: Dict[str, Any]) -> Dict[str, Any]:
ticker = state["company_of_interest"]
current_date = state["trade_date"]
tools = get_agent_tools(tool_group)
system_message = prompt_builder(ticker, current_date)
tool_names_str = ", ".join(tool.name for tool in tools)
full_message = format_analyst_prompt(system_message, current_date, ticker, tool_names_str)
result = create_and_invoke_chain(llm, tools, full_message, state["messages"])
report = ""
if len(result.tool_calls) == 0:
report = parse_llm_response(result.content)
return {"messages": [result], output_key: report}
return analyst_node

540
tradingagents/agents/utils/historical_memory_builder.py
View File

@ -9,15 +9,16 @@ This module creates agent memories from historical stock data by:
5. Storing memories in ChromaDB for future retrieval
"""
import os
import re
import json
import yfinance as yf
import pandas as pd
from datetime import datetime, timedelta
from typing import List, Dict, Tuple, Optional, Any
from tradingagents.tools.executor import execute_tool
from typing import Any, Dict, List, Optional, Tuple
from tradingagents.agents.utils.memory import FinancialSituationMemory
from tradingagents.dataflows.y_finance import get_ticker_history
from tradingagents.tools.executor import execute_tool
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
class HistoricalMemoryBuilder:
@ -35,7 +36,7 @@ class HistoricalMemoryBuilder:
"bear": 0,
"trader": 0,
"invest_judge": 0,
"risk_manager": 0
"risk_manager": 0,
}
def get_tickers_from_alpha_vantage(self, limit: int = 20) -> List[str]:
@ -48,7 +49,7 @@ class HistoricalMemoryBuilder:
Returns:
List of ticker symbols from top gainers and losers
"""
print(f"\n🔍 Fetching top movers from Alpha Vantage...")
logger.info("🔍 Fetching top movers from Alpha Vantage...")
try:
# Use execute_tool to call the alpha vantage function
@ -57,13 +58,13 @@ class HistoricalMemoryBuilder:
# Parse the markdown table response to extract tickers
tickers = set()
lines = response.split('\n')
lines = response.split("\n")
for line in lines:
# Look for table rows with ticker data
if '|' in line and not line.strip().startswith('|---'):
parts = [p.strip() for p in line.split('|')]
if "|" in line and not line.strip().startswith("|---"):
parts = [p.strip() for p in line.split("|")]
# Table format: | Ticker | Price | Change % | Volume |
if len(parts) >= 2 and parts[1] and parts[1] not in ['Ticker', '']:
if len(parts) >= 2 and parts[1] and parts[1] not in ["Ticker", ""]:
ticker = parts[1].strip()
# Filter out warrants, units, and problematic tickers
@ -71,14 +72,16 @@ class HistoricalMemoryBuilder:
tickers.add(ticker)
ticker_list = sorted(list(tickers))
print(f" ✅ Found {len(ticker_list)} unique tickers from Alpha Vantage")
print(f" Tickers: {', '.join(ticker_list[:10])}{'...' if len(ticker_list) > 10 else ''}")
logger.info(f"✅ Found {len(ticker_list)} unique tickers from Alpha Vantage")
logger.debug(
f"Tickers: {', '.join(ticker_list[:10])}{'...' if len(ticker_list) > 10 else ''}"
)
return ticker_list
except Exception as e:
print(f" ⚠️ Error fetching from Alpha Vantage: {e}")
print(f" Falling back to empty list")
logger.warning(f"⚠️ Error fetching from Alpha Vantage: {e}")
logger.warning("Falling back to empty list")
return []
def _is_valid_ticker(self, ticker: str) -> bool:
@ -102,23 +105,23 @@ class HistoricalMemoryBuilder:
return False
# Must be uppercase letters and numbers only
if not re.match(r'^[A-Z]{1,5}$', ticker):
if not re.match(r"^[A-Z]{1,5}$", ticker):
return False
# Filter out warrants (W, WW, WS suffix)
if ticker.endswith('W') or ticker.endswith('WW') or ticker.endswith('WS'):
if ticker.endswith("W") or ticker.endswith("WW") or ticker.endswith("WS"):
return False
# Filter out units
if ticker.endswith('U'):
if ticker.endswith("U"):
return False
# Filter out rights
if ticker.endswith('R') and len(ticker) > 1:
if ticker.endswith("R") and len(ticker) > 1:
return False
# Filter out other suffixes that indicate derivatives
if ticker.endswith('Z'): # Often used for special situations
if ticker.endswith("Z"): # Often used for special situations
return False
return True
@ -129,7 +132,7 @@ class HistoricalMemoryBuilder:
start_date: str,
end_date: str,
min_move_pct: float = 15.0,
window_days: int = 5
window_days: int = 5,
) -> List[Dict[str, Any]]:
"""
Find stocks that had significant moves (>15% in 5 days).
@ -153,67 +156,68 @@ class HistoricalMemoryBuilder:
"""
high_movers = []
print(f"\n🔍 Scanning for high movers ({min_move_pct}%+ in {window_days} days)")
print(f" Period: {start_date} to {end_date}")
print(f" Tickers: {len(tickers)}\n")
logger.info(f"🔍 Scanning for high movers ({min_move_pct}%+ in {window_days} days)")
logger.info(f"Period: {start_date} to {end_date}")
logger.info(f"Tickers: {len(tickers)}")
for ticker in tickers:
try:
print(f" Scanning {ticker}...", end=" ")
logger.info(f"Scanning {ticker}...")
# Download historical data using yfinance
stock = yf.Ticker(ticker)
df = stock.history(start=start_date, end=end_date)
df = get_ticker_history(ticker, start=start_date, end=end_date)
if df.empty:
print("No data")
logger.debug(f"{ticker}: No data")
continue
# Calculate rolling returns over window_days
df['rolling_return'] = df['Close'].pct_change(periods=window_days) * 100
df["rolling_return"] = df["Close"].pct_change(periods=window_days) * 100
# Find periods with moves >= min_move_pct
significant_moves = df[abs(df['rolling_return']) >= min_move_pct]
significant_moves = df[abs(df["rolling_return"]) >= min_move_pct]
if not significant_moves.empty:
for idx, row in significant_moves.iterrows():
# Get the start date (window_days before this date)
move_end_date = idx.strftime('%Y-%m-%d')
move_start_date = (idx - timedelta(days=window_days)).strftime('%Y-%m-%d')
move_end_date = idx.strftime("%Y-%m-%d")
move_start_date = (idx - timedelta(days=window_days)).strftime("%Y-%m-%d")
# Get prices
try:
start_price = df.loc[df.index >= move_start_date, 'Close'].iloc[0]
end_price = row['Close']
move_pct = row['rolling_return']
start_price = df.loc[df.index >= move_start_date, "Close"].iloc[0]
end_price = row["Close"]
move_pct = row["rolling_return"]
high_movers.append({
'ticker': ticker,
'move_start_date': move_start_date,
'move_end_date': move_end_date,
'move_pct': move_pct,
'direction': 'up' if move_pct > 0 else 'down',
'start_price': start_price,
'end_price': end_price
})
high_movers.append(
{
"ticker": ticker,
"move_start_date": move_start_date,
"move_end_date": move_end_date,
"move_pct": move_pct,
"direction": "up" if move_pct > 0 else "down",
"start_price": start_price,
"end_price": end_price,
}
)
except (IndexError, KeyError):
continue
print(f"Found {len([m for m in high_movers if m['ticker'] == ticker])} moves")
logger.info(
f"Found {len([m for m in high_movers if m['ticker'] == ticker])} moves for {ticker}"
)
else:
print("No significant moves")
logger.debug(f"{ticker}: No significant moves")
except Exception as e:
print(f"Error: {e}")
logger.error(f"Error scanning {ticker}: {e}")
continue
print(f"\n✅ Total high movers found: {len(high_movers)}\n")
logger.info(f"✅ Total high movers found: {len(high_movers)}")
return high_movers
def run_retrospective_analysis(
self,
ticker: str,
analysis_date: str
self, ticker: str, analysis_date: str
) -> Optional[Dict[str, Any]]:
"""
Run the trading graph analysis for a ticker at a specific historical date.
@ -238,47 +242,48 @@ class HistoricalMemoryBuilder:
# Import here to avoid circular imports
from tradingagents.graph.trading_graph import TradingAgentsGraph
print(f" Running analysis for {ticker} on {analysis_date}...")
logger.info(f"Running analysis for {ticker} on {analysis_date}...")
# Create trading graph instance
# Use fewer analysts to reduce token usage
graph = TradingAgentsGraph(
selected_analysts=["market", "fundamentals"], # Skip social/news to reduce tokens
config=self.config,
debug=False
debug=False,
)
# Run the analysis (returns tuple: final_state, processed_signal)
final_state, _ = graph.propagate(ticker, analysis_date)
# Extract reports and decisions (with type safety)
def safe_get_str(d, key, default=''):
def safe_get_str(d, key, default=""):
"""Safely extract string from state, handling lists or other types."""
value = d.get(key, default)
if isinstance(value, list):
# If it's a list, try to extract text from messages
return ' '.join(str(item) for item in value)
return " ".join(str(item) for item in value)
return str(value) if value else default
# Extract reports and decisions
analysis_data = {
'market_report': safe_get_str(final_state, 'market_report'),
'sentiment_report': safe_get_str(final_state, 'sentiment_report'),
'news_report': safe_get_str(final_state, 'news_report'),
'fundamentals_report': safe_get_str(final_state, 'fundamentals_report'),
'investment_plan': safe_get_str(final_state, 'investment_plan'),
'final_decision': safe_get_str(final_state, 'final_trade_decision'),
"market_report": safe_get_str(final_state, "market_report"),
"sentiment_report": safe_get_str(final_state, "sentiment_report"),
"news_report": safe_get_str(final_state, "news_report"),
"fundamentals_report": safe_get_str(final_state, "fundamentals_report"),
"investment_plan": safe_get_str(final_state, "investment_plan"),
"final_decision": safe_get_str(final_state, "final_trade_decision"),
}
# Extract structured signals from reports
analysis_data['structured_signals'] = self.extract_structured_signals(analysis_data)
analysis_data["structured_signals"] = self.extract_structured_signals(analysis_data)
return analysis_data
except Exception as e:
print(f" Error running analysis: {e}")
logger.error(f"Error running analysis: {e}")
import traceback
print(f" Traceback: {traceback.format_exc()}")
logger.debug(f"Traceback: {traceback.format_exc()}")
return None
def extract_structured_signals(self, reports: Dict[str, str]) -> Dict[str, Any]:
@ -300,63 +305,101 @@ class HistoricalMemoryBuilder:
"""
signals = {}
market_report = reports.get('market_report', '')
sentiment_report = reports.get('sentiment_report', '')
news_report = reports.get('news_report', '')
fundamentals_report = reports.get('fundamentals_report', '')
market_report = reports.get("market_report", "")
sentiment_report = reports.get("sentiment_report", "")
news_report = reports.get("news_report", "")
fundamentals_report = reports.get("fundamentals_report", "")
# Extract volume signals
signals['unusual_volume'] = bool(
re.search(r'(unusual volume|volume spike|high volume|increased volume)', market_report, re.IGNORECASE)
signals["unusual_volume"] = bool(
re.search(
r"(unusual volume|volume spike|high volume|increased volume)",
market_report,
re.IGNORECASE,
)
)
# Extract sentiment
if re.search(r'(bullish|positive outlook|strong buy|buy)', sentiment_report + news_report, re.IGNORECASE):
signals['analyst_sentiment'] = 'bullish'
elif re.search(r'(bearish|negative outlook|strong sell|sell)', sentiment_report + news_report, re.IGNORECASE):
signals['analyst_sentiment'] = 'bearish'
if re.search(
r"(bullish|positive outlook|strong buy|buy)",
sentiment_report + news_report,
re.IGNORECASE,
):
signals["analyst_sentiment"] = "bullish"
elif re.search(
r"(bearish|negative outlook|strong sell|sell)",
sentiment_report + news_report,
re.IGNORECASE,
):
signals["analyst_sentiment"] = "bearish"
else:
signals['analyst_sentiment'] = 'neutral'
signals["analyst_sentiment"] = "neutral"
# Extract news sentiment
if re.search(r'(positive|good news|beat expectations|upgrade|growth)', news_report, re.IGNORECASE):
signals['news_sentiment'] = 'positive'
elif re.search(r'(negative|bad news|miss expectations|downgrade|decline)', news_report, re.IGNORECASE):
signals['news_sentiment'] = 'negative'
if re.search(
r"(positive|good news|beat expectations|upgrade|growth)", news_report, re.IGNORECASE
):
signals["news_sentiment"] = "positive"
elif re.search(
r"(negative|bad news|miss expectations|downgrade|decline)", news_report, re.IGNORECASE
):
signals["news_sentiment"] = "negative"
else:
signals['news_sentiment'] = 'neutral'
signals["news_sentiment"] = "neutral"
# Extract short interest
if re.search(r'(high short interest|heavily shorted|short squeeze)', market_report + news_report, re.IGNORECASE):
signals['short_interest'] = 'high'
elif re.search(r'(low short interest|minimal short)', market_report, re.IGNORECASE):
signals['short_interest'] = 'low'
if re.search(
r"(high short interest|heavily shorted|short squeeze)",
market_report + news_report,
re.IGNORECASE,
):
signals["short_interest"] = "high"
elif re.search(r"(low short interest|minimal short)", market_report, re.IGNORECASE):
signals["short_interest"] = "low"
else:
signals['short_interest'] = 'medium'
signals["short_interest"] = "medium"
# Extract insider activity
if re.search(r'(insider buying|executive purchased|insider purchases)', news_report + fundamentals_report, re.IGNORECASE):
signals['insider_activity'] = 'buying'
elif re.search(r'(insider selling|executive sold|insider sales)', news_report + fundamentals_report, re.IGNORECASE):
signals['insider_activity'] = 'selling'
if re.search(
r"(insider buying|executive purchased|insider purchases)",
news_report + fundamentals_report,
re.IGNORECASE,
):
signals["insider_activity"] = "buying"
elif re.search(
r"(insider selling|executive sold|insider sales)",
news_report + fundamentals_report,
re.IGNORECASE,
):
signals["insider_activity"] = "selling"
else:
signals['insider_activity'] = 'none'
signals["insider_activity"] = "none"
# Extract price trend
if re.search(r'(uptrend|bullish trend|rising|moving higher|higher highs)', market_report, re.IGNORECASE):
signals['price_trend'] = 'uptrend'
elif re.search(r'(downtrend|bearish trend|falling|moving lower|lower lows)', market_report, re.IGNORECASE):
signals['price_trend'] = 'downtrend'
if re.search(
r"(uptrend|bullish trend|rising|moving higher|higher highs)",
market_report,
re.IGNORECASE,
):
signals["price_trend"] = "uptrend"
elif re.search(
r"(downtrend|bearish trend|falling|moving lower|lower lows)",
market_report,
re.IGNORECASE,
):
signals["price_trend"] = "downtrend"
else:
signals['price_trend'] = 'sideways'
signals["price_trend"] = "sideways"
# Extract volatility
if re.search(r'(high volatility|volatile|wild swings|sharp movements)', market_report, re.IGNORECASE):
signals['volatility'] = 'high'
elif re.search(r'(low volatility|stable|steady)', market_report, re.IGNORECASE):
signals['volatility'] = 'low'
if re.search(
r"(high volatility|volatile|wild swings|sharp movements)", market_report, re.IGNORECASE
):
signals["volatility"] = "high"
elif re.search(r"(low volatility|stable|steady)", market_report, re.IGNORECASE):
signals["volatility"] = "low"
else:
signals['volatility'] = 'medium'
signals["volatility"] = "medium"
return signals
@ -368,7 +411,7 @@ class HistoricalMemoryBuilder:
min_move_pct: float = 15.0,
analysis_windows: List[int] = [7, 30],
max_samples: int = 50,
sample_strategy: str = "diverse"
sample_strategy: str = "diverse",
) -> Dict[str, FinancialSituationMemory]:
"""
Build memories by finding high movers and running retrospective analyses.
@ -391,25 +434,28 @@ class HistoricalMemoryBuilder:
Returns:
Dictionary of populated memory instances for each agent type
"""
print("=" * 70)
print("🏗️ BUILDING MEMORIES FROM HIGH MOVERS")
print("=" * 70)
logger.info("=" * 70)
logger.info("🏗️ BUILDING MEMORIES FROM HIGH MOVERS")
logger.info("=" * 70)
# Step 1: Find high movers
high_movers = self.find_high_movers(tickers, start_date, end_date, min_move_pct)
if not high_movers:
print("⚠️ No high movers found. Try a different date range or lower threshold.")
logger.warning(
"⚠️ No high movers found. Try a different date range or lower threshold."
)
return {}
# Step 1.5: Sample/filter high movers based on strategy
sampled_movers = self._sample_high_movers(high_movers, max_samples, sample_strategy)
print(f"\n📊 Sampling Strategy: {sample_strategy}")
print(f" Total high movers found: {len(high_movers)}")
print(f" Samples to analyze: {len(sampled_movers)}")
print(f" Estimated runtime: ~{len(sampled_movers) * len(analysis_windows) * 2} minutes")
print()
logger.info(f"📊 Sampling Strategy: {sample_strategy}")
logger.info(f"Total high movers found: {len(high_movers)}")
logger.info(f"Samples to analyze: {len(sampled_movers)}")
logger.info(
f"Estimated runtime: ~{len(sampled_movers) * len(analysis_windows) * 2} minutes"
)
# Initialize memory stores
agent_memories = {
@ -417,35 +463,35 @@ class HistoricalMemoryBuilder:
"bear": FinancialSituationMemory("bear_memory", self.config),
"trader": FinancialSituationMemory("trader_memory", self.config),
"invest_judge": FinancialSituationMemory("invest_judge_memory", self.config),
"risk_manager": FinancialSituationMemory("risk_manager_memory", self.config)
"risk_manager": FinancialSituationMemory("risk_manager_memory", self.config),
}
# Step 2: For each high mover, run retrospective analyses
print("\n📊 Running retrospective analyses...\n")
logger.info("📊 Running retrospective analyses...")
for idx, mover in enumerate(sampled_movers, 1):
ticker = mover['ticker']
move_pct = mover['move_pct']
direction = mover['direction']
move_start_date = mover['move_start_date']
ticker = mover["ticker"]
move_pct = mover["move_pct"]
direction = mover["direction"]
move_start_date = mover["move_start_date"]
print(f" [{idx}/{len(sampled_movers)}] {ticker}: {move_pct:+.1f}% {direction}")
logger.info(f"[{idx}/{len(sampled_movers)}] {ticker}: {move_pct:+.1f}% {direction}")
# Run analyses at different time windows before the move
for days_before in analysis_windows:
# Calculate analysis date
try:
analysis_date = (
datetime.strptime(move_start_date, '%Y-%m-%d') - timedelta(days=days_before)
).strftime('%Y-%m-%d')
datetime.strptime(move_start_date, "%Y-%m-%d") - timedelta(days=days_before)
).strftime("%Y-%m-%d")
print(f" Analyzing T-{days_before} days ({analysis_date})...")
logger.info(f"Analyzing T-{days_before} days ({analysis_date})...")
# Run trading graph analysis
analysis = self.run_retrospective_analysis(ticker, analysis_date)
if not analysis:
print(f" ⚠️ Analysis failed, skipping...")
logger.warning("⚠️ Analysis failed, skipping...")
continue
# Create combined situation text
@ -469,8 +515,7 @@ class HistoricalMemoryBuilder:
# Extract agent recommendation from investment plan and final decision
agent_recommendation = self._extract_recommendation(
analysis.get('investment_plan', ''),
analysis.get('final_decision', '')
analysis.get("investment_plan", ""), analysis.get("final_decision", "")
)
# Determine if agent was correct
@ -478,18 +523,22 @@ class HistoricalMemoryBuilder:
# Create metadata
metadata = {
'ticker': ticker,
'analysis_date': analysis_date,
'days_before_move': days_before,
'move_pct': abs(move_pct),
'move_direction': direction,
'agent_recommendation': agent_recommendation,
'was_correct': was_correct,
'structured_signals': analysis['structured_signals']
"ticker": ticker,
"analysis_date": analysis_date,
"days_before_move": days_before,
"move_pct": abs(move_pct),
"move_direction": direction,
"agent_recommendation": agent_recommendation,
"was_correct": was_correct,
"structured_signals": analysis["structured_signals"],
}
# Create recommendation text
lesson_text = f"This signal combination is reliable for predicting {direction} moves." if was_correct else "This signal combination can be misleading. Need to consider other factors."
lesson_text = (
f"This signal combination is reliable for predicting {direction} moves."
if was_correct
else "This signal combination can be misleading. Need to consider other factors."
)
recommendation_text = f"""
Agent Decision: {agent_recommendation}
@ -507,38 +556,40 @@ Lesson: {lesson_text}
# Store in all agent memories
for agent_type, memory in agent_memories.items():
memory.add_situations_with_metadata([
(situation_text, recommendation_text, metadata)
])
memory.add_situations_with_metadata(
[(situation_text, recommendation_text, metadata)]
)
self.memories_created[agent_type] = self.memories_created.get(agent_type, 0) + 1
print(f" ✅ Memory created: {agent_recommendation} -> {direction} ({was_correct})")
logger.info(
f"✅ Memory created: {agent_recommendation} -> {direction} ({was_correct})"
)
except Exception as e:
print(f" ⚠️ Error: {e}")
logger.warning(f"⚠️ Error: {e}")
continue
# Print summary
print("\n" + "=" * 70)
print("📊 MEMORY CREATION SUMMARY")
print("=" * 70)
print(f" High movers analyzed: {len(sampled_movers)}")
print(f" Analysis windows: {analysis_windows} days before move")
# Log summary
logger.info("=" * 70)
logger.info("📊 MEMORY CREATION SUMMARY")
logger.info("=" * 70)
logger.info(f" High movers analyzed: {len(sampled_movers)}")
logger.info(f" Analysis windows: {analysis_windows} days before move")
for agent_type, count in self.memories_created.items():
print(f" {agent_type.ljust(15)}: {count} memories")
logger.info(f" {agent_type.ljust(15)}: {count} memories")
# Print statistics
print("\n📈 MEMORY BANK STATISTICS")
print("=" * 70)
# Log statistics
logger.info("\n📈 MEMORY BANK STATISTICS")
logger.info("=" * 70)
for agent_type, memory in agent_memories.items():
stats = memory.get_statistics()
print(f"\n {agent_type.upper()}:")
print(f" Total memories: {stats['total_memories']}")
print(f" Accuracy rate: {stats['accuracy_rate']:.1f}%")
print(f" Avg move: {stats['avg_move_pct']:.1f}%")
logger.info(f"\n {agent_type.upper()}:")
logger.info(f" Total memories: {stats['total_memories']}")
logger.info(f" Accuracy rate: {stats['accuracy_rate']:.1f}%")
logger.info(f" Avg move: {stats['avg_move_pct']:.1f}%")
print("=" * 70 + "\n")
logger.info("=" * 70)
return agent_memories
@ -551,11 +602,13 @@ Lesson: {lesson_text}
combined_text = (investment_plan + " " + final_decision).lower()
# Check for clear buy/sell/hold signals
if re.search(r'\b(strong buy|buy|long position|bullish|recommend buying)\b', combined_text):
if re.search(r"\b(strong buy|buy|long position|bullish|recommend buying)\b", combined_text):
return "buy"
elif re.search(r'\b(strong sell|sell|short position|bearish|recommend selling)\b', combined_text):
elif re.search(
r"\b(strong sell|sell|short position|bearish|recommend selling)\b", combined_text
):
return "sell"
elif re.search(r'\b(hold|neutral|wait|avoid)\b', combined_text):
elif re.search(r"\b(hold|neutral|wait|avoid)\b", combined_text):
return "hold"
else:
return "unclear"
@ -589,10 +642,7 @@ Lesson: {lesson_text}
return "\n".join(lines)
def _sample_high_movers(
self,
high_movers: List[Dict[str, Any]],
max_samples: int,
strategy: str
self, high_movers: List[Dict[str, Any]], max_samples: int, strategy: str
) -> List[Dict[str, Any]]:
"""
Sample high movers based on strategy to reduce analysis time.
@ -612,12 +662,12 @@ Lesson: {lesson_text}
if strategy == "diverse":
# Get balanced mix of up/down moves across different magnitudes
up_moves = [m for m in high_movers if m['direction'] == 'up']
down_moves = [m for m in high_movers if m['direction'] == 'down']
up_moves = [m for m in high_movers if m["direction"] == "up"]
down_moves = [m for m in high_movers if m["direction"] == "down"]
# Sort each by magnitude
up_moves.sort(key=lambda x: abs(x['move_pct']), reverse=True)
down_moves.sort(key=lambda x: abs(x['move_pct']), reverse=True)
up_moves.sort(key=lambda x: abs(x["move_pct"]), reverse=True)
down_moves.sort(key=lambda x: abs(x["move_pct"]), reverse=True)
# Take half from each direction (or proportional if imbalanced)
up_count = min(len(up_moves), max_samples // 2)
@ -637,14 +687,14 @@ Lesson: {lesson_text}
# Divide into 3 buckets by magnitude
bucket_size = len(moves) // 3
large = moves[:bucket_size]
medium = moves[bucket_size:bucket_size*2]
small = moves[bucket_size*2:]
medium = moves[bucket_size : bucket_size * 2]
small = moves[bucket_size * 2 :]
# Sample proportionally from each bucket
samples = []
samples.extend(large[:count // 3])
samples.extend(medium[:count // 3])
samples.extend(small[:count - (2 * (count // 3))])
samples.extend(large[: count // 3])
samples.extend(medium[: count // 3])
samples.extend(small[: count - (2 * (count // 3))])
return samples
sampled = []
@ -655,12 +705,12 @@ Lesson: {lesson_text}
elif strategy == "largest":
# Take the largest absolute moves
sorted_movers = sorted(high_movers, key=lambda x: abs(x['move_pct']), reverse=True)
sorted_movers = sorted(high_movers, key=lambda x: abs(x["move_pct"]), reverse=True)
return sorted_movers[:max_samples]
elif strategy == "recent":
# Take the most recent moves
sorted_movers = sorted(high_movers, key=lambda x: x['move_end_date'], reverse=True)
sorted_movers = sorted(high_movers, key=lambda x: x["move_end_date"], reverse=True)
return sorted_movers[:max_samples]
elif strategy == "random":
@ -687,7 +737,9 @@ Lesson: {lesson_text}
# Get technical/price data (what Market Analyst sees)
stock_data = execute_tool("get_stock_data", symbol=ticker, start_date=date)
indicators = execute_tool("get_indicators", symbol=ticker, curr_date=date)
data["market_report"] = f"Stock Data:\n{stock_data}\n\nTechnical Indicators:\n{indicators}"
data["market_report"] = (
f"Stock Data:\n{stock_data}\n\nTechnical Indicators:\n{indicators}"
)
except Exception as e:
data["market_report"] = f"Error fetching market data: {e}"
@ -700,7 +752,9 @@ Lesson: {lesson_text}
try:
# Get sentiment (what Social Analyst sees)
sentiment = execute_tool("get_reddit_discussions", symbol=ticker, from_date=date, to_date=date)
sentiment = execute_tool(
"get_reddit_discussions", symbol=ticker, from_date=date, to_date=date
)
data["sentiment_report"] = sentiment
except Exception as e:
data["sentiment_report"] = f"Error fetching sentiment: {e}"
@ -727,14 +781,19 @@ Lesson: {lesson_text}
"""
try:
# Get stock prices for both dates
start_data = execute_tool("get_stock_data", symbol=ticker, start_date=start_date, end_date=start_date)
end_data = execute_tool("get_stock_data", symbol=ticker, start_date=end_date, end_date=end_date)
start_data = execute_tool(
"get_stock_data", symbol=ticker, start_date=start_date, end_date=start_date
)
end_data = execute_tool(
"get_stock_data", symbol=ticker, start_date=end_date, end_date=end_date
)
# Parse prices (this is simplified - you'd need to parse the actual response)
# Assuming response has close price - adjust based on actual API response
import re
start_match = re.search(r'Close[:\s]+\$?([\d.]+)', str(start_data))
end_match = re.search(r'Close[:\s]+\$?([\d.]+)', str(end_data))
start_match = re.search(r"Close[:\s]+\$?([\d.]+)", str(start_data))
end_match = re.search(r"Close[:\s]+\$?([\d.]+)", str(end_data))
if start_match and end_match:
start_price = float(start_match.group(1))
@ -743,10 +802,12 @@ Lesson: {lesson_text}
return None
except Exception as e:
print(f"Error calculating returns: {e}")
logger.error(f"Error calculating returns: {e}")
return None
def _create_bull_researcher_memory(self, situation: str, returns: float, ticker: str, date: str) -> str:
def _create_bull_researcher_memory(
self, situation: str, returns: float, ticker: str, date: str
) -> str:
"""Create memory for bull researcher based on outcome.
Returns lesson learned from bullish perspective.
@ -780,7 +841,9 @@ Stock moved {returns:.2f}%, indicating mixed signals.
Lesson: This pattern of indicators doesn't provide strong directional conviction. Look for clearer signals before making strong bullish arguments.
"""
def _create_bear_researcher_memory(self, situation: str, returns: float, ticker: str, date: str) -> str:
def _create_bear_researcher_memory(
self, situation: str, returns: float, ticker: str, date: str
) -> str:
"""Create memory for bear researcher based on outcome."""
if returns < -5:
return f"""SUCCESSFUL BEARISH ANALYSIS for {ticker} on {date}:
@ -842,7 +905,9 @@ Trading lesson:
Recommendation: Pattern recognition suggests {action} in similar future scenarios.
"""
def _create_invest_judge_memory(self, situation: str, returns: float, ticker: str, date: str) -> str:
def _create_invest_judge_memory(
self, situation: str, returns: float, ticker: str, date: str
) -> str:
"""Create memory for investment judge/research manager."""
if returns > 5:
verdict = "Strong BUY recommendation was warranted"
@ -868,7 +933,9 @@ When synthesizing bull/bear arguments in similar conditions:
Recommendation for similar situations: {verdict}
"""
def _create_risk_manager_memory(self, situation: str, returns: float, ticker: str, date: str) -> str:
def _create_risk_manager_memory(
self, situation: str, returns: float, ticker: str, date: str
) -> str:
"""Create memory for risk manager."""
volatility = "HIGH" if abs(returns) > 10 else "MEDIUM" if abs(returns) > 5 else "LOW"
@ -901,7 +968,7 @@ Recommendation: {risk_assessment}
start_date: str,
end_date: str,
lookforward_days: int = 7,
interval_days: int = 30
interval_days: int = 30,
) -> Dict[str, List[Tuple[str, str]]]:
"""Build historical memories for a stock across a date range.
@ -915,28 +982,22 @@ Recommendation: {risk_assessment}
Returns:
Dictionary mapping agent type to list of (situation, lesson) tuples
"""
memories = {
"bull": [],
"bear": [],
"trader": [],
"invest_judge": [],
"risk_manager": []
}
memories = {"bull": [], "bear": [], "trader": [], "invest_judge": [], "risk_manager": []}
current_date = datetime.strptime(start_date, "%Y-%m-%d")
end_dt = datetime.strptime(end_date, "%Y-%m-%d")
print(f"\n🧠 Building historical memories for {ticker}")
print(f" Period: {start_date} to {end_date}")
print(f" Lookforward: {lookforward_days} days")
print(f" Sampling interval: {interval_days} days\n")
logger.info(f"🧠 Building historical memories for {ticker}")
logger.info(f"Period: {start_date} to {end_date}")
logger.info(f"Lookforward: {lookforward_days} days")
logger.info(f"Sampling interval: {interval_days} days")
sample_count = 0
while current_date <= end_dt:
date_str = current_date.strftime("%Y-%m-%d")
future_date_str = (current_date + timedelta(days=lookforward_days)).strftime("%Y-%m-%d")
print(f" 📊 Sampling {date_str}...", end=" ")
logger.info(f"📊 Sampling {date_str}...")
# Get historical data for this period
data = self._get_stock_data_for_period(ticker, date_str)
@ -946,42 +1007,49 @@ Recommendation: {risk_assessment}
returns = self._calculate_returns(ticker, date_str, future_date_str)
if returns is not None:
print(f"Return: {returns:+.2f}%")
logger.info(f"Return: {returns:+.2f}%")
# Create agent-specific memories
memories["bull"].append((
situation,
self._create_bull_researcher_memory(situation, returns, ticker, date_str)
))
memories["bull"].append(
(
situation,
self._create_bull_researcher_memory(situation, returns, ticker, date_str),
)
)
memories["bear"].append((
situation,
self._create_bear_researcher_memory(situation, returns, ticker, date_str)
))
memories["bear"].append(
(
situation,
self._create_bear_researcher_memory(situation, returns, ticker, date_str),
)
)
memories["trader"].append((
situation,
self._create_trader_memory(situation, returns, ticker, date_str)
))
memories["trader"].append(
(situation, self._create_trader_memory(situation, returns, ticker, date_str))
)
memories["invest_judge"].append((
situation,
self._create_invest_judge_memory(situation, returns, ticker, date_str)
))
memories["invest_judge"].append(
(
situation,
self._create_invest_judge_memory(situation, returns, ticker, date_str),
)
)
memories["risk_manager"].append((
situation,
self._create_risk_manager_memory(situation, returns, ticker, date_str)
))
memories["risk_manager"].append(
(
situation,
self._create_risk_manager_memory(situation, returns, ticker, date_str),
)
)
sample_count += 1
else:
print("⚠️ No data")
logger.warning("⚠️ No data")
# Move to next interval
current_date += timedelta(days=interval_days)
print(f"\n✅ Created {sample_count} memory samples for {ticker}")
logger.info(f"✅ Created {sample_count} memory samples for {ticker}")
for agent_type in memories:
self.memories_created[agent_type] += len(memories[agent_type])
@ -993,7 +1061,7 @@ Recommendation: {risk_assessment}
start_date: str,
end_date: str,
lookforward_days: int = 7,
interval_days: int = 30
interval_days: int = 30,
) -> Dict[str, FinancialSituationMemory]:
"""Build and populate memories for all agent types across multiple stocks.
@ -1013,12 +1081,12 @@ Recommendation: {risk_assessment}
"bear": FinancialSituationMemory("bear_memory", self.config),
"trader": FinancialSituationMemory("trader_memory", self.config),
"invest_judge": FinancialSituationMemory("invest_judge_memory", self.config),
"risk_manager": FinancialSituationMemory("risk_manager_memory", self.config)
"risk_manager": FinancialSituationMemory("risk_manager_memory", self.config),
}
print("=" * 70)
print("🏗️ HISTORICAL MEMORY BUILDER")
print("=" * 70)
logger.info("=" * 70)
logger.info("🏗️ HISTORICAL MEMORY BUILDER")
logger.info("=" * 70)
# Build memories for each ticker
for ticker in tickers:
@ -1027,7 +1095,7 @@ Recommendation: {risk_assessment}
start_date=start_date,
end_date=end_date,
lookforward_days=lookforward_days,
interval_days=interval_days
interval_days=interval_days,
)
# Add memories to each agent's memory store
@ -1036,12 +1104,12 @@ Recommendation: {risk_assessment}
agent_memories[agent_type].add_situations(memory_list)
# Print summary
print("\n" + "=" * 70)
print("📊 MEMORY CREATION SUMMARY")
print("=" * 70)
logger.info("=" * 70)
logger.info("📊 MEMORY CREATION SUMMARY")
logger.info("=" * 70)
for agent_type, count in self.memories_created.items():
print(f" {agent_type.ljust(15)}: {count} memories")
print("=" * 70 + "\n")
logger.info(f"{agent_type.ljust(15)}: {count} memories")
logger.info("=" * 70)
return agent_memories
@ -1060,19 +1128,19 @@ if __name__ == "__main__":
tickers=tickers,
start_date="2024-01-01",
end_date="2024-12-01",
lookforward_days=7, # 1-week returns
interval_days=30 # Sample monthly
lookforward_days=7, # 1-week returns
interval_days=30, # Sample monthly
)
# Test retrieval
test_situation = "Strong earnings beat with positive sentiment and bullish technical indicators in tech sector"
print("\n🔍 Testing memory retrieval...")
print(f"Query: {test_situation}\n")
logger.info("🔍 Testing memory retrieval...")
logger.info(f"Query: {test_situation}")
for agent_type, memory in memories.items():
print(f"\n{agent_type.upper()} MEMORIES:")
logger.info(f"\n{agent_type.upper()} MEMORIES:")
results = memory.get_memories(test_situation, n_matches=2)
for i, result in enumerate(results, 1):
print(f"\n Match {i} (similarity: {result['similarity_score']:.2f}):")
print(f" {result['recommendation'][:200]}...")
logger.info(f"\n Match {i} (similarity: {result['similarity_score']:.2f}):")
logger.info(f" {result['recommendation'][:200]}...")

59
tradingagents/agents/utils/llm_utils.py Normal file
View File

@ -0,0 +1,59 @@
from typing import Any, Dict, List, Union
from langchain_core.messages import BaseMessage, HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
def parse_llm_response(response_content: Union[str, List[Union[str, Dict[str, Any]]]]) -> str:
"""
Parse content from an LLM response, handling both string and list formats.
This function standardizes extraction of text from various LLM provider response formats
(e.g., standard strings vs Anthropic's block format).
Args:
response_content: The raw content field from an LLM response object.
Returns:
The extracted text content as a string.
"""
if isinstance(response_content, list):
return "\n".join(
block.get("text", str(block)) if isinstance(block, dict) else str(block)
for block in response_content
)
return str(response_content) if response_content is not None else ""
def create_and_invoke_chain(
llm: Any, tools: List[Any], system_message: str, messages: List[BaseMessage]
) -> Any:
"""
Create and invoke a standard agent chain with tools.
Args:
llm: The Language Model to use
tools: List of tools to bind to the LLM
system_message: The system prompt content
messages: The chat history messages
Returns:
The LLM response (AIMessage)
"""
prompt = ChatPromptTemplate.from_messages(
[
("system", system_message),
MessagesPlaceholder(variable_name="messages"),
]
)
# Ensure at least one non-system message for Gemini compatibility
# Gemini API requires at least one HumanMessage in addition to SystemMessage
if not messages:
messages = [
HumanMessage(content="Please provide your analysis based on the context above.")
]
chain = prompt | llm.bind_tools(tools)
return chain.invoke({"messages": messages})

124
tradingagents/agents/utils/memory.py
View File

@ -1,8 +1,12 @@
import os
from typing import Any, Dict, List, Optional, Tuple
import chromadb
from chromadb.config import Settings
from openai import OpenAI
from typing import List, Dict, Any, Optional, Tuple
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
class FinancialSituationMemory:
@ -17,7 +21,7 @@ class FinancialSituationMemory:
self.embedding_backend = "https://api.openai.com/v1"
self.embedding = "text-embedding-3-small"
self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
self.client = OpenAI(api_key=config.validate_key("openai_api_key", "OpenAI"))
# Use persistent storage in project directory
persist_directory = os.path.join(config.get("project_dir", "."), "memory_db")
@ -28,43 +32,52 @@ class FinancialSituationMemory:
# Get or create collection
try:
self.situation_collection = self.chroma_client.get_collection(name=name)
except:
except Exception:
self.situation_collection = self.chroma_client.create_collection(name=name)
def get_embedding(self, text):
"""Get OpenAI embedding for a text"""
response = self.client.embeddings.create(
model=self.embedding, input=text
)
response = self.client.embeddings.create(model=self.embedding, input=text)
return response.data[0].embedding
def add_situations(self, situations_and_advice):
"""Add financial situations and their corresponding advice. Parameter is a list of tuples (situation, rec)"""
def _batch_add(
self,
documents: List[str],
metadatas: List[Dict[str, Any]],
embeddings: List[List[float]],
ids: List[str] = None,
):
"""Internal helper to batch add documents to ChromaDB."""
if not documents:
return
situations = []
advice = []
ids = []
embeddings = []
offset = self.situation_collection.count()
for i, (situation, recommendation) in enumerate(situations_and_advice):
situations.append(situation)
advice.append(recommendation)
ids.append(str(offset + i))
embeddings.append(self.get_embedding(situation))
if ids is None:
offset = self.situation_collection.count()
ids = [str(offset + i) for i in range(len(documents))]
self.situation_collection.add(
documents=situations,
metadatas=[{"recommendation": rec} for rec in advice],
documents=documents,
metadatas=metadatas,
embeddings=embeddings,
ids=ids,
)
def add_situations(self, situations_and_advice):
"""Add financial situations and their corresponding advice. Parameter is a list of tuples (situation, rec)"""
situations = []
metadatas = []
embeddings = []
for situation, recommendation in situations_and_advice:
situations.append(situation)
metadatas.append({"recommendation": recommendation})
embeddings.append(self.get_embedding(situation))
self._batch_add(situations, metadatas, embeddings)
def add_situations_with_metadata(
self,
situations_and_outcomes: List[Tuple[str, str, Dict[str, Any]]]
self, situations_and_outcomes: List[Tuple[str, str, Dict[str, Any]]]
):
"""
Add financial situations with enhanced metadata for learning system.
@ -88,15 +101,11 @@ class FinancialSituationMemory:
- etc.
"""
situations = []
ids = []
embeddings = []
metadatas = []
embeddings = []
offset = self.situation_collection.count()
for i, (situation, recommendation, metadata) in enumerate(situations_and_outcomes):
for situation, recommendation, metadata in situations_and_outcomes:
situations.append(situation)
ids.append(str(offset + i))
embeddings.append(self.get_embedding(situation))
# Merge recommendation with metadata
@ -107,12 +116,7 @@ class FinancialSituationMemory:
full_metadata = self._sanitize_metadata(full_metadata)
metadatas.append(full_metadata)
self.situation_collection.add(
documents=situations,
metadatas=metadatas,
embeddings=embeddings,
ids=ids,
)
self._batch_add(situations, metadatas, embeddings)
def _sanitize_metadata(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
"""
@ -164,7 +168,7 @@ class FinancialSituationMemory:
current_situation: str,
signal_filters: Optional[Dict[str, Any]] = None,
n_matches: int = 3,
min_similarity: float = 0.5
min_similarity: float = 0.5,
) -> List[Dict[str, Any]]:
"""
Hybrid search: Filter by structured signals, then rank by embedding similarity.
@ -216,18 +220,20 @@ class FinancialSituationMemory:
metadata = results["metadatas"][0][i]
matched_results.append({
"matched_situation": results["documents"][0][i],
"recommendation": metadata.get("recommendation", ""),
"similarity_score": similarity_score,
"metadata": metadata,
# Extract key fields for convenience
"ticker": metadata.get("ticker", ""),
"move_pct": metadata.get("move_pct", 0),
"move_direction": metadata.get("move_direction", ""),
"was_correct": metadata.get("was_correct", False),
"days_before_move": metadata.get("days_before_move", 0),
})
matched_results.append(
{
"matched_situation": results["documents"][0][i],
"recommendation": metadata.get("recommendation", ""),
"similarity_score": similarity_score,
"metadata": metadata,
# Extract key fields for convenience
"ticker": metadata.get("ticker", ""),
"move_pct": metadata.get("move_pct", 0),
"move_direction": metadata.get("move_direction", ""),
"was_correct": metadata.get("was_correct", False),
"days_before_move": metadata.get("days_before_move", 0),
}
)
# Return top n_matches
return matched_results[:n_matches]
@ -250,13 +256,11 @@ class FinancialSituationMemory:
"total_memories": 0,
"accuracy_rate": 0.0,
"avg_move_pct": 0.0,
"signal_distribution": {}
"signal_distribution": {},
}
# Get all memories
all_results = self.situation_collection.get(
include=["metadatas"]
)
all_results = self.situation_collection.get(include=["metadatas"])
metadatas = all_results["metadatas"]
@ -283,7 +287,7 @@ class FinancialSituationMemory:
"total_memories": total_count,
"accuracy_rate": accuracy_rate,
"avg_move_pct": avg_move_pct,
"signal_distribution": signal_distribution
"signal_distribution": signal_distribution,
}
@ -324,10 +328,10 @@ if __name__ == "__main__":
recommendations = matcher.get_memories(current_situation, n_matches=2)
for i, rec in enumerate(recommendations, 1):
print(f"\nMatch {i}:")
print(f"Similarity Score: {rec['similarity_score']:.2f}")
print(f"Matched Situation: {rec['matched_situation']}")
print(f"Recommendation: {rec['recommendation']}")
logger.info(f"Match {i}:")
logger.info(f"Similarity Score: {rec['similarity_score']:.2f}")
logger.info(f"Matched Situation: {rec['matched_situation']}")
logger.info(f"Recommendation: {rec['recommendation']}")
except Exception as e:
print(f"Error during recommendation: {str(e)}")
logger.error(f"Error during recommendation: {str(e)}")

76
tradingagents/agents/utils/prompt_templates.py Normal file
View File

@ -0,0 +1,76 @@
"""
Shared prompt templates and utilities for trading agent prompts.
This module provides reusable prompt components to ensure consistency
and reduce token usage across all agent prompts.
"""
# Base collaborative boilerplate used in all analyst prompts
BASE_COLLABORATIVE_BOILERPLATE = (
"You are a helpful AI assistant, collaborating with other assistants. "
"Use the provided tools to progress towards answering the question. "
"If you are unable to fully answer, that's OK; another assistant with different tools "
"will help where you left off. Execute what you can to make progress. "
"If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable, "
"prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop."
)
# Standard date awareness instructions
STANDARD_DATE_AWARENESS_TEMPLATE = """
## CRITICAL: DATE AWARENESS
**Current Analysis Date:** {current_date}
**Instructions:**
- Treat {current_date} as "TODAY" for all calculations and references
- "Last 6 months" means 6 months ending on {current_date}
- "Last week" means the 7 days ending on {current_date}
- "Next week" means the 7 days starting from {current_date}
- Do NOT use 2024 or 2025 unless {current_date} is actually in that year
- When calling tools, ensure date parameters are relative to {current_date}
- All "recent" references should be relative to {current_date}
"""
def get_date_awareness_section(current_date: str) -> str:
"""Generate date awareness section for a prompt."""
return STANDARD_DATE_AWARENESS_TEMPLATE.format(current_date=current_date)
def validate_analyst_output(report: str, required_sections: list) -> dict:
"""
Validate that report contains all required sections.
Args:
report: The analyst report text to validate
required_sections: List of section names to check for
Returns:
Dictionary mapping section names to boolean (True if found)
"""
validation = {}
for section in required_sections:
# Check if section header exists (with ### or ##)
validation[section] = (
f"### {section}" in report or f"## {section}" in report or f"**{section}**" in report
)
return validation
def format_analyst_prompt(
system_message: str, current_date: str, ticker: str, tool_names: str
) -> str:
"""
Format a complete analyst prompt with boilerplate and context.
Args:
system_message: The agent-specific system message
current_date: Current analysis date
ticker: Stock ticker symbol
tool_names: Comma-separated list of tool names
Returns:
Formatted prompt string
"""
return (
f"{BASE_COLLABORATIVE_BOILERPLATE}\n\n{system_message}\n\n"
f"Context: {ticker} | Date: {current_date} | Tools: {tool_names}"
)

6
tradingagents/agents/utils/twitter_data_tools.py
View File

@ -1,7 +1,10 @@
from langchain_core.tools import tool
from typing import Annotated
from langchain_core.tools import tool
from tradingagents.tools.executor import execute_tool
@tool
def get_tweets(
query: Annotated[str, "Search query for tweets (e.g. ticker symbol or topic)"],
@ -18,6 +21,7 @@ def get_tweets(
"""
return execute_tool("get_tweets", query=query, count=count)
@tool
def get_tweets_from_user(
username: Annotated[str, "Twitter username (without @) to fetch tweets from"],

121
tradingagents/config.py Normal file
View File

@ -0,0 +1,121 @@
import os
from typing import Any, Optional
from dotenv import load_dotenv
from tradingagents.default_config import DEFAULT_CONFIG
# Load environment variables from .env file
load_dotenv()
class Config:
"""
Centralized configuration management.
Merges environment variables with default configuration.
"""
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super(Config, cls).__new__(cls)
cls._instance._initialize()
return cls._instance
def _initialize(self):
self._defaults = DEFAULT_CONFIG
self._env_cache = {}
def _get_env(self, key: str, default: Any = None) -> Any:
"""Helper to get env var with optional default from config dictionary."""
val = os.getenv(key)
if val is not None:
return val
return default
# --- API Keys ---
@property
def openai_api_key(self) -> Optional[str]:
return self._get_env("OPENAI_API_KEY")
@property
def alpha_vantage_api_key(self) -> Optional[str]:
return self._get_env("ALPHA_VANTAGE_API_KEY")
@property
def finnhub_api_key(self) -> Optional[str]:
return self._get_env("FINNHUB_API_KEY")
@property
def tradier_api_key(self) -> Optional[str]:
return self._get_env("TRADIER_API_KEY")
@property
def fmp_api_key(self) -> Optional[str]:
return self._get_env("FMP_API_KEY")
@property
def reddit_client_id(self) -> Optional[str]:
return self._get_env("REDDIT_CLIENT_ID")
@property
def reddit_client_secret(self) -> Optional[str]:
return self._get_env("REDDIT_CLIENT_SECRET")
@property
def reddit_user_agent(self) -> str:
return self._get_env("REDDIT_USER_AGENT", "TradingAgents/1.0")
@property
def twitter_bearer_token(self) -> Optional[str]:
return self._get_env("TWITTER_BEARER_TOKEN")
@property
def serper_api_key(self) -> Optional[str]:
return self._get_env("SERPER_API_KEY")
@property
def gemini_api_key(self) -> Optional[str]:
return self._get_env("GEMINI_API_KEY")
# --- Paths and Settings ---
@property
def results_dir(self) -> str:
return self._defaults.get("results_dir", "./results")
@property
def user_workspace(self) -> str:
return self._get_env("USER_WORKSPACE", self._defaults.get("project_dir"))
# --- Methods ---
def validate_key(self, key_property: str, service_name: str) -> str:
"""
Validate that a specific API key property is set.
Returns the key if valid, raises ValueError otherwise.
"""
key = getattr(self, key_property)
if not key:
raise ValueError(
f"{service_name} API Key not found. Please set correct environment variable."
)
return key
def get(self, key: str, default: Any = None) -> Any:
"""
Get configuration value.
Checks properties first, then defaults.
"""
if hasattr(self, key):
val = getattr(self, key)
if val is not None:
return val
return self._defaults.get(key, default)
# Global config instance
config = Config()

29
tradingagents/dataflows/alpha_vantage.py
View File

@ -1,5 +1,28 @@
# Import functions from specialized modules
from .alpha_vantage_fundamentals import (
get_balance_sheet,
get_cashflow,
get_fundamentals,
get_income_statement,
)
from .alpha_vantage_news import (
get_global_news,
get_insider_sentiment,
get_insider_transactions,
get_news,
)
from .alpha_vantage_stock import get_stock, get_top_gainers_losers
from .alpha_vantage_indicator import get_indicator
from .alpha_vantage_fundamentals import get_fundamentals, get_balance_sheet, get_cashflow, get_income_statement
from .alpha_vantage_news import get_news, get_insider_transactions, get_insider_sentiment, get_global_news
__all__ = [
"get_stock",
"get_top_gainers_losers",
"get_fundamentals",
"get_balance_sheet",
"get_cashflow",
"get_income_statement",
"get_news",
"get_global_news",
"get_insider_transactions",
"get_insider_sentiment",
]

106
tradingagents/dataflows/alpha_vantage_analysts.py
View File

@ -3,17 +3,19 @@ Alpha Vantage Analyst Rating Changes Detection
Tracks recent analyst upgrades/downgrades and price target changes
"""
import os
import requests
import json
from datetime import datetime, timedelta
from typing import Annotated, List
from typing import Annotated, Dict, List, Union
from .alpha_vantage_common import _make_api_request
def get_analyst_rating_changes(
lookback_days: Annotated[int, "Number of days to look back for rating changes"] = 7,
change_types: Annotated[List[str], "Types of changes to track"] = None,
top_n: Annotated[int, "Number of top results to return"] = 20,
) -> str:
return_structured: Annotated[bool, "Return list of dicts instead of markdown"] = False,
) -> Union[List[Dict], str]:
"""
Track recent analyst upgrades/downgrades and rating changes.
@ -23,14 +25,12 @@ def get_analyst_rating_changes(
lookback_days: Number of days to look back (default 7)
change_types: Types of changes ["upgrade", "downgrade", "initiated", "reiterated"]
top_n: Maximum number of results to return
return_structured: If True, returns list of dicts instead of markdown
Returns:
Formatted markdown report of recent analyst rating changes
If return_structured=True: list of analyst change dicts
If return_structured=False: Formatted markdown report
"""
api_key = os.getenv("ALPHA_VANTAGE_API_KEY")
if not api_key:
return "Error: ALPHA_VANTAGE_API_KEY not set in environment variables"
if change_types is None:
change_types = ["upgrade", "downgrade", "initiated"]
@ -38,26 +38,31 @@ def get_analyst_rating_changes(
# We'll use news sentiment API which includes analyst actions
# For production, consider using Financial Modeling Prep or Benzinga API
url = "https://www.alphavantage.co/query"
try:
# Get market news which includes analyst actions
params = {
"function": "NEWS_SENTIMENT",
"topics": "earnings,technology,finance",
"sort": "LATEST",
"limit": 200, # Get more news to find analyst actions
"apikey": api_key,
"limit": "200", # Get more news to find analyst actions
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
response_text = _make_api_request("NEWS_SENTIMENT", params)
try:
data = json.loads(response_text)
except json.JSONDecodeError:
if return_structured:
return []
return f"API Error: Failed to parse JSON response: {response_text[:100]}"
if "Note" in data:
if return_structured:
return []
return f"API Rate Limit: {data['Note']}"
if "Error Message" in data:
if return_structured:
return []
return f"API Error: {data['Error Message']}"
# Parse news for analyst actions
@ -79,10 +84,21 @@ def get_analyst_rating_changes(
text = f"{title} {summary}"
# Look for analyst action keywords
is_upgrade = any(word in text for word in ["upgrade", "upgrades", "raised", "raises rating"])
is_downgrade = any(word in text for word in ["downgrade", "downgrades", "lowered", "lowers rating"])
is_initiated = any(word in text for word in ["initiates", "initiated", "coverage", "starts coverage"])
is_reiterated = any(word in text for word in ["reiterates", "reiterated", "maintains", "confirms"])
is_upgrade = any(
word in text for word in ["upgrade", "upgrades", "raised", "raises rating"]
)
is_downgrade = any(
word in text
for word in ["downgrade", "downgrades", "lowered", "lowers rating"]
)
is_initiated = any(
word in text
for word in ["initiates", "initiated", "coverage", "starts coverage"]
)
is_reiterated = any(
word in text
for word in ["reiterates", "reiterated", "maintains", "confirms"]
)
# Extract tickers from article
tickers = []
@ -108,36 +124,44 @@ def get_analyst_rating_changes(
hours_old = (datetime.now() - article_date).total_seconds() / 3600
for ticker in tickers[:3]: # Max 3 tickers per article
analyst_changes.append({
"ticker": ticker,
"action": action_type,
"date": time_published[:8],
"hours_old": int(hours_old),
"headline": article.get("title", "")[:100],
"source": article.get("source", "Unknown"),
"url": article.get("url", ""),
})
analyst_changes.append(
{
"ticker": ticker,
"action": action_type,
"date": time_published[:8],
"hours_old": int(hours_old),
"headline": article.get("title", "")[:100],
"source": article.get("source", "Unknown"),
"url": article.get("url", ""),
}
)
except (ValueError, KeyError) as e:
except (ValueError, KeyError):
continue
# Remove duplicates (keep most recent per ticker)
seen_tickers = {}
for change in analyst_changes:
ticker = change["ticker"]
if ticker not in seen_tickers or change["hours_old"] < seen_tickers[ticker]["hours_old"]:
if (
ticker not in seen_tickers
or change["hours_old"] < seen_tickers[ticker]["hours_old"]
):
seen_tickers[ticker] = change
# Sort by freshness (most recent first)
sorted_changes = sorted(
seen_tickers.values(),
key=lambda x: x["hours_old"]
)[:top_n]
sorted_changes = sorted(seen_tickers.values(), key=lambda x: x["hours_old"])[:top_n]
# Format output
if not sorted_changes:
if return_structured:
return []
return f"No analyst rating changes found in the last {lookback_days} days"
# Return structured data if requested
if return_structured:
return sorted_changes
report = f"# Analyst Rating Changes - Last {lookback_days} Days\n\n"
report += f"**Tracking**: {', '.join(change_types)}\n\n"
report += f"**Found**: {len(sorted_changes)} recent analyst actions\n\n"
@ -146,7 +170,11 @@ def get_analyst_rating_changes(
report += "|--------|--------|--------|-----------|----------|\n"
for change in sorted_changes:
freshness = "🔥 FRESH" if change["hours_old"] < 24 else "🟢 Recent" if change["hours_old"] < 72 else "Older"
freshness = (
"🔥 FRESH"
if change["hours_old"] < 24
else "🟢 Recent" if change["hours_old"] < 72 else "Older"
)
report += f"| {change['ticker']} | "
report += f"{change['action'].upper()} | "
@ -161,9 +189,9 @@ def get_analyst_rating_changes(
return report
except requests.exceptions.RequestException as e:
return f"Error fetching analyst rating changes: {str(e)}"
except Exception as e:
if return_structured:
return []
return f"Unexpected error in analyst rating detection: {str(e)}"

44
tradingagents/dataflows/alpha_vantage_common.py
View File

@ -1,25 +1,29 @@
import os
import requests
import pandas as pd
import json
from datetime import datetime
from io import StringIO
from typing import Union
import pandas as pd
import requests
from tradingagents.config import config
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
API_BASE_URL = "https://www.alphavantage.co/query"
def get_api_key() -> str:
"""Retrieve the API key for Alpha Vantage from environment variables."""
api_key = os.getenv("ALPHA_VANTAGE_API_KEY")
if not api_key:
raise ValueError("ALPHA_VANTAGE_API_KEY environment variable is not set.")
return api_key
return config.validate_key("alpha_vantage_api_key", "Alpha Vantage")
def format_datetime_for_api(date_input) -> str:
"""Convert various date formats to YYYYMMDDTHHMM format required by Alpha Vantage API."""
if isinstance(date_input, str):
# If already in correct format, return as-is
if len(date_input) == 13 and 'T' in date_input:
if len(date_input) == 13 and "T" in date_input:
return date_input
# Try to parse common date formats
try:
@ -36,10 +40,13 @@ def format_datetime_for_api(date_input) -> str:
else:
raise ValueError(f"Date must be string or datetime object, got {type(date_input)}")
class AlphaVantageRateLimitError(Exception):
"""Exception raised when Alpha Vantage API rate limit is exceeded."""
pass
def _make_api_request(function_name: str, params: dict) -> Union[dict, str]:
"""Helper function to make API requests and handle responses.
@ -48,14 +55,16 @@ def _make_api_request(function_name: str, params: dict) -> Union[dict, str]:
"""
# Create a copy of params to avoid modifying the original
api_params = params.copy()
api_params.update({
"function": function_name,
"apikey": get_api_key(),
"source": "trading_agents",
})
api_params.update(
{
"function": function_name,
"apikey": get_api_key(),
"source": "trading_agents",
}
)
# Handle entitlement parameter if present in params or global variable
current_entitlement = globals().get('_current_entitlement')
current_entitlement = globals().get("_current_entitlement")
entitlement = api_params.get("entitlement") or current_entitlement
if entitlement:
@ -76,7 +85,9 @@ def _make_api_request(function_name: str, params: dict) -> Union[dict, str]:
if "Information" in response_json:
info_message = response_json["Information"]
if "rate limit" in info_message.lower() or "api key" in info_message.lower():
raise AlphaVantageRateLimitError(f"Alpha Vantage rate limit exceeded: {info_message}")
raise AlphaVantageRateLimitError(
f"Alpha Vantage rate limit exceeded: {info_message}"
)
except json.JSONDecodeError:
# Response is not JSON (likely CSV data), which is normal
pass
@ -84,7 +95,6 @@ def _make_api_request(function_name: str, params: dict) -> Union[dict, str]:
return response_text
def _filter_csv_by_date_range(csv_data: str, start_date: str, end_date: str) -> str:
"""
Filter CSV data to include only rows within the specified date range.
@ -119,5 +129,5 @@ def _filter_csv_by_date_range(csv_data: str, start_date: str, end_date: str) ->
except Exception as e:
# If filtering fails, return original data with a warning
print(f"Warning: Failed to filter CSV data by date range: {e}")
logger.warning(f"Failed to filter CSV data by date range: {e}")
return csv_data

1
tradingagents/dataflows/alpha_vantage_fundamentals.py
View File

@ -74,4 +74,3 @@ def get_income_statement(ticker: str, freq: str = "quarterly", curr_date: str =
}
return _make_api_request("INCOME_STATEMENT", params)

182
tradingagents/dataflows/alpha_vantage_indicator.py
View File

@ -1,5 +1,10 @@
from tradingagents.utils.logger import get_logger
from .alpha_vantage_common import _make_api_request
logger = get_logger(__name__)
def get_indicator(
symbol: str,
indicator: str,
@ -7,7 +12,7 @@ def get_indicator(
look_back_days: int,
interval: str = "daily",
time_period: int = 14,
series_type: str = "close"
series_type: str = "close",
) -> str:
"""
Returns Alpha Vantage technical indicator values over a time window.
@ -25,6 +30,7 @@ def get_indicator(
String containing indicator values and description
"""
from datetime import datetime
from dateutil.relativedelta import relativedelta
supported_indicators = {
@ -39,7 +45,7 @@ def get_indicator(
"boll_ub": ("Bollinger Upper Band", "close"),
"boll_lb": ("Bollinger Lower Band", "close"),
"atr": ("ATR", None),
"vwma": ("VWMA", "close")
"vwma": ("VWMA", "close"),
}
indicator_descriptions = {
@ -54,7 +60,7 @@ def get_indicator(
"boll_ub": "Bollinger Upper Band: Typically 2 standard deviations above the middle line. Usage: Signals potential overbought conditions and breakout zones. Tips: Confirm signals with other tools; prices may ride the band in strong trends.",
"boll_lb": "Bollinger Lower Band: Typically 2 standard deviations below the middle line. Usage: Indicates potential oversold conditions. Tips: Use additional analysis to avoid false reversal signals.",
"atr": "ATR: Averages true range to measure volatility. Usage: Set stop-loss levels and adjust position sizes based on current market volatility. Tips: It's a reactive measure, so use it as part of a broader risk management strategy.",
"vwma": "VWMA: A moving average weighted by volume. Usage: Confirm trends by integrating price action with volume data. Tips: Watch for skewed results from volume spikes; use in combination with other volume analyses."
"vwma": "VWMA: A moving average weighted by volume. Usage: Confirm trends by integrating price action with volume data. Tips: Watch for skewed results from volume spikes; use in combination with other volume analyses.",
}
if indicator not in supported_indicators:
@ -75,73 +81,100 @@ def get_indicator(
try:
# Get indicator data for the period
if indicator == "close_50_sma":
data = _make_api_request("SMA", {
"symbol": symbol,
"interval": interval,
"time_period": "50",
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"SMA",
{
"symbol": symbol,
"interval": interval,
"time_period": "50",
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "close_200_sma":
data = _make_api_request("SMA", {
"symbol": symbol,
"interval": interval,
"time_period": "200",
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"SMA",
{
"symbol": symbol,
"interval": interval,
"time_period": "200",
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "close_10_ema":
data = _make_api_request("EMA", {
"symbol": symbol,
"interval": interval,
"time_period": "10",
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"EMA",
{
"symbol": symbol,
"interval": interval,
"time_period": "10",
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "macd":
data = _make_api_request("MACD", {
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"MACD",
{
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "macds":
data = _make_api_request("MACD", {
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"MACD",
{
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "macdh":
data = _make_api_request("MACD", {
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"MACD",
{
"symbol": symbol,
"interval": interval,
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "rsi":
data = _make_api_request("RSI", {
"symbol": symbol,
"interval": interval,
"time_period": str(time_period),
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"RSI",
{
"symbol": symbol,
"interval": interval,
"time_period": str(time_period),
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator in ["boll", "boll_ub", "boll_lb"]:
data = _make_api_request("BBANDS", {
"symbol": symbol,
"interval": interval,
"time_period": "20",
"series_type": series_type,
"datatype": "csv"
})
data = _make_api_request(
"BBANDS",
{
"symbol": symbol,
"interval": interval,
"time_period": "20",
"series_type": series_type,
"datatype": "csv",
},
)
elif indicator == "atr":
data = _make_api_request("ATR", {
"symbol": symbol,
"interval": interval,
"time_period": str(time_period),
"datatype": "csv"
})
data = _make_api_request(
"ATR",
{
"symbol": symbol,
"interval": interval,
"time_period": str(time_period),
"datatype": "csv",
},
)
elif indicator == "vwma":
# Alpha Vantage doesn't have direct VWMA, so we'll return an informative message
# In a real implementation, this would need to be calculated from OHLCV data
@ -150,23 +183,30 @@ def get_indicator(
return f"Error: Indicator {indicator} not implemented yet."
# Parse CSV data and extract values for the date range
lines = data.strip().split('\n')
lines = data.strip().split("\n")
if len(lines) < 2:
return f"Error: No data returned for {indicator}"
# Parse header and data
header = [col.strip() for col in lines[0].split(',')]
header = [col.strip() for col in lines[0].split(",")]
try:
date_col_idx = header.index('time')
date_col_idx = header.index("time")
except ValueError:
return f"Error: 'time' column not found in data for {indicator}. Available columns: {header}"
# Map internal indicator names to expected CSV column names from Alpha Vantage
col_name_map = {
"macd": "MACD", "macds": "MACD_Signal", "macdh": "MACD_Hist",
"boll": "Real Middle Band", "boll_ub": "Real Upper Band", "boll_lb": "Real Lower Band",
"rsi": "RSI", "atr": "ATR", "close_10_ema": "EMA",
"close_50_sma": "SMA", "close_200_sma": "SMA"
"macd": "MACD",
"macds": "MACD_Signal",
"macdh": "MACD_Hist",
"boll": "Real Middle Band",
"boll_ub": "Real Upper Band",
"boll_lb": "Real Lower Band",
"rsi": "RSI",
"atr": "ATR",
"close_10_ema": "EMA",
"close_50_sma": "SMA",
"close_200_sma": "SMA",
}
target_col_name = col_name_map.get(indicator)
@ -184,7 +224,7 @@ def get_indicator(
for line in lines[1:]:
if not line.strip():
continue
values = line.split(',')
values = line.split(",")
if len(values) > value_col_idx:
try:
date_str = values[date_col_idx].strip()
@ -218,5 +258,5 @@ def get_indicator(
return result_str
except Exception as e:
print(f"Error getting Alpha Vantage indicator data for {indicator}: {e}")
logger.error(f"Error getting Alpha Vantage indicator data for {indicator}: {e}")
return f"Error retrieving {indicator} data: {str(e)}"

49
tradingagents/dataflows/alpha_vantage_news.py
View File

@ -1,7 +1,11 @@
from typing import Union, Dict, Optional
from typing import Dict, Union
from .alpha_vantage_common import _make_api_request, format_datetime_for_api
def get_news(ticker: str = None, start_date: str = None, end_date: str = None, query: str = None) -> Union[Dict[str, str], str]:
def get_news(
ticker: str = None, start_date: str = None, end_date: str = None, query: str = None
) -> Union[Dict[str, str], str]:
"""Returns live and historical market news & sentiment data.
Args:
@ -29,7 +33,9 @@ def get_news(ticker: str = None, start_date: str = None, end_date: str = None, q
return _make_api_request("NEWS_SENTIMENT", params)
def get_global_news(date: str, look_back_days: int = 7, limit: int = 5) -> Union[Dict[str, str], str]:
def get_global_news(
date: str, look_back_days: int = 7, limit: int = 5
) -> Union[Dict[str, str], str]:
"""Returns global market news & sentiment data.
Args:
@ -49,7 +55,41 @@ def get_global_news(date: str, look_back_days: int = 7, limit: int = 5) -> Union
return _make_api_request("NEWS_SENTIMENT", params)
def get_insider_transactions(symbol: str = None, ticker: str = None, curr_date: str = None) -> Union[Dict[str, str], str]:
def get_alpha_vantage_news_feed(
topics: str = None, time_from: str = None, limit: int = 50
) -> Union[Dict[str, str], str]:
"""Returns news feed from Alpha Vantage with optional topic filtering.
Args:
topics: Comma-separated topics (e.g., "technology,finance,earnings").
Valid topics: blockchain, earnings, ipo, mergers_and_acquisitions,
financial_markets, economy_fiscal, economy_monetary, economy_macro,
energy_transportation, finance, life_sciences, manufacturing,
real_estate, retail_wholesale, technology
time_from: Start time in format YYYYMMDDTHHMM (e.g., "20240101T0000").
limit: Maximum number of articles to return.
Returns:
Dictionary containing news sentiment data or JSON string.
"""
params = {
"sort": "LATEST",
"limit": str(limit),
}
if topics:
params["topics"] = topics
if time_from:
params["time_from"] = time_from
return _make_api_request("NEWS_SENTIMENT", params)
def get_insider_transactions(
symbol: str = None, ticker: str = None, curr_date: str = None
) -> Union[Dict[str, str], str]:
"""Returns latest and historical insider transactions.
Args:
@ -70,6 +110,7 @@ def get_insider_transactions(symbol: str = None, ticker: str = None, curr_date:
return _make_api_request("INSIDER_TRANSACTIONS", params)
def get_insider_sentiment(symbol: str = None, ticker: str = None, curr_date: str = None) -> str:
"""Returns insider sentiment data derived from Alpha Vantage transactions.

47
tradingagents/dataflows/alpha_vantage_stock.py
View File

@ -1,11 +1,9 @@
from datetime import datetime
from .alpha_vantage_common import _make_api_request, _filter_csv_by_date_range
def get_stock(
symbol: str,
start_date: str,
end_date: str
) -> str:
from .alpha_vantage_common import _filter_csv_by_date_range, _make_api_request
def get_stock(symbol: str, start_date: str, end_date: str) -> str:
"""
Returns raw daily OHLCV values, adjusted close values, and historical split/dividend events
filtered to the specified date range.
@ -38,9 +36,17 @@ def get_stock(
return _filter_csv_by_date_range(response, start_date, end_date)
def get_top_gainers_losers(limit: int = 10) -> str:
def get_top_gainers_losers(limit: int = 10, return_structured: bool = False):
"""
Returns the top gainers, losers, and most active stocks from Alpha Vantage.
Args:
limit: Maximum number of items per category
return_structured: If True, returns dict with raw data instead of markdown
Returns:
If return_structured=True: dict with 'gainers', 'losers', 'most_active' lists
If return_structured=False: Formatted markdown string
"""
params = {}
@ -49,37 +55,58 @@ def get_top_gainers_losers(limit: int = 10) -> str:
try:
import json
data = json.loads(response_text)
if "top_gainers" not in data:
if return_structured:
return {"error": f"Unexpected response format: {response_text[:200]}..."}
return f"Error: Unexpected response format: {response_text[:200]}..."
# Apply limit to data
gainers = data.get("top_gainers", [])[:limit]
losers = data.get("top_losers", [])[:limit]
most_active = data.get("most_actively_traded", [])[:limit]
# Return structured data if requested
if return_structured:
return {
"gainers": gainers,
"losers": losers,
"most_active": most_active,
}
# Format as markdown report
report = "## Top Market Movers (Alpha Vantage)\n\n"
# Top Gainers
report += "### Top Gainers\n"
report += "| Ticker | Price | Change % | Volume |\n"
report += "|--------|-------|----------|--------|\n"
for item in data.get("top_gainers", [])[:limit]:
for item in gainers:
report += f"| {item['ticker']} | {item['price']} | {item['change_percentage']} | {item['volume']} |\n"
# Top Losers
report += "\n### Top Losers\n"
report += "| Ticker | Price | Change % | Volume |\n"
report += "|--------|-------|----------|--------|\n"
for item in data.get("top_losers", [])[:limit]:
for item in losers:
report += f"| {item['ticker']} | {item['price']} | {item['change_percentage']} | {item['volume']} |\n"
# Most Active
report += "\n### Most Active\n"
report += "| Ticker | Price | Change % | Volume |\n"
report += "|--------|-------|----------|--------|\n"
for item in data.get("most_actively_traded", [])[:limit]:
for item in most_active:
report += f"| {item['ticker']} | {item['price']} | {item['change_percentage']} | {item['volume']} |\n"
return report
except json.JSONDecodeError:
if return_structured:
return {"error": f"Failed to parse JSON response: {response_text[:200]}..."}
return f"Error: Failed to parse JSON response: {response_text[:200]}..."
except Exception as e:
if return_structured:
return {"error": str(e)}
return f"Error processing market movers: {str(e)}"

684
tradingagents/dataflows/alpha_vantage_volume.py
View File

@ -1,154 +1,631 @@
"""
Alpha Vantage Unusual Volume Detection
Unusual Volume Detection using yfinance
Identifies stocks with unusual volume but minimal price movement (accumulation signal)
"""
import os
import requests
from datetime import datetime, timedelta
from typing import Annotated, List, Dict
import hashlib
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime
from pathlib import Path
from typing import Annotated, Dict, List, Optional, Union
import pandas as pd
from tradingagents.dataflows.y_finance import _get_ticker_universe, get_ticker_history
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def _get_cache_path(ticker_universe: Union[str, List[str]]) -> Path:
"""
Get the cache file path for unusual volume raw data.
Args:
ticker_universe: Universe identifier
Returns:
Path to cache file
"""
# Get cache directory
current_file = Path(__file__)
cache_dir = current_file.parent / "data_cache"
cache_dir.mkdir(exist_ok=True)
# Create cache key from universe only (thresholds are applied later)
if isinstance(ticker_universe, str):
universe_key = ticker_universe
else:
# Stable hash for custom lists so different lists don't collide
clean_tickers = [t.upper().strip() for t in ticker_universe if isinstance(t, str)]
hash_suffix = hashlib.md5(",".join(sorted(clean_tickers)).encode()).hexdigest()[:8]
universe_key = f"custom_{hash_suffix}"
cache_key = f"unusual_volume_raw_{universe_key}".replace(".", "_")
return cache_dir / f"{cache_key}.json"
def _load_cache(cache_path: Path) -> Optional[Dict]:
"""
Load cached unusual volume raw data if it exists and is from today.
Args:
cache_path: Path to cache file
Returns:
Cached results dict if valid, None otherwise
"""
if not cache_path.exists():
return None
try:
with open(cache_path, "r") as f:
cache_data = json.load(f)
# Check if cache is from today
cache_date = cache_data.get("date")
today = datetime.now().strftime("%Y-%m-%d")
has_raw_data = bool(cache_data.get("raw_data"))
if cache_date == today and has_raw_data:
return cache_data
else:
# Cache is stale, return None to trigger recompute
return None
except Exception:
# If cache is corrupted, return None to trigger recompute
return None
def _save_cache(cache_path: Path, raw_data: Dict[str, List[Dict]], date: str):
"""
Save unusual volume raw data to cache.
Args:
cache_path: Path to cache file
raw_data: Raw ticker data to cache
date: Date string (YYYY-MM-DD)
"""
try:
cache_data = {"date": date, "raw_data": raw_data, "timestamp": datetime.now().isoformat()}
with open(cache_path, "w") as f:
json.dump(cache_data, f, indent=2)
except Exception as e:
# If caching fails, just continue without cache
logger.warning(f"Could not save cache: {e}")
def _history_to_records(hist: pd.DataFrame) -> List[Dict[str, Union[str, float, int]]]:
"""Convert a yfinance history DataFrame to a cache-friendly list of dicts."""
# Include Open price for intraday direction analysis (accumulation vs distribution)
cols_to_use = ["Close", "Volume"]
if "Open" in hist.columns:
cols_to_use = ["Open", "Close", "Volume"]
hist_for_cache = hist[cols_to_use].copy()
hist_for_cache = hist_for_cache.reset_index()
date_col = "Date" if "Date" in hist_for_cache.columns else hist_for_cache.columns[0]
hist_for_cache.rename(columns={date_col: "Date"}, inplace=True)
hist_for_cache["Date"] = pd.to_datetime(hist_for_cache["Date"]).dt.strftime("%Y-%m-%d")
final_cols = ["Date"] + cols_to_use
hist_for_cache = hist_for_cache[final_cols]
return hist_for_cache.to_dict(orient="records")
def _records_to_dataframe(history_records: List[Dict[str, Union[str, float, int]]]) -> pd.DataFrame:
"""Convert cached history records back to a DataFrame for calculation."""
hist_df = pd.DataFrame(history_records)
if hist_df.empty:
return hist_df
hist_df["Date"] = pd.to_datetime(hist_df["Date"])
hist_df = hist_df.sort_values("Date")
return hist_df
def get_cached_average_volume(
symbol: str,
lookback_days: int = 20,
curr_date: Optional[str] = None,
cache_key: str = "default",
fallback_download: bool = True,
) -> Dict[str, Union[str, float, int, None]]:
"""Get average volume using cached unusual-volume data, with optional fallback download."""
symbol = symbol.upper()
cache_path = _get_cache_path(cache_key)
cache_date = None
history_records = None
if cache_path.exists():
try:
with open(cache_path, "r") as f:
cache_data = json.load(f)
cache_date = cache_data.get("date")
raw_data = cache_data.get("raw_data") or {}
history_records = raw_data.get(symbol)
except Exception:
history_records = None
source = "cache"
if not history_records and fallback_download:
history_records = _download_ticker_history(
symbol, history_period_days=max(90, lookback_days * 2)
)
source = "download"
if not history_records:
return {
"symbol": symbol,
"average_volume": None,
"latest_volume": None,
"lookback_days": lookback_days,
"source": source,
"cache_date": cache_date,
"error": "No volume data found",
}
hist_df = _records_to_dataframe(history_records)
if hist_df.empty or "Volume" not in hist_df.columns:
return {
"symbol": symbol,
"average_volume": None,
"latest_volume": None,
"lookback_days": lookback_days,
"source": source,
"cache_date": cache_date,
"error": "No volume data found",
}
if curr_date:
curr_dt = pd.to_datetime(curr_date)
hist_df = hist_df[hist_df["Date"] <= curr_dt]
recent = hist_df.tail(lookback_days)
if recent.empty:
return {
"symbol": symbol,
"average_volume": None,
"latest_volume": None,
"lookback_days": lookback_days,
"source": source,
"cache_date": cache_date,
"error": "No recent volume data found",
}
average_volume = float(recent["Volume"].mean())
latest_volume = float(recent["Volume"].iloc[-1])
return {
"symbol": symbol,
"average_volume": average_volume,
"latest_volume": latest_volume,
"lookback_days": lookback_days,
"source": source,
"cache_date": cache_date,
}
def get_cached_average_volume_batch(
symbols: List[str],
lookback_days: int = 20,
curr_date: Optional[str] = None,
cache_key: str = "default",
fallback_download: bool = True,
) -> Dict[str, Dict[str, Union[str, float, int, None]]]:
"""Get average volumes for multiple tickers using the cache once."""
cache_path = _get_cache_path(cache_key)
cache_date = None
raw_data = {}
if cache_path.exists():
try:
with open(cache_path, "r") as f:
cache_data = json.load(f)
cache_date = cache_data.get("date")
raw_data = cache_data.get("raw_data") or {}
except Exception:
raw_data = {}
results: Dict[str, Dict[str, Union[str, float, int, None]]] = {}
symbols_upper = [s.upper() for s in symbols if isinstance(s, str)]
def compute_from_records(symbol: str, history_records: List[Dict[str, Union[str, float, int]]]):
hist_df = _records_to_dataframe(history_records)
if hist_df.empty or "Volume" not in hist_df.columns:
return None, None, "No volume data found"
if curr_date:
curr_dt = pd.to_datetime(curr_date)
hist_df = hist_df[hist_df["Date"] <= curr_dt]
recent = hist_df.tail(lookback_days)
if recent.empty:
return None, None, "No recent volume data found"
avg_volume = float(recent["Volume"].mean())
latest_volume = float(recent["Volume"].iloc[-1])
return avg_volume, latest_volume, None
missing = []
for symbol in symbols_upper:
history_records = raw_data.get(symbol)
if history_records:
avg_volume, latest_volume, error = compute_from_records(symbol, history_records)
results[symbol] = {
"symbol": symbol,
"average_volume": avg_volume,
"latest_volume": latest_volume,
"lookback_days": lookback_days,
"source": "cache",
"cache_date": cache_date,
"error": error,
}
else:
missing.append(symbol)
if fallback_download and missing:
for symbol in missing:
history_records = _download_ticker_history(
symbol, history_period_days=max(90, lookback_days * 2)
)
if history_records:
avg_volume, latest_volume, error = compute_from_records(symbol, history_records)
results[symbol] = {
"symbol": symbol,
"average_volume": avg_volume,
"latest_volume": latest_volume,
"lookback_days": lookback_days,
"source": "download",
"cache_date": cache_date,
"error": error,
}
else:
results[symbol] = {
"symbol": symbol,
"average_volume": None,
"latest_volume": None,
"lookback_days": lookback_days,
"source": "download",
"cache_date": cache_date,
"error": "No volume data found",
}
return results
def _evaluate_unusual_volume_from_history(
ticker: str,
history_records: List[Dict[str, Union[str, float, int]]],
min_volume_multiple: float,
max_price_change: float,
lookback_days: int = 30,
) -> Optional[Dict]:
"""
Evaluate a ticker's cached history for unusual volume patterns.
Now includes DIRECTION ANALYSIS to distinguish:
- Accumulation (high volume + price holds/rises) = BULLISH - keep
- Distribution (high volume + price drops) = BEARISH - skip
Args:
ticker: Stock ticker symbol
history_records: Cached price/volume history records
min_volume_multiple: Minimum volume multiple vs average
max_price_change: Maximum absolute price change percentage
lookback_days: Days to look back for average volume calculation
Returns:
Dict with ticker data if unusual volume detected, None otherwise
"""
try:
hist = _records_to_dataframe(history_records)
if hist.empty or len(hist) < lookback_days + 1:
return None
current_data = hist.iloc[-1]
current_volume = current_data["Volume"]
current_price = current_data["Close"]
avg_volume = hist["Volume"].iloc[-(lookback_days + 1) : -1].mean()
if pd.isna(avg_volume) or avg_volume <= 0:
return None
volume_ratio = current_volume / avg_volume
price_start = hist["Close"].iloc[-(lookback_days + 1)]
price_end = current_price
price_change_pct = ((price_end - price_start) / price_start) * 100
# === DIRECTION ANALYSIS (NEW) ===
# Check intraday direction to distinguish accumulation from distribution
intraday_change_pct = 0.0
direction = "neutral"
if "Open" in current_data and pd.notna(current_data["Open"]):
open_price = current_data["Open"]
if open_price > 0:
intraday_change_pct = ((current_price - open_price) / open_price) * 100
# Classify direction based on intraday movement
if intraday_change_pct > 0.5:
direction = "bullish" # Closed higher than open
elif intraday_change_pct < -1.5:
direction = "bearish" # Closed significantly lower than open
else:
direction = "neutral" # Flat intraday
# === DISTRIBUTION FILTER (NEW) ===
# Skip if high volume + bearish direction = likely distribution (selling)
if volume_ratio >= min_volume_multiple and direction == "bearish":
# This is likely DISTRIBUTION - smart money selling, not accumulation
# Return None to filter it out
return None
# Filter: High volume multiple AND low price change (accumulation signal)
if volume_ratio >= min_volume_multiple and abs(price_change_pct) < max_price_change:
# Determine signal type with direction context
if direction == "bullish" and abs(price_change_pct) < 3.0:
signal = "strong_accumulation" # Best signal: high volume, rising intraday
elif abs(price_change_pct) < 2.0:
signal = "accumulation"
elif abs(price_change_pct) < 5.0:
signal = "moderate_activity"
else:
signal = "building_momentum"
return {
"ticker": ticker.upper(),
"volume": int(current_volume),
"price": round(float(current_price), 2),
"price_change_pct": round(price_change_pct, 2),
"intraday_change_pct": round(intraday_change_pct, 2),
"direction": direction,
"volume_ratio": round(volume_ratio, 2),
"avg_volume": int(avg_volume),
"signal": signal,
}
return None
except Exception:
return None
def _download_ticker_history(
ticker: str, history_period_days: int = 90
) -> Optional[List[Dict[str, Union[str, float, int]]]]:
"""
Download raw history for a ticker and return cache-friendly records.
Args:
ticker: Stock ticker symbol
history_period_days: Total days of history to download (default: 90)
Returns:
List of history records or None if insufficient data
"""
try:
hist = get_ticker_history(ticker, period=f"{history_period_days}d")
if hist.empty:
return None
if hist.index.tz is not None:
hist.index = hist.index.tz_localize(None)
return _history_to_records(hist)
except Exception:
return None
def download_volume_data(
tickers: List[str],
history_period_days: int = 90,
use_cache: bool = True,
cache_key: str = "default",
) -> Dict[str, List[Dict[str, Union[str, float, int]]]]:
"""
Download or load cached volume data for a list of tickers.
This is the main data fetching function that:
1. If use_cache=True: Check if cache exists and is fresh (from today)
2. If cache is stale or use_cache=False: Download fresh data
3. Always save downloaded data to cache (for next time)
Args:
tickers: List of ticker symbols to download
history_period_days: Total days of history to download (default: 90)
use_cache: Whether to USE existing cache (fresh data always gets saved)
cache_key: Identifier for cache file (default: "default")
Returns:
Dict mapping ticker symbols to their history records
"""
today = datetime.now().strftime("%Y-%m-%d")
# Get cache path (we always need it for saving)
cache_path = _get_cache_path(cache_key)
# Try to load cache only if use_cache=True
if use_cache:
cached_data = _load_cache(cache_path)
# Check if cache is fresh (from today)
if cached_data and cached_data.get("date") == today:
logger.info(f"Using cached volume data from {cached_data['date']}")
return cached_data["raw_data"]
elif cached_data:
logger.info(f"Cache is stale (from {cached_data.get('date')}), re-downloading...")
else:
logger.info("Skipping cache (use_cache=False), forcing fresh download...")
# Download fresh data
logger.info(
f"Downloading {history_period_days} days of volume data for {len(tickers)} tickers..."
)
raw_data = {}
with ThreadPoolExecutor(max_workers=15) as executor:
futures = {
executor.submit(_download_ticker_history, ticker, history_period_days): ticker
for ticker in tickers
}
completed = 0
for future in as_completed(futures):
completed += 1
if completed % 50 == 0:
logger.info(f"Progress: {completed}/{len(tickers)} tickers downloaded...")
ticker_symbol = futures[future].upper()
history_records = future.result()
if history_records:
raw_data[ticker_symbol] = history_records
# Always save fresh data to cache (so it's available next time)
if cache_path and raw_data:
logger.info(f"Saving {len(raw_data)} tickers to cache...")
_save_cache(cache_path, raw_data, today)
return raw_data
def get_unusual_volume(
date: Annotated[str, "Analysis date in yyyy-mm-dd format"] = None,
min_volume_multiple: Annotated[float, "Minimum volume multiple vs average"] = 3.0,
max_price_change: Annotated[float, "Maximum price change percentage"] = 5.0,
top_n: Annotated[int, "Number of top results to return"] = 20,
) -> str:
tickers: Annotated[Optional[List[str]], "Custom ticker list or None to use config file"] = None,
max_tickers_to_scan: Annotated[int, "Maximum number of tickers to scan"] = 3000,
use_cache: Annotated[bool, "Use cached raw data when available"] = True,
return_structured: Annotated[bool, "Return list of dicts instead of markdown"] = False,
):
"""
Find stocks with unusual volume but minimal price movement.
This is a strong accumulation signal - smart money buying before a breakout.
Scans all major US stocks (3000+ including S&P 500, NASDAQ, small caps, meme stocks) using yfinance.
Args:
date: Analysis date in yyyy-mm-dd format
min_volume_multiple: Minimum volume multiple vs 30-day average
date: Analysis date in yyyy-mm-dd format (for reporting only)
min_volume_multiple: Minimum volume multiple vs 30-day average (e.g., 3.0 = 3x average volume)
max_price_change: Maximum absolute price change percentage
top_n: Number of top results to return
tickers: Custom list of ticker symbols, or None to load from config file
max_tickers_to_scan: Maximum number of tickers to scan (default: 3000, scans all)
use_cache: Whether to reuse/save cached raw data
return_structured: If True, returns list of candidate dicts instead of markdown
Returns:
Formatted markdown report of stocks with unusual volume
If return_structured=True: list of candidate dicts with ticker, volume_ratio, signal, etc.
If return_structured=False: Formatted markdown report
"""
api_key = os.getenv("ALPHA_VANTAGE_API_KEY")
if not api_key:
return "Error: ALPHA_VANTAGE_API_KEY not set in environment variables"
# For unusual volume detection, we'll use Alpha Vantage's market data
# Note: Alpha Vantage doesn't have a direct "unusual volume" endpoint,
# so we'll use a combination of their screening and market movers data
# Strategy: Get top active stocks (high volume) and filter for minimal price change
url = "https://www.alphavantage.co/query"
try:
# Get top active stocks by volume
params = {
"function": "TOP_GAINERS_LOSERS",
"apikey": api_key,
}
lookback_days = 30
today = datetime.now().strftime("%Y-%m-%d")
analysis_date = date or today
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
ticker_list = _get_ticker_universe(tickers=tickers, max_tickers=max_tickers_to_scan)
ticker_count = len(ticker_list) if ticker_list else 0
if not ticker_list:
return "Error: No tickers found"
if "Note" in data:
return f"API Rate Limit: {data['Note']}"
# Use the new helper function to download/load data
# Create cache key from ticker list or "default"
if isinstance(tickers, list):
import hashlib
if "Error Message" in data:
return f"API Error: {data['Error Message']}"
cache_key = "custom_" + hashlib.md5(",".join(sorted(tickers)).encode()).hexdigest()[:8]
else:
cache_key = "default"
raw_data = download_volume_data(
tickers=ticker_list, history_period_days=90, use_cache=use_cache, cache_key=cache_key
)
if not raw_data:
return "Error: Unable to retrieve volume data for requested tickers"
# Combine all movers (gainers, losers, and most actively traded)
unusual_candidates = []
for ticker in ticker_list:
history_records = raw_data.get(ticker.upper())
if not history_records:
continue
# Process most actively traded (these have high volume)
if "most_actively_traded" in data:
for stock in data["most_actively_traded"][:50]: # Check top 50
try:
ticker = stock.get("ticker", "")
price_change = abs(float(stock.get("change_percentage", "0").replace("%", "")))
volume = int(stock.get("volume", 0))
price = float(stock.get("price", 0))
candidate = _evaluate_unusual_volume_from_history(
ticker,
history_records,
min_volume_multiple,
max_price_change,
lookback_days=lookback_days,
)
if candidate:
unusual_candidates.append(candidate)
# Filter: High volume but low price change (accumulation signal)
if price_change <= max_price_change and volume > 0:
unusual_candidates.append({
"ticker": ticker,
"volume": volume,
"price": price,
"price_change_pct": price_change,
"signal": "accumulation" if price_change < 2.0 else "moderate_activity"
})
if not unusual_candidates:
if return_structured:
return []
return f"No stocks found with unusual volume patterns matching criteria\n\nScanned {len(ticker_list)} tickers."
except (ValueError, KeyError) as e:
continue
# Also check gainers and losers with unusual volume patterns
for category in ["top_gainers", "top_losers"]:
if category in data:
for stock in data[category][:30]:
try:
ticker = stock.get("ticker", "")
price_change = abs(float(stock.get("change_percentage", "0").replace("%", "")))
volume = int(stock.get("volume", 0))
price = float(stock.get("price", 0))
# For gainers/losers, we want very high volume
# This indicates strong conviction in the move
if volume > 0:
unusual_candidates.append({
"ticker": ticker,
"volume": volume,
"price": price,
"price_change_pct": price_change,
"signal": "breakout" if price_change > 5.0 else "building_momentum"
})
except (ValueError, KeyError) as e:
continue
# Remove duplicates (keep highest volume)
seen_tickers = {}
for candidate in unusual_candidates:
ticker = candidate["ticker"]
if ticker not in seen_tickers or candidate["volume"] > seen_tickers[ticker]["volume"]:
seen_tickers[ticker] = candidate
# Sort by volume (highest first) and take top N
# Sort by volume ratio (highest first)
sorted_candidates = sorted(
seen_tickers.values(),
key=lambda x: x["volume"],
reverse=True
)[:top_n]
unusual_candidates, key=lambda x: (x.get("volume_ratio", 0), x["volume"]), reverse=True
)
# Take top N for display
sorted_candidates = sorted_candidates[:top_n]
# Return structured data if requested
if return_structured:
return sorted_candidates
# Format output
if not sorted_candidates:
return "No stocks found with unusual volume patterns matching criteria"
report = f"# Unusual Volume Detected - {date or 'Latest'}\n\n"
report += f"**Criteria**: Volume signal detected, Price Change <{max_price_change}% preferred\n\n"
report = f"# Unusual Volume Detected - {analysis_date}\n\n"
report += "**Criteria**: \n"
report += f"- Price Change: <{max_price_change}% (accumulation pattern)\n"
report += f"- Volume Multiple: Current volume ≥ {min_volume_multiple}x 30-day average\n"
report += f"- Tickers Scanned: {ticker_count}\n\n"
report += f"**Found**: {len(sorted_candidates)} stocks with unusual activity\n\n"
report += "## Top Unusual Volume Candidates\n\n"
report += "| Ticker | Price | Volume | Price Change % | Signal |\n"
report += "|--------|-------|--------|----------------|--------|\n"
report += (
"| Ticker | Price | Volume | Avg Volume | Volume Ratio | Price Change % | Signal |\n"
)
report += (
"|--------|-------|--------|------------|--------------|----------------|--------|\n"
)
for candidate in sorted_candidates:
volume_ratio_str = (
f"{candidate.get('volume_ratio', 'N/A')}x"
if candidate.get("volume_ratio")
else "N/A"
)
avg_vol_str = (
f"{candidate.get('avg_volume', 0):,}" if candidate.get("avg_volume") else "N/A"
)
report += f"| {candidate['ticker']} | "
report += f"${candidate['price']:.2f} | "
report += f"{candidate['volume']:,} | "
report += f"{avg_vol_str} | "
report += f"{volume_ratio_str} | "
report += f"{candidate['price_change_pct']:.2f}% | "
report += f"{candidate['signal']} |\n"
report += "\n\n## Signal Definitions\n\n"
report += "- **strong_accumulation**: High volume + bullish intraday direction - Strongest buy signal\n"
report += "- **accumulation**: High volume, minimal price change (<2%) - Smart money building position\n"
report += "- **moderate_activity**: Elevated volume with 2-5% price change - Early momentum\n"
report += "- **building_momentum**: Losers/Gainers with strong volume - Conviction in direction\n"
report += "- **breakout**: Strong price move (>5%) on high volume - Already in motion\n"
report += (
"- **moderate_activity**: Elevated volume with 2-5% price change - Early momentum\n"
)
report += "- **building_momentum**: High volume with moderate price change - Conviction building\n"
report += "\n**Note**: Distribution patterns (high volume + bearish direction) are automatically filtered out.\n"
return report
except requests.exceptions.RequestException as e:
return f"Error fetching unusual volume data: {str(e)}"
except Exception as e:
if return_structured:
return []
return f"Unexpected error in unusual volume detection: {str(e)}"
@ -157,6 +634,11 @@ def get_alpha_vantage_unusual_volume(
min_volume_multiple: float = 3.0,
max_price_change: float = 5.0,
top_n: int = 20,
tickers: Optional[List[str]] = None,
max_tickers_to_scan: int = 3000,
use_cache: bool = True,
) -> str:
"""Alias for get_unusual_volume to match registry naming convention"""
return get_unusual_volume(date, min_volume_multiple, max_price_change, top_n)
return get_unusual_volume(
date, min_volume_multiple, max_price_change, top_n, tickers, max_tickers_to_scan, use_cache
)

3
tradingagents/dataflows/config.py
View File

@ -1,6 +1,7 @@
import tradingagents.default_config as default_config
from typing import Dict, Optional
import tradingagents.default_config as default_config
# Use default config but allow it to be overridden
_config: Optional[Dict] = None
DATA_DIR: Optional[str] = None

147
tradingagents/dataflows/delisted_cache.py Normal file
View File

@ -0,0 +1,147 @@
"""
Delisted Cache System
---------------------
Track tickers that consistently fail data fetches (likely delisted).
SAFETY: Only cache tickers that:
- Passed initial format validation (not units/warrants/common words)
- Failed multiple times over multiple days
- Have consistent failure patterns (not temporary API issues)
"""
import json
from datetime import datetime
from pathlib import Path
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
class DelistedCache:
"""
Track tickers that consistently fail data fetches (likely delisted).
SAFETY: Only cache tickers that:
- Passed initial format validation (not units/warrants/common words)
- Failed multiple times over multiple days
- Have consistent failure patterns (not temporary API issues)
"""
def __init__(self, cache_file="data/delisted_cache.json"):
self.cache_file = Path(cache_file)
self.cache = self._load_cache()
def _load_cache(self):
if self.cache_file.exists():
with open(self.cache_file, "r") as f:
return json.load(f)
return {}
def mark_failed(self, ticker, reason="no_data", error_code=None):
"""
Record a failed data fetch for a ticker.
Args:
ticker: Stock symbol
reason: Human-readable failure reason
error_code: Specific error (e.g., "404", "no_price_data", "empty_history")
"""
ticker = ticker.upper()
if ticker not in self.cache:
self.cache[ticker] = {
"first_failed": datetime.now().isoformat(),
"last_failed": datetime.now().isoformat(),
"fail_count": 1,
"reason": reason,
"error_code": error_code,
"fail_dates": [datetime.now().date().isoformat()],
}
else:
self.cache[ticker]["fail_count"] += 1
self.cache[ticker]["last_failed"] = datetime.now().isoformat()
self.cache[ticker]["reason"] = reason # Update to latest reason
# Track unique failure dates
today = datetime.now().date().isoformat()
if today not in self.cache[ticker].get("fail_dates", []):
self.cache[ticker].setdefault("fail_dates", []).append(today)
self._save_cache()
def is_likely_delisted(self, ticker, fail_threshold=5, days_threshold=14, min_unique_days=3):
"""
Conservative check: ticker must fail multiple times across multiple days.
Args:
fail_threshold: Minimum number of total failures (default: 5)
days_threshold: Must have failed within this many days (default: 14)
min_unique_days: Must have failed on at least this many different days (default: 3)
Returns:
bool: True if ticker is likely delisted
"""
ticker = ticker.upper()
if ticker not in self.cache:
return False
data = self.cache[ticker]
last_failed = datetime.fromisoformat(data["last_failed"])
days_since = (datetime.now() - last_failed).days
# Count unique failure days
unique_fail_days = len(set(data.get("fail_dates", [])))
# Conservative criteria:
# - Must have failed at least 5 times
# - Must have failed on at least 3 different days (not just repeated same-day attempts)
# - Last failure within 14 days (don't cache stale data)
return (
data["fail_count"] >= fail_threshold
and unique_fail_days >= min_unique_days
and days_since <= days_threshold
)
def get_failure_summary(self, ticker):
"""Get detailed failure info for manual review."""
ticker = ticker.upper()
if ticker not in self.cache:
return None
data = self.cache[ticker]
return {
"ticker": ticker,
"fail_count": data["fail_count"],
"unique_days": len(set(data.get("fail_dates", []))),
"first_failed": data["first_failed"],
"last_failed": data["last_failed"],
"reason": data["reason"],
"is_likely_delisted": self.is_likely_delisted(ticker),
}
def _save_cache(self):
self.cache_file.parent.mkdir(parents=True, exist_ok=True)
with open(self.cache_file, "w") as f:
json.dump(self.cache, f, indent=2)
def export_review_list(self, output_file="data/delisted_review.txt"):
"""Export tickers that need manual review to add to DELISTED_TICKERS."""
likely_delisted = [
ticker for ticker in self.cache.keys() if self.is_likely_delisted(ticker)
]
if not likely_delisted:
return
with open(output_file, "w") as f:
f.write(
"# Tickers that have failed consistently (review before adding to DELISTED_TICKERS)\n\n"
)
for ticker in sorted(likely_delisted):
summary = self.get_failure_summary(ticker)
f.write(
f"{ticker:8s} - Failed {summary['fail_count']:2d} times across {summary['unique_days']} days - {summary['reason']}\n"
)
logger.info(f"📝 Review list exported to: {output_file}")

0
tradingagents/dataflows/discovery/__init__.py Normal file
View File

598
tradingagents/dataflows/discovery/analytics.py Normal file
View File

@ -0,0 +1,598 @@
import glob
import json
import os
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
class DiscoveryAnalytics:
"""
Handles performance tracking, statistics, and result saving for the Discovery Graph.
"""
def __init__(self, data_dir: str = "data"):
self.data_dir = Path(data_dir)
self.recommendations_dir = self.data_dir / "recommendations"
self.recommendations_dir.mkdir(parents=True, exist_ok=True)
def _load_existing_database(self) -> Dict[str, Dict]:
"""Load existing performance database keyed by (ticker, discovery_date).
Returns a dict mapping "TICKER|DATE" -> rec dict, preserving accumulated
return data (return_1d, return_7d, etc.) across runs.
"""
db_path = self.recommendations_dir / "performance_database.json"
if not db_path.exists():
return {}
try:
with open(db_path, "r") as f:
data = json.load(f)
except Exception as e:
logger.warning(f"Error loading performance database: {e}")
return {}
existing = {}
by_date = data.get("recommendations_by_date", {})
for recs in by_date.values():
if isinstance(recs, list):
for rec in recs:
key = f"{rec.get('ticker')}|{rec.get('discovery_date')}"
existing[key] = rec
return existing
def _load_raw_recommendations(self) -> List[Dict]:
"""Load recommendations from raw date files."""
all_recs = []
pattern = str(self.recommendations_dir / "*.json")
for filepath in glob.glob(pattern):
if "performance_database" in filepath or "statistics" in filepath:
continue
try:
with open(filepath, "r") as f:
data = json.load(f)
recs = data.get("recommendations", [])
for rec in recs:
rec["discovery_date"] = data.get(
"date", os.path.basename(filepath).replace(".json", "")
)
all_recs.append(rec)
except Exception as e:
logger.warning(f"Error loading {filepath}: {e}")
return all_recs
def update_performance_tracking(self):
"""Update performance metrics for all recommendations.
Loads accumulated data from performance_database.json first, merges in
any new recs from raw date files, then updates prices for open positions.
This preserves return_1d/return_7d/return_30d across runs.
"""
logger.info("📊 Updating recommendation performance tracking...")
if not self.recommendations_dir.exists():
logger.info("No historical recommendations to track yet.")
return
# Step 1: Load existing database (preserves accumulated return data)
existing = self._load_existing_database()
logger.info(f"Loaded {len(existing)} existing records from performance database")
# Step 2: Load raw recommendation files and merge new ones
raw_recs = self._load_raw_recommendations()
new_count = 0
for rec in raw_recs:
key = f"{rec.get('ticker')}|{rec.get('discovery_date')}"
if key not in existing:
existing[key] = rec
new_count += 1
if not existing:
logger.info("No recommendations found to track.")
return
if new_count > 0:
logger.info(f"Added {new_count} new recommendations")
all_recs = list(existing.values())
open_recs = [r for r in all_recs if r.get("status") != "closed"]
logger.info(f"Tracking {len(open_recs)} open positions (out of {len(all_recs)} total)...")
# Step 3: Update prices for open positions
today = datetime.now().strftime("%Y-%m-%d")
updated_count = 0
for rec in all_recs:
ticker = rec.get("ticker")
discovery_date = rec.get("discovery_date")
entry_price = rec.get("entry_price")
if rec.get("status") == "closed" or not all([ticker, discovery_date, entry_price]):
continue
try:
from tradingagents.dataflows.y_finance import get_stock_price
current_price = get_stock_price(ticker, curr_date=today)
if current_price is None:
continue
rec_date = datetime.strptime(discovery_date, "%Y-%m-%d")
days_held = (datetime.now() - rec_date).days
return_pct = ((current_price - entry_price) / entry_price) * 100
rec["current_price"] = current_price
rec["return_pct"] = round(return_pct, 2)
rec["days_held"] = days_held
rec["last_updated"] = today
# Capture milestone returns (only once, at the first eligible run)
if days_held >= 1 and "return_1d" not in rec:
rec["return_1d"] = round(return_pct, 2)
rec["win_1d"] = return_pct > 0
if days_held >= 7 and "return_7d" not in rec:
rec["return_7d"] = round(return_pct, 2)
rec["win_7d"] = return_pct > 0
if days_held >= 30 and "return_30d" not in rec:
rec["return_30d"] = round(return_pct, 2)
rec["win_30d"] = return_pct > 0
rec["status"] = "closed"
updated_count += 1
except Exception:
pass
# Step 4: Always save — even if no price updates, the merge may have added new recs
if updated_count > 0 or new_count > 0:
logger.info(f"Updated {updated_count} positions, {new_count} new recs")
self._save_performance_db(all_recs)
else:
logger.info("No updates needed")
def _save_performance_db(self, all_recs: List[Dict]):
"""Save the aggregated performance database and recalculate stats."""
# Save updated database
by_date = {}
for rec in all_recs:
date = rec.get("discovery_date", "unknown")
if date not in by_date:
by_date[date] = []
by_date[date].append(rec)
db_path = self.recommendations_dir / "performance_database.json"
with open(db_path, "w") as f:
json.dump(
{
"last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"total_recommendations": len(all_recs),
"recommendations_by_date": by_date,
},
f,
indent=2,
)
# Calculate and save statistics
stats = self.calculate_statistics(all_recs)
stats_path = self.recommendations_dir / "statistics.json"
with open(stats_path, "w") as f:
json.dump(stats, f, indent=2)
logger.info("💾 Updated performance database and statistics")
@staticmethod
def _normalize_strategy(name: str) -> str:
"""Normalize strategy names to snake_case canonical form.
Merges duplicates like 'Momentum' / 'momentum', 'Insider Play' / 'insider_buying'.
"""
import re
if not name:
return "unknown"
# Lowercase and replace separators with underscore
normalized = name.strip().lower()
normalized = re.sub(r"[\s/]+", "_", normalized)
# Collapse multiple underscores
normalized = re.sub(r"_+", "_", normalized).strip("_")
# Map known aliases to canonical names
aliases = {
"insider_play": "insider_buying",
"earnings_play": "earnings_calendar",
"contrarian_value": "contrarian_value",
"news_catalyst": "news_catalyst",
"volume_accumulation": "volume_accumulation",
"momentum_hype": "momentum",
"momentum_hype_short_squeeze": "short_squeeze",
}
return aliases.get(normalized, normalized)
def calculate_statistics(self, recommendations: list) -> dict:
"""Calculate aggregate statistics from historical performance."""
stats = {
"total_recommendations": len(recommendations),
"by_strategy": {},
"overall_1d": {"count": 0, "wins": 0, "avg_return": 0},
"overall_7d": {"count": 0, "wins": 0, "avg_return": 0},
"overall_30d": {"count": 0, "wins": 0, "avg_return": 0},
}
def _get_strategy_bucket(strategy_name):
if strategy_name not in stats["by_strategy"]:
stats["by_strategy"][strategy_name] = {
"count": 0,
"wins_1d": 0,
"losses_1d": 0,
"wins_7d": 0,
"losses_7d": 0,
"wins_30d": 0,
"losses_30d": 0,
"avg_return_1d": 0,
"avg_return_7d": 0,
"avg_return_30d": 0,
}
return stats["by_strategy"][strategy_name]
# Calculate by strategy
for rec in recommendations:
strategy = self._normalize_strategy(rec.get("strategy_match", "unknown"))
bucket = _get_strategy_bucket(strategy)
bucket["count"] += 1
# 1-day stats
if "return_1d" in rec:
stats["overall_1d"]["count"] += 1
bucket["avg_return_1d"] += rec["return_1d"]
if rec.get("win_1d"):
stats["overall_1d"]["wins"] += 1
bucket["wins_1d"] += 1
else:
bucket["losses_1d"] += 1
stats["overall_1d"]["avg_return"] += rec["return_1d"]
# 7-day stats
if "return_7d" in rec:
stats["overall_7d"]["count"] += 1
bucket["avg_return_7d"] += rec["return_7d"]
if rec.get("win_7d"):
stats["overall_7d"]["wins"] += 1
bucket["wins_7d"] += 1
else:
bucket["losses_7d"] += 1
stats["overall_7d"]["avg_return"] += rec["return_7d"]
# 30-day stats
if "return_30d" in rec:
stats["overall_30d"]["count"] += 1
bucket["avg_return_30d"] += rec["return_30d"]
if rec.get("win_30d"):
stats["overall_30d"]["wins"] += 1
bucket["wins_30d"] += 1
else:
bucket["losses_30d"] += 1
stats["overall_30d"]["avg_return"] += rec["return_30d"]
# Calculate overall averages and win rates
self._calculate_metric_averages(stats["overall_1d"])
self._calculate_metric_averages(stats["overall_7d"])
self._calculate_metric_averages(stats["overall_30d"])
# Calculate per-strategy win rates and avg returns
for strategy, data in stats["by_strategy"].items():
total_1d = data["wins_1d"] + data["losses_1d"]
total_7d = data["wins_7d"] + data["losses_7d"]
total_30d = data["wins_30d"] + data["losses_30d"]
if total_1d > 0:
data["win_rate_1d"] = round((data["wins_1d"] / total_1d) * 100, 1)
data["avg_return_1d"] = round(data["avg_return_1d"] / total_1d, 2)
if total_7d > 0:
data["win_rate_7d"] = round((data["wins_7d"] / total_7d) * 100, 1)
data["avg_return_7d"] = round(data["avg_return_7d"] / total_7d, 2)
if total_30d > 0:
data["win_rate_30d"] = round((data["wins_30d"] / total_30d) * 100, 1)
data["avg_return_30d"] = round(data["avg_return_30d"] / total_30d, 2)
return stats
def _calculate_metric_averages(self, metric_dict):
if metric_dict["count"] > 0:
metric_dict["win_rate"] = round((metric_dict["wins"] / metric_dict["count"]) * 100, 1)
metric_dict["avg_return"] = round(metric_dict["avg_return"] / metric_dict["count"], 2)
def load_historical_stats(self) -> dict:
"""Load historical performance statistics."""
stats_file = self.recommendations_dir / "statistics.json"
if not stats_file.exists():
return {
"available": False,
"message": "No historical data yet - this will improve over time as we track performance",
}
try:
with open(stats_file, "r") as f:
stats = json.load(f)
# Format insights
insights = {
"available": True,
"total_tracked": stats.get("total_recommendations", 0),
"overall_1d_win_rate": stats.get("overall_1d", {}).get("win_rate", 0),
"overall_7d_win_rate": stats.get("overall_7d", {}).get("win_rate", 0),
"overall_30d_win_rate": stats.get("overall_30d", {}).get("win_rate", 0),
"by_strategy": stats.get("by_strategy", {}),
"summary": self.format_stats_summary(stats),
}
return insights
except Exception as e:
logger.warning(f"Could not load historical stats: {e}")
return {"available": False, "message": "Error loading historical data"}
def format_stats_summary(self, stats: dict) -> str:
"""Format statistics into a concise summary."""
lines = []
overall_1d = stats.get("overall_1d", {})
overall_7d = stats.get("overall_7d", {})
overall_30d = stats.get("overall_30d", {})
if overall_1d.get("count", 0) > 0:
lines.append(
f"Historical 1-day win rate: {overall_1d.get('win_rate', 0)}% ({overall_1d.get('count')} tracked)"
)
if overall_7d.get("count", 0) > 0:
lines.append(
f"Historical 7-day win rate: {overall_7d.get('win_rate', 0)}% ({overall_7d.get('count')} tracked)"
)
if overall_30d.get("count", 0) > 0:
lines.append(
f"Historical 30-day win rate: {overall_30d.get('win_rate', 0)}% ({overall_30d.get('count')} tracked)"
)
# Top performing strategies
by_strategy = stats.get("by_strategy", {})
if by_strategy:
lines.append("\nBest performing strategies (7-day):")
sorted_strats = sorted(
[(k, v) for k, v in by_strategy.items() if v.get("win_rate_7d")],
key=lambda x: x[1].get("win_rate_7d", 0),
reverse=True,
)[:3]
for strategy, data in sorted_strats:
wr = data.get("win_rate_7d", 0)
count = data.get("wins_7d", 0) + data.get("losses_7d", 0)
lines.append(f" - {strategy}: {wr}% win rate ({count} samples)")
return "\n".join(lines) if lines else "No historical data available yet"
def save_recommendations(self, rankings: list, trade_date: str, llm_provider: str):
"""Save recommendations for tracking."""
from tradingagents.dataflows.y_finance import get_stock_price
# Get current prices for entry tracking
enriched_rankings = []
for rank in rankings:
ticker = rank.get("ticker")
# Get current price as entry price
try:
entry_price = get_stock_price(ticker, curr_date=trade_date)
except Exception as e:
logger.warning(f"Could not get entry price for {ticker}: {e}")
entry_price = None
enriched_rankings.append(
{
"ticker": ticker,
"rank": rank.get("rank"),
"strategy_match": rank.get("strategy_match"),
"final_score": rank.get("final_score"),
"confidence": rank.get("confidence"),
"reason": rank.get("reason"),
"entry_price": entry_price,
"discovery_date": trade_date,
"status": "open", # open or closed
}
)
# Save to dated file
output_file = self.recommendations_dir / f"{trade_date}.json"
with open(output_file, "w") as f:
json.dump(
{
"date": trade_date,
"llm_provider": llm_provider,
"recommendations": enriched_rankings,
},
f,
indent=2,
)
logger.info(
f" 📊 Saved {len(enriched_rankings)} recommendations for tracking: {output_file}"
)
def save_discovery_results(self, state: dict, trade_date: str, config: Dict[str, Any]):
"""Save full discovery results and tool logs."""
run_dir = config.get("discovery_run_dir")
if run_dir:
results_dir = Path(run_dir)
else:
run_timestamp = datetime.now().strftime("%H_%M_%S")
results_dir = (
Path(config.get("results_dir", "./results"))
/ "discovery"
/ trade_date
/ f"run_{run_timestamp}"
)
results_dir.mkdir(parents=True, exist_ok=True)
# Save main results as markdown
try:
with open(results_dir / "discovery_results.md", "w") as f:
f.write(f"# Discovery Analysis - {trade_date}\n\n")
f.write(f"**LLM Provider**: {config.get('llm_provider', 'unknown').upper()}\n")
f.write(
f"**Models**: Shallow={config.get('quick_think_llm', 'N/A')}, Deep={config.get('deep_think_llm', 'N/A')}\n\n"
)
f.write("## Top Investment Opportunities\n\n")
final_ranking = state.get("final_ranking", "")
if final_ranking:
self._write_ranking_md(f, final_ranking)
else:
f.write("*No recommendations generated.*\n\n")
# Format candidates analyzed section
f.write("\n## All Candidates Analyzed\n\n")
opportunities = state.get("opportunities", [])
if opportunities:
f.write(f"Total candidates analyzed: {len(opportunities)}\n\n")
for opp in opportunities:
ticker = opp.get("ticker", "UNKNOWN")
strategy = opp.get("strategy", "N/A")
f.write(f"- **{ticker}** ({strategy})\n")
except Exception as e:
logger.error(f"Error saving results: {e}")
# Save as JSON
try:
with open(results_dir / "discovery_result.json", "w") as f:
json_state = {
"trade_date": trade_date,
"tickers": state.get("tickers", []),
"filtered_tickers": state.get("filtered_tickers", []),
"final_ranking": state.get("final_ranking", ""),
"status": state.get("status", ""),
}
json.dump(json_state, f, indent=2)
except Exception as e:
logger.error(f"Error saving JSON: {e}")
# Save tool logs
tool_logs = state.get("tool_logs", [])
if tool_logs:
tool_log_max_chars = (
config.get("discovery", {}).get("tool_log_max_chars", 10_000) if config else 10_000
)
self._save_tool_logs(results_dir, tool_logs, trade_date, tool_log_max_chars)
logger.info(f" Results saved to: {results_dir}")
def _write_ranking_md(self, f, final_ranking):
try:
# Handle both string and dict/list formats
if isinstance(final_ranking, str):
rankings = json.loads(final_ranking)
else:
rankings = final_ranking
# Handle both direct list and dict with 'rankings' key
if isinstance(rankings, dict):
rankings = rankings.get("rankings", [])
for rank in rankings:
ticker = rank.get("ticker", "UNKNOWN")
company_name = rank.get("company_name", ticker)
current_price = rank.get("current_price")
description = rank.get("description", "")
strategy = rank.get("strategy_match", "N/A")
final_score = rank.get("final_score", 0)
confidence = rank.get("confidence", 0)
reason = rank.get("reason", "")
rank_num = rank.get("rank", "?")
# Format price
price_str = f"${current_price:.2f}" if current_price else "N/A"
# Write formatted recommendation
f.write(f"### #{rank_num}: {ticker}\n\n")
f.write(f"**Company:** {company_name}\n\n")
f.write(f"**Current Price:** {price_str}\n\n")
f.write(f"**Strategy:** {strategy}\n\n")
f.write(f"**Score:** {final_score} | **Confidence:** {confidence}/10\n\n")
if description:
f.write("**Description:**\n\n")
f.write(f"> {description}\n\n")
f.write("**Investment Thesis:**\n\n")
# Wrap long text nicely
wrapped_reason = reason.replace(". ", ".\n\n")
f.write(f"{wrapped_reason}\n\n")
f.write("---\n\n")
except (json.JSONDecodeError, TypeError, AttributeError) as e:
f.write(f"⚠️ Error formatting rankings: {e}\n\n")
f.write("```json\n")
f.write(str(final_ranking))
f.write("\n```\n\n")
def _save_tool_logs(
self, results_dir: Path, tool_logs: list, trade_date: str, md_max_chars: int
):
try:
with open(results_dir / "tool_execution_logs.json", "w") as f:
json.dump(tool_logs, f, indent=2)
with open(results_dir / "tool_execution_logs.md", "w") as f:
f.write(f"# Tool Execution Logs - {trade_date}\n\n")
for i, log in enumerate(tool_logs, 1):
step = log.get("step", "Unknown step")
log_type = log.get("type", "tool")
f.write(f"## {i}. {step}\n\n")
f.write(f"- **Type:** `{log_type}`\n")
f.write(f"- **Node:** {log.get('node', '')}\n")
f.write(f"- **Timestamp:** {log.get('timestamp', '')}\n")
if log.get("context"):
f.write(f"- **Context:** {log['context']}\n")
if log.get("error"):
f.write(f"- **Error:** {log['error']}\n")
if log_type == "llm":
f.write(f"- **Model:** `{log.get('model', 'unknown')}`\n")
f.write(f"- **Prompt Length:** {log.get('prompt_length', 0)} chars\n")
f.write(f"- **Output Length:** {log.get('output_length', 0)} chars\n\n")
prompt = log.get("prompt", "")
output = log.get("output", "")
if md_max_chars and len(prompt) > md_max_chars:
prompt = prompt[:md_max_chars] + "... [truncated]"
if md_max_chars and len(output) > md_max_chars:
output = output[:md_max_chars] + "... [truncated]"
f.write("### Prompt\n")
f.write(f"```\n{prompt}\n```\n\n")
f.write("### Output\n")
f.write(f"```\n{output}\n```\n\n")
else:
f.write(f"- **Tool:** `{log.get('tool', '')}`\n")
f.write(f"- **Parameters:** `{log.get('parameters', {})}`\n")
f.write(f"- **Output Length:** {log.get('output_length', 0)} chars\n\n")
output = log.get("output", "")
if md_max_chars and len(output) > md_max_chars:
output = output[:md_max_chars] + "... [truncated]"
f.write(f"### Output\n```\n{output}\n```\n\n")
f.write("---\n\n")
except Exception as e:
logger.error(f"Error saving tool logs: {e}")

76
tradingagents/dataflows/discovery/candidate.py Normal file
View File

@ -0,0 +1,76 @@
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Any, Dict, List
@dataclass
class Candidate:
"""Lightweight candidate wrapper for discovery flow."""
ticker: str
source: str = ""
priority: str = "unknown"
context: str = ""
allow_invalid: bool = False
all_sources: List[str] = field(default_factory=list)
context_details: List[str] = field(default_factory=list)
extras: Dict[str, Any] = field(default_factory=dict)
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "Candidate":
known_keys = {
"ticker",
"source",
"priority",
"context",
"allow_invalid",
"all_sources",
"context_details",
"sources",
"contexts",
}
extras = {k: v for k, v in data.items() if k not in known_keys}
candidate = cls(
ticker=(data.get("ticker") or "").upper().strip(),
source=data.get("source", "") or "",
priority=data.get("priority", "unknown") or "unknown",
context=data.get("context", "") or "",
allow_invalid=bool(data.get("allow_invalid", False)),
all_sources=list(data.get("all_sources") or data.get("sources") or []),
context_details=list(data.get("context_details") or data.get("contexts") or []),
extras=extras,
)
candidate.normalize()
return candidate
def normalize(self) -> None:
"""Ensure sources/context lists are populated and deduped."""
if not self.all_sources and self.source:
self.all_sources = [self.source]
if not self.context_details and self.context:
self.context_details = [self.context]
self.all_sources = list(dict.fromkeys([s for s in self.all_sources if s]))
self.context_details = list(dict.fromkeys([c for c in self.context_details if c]))
if not self.source and self.all_sources:
self.source = self.all_sources[0]
if not self.context and self.context_details:
self.context = self.context_details[0]
def to_dict(self) -> Dict[str, Any]:
data = dict(self.extras)
data.update(
{
"ticker": self.ticker,
"source": self.source,
"priority": self.priority,
"context": self.context,
"allow_invalid": self.allow_invalid,
"all_sources": self.all_sources,
"context_details": self.context_details,
}
)
return data

178
tradingagents/dataflows/discovery/common_utils.py Normal file
View File

@ -0,0 +1,178 @@
"""Common utilities for discovery scanners."""
import re
from typing import List, Optional, Set
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def get_common_stopwords() -> Set[str]:
"""Get common words that look like tickers but aren't.
Returns:
Set of uppercase words to filter out from ticker extraction
"""
return {
# Common words
"THE",
"AND",
"FOR",
"ARE",
"BUT",
"NOT",
"YOU",
"ALL",
"CAN",
"HER",
"WAS",
"ONE",
"OUR",
"OUT",
"DAY",
"WHO",
"HAS",
"HAD",
"NEW",
"NOW",
"GET",
"GOT",
"PUT",
"SET",
"RUN",
"TOP",
"BIG",
# Financial terms
"CEO",
"CFO",
"CTO",
"COO",
"USD",
"USA",
"SEC",
"IPO",
"ETF",
"NYSE",
"NASDAQ",
"WSB",
"DD",
"YOLO",
"FD",
"ATH",
"ATL",
"GDP",
"STOCK",
"STOCKS",
"MARKET",
"NEWS",
"PRICE",
"TRADE",
"SALES",
# Time
"JAN",
"FEB",
"MAR",
"APR",
"MAY",
"JUN",
"JUL",
"AUG",
"SEP",
"OCT",
"NOV",
"DEC",
"MON",
"TUE",
"WED",
"THU",
"FRI",
"SAT",
"SUN",
}
def extract_tickers_from_text(
text: str, stop_words: Optional[Set[str]] = None, max_text_length: int = 100_000
) -> List[str]:
"""Extract valid ticker symbols from text.
Uses regex patterns to find potential tickers ($TICKER or standalone TICKER),
filters out common stopwords, and returns deduplicated list.
Args:
text: Text to extract tickers from
stop_words: Custom stopwords to filter (uses defaults if None)
max_text_length: Maximum text length to process (prevents ReDoS)
Returns:
List of unique ticker symbols found in text
Example:
>>> extract_tickers_from_text("I like $AAPL and MSFT stocks")
['AAPL', 'MSFT']
"""
# Truncate oversized text to prevent ReDoS
if len(text) > max_text_length:
logger.warning(f"Truncating oversized text from {len(text)} to {max_text_length} chars")
text = text[:max_text_length]
# Match: $TICKER or standalone TICKER (2-5 uppercase letters)
ticker_pattern = r"\b([A-Z]{2,5})\b|\$([A-Z]{2,5})"
matches = re.findall(ticker_pattern, text)
# Flatten tuples and deduplicate
tickers = list(set([t[0] or t[1] for t in matches if t[0] or t[1]]))
# Filter stopwords
stop_words = stop_words or get_common_stopwords()
filtered_tickers = [t for t in tickers if t not in stop_words]
return filtered_tickers
def validate_ticker_format(ticker: str) -> bool:
"""Validate ticker symbol format.
Args:
ticker: Ticker symbol to validate
Returns:
True if ticker matches expected format (2-5 uppercase letters)
"""
if not ticker or not isinstance(ticker, str):
return False
return bool(re.match(r"^[A-Z]{2,5}$", ticker.strip().upper()))
def validate_candidate_structure(candidate: dict) -> bool:
"""Validate candidate dictionary has required keys.
Args:
candidate: Candidate dictionary to validate
Returns:
True if candidate has all required keys with valid types
"""
required_keys = {"ticker", "source", "context", "priority"}
if not isinstance(candidate, dict):
return False
if not required_keys.issubset(candidate.keys()):
missing = required_keys - set(candidate.keys())
logger.warning(f"Candidate missing required keys: {missing}")
return False
# Validate ticker format
if not validate_ticker_format(candidate.get("ticker", "")):
logger.warning(f"Invalid ticker format: {candidate.get('ticker')}")
return False
# Validate priority is string
if not isinstance(candidate.get("priority"), str):
logger.warning(f"Invalid priority type: {type(candidate.get('priority'))}")
return False
return True

204
tradingagents/dataflows/discovery/discovery_config.py Normal file
View File

@ -0,0 +1,204 @@
"""Typed discovery configuration — single source of truth for all discovery consumers."""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Any, Dict, List
@dataclass
class FilterConfig:
"""Filter-stage settings (from discovery.filters.*)."""
min_average_volume: int = 500_000
volume_lookback_days: int = 10
filter_same_day_movers: bool = True
intraday_movement_threshold: float = 10.0
filter_recent_movers: bool = True
recent_movement_lookback_days: int = 7
recent_movement_threshold: float = 10.0
recent_mover_action: str = "filter"
# Volume / compression detection
volume_cache_key: str = "default"
min_market_cap: int = 0
compression_atr_pct_max: float = 2.0
compression_bb_width_max: float = 6.0
compression_min_volume_ratio: float = 1.3
@dataclass
class EnrichmentConfig:
"""Enrichment-stage settings (from discovery.enrichment.*)."""
batch_news_vendor: str = "google"
batch_news_batch_size: int = 150
news_lookback_days: float = 0.5
context_max_snippets: int = 2
context_snippet_max_chars: int = 140
earnings_lookforward_days: int = 30
@dataclass
class RankerConfig:
"""Ranker settings (from discovery root level)."""
max_candidates_to_analyze: int = 200
analyze_all_candidates: bool = False
final_recommendations: int = 15
truncate_ranking_context: bool = False
max_news_chars: int = 500
max_insider_chars: int = 300
max_recommendations_chars: int = 300
@dataclass
class ChartConfig:
"""Console price chart settings (from discovery root level)."""
enabled: bool = True
library: str = "plotille"
windows: List[str] = field(default_factory=lambda: ["1d", "7d", "1m", "6m", "1y"])
lookback_days: int = 30
width: int = 60
height: int = 12
max_tickers: int = 10
show_movement_stats: bool = True
@dataclass
class LoggingConfig:
"""Tool execution logging settings (from discovery root level)."""
log_tool_calls: bool = True
log_tool_calls_console: bool = False
log_prompts_console: bool = False # Show LLM prompts in console (always saved to log file)
tool_log_max_chars: int = 10_000
tool_log_exclude: List[str] = field(default_factory=lambda: ["validate_ticker"])
@dataclass
class DiscoveryConfig:
"""
Consolidated discovery configuration.
All defaults match ``default_config.py``. Consumers should create an
instance via ``DiscoveryConfig.from_config(raw_config)`` rather than
reaching into the raw dict themselves.
"""
# Nested configs
filters: FilterConfig = field(default_factory=FilterConfig)
enrichment: EnrichmentConfig = field(default_factory=EnrichmentConfig)
ranker: RankerConfig = field(default_factory=RankerConfig)
charts: ChartConfig = field(default_factory=ChartConfig)
logging: LoggingConfig = field(default_factory=LoggingConfig)
# Flat settings at discovery root level
deep_dive_max_workers: int = 1
discovery_mode: str = "hybrid"
@classmethod
def from_config(cls, raw_config: Dict[str, Any]) -> DiscoveryConfig:
"""Build a ``DiscoveryConfig`` from the raw application config dict."""
disc = raw_config.get("discovery", {})
# Default instances — used to read fallback values for fields that
# use default_factory (which aren't available as class-level attrs).
_fd = FilterConfig()
_ed = EnrichmentConfig()
_rd = RankerConfig()
_cd = ChartConfig()
_ld = LoggingConfig()
# Filters — nested under "filters" key, fallback to root for old configs
f = disc.get("filters", disc)
filters = FilterConfig(
min_average_volume=f.get("min_average_volume", _fd.min_average_volume),
volume_lookback_days=f.get("volume_lookback_days", _fd.volume_lookback_days),
filter_same_day_movers=f.get("filter_same_day_movers", _fd.filter_same_day_movers),
intraday_movement_threshold=f.get(
"intraday_movement_threshold", _fd.intraday_movement_threshold
),
filter_recent_movers=f.get("filter_recent_movers", _fd.filter_recent_movers),
recent_movement_lookback_days=f.get(
"recent_movement_lookback_days", _fd.recent_movement_lookback_days
),
recent_movement_threshold=f.get(
"recent_movement_threshold", _fd.recent_movement_threshold
),
recent_mover_action=f.get("recent_mover_action", _fd.recent_mover_action),
volume_cache_key=f.get("volume_cache_key", _fd.volume_cache_key),
min_market_cap=f.get("min_market_cap", _fd.min_market_cap),
compression_atr_pct_max=f.get("compression_atr_pct_max", _fd.compression_atr_pct_max),
compression_bb_width_max=f.get(
"compression_bb_width_max", _fd.compression_bb_width_max
),
compression_min_volume_ratio=f.get(
"compression_min_volume_ratio", _fd.compression_min_volume_ratio
),
)
# Enrichment — nested under "enrichment" key, fallback to root
e = disc.get("enrichment", disc)
enrichment = EnrichmentConfig(
batch_news_vendor=e.get("batch_news_vendor", _ed.batch_news_vendor),
batch_news_batch_size=e.get("batch_news_batch_size", _ed.batch_news_batch_size),
news_lookback_days=e.get("news_lookback_days", _ed.news_lookback_days),
context_max_snippets=e.get("context_max_snippets", _ed.context_max_snippets),
context_snippet_max_chars=e.get(
"context_snippet_max_chars", _ed.context_snippet_max_chars
),
earnings_lookforward_days=e.get(
"earnings_lookforward_days", _ed.earnings_lookforward_days
),
)
# Ranker
ranker = RankerConfig(
max_candidates_to_analyze=disc.get(
"max_candidates_to_analyze", _rd.max_candidates_to_analyze
),
analyze_all_candidates=disc.get("analyze_all_candidates", _rd.analyze_all_candidates),
final_recommendations=disc.get("final_recommendations", _rd.final_recommendations),
truncate_ranking_context=disc.get(
"truncate_ranking_context", _rd.truncate_ranking_context
),
max_news_chars=disc.get("max_news_chars", _rd.max_news_chars),
max_insider_chars=disc.get("max_insider_chars", _rd.max_insider_chars),
max_recommendations_chars=disc.get(
"max_recommendations_chars", _rd.max_recommendations_chars
),
)
# Charts — keys prefixed with "price_chart_" at discovery root level
charts = ChartConfig(
enabled=disc.get("console_price_charts", _cd.enabled),
library=disc.get("price_chart_library", _cd.library),
windows=disc.get("price_chart_windows", _cd.windows),
lookback_days=disc.get("price_chart_lookback_days", _cd.lookback_days),
width=disc.get("price_chart_width", _cd.width),
height=disc.get("price_chart_height", _cd.height),
max_tickers=disc.get("price_chart_max_tickers", _cd.max_tickers),
show_movement_stats=disc.get(
"price_chart_show_movement_stats", _cd.show_movement_stats
),
)
# Logging
logging_cfg = LoggingConfig(
log_tool_calls=disc.get("log_tool_calls", _ld.log_tool_calls),
log_tool_calls_console=disc.get("log_tool_calls_console", _ld.log_tool_calls_console),
log_prompts_console=disc.get("log_prompts_console", _ld.log_prompts_console),
tool_log_max_chars=disc.get("tool_log_max_chars", _ld.tool_log_max_chars),
tool_log_exclude=disc.get("tool_log_exclude", _ld.tool_log_exclude),
)
return cls(
filters=filters,
enrichment=enrichment,
ranker=ranker,
charts=charts,
logging=logging_cfg,
deep_dive_max_workers=disc.get("deep_dive_max_workers", 1),
discovery_mode=disc.get("discovery_mode", "hybrid"),
)

910
tradingagents/dataflows/discovery/filter.py Normal file
View File

@ -0,0 +1,910 @@
import json
import re
from datetime import datetime, timedelta
from typing import Any, Callable, Dict, List
import pandas as pd
from tradingagents.dataflows.discovery.candidate import Candidate
from tradingagents.dataflows.discovery.discovery_config import DiscoveryConfig
from tradingagents.dataflows.discovery.utils import (
PRIORITY_ORDER,
Strategy,
is_valid_ticker,
resolve_trade_date,
)
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def _parse_market_cap_to_billions(value: Any) -> Any:
"""Parse market cap into billions of USD when possible."""
if value is None:
return None
if isinstance(value, (int, float)):
# Assume raw dollars if large; otherwise already in billions
return round(value / 1_000_000_000, 3) if value > 1_000_000 else float(value)
if isinstance(value, str):
text = value.strip().upper().replace(",", "").replace("$", "")
if not text or text in {"N/A", "NA", "NONE"}:
return None
multipliers = {"T": 1000.0, "B": 1.0, "M": 0.001, "K": 0.000001}
suffix = text[-1]
if suffix in multipliers:
try:
return round(float(text[:-1]) * multipliers[suffix], 3)
except ValueError:
return None
# Fallback: treat as raw dollars
try:
numeric = float(text)
return round(numeric / 1_000_000_000, 3) if numeric > 1_000_000 else numeric
except ValueError:
return None
return None
def _extract_atr_pct(technical_report: str) -> Any:
"""Extract ATR % of price from technical report."""
if not technical_report:
return None
match = re.search(r"ATR:\s*\$?[\d\.]+\s*\(([\d\.]+)% of price\)", technical_report)
if match:
try:
return float(match.group(1))
except ValueError:
return None
return None
def _extract_bb_width_pct(technical_report: str) -> Any:
"""Extract Bollinger bandwidth % from technical report."""
if not technical_report:
return None
match = re.search(r"Bandwidth:\s*([\d\.]+)%", technical_report)
if match:
try:
return float(match.group(1))
except ValueError:
return None
return None
def _build_combined_context(
primary_context: str,
context_details: list,
max_snippets: int,
snippet_max_chars: int,
) -> str:
"""Combine multiple contexts into a compact summary."""
if not context_details:
return primary_context or ""
primary_context = primary_context or context_details[0]
others = [c for c in context_details if c and c != primary_context]
if not others:
return primary_context
trimmed = []
for item in others[:max_snippets]:
snippet = item.strip()
if len(snippet) > snippet_max_chars:
snippet = snippet[:snippet_max_chars].rstrip() + "..."
trimmed.append(snippet)
if not trimmed:
return primary_context
return f"{primary_context} | Other signals: " + "; ".join(trimmed)
class CandidateFilter:
"""
Handles filtering and enrichment of discovery candidates.
"""
def __init__(self, config: Dict[str, Any], tool_executor: Callable):
self.config = config
self.execute_tool = tool_executor
dc = DiscoveryConfig.from_config(config)
# Filter settings
self.filter_same_day_movers = dc.filters.filter_same_day_movers
self.intraday_movement_threshold = dc.filters.intraday_movement_threshold
self.filter_recent_movers = dc.filters.filter_recent_movers
self.recent_movement_lookback_days = dc.filters.recent_movement_lookback_days
self.recent_movement_threshold = dc.filters.recent_movement_threshold
self.recent_mover_action = dc.filters.recent_mover_action
self.min_average_volume = dc.filters.min_average_volume
self.volume_lookback_days = dc.filters.volume_lookback_days
# Filter extras (volume/compression detection)
self.volume_cache_key = dc.filters.volume_cache_key
self.min_market_cap = dc.filters.min_market_cap
self.compression_atr_pct_max = dc.filters.compression_atr_pct_max
self.compression_bb_width_max = dc.filters.compression_bb_width_max
self.compression_min_volume_ratio = dc.filters.compression_min_volume_ratio
# Enrichment settings
self.batch_news_vendor = dc.enrichment.batch_news_vendor
self.batch_news_batch_size = dc.enrichment.batch_news_batch_size
self.news_lookback_days = dc.enrichment.news_lookback_days
self.context_max_snippets = dc.enrichment.context_max_snippets
self.context_snippet_max_chars = dc.enrichment.context_snippet_max_chars
# ML predictor (loaded lazily — None if no model file exists)
self._ml_predictor = None
self._ml_predictor_loaded = False
def filter(self, state: Dict[str, Any]) -> Dict[str, Any]:
"""Filter candidates based on strategy and enrich with additional data."""
candidates = state.get("candidate_metadata", [])
if not candidates:
# Fallback if metadata missing (backward compatibility)
candidates = [{"ticker": t, "source": "unknown"} for t in state["tickers"]]
# Calculate date range for news (configurable days back from trade_date)
end_date_obj = resolve_trade_date(state)
start_date_obj = end_date_obj - timedelta(days=self.news_lookback_days)
start_date = start_date_obj.strftime("%Y-%m-%d")
end_date = end_date_obj.strftime("%Y-%m-%d")
logger.info(f"🔍 Filtering and enriching {len(candidates)} candidates...")
priority_order = self._priority_order()
candidates = self._dedupe_candidates(candidates, priority_order)
candidates = self._sort_by_priority(candidates, priority_order)
self._log_priority_breakdown(candidates)
volume_by_ticker = self._fetch_batch_volume(state, candidates)
news_by_ticker = self._fetch_batch_news(start_date, end_date, candidates)
(
filtered_candidates,
filtered_reasons,
failed_tickers,
delisted_cache,
) = self._filter_and_enrich_candidates(
state=state,
candidates=candidates,
volume_by_ticker=volume_by_ticker,
news_by_ticker=news_by_ticker,
end_date=end_date,
)
# Print consolidated filtering summary
self._print_filter_summary(candidates, filtered_candidates, filtered_reasons)
# Print consolidated list of failed tickers
if failed_tickers:
logger.warning(
f"⚠️ {len(failed_tickers)} tickers failed data fetch (possibly delisted)"
)
if len(failed_tickers) <= 10:
logger.warning(f"{', '.join(failed_tickers)}")
else:
logger.warning(
f"{', '.join(failed_tickers[:10])} ... and {len(failed_tickers)-10} more"
)
# Export review list
delisted_cache.export_review_list()
return {
"filtered_tickers": [c["ticker"] for c in filtered_candidates],
"candidate_metadata": filtered_candidates,
"status": "filtered",
}
def _priority_order(self) -> Dict[str, int]:
return dict(PRIORITY_ORDER)
def _dedupe_candidates(
self, candidates: List[Dict[str, Any]], priority_order: Dict[str, int]
) -> List[Dict[str, Any]]:
"""Deduplicate by ticker while preserving multi-source evidence."""
unique_candidates: Dict[str, Candidate] = {}
for cand in candidates:
ticker = cand.get("ticker")
if not ticker or not is_valid_ticker(ticker):
continue
candidate = Candidate.from_dict(cand)
ticker = candidate.ticker
if ticker not in unique_candidates:
unique_candidates[ticker] = candidate
continue
existing = unique_candidates[ticker]
existing_rank = priority_order.get(existing.priority, 4)
incoming_rank = priority_order.get(candidate.priority, 4)
if incoming_rank < existing_rank:
primary = candidate
secondary = existing
elif incoming_rank == existing_rank:
existing_context = existing.context
incoming_context = candidate.context
if len(incoming_context) > len(existing_context):
primary = candidate
secondary = existing
else:
primary = existing
secondary = candidate
else:
primary = existing
secondary = candidate
# Merge sources and contexts
merged_sources = list(dict.fromkeys(primary.all_sources + secondary.all_sources))
merged_contexts = list(
dict.fromkeys(primary.context_details + secondary.context_details)
)
primary.all_sources = merged_sources
primary.context_details = merged_contexts
primary.context = _build_combined_context(
primary.context,
merged_contexts,
max_snippets=self.context_max_snippets,
snippet_max_chars=self.context_snippet_max_chars,
)
if secondary.allow_invalid:
primary.allow_invalid = True
unique_candidates[ticker] = primary
# Compute confluence scores and boost priority for multi-source candidates
for candidate in unique_candidates.values():
source_count = len(candidate.all_sources)
candidate.extras["confluence_score"] = source_count
if source_count >= 3 and candidate.priority != "critical":
candidate.priority = "critical"
elif source_count >= 2 and candidate.priority in ("medium", "low", "unknown"):
candidate.priority = "high"
return [candidate.to_dict() for candidate in unique_candidates.values()]
def _sort_by_priority(
self, candidates: List[Dict[str, Any]], priority_order: Dict[str, int]
) -> List[Dict[str, Any]]:
candidates.sort(key=lambda x: priority_order.get(x.get("priority", "unknown"), 4))
return candidates
def _log_priority_breakdown(self, candidates: List[Dict[str, Any]]) -> None:
critical_priority = sum(1 for c in candidates if c.get("priority") == "critical")
high_priority = sum(1 for c in candidates if c.get("priority") == "high")
medium_priority = sum(1 for c in candidates if c.get("priority") == "medium")
low_priority = sum(1 for c in candidates if c.get("priority") == "low")
logger.info(
f"Priority breakdown: {critical_priority} critical, {high_priority} high, {medium_priority} medium, {low_priority} low"
)
def _fetch_batch_volume(
self, state: Dict[str, Any], candidates: List[Dict[str, Any]]
) -> Dict[str, Any]:
if not (self.min_average_volume and candidates):
return {}
return self._run_tool(
state=state,
step="Check average volume (batch)",
tool_name="get_average_volume_batch",
default={},
symbols=[c.get("ticker", "") for c in candidates],
lookback_days=self.volume_lookback_days,
curr_date=state.get("trade_date"),
cache_key=self.volume_cache_key,
)
def _fetch_batch_news(
self, start_date: str, end_date: str, candidates: List[Dict[str, Any]]
) -> Dict[str, Any]:
all_tickers = [c.get("ticker", "") for c in candidates if c.get("ticker")]
if not all_tickers:
return {}
try:
if self.batch_news_vendor == "google":
from tradingagents.dataflows.openai import get_batch_stock_news_google
logger.info(f"📰 Batch fetching news (Google) for {len(all_tickers)} tickers...")
news_by_ticker = self._run_call(
"batch fetching news (Google)",
get_batch_stock_news_google,
default={},
tickers=all_tickers,
start_date=start_date,
end_date=end_date,
batch_size=self.batch_news_batch_size,
)
else: # Default to OpenAI
from tradingagents.dataflows.openai import get_batch_stock_news_openai
logger.info(f"📰 Batch fetching news (OpenAI) for {len(all_tickers)} tickers...")
news_by_ticker = self._run_call(
"batch fetching news (OpenAI)",
get_batch_stock_news_openai,
default={},
tickers=all_tickers,
start_date=start_date,
end_date=end_date,
batch_size=self.batch_news_batch_size,
)
logger.info(f"✓ Batch news fetched for {len(news_by_ticker)} tickers")
return news_by_ticker
except Exception as e:
logger.warning(f"Batch news fetch failed, will skip news enrichment: {e}")
return {}
def _filter_and_enrich_candidates(
self,
state: Dict[str, Any],
candidates: List[Dict[str, Any]],
volume_by_ticker: Dict[str, Any],
news_by_ticker: Dict[str, Any],
end_date: str,
):
filtered_candidates = []
filtered_reasons = {
"volume": 0,
"intraday_moved": 0,
"recent_moved": 0,
"market_cap": 0,
"no_data": 0,
}
# Initialize delisted cache for tracking failed tickers
from tradingagents.dataflows.delisted_cache import DelistedCache
delisted_cache = DelistedCache()
failed_tickers = []
for cand in candidates:
ticker = cand["ticker"]
try:
# Same-day mover filter (check intraday movement first)
if self.filter_same_day_movers:
from tradingagents.dataflows.y_finance import check_intraday_movement
try:
intraday_check = check_intraday_movement(
ticker=ticker, movement_threshold=self.intraday_movement_threshold
)
# Skip if already moved significantly today
if intraday_check.get("already_moved"):
filtered_reasons["intraday_moved"] += 1
intraday_pct = intraday_check.get("intraday_change_pct", 0)
logger.info(
f"Filtered {ticker}: Already moved {intraday_pct:+.1f}% today (stale)"
)
continue
# Add intraday data to candidate metadata for ranking
cand["intraday_change_pct"] = intraday_check.get("intraday_change_pct", 0)
except Exception as e:
# Don't filter out if check fails, just log
logger.warning(f"Could not check intraday movement for {ticker}: {e}")
# Recent multi-day mover filter (avoid stocks that already ran)
if self.filter_recent_movers:
from tradingagents.dataflows.y_finance import check_if_price_reacted
try:
reaction = check_if_price_reacted(
ticker=ticker,
lookback_days=self.recent_movement_lookback_days,
reaction_threshold=self.recent_movement_threshold,
)
cand["recent_change_pct"] = reaction.get("price_change_pct")
cand["recent_move_status"] = reaction.get("status")
if reaction.get("status") == "lagging":
if self.recent_mover_action == "filter":
filtered_reasons["recent_moved"] += 1
change_pct = reaction.get("price_change_pct", 0)
logger.info(
f"Filtered {ticker}: Already moved {change_pct:+.1f}% in last "
f"{self.recent_movement_lookback_days} days"
)
continue
if self.recent_mover_action == "deprioritize":
cand["priority"] = "low"
existing_context = cand.get("context", "")
change_pct = reaction.get("price_change_pct", 0)
cand["context"] = (
f"{existing_context} | ⚠️ Recent move: {change_pct:+.1f}% "
f"over {self.recent_movement_lookback_days}d"
)
except Exception as e:
logger.warning(f"Could not check recent movement for {ticker}: {e}")
# Liquidity filter based on average volume
if self.min_average_volume:
volume_data = {}
if isinstance(volume_by_ticker, dict):
volume_data = volume_by_ticker.get(ticker.upper(), {})
avg_volume = None
latest_volume = None
if isinstance(volume_data, dict):
avg_volume = volume_data.get("average_volume")
latest_volume = volume_data.get("latest_volume")
elif isinstance(volume_data, (int, float)):
avg_volume = float(volume_data)
cand["average_volume"] = avg_volume
cand["latest_volume"] = latest_volume
if avg_volume and latest_volume:
cand["volume_ratio"] = latest_volume / avg_volume
if avg_volume is not None and avg_volume < self.min_average_volume:
filtered_reasons["volume"] += 1
continue
# Get Fundamentals and Price (fetch once, reuse in later stages)
try:
from tradingagents.dataflows.y_finance import get_fundamentals, get_stock_price
# Get current price
current_price = get_stock_price(ticker)
cand["current_price"] = current_price
# Track failures for delisted cache
if current_price is None:
delisted_cache.mark_failed(ticker, "no_price_data")
failed_tickers.append(ticker)
filtered_reasons["no_data"] += 1
continue
# Get fundamentals
fund_json = get_fundamentals(ticker)
if fund_json and not fund_json.startswith("Error"):
fund = json.loads(fund_json)
cand["fundamentals"] = fund
# Market cap filter (if configured)
if self.min_market_cap:
market_cap_raw = fund.get("MarketCapitalization")
market_cap_bil = _parse_market_cap_to_billions(market_cap_raw)
cand["market_cap_bil"] = market_cap_bil
if market_cap_bil is not None and market_cap_bil < self.min_market_cap:
filtered_reasons["market_cap"] += 1
continue
# Extract business description for ranker LLM context
business_description = fund.get("Description", "")
if business_description and business_description != "N/A":
cand["business_description"] = business_description
else:
# Fallback to sector/industry description
sector = fund.get("Sector", "")
industry = fund.get("Industry", "")
company_name = fund.get("Name", ticker)
if sector and industry:
cand["business_description"] = (
f"{company_name} is a {industry} company in the {sector} sector."
)
else:
cand["business_description"] = (
f"{company_name} - Business description not available."
)
# Extract short interest from fundamentals (no extra API call)
short_pct_raw = fund.get(
"ShortPercentOfFloat", fund.get("ShortPercentFloat")
)
short_interest_pct = None
if short_pct_raw and short_pct_raw != "N/A":
try:
short_interest_pct = round(float(short_pct_raw) * 100, 2)
except (ValueError, TypeError):
pass
cand["short_interest_pct"] = short_interest_pct
cand["high_short_interest"] = (
short_interest_pct is not None and short_interest_pct > 15.0
)
short_ratio_raw = fund.get("ShortRatio")
if short_ratio_raw and short_ratio_raw != "N/A":
try:
cand["short_ratio"] = float(short_ratio_raw)
except (ValueError, TypeError):
cand["short_ratio"] = None
else:
cand["short_ratio"] = None
else:
cand["fundamentals"] = {}
cand["business_description"] = (
f"{ticker} - Business description not available."
)
cand["short_interest_pct"] = None
cand["high_short_interest"] = False
cand["short_ratio"] = None
except Exception as e:
logger.warning(f"Could not fetch fundamentals for {ticker}: {e}")
delisted_cache.mark_failed(ticker, str(e))
failed_tickers.append(ticker)
cand["current_price"] = None
cand["fundamentals"] = {}
cand["business_description"] = f"{ticker} - Business description not available."
filtered_reasons["no_data"] += 1
continue
# Assign strategy based on source (prioritize leading indicators)
self._assign_strategy(cand)
# Technical Analysis Check (New)
today_str = end_date
rsi_data = self._run_tool(
state=state,
step="Get technical indicators",
tool_name="get_indicators",
default=None,
symbol=ticker,
curr_date=today_str,
)
if rsi_data:
cand["technical_indicators"] = rsi_data
# Volatility compression detection (low ATR + tight Bollinger bands)
atr_pct = _extract_atr_pct(rsi_data)
bb_width = _extract_bb_width_pct(rsi_data)
volume_ratio = cand.get("volume_ratio")
cand["atr_pct"] = atr_pct
cand["bb_width_pct"] = bb_width
has_compression = (
atr_pct is not None
and bb_width is not None
and atr_pct <= self.compression_atr_pct_max
and bb_width <= self.compression_bb_width_max
)
has_volume_uptick = (
volume_ratio is not None
and volume_ratio >= self.compression_min_volume_ratio
)
if has_compression:
cand["has_volatility_compression"] = has_volume_uptick
if has_volume_uptick:
compression_context = (
f"🧊 Volatility compression: ATR {atr_pct:.1f}%, "
f"BB width {bb_width:.1f}%, Vol ratio {volume_ratio:.2f}x"
)
else:
compression_context = (
f"🧊 Volatility compression: ATR {atr_pct:.1f}%, "
f"BB width {bb_width:.1f}%"
)
existing_context = cand.get("context", "")
cand["context"] = f"{existing_context} | {compression_context}"
if has_volume_uptick and cand.get("priority") in {"low", "medium"}:
cand["priority"] = "high"
# === Per-ticker enrichment ===
# 1. News - Use discovery news if batch news is empty/missing
batch_news = news_by_ticker.get(ticker.upper(), news_by_ticker.get(ticker, ""))
discovery_news = cand.get("news_context", [])
# Prefer batch news, but fall back to discovery news if batch is empty
if batch_news and batch_news.strip() and "No news found" not in batch_news:
cand["news"] = batch_news
elif discovery_news:
# Convert discovery news_context to list format
cand["news"] = discovery_news
else:
cand["news"] = ""
# 2. Insider Transactions
insider = self._run_tool(
state=state,
step="Get insider transactions",
tool_name="get_insider_transactions",
default="",
ticker=ticker,
)
cand["insider_transactions"] = insider or ""
# 3. Analyst Recommendations
recommendations = self._run_tool(
state=state,
step="Get recommendations",
tool_name="get_recommendation_trends",
default="",
ticker=ticker,
)
cand["recommendations"] = recommendations or ""
# 4. Options Activity with Flow Analysis
options = self._run_tool(
state=state,
step="Get options activity",
tool_name="get_options_activity",
default=None,
ticker=ticker,
num_expirations=3,
curr_date=end_date,
)
if options is None:
cand["options_activity"] = ""
cand["options_flow"] = {}
cand["has_bullish_options_flow"] = False
else:
cand["options_activity"] = options
# Analyze options flow for unusual activity signals
from tradingagents.dataflows.y_finance import analyze_options_flow
options_analysis = self._run_call(
"analyzing options flow",
analyze_options_flow,
default={},
ticker=ticker,
num_expirations=3,
)
cand["options_flow"] = options_analysis or {}
# Flag unusual bullish flow as a positive signal
if options_analysis.get("is_bullish_flow"):
cand["has_bullish_options_flow"] = True
flow_context = (
f"🎯 Unusual bullish options flow: "
f"{options_analysis['unusual_calls']} unusual calls vs "
f"{options_analysis['unusual_puts']} puts, "
f"P/C ratio: {options_analysis['pc_volume_ratio']}"
)
# Append to context
existing_context = cand.get("context", "")
cand["context"] = f"{existing_context} | {flow_context}"
elif options_analysis.get("signal") in ["very_bullish", "bullish"]:
cand["has_bullish_options_flow"] = True
else:
cand["has_bullish_options_flow"] = False
# Normalize options signal for quantitative scoring
cand["options_signal"] = cand.get("options_flow", {}).get("signal", "neutral")
# 5. Earnings Estimate Enrichment
from tradingagents.dataflows.finnhub_api import get_ticker_earnings_estimate
earnings_to = (
datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=30)
).strftime("%Y-%m-%d")
earnings_data = self._run_call(
"fetching earnings estimate",
get_ticker_earnings_estimate,
default={},
ticker=ticker,
from_date=end_date,
to_date=earnings_to,
)
if earnings_data.get("has_upcoming_earnings"):
cand["has_upcoming_earnings"] = True
cand["days_to_earnings"] = earnings_data.get("days_to_earnings")
cand["eps_estimate"] = earnings_data.get("eps_estimate")
cand["revenue_estimate"] = earnings_data.get("revenue_estimate")
cand["earnings_date"] = earnings_data.get("earnings_date")
else:
cand["has_upcoming_earnings"] = False
# Extract derived signals for quant scoring
tech_report = cand.get("technical_indicators", "")
rsi_match = re.search(
r"RSI.*?Value[:\s]*(\d+\.?\d*)", tech_report, re.IGNORECASE | re.DOTALL
)
if rsi_match:
cand["rsi_value"] = float(rsi_match.group(1))
insider_text = cand.get("insider_transactions", "")
cand["has_insider_buying"] = (
isinstance(insider_text, str) and "Purchase" in insider_text
)
# Compute quantitative pre-score
cand["quant_score"] = self._compute_quant_score(cand)
# ML win probability prediction (if model available)
ml_result = self._predict_ml(cand, ticker, end_date)
if ml_result:
cand["ml_win_probability"] = ml_result["win_prob"]
cand["ml_prediction"] = ml_result["prediction"]
cand["ml_loss_probability"] = ml_result["loss_prob"]
filtered_candidates.append(cand)
except Exception as e:
logger.error(f"Error checking {ticker}: {e}")
return filtered_candidates, filtered_reasons, failed_tickers, delisted_cache
def _print_filter_summary(
self,
candidates: List[Dict[str, Any]],
filtered_candidates: List[Dict[str, Any]],
filtered_reasons: Dict[str, int],
) -> None:
logger.info("\n 📊 Filtering Summary:")
logger.info(f" Starting candidates: {len(candidates)}")
if filtered_reasons.get("intraday_moved", 0) > 0:
logger.info(f" ❌ Same-day movers: {filtered_reasons['intraday_moved']}")
if filtered_reasons.get("recent_moved", 0) > 0:
logger.info(f" ❌ Recent movers: {filtered_reasons['recent_moved']}")
if filtered_reasons.get("volume", 0) > 0:
logger.info(f" ❌ Low volume: {filtered_reasons['volume']}")
if filtered_reasons.get("market_cap", 0) > 0:
logger.info(f" ❌ Below market cap: {filtered_reasons['market_cap']}")
if filtered_reasons.get("no_data", 0) > 0:
logger.info(f" ❌ No data available: {filtered_reasons['no_data']}")
logger.info(f" ✅ Passed filters: {len(filtered_candidates)}")
def _predict_ml(self, cand: Dict[str, Any], ticker: str, end_date: str) -> Any:
"""Run ML win probability prediction for a candidate."""
# Lazy-load predictor on first call
if not self._ml_predictor_loaded:
self._ml_predictor_loaded = True
try:
from tradingagents.ml.predictor import MLPredictor
self._ml_predictor = MLPredictor.load()
if self._ml_predictor:
logger.info("ML predictor loaded — will add win probabilities")
except Exception as e:
logger.debug(f"ML predictor not available: {e}")
if self._ml_predictor is None:
return None
try:
from tradingagents.dataflows.y_finance import download_history
from tradingagents.ml.feature_engineering import (
compute_features_single,
)
# Fetch OHLCV for feature computation (needs ~210 rows of history)
ohlcv = download_history(
ticker,
start=pd.Timestamp(end_date) - pd.DateOffset(years=2),
end=end_date,
multi_level_index=False,
progress=False,
auto_adjust=True,
)
if ohlcv.empty:
return None
ohlcv = ohlcv.reset_index()
market_cap = cand.get("market_cap_bil", 0)
market_cap_usd = market_cap * 1e9 if market_cap else None
features = compute_features_single(ohlcv, end_date, market_cap=market_cap_usd)
if features is None:
return None
return self._ml_predictor.predict(features)
except Exception as e:
logger.debug(f"ML prediction failed for {ticker}: {e}")
return None
def _compute_quant_score(self, cand: Dict[str, Any]) -> int:
"""Compute a 0-100 quantitative pre-score from hard data."""
score = 0
# Volume ratio (max +15)
vol_ratio = cand.get("volume_ratio")
if vol_ratio is not None:
if vol_ratio >= 2.0:
score += 15
elif vol_ratio >= 1.5:
score += 10
elif vol_ratio >= 1.3:
score += 5
# Confluence — per independent source, max 3 (max +30)
confluence = cand.get("confluence_score", 1)
score += min(confluence, 3) * 10
# Options flow signal (max +20)
options_signal = cand.get("options_signal", "neutral")
if options_signal == "very_bullish":
score += 20
elif options_signal == "bullish":
score += 15
# Insider buying detected (max +10)
if cand.get("has_insider_buying"):
score += 10
# Volatility compression with volume uptick (max +10)
if cand.get("has_volatility_compression"):
score += 10
# Healthy RSI momentum: 40-65 range (max +5)
rsi = cand.get("rsi_value")
if rsi is not None and 40 <= rsi <= 65:
score += 5
# Short squeeze potential: 5-20% short interest (max +5)
short_pct = cand.get("short_interest_pct")
if short_pct is not None and 5.0 <= short_pct <= 20.0:
score += 5
return min(score, 100)
def _run_tool(
self,
state: Dict[str, Any],
step: str,
tool_name: str,
default: Any = None,
**params: Any,
) -> Any:
try:
return self.execute_tool(
state,
node="filter",
step=step,
tool_name=tool_name,
**params,
)
except Exception as e:
logger.error(f"Error during {step}: {e}")
return default
def _run_call(
self,
label: str,
func: Callable,
default: Any = None,
**kwargs: Any,
) -> Any:
try:
return func(**kwargs)
except Exception as e:
logger.error(f"Error {label}: {e}")
return default
def _assign_strategy(self, cand: Dict[str, Any]):
"""Assign strategy based on source."""
source = cand.get("source", "")
strategy = Strategy.MOMENTUM.value
if source == "reddit_dd_undiscovered":
strategy = Strategy.UNDISCOVERED_DD.value # LEADING - quality research before hype
elif source == "earnings_accumulation":
strategy = Strategy.PRE_EARNINGS_ACCUMULATION.value # LEADING - highest priority
elif source == "unusual_volume":
strategy = Strategy.EARLY_ACCUMULATION.value # LEADING
elif source == "analyst_upgrade":
strategy = Strategy.ANALYST_UPGRADE.value # LEADING - institutional signal
elif source == "short_squeeze":
strategy = Strategy.SHORT_SQUEEZE.value # Event-driven - high volatility
elif source == "semantic_news_match":
strategy = Strategy.NEWS_CATALYST.value # LEADING - news-driven
elif source == "earnings_catalyst":
strategy = Strategy.EARNINGS_PLAY.value # Event-driven
elif source == "ipo_listing":
strategy = Strategy.IPO_OPPORTUNITY.value # Event-driven
elif source == "loser":
strategy = Strategy.CONTRARIAN_VALUE.value
elif source == "gainer":
strategy = Strategy.MOMENTUM_CHASE.value
elif source == "social_trending" or source == "twitter_sentiment":
strategy = Strategy.SOCIAL_HYPE.value # LAGGING
elif source == "market_mover":
strategy = Strategy.MOMENTUM_CHASE.value # LAGGING - lowest priority
cand["strategy"] = strategy

7
tradingagents/dataflows/discovery/performance/__init__.py Normal file
View File

@ -0,0 +1,7 @@
"""
Performance tracking module for positions and recommendations.
"""
from .position_tracker import PositionTracker
__all__ = ["PositionTracker"]

197
tradingagents/dataflows/discovery/performance/position_tracker.py Normal file
View File

@ -0,0 +1,197 @@
"""
Position Tracker Module
Monitors positions continuously with dynamic price history tracking.
Maintains complete price time-series and calculates real-time metrics.
"""
import json
from datetime import datetime
from pathlib import Path
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
from typing import Any, Dict, List, Optional
class PositionTracker:
"""
Dynamic position tracking system that monitors positions continuously.
Maintains complete price history and calculates real-time metrics.
"""
def __init__(self, data_dir: str = "data"):
"""
Initialize PositionTracker.
Args:
data_dir: Root directory for position storage (default: "data")
"""
self.data_dir = Path(data_dir)
self.positions_dir = self.data_dir / "positions"
self.positions_dir.mkdir(parents=True, exist_ok=True)
def create_position(self, recommendation: Dict[str, Any]) -> Dict[str, Any]:
"""
Create a new position dictionary from a recommendation.
Args:
recommendation: Recommendation dict with at minimum:
- ticker: Stock ticker
- entry_price: Entry price for the position
- recommendation_date: Date of recommendation
- scanner: Source scanner
- strategy: Strategy name
- pipeline: Pipeline identifier
- confidence: Confidence score (0-1)
- shares: Number of shares to buy
Returns:
Position dictionary with initialized structure
"""
now = datetime.utcnow()
position = {
"ticker": recommendation.get("ticker"),
"entry_price": recommendation.get("entry_price"),
"recommendation_date": recommendation.get("recommendation_date"),
"pipeline": recommendation.get("pipeline"),
"scanner": recommendation.get("scanner"),
"strategy": recommendation.get("strategy"),
"confidence": recommendation.get("confidence"),
"shares": recommendation.get("shares"),
"created_at": now.isoformat(),
"status": "open",
"price_history": [
{
"timestamp": now.isoformat(),
"price": recommendation.get("entry_price"),
"return_pct": 0.0,
"hours_held": 0.0,
"days_held": 0.0,
}
],
"metrics": {
"peak_return": 0.0,
"current_return": 0.0,
"current_price": recommendation.get("entry_price"),
"days_held": 0.0,
"status": "open",
},
}
return position
def update_position_price(
self,
position: Dict[str, Any],
new_price: float,
timestamp: Optional[str] = None,
) -> Dict[str, Any]:
"""
Update position with new price point and recalculate metrics.
Args:
position: Position dictionary to update
new_price: New price to add to history
timestamp: ISO timestamp for price (default: current UTC time)
Returns:
Updated position dictionary
"""
if timestamp is None:
timestamp = datetime.utcnow().isoformat()
# Convert timestamp to datetime if it's a string
if isinstance(timestamp, str):
price_time = datetime.fromisoformat(timestamp)
else:
price_time = timestamp
# Get entry time from recommendation_date or created_at
if isinstance(position["recommendation_date"], str):
entry_time = datetime.fromisoformat(position["recommendation_date"])
else:
entry_time = datetime.fromisoformat(position["created_at"])
# Calculate time differences
time_diff = price_time - entry_time
hours_held = time_diff.total_seconds() / 3600
days_held = time_diff.total_seconds() / (3600 * 24)
# Calculate returns
entry_price = position["entry_price"]
return_pct = ((new_price - entry_price) / entry_price) * 100
# Create price history entry
price_entry = {
"timestamp": timestamp,
"price": new_price,
"return_pct": return_pct,
"hours_held": hours_held,
"days_held": days_held,
}
# Add to price history
position["price_history"].append(price_entry)
# Update metrics
position["metrics"]["current_price"] = new_price
position["metrics"]["current_return"] = return_pct
position["metrics"]["days_held"] = days_held
# Update peak return if current return is higher
if return_pct > position["metrics"]["peak_return"]:
position["metrics"]["peak_return"] = return_pct
return position
def save_position(self, position: Dict[str, Any]) -> str:
"""
Save position to JSON file.
Creates file: {ticker}_{created_at_timestamp}.json
Args:
position: Position dictionary to save
Returns:
Path to saved file
"""
ticker = position["ticker"]
created_at = position["created_at"]
# Parse created_at to create a filename-safe timestamp
created_dt = datetime.fromisoformat(created_at)
timestamp_str = created_dt.strftime("%Y%m%d_%H%M%S")
filename = f"{ticker}_{timestamp_str}.json"
filepath = self.positions_dir / filename
with open(filepath, "w") as f:
json.dump(position, f, indent=2)
return str(filepath)
def load_all_open_positions(self) -> List[Dict[str, Any]]:
"""
Load all positions with status="open" from disk.
Returns:
List of position dictionaries
"""
open_positions = []
if not self.positions_dir.exists():
return open_positions
for filepath in self.positions_dir.glob("*.json"):
try:
with open(filepath, "r") as f:
position = json.load(f)
if position.get("status") == "open":
open_positions.append(position)
except (json.JSONDecodeError, IOError) as e:
# Log error but continue loading other positions
logger.error(f"Error loading position from {filepath}: {e}")
return open_positions

682
tradingagents/dataflows/discovery/ranker.py Normal file
View File

@ -0,0 +1,682 @@
import json
import re
from datetime import datetime
from typing import Any, Dict, List, Optional
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.messages import HumanMessage
from pydantic import BaseModel, Field
from tradingagents.dataflows.discovery.discovery_config import DiscoveryConfig
from tradingagents.dataflows.discovery.utils import append_llm_log, resolve_llm_name
from tradingagents.utils.logger import get_logger
logger = get_logger(__name__)
def extract_json_from_markdown(text: str) -> Optional[str]:
"""
Extract JSON from markdown code blocks.
Handles cases where LLMs return JSON wrapped in ```json...``` or just ```...```
"""
if not text:
return None
# Try to find JSON in markdown code blocks
patterns = [
r"```json\s*([\s\S]*?)\s*```", # ```json ... ```
r"```\s*([\s\S]*?)\s*```", # ``` ... ```
]
for pattern in patterns:
match = re.search(pattern, text, re.IGNORECASE)
if match:
return match.group(1).strip()
# If no code blocks, check if the text itself is valid JSON
text = text.strip()
if text.startswith("{") or text.startswith("["):
return text
return None
class StockRanking(BaseModel):
"""Single stock ranking."""
rank: int = Field(description="Rank 1-N")
ticker: str = Field(description="Stock ticker symbol")
company_name: str = Field(description="Company name")
current_price: float = Field(description="Current stock price")
strategy_match: str = Field(description="Strategy that matched")
final_score: int = Field(description="Score 0-100")
confidence: int = Field(description="Confidence 1-10")
reason: str = Field(
description="Detailed investment thesis (4-6 sentences) defending the trade with specific catalysts, risk/reward, and timing"
)
description: str = Field(description="Company description")
class RankingResponse(BaseModel):
"""LLM ranking response."""
rankings: List[StockRanking] = Field(description="List of ranked stocks")
class CandidateRanker:
"""
Handles ranking of filtered candidates using Deep Thinking LLM.
"""
def __init__(self, config: Dict[str, Any], llm: BaseChatModel, analytics: Any):
self.config = config
self.llm = llm
self.analytics = analytics
dc = DiscoveryConfig.from_config(config)
self.max_candidates_to_analyze = dc.ranker.max_candidates_to_analyze
self.final_recommendations = dc.ranker.final_recommendations
# Truncation settings
self.truncate_context = dc.ranker.truncate_ranking_context
self.max_news_chars = dc.ranker.max_news_chars
self.max_insider_chars = dc.ranker.max_insider_chars
self.max_recommendations_chars = dc.ranker.max_recommendations_chars
# Prompt logging
self.log_prompts_console = dc.logging.log_prompts_console
def rank(self, state: Dict[str, Any]) -> Dict[str, Any]:
"""Rank all filtered candidates and select the top opportunities."""
candidates = state.get("candidate_metadata", [])
trade_date = state.get("trade_date", datetime.now().strftime("%Y-%m-%d"))
if len(candidates) == 0:
logger.warning("⚠️ No candidates to rank.")
return {
"opportunities": [],
"final_ranking": "[]",
"status": "complete",
"tool_logs": state.get("tool_logs", []),
}
# Limit candidates to prevent token overflow
max_candidates = min(self.max_candidates_to_analyze, 200)
if len(candidates) > max_candidates:
logger.warning(
f"⚠️ Too many candidates ({len(candidates)}), limiting to top {max_candidates} by priority"
)
candidates = candidates[:max_candidates]
logger.info(
f"🏆 Ranking {len(candidates)} candidates to select top {self.final_recommendations}..."
)
# Load historical performance statistics
historical_stats = self.analytics.load_historical_stats()
if historical_stats.get("available"):
logger.info(
f"📊 Loaded historical stats: {historical_stats.get('total_tracked', 0)} tracked recommendations"
)
# Build RICH context for each candidate
candidate_summaries = []
for cand in candidates:
ticker = cand.get("ticker", "UNKNOWN")
strategy = cand.get("strategy", "unknown")
priority = cand.get("priority", "unknown")
context = cand.get("context", "No context available")
all_sources = cand.get("all_sources", [cand.get("source", "unknown")])
technical_indicators = cand.get("technical_indicators", "")
avg_volume = cand.get("average_volume", "N/A")
intraday_change = cand.get("intraday_change_pct", "N/A")
current_price = cand.get("current_price")
# Formatting helpers
volume_str = (
f"{avg_volume:,.0f}" if isinstance(avg_volume, (int, float)) else str(avg_volume)
)
intraday_str = (
f"{intraday_change:+.1f}%"
if isinstance(intraday_change, (int, float))
else str(intraday_change)
)
price_str = f"${current_price:.2f}" if current_price else "N/A"
# Use fundamentals already fetched - pass more complete data
fund = cand.get("fundamentals", {})
fundamentals_summary = self._format_fundamentals_expanded(fund)
# Use full technical indicators instead of extracting only RSI
tech_summary = (
technical_indicators if technical_indicators else "No technical data available."
)
# Get options activity
options_activity = cand.get("options_activity", "")
# Get business description for context
business_description = cand.get("business_description", "")
# News summary - handle both batch news (string) and discovery news (list of dicts)
news_items = cand.get("news", [])
news_summary = ""
if isinstance(news_items, list) and news_items:
# List format from discovery scanner
headlines = []
for item in news_items[:3]:
if isinstance(item, dict):
# Discovery news format: {'news_title': '...', 'news_summary': '...', 'sentiment': '...', 'published_at': '...'}
title = item.get("news_title", item.get("title", ""))
summary = item.get("news_summary", "")
# Get timestamp from various possible fields
timestamp = item.get("published_at") or item.get("timestamp") or ""
# Format timestamp for display (extract date/time portion)
time_str = self._format_news_timestamp(timestamp)
if title:
if time_str:
headlines.append(
f"[{time_str}] {title}: {summary}"
if summary
else f"[{time_str}] {title}"
)
else:
headlines.append(f"{title}: {summary}" if summary else title)
elif isinstance(item, str):
headlines.append(item)
news_summary = "; ".join(headlines) if headlines else ""
elif isinstance(news_items, str):
news_summary = news_items
# Apply truncation if configured
if self.truncate_context and self.max_news_chars > 0:
if len(news_summary) > self.max_news_chars:
news_summary = news_summary[: self.max_news_chars] + "..."
source_str = (
", ".join(all_sources) if isinstance(all_sources, list) else str(all_sources)
)
# Format insider/analyst data
insider_text = cand.get("insider_transactions", "N/A")
recommendations_text = cand.get("recommendations", "N/A")
# Apply truncation if configured
if self.truncate_context:
if (
self.max_insider_chars > 0
and isinstance(insider_text, str)
and len(insider_text) > self.max_insider_chars
):
insider_text = insider_text[: self.max_insider_chars] + "..."
if (
self.max_recommendations_chars > 0
and isinstance(recommendations_text, str)
and len(recommendations_text) > self.max_recommendations_chars
):
recommendations_text = (
recommendations_text[: self.max_recommendations_chars] + "..."
)
# New enrichment fields
confluence_score = cand.get("confluence_score", 1)
quant_score = cand.get("quant_score", "N/A")
# ML prediction
ml_win_prob = cand.get("ml_win_probability")
ml_prediction = cand.get("ml_prediction")
if ml_win_prob is not None:
ml_str = f"{ml_win_prob:.1%} (Predicted: {ml_prediction})"
else:
ml_str = "N/A"
short_interest_pct = cand.get("short_interest_pct")
high_short = cand.get("high_short_interest", False)
short_str = f"{short_interest_pct:.1f}%" if short_interest_pct else "N/A"
if high_short:
short_str += " (HIGH)"
# Earnings estimate
if cand.get("has_upcoming_earnings"):
days = cand.get("days_to_earnings", "?")
eps_est = cand.get("eps_estimate")
rev_est = cand.get("revenue_estimate")
earnings_date = cand.get("earnings_date", "N/A")
eps_str = f"${eps_est:.2f}" if isinstance(eps_est, (int, float)) else "N/A"
rev_str = f"${rev_est:,.0f}" if isinstance(rev_est, (int, float)) else "N/A"
earnings_section = f"Earnings in {days} days ({earnings_date}): EPS Est {eps_str}, Rev Est {rev_str}"
else:
earnings_section = "No upcoming earnings within 30 days"
summary = f"""### {ticker} (Priority: {priority.upper()})
- **Strategy Match**: {strategy}
- **Sources**: {source_str} | **Confluence**: {confluence_score} source(s)
- **Quant Pre-Score**: {quant_score}/100 | **ML Win Probability**: {ml_str}
- **Price**: {price_str} | **Current Price (numeric)**: {current_price if isinstance(current_price, (int, float)) else "N/A"} | **Intraday**: {intraday_str} | **Avg Volume**: {volume_str}
- **Short Interest**: {short_str}
- **Discovery Context**: {context}
- **Business**: {business_description}
- **News**: {news_summary}
**Technical Analysis**:
{tech_summary}
**Fundamentals**: {fundamentals_summary}
**Insider Transactions**:
{insider_text}
**Analyst Recommendations**:
{recommendations_text}
**Options Activity**:
{options_activity if options_activity else "N/A"}
**Upcoming Earnings**: {earnings_section}
"""
candidate_summaries.append(summary)
combined_candidates_text = "\n".join(candidate_summaries)
# Build Prompt
prompt = f"""You are an analyst tasked with selecting the absolute best {self.final_recommendations} stock opportunities from a pre-filtered list.
CURRENT DATE: {trade_date}
GOAL: Select the top {self.final_recommendations} stocks with the highest probability of generating >5% returns in the next 1-7 days.
Focus on asymmetric risk/reward: massive upside potential with managed risk.
HISTORICAL INSIGHTS:
{json.dumps(historical_stats.get('summary', 'N/A'), indent=2)}
CANDIDATES FOR REVIEW:
{combined_candidates_text}
INSTRUCTIONS:
1. Analyze each candidate's "Discovery Context" (why it was found) and "Strategy Match".
2. Cross-reference with Technicals (RSI, etc.) and Fundamentals.
3. Use the Quantitative Pre-Score as an objective baseline. Scores above 50 indicate strong multi-factor alignment.
4. The ML Win Probability is a trained model's estimate that this stock hits +5% within 7 days. Treat scores above 60% as strong ML confirmation.
5. Prioritize "LEADING" indicators (Undiscovered DD, Earnings Accumulation, Insider Buying) over lagging ones.
6. Select exactly {self.final_recommendations} winners.
7. Use ONLY the information provided in the candidates section; do NOT invent catalysts, prices, or metrics.
8. If a required field is missing, set it to null (do not guess).
9. Rank only tickers from the candidates list.
10. Reasons must reference at least two concrete facts from the candidate context.
Output a JSON object with a 'rankings' list. Each item should have:
- rank: 1 to {self.final_recommendations}
- ticker: stock symbol
- company_name: name
- current_price: price
- strategy_match: main strategy
- final_score: 0-100 score
- confidence: 1-10 confidence level
- reason: Detailed investment thesis (4-6 sentences). Defend the trade: (1) what is the catalyst/edge, (2) why NOW and not later, (3) what does the risk/reward look like, (4) what could go wrong. Reference specific data points from the candidate context.
- description: Brief company description.
JSON FORMAT ONLY. No markdown, no extra text. All numeric fields must be numbers (not strings)."""
# Invoke LLM with structured output
logger.info("🧠 Deep Thinking Ranker analyzing opportunities...")
logger.info(
f"Invoking ranking LLM with {len(candidates)} candidates, prompt length: {len(prompt)} chars"
)
if self.log_prompts_console:
logger.info(f"Full ranking prompt:\n{prompt}")
else:
logger.debug(f"Full ranking prompt:\n{prompt}")
try:
# Use structured output with include_raw for debugging
structured_llm = self.llm.with_structured_output(RankingResponse, include_raw=True)
response = structured_llm.invoke([HumanMessage(content=prompt)])
tool_logs = state.get("tool_logs", [])
append_llm_log(
tool_logs,
node="ranker",
step="Rank candidates",
model=resolve_llm_name(self.llm),
prompt=prompt,
output=response,
)
state["tool_logs"] = tool_logs
# Handle the response (dict with raw, parsed, parsing_error)
if isinstance(response, dict):
result = response.get("parsed")
raw = response.get("raw")
parsing_error = response.get("parsing_error")
# Log debug info
logger.info(f"Structured output - parsed type: {type(result)}")
if parsing_error:
logger.error(f"Parsing error: {parsing_error}")
if raw and hasattr(raw, "content"):
logger.debug(f"Raw content preview: {str(raw.content)[:500]}...")
else:
# Direct RankingResponse (shouldn't happen with include_raw=True)
result = response
# Extract rankings - with fallback for markdown-wrapped JSON
if result is None:
logger.warning(
"Structured output parsing returned None - attempting fallback extraction"
)
# Try to extract JSON from raw response (handles ```json...``` wrapping)
raw_text = None
if raw and hasattr(raw, "content"):
content = raw.content
if isinstance(content, str):
raw_text = content
elif isinstance(content, list):
# Handle list of content blocks (e.g., [{'type': 'text', 'text': '...'}])
for block in content:
if isinstance(block, dict) and block.get("type") == "text":
raw_text = block.get("text", "")
break
elif isinstance(block, str):
raw_text = block
break
if raw_text:
json_str = extract_json_from_markdown(raw_text)
if json_str:
try:
parsed_data = json.loads(json_str)
result = RankingResponse.model_validate(parsed_data)
logger.info(
"Successfully extracted JSON from markdown-wrapped response"
)
except json.JSONDecodeError as e:
logger.error(f"Failed to parse extracted JSON: {e}")
except Exception as e:
logger.error(f"Failed to validate extracted JSON: {e}")
if result is None:
logger.error("Parsed result is None - check raw response for clues")
raise ValueError(
"LLM returned None. This may be due to content filtering or prompt length. "
"Check LOG_LEVEL=DEBUG for details."
)
if not hasattr(result, "rankings"):
logger.error(f"Result missing 'rankings'. Type: {type(result)}, Value: {result}")
raise ValueError(f"Unexpected result format: {type(result)}")
final_ranking_list = [ranking.model_dump() for ranking in result.rankings]
logger.info(f"✅ Selected {len(final_ranking_list)} top recommendations")
logger.info(
f"Successfully ranked {len(final_ranking_list)} opportunities: "
f"{[r['ticker'] for r in final_ranking_list]}"
)
# Update state with opportunities for downstream use (deep dive)
state_opportunities = []
for rank_dict in final_ranking_list:
ticker = rank_dict["ticker"].upper()
# Find original candidate metadata
meta = next((c for c in candidates if c.get("ticker") == ticker), {})
state_opportunities.append(
{
"ticker": ticker,
"strategy": rank_dict["strategy_match"],
"reason": rank_dict["reason"],
"score": rank_dict["final_score"],
"rank": rank_dict["rank"],
"metadata": meta,
}
)
return {
"final_ranking": final_ranking_list, # List of dicts
"opportunities": state_opportunities,
"status": "ranked",
}
except ValueError as e:
tool_logs = state.get("tool_logs", [])
append_llm_log(
tool_logs,
node="ranker",
step="Rank candidates",
model=resolve_llm_name(self.llm),
prompt=prompt,
output="",
error=str(e),
)
state["tool_logs"] = tool_logs
# Structured output validation failed
logger.error(f"❌ Error: {e}")
logger.error(f"Structured output validation error: {e}")
return {"final_ranking": [], "opportunities": [], "status": "ranking_failed"}
except Exception as e:
tool_logs = state.get("tool_logs", [])
append_llm_log(
tool_logs,
node="ranker",
step="Rank candidates",
model=resolve_llm_name(self.llm),
prompt=prompt,
output="",
error=str(e),
)
state["tool_logs"] = tool_logs
logger.error(f"❌ Error during ranking: {e}")
logger.exception(f"Unexpected error during ranking: {e}")
return {"final_ranking": [], "opportunities": [], "status": "error"}
def _format_news_timestamp(self, timestamp: str) -> str:
"""
Format news timestamp for display in ranking prompt.
Handles various timestamp formats:
- ISO-8601: 2026-01-31T14:30:00Z -> Jan 31 14:30
- Date only: 2026-01-31 -> Jan 31
- Already formatted strings pass through
"""
if not timestamp:
return ""
try:
# Try ISO-8601 format first
if "T" in timestamp:
# Parse ISO format: 2026-01-31T14:30:00Z or 2026-01-31T14:30:00+00:00
dt_str = timestamp.replace("Z", "+00:00")
# Handle timezone suffix
if "+" in dt_str:
dt_str = dt_str.split("+")[0]
elif dt_str.count("-") > 2:
# Handle negative timezone offset like -05:00
parts = dt_str.rsplit("-", 1)
if ":" in parts[-1]:
dt_str = parts[0]
dt = datetime.fromisoformat(dt_str)
return dt.strftime("%b %d %H:%M")
# Try date-only format
if len(timestamp) == 10 and timestamp.count("-") == 2:
dt = datetime.strptime(timestamp, "%Y-%m-%d")
return dt.strftime("%b %d")
# Try compact format from Alpha Vantage: 20260131T143000
if len(timestamp) >= 8 and timestamp[:8].isdigit():
dt = datetime.strptime(timestamp[:8], "%Y%m%d")
if len(timestamp) >= 15 and timestamp[8] == "T":
dt = datetime.strptime(timestamp[:15], "%Y%m%dT%H%M%S")
return dt.strftime("%b %d %H:%M")
return dt.strftime("%b %d")
# If it's already a short readable format, return as-is
if len(timestamp) <= 20:
return timestamp
except (ValueError, AttributeError):
# If parsing fails, return empty to avoid cluttering output
pass
return ""
def _format_fundamentals_expanded(self, fund: Dict[str, Any]) -> str:
"""Format fundamentals dictionary with comprehensive data for ranking LLM."""
if not fund:
return "N/A"
def fmt_pct(val):
if val == "N/A" or val is None:
return "N/A"
try:
return f"{float(val)*100:.1f}%"
except Exception:
return str(val)
def fmt_large(val, prefix="$"):
if val == "N/A" or val is None:
return "N/A"
try:
n = float(val)
if n >= 1e12:
return f"{prefix}{n/1e12:.2f}T"
if n >= 1e9:
return f"{prefix}{n/1e9:.2f}B"
if n >= 1e6:
return f"{prefix}{n/1e6:.1f}M"
return f"{prefix}{n:,.0f}"
except Exception:
return str(val)
def fmt_ratio(val):
if val == "N/A" or val is None:
return "N/A"
try:
return f"{float(val):.2f}"
except Exception:
return str(val)
parts = []
# Basic info
sector = fund.get("Sector", "N/A")
industry = fund.get("Industry", "N/A")
if sector != "N/A":
parts.append(f"Sector: {sector}")
if industry != "N/A":
parts.append(f"Industry: {industry}")
# Valuation
mc = fmt_large(fund.get("MarketCapitalization"))
pe = fmt_ratio(fund.get("PERatio"))
fwd_pe = fmt_ratio(fund.get("ForwardPE"))
peg = fmt_ratio(fund.get("PEGRatio"))
pb = fmt_ratio(fund.get("PriceToBookRatio"))
ps = fmt_ratio(fund.get("PriceToSalesRatioTTM"))
valuation_parts = []
if mc != "N/A":
valuation_parts.append(f"Cap: {mc}")
if pe != "N/A":
valuation_parts.append(f"P/E: {pe}")
if fwd_pe != "N/A":
valuation_parts.append(f"Fwd P/E: {fwd_pe}")
if peg != "N/A":
valuation_parts.append(f"PEG: {peg}")
if pb != "N/A":
valuation_parts.append(f"P/B: {pb}")
if ps != "N/A":
valuation_parts.append(f"P/S: {ps}")
if valuation_parts:
parts.append("Valuation: " + ", ".join(valuation_parts))
# Growth metrics
rev_growth = fmt_pct(fund.get("QuarterlyRevenueGrowthYOY"))
earnings_growth = fmt_pct(fund.get("QuarterlyEarningsGrowthYOY"))
growth_parts = []
if rev_growth != "N/A":
growth_parts.append(f"Rev Growth: {rev_growth}")
if earnings_growth != "N/A":
growth_parts.append(f"Earnings Growth: {earnings_growth}")
if growth_parts:
parts.append("Growth: " + ", ".join(growth_parts))
# Profitability
profit_margin = fmt_pct(fund.get("ProfitMargin"))
oper_margin = fmt_pct(fund.get("OperatingMarginTTM"))
roe = fmt_pct(fund.get("ReturnOnEquityTTM"))
roa = fmt_pct(fund.get("ReturnOnAssetsTTM"))
profit_parts = []
if profit_margin != "N/A":
profit_parts.append(f"Profit Margin: {profit_margin}")
if oper_margin != "N/A":
profit_parts.append(f"Oper Margin: {oper_margin}")
if roe != "N/A":
profit_parts.append(f"ROE: {roe}")
if roa != "N/A":
profit_parts.append(f"ROA: {roa}")
if profit_parts:
parts.append("Profitability: " + ", ".join(profit_parts))
# Dividend info
div_yield = fmt_pct(fund.get("DividendYield"))
if div_yield != "N/A" and div_yield != "0.0%":
parts.append(f"Dividend: {div_yield} yield")
# Financial health
current_ratio = fmt_ratio(fund.get("CurrentRatio"))
debt_to_equity = fmt_ratio(fund.get("DebtToEquity"))
if current_ratio != "N/A" or debt_to_equity != "N/A":
health_parts = []
if current_ratio != "N/A":
health_parts.append(f"Current Ratio: {current_ratio}")
if debt_to_equity != "N/A":
health_parts.append(f"D/E: {debt_to_equity}")
parts.append("Financial Health: " + ", ".join(health_parts))
# Analyst targets
target_high = fmt_large(fund.get("AnalystTargetPrice"))
if target_high != "N/A":
parts.append(f"Analyst Target: {target_high}")
# Earnings info
eps = fund.get("EPS", "N/A")
if eps != "N/A":
try:
eps = f"${float(eps):.2f}"
parts.append(f"EPS: {eps}")
except Exception:
pass
# Beta (volatility)
beta = fund.get("Beta", "N/A")
if beta != "N/A":
try:
beta = f"{float(beta):.2f}"
parts.append(f"Beta: {beta}")
except Exception:
pass
# 52-week range
week52_high = fund.get("52WeekHigh", "N/A")
week52_low = fund.get("52WeekLow", "N/A")
if week52_high != "N/A" and week52_low != "N/A":
try:
parts.append(f"52W Range: ${float(week52_low):.2f} - ${float(week52_high):.2f}")
except Exception:
pass
# Short interest
short_pct = fund.get("ShortPercentFloat", "N/A")
if short_pct != "N/A":
try:
parts.append(f"Short Interest: {float(short_pct)*100:.1f}%")
except Exception:
pass
return " | ".join(parts) if parts else "N/A"

Some files were not shown because too many files have changed in this diff Show More