+ {/* Hero Section */}
+
+
+ Nifty 50 AI Recommendations
+
+
+ AI-powered daily stock analysis for all Nifty 50 stocks. Get actionable buy, sell, and hold recommendations.
+
+
+ Last updated: {new Date(recommendation.date).toLocaleDateString('en-IN', {
+ weekday: 'long',
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric',
+ })}
+
+
+
+ {/* Summary Stats */}
+
+
+ {/* Chart and Stats Section */}
+
+
+
+
+
Decision Distribution
+
+
+
+
+
+
Quick Analysis
+
+
+
+ Bullish Signals
+ {recommendation.summary.buy}
+
+
+ {((recommendation.summary.buy / recommendation.summary.total) * 100).toFixed(0)}% of stocks show buying opportunities
+
+
+
+
+ Neutral Position
+ {recommendation.summary.hold}
+
+
+ {((recommendation.summary.hold / recommendation.summary.total) * 100).toFixed(0)}% of stocks recommend holding
+
+
+
+
+ Bearish Signals
+ {recommendation.summary.sell}
+
+
+ {((recommendation.summary.sell / recommendation.summary.total) * 100).toFixed(0)}% of stocks suggest selling
+
+
+
+
+
+
+ {/* Top Picks and Avoid Section */}
+
+
+
+ {/* All Stocks Section */}
+
+
+
+
+
All Stocks
+
+
+ {filterButtons.map(({ label, value, count }) => (
+ setFilter(value)}
+ className={`px-3 py-1.5 text-sm font-medium rounded-lg transition-colors ${
+ filter === value
+ ? 'bg-nifty-600 text-white'
+ : 'bg-gray-100 text-gray-600 hover:bg-gray-200'
+ }`}
+ >
+ {label} ({count})
+
+ ))}
+
+
+
+ {filteredStocks.map((stock) => (
+
+
+ {filteredStocks.length === 0 && (
+
+
No stocks match the selected filter.
+
+
+ {/* CTA Section */}
+
+
+
+
+ Track Historical Recommendations
+
+
+ View past recommendations and track how our AI predictions performed over time.
+
+
+
+ View History
+
+
+
+
(null);
+
+ const dates = sampleRecommendations.map(r => r.date);
+
+ const getRecommendation = (date: string) => {
+ return sampleRecommendations.find(r => r.date === date);
+ };
+
+ return (
+
+ {/* Header */}
+
+
+ Historical Recommendations
+
+
+ Browse past AI recommendations and track performance over time.
+
+
+
+ {/* Date Selector */}
+
+
+
Select Date
+
+
+ {dates.map((date) => {
+ const rec = getRecommendation(date);
+ return (
+
setSelectedDate(selectedDate === date ? null : date)}
+ className={`px-4 py-2 rounded-lg text-sm font-medium transition-all ${
+ selectedDate === date
+ ? 'bg-nifty-600 text-white'
+ : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+ }`}
+ >
+ {new Date(date).toLocaleDateString('en-IN', { month: 'short', day: 'numeric' })}
+
+ {rec?.summary.buy}B / {rec?.summary.sell}S / {rec?.summary.hold}H
+
+
+ );
+ })}
+
+
+
+ {/* Selected Date Details */}
+ {selectedDate && (
+
+
+
+
+ {new Date(selectedDate).toLocaleDateString('en-IN', {
+ weekday: 'long',
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric',
+ })}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {Object.values(getRecommendation(selectedDate)?.analysis || {}).map((stock) => (
+
+
+
+ {stock.symbol}
+
+
{stock.company_name}
+
+
+
+ ))}
+
+
+ )}
+
+ {/* Summary Cards */}
+
+
+
+
{dates.length}
+
Days of Analysis
+
+
+
+
+ {sampleRecommendations.reduce((acc, r) => acc + r.summary.buy, 0)}
+
+
Total Buy Signals
+
+
+
+
+ {sampleRecommendations.reduce((acc, r) => acc + r.summary.sell, 0)}
+
+
Total Sell Signals
+
+
+
+
+
+
Stock Not Found
+
The stock "{symbol}" was not found in Nifty 50.
+
+ View All Stocks
+
+
+
+ {/* Back Button */}
+
+
+
+ Back to All Stocks
+
+
+
+ {/* Stock Header */}
+
+
+
+
+
+
{stock.symbol}
+ {analysis?.decision && (
+
+
+ )}
+
+
{stock.company_name}
+
+ {stock.sector || 'N/A'}
+
+
+
+
Latest Analysis
+
+
+
+
+
+ {analysis ? (
+
+
+
Decision
+
+
+
Confidence
+
+
+
Risk Level
+
+
+ ) : (
+
+ No analysis available for this stock yet.
+
+ )}
+
+
+ {/* Quick Stats Grid */}
+
+
+
{history.length}
+
Total Analyses
+
+
+
+ {history.filter(h => h.decision === 'BUY').length}
+
+
Buy Signals
+
+
+
+ {history.filter(h => h.decision === 'HOLD').length}
+
+
Hold Signals
+
+
+
+ {history.filter(h => h.decision === 'SELL').length}
+
+
Sell Signals
+
+
+
+ {/* Analysis History */}
+
+
+
Recommendation History
+
+
+ {history.length > 0 ? (
+
+ {history.map((entry, idx) => (
+
+
+
+ {new Date(entry.date).toLocaleDateString('en-IN', {
+ weekday: 'short',
+ month: 'short',
+ day: 'numeric',
+ year: 'numeric',
+ })}
+
+
+
+
+ ))}
+
+
+
No History Yet
+
Recommendation history will appear here as we analyze this stock daily.
+
+
+ {/* Top Pick / Avoid Status */}
+ {latestRecommendation && (
+ <>
+ {latestRecommendation.top_picks.some(p => p.symbol === symbol) && (
+
+
+
+
+
+
+
Top Pick
+
+ {latestRecommendation.top_picks.find(p => p.symbol === symbol)?.reason}
+
+
+
+
+ )}
+
+ {latestRecommendation.stocks_to_avoid.some(s => s.symbol === symbol) && (
+
+
+
+
+
+
Stock to Avoid
+
+ {latestRecommendation.stocks_to_avoid.find(s => s.symbol === symbol)?.reason}
+
+
+
+
+ )}
+
+ )}
+
+ {/* Disclaimer */}
+
+
+
+
+ Disclaimer: This AI-generated recommendation is for educational purposes only.
+ It should not be considered as financial advice. Always do your own research and consult with
+ a qualified financial advisor before making investment decisions.
+
+
+
('ALL');
+
+ const recommendation = getLatestRecommendation();
+
+ const sectors = useMemo(() => {
+ const sectorSet = new Set(NIFTY_50_STOCKS.map(s => s.sector).filter(Boolean));
+ return ['ALL', ...Array.from(sectorSet).sort()];
+ }, []);
+
+ const filteredStocks = useMemo(() => {
+ return NIFTY_50_STOCKS.filter(stock => {
+ const matchesSearch =
+ stock.symbol.toLowerCase().includes(search.toLowerCase()) ||
+ stock.company_name.toLowerCase().includes(search.toLowerCase());
+
+ const matchesSector = sectorFilter === 'ALL' || stock.sector === sectorFilter;
+
+ return matchesSearch && matchesSector;
+ });
+ }, [search, sectorFilter]);
+
+ const getStockAnalysis = (symbol: string) => {
+ return recommendation?.analysis[symbol];
+ };
+
+ return (
+
+ {/* Header */}
+
+
+ All Nifty 50 Stocks
+
+
+ Browse all 50 stocks in the Nifty index with their latest AI recommendations.
+
+
+
+ {/* Search and Filter */}
+
+
+ {/* Search */}
+
+
+
+ {/* Sector Filter */}
+
+ setSectorFilter(e.target.value)}
+ className="px-4 py-2.5 rounded-lg border border-gray-200 focus:border-nifty-500 focus:ring-2 focus:ring-nifty-500/20 outline-none bg-white"
+ >
+ {sectors.map((sector) => (
+
+ {sector === 'ALL' ? 'All Sectors' : sector}
+
+ ))}
+
+
+
+
+
+ Showing {filteredStocks.length} of {NIFTY_50_STOCKS.length} stocks
+
+
+
+ {/* Stocks Grid */}
+
+ {filteredStocks.map((stock) => {
+ const analysis = getStockAnalysis(stock.symbol);
+ return (
+
+
+
+
{stock.symbol}
+
{stock.company_name}
+
+
+
+
+
+ {stock.sector}
+
+
+ {analysis && (
+
+ )}
+
+ );
+ })}
+
+
+ {filteredStocks.length === 0 && (
+
+
+
No stocks found
+
Try adjusting your search or filter criteria.
+
+ )}
+
;
+ summary: Summary;
+ top_picks: TopPick[];
+ stocks_to_avoid: StockToAvoid[];
+}
+
+export interface StockHistory {
+ date: string;
+ decision: string;
+ confidence?: string;
+ risk?: string;
+}
+
+class ApiService {
+ private baseUrl: string;
+
+ constructor() {
+ this.baseUrl = API_BASE_URL;
+ }
+
+ private async fetch(endpoint: string, options?: RequestInit): Promise {
+ const url = `${this.baseUrl}${endpoint}`;
+ const response = await fetch(url, {
+ ...options,
+ headers: {
+ 'Content-Type': 'application/json',
+ ...options?.headers,
+ },
+ });
+
+ if (!response.ok) {
+ throw new Error(`API Error: ${response.status} ${response.statusText}`);
+ }
+
+ return response.json();
+ }
+
+ /**
+ * Get all daily recommendations
+ */
+ async getAllRecommendations(): Promise<{ recommendations: DailyRecommendation[]; count: number }> {
+ return this.fetch('/recommendations');
+ }
+
+ /**
+ * Get the latest recommendation
+ */
+ async getLatestRecommendation(): Promise {
+ return this.fetch('/recommendations/latest');
+ }
+
+ /**
+ * Get recommendation for a specific date
+ */
+ async getRecommendationByDate(date: string): Promise {
+ return this.fetch(`/recommendations/${date}`);
+ }
+
+ /**
+ * Get historical recommendations for a stock
+ */
+ async getStockHistory(symbol: string): Promise<{ symbol: string; history: StockHistory[]; count: number }> {
+ return this.fetch(`/stocks/${symbol}/history`);
+ }
+
+ /**
+ * Get all available dates
+ */
+ async getAvailableDates(): Promise<{ dates: string[]; count: number }> {
+ return this.fetch('/dates');
+ }
+
+ /**
+ * Health check
+ */
+ async healthCheck(): Promise<{ status: string; database: string }> {
+ return this.fetch('/health');
+ }
+
+ /**
+ * Save a new recommendation (used by the analyzer)
+ */
+ async saveRecommendation(recommendation: {
+ date: string;
+ analysis: Record;
+ summary: Summary;
+ top_picks: TopPick[];
+ stocks_to_avoid: StockToAvoid[];
+ }): Promise<{ message: string }> {
+ return this.fetch('/recommendations', {
+ method: 'POST',
+ body: JSON.stringify(recommendation),
+ });
+ }
+}
+
+export const api = new ApiService();
+
+// Export a hook-friendly version for React Query or SWR
+export default api;
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
new file mode 100644
index 00000000..db455e17
--- /dev/null
+++ b/frontend/src/types/index.ts
@@ -0,0 +1,130 @@
+export type Decision = 'BUY' | 'SELL' | 'HOLD';
+export type Confidence = 'HIGH' | 'MEDIUM' | 'LOW';
+export type Risk = 'HIGH' | 'MEDIUM' | 'LOW';
+
+export interface StockAnalysis {
+ symbol: string;
+ company_name: string;
+ decision: Decision | null;
+ confidence?: Confidence;
+ risk?: Risk;
+ raw_analysis?: string;
+ error?: string | null;
+}
+
+export interface RankingResult {
+ ranking: string;
+ stocks_analyzed: number;
+ timestamp: string;
+ error?: string;
+}
+
+export interface TopPick {
+ rank: number;
+ symbol: string;
+ company_name: string;
+ decision: string;
+ reason: string;
+ risk_level: Risk;
+}
+
+export interface StockToAvoid {
+ symbol: string;
+ company_name: string;
+ reason: string;
+}
+
+export interface DailyRecommendation {
+ date: string;
+ analysis: Record;
+ ranking: RankingResult;
+ summary: {
+ total: number;
+ buy: number;
+ sell: number;
+ hold: number;
+ };
+ top_picks: TopPick[];
+ stocks_to_avoid: StockToAvoid[];
+}
+
+export interface HistoricalEntry {
+ date: string;
+ symbol: string;
+ company_name: string;
+ decision: Decision;
+ confidence?: Confidence;
+ risk?: Risk;
+}
+
+export interface StockHistory {
+ symbol: string;
+ company_name: string;
+ history: HistoricalEntry[];
+ stats: {
+ total_recommendations: number;
+ buy_count: number;
+ sell_count: number;
+ hold_count: number;
+ accuracy?: number;
+ };
+}
+
+export interface NiftyStock {
+ symbol: string;
+ company_name: string;
+ sector?: string;
+}
+
+export const NIFTY_50_STOCKS: NiftyStock[] = [
+ { symbol: 'RELIANCE', company_name: 'Reliance Industries Ltd', sector: 'Energy' },
+ { symbol: 'TCS', company_name: 'Tata Consultancy Services Ltd', sector: 'IT' },
+ { symbol: 'HDFCBANK', company_name: 'HDFC Bank Ltd', sector: 'Banking' },
+ { symbol: 'INFY', company_name: 'Infosys Ltd', sector: 'IT' },
+ { symbol: 'ICICIBANK', company_name: 'ICICI Bank Ltd', sector: 'Banking' },
+ { symbol: 'HINDUNILVR', company_name: 'Hindustan Unilever Ltd', sector: 'FMCG' },
+ { symbol: 'ITC', company_name: 'ITC Ltd', sector: 'FMCG' },
+ { symbol: 'SBIN', company_name: 'State Bank of India', sector: 'Banking' },
+ { symbol: 'BHARTIARTL', company_name: 'Bharti Airtel Ltd', sector: 'Telecom' },
+ { symbol: 'KOTAKBANK', company_name: 'Kotak Mahindra Bank Ltd', sector: 'Banking' },
+ { symbol: 'LT', company_name: 'Larsen & Toubro Ltd', sector: 'Infrastructure' },
+ { symbol: 'AXISBANK', company_name: 'Axis Bank Ltd', sector: 'Banking' },
+ { symbol: 'ASIANPAINT', company_name: 'Asian Paints Ltd', sector: 'Consumer' },
+ { symbol: 'MARUTI', company_name: 'Maruti Suzuki India Ltd', sector: 'Auto' },
+ { symbol: 'HCLTECH', company_name: 'HCL Technologies Ltd', sector: 'IT' },
+ { symbol: 'SUNPHARMA', company_name: 'Sun Pharmaceutical Industries Ltd', sector: 'Pharma' },
+ { symbol: 'TITAN', company_name: 'Titan Company Ltd', sector: 'Consumer' },
+ { symbol: 'BAJFINANCE', company_name: 'Bajaj Finance Ltd', sector: 'Finance' },
+ { symbol: 'WIPRO', company_name: 'Wipro Ltd', sector: 'IT' },
+ { symbol: 'ULTRACEMCO', company_name: 'UltraTech Cement Ltd', sector: 'Cement' },
+ { symbol: 'NESTLEIND', company_name: 'Nestle India Ltd', sector: 'FMCG' },
+ { symbol: 'NTPC', company_name: 'NTPC Ltd', sector: 'Power' },
+ { symbol: 'POWERGRID', company_name: 'Power Grid Corporation of India Ltd', sector: 'Power' },
+ { symbol: 'M&M', company_name: 'Mahindra & Mahindra Ltd', sector: 'Auto' },
+ { symbol: 'TATAMOTORS', company_name: 'Tata Motors Ltd', sector: 'Auto' },
+ { symbol: 'ONGC', company_name: 'Oil & Natural Gas Corporation Ltd', sector: 'Energy' },
+ { symbol: 'JSWSTEEL', company_name: 'JSW Steel Ltd', sector: 'Metals' },
+ { symbol: 'TATASTEEL', company_name: 'Tata Steel Ltd', sector: 'Metals' },
+ { symbol: 'ADANIENT', company_name: 'Adani Enterprises Ltd', sector: 'Conglomerate' },
+ { symbol: 'ADANIPORTS', company_name: 'Adani Ports and SEZ Ltd', sector: 'Infrastructure' },
+ { symbol: 'COALINDIA', company_name: 'Coal India Ltd', sector: 'Mining' },
+ { symbol: 'BAJAJFINSV', company_name: 'Bajaj Finserv Ltd', sector: 'Finance' },
+ { symbol: 'TECHM', company_name: 'Tech Mahindra Ltd', sector: 'IT' },
+ { symbol: 'HDFCLIFE', company_name: 'HDFC Life Insurance Company Ltd', sector: 'Insurance' },
+ { symbol: 'SBILIFE', company_name: 'SBI Life Insurance Company Ltd', sector: 'Insurance' },
+ { symbol: 'GRASIM', company_name: 'Grasim Industries Ltd', sector: 'Cement' },
+ { symbol: 'DIVISLAB', company_name: "Divi's Laboratories Ltd", sector: 'Pharma' },
+ { symbol: 'DRREDDY', company_name: "Dr. Reddy's Laboratories Ltd", sector: 'Pharma' },
+ { symbol: 'CIPLA', company_name: 'Cipla Ltd', sector: 'Pharma' },
+ { symbol: 'BRITANNIA', company_name: 'Britannia Industries Ltd', sector: 'FMCG' },
+ { symbol: 'EICHERMOT', company_name: 'Eicher Motors Ltd', sector: 'Auto' },
+ { symbol: 'APOLLOHOSP', company_name: 'Apollo Hospitals Enterprise Ltd', sector: 'Healthcare' },
+ { symbol: 'INDUSINDBK', company_name: 'IndusInd Bank Ltd', sector: 'Banking' },
+ { symbol: 'HEROMOTOCO', company_name: 'Hero MotoCorp Ltd', sector: 'Auto' },
+ { symbol: 'TATACONSUM', company_name: 'Tata Consumer Products Ltd', sector: 'FMCG' },
+ { symbol: 'BPCL', company_name: 'Bharat Petroleum Corporation Ltd', sector: 'Energy' },
+ { symbol: 'UPL', company_name: 'UPL Ltd', sector: 'Chemicals' },
+ { symbol: 'HINDALCO', company_name: 'Hindalco Industries Ltd', sector: 'Metals' },
+ { symbol: 'BAJAJ-AUTO', company_name: 'Bajaj Auto Ltd', sector: 'Auto' },
+ { symbol: 'LTIM', company_name: 'LTIMindtree Ltd', sector: 'IT' },
+];
diff --git a/frontend/tailwind.config.js b/frontend/tailwind.config.js
new file mode 100644
index 00000000..c1e41357
--- /dev/null
+++ b/frontend/tailwind.config.js
@@ -0,0 +1,45 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+ content: [
+ "./index.html",
+ "./src/**/*.{js,ts,jsx,tsx}",
+ ],
+ theme: {
+ extend: {
+ colors: {
+ 'nifty': {
+ 50: '#f0f9ff',
+ 100: '#e0f2fe',
+ 200: '#bae6fd',
+ 300: '#7dd3fc',
+ 400: '#38bdf8',
+ 500: '#0ea5e9',
+ 600: '#0284c7',
+ 700: '#0369a1',
+ 800: '#075985',
+ 900: '#0c4a6e',
+ },
+ 'bull': {
+ light: '#dcfce7',
+ DEFAULT: '#22c55e',
+ dark: '#15803d',
+ },
+ 'bear': {
+ light: '#fee2e2',
+ DEFAULT: '#ef4444',
+ dark: '#b91c1c',
+ },
+ 'hold': {
+ light: '#fef3c7',
+ DEFAULT: '#f59e0b',
+ dark: '#b45309',
+ }
+ },
+ fontFamily: {
+ sans: ['Inter', 'system-ui', 'sans-serif'],
+ display: ['Lexend', 'system-ui', 'sans-serif'],
+ },
+ },
+ },
+ plugins: [],
+}
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
new file mode 100644
index 00000000..a9b5a59c
--- /dev/null
+++ b/frontend/tsconfig.app.json
@@ -0,0 +1,28 @@
+{
+ "compilerOptions": {
+ "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+ "target": "ES2022",
+ "useDefineForClassFields": true,
+ "lib": ["ES2022", "DOM", "DOM.Iterable"],
+ "module": "ESNext",
+ "types": ["vite/client"],
+ "skipLibCheck": true,
+
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "verbatimModuleSyntax": true,
+ "moduleDetection": "force",
+ "noEmit": true,
+ "jsx": "react-jsx",
+
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "erasableSyntaxOnly": true,
+ "noFallthroughCasesInSwitch": true,
+ "noUncheckedSideEffectImports": true
+ },
+ "include": ["src"]
+}
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
new file mode 100644
index 00000000..1ffef600
--- /dev/null
+++ b/frontend/tsconfig.json
@@ -0,0 +1,7 @@
+{
+ "files": [],
+ "references": [
+ { "path": "./tsconfig.app.json" },
+ { "path": "./tsconfig.node.json" }
+ ]
+}
diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json
new file mode 100644
index 00000000..8a67f62f
--- /dev/null
+++ b/frontend/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+ "compilerOptions": {
+ "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+ "target": "ES2023",
+ "lib": ["ES2023"],
+ "module": "ESNext",
+ "types": ["node"],
+ "skipLibCheck": true,
+
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "verbatimModuleSyntax": true,
+ "moduleDetection": "force",
+ "noEmit": true,
+
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "erasableSyntaxOnly": true,
+ "noFallthroughCasesInSwitch": true,
+ "noUncheckedSideEffectImports": true
+ },
+ "include": ["vite.config.ts"]
+}
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
new file mode 100644
index 00000000..8c9413b9
--- /dev/null
+++ b/frontend/vite.config.ts
@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+// https://vite.dev/config/
+export default defineConfig({
+ plugins: [react(), tailwindcss()],
+ server: {
+ host: '0.0.0.0',
+ port: 5173,
+ cors: true,
+ hmr: {
+ host: '192.168.3.200',
+ },
+ },
+})
diff --git a/nifty50_recommend.py b/nifty50_recommend.py
new file mode 100644
index 00000000..d466bddb
--- /dev/null
+++ b/nifty50_recommend.py
@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Nifty 50 Stock Recommendation CLI.
+
+This script runs the Nifty 50 recommendation system to predict all Nifty 50 stocks
+and select the ones with highest short-term growth potential using Claude Opus 4.5.
+
+Usage:
+ # Full run (all 50 stocks)
+ python nifty50_recommend.py --date 2025-01-30
+
+ # Test with specific stocks
+ python nifty50_recommend.py --stocks TCS,INFY,RELIANCE --date 2025-01-30
+
+ # Quiet mode (less output)
+ python nifty50_recommend.py --date 2025-01-30 --quiet
+"""
+
+import argparse
+import sys
+from datetime import datetime
+
+
+def parse_args():
+ """Parse command line arguments."""
+ parser = argparse.ArgumentParser(
+ description="Nifty 50 Stock Recommendation System using Claude Opus 4.5",
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog="""
+Examples:
+ # Analyze all 50 Nifty stocks
+ python nifty50_recommend.py --date 2025-01-30
+
+ # Analyze specific stocks only
+ python nifty50_recommend.py --stocks TCS,INFY,RELIANCE --date 2025-01-30
+
+ # Save results to custom directory
+ python nifty50_recommend.py --date 2025-01-30 --output ./my_results
+
+ # Quick test with 3 stocks
+ python nifty50_recommend.py --stocks TCS,INFY,RELIANCE --date 2025-01-30
+ """
+ )
+
+ parser.add_argument(
+ "--date",
+ "-d",
+ type=str,
+ default=datetime.now().strftime("%Y-%m-%d"),
+ help="Analysis date in YYYY-MM-DD format (default: today)"
+ )
+
+ parser.add_argument(
+ "--stocks",
+ "-s",
+ type=str,
+ default=None,
+ help="Comma-separated list of stock symbols to analyze (default: all 50)"
+ )
+
+ parser.add_argument(
+ "--output",
+ "-o",
+ type=str,
+ default=None,
+ help="Directory to save results (default: ./results/nifty50_recommendations)"
+ )
+
+ parser.add_argument(
+ "--quiet",
+ "-q",
+ action="store_true",
+ help="Suppress progress output"
+ )
+
+ parser.add_argument(
+ "--no-save",
+ action="store_true",
+ help="Don't save results to disk"
+ )
+
+ parser.add_argument(
+ "--test-credentials",
+ action="store_true",
+ help="Only test Claude credentials and exit"
+ )
+
+ return parser.parse_args()
+
+
+def test_credentials():
+ """Test if Claude credentials are valid."""
+ from tradingagents.nifty50_recommender import get_claude_credentials
+
+ try:
+ token = get_claude_credentials()
+ print(f"✓ Claude credentials found")
+ print(f" Token prefix: {token[:20]}...")
+ return True
+ except FileNotFoundError as e:
+ print(f"✗ Credentials file not found: {e}")
+ return False
+ except KeyError as e:
+ print(f"✗ Invalid credentials format: {e}")
+ return False
+ except Exception as e:
+ print(f"✗ Error reading credentials: {e}")
+ return False
+
+
+def main():
+ """Main entry point."""
+ args = parse_args()
+
+ # Test credentials mode
+ if args.test_credentials:
+ success = test_credentials()
+ sys.exit(0 if success else 1)
+
+ # Validate date format
+ try:
+ datetime.strptime(args.date, "%Y-%m-%d")
+ except ValueError:
+ print(f"Error: Invalid date format '{args.date}'. Use YYYY-MM-DD")
+ sys.exit(1)
+
+ # Parse stock subset
+ stock_subset = None
+ if args.stocks:
+ stock_subset = [s.strip().upper() for s in args.stocks.split(",")]
+ print(f"Analyzing subset: {', '.join(stock_subset)}")
+
+ # Import the simplified recommender (works with Claude Max subscription)
+ try:
+ from tradingagents.nifty50_simple_recommender import run_recommendation
+ except ImportError as e:
+ print(f"Error importing recommender module: {e}")
+ print("Make sure you're running from the TradingAgents directory")
+ sys.exit(1)
+
+ # Run the recommendation
+ try:
+ predictions, ranking = run_recommendation(
+ trade_date=args.date,
+ stock_subset=stock_subset,
+ save_results=not args.no_save,
+ results_dir=args.output,
+ verbose=not args.quiet
+ )
+
+ # Print summary
+ if not args.quiet:
+ print("\n" + "="*60)
+ print("SUMMARY")
+ print("="*60)
+
+ successful = sum(1 for p in predictions.values() if not p.get("error"))
+ print(f"Stocks analyzed: {successful}/{len(predictions)}")
+
+ # Count decisions
+ decisions = {}
+ for p in predictions.values():
+ if not p.get("error"):
+ decision = str(p.get("decision", "UNKNOWN"))
+ decisions[decision] = decisions.get(decision, 0) + 1
+
+ print("\nDecision breakdown:")
+ for decision, count in sorted(decisions.items()):
+ print(f" {decision}: {count}")
+
+ except FileNotFoundError as e:
+ print(f"\nError: {e}")
+ print("\nTo authenticate with Claude, run:")
+ print(" claude auth login")
+ sys.exit(1)
+ except Exception as e:
+ print(f"\nError running recommendation: {e}")
+ import traceback
+ traceback.print_exc()
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/package.json b/package.json
new file mode 100644
index 00000000..dc0ba8ba
--- /dev/null
+++ b/package.json
@@ -0,0 +1,23 @@
+{
+ "name": "tradingagents",
+ "version": "1.0.0",
+ "description": "
",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/TauricResearch/TradingAgents.git"
+ },
+ "keywords": [],
+ "author": "",
+ "license": "ISC",
+ "bugs": {
+ "url": "https://github.com/TauricResearch/TradingAgents/issues"
+ },
+ "homepage": "https://github.com/TauricResearch/TradingAgents#readme",
+ "dependencies": {
+ "playwright": "^1.58.1"
+ }
+}
diff --git a/requirements.txt b/requirements.txt
index a6154cd2..b29d878a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -24,3 +24,5 @@ rich
questionary
langchain_anthropic
langchain-google-genai
+jugaad-data
+sentence-transformers
diff --git a/tradingagents/agents/utils/memory.py b/tradingagents/agents/utils/memory.py
index 69b8ab8c..04bf2c52 100644
--- a/tradingagents/agents/utils/memory.py
+++ b/tradingagents/agents/utils/memory.py
@@ -1,25 +1,31 @@
import chromadb
from chromadb.config import Settings
-from openai import OpenAI
+from chromadb.utils import embedding_functions
class FinancialSituationMemory:
+ """Memory system for storing and retrieving financial situations using local embeddings."""
+
def __init__(self, name, config):
- if config["backend_url"] == "http://localhost:11434/v1":
- self.embedding = "nomic-embed-text"
- else:
- self.embedding = "text-embedding-3-small"
- self.client = OpenAI(base_url=config["backend_url"])
+ """
+ Initialize the memory system with local embeddings.
+
+ Args:
+ name: Name for the ChromaDB collection
+ config: Configuration dictionary (kept for compatibility)
+ """
+ # Use ChromaDB's default embedding function (uses all-MiniLM-L6-v2 internally)
+ self.embedding_fn = embedding_functions.DefaultEmbeddingFunction()
self.chroma_client = chromadb.Client(Settings(allow_reset=True))
- self.situation_collection = self.chroma_client.create_collection(name=name)
+ self.situation_collection = self.chroma_client.create_collection(
+ name=name,
+ embedding_function=self.embedding_fn
+ )
def get_embedding(self, text):
- """Get OpenAI embedding for a text"""
-
- response = self.client.embeddings.create(
- model=self.embedding, input=text
- )
- return response.data[0].embedding
+ """Get embedding for a text using the embedding function."""
+ embeddings = self.embedding_fn([text])
+ return embeddings[0]
def add_situations(self, situations_and_advice):
"""Add financial situations and their corresponding advice. Parameter is a list of tuples (situation, rec)"""
@@ -27,7 +33,6 @@ class FinancialSituationMemory:
situations = []
advice = []
ids = []
- embeddings = []
offset = self.situation_collection.count()
@@ -35,41 +40,39 @@ class FinancialSituationMemory:
situations.append(situation)
advice.append(recommendation)
ids.append(str(offset + i))
- embeddings.append(self.get_embedding(situation))
+ # Let ChromaDB handle embeddings automatically
self.situation_collection.add(
documents=situations,
metadatas=[{"recommendation": rec} for rec in advice],
- embeddings=embeddings,
ids=ids,
)
def get_memories(self, current_situation, n_matches=1):
- """Find matching recommendations using OpenAI embeddings"""
- query_embedding = self.get_embedding(current_situation)
-
+ """Find matching recommendations using embeddings"""
results = self.situation_collection.query(
- query_embeddings=[query_embedding],
+ query_texts=[current_situation],
n_results=n_matches,
include=["metadatas", "documents", "distances"],
)
matched_results = []
- for i in range(len(results["documents"][0])):
- matched_results.append(
- {
- "matched_situation": results["documents"][0][i],
- "recommendation": results["metadatas"][0][i]["recommendation"],
- "similarity_score": 1 - results["distances"][0][i],
- }
- )
+ if results["documents"] and results["documents"][0]:
+ for i in range(len(results["documents"][0])):
+ matched_results.append(
+ {
+ "matched_situation": results["documents"][0][i],
+ "recommendation": results["metadatas"][0][i]["recommendation"],
+ "similarity_score": 1 - results["distances"][0][i],
+ }
+ )
return matched_results
if __name__ == "__main__":
# Example usage
- matcher = FinancialSituationMemory()
+ matcher = FinancialSituationMemory("test_memory", {})
# Example data
example_data = [
@@ -96,7 +99,7 @@ if __name__ == "__main__":
# Example query
current_situation = """
- Market showing increased volatility in tech sector, with institutional investors
+ Market showing increased volatility in tech sector, with institutional investors
reducing positions and rising interest rates affecting growth stock valuations
"""
diff --git a/tradingagents/agents/utils/news_data_tools.py b/tradingagents/agents/utils/news_data_tools.py
index 0df9d047..8e9f2fb2 100644
--- a/tradingagents/agents/utils/news_data_tools.py
+++ b/tradingagents/agents/utils/news_data_tools.py
@@ -1,6 +1,7 @@
from langchain_core.tools import tool
from typing import Annotated
from tradingagents.dataflows.interface import route_to_vendor
+from tradingagents.dataflows.markets import is_nifty_50_stock
@tool
def get_news(
@@ -52,6 +53,12 @@ def get_insider_sentiment(
Returns:
str: A report of insider sentiment data
"""
+ # Check if this is an NSE stock - insider sentiment from SEC sources is not available
+ if is_nifty_50_stock(ticker):
+ return (f"Note: SEC-style insider sentiment data is not available for Indian NSE stocks like {ticker}. "
+ f"For Indian stocks, insider trading disclosures are regulated by SEBI (Securities and Exchange Board of India) "
+ f"and can be found on NSE/BSE websites or through the company's regulatory filings.")
+
return route_to_vendor("get_insider_sentiment", ticker, curr_date)
@tool
diff --git a/tradingagents/claude_max_llm.py b/tradingagents/claude_max_llm.py
new file mode 100644
index 00000000..a3e718ca
--- /dev/null
+++ b/tradingagents/claude_max_llm.py
@@ -0,0 +1,164 @@
+"""
+Claude Max LLM Wrapper.
+
+This module provides a LangChain-compatible LLM that uses the Claude CLI
+with Max subscription authentication instead of API keys.
+"""
+
+import os
+import subprocess
+import json
+from typing import Any, Dict, List, Optional, Iterator
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import (
+ AIMessage,
+ BaseMessage,
+ HumanMessage,
+ SystemMessage,
+)
+from langchain_core.outputs import ChatGeneration, ChatResult
+from langchain_core.callbacks import CallbackManagerForLLMRun
+
+
+class ClaudeMaxLLM(BaseChatModel):
+ """
+ A LangChain-compatible chat model that uses Claude CLI with Max subscription.
+
+ This bypasses API key requirements by using the Claude CLI which authenticates
+ via OAuth tokens from your Claude Max subscription.
+ """
+
+ model: str = "sonnet" # Use alias for Claude Max subscription
+ max_tokens: int = 4096
+ temperature: float = 0.7
+ claude_cli_path: str = "claude"
+
+ @property
+ def _llm_type(self) -> str:
+ return "claude-max"
+
+ @property
+ def _identifying_params(self) -> Dict[str, Any]:
+ return {
+ "model": self.model,
+ "max_tokens": self.max_tokens,
+ "temperature": self.temperature,
+ }
+
+ def _format_messages_for_prompt(self, messages: List[BaseMessage]) -> str:
+ """Convert LangChain messages to a single prompt string."""
+ formatted_parts = []
+
+ for msg in messages:
+ if isinstance(msg, SystemMessage):
+ formatted_parts.append(f"\n{msg.content}\n \n")
+ elif isinstance(msg, HumanMessage):
+ formatted_parts.append(f"Human: {msg.content}\n")
+ elif isinstance(msg, AIMessage):
+ formatted_parts.append(f"Assistant: {msg.content}\n")
+ else:
+ formatted_parts.append(f"{msg.content}\n")
+
+ return "\n".join(formatted_parts)
+
+ def _call_claude_cli(self, prompt: str) -> str:
+ """Call the Claude CLI and return the response."""
+ # Create environment without ANTHROPIC_API_KEY to force subscription auth
+ env = os.environ.copy()
+ env.pop("ANTHROPIC_API_KEY", None)
+
+ # Build the command
+ cmd = [
+ self.claude_cli_path,
+ "--print", # Non-interactive mode
+ "--model", self.model,
+ prompt
+ ]
+
+ try:
+ result = subprocess.run(
+ cmd,
+ capture_output=True,
+ text=True,
+ env=env,
+ timeout=300, # 5 minute timeout
+ )
+
+ if result.returncode != 0:
+ raise RuntimeError(f"Claude CLI error: {result.stderr}")
+
+ return result.stdout.strip()
+
+ except subprocess.TimeoutExpired:
+ raise RuntimeError("Claude CLI timed out after 5 minutes")
+ except FileNotFoundError:
+ raise RuntimeError(
+ f"Claude CLI not found at '{self.claude_cli_path}'. "
+ "Make sure Claude Code is installed and in your PATH."
+ )
+
+ def _generate(
+ self,
+ messages: List[BaseMessage],
+ stop: Optional[List[str]] = None,
+ run_manager: Optional[CallbackManagerForLLMRun] = None,
+ **kwargs: Any,
+ ) -> ChatResult:
+ """Generate a response from the Claude CLI."""
+ prompt = self._format_messages_for_prompt(messages)
+ response_text = self._call_claude_cli(prompt)
+
+ # Apply stop sequences if provided
+ if stop:
+ for stop_seq in stop:
+ if stop_seq in response_text:
+ response_text = response_text.split(stop_seq)[0]
+
+ message = AIMessage(content=response_text)
+ generation = ChatGeneration(message=message)
+
+ return ChatResult(generations=[generation])
+
+ def invoke(self, input: Any, **kwargs) -> AIMessage:
+ """Invoke the model with the given input."""
+ if isinstance(input, str):
+ messages = [HumanMessage(content=input)]
+ elif isinstance(input, list):
+ messages = input
+ else:
+ messages = [HumanMessage(content=str(input))]
+
+ result = self._generate(messages, **kwargs)
+ return result.generations[0].message
+
+
+def get_claude_max_llm(model: str = "claude-sonnet-4-5-20250514", **kwargs) -> ClaudeMaxLLM:
+ """
+ Factory function to create a ClaudeMaxLLM instance.
+
+ Args:
+ model: The Claude model to use (default: claude-sonnet-4-5-20250514)
+ **kwargs: Additional arguments passed to ClaudeMaxLLM
+
+ Returns:
+ A configured ClaudeMaxLLM instance
+ """
+ return ClaudeMaxLLM(model=model, **kwargs)
+
+
+def test_claude_max():
+ """Test the Claude Max LLM wrapper."""
+ print("Testing Claude Max LLM wrapper...")
+
+ llm = ClaudeMaxLLM(model="claude-sonnet-4-5-20250514")
+
+ # Test with a simple prompt
+ response = llm.invoke("Say 'Hello, I am using Claude Max subscription!' in exactly those words.")
+ print(f"Response: {response.content}")
+
+ return response
+
+
+if __name__ == "__main__":
+ test_claude_max()
diff --git a/tradingagents/dataflows/google.py b/tradingagents/dataflows/google.py
index 3fe20f3c..bf424e71 100644
--- a/tradingagents/dataflows/google.py
+++ b/tradingagents/dataflows/google.py
@@ -1,14 +1,50 @@
-from typing import Annotated
+from typing import Annotated, Union
from datetime import datetime
from dateutil.relativedelta import relativedelta
from .googlenews_utils import getNewsData
+from .markets import is_nifty_50_stock, get_nifty_50_company_name
def get_google_news(
query: Annotated[str, "Query to search with"],
curr_date: Annotated[str, "Curr date in yyyy-mm-dd format"],
- look_back_days: Annotated[int, "how many days to look back"],
+ look_back_days: Annotated[Union[int, str], "how many days to look back OR end_date string"],
) -> str:
+ """
+ Fetch Google News for a query.
+
+ Note: This function handles two calling conventions:
+ 1. Original: (query, curr_date, look_back_days: int)
+ 2. From get_news interface: (ticker, start_date, end_date) where end_date is a string
+
+ When called with end_date string, it calculates look_back_days from the date difference.
+ """
+ # Handle case where look_back_days is actually an end_date string (from get_news interface)
+ if isinstance(look_back_days, str):
+ try:
+ # Called as (ticker, start_date, end_date) - need to swap and calculate
+ start_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
+ end_date_dt = datetime.strptime(look_back_days, "%Y-%m-%d")
+ # Swap: curr_date should be end_date, calculate days difference
+ actual_curr_date = look_back_days # end_date becomes curr_date
+ actual_look_back_days = (end_date_dt - start_date_dt).days
+ if actual_look_back_days < 0:
+ actual_look_back_days = abs(actual_look_back_days)
+ curr_date = actual_curr_date
+ look_back_days = actual_look_back_days
+ except ValueError:
+ # If parsing fails, default to 7 days
+ look_back_days = 7
+
+ # For NSE stocks, enhance query with company name for better news results
+ original_query = query
+ if is_nifty_50_stock(query):
+ company_name = get_nifty_50_company_name(query)
+ if company_name:
+ # Use company name for better news search results
+ # Add "NSE" and "stock" to filter for relevant financial news
+ query = f"{company_name} NSE stock"
+
query = query.replace(" ", "+")
start_date = datetime.strptime(curr_date, "%Y-%m-%d")
@@ -27,4 +63,6 @@ def get_google_news(
if len(news_results) == 0:
return ""
- return f"## {query} Google News, from {before} to {curr_date}:\n\n{news_str}"
\ No newline at end of file
+ # Use original query (symbol) in the header for clarity
+ display_query = original_query if is_nifty_50_stock(original_query) else query.replace("+", " ")
+ return f"## {display_query} Google News, from {before} to {curr_date}:\n\n{news_str}"
\ No newline at end of file
diff --git a/tradingagents/dataflows/interface.py b/tradingagents/dataflows/interface.py
index 4cd5ddef..67d0604a 100644
--- a/tradingagents/dataflows/interface.py
+++ b/tradingagents/dataflows/interface.py
@@ -16,6 +16,8 @@ from .alpha_vantage import (
get_news as get_alpha_vantage_news
)
from .alpha_vantage_common import AlphaVantageRateLimitError
+from .jugaad_data import get_jugaad_stock_data, get_jugaad_indicators
+from .markets import detect_market, Market, is_nifty_50_stock
# Configuration and routing logic
from .config import get_config
@@ -58,7 +60,8 @@ VENDOR_LIST = [
"local",
"yfinance",
"openai",
- "google"
+ "google",
+ "jugaad_data"
]
# Mapping of methods to their vendor-specific implementations
@@ -68,12 +71,14 @@ VENDOR_METHODS = {
"alpha_vantage": get_alpha_vantage_stock,
"yfinance": get_YFin_data_online,
"local": get_YFin_data,
+ "jugaad_data": get_jugaad_stock_data,
},
# technical_indicators
"get_indicators": {
"alpha_vantage": get_alpha_vantage_indicator,
"yfinance": get_stock_stats_indicators_window,
- "local": get_stock_stats_indicators_window
+ "local": get_stock_stats_indicators_window,
+ "jugaad_data": get_jugaad_indicators,
},
# fundamental_data
"get_fundamentals": {
@@ -123,9 +128,18 @@ def get_category_for_method(method: str) -> str:
return category
raise ValueError(f"Method '{method}' not found in any category")
-def get_vendor(category: str, method: str = None) -> str:
+def get_vendor(category: str, method: str = None, symbol: str = None) -> str:
"""Get the configured vendor for a data category or specific tool method.
Tool-level configuration takes precedence over category-level.
+ For NSE stocks, automatically routes to jugaad_data for core_stock_apis and technical_indicators.
+
+ Args:
+ category: Data category (e.g., "core_stock_apis", "technical_indicators")
+ method: Specific tool method name
+ symbol: Stock symbol (used for market detection)
+
+ Returns:
+ Vendor name string
"""
config = get_config()
@@ -135,13 +149,44 @@ def get_vendor(category: str, method: str = None) -> str:
if method in tool_vendors:
return tool_vendors[method]
+ # Market-aware vendor routing for NSE stocks
+ if symbol:
+ market_config = config.get("market", "auto")
+ market = detect_market(symbol, market_config)
+
+ if market == Market.INDIA_NSE:
+ # Use yfinance as primary for NSE stocks (more reliable than jugaad_data from outside India)
+ # jugaad_data requires direct NSE access which may be blocked/slow
+ if category in ("core_stock_apis", "technical_indicators"):
+ return "yfinance" # yfinance handles .NS suffix automatically
+ # Use yfinance for fundamentals (with .NS suffix handled in y_finance.py)
+ elif category == "fundamental_data":
+ return "yfinance"
+ # Use google for news (handled in google.py with company name enhancement)
+ elif category == "news_data":
+ return "google"
+
# Fall back to category-level configuration
return config.get("data_vendors", {}).get(category, "default")
def route_to_vendor(method: str, *args, **kwargs):
"""Route method calls to appropriate vendor implementation with fallback support."""
category = get_category_for_method(method)
- vendor_config = get_vendor(category, method)
+
+ # Extract symbol from args/kwargs for market-aware routing
+ symbol = None
+ if args:
+ # First argument is typically the symbol/ticker
+ symbol = args[0]
+ elif "symbol" in kwargs:
+ symbol = kwargs["symbol"]
+ elif "ticker" in kwargs:
+ symbol = kwargs["ticker"]
+ elif "query" in kwargs:
+ # For news queries, the query might be the symbol
+ symbol = kwargs["query"]
+
+ vendor_config = get_vendor(category, method, symbol)
# Handle comma-separated vendors
primary_vendors = [v.strip() for v in vendor_config.split(',')]
diff --git a/tradingagents/dataflows/jugaad_data.py b/tradingagents/dataflows/jugaad_data.py
new file mode 100644
index 00000000..e51835fc
--- /dev/null
+++ b/tradingagents/dataflows/jugaad_data.py
@@ -0,0 +1,372 @@
+"""
+Data vendor using jugaad-data library for Indian NSE stocks.
+Provides historical OHLCV data, live quotes, and index data for NSE.
+
+Note: jugaad-data requires network access to NSE India website which may be
+slow or blocked from some locations. The implementation includes timeouts
+and will raise exceptions to trigger fallback to yfinance.
+"""
+
+from typing import Annotated
+from datetime import datetime, date
+import pandas as pd
+import signal
+
+from .markets import normalize_symbol, is_nifty_50_stock
+
+
+class JugaadDataTimeoutError(Exception):
+ """Raised when jugaad-data request times out."""
+ pass
+
+
+def _timeout_handler(signum, frame):
+ raise JugaadDataTimeoutError("jugaad-data request timed out")
+
+
+def get_jugaad_stock_data(
+ symbol: Annotated[str, "ticker symbol of the company"],
+ start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+ end_date: Annotated[str, "End date in yyyy-mm-dd format"],
+) -> str:
+ """
+ Fetch historical stock data from NSE using jugaad-data.
+
+ Args:
+ symbol: NSE stock symbol (e.g., 'RELIANCE', 'TCS')
+ start_date: Start date in yyyy-mm-dd format
+ end_date: End date in yyyy-mm-dd format
+
+ Returns:
+ CSV formatted string with OHLCV data
+
+ Raises:
+ ImportError: If jugaad-data is not installed
+ JugaadDataTimeoutError: If request times out
+ Exception: For other errors (triggers fallback)
+ """
+ try:
+ from jugaad_data.nse import stock_df
+ except ImportError:
+ raise ImportError("jugaad-data library not installed. Please install it with: pip install jugaad-data")
+
+ # Normalize symbol for NSE (remove .NS suffix if present)
+ nse_symbol = normalize_symbol(symbol, target="nse")
+
+ # Parse dates
+ try:
+ start_dt = datetime.strptime(start_date, "%Y-%m-%d").date()
+ end_dt = datetime.strptime(end_date, "%Y-%m-%d").date()
+ except ValueError as e:
+ raise ValueError(f"Error parsing dates: {e}. Please use yyyy-mm-dd format.")
+
+ # Set a timeout for the request (15 seconds)
+ # This helps avoid hanging when NSE website is slow
+ timeout_seconds = 15
+ old_handler = None
+
+ try:
+ # Set timeout using signal (only works on Unix)
+ try:
+ old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
+ signal.alarm(timeout_seconds)
+ except (AttributeError, ValueError):
+ # signal.SIGALRM not available on Windows
+ pass
+
+ # Fetch data using jugaad-data
+ # series='EQ' for equity stocks
+ data = stock_df(
+ symbol=nse_symbol,
+ from_date=start_dt,
+ to_date=end_dt,
+ series="EQ"
+ )
+
+ # Cancel the alarm
+ try:
+ signal.alarm(0)
+ if old_handler:
+ signal.signal(signal.SIGALRM, old_handler)
+ except (AttributeError, ValueError):
+ pass
+
+ if data.empty:
+ raise ValueError(f"No data found for symbol '{nse_symbol}' between {start_date} and {end_date}")
+
+ # Rename columns to match yfinance format for consistency
+ column_mapping = {
+ "DATE": "Date",
+ "OPEN": "Open",
+ "HIGH": "High",
+ "LOW": "Low",
+ "CLOSE": "Close",
+ "LTP": "Last",
+ "VOLUME": "Volume",
+ "VALUE": "Value",
+ "NO OF TRADES": "Trades",
+ "PREV. CLOSE": "Prev Close",
+ }
+
+ # Rename columns that exist
+ for old_name, new_name in column_mapping.items():
+ if old_name in data.columns:
+ data = data.rename(columns={old_name: new_name})
+
+ # Select relevant columns (similar to yfinance output)
+ available_cols = ["Date", "Open", "High", "Low", "Close", "Volume"]
+ cols_to_use = [col for col in available_cols if col in data.columns]
+ data = data[cols_to_use]
+
+ # Round numerical values
+ numeric_columns = ["Open", "High", "Low", "Close"]
+ for col in numeric_columns:
+ if col in data.columns:
+ data[col] = data[col].round(2)
+
+ # Sort by date
+ if "Date" in data.columns:
+ data = data.sort_values("Date")
+
+ # Convert to CSV string
+ csv_string = data.to_csv(index=False)
+
+ # Add header information
+ header = f"# Stock data for {nse_symbol} (NSE) from {start_date} to {end_date}\n"
+ header += f"# Total records: {len(data)}\n"
+ header += f"# Data source: NSE India via jugaad-data\n"
+ header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+
+ return header + csv_string
+
+ except JugaadDataTimeoutError:
+ # Re-raise timeout errors to trigger fallback
+ raise
+ except Exception as e:
+ error_msg = str(e)
+ # Raise exceptions to trigger fallback to yfinance
+ if "No data" in error_msg or "empty" in error_msg.lower():
+ raise ValueError(f"No data found for symbol '{nse_symbol}' between {start_date} and {end_date}. Please verify the symbol is listed on NSE.")
+ raise RuntimeError(f"Error fetching data for {nse_symbol} from jugaad-data: {error_msg}")
+
+
+def get_jugaad_live_quote(
+ symbol: Annotated[str, "ticker symbol of the company"],
+) -> str:
+ """
+ Fetch live quote for an NSE stock.
+
+ Args:
+ symbol: NSE stock symbol
+
+ Returns:
+ Formatted string with current quote information
+ """
+ try:
+ from jugaad_data.nse import NSELive
+ except ImportError:
+ return "Error: jugaad-data library not installed. Please install it with: pip install jugaad-data"
+
+ nse_symbol = normalize_symbol(symbol, target="nse")
+
+ try:
+ nse = NSELive()
+ quote = nse.stock_quote(nse_symbol)
+
+ if not quote:
+ return f"No live quote available for '{nse_symbol}'"
+
+ # Extract price info
+ price_info = quote.get("priceInfo", {})
+ trade_info = quote.get("tradeInfo", {})
+ security_info = quote.get("securityInfo", {})
+
+ result = f"# Live Quote for {nse_symbol} (NSE)\n"
+ result += f"# Retrieved: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+
+ result += f"Last Price: {price_info.get('lastPrice', 'N/A')}\n"
+ result += f"Change: {price_info.get('change', 'N/A')}\n"
+ result += f"% Change: {price_info.get('pChange', 'N/A')}%\n"
+ result += f"Open: {price_info.get('open', 'N/A')}\n"
+ result += f"High: {price_info.get('intraDayHighLow', {}).get('max', 'N/A')}\n"
+ result += f"Low: {price_info.get('intraDayHighLow', {}).get('min', 'N/A')}\n"
+ result += f"Previous Close: {price_info.get('previousClose', 'N/A')}\n"
+ result += f"Volume: {trade_info.get('totalTradedVolume', 'N/A')}\n"
+ result += f"Value: {trade_info.get('totalTradedValue', 'N/A')}\n"
+
+ return result
+
+ except Exception as e:
+ return f"Error fetching live quote for {nse_symbol}: {str(e)}"
+
+
+def get_jugaad_index_data(
+ index_name: Annotated[str, "Index name (e.g., 'NIFTY 50', 'NIFTY BANK')"],
+ start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+ end_date: Annotated[str, "End date in yyyy-mm-dd format"],
+) -> str:
+ """
+ Fetch historical index data from NSE.
+
+ Args:
+ index_name: NSE index name (e.g., 'NIFTY 50', 'NIFTY BANK')
+ start_date: Start date in yyyy-mm-dd format
+ end_date: End date in yyyy-mm-dd format
+
+ Returns:
+ CSV formatted string with index data
+ """
+ try:
+ from jugaad_data.nse import index_df
+ except ImportError:
+ return "Error: jugaad-data library not installed. Please install it with: pip install jugaad-data"
+
+ try:
+ start_dt = datetime.strptime(start_date, "%Y-%m-%d").date()
+ end_dt = datetime.strptime(end_date, "%Y-%m-%d").date()
+ except ValueError as e:
+ return f"Error parsing dates: {e}. Please use yyyy-mm-dd format."
+
+ try:
+ data = index_df(
+ symbol=index_name.upper(),
+ from_date=start_dt,
+ to_date=end_dt
+ )
+
+ if data.empty:
+ return f"No data found for index '{index_name}' between {start_date} and {end_date}"
+
+ # Sort by date
+ if "HistoricalDate" in data.columns:
+ data = data.sort_values("HistoricalDate")
+
+ csv_string = data.to_csv(index=False)
+
+ header = f"# Index data for {index_name} from {start_date} to {end_date}\n"
+ header += f"# Total records: {len(data)}\n"
+ header += f"# Data source: NSE India via jugaad-data\n"
+ header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+
+ return header + csv_string
+
+ except Exception as e:
+ return f"Error fetching index data for {index_name}: {str(e)}"
+
+
+def get_jugaad_indicators(
+ symbol: Annotated[str, "ticker symbol of the company"],
+ indicator: Annotated[str, "technical indicator to calculate"],
+ curr_date: Annotated[str, "The current trading date, YYYY-mm-dd"],
+ look_back_days: Annotated[int, "how many days to look back"] = 30,
+) -> str:
+ """
+ Calculate technical indicators for NSE stocks using jugaad-data.
+ This fetches data and calculates indicators using stockstats.
+
+ Args:
+ symbol: NSE stock symbol
+ indicator: Technical indicator name
+ curr_date: Current date for calculation
+ look_back_days: Number of days to look back
+
+ Returns:
+ Formatted string with indicator values
+
+ Raises:
+ ImportError: If required libraries not installed
+ Exception: For other errors (triggers fallback)
+ """
+ try:
+ from jugaad_data.nse import stock_df
+ from stockstats import wrap
+ except ImportError as e:
+ raise ImportError(f"Required library not installed: {e}")
+
+ nse_symbol = normalize_symbol(symbol, target="nse")
+
+ # Set timeout for NSE request
+ timeout_seconds = 15
+ old_handler = None
+
+ try:
+ # Set timeout using signal (only works on Unix)
+ try:
+ old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
+ signal.alarm(timeout_seconds)
+ except (AttributeError, ValueError):
+ pass
+
+ # Calculate date range - need more history for indicator calculation
+ curr_dt = datetime.strptime(curr_date, "%Y-%m-%d").date()
+ # Fetch extra data for indicator calculation (e.g., 200-day SMA needs 200+ days)
+ start_dt = date(curr_dt.year - 1, curr_dt.month, curr_dt.day) # 1 year back
+
+ data = stock_df(
+ symbol=nse_symbol,
+ from_date=start_dt,
+ to_date=curr_dt,
+ series="EQ"
+ )
+
+ # Cancel the alarm
+ try:
+ signal.alarm(0)
+ if old_handler:
+ signal.signal(signal.SIGALRM, old_handler)
+ except (AttributeError, ValueError):
+ pass
+
+ if data.empty:
+ raise ValueError(f"No data found for symbol '{nse_symbol}' to calculate {indicator}")
+
+ # Prepare data for stockstats
+ column_mapping = {
+ "DATE": "date",
+ "OPEN": "open",
+ "HIGH": "high",
+ "LOW": "low",
+ "CLOSE": "close",
+ "VOLUME": "volume",
+ }
+
+ for old_name, new_name in column_mapping.items():
+ if old_name in data.columns:
+ data = data.rename(columns={old_name: new_name})
+
+ # Wrap with stockstats
+ df = wrap(data)
+
+ # Calculate the indicator
+ df[indicator] # This triggers stockstats calculation
+
+ # Get the last N days of indicator values
+ from dateutil.relativedelta import relativedelta
+ result_data = []
+ curr_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
+ before = curr_date_dt - relativedelta(days=look_back_days)
+
+ df["date_str"] = pd.to_datetime(df["date"]).dt.strftime("%Y-%m-%d")
+
+ for _, row in df.iterrows():
+ row_date = datetime.strptime(row["date_str"], "%Y-%m-%d")
+ if before <= row_date <= curr_date_dt:
+ ind_value = row[indicator]
+ if pd.isna(ind_value):
+ result_data.append((row["date_str"], "N/A"))
+ else:
+ result_data.append((row["date_str"], str(round(ind_value, 4))))
+
+ result_data.sort(reverse=True) # Most recent first
+
+ result_str = f"## {indicator} values for {nse_symbol} (NSE) from {before.strftime('%Y-%m-%d')} to {curr_date}:\n\n"
+ for date_str, value in result_data:
+ result_str += f"{date_str}: {value}\n"
+
+ return result_str
+
+ except JugaadDataTimeoutError:
+ # Re-raise timeout to trigger fallback
+ raise
+ except Exception as e:
+ raise RuntimeError(f"Error calculating {indicator} for {nse_symbol}: {str(e)}")
diff --git a/tradingagents/dataflows/markets.py b/tradingagents/dataflows/markets.py
new file mode 100644
index 00000000..e5994bb1
--- /dev/null
+++ b/tradingagents/dataflows/markets.py
@@ -0,0 +1,172 @@
+"""
+Market configuration and stock lists for different markets.
+Supports US and Indian NSE (Nifty 50) stocks.
+"""
+
+from enum import Enum
+from typing import Optional
+
+
+class Market(Enum):
+ """Supported markets."""
+ US = "us"
+ INDIA_NSE = "india_nse"
+
+
+# Nifty 50 stocks with company names
+NIFTY_50_STOCKS = {
+ "RELIANCE": "Reliance Industries Ltd",
+ "TCS": "Tata Consultancy Services Ltd",
+ "HDFCBANK": "HDFC Bank Ltd",
+ "INFY": "Infosys Ltd",
+ "ICICIBANK": "ICICI Bank Ltd",
+ "HINDUNILVR": "Hindustan Unilever Ltd",
+ "ITC": "ITC Ltd",
+ "SBIN": "State Bank of India",
+ "BHARTIARTL": "Bharti Airtel Ltd",
+ "KOTAKBANK": "Kotak Mahindra Bank Ltd",
+ "LT": "Larsen & Toubro Ltd",
+ "AXISBANK": "Axis Bank Ltd",
+ "ASIANPAINT": "Asian Paints Ltd",
+ "MARUTI": "Maruti Suzuki India Ltd",
+ "HCLTECH": "HCL Technologies Ltd",
+ "SUNPHARMA": "Sun Pharmaceutical Industries Ltd",
+ "TITAN": "Titan Company Ltd",
+ "BAJFINANCE": "Bajaj Finance Ltd",
+ "WIPRO": "Wipro Ltd",
+ "ULTRACEMCO": "UltraTech Cement Ltd",
+ "NESTLEIND": "Nestle India Ltd",
+ "NTPC": "NTPC Ltd",
+ "POWERGRID": "Power Grid Corporation of India Ltd",
+ "M&M": "Mahindra & Mahindra Ltd",
+ "TATAMOTORS": "Tata Motors Ltd",
+ "ONGC": "Oil & Natural Gas Corporation Ltd",
+ "JSWSTEEL": "JSW Steel Ltd",
+ "TATASTEEL": "Tata Steel Ltd",
+ "ADANIENT": "Adani Enterprises Ltd",
+ "ADANIPORTS": "Adani Ports and SEZ Ltd",
+ "COALINDIA": "Coal India Ltd",
+ "BAJAJFINSV": "Bajaj Finserv Ltd",
+ "TECHM": "Tech Mahindra Ltd",
+ "HDFCLIFE": "HDFC Life Insurance Company Ltd",
+ "SBILIFE": "SBI Life Insurance Company Ltd",
+ "GRASIM": "Grasim Industries Ltd",
+ "DIVISLAB": "Divi's Laboratories Ltd",
+ "DRREDDY": "Dr. Reddy's Laboratories Ltd",
+ "CIPLA": "Cipla Ltd",
+ "BRITANNIA": "Britannia Industries Ltd",
+ "EICHERMOT": "Eicher Motors Ltd",
+ "APOLLOHOSP": "Apollo Hospitals Enterprise Ltd",
+ "INDUSINDBK": "IndusInd Bank Ltd",
+ "HEROMOTOCO": "Hero MotoCorp Ltd",
+ "TATACONSUM": "Tata Consumer Products Ltd",
+ "BPCL": "Bharat Petroleum Corporation Ltd",
+ "UPL": "UPL Ltd",
+ "HINDALCO": "Hindalco Industries Ltd",
+ "BAJAJ-AUTO": "Bajaj Auto Ltd",
+ "LTIM": "LTIMindtree Ltd",
+}
+
+
+def is_nifty_50_stock(symbol: str) -> bool:
+ """
+ Check if a symbol is a Nifty 50 stock.
+
+ Args:
+ symbol: Stock symbol (with or without .NS suffix)
+
+ Returns:
+ True if the symbol is in the Nifty 50 list
+ """
+ # Remove .NS suffix if present
+ clean_symbol = symbol.upper().replace(".NS", "")
+ return clean_symbol in NIFTY_50_STOCKS
+
+
+def get_nifty_50_company_name(symbol: str) -> Optional[str]:
+ """
+ Get the company name for a Nifty 50 stock symbol.
+
+ Args:
+ symbol: Stock symbol (with or without .NS suffix)
+
+ Returns:
+ Company name if found, None otherwise
+ """
+ clean_symbol = symbol.upper().replace(".NS", "")
+ return NIFTY_50_STOCKS.get(clean_symbol)
+
+
+def detect_market(symbol: str, config_market: str = "auto") -> Market:
+ """
+ Detect the market for a given symbol.
+
+ Args:
+ symbol: Stock symbol
+ config_market: Market setting from config ("auto", "us", "india_nse")
+
+ Returns:
+ Market enum indicating the detected market
+ """
+ if config_market == "india_nse":
+ return Market.INDIA_NSE
+ elif config_market == "us":
+ return Market.US
+
+ # Auto-detection
+ # Check if symbol has .NS suffix (yfinance format for NSE)
+ if symbol.upper().endswith(".NS"):
+ return Market.INDIA_NSE
+
+ # Check if symbol is in Nifty 50 list
+ if is_nifty_50_stock(symbol):
+ return Market.INDIA_NSE
+
+ # Default to US market
+ return Market.US
+
+
+def normalize_symbol(symbol: str, target: str = "yfinance") -> str:
+ """
+ Normalize a symbol for a specific data source.
+
+ Args:
+ symbol: Stock symbol
+ target: Target format ("yfinance", "jugaad", "nse")
+
+ Returns:
+ Normalized symbol for the target
+ """
+ clean_symbol = symbol.upper().replace(".NS", "")
+
+ if target == "yfinance":
+ # yfinance requires .NS suffix for NSE stocks
+ if is_nifty_50_stock(clean_symbol):
+ return f"{clean_symbol}.NS"
+ return clean_symbol
+
+ elif target in ("jugaad", "nse"):
+ # jugaad-data and NSE use symbols without suffix
+ return clean_symbol
+
+ return symbol.upper()
+
+
+def get_nifty_50_list() -> list:
+ """
+ Get list of all Nifty 50 stock symbols.
+
+ Returns:
+ List of Nifty 50 stock symbols
+ """
+ return list(NIFTY_50_STOCKS.keys())
+
+
+def get_nifty_50_with_names() -> dict:
+ """
+ Get dictionary of Nifty 50 stocks with company names.
+
+ Returns:
+ Dictionary mapping symbols to company names
+ """
+ return NIFTY_50_STOCKS.copy()
diff --git a/tradingagents/dataflows/y_finance.py b/tradingagents/dataflows/y_finance.py
index da7273d5..b6f109b3 100644
--- a/tradingagents/dataflows/y_finance.py
+++ b/tradingagents/dataflows/y_finance.py
@@ -4,6 +4,7 @@ from dateutil.relativedelta import relativedelta
import yfinance as yf
import os
from .stockstats_utils import StockstatsUtils
+from .markets import normalize_symbol, is_nifty_50_stock
def get_YFin_data_online(
symbol: Annotated[str, "ticker symbol of the company"],
@@ -14,8 +15,11 @@ def get_YFin_data_online(
datetime.strptime(start_date, "%Y-%m-%d")
datetime.strptime(end_date, "%Y-%m-%d")
+ # Normalize symbol for yfinance (adds .NS suffix for NSE stocks)
+ normalized_symbol = normalize_symbol(symbol, target="yfinance")
+
# Create ticker object
- ticker = yf.Ticker(symbol.upper())
+ ticker = yf.Ticker(normalized_symbol)
# Fetch historical data for the specified date range
data = ticker.history(start=start_date, end=end_date)
@@ -23,7 +27,7 @@ def get_YFin_data_online(
# Check if data is empty
if data.empty:
return (
- f"No data found for symbol '{symbol}' between {start_date} and {end_date}"
+ f"No data found for symbol '{normalized_symbol}' between {start_date} and {end_date}"
)
# Remove timezone info from index for cleaner output
@@ -40,7 +44,7 @@ def get_YFin_data_online(
csv_string = data.to_csv()
# Add header information
- header = f"# Stock data for {symbol.upper()} from {start_date} to {end_date}\n"
+ header = f"# Stock data for {normalized_symbol} from {start_date} to {end_date}\n"
header += f"# Total records: {len(data)}\n"
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
@@ -300,7 +304,9 @@ def get_balance_sheet(
):
"""Get balance sheet data from yfinance."""
try:
- ticker_obj = yf.Ticker(ticker.upper())
+ # Normalize symbol for yfinance (adds .NS suffix for NSE stocks)
+ normalized_ticker = normalize_symbol(ticker, target="yfinance")
+ ticker_obj = yf.Ticker(normalized_ticker)
if freq.lower() == "quarterly":
data = ticker_obj.quarterly_balance_sheet
@@ -308,19 +314,19 @@ def get_balance_sheet(
data = ticker_obj.balance_sheet
if data.empty:
- return f"No balance sheet data found for symbol '{ticker}'"
-
+ return f"No balance sheet data found for symbol '{normalized_ticker}'"
+
# Convert to CSV string for consistency with other functions
csv_string = data.to_csv()
-
+
# Add header information
- header = f"# Balance Sheet data for {ticker.upper()} ({freq})\n"
+ header = f"# Balance Sheet data for {normalized_ticker} ({freq})\n"
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
-
+
return header + csv_string
-
+
except Exception as e:
- return f"Error retrieving balance sheet for {ticker}: {str(e)}"
+ return f"Error retrieving balance sheet for {normalized_ticker}: {str(e)}"
def get_cashflow(
@@ -330,27 +336,29 @@ def get_cashflow(
):
"""Get cash flow data from yfinance."""
try:
- ticker_obj = yf.Ticker(ticker.upper())
-
+ # Normalize symbol for yfinance (adds .NS suffix for NSE stocks)
+ normalized_ticker = normalize_symbol(ticker, target="yfinance")
+ ticker_obj = yf.Ticker(normalized_ticker)
+
if freq.lower() == "quarterly":
data = ticker_obj.quarterly_cashflow
else:
data = ticker_obj.cashflow
-
+
if data.empty:
- return f"No cash flow data found for symbol '{ticker}'"
-
+ return f"No cash flow data found for symbol '{normalized_ticker}'"
+
# Convert to CSV string for consistency with other functions
csv_string = data.to_csv()
-
+
# Add header information
- header = f"# Cash Flow data for {ticker.upper()} ({freq})\n"
+ header = f"# Cash Flow data for {normalized_ticker} ({freq})\n"
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
-
+
return header + csv_string
-
+
except Exception as e:
- return f"Error retrieving cash flow for {ticker}: {str(e)}"
+ return f"Error retrieving cash flow for {normalized_ticker}: {str(e)}"
def get_income_statement(
@@ -360,27 +368,29 @@ def get_income_statement(
):
"""Get income statement data from yfinance."""
try:
- ticker_obj = yf.Ticker(ticker.upper())
-
+ # Normalize symbol for yfinance (adds .NS suffix for NSE stocks)
+ normalized_ticker = normalize_symbol(ticker, target="yfinance")
+ ticker_obj = yf.Ticker(normalized_ticker)
+
if freq.lower() == "quarterly":
data = ticker_obj.quarterly_income_stmt
else:
data = ticker_obj.income_stmt
-
+
if data.empty:
- return f"No income statement data found for symbol '{ticker}'"
-
+ return f"No income statement data found for symbol '{normalized_ticker}'"
+
# Convert to CSV string for consistency with other functions
csv_string = data.to_csv()
-
+
# Add header information
- header = f"# Income Statement data for {ticker.upper()} ({freq})\n"
+ header = f"# Income Statement data for {normalized_ticker} ({freq})\n"
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
-
+
return header + csv_string
-
+
except Exception as e:
- return f"Error retrieving income statement for {ticker}: {str(e)}"
+ return f"Error retrieving income statement for {normalized_ticker}: {str(e)}"
def get_insider_transactions(
@@ -388,20 +398,26 @@ def get_insider_transactions(
):
"""Get insider transactions data from yfinance."""
try:
- ticker_obj = yf.Ticker(ticker.upper())
+ # Normalize symbol for yfinance (adds .NS suffix for NSE stocks)
+ normalized_ticker = normalize_symbol(ticker, target="yfinance")
+ ticker_obj = yf.Ticker(normalized_ticker)
data = ticker_obj.insider_transactions
-
+
if data is None or data.empty:
- return f"No insider transactions data found for symbol '{ticker}'"
-
+ # Check if this is an NSE stock - insider data may not be available
+ if is_nifty_50_stock(ticker):
+ return (f"Note: SEC-style insider transaction data is not available for Indian NSE stocks like {normalized_ticker}. "
+ f"For Indian stocks, insider trading disclosures are filed with SEBI and available through NSE/BSE websites.")
+ return f"No insider transactions data found for symbol '{normalized_ticker}'"
+
# Convert to CSV string for consistency with other functions
csv_string = data.to_csv()
-
+
# Add header information
- header = f"# Insider Transactions data for {ticker.upper()}\n"
+ header = f"# Insider Transactions data for {normalized_ticker}\n"
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
-
+
return header + csv_string
-
+
except Exception as e:
- return f"Error retrieving insider transactions for {ticker}: {str(e)}"
\ No newline at end of file
+ return f"Error retrieving insider transactions for {normalized_ticker}: {str(e)}"
\ No newline at end of file
diff --git a/tradingagents/default_config.py b/tradingagents/default_config.py
index 1f40a2a2..57adff38 100644
--- a/tradingagents/default_config.py
+++ b/tradingagents/default_config.py
@@ -13,16 +13,30 @@ DEFAULT_CONFIG = {
"deep_think_llm": "o4-mini",
"quick_think_llm": "gpt-4o-mini",
"backend_url": "https://api.openai.com/v1",
+ # Anthropic-specific config for Claude models (using aliases for Claude Max subscription)
+ "anthropic_config": {
+ "deep_think_llm": "opus", # Claude Opus 4.5 for deep analysis
+ "quick_think_llm": "sonnet", # Claude Sonnet 4.5 for quick tasks
+ },
# Debate and discussion settings
"max_debate_rounds": 1,
"max_risk_discuss_rounds": 1,
"max_recur_limit": 100,
+ # Market configuration
+ # Options: "auto" (detect from symbol), "us", "india_nse"
+ # When set to "auto", Nifty 50 stocks are automatically detected and routed to NSE vendors
+ "market": "auto",
# Data vendor configuration
# Category-level configuration (default for all tools in category)
+ # For NSE stocks (when market is "auto" or "india_nse"):
+ # - core_stock_apis: jugaad_data (primary), yfinance (fallback)
+ # - technical_indicators: jugaad_data (primary), yfinance (fallback)
+ # - fundamental_data: yfinance (with .NS suffix)
+ # - news_data: google (with company name enhancement)
"data_vendors": {
- "core_stock_apis": "yfinance", # Options: yfinance, alpha_vantage, local
- "technical_indicators": "yfinance", # Options: yfinance, alpha_vantage, local
- "fundamental_data": "alpha_vantage", # Options: openai, alpha_vantage, local
+ "core_stock_apis": "yfinance", # Options: yfinance, alpha_vantage, local, jugaad_data
+ "technical_indicators": "yfinance", # Options: yfinance, alpha_vantage, local, jugaad_data
+ "fundamental_data": "alpha_vantage", # Options: openai, alpha_vantage, local, yfinance
"news_data": "alpha_vantage", # Options: openai, alpha_vantage, google, local
},
# Tool-level configuration (takes precedence over category-level)
diff --git a/tradingagents/graph/trading_graph.py b/tradingagents/graph/trading_graph.py
index 40cdff75..f1866d93 100644
--- a/tradingagents/graph/trading_graph.py
+++ b/tradingagents/graph/trading_graph.py
@@ -9,6 +9,7 @@ from typing import Dict, Any, Tuple, List, Optional
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI
+from tradingagents.claude_max_llm import ClaudeMaxLLM
from langgraph.prebuilt import ToolNode
@@ -76,8 +77,9 @@ class TradingAgentsGraph:
self.deep_thinking_llm = ChatOpenAI(model=self.config["deep_think_llm"], base_url=self.config["backend_url"])
self.quick_thinking_llm = ChatOpenAI(model=self.config["quick_think_llm"], base_url=self.config["backend_url"])
elif self.config["llm_provider"].lower() == "anthropic":
- self.deep_thinking_llm = ChatAnthropic(model=self.config["deep_think_llm"], base_url=self.config["backend_url"])
- self.quick_thinking_llm = ChatAnthropic(model=self.config["quick_think_llm"], base_url=self.config["backend_url"])
+ # Use ClaudeMaxLLM to leverage Claude Max subscription via CLI
+ self.deep_thinking_llm = ClaudeMaxLLM(model=self.config["deep_think_llm"])
+ self.quick_thinking_llm = ClaudeMaxLLM(model=self.config["quick_think_llm"])
elif self.config["llm_provider"].lower() == "google":
self.deep_thinking_llm = ChatGoogleGenerativeAI(model=self.config["deep_think_llm"])
self.quick_thinking_llm = ChatGoogleGenerativeAI(model=self.config["quick_think_llm"])
diff --git a/tradingagents/nifty50_recommender.py b/tradingagents/nifty50_recommender.py
new file mode 100644
index 00000000..15711274
--- /dev/null
+++ b/tradingagents/nifty50_recommender.py
@@ -0,0 +1,448 @@
+"""
+Nifty 50 Stock Recommendation System.
+
+This module predicts all 50 Nifty stocks and selects the ones with highest
+short-term growth potential using Claude Opus 4.5 via Claude Max subscription.
+"""
+
+import os
+# Disable CUDA to avoid library issues with embeddings
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+# Remove API key to force Claude Max subscription auth
+os.environ.pop("ANTHROPIC_API_KEY", None)
+
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Tuple
+from datetime import datetime
+
+from tradingagents.graph.trading_graph import TradingAgentsGraph
+from tradingagents.default_config import DEFAULT_CONFIG
+from tradingagents.dataflows.markets import NIFTY_50_STOCKS, get_nifty_50_list
+from tradingagents.claude_max_llm import ClaudeMaxLLM
+
+
+def verify_claude_cli() -> bool:
+ """
+ Verify that Claude CLI is available and authenticated.
+
+ Returns:
+ True if Claude CLI is available
+
+ Raises:
+ RuntimeError: If Claude CLI is not available or not authenticated
+ """
+ import subprocess
+
+ try:
+ result = subprocess.run(
+ ["claude", "--version"],
+ capture_output=True,
+ text=True,
+ timeout=10
+ )
+ if result.returncode == 0:
+ return True
+ except FileNotFoundError:
+ pass
+
+ raise RuntimeError(
+ "Claude CLI is not available.\n\n"
+ "To use this recommendation system with Claude Max subscription:\n"
+ "1. Install Claude Code: npm install -g @anthropic-ai/claude-code\n"
+ "2. Authenticate: claude auth login\n"
+ )
+
+
+def create_claude_config() -> Dict[str, Any]:
+ """
+ Create a configuration dictionary for using Claude models.
+
+ Returns:
+ Configuration dictionary with Anthropic settings
+ """
+ config = DEFAULT_CONFIG.copy()
+ config["llm_provider"] = "anthropic"
+ config["deep_think_llm"] = config["anthropic_config"]["deep_think_llm"]
+ config["quick_think_llm"] = config["anthropic_config"]["quick_think_llm"]
+ config["market"] = "india_nse"
+
+ # Use jugaad_data for NSE stocks
+ config["data_vendors"] = {
+ "core_stock_apis": "jugaad_data",
+ "technical_indicators": "jugaad_data",
+ "fundamental_data": "yfinance",
+ "news_data": "google",
+ }
+
+ return config
+
+
+def predict_stock(
+ graph: TradingAgentsGraph,
+ symbol: str,
+ trade_date: str
+) -> Dict[str, Any]:
+ """
+ Run prediction for a single stock.
+
+ Args:
+ graph: The TradingAgentsGraph instance
+ symbol: Stock symbol (e.g., 'RELIANCE', 'TCS')
+ trade_date: Date for the prediction (YYYY-MM-DD format)
+
+ Returns:
+ Dictionary containing prediction results including decision,
+ market report, fundamentals report, news report, investment plan,
+ and final trade decision
+ """
+ try:
+ final_state, decision = graph.propagate(symbol, trade_date)
+
+ return {
+ "symbol": symbol,
+ "company_name": NIFTY_50_STOCKS.get(symbol, symbol),
+ "decision": decision,
+ "market_report": final_state.get("market_report", ""),
+ "fundamentals_report": final_state.get("fundamentals_report", ""),
+ "news_report": final_state.get("news_report", ""),
+ "sentiment_report": final_state.get("sentiment_report", ""),
+ "investment_plan": final_state.get("investment_plan", ""),
+ "final_trade_decision": final_state.get("final_trade_decision", ""),
+ "investment_debate": {
+ "bull_history": final_state.get("investment_debate_state", {}).get("bull_history", ""),
+ "bear_history": final_state.get("investment_debate_state", {}).get("bear_history", ""),
+ "judge_decision": final_state.get("investment_debate_state", {}).get("judge_decision", ""),
+ },
+ "risk_debate": {
+ "risky_history": final_state.get("risk_debate_state", {}).get("risky_history", ""),
+ "safe_history": final_state.get("risk_debate_state", {}).get("safe_history", ""),
+ "neutral_history": final_state.get("risk_debate_state", {}).get("neutral_history", ""),
+ "judge_decision": final_state.get("risk_debate_state", {}).get("judge_decision", ""),
+ },
+ "error": None,
+ }
+ except Exception as e:
+ return {
+ "symbol": symbol,
+ "company_name": NIFTY_50_STOCKS.get(symbol, symbol),
+ "decision": None,
+ "error": str(e),
+ }
+
+
+def predict_all_nifty50(
+ trade_date: str,
+ config: Optional[Dict[str, Any]] = None,
+ stock_subset: Optional[List[str]] = None,
+ on_progress: Optional[callable] = None
+) -> Dict[str, Dict[str, Any]]:
+ """
+ Run predictions for all 50 Nifty stocks (or a subset).
+
+ Args:
+ trade_date: Date for the predictions (YYYY-MM-DD format)
+ config: Optional configuration dictionary. If None, uses Claude config
+ stock_subset: Optional list of stock symbols to analyze. If None, analyzes all 50
+ on_progress: Optional callback function(current_index, total, symbol, result)
+
+ Returns:
+ Dictionary mapping stock symbols to their prediction results
+ """
+ if config is None:
+ config = create_claude_config()
+
+ # Verify Claude CLI is available for Max subscription
+ verify_claude_cli()
+
+ # Initialize the graph
+ graph = TradingAgentsGraph(
+ selected_analysts=["market", "social", "news", "fundamentals"],
+ debug=False,
+ config=config
+ )
+
+ # Get list of stocks to analyze
+ stocks = stock_subset if stock_subset else get_nifty_50_list()
+ total = len(stocks)
+
+ predictions = {}
+
+ for i, symbol in enumerate(stocks, 1):
+ result = predict_stock(graph, symbol, trade_date)
+ predictions[symbol] = result
+
+ if on_progress:
+ on_progress(i, total, symbol, result)
+
+ return predictions
+
+
+def format_predictions_for_prompt(predictions: Dict[str, Dict[str, Any]]) -> str:
+ """
+ Format all predictions into a comprehensive prompt for Claude.
+
+ Args:
+ predictions: Dictionary of prediction results
+
+ Returns:
+ Formatted string containing all predictions
+ """
+ formatted_parts = []
+
+ for symbol, pred in predictions.items():
+ if pred.get("error"):
+ formatted_parts.append(f"""
+=== {symbol} ({pred.get('company_name', symbol)}) ===
+ERROR: {pred['error']}
+""")
+ continue
+
+ formatted_parts.append(f"""
+=== {symbol} ({pred.get('company_name', symbol)}) ===
+
+DECISION: {pred.get('decision', 'N/A')}
+
+MARKET ANALYSIS:
+{pred.get('market_report', 'N/A')[:1000]}
+
+FUNDAMENTALS:
+{pred.get('fundamentals_report', 'N/A')[:1000]}
+
+NEWS & SENTIMENT:
+{pred.get('news_report', 'N/A')[:500]}
+{pred.get('sentiment_report', 'N/A')[:500]}
+
+INVESTMENT PLAN:
+{pred.get('investment_plan', 'N/A')[:500]}
+
+FINAL TRADE DECISION:
+{pred.get('final_trade_decision', 'N/A')[:500]}
+
+BULL/BEAR DEBATE SUMMARY:
+Bull: {pred.get('investment_debate', {}).get('bull_history', 'N/A')[:300]}
+Bear: {pred.get('investment_debate', {}).get('bear_history', 'N/A')[:300]}
+Judge: {pred.get('investment_debate', {}).get('judge_decision', 'N/A')[:300]}
+
+RISK ASSESSMENT:
+{pred.get('risk_debate', {}).get('judge_decision', 'N/A')[:300]}
+
+---
+""")
+
+ return "\n".join(formatted_parts)
+
+
+def parse_ranking_response(response_text: str) -> Dict[str, Any]:
+ """
+ Parse the ranking response from Claude.
+
+ Args:
+ response_text: Raw response text from Claude
+
+ Returns:
+ Dictionary containing parsed ranking results
+ """
+ return {
+ "raw_response": response_text,
+ "parsed": True,
+ }
+
+
+def rank_stocks_for_growth(
+ predictions: Dict[str, Dict[str, Any]],
+) -> Dict[str, Any]:
+ """
+ Use Claude Opus 4.5 to rank stocks by short-term growth potential.
+
+ Args:
+ predictions: Dictionary of prediction results for all stocks
+
+ Returns:
+ Dictionary containing ranking results with top picks and stocks to avoid
+ """
+ # Initialize Claude Opus via Max subscription
+ llm = ClaudeMaxLLM(model="opus")
+
+ # Filter out stocks with errors
+ valid_predictions = {
+ k: v for k, v in predictions.items()
+ if not v.get("error")
+ }
+
+ if not valid_predictions:
+ return {
+ "error": "No valid predictions to rank",
+ "top_picks": [],
+ "stocks_to_avoid": [],
+ }
+
+ # Format predictions for prompt
+ formatted = format_predictions_for_prompt(valid_predictions)
+
+ prompt = f"""You are an expert stock analyst specializing in the Indian equity market.
+Analyze the following predictions for Nifty 50 stocks and select the TOP 3 stocks with
+the highest short-term growth potential (1-2 weeks timeframe).
+
+For each stock, consider:
+1. BUY/SELL/HOLD decision and the confidence level
+2. Technical indicators and price momentum
+3. Fundamental strength (earnings, revenue, valuations)
+4. News sentiment and potential catalysts
+5. Risk factors and volatility
+
+STOCK PREDICTIONS:
+{formatted}
+
+Based on your comprehensive analysis, provide your recommendations in the following format:
+
+## TOP 3 PICKS FOR SHORT-TERM GROWTH
+
+### 1. TOP PICK: [SYMBOL]
+**Company:** [Company Name]
+**Recommendation:** [BUY/STRONG BUY]
+**Target Upside:** [X%]
+**Reasoning:** [2-3 sentences explaining why this is the top pick, citing specific data points]
+**Key Catalysts:** [List 2-3 near-term catalysts]
+**Risk Level:** [Low/Medium/High]
+
+### 2. SECOND PICK: [SYMBOL]
+**Company:** [Company Name]
+**Recommendation:** [BUY/STRONG BUY]
+**Target Upside:** [X%]
+**Reasoning:** [2-3 sentences]
+**Key Catalysts:** [List 2-3 near-term catalysts]
+**Risk Level:** [Low/Medium/High]
+
+### 3. THIRD PICK: [SYMBOL]
+**Company:** [Company Name]
+**Recommendation:** [BUY/STRONG BUY]
+**Target Upside:** [X%]
+**Reasoning:** [2-3 sentences]
+**Key Catalysts:** [List 2-3 near-term catalysts]
+**Risk Level:** [Low/Medium/High]
+
+## STOCKS TO AVOID
+
+List any stocks that show concerning signals and should be avoided:
+- [SYMBOL]: [Brief reason - e.g., "Bearish technical setup, negative news flow"]
+- [SYMBOL]: [Brief reason]
+
+## MARKET CONTEXT
+
+Provide a brief (2-3 sentences) overview of the current market conditions affecting these recommendations.
+
+## DISCLAIMER
+
+Include a brief investment disclaimer.
+"""
+
+ # Use Claude Opus 4.5's large context window
+ response = llm.invoke(prompt)
+
+ return {
+ "ranking_analysis": response.content,
+ "total_stocks_analyzed": len(valid_predictions),
+ "stocks_with_errors": len(predictions) - len(valid_predictions),
+ "timestamp": datetime.now().isoformat(),
+ }
+
+
+def run_recommendation(
+ trade_date: str,
+ stock_subset: Optional[List[str]] = None,
+ save_results: bool = True,
+ results_dir: Optional[str] = None,
+ verbose: bool = True
+) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]:
+ """
+ Main entry point for running the Nifty 50 recommendation system.
+
+ Args:
+ trade_date: Date for the predictions (YYYY-MM-DD format)
+ stock_subset: Optional list of stock symbols to analyze. If None, analyzes all 50
+ save_results: Whether to save results to disk
+ results_dir: Directory to save results. If None, uses default
+ verbose: Whether to print progress updates
+
+ Returns:
+ Tuple of (predictions dict, ranking results dict)
+ """
+ def progress_callback(current, total, symbol, result):
+ if verbose:
+ status = "✓" if not result.get("error") else "✗"
+ decision = result.get("decision", "ERROR") if not result.get("error") else "ERROR"
+ print(f"[{current}/{total}] {symbol}: {status} {decision}")
+
+ if verbose:
+ print(f"\n{'='*60}")
+ print(f"NIFTY 50 STOCK RECOMMENDATION SYSTEM")
+ print(f"{'='*60}")
+ print(f"Date: {trade_date}")
+ stocks = stock_subset if stock_subset else get_nifty_50_list()
+ print(f"Analyzing {len(stocks)} stocks...")
+ print(f"{'='*60}\n")
+
+ # Run predictions for all stocks
+ predictions = predict_all_nifty50(
+ trade_date=trade_date,
+ stock_subset=stock_subset,
+ on_progress=progress_callback
+ )
+
+ if verbose:
+ successful = sum(1 for p in predictions.values() if not p.get("error"))
+ print(f"\n{'='*60}")
+ print(f"Predictions Complete: {successful}/{len(predictions)} successful")
+ print(f"{'='*60}\n")
+ print("Ranking stocks with Claude Opus 4.5...")
+
+ # Rank stocks using Claude Opus 4.5
+ ranking = rank_stocks_for_growth(predictions)
+
+ if verbose:
+ print(f"\n{'='*60}")
+ print("RECOMMENDATION RESULTS")
+ print(f"{'='*60}\n")
+ print(ranking.get("ranking_analysis", "No ranking available"))
+
+ # Save results if requested
+ if save_results:
+ if results_dir is None:
+ results_dir = Path(DEFAULT_CONFIG["results_dir"]) / "nifty50_recommendations"
+ else:
+ results_dir = Path(results_dir)
+
+ results_dir.mkdir(parents=True, exist_ok=True)
+
+ # Save predictions
+ predictions_file = results_dir / f"predictions_{trade_date}.json"
+ with open(predictions_file, "w") as f:
+ # Convert to serializable format
+ serializable_predictions = {}
+ for symbol, pred in predictions.items():
+ serializable_predictions[symbol] = {
+ k: str(v) if not isinstance(v, (str, dict, list, type(None))) else v
+ for k, v in pred.items()
+ }
+ json.dump(serializable_predictions, f, indent=2)
+
+ # Save ranking
+ ranking_file = results_dir / f"ranking_{trade_date}.json"
+ with open(ranking_file, "w") as f:
+ json.dump(ranking, f, indent=2)
+
+ # Save readable report
+ report_file = results_dir / f"report_{trade_date}.md"
+ with open(report_file, "w") as f:
+ f.write(f"# Nifty 50 Stock Recommendation Report\n\n")
+ f.write(f"**Date:** {trade_date}\n\n")
+ f.write(f"**Stocks Analyzed:** {ranking.get('total_stocks_analyzed', 0)}\n\n")
+ f.write(f"**Generated:** {ranking.get('timestamp', 'N/A')}\n\n")
+ f.write("---\n\n")
+ f.write(ranking.get("ranking_analysis", "No ranking available"))
+
+ if verbose:
+ print(f"\nResults saved to: {results_dir}")
+
+ return predictions, ranking
diff --git a/tradingagents/nifty50_simple_recommender.py b/tradingagents/nifty50_simple_recommender.py
new file mode 100644
index 00000000..ba1fb28e
--- /dev/null
+++ b/tradingagents/nifty50_simple_recommender.py
@@ -0,0 +1,364 @@
+"""
+Simplified Nifty 50 Stock Recommendation System.
+
+This module uses Claude Max subscription (via CLI) to analyze pre-fetched stock data
+and provide recommendations. It bypasses the complex agent framework to work with
+Claude Max subscription without API keys.
+"""
+
+import os
+# Disable CUDA to avoid library issues with embeddings
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+# Remove API key to force Claude Max subscription auth
+os.environ.pop("ANTHROPIC_API_KEY", None)
+
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Tuple
+from datetime import datetime, timedelta
+
+from tradingagents.dataflows.markets import NIFTY_50_STOCKS, get_nifty_50_list
+from tradingagents.claude_max_llm import ClaudeMaxLLM
+
+# Import data fetching tools
+from tradingagents.agents.utils.agent_utils import (
+ get_stock_data,
+ get_indicators,
+ get_fundamentals,
+ get_news,
+)
+
+
+def fetch_stock_data(symbol: str, trade_date: str) -> Dict[str, str]:
+ """
+ Fetch all relevant data for a stock.
+
+ Args:
+ symbol: Stock symbol (e.g., 'TCS', 'RELIANCE')
+ trade_date: Date for analysis (YYYY-MM-DD)
+
+ Returns:
+ Dictionary with stock data, indicators, fundamentals, and news
+ """
+ # Calculate date range (10 days before trade date)
+ end_date = trade_date
+ start_date = (datetime.strptime(trade_date, "%Y-%m-%d") - timedelta(days=30)).strftime("%Y-%m-%d")
+
+ data = {}
+
+ # Fetch stock price data
+ try:
+ data["price_data"] = get_stock_data.invoke({
+ "symbol": symbol,
+ "start_date": start_date,
+ "end_date": end_date
+ })
+ except Exception as e:
+ data["price_data"] = f"Error fetching price data: {e}"
+
+ # Fetch technical indicators
+ try:
+ data["indicators"] = get_indicators.invoke({
+ "symbol": symbol,
+ "start_date": start_date,
+ "end_date": end_date
+ })
+ except Exception as e:
+ data["indicators"] = f"Error fetching indicators: {e}"
+
+ # Fetch fundamentals
+ try:
+ data["fundamentals"] = get_fundamentals.invoke({
+ "symbol": symbol
+ })
+ except Exception as e:
+ data["fundamentals"] = f"Error fetching fundamentals: {e}"
+
+ # Fetch news
+ try:
+ company_name = NIFTY_50_STOCKS.get(symbol, symbol)
+ data["news"] = get_news.invoke({
+ "symbol": symbol,
+ "company_name": company_name
+ })
+ except Exception as e:
+ data["news"] = f"Error fetching news: {e}"
+
+ return data
+
+
+def analyze_stock(symbol: str, data: Dict[str, str], llm: ClaudeMaxLLM) -> Dict[str, Any]:
+ """
+ Use Claude to analyze a stock based on pre-fetched data.
+
+ Args:
+ symbol: Stock symbol
+ data: Pre-fetched stock data
+ llm: ClaudeMaxLLM instance
+
+ Returns:
+ Analysis result with decision and reasoning
+ """
+ company_name = NIFTY_50_STOCKS.get(symbol, symbol)
+
+ prompt = f"""You are an expert stock analyst. Analyze the following data for {symbol} ({company_name}) and provide:
+1. A trading decision: BUY, SELL, or HOLD
+2. Confidence level: High, Medium, or Low
+3. Key reasoning (2-3 sentences)
+4. Risk assessment: High, Medium, or Low
+
+## Price Data (Last 30 days)
+{data.get('price_data', 'Not available')[:2000]}
+
+## Technical Indicators
+{data.get('indicators', 'Not available')[:2000]}
+
+## Fundamentals
+{data.get('fundamentals', 'Not available')[:2000]}
+
+## Recent News
+{data.get('news', 'Not available')[:1500]}
+
+Provide your analysis in this exact format:
+DECISION: [BUY/SELL/HOLD]
+CONFIDENCE: [High/Medium/Low]
+REASONING: [Your 2-3 sentence reasoning]
+RISK: [High/Medium/Low]
+TARGET: [Expected price movement in next 1-2 weeks, e.g., "+5%" or "-3%"]
+"""
+
+ try:
+ response = llm.invoke(prompt)
+ analysis_text = response.content
+
+ # Parse the response
+ result = {
+ "symbol": symbol,
+ "company_name": company_name,
+ "raw_analysis": analysis_text,
+ "error": None
+ }
+
+ # Extract structured data (handle markdown formatting like **DECISION:**)
+ import re
+ text_upper = analysis_text.upper()
+
+ # Look for DECISION
+ decision_match = re.search(r'\*?\*?DECISION:?\*?\*?\s*([A-Z]+)', text_upper)
+ if decision_match:
+ result["decision"] = decision_match.group(1).strip()
+
+ # Look for CONFIDENCE
+ confidence_match = re.search(r'\*?\*?CONFIDENCE:?\*?\*?\s*([A-Z]+)', text_upper)
+ if confidence_match:
+ result["confidence"] = confidence_match.group(1).strip()
+
+ # Look for RISK
+ risk_match = re.search(r'\*?\*?RISK:?\*?\*?\s*([A-Z]+)', text_upper)
+ if risk_match:
+ result["risk"] = risk_match.group(1).strip()
+
+ return result
+
+ except Exception as e:
+ return {
+ "symbol": symbol,
+ "company_name": company_name,
+ "decision": None,
+ "error": str(e)
+ }
+
+
+def analyze_all_stocks(
+ trade_date: str,
+ stock_subset: Optional[List[str]] = None,
+ on_progress: Optional[callable] = None
+) -> Dict[str, Dict[str, Any]]:
+ """
+ Analyze all Nifty 50 stocks (or a subset).
+
+ Args:
+ trade_date: Date for analysis
+ stock_subset: Optional list of symbols to analyze
+ on_progress: Optional callback(current, total, symbol, result)
+
+ Returns:
+ Dictionary of analysis results
+ """
+ # Initialize Claude LLM
+ llm = ClaudeMaxLLM(model="sonnet")
+
+ stocks = stock_subset if stock_subset else get_nifty_50_list()
+ total = len(stocks)
+ results = {}
+
+ for i, symbol in enumerate(stocks, 1):
+ # Fetch data
+ data = fetch_stock_data(symbol, trade_date)
+
+ # Analyze with Claude
+ analysis = analyze_stock(symbol, data, llm)
+ results[symbol] = analysis
+
+ if on_progress:
+ on_progress(i, total, symbol, analysis)
+
+ return results
+
+
+def rank_stocks(results: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+ """
+ Rank stocks by growth potential using Claude Opus.
+
+ Args:
+ results: Analysis results for all stocks
+
+ Returns:
+ Ranking with top picks
+ """
+ llm = ClaudeMaxLLM(model="opus")
+
+ # Build summary of all analyses
+ summaries = []
+ for symbol, analysis in results.items():
+ if analysis.get("error"):
+ continue
+ summaries.append(f"""
+{symbol} ({analysis.get('company_name', symbol)}):
+- Decision: {analysis.get('decision', 'N/A')}
+- Confidence: {analysis.get('confidence', 'N/A')}
+- Risk: {analysis.get('risk', 'N/A')}
+- Analysis: {analysis.get('raw_analysis', 'N/A')[:300]}
+""")
+
+ if not summaries:
+ return {"error": "No valid analyses to rank", "ranking": None}
+
+ prompt = f"""You are an expert stock analyst. Based on the following analyses of Nifty 50 stocks,
+identify the TOP 3 stocks with highest short-term growth potential (1-2 weeks).
+
+## Stock Analyses
+{''.join(summaries)}
+
+Provide your ranking in this format:
+
+## TOP 3 PICKS
+
+### 1. [SYMBOL] - TOP PICK
+**Decision:** [BUY/STRONG BUY]
+**Reason:** [2-3 sentences explaining why this is the top pick]
+**Risk Level:** [Low/Medium/High]
+
+### 2. [SYMBOL] - SECOND PICK
+**Decision:** [BUY]
+**Reason:** [2-3 sentences]
+**Risk Level:** [Low/Medium/High]
+
+### 3. [SYMBOL] - THIRD PICK
+**Decision:** [BUY]
+**Reason:** [2-3 sentences]
+**Risk Level:** [Low/Medium/High]
+
+## STOCKS TO AVOID
+List 2-3 stocks that should be avoided with brief reasons.
+"""
+
+ try:
+ response = llm.invoke(prompt)
+ return {
+ "ranking": response.content,
+ "stocks_analyzed": len(summaries),
+ "timestamp": datetime.now().isoformat()
+ }
+ except Exception as e:
+ return {"error": str(e), "ranking": None}
+
+
+def run_recommendation(
+ trade_date: str,
+ stock_subset: Optional[List[str]] = None,
+ save_results: bool = True,
+ results_dir: Optional[str] = None,
+ verbose: bool = True
+) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, Any]]:
+ """
+ Main entry point for the recommendation system.
+
+ Args:
+ trade_date: Date for analysis
+ stock_subset: Optional list of symbols
+ save_results: Whether to save results to disk
+ results_dir: Directory for results
+ verbose: Print progress
+
+ Returns:
+ Tuple of (analysis results, ranking)
+ """
+ def progress_callback(current, total, symbol, result):
+ if verbose:
+ status = "✓" if not result.get("error") else "✗"
+ decision = result.get("decision", "ERROR") if not result.get("error") else "ERROR"
+ print(f"[{current}/{total}] {symbol}: {status} {decision}")
+
+ if verbose:
+ print(f"\n{'='*60}")
+ print("NIFTY 50 STOCK RECOMMENDATION SYSTEM (Simple)")
+ print(f"{'='*60}")
+ print(f"Date: {trade_date}")
+ stocks = stock_subset if stock_subset else get_nifty_50_list()
+ print(f"Analyzing {len(stocks)} stocks...")
+ print(f"Using Claude Max subscription via CLI")
+ print(f"{'='*60}\n")
+
+ # Analyze all stocks
+ results = analyze_all_stocks(trade_date, stock_subset, progress_callback)
+
+ if verbose:
+ successful = sum(1 for r in results.values() if not r.get("error"))
+ print(f"\n{'='*60}")
+ print(f"Analysis Complete: {successful}/{len(results)} successful")
+ print(f"{'='*60}\n")
+ print("Ranking stocks with Claude Opus...")
+
+ # Rank stocks
+ ranking = rank_stocks(results)
+
+ if verbose:
+ print(f"\n{'='*60}")
+ print("RECOMMENDATION RESULTS")
+ print(f"{'='*60}\n")
+ if ranking.get("ranking"):
+ print(ranking["ranking"])
+ else:
+ print(f"Error: {ranking.get('error', 'Unknown error')}")
+
+ # Save results if requested
+ if save_results:
+ from tradingagents.default_config import DEFAULT_CONFIG
+ if results_dir is None:
+ results_dir = Path(DEFAULT_CONFIG["results_dir"]) / "nifty50_simple_recommendations"
+ else:
+ results_dir = Path(results_dir)
+
+ results_dir.mkdir(parents=True, exist_ok=True)
+
+ # Save analysis results
+ with open(results_dir / f"analysis_{trade_date}.json", "w") as f:
+ json.dump(results, f, indent=2, default=str)
+
+ # Save ranking
+ with open(results_dir / f"ranking_{trade_date}.json", "w") as f:
+ json.dump(ranking, f, indent=2, default=str)
+
+ # Save readable report
+ with open(results_dir / f"report_{trade_date}.md", "w") as f:
+ f.write(f"# Nifty 50 Stock Recommendation Report\n\n")
+ f.write(f"**Date:** {trade_date}\n\n")
+ f.write(f"**Stocks Analyzed:** {ranking.get('stocks_analyzed', 0)}\n\n")
+ f.write("---\n\n")
+ f.write(ranking.get("ranking", "No ranking available"))
+
+ if verbose:
+ print(f"\nResults saved to: {results_dir}")
+
+ return results, ranking
![](\"assets/TauricResearch.png\")