Skip to content

FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.

feat: Add new agents folder structure

rudrasheth0997da2cd16b
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.py
new file mode 100644
index 000000000..57783d74f
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/benjamin_graham_agent.py
@@ -0,0 +1,373 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class GrahamSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def benjamin_graham_agent(state: AgentState, agent_id: str = "benjamin_graham_agent"):
+ """
+ Benjamin Graham: Margin of safety, net-net stocks, mathematical approach
+ Focus: Quantitative screens, asset protection, statistical cheapness
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ graham_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Applying Graham's quantitative screens")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "total_assets", "current_assets",
+ "current_liabilities", "total_debt", "cash_and_equivalents",
+ "inventory", "accounts_receivable", "shareholders_equity"
+ ],
+ end_date,
+ period="annual",
+ limit=5,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Graham's systematic analyses
+ net_net_analysis = analyze_net_net_value(financial_line_items, market_cap)
+ defensive_criteria = analyze_defensive_investor_criteria(metrics, financial_line_items)
+ margin_of_safety = calculate_margin_of_safety(metrics, financial_line_items, market_cap)
+ earnings_stability = analyze_earnings_stability(financial_line_items)
+ asset_protection = analyze_asset_protection(financial_line_items, market_cap)
+
+ # Graham's systematic scoring
+ total_score = (
+ net_net_analysis["score"] * 0.3 +
+ defensive_criteria["score"] * 0.25 +
+ margin_of_safety["score"] * 0.2 +
+ earnings_stability["score"] * 0.15 +
+ asset_protection["score"] * 0.1
+ )
+
+ # Graham's mechanical approach
+ if total_score >= 7.0:
+ signal = "bullish"
+ elif total_score <= 3.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "net_net_analysis": net_net_analysis,
+ "defensive_criteria": defensive_criteria,
+ "margin_of_safety": margin_of_safety,
+ "earnings_stability": earnings_stability,
+ "asset_protection": asset_protection
+ }
+
+ graham_output = generate_graham_output(ticker, analysis_data, state, agent_id)
+
+ graham_analysis[ticker] = {
+ "signal": graham_output.signal,
+ "confidence": graham_output.confidence,
+ "reasoning": graham_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=graham_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(graham_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(graham_analysis, "Benjamin Graham Agent")
+
+ state["data"]["analyst_signals"][agent_id] = graham_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_net_net_value(financial_line_items: list, market_cap: float) -> dict:
+ """Graham's net-net working capital analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for net-net analysis"}
+
+ latest = financial_line_items[0]
+
+ # Calculate Net-Net Working Capital
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ # Conservative liquidation values
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ receivables = (latest.accounts_receivable * 0.85) if latest.accounts_receivable else 0
+ inventory = (latest.inventory * 0.5) if latest.inventory else 0
+
+ liquidation_value = cash + receivables + inventory
+ net_net_value = liquidation_value - current_liabilities - total_debt
+
+ if net_net_value > 0:
+ nnwc_ratio = net_net_value / market_cap
+ if nnwc_ratio > 0.5: # Trading below 50% of liquidation value
+ score += 5
+ details.append(f"Exceptional net-net: {nnwc_ratio:.1%} of market cap")
+ elif nnwc_ratio > 0.2:
+ score += 3
+ details.append(f"Good net-net value: {nnwc_ratio:.1%} of market cap")
+ else:
+ score += 1
+ details.append(f"Some net-net value: {nnwc_ratio:.1%} of market cap")
+ else:
+ details.append("No net-net working capital protection")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_defensive_investor_criteria(metrics: list, financial_line_items: list) -> dict:
+ """Graham's 10 criteria for defensive investors"""
+ score = 0
+ criteria_met = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No data for defensive criteria"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # 1. Size requirement (large company)
+ if latest_financial.revenue and latest_financial.revenue > 100_000_000: # $100M+ revenue
+ criteria_met += 1
+ details.append("✓ Adequate size")
+
+ # 2. Strong financial condition (current ratio > 2)
+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 2.0:
+ criteria_met += 1
+ details.append(f"✓ Strong current ratio: {latest_metrics.current_ratio:.1f}")
+
+ # 3. Earnings stability (positive earnings last 10 years)
+ earnings_history = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings_history) >= 5:
+ positive_years = sum(1 for e in earnings_history if e > 0)
+ if positive_years == len(earnings_history):
+ criteria_met += 1
+ details.append(f"✓ Earnings stability: {positive_years}/{len(earnings_history)} positive years")
+
+ # 4. Dividend record (consistent dividends)
+ # Note: Would need dividend data, assuming if profitable and mature
+ if latest_financial.net_income and latest_financial.net_income > 0:
+ criteria_met += 0.5 # Partial credit
+ details.append("? Dividend assumption based on profitability")
+
+ # 5. Earnings growth (33% increase over 10 years)
+ if len(earnings_history) >= 5:
+ if earnings_history[0] > earnings_history[-1] * 1.33:
+ criteria_met += 1
+ details.append("✓ Adequate earnings growth")
+
+ # 6. Moderate P/E ratio
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15:
+ criteria_met += 1
+ details.append(f"✓ Reasonable P/E: {latest_metrics.price_to_earnings:.1f}")
+
+ # 7. Moderate P/B ratio
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:
+ criteria_met += 1
+ details.append(f"✓ Conservative P/B: {latest_metrics.price_to_book:.1f}")
+
+ # 8-10. Additional safety criteria
+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity < 0.5:
+ criteria_met += 1
+ details.append(f"✓ Low debt: {latest_metrics.debt_to_equity:.2f} D/E")
+
+ score = (criteria_met / 8) * 10 # Normalize to 10-point scale
+
+ return {
+ "score": score,
+ "criteria_met": criteria_met,
+ "details": "; ".join(details)
+ }
+
+
+def calculate_margin_of_safety(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Graham's margin of safety calculation"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for margin of safety"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # Book value approach
+ if latest_financial.shareholders_equity and latest_financial.shareholders_equity > 0:
+ book_value = latest_financial.shareholders_equity
+ pb_ratio = market_cap / book_value
+
+ if pb_ratio < 0.67: # Trading below 2/3 of book value
+ score += 4
+ details.append(f"Excellent margin of safety: {pb_ratio:.2f} P/B")
+ elif pb_ratio < 1.0:
+ score += 2
+ details.append(f"Good margin of safety: {pb_ratio:.2f} P/B")
+
+ # Earnings approach (conservative P/E)
+ if latest_financial.net_income and latest_financial.net_income > 0:
+ pe_ratio = market_cap / latest_financial.net_income
+
+ if pe_ratio < 10:
+ score += 3
+ details.append(f"Conservative earnings multiple: {pe_ratio:.1f} P/E")
+ elif pe_ratio < 15:
+ score += 1
+ details.append(f"Reasonable earnings multiple: {pe_ratio:.1f} P/E")
+
+ # Asset coverage
+ if latest_financial.total_assets and latest_financial.total_debt:
+ asset_coverage = latest_financial.total_assets / latest_financial.total_debt
+ if asset_coverage > 2.0:
+ score += 2
+ details.append(f"Strong asset coverage: {asset_coverage:.1f}x")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_earnings_stability(financial_line_items: list) -> dict:
+ """Graham emphasized earnings stability over growth"""
+ score = 0
+ details = []
+
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) < 3:
+ return {"score": 0, "details": "Insufficient earnings history"}
+
+ # No losses in recent years
+ losses = sum(1 for e in earnings if e < 0)
+ if losses == 0:
+ score += 3
+ details.append("No losses in available periods")
+ elif losses <= 1:
+ score += 1
+ details.append(f"Only {losses} loss year")
+
+ # Earnings consistency (low volatility)
+ if earnings:
+ avg_earnings = sum(earnings) / len(earnings)
+ volatility = sum((e - avg_earnings) ** 2 for e in earnings) / len(earnings)
+ coefficient_of_variation = (volatility ** 0.5) / abs(avg_earnings) if avg_earnings != 0 else float('inf')
+
+ if coefficient_of_variation < 0.3:
+ score += 2
+ details.append(f"Low earnings volatility: {coefficient_of_variation:.2f} CV")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_asset_protection(financial_line_items: list, market_cap: float) -> dict:
+ """Graham's focus on asset protection for bondholders and stockholders"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No asset data"}
+
+ latest = financial_line_items[0]
+
+ # Working capital adequacy
+ if latest.current_assets and latest.current_liabilities:
+ working_capital = latest.current_assets - latest.current_liabilities
+ if working_capital > 0:
+ wc_ratio = working_capital / market_cap
+ if wc_ratio > 0.3:
+ score += 2
+ details.append(f"Strong working capital: {wc_ratio:.1%} of market cap")
+
+ # Debt coverage
+ if latest.total_assets and latest.total_debt:
+ if latest.total_debt == 0:
+ score += 3
+ details.append("Debt-free company")
+ else:
+ debt_ratio = latest.total_debt / latest.total_assets
+ if debt_ratio < 0.3:
+ score += 2
+ details.append(f"Conservative debt: {debt_ratio:.1%} of assets")
+
+ # Tangible book value
+ if latest.shareholders_equity:
+ tangible_equity = latest.shareholders_equity # Simplified
+ if tangible_equity > market_cap * 0.5:
+ score += 2
+ details.append("Trading below tangible book value")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_graham_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> GrahamSignal:
+ """Generate Graham-style systematic investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Benjamin Graham's AI agent, the father of value investing. Follow his systematic approach:
+
+ 1. Mathematical and quantitative analysis over speculation
+ 2. Margin of safety: "Price is what you pay, value is what you get"
+ 3. Net-net working capital for maximum safety
+ 4. Defensive investor criteria: 10-point checklist
+ 5. Asset protection: Focus on balance sheet strength
+ 6. Earnings stability over growth
+ 7. Systematic approach: Remove emotion from investing
+ 8. Statistical cheapness: Buy groups of undervalued securities
+
+ Reasoning style:
+ - Emphasize quantitative metrics and ratios
+ - Focus on asset protection and balance sheet
+ - Stress margin of safety in every decision
+ - Use systematic, unemotional language
+ - Prefer statistical evidence over narratives
+ - Always consider downside protection first
+
+ Return bullish only for statistically cheap, safe companies with adequate margin of safety."""),
+
+ ("human", """Apply Graham's systematic analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_graham_signal():
+ return GrahamSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=GrahamSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_graham_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.py
new file mode 100644
index 000000000..0f09434d9
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/bill_miller_agent.py
@@ -0,0 +1,376 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class MillerSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def bill_miller_agent(state: AgentState, agent_id: str = "bill_miller_agent"):
+ """
+ Bill Miller: Concentrated value, contrarian timing
+ Focus: Technology value plays, contrarian bets, concentrated positions
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ miller_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Analyzing contrarian value opportunity")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=7, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_assets",
+ "shareholders_equity", "total_debt", "research_and_development",
+ "operating_income", "outstanding_shares"
+ ],
+ end_date,
+ period="annual",
+ limit=7,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Miller's analytical framework
+ contrarian_opportunity = analyze_contrarian_setup(metrics, financial_line_items, market_cap)
+ technology_value = analyze_technology_value_potential(financial_line_items, market_cap)
+ long_term_drivers = analyze_long_term_growth_drivers(financial_line_items)
+ market_misperception = identify_market_misperceptions(metrics, financial_line_items)
+ concentration_worthiness = evaluate_concentration_candidate(metrics, financial_line_items, market_cap)
+
+ # Miller's conviction-weighted scoring
+ total_score = (
+ contrarian_opportunity["score"] * 0.3 +
+ concentration_worthiness["score"] * 0.25 +
+ technology_value["score"] * 0.2 +
+ long_term_drivers["score"] * 0.15 +
+ market_misperception["score"] * 0.1
+ )
+
+ # Miller's high-conviction approach
+ if total_score >= 8.0:
+ signal = "bullish"
+ elif total_score <= 4.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "contrarian_opportunity": contrarian_opportunity,
+ "technology_value": technology_value,
+ "long_term_drivers": long_term_drivers,
+ "market_misperception": market_misperception,
+ "concentration_worthiness": concentration_worthiness
+ }
+
+ miller_output = generate_miller_output(ticker, analysis_data, state, agent_id)
+
+ miller_analysis[ticker] = {
+ "signal": miller_output.signal,
+ "confidence": miller_output.confidence,
+ "reasoning": miller_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=miller_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(miller_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(miller_analysis, "Bill Miller Agent")
+
+ state["data"]["analyst_signals"][agent_id] = miller_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_contrarian_setup(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Miller's contrarian opportunity identification"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No contrarian data"}
+
+ latest_metrics = metrics[0]
+
+ # Extreme valuation as contrarian signal
+ if latest_metrics.price_to_earnings:
+ if latest_metrics.price_to_earnings < 8: # Extremely cheap
+ score += 3
+ details.append(f"Extreme valuation contrarian setup: {latest_metrics.price_to_earnings:.1f} P/E")
+ elif latest_metrics.price_to_earnings < 12:
+ score += 2
+ details.append(f"Attractive contrarian valuation: {latest_metrics.price_to_earnings:.1f} P/E")
+
+ # Market sentiment indicators
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.0:
+ score += 2
+ details.append(f"Market pessimism: {latest_metrics.price_to_book:.2f} P/B below 1.0")
+
+ # Temporary business challenges creating opportunity
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(earnings) >= 5 and len(revenues) >= 5:
+ recent_earnings_decline = earnings[0] < earnings[2] # Current vs 2 years ago
+ revenue_resilience = revenues[0] > revenues[2] * 0.9 # Revenue holding up
+
+ if recent_earnings_decline and revenue_resilience:
+ score += 2
+ details.append("Temporary earnings pressure with revenue resilience - contrarian opportunity")
+
+ # Technology disruption creating value
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals[:3]) / sum(revenues[:3]) if len(revenues) >= 3 else 0
+ if rd_intensity > 0.1: # 10%+ R&D intensity
+ score += 1
+ details.append(f"High R&D investment for future positioning: {rd_intensity:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_technology_value_potential(financial_line_items: list, market_cap: float) -> dict:
+ """Miller's technology value analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No technology data"}
+
+ latest = financial_line_items[0]
+
+ # Asset-light technology model
+ if latest.total_assets and latest.revenue:
+ asset_turnover = latest.revenue / latest.total_assets
+ if asset_turnover > 1.0: # Efficient asset utilization
+ score += 2
+ details.append(f"Asset-efficient model: {asset_turnover:.1f}x turnover")
+
+ # Scalability indicators
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ margins = []
+ for item in financial_line_items:
+ if item.operating_income and item.revenue and item.revenue > 0:
+ margins.append(item.operating_income / item.revenue)
+
+ if len(revenues) >= 3 and len(margins) >= 3:
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ margin_expansion = margins[0] - margins[-1]
+
+ if revenue_growth > 0.1 and margin_expansion > 0.02: # Growth with margin expansion
+ score += 3
+ details.append(f"Scalable growth: {revenue_growth:.1%} revenue CAGR with margin expansion")
+
+ # R&D efficiency
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ if rd_vals and revenues:
+ rd_to_revenue = rd_vals[0] / revenues[0] if revenues[0] > 0 else 0
+ if 0.05 <= rd_to_revenue <= 0.2: # 5-20% R&D ratio
+ score += 1
+ details.append(f"Strategic R&D investment: {rd_to_revenue:.1%} of revenue")
+
+ # Network effects and switching costs (proxy)
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_margin = latest.free_cash_flow / latest.revenue if latest.revenue > 0 else 0
+ if fcf_margin > 0.2: # 20%+ FCF margin
+ score += 2
+ details.append(f"High-margin business model: {fcf_margin:.1%} FCF margin")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_long_term_growth_drivers(financial_line_items: list) -> dict:
+ """Miller's long-term growth potential analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No growth data"}
+
+ # Consistent revenue growth trend
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ if growth_years >= len(revenues) * 0.8: # 80%+ growth years
+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ score += 2
+ details.append(f"Consistent growth track record: {revenue_cagr:.1%} CAGR")
+
+ # Reinvestment for growth
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ if rd_vals and len(rd_vals) >= 3:
+ rd_growth = (rd_vals[0] / rd_vals[-1]) ** (1 / len(rd_vals)) - 1
+ if rd_growth > 0.1: # 10%+ R&D growth
+ score += 1
+ details.append(f"Growing R&D investment: {rd_growth:.1%} CAGR")
+
+ # Market expansion capability
+ if latest.total_assets and latest.shareholders_equity:
+ leverage_capacity = (latest.total_assets - latest.shareholders_equity) / latest.shareholders_equity
+ if leverage_capacity < 0.5: # Low leverage = expansion capacity
+ score += 1
+ details.append("Balance sheet capacity for growth investments")
+
+ # Free cash flow reinvestment
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals and revenues:
+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)
+ if positive_fcf_years >= len(fcf_vals) * 0.8: # Consistent cash generation
+ score += 2
+ details.append(f"Self-funding growth capability: {positive_fcf_years}/{len(fcf_vals)} positive FCF years")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def identify_market_misperceptions(metrics: list, financial_line_items: list) -> dict:
+ """Miller's market misperception identification"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No misperception data"}
+
+ latest_metrics = metrics[0]
+
+ # Quality company trading at value multiple
+ if (latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15 and
+ latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15):
+ score += 3
+ details.append(
+ f"Quality-value disconnect: {latest_metrics.return_on_equity:.1%} ROE at {latest_metrics.price_to_earnings:.1f} P/E")
+
+ # Growth company with temporary headwinds
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(earnings) >= 5 and len(revenues) >= 5:
+ historical_earnings_growth = (earnings[-1] / earnings[-3]) ** (1 / 2) - 1 # Earlier period growth
+ recent_earnings_decline = earnings[0] < earnings[1]
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+
+ if historical_earnings_growth > 0.15 and recent_earnings_decline and revenue_growth > 0.05:
+ score += 2
+ details.append("Historical growth company with temporary earnings setback")
+
+ # Asset value not recognized
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.2:
+ latest_financial = financial_line_items[0]
+ if latest_financial.total_assets and latest_financial.total_debt:
+ tangible_assets = latest_financial.total_assets - latest_financial.total_debt
+ if tangible_assets > 0:
+ score += 1
+ details.append(f"Asset value misperception: {latest_metrics.price_to_book:.2f} P/B")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def evaluate_concentration_candidate(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Miller's concentrated portfolio candidate evaluation"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No concentration data"}
+
+ latest_metrics = metrics[0]
+
+ # High conviction criteria
+ # Strong competitive position
+ if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.18:
+ score += 2
+ details.append(f"Strong competitive position: {latest_metrics.return_on_equity:.1%} ROE")
+
+ # Significant upside potential
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 12:
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if earnings:
+ # Assume normal multiple of 18x
+ upside_potential = (18 * earnings[0]) / market_cap - 1
+ if upside_potential > 0.5: # 50%+ upside
+ score += 3
+ details.append(f"Significant upside potential: {upside_potential:.1%}")
+
+ # Business model durability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues and len(revenues) >= 7:
+ revenue_consistency = len([r for r in revenues if r > min(revenues) * 1.1]) / len(revenues)
+ if revenue_consistency > 0.8: # 80%+ years above minimum
+ score += 2
+ details.append("Durable business model with consistent revenue growth")
+
+ # Management execution track record
+ if latest_metrics.return_on_invested_capital and latest_metrics.return_on_invested_capital > 0.12:
+ score += 1
+ details.append(f"Strong capital allocation: {latest_metrics.return_on_invested_capital:.1%} ROIC")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_miller_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MillerSignal:
+ """Generate Miller-style contrarian value decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Bill Miller's AI agent, applying contrarian value investing with technology focus:
+
+ 1. Contrarian timing: Buy when others are selling, especially in technology
+ 2. Concentrated bets: Make large positions in high-conviction ideas
+ 3. Technology value: Find undervalued technology and growth companies
+ 4. Long-term perspective: Focus on 3-5 year value creation
+ 5. Market misperceptions: Identify when market misprices quality companies
+ 6. Fundamental analysis: Deep research into business models and competitive advantages
+ 7. Patient opportunism: Wait for exceptional risk/reward opportunities
+
+ Reasoning style:
+ - Emphasize contrarian opportunities and market misperceptions
+ - Focus on technology companies trading at value multiples
+ - Discuss long-term growth drivers and competitive positioning
+ - Consider concentration worthiness and conviction level
+ - Express willingness to be different from consensus
+ - Analyze both current challenges and future potential
+ - Apply rigorous fundamental analysis
+
+ Return bullish for high-conviction contrarian opportunities with significant upside potential."""),
+
+ ("human", """Apply contrarian value analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_miller_signal():
+ return MillerSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=MillerSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_miller_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.py
new file mode 100644
index 000000000..df950b993
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/charlie_munger_agent.py
@@ -0,0 +1,374 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class MungerSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def charlie_munger_agent(state: AgentState, agent_id: str = "charlie_munger_agent"):
+ """
+ Charlie Munger: Mental models, quality businesses, patience
+ Focus: Multidisciplinary thinking, concentrated bets, long-term compounding
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ munger_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Applying multidisciplinary mental models")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "shareholders_equity",
+ "total_debt", "retained_earnings", "operating_margin",
+ "research_and_development", "outstanding_shares", "total_assets"
+ ],
+ end_date,
+ period="annual",
+ limit=10,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Munger's mental model analyses
+ business_quality = analyze_mental_model_quality(metrics, financial_line_items)
+ moat_durability = analyze_competitive_moat_durability(metrics, financial_line_items)
+ management_rationality = analyze_management_rationality(financial_line_items)
+ compound_growth = analyze_compounding_potential(financial_line_items)
+ incentive_alignment = analyze_incentive_structures(financial_line_items)
+
+ # Munger's weighted approach (fewer, better decisions)
+ total_score = (
+ business_quality["score"] * 0.3 +
+ moat_durability["score"] * 0.25 +
+ management_rationality["score"] * 0.2 +
+ compound_growth["score"] * 0.15 +
+ incentive_alignment["score"] * 0.1
+ )
+
+ # Munger's high-conviction approach
+ if total_score >= 8.5: # Very high bar
+ signal = "bullish"
+ elif total_score <= 3.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "business_quality": business_quality,
+ "moat_durability": moat_durability,
+ "management_rationality": management_rationality,
+ "compound_growth": compound_growth,
+ "incentive_alignment": incentive_alignment
+ }
+
+ munger_output = generate_munger_output(ticker, analysis_data, state, agent_id)
+
+ munger_analysis[ticker] = {
+ "signal": munger_output.signal,
+ "confidence": munger_output.confidence,
+ "reasoning": munger_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=munger_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(munger_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(munger_analysis, "Charlie Munger Agent")
+
+ state["data"]["analyst_signals"][agent_id] = munger_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_mental_model_quality(metrics: list, financial_line_items: list) -> dict:
+ """Munger's multidisciplinary analysis of business quality"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No data for quality analysis"}
+
+ # Psychology model: Customer psychology and habits
+ # Measured by revenue consistency and margin stability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues and len(revenues) >= 5:
+ revenue_volatility = (max(revenues) - min(revenues)) / max(revenues)
+ if revenue_volatility < 0.2: # Stable customer behavior
+ score += 2
+ details.append(f"Stable customer psychology: {revenue_volatility:.1%} revenue volatility")
+
+ # Economics model: High return on capital
+ roic_vals = [m.return_on_invested_capital for m in metrics if m.return_on_invested_capital]
+ if roic_vals:
+ avg_roic = sum(roic_vals) / len(roic_vals)
+ if avg_roic > 0.15: # 15%+ ROIC consistently
+ score += 3
+ details.append(f"Superior capital efficiency: {avg_roic:.1%} avg ROIC")
+
+ # Math model: Compound growth potential
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if len(earnings) >= 5:
+ cagr = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1
+ if cagr > 0.1: # 10%+ earnings CAGR
+ score += 2
+ details.append(f"Compounding machine: {cagr:.1%} earnings CAGR")
+
+ # Physics model: Competitive forces and market position
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ avg_margin = sum(margins) / len(margins)
+ if avg_margin > 0.2: # 20%+ operating margins
+ score += 2
+ details.append(f"Pricing power evidence: {avg_margin:.1%} avg operating margin")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_competitive_moat_durability(metrics: list, financial_line_items: list) -> dict:
+ """Munger's focus on durable competitive advantages"""
+ score = 0
+ details = []
+
+ if not metrics:
+ return {"score": 0, "details": "No metrics for moat analysis"}
+
+ # Consistent high returns (sign of moat)
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if roe_vals:
+ high_roe_years = sum(1 for roe in roe_vals if roe > 0.15)
+ if high_roe_years >= len(roe_vals) * 0.8: # 80% of years
+ score += 3
+ details.append(f"Durable high returns: {high_roe_years}/{len(roe_vals)} years ROE >15%")
+
+ # Market share stability (revenue growth matching/exceeding market)
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ growth_consistency = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ if growth_consistency >= len(revenues) * 0.7:
+ score += 2
+ details.append("Market position strength: consistent revenue progression")
+
+ # R&D efficiency (innovation moat)
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])
+ if 0.05 <= rd_intensity <= 0.15: # Efficient innovation spend
+ score += 2
+ details.append(f"Innovation moat: {rd_intensity:.1%} R&D efficiency")
+
+ # Capital requirements (barrier to entry)
+ assets = [item.total_assets for item in financial_line_items if item.total_assets]
+ if assets and revenues:
+ asset_turnover = revenues[0] / assets[0] if assets[0] > 0 else 0
+ if asset_turnover > 1.5: # Asset-light model
+ score += 1
+ details.append(f"Capital-efficient model: {asset_turnover:.1f}x asset turnover")
+ elif asset_turnover < 0.5: # High barriers
+ score += 1
+ details.append(f"High barriers to entry: {asset_turnover:.1f}x asset turnover")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_management_rationality(financial_line_items: list) -> dict:
+ """Munger's assessment of management decision-making"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No data for management analysis"}
+
+ # Capital allocation rationality
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ retained_earnings = [item.retained_earnings for item in financial_line_items if item.retained_earnings]
+
+ if len(retained_earnings) >= 3:
+ # Check if retained earnings are creating value
+ re_growth = (retained_earnings[0] - retained_earnings[-1]) / abs(retained_earnings[-1])
+ if re_growth > 0.5: # 50%+ growth in retained earnings
+ score += 2
+ details.append(f"Value-creating reinvestment: {re_growth:.1%} retained earnings growth")
+
+ # Share buyback rationality (buying when cheap)
+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+
+ if len(shares) >= 3 and len(earnings) >= 3:
+ share_reduction = (shares[-1] - shares[0]) / shares[-1]
+ earnings_growth = (earnings[0] - earnings[-1]) / earnings[-1]
+
+ if share_reduction > 0.05 and earnings_growth > share_reduction:
+ score += 2
+ details.append("Rational buybacks: reducing shares while growing earnings")
+
+ # Debt management
+ debt_vals = [item.total_debt for item in financial_line_items if item.total_debt is not None]
+ if debt_vals:
+ if all(debt <= debt_vals[0] * 1.1 for debt in debt_vals): # Controlled debt growth
+ score += 1
+ details.append("Conservative debt management")
+
+ # Dividend policy consistency
+ # Note: Would need dividend data for full analysis
+ if fcf_vals and all(fcf > 0 for fcf in fcf_vals):
+ score += 1
+ details.append("Consistent cash generation enables rational capital allocation")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_compounding_potential(financial_line_items: list) -> dict:
+ """Munger's emphasis on long-term compounding"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No data for compounding analysis"}
+
+ # Revenue compounding
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ if revenue_cagr > 0.1:
+ score += 2
+ details.append(f"Revenue compounding: {revenue_cagr:.1%} CAGR")
+
+ # Earnings compounding quality
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if len(earnings) >= 5:
+ earnings_cagr = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1
+ if earnings_cagr > revenue_cagr if 'revenue_cagr' in locals() else 0.08:
+ score += 2
+ details.append(f"Earnings leverage: {earnings_cagr:.1%} CAGR")
+
+ # Free cash flow compounding
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow and item.free_cash_flow > 0]
+ if len(fcf_vals) >= 3:
+ fcf_growth = (fcf_vals[0] / fcf_vals[-1]) ** (1 / len(fcf_vals)) - 1
+ if fcf_growth > 0.12: # 12%+ FCF growth
+ score += 3
+ details.append(f"Cash compounding: {fcf_growth:.1%} FCF CAGR")
+
+ # Reinvestment rate efficiency
+ if retained_earnings and len(retained_earnings) >= 3:
+ reinvestment_efficiency = earnings_cagr / (
+ retained_earnings[0] / revenues[0]) if 'earnings_cagr' in locals() and revenues else 0
+ if reinvestment_efficiency > 2.0: # High returns on reinvestment
+ score += 1
+ details.append("Efficient reinvestment compounding")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_incentive_structures(financial_line_items: list) -> dict:
+ """Munger's focus on proper incentive alignment"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No data for incentive analysis"}
+
+ # Management ownership alignment (proxy through performance)
+ # If management is aligned, we should see improving metrics over time
+
+ # Consistent margin improvement (management efficiency)
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if len(margins) >= 3:
+ margin_trend = sum(1 for i in range(len(margins) - 1) if margins[i] >= margins[i + 1])
+ if margin_trend >= len(margins) * 0.6:
+ score += 2
+ details.append("Management efficiency: improving operational margins")
+
+ # Capital efficiency improvement
+ assets = [item.total_assets for item in financial_line_items if item.total_assets]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(assets) >= 3 and len(revenues) >= 3:
+ recent_efficiency = revenues[0] / assets[0] if assets[0] > 0 else 0
+ older_efficiency = revenues[-1] / assets[-1] if assets[-1] > 0 else 0
+
+ if recent_efficiency > older_efficiency * 1.1:
+ score += 1
+ details.append("Improving capital efficiency over time")
+
+ # Long-term value creation focus
+ shareholders_equity = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]
+ if len(shareholders_equity) >= 5:
+ equity_cagr = (shareholders_equity[0] / shareholders_equity[-1]) ** (1 / len(shareholders_equity)) - 1
+ if equity_cagr > 0.1:
+ score += 2
+ details.append(f"Shareholder value creation: {equity_cagr:.1%} equity CAGR")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_munger_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MungerSignal:
+ """Generate Munger-style investment decision using mental models"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Charlie Munger's AI agent, applying multidisciplinary mental models to investing:
+
+ 1. Mental Models: Psychology, economics, math, physics applied to business analysis
+ 2. Quality over quantity: "It's better to buy a wonderful company at a fair price"
+ 3. Long-term compounding: "The first rule of compounding is to never interrupt it unnecessarily"
+ 4. Rational management: Assess capital allocation and incentive alignment
+ 5. Durable moats: Sustainable competitive advantages over decades
+ 6. Concentrated bets: "Diversification is protection against ignorance"
+ 7. Patience and discipline: Wait for exceptional opportunities
+
+ Reasoning style:
+ - Use multidisciplinary frameworks and analogies
+ - Emphasize long-term thinking and compounding
+ - Focus on business quality and management rationality
+ - Apply inverse thinking: "What could go wrong?"
+ - Reference mental models and psychological biases
+ - Express strong convictions when warranted
+ - Admit when outside circle of competence
+
+ Return bullish only for exceptional businesses with durable moats and rational management."""),
+
+ ("human", """Apply multidisciplinary mental models to analyze {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_munger_signal():
+ return MungerSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=MungerSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_munger_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.py
new file mode 100644
index 000000000..5a2e4284b
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/david_einhorn_agent.py
@@ -0,0 +1,410 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class EinhornSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def david_einhorn_agent(state: AgentState, agent_id: str = "david_einhorn_agent"):
+ """
+ David Einhorn: Short selling + value, forensic accounting
+ Focus: Accounting irregularities, overvalued shorts, undervalued longs
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ einhorn_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Conducting forensic accounting analysis")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "operating_income", "free_cash_flow",
+ "total_assets", "current_assets", "accounts_receivable",
+ "inventory", "total_debt", "shareholders_equity", "depreciation"
+ ],
+ end_date,
+ period="annual",
+ limit=5,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Einhorn's analytical framework
+ accounting_quality = analyze_accounting_quality(financial_line_items)
+ earnings_quality = analyze_earnings_vs_cash_flow(financial_line_items)
+ valuation_vs_reality = analyze_valuation_disconnect(metrics, financial_line_items, market_cap)
+ red_flags = identify_red_flags(financial_line_items)
+ fundamental_value = calculate_fundamental_value(financial_line_items, market_cap)
+
+ # Einhorn's long/short framework
+ total_score = (
+ accounting_quality["score"] * 0.25 +
+ earnings_quality["score"] * 0.25 +
+ fundamental_value["score"] * 0.2 +
+ valuation_vs_reality["score"] * 0.2 +
+ red_flags["score"] * 0.1
+ )
+
+ # Einhorn's approach: strong convictions both ways
+ if total_score >= 7.5:
+ signal = "bullish"
+ elif total_score <= 3.5:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "accounting_quality": accounting_quality,
+ "earnings_quality": earnings_quality,
+ "valuation_vs_reality": valuation_vs_reality,
+ "red_flags": red_flags,
+ "fundamental_value": fundamental_value
+ }
+
+ einhorn_output = generate_einhorn_output(ticker, analysis_data, state, agent_id)
+
+ einhorn_analysis[ticker] = {
+ "signal": einhorn_output.signal,
+ "confidence": einhorn_output.confidence,
+ "reasoning": einhorn_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=einhorn_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(einhorn_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(einhorn_analysis, "David Einhorn Agent")
+
+ state["data"]["analyst_signals"][agent_id] = einhorn_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_accounting_quality(financial_line_items: list) -> dict:
+ """Einhorn's forensic accounting analysis"""
+ score = 0
+ details = []
+ red_flags = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No accounting data"}
+
+ # Revenue quality analysis
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ receivables = [item.accounts_receivable for item in financial_line_items if item.accounts_receivable]
+
+ if len(revenues) >= 3 and len(receivables) >= 3:
+ # Days sales outstanding trend
+ recent_dso = (receivables[0] / revenues[0]) * 365 if revenues[0] > 0 else 0
+ older_dso = (receivables[-1] / revenues[-1]) * 365 if revenues[-1] > 0 else 0
+
+ if recent_dso > older_dso * 1.3: # 30%+ increase in DSO
+ red_flags.append("Deteriorating receivables collection")
+ score -= 2
+ elif recent_dso < older_dso * 1.1: # Stable or improving
+ score += 1
+ details.append("Stable receivables management")
+
+ # Inventory quality
+ inventories = [item.inventory for item in financial_line_items if item.inventory]
+ if len(inventories) >= 3 and len(revenues) >= 3:
+ recent_inventory_turns = revenues[0] / inventories[0] if inventories[0] > 0 else 0
+ older_inventory_turns = revenues[-1] / inventories[-1] if inventories[-1] > 0 else 0
+
+ if recent_inventory_turns < older_inventory_turns * 0.8: # Slowing turns
+ red_flags.append("Deteriorating inventory turns")
+ score -= 1
+ elif recent_inventory_turns > older_inventory_turns * 1.1:
+ score += 1
+ details.append("Improving inventory management")
+
+ # Asset quality
+ assets = [item.total_assets for item in financial_line_items if item.total_assets]
+ if len(assets) >= 3:
+ asset_growth = (assets[0] / assets[-1]) ** (1 / len(assets)) - 1
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 if revenues else 0
+
+ if asset_growth > revenue_growth * 1.5: # Assets growing much faster than revenue
+ red_flags.append("Asset growth exceeds revenue growth")
+ score -= 1
+ else:
+ score += 1
+ details.append("Reasonable asset growth relative to revenue")
+
+ if red_flags:
+ details.append(f"Red flags: {'; '.join(red_flags)}")
+
+ return {"score": score, "details": "; ".join(details), "red_flags": red_flags}
+
+
+def analyze_earnings_vs_cash_flow(financial_line_items: list) -> dict:
+ """Einhorn's earnings quality through cash flow analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No cash flow data"}
+
+ # Earnings vs cash flow divergence
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ cash_flows = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+
+ if len(earnings) >= 3 and len(cash_flows) >= 3:
+ # Compare cumulative earnings vs cash flow
+ total_earnings = sum(earnings)
+ total_cash_flow = sum(cash_flows)
+
+ if total_cash_flow > total_earnings * 0.8: # FCF is 80%+ of earnings
+ score += 2
+ details.append(f"Strong cash conversion: FCF/Earnings = {total_cash_flow / total_earnings:.2f}")
+ elif total_cash_flow < total_earnings * 0.5: # FCF is <50% of earnings
+ score -= 2
+ details.append(f"Poor cash conversion: FCF/Earnings = {total_cash_flow / total_earnings:.2f}")
+
+ # Accruals analysis (simplified)
+ if earnings and cash_flows:
+ recent_accruals = earnings[0] - cash_flows[0] if len(earnings) > 0 and len(cash_flows) > 0 else 0
+ if abs(recent_accruals) > abs(earnings[0]) * 0.3: # High accruals relative to earnings
+ score -= 1
+ details.append("High accruals relative to earnings - quality concern")
+ else:
+ score += 1
+ details.append("Reasonable accruals level")
+
+ # Consistency of cash generation
+ if cash_flows:
+ positive_fcf_years = sum(1 for fcf in cash_flows if fcf > 0)
+ if positive_fcf_years == len(cash_flows):
+ score += 2
+ details.append(f"Consistent cash generation: {positive_fcf_years}/{len(cash_flows)} years")
+ elif positive_fcf_years < len(cash_flows) * 0.6:
+ score -= 1
+ details.append("Inconsistent cash generation")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_valuation_disconnect(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Einhorn's analysis of valuation vs fundamental reality"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No valuation data"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # P/E vs growth analysis
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings > 0:
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if len(earnings) >= 3:
+ earnings_growth = (earnings[0] / earnings[-1]) ** (1 / len(earnings)) - 1
+ peg_ratio = latest_metrics.price_to_earnings / (earnings_growth * 100) if earnings_growth > 0 else float(
+ 'inf')
+
+ if peg_ratio < 1.0: # Undervalued relative to growth
+ score += 2
+ details.append(f"Attractive PEG ratio: {peg_ratio:.2f}")
+ elif peg_ratio > 2.0: # Overvalued relative to growth
+ score -= 2
+ details.append(f"Expensive PEG ratio: {peg_ratio:.2f}")
+
+ # Book value reality check
+ if latest_metrics.price_to_book:
+ if latest_metrics.price_to_book < 1.0: # Trading below book
+ score += 1
+ details.append(f"Trading below book value: {latest_metrics.price_to_book:.2f} P/B")
+ elif latest_metrics.price_to_book > 3.0 and latest_metrics.return_on_equity and latest_metrics.return_on_equity < 0.15:
+ score -= 2
+ details.append(
+ f"High P/B with mediocre ROE: {latest_metrics.price_to_book:.2f} P/B, {latest_metrics.return_on_equity:.1%} ROE")
+
+ # Asset-based valuation
+ if latest_financial.total_assets and latest_financial.total_debt:
+ tangible_book = latest_financial.total_assets - latest_financial.total_debt
+ if tangible_book > market_cap:
+ score += 2
+ details.append("Trading below tangible asset value")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def identify_red_flags(financial_line_items: list) -> dict:
+ """Einhorn's red flag identification system"""
+ score = 0
+ details = []
+ flags = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No data for red flag analysis"}
+
+ # Rapid asset growth without corresponding revenue growth
+ assets = [item.total_assets for item in financial_line_items if item.total_assets]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(assets) >= 3 and len(revenues) >= 3:
+ asset_cagr = (assets[0] / assets[-1]) ** (1 / len(assets)) - 1
+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+
+ if asset_cagr > revenue_cagr + 0.1: # Assets growing 10%+ faster than revenue
+ flags.append("Asset growth exceeds revenue growth")
+ score -= 2
+
+ # Declining margins with flat/growing revenue
+ margins = []
+ for item in financial_line_items:
+ if item.revenue and item.operating_income and item.revenue > 0:
+ margins.append(item.operating_income / item.revenue)
+
+ if len(margins) >= 3:
+ margin_trend = margins[0] - margins[-1]
+ if margin_trend < -0.05: # 5%+ margin decline
+ flags.append("Significant margin compression")
+ score -= 1
+
+ # Inconsistent cash flow patterns
+ cash_flows = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if cash_flows:
+ negative_years = sum(1 for fcf in cash_flows if fcf < 0)
+ if negative_years > len(cash_flows) * 0.4: # >40% negative FCF years
+ flags.append("Inconsistent cash generation")
+ score -= 1
+
+ # High receivables growth
+ receivables = [item.accounts_receivable for item in financial_line_items if item.accounts_receivable]
+ if len(receivables) >= 3 and len(revenues) >= 3:
+ receivables_growth = (receivables[0] / receivables[-1]) ** (1 / len(receivables)) - 1
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+
+ if receivables_growth > revenue_growth + 0.15: # Receivables growing 15%+ faster
+ flags.append("Receivables growing faster than revenue")
+ score -= 1
+
+ if not flags:
+ score += 2
+ details.append("No major red flags identified")
+ else:
+ details.append(f"Red flags: {'; '.join(flags)}")
+
+ return {"score": score, "details": "; ".join(details), "flags": flags}
+
+
+def calculate_fundamental_value(financial_line_items: list, market_cap: float) -> dict:
+ """Einhorn's fundamental valuation analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No fundamental data"}
+
+ latest = financial_line_items[0]
+
+ # Asset-based valuation
+ if latest.total_assets and latest.total_debt:
+ book_value = latest.total_assets - latest.total_debt
+ pb_ratio = market_cap / book_value if book_value > 0 else float('inf')
+
+ if pb_ratio < 1.0:
+ score += 3
+ details.append(f"Trading below book value: {pb_ratio:.2f} P/B")
+ elif pb_ratio < 1.5:
+ score += 1
+ details.append(f"Reasonable book value: {pb_ratio:.2f} P/B")
+
+ # Earnings-based valuation
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if earnings:
+ avg_earnings = sum(earnings) / len(earnings)
+ pe_ratio = market_cap / avg_earnings
+
+ if pe_ratio < 12:
+ score += 2
+ details.append(f"Low earnings multiple: {pe_ratio:.1f} P/E")
+ elif pe_ratio > 25:
+ score -= 1
+ details.append(f"High earnings multiple: {pe_ratio:.1f} P/E")
+
+ # Cash flow valuation
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_yield = latest.free_cash_flow / market_cap
+ if fcf_yield > 0.08: # 8%+ FCF yield
+ score += 2
+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")
+ elif fcf_yield < 0.03: # <3% FCF yield
+ score -= 1
+ details.append(f"Low FCF yield: {fcf_yield:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_einhorn_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> EinhornSignal:
+ """Generate Einhorn-style forensic analysis decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are David Einhorn's AI agent, applying forensic accounting and value analysis:
+
+ 1. Forensic accounting: Scrutinize financial statements for quality and red flags
+ 2. Earnings quality: Compare earnings to cash flows, analyze accruals
+ 3. Value vs. price: Identify disconnects between valuation and reality
+ 4. Short candidates: Find overvalued companies with accounting issues
+ 5. Long candidates: Find undervalued companies with clean accounting
+ 6. Red flag detection: Identify warning signs of financial manipulation
+ 7. Contrarian positioning: Take positions opposite to market sentiment
+
+ Reasoning style:
+ - Emphasize accounting quality and financial statement analysis
+ - Focus on earnings vs. cash flow divergences
+ - Identify specific red flags and warning signs
+ - Discuss valuation relative to fundamental reality
+ - Express skepticism toward popular stocks
+ - Provide detailed forensic analysis
+ - Consider both long and short opportunities
+
+ Return bullish for undervalued companies with clean accounting, bearish for overvalued companies with red flags."""),
+
+ ("human", """Apply forensic accounting analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_einhorn_signal():
+ return EinhornSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=EinhornSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_einhorn_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.py
new file mode 100644
index 000000000..c7fb040ce
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/howard_marks_agent.py
@@ -0,0 +1,396 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class MarksSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def howard_marks_agent(state: AgentState, agent_id: str = "howard_marks_agent"):
+ """
+ Howard Marks: Second-level thinking, risk assessment, cycles
+ Focus: Market psychology, risk-adjusted returns, contrarian positioning
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ marks_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Applying second-level thinking")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=7, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "total_assets", "operating_margin",
+ "current_assets", "current_liabilities"
+ ],
+ end_date,
+ period="annual",
+ limit=7,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Marks' analytical framework
+ risk_assessment = analyze_risk_factors(metrics, financial_line_items, market_cap)
+ cycle_positioning = analyze_cycle_position(metrics, financial_line_items)
+ second_level_thinking = apply_second_level_thinking(metrics, financial_line_items, market_cap)
+ market_psychology = analyze_market_psychology_indicators(metrics, market_cap)
+ asymmetric_returns = evaluate_asymmetric_opportunities(financial_line_items, market_cap)
+
+ # Marks' risk-adjusted scoring
+ total_score = (
+ risk_assessment["score"] * 0.3 +
+ second_level_thinking["score"] * 0.25 +
+ asymmetric_returns["score"] * 0.2 +
+ cycle_positioning["score"] * 0.15 +
+ market_psychology["score"] * 0.1
+ )
+
+ # Marks' nuanced approach
+ if total_score >= 7.5:
+ signal = "bullish"
+ elif total_score <= 4.5:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "risk_assessment": risk_assessment,
+ "cycle_positioning": cycle_positioning,
+ "second_level_thinking": second_level_thinking,
+ "market_psychology": market_psychology,
+ "asymmetric_returns": asymmetric_returns
+ }
+
+ marks_output = generate_marks_output(ticker, analysis_data, state, agent_id)
+
+ marks_analysis[ticker] = {
+ "signal": marks_output.signal,
+ "confidence": marks_output.confidence,
+ "reasoning": marks_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=marks_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(marks_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(marks_analysis, "Howard Marks Agent")
+
+ state["data"]["analyst_signals"][agent_id] = marks_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_risk_factors(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Marks' comprehensive risk assessment framework"""
+ score = 0
+ details = []
+ risk_factors = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No data for risk analysis"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # Financial leverage risk
+ if latest_metrics.debt_to_equity:
+ if latest_metrics.debt_to_equity < 0.3:
+ score += 2
+ details.append(f"Low leverage risk: {latest_metrics.debt_to_equity:.2f} D/E")
+ elif latest_metrics.debt_to_equity > 1.0:
+ risk_factors.append("High leverage risk")
+ score -= 1
+
+ # Earnings quality and sustainability
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings and len(earnings) >= 5:
+ earnings_volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))
+ if earnings_volatility < 0.5:
+ score += 2
+ details.append(f"Stable earnings pattern: {earnings_volatility:.2f} volatility")
+ else:
+ risk_factors.append("High earnings volatility")
+
+ # Liquidity risk
+ if latest_metrics.current_ratio:
+ if latest_metrics.current_ratio > 1.5:
+ score += 1
+ details.append(f"Adequate liquidity: {latest_metrics.current_ratio:.1f} current ratio")
+ elif latest_metrics.current_ratio < 1.0:
+ risk_factors.append("Liquidity concerns")
+ score -= 2
+
+ # Business model sustainability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues and len(revenues) >= 5:
+ revenue_trend = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ if revenue_trend >= len(revenues) * 0.7:
+ score += 1
+ details.append("Sustainable revenue pattern")
+ else:
+ risk_factors.append("Declining revenue trend")
+
+ # Margin compression risk
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and len(margins) >= 3:
+ margin_trend = margins[0] - margins[-1]
+ if margin_trend > 0.02: # 2% margin improvement
+ score += 1
+ details.append("Improving margin profile")
+ elif margin_trend < -0.05: # 5% margin decline
+ risk_factors.append("Margin compression risk")
+ score -= 1
+
+ if risk_factors:
+ details.append(f"Risk factors: {'; '.join(risk_factors)}")
+
+ return {"score": score, "details": "; ".join(details), "risk_factors": risk_factors}
+
+
+def analyze_cycle_position(metrics: list, financial_line_items: list) -> dict:
+ """Marks' cycle awareness analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No cycle data"}
+
+ # Revenue cycle analysis
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ # Analyze cyclical patterns
+ recent_growth = (revenues[0] / revenues[2]) ** (1 / 2) - 1 # 2-year CAGR
+ longer_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period CAGR
+
+ if recent_growth < longer_growth * 0.5: # Significant slowdown
+ score += 2 # Good time to buy in cycle
+ details.append("Potential cyclical trough - contrarian opportunity")
+ elif recent_growth > longer_growth * 2: # Acceleration
+ score -= 1 # Potential cycle peak
+ details.append("Potential cyclical peak - exercise caution")
+
+ # Margin cycle analysis
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if len(margins) >= 5:
+ current_margin = margins[0]
+ avg_margin = sum(margins) / len(margins)
+
+ if current_margin < avg_margin * 0.8: # Below average margins
+ score += 1
+ details.append("Below-average margins suggest cycle opportunity")
+
+ # Return on equity cycle
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if len(roe_vals) >= 5:
+ current_roe = roe_vals[0]
+ avg_roe = sum(roe_vals) / len(roe_vals)
+
+ if current_roe < avg_roe * 0.7: # Significantly below average
+ score += 2
+ details.append("Depressed ROE suggests cyclical opportunity")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def apply_second_level_thinking(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Marks' second-level thinking analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for second-level analysis"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # What is the market NOT seeing?
+ # Low valuation with improving fundamentals
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.2:
+ # Check if fundamentals are actually improving
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 3 and earnings[0] > earnings[1] > 0:
+ score += 3
+ details.append("Market pessimism vs improving fundamentals - second-level opportunity")
+
+ # Hidden asset value
+ if latest_financial.total_assets and latest_financial.total_debt:
+ net_asset_value = latest_financial.total_assets - latest_financial.total_debt
+ if net_asset_value > market_cap * 1.3:
+ score += 2
+ details.append("Hidden asset value not reflected in price")
+
+ # Temporary problems vs permanent impairment
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ recent_decline = revenues[0] < revenues[1]
+ historical_growth = revenues[-1] < revenues[-3] # Was growing historically
+
+ if recent_decline and historical_growth:
+ score += 1
+ details.append("Temporary setback in historically growing business")
+
+ # Quality company at cyclical low
+ if latest_metrics.return_on_equity:
+ historical_roe = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if len(historical_roe) >= 5:
+ avg_roe = sum(historical_roe[1:]) / len(historical_roe[1:]) # Exclude current
+ if avg_roe > 0.15 and latest_metrics.return_on_equity < avg_roe * 0.6:
+ score += 2
+ details.append("Quality company at cyclical low ROE")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_market_psychology_indicators(metrics: list, market_cap: float) -> dict:
+ """Marks' market psychology assessment"""
+ score = 0
+ details = []
+
+ if not metrics or not market_cap:
+ return {"score": 0, "details": "No psychology indicators"}
+
+ latest_metrics = metrics[0]
+
+ # Extreme valuation as psychology indicator
+ if latest_metrics.price_to_earnings:
+ if latest_metrics.price_to_earnings < 8: # Extreme pessimism
+ score += 2
+ details.append(f"Market pessimism: {latest_metrics.price_to_earnings:.1f} P/E")
+ elif latest_metrics.price_to_earnings > 30: # Extreme optimism
+ score -= 2
+ details.append(f"Market euphoria: {latest_metrics.price_to_earnings:.1f} P/E")
+
+ # Book value psychology
+ if latest_metrics.price_to_book:
+ if latest_metrics.price_to_book < 0.8: # Trading below book
+ score += 1
+ details.append("Market pricing below book value - potential pessimism")
+ elif latest_metrics.price_to_book > 3: # High premium
+ score -= 1
+ details.append("Market paying high premium - potential optimism")
+
+ # Contrarian indicators (simplified)
+ # Would typically incorporate sentiment data, analyst revisions, etc.
+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity > 0.8:
+ score += 1 # High debt companies often overlooked
+ details.append("High debt company - potential contrarian opportunity")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def evaluate_asymmetric_opportunities(financial_line_items: list, market_cap: float) -> dict:
+ """Marks' asymmetric risk/return evaluation"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No asymmetric data"}
+
+ latest = financial_line_items[0]
+
+ # Downside protection analysis
+ total_assets = latest.total_assets if latest.total_assets else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ # Asset floor
+ if total_assets > 0:
+ net_assets = total_assets - total_debt
+ if net_assets > market_cap * 0.8: # Strong asset backing
+ score += 2
+ details.append("Strong downside protection from asset backing")
+
+ # Upside potential from normalized earnings
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if earnings and len(earnings) >= 3:
+ # Use best historical earnings as proxy for potential
+ best_earnings = max(earnings)
+ current_earnings = earnings[0] if earnings[0] > 0 else earnings[1] if len(earnings) > 1 else 0
+
+ if best_earnings > current_earnings * 1.5: # Significant upside potential
+ normalized_value = best_earnings * 15 # 15x multiple
+ upside_ratio = normalized_value / market_cap
+
+ if upside_ratio > 2: # 100%+ upside potential
+ score += 3
+ details.append(f"Significant upside potential: {upside_ratio:.1f}x from normalized earnings")
+
+ # Free cash flow asymmetry
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_yield = latest.free_cash_flow / market_cap
+ if fcf_yield > 0.1: # 10%+ FCF yield
+ score += 1
+ details.append(f"Attractive FCF yield provides downside support: {fcf_yield:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_marks_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> MarksSignal:
+ """Generate Marks-style risk-aware investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Howard Marks' AI agent, applying sophisticated risk-aware value investing:
+
+ 1. Second-level thinking: "What is the market not seeing?"
+ 2. Risk assessment: "Risk is the probability of loss, not volatility"
+ 3. Cycle awareness: Understand where we are in the cycle
+ 4. Market psychology: Recognize euphoria and pessimism
+ 5. Asymmetric opportunities: Limited downside, significant upside
+ 6. Contrarian positioning: Buy when others are selling
+ 7. Risk-adjusted returns: Focus on risk-adjusted, not absolute returns
+
+ Reasoning style:
+ - Emphasize risk analysis and downside protection
+ - Consider market psychology and sentiment
+ - Apply second-level thinking to find hidden opportunities
+ - Discuss cyclical positioning and timing
+ - Focus on asymmetric risk/reward profiles
+ - Express nuanced, probabilistic thinking
+ - Acknowledge uncertainty and multiple scenarios
+
+ Return bullish for asymmetric opportunities with limited downside and strong risk-adjusted returns."""),
+
+ ("human", """Apply second-level thinking and risk analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_marks_signal():
+ return MarksSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=MarksSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_marks_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.py
new file mode 100644
index 000000000..38bd7facf
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/jean_marie_eveillard_agent.py
@@ -0,0 +1,407 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class EveillardSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def jean_marie_eveillard_agent(state: AgentState, agent_id: str = "jean_marie_eveillard_agent"):
+ """
+ Jean-Marie Eveillard: Global value, capital preservation
+ Focus: Downside protection, global diversification, conservative value
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ eveillard_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Analyzing capital preservation potential")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=6, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_assets",
+ "current_assets", "current_liabilities", "total_debt",
+ "shareholders_equity", "cash_and_equivalents"
+ ],
+ end_date,
+ period="annual",
+ limit=6,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Eveillard's conservative framework
+ capital_preservation = analyze_capital_preservation(financial_line_items, market_cap)
+ balance_sheet_quality = analyze_conservative_balance_sheet(financial_line_items)
+ valuation_safety = analyze_valuation_margin_of_safety(metrics, financial_line_items, market_cap)
+ business_predictability = analyze_business_predictability(financial_line_items)
+ downside_protection = calculate_downside_protection(financial_line_items, market_cap)
+
+ # Eveillard's conservative scoring
+ total_score = (
+ capital_preservation["score"] * 0.3 +
+ balance_sheet_quality["score"] * 0.25 +
+ downside_protection["score"] * 0.2 +
+ valuation_safety["score"] * 0.15 +
+ business_predictability["score"] * 0.1
+ )
+
+ # Eveillard's very conservative approach
+ if total_score >= 8.5:
+ signal = "bullish"
+ elif total_score <= 5.0:
+ signal = "bearish"
+ else:
+ signal = "neutral" # Often neutral - very selective
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "capital_preservation": capital_preservation,
+ "balance_sheet_quality": balance_sheet_quality,
+ "valuation_safety": valuation_safety,
+ "business_predictability": business_predictability,
+ "downside_protection": downside_protection
+ }
+
+ eveillard_output = generate_eveillard_output(ticker, analysis_data, state, agent_id)
+
+ eveillard_analysis[ticker] = {
+ "signal": eveillard_output.signal,
+ "confidence": eveillard_output.confidence,
+ "reasoning": eveillard_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=eveillard_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(eveillard_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(eveillard_analysis, "Jean-Marie Eveillard Agent")
+
+ state["data"]["analyst_signals"][agent_id] = eveillard_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_capital_preservation(financial_line_items: list, market_cap: float) -> dict:
+ """Eveillard's capital preservation analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No capital preservation data"}
+
+ latest = financial_line_items[0]
+
+ # Strong cash position
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ if cash > market_cap * 0.1: # 10%+ cash relative to market cap
+ score += 2
+ details.append(f"Strong cash position: {(cash / market_cap):.1%} of market cap")
+
+ # Asset backing
+ if latest.total_assets and latest.total_debt:
+ net_assets = latest.total_assets - latest.total_debt
+ if net_assets > market_cap:
+ score += 3
+ details.append(f"Strong asset backing: {(net_assets / market_cap):.1f}x market cap")
+ elif net_assets > market_cap * 0.7:
+ score += 2
+ details.append(f"Adequate asset backing: {(net_assets / market_cap):.1f}x market cap")
+
+ # Working capital strength
+ if latest.current_assets and latest.current_liabilities:
+ working_capital = latest.current_assets - latest.current_liabilities
+ if working_capital > market_cap * 0.2:
+ score += 2
+ details.append(f"Strong working capital: {(working_capital / market_cap):.1%} of market cap")
+
+ # Dividend history (capital return)
+ # Note: Would need dividend data, using profitability as proxy
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ positive_years = sum(1 for e in earnings if e > 0)
+ if positive_years == len(earnings):
+ score += 1
+ details.append(f"Consistent profitability: {positive_years}/{len(earnings)} years")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_conservative_balance_sheet(financial_line_items: list) -> dict:
+ """Eveillard's conservative balance sheet requirements"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No balance sheet data"}
+
+ latest = financial_line_items[0]
+
+ # Low debt levels
+ if latest.total_debt and latest.shareholders_equity:
+ debt_to_equity = latest.total_debt / latest.shareholders_equity
+ if debt_to_equity < 0.2: # Very conservative
+ score += 3
+ details.append(f"Very low debt: {debt_to_equity:.2f} D/E")
+ elif debt_to_equity < 0.4:
+ score += 2
+ details.append(f"Conservative debt: {debt_to_equity:.2f} D/E")
+ elif debt_to_equity > 1.0:
+ score -= 1
+ details.append(f"High debt concern: {debt_to_equity:.2f} D/E")
+
+ # Strong liquidity
+ if latest.current_assets and latest.current_liabilities:
+ current_ratio = latest.current_assets / latest.current_liabilities
+ if current_ratio > 2.0:
+ score += 2
+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")
+ elif current_ratio < 1.2:
+ score -= 1
+ details.append(f"Liquidity concern: {current_ratio:.1f} current ratio")
+
+ # Asset quality
+ if latest.cash_and_equivalents and latest.current_assets:
+ cash_ratio = latest.cash_and_equivalents / latest.current_assets
+ if cash_ratio > 0.3: # 30%+ cash in current assets
+ score += 1
+ details.append(f"High-quality liquid assets: {cash_ratio:.1%} cash ratio")
+
+ # Equity base stability
+ equity_vals = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]
+ if len(equity_vals) >= 3:
+ equity_growth = (equity_vals[0] / equity_vals[-1]) ** (1 / len(equity_vals)) - 1
+ if equity_growth > 0.05: # 5%+ equity growth
+ score += 1
+ details.append(f"Growing equity base: {equity_growth:.1%} CAGR")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_valuation_margin_of_safety(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Eveillard's margin of safety requirements"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No valuation data"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # Conservative P/E analysis
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings > 0:
+ if latest_metrics.price_to_earnings < 12:
+ score += 3
+ details.append(f"Conservative P/E: {latest_metrics.price_to_earnings:.1f}")
+ elif latest_metrics.price_to_earnings < 18:
+ score += 1
+ details.append(f"Reasonable P/E: {latest_metrics.price_to_earnings:.1f}")
+
+ # Book value safety
+ if latest_metrics.price_to_book:
+ if latest_metrics.price_to_book < 1.0:
+ score += 3
+ details.append(f"Trading below book: {latest_metrics.price_to_book:.2f} P/B")
+ elif latest_metrics.price_to_book < 1.5:
+ score += 2
+ details.append(f"Conservative P/B: {latest_metrics.price_to_book:.2f}")
+
+ # Free cash flow yield
+ if latest_financial.free_cash_flow and latest_financial.free_cash_flow > 0:
+ fcf_yield = latest_financial.free_cash_flow / market_cap
+ if fcf_yield > 0.08: # 8%+ yield
+ score += 2
+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")
+ elif fcf_yield > 0.05:
+ score += 1
+ details.append(f"Reasonable FCF yield: {fcf_yield:.1%}")
+
+ # Dividend yield (simplified - would need actual dividend data)
+ if latest_financial.net_income and latest_financial.net_income > 0:
+ estimated_dividend_yield = (latest_financial.net_income * 0.3) / market_cap # Assume 30% payout
+ if estimated_dividend_yield > 0.03: # 3%+ yield
+ score += 1
+ details.append(f"Potential dividend yield: {estimated_dividend_yield:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_business_predictability(financial_line_items: list) -> dict:
+ """Eveillard's preference for predictable businesses"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No predictability data"}
+
+ # Revenue stability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ revenue_volatility = (max(revenues) - min(revenues)) / max(revenues)
+ if revenue_volatility < 0.2: # Low volatility
+ score += 2
+ details.append(f"Stable revenue pattern: {revenue_volatility:.1%} volatility")
+ elif revenue_volatility > 0.5:
+ score -= 1
+ details.append(f"High revenue volatility: {revenue_volatility:.1%}")
+
+ # Earnings consistency
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ negative_years = sum(1 for e in earnings if e < 0)
+ if negative_years == 0:
+ score += 2
+ details.append(f"No loss years in {len(earnings)} periods")
+ elif negative_years <= 1:
+ score += 1
+ details.append(f"Only {negative_years} loss year(s)")
+
+ # Cash flow predictability
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals:
+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)
+ if positive_fcf_years >= len(fcf_vals) * 0.8: # 80%+ positive years
+ score += 2
+ details.append(f"Consistent cash generation: {positive_fcf_years}/{len(fcf_vals)} years")
+
+ # Business model simplicity (proxy: stable margins)
+ margins = []
+ for item in financial_line_items:
+ if item.net_income and item.revenue and item.revenue > 0:
+ margins.append(item.net_income / item.revenue)
+
+ if len(margins) >= 3:
+ margin_stability = max(margins) - min(margins)
+ if margin_stability < 0.05: # 5% margin range
+ score += 1
+ details.append(f"Stable profit margins: {margin_stability:.1%} range")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def calculate_downside_protection(financial_line_items: list, market_cap: float) -> dict:
+ """Eveillard's downside protection calculation"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No downside protection data"}
+
+ latest = financial_line_items[0]
+
+ # Liquidation value analysis
+ current_assets = latest.current_assets if latest.current_assets else 0
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+
+ # Conservative liquidation values
+ conservative_assets = cash + (current_assets - cash) * 0.7 # 70% recovery on non-cash
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ net_liquidation_value = conservative_assets - current_liabilities - total_debt
+
+ if net_liquidation_value > 0:
+ liquidation_ratio = net_liquidation_value / market_cap
+ if liquidation_ratio > 0.7: # 70%+ of market cap
+ score += 4
+ details.append(f"Excellent liquidation protection: {liquidation_ratio:.1%}")
+ elif liquidation_ratio > 0.4:
+ score += 2
+ details.append(f"Good liquidation protection: {liquidation_ratio:.1%}")
+ elif liquidation_ratio > 0.2:
+ score += 1
+ details.append(f"Some liquidation protection: {liquidation_ratio:.1%}")
+
+ # Tangible book value protection
+ if latest.shareholders_equity:
+ book_protection = latest.shareholders_equity / market_cap
+ if book_protection > 1.0:
+ score += 2
+ details.append(f"Trading below book value: {book_protection:.1f}x")
+ elif book_protection > 0.8:
+ score += 1
+ details.append(f"Near book value protection: {book_protection:.1f}x")
+
+ # Earnings floor
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ worst_earnings = min(earnings)
+ if worst_earnings > 0:
+ score += 2
+ details.append("No historical losses provide earnings floor")
+ elif worst_earnings > -market_cap * 0.03: # Small loss relative to market cap
+ score += 1
+ details.append("Limited historical downside from worst performance")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_eveillard_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> EveillardSignal:
+ """Generate Eveillard-style capital preservation decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Jean-Marie Eveillard's AI agent, applying global value investing with capital preservation focus:
+
+ 1. Capital preservation: "Return of capital is more important than return on capital"
+ 2. Conservative balance sheets: Low debt, strong liquidity, asset backing
+ 3. Margin of safety: Buy with significant downside protection
+ 4. Predictable businesses: Avoid complexity and volatility
+ 5. Global perspective: Consider opportunities worldwide
+ 6. Patient approach: Wait for exceptional opportunities
+ 7. Risk awareness: Focus on what can go wrong
+
+ Reasoning style:
+ - Emphasize downside protection and risk management
+ - Focus on balance sheet strength and financial conservatism
+ - Discuss predictability and business simplicity
+ - Consider liquidation values and asset backing
+ - Express conservative skepticism
+ - Require substantial margin of safety
+ - Acknowledge when standards are not met
+
+ Return bullish only for exceptionally safe investments with strong downside protection and reasonable upside."""),
+
+ ("human", """Apply capital preservation analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_eveillard_signal():
+ return EveillardSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=EveillardSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_eveillard_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.py
new file mode 100644
index 000000000..1f5fe7087
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/joel_greenblatt_agent.py
@@ -0,0 +1,355 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class GreenblattSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def joel_greenblatt_agent(state: AgentState, agent_id: str = "joel_greenblatt_agent"):
+ """
+ Joel Greenblatt: Magic formula (high ROC + low P/E)
+ Focus: Systematic value investing, high returns on capital, cheap valuations
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ greenblatt_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Applying Magic Formula criteria")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "total_assets", "current_assets",
+ "current_liabilities", "total_debt", "shareholders_equity",
+ "operating_income", "interest_expense", "free_cash_flow"
+ ],
+ end_date,
+ period="annual",
+ limit=5,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Greenblatt's Magic Formula components
+ earnings_yield = calculate_earnings_yield(financial_line_items, market_cap)
+ return_on_capital = calculate_return_on_capital(financial_line_items)
+ magic_formula_rank = calculate_magic_formula_rank(earnings_yield, return_on_capital)
+ business_quality = analyze_business_quality_greenblatt(metrics, financial_line_items)
+ special_situations = analyze_special_situations(financial_line_items, market_cap)
+
+ # Greenblatt's systematic scoring
+ total_score = (
+ magic_formula_rank["score"] * 0.4 +
+ earnings_yield["score"] * 0.25 +
+ return_on_capital["score"] * 0.25 +
+ business_quality["score"] * 0.1
+ )
+
+ # Magic Formula approach: systematic and mechanical
+ if total_score >= 8.0:
+ signal = "bullish"
+ elif total_score <= 4.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "earnings_yield": earnings_yield,
+ "return_on_capital": return_on_capital,
+ "magic_formula_rank": magic_formula_rank,
+ "business_quality": business_quality,
+ "special_situations": special_situations
+ }
+
+ greenblatt_output = generate_greenblatt_output(ticker, analysis_data, state, agent_id)
+
+ greenblatt_analysis[ticker] = {
+ "signal": greenblatt_output.signal,
+ "confidence": greenblatt_output.confidence,
+ "reasoning": greenblatt_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=greenblatt_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(greenblatt_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(greenblatt_analysis, "Joel Greenblatt Agent")
+
+ state["data"]["analyst_signals"][agent_id] = greenblatt_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def calculate_earnings_yield(financial_line_items: list, market_cap: float) -> dict:
+ """Calculate Greenblatt's earnings yield (EBIT / Enterprise Value)"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for earnings yield", "value": None}
+
+ latest = financial_line_items[0]
+
+ # Calculate EBIT (Operating Income)
+ ebit = latest.operating_income if latest.operating_income else 0
+
+ # Calculate Enterprise Value
+ total_debt = latest.total_debt if latest.total_debt else 0
+ cash = latest.current_assets * 0.2 if latest.current_assets else 0 # Rough cash estimate
+ enterprise_value = market_cap + total_debt - cash
+
+ if enterprise_value > 0 and ebit > 0:
+ earnings_yield = ebit / enterprise_value
+
+ # Greenblatt's scoring system
+ if earnings_yield > 0.15: # 15%+ earnings yield
+ score = 10
+ details.append(f"Exceptional earnings yield: {earnings_yield:.1%}")
+ elif earnings_yield > 0.12:
+ score = 8
+ details.append(f"Strong earnings yield: {earnings_yield:.1%}")
+ elif earnings_yield > 0.09:
+ score = 6
+ details.append(f"Good earnings yield: {earnings_yield:.1%}")
+ elif earnings_yield > 0.06:
+ score = 4
+ details.append(f"Fair earnings yield: {earnings_yield:.1%}")
+ else:
+ score = 2
+ details.append(f"Low earnings yield: {earnings_yield:.1%}")
+ else:
+ earnings_yield = 0
+ details.append("No positive earnings yield")
+
+ return {
+ "score": score,
+ "value": earnings_yield,
+ "details": "; ".join(details)
+ }
+
+
+def calculate_return_on_capital(financial_line_items: list) -> dict:
+ """Calculate Greenblatt's return on invested capital"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No data for ROIC", "value": None}
+
+ latest = financial_line_items[0]
+
+ # Calculate ROIC = EBIT / (Net Working Capital + Net Fixed Assets)
+ ebit = latest.operating_income if latest.operating_income else 0
+
+ # Working Capital
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+ working_capital = current_assets - current_liabilities
+
+ # Invested Capital (simplified)
+ total_assets = latest.total_assets if latest.total_assets else 0
+ invested_capital = max(working_capital + (total_assets - current_assets), total_assets * 0.5)
+
+ if invested_capital > 0 and ebit > 0:
+ roic = ebit / invested_capital
+
+ # Greenblatt's ROIC scoring
+ if roic > 0.25: # 25%+ ROIC
+ score = 10
+ details.append(f"Exceptional ROIC: {roic:.1%}")
+ elif roic > 0.20:
+ score = 8
+ details.append(f"Strong ROIC: {roic:.1%}")
+ elif roic > 0.15:
+ score = 6
+ details.append(f"Good ROIC: {roic:.1%}")
+ elif roic > 0.10:
+ score = 4
+ details.append(f"Fair ROIC: {roic:.1%}")
+ else:
+ score = 2
+ details.append(f"Low ROIC: {roic:.1%}")
+ else:
+ roic = 0
+ details.append("No positive return on capital")
+
+ return {
+ "score": score,
+ "value": roic,
+ "details": "; ".join(details)
+ }
+
+
+def calculate_magic_formula_rank(earnings_yield: dict, return_on_capital: dict) -> dict:
+ """Combine earnings yield and ROIC for Magic Formula ranking"""
+ score = 0
+ details = []
+
+ ey_score = earnings_yield.get("score", 0)
+ roic_score = return_on_capital.get("score", 0)
+
+ # Magic Formula combines both metrics
+ combined_score = (ey_score + roic_score) / 2
+
+ if combined_score >= 9:
+ score = 10
+ details.append("Magic Formula: Top tier (high ROIC + high earnings yield)")
+ elif combined_score >= 7:
+ score = 8
+ details.append("Magic Formula: Strong candidate")
+ elif combined_score >= 5:
+ score = 6
+ details.append("Magic Formula: Decent candidate")
+ else:
+ score = 3
+ details.append("Magic Formula: Below average")
+
+ # Bonus for exceptional combination
+ ey_val = earnings_yield.get("value", 0)
+ roic_val = return_on_capital.get("value", 0)
+
+ if ey_val > 0.12 and roic_val > 0.20:
+ score = min(10, score + 2)
+ details.append("Exceptional Magic Formula combination")
+
+ return {
+ "score": score,
+ "combined_score": combined_score,
+ "details": "; ".join(details)
+ }
+
+
+def analyze_business_quality_greenblatt(metrics: list, financial_line_items: list) -> dict:
+ """Greenblatt's additional quality checks beyond Magic Formula"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No data for quality analysis"}
+
+ # Consistent profitability
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ positive_years = sum(1 for e in earnings if e > 0)
+ if positive_years == len(earnings):
+ score += 3
+ details.append(f"Consistent profitability: {positive_years}/{len(earnings)} years")
+
+ # Revenue growth
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ if revenue_growth > 0.05:
+ score += 2
+ details.append(f"Revenue growth: {revenue_growth:.1%} CAGR")
+
+ # Free cash flow generation
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals:
+ positive_fcf = sum(1 for fcf in fcf_vals if fcf > 0)
+ if positive_fcf >= len(fcf_vals) * 0.8:
+ score += 2
+ details.append(f"Strong FCF generation: {positive_fcf}/{len(fcf_vals)} years")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_special_situations(financial_line_items: list, market_cap: float) -> dict:
+ """Greenblatt's special situation analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No special situation data"}
+
+ latest = financial_line_items[0]
+
+ # Net cash position (special situation value)
+ current_assets = latest.current_assets if latest.current_assets else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ if current_assets > total_debt * 1.5:
+ net_cash = current_assets - total_debt
+ if net_cash > market_cap * 0.2:
+ score += 2
+ details.append(f"Net cash opportunity: {(net_cash / market_cap):.1%} of market cap")
+
+ # Asset value relative to market cap
+ if latest.total_assets:
+ asset_ratio = latest.total_assets / market_cap
+ if asset_ratio > 1.5:
+ score += 1
+ details.append(f"Asset value: {asset_ratio:.1f}x market cap")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_greenblatt_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> GreenblattSignal:
+ """Generate Greenblatt-style Magic Formula investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Joel Greenblatt's AI agent, implementing the Magic Formula strategy:
+
+ 1. Magic Formula: High return on invested capital + High earnings yield
+ 2. Systematic approach: Remove emotion, follow the formula mechanically
+ 3. Value investing: Buy good businesses at cheap prices
+ 4. Special situations: Spinoffs, mergers, bankruptcies for extra returns
+ 5. Long-term perspective: Hold for 2-3 years minimum
+ 6. Diversification: Own 20-30 positions to reduce risk
+ 7. Patience: Trust the process even during underperformance
+
+ Reasoning style:
+ - Emphasize quantitative Magic Formula metrics
+ - Focus on ROIC and earnings yield primarily
+ - Discuss systematic, mechanical approach
+ - Reference statistical advantages of the formula
+ - Consider special situations as bonus opportunities
+ - Express confidence in proven methodology
+ - Acknowledge short-term volatility but long-term outperformance
+
+ Return bullish for high Magic Formula scores (top quartile companies)."""),
+
+ ("human", """Apply Magic Formula analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_greenblatt_signal():
+ return GreenblattSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=GreenblattSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_greenblatt_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.py
new file mode 100644
index 000000000..9b4d307d4
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/marty_whitman_agent.py
@@ -0,0 +1,445 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class WhitmanSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def marty_whitman_agent(state: AgentState, agent_id: str = "marty_whitman_agent"):
+ """
+ Marty Whitman: Safe & cheap, asset-based investing
+ Focus: Balance sheet analysis, asset values, financial safety
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ whitman_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Analyzing safe & cheap criteria")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "total_assets", "current_assets",
+ "current_liabilities", "total_debt", "shareholders_equity",
+ "cash_and_equivalents", "accounts_receivable", "inventory",
+ "property_plant_equipment", "goodwill"
+ ],
+ end_date,
+ period="annual",
+ limit=5,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Whitman's asset-focused framework
+ asset_value_analysis = analyze_asset_values(financial_line_items, market_cap)
+ financial_safety = analyze_financial_safety(financial_line_items)
+ balance_sheet_strength = analyze_balance_sheet_quality(financial_line_items)
+ safe_and_cheap = evaluate_safe_and_cheap_criteria(metrics, financial_line_items, market_cap)
+ credit_worthiness = analyze_credit_worthiness(financial_line_items)
+
+ # Whitman's asset-based scoring
+ total_score = (
+ asset_value_analysis["score"] * 0.3 +
+ financial_safety["score"] * 0.25 +
+ safe_and_cheap["score"] * 0.2 +
+ balance_sheet_strength["score"] * 0.15 +
+ credit_worthiness["score"] * 0.1
+ )
+
+ # Whitman's safety-first approach
+ if total_score >= 8.0:
+ signal = "bullish"
+ elif total_score <= 4.5:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "asset_value_analysis": asset_value_analysis,
+ "financial_safety": financial_safety,
+ "balance_sheet_strength": balance_sheet_strength,
+ "safe_and_cheap": safe_and_cheap,
+ "credit_worthiness": credit_worthiness
+ }
+
+ whitman_output = generate_whitman_output(ticker, analysis_data, state, agent_id)
+
+ whitman_analysis[ticker] = {
+ "signal": whitman_output.signal,
+ "confidence": whitman_output.confidence,
+ "reasoning": whitman_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=whitman_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(whitman_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(whitman_analysis, "Marty Whitman Agent")
+
+ state["data"]["analyst_signals"][agent_id] = whitman_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_asset_values(financial_line_items: list, market_cap: float) -> dict:
+ """Whitman's asset-based valuation analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No asset data"}
+
+ latest = financial_line_items[0]
+
+ # Tangible asset value
+ total_assets = latest.total_assets if latest.total_assets else 0
+ goodwill = latest.goodwill if latest.goodwill else 0
+ tangible_assets = total_assets - goodwill
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ if tangible_assets > 0:
+ net_tangible_assets = tangible_assets - total_debt
+ if net_tangible_assets > market_cap:
+ score += 4
+ details.append(f"Trading below tangible assets: {(net_tangible_assets / market_cap):.1f}x")
+ elif net_tangible_assets > market_cap * 0.8:
+ score += 3
+ details.append(f"Strong tangible asset backing: {(net_tangible_assets / market_cap):.1f}x")
+ elif net_tangible_assets > market_cap * 0.6:
+ score += 2
+ details.append(f"Adequate tangible asset backing: {(net_tangible_assets / market_cap):.1f}x")
+
+ # Working capital value
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+ working_capital = current_assets - current_liabilities
+
+ if working_capital > 0:
+ wc_ratio = working_capital / market_cap
+ if wc_ratio > 0.5:
+ score += 2
+ details.append(f"Strong working capital: {wc_ratio:.1%} of market cap")
+ elif wc_ratio > 0.2:
+ score += 1
+ details.append(f"Positive working capital: {wc_ratio:.1%} of market cap")
+
+ # Book value relationship
+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0
+ if shareholders_equity > 0:
+ price_to_book = market_cap / shareholders_equity
+ if price_to_book < 0.8:
+ score += 2
+ details.append(f"Trading below 80% of book: {price_to_book:.2f} P/B")
+ elif price_to_book < 1.2:
+ score += 1
+ details.append(f"Reasonable P/B ratio: {price_to_book:.2f}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_financial_safety(financial_line_items: list) -> dict:
+ """Whitman's financial safety analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No safety data"}
+
+ latest = financial_line_items[0]
+
+ # Debt safety
+ total_debt = latest.total_debt if latest.total_debt else 0
+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0
+
+ if shareholders_equity > 0:
+ debt_to_equity = total_debt / shareholders_equity
+ if debt_to_equity < 0.3:
+ score += 3
+ details.append(f"Very safe debt level: {debt_to_equity:.2f} D/E")
+ elif debt_to_equity < 0.6:
+ score += 2
+ details.append(f"Safe debt level: {debt_to_equity:.2f} D/E")
+ elif debt_to_equity > 1.5:
+ score -= 1
+ details.append(f"High debt concern: {debt_to_equity:.2f} D/E")
+
+ # Liquidity safety
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+
+ if current_liabilities > 0:
+ current_ratio = current_assets / current_liabilities
+ if current_ratio > 2.0:
+ score += 2
+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")
+ elif current_ratio > 1.5:
+ score += 1
+ details.append(f"Adequate liquidity: {current_ratio:.1f} current ratio")
+ elif current_ratio < 1.0:
+ score -= 2
+ details.append(f"Liquidity concern: {current_ratio:.1f} current ratio")
+
+ # Cash position
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ total_assets = latest.total_assets if latest.total_assets else 0
+
+ if total_assets > 0:
+ cash_ratio = cash / total_assets
+ if cash_ratio > 0.15: # 15%+ cash
+ score += 2
+ details.append(f"Strong cash position: {cash_ratio:.1%} of assets")
+ elif cash_ratio > 0.05:
+ score += 1
+ details.append(f"Reasonable cash position: {cash_ratio:.1%} of assets")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_balance_sheet_quality(financial_line_items: list) -> dict:
+ """Whitman's balance sheet quality assessment"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No balance sheet data"}
+
+ latest = financial_line_items[0]
+
+ # Asset quality analysis
+ current_assets = latest.current_assets if latest.current_assets else 0
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ receivables = latest.accounts_receivable if latest.accounts_receivable else 0
+ inventory = latest.inventory if latest.inventory else 0
+
+ # High-quality current assets
+ if current_assets > 0:
+ quality_assets = cash + receivables # Cash + receivables are higher quality
+ quality_ratio = quality_assets / current_assets
+ if quality_ratio > 0.7:
+ score += 2
+ details.append(f"High-quality current assets: {quality_ratio:.1%} cash+receivables")
+ elif quality_ratio > 0.5:
+ score += 1
+ details.append(f"Reasonable asset quality: {quality_ratio:.1%} cash+receivables")
+
+ # Fixed asset efficiency
+ ppe = latest.property_plant_equipment if latest.property_plant_equipment else 0
+ revenue = latest.revenue if latest.revenue else 0
+
+ if ppe > 0 and revenue > 0:
+ asset_turnover = revenue / ppe
+ if asset_turnover > 3.0: # Efficient use of fixed assets
+ score += 1
+ details.append(f"Efficient fixed asset use: {asset_turnover:.1f}x turnover")
+
+ # Goodwill concerns
+ goodwill = latest.goodwill if latest.goodwill else 0
+ total_assets = latest.total_assets if latest.total_assets else 0
+
+ if total_assets > 0:
+ goodwill_ratio = goodwill / total_assets
+ if goodwill_ratio < 0.1: # Low goodwill
+ score += 2
+ details.append(f"Low goodwill risk: {goodwill_ratio:.1%} of assets")
+ elif goodwill_ratio > 0.3: # High goodwill
+ score -= 1
+ details.append(f"High goodwill concern: {goodwill_ratio:.1%} of assets")
+
+ # Equity growth
+ equity_vals = [item.shareholders_equity for item in financial_line_items if item.shareholders_equity]
+ if len(equity_vals) >= 3:
+ equity_growth = (equity_vals[0] / equity_vals[-1]) ** (1 / len(equity_vals)) - 1
+ if equity_growth > 0.08: # 8%+ equity growth
+ score += 1
+ details.append(f"Growing equity base: {equity_growth:.1%} CAGR")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def evaluate_safe_and_cheap_criteria(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Whitman's 'safe and cheap' evaluation"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No safe & cheap data"}
+
+ latest_metrics = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ # "Safe" criteria
+ safety_score = 0
+
+ # Low debt
+ if latest_metrics.debt_to_equity and latest_metrics.debt_to_equity < 0.5:
+ safety_score += 1
+ details.append(f"Safe debt level: {latest_metrics.debt_to_equity:.2f} D/E")
+
+ # Strong balance sheet
+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 1.5:
+ safety_score += 1
+ details.append(f"Safe liquidity: {latest_metrics.current_ratio:.1f} current ratio")
+
+ # Asset backing
+ if latest_financial.total_assets and latest_financial.total_debt:
+ asset_coverage = latest_financial.total_assets / latest_financial.total_debt
+ if asset_coverage > 3.0:
+ safety_score += 1
+ details.append(f"Safe asset coverage: {asset_coverage:.1f}x")
+
+ # "Cheap" criteria
+ cheap_score = 0
+
+ # Low P/B
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:
+ cheap_score += 1
+ details.append(f"Cheap P/B: {latest_metrics.price_to_book:.2f}")
+
+ # Low P/E
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 15:
+ cheap_score += 1
+ details.append(f"Cheap P/E: {latest_metrics.price_to_earnings:.1f}")
+
+ # Asset value
+ if latest_financial.shareholders_equity and latest_financial.shareholders_equity > market_cap:
+ cheap_score += 1
+ details.append("Cheap relative to book value")
+
+ # Combined safe & cheap score
+ if safety_score >= 2 and cheap_score >= 2:
+ score = 10 # Perfect safe & cheap
+ details.append("Meets Whitman's safe & cheap criteria")
+ elif safety_score >= 2:
+ score = 6 # Safe but not cheap
+ details.append("Safe but not particularly cheap")
+ elif cheap_score >= 2:
+ score = 4 # Cheap but not safe
+ details.append("Cheap but safety concerns")
+ else:
+ score = 2 # Neither safe nor cheap
+ details.append("Does not meet safe & cheap criteria")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_credit_worthiness(financial_line_items: list) -> dict:
+ """Whitman's credit analysis approach"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No credit data"}
+
+ latest = financial_line_items[0]
+
+ # Interest coverage capability
+ operating_income = latest.net_income if latest.net_income else 0 # Simplified
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ if total_debt > 0:
+ # Estimate interest expense at 5%
+ estimated_interest = total_debt * 0.05
+ if operating_income > estimated_interest * 3: # 3x coverage
+ score += 2
+ details.append("Strong estimated interest coverage")
+ elif operating_income > estimated_interest:
+ score += 1
+ details.append("Adequate estimated interest coverage")
+ elif total_debt == 0:
+ score += 3
+ details.append("No debt - excellent credit position")
+
+ # Cash flow coverage
+ free_cash_flow = latest.free_cash_flow if latest.free_cash_flow else 0
+ if free_cash_flow > 0 and total_debt > 0:
+ debt_paydown_years = total_debt / free_cash_flow
+ if debt_paydown_years < 5:
+ score += 2
+ details.append(f"Can pay down debt in {debt_paydown_years:.1f} years")
+ elif debt_paydown_years < 10:
+ score += 1
+ details.append(f"Reasonable debt paydown period: {debt_paydown_years:.1f} years")
+
+ # Working capital strength
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+
+ if current_liabilities > 0:
+ working_capital_ratio = current_assets / current_liabilities
+ if working_capital_ratio > 2.0:
+ score += 1
+ details.append(f"Strong working capital for credit: {working_capital_ratio:.1f}x")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_whitman_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> WhitmanSignal:
+ """Generate Whitman-style safe & cheap investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Marty Whitman's AI agent, applying safe & cheap asset-based investing:
+
+ 1. Safe & Cheap: Both criteria must be met - financial safety AND attractive valuation
+ 2. Asset-based analysis: Focus on balance sheet values and asset backing
+ 3. Financial safety: Low debt, strong liquidity, conservative capital structure
+ 4. Credit analysis: Evaluate creditworthiness and financial flexibility
+ 5. Tangible value: Prefer tangible assets over intangibles and goodwill
+ 6. Balance sheet focus: Income statement is secondary to balance sheet strength
+ 7. Risk management: Downside protection through asset values
+
+ Reasoning style:
+ - Emphasize balance sheet analysis and asset values
+ - Focus on financial safety and conservative capital structure
+ - Discuss tangible asset backing and liquidation values
+ - Consider credit worthiness and debt capacity
+ - Apply rigorous safe & cheap criteria
+ - Express preference for asset-rich, debt-light companies
+ - Acknowledge when safety or cheapness criteria are not met
+
+ Return bullish only for companies that are both financially safe AND attractively cheap."""),
+
+ ("human", """Apply safe & cheap asset-based analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_whitman_signal():
+ return WhitmanSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=WhitmanSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_whitman_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.py
new file mode 100644
index 000000000..a13d44984
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/seth_klarman_agent.py
@@ -0,0 +1,395 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class KlarmanSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def seth_klarman_agent(state: AgentState, agent_id: str = "seth_klarman_agent"):
+ """
+ Seth Klarman: Absolute return, risk-first approach, contrarian
+ Focus: Capital preservation, asymmetric risk/reward, distressed opportunities
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ klarman_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Analyzing downside protection")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=5, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "total_assets", "current_assets",
+ "current_liabilities", "total_debt", "cash_and_equivalents",
+ "shareholders_equity", "free_cash_flow", "operating_income"
+ ],
+ end_date,
+ period="annual",
+ limit=5,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Klarman's risk-first analyses
+ downside_protection = analyze_downside_protection(financial_line_items, market_cap)
+ asymmetric_opportunity = analyze_asymmetric_risk_reward(metrics, financial_line_items, market_cap)
+ contrarian_indicators = analyze_contrarian_opportunity(metrics, financial_line_items)
+ balance_sheet_strength = analyze_balance_sheet_fortress(financial_line_items)
+ margin_of_safety = calculate_klarman_margin_of_safety(financial_line_items, market_cap)
+
+ # Klarman's conservative scoring (risk-adjusted)
+ total_score = (
+ downside_protection["score"] * 0.3 +
+ balance_sheet_strength["score"] * 0.25 +
+ margin_of_safety["score"] * 0.2 +
+ asymmetric_opportunity["score"] * 0.15 +
+ contrarian_indicators["score"] * 0.1
+ )
+
+ # Klarman's high bar for investment
+ if total_score >= 8.0:
+ signal = "bullish"
+ elif total_score <= 4.0:
+ signal = "bearish"
+ else:
+ signal = "neutral" # Most opportunities don't meet Klarman's standards
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "downside_protection": downside_protection,
+ "asymmetric_opportunity": asymmetric_opportunity,
+ "contrarian_indicators": contrarian_indicators,
+ "balance_sheet_strength": balance_sheet_strength,
+ "margin_of_safety": margin_of_safety
+ }
+
+ klarman_output = generate_klarman_output(ticker, analysis_data, state, agent_id)
+
+ klarman_analysis[ticker] = {
+ "signal": klarman_output.signal,
+ "confidence": klarman_output.confidence,
+ "reasoning": klarman_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=klarman_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(klarman_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(klarman_analysis, "Seth Klarman Agent")
+
+ state["data"]["analyst_signals"][agent_id] = klarman_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_downside_protection(financial_line_items: list, market_cap: float) -> dict:
+ """Klarman's obsession with downside protection"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for downside analysis"}
+
+ latest = financial_line_items[0]
+
+ # Asset coverage
+ total_assets = latest.total_assets if latest.total_assets else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ if total_assets > 0:
+ asset_coverage = total_assets / market_cap
+ if asset_coverage > 2.0:
+ score += 3
+ details.append(f"Strong asset coverage: {asset_coverage:.1f}x market cap")
+ elif asset_coverage > 1.5:
+ score += 2
+ details.append(f"Adequate asset coverage: {asset_coverage:.1f}x market cap")
+
+ # Liquidation value protection
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+
+ # Conservative liquidation values
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ liquidation_value = cash + (current_assets - cash) * 0.7 # 70% recovery on non-cash assets
+ net_liquidation = liquidation_value - current_liabilities - total_debt
+
+ if net_liquidation > 0:
+ liquidation_ratio = net_liquidation / market_cap
+ if liquidation_ratio > 0.5:
+ score += 4
+ details.append(f"Exceptional liquidation protection: {liquidation_ratio:.1%}")
+ elif liquidation_ratio > 0.2:
+ score += 2
+ details.append(f"Good liquidation value: {liquidation_ratio:.1%}")
+
+ # Earnings floor
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ worst_earnings = min(earnings)
+ if worst_earnings > 0:
+ score += 2
+ details.append("No losses in available periods")
+ elif worst_earnings > -market_cap * 0.05: # Small losses relative to market cap
+ score += 1
+ details.append("Limited downside from worst historical performance")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_asymmetric_risk_reward(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Klarman's focus on asymmetric opportunities"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for asymmetric analysis"}
+
+ latest = financial_line_items[0]
+
+ # Upside potential vs downside risk
+ # Calculate normalized earnings power
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if earnings:
+ avg_earnings = sum(earnings) / len(earnings)
+ normalized_pe = market_cap / avg_earnings if avg_earnings > 0 else 0
+
+ # If trading at low multiple with asset protection, asymmetric opportunity
+ if normalized_pe < 12 and latest.total_assets and latest.total_assets > market_cap:
+ score += 3
+ details.append(f"Asymmetric setup: {normalized_pe:.1f} P/E with asset backing")
+
+ # Free cash flow yield vs risk
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_yield = latest.free_cash_flow / market_cap
+ debt_ratio = (latest.total_debt / latest.total_assets) if latest.total_assets else 1
+
+ # High FCF yield with low debt = good risk/reward
+ if fcf_yield > 0.1 and debt_ratio < 0.3:
+ score += 2
+ details.append(f"Strong FCF yield ({fcf_yield:.1%}) with low debt")
+
+ # Catalyst potential (simplified)
+ # Look for companies with improving trends that market hasn't recognized
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ recent_growth = (revenues[0] / revenues[1]) - 1
+ if recent_growth > 0.1: # 10%+ recent growth
+ score += 1
+ details.append(f"Potential catalyst: {recent_growth:.1%} recent revenue growth")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_contrarian_opportunity(metrics: list, financial_line_items: list) -> dict:
+ """Klarman's contrarian approach to investing"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No data for contrarian analysis"}
+
+ latest_metrics = metrics[0]
+
+ # Low valuation multiples (contrarian indicator)
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.0:
+ score += 2
+ details.append(f"Contrarian P/B: {latest_metrics.price_to_book:.2f}")
+
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 10:
+ score += 2
+ details.append(f"Contrarian P/E: {latest_metrics.price_to_earnings:.1f}")
+
+ # Temporary earnings depression
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 3:
+ recent_earnings = earnings[0]
+ historical_avg = sum(earnings[1:]) / len(earnings[1:])
+
+ if recent_earnings < historical_avg * 0.7 and recent_earnings > 0:
+ score += 2
+ details.append("Potential temporary earnings depression")
+
+ # Industry or company-specific distress signals
+ # (Would typically require more external data, simplified here)
+ if latest_metrics.current_ratio and latest_metrics.current_ratio < 1.2:
+ # Low current ratio might indicate distress (opportunity for contrarian)
+ score += 1
+ details.append("Potential distress situation for contrarian investment")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_balance_sheet_fortress(financial_line_items: list) -> dict:
+ """Klarman's requirement for fortress balance sheets"""
+ score = 0
+ details = []
+
+ if not financial_line_items:
+ return {"score": 0, "details": "No balance sheet data"}
+
+ latest = financial_line_items[0]
+
+ # Cash and liquidity
+ cash = latest.cash_and_equivalents if latest.cash_and_equivalents else 0
+ current_assets = latest.current_assets if latest.current_assets else 0
+ current_liabilities = latest.current_liabilities if latest.current_liabilities else 0
+
+ if current_liabilities > 0:
+ current_ratio = current_assets / current_liabilities
+ if current_ratio > 2.0:
+ score += 2
+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")
+
+ # Debt levels
+ total_debt = latest.total_debt if latest.total_debt else 0
+ shareholders_equity = latest.shareholders_equity if latest.shareholders_equity else 0
+
+ if shareholders_equity > 0:
+ debt_to_equity = total_debt / shareholders_equity
+ if debt_to_equity < 0.3:
+ score += 3
+ details.append(f"Conservative debt: {debt_to_equity:.2f} D/E")
+ elif debt_to_equity < 0.5:
+ score += 1
+ details.append(f"Moderate debt: {debt_to_equity:.2f} D/E")
+
+ # Working capital strength
+ working_capital = current_assets - current_liabilities
+ if working_capital > 0 and latest.total_assets:
+ wc_ratio = working_capital / latest.total_assets
+ if wc_ratio > 0.2:
+ score += 2
+ details.append(f"Strong working capital: {wc_ratio:.1%} of assets")
+
+ # Interest coverage
+ if latest.operating_income and total_debt > 0:
+ # Simplified interest coverage (assume 5% interest rate)
+ estimated_interest = total_debt * 0.05
+ if latest.operating_income > estimated_interest * 5:
+ score += 2
+ details.append("Strong interest coverage capability")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def calculate_klarman_margin_of_safety(financial_line_items: list, market_cap: float) -> dict:
+ """Klarman's conservative margin of safety calculation"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for margin of safety"}
+
+ latest = financial_line_items[0]
+
+ # Conservative asset-based valuation
+ total_assets = latest.total_assets if latest.total_assets else 0
+ total_debt = latest.total_debt if latest.total_debt else 0
+
+ # Apply conservative haircuts to assets
+ conservative_asset_value = total_assets * 0.7 # 30% haircut
+ net_asset_value = conservative_asset_value - total_debt
+
+ if net_asset_value > 0:
+ asset_margin = (net_asset_value - market_cap) / market_cap
+ if asset_margin > 0.5:
+ score += 3
+ details.append(f"Excellent asset margin of safety: {asset_margin:.1%}")
+ elif asset_margin > 0.2:
+ score += 2
+ details.append(f"Good asset margin of safety: {asset_margin:.1%}")
+
+ # Conservative earnings-based valuation
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+ if earnings:
+ # Use conservative multiple (10x) on average earnings
+ avg_earnings = sum(earnings) / len(earnings)
+ conservative_earnings_value = avg_earnings * 10
+
+ earnings_margin = (conservative_earnings_value - market_cap) / market_cap
+ if earnings_margin > 0.3:
+ score += 2
+ details.append(f"Earnings margin of safety: {earnings_margin:.1%}")
+
+ # Free cash flow margin of safety
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ # Conservative 12x FCF multiple
+ fcf_value = latest.free_cash_flow * 12
+ fcf_margin = (fcf_value - market_cap) / market_cap
+
+ if fcf_margin > 0.25:
+ score += 2
+ details.append(f"FCF margin of safety: {fcf_margin:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_klarman_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> KlarmanSignal:
+ """Generate Klarman-style risk-first investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Seth Klarman's AI agent, following absolute return value investing principles:
+
+ 1. Risk first: "Return OF capital is more important than return ON capital"
+ 2. Margin of safety: Buy with significant downside protection
+ 3. Contrarian approach: Buy when others are selling
+ 4. Asymmetric risk/reward: Limited downside, substantial upside
+ 5. Balance sheet fortress: Strong financial position required
+ 6. Patient opportunism: Wait for exceptional opportunities
+ 7. Absolute return focus: Preserve capital above all else
+
+ Reasoning style:
+ - Emphasize downside protection and risk analysis first
+ - Focus on balance sheet strength and asset coverage
+ - Discuss margin of safety quantitatively
+ - Consider contrarian and distressed opportunities
+ - Express skepticism and conservatism
+ - Require exceptional risk/reward ratios
+ - Acknowledge when opportunities don't meet standards
+
+ Return bullish only for exceptional risk/reward opportunities with substantial downside protection."""),
+
+ ("human", """Apply risk-first value analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_klarman_signal():
+ return KlarmanSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=KlarmanSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_klarman_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.py
new file mode 100644
index 000000000..98dbd4b62
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/Trader_Investors_agent/warren_buffett_agent.py
@@ -0,0 +1,323 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class BuffettSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+
+
+def warren_buffett_agent(state: AgentState, agent_id: str = "warren_buffett_agent"):
+ """
+ Warren Buffett: Buy wonderful companies at fair prices, hold forever
+ Focus: Economic moats, predictable earnings, strong management, reasonable price
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ buffett_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Analyzing wonderful business qualities")
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)
+
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "retained_earnings", "operating_margin",
+ "research_and_development", "outstanding_shares"
+ ],
+ end_date,
+ period="annual",
+ limit=10,
+ api_key=api_key,
+ )
+
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Buffett's key analyses
+ moat_analysis = analyze_economic_moat(metrics, financial_line_items)
+ earnings_predictability = analyze_earnings_predictability(financial_line_items)
+ financial_strength = analyze_financial_fortress(metrics, financial_line_items)
+ management_quality = analyze_capital_allocation(financial_line_items)
+ valuation_analysis = buffett_valuation(financial_line_items, market_cap)
+
+ total_score = (
+ moat_analysis["score"] * 0.3 +
+ earnings_predictability["score"] * 0.25 +
+ financial_strength["score"] * 0.2 +
+ management_quality["score"] * 0.15 +
+ valuation_analysis["score"] * 0.1
+ )
+
+ # Buffett's binary approach: Wonderful business or pass
+ if total_score >= 8.0:
+ signal = "bullish"
+ elif total_score <= 4.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "moat_analysis": moat_analysis,
+ "earnings_predictability": earnings_predictability,
+ "financial_strength": financial_strength,
+ "management_quality": management_quality,
+ "valuation_analysis": valuation_analysis
+ }
+
+ buffett_output = generate_buffett_output(ticker, analysis_data, state, agent_id)
+
+ buffett_analysis[ticker] = {
+ "signal": buffett_output.signal,
+ "confidence": buffett_output.confidence,
+ "reasoning": buffett_output.reasoning
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=buffett_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(buffett_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(buffett_analysis, "Warren Buffett Agent")
+
+ state["data"]["analyst_signals"][agent_id] = buffett_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def analyze_economic_moat(metrics: list, financial_line_items: list) -> dict:
+ """Buffett's moat analysis: High ROE, consistent margins, pricing power"""
+ score = 0
+ details = []
+
+ if not metrics:
+ return {"score": 0, "details": "No metrics data"}
+
+ # High and consistent ROE (15%+ for 7+ years)
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if roe_vals:
+ high_roe_count = sum(1 for roe in roe_vals if roe > 0.15)
+ if high_roe_count >= 7:
+ score += 3
+ details.append(f"Exceptional ROE consistency: {high_roe_count}/10 years >15%")
+ elif high_roe_count >= 5:
+ score += 2
+ details.append(f"Good ROE consistency: {high_roe_count}/10 years >15%")
+
+ # Consistent operating margins (pricing power)
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and len(margins) >= 5:
+ margin_stability = max(margins) - min(margins)
+ avg_margin = sum(margins) / len(margins)
+ if margin_stability < 0.05 and avg_margin > 0.15:
+ score += 2
+ details.append(f"Stable high margins: {avg_margin:.1%} avg, {margin_stability:.1%} volatility")
+
+ # Revenue growth without excessive capex
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ if 0.05 <= cagr <= 0.15: # Buffett likes steady, not explosive growth
+ score += 2
+ details.append(f"Steady revenue growth: {cagr:.1%} CAGR")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_earnings_predictability(financial_line_items: list) -> dict:
+ """Buffett values predictable, growing earnings"""
+ score = 0
+ details = []
+
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) < 5:
+ return {"score": 0, "details": "Insufficient earnings history"}
+
+ # Positive earnings in 8+ of last 10 years
+ positive_years = sum(1 for e in earnings if e > 0)
+ if positive_years >= 8:
+ score += 3
+ details.append(f"Consistent profitability: {positive_years}/10 years positive")
+
+ # Earnings growth trend
+ if len(earnings) >= 10:
+ recent_avg = sum(earnings[:5]) / 5
+ older_avg = sum(earnings[5:10]) / 5
+ if recent_avg > older_avg * 1.5:
+ score += 2
+ details.append("Strong earnings growth trend over decade")
+
+ # Low earnings volatility
+ if earnings:
+ volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))
+ if volatility < 1.0: # Relatively stable
+ score += 2
+ details.append(f"Low earnings volatility: {volatility:.2f}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_financial_fortress(metrics: list, financial_line_items: list) -> dict:
+ """Buffett's fortress balance sheet requirements"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No financial data"}
+
+ latest = metrics[0]
+
+ # Low debt-to-equity (financial safety)
+ if latest.debt_to_equity and latest.debt_to_equity < 0.3:
+ score += 3
+ details.append(f"Conservative debt: {latest.debt_to_equity:.2f} D/E")
+
+ # High current ratio (liquidity)
+ if latest.current_ratio and latest.current_ratio > 1.5:
+ score += 2
+ details.append(f"Strong liquidity: {latest.current_ratio:.1f} current ratio")
+
+ # Positive free cash flow consistency
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals:
+ positive_fcf = sum(1 for fcf in fcf_vals if fcf > 0)
+ if positive_fcf >= 8:
+ score += 2
+ details.append(f"Reliable cash generation: {positive_fcf}/10 years positive FCF")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def analyze_capital_allocation(financial_line_items: list) -> dict:
+ """Buffett values management that allocates capital wisely"""
+ score = 0
+ details = []
+
+ # Share buybacks when appropriate (declining share count)
+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]
+ if len(shares) >= 5:
+ share_reduction = (shares[-1] - shares[0]) / shares[-1]
+ if share_reduction > 0.1: # 10%+ reduction
+ score += 2
+ details.append(f"Shareholder-friendly buybacks: {share_reduction:.1%} share reduction")
+
+ # Retained earnings growth (reinvestment effectiveness)
+ retained_earnings = [item.retained_earnings for item in financial_line_items if item.retained_earnings]
+ if len(retained_earnings) >= 5:
+ re_growth = (retained_earnings[0] - retained_earnings[-1]) / abs(retained_earnings[-1])
+ if re_growth > 0.5: # 50%+ growth in retained earnings
+ score += 2
+ details.append(f"Effective reinvestment: {re_growth:.1%} retained earnings growth")
+
+ # Reasonable R&D (not excessive, not zero)
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals) / sum(revenues)
+ if 0.02 <= rd_intensity <= 0.08: # 2-8% of revenue
+ score += 1
+ details.append(f"Balanced R&D spend: {rd_intensity:.1%} of revenue")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def buffett_valuation(financial_line_items: list, market_cap: float) -> dict:
+ """Buffett's 'fair price for wonderful business' approach"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No valuation data"}
+
+ latest = financial_line_items[0]
+ earnings = [item.net_income for item in financial_line_items if item.net_income and item.net_income > 0]
+
+ if not earnings:
+ return {"score": 0, "details": "No positive earnings for valuation"}
+
+ # Owner earnings approximation (FCF)
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_yield = latest.free_cash_flow / market_cap
+ if fcf_yield > 0.08: # 8%+ FCF yield
+ score += 3
+ details.append(f"Attractive FCF yield: {fcf_yield:.1%}")
+ elif fcf_yield > 0.05:
+ score += 1
+ details.append(f"Reasonable FCF yield: {fcf_yield:.1%}")
+
+ # PE ratio (Buffett likes reasonable multiples)
+ if latest.net_income and latest.net_income > 0:
+ pe_ratio = market_cap / latest.net_income
+ if pe_ratio < 15:
+ score += 2
+ details.append(f"Reasonable valuation: {pe_ratio:.1f} P/E")
+ elif pe_ratio < 25:
+ score += 1
+ details.append(f"Fair valuation: {pe_ratio:.1f} P/E")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def generate_buffett_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> BuffettSignal:
+ """Generate Buffett-style investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Warren Buffett's AI agent. Follow his investment philosophy:
+
+ 1. "Buy wonderful companies at fair prices" - Seek businesses with durable competitive advantages
+ 2. Economic moats: High ROE, pricing power, brand strength, network effects
+ 3. Predictable earnings: Consistent profitability over many years
+ 4. Financial fortress: Low debt, strong balance sheet, reliable cash flow
+ 5. Quality management: Efficient capital allocation, shareholder-friendly
+ 6. Long-term perspective: "Our favorite holding period is forever"
+ 7. Circle of competence: Understand the business model completely
+
+ Reasoning style:
+ - Focus on business fundamentals, not market movements
+ - Emphasize competitive advantages and moats
+ - Discuss management quality and capital allocation
+ - Value predictability over growth
+ - Use homespun analogies and simple explanations
+ - Express high conviction for quality businesses
+
+ Return signal: bullish (wonderful business at fair price), neutral (good business, wrong price), bearish (poor business fundamentals)"""),
+
+ ("human", """Analyze {ticker} using Buffett's criteria:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string"
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_buffett_signal():
+ return BuffettSignal(signal="neutral", confidence=0.0, reasoning="Analysis error, defaulting to neutral")
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=BuffettSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_buffett_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.py
new file mode 100644
index 000000000..1409eaae5
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/arq_capital_hedge_fund_agent/arq_agent.py
@@ -0,0 +1,907 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+import math
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class AQRSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ factor_exposures: dict
+
+
+def aqr_capital_hedge_fund_agent(state: AgentState, agent_id: str = "aqr_capital_hedge_fund_agent"):
+ """
+ AQR Capital Management: Factor investing, value-momentum combination
+ Structure: Academic Research → Factor Analysis → Portfolio Construction → Risk Management → Cliff Asness Decision
+ Philosophy: Systematic factor investing, academic rigor, long-term evidence
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ aqr_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Academic research team analyzing factors")
+
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="annual",
+ limit=10,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # AQR's factor-based analysis structure
+ progress.update_status(agent_id, ticker, "Academic research team analysis")
+ academic_research = academic_research_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Factor analysis team")
+ factor_analysis = factor_analysis_team(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Portfolio construction team")
+ portfolio_construction = portfolio_construction_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk management analysis")
+ risk_management = risk_management_analysis(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Cliff Asness systematic decision")
+ cliff_asness_decision = cliff_asness_systematic_decision(
+ academic_research, factor_analysis, portfolio_construction, risk_management
+ )
+
+ # AQR's factor-weighted scoring
+ total_score = (
+ factor_analysis["score"] * 0.4 +
+ academic_research["score"] * 0.25 +
+ portfolio_construction["score"] * 0.2 +
+ risk_management["score"] * 0.15
+ )
+
+ # AQR's systematic factor approach
+ factor_strength = factor_analysis.get("combined_factor_score", 0)
+ if total_score >= 7.5 and factor_strength > 0.6:
+ signal = "bullish"
+ elif total_score <= 4.0 or factor_strength < 0.3:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "academic_research": academic_research,
+ "factor_analysis": factor_analysis,
+ "portfolio_construction": portfolio_construction,
+ "risk_management": risk_management,
+ "cliff_asness_decision": cliff_asness_decision
+ }
+
+ aqr_output = generate_aqr_output(ticker, analysis_data, state, agent_id)
+
+ aqr_analysis[ticker] = {
+ "signal": aqr_output.signal,
+ "confidence": aqr_output.confidence,
+ "reasoning": aqr_output.reasoning,
+ "factor_exposures": aqr_output.factor_exposures
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=aqr_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(aqr_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(aqr_analysis, "AQR Capital Management")
+
+ state["data"]["analyst_signals"][agent_id] = aqr_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def academic_research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """AQR's academic research team analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No academic research data"}
+
+ # Long-term evidence analysis
+ historical_performance = analyze_long_term_evidence(metrics, financial_line_items)
+ if historical_performance > 0.7:
+ score += 3
+ details.append(f"Strong long-term evidence: {historical_performance:.2f}")
+
+ # Academic factor validation
+ factor_persistence = validate_factor_persistence(metrics, financial_line_items)
+ if factor_persistence > 0.6:
+ score += 2
+ details.append(f"Factor persistence validated: {factor_persistence:.2f}")
+
+ # Statistical significance testing
+ statistical_significance = test_statistical_significance(financial_line_items)
+ if statistical_significance > 0.95: # 95% confidence
+ score += 2
+ details.append(f"Statistically significant at {statistical_significance:.1%} level")
+
+ # Out-of-sample performance
+ out_of_sample_test = conduct_out_of_sample_test(financial_line_items)
+ if out_of_sample_test > 0.6:
+ score += 2
+ details.append("Passes out-of-sample validation")
+
+ # Literature review consistency
+ literature_consistency = check_literature_consistency(metrics)
+ if literature_consistency > 0.7:
+ score += 1
+ details.append("Consistent with academic literature")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def factor_analysis_team(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """AQR's factor analysis team"""
+ score = 0
+ details = []
+ factor_scores = {}
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No factor data"}
+
+ # Value factor analysis
+ value_score = calculate_value_factor(metrics, market_cap)
+ factor_scores["value"] = value_score
+ if value_score > 0.6:
+ score += 2.5
+ details.append(f"Strong value factor: {value_score:.2f}")
+
+ # Momentum factor analysis
+ momentum_score = calculate_momentum_factor(financial_line_items)
+ factor_scores["momentum"] = momentum_score
+ if momentum_score > 0.6:
+ score += 2.5
+ details.append(f"Positive momentum factor: {momentum_score:.2f}")
+
+ # Quality factor analysis
+ quality_score = calculate_quality_factor(metrics, financial_line_items)
+ factor_scores["quality"] = quality_score
+ if quality_score > 0.7:
+ score += 2
+ details.append(f"High quality factor: {quality_score:.2f}")
+
+ # Low volatility factor
+ low_vol_score = calculate_low_volatility_factor(financial_line_items)
+ factor_scores["low_volatility"] = low_vol_score
+ if low_vol_score > 0.6:
+ score += 1.5
+ details.append(f"Low volatility characteristics: {low_vol_score:.2f}")
+
+ # Profitability factor
+ profitability_score = calculate_profitability_factor(metrics, financial_line_items)
+ factor_scores["profitability"] = profitability_score
+ if profitability_score > 0.7:
+ score += 1.5
+ details.append(f"Strong profitability factor: {profitability_score:.2f}")
+
+ # Factor combination analysis (AQR's specialty)
+ combined_factor_score = combine_factors_aqr_style(factor_scores)
+
+ # Value-momentum crash protection
+ crash_protection = analyze_value_momentum_crash_protection(factor_scores)
+ if crash_protection > 0.6:
+ score += 1
+ details.append("Good crash protection from factor combination")
+
+ return {
+ "score": min(score, 10),
+ "details": "; ".join(details),
+ "factor_scores": factor_scores,
+ "combined_factor_score": combined_factor_score
+ }
+
+
+def portfolio_construction_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """AQR's portfolio construction team analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No portfolio construction data"}
+
+ # Factor timing analysis
+ factor_timing_score = analyze_factor_timing(financial_line_items)
+ if factor_timing_score > 0.6:
+ score += 2
+ details.append(f"Good factor timing opportunity: {factor_timing_score:.2f}")
+
+ # Position sizing optimization
+ position_sizing = optimize_position_sizing(metrics, market_cap)
+ if position_sizing > 0.7:
+ score += 2
+ details.append("Optimal position sizing for factor exposure")
+
+ # Transaction cost analysis
+ transaction_costs = analyze_transaction_costs_aqr(market_cap)
+ if transaction_costs < 0.02: # Low transaction costs
+ score += 1.5
+ details.append(f"Low implementation costs: {transaction_costs:.2%}")
+
+ # Capacity constraints
+ strategy_capacity = assess_aqr_strategy_capacity(market_cap)
+ if strategy_capacity > 0.8:
+ score += 1.5
+ details.append("High strategy capacity")
+
+ # Risk budgeting
+ risk_budgeting_score = analyze_risk_budgeting(financial_line_items)
+ if risk_budgeting_score > 0.7:
+ score += 1
+ details.append("Efficient risk budgeting allocation")
+
+ # Rebalancing frequency optimization
+ rebalancing_analysis = optimize_rebalancing_frequency(financial_line_items)
+ if rebalancing_analysis > 0.6:
+ score += 1
+ details.append("Optimal rebalancing frequency identified")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def risk_management_analysis(metrics: list, financial_line_items: list) -> dict:
+ """AQR's risk management analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No risk data"}
+
+ # Factor risk decomposition
+ factor_risk_decomp = decompose_factor_risks(metrics, financial_line_items)
+ if factor_risk_decomp.get("diversification_ratio", 0) > 0.7:
+ score += 2
+ details.append("Good factor diversification")
+
+ # Drawdown control
+ drawdown_analysis = analyze_drawdown_control(financial_line_items)
+ if drawdown_analysis < 0.15: # <15% max drawdown
+ score += 2
+ details.append(f"Controlled drawdown risk: {drawdown_analysis:.1%}")
+
+ # Regime analysis
+ regime_analysis = conduct_regime_analysis(financial_line_items)
+ if regime_analysis.get("regime_stability", 0) > 0.6:
+ score += 1.5
+ details.append("Stable across market regimes")
+
+ # Tail risk hedging
+ tail_risk_hedge = analyze_tail_risk_hedging(financial_line_items)
+ if tail_risk_hedge > 0.6:
+ score += 1.5
+ details.append("Good tail risk characteristics")
+
+ # Leverage optimization
+ leverage_analysis = optimize_leverage_aqr(metrics, financial_line_items)
+ if leverage_analysis > 0.7:
+ score += 1
+ details.append("Optimal leverage for factor exposure")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def cliff_asness_systematic_decision(academic_research: dict, factor_analysis: dict,
+ portfolio_construction: dict, risk_management: dict) -> dict:
+ """Cliff Asness' systematic factor-based decision"""
+ details = []
+
+ # Factor strength analysis
+ factor_strength = factor_analysis.get("combined_factor_score", 0)
+ academic_validation = academic_research["score"] / 10
+ implementation_feasibility = portfolio_construction["score"] / 10
+ risk_control = risk_management["score"] / 10
+
+ # AQR's decision framework
+ overall_attractiveness = (
+ factor_strength * 0.4 +
+ academic_validation * 0.3 +
+ implementation_feasibility * 0.2 +
+ risk_control * 0.1
+ )
+
+ # Factor timing considerations
+ value_momentum_combination = factor_analysis.get("factor_scores", {})
+ value_score = value_momentum_combination.get("value", 0)
+ momentum_score = value_momentum_combination.get("momentum", 0)
+
+ # Cliff's decision logic
+ if overall_attractiveness > 0.7 and factor_strength > 0.6:
+ if value_score > 0.6 and momentum_score > 0.6:
+ decision = "High conviction factor combination"
+ details.append("Strong value-momentum combination with academic support")
+ else:
+ decision = "Single factor exposure"
+ details.append("Strong single factor with systematic evidence")
+ elif overall_attractiveness > 0.5:
+ decision = "Moderate factor allocation"
+ details.append("Moderate factor exposure with risk controls")
+ elif factor_strength < 0.3:
+ decision = "Avoid - weak factor exposure"
+ details.append("Insufficient factor exposure for systematic strategy")
+ else:
+ decision = "Hold for better factor timing"
+ details.append("Wait for stronger factor signals")
+
+ # Academic rigor check
+ if academic_research["score"] < 6:
+ decision = "Insufficient academic evidence"
+ details.append("Does not meet AQR's academic rigor standards")
+
+ return {
+ "decision": decision,
+ "overall_attractiveness": overall_attractiveness,
+ "factor_strength": factor_strength,
+ "details": "; ".join(details)
+ }
+
+
+# Factor Analysis Helper Functions
+def calculate_value_factor(metrics: list, market_cap: float) -> float:
+ """Calculate AQR's value factor score"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ value_score = 0
+ components = 0
+
+ # Price-to-book
+ if latest.price_to_book:
+ pb_score = max(0, 1 - (latest.price_to_book / 2)) # Normalize by 2.0
+ value_score += pb_score
+ components += 1
+
+ # Price-to-earnings
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ pe_score = max(0, 1 - (latest.price_to_earnings / 20)) # Normalize by 20
+ value_score += pe_score
+ components += 1
+
+ # Enterprise value to EBITDA (approximated)
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ ev_ebitda_proxy = latest.price_to_earnings * 0.8 # Rough proxy
+ ev_ebitda_score = max(0, 1 - (ev_ebitda_proxy / 15))
+ value_score += ev_ebitda_score
+ components += 1
+
+ return value_score / components if components > 0 else 0.5
+
+
+def calculate_momentum_factor(financial_line_items: list) -> float:
+ """Calculate AQR's momentum factor score"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) < 4:
+ return 0.5
+
+ # Revenue momentum (multiple time horizons)
+ short_term_momentum = (revenues[0] / revenues[1]) - 1 # 1-year
+ medium_term_momentum = (revenues[0] / revenues[2]) ** 0.5 - 1 # 2-year annualized
+ long_term_momentum = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period
+
+ # Weight recent momentum more heavily
+ momentum_score = (
+ short_term_momentum * 0.5 +
+ medium_term_momentum * 0.3 +
+ long_term_momentum * 0.2
+ )
+
+ # Normalize to 0-1 scale
+ return min(max((momentum_score + 0.2) / 0.4, 0), 1) # -20% to +20% maps to 0-1
+
+
+def calculate_quality_factor(metrics: list, financial_line_items: list) -> float:
+ """Calculate AQR's quality factor score"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ quality_components = []
+
+ # Profitability metrics
+ if latest.return_on_equity:
+ roe_score = min(latest.return_on_equity / 0.2, 1.0) # Normalize by 20%
+ quality_components.append(roe_score)
+
+ if latest.return_on_assets:
+ roa_score = min(latest.return_on_assets / 0.1, 1.0) # Normalize by 10%
+ quality_components.append(roa_score)
+
+ # Earnings stability
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ earnings_stability = 1 - min(calculate_coefficient_of_variation(earnings), 1.0)
+ quality_components.append(earnings_stability)
+
+ # Debt-to-equity (lower is better for quality)
+ if latest.debt_to_equity is not None:
+ debt_quality = max(0, 1 - latest.debt_to_equity) # 0 debt = 1.0 score
+ quality_components.append(debt_quality)
+
+ return sum(quality_components) / len(quality_components) if quality_components else 0.5
+
+
+def calculate_low_volatility_factor(financial_line_items: list) -> float:
+ """Calculate low volatility factor score"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+
+ if not revenues and not earnings:
+ return 0.5
+
+ volatility_scores = []
+
+ if revenues:
+ revenue_vol = calculate_coefficient_of_variation(revenues)
+ volatility_scores.append(max(0, 1 - revenue_vol))
+
+ if earnings:
+ earnings_vol = calculate_coefficient_of_variation(earnings)
+ volatility_scores.append(max(0, 1 - earnings_vol))
+
+ return sum(volatility_scores) / len(volatility_scores) if volatility_scores else 0.5
+
+
+def calculate_profitability_factor(metrics: list, financial_line_items: list) -> float:
+ """Calculate profitability factor score"""
+ if not metrics or not financial_line_items:
+ return 0.5
+
+ latest = metrics[0]
+ latest_financial = financial_line_items[0]
+
+ profitability_components = []
+
+ # Gross margins
+ if latest_financial.operating_margin:
+ margin_score = min(latest_financial.operating_margin / 0.2, 1.0) # Normalize by 20%
+ profitability_components.append(margin_score)
+
+ # Return on invested capital
+ if latest.return_on_invested_capital:
+ roic_score = min(latest.return_on_invested_capital / 0.15, 1.0)
+ profitability_components.append(roic_score)
+
+ # Free cash flow margin
+ if latest_financial.free_cash_flow and latest_financial.revenue:
+ fcf_margin = latest_financial.free_cash_flow / latest_financial.revenue
+ fcf_score = min(max(fcf_margin / 0.1, 0), 1.0) # Normalize by 10%
+ profitability_components.append(fcf_score)
+
+ return sum(profitability_components) / len(profitability_components) if profitability_components else 0.5
+
+
+def combine_factors_aqr_style(factor_scores: dict) -> float:
+ """Combine factors using AQR's methodology"""
+ if not factor_scores:
+ return 0.5
+
+ # AQR's factor combination approach
+ value_score = factor_scores.get("value", 0.5)
+ momentum_score = factor_scores.get("momentum", 0.5)
+ quality_score = factor_scores.get("quality", 0.5)
+
+ # Value-momentum combination (AQR's specialty)
+ if value_score > 0.6 and momentum_score > 0.6:
+ # Strong combination bonus
+ combined_score = (value_score + momentum_score) / 2 + 0.1
+ else:
+ # Standard combination
+ combined_score = (
+ value_score * 0.35 +
+ momentum_score * 0.35 +
+ quality_score * 0.3
+ )
+
+ return min(combined_score, 1.0)
+
+
+def analyze_value_momentum_crash_protection(factor_scores: dict) -> float:
+ """Analyze crash protection from value-momentum combination"""
+ value_score = factor_scores.get("value", 0.5)
+ momentum_score = factor_scores.get("momentum", 0.5)
+ quality_score = factor_scores.get("quality", 0.5)
+
+ # Value provides crash protection, momentum can be risky
+ crash_protection = value_score * 0.6 + quality_score * 0.4 - max(0, momentum_score - 0.5) * 0.2
+
+ return min(max(crash_protection, 0), 1.0)
+
+
+def analyze_long_term_evidence(metrics: list, financial_line_items: list) -> float:
+ """Analyze long-term evidence for factor performance"""
+ if len(financial_line_items) < 5:
+ return 0.3 # Insufficient data
+
+ # Consistency over time
+ consistent_performance = 0
+
+ # Revenue consistency
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues:
+ positive_growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ consistency = positive_growth_years / (len(revenues) - 1)
+ consistent_performance += consistency * 0.5
+
+ # Profitability consistency
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ positive_earnings_years = sum(1 for e in earnings if e > 0)
+ profitability_consistency = positive_earnings_years / len(earnings)
+ consistent_performance += profitability_consistency * 0.5
+
+ return min(consistent_performance, 1.0)
+
+
+def validate_factor_persistence(metrics: list, financial_line_items: list) -> float:
+ """Validate factor persistence over time"""
+ if len(metrics) < 3:
+ return 0.5
+
+ # Check if factors persist over time
+ persistence_score = 0
+
+ # Value factor persistence
+ pb_ratios = [m.price_to_book for m in metrics if m.price_to_book]
+ if len(pb_ratios) >= 3:
+ value_trend = pb_ratios[0] < pb_ratios[-1] # Becoming cheaper
+ if value_trend:
+ persistence_score += 0.3
+
+ # Quality factor persistence
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if len(roe_vals) >= 3:
+ avg_roe = sum(roe_vals) / len(roe_vals)
+ if avg_roe > 0.12: # Consistently high quality
+ persistence_score += 0.4
+
+ # Momentum persistence
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ momentum_trend = revenues[0] > revenues[-1] # Growth trend
+ if momentum_trend:
+ persistence_score += 0.3
+
+ return persistence_score
+
+
+def test_statistical_significance(financial_line_items: list) -> float:
+ """Test statistical significance of factor performance"""
+ if len(financial_line_items) < 5:
+ return 0.6 # Insufficient data for strong significance
+
+ # Simple t-test approximation for revenue growth
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]
+
+ if growth_rates:
+ mean_growth = sum(growth_rates) / len(growth_rates)
+ if len(growth_rates) > 1:
+ variance = sum((g - mean_growth) ** 2 for g in growth_rates) / (len(growth_rates) - 1)
+ std_error = math.sqrt(variance / len(growth_rates))
+
+ if std_error > 0:
+ t_stat = abs(mean_growth / std_error)
+ # Rough conversion to confidence level
+ return min(0.5 + t_stat * 0.1, 0.99)
+
+ return 0.7 # Moderate significance
+
+
+def conduct_out_of_sample_test(financial_line_items: list) -> float:
+ """Conduct out-of-sample test"""
+ if len(financial_line_items) < 8:
+ return 0.5
+
+ # Split data and test performance
+ in_sample = financial_line_items[len(financial_line_items) // 2:]
+ out_sample = financial_line_items[:len(financial_line_items) // 2]
+
+ # Test revenue growth persistence
+ in_sample_revenues = [item.revenue for item in in_sample if item.revenue]
+ out_sample_revenues = [item.revenue for item in out_sample if item.revenue]
+
+ if len(in_sample_revenues) >= 2 and len(out_sample_revenues) >= 2:
+ in_sample_growth = (in_sample_revenues[0] / in_sample_revenues[-1]) - 1
+ out_sample_growth = (out_sample_revenues[0] / out_sample_revenues[-1]) - 1
+
+ # Check if growth pattern persists
+ if (in_sample_growth > 0 and out_sample_growth > 0) or (in_sample_growth < 0 and out_sample_growth < 0):
+ return 0.8 # Good out-of-sample performance
+ else:
+ return 0.4 # Poor out-of-sample performance
+
+ return 0.6 # Moderate out-of-sample performance
+
+
+def check_literature_consistency(metrics: list) -> float:
+ """Check consistency with academic literature"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ consistency_score = 0
+
+ # Value factor literature consistency
+ if latest.price_to_book and latest.price_to_book < 1.5:
+ consistency_score += 0.3 # Consistent with value literature
+
+ # Quality factor literature consistency
+ if latest.return_on_equity and latest.return_on_equity > 0.15:
+ consistency_score += 0.4 # Consistent with quality literature
+
+ # Size factor (smaller companies historically outperform)
+ # This would require market cap data relative to universe
+ consistency_score += 0.3 # Placeholder
+
+ return consistency_score
+
+
+def analyze_factor_timing(financial_line_items: list) -> float:
+ """Analyze factor timing opportunities"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) < 4:
+ return 0.5
+
+ # Check for inflection points in business cycle
+ recent_acceleration = (revenues[0] / revenues[1]) > (revenues[1] / revenues[2])
+
+ if recent_acceleration:
+ return 0.8 # Good timing for momentum
+ else:
+ return 0.4 # Poor timing
+
+
+def optimize_position_sizing(metrics: list, market_cap: float) -> float:
+ """Optimize position sizing for factor exposure"""
+ if not metrics:
+ return 0.5
+
+ # Kelly criterion approximation
+ latest = metrics[0]
+
+ if latest.return_on_equity and latest.return_on_equity > 0:
+ expected_return = latest.return_on_equity * 0.5 # Conservative estimate
+ volatility = 0.2 # Assumed volatility
+
+ if volatility > 0:
+ kelly_fraction = expected_return / (volatility ** 2)
+ optimal_size = min(max(kelly_fraction, 0), 0.1) # Cap at 10%
+ return optimal_size * 10 # Scale to 0-1
+
+ return 0.5
+
+
+def analyze_transaction_costs_aqr(market_cap: float) -> float:
+ """Analyze transaction costs for AQR strategies"""
+ if market_cap > 50_000_000_000: # $50B+
+ return 0.005 # 0.5 bps
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.01 # 1 bps
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.02 # 2 bps
+ else:
+ return 0.05 # 5 bps
+
+
+def assess_aqr_strategy_capacity(market_cap: float) -> float:
+ """Assess strategy capacity for AQR factor strategies"""
+ # Larger companies have higher capacity
+ return min(math.log10(market_cap / 1_000_000_000) / 2, 1.0)
+
+
+def analyze_risk_budgeting(financial_line_items: list) -> float:
+ """Analyze risk budgeting allocation"""
+ # Simplified risk budgeting based on earnings stability
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ earnings_cv = calculate_coefficient_of_variation(earnings)
+ return max(0, 1 - earnings_cv)
+
+ return 0.5
+
+
+def optimize_rebalancing_frequency(financial_line_items: list) -> float:
+ """Optimize rebalancing frequency"""
+ # Based on persistence of factor signals
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ # Check signal persistence
+ growth_consistency = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ persistence = growth_consistency / (len(revenues) - 1)
+
+ if persistence > 0.7:
+ return 0.8 # Low rebalancing frequency needed
+ else:
+ return 0.4 # High rebalancing frequency needed
+
+ return 0.6
+
+
+def decompose_factor_risks(metrics: list, financial_line_items: list) -> dict:
+ """Decompose factor risks"""
+ return {
+ "market_beta": 0.7,
+ "value_loading": 0.6,
+ "momentum_loading": 0.4,
+ "quality_loading": 0.5,
+ "size_loading": 0.3,
+ "diversification_ratio": 0.8
+ }
+
+
+def analyze_drawdown_control(financial_line_items: list) -> float:
+ """Analyze drawdown control"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ peak = max(earnings)
+ trough = min(earnings)
+ if peak > 0:
+ max_drawdown = (peak - trough) / peak
+ return max_drawdown
+
+ return 0.2 # Assumed 20% max drawdown
+
+
+def conduct_regime_analysis(financial_line_items: list) -> dict:
+ """Conduct regime analysis"""
+ return {
+ "regime_stability": 0.7,
+ "bull_market_performance": 0.8,
+ "bear_market_performance": 0.6,
+ "recession_performance": 0.5
+ }
+
+
+def analyze_tail_risk_hedging(financial_line_items: list) -> float:
+ """Analyze tail risk hedging characteristics"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ # Check for negative skewness (tail risk)
+ sorted_earnings = sorted(earnings)
+ worst_10pct = sorted_earnings[:max(1, len(earnings) // 10)]
+
+ if worst_10pct:
+ avg_earnings = sum(earnings) / len(earnings)
+ worst_performance = sum(worst_10pct) / len(worst_10pct)
+
+ if avg_earnings > 0:
+ tail_ratio = worst_performance / avg_earnings
+ return max(0, 1 + tail_ratio) # Better if tail ratio is less negative
+
+ return 0.6
+
+
+def optimize_leverage_aqr(metrics: list, financial_line_items: list) -> float:
+ """Optimize leverage for AQR factor strategies"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+
+ # Target leverage based on Sharpe ratio
+ if latest.return_on_equity:
+ estimated_sharpe = latest.return_on_equity * 2 # Rough proxy
+ optimal_leverage = min(max(estimated_sharpe, 1.0), 3.0) # 1x to 3x leverage
+ return optimal_leverage / 3.0 # Normalize to 0-1
+
+ return 0.7 # Moderate leverage
+
+
+def calculate_coefficient_of_variation(data: list) -> float:
+ """Calculate coefficient of variation"""
+ if not data or len(data) < 2:
+ return 1.0
+
+ mean_val = sum(data) / len(data)
+ if mean_val == 0:
+ return 1.0
+
+ variance = sum((x - mean_val) ** 2 for x in data) / (len(data) - 1)
+ std_dev = math.sqrt(variance)
+
+ return std_dev / abs(mean_val)
+
+
+def generate_aqr_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> AQRSignal:
+ """Generate AQR's factor-based investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are AQR Capital Management's AI system, implementing Cliff Asness' factor investing approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Academic Research Team: Literature review and statistical validation
+ - Factor Analysis Team: Value, momentum, quality, and low-vol factor analysis
+ - Portfolio Construction Team: Position sizing and implementation
+ - Risk Management Team: Factor risk decomposition and drawdown control
+ - Cliff Asness Systematic Decision: Factor combination and timing
+
+ PHILOSOPHY:
+ 1. Factor Investing: Systematic exposure to value, momentum, quality factors
+ 2. Academic Rigor: Evidence-based investing with statistical validation
+ 3. Factor Timing: Intelligent timing of factor exposures
+ 4. Value-Momentum Combination: AQR's specialty in combining opposing factors
+ 5. Risk Management: Sophisticated factor risk controls
+ 6. Long-term Evidence: Focus on factors with decades of evidence
+ 7. Implementation Focus: Minimize transaction costs and market impact
+
+ REASONING STYLE:
+ - Reference academic literature and statistical evidence
+ - Discuss factor exposures and loadings quantitatively
+ - Apply rigorous statistical testing and out-of-sample validation
+ - Consider factor timing and regime analysis
+ - Express confidence in factor persistence and literature consistency
+ - Analyze implementation costs and capacity constraints
+ - Focus on risk-adjusted returns and Sharpe ratios
+
+ Return investment signal with detailed factor exposure analysis."""),
+
+ ("human", """Apply AQR's factor analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "factor_exposures": {{
+ "value": float,
+ "momentum": float,
+ "quality": float,
+ "low_volatility": float,
+ "profitability": float,
+ "combined_factor_score": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_aqr_signal():
+ return AQRSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ factor_exposures={
+ "value": 0.5,
+ "momentum": 0.5,
+ "quality": 0.5,
+ "low_volatility": 0.5,
+ "profitability": 0.5,
+ "combined_factor_score": 0.5
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=AQRSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_aqr_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py
new file mode 100644
index 000000000..4cb77fcd1
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/bridgewater_associates_hedge_fund_agent/bridgewater_associates_agent.py
@@ -0,0 +1,511 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class BridgewaterSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ all_weather_allocation: dict
+
+
+def bridgewater_associates_agent(state: AgentState, agent_id: str = "bridgewater_associates_agent"):
+ """
+ Bridgewater Associates: All Weather portfolio, economic machine principles
+ Structure: Economic Research → Portfolio Construction → Risk Management → Ray Dalio Final Decision
+ Philosophy: Diversification across economic environments, systematic risk parity
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ bridgewater_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Economic research team analyzing macro environment")
+
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=10, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "interest_expense"
+ ],
+ end_date,
+ period="annual",
+ limit=10,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Bridgewater's multi-team analysis structure
+ progress.update_status(agent_id, ticker, "Economic research team analysis")
+ economic_research = economic_research_team_analysis(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Portfolio construction team analysis")
+ portfolio_construction = portfolio_construction_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk management team analysis")
+ risk_management = risk_management_team_analysis(financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "All Weather framework analysis")
+ all_weather_analysis = all_weather_framework_analysis(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Ray Dalio's synthesis and final decision")
+ ray_dalio_synthesis = ray_dalio_final_decision(
+ economic_research, portfolio_construction, risk_management, all_weather_analysis
+ )
+
+ # Bridgewater's risk-parity weighted scoring
+ total_score = (
+ economic_research["score"] * 0.3 +
+ all_weather_analysis["score"] * 0.25 +
+ risk_management["score"] * 0.25 +
+ portfolio_construction["score"] * 0.2
+ )
+
+ # Bridgewater's systematic approach
+ if total_score >= 7.5:
+ signal = "bullish"
+ elif total_score <= 4.0:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "economic_research": economic_research,
+ "portfolio_construction": portfolio_construction,
+ "risk_management": risk_management,
+ "all_weather_analysis": all_weather_analysis,
+ "ray_dalio_synthesis": ray_dalio_synthesis
+ }
+
+ bridgewater_output = generate_bridgewater_output(ticker, analysis_data, state, agent_id)
+
+ bridgewater_analysis[ticker] = {
+ "signal": bridgewater_output.signal,
+ "confidence": bridgewater_output.confidence,
+ "reasoning": bridgewater_output.reasoning,
+ "all_weather_allocation": bridgewater_output.all_weather_allocation
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=bridgewater_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(bridgewater_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(bridgewater_analysis, "Bridgewater Associates")
+
+ state["data"]["analyst_signals"][agent_id] = bridgewater_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def economic_research_team_analysis(metrics: list, financial_line_items: list) -> dict:
+ """Bridgewater's economic research team analyzing macro environment impact"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No economic data"}
+
+ # Economic cycle positioning
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ # Growth trend analysis
+ recent_growth = (revenues[0] / revenues[2]) ** (1 / 2) - 1 # 2-year CAGR
+ longer_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1 # Full period
+
+ # Economic machine principle: Growth and inflation environment
+ if 0.02 <= recent_growth <= 0.08: # Goldilocks growth
+ score += 2
+ details.append(f"Sustainable growth environment: {recent_growth:.1%} recent growth")
+ elif recent_growth > 0.15: # Overheating risk
+ score -= 1
+ details.append(f"Potential overheating: {recent_growth:.1%} growth")
+
+ # Debt cycle analysis
+ debt_metrics = [m.debt_to_equity for m in metrics if m.debt_to_equity]
+ if debt_metrics:
+ current_leverage = debt_metrics[0]
+ avg_leverage = sum(debt_metrics) / len(debt_metrics)
+
+ # Bridgewater's debt cycle framework
+ if current_leverage < avg_leverage * 0.8: # Deleveraging phase
+ score += 1
+ details.append("Company in deleveraging phase - defensive positioning")
+ elif current_leverage > avg_leverage * 1.3: # High leverage risk
+ score -= 2
+ details.append("High leverage in debt cycle - risk concern")
+
+ # Currency and inflation hedging capability
+ international_exposure = analyze_international_exposure(financial_line_items)
+ if international_exposure > 0.3: # 30%+ international
+ score += 1
+ details.append("Natural currency hedging through international exposure")
+
+ # Interest rate sensitivity
+ interest_coverage = calculate_interest_coverage(financial_line_items)
+ if interest_coverage > 5: # Low interest rate sensitivity
+ score += 1
+ details.append(f"Low interest rate risk: {interest_coverage:.1f}x coverage")
+ elif interest_coverage < 2:
+ score -= 1
+ details.append(f"High interest rate sensitivity: {interest_coverage:.1f}x coverage")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def portfolio_construction_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Bridgewater's portfolio construction team analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No portfolio construction data"}
+
+ latest_metrics = metrics[0]
+
+ # Risk-adjusted returns
+ if latest_metrics.return_on_equity:
+ roe_consistency = len([m.return_on_equity for m in metrics if m.return_on_equity and m.return_on_equity > 0.1])
+ if roe_consistency >= len(metrics) * 0.8: # Consistent returns
+ score += 2
+ details.append(f"Consistent risk-adjusted returns: {roe_consistency}/{len(metrics)} years ROE >10%")
+
+ # Diversification benefits
+ revenue_stability = analyze_revenue_diversification(financial_line_items)
+ if revenue_stability > 0.8: # Stable revenue streams
+ score += 1
+ details.append("Revenue diversification provides portfolio stability")
+
+ # Correlation with economic factors
+ earnings_correlation = analyze_economic_correlation(financial_line_items)
+ if earnings_correlation < 0.7: # Low correlation
+ score += 2
+ details.append("Low correlation with economic cycles - diversification benefit")
+
+ # Liquidity for rebalancing
+ if latest_metrics.current_ratio and latest_metrics.current_ratio > 1.5:
+ score += 1
+ details.append(f"Adequate liquidity for dynamic rebalancing: {latest_metrics.current_ratio:.1f}")
+
+ # Valuation relative to fair value
+ if latest_metrics.price_to_earnings and latest_metrics.price_to_earnings < 18:
+ score += 1
+ details.append(f"Reasonable valuation for portfolio inclusion: {latest_metrics.price_to_earnings:.1f} P/E")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def risk_management_team_analysis(financial_line_items: list, market_cap: float) -> dict:
+ """Bridgewater's risk management team analysis"""
+ score = 0
+ details = []
+ risk_factors = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No risk data"}
+
+ latest = financial_line_items[0]
+
+ # Balance sheet risk
+ if latest.total_debt and latest.shareholders_equity:
+ leverage_ratio = latest.total_debt / latest.shareholders_equity
+ if leverage_ratio < 0.4: # Low leverage risk
+ score += 2
+ details.append(f"Low balance sheet risk: {leverage_ratio:.2f} D/E")
+ elif leverage_ratio > 1.0:
+ risk_factors.append("High leverage risk")
+ score -= 2
+
+ # Liquidity risk
+ if latest.current_assets and latest.current_liabilities:
+ liquidity_ratio = latest.current_assets / latest.current_liabilities
+ if liquidity_ratio > 2.0:
+ score += 1
+ details.append(f"Low liquidity risk: {liquidity_ratio:.1f} current ratio")
+ elif liquidity_ratio < 1.2:
+ risk_factors.append("Liquidity concerns")
+ score -= 1
+
+ # Earnings volatility risk
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings and len(earnings) >= 5:
+ earnings_volatility = (max(earnings) - min(earnings)) / max(abs(max(earnings)), abs(min(earnings)))
+ if earnings_volatility < 0.5:
+ score += 1
+ details.append(f"Low earnings volatility: {earnings_volatility:.2f}")
+ elif earnings_volatility > 1.0:
+ risk_factors.append("High earnings volatility")
+ score -= 1
+
+ # Concentration risk
+ revenue_concentration = analyze_business_concentration(financial_line_items)
+ if revenue_concentration < 0.6: # Diversified business
+ score += 1
+ details.append("Low business concentration risk")
+ else:
+ risk_factors.append("Business concentration risk")
+
+ # Tail risk assessment
+ worst_performance = analyze_worst_case_scenarios(financial_line_items)
+ if worst_performance > -0.2: # Limited downside
+ score += 2
+ details.append("Limited tail risk exposure")
+
+ if risk_factors:
+ details.append(f"Risk factors identified: {'; '.join(risk_factors)}")
+
+ return {"score": score, "details": "; ".join(details), "risk_factors": risk_factors}
+
+
+def all_weather_framework_analysis(metrics: list, financial_line_items: list) -> dict:
+ """Bridgewater's All Weather framework analysis"""
+ score = 0
+ details = []
+ environment_scores = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No All Weather data"}
+
+ # Four economic environments analysis
+ # 1. Rising Growth
+ growth_performance = analyze_growth_environment_performance(financial_line_items)
+ environment_scores["rising_growth"] = growth_performance
+ if growth_performance > 0.7:
+ score += 2
+ details.append("Strong performance in rising growth environment")
+
+ # 2. Falling Growth
+ recession_resilience = analyze_recession_resilience(financial_line_items)
+ environment_scores["falling_growth"] = recession_resilience
+ if recession_resilience > 0.6:
+ score += 2
+ details.append("Good resilience in falling growth environment")
+
+ # 3. Rising Inflation
+ inflation_protection = analyze_inflation_protection(financial_line_items)
+ environment_scores["rising_inflation"] = inflation_protection
+ if inflation_protection > 0.5:
+ score += 1
+ details.append("Some inflation protection characteristics")
+
+ # 4. Falling Inflation
+ deflation_performance = analyze_deflation_performance(metrics, financial_line_items)
+ environment_scores["falling_inflation"] = deflation_performance
+ if deflation_performance > 0.6:
+ score += 1
+ details.append("Good performance in falling inflation environment")
+
+ # All Weather balance score
+ environment_balance = min(environment_scores.values()) / max(environment_scores.values())
+ if environment_balance > 0.7: # Balanced across environments
+ score += 3
+ details.append("Well-balanced performance across economic environments")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "environment_scores": environment_scores
+ }
+
+
+def ray_dalio_final_decision(economic_research: dict, portfolio_construction: dict,
+ risk_management: dict, all_weather_analysis: dict) -> dict:
+ """Ray Dalio's final synthesis and decision"""
+ details = []
+
+ # Synthesis of team inputs
+ total_team_score = (
+ economic_research["score"] +
+ portfolio_construction["score"] +
+ risk_management["score"] +
+ all_weather_analysis["score"]
+ ) / 4
+
+ # Ray's decision framework
+ if total_team_score >= 7:
+ decision = "Strong conviction buy"
+ details.append("All teams align on strong fundamental and risk-adjusted opportunity")
+ elif total_team_score >= 5:
+ decision = "Moderate allocation"
+ details.append("Mixed signals from teams - moderate position appropriate")
+ elif len(risk_management.get("risk_factors", [])) > 2:
+ decision = "Risk concerns override"
+ details.append("Risk management team identifies too many risk factors")
+ else:
+ decision = "Pass on opportunity"
+ details.append("Insufficient conviction across research teams")
+
+ # Economic machine principles
+ if all_weather_analysis.get("environment_scores", {}).get("rising_growth", 0) > 0.8:
+ details.append("Strong positioning for current economic environment")
+
+ return {
+ "decision": decision,
+ "team_alignment": total_team_score,
+ "details": "; ".join(details)
+ }
+
+
+# Helper functions for economic analysis
+def analyze_international_exposure(financial_line_items: list) -> float:
+ """Estimate international exposure (simplified)"""
+ # In practice, would analyze geographic revenue breakdown
+ return 0.4 # Placeholder - 40% international exposure
+
+
+def calculate_interest_coverage(financial_line_items: list) -> float:
+ """Calculate interest coverage ratio"""
+ latest = financial_line_items[0]
+ if latest.interest_expense and latest.interest_expense > 0:
+ operating_income = latest.net_income + latest.interest_expense # Simplified
+ return operating_income / latest.interest_expense
+ return 10.0 # High coverage if no debt
+
+
+def analyze_revenue_diversification(financial_line_items: list) -> float:
+ """Analyze revenue stream diversification"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues:
+ volatility = (max(revenues) - min(revenues)) / max(revenues)
+ return 1 - min(volatility, 1.0) # Higher score for more stable revenue
+ return 0.5
+
+
+def analyze_economic_correlation(financial_line_items: list) -> float:
+ """Analyze correlation with economic cycles (simplified)"""
+ return 0.6 # Placeholder correlation coefficient
+
+
+def analyze_business_concentration(financial_line_items: list) -> float:
+ """Analyze business line concentration risk"""
+ return 0.5 # Placeholder - would analyze business segments
+
+
+def analyze_worst_case_scenarios(financial_line_items: list) -> float:
+ """Analyze worst-case performance"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ worst_earnings = min(earnings)
+ avg_earnings = sum(earnings) / len(earnings)
+ return worst_earnings / avg_earnings if avg_earnings > 0 else -1.0
+ return -0.5
+
+
+def analyze_growth_environment_performance(financial_line_items: list) -> float:
+ """Performance in rising growth environment"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ growth_periods = sum(1 for i in range(len(revenues) - 1) if revenues[i] > revenues[i + 1])
+ return growth_periods / (len(revenues) - 1)
+ return 0.5
+
+
+def analyze_recession_resilience(financial_line_items: list) -> float:
+ """Resilience in falling growth environment"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ negative_years = sum(1 for e in earnings if e < 0)
+ return 1 - (negative_years / len(earnings))
+ return 0.5
+
+
+def analyze_inflation_protection(financial_line_items: list) -> float:
+ """Inflation protection characteristics"""
+ # Would analyze pricing power, asset-light model, etc.
+ return 0.5 # Placeholder
+
+
+def analyze_deflation_performance(metrics: list, financial_line_items: list) -> float:
+ """Performance in falling inflation environment"""
+ # Would analyze bond-like characteristics, stable cash flows
+ return 0.6 # Placeholder
+
+
+def generate_bridgewater_output(ticker: str, analysis_data: dict, state: AgentState,
+ agent_id: str) -> BridgewaterSignal:
+ """Generate Bridgewater's systematic investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Bridgewater Associates' AI system, implementing Ray Dalio's All Weather and economic machine principles:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Economic Research Team: Macro environment and debt cycle analysis
+ - Portfolio Construction Team: Risk-adjusted returns and diversification
+ - Risk Management Team: Comprehensive risk assessment
+ - All Weather Framework: Performance across four economic environments
+ - Ray Dalio Synthesis: Final decision integration
+
+ PHILOSOPHY:
+ 1. All Weather: Balanced performance across economic environments (growth/inflation up/down)
+ 2. Economic Machine: Understanding debt cycles and economic principles
+ 3. Risk Parity: Equal risk contribution, not equal dollar allocation
+ 4. Systematic Approach: Remove emotion, follow systematic principles
+ 5. Diversification: True diversification across uncorrelated return streams
+ 6. Transparency: Radical transparency in decision-making process
+
+ REASONING STYLE:
+ - Reference team analyses and organizational structure
+ - Apply economic machine principles to company analysis
+ - Consider All Weather framework and environmental balance
+ - Discuss risk parity and diversification benefits
+ - Synthesize multiple team perspectives
+ - Express systematic, principle-based reasoning
+ - Consider position sizing based on risk contribution
+
+ Return the investment signal with All Weather allocation recommendations."""),
+
+ ("human", """Apply Bridgewater's systematic analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "all_weather_allocation": {{
+ "rising_growth_weight": float,
+ "falling_growth_weight": float,
+ "rising_inflation_weight": float,
+ "falling_inflation_weight": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_bridgewater_signal():
+ return BridgewaterSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ all_weather_allocation={
+ "rising_growth_weight": 0.25,
+ "falling_growth_weight": 0.25,
+ "rising_inflation_weight": 0.25,
+ "falling_inflation_weight": 0.25
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=BridgewaterSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_bridgewater_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.py
new file mode 100644
index 000000000..5f1ef08e5
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/citadel_hedge_fund_agent/citadel_agent.py
@@ -0,0 +1,754 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class CitadelSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ strategy_allocation: dict
+
+
+def citadel_hedge_fund_agent(state: AgentState, agent_id: str = "citadel_hedge_fund_agent"):
+ """
+ Citadel: Multi-strategy quantitative approach
+ Structure: Fundamental Research → Quantitative Research → Global Macro → Trading → Ken Griffin Final Decision
+ Philosophy: Multi-strategy approach, technological edge, risk management, market making
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ citadel_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Fundamental research team analyzing company")
+
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=8, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="annual",
+ limit=8,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Citadel's multi-department analysis
+ progress.update_status(agent_id, ticker, "Fundamental research department")
+ fundamental_research = fundamental_research_department(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Quantitative research department")
+ quantitative_research = quantitative_research_department(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Global macro department")
+ global_macro = global_macro_department(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Trading department analysis")
+ trading_department = trading_department_analysis(financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk management oversight")
+ risk_management = risk_management_oversight(financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Ken Griffin's multi-strategy synthesis")
+ ken_griffin_decision = ken_griffin_multi_strategy_synthesis(
+ fundamental_research, quantitative_research, global_macro,
+ trading_department, risk_management
+ )
+
+ # Citadel's multi-strategy scoring
+ total_score = (
+ fundamental_research["score"] * 0.25 +
+ quantitative_research["score"] * 0.25 +
+ trading_department["score"] * 0.2 +
+ global_macro["score"] * 0.15 +
+ risk_management["score"] * 0.15
+ )
+
+ # Citadel's multi-strategy decision framework
+ if total_score >= 8.0 and ken_griffin_decision.get("risk_adjusted_return", 0) > 0.15:
+ signal = "bullish"
+ elif total_score <= 4.0 or len(risk_management.get("risk_flags", [])) > 2:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "fundamental_research": fundamental_research,
+ "quantitative_research": quantitative_research,
+ "global_macro": global_macro,
+ "trading_department": trading_department,
+ "risk_management": risk_management,
+ "ken_griffin_decision": ken_griffin_decision
+ }
+
+ citadel_output = generate_citadel_output(ticker, analysis_data, state, agent_id)
+
+ citadel_analysis[ticker] = {
+ "signal": citadel_output.signal,
+ "confidence": citadel_output.confidence,
+ "reasoning": citadel_output.reasoning,
+ "strategy_allocation": citadel_output.strategy_allocation
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=citadel_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(citadel_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(citadel_analysis, "Citadel")
+
+ state["data"]["analyst_signals"][agent_id] = citadel_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def fundamental_research_department(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Citadel's fundamental research department analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No fundamental data"}
+
+ latest_metrics = metrics[0]
+
+ # Deep value analysis
+ if latest_metrics.price_to_book and latest_metrics.price_to_book < 1.5:
+ score += 2
+ details.append(f"Attractive book value: {latest_metrics.price_to_book:.2f} P/B")
+
+ # Quality metrics
+ if latest_metrics.return_on_equity and latest_metrics.return_on_equity > 0.15:
+ score += 2
+ details.append(f"High quality: {latest_metrics.return_on_equity:.1%} ROE")
+
+ # Growth sustainability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ if 0.05 <= revenue_cagr <= 0.25: # Sustainable growth
+ score += 2
+ details.append(f"Sustainable growth: {revenue_cagr:.1%} revenue CAGR")
+
+ # Competitive position
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ avg_margin = sum(margins) / len(margins)
+ if avg_margin > 0.15: # Strong competitive moat
+ score += 2
+ details.append(f"Strong margins: {avg_margin:.1%} average operating margin")
+
+ # Management capital allocation
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals:
+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)
+ if positive_fcf_years >= len(fcf_vals) * 0.8:
+ score += 1
+ details.append(f"Strong capital allocation: {positive_fcf_years}/{len(fcf_vals)} positive FCF years")
+
+ # Catalyst identification
+ if len(revenues) >= 3 and revenues[0] > revenues[1] * 1.1: # 10%+ recent acceleration
+ score += 1
+ details.append("Recent business acceleration identified")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def quantitative_research_department(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Citadel's quantitative research department analysis"""
+ score = 0
+ details = []
+ quant_metrics = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No quant data"}
+
+ # Factor model analysis
+ factor_loadings = calculate_factor_loadings(metrics, financial_line_items)
+ quant_metrics["factors"] = factor_loadings
+
+ if factor_loadings.get("value_factor", 0) > 0.6:
+ score += 2
+ details.append("Strong value factor loading")
+
+ if factor_loadings.get("quality_factor", 0) > 0.7:
+ score += 2
+ details.append("High quality factor exposure")
+
+ # Statistical signals
+ mean_reversion_signal = calculate_mean_reversion_score(metrics)
+ quant_metrics["mean_reversion"] = mean_reversion_signal
+ if abs(mean_reversion_signal) > 0.6:
+ score += 1.5
+ details.append(f"Strong mean reversion signal: {mean_reversion_signal:.2f}")
+
+ # Momentum analysis
+ momentum_score = calculate_momentum_score(financial_line_items)
+ quant_metrics["momentum"] = momentum_score
+ if momentum_score > 0.6:
+ score += 1.5
+ details.append(f"Positive momentum: {momentum_score:.2f}")
+
+ # Volatility analysis
+ volatility_score = analyze_volatility_patterns(financial_line_items)
+ quant_metrics["volatility"] = volatility_score
+ if volatility_score < 0.4: # Low volatility is good
+ score += 1
+ details.append("Low volatility profile")
+
+ # Cross-sectional ranking
+ percentile_rank = calculate_cross_sectional_rank(metrics)
+ quant_metrics["percentile_rank"] = percentile_rank
+ if percentile_rank > 0.8: # Top 20%
+ score += 2
+ details.append(f"Top quintile ranking: {percentile_rank:.1%}")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "quant_metrics": quant_metrics
+ }
+
+
+def global_macro_department(metrics: list, financial_line_items: list) -> dict:
+ """Citadel's global macro department analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No macro data"}
+
+ # Economic cycle positioning
+ latest = financial_line_items[0]
+
+ # Interest rate sensitivity
+ if latest.total_debt and latest.total_assets:
+ debt_ratio = latest.total_debt / latest.total_assets
+ if debt_ratio < 0.3: # Low interest rate sensitivity
+ score += 2
+ details.append(f"Low interest rate risk: {debt_ratio:.1%} debt/assets")
+ elif debt_ratio > 0.6:
+ score -= 1
+ details.append(f"High interest rate sensitivity: {debt_ratio:.1%} debt/assets")
+
+ # Currency exposure analysis
+ international_revenue_proxy = analyze_international_exposure(financial_line_items)
+ if 0.2 <= international_revenue_proxy <= 0.6: # Balanced exposure
+ score += 1
+ details.append("Balanced international exposure")
+
+ # Inflation hedging capability
+ pricing_power = analyze_pricing_power(financial_line_items)
+ if pricing_power > 0.7:
+ score += 2
+ details.append("Strong pricing power - inflation hedge")
+
+ # Economic cycle resilience
+ recession_resilience = analyze_recession_performance(financial_line_items)
+ if recession_resilience > 0.6:
+ score += 1
+ details.append("Good recession resilience")
+
+ # Commodity exposure
+ commodity_sensitivity = analyze_commodity_exposure(financial_line_items)
+ if commodity_sensitivity < 0.3: # Low commodity risk
+ score += 1
+ details.append("Low commodity price sensitivity")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def trading_department_analysis(financial_line_items: list, market_cap: float) -> dict:
+ """Citadel's trading department analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No trading data"}
+
+ # Liquidity analysis
+ liquidity_score = assess_trading_liquidity(market_cap)
+ if liquidity_score > 0.8:
+ score += 3
+ details.append("High liquidity for large position sizes")
+ elif liquidity_score > 0.6:
+ score += 2
+ details.append("Adequate liquidity for trading")
+
+ # Market making opportunities
+ volatility = estimate_trading_volatility(financial_line_items)
+ if 0.15 <= volatility <= 0.35: # Optimal volatility for market making
+ score += 2
+ details.append(f"Good market making opportunity: {volatility:.1%} volatility")
+
+ # Execution efficiency
+ market_impact = estimate_market_impact_cost(market_cap)
+ if market_impact < 0.02: # Low market impact
+ score += 2
+ details.append(f"Low execution costs: {market_impact:.2%} market impact")
+
+ # Options market opportunities
+ options_opportunity = analyze_options_opportunities(financial_line_items, market_cap)
+ if options_opportunity > 0.6:
+ score += 1
+ details.append("Good options trading opportunities")
+
+ # High-frequency trading signals
+ hft_signals = analyze_hft_opportunities(financial_line_items)
+ if hft_signals > 0.5:
+ score += 1
+ details.append("Positive high-frequency signals")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def risk_management_oversight(financial_line_items: list, market_cap: float) -> dict:
+ """Citadel's risk management oversight"""
+ score = 0
+ details = []
+ risk_flags = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No risk data"}
+
+ latest = financial_line_items[0]
+
+ # Leverage risk
+ if latest.total_debt and latest.shareholders_equity:
+ leverage = latest.total_debt / latest.shareholders_equity
+ if leverage < 0.5:
+ score += 2
+ details.append(f"Conservative leverage: {leverage:.2f} D/E")
+ elif leverage > 1.5:
+ risk_flags.append("High leverage risk")
+ score -= 2
+
+ # Liquidity risk
+ if latest.current_assets and latest.current_liabilities:
+ current_ratio = latest.current_assets / latest.current_liabilities
+ if current_ratio > 1.5:
+ score += 1
+ details.append(f"Strong liquidity: {current_ratio:.1f} current ratio")
+ elif current_ratio < 1.0:
+ risk_flags.append("Liquidity concerns")
+ score -= 1
+
+ # Earnings quality risk
+ earnings_quality = assess_earnings_quality(financial_line_items)
+ if earnings_quality > 0.7:
+ score += 2
+ details.append("High earnings quality")
+ elif earnings_quality < 0.4:
+ risk_flags.append("Earnings quality concerns")
+ score -= 1
+
+ # Concentration risk
+ business_concentration = assess_business_concentration_risk(financial_line_items)
+ if business_concentration < 0.6:
+ score += 1
+ details.append("Diversified business model")
+ elif business_concentration > 0.8:
+ risk_flags.append("High business concentration")
+
+ # Tail risk assessment
+ tail_risk = calculate_tail_risk_metrics(financial_line_items)
+ if tail_risk < 0.3:
+ score += 2
+ details.append("Low tail risk profile")
+ elif tail_risk > 0.7:
+ risk_flags.append("High tail risk")
+ score -= 1
+
+ # Regulatory risk
+ regulatory_risk = assess_regulatory_risk(financial_line_items)
+ if regulatory_risk < 0.4:
+ score += 1
+ details.append("Low regulatory risk")
+
+ if risk_flags:
+ details.append(f"Risk flags: {'; '.join(risk_flags)}")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "risk_flags": risk_flags
+ }
+
+
+def ken_griffin_multi_strategy_synthesis(fundamental_research: dict, quantitative_research: dict,
+ global_macro: dict, trading_department: dict,
+ risk_management: dict) -> dict:
+ """Ken Griffin's multi-strategy synthesis and final decision"""
+ details = []
+
+ # Multi-strategy scoring
+ fundamental_score = fundamental_research["score"] / 10
+ quant_score = quantitative_research["score"] / 10
+ macro_score = global_macro["score"] / 10
+ trading_score = trading_department["score"] / 10
+ risk_score = risk_management["score"] / 10
+
+ # Ken Griffin's decision framework
+ overall_attractiveness = (
+ fundamental_score * 0.3 +
+ quant_score * 0.25 +
+ trading_score * 0.2 +
+ macro_score * 0.15 +
+ risk_score * 0.1
+ )
+
+ # Risk-adjusted return estimation
+ risk_adjustment = 1 - (len(risk_management.get("risk_flags", [])) * 0.2)
+ risk_adjusted_return = overall_attractiveness * risk_adjustment
+
+ # Strategy allocation decision
+ strategy_weights = {
+ "equity_long_short": 0.4,
+ "quantitative": 0.25,
+ "macro": 0.15,
+ "market_making": 0.1,
+ "convertible_arbitrage": 0.1
+ }
+
+ # Adjust weights based on departmental strengths
+ if quant_score > 0.7:
+ strategy_weights["quantitative"] += 0.1
+ strategy_weights["equity_long_short"] -= 0.05
+ strategy_weights["macro"] -= 0.05
+
+ if trading_score > 0.8:
+ strategy_weights["market_making"] += 0.1
+ strategy_weights["equity_long_short"] -= 0.1
+
+ # Final decision logic
+ if risk_adjusted_return > 0.15 and len(risk_management.get("risk_flags", [])) <= 1:
+ decision = "Multi-strategy allocation"
+ details.append("Strong opportunity across multiple strategies")
+ elif risk_adjusted_return > 0.1:
+ decision = "Selective strategy allocation"
+ details.append("Moderate opportunity with selective strategy focus")
+ elif len(risk_management.get("risk_flags", [])) > 2:
+ decision = "Risk override - pass"
+ details.append("Risk management concerns override opportunity")
+ else:
+ decision = "Insufficient multi-strategy edge"
+ details.append("No clear edge across Citadel's strategy platforms")
+
+ return {
+ "decision": decision,
+ "overall_attractiveness": overall_attractiveness,
+ "risk_adjusted_return": risk_adjusted_return,
+ "strategy_weights": strategy_weights,
+ "details": "; ".join(details)
+ }
+
+
+# Helper functions for Citadel analysis
+def calculate_factor_loadings(metrics: list, financial_line_items: list) -> dict:
+ """Calculate factor model loadings"""
+ if not metrics:
+ return {}
+
+ latest = metrics[0]
+ factors = {}
+
+ # Value factor
+ if latest.price_to_book:
+ factors["value_factor"] = max(0, 1 - (latest.price_to_book / 2)) # Lower P/B = higher value
+
+ # Quality factor
+ if latest.return_on_equity:
+ factors["quality_factor"] = min(latest.return_on_equity / 0.2, 1.0) # Normalize by 20%
+
+ # Growth factor
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ factors["growth_factor"] = min(growth / 0.15, 1.0) # Normalize by 15%
+
+ return factors
+
+
+def calculate_mean_reversion_score(metrics: list) -> float:
+ """Calculate mean reversion signal"""
+ if len(metrics) < 4:
+ return 0.0
+
+ pe_ratios = [m.price_to_earnings for m in metrics if m.price_to_earnings and m.price_to_earnings > 0]
+ if len(pe_ratios) >= 4:
+ current_pe = pe_ratios[0]
+ historical_mean = sum(pe_ratios[1:]) / len(pe_ratios[1:])
+
+ if historical_mean > 0:
+ deviation = (current_pe - historical_mean) / historical_mean
+ return -deviation # Negative deviation = positive signal
+
+ return 0.0
+
+
+def calculate_momentum_score(financial_line_items: list) -> float:
+ """Calculate momentum signal"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ recent_growth = (revenues[0] / revenues[1]) - 1
+ longer_growth = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1
+
+ if longer_growth > 0:
+ momentum = (recent_growth - longer_growth) / longer_growth
+ return max(min(momentum, 1.0), -1.0)
+
+ return 0.0
+
+
+def analyze_volatility_patterns(financial_line_items: list) -> float:
+ """Analyze earnings volatility"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 4:
+ mean_earnings = sum(earnings) / len(earnings)
+ if mean_earnings != 0:
+ variance = sum((e - mean_earnings) ** 2 for e in earnings) / len(earnings)
+ cv = (variance ** 0.5) / abs(mean_earnings)
+ return min(cv, 1.0)
+
+ return 0.5
+
+
+def calculate_cross_sectional_rank(metrics: list) -> float:
+ """Calculate cross-sectional ranking (simplified)"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ rank_components = []
+
+ if latest.return_on_equity:
+ rank_components.append(min(latest.return_on_equity / 0.2, 1.0))
+
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ rank_components.append(max(0, 1 - (latest.price_to_earnings / 25)))
+
+ if rank_components:
+ return sum(rank_components) / len(rank_components)
+
+ return 0.5
+
+
+def analyze_international_exposure(financial_line_items: list) -> float:
+ """Estimate international revenue exposure"""
+ return 0.4 # Placeholder - would analyze geographic segments
+
+
+def analyze_pricing_power(financial_line_items: list) -> float:
+ """Analyze pricing power through margin stability"""
+ margins = []
+ for item in financial_line_items:
+ if item.operating_margin:
+ margins.append(item.operating_margin)
+
+ if len(margins) >= 3:
+ margin_stability = 1 - ((max(margins) - min(margins)) / max(margins))
+ return max(margin_stability, 0)
+
+ return 0.5
+
+
+def analyze_recession_performance(financial_line_items: list) -> float:
+ """Analyze performance during economic downturns"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ negative_years = sum(1 for e in earnings if e < 0)
+ return 1 - (negative_years / len(earnings))
+
+ return 0.5
+
+
+def analyze_commodity_exposure(financial_line_items: list) -> float:
+ """Analyze commodity price sensitivity"""
+ return 0.3 # Placeholder - would analyze input cost sensitivity
+
+
+def assess_trading_liquidity(market_cap: float) -> float:
+ """Assess trading liquidity based on market cap"""
+ if market_cap > 50_000_000_000: # $50B+
+ return 0.95
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.85
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.65
+ else:
+ return 0.3
+
+
+def estimate_trading_volatility(financial_line_items: list) -> float:
+ """Estimate trading volatility"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues:
+ mean_rev = sum(revenues) / len(revenues)
+ if mean_rev > 0:
+ variance = sum((r - mean_rev) ** 2 for r in revenues) / len(revenues)
+ return (variance ** 0.5) / mean_rev
+
+ return 0.25
+
+
+def estimate_market_impact_cost(market_cap: float) -> float:
+ """Estimate market impact costs"""
+ if market_cap > 100_000_000_000: # $100B+
+ return 0.005
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.01
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.03
+ else:
+ return 0.08
+
+
+def analyze_options_opportunities(financial_line_items: list, market_cap: float) -> float:
+ """Analyze options trading opportunities"""
+ if market_cap > 5_000_000_000: # Large cap with active options
+ return 0.8
+ elif market_cap > 1_000_000_000:
+ return 0.6
+ else:
+ return 0.3
+
+
+def analyze_hft_opportunities(financial_line_items: list) -> float:
+ """Analyze high-frequency trading opportunities"""
+ return 0.6 # Placeholder for HFT signal analysis
+
+
+def assess_earnings_quality(financial_line_items: list) -> float:
+ """Assess earnings quality"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+
+ if earnings and fcf_vals and len(earnings) == len(fcf_vals):
+ total_earnings = sum(earnings)
+ total_fcf = sum(fcf_vals)
+
+ if total_earnings > 0:
+ cash_conversion = total_fcf / total_earnings
+ return min(max(cash_conversion, 0), 1.0)
+
+ return 0.5
+
+
+def assess_business_concentration_risk(financial_line_items: list) -> float:
+ """Assess business concentration risk"""
+ return 0.5 # Placeholder - would analyze business segment data
+
+
+def calculate_tail_risk_metrics(financial_line_items: list) -> float:
+ """Calculate tail risk metrics"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ sorted_earnings = sorted(earnings)
+ worst_5pct = sorted_earnings[:max(1, len(earnings) // 20)]
+ if worst_5pct:
+ avg_earnings = sum(earnings) / len(earnings)
+ worst_performance = min(worst_5pct)
+ if avg_earnings > 0:
+ return abs(worst_performance) / avg_earnings
+
+ return 0.5
+
+
+def assess_regulatory_risk(financial_line_items: list) -> float:
+ """Assess regulatory risk"""
+ return 0.3 # Placeholder - would analyze regulatory environment
+
+
+def generate_citadel_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> CitadelSignal:
+ """Generate Citadel's multi-strategy investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Citadel's AI system, implementing Ken Griffin's multi-strategy hedge fund approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Fundamental Research Department: Deep value and quality analysis
+ - Quantitative Research Department: Factor models and statistical signals
+ - Global Macro Department: Economic cycle and currency analysis
+ - Trading Department: Liquidity, execution, and market making
+ - Risk Management: Comprehensive risk oversight
+ - Ken Griffin Multi-Strategy Synthesis: Integration across all platforms
+
+ PHILOSOPHY:
+ 1. Multi-Strategy Approach: Diversify across equity long/short, quant, macro, market making
+ 2. Technological Edge: Advanced technology and data analytics
+ 3. Risk Management: Sophisticated risk controls and position sizing
+ 4. Market Making: Provide liquidity while capturing spreads
+ 5. Systematic Execution: Minimize market impact and transaction costs
+ 6. Global Perspective: Opportunities across markets and asset classes
+ 7. Performance Focus: Risk-adjusted returns and alpha generation
+
+ REASONING STYLE:
+ - Reference multiple departmental analyses and perspectives
+ - Integrate fundamental, quantitative, and macro insights
+ - Consider trading feasibility and execution efficiency
+ - Apply rigorous risk management overlay
+ - Discuss multi-strategy allocation and position sizing
+ - Express confidence in technological and analytical edge
+ - Consider market making and liquidity provision opportunities
+
+ Return investment signal with multi-strategy allocation recommendations."""),
+
+ ("human", """Apply Citadel's multi-strategy analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "strategy_allocation": {{
+ "equity_long_short": float,
+ "quantitative": float,
+ "global_macro": float,
+ "market_making": float,
+ "convertible_arbitrage": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_citadel_signal():
+ return CitadelSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ strategy_allocation={
+ "equity_long_short": 0.4,
+ "quantitative": 0.25,
+ "global_macro": 0.15,
+ "market_making": 0.1,
+ "convertible_arbitrage": 0.1
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=CitadelSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_citadel_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.py
new file mode 100644
index 000000000..0cfb4de80
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/de_shaw_hedge_fund_agent/de_shaw_agent.py
@@ -0,0 +1,913 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+import math
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class DEShawSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ computational_models: dict
+
+
+def de_shaw_hedge_fund_agent(state: AgentState, agent_id: str = "de_shaw_hedge_fund_agent"):
+ """
+ D.E. Shaw: Computational finance, quantitative hedge fund
+ Structure: Research → Computational Finance → Trading Systems → Risk Control → David Shaw Decision
+ Philosophy: Scientific approach, computational methods, systematic strategies
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ de_shaw_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Research team computational analysis")
+
+ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=20, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="quarterly",
+ limit=20,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # DE Shaw's computational analysis structure
+ progress.update_status(agent_id, ticker, "Research team analysis")
+ research_team = research_team_computational_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Computational finance models")
+ computational_finance = computational_finance_models(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Trading systems analysis")
+ trading_systems = trading_systems_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk control systems")
+ risk_control = risk_control_systems(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "David Shaw systematic decision")
+ david_shaw_decision = david_shaw_systematic_decision(
+ research_team, computational_finance, trading_systems, risk_control
+ )
+
+ # DE Shaw's computational scoring
+ total_score = (
+ computational_finance["score"] * 0.35 +
+ research_team["score"] * 0.25 +
+ trading_systems["score"] * 0.2 +
+ risk_control["score"] * 0.2
+ )
+
+ # DE Shaw's systematic decision framework
+ model_confidence = computational_finance.get("model_confidence", 0)
+ if total_score >= 8.0 and model_confidence > 0.8:
+ signal = "bullish"
+ elif total_score <= 3.5 or model_confidence < 0.4:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "research_team": research_team,
+ "computational_finance": computational_finance,
+ "trading_systems": trading_systems,
+ "risk_control": risk_control,
+ "david_shaw_decision": david_shaw_decision
+ }
+
+ de_shaw_output = generate_de_shaw_output(ticker, analysis_data, state, agent_id)
+
+ de_shaw_analysis[ticker] = {
+ "signal": de_shaw_output.signal,
+ "confidence": de_shaw_output.confidence,
+ "reasoning": de_shaw_output.reasoning,
+ "computational_models": de_shaw_output.computational_models
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=de_shaw_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(de_shaw_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(de_shaw_analysis, "D.E. Shaw")
+
+ state["data"]["analyst_signals"][agent_id] = de_shaw_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def research_team_computational_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """DE Shaw's research team computational analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No computational research data"}
+
+ # Computational valuation models
+ dcf_model_score = run_dcf_computational_model(financial_line_items, market_cap)
+ if dcf_model_score > 0.7:
+ score += 2.5
+ details.append(f"DCF model indicates undervaluation: {dcf_model_score:.2f}")
+
+ # Factor decomposition analysis
+ factor_decomp_score = perform_factor_decomposition(metrics, financial_line_items)
+ score += factor_decomp_score
+ details.append(f"Factor decomposition score: {factor_decomp_score:.2f}")
+
+ # Time series analysis
+ time_series_score = conduct_time_series_analysis(financial_line_items)
+ if time_series_score > 0.6:
+ score += 2
+ details.append(f"Time series analysis positive: {time_series_score:.2f}")
+
+ # Cross-sectional analysis
+ cross_sectional_score = perform_cross_sectional_analysis(metrics, market_cap)
+ score += cross_sectional_score
+ details.append(f"Cross-sectional ranking: {cross_sectional_score:.2f}")
+
+ # Alternative data integration
+ alt_data_score = integrate_alternative_data(financial_line_items)
+ if alt_data_score > 0.5:
+ score += 1.5
+ details.append(f"Alternative data signals: {alt_data_score:.2f}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def computational_finance_models(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """DE Shaw's computational finance models"""
+ score = 0
+ details = []
+ model_outputs = {}
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No computational finance data"}
+
+ # Monte Carlo simulation
+ monte_carlo_result = run_monte_carlo_simulation(financial_line_items, market_cap)
+ model_outputs["monte_carlo"] = monte_carlo_result
+ if monte_carlo_result.get("probability_of_profit", 0) > 0.7:
+ score += 3
+ details.append(f"Monte Carlo: {monte_carlo_result['probability_of_profit']:.1%} profit probability")
+
+ # Stochastic differential equations
+ sde_model_result = apply_sde_models(financial_line_items)
+ model_outputs["sde"] = sde_model_result
+ score += sde_model_result.get("score", 0)
+ details.append(f"SDE model score: {sde_model_result.get('score', 0):.2f}")
+
+ # Machine learning ensemble
+ ml_ensemble_result = run_ml_ensemble_models(metrics, financial_line_items)
+ model_outputs["ml_ensemble"] = ml_ensemble_result
+ if ml_ensemble_result.get("prediction_confidence", 0) > 0.8:
+ score += 2.5
+ details.append(f"ML ensemble high confidence: {ml_ensemble_result['prediction_confidence']:.1%}")
+
+ # Options pricing models
+ options_model_score = analyze_options_pricing_opportunities(market_cap)
+ model_outputs["options"] = {"score": options_model_score}
+ if options_model_score > 1:
+ score += options_model_score
+ details.append(f"Options pricing opportunity: {options_model_score:.2f}")
+
+ # Risk-neutral valuation
+ risk_neutral_value = calculate_risk_neutral_valuation(financial_line_items, market_cap)
+ model_outputs["risk_neutral"] = risk_neutral_value
+ if risk_neutral_value.get("upside_potential", 0) > 0.2:
+ score += 2
+ details.append(f"Risk-neutral upside: {risk_neutral_value['upside_potential']:.1%}")
+
+ # Model confidence calculation
+ model_confidence = calculate_model_confidence(model_outputs)
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "model_outputs": model_outputs,
+ "model_confidence": model_confidence
+ }
+
+
+def trading_systems_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """DE Shaw's trading systems analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No trading systems data"}
+
+ # Algorithmic execution analysis
+ execution_score = analyze_algorithmic_execution(market_cap)
+ score += execution_score
+ details.append(f"Execution efficiency score: {execution_score:.2f}")
+
+ # Market microstructure analysis
+ microstructure_score = analyze_market_microstructure(financial_line_items, market_cap)
+ if microstructure_score > 0.6:
+ score += 2
+ details.append(f"Microstructure opportunity: {microstructure_score:.2f}")
+
+ # High-frequency signals
+ hf_signals = generate_high_frequency_signals(financial_line_items)
+ if hf_signals > 0.5:
+ score += 1.5
+ details.append(f"HF signals positive: {hf_signals:.2f}")
+
+ # Latency arbitrage potential
+ latency_arb_score = assess_latency_arbitrage(market_cap)
+ score += latency_arb_score
+ details.append(f"Latency arbitrage score: {latency_arb_score:.2f}")
+
+ # Market making opportunities
+ market_making_score = evaluate_market_making_opportunity(market_cap)
+ if market_making_score > 0.7:
+ score += 2
+ details.append(f"Market making opportunity: {market_making_score:.2f}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def risk_control_systems(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """DE Shaw's risk control systems"""
+ score = 0
+ details = []
+ risk_metrics = {}
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No risk control data"}
+
+ # Value-at-Risk calculation
+ var_calculation = calculate_advanced_var(financial_line_items)
+ risk_metrics["var"] = var_calculation
+ if var_calculation < 0.15: # 15% VaR threshold
+ score += 2
+ details.append(f"Acceptable VaR: {var_calculation:.1%}")
+
+ # Stress testing
+ stress_test_results = conduct_comprehensive_stress_testing(financial_line_items)
+ risk_metrics["stress_tests"] = stress_test_results
+ if stress_test_results.get("pass_rate", 0) > 0.8:
+ score += 2
+ details.append(f"Stress tests passed: {stress_test_results['pass_rate']:.1%}")
+
+ # Correlation analysis
+ correlation_analysis = perform_correlation_analysis(metrics, financial_line_items)
+ risk_metrics["correlation"] = correlation_analysis
+ if correlation_analysis < 0.5: # Low correlation
+ score += 1.5
+ details.append("Low correlation with portfolio")
+
+ # Liquidity risk assessment
+ liquidity_risk = assess_advanced_liquidity_risk(market_cap)
+ risk_metrics["liquidity"] = liquidity_risk
+ if liquidity_risk < 0.3:
+ score += 1.5
+ details.append("Low liquidity risk")
+
+ # Dynamic hedging requirements
+ hedging_requirements = calculate_dynamic_hedging_needs(financial_line_items)
+ risk_metrics["hedging"] = hedging_requirements
+ if hedging_requirements < 0.2: # Low hedging needs
+ score += 1
+ details.append("Low hedging requirements")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "risk_metrics": risk_metrics
+ }
+
+
+def david_shaw_systematic_decision(research_team: dict, computational_finance: dict,
+ trading_systems: dict, risk_control: dict) -> dict:
+ """David Shaw's systematic computational decision"""
+ details = []
+
+ # Computational model synthesis
+ research_score = research_team["score"] / 10
+ model_confidence = computational_finance.get("model_confidence", 0)
+ execution_feasibility = trading_systems["score"] / 10
+ risk_acceptability = risk_control["score"] / 8
+
+ # Shaw's decision framework
+ overall_systematic_edge = (
+ model_confidence * 0.35 +
+ research_score * 0.3 +
+ execution_feasibility * 0.2 +
+ risk_acceptability * 0.15
+ )
+
+ # Computational conviction analysis
+ model_outputs = computational_finance.get("model_outputs", {})
+ monte_carlo_prob = model_outputs.get("monte_carlo", {}).get("probability_of_profit", 0.5)
+
+ # Shaw's systematic decision logic
+ if overall_systematic_edge > 0.8 and model_confidence > 0.85:
+ if monte_carlo_prob > 0.75:
+ decision = "High conviction systematic position"
+ details.append("Strong computational edge with high model confidence")
+ else:
+ decision = "Moderate systematic position"
+ details.append("Good computational signals with moderate probability")
+ elif overall_systematic_edge > 0.6:
+ decision = "Systematic position with enhanced monitoring"
+ details.append("Adequate systematic edge requiring close monitoring")
+ elif execution_feasibility < 0.4:
+ decision = "Pass - execution constraints"
+ details.append("Computational edge limited by execution constraints")
+ else:
+ decision = "Insufficient systematic edge"
+ details.append("Computational models do not indicate sufficient edge")
+
+ # Expected Sharpe ratio
+ expected_sharpe = overall_systematic_edge * 2 # Target 2.0 Sharpe for top decile
+
+ # Computational complexity assessment
+ model_complexity = len(model_outputs) * 0.1
+
+ return {
+ "decision": decision,
+ "overall_systematic_edge": overall_systematic_edge,
+ "expected_sharpe": expected_sharpe,
+ "model_complexity": model_complexity,
+ "details": "; ".join(details)
+ }
+
+
+# Computational Finance Helper Functions
+def run_dcf_computational_model(financial_line_items: list, market_cap: float) -> float:
+ """Run computational DCF model"""
+ if not financial_line_items or not market_cap:
+ return 0.5
+
+ latest = financial_line_items[0]
+ if not latest.free_cash_flow or latest.free_cash_flow <= 0:
+ return 0.3
+
+ # Advanced DCF with multiple scenarios
+ base_fcf = latest.free_cash_flow
+
+ # Scenario analysis
+ scenarios = [
+ {"growth": 0.05, "terminal_multiple": 12, "probability": 0.3},
+ {"growth": 0.08, "terminal_multiple": 15, "probability": 0.4},
+ {"growth": 0.12, "terminal_multiple": 18, "probability": 0.3}
+ ]
+
+ expected_value = 0
+ for scenario in scenarios:
+ scenario_value = 0
+ for year in range(1, 6):
+ future_fcf = base_fcf * (1 + scenario["growth"]) ** year
+ pv = future_fcf / (1.1 ** year) # 10% discount rate
+ scenario_value += pv
+
+ # Terminal value
+ terminal_fcf = base_fcf * (1 + scenario["growth"]) ** 5
+ terminal_value = terminal_fcf * scenario["terminal_multiple"] / (1.1 ** 5)
+ scenario_value += terminal_value
+
+ expected_value += scenario_value * scenario["probability"]
+
+ # Compare to market cap
+ if expected_value > market_cap:
+ upside = (expected_value - market_cap) / market_cap
+ return min(upside / 0.5, 1.0) # Normalize by 50% upside
+
+ return 0.3
+
+
+def perform_factor_decomposition(metrics: list, financial_line_items: list) -> float:
+ """Perform advanced factor decomposition"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ factor_score = 0
+
+ # Value factor
+ if latest.price_to_book:
+ value_score = max(0, 1 - (latest.price_to_book / 2))
+ factor_score += value_score * 0.3
+
+ # Quality factor
+ if latest.return_on_equity:
+ quality_score = min(latest.return_on_equity / 0.2, 1.0)
+ factor_score += quality_score * 0.3
+
+ # Growth factor
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ growth_rate = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ growth_score = min(growth_rate / 0.15, 1.0)
+ factor_score += growth_score * 0.4
+
+ return factor_score
+
+
+def conduct_time_series_analysis(financial_line_items: list) -> float:
+ """Conduct advanced time series analysis"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) < 8:
+ return 0.4
+
+ # Trend analysis using linear regression
+ n = len(revenues)
+ x_mean = (n - 1) / 2
+ y_mean = sum(revenues) / n
+
+ numerator = sum((i - x_mean) * (revenues[i] - y_mean) for i in range(n))
+ denominator = sum((i - x_mean) ** 2 for i in range(n))
+
+ if denominator > 0:
+ slope = numerator / denominator
+ r_squared = (numerator ** 2) / (denominator * sum((y - y_mean) ** 2 for y in revenues))
+
+ # Positive trend with good fit
+ if slope > 0 and r_squared > 0.6:
+ return min((slope / y_mean) * 10 * r_squared, 1.0)
+
+ return 0.4
+
+
+def perform_cross_sectional_analysis(metrics: list, market_cap: float) -> float:
+ """Perform cross-sectional ranking analysis"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+
+ # Multi-factor ranking
+ ranking_score = 0
+
+ if latest.return_on_equity:
+ roe_percentile = min(latest.return_on_equity / 0.25, 1.0)
+ ranking_score += roe_percentile * 0.3
+
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ pe_percentile = max(0, 1 - (latest.price_to_earnings / 25))
+ ranking_score += pe_percentile * 0.3
+
+ # Size factor
+ size_factor = min(math.log10(market_cap / 1_000_000_000) / 2, 1.0)
+ ranking_score += size_factor * 0.4
+
+ return ranking_score
+
+
+def integrate_alternative_data(financial_line_items: list) -> float:
+ """Integrate alternative data signals"""
+ # Simulated alternative data integration
+ base_fundamentals = 0.5
+
+ # Would integrate satellite data, credit card transactions, etc.
+ alt_data_boost = 0.2 # Placeholder
+
+ return min(base_fundamentals + alt_data_boost, 1.0)
+
+
+def run_monte_carlo_simulation(financial_line_items: list, market_cap: float) -> dict:
+ """Run Monte Carlo simulation for price prediction"""
+ if not financial_line_items:
+ return {"probability_of_profit": 0.5}
+
+ # Simulate 10,000 paths
+ num_simulations = 1000 # Reduced for computational efficiency
+ profitable_outcomes = 0
+
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ # Calculate historical volatility
+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]
+ mean_growth = sum(growth_rates) / len(growth_rates)
+ volatility = (sum((g - mean_growth) ** 2 for g in growth_rates) / len(growth_rates)) ** 0.5
+
+ # Monte Carlo simulation
+ for _ in range(num_simulations):
+ # Simulate 1-year forward performance
+ random_shock = (hash(str(_)) % 1000 - 500) / 500 # Pseudo-random between -1 and 1
+ simulated_return = mean_growth + random_shock * volatility
+
+ if simulated_return > 0.05: # 5% profit threshold
+ profitable_outcomes += 1
+
+ probability_of_profit = profitable_outcomes / num_simulations
+ else:
+ probability_of_profit = 0.5
+
+ return {
+ "probability_of_profit": probability_of_profit,
+ "simulations": num_simulations
+ }
+
+
+def apply_sde_models(financial_line_items: list) -> dict:
+ """Apply stochastic differential equation models"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) < 6:
+ return {"score": 0.5}
+
+ # Geometric Brownian Motion model for revenue evolution
+ # dS = μS dt + σS dW
+
+ # Calculate drift (μ) and volatility (σ)
+ growth_rates = [(revenues[i] / revenues[i + 1]) - 1 for i in range(len(revenues) - 1)]
+ drift = sum(growth_rates) / len(growth_rates)
+ volatility = (sum((g - drift) ** 2 for g in growth_rates) / len(growth_rates)) ** 0.5
+
+ # SDE score based on favorable drift and manageable volatility
+ if drift > 0.05 and volatility < 0.3:
+ sde_score = min(drift / volatility, 1.0) if volatility > 0 else 0.5
+ else:
+ sde_score = 0.3
+
+ return {"score": sde_score, "drift": drift, "volatility": volatility}
+
+
+def run_ml_ensemble_models(metrics: list, financial_line_items: list) -> dict:
+ """Run machine learning ensemble models"""
+ if not metrics or not financial_line_items:
+ return {"prediction_confidence": 0.5}
+
+ # Simulate ensemble of models
+ models = ["random_forest", "gradient_boosting", "neural_network", "svm"]
+ predictions = []
+
+ for model in models:
+ # Simplified model predictions based on fundamentals
+ latest = metrics[0]
+ if latest.return_on_equity and latest.price_to_earnings:
+ if model == "random_forest":
+ pred = min(latest.return_on_equity * 3, 1.0)
+ elif model == "gradient_boosting":
+ pred = max(0, 1 - (latest.price_to_earnings / 20))
+ elif model == "neural_network":
+ pred = (latest.return_on_equity * 2 + (1 - latest.price_to_earnings / 25)) / 2
+ else: # SVM
+ pred = 0.5 + (latest.return_on_equity - 0.1) * 2
+
+ predictions.append(max(0, min(pred, 1.0)))
+ else:
+ predictions.append(0.5)
+
+ # Ensemble prediction
+ ensemble_pred = sum(predictions) / len(predictions)
+
+ # Confidence based on model agreement
+ variance = sum((p - ensemble_pred) ** 2 for p in predictions) / len(predictions)
+ confidence = max(0, 1 - variance * 4)
+
+ return {
+ "ensemble_prediction": ensemble_pred,
+ "prediction_confidence": confidence,
+ "individual_predictions": dict(zip(models, predictions))
+ }
+
+
+def analyze_options_pricing_opportunities(market_cap: float) -> float:
+ """Analyze options pricing opportunities"""
+ # Larger companies have more liquid options markets
+ if market_cap > 50_000_000_000: # $50B+
+ return 1.5
+ elif market_cap > 10_000_000_000: # $10B+
+ return 1.0
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.5
+ else:
+ return 0.2
+
+
+def calculate_risk_neutral_valuation(financial_line_items: list, market_cap: float) -> dict:
+ """Calculate risk-neutral valuation"""
+ if not financial_line_items or not market_cap:
+ return {"upside_potential": 0}
+
+ latest = financial_line_items[0]
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ # Risk-neutral DCF at risk-free rate
+ risk_free_rate = 0.03 # 3% risk-free rate
+ risk_neutral_value = latest.free_cash_flow / risk_free_rate # Perpetuity
+
+ upside_potential = (risk_neutral_value - market_cap) / market_cap
+ return {"upside_potential": max(0, upside_potential)}
+
+ return {"upside_potential": 0}
+
+
+def calculate_model_confidence(model_outputs: dict) -> float:
+ """Calculate overall model confidence"""
+ confidence_scores = []
+
+ if "monte_carlo" in model_outputs:
+ mc_prob = model_outputs["monte_carlo"].get("probability_of_profit", 0.5)
+ confidence_scores.append(abs(mc_prob - 0.5) * 2) # Distance from 50%
+
+ if "ml_ensemble" in model_outputs:
+ ml_conf = model_outputs["ml_ensemble"].get("prediction_confidence", 0.5)
+ confidence_scores.append(ml_conf)
+
+ if "sde" in model_outputs:
+ sde_score = model_outputs["sde"].get("score", 0.5)
+ confidence_scores.append(sde_score)
+
+ return sum(confidence_scores) / len(confidence_scores) if confidence_scores else 0.5
+
+
+def analyze_algorithmic_execution(market_cap: float) -> float:
+ """Analyze algorithmic execution efficiency"""
+ # Execution efficiency based on market cap and liquidity
+ if market_cap > 100_000_000_000: # $100B+
+ return 2.0
+ elif market_cap > 20_000_000_000: # $20B+
+ return 1.5
+ elif market_cap > 5_000_000_000: # $5B+
+ return 1.0
+ else:
+ return 0.5
+
+
+def analyze_market_microstructure(financial_line_items: list, market_cap: float) -> float:
+ """Analyze market microstructure opportunities"""
+ # Microstructure opportunities in larger, more liquid names
+ liquidity_score = min(market_cap / 10_000_000_000, 1.0) # Normalize by $10B
+
+ # Add fundamental volatility component
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues:
+ volatility = calculate_coefficient_of_variation(revenues)
+ volatility_score = min(volatility, 1.0)
+ return (liquidity_score + volatility_score) / 2
+
+ return liquidity_score
+
+
+def generate_high_frequency_signals(financial_line_items: list) -> float:
+ """Generate high-frequency trading signals"""
+ # HF signals based on earnings volatility and predictability
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 8:
+ # Look for patterns in quarterly earnings
+ earnings_changes = [earnings[i] - earnings[i + 1] for i in range(len(earnings) - 1)]
+ if earnings_changes:
+ autocorr = calculate_autocorrelation(earnings_changes, 1)
+ return min(abs(autocorr), 1.0)
+
+ return 0.4
+
+
+def assess_latency_arbitrage(market_cap: float) -> float:
+ """Assess latency arbitrage opportunities"""
+ # Latency arbitrage more viable in larger, more traded stocks
+ if market_cap > 50_000_000_000: # $50B+
+ return 1.0
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.7
+ else:
+ return 0.3
+
+
+def evaluate_market_making_opportunity(market_cap: float) -> float:
+ """Evaluate market making opportunity"""
+ # Market making viability based on trading volume proxy (market cap)
+ if market_cap > 20_000_000_000: # $20B+
+ return 0.9
+ elif market_cap > 5_000_000_000: # $5B+
+ return 0.7
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.5
+ else:
+ return 0.2
+
+
+def calculate_advanced_var(financial_line_items: list) -> float:
+ """Calculate advanced Value-at-Risk"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 8:
+ # Calculate 95% VaR using historical simulation
+ sorted_earnings = sorted(earnings)
+ var_index = int(len(sorted_earnings) * 0.05)
+ worst_5pct = sorted_earnings[:var_index + 1]
+
+ if worst_5pct and max(earnings) > 0:
+ var_loss = (max(earnings) - min(worst_5pct)) / max(earnings)
+ return var_loss
+
+ return 0.2 # Default 20% VaR
+
+
+def conduct_comprehensive_stress_testing(financial_line_items: list) -> dict:
+ """Conduct comprehensive stress testing"""
+ stress_scenarios = [
+ "market_crash", "recession", "sector_downturn",
+ "liquidity_crisis", "interest_rate_shock"
+ ]
+
+ passed_tests = 0
+
+ # Simplified stress testing based on historical performance
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if earnings and revenues:
+ # Test earnings stability (recession scenario)
+ negative_earnings = sum(1 for e in earnings if e < 0)
+ if negative_earnings <= len(earnings) * 0.2: # <20% negative years
+ passed_tests += 2
+
+ # Test revenue resilience
+ revenue_declines = sum(1 for i in range(len(revenues) - 1) if revenues[i] < revenues[i + 1])
+ if revenue_declines <= len(revenues) * 0.3: # <30% declining years
+ passed_tests += 2
+
+ # Test margin stability (sector downturn)
+ if len(earnings) == len(revenues):
+ margins = [earnings[i] / revenues[i] if revenues[i] > 0 else 0 for i in range(len(earnings))]
+ margin_volatility = calculate_coefficient_of_variation(margins)
+ if margin_volatility < 0.5:
+ passed_tests += 1
+
+ pass_rate = passed_tests / len(stress_scenarios)
+
+ return {
+ "pass_rate": pass_rate,
+ "tests_passed": passed_tests,
+ "total_tests": len(stress_scenarios)
+ }
+
+
+def perform_correlation_analysis(metrics: list, financial_line_items: list) -> float:
+ """Perform correlation analysis with market factors"""
+ # Simplified correlation analysis
+ # In practice, would correlate with market indices, sector ETFs, etc.
+
+ if not metrics or not financial_line_items:
+ return 0.6 # Default moderate correlation
+
+ # Proxy correlation using business fundamentals
+ latest = metrics[0]
+
+ # High ROE, reasonable valuation suggests lower market correlation
+ if latest.return_on_equity and latest.price_to_earnings:
+ if latest.return_on_equity > 0.15 and latest.price_to_earnings < 20:
+ return 0.3 # Low correlation - idiosyncratic opportunity
+
+ return 0.6 # Moderate correlation
+
+
+def assess_advanced_liquidity_risk(market_cap: float) -> float:
+ """Assess advanced liquidity risk"""
+ # Liquidity risk inversely related to market cap
+ if market_cap > 100_000_000_000: # $100B+
+ return 0.05
+ elif market_cap > 20_000_000_000: # $20B+
+ return 0.1
+ elif market_cap > 5_000_000_000: # $5B+
+ return 0.2
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.4
+ else:
+ return 0.7
+
+
+def calculate_dynamic_hedging_needs(financial_line_items: list) -> float:
+ """Calculate dynamic hedging requirements"""
+ # Hedging needs based on business volatility
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+
+ hedging_score = 0
+
+ if revenues:
+ revenue_volatility = calculate_coefficient_of_variation(revenues)
+ hedging_score += revenue_volatility * 0.5
+
+ if earnings:
+ earnings_volatility = calculate_coefficient_of_variation(earnings)
+ hedging_score += earnings_volatility * 0.5
+
+ return min(hedging_score, 1.0)
+
+
+def calculate_coefficient_of_variation(data: list) -> float:
+ """Calculate coefficient of variation"""
+ if not data or len(data) < 2:
+ return 1.0
+
+ mean_val = sum(data) / len(data)
+ if mean_val == 0:
+ return 1.0
+
+ variance = sum((x - mean_val) ** 2 for x in data) / len(data)
+ std_dev = (variance ** 0.5)
+
+ return std_dev / abs(mean_val)
+
+
+def calculate_autocorrelation(data: list, lag: int) -> float:
+ """Calculate autocorrelation with given lag"""
+ if len(data) <= lag:
+ return 0
+
+ mean_val = sum(data) / len(data)
+ numerator = sum((data[i] - mean_val) * (data[i + lag] - mean_val)
+ for i in range(len(data) - lag))
+ denominator = sum((x - mean_val) ** 2 for x in data)
+
+ return numerator / denominator if denominator != 0 else 0
+
+
+def generate_de_shaw_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> DEShawSignal:
+ """Generate DE Shaw's computational finance investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are D.E. Shaw's AI system, implementing David Shaw's computational finance approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Research Team: Computational analysis and quantitative research
+ - Computational Finance: Monte Carlo, SDE models, ML ensemble, options pricing
+ - Trading Systems: Algorithmic execution, HFT, market microstructure
+ - Risk Control: Advanced VaR, stress testing, correlation analysis
+ - David Shaw Systematic Decision: Scientific computational synthesis
+
+ PHILOSOPHY:
+ 1. Computational Finance: Advanced mathematical and computational methods
+ 2. Scientific Approach: Rigorous quantitative analysis and modeling
+ 3. Systematic Strategies: Algorithm-driven investment decisions
+ 4. Risk Management: Sophisticated risk control and hedging
+ 5. Technology Edge: Cutting-edge computational infrastructure
+ 6. Market Efficiency: Exploit computational advantages and inefficiencies
+ 7. Diversification: Multiple uncorrelated computational strategies
+
+ REASONING STYLE:
+ - Reference computational models and mathematical analysis
+ - Discuss Monte Carlo simulations and stochastic processes
+ - Apply machine learning and statistical methods
+ - Consider execution algorithms and market microstructure
+ - Express confidence in computational edge and model validation
+ - Analyze risk-adjusted returns and Sharpe ratios
+ - Focus on systematic, repeatable investment processes
+
+ Return investment signal with computational model outputs and confidence metrics."""),
+
+ ("human", """Apply D.E. Shaw's computational analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "computational_models": {{
+ "monte_carlo_probability": float,
+ "ml_ensemble_prediction": float,
+ "sde_model_score": float,
+ "risk_neutral_upside": float,
+ "model_confidence": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_de_shaw_signal():
+ return DEShawSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ computational_models={
+ "monte_carlo_probability": 0.5,
+ "ml_ensemble_prediction": 0.5,
+ "sde_model_score": 0.5,
+ "risk_neutral_upside": 0.0,
+ "model_confidence": 0.5
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=DEShawSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_de_shaw_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.py
new file mode 100644
index 000000000..85f19418f
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/elliott_management_hedge_fund_agent/elliott_management_agent.py
@@ -0,0 +1,825 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class ElliottSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ activist_potential: dict
+
+
+def elliott_management_hedge_fund_agent(state: AgentState, agent_id: str = "elliott_management_hedge_fund_agent"):
+ """
+ Elliott Management: Activist investing, event-driven strategies
+ Structure: Research → Legal → Activism → Event-Driven → Paul Singer Decision
+ Philosophy: Catalyst-driven value creation, shareholder activism, distressed opportunities
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ elliott_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Research team analyzing activist opportunity")
+
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=6, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="annual",
+ limit=6,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Elliott's activist-focused analysis structure
+ progress.update_status(agent_id, ticker, "Research team fundamental analysis")
+ research_team = research_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Legal team governance analysis")
+ legal_team = legal_team_governance_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Activism team catalyst identification")
+ activism_team = activism_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Event-driven team analysis")
+ event_driven_team = event_driven_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Paul Singer strategic decision")
+ paul_singer_decision = paul_singer_strategic_decision(
+ research_team, legal_team, activism_team, event_driven_team
+ )
+
+ # Elliott's catalyst-weighted scoring
+ total_score = (
+ activism_team["score"] * 0.35 +
+ research_team["score"] * 0.25 +
+ event_driven_team["score"] * 0.2 +
+ legal_team["score"] * 0.2
+ )
+
+ # Elliott's activist decision framework
+ activist_potential = activism_team.get("activist_score", 0)
+ if total_score >= 7.5 and activist_potential > 0.7:
+ signal = "bullish"
+ elif total_score <= 4.0 or legal_team.get("governance_score", 0) < 0.3:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "research_team": research_team,
+ "legal_team": legal_team,
+ "activism_team": activism_team,
+ "event_driven_team": event_driven_team,
+ "paul_singer_decision": paul_singer_decision
+ }
+
+ elliott_output = generate_elliott_output(ticker, analysis_data, state, agent_id)
+
+ elliott_analysis[ticker] = {
+ "signal": elliott_output.signal,
+ "confidence": elliott_output.confidence,
+ "reasoning": elliott_output.reasoning,
+ "activist_potential": elliott_output.activist_potential
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=elliott_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(elliott_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(elliott_analysis, "Elliott Management")
+
+ state["data"]["analyst_signals"][agent_id] = elliott_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Elliott's research team fundamental analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No research data"}
+
+ # Hidden asset value
+ asset_value_opportunity = analyze_hidden_asset_value(financial_line_items, market_cap)
+ if asset_value_opportunity > 0.3:
+ score += 3
+ details.append(f"Hidden asset value opportunity: {asset_value_opportunity:.1%} of market cap")
+
+ # Underperforming business segments
+ business_optimization = identify_business_optimization_opportunities(financial_line_items)
+ if business_optimization > 0.6:
+ score += 2.5
+ details.append("Significant business optimization opportunities identified")
+
+ # Capital allocation inefficiencies
+ capital_allocation_issues = analyze_capital_allocation_inefficiencies(financial_line_items)
+ if capital_allocation_issues > 0.7:
+ score += 2
+ details.append("Poor capital allocation creating value opportunity")
+
+ # Margin improvement potential
+ margin_expansion_potential = analyze_margin_expansion_potential(financial_line_items)
+ if margin_expansion_potential > 0.5:
+ score += 1.5
+ details.append(f"Margin expansion potential: {margin_expansion_potential:.1%}")
+
+ # Sum-of-the-parts analysis
+ sotp_discount = calculate_sum_of_parts_discount(financial_line_items, market_cap)
+ if sotp_discount > 0.2:
+ score += 2
+ details.append(f"Sum-of-parts discount: {sotp_discount:.1%}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def legal_team_governance_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Elliott's legal team corporate governance analysis"""
+ score = 0
+ details = []
+ governance_issues = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No governance data"}
+
+ # Management accountability
+ management_performance = assess_management_performance(metrics, financial_line_items)
+ if management_performance < 0.4:
+ governance_issues.append("Poor management performance")
+ score += 2 # Opportunity for change
+ details.append("Management underperformance creates activist opportunity")
+
+ # Board composition analysis
+ board_independence = analyze_board_independence_proxy(financial_line_items)
+ if board_independence < 0.6:
+ governance_issues.append("Board independence concerns")
+ score += 1.5
+ details.append("Board independence issues identified")
+
+ # Executive compensation analysis
+ compensation_alignment = analyze_executive_compensation_proxy(financial_line_items)
+ if compensation_alignment < 0.5:
+ governance_issues.append("Executive compensation misalignment")
+ score += 1.5
+ details.append("Executive compensation not aligned with performance")
+
+ # Shareholder rights
+ shareholder_rights_score = assess_shareholder_rights_proxy(market_cap)
+ if shareholder_rights_score > 0.7:
+ score += 2
+ details.append("Strong shareholder rights framework")
+
+ # Acquisition defense analysis
+ takeover_defenses = analyze_takeover_defenses_proxy(market_cap)
+ if takeover_defenses < 0.5:
+ score += 1
+ details.append("Limited takeover defenses")
+
+ governance_score = score / 8 # Normalize to 0-1
+
+ if governance_issues:
+ details.append(f"Governance issues: {'; '.join(governance_issues)}")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "governance_issues": governance_issues,
+ "governance_score": governance_score
+ }
+
+
+def activism_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Elliott's activism team catalyst and campaign analysis"""
+ score = 0
+ details = []
+ activist_catalysts = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No activism data"}
+
+ # Strategic alternatives analysis
+ strategic_alternatives = identify_strategic_alternatives(financial_line_items, market_cap)
+ if strategic_alternatives > 0.7:
+ score += 3
+ activist_catalysts.append("Strategic alternatives")
+ details.append("Strong case for strategic alternatives (spin-offs, sales)")
+
+ # Operational turnaround potential
+ turnaround_potential = assess_operational_turnaround_potential(financial_line_items)
+ if turnaround_potential > 0.6:
+ score += 2.5
+ activist_catalysts.append("Operational improvements")
+ details.append("Significant operational turnaround opportunity")
+
+ # Balance sheet optimization
+ balance_sheet_optimization = analyze_balance_sheet_optimization(financial_line_items)
+ if balance_sheet_optimization > 0.5:
+ score += 2
+ activist_catalysts.append("Balance sheet optimization")
+ details.append("Balance sheet optimization opportunities")
+
+ # Market position improvement
+ market_position_catalyst = analyze_market_position_catalyst(financial_line_items)
+ if market_position_catalyst > 0.6:
+ score += 1.5
+ activist_catalysts.append("Market position improvement")
+ details.append("Market position improvement potential")
+
+ # Management change catalyst
+ management_change_potential = assess_management_change_potential(metrics, financial_line_items)
+ if management_change_potential > 0.7:
+ score += 2
+ activist_catalysts.append("Management change")
+ details.append("Strong case for management changes")
+
+ # ESG improvement opportunities
+ esg_catalyst = identify_esg_improvement_opportunities(financial_line_items)
+ if esg_catalyst > 0.5:
+ score += 1
+ activist_catalysts.append("ESG improvements")
+ details.append("ESG improvement opportunities identified")
+
+ activist_score = score / 12 # Normalize to 0-1
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "activist_catalysts": activist_catalysts,
+ "activist_score": activist_score
+ }
+
+
+def event_driven_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Elliott's event-driven team analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No event-driven data"}
+
+ # M&A probability analysis
+ ma_probability = assess_ma_probability(financial_line_items, market_cap)
+ if ma_probability > 0.6:
+ score += 3
+ details.append(f"High M&A probability: {ma_probability:.1%}")
+
+ # Spin-off opportunities
+ spinoff_potential = analyze_spinoff_potential(financial_line_items)
+ if spinoff_potential > 0.7:
+ score += 2.5
+ details.append("Strong spin-off potential identified")
+
+ # Special dividend potential
+ special_dividend_potential = analyze_special_dividend_potential(financial_line_items)
+ if special_dividend_potential > 0.6:
+ score += 2
+ details.append("Special dividend potential")
+
+ # Distressed situation analysis
+ distressed_opportunity = analyze_distressed_opportunity(financial_line_items)
+ if distressed_opportunity > 0.5:
+ score += 2
+ details.append("Distressed investment opportunity")
+
+ # Regulatory catalyst analysis
+ regulatory_catalyst = identify_regulatory_catalysts(financial_line_items)
+ if regulatory_catalyst > 0.5:
+ score += 1.5
+ details.append("Regulatory catalysts identified")
+
+ # Litigation catalyst
+ litigation_catalyst = assess_litigation_catalyst_potential(financial_line_items)
+ if litigation_catalyst > 0.4:
+ score += 1
+ details.append("Potential litigation catalysts")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def paul_singer_strategic_decision(research_team: dict, legal_team: dict,
+ activism_team: dict, event_driven_team: dict) -> dict:
+ """Paul Singer's strategic decision framework"""
+ details = []
+
+ # Elliott's decision framework
+ fundamental_value = research_team["score"] / 10
+ governance_opportunity = legal_team["score"] / 8
+ activist_potential = activism_team.get("activist_score", 0)
+ event_catalyst = event_driven_team["score"] / 10
+
+ # Paul Singer's strategic analysis
+ overall_opportunity = (
+ fundamental_value * 0.3 +
+ activist_potential * 0.35 +
+ event_catalyst * 0.25 +
+ governance_opportunity * 0.1
+ )
+
+ # Campaign complexity assessment
+ campaign_complexity = assess_campaign_complexity(activism_team, legal_team)
+
+ # Risk-reward analysis
+ if overall_opportunity > 0.8 and activist_potential > 0.7:
+ if campaign_complexity < 0.6:
+ decision = "Launch activist campaign"
+ details.append("High-conviction activist opportunity with manageable complexity")
+ else:
+ decision = "Complex activist situation - detailed planning required"
+ details.append("High opportunity but complex campaign execution needed")
+ elif overall_opportunity > 0.6:
+ if event_catalyst > 0.7:
+ decision = "Event-driven position"
+ details.append("Strong event-driven catalyst without activism requirement")
+ else:
+ decision = "Moderate activist position"
+ details.append("Moderate opportunity for value creation through activism")
+ elif fundamental_value > 0.6 and activist_potential < 0.4:
+ decision = "Traditional value investment"
+ details.append("Fundamental value present but limited activist opportunity")
+ else:
+ decision = "Pass - insufficient catalyst potential"
+ details.append("Insufficient catalyst opportunity for Elliott's strategy")
+
+ # Timeline assessment
+ if "Management change" in activism_team.get("activist_catalysts", []):
+ expected_timeline = "12-18 months"
+ elif "Strategic alternatives" in activism_team.get("activist_catalysts", []):
+ expected_timeline = "18-24 months"
+ else:
+ expected_timeline = "6-12 months"
+
+ return {
+ "decision": decision,
+ "overall_opportunity": overall_opportunity,
+ "campaign_complexity": campaign_complexity,
+ "expected_timeline": expected_timeline,
+ "details": "; ".join(details)
+ }
+
+
+# Helper functions for Elliott's analysis
+def analyze_hidden_asset_value(financial_line_items: list, market_cap: float) -> float:
+ """Analyze hidden asset value opportunities"""
+ if not financial_line_items or not market_cap:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # Real estate and other assets potentially undervalued
+ if latest.total_assets and latest.total_debt:
+ net_assets = latest.total_assets - latest.total_debt
+ if net_assets > market_cap:
+ hidden_value = (net_assets - market_cap) / market_cap
+ return min(hidden_value, 1.0)
+
+ return 0
+
+
+def identify_business_optimization_opportunities(financial_line_items: list) -> float:
+ """Identify business optimization opportunities"""
+ # Look for declining margins or inconsistent performance
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+
+ if len(margins) >= 3:
+ recent_margin = margins[0]
+ historical_best = max(margins)
+
+ if historical_best > recent_margin * 1.3: # 30%+ margin decline from peak
+ return 0.8 # High optimization opportunity
+ elif historical_best > recent_margin * 1.15: # 15%+ margin decline
+ return 0.6 # Moderate optimization opportunity
+
+ return 0.3
+
+
+def analyze_capital_allocation_inefficiencies(financial_line_items: list) -> float:
+ """Analyze capital allocation inefficiencies"""
+ # Look for poor FCF to earnings conversion or excessive capex
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+
+ if fcf_vals and earnings and len(fcf_vals) == len(earnings):
+ total_fcf = sum(fcf_vals)
+ total_earnings = sum(earnings)
+
+ if total_earnings > 0:
+ cash_conversion = total_fcf / total_earnings
+ if cash_conversion < 0.6: # Poor cash conversion
+ return 0.8
+ elif cash_conversion < 0.8:
+ return 0.5
+
+ return 0.3
+
+
+def analyze_margin_expansion_potential(financial_line_items: list) -> float:
+ """Analyze margin expansion potential"""
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+
+ if margins:
+ current_margin = margins[0]
+ if current_margin < 0.1: # <10% operating margin
+ return 0.7 # High margin expansion potential
+ elif current_margin < 0.15: # <15% operating margin
+ return 0.5 # Moderate margin expansion potential
+
+ return 0.2
+
+
+def calculate_sum_of_parts_discount(financial_line_items: list, market_cap: float) -> float:
+ """Calculate sum-of-the-parts discount (simplified)"""
+ # This would typically require detailed business segment analysis
+ # Simplified approach based on total assets vs market cap
+
+ if not financial_line_items or not market_cap:
+ return 0
+
+ latest = financial_line_items[0]
+ if latest.total_assets:
+ # Assume asset-based valuation at 1.2x book value
+ estimated_sotp_value = latest.total_assets * 1.2
+ if estimated_sotp_value > market_cap:
+ discount = (estimated_sotp_value - market_cap) / market_cap
+ return min(discount, 0.5) # Cap at 50%
+
+ return 0
+
+
+def assess_management_performance(metrics: list, financial_line_items: list) -> float:
+ """Assess management performance"""
+ if not metrics:
+ return 0.5
+
+ # ROE trend analysis
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if len(roe_vals) >= 3:
+ recent_roe = sum(roe_vals[:2]) / 2
+ historical_roe = sum(roe_vals[2:]) / len(roe_vals[2:])
+
+ if recent_roe > historical_roe * 1.2:
+ return 0.8 # Improving performance
+ elif recent_roe < historical_roe * 0.8:
+ return 0.3 # Declining performance
+
+ # Revenue growth consistency
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ consistency = growth_years / (len(revenues) - 1)
+ return consistency
+
+ return 0.5
+
+
+def analyze_board_independence_proxy(financial_line_items: list) -> float:
+ """Analyze board independence (proxy through governance metrics)"""
+ # In practice, would analyze board composition data
+ # Proxy: companies with consistent performance likely have better governance
+
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ positive_years = sum(1 for e in earnings if e > 0)
+ return positive_years / len(earnings)
+
+ return 0.6 # Default moderate score
+
+
+def analyze_executive_compensation_proxy(financial_line_items: list) -> float:
+ """Analyze executive compensation alignment (proxy)"""
+ # Proxy: FCF growth vs revenue growth alignment
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(fcf_vals) >= 3 and len(revenues) >= 3:
+ fcf_growth = (fcf_vals[0] / fcf_vals[-1]) - 1
+ revenue_growth = (revenues[0] / revenues[-1]) - 1
+
+ # Good alignment if FCF grows faster than revenue
+ if fcf_growth > revenue_growth:
+ return 0.8
+ elif fcf_growth > revenue_growth * 0.8:
+ return 0.6
+
+ return 0.4 # Poor alignment assumed
+
+
+def assess_shareholder_rights_proxy(market_cap: float) -> float:
+ """Assess shareholder rights (proxy through market cap)"""
+ # Larger companies typically have better shareholder rights
+ if market_cap > 10_000_000_000: # $10B+
+ return 0.8
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.6
+ else:
+ return 0.4
+
+
+def analyze_takeover_defenses_proxy(market_cap: float) -> float:
+ """Analyze takeover defenses (proxy)"""
+ # Smaller companies typically have fewer defenses
+ if market_cap < 5_000_000_000: # <$5B
+ return 0.3 # Limited defenses
+ elif market_cap < 20_000_000_000: # <$20B
+ return 0.6 # Moderate defenses
+ else:
+ return 0.8 # Strong defenses
+
+
+def identify_strategic_alternatives(financial_line_items: list, market_cap: float) -> float:
+ """Identify strategic alternatives potential"""
+ if not financial_line_items:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # Look for conglomerate discount or diversified business
+ # Proxy: high asset base relative to market cap suggests complex structure
+ if latest.total_assets and market_cap:
+ asset_ratio = latest.total_assets / market_cap
+ if asset_ratio > 3: # Highly asset-intensive
+ return 0.8
+ elif asset_ratio > 2:
+ return 0.6
+
+ return 0.4
+
+
+def assess_operational_turnaround_potential(financial_line_items: list) -> float:
+ """Assess operational turnaround potential"""
+ # Look for declining margins with stable/growing revenue
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(margins) >= 3 and len(revenues) >= 3:
+ margin_trend = margins[0] - margins[-1] # Recent vs historical
+ revenue_stability = revenues[0] / revenues[-1] # Growth ratio
+
+ if margin_trend < -0.05 and revenue_stability > 0.9: # Declining margins, stable revenue
+ return 0.8
+ elif margin_trend < 0 and revenue_stability > 0.8:
+ return 0.6
+
+ return 0.3
+
+
+def analyze_balance_sheet_optimization(financial_line_items: list) -> float:
+ """Analyze balance sheet optimization opportunities"""
+ if not financial_line_items:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # Look for excess cash or conservative capital structure
+ if latest.current_assets and latest.current_liabilities:
+ excess_liquidity = latest.current_assets - latest.current_liabilities
+ if latest.total_assets and excess_liquidity > latest.total_assets * 0.2:
+ return 0.8 # Significant excess cash
+
+ # Low debt utilization
+ if latest.total_debt and latest.shareholders_equity:
+ debt_ratio = latest.total_debt / latest.shareholders_equity
+ if debt_ratio < 0.3: # Very conservative
+ return 0.6
+
+ return 0.3
+
+
+def analyze_market_position_catalyst(financial_line_items: list) -> float:
+ """Analyze market position improvement catalyst"""
+ # Look for companies with declining market share (revenue issues)
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if len(revenues) >= 4:
+ recent_decline = revenues[0] < revenues[1]
+ historical_strength = max(revenues[2:]) > revenues[0] * 1.2
+
+ if recent_decline and historical_strength:
+ return 0.7 # Lost market position, recovery potential
+
+ return 0.4
+
+
+def assess_management_change_potential(metrics: list, financial_line_items: list) -> float:
+ """Assess management change potential"""
+ # Poor performance metrics suggest management change opportunity
+ management_score = assess_management_performance(metrics, financial_line_items)
+
+ if management_score < 0.3:
+ return 0.8 # Strong case for management change
+ elif management_score < 0.5:
+ return 0.6 # Moderate case for management change
+
+ return 0.2
+
+
+def identify_esg_improvement_opportunities(financial_line_items: list) -> float:
+ """Identify ESG improvement opportunities"""
+ # Proxy through R&D spending and operational efficiency
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])
+ if rd_intensity < 0.02: # <2% R&D intensity
+ return 0.6 # ESG improvement opportunity through innovation
+
+ return 0.4
+
+
+def assess_ma_probability(financial_line_items: list, market_cap: float) -> float:
+ """Assess M&A probability"""
+ if not financial_line_items or not market_cap:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # Attractive M&A targets: strong assets, reasonable valuation
+ if latest.total_assets and latest.total_debt:
+ net_assets = latest.total_assets - latest.total_debt
+ asset_multiple = market_cap / net_assets if net_assets > 0 else 0
+
+ if 0.8 <= asset_multiple <= 1.5: # Reasonable valuation
+ return 0.7
+ elif asset_multiple < 0.8: # Cheap
+ return 0.6
+
+ return 0.3
+
+
+def analyze_spinoff_potential(financial_line_items: list) -> float:
+ """Analyze spin-off potential"""
+ # Look for complex business structures (high assets, multiple segments implied)
+ if not financial_line_items:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # Proxy: high asset base suggests complex business
+ if latest.total_assets and latest.revenue:
+ asset_intensity = latest.total_assets / latest.revenue
+ if asset_intensity > 3: # Very asset-intensive
+ return 0.8
+ elif asset_intensity > 2:
+ return 0.6
+
+ return 0.3
+
+
+def analyze_special_dividend_potential(financial_line_items: list) -> float:
+ """Analyze special dividend potential"""
+ # Look for excess cash generation
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+
+ if fcf_vals:
+ avg_fcf = sum(fcf_vals) / len(fcf_vals)
+ if avg_fcf > 0:
+ # Check for cash accumulation
+ latest = financial_line_items[0]
+ if latest.current_assets:
+ # Proxy for cash accumulation
+ return min(avg_fcf / (latest.current_assets * 0.1), 1.0)
+
+ return 0.3
+
+
+def analyze_distressed_opportunity(financial_line_items: list) -> float:
+ """Analyze distressed investment opportunity"""
+ # Look for financial distress signals
+ if not financial_line_items:
+ return 0
+
+ latest = financial_line_items[0]
+
+ # High debt, low liquidity
+ if latest.total_debt and latest.current_assets and latest.current_liabilities:
+ debt_burden = latest.total_debt / latest.current_assets if latest.current_assets > 0 else 10
+ liquidity_ratio = latest.current_assets / latest.current_liabilities
+
+ if debt_burden > 2 and liquidity_ratio < 1.2:
+ return 0.7 # Distressed situation
+ elif debt_burden > 1.5 or liquidity_ratio < 1.0:
+ return 0.5 # Some distress
+
+ return 0.2
+
+
+def identify_regulatory_catalysts(financial_line_items: list) -> float:
+ """Identify regulatory catalysts"""
+ # Industry-specific regulatory changes (simplified)
+ return 0.4 # Placeholder - would analyze specific industry regulations
+
+
+def assess_litigation_catalyst_potential(financial_line_items: list) -> float:
+ """Assess litigation catalyst potential"""
+ # Look for companies with potential legal value creation
+ return 0.3 # Placeholder - would analyze specific legal situations
+
+
+def assess_campaign_complexity(activism_team: dict, legal_team: dict) -> float:
+ """Assess activist campaign complexity"""
+ governance_issues = len(legal_team.get("governance_issues", []))
+ activist_catalysts = len(activism_team.get("activist_catalysts", []))
+
+ # More issues = more complex campaign
+ complexity_score = (governance_issues * 0.15) + (activist_catalysts * 0.1)
+
+ return min(complexity_score, 1.0)
+
+
+def generate_elliott_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> ElliottSignal:
+ """Generate Elliott Management's activist investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Elliott Management's AI system, implementing Paul Singer's activist hedge fund approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Research Team: Fundamental analysis and hidden value identification
+ - Legal Team: Corporate governance and shareholder rights analysis
+ - Activism Team: Catalyst identification and campaign strategy
+ - Event-Driven Team: M&A, spin-offs, and special situations
+ - Paul Singer Strategic Decision: Overall campaign and value creation strategy
+
+ PHILOSOPHY:
+ 1. Catalyst-Driven Investing: Focus on specific catalysts for value creation
+ 2. Shareholder Activism: Active engagement to unlock shareholder value
+ 3. Event-Driven Opportunities: M&A arbitrage, spin-offs, special situations
+ 4. Governance Improvement: Board changes, management accountability
+ 5. Strategic Alternatives: Spin-offs, divestitures, strategic sales
+ 6. Operational Improvements: Margin expansion, cost reduction
+ 7. Balance Sheet Optimization: Capital allocation, leverage, dividends
+
+ REASONING STYLE:
+ - Identify specific catalysts and value creation opportunities
+ - Assess management performance and governance issues
+ - Analyze strategic alternatives and operational improvements
+ - Consider campaign complexity and execution timeline
+ - Express conviction in activist value creation potential
+ - Discuss legal and governance framework for activism
+ - Focus on risk-adjusted returns from catalyst realization
+
+ Return investment signal with detailed activist potential analysis."""),
+
+ ("human", """Apply Elliott Management's activist analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "activist_potential": {{
+ "catalyst_strength": float,
+ "campaign_complexity": float,
+ "expected_timeline": "string",
+ "value_creation_potential": float,
+ "governance_opportunity": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_elliott_signal():
+ return ElliottSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ activist_potential={
+ "catalyst_strength": 0.5,
+ "campaign_complexity": 0.5,
+ "expected_timeline": "12-18 months",
+ "value_creation_potential": 0.5,
+ "governance_opportunity": 0.5
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=ElliottSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_elliott_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.py
new file mode 100644
index 000000000..59782cdb7
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/agent_orchestrator.py
@@ -0,0 +1,562 @@
+# -*- coding: utf-8 -*-
+# agent_orchestrator.py
+
+import asyncio
+import json
+import logging
+import numpy as np
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+import google.generativeai as genai
+
+# Import all agents
+from fincept_terminal.Agents.fincept_hedge_fund.macro_cycle_agent import MacroCycleAgent
+from fincept_terminal.Agents.fincept_hedge_fund.central_bank_agent import CentralBankAgent
+from fincept_terminal.Agents.fincept_hedge_fund.geopolitical_agent import GeopoliticalAgent
+from fincept_terminal.Agents.fincept_hedge_fund.regulatory_agent import RegulatoryAgent
+from fincept_terminal.Agents.fincept_hedge_fund.sentiment_agent import SentimentAgent
+from fincept_terminal.Agents.fincept_hedge_fund.institutional_flow_agent import InstitutionalFlowAgent
+from fincept_terminal.Agents.fincept_hedge_fund.supply_chain_agent import SupplyChainAgent
+from fincept_terminal.Agents.fincept_hedge_fund.innovation_agent import InnovationAgent
+from fincept_terminal.Agents.fincept_hedge_fund.currency_agent import CurrencyAgent
+from fincept_terminal.Agents.fincept_hedge_fund.behavioral_agent import BehavioralAgent
+from config import CONFIG
+
+
+@dataclass
+class AgentDecision:
+ """Standardized agent decision structure"""
+ agent_name: str
+ timestamp: datetime
+ signal_strength: float # 0-1
+ direction: str # bullish, bearish, neutral
+ confidence: float
+ key_insights: List[str]
+ market_implications: Dict[str, float]
+ time_horizon: str
+ raw_analysis: Dict[str, Any]
+
+
+@dataclass
+class ConsensusDecision:
+ """Final consensus decision from all agents"""
+ timestamp: datetime
+ overall_signal: str # strong_buy, buy, hold, sell, strong_sell
+ conviction_level: float # 0-1
+ asset_allocation: Dict[str, float]
+ sector_weights: Dict[str, float]
+ risk_level: float
+ consensus_factors: List[str]
+ dissenting_views: List[str]
+ execution_priority: str
+
+
+class AgentOrchestrator:
+ """Orchestrates multi-agent analysis with inter-agent communication"""
+
+ def __init__(self, gemini_api_key: str):
+ # Configure Gemini AI
+ genai.configure(api_key=gemini_api_key)
+ self.gemini_model = genai.GenerativeModel('gemini-pro')
+
+ # Initialize all agents
+ self.agents = {
+ 'macro': MacroCycleAgent(),
+ 'fed': CentralBankAgent(),
+ 'geo': GeopoliticalAgent(),
+ 'regulatory': RegulatoryAgent(),
+ 'sentiment': SentimentAgent(),
+ 'flows': InstitutionalFlowAgent(),
+ 'supply': SupplyChainAgent(),
+ 'innovation': InnovationAgent(),
+ 'fx': CurrencyAgent(),
+ 'behavioral': BehavioralAgent()
+ }
+
+ # Agent communication weights for decision making
+ self.agent_weights = {
+ 'macro': 0.20, # Highest weight - drives overall allocation
+ 'fed': 0.18, # Critical for duration and rates
+ 'geo': 0.15, # Major risk factor
+ 'flows': 0.12, # Smart money indicator
+ 'sentiment': 0.10, # Contrarian signals
+ 'regulatory': 0.08, # Policy impacts
+ 'supply': 0.07, # Sector-specific risks
+ 'fx': 0.05, # Portfolio hedging
+ 'behavioral': 0.03, # Market psychology
+ 'innovation': 0.02 # Long-term trends
+ }
+
+ # Setup logging
+ logging.basicConfig(level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+ self.logger = logging.getLogger("AgentOrchestrator")
+
+ async def run_comprehensive_analysis(self, target_assets: List[str] = None) -> ConsensusDecision:
+ """Run comprehensive analysis with all agents and generate consensus decision"""
+ self.logger.info("🚀 Starting comprehensive multi-agent analysis...")
+
+ # Step 1: Run all agents concurrently
+ agent_decisions = await self._execute_all_agents()
+
+ # Step 2: Enable agent-to-agent communication
+ enriched_decisions = await self._facilitate_agent_communication(agent_decisions)
+
+ # Step 3: Generate consensus using Gemini AI
+ consensus = await self._generate_consensus_decision(enriched_decisions, target_assets)
+
+ # Step 4: Validate and refine decision
+ final_decision = await self._validate_and_refine_decision(consensus, enriched_decisions)
+
+ self.logger.info(f"✅ Analysis complete. Final signal: {final_decision.overall_signal}")
+ return final_decision
+
+ async def _execute_all_agents(self) -> Dict[str, AgentDecision]:
+ """Execute all agents concurrently and standardize outputs"""
+ self.logger.info("📊 Executing all agents concurrently...")
+
+ async def run_single_agent(name: str, agent: Any) -> AgentDecision:
+ try:
+ # Get agent report
+ if hasattr(agent, 'get_cycle_report'):
+ report = await agent.get_cycle_report()
+ elif hasattr(agent, 'get_policy_report'):
+ report = await agent.get_policy_report()
+ elif hasattr(agent, 'get_geopolitical_report'):
+ report = await agent.get_geopolitical_report()
+ elif hasattr(agent, 'get_regulatory_report'):
+ report = await agent.get_regulatory_report()
+ elif hasattr(agent, 'get_sentiment_report'):
+ report = await agent.get_sentiment_report()
+ elif hasattr(agent, 'get_flow_report'):
+ report = await agent.get_flow_report()
+ elif hasattr(agent, 'get_supply_chain_report'):
+ report = await agent.get_supply_chain_report()
+ elif hasattr(agent, 'get_innovation_report'):
+ report = await agent.get_innovation_report()
+ elif hasattr(agent, 'get_currency_report'):
+ report = await agent.get_currency_report()
+ elif hasattr(agent, 'get_behavioral_report'):
+ report = await agent.get_behavioral_report()
+ else:
+ report = {"error": f"No report method found for {name}"}
+
+ # Standardize the output
+ return self._standardize_agent_output(name, report)
+
+ except Exception as e:
+ self.logger.error(f"❌ Error in agent {name}: {e}")
+ return self._create_error_decision(name, str(e))
+
+ # Run all agents concurrently
+ tasks = [run_single_agent(name, agent) for name, agent in self.agents.items()]
+ results = await asyncio.gather(*tasks, return_exceptions=True)
+
+ # Combine results
+ agent_decisions = {}
+ for i, (name, agent) in enumerate(self.agents.items()):
+ if i < len(results) and isinstance(results[i], AgentDecision):
+ agent_decisions[name] = results[i]
+ else:
+ agent_decisions[name] = self._create_error_decision(name, "Execution failed")
+
+ self.logger.info(f"📈 Completed analysis from {len(agent_decisions)} agents")
+ return agent_decisions
+
+ def _standardize_agent_output(self, agent_name: str, report: Dict[str, Any]) -> AgentDecision:
+ """Standardize agent outputs into common decision format"""
+ try:
+ # Extract key metrics based on agent type
+ signal_strength, direction, confidence, insights, implications = self._extract_agent_metrics(agent_name,
+ report)
+
+ return AgentDecision(
+ agent_name=agent_name,
+ timestamp=datetime.now(),
+ signal_strength=signal_strength,
+ direction=direction,
+ confidence=confidence,
+ key_insights=insights,
+ market_implications=implications,
+ time_horizon=self._determine_time_horizon(agent_name, report),
+ raw_analysis=report
+ )
+
+ except Exception as e:
+ self.logger.error(f"Error standardizing {agent_name} output: {e}")
+ return self._create_error_decision(agent_name, str(e))
+
+ def _extract_agent_metrics(self, agent_name: str, report: Dict) -> tuple:
+ """Extract standardized metrics from agent reports"""
+ # Default values
+ signal_strength = 0.5
+ direction = "neutral"
+ confidence = 0.5
+ insights = []
+ implications = {}
+
+ try:
+ if agent_name == 'macro':
+ cycle_analysis = report.get('cycle_analysis', {})
+ phase = cycle_analysis.get('current_phase', 'expansion')
+ signal_strength = cycle_analysis.get('strength', 0.5)
+ direction = "bullish" if phase in ['expansion', 'trough'] else "bearish"
+ confidence = cycle_analysis.get('confidence', 0.5)
+ insights = [f"Business cycle: {phase}"]
+ implications = report.get('investment_implications', {})
+
+ elif agent_name == 'fed':
+ fed_analysis = report.get('fed_analysis', {})
+ stance = fed_analysis.get('policy_stance', 'neutral')
+ signal_strength = fed_analysis.get('probability', 0.5)
+ direction = "bearish" if stance == 'hawkish' else "bullish" if stance == 'dovish' else "neutral"
+ confidence = fed_analysis.get('confidence', 0.5)
+ insights = [f"Fed stance: {stance}", f"Rate direction: {fed_analysis.get('rate_direction', 'holding')}"]
+ implications = report.get('market_impact', {})
+
+ elif agent_name == 'geo':
+ risk_assessment = report.get('global_risk_assessment', {})
+ risk_level = risk_assessment.get('overall_risk_level', 5)
+ signal_strength = min(risk_level / 10, 1.0)
+ direction = "bearish" if risk_level > 6 else "neutral"
+ confidence = 0.7
+ top_risks = risk_assessment.get('top_risks', [])
+ insights = [f"Geopolitical risk: {risk_level}/10"] + [risk.get('type', '') for risk in top_risks[:2]]
+ implications = report.get('investment_implications', {})
+
+ elif agent_name == 'sentiment':
+ sentiment_analysis = report.get('sentiment_analysis', {})
+ overall_sentiment = sentiment_analysis.get('overall_sentiment', 0)
+ signal_strength = abs(overall_sentiment)
+ direction = "bullish" if overall_sentiment > 0.2 else "bearish" if overall_sentiment < -0.2 else "neutral"
+ confidence = 0.6
+ insights = [f"Market sentiment: {sentiment_analysis.get('sentiment_classification', 'neutral')}"]
+ contrarian_signals = report.get('contrarian_signals', [])
+ if contrarian_signals:
+ insights.append(f"Contrarian opportunities: {len(contrarian_signals)}")
+ implications = {"sentiment_momentum": overall_sentiment}
+
+ elif agent_name == 'flows':
+ flow_analysis = report.get('flow_analysis', {})
+ flow_sentiment = flow_analysis.get('overall_flow_sentiment', 0)
+ signal_strength = abs(flow_sentiment)
+ direction = "bullish" if flow_sentiment > 0.1 else "bearish" if flow_sentiment < -0.1 else "neutral"
+ confidence = 0.8
+ insights = [f"Institutional flows: {flow_analysis.get('flow_classification', 'balanced')}"]
+ implications = {"flow_momentum": flow_sentiment}
+
+ # Add similar extraction logic for other agents...
+ else:
+ # Generic extraction for other agents
+ insights = ["Analysis completed"]
+ implications = {"general_impact": 0.0}
+
+ except Exception as e:
+ self.logger.error(f"Error extracting metrics for {agent_name}: {e}")
+
+ return signal_strength, direction, confidence, insights, implications
+
+ def _determine_time_horizon(self, agent_name: str, report: Dict) -> str:
+ """Determine time horizon based on agent type"""
+ horizon_map = {
+ 'macro': 'long_term',
+ 'fed': 'medium_term',
+ 'geo': 'medium_term',
+ 'regulatory': 'long_term',
+ 'sentiment': 'short_term',
+ 'flows': 'short_term',
+ 'supply': 'medium_term',
+ 'innovation': 'long_term',
+ 'fx': 'short_term',
+ 'behavioral': 'short_term'
+ }
+ return horizon_map.get(agent_name, 'medium_term')
+
+ async def _facilitate_agent_communication(self, decisions: Dict[str, AgentDecision]) -> Dict[str, AgentDecision]:
+ """Enable agents to communicate and refine their decisions based on peer insights"""
+ self.logger.info("🤝 Facilitating inter-agent communication...")
+
+ # Create communication summary for each agent
+ for agent_name, decision in decisions.items():
+ # Get peer insights relevant to this agent
+ peer_insights = self._get_relevant_peer_insights(agent_name, decisions)
+
+ # Use Gemini to refine the decision based on peer insights
+ if peer_insights:
+ refined_decision = await self._refine_decision_with_peers(decision, peer_insights)
+ decisions[agent_name] = refined_decision
+
+ return decisions
+
+ def _get_relevant_peer_insights(self, agent_name: str, decisions: Dict[str, AgentDecision]) -> Dict[str, str]:
+ """Get insights from peer agents relevant to the current agent"""
+ peer_insights = {}
+
+ # Define agent relationships and relevant insights
+ agent_relationships = {
+ 'macro': ['fed', 'geo', 'flows'], # Macro affected by policy, geopolitics, flows
+ 'fed': ['macro', 'sentiment', 'flows'], # Fed policy affects sentiment, flows
+ 'geo': ['supply', 'fx', 'flows'], # Geopolitics affects supply chains, currency, flows
+ 'sentiment': ['behavioral', 'flows', 'macro'], # Sentiment relates to behavior, flows, macro
+ 'flows': ['sentiment', 'macro', 'fed'], # Flows influenced by sentiment, macro, policy
+ 'supply': ['geo', 'innovation', 'regulatory'], # Supply chains affected by geopolitics, innovation
+ 'regulatory': ['innovation', 'supply', 'flows'], # Regulation affects innovation, supply, flows
+ 'fx': ['fed', 'geo', 'flows'], # Currency affected by policy, geopolitics, flows
+ 'behavioral': ['sentiment', 'flows', 'macro'], # Behavior relates to sentiment, flows, macro
+ 'innovation': ['regulatory', 'supply', 'macro'] # Innovation affected by regulation, supply, macro
+ }
+
+ relevant_agents = agent_relationships.get(agent_name, [])
+
+ for peer_agent in relevant_agents:
+ if peer_agent in decisions:
+ peer_decision = decisions[peer_agent]
+ insight_summary = f"{peer_decision.direction} signal ({peer_decision.signal_strength:.2f} strength) - {peer_decision.key_insights[0] if peer_decision.key_insights else 'No specific insights'}"
+ peer_insights[peer_agent] = insight_summary
+
+ return peer_insights
+
+ async def _refine_decision_with_peers(self, original_decision: AgentDecision,
+ peer_insights: Dict[str, str]) -> AgentDecision:
+ """Use Gemini AI to refine agent decision based on peer insights"""
+ try:
+ peer_summary = "\n".join([f"{agent}: {insight}" for agent, insight in peer_insights.items()])
+
+ prompt = f"""
+ As the {original_decision.agent_name} agent, refine your analysis considering peer agent insights:
+
+ Your Original Analysis:
+ - Signal: {original_decision.direction} ({original_decision.signal_strength:.2f} strength)
+ - Confidence: {original_decision.confidence:.2f}
+ - Key Insights: {', '.join(original_decision.key_insights)}
+
+ Peer Agent Insights:
+ {peer_summary}
+
+ Considering these peer insights, should you:
+ 1. Maintain your original assessment
+ 2. Increase/decrease signal strength
+ 3. Change direction
+ 4. Adjust confidence level
+
+ Provide response in JSON format:
+ {{
+ "action": "maintain/strengthen/weaken/reverse",
+ "new_signal_strength": 0.0-1.0,
+ "new_direction": "bullish/bearish/neutral",
+ "new_confidence": 0.0-1.0,
+ "reasoning": "Brief explanation",
+ "key_factors": ["factor1", "factor2"]
+ }}
+ """
+
+ response = self.gemini_model.generate_content(prompt)
+ refinement = json.loads(response.text)
+
+ # Update decision based on Gemini's analysis
+ original_decision.signal_strength = refinement.get("new_signal_strength", original_decision.signal_strength)
+ original_decision.direction = refinement.get("new_direction", original_decision.direction)
+ original_decision.confidence = refinement.get("new_confidence", original_decision.confidence)
+ original_decision.key_insights.append(f"Peer-refined: {refinement.get('reasoning', 'No reasoning')}")
+
+ return original_decision
+
+ except Exception as e:
+ self.logger.error(f"Error refining decision with Gemini: {e}")
+ return original_decision
+
+ async def _generate_consensus_decision(self, decisions: Dict[str, AgentDecision],
+ target_assets: List[str] = None) -> ConsensusDecision:
+ """Generate final consensus decision using Gemini AI"""
+ self.logger.info("🧠 Generating consensus decision with Gemini AI...")
+
+ # Prepare decision summary
+ decision_summary = self._prepare_decision_summary(decisions)
+
+ prompt = f"""
+ As a senior portfolio manager, analyze these AI agent insights and create a final investment decision:
+
+ Agent Analysis Summary:
+ {decision_summary}
+
+ Agent Weights for Decision Making:
+ {json.dumps(self.agent_weights, indent=2)}
+
+ Target Assets: {target_assets or "Broad market exposure"}
+
+ Generate a comprehensive investment decision with:
+ 1. Overall signal (strong_buy/buy/hold/sell/strong_sell)
+ 2. Conviction level (0-1)
+ 3. Asset allocation percentages
+ 4. Sector weight recommendations
+ 5. Risk level assessment (0-1)
+ 6. Key consensus factors
+ 7. Main dissenting views
+ 8. Execution priority (immediate/gradual/wait)
+
+ Consider:
+ - Agent reliability and track record
+ - Signal consistency across agents
+ - Risk-adjusted returns
+ - Current market regime
+ - Diversification principles
+
+ Provide response in JSON format with all requested fields.
+ """
+
+ try:
+ response = self.gemini_model.generate_content(prompt)
+ consensus_data = json.loads(response.text)
+
+ return ConsensusDecision(
+ timestamp=datetime.now(),
+ overall_signal=consensus_data.get("overall_signal", "hold"),
+ conviction_level=consensus_data.get("conviction_level", 0.5),
+ asset_allocation=consensus_data.get("asset_allocation", {"stocks": 0.6, "bonds": 0.4}),
+ sector_weights=consensus_data.get("sector_weights", {}),
+ risk_level=consensus_data.get("risk_level", 0.5),
+ consensus_factors=consensus_data.get("consensus_factors", []),
+ dissenting_views=consensus_data.get("dissenting_views", []),
+ execution_priority=consensus_data.get("execution_priority", "gradual")
+ )
+
+ except Exception as e:
+ self.logger.error(f"Error generating consensus with Gemini: {e}")
+ return self._create_default_consensus(decisions)
+
+ def _prepare_decision_summary(self, decisions: Dict[str, AgentDecision]) -> str:
+ """Prepare summary of all agent decisions"""
+ summary_lines = []
+
+ for agent_name, decision in decisions.items():
+ weight = self.agent_weights.get(agent_name, 0.0)
+ summary_lines.append(
+ f"{agent_name.upper()} (Weight: {weight:.1%}): "
+ f"{decision.direction} signal, "
+ f"Strength: {decision.signal_strength:.2f}, "
+ f"Confidence: {decision.confidence:.2f}, "
+ f"Horizon: {decision.time_horizon}, "
+ f"Key: {decision.key_insights[0] if decision.key_insights else 'N/A'}"
+ )
+
+ return "\n".join(summary_lines)
+
+ async def _validate_and_refine_decision(self, consensus: ConsensusDecision,
+ decisions: Dict[str, AgentDecision]) -> ConsensusDecision:
+ """Validate and refine the final decision"""
+ self.logger.info("✅ Validating and refining final decision...")
+
+ # Risk checks
+ if consensus.risk_level > 0.8:
+ self.logger.warning("⚠️ High risk level detected, adjusting position sizes...")
+ # Reduce allocation to risky assets
+ for asset in ["stocks", "growth", "emerging_markets"]:
+ if asset in consensus.asset_allocation:
+ consensus.asset_allocation[asset] *= 0.8
+
+ # Consistency checks
+ bullish_agents = len([d for d in decisions.values() if d.direction == "bullish"])
+ bearish_agents = len([d for d in decisions.values() if d.direction == "bearish"])
+
+ if abs(bullish_agents - bearish_agents) <= 1:
+ self.logger.info("📊 Mixed signals detected, reducing conviction...")
+ consensus.conviction_level *= 0.8
+ consensus.execution_priority = "gradual"
+
+ return consensus
+
+ def _create_error_decision(self, agent_name: str, error_msg: str) -> AgentDecision:
+ """Create default decision for failed agents"""
+ return AgentDecision(
+ agent_name=agent_name,
+ timestamp=datetime.now(),
+ signal_strength=0.0,
+ direction="neutral",
+ confidence=0.0,
+ key_insights=[f"Error: {error_msg}"],
+ market_implications={},
+ time_horizon="unknown",
+ raw_analysis={"error": error_msg}
+ )
+
+ def _create_default_consensus(self, decisions: Dict[str, AgentDecision]) -> ConsensusDecision:
+ """Create default consensus when Gemini fails"""
+ # Simple weighted average approach
+ total_weighted_signal = 0.0
+ total_weight = 0.0
+
+ for agent_name, decision in decisions.items():
+ weight = self.agent_weights.get(agent_name, 0.0)
+ signal_value = decision.signal_strength * (
+ 1 if decision.direction == "bullish" else -1 if decision.direction == "bearish" else 0)
+ total_weighted_signal += signal_value * weight
+ total_weight += weight
+
+ avg_signal = total_weighted_signal / total_weight if total_weight > 0 else 0.0
+
+ if avg_signal > 0.3:
+ overall_signal = "buy"
+ elif avg_signal < -0.3:
+ overall_signal = "sell"
+ else:
+ overall_signal = "hold"
+
+ return ConsensusDecision(
+ timestamp=datetime.now(),
+ overall_signal=overall_signal,
+ conviction_level=abs(avg_signal),
+ asset_allocation={"stocks": 0.6, "bonds": 0.3, "cash": 0.1},
+ sector_weights={},
+ risk_level=0.5,
+ consensus_factors=["Default consensus due to system error"],
+ dissenting_views=[],
+ execution_priority="gradual"
+ )
+
+
+async def run_hedge_fund_analysis(gemini_api_key: str, target_assets: List[str] = None):
+ """Main function to run complete hedge fund analysis"""
+ orchestrator = AgentOrchestrator(gemini_api_key)
+
+ print("🏦 AI HEDGE FUND - MULTI-AGENT ANALYSIS")
+ print("=" * 50)
+
+ # Run comprehensive analysis
+ decision = await orchestrator.run_comprehensive_analysis(target_assets)
+
+ # Display results
+ print(f"\n📈 FINAL INVESTMENT DECISION")
+ print(f"Signal: {decision.overall_signal.upper()}")
+ print(f"Conviction: {decision.conviction_level:.1%}")
+ print(f"Risk Level: {decision.risk_level:.1%}")
+ print(f"Execution: {decision.execution_priority}")
+
+ print(f"\n💼 ASSET ALLOCATION:")
+ for asset, weight in decision.asset_allocation.items():
+ print(f" {asset.capitalize()}: {weight:.1%}")
+
+ print(f"\n🔍 KEY CONSENSUS FACTORS:")
+ for factor in decision.consensus_factors[:3]:
+ print(f" • {factor}")
+
+ if decision.dissenting_views:
+ print(f"\n⚠️ DISSENTING VIEWS:")
+ for view in decision.dissenting_views[:2]:
+ print(f" • {view}")
+
+ return decision
+
+
+# Example usage
+if __name__ == "__main__":
+ import os
+
+ # Set your Gemini API key
+ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "your-gemini-api-key-here")
+
+ # Define target assets (optional)
+ TARGET_ASSETS = ["SPY", "QQQ", "TLT", "GLD", "VXX"]
+
+ # Run the analysis
+ asyncio.run(run_hedge_fund_analysis(GEMINI_API_KEY, TARGET_ASSETS))
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.py
new file mode 100644
index 000000000..4a9800fc1
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/behavioral_agent.py
@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+# agents/behavioral_agent.py - Behavioral Finance Analysis Agent
+
+import asyncio
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+import logging
+from dataclasses import dataclass
+import openai
+
+from config import CONFIG
+from data_feeds import DataFeedManager
+
+
+@dataclass
+class BehaviorSignal:
+ """Behavioral finance signal"""
+ behavior_type: str
+ intensity: float # 0-1
+ market_impact: str # bullish, bearish, neutral
+ contrarian_opportunity: bool
+ affected_assets: List[str]
+ confidence: float
+
+
+class BehavioralAgent:
+ """Behavioral finance analysis - crowd psychology and market inefficiencies"""
+
+ def __init__(self):
+ self.name = "behavioral"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ self.behavioral_patterns = {
+ "herd_behavior": {
+ "indicators": ["consensus_trades", "crowded_positions", "momentum_chasing"],
+ "contrarian_threshold": 0.7
+ },
+ "overconfidence": {
+ "indicators": ["excessive_trading", "narrow_spreads", "low_volatility"],
+ "contrarian_threshold": 0.6
+ },
+ "loss_aversion": {
+ "indicators": ["selling_pressure", "defensive_positioning", "cash_hoarding"],
+ "contrarian_threshold": 0.8
+ },
+ "anchoring": {
+ "indicators": ["resistance_levels", "round_numbers", "historical_highs"],
+ "contrarian_threshold": 0.5
+ },
+ "recency_bias": {
+ "indicators": ["trend_extrapolation", "momentum_investing", "recent_news_focus"],
+ "contrarian_threshold": 0.6
+ }
+ }
+
+ self.market_psychology_indicators = {
+ "fear": ["VIX", "put_call_ratio", "safe_haven_flows"],
+ "greed": ["margin_debt", "IPO_activity", "speculative_trading"],
+ "complacency": ["low_volatility", "compressed_spreads", "leverage_buildup"],
+ "panic": ["forced_selling", "liquidity_crisis", "correlation_spike"]
+ }
+
+ async def analyze_behavioral_patterns(self) -> List[BehaviorSignal]:
+ """Analyze behavioral finance patterns in markets"""
+ signals = []
+
+ for pattern, config in self.behavioral_patterns.items():
+ try:
+ signal = await self._analyze_behavioral_pattern(pattern, config)
+ if signal:
+ signals.append(signal)
+ except Exception as e:
+ logging.error(f"Error analyzing {pattern}: {e}")
+ continue
+
+ return signals
+
+ async def _analyze_behavioral_pattern(self, pattern: str, config: Dict) -> Optional[BehaviorSignal]:
+ """Analyze specific behavioral pattern"""
+ # Simulate behavioral pattern analysis
+ # In production, would analyze actual market data for these patterns
+
+ # Generate realistic behavioral intensity
+ base_intensity = np.random.uniform(0.2, 0.8)
+
+ # Adjust based on pattern type
+ pattern_adjustments = {
+ "herd_behavior": np.random.normal(0.1, 0.2),
+ "overconfidence": np.random.normal(-0.1, 0.15),
+ "loss_aversion": np.random.normal(0.05, 0.25),
+ "anchoring": np.random.normal(0, 0.1),
+ "recency_bias": np.random.normal(0.08, 0.18)
+ }
+
+ intensity = np.clip(base_intensity + pattern_adjustments.get(pattern, 0), 0, 1)
+
+ # Determine market impact
+ if pattern in ["herd_behavior", "overconfidence", "recency_bias"]:
+ if intensity > 0.6:
+ market_impact = "bearish" # Contrarian signal
+ else:
+ market_impact = "bullish"
+ elif pattern == "loss_aversion":
+ market_impact = "bullish" if intensity > 0.6 else "bearish"
+ else:
+ market_impact = "neutral"
+
+ # Check for contrarian opportunity
+ contrarian_opportunity = intensity > config["contrarian_threshold"]
+
+ # Determine affected assets
+ affected_assets = self._get_affected_assets(pattern, intensity)
+
+ return BehaviorSignal(
+ behavior_type=pattern,
+ intensity=intensity,
+ market_impact=market_impact,
+ contrarian_opportunity=contrarian_opportunity,
+ affected_assets=affected_assets,
+ confidence=0.5 + intensity * 0.3 # Higher intensity = higher confidence
+ )
+
+ def _get_affected_assets(self, pattern: str, intensity: float) -> List[str]:
+ """Determine which assets are affected by behavioral pattern"""
+ if pattern == "herd_behavior":
+ if intensity > 0.7:
+ return ["momentum_stocks", "growth_stocks", "crypto"]
+ else:
+ return ["broad_market"]
+ elif pattern == "overconfidence":
+ return ["individual_stocks", "options", "leveraged_products"]
+ elif pattern == "loss_aversion":
+ return ["defensive_stocks", "bonds", "gold", "utilities"]
+ elif pattern == "anchoring":
+ return ["stocks_near_highs", "round_number_levels"]
+ elif pattern == "recency_bias":
+ return ["trending_sectors", "recent_winners"]
+ else:
+ return ["broad_market"]
+
+ async def analyze_market_psychology(self) -> Dict[str, float]:
+ """Analyze overall market psychology"""
+ psychology_scores = {}
+
+ for emotion, indicators in self.market_psychology_indicators.items():
+ # Simulate psychology analysis
+ # In production, would analyze actual market indicators
+ score = np.random.uniform(0.2, 0.8)
+
+ # Add some correlation between emotions
+ if emotion == "fear" and "greed" in psychology_scores:
+ score = max(0.1, 1.0 - psychology_scores["greed"] + np.random.normal(0, 0.1))
+ elif emotion == "greed" and "fear" in psychology_scores:
+ score = max(0.1, 1.0 - psychology_scores["fear"] + np.random.normal(0, 0.1))
+
+ psychology_scores[emotion] = np.clip(score, 0, 1)
+
+ return psychology_scores
+
+ def _detect_behavioral_anomalies(self, signals: List[BehaviorSignal]) -> List[str]:
+ """Detect behavioral anomalies in the market"""
+ anomalies = []
+
+ # High intensity behavioral patterns
+ high_intensity_patterns = [s for s in signals if s.intensity > 0.7]
+ if len(high_intensity_patterns) >= 2:
+ anomalies.append("multiple_behavioral_extremes")
+
+ # Strong contrarian opportunities
+ contrarian_signals = [s for s in signals if s.contrarian_opportunity]
+ if len(contrarian_signals) >= 3:
+ anomalies.append("multiple_contrarian_opportunities")
+
+ # Conflicting behavioral signals
+ bullish_signals = [s for s in signals if s.market_impact == "bullish"]
+ bearish_signals = [s for s in signals if s.market_impact == "bearish"]
+
+ if len(bullish_signals) > 0 and len(bearish_signals) > 0:
+ if abs(len(bullish_signals) - len(bearish_signals)) <= 1:
+ anomalies.append("conflicting_behavioral_signals")
+
+ return anomalies
+
+ async def get_behavioral_report(self) -> Dict:
+ """Generate comprehensive behavioral finance report"""
+ # Analyze behavioral patterns
+ behavioral_signals = await self.analyze_behavioral_patterns()
+
+ # Analyze market psychology
+ psychology_scores = await self.analyze_market_psychology()
+
+ # Detect anomalies
+ anomalies = self._detect_behavioral_anomalies(behavioral_signals)
+
+ # Calculate overall behavioral sentiment
+ overall_sentiment = self._calculate_behavioral_sentiment(behavioral_signals, psychology_scores)
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "behavioral_analysis": {
+ "overall_sentiment": overall_sentiment,
+ "sentiment_classification": self._classify_sentiment(overall_sentiment),
+ "behavioral_patterns": [{
+ "pattern": signal.behavior_type,
+ "intensity": signal.intensity,
+ "market_impact": signal.market_impact,
+ "contrarian_opportunity": signal.contrarian_opportunity,
+ "affected_assets": signal.affected_assets,
+ "confidence": signal.confidence
+ } for signal in behavioral_signals],
+ "market_psychology": psychology_scores,
+ "behavioral_anomalies": anomalies
+ },
+ "trading_implications": {
+ "contrarian_opportunities": [s.behavior_type for s in behavioral_signals
+ if s.contrarian_opportunity],
+ "behavioral_momentum": [s.behavior_type for s in behavioral_signals
+ if s.intensity > 0.6 and not s.contrarian_opportunity],
+ "risk_management": self._get_behavioral_risk_management(behavioral_signals),
+ "position_sizing": self._get_behavioral_position_sizing(behavioral_signals)
+ },
+ "monitoring_priorities": {
+ "extreme_behaviors": [s.behavior_type for s in behavioral_signals if s.intensity > 0.7],
+ "contrarian_signals": [s.behavior_type for s in behavioral_signals if s.contrarian_opportunity],
+ "psychology_extremes": [emotion for emotion, score in psychology_scores.items()
+ if score > 0.7 or score < 0.3]
+ }
+ }
+
+ def _calculate_behavioral_sentiment(self, signals: List[BehaviorSignal],
+ psychology: Dict[str, float]) -> float:
+ """Calculate overall behavioral sentiment"""
+ if not signals and not psychology:
+ return 0.0
+
+ # Weight behavioral signals
+ signal_sentiment = 0.0
+ if signals:
+ bullish_weight = sum(s.intensity for s in signals if s.market_impact == "bullish")
+ bearish_weight = sum(s.intensity for s in signals if s.market_impact == "bearish")
+ total_weight = bullish_weight + bearish_weight
+
+ if total_weight > 0:
+ signal_sentiment = (bullish_weight - bearish_weight) / total_weight
+
+ # Weight psychology scores
+ psychology_sentiment = 0.0
+ if psychology:
+ greed_score = psychology.get("greed", 0.5)
+ fear_score = psychology.get("fear", 0.5)
+ psychology_sentiment = greed_score - fear_score
+
+ # Combine (60% signals, 40% psychology)
+ if signals and psychology:
+ combined_sentiment = 0.6 * signal_sentiment + 0.4 * psychology_sentiment
+ elif signals:
+ combined_sentiment = signal_sentiment
+ elif psychology:
+ combined_sentiment = psychology_sentiment
+ else:
+ combined_sentiment = 0.0
+
+ return np.clip(combined_sentiment, -1.0, 1.0)
+
+ def _classify_sentiment(self, sentiment: float) -> str:
+ """Classify behavioral sentiment"""
+ if sentiment > 0.4:
+ return "behavioral_euphoria"
+ elif sentiment > 0.1:
+ return "behavioral_optimism"
+ elif sentiment > -0.1:
+ return "behavioral_neutral"
+ elif sentiment > -0.4:
+ return "behavioral_pessimism"
+ else:
+ return "behavioral_despair"
+
+ def _get_behavioral_risk_management(self, signals: List[BehaviorSignal]) -> List[str]:
+ """Get behavioral risk management recommendations"""
+ recommendations = []
+
+ # Check for high-intensity patterns
+ high_intensity = [s for s in signals if s.intensity > 0.7]
+ if high_intensity:
+ recommendations.append("Monitor for behavioral reversals")
+ recommendations.append("Consider reducing position sizes")
+
+ # Check for herd behavior
+ herd_signals = [s for s in signals if s.behavior_type == "herd_behavior" and s.intensity > 0.6]
+ if herd_signals:
+ recommendations.append("Prepare for trend reversals")
+ recommendations.append("Avoid momentum chasing")
+
+ # Check for overconfidence
+ overconfidence_signals = [s for s in signals if s.behavior_type == "overconfidence" and s.intensity > 0.5]
+ if overconfidence_signals:
+ recommendations.append("Increase due diligence")
+ recommendations.append("Diversify more broadly")
+
+ return recommendations or ["Standard behavioral risk monitoring"]
+
+ def _get_behavioral_position_sizing(self, signals: List[BehaviorSignal]) -> str:
+ """Get position sizing recommendation based on behavioral patterns"""
+ contrarian_count = sum(1 for s in signals if s.contrarian_opportunity)
+ high_intensity_count = sum(1 for s in signals if s.intensity > 0.7)
+
+ if contrarian_count >= 2:
+ return "reduce_size" # Multiple contrarian signals suggest caution
+ elif high_intensity_count >= 2:
+ return "reduce_size" # Multiple extreme behaviors suggest volatility
+ elif contrarian_count == 1 and high_intensity_count == 0:
+ return "increase_size" # Single contrarian opportunity with low extremes
+ else:
+ return "normal"
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.py
new file mode 100644
index 000000000..1d737705b
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/central_bank_agent.py
@@ -0,0 +1,749 @@
+# -*- coding: utf-8 -*-
+# agents/central_bank_agent.py - Central Bank Policy Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+import re
+from textblob import TextBlob
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class PolicySignal:
+ """Central bank policy signal structure"""
+ bank: str
+ policy_stance: str # dovish, neutral, hawkish
+ rate_direction: str # cutting, holding, raising
+ probability: float
+ next_meeting_date: Optional[datetime]
+ key_factors: List[str]
+ market_impact: Dict[str, float]
+ confidence: float
+
+
+class CentralBankAgent:
+ """Advanced central bank policy analysis and prediction"""
+
+ def __init__(self):
+ self.name = "central_bank"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Central bank meeting schedules (approximate)
+ self.meeting_schedules = {
+ "FED": [
+ "2025-01-29", "2025-03-19", "2025-04-30", "2025-06-11",
+ "2025-07-30", "2025-09-17", "2025-10-29", "2025-12-17"
+ ],
+ "ECB": [
+ "2025-01-23", "2025-03-06", "2025-04-10", "2025-06-05",
+ "2025-07-17", "2025-09-11", "2025-10-23", "2025-12-11"
+ ],
+ "BOJ": [
+ "2025-01-23", "2025-03-19", "2025-04-28", "2025-06-14",
+ "2025-07-31", "2025-09-20", "2025-10-31", "2025-12-19"
+ ]
+ }
+
+ # Policy keywords and their sentiment weights
+ self.policy_keywords = {
+ "hawkish": {
+ "aggressive", "tighten", "restrictive", "combat inflation",
+ "rate hikes", "cooling", "overheating", "price pressures",
+ "vigilant", "determined", "forceful", "anchor expectations"
+ },
+ "dovish": {
+ "accommodate", "supportive", "gradual", "patient", "flexible",
+ "employment", "growth", "stimulus", "easy", "cautious",
+ "measured", "data dependent", "appropriate", "monitor"
+ },
+ "neutral": {
+ "balanced", "assess", "evaluate", "conditions", "outlook",
+ "appropriate", "meetings", "review", "consider", "analyze"
+ }
+ }
+
+ # Economic indicators that influence policy
+ self.policy_indicators = {
+ "inflation": {
+ "CPIAUCSL": 0.25, # CPI
+ "CPILFESL": 0.25, # Core CPI
+ "PCEPI": 0.20, # PCE Price Index
+ "PCEPILFE": 0.20, # Core PCE
+ "DFEDTARU": 0.10 # Fed Target Rate
+ },
+ "employment": {
+ "UNRATE": 0.35, # Unemployment Rate
+ "PAYEMS": 0.25, # Nonfarm Payrolls
+ "AWHMAN": 0.15, # Average Weekly Hours
+ "AHETPI": 0.25 # Average Hourly Earnings
+ },
+ "growth": {
+ "GDPC1": 0.40, # Real GDP
+ "INDPRO": 0.30, # Industrial Production
+ "RSAFS": 0.30 # Retail Sales
+ },
+ "financial": {
+ "GS10": 0.25, # 10-Year Treasury
+ "GS2": 0.25, # 2-Year Treasury
+ "VIXCLS": 0.20, # VIX
+ "DEXUSEU": 0.15, # USD/EUR
+ "DTWEXBGS": 0.15 # Trade Weighted USD
+ }
+ }
+
+ # Market impact coefficients by asset class
+ self.market_impact_coefficients = {
+ "bonds": {
+ "hawkish": -0.8, # Negative for bond prices
+ "neutral": 0.0,
+ "dovish": 0.6
+ },
+ "stocks": {
+ "hawkish": -0.4, # Generally negative but less than bonds
+ "neutral": 0.1,
+ "dovish": 0.7
+ },
+ "dollar": {
+ "hawkish": 0.9, # Strong positive for USD
+ "neutral": 0.0,
+ "dovish": -0.6
+ },
+ "gold": {
+ "hawkish": -0.7, # Negative for gold
+ "neutral": 0.0,
+ "dovish": 0.5
+ }
+ }
+
+ async def analyze_fed_policy(self) -> PolicySignal:
+ """Comprehensive Federal Reserve policy analysis"""
+ try:
+ # Fetch economic indicators
+ economic_data = await self._fetch_policy_indicators()
+
+ # Get recent Fed communications
+ fed_communications = await self._fetch_fed_communications()
+
+ # Analyze policy stance from data
+ data_stance = self._analyze_data_driven_stance(economic_data)
+
+ # Analyze communications sentiment
+ comm_stance = self._analyze_communication_sentiment(fed_communications)
+
+ # Combine signals with weights
+ combined_stance = self._combine_policy_signals(data_stance, comm_stance)
+
+ # Predict rate direction
+ rate_direction, probability = self._predict_rate_direction(economic_data, combined_stance)
+
+ # Get next meeting date
+ next_meeting = self._get_next_meeting_date("FED")
+
+ # Calculate market impact
+ market_impact = self._calculate_market_impact(combined_stance, rate_direction)
+
+ # Generate LLM analysis
+ llm_analysis = await self._generate_policy_analysis(economic_data, fed_communications, combined_stance)
+
+ return PolicySignal(
+ bank="FED",
+ policy_stance=combined_stance["stance"],
+ rate_direction=rate_direction,
+ probability=probability,
+ next_meeting_date=next_meeting,
+ key_factors=llm_analysis.get("key_factors", []),
+ market_impact=market_impact,
+ confidence=combined_stance["confidence"]
+ )
+
+ except Exception as e:
+ logging.error(f"Error in Fed policy analysis: {e}")
+ return self._default_policy_signal("FED")
+
+ async def _fetch_policy_indicators(self) -> Dict[str, pd.Series]:
+ """Fetch economic indicators relevant to monetary policy"""
+ data_requests = {}
+
+ # Collect all indicators
+ all_indicators = set()
+ for category in self.policy_indicators.values():
+ all_indicators.update(category.keys())
+
+ # Create requests
+ for indicator in all_indicators:
+ data_requests[indicator] = {
+ "series_id": indicator,
+ "limit": 60 # 5 years of monthly data
+ }
+
+ try:
+ raw_data = await self.data_manager.get_multi_source_data({
+ "economic": data_requests
+ })
+
+ # Process into time series
+ processed_data = {}
+ economic_data = raw_data.get("economic", {})
+
+ for key, data_points in economic_data.items():
+ if data_points and len(data_points) > 0:
+ # Create DataFrame from data points
+ df_data = []
+ for dp in data_points:
+ df_data.append({
+ 'date': dp.timestamp,
+ 'value': dp.value
+ })
+
+ if df_data:
+ df = pd.DataFrame(df_data)
+ df['date'] = pd.to_datetime(df['date'])
+ df = df.sort_values('date').set_index('date')
+ processed_data[key] = df['value']
+
+ return processed_data
+
+ except Exception as e:
+ logging.error(f"Error fetching policy indicators: {e}")
+ return {}
+
+ async def _fetch_fed_communications(self) -> List[DataPoint]:
+ """Fetch recent Federal Reserve communications and speeches"""
+ keywords = ["federal reserve", "jerome powell", "fed policy", "interest rates", "monetary policy"]
+
+ communications = []
+ try:
+ for keyword in keywords:
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": keyword,
+ "sources": ["reuters", "bloomberg", "wsj"],
+ "hours_back": 168 # 1 week
+ }
+ })
+
+ if "news" in news_data and news_data["news"]:
+ communications.extend(news_data["news"])
+
+ # Filter for actual Fed communications
+ fed_communications = []
+ for comm in communications:
+ if any(term in comm.value.lower() for term in ["fed", "federal reserve", "powell", "fomc"]):
+ fed_communications.append(comm)
+
+ return fed_communications
+
+ except Exception as e:
+ logging.error(f"Error fetching Fed communications: {e}")
+ return []
+
+ def _analyze_data_driven_stance(self, data: Dict[str, pd.Series]) -> Dict:
+ """Analyze policy stance based on economic data"""
+ stance_scores = []
+ confidence_factors = []
+
+ try:
+ # Inflation analysis
+ inflation_score = self._analyze_inflation_pressure(data)
+ stance_scores.append(inflation_score * 0.4) # 40% weight
+ confidence_factors.append(0.9 if inflation_score != 0 else 0.3)
+
+ # Employment analysis
+ employment_score = self._analyze_employment_conditions(data)
+ stance_scores.append(employment_score * 0.3) # 30% weight
+ confidence_factors.append(0.8 if employment_score != 0 else 0.3)
+
+ # Growth analysis
+ growth_score = self._analyze_growth_momentum(data)
+ stance_scores.append(growth_score * 0.2) # 20% weight
+ confidence_factors.append(0.7 if growth_score != 0 else 0.3)
+
+ # Financial conditions
+ financial_score = self._analyze_financial_conditions(data)
+ stance_scores.append(financial_score * 0.1) # 10% weight
+ confidence_factors.append(0.6 if financial_score != 0 else 0.3)
+
+ # Calculate overall stance
+ overall_score = np.sum(stance_scores)
+ confidence = np.mean(confidence_factors)
+
+ if overall_score > 0.3:
+ stance = "hawkish"
+ elif overall_score < -0.3:
+ stance = "dovish"
+ else:
+ stance = "neutral"
+
+ return {
+ "stance": stance,
+ "score": overall_score,
+ "confidence": confidence,
+ "components": {
+ "inflation": inflation_score,
+ "employment": employment_score,
+ "growth": growth_score,
+ "financial": financial_score
+ }
+ }
+
+ except Exception as e:
+ logging.error(f"Error in data-driven stance analysis: {e}")
+ return {"stance": "neutral", "score": 0.0, "confidence": 0.3, "components": {}}
+
+ def _analyze_inflation_pressure(self, data: Dict[str, pd.Series]) -> float:
+ """Analyze inflation pressure for policy implications"""
+ inflation_indicators = self.policy_indicators["inflation"]
+ scores = []
+
+ for indicator, weight in inflation_indicators.items():
+ if indicator in data and not data[indicator].empty and len(data[indicator]) >= 12:
+ series = data[indicator]
+
+ # Calculate year-over-year change
+ yoy_change = series.pct_change(12).iloc[-1] * 100
+
+ # Fed target is typically around 2%
+ if indicator in ["CPIAUCSL", "CPILFESL", "PCEPI", "PCEPILFE"]:
+ if yoy_change > 3.0:
+ score = 1.0 # Strong hawkish signal
+ elif yoy_change > 2.5:
+ score = 0.5 # Moderate hawkish
+ elif yoy_change < 1.5:
+ score = -0.5 # Moderate dovish
+ elif yoy_change < 1.0:
+ score = -1.0 # Strong dovish
+ else:
+ score = 0.0 # Neutral
+ else:
+ score = 0.0
+
+ scores.append(score * weight)
+
+ return np.sum(scores) if scores else 0.0
+
+ def _analyze_employment_conditions(self, data: Dict[str, pd.Series]) -> float:
+ """Analyze employment conditions for policy implications"""
+ employment_indicators = self.policy_indicators["employment"]
+ scores = []
+
+ for indicator, weight in employment_indicators.items():
+ if indicator in data and not data[indicator].empty:
+ series = data[indicator]
+
+ if indicator == "UNRATE":
+ current_rate = series.iloc[-1]
+ if current_rate < 3.5:
+ score = 1.0 # Very tight labor market - hawkish
+ elif current_rate < 4.0:
+ score = 0.5 # Tight labor market
+ elif current_rate > 5.5:
+ score = -0.5 # Loose labor market - dovish
+ elif current_rate > 6.5:
+ score = -1.0 # Very loose labor market
+ else:
+ score = 0.0
+ elif indicator == "PAYEMS":
+ # Payroll growth
+ if len(series) >= 3:
+ avg_growth = series.pct_change().iloc[-3:].mean() * 100
+ if avg_growth > 0.4: # >400k jobs/month
+ score = 0.5 # Strong growth - slightly hawkish
+ elif avg_growth < 0.1: # <100k jobs/month
+ score = -0.5 # Weak growth - dovish
+ else:
+ score = 0.0
+ else:
+ score = 0.0
+ else:
+ score = 0.0
+
+ scores.append(score * weight)
+
+ return np.sum(scores) if scores else 0.0
+
+ def _analyze_growth_momentum(self, data: Dict[str, pd.Series]) -> float:
+ """Analyze economic growth momentum"""
+ growth_indicators = self.policy_indicators["growth"]
+ scores = []
+
+ for indicator, weight in growth_indicators.items():
+ if indicator in data and not data[indicator].empty and len(data[indicator]) >= 4:
+ series = data[indicator]
+
+ # Calculate quarterly growth rate
+ quarterly_growth = series.pct_change(3).iloc[-1] * 100
+
+ if indicator == "GDPC1":
+ if quarterly_growth > 3.0:
+ score = 0.5 # Strong growth - slightly hawkish
+ elif quarterly_growth < 1.0:
+ score = -0.5 # Weak growth - dovish
+ elif quarterly_growth < 0:
+ score = -1.0 # Contraction - very dovish
+ else:
+ score = 0.0
+ else:
+ # For other indicators, use similar logic
+ if quarterly_growth > 2.0:
+ score = 0.3
+ elif quarterly_growth < 0:
+ score = -0.5
+ else:
+ score = 0.0
+
+ scores.append(score * weight)
+
+ return np.sum(scores) if scores else 0.0
+
+ def _analyze_financial_conditions(self, data: Dict[str, pd.Series]) -> float:
+ """Analyze financial market conditions"""
+ financial_indicators = self.policy_indicators["financial"]
+ scores = []
+
+ for indicator, weight in financial_indicators.items():
+ if indicator in data and not data[indicator].empty:
+ series = data[indicator]
+
+ if indicator == "GS10":
+ # 10-year treasury yield
+ current_yield = series.iloc[-1]
+ if current_yield > 5.0:
+ score = 0.5 # High yields - less need for tightening
+ elif current_yield < 3.0:
+ score = -0.3 # Low yields - room for accommodation
+ else:
+ score = 0.0
+ elif indicator == "VIXCLS":
+ # VIX volatility index
+ current_vix = series.iloc[-1]
+ if current_vix > 30:
+ score = -0.8 # High volatility - dovish signal
+ elif current_vix < 15:
+ score = 0.3 # Low volatility - can be hawkish
+ else:
+ score = 0.0
+ else:
+ score = 0.0
+
+ scores.append(score * weight)
+
+ return np.sum(scores) if scores else 0.0
+
+ def _analyze_communication_sentiment(self, communications: List[DataPoint]) -> Dict:
+ """Analyze sentiment from Fed communications"""
+ if not communications:
+ return {"stance": "neutral", "confidence": 0.2, "score": 0.0}
+
+ stance_scores = []
+ confidence_scores = []
+
+ for comm in communications:
+ text = comm.value.lower()
+
+ # Count keyword occurrences
+ hawkish_count = sum(1 for keyword in self.policy_keywords["hawkish"] if keyword in text)
+ dovish_count = sum(1 for keyword in self.policy_keywords["dovish"] if keyword in text)
+ neutral_count = sum(1 for keyword in self.policy_keywords["neutral"] if keyword in text)
+
+ total_keywords = hawkish_count + dovish_count + neutral_count
+
+ if total_keywords > 0:
+ # Calculate sentiment score
+ sentiment_score = (hawkish_count - dovish_count) / total_keywords
+ stance_scores.append(sentiment_score * comm.confidence)
+ confidence_scores.append(comm.confidence)
+
+ if not stance_scores:
+ return {"stance": "neutral", "confidence": 0.2, "score": 0.0}
+
+ # Weight by confidence and recency
+ weighted_score = np.average(stance_scores, weights=confidence_scores)
+ avg_confidence = np.mean(confidence_scores)
+
+ if weighted_score > 0.2:
+ stance = "hawkish"
+ elif weighted_score < -0.2:
+ stance = "dovish"
+ else:
+ stance = "neutral"
+
+ return {
+ "stance": stance,
+ "confidence": avg_confidence,
+ "score": weighted_score
+ }
+
+ def _combine_policy_signals(self, data_stance: Dict, comm_stance: Dict) -> Dict:
+ """Combine data-driven and communication-based policy signals"""
+ # Weight data more heavily than communications
+ data_weight = 0.7
+ comm_weight = 0.3
+
+ combined_score = (data_stance["score"] * data_weight +
+ comm_stance["score"] * comm_weight)
+
+ combined_confidence = (data_stance["confidence"] * data_weight +
+ comm_stance["confidence"] * comm_weight)
+
+ if combined_score > 0.25:
+ stance = "hawkish"
+ elif combined_score < -0.25:
+ stance = "dovish"
+ else:
+ stance = "neutral"
+
+ return {
+ "stance": stance,
+ "score": combined_score,
+ "confidence": combined_confidence,
+ "data_component": data_stance,
+ "communication_component": comm_stance
+ }
+
+ def _predict_rate_direction(self, data: Dict[str, pd.Series], stance: Dict) -> Tuple[str, float]:
+ """Predict rate direction and probability"""
+ current_rate = 5.25 # Approximate current fed funds rate
+
+ # Get current inflation and unemployment
+ current_inflation = 0.0
+ current_unemployment = 0.0
+
+ if "CPIAUCSL" in data and not data["CPIAUCSL"].empty and len(data["CPIAUCSL"]) >= 12:
+ current_inflation = data["CPIAUCSL"].pct_change(12).iloc[-1] * 100
+
+ if "UNRATE" in data and not data["UNRATE"].empty:
+ current_unemployment = data["UNRATE"].iloc[-1]
+
+ # Decision logic based on dual mandate
+ if stance["stance"] == "hawkish":
+ if current_inflation > 3.0 or current_unemployment < 3.5:
+ direction = "raising"
+ probability = 0.75 + stance["confidence"] * 0.2
+ else:
+ direction = "holding"
+ probability = 0.60 + stance["confidence"] * 0.15
+ elif stance["stance"] == "dovish":
+ if current_inflation < 1.5 or current_unemployment > 5.0:
+ direction = "cutting"
+ probability = 0.70 + stance["confidence"] * 0.2
+ else:
+ direction = "holding"
+ probability = 0.55 + stance["confidence"] * 0.15
+ else:
+ direction = "holding"
+ probability = 0.65 + stance["confidence"] * 0.1
+
+ # Adjust for current rate level
+ if current_rate > 6.0 and direction == "raising":
+ probability *= 0.8 # Less likely to raise from high levels
+ elif current_rate < 2.0 and direction == "cutting":
+ probability *= 0.7 # Less room to cut from low levels
+
+ return direction, min(probability, 0.95)
+
+ def _get_next_meeting_date(self, bank: str) -> Optional[datetime]:
+ """Get next central bank meeting date"""
+ if bank not in self.meeting_schedules:
+ return None
+
+ today = datetime.now()
+ try:
+ meeting_dates = [datetime.strptime(date, "%Y-%m-%d") for date in self.meeting_schedules[bank]]
+ future_meetings = [date for date in meeting_dates if date > today]
+ return min(future_meetings) if future_meetings else None
+ except Exception as e:
+ logging.error(f"Error parsing meeting dates: {e}")
+ return None
+
+ def _calculate_market_impact(self, stance: Dict, rate_direction: str) -> Dict[str, float]:
+ """Calculate expected market impact of policy stance"""
+ stance_name = stance["stance"]
+ impact_strength = abs(stance["score"]) * stance["confidence"]
+
+ market_impacts = {}
+
+ for asset_class, coefficients in self.market_impact_coefficients.items():
+ base_impact = coefficients[stance_name]
+
+ # Adjust for rate direction
+ if rate_direction == "raising" and stance_name == "hawkish":
+ base_impact *= 1.2
+ elif rate_direction == "cutting" and stance_name == "dovish":
+ base_impact *= 1.2
+
+ # Scale by impact strength
+ final_impact = base_impact * impact_strength
+ market_impacts[asset_class] = np.clip(final_impact, -1.0, 1.0)
+
+ return market_impacts
+
+ async def _generate_policy_analysis(self, data: Dict[str, pd.Series],
+ communications: List[DataPoint],
+ stance: Dict) -> Dict:
+ """Generate LLM-enhanced policy analysis"""
+ try:
+ # Prepare data summary
+ data_summary = self._prepare_policy_data_summary(data)
+ comm_summary = self._prepare_communication_summary(communications)
+
+ prompt = f"""
+ As a Federal Reserve policy expert, analyze the current monetary policy outlook.
+
+ Current Policy Stance: {stance["stance"]} (confidence: {stance["confidence"]:.2f})
+
+ Economic Data Summary:
+ {data_summary}
+
+ Recent Fed Communications:
+ {comm_summary}
+
+ Please provide:
+ 1. Key factors driving current policy stance
+ 2. Most important risks to monitor
+ 3. Probability of policy error (too tight/loose)
+ 4. Market positioning recommendations
+ 5. Timeline for next major policy shift
+
+ Format as JSON with keys: key_factors, risks, policy_error_risk, market_recommendations, timeline
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM policy analysis: {e}")
+ return {
+ "key_factors": ["Inflation trends", "Employment conditions"],
+ "risks": ["Policy lag effects", "Market volatility"],
+ "policy_error_risk": 0.3,
+ "market_recommendations": "Maintain balanced positioning",
+ "timeline": "Next 3-6 months"
+ }
+
+ def _prepare_policy_data_summary(self, data: Dict[str, pd.Series]) -> str:
+ """Prepare policy-relevant data summary"""
+ summary_lines = []
+
+ # Key indicators for Fed policy
+ key_indicators = {
+ "CPIAUCSL": "Core Inflation",
+ "UNRATE": "Unemployment Rate",
+ "PAYEMS": "Job Growth",
+ "GDPC1": "GDP Growth",
+ "GS10": "10Y Treasury Yield"
+ }
+
+ for indicator, name in key_indicators.items():
+ if indicator in data and not data[indicator].empty:
+ latest = data[indicator].iloc[-1]
+
+ if indicator in ["CPIAUCSL"] and len(data[indicator]) >= 12:
+ yoy_change = data[indicator].pct_change(12).iloc[-1] * 100
+ summary_lines.append(f"{name}: {yoy_change:.1f}% YoY")
+ elif indicator == "PAYEMS" and len(data[indicator]) >= 1:
+ monthly_change = data[indicator].diff().iloc[-1]
+ summary_lines.append(f"{name}: {monthly_change:.0f}k (monthly)")
+ else:
+ summary_lines.append(f"{name}: {latest:.2f}")
+
+ return "\n".join(summary_lines)
+
+ def _prepare_communication_summary(self, communications: List[DataPoint]) -> str:
+ """Prepare Fed communications summary"""
+ if not communications:
+ return "No recent Fed communications available"
+
+ # Get most recent and relevant communications
+ recent_comms = sorted(communications, key=lambda x: x.timestamp, reverse=True)[:5]
+
+ summary_lines = []
+ for comm in recent_comms:
+ date_str = comm.timestamp.strftime("%Y-%m-%d")
+ title = comm.value[:100] + "..." if len(comm.value) > 100 else comm.value
+ summary_lines.append(f"{date_str}: {title}")
+
+ return "\n".join(summary_lines)
+
+ def _default_policy_signal(self, bank: str) -> PolicySignal:
+ """Return default policy signal in case of errors"""
+ return PolicySignal(
+ bank=bank,
+ policy_stance="neutral",
+ rate_direction="holding",
+ probability=0.5,
+ next_meeting_date=self._get_next_meeting_date(bank),
+ key_factors=["Data dependency", "Inflation monitoring"],
+ market_impact={
+ "bonds": 0.0,
+ "stocks": 0.0,
+ "dollar": 0.0,
+ "gold": 0.0
+ },
+ confidence=0.3
+ )
+
+ async def get_policy_report(self) -> Dict:
+ """Generate comprehensive central bank policy report"""
+ fed_signal = await self.analyze_fed_policy()
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "fed_analysis": {
+ "policy_stance": fed_signal.policy_stance,
+ "rate_direction": fed_signal.rate_direction,
+ "probability": fed_signal.probability,
+ "confidence": fed_signal.confidence,
+ "next_meeting": fed_signal.next_meeting_date.isoformat() if fed_signal.next_meeting_date else None,
+ "key_factors": fed_signal.key_factors
+ },
+ "market_impact": fed_signal.market_impact,
+ "trading_implications": {
+ "duration_positioning": "short" if fed_signal.policy_stance == "hawkish" else "long",
+ "sector_rotation": self._get_sector_implications(fed_signal),
+ "currency_bias": "bullish_usd" if fed_signal.policy_stance == "hawkish" else "bearish_usd"
+ },
+ "risk_factors": {
+ "policy_uncertainty": 1 - fed_signal.confidence,
+ "communication_risk": 0.3,
+ "market_reaction_risk": 0.4
+ }
+ }
+
+ def _get_sector_implications(self, signal: PolicySignal) -> Dict[str, str]:
+ """Get sector rotation implications from policy stance"""
+ if signal.policy_stance == "hawkish":
+ return {
+ "financials": "bullish", # Higher rates benefit banks
+ "technology": "bearish", # Higher discount rates hurt growth stocks
+ "utilities": "bearish", # Rate-sensitive sector
+ "real_estate": "bearish" # REITs hurt by higher rates
+ }
+ elif signal.policy_stance == "dovish":
+ return {
+ "technology": "bullish", # Lower rates help growth stocks
+ "real_estate": "bullish", # REITs benefit from lower rates
+ "utilities": "bullish", # Rate-sensitive sectors benefit
+ "financials": "bearish" # Lower rates hurt bank margins
+ }
+ else:
+ return {
+ "balanced": "neutral",
+ "defensive": "slight_overweight"
+ }
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.py
new file mode 100644
index 000000000..4136ef8b6
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/config.py
@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+# config.py - Production Configuration for AI Hedge Fund System
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+import logging
+from pathlib import Path
+
+
+@dataclass
+class APIConfig:
+ """API Configuration for external services"""
+ openai_api_key: str = os.getenv("OPENAI_API_KEY", "")
+ anthropic_api_key: str = os.getenv("ANTHROPIC_API_KEY", "")
+ finnhub_api_key: str = os.getenv("FINNHUB_API_KEY", "")
+ alpha_vantage_key: str = os.getenv("ALPHA_VANTAGE_API_KEY", "")
+ fred_api_key: str = os.getenv("FRED_API_KEY", "")
+ newsapi_key: str = os.getenv("NEWS_API_KEY", "")
+ twitter_bearer_token: str = os.getenv("TWITTER_BEARER_TOKEN", "")
+ reddit_client_id: str = os.getenv("REDDIT_CLIENT_ID", "")
+ reddit_client_secret: str = os.getenv("REDDIT_CLIENT_SECRET", "")
+ polygon_api_key: str = os.getenv("POLYGON_API_KEY", "")
+
+
+@dataclass
+class LLMConfig:
+ """LLM Configuration for different thinking modes"""
+ deep_think_model: str = "gpt-4o"
+ quick_think_model: str = "gpt-4o-mini"
+ temperature: float = 0.1
+ max_tokens: int = 4000
+ timeout: int = 30
+ max_retries: int = 3
+
+
+@dataclass
+class AgentConfig:
+ """Individual agent configuration"""
+ confidence_threshold: float = 0.7
+ update_frequency: int = 300 # seconds
+ data_lookback_days: int = 30
+ max_api_calls_per_hour: int = 100
+ enable_caching: bool = True
+ cache_ttl: int = 1800 # 30 minutes
+
+
+@dataclass
+class RiskConfig:
+ """Risk management parameters"""
+ max_position_size: float = 0.05 # 5% max per position
+ max_sector_exposure: float = 0.25 # 25% max per sector
+ max_country_exposure: float = 0.40 # 40% max per country
+ stop_loss_threshold: float = 0.02 # 2% stop loss
+ var_limit: float = 0.03 # 3% daily VaR limit
+ correlation_limit: float = 0.8 # Max correlation between positions
+
+
+@dataclass
+class TradingConfig:
+ """Trading execution parameters"""
+ min_trade_size: float = 1000.0 # Minimum trade size USD
+ max_trade_size: float = 1000000.0 # Maximum trade size USD
+ slippage_assumption: float = 0.001 # 10 bps slippage
+ commission_rate: float = 0.0005 # 5 bps commission
+ market_impact_threshold: float = 0.01 # 1% of daily volume
+
+
+class Config:
+ """Main configuration class"""
+
+ def __init__(self):
+ self.api = APIConfig()
+ self.llm = LLMConfig()
+ self.agent = AgentConfig()
+ self.risk = RiskConfig()
+ self.trading = TradingConfig()
+
+ # Logging configuration
+ self.log_level = logging.INFO
+ self.log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+ # Data storage paths
+ self.data_dir = Path("data")
+ self.cache_dir = Path("cache")
+ self.logs_dir = Path("logs")
+
+ # Create directories if they don't exist
+ for directory in [self.data_dir, self.cache_dir, self.logs_dir]:
+ directory.mkdir(exist_ok=True)
+
+ # Agent weights for decision aggregation
+ self.agent_weights = {
+ "macro_cycle": 0.15,
+ "central_bank": 0.20,
+ "geopolitical": 0.18,
+ "regulatory": 0.12,
+ "sentiment": 0.10,
+ "institutional_flow": 0.15,
+ "supply_chain": 0.05,
+ "innovation": 0.03,
+ "currency": 0.02,
+ "behavioral": 0.00
+ }
+
+ # Market hours and trading sessions
+ self.trading_sessions = {
+ "US": {"open": "09:30", "close": "16:00", "timezone": "America/New_York"},
+ "EU": {"open": "08:00", "close": "16:30", "timezone": "Europe/London"},
+ "ASIA": {"open": "09:00", "close": "15:00", "timezone": "Asia/Tokyo"}
+ }
+
+ # Asset class mappings
+ self.asset_classes = {
+ "equities": ["SPY", "QQQ", "IWM", "EFA", "EEM"],
+ "bonds": ["TLT", "IEF", "SHY", "LQD", "HYG"],
+ "commodities": ["GLD", "SLV", "USO", "UNG", "DBA"],
+ "currencies": ["UUP", "FXE", "FXY", "FXB", "EWZ"],
+ "volatility": ["VIX", "UVXY", "SVXY"]
+ }
+
+ # Economic indicators to monitor
+ self.economic_indicators = [
+ "GDP", "CPI", "PPI", "UNRATE", "FEDFUNDS", "DGS10", "DGS2",
+ "DEXUSEU", "DEXCHUS", "DEXJPUS", "DEXUSUK", "CPIAUCSL",
+ "PAYEMS", "INDPRO", "HOUST", "RSAFS", "UMCSENT"
+ ]
+
+ # News sources and their reliability scores
+ self.news_sources = {
+ "reuters": 0.95,
+ "bloomberg": 0.95,
+ "wsj": 0.90,
+ "ft": 0.90,
+ "cnbc": 0.75,
+ "marketwatch": 0.70,
+ "yahoo_finance": 0.65
+ }
+
+ def validate_config(self) -> bool:
+ """Validate configuration settings"""
+ required_keys = [
+ self.api.openai_api_key,
+ self.api.finnhub_api_key,
+ self.api.fred_api_key
+ ]
+
+ if not all(required_keys):
+ raise ValueError("Missing required API keys. Check environment variables.")
+
+ if sum(self.agent_weights.values()) != 1.0:
+ raise ValueError("Agent weights must sum to 1.0")
+
+ return True
+
+ def get_market_hours(self, market: str) -> Dict[str, str]:
+ """Get trading hours for specific market"""
+ return self.trading_sessions.get(market.upper(), {})
+
+ def get_asset_universe(self, asset_class: str) -> List[str]:
+ """Get tradeable assets for asset class"""
+ return self.asset_classes.get(asset_class.lower(), [])
+
+
+# Global configuration instance
+CONFIG = Config()
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.py
new file mode 100644
index 000000000..620e196a4
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/currency_agent.py
@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# agents/currency_agent.py - Foreign Exchange Analysis Agent
+
+import asyncio
+import numpy as np
+from datetime import datetime
+from typing import Dict, List, Optional
+import logging
+from dataclasses import dataclass
+import openai
+
+from config import CONFIG
+from data_feeds import DataFeedManager
+
+
+@dataclass
+class CurrencySignal:
+ """Currency trading signal"""
+ currency_pair: str
+ direction: str # long, short, neutral
+ strength: float # 0-1
+ time_horizon: str
+ drivers: List[str]
+ confidence: float
+
+
+class CurrencyAgent:
+ """Foreign exchange analysis and currency trading signals"""
+
+ def __init__(self):
+ self.name = "currency"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ self.major_pairs = ["EURUSD", "GBPUSD", "USDJPY", "USDCAD", "AUDUSD", "USDCHF"]
+
+ self.currency_drivers = {
+ "interest_rate_differential": 0.30,
+ "economic_growth": 0.25,
+ "political_stability": 0.20,
+ "trade_balance": 0.15,
+ "risk_sentiment": 0.10
+ }
+
+ async def analyze_currency_trends(self) -> List[CurrencySignal]:
+ """Analyze major currency trends"""
+ signals = []
+
+ for pair in self.major_pairs:
+ try:
+ signal = await self._analyze_currency_pair(pair)
+ if signal:
+ signals.append(signal)
+ except Exception as e:
+ logging.error(f"Error analyzing {pair}: {e}")
+ continue
+
+ return signals
+
+ async def _analyze_currency_pair(self, pair: str) -> Optional[CurrencySignal]:
+ """Analyze specific currency pair"""
+ # Simulate currency analysis
+ base_currency = pair[:3]
+ quote_currency = pair[3:]
+
+ # Simulate various factors
+ rate_differential = np.random.normal(0, 0.5)
+ economic_growth_diff = np.random.normal(0, 0.3)
+ political_stability = np.random.uniform(-0.5, 0.5)
+
+ # Combine factors
+ signal_strength = (rate_differential * 0.4 +
+ economic_growth_diff * 0.4 +
+ political_stability * 0.2)
+
+ if signal_strength > 0.2:
+ direction = "long"
+ strength = min(signal_strength, 1.0)
+ elif signal_strength < -0.2:
+ direction = "short"
+ strength = min(abs(signal_strength), 1.0)
+ else:
+ direction = "neutral"
+ strength = 0.1
+
+ drivers = ["interest_rates", "economic_data"]
+ if abs(political_stability) > 0.3:
+ drivers.append("political_events")
+
+ return CurrencySignal(
+ currency_pair=pair,
+ direction=direction,
+ strength=strength,
+ time_horizon="medium",
+ drivers=drivers,
+ confidence=0.6
+ )
+
+ async def get_currency_report(self) -> Dict:
+ """Generate currency analysis report"""
+ signals = await self.analyze_currency_trends()
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "currency_analysis": {
+ "usd_outlook": self._assess_usd_outlook(signals),
+ "currency_signals": [{
+ "pair": signal.currency_pair,
+ "direction": signal.direction,
+ "strength": signal.strength,
+ "time_horizon": signal.time_horizon,
+ "key_drivers": signal.drivers,
+ "confidence": signal.confidence
+ } for signal in signals],
+ "strongest_signals": [s.currency_pair for s in signals
+ if s.strength > 0.6 and s.direction != "neutral"]
+ }
+ }
+
+ def _assess_usd_outlook(self, signals: List[CurrencySignal]) -> str:
+ """Assess overall USD outlook from currency signals"""
+ usd_signals = [s for s in signals if "USD" in s.currency_pair]
+
+ if not usd_signals:
+ return "neutral"
+
+ bullish_count = sum(1 for s in usd_signals
+ if (s.currency_pair.startswith("USD") and s.direction == "long") or
+ (s.currency_pair.endswith("USD") and s.direction == "short"))
+
+ if bullish_count > len(usd_signals) * 0.6:
+ return "bullish"
+ elif bullish_count < len(usd_signals) * 0.4:
+ return "bearish"
+ else:
+ return "neutral"
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.py
new file mode 100644
index 000000000..5a2cfe72c
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/data_feeds.py
@@ -0,0 +1,478 @@
+# -*- coding: utf-8 -*-
+# data_feeds.py - Production Data Sources and Feed Management
+
+import asyncio
+import aiohttp
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Union
+import json
+import logging
+from dataclasses import dataclass
+import redis
+from config import CONFIG
+import time
+import hashlib
+
+
+@dataclass
+class DataPoint:
+ """Standardized data point structure"""
+ timestamp: datetime
+ source: str
+ data_type: str
+ value: Union[float, str, Dict]
+ confidence: float
+ metadata: Dict[str, Any]
+
+
+class DataCache:
+ """Redis-based caching for data feeds"""
+
+ def __init__(self):
+ self.redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
+ self.default_ttl = CONFIG.agent.cache_ttl
+
+ def get(self, key: str) -> Optional[Any]:
+ """Get cached data"""
+ try:
+ data = self.redis_client.get(key)
+ return json.loads(data) if data else None
+ except Exception:
+ return None
+
+ def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+ """Set cached data"""
+ try:
+ ttl = ttl or self.default_ttl
+ return self.redis_client.setex(key, ttl, json.dumps(value, default=str))
+ except Exception:
+ return False
+
+ def generate_key(self, source: str, params: Dict) -> str:
+ """Generate cache key from parameters"""
+ param_str = json.dumps(params, sort_keys=True)
+ return f"{source}:{hashlib.md5(param_str.encode()).hexdigest()}"
+
+
+class EconomicDataFeed:
+ """Federal Reserve Economic Data (FRED) API integration"""
+
+ def __init__(self):
+ self.base_url = "https://api.stlouisfed.org/fred"
+ self.api_key = CONFIG.api.fred_api_key
+ self.cache = DataCache()
+ self.session = None
+
+ async def __aenter__(self):
+ self.session = aiohttp.ClientSession()
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ if self.session:
+ await self.session.close()
+
+ async def get_series(self, series_id: str, limit: int = 100) -> List[DataPoint]:
+ """Get economic time series data"""
+ cache_key = self.cache.generate_key("fred", {"series": series_id, "limit": limit})
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ url = f"{self.base_url}/series/observations"
+ params = {
+ "series_id": series_id,
+ "api_key": self.api_key,
+ "file_type": "json",
+ "limit": limit,
+ "sort_order": "desc"
+ }
+
+ try:
+ async with self.session.get(url, params=params) as response:
+ data = await response.json()
+ observations = data.get("observations", [])
+
+ data_points = []
+ for obs in observations:
+ if obs["value"] != ".":
+ dp = DataPoint(
+ timestamp=datetime.strptime(obs["date"], "%Y-%m-%d"),
+ source="FRED",
+ data_type=series_id,
+ value=float(obs["value"]),
+ confidence=0.95,
+ metadata={"series_id": series_id}
+ )
+ data_points.append(dp)
+
+ # Cache the results
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching FRED data for {series_id}: {e}")
+ return []
+
+
+class NewsDataFeed:
+ """News API integration for sentiment and events"""
+
+ def __init__(self):
+ self.api_key = CONFIG.api.newsapi_key
+ self.base_url = "https://newsapi.org/v2"
+ self.cache = DataCache()
+ self.session = None
+
+ async def __aenter__(self):
+ self.session = aiohttp.ClientSession()
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ if self.session:
+ await self.session.close()
+
+ async def get_headlines(self, query: str, sources: List[str] = None,
+ hours_back: int = 24) -> List[DataPoint]:
+ """Get news headlines with relevance scoring"""
+ cache_key = self.cache.generate_key("news", {
+ "query": query,
+ "sources": sources,
+ "hours": hours_back
+ })
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ from_date = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+
+ params = {
+ "q": query,
+ "from": from_date,
+ "sortBy": "relevancy",
+ "apiKey": self.api_key,
+ "language": "en",
+ "pageSize": 100
+ }
+
+ if sources:
+ params["sources"] = ",".join(sources)
+
+ try:
+ async with self.session.get(f"{self.base_url}/everything", params=params) as response:
+ data = await response.json()
+ articles = data.get("articles", [])
+
+ data_points = []
+ for article in articles:
+ # Calculate relevance confidence based on source reliability
+ source_name = article.get("source", {}).get("name", "").lower()
+ confidence = CONFIG.news_sources.get(source_name, 0.50)
+
+ dp = DataPoint(
+ timestamp=datetime.fromisoformat(article["publishedAt"].replace("Z", "+00:00")),
+ source=source_name,
+ data_type="news_headline",
+ value=article["title"],
+ confidence=confidence,
+ metadata={
+ "description": article.get("description", ""),
+ "url": article.get("url", ""),
+ "author": article.get("author", ""),
+ "query": query
+ }
+ )
+ data_points.append(dp)
+
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching news data: {e}")
+ return []
+
+
+class MarketDataFeed:
+ """Financial market data from multiple sources"""
+
+ def __init__(self):
+ self.finnhub_key = CONFIG.api.finnhub_api_key
+ self.polygon_key = CONFIG.api.polygon_api_key
+ self.cache = DataCache()
+ self.session = None
+
+ async def __aenter__(self):
+ self.session = aiohttp.ClientSession()
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ if self.session:
+ await self.session.close()
+
+ async def get_institutional_trades(self, symbol: str) -> List[DataPoint]:
+ """Get institutional trading data from Finnhub"""
+ cache_key = self.cache.generate_key("institutional", {"symbol": symbol})
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ url = f"https://finnhub.io/api/v1/stock/institutional-portfolio"
+ params = {
+ "symbol": symbol,
+ "token": self.finnhub_key
+ }
+
+ try:
+ async with self.session.get(url, params=params) as response:
+ data = await response.json()
+
+ data_points = []
+ for filing in data.get("data", []):
+ dp = DataPoint(
+ timestamp=datetime.now(),
+ source="Finnhub",
+ data_type="institutional_holding",
+ value=filing.get("change", 0),
+ confidence=0.85,
+ metadata={
+ "symbol": symbol,
+ "institution": filing.get("name", ""),
+ "shares": filing.get("share", 0),
+ "portfolio_percent": filing.get("portfolioPercent", 0)
+ }
+ )
+ data_points.append(dp)
+
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching institutional data: {e}")
+ return []
+
+ async def get_insider_trades(self, symbol: str, days_back: int = 30) -> List[DataPoint]:
+ """Get insider trading data"""
+ cache_key = self.cache.generate_key("insider", {"symbol": symbol, "days": days_back})
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ from_date = (datetime.now() - timedelta(days=days_back)).strftime("%Y-%m-%d")
+ to_date = datetime.now().strftime("%Y-%m-%d")
+
+ url = f"https://finnhub.io/api/v1/stock/insider-transactions"
+ params = {
+ "symbol": symbol,
+ "from": from_date,
+ "to": to_date,
+ "token": self.finnhub_key
+ }
+
+ try:
+ async with self.session.get(url, params=params) as response:
+ data = await response.json()
+
+ data_points = []
+ for trade in data.get("data", []):
+ dp = DataPoint(
+ timestamp=datetime.strptime(trade["transactionDate"], "%Y-%m-%d"),
+ source="Finnhub",
+ data_type="insider_trade",
+ value=trade.get("change", 0),
+ confidence=0.90,
+ metadata={
+ "symbol": symbol,
+ "name": trade.get("name", ""),
+ "share": trade.get("share", 0),
+ "transaction_code": trade.get("transactionCode", ""),
+ "transaction_price": trade.get("transactionPrice", 0)
+ }
+ )
+ data_points.append(dp)
+
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching insider data: {e}")
+ return []
+
+
+class SentimentDataFeed:
+ """Social media and sentiment data aggregation"""
+
+ def __init__(self):
+ self.reddit_id = CONFIG.api.reddit_client_id
+ self.reddit_secret = CONFIG.api.reddit_client_secret
+ self.twitter_token = CONFIG.api.twitter_bearer_token
+ self.cache = DataCache()
+ self.session = None
+
+ async def __aenter__(self):
+ self.session = aiohttp.ClientSession()
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ if self.session:
+ await self.session.close()
+
+ async def get_reddit_sentiment(self, subreddits: List[str], keywords: List[str]) -> List[DataPoint]:
+ """Get Reddit sentiment for specific keywords"""
+ cache_key = self.cache.generate_key("reddit", {
+ "subreddits": subreddits,
+ "keywords": keywords
+ })
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ # Reddit API implementation would go here
+ # For now, return mock structure
+ data_points = []
+
+ try:
+ # This would be actual Reddit API calls
+ for subreddit in subreddits:
+ for keyword in keywords:
+ dp = DataPoint(
+ timestamp=datetime.now(),
+ source="Reddit",
+ data_type="social_sentiment",
+ value=np.random.uniform(-1, 1), # Placeholder sentiment score
+ confidence=0.60,
+ metadata={
+ "subreddit": subreddit,
+ "keyword": keyword,
+ "post_count": np.random.randint(10, 100),
+ "engagement_score": np.random.uniform(0, 1)
+ }
+ )
+ data_points.append(dp)
+
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching Reddit sentiment: {e}")
+ return []
+
+
+class GeopoliticalDataFeed:
+ """Geopolitical events and risk monitoring"""
+
+ def __init__(self):
+ self.cache = DataCache()
+ self.session = None
+
+ async def __aenter__(self):
+ self.session = aiohttp.ClientSession()
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ if self.session:
+ await self.session.close()
+
+ async def get_conflict_data(self) -> List[DataPoint]:
+ """Get global conflict and tension data"""
+ cache_key = self.cache.generate_key("geopolitical", {"type": "conflicts"})
+ cached = self.cache.get(cache_key)
+
+ if cached and CONFIG.agent.enable_caching:
+ return [DataPoint(**dp) for dp in cached]
+
+ # This would integrate with GDELT, ACLED, or similar sources
+ # For production, you'd implement actual API calls
+ data_points = []
+
+ try:
+ # Mock implementation - replace with real geopolitical data sources
+ conflicts = ["Russia-Ukraine", "China-Taiwan", "Middle East", "North Korea"]
+
+ for conflict in conflicts:
+ dp = DataPoint(
+ timestamp=datetime.now(),
+ source="GDELT",
+ data_type="geopolitical_tension",
+ value=np.random.uniform(0, 10), # Tension score 0-10
+ confidence=0.75,
+ metadata={
+ "conflict_region": conflict,
+ "escalation_risk": np.random.choice(["low", "medium", "high"]),
+ "affected_sectors": ["defense", "energy", "tech"],
+ "sanctions_risk": np.random.uniform(0, 1)
+ }
+ )
+ data_points.append(dp)
+
+ self.cache.set(cache_key, [dp.__dict__ for dp in data_points])
+ return data_points
+
+ except Exception as e:
+ logging.error(f"Error fetching geopolitical data: {e}")
+ return []
+
+
+class DataFeedManager:
+ """Central manager for all data feeds"""
+
+ def __init__(self):
+ self.feeds = {
+ "economic": EconomicDataFeed(),
+ "news": NewsDataFeed(),
+ "market": MarketDataFeed(),
+ "sentiment": SentimentDataFeed(),
+ "geopolitical": GeopoliticalDataFeed()
+ }
+
+ async def get_multi_source_data(self, data_requests: Dict[str, Dict]) -> Dict[str, List[DataPoint]]:
+ """Get data from multiple sources concurrently"""
+ results = {}
+
+ async def fetch_data(feed_name: str, feed_obj: Any, request_params: Dict):
+ async with feed_obj as feed:
+ if feed_name == "economic":
+ data = await feed.get_series(**request_params)
+ elif feed_name == "news":
+ data = await feed.get_headlines(**request_params)
+ elif feed_name == "market":
+ if request_params.get("data_type") == "institutional":
+ data = await feed.get_institutional_trades(request_params["symbol"])
+ else:
+ data = await feed.get_insider_trades(**request_params)
+ elif feed_name == "sentiment":
+ data = await feed.get_reddit_sentiment(**request_params)
+ elif feed_name == "geopolitical":
+ data = await feed.get_conflict_data()
+ else:
+ data = []
+
+ results[feed_name] = data
+
+ tasks = []
+ for feed_name, request_params in data_requests.items():
+ if feed_name in self.feeds:
+ feed_obj = self.feeds[feed_name]
+ tasks.append(fetch_data(feed_name, feed_obj, request_params))
+
+ await asyncio.gather(*tasks, return_exceptions=True)
+ return results
+
+ def get_latest_data_summary(self) -> Dict[str, Any]:
+ """Get summary of latest data availability"""
+ summary = {
+ "timestamp": datetime.now().isoformat(),
+ "data_sources": list(self.feeds.keys()),
+ "cache_status": "enabled" if CONFIG.agent.enable_caching else "disabled",
+ "api_rate_limits": {
+ "economic": f"{CONFIG.agent.max_api_calls_per_hour}/hour",
+ "news": f"{CONFIG.agent.max_api_calls_per_hour}/hour",
+ "market": f"{CONFIG.agent.max_api_calls_per_hour}/hour"
+ }
+ }
+ return summary
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.py
new file mode 100644
index 000000000..d3a055171
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/geopolitical_agent.py
@@ -0,0 +1,894 @@
+# -*- coding: utf-8 -*-
+# agents/geopolitical_agent.py - Geopolitical Risk Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+from collections import defaultdict
+import re
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class GeopoliticalRisk:
+ """Geopolitical risk assessment structure"""
+ region: str
+ risk_type: str
+ current_level: int # 1-10 scale
+ trend: str # escalating, stable, de-escalating
+ probability_impact: float # 0-1
+ affected_sectors: List[str]
+ timeline: str
+ mitigation_strategies: List[str]
+ confidence: float
+
+
+@dataclass
+class ConflictSignal:
+ """Military conflict monitoring signal"""
+ conflict_name: str
+ escalation_risk: float
+ economic_impact: Dict[str, float]
+ supply_chain_risk: Dict[str, float]
+ market_sectors: Dict[str, float]
+ duration_estimate: str
+
+
+class GeopoliticalAgent:
+ """Advanced geopolitical risk monitoring and analysis"""
+
+ def __init__(self):
+ self.name = "geopolitical"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Geopolitical risk factors and their weights
+ self.risk_factors = {
+ "military_conflicts": {
+ "Russia-Ukraine": 0.25,
+ "China-Taiwan": 0.20,
+ "Middle_East": 0.15,
+ "North_Korea": 0.10,
+ "India-Pakistan": 0.08,
+ "Balkans": 0.05,
+ "Arctic": 0.07,
+ "Cyber_warfare": 0.10
+ },
+ "trade_tensions": {
+ "US-China": 0.30,
+ "US-EU": 0.15,
+ "China-EU": 0.15,
+ "US-Russia": 0.20,
+ "Brexit_aftermath": 0.10,
+ "USMCA_issues": 0.10
+ },
+ "sanctions_regime": {
+ "Russia_sanctions": 0.35,
+ "China_tech_sanctions": 0.25,
+ "Iran_sanctions": 0.15,
+ "North_Korea_sanctions": 0.10,
+ "Secondary_sanctions": 0.15
+ },
+ "political_instability": {
+ "US_domestic": 0.20,
+ "EU_integration": 0.18,
+ "China_internal": 0.15,
+ "Middle_East_regimes": 0.15,
+ "Latin_America": 0.12,
+ "Africa_coups": 0.10,
+ "Democratic_backsliding": 0.10
+ }
+ }
+
+ # Sector impact mapping from geopolitical events
+ self.sector_impact_map = {
+ "military_conflicts": {
+ "defense": 0.8,
+ "energy": 0.6,
+ "commodities": 0.7,
+ "technology": -0.3,
+ "tourism": -0.6,
+ "airlines": -0.5,
+ "insurance": -0.4
+ },
+ "trade_tensions": {
+ "technology": -0.7,
+ "manufacturing": -0.5,
+ "agriculture": -0.4,
+ "automotive": -0.6,
+ "semiconductors": -0.8,
+ "renewable_energy": 0.3
+ },
+ "sanctions_regime": {
+ "energy": -0.8,
+ "banking": -0.6,
+ "technology": -0.5,
+ "shipping": -0.4,
+ "commodities": 0.4,
+ "defense": 0.5
+ },
+ "political_instability": {
+ "healthcare": 0.2,
+ "utilities": 0.3,
+ "consumer_staples": 0.4,
+ "financials": -0.4,
+ "real_estate": -0.3,
+ "currency": -0.6
+ }
+ }
+
+ # Key geopolitical indicators to monitor
+ self.geopolitical_keywords = {
+ "conflict_escalation": [
+ "military buildup", "troop movements", "weapon shipments",
+ "border tensions", "missile tests", "naval exercises",
+ "air defense", "invasion", "occupation", "blockade"
+ ],
+ "diplomatic_tensions": [
+ "sanctions", "tariffs", "trade war", "diplomatic expulsion",
+ "embassy closure", "summit cancellation", "treaty withdrawal",
+ "alliance strain", "diplomatic protest"
+ ],
+ "regime_change": [
+ "coup", "revolution", "civil unrest", "protests",
+ "election fraud", "authoritarianism", "martial law",
+ "state of emergency", "government collapse"
+ ],
+ "economic_warfare": [
+ "currency manipulation", "debt trap", "supply chain disruption",
+ "critical minerals", "technology transfer", "intellectual property",
+ "cyber attacks", "financial warfare"
+ ]
+ }
+
+ # Regional risk weightings based on global economic impact
+ self.regional_weights = {
+ "North_America": 0.25,
+ "Europe": 0.20,
+ "East_Asia": 0.25,
+ "Middle_East": 0.15,
+ "South_America": 0.08,
+ "Africa": 0.05,
+ "South_Asia": 0.02
+ }
+
+ async def analyze_global_risks(self) -> List[GeopoliticalRisk]:
+ """Comprehensive global geopolitical risk analysis"""
+ risks = []
+
+ try:
+ # Analyze each risk category
+ for risk_category, risk_items in self.risk_factors.items():
+ category_risks = await self._analyze_risk_category(risk_category, risk_items)
+ risks.extend(category_risks)
+
+ # Sort by risk level and confidence
+ risks.sort(key=lambda x: x.current_level * x.confidence, reverse=True)
+
+ return risks[:10] # Return top 10 risks
+
+ except Exception as e:
+ logging.error(f"Error in global risk analysis: {e}")
+ return [self._default_geopolitical_risk()]
+
+ async def _analyze_risk_category(self, category: str, risk_items: Dict[str, float]) -> List[GeopoliticalRisk]:
+ """Analyze specific risk category"""
+ category_risks = []
+
+ # Get news data for this category
+ news_data = await self._fetch_category_news(category, list(risk_items.keys()))
+
+ for risk_item, weight in risk_items.items():
+ try:
+ # Filter news for this specific risk
+ relevant_news = [news for news in news_data
+ if self._is_relevant_to_risk(news, risk_item)]
+
+ # Calculate risk level
+ risk_level = self._calculate_risk_level(relevant_news, risk_item, category)
+
+ # Determine trend
+ trend = self._determine_risk_trend(relevant_news)
+
+ # Calculate probability and impact
+ prob_impact = self._calculate_probability_impact(risk_level, weight, relevant_news)
+
+ # Get affected sectors
+ affected_sectors = self._get_affected_sectors(category, risk_level)
+
+ # Generate timeline estimate
+ timeline = self._estimate_timeline(risk_level, trend, relevant_news)
+
+ # Get mitigation strategies
+ mitigation = self._get_mitigation_strategies(risk_item, category)
+
+ # Calculate confidence
+ confidence = self._calculate_risk_confidence(relevant_news, risk_item)
+
+ risk = GeopoliticalRisk(
+ region=self._get_region_from_risk(risk_item),
+ risk_type=category,
+ current_level=risk_level,
+ trend=trend,
+ probability_impact=prob_impact,
+ affected_sectors=affected_sectors,
+ timeline=timeline,
+ mitigation_strategies=mitigation,
+ confidence=confidence
+ )
+
+ category_risks.append(risk)
+
+ except Exception as e:
+ logging.error(f"Error analyzing {risk_item}: {e}")
+ continue
+
+ return category_risks
+
+ async def _fetch_category_news(self, category: str, risk_items: List[str]) -> List[DataPoint]:
+ """Fetch news data for specific risk category"""
+ all_news = []
+
+ # Create search queries for each risk item
+ queries = []
+ if category == "military_conflicts":
+ queries = ["military conflict", "war", "invasion", "missile", "defense"]
+ elif category == "trade_tensions":
+ queries = ["trade war", "tariffs", "sanctions", "trade dispute"]
+ elif category == "sanctions_regime":
+ queries = ["sanctions", "embargo", "trade restrictions"]
+ elif category == "political_instability":
+ queries = ["political crisis", "coup", "election", "protests"]
+
+ for query in queries:
+ try:
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": query,
+ "sources": ["reuters", "bloomberg", "wsj", "ft"],
+ "hours_back": 72 # 3 days
+ }
+ })
+
+ if "news" in news_data:
+ all_news.extend(news_data["news"])
+
+ except Exception as e:
+ logging.error(f"Error fetching news for {query}: {e}")
+ continue
+
+ return all_news
+
+ def _is_relevant_to_risk(self, news: DataPoint, risk_item: str) -> bool:
+ """Check if news article is relevant to specific risk"""
+ text = (news.value + " " + news.metadata.get("description", "")).lower()
+
+ # Create keywords for each risk item
+ risk_keywords = {
+ "Russia-Ukraine": ["russia", "ukraine", "putin", "zelensky", "kyiv", "moscow"],
+ "China-Taiwan": ["china", "taiwan", "beijing", "taipei", "strait", "xi jinping"],
+ "Middle_East": ["iran", "israel", "gaza", "lebanon", "syria", "yemen"],
+ "North_Korea": ["north korea", "kim jong", "pyongyang", "dprk"],
+ "US-China": ["us china", "trade war", "biden", "xi jinping", "tariff"],
+ "Russia_sanctions": ["russia sanctions", "swift", "energy embargo"],
+ "China_tech_sanctions": ["china tech", "semiconductor", "huawei", "tiktok"]
+ }
+
+ keywords = risk_keywords.get(risk_item, [risk_item.lower().replace("_", " ")])
+
+ return any(keyword in text for keyword in keywords)
+
+ def _calculate_risk_level(self, news: List[DataPoint], risk_item: str, category: str) -> int:
+ """Calculate current risk level (1-10 scale)"""
+ if not news:
+ return 3 # Default moderate risk
+
+ # Base risk levels for different risk items
+ base_risks = {
+ "Russia-Ukraine": 8,
+ "China-Taiwan": 6,
+ "Middle_East": 7,
+ "US-China": 5,
+ "North_Korea": 4
+ }
+
+ base_risk = base_risks.get(risk_item, 5)
+
+ # Analyze news sentiment and intensity
+ escalation_keywords = self.geopolitical_keywords.get("conflict_escalation", [])
+ tension_keywords = self.geopolitical_keywords.get("diplomatic_tensions", [])
+
+ escalation_count = 0
+ total_articles = len(news)
+
+ for article in news:
+ text = article.value.lower()
+ escalation_count += sum(1 for keyword in escalation_keywords if keyword in text)
+ escalation_count += sum(1 for keyword in tension_keywords if keyword in text)
+
+ # Adjust base risk based on recent news intensity
+ if total_articles > 0:
+ intensity_factor = min(escalation_count / total_articles, 2.0)
+ adjusted_risk = base_risk + intensity_factor
+ else:
+ adjusted_risk = base_risk
+
+ return int(np.clip(adjusted_risk, 1, 10))
+
+ def _determine_risk_trend(self, news: List[DataPoint]) -> str:
+ """Determine if risk is escalating, stable, or de-escalating"""
+ if len(news) < 2:
+ return "stable"
+
+ # Sort news by date
+ sorted_news = sorted(news, key=lambda x: x.timestamp)
+
+ # Compare recent vs older news intensity
+ midpoint = len(sorted_news) // 2
+ older_news = sorted_news[:midpoint]
+ recent_news = sorted_news[midpoint:]
+
+ older_intensity = self._calculate_news_intensity(older_news)
+ recent_intensity = self._calculate_news_intensity(recent_news)
+
+ if recent_intensity > older_intensity * 1.2:
+ return "escalating"
+ elif recent_intensity < older_intensity * 0.8:
+ return "de-escalating"
+ else:
+ return "stable"
+
+ def _calculate_news_intensity(self, news: List[DataPoint]) -> float:
+ """Calculate intensity score of news articles"""
+ if not news:
+ return 0.0
+
+ intensity_score = 0.0
+ escalation_keywords = (self.geopolitical_keywords.get("conflict_escalation", []) +
+ self.geopolitical_keywords.get("diplomatic_tensions", []))
+
+ for article in news:
+ text = article.value.lower()
+ keyword_count = sum(1 for keyword in escalation_keywords if keyword in text)
+ # Weight by article confidence
+ intensity_score += keyword_count * article.confidence
+
+ return intensity_score / len(news)
+
+ def _calculate_probability_impact(self, risk_level: int, weight: float,
+ news: List[DataPoint]) -> float:
+ """Calculate probability-weighted impact"""
+ # Convert risk level to probability (non-linear)
+ probability = (risk_level / 10) ** 1.5
+
+ # Weight by global economic impact
+ economic_impact = weight
+
+ # Adjust based on news recency and volume
+ if news:
+ avg_age_hours = np.mean([(datetime.now() - article.timestamp).total_seconds() / 3600
+ for article in news])
+ recency_factor = max(0.5, 1.0 - avg_age_hours / 168) # Decay over 1 week
+ volume_factor = min(1.5, len(news) / 10) # More news = higher impact
+ else:
+ recency_factor = 0.5
+ volume_factor = 0.5
+
+ return probability * economic_impact * recency_factor * volume_factor
+
+ def _get_affected_sectors(self, category: str, risk_level: int) -> List[str]:
+ """Get sectors most affected by this risk category"""
+ if category not in self.sector_impact_map:
+ return ["broad_market"]
+
+ sector_impacts = self.sector_impact_map[category]
+
+ # Filter sectors by risk level threshold and impact magnitude
+ threshold = 0.3 if risk_level > 7 else 0.4 if risk_level > 5 else 0.5
+
+ affected_sectors = []
+ for sector, impact in sector_impacts.items():
+ if abs(impact) >= threshold:
+ affected_sectors.append(sector)
+
+ return affected_sectors or ["broad_market"]
+
+ def _estimate_timeline(self, risk_level: int, trend: str, news: List[DataPoint]) -> str:
+ """Estimate timeline for risk materialization"""
+ base_timelines = {
+ "escalating": {
+ 9: "1-3 months",
+ 7: "3-6 months",
+ 5: "6-12 months",
+ 3: "1-2 years"
+ },
+ "stable": {
+ 9: "3-6 months",
+ 7: "6-12 months",
+ 5: "1-2 years",
+ 3: "2+ years"
+ },
+ "de-escalating": {
+ 9: "6-12 months",
+ 7: "1-2 years",
+ 5: "2+ years",
+ 3: "Low probability"
+ }
+ }
+
+ timeline_map = base_timelines.get(trend, base_timelines["stable"])
+
+ # Find closest risk level
+ for level in sorted(timeline_map.keys(), reverse=True):
+ if risk_level >= level:
+ return timeline_map[level]
+
+ return "2+ years"
+
+ def _get_mitigation_strategies(self, risk_item: str, category: str) -> List[str]:
+ """Get investment mitigation strategies for specific risks"""
+ strategies = {
+ "military_conflicts": [
+ "Increase defense sector allocation",
+ "Hedge energy exposure",
+ "Diversify geographically",
+ "Add gold/commodities hedge",
+ "Reduce emerging market exposure"
+ ],
+ "trade_tensions": [
+ "Avoid single-country exposure",
+ "Focus on domestic-oriented companies",
+ "Hedge currency exposure",
+ "Diversify supply chains",
+ "Consider trade-war beneficiaries"
+ ],
+ "sanctions_regime": [
+ "Avoid sanctioned sectors/countries",
+ "Increase compliance monitoring",
+ "Diversify banking relationships",
+ "Focus on domestic markets",
+ "Consider alternative payment systems"
+ ],
+ "political_instability": [
+ "Increase safe-haven assets",
+ "Reduce political-sensitive sectors",
+ "Focus on multinational companies",
+ "Add volatility hedges",
+ "Maintain higher cash levels"
+ ]
+ }
+
+ return strategies.get(category, ["Monitor closely", "Maintain diversification"])
+
+ def _get_region_from_risk(self, risk_item: str) -> str:
+ """Map risk item to geographical region"""
+ region_mapping = {
+ "Russia-Ukraine": "Europe",
+ "China-Taiwan": "East_Asia",
+ "Middle_East": "Middle_East",
+ "North_Korea": "East_Asia",
+ "US-China": "Global",
+ "US-EU": "North_America",
+ "Brexit": "Europe",
+ "India-Pakistan": "South_Asia"
+ }
+
+ return region_mapping.get(risk_item, "Global")
+
+ def _calculate_risk_confidence(self, news: List[DataPoint], risk_item: str) -> float:
+ """Calculate confidence in risk assessment"""
+ confidence_factors = []
+
+ # News volume factor
+ news_count = len(news)
+ volume_confidence = min(1.0, news_count / 20) # Optimal around 20 articles
+ confidence_factors.append(volume_confidence * 0.3)
+
+ # Source reliability
+ if news:
+ avg_source_confidence = np.mean([article.confidence for article in news])
+ confidence_factors.append(avg_source_confidence * 0.4)
+ else:
+ confidence_factors.append(0.3 * 0.4)
+
+ # News recency
+ if news:
+ most_recent = max(news, key=lambda x: x.timestamp)
+ hours_since = (datetime.now() - most_recent.timestamp).total_seconds() / 3600
+ recency_confidence = max(0.3, 1.0 - hours_since / 72) # Decay over 3 days
+ confidence_factors.append(recency_confidence * 0.3)
+ else:
+ confidence_factors.append(0.3 * 0.3)
+
+ return np.sum(confidence_factors)
+
+ async def analyze_conflict_escalation(self, conflict_name: str) -> ConflictSignal:
+ """Deep analysis of specific military conflict"""
+ try:
+ # Fetch conflict-specific news
+ conflict_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": conflict_name,
+ "sources": ["reuters", "bloomberg", "wsj"],
+ "hours_back": 48
+ }
+ })
+
+ news_data = conflict_news.get("news", [])
+
+ # Calculate escalation risk
+ escalation_risk = self._calculate_escalation_risk(news_data, conflict_name)
+
+ # Assess economic impact
+ economic_impact = self._assess_economic_impact(conflict_name, escalation_risk)
+
+ # Analyze supply chain risks
+ supply_chain_risk = self._analyze_supply_chain_impact(conflict_name)
+
+ # Get market sector impacts
+ market_sectors = self._get_market_sector_impacts(conflict_name, escalation_risk)
+
+ # Estimate duration
+ duration_estimate = self._estimate_conflict_duration(news_data, escalation_risk)
+
+ return ConflictSignal(
+ conflict_name=conflict_name,
+ escalation_risk=escalation_risk,
+ economic_impact=economic_impact,
+ supply_chain_risk=supply_chain_risk,
+ market_sectors=market_sectors,
+ duration_estimate=duration_estimate
+ )
+
+ except Exception as e:
+ logging.error(f"Error analyzing conflict {conflict_name}: {e}")
+ return self._default_conflict_signal(conflict_name)
+
+ def _calculate_escalation_risk(self, news: List[DataPoint], conflict_name: str) -> float:
+ """Calculate probability of conflict escalation"""
+ if not news:
+ return 0.3 # Default moderate risk
+
+ escalation_indicators = [
+ "military buildup", "troop deployment", "weapon delivery",
+ "alliance activation", "nuclear threat", "red line crossed",
+ "ultimatum", "deadline", "mobilization", "intervention"
+ ]
+
+ escalation_score = 0.0
+
+ for article in news:
+ text = article.value.lower()
+ indicator_count = sum(1 for indicator in escalation_indicators if indicator in text)
+ escalation_score += indicator_count * article.confidence
+
+ # Normalize by number of articles
+ if news:
+ normalized_score = escalation_score / len(news)
+ # Convert to probability (0-1)
+ return min(1.0, normalized_score / 3.0) # Scale factor
+
+ return 0.3
+
+ def _assess_economic_impact(self, conflict_name: str, escalation_risk: float) -> Dict[str, float]:
+ """Assess economic impact of conflict escalation"""
+ # Base economic impacts by conflict
+ base_impacts = {
+ "Russia-Ukraine": {
+ "global_gdp": -0.8,
+ "inflation": 2.5,
+ "energy_prices": 0.4,
+ "food_prices": 0.3,
+ "supply_chains": -0.6
+ },
+ "China-Taiwan": {
+ "global_gdp": -2.5,
+ "inflation": 1.8,
+ "tech_supply": -0.8,
+ "shipping": -0.7,
+ "semiconductors": -0.9
+ },
+ "Middle_East": {
+ "global_gdp": -0.5,
+ "oil_prices": 0.6,
+ "shipping": -0.4,
+ "regional_markets": -0.8,
+ "defense_spending": 0.3
+ }
+ }
+
+ base_impact = base_impacts.get(conflict_name, {
+ "global_gdp": -0.3,
+ "inflation": 1.0,
+ "volatility": 0.5
+ })
+
+ # Scale by escalation risk
+ scaled_impact = {}
+ for key, value in base_impact.items():
+ scaled_impact[key] = value * escalation_risk
+
+ return scaled_impact
+
+ def _analyze_supply_chain_impact(self, conflict_name: str) -> Dict[str, float]:
+ """Analyze supply chain disruption risks"""
+ supply_chain_risks = {
+ "Russia-Ukraine": {
+ "energy": 0.8,
+ "fertilizers": 0.7,
+ "grains": 0.6,
+ "metals": 0.5,
+ "semiconductors": 0.3
+ },
+ "China-Taiwan": {
+ "semiconductors": 0.9,
+ "electronics": 0.8,
+ "rare_earths": 0.7,
+ "shipping": 0.6,
+ "manufacturing": 0.7
+ },
+ "Middle_East": {
+ "oil": 0.9,
+ "gas": 0.7,
+ "shipping": 0.6,
+ "petrochemicals": 0.5
+ }
+ }
+
+ return supply_chain_risks.get(conflict_name, {"general": 0.4})
+
+ def _get_market_sector_impacts(self, conflict_name: str, escalation_risk: float) -> Dict[str, float]:
+ """Get sector-specific market impacts"""
+ sector_impacts = {
+ "Russia-Ukraine": {
+ "energy": 0.6,
+ "defense": 0.8,
+ "agriculture": 0.4,
+ "technology": -0.3,
+ "airlines": -0.6,
+ "tourism": -0.7
+ },
+ "China-Taiwan": {
+ "semiconductors": -0.9,
+ "technology": -0.7,
+ "defense": 0.8,
+ "shipping": -0.6,
+ "manufacturing": -0.5,
+ "commodities": 0.3
+ },
+ "Middle_East": {
+ "energy": 0.8,
+ "defense": 0.6,
+ "airlines": -0.5,
+ "insurance": -0.4,
+ "shipping": -0.3
+ }
+ }
+
+ base_impacts = sector_impacts.get(conflict_name, {"broad_market": -0.2})
+
+ # Scale by escalation risk
+ scaled_impacts = {}
+ for sector, impact in base_impacts.items():
+ scaled_impacts[sector] = impact * escalation_risk
+
+ return scaled_impacts
+
+ def _estimate_conflict_duration(self, news: List[DataPoint], escalation_risk: float) -> str:
+ """Estimate conflict duration based on escalation risk"""
+ if escalation_risk > 0.8:
+ return "6+ months (high intensity)"
+ elif escalation_risk > 0.6:
+ return "3-12 months (prolonged)"
+ elif escalation_risk > 0.4:
+ return "1-6 months (limited)"
+ else:
+ return "Weeks to months (contained)"
+
+ def _default_geopolitical_risk(self) -> GeopoliticalRisk:
+ """Return default risk in case of errors"""
+ return GeopoliticalRisk(
+ region="Global",
+ risk_type="general_uncertainty",
+ current_level=5,
+ trend="stable",
+ probability_impact=0.3,
+ affected_sectors=["broad_market"],
+ timeline="6-12 months",
+ mitigation_strategies=["Maintain diversification", "Monitor developments"],
+ confidence=0.3
+ )
+
+ def _default_conflict_signal(self, conflict_name: str) -> ConflictSignal:
+ """Return default conflict signal"""
+ return ConflictSignal(
+ conflict_name=conflict_name,
+ escalation_risk=0.3,
+ economic_impact={"global_gdp": -0.1},
+ supply_chain_risk={"general": 0.2},
+ market_sectors={"broad_market": -0.1},
+ duration_estimate="Unknown"
+ )
+
+ async def generate_llm_geopolitical_analysis(self, risks: List[GeopoliticalRisk]) -> Dict:
+ """Generate LLM-enhanced geopolitical analysis"""
+ try:
+ # Prepare risk summary
+ risk_summary = self._prepare_risk_summary(risks)
+
+ prompt = f"""
+ As a senior geopolitical risk analyst, analyze the current global risk landscape and provide investment guidance.
+
+ Current Top Risks:
+ {risk_summary}
+
+ Please provide:
+ 1. Most critical risks requiring immediate attention
+ 2. Potential black swan scenarios (low probability, high impact)
+ 3. Portfolio hedging strategies
+ 4. Regional allocation recommendations
+ 5. Timeline for next major geopolitical shift
+ 6. Early warning indicators to monitor
+
+ Format as JSON with keys: critical_risks, black_swan_scenarios, hedging_strategies,
+ regional_allocation, timeline, early_warning_indicators
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM geopolitical analysis: {e}")
+ return {
+ "critical_risks": ["Russia-Ukraine conflict", "US-China tensions"],
+ "black_swan_scenarios": ["Taiwan invasion", "Nuclear incident"],
+ "hedging_strategies": ["Increase defense allocation", "Add gold hedge"],
+ "regional_allocation": "Underweight emerging markets",
+ "timeline": "Next 6-12 months",
+ "early_warning_indicators": ["Troop movements", "Diplomatic withdrawals"]
+ }
+
+ def _prepare_risk_summary(self, risks: List[GeopoliticalRisk]) -> str:
+ """Prepare risk summary for LLM analysis"""
+ summary_lines = []
+
+ for risk in risks[:5]: # Top 5 risks
+ summary_lines.append(
+ f"{risk.region} - {risk.risk_type}: Level {risk.current_level}/10 "
+ f"({risk.trend}), Impact: {risk.probability_impact:.2f}, "
+ f"Sectors: {', '.join(risk.affected_sectors[:3])}"
+ )
+
+ return "\n".join(summary_lines)
+
+ async def get_geopolitical_report(self) -> Dict:
+ """Generate comprehensive geopolitical risk report"""
+ # Analyze global risks
+ global_risks = await self.analyze_global_risks()
+
+ # Analyze specific conflicts
+ conflicts = ["Russia-Ukraine", "China-Taiwan", "Middle_East"]
+ conflict_analyses = []
+
+ for conflict in conflicts:
+ signal = await self.analyze_conflict_escalation(conflict)
+ conflict_analyses.append({
+ "conflict": conflict,
+ "escalation_risk": signal.escalation_risk,
+ "economic_impact": signal.economic_impact,
+ "duration_estimate": signal.duration_estimate
+ })
+
+ # Generate LLM analysis
+ llm_analysis = await self.generate_llm_geopolitical_analysis(global_risks)
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "global_risk_assessment": {
+ "overall_risk_level": np.mean([risk.current_level for risk in global_risks]),
+ "top_risks": [{
+ "region": risk.region,
+ "type": risk.risk_type,
+ "level": risk.current_level,
+ "trend": risk.trend,
+ "timeline": risk.timeline,
+ "affected_sectors": risk.affected_sectors
+ } for risk in global_risks[:5]]
+ },
+ "conflict_monitor": conflict_analyses,
+ "investment_implications": {
+ "defensive_positioning": self._calculate_defensive_score(global_risks),
+ "sector_rotation": self._get_sector_rotation_recommendations(global_risks),
+ "regional_weights": self._get_regional_weight_adjustments(global_risks),
+ "hedging_requirements": self._get_hedging_requirements(global_risks)
+ },
+ "llm_analysis": llm_analysis,
+ "risk_monitoring": {
+ "update_frequency": "every 6 hours",
+ "key_indicators": ["news_flow", "market_volatility", "diplomatic_activity"],
+ "escalation_triggers": ["military_movement", "sanctions_announcement", "alliance_activation"]
+ }
+ }
+
+ def _calculate_defensive_score(self, risks: List[GeopoliticalRisk]) -> float:
+ """Calculate how defensive portfolio should be"""
+ high_risk_count = sum(1 for risk in risks if risk.current_level >= 7)
+ escalating_risks = sum(1 for risk in risks if risk.trend == "escalating")
+
+ defensive_score = (high_risk_count * 0.15 + escalating_risks * 0.10)
+ return min(1.0, defensive_score)
+
+ def _get_sector_rotation_recommendations(self, risks: List[GeopoliticalRisk]) -> Dict[str, str]:
+ """Get sector rotation based on geopolitical risks"""
+ sector_scores = defaultdict(float)
+
+ for risk in risks:
+ weight = risk.current_level * risk.confidence / 10
+ for sector in risk.affected_sectors:
+ if sector in self.sector_impact_map.get(risk.risk_type, {}):
+ impact = self.sector_impact_map[risk.risk_type][sector]
+ sector_scores[sector] += impact * weight
+
+ recommendations = {}
+ for sector, score in sector_scores.items():
+ if score > 0.2:
+ recommendations[sector] = "overweight"
+ elif score < -0.2:
+ recommendations[sector] = "underweight"
+ else:
+ recommendations[sector] = "neutral"
+
+ return recommendations
+
+ def _get_regional_weight_adjustments(self, risks: List[GeopoliticalRisk]) -> Dict[str, float]:
+ """Get regional allocation adjustments"""
+ regional_adjustments = {}
+
+ for region, base_weight in self.regional_weights.items():
+ region_risks = [risk for risk in risks if risk.region == region]
+
+ if region_risks:
+ avg_risk = np.mean([risk.current_level for risk in region_risks])
+ # Reduce allocation for high-risk regions
+ adjustment = max(-0.5, (5 - avg_risk) / 10)
+ regional_adjustments[region] = base_weight * (1 + adjustment)
+ else:
+ regional_adjustments[region] = base_weight
+
+ # Normalize to sum to 1
+ total_weight = sum(regional_adjustments.values())
+ return {region: weight / total_weight for region, weight in regional_adjustments.items()}
+
+ def _get_hedging_requirements(self, risks: List[GeopoliticalRisk]) -> List[str]:
+ """Get specific hedging requirements"""
+ hedges = []
+
+ high_risks = [risk for risk in risks if risk.current_level >= 7]
+
+ for risk in high_risks:
+ if "energy" in risk.affected_sectors:
+ hedges.append("Energy price hedge")
+ if "technology" in risk.affected_sectors:
+ hedges.append("Tech sector put options")
+ if "currency" in risk.affected_sectors:
+ hedges.append("USD strength hedge")
+ if risk.risk_type == "military_conflicts":
+ hedges.append("Gold allocation increase")
+ hedges.append("Defense sector exposure")
+
+ return list(set(hedges)) # Remove duplicates
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.py
new file mode 100644
index 000000000..4781bc9e5
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/innovation_agent.py
@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+# agents/innovation_agent.py - Technology Innovation Cycle Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+import logging
+from dataclasses import dataclass
+import openai
+import json
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class InnovationSignal:
+ """Technology innovation signal"""
+ technology_sector: str
+ adoption_stage: str # emerging, growth, maturity, decline
+ disruption_potential: float # 0-1
+ investment_opportunity: str
+ time_horizon: str
+ confidence: float
+
+
+class InnovationAgent:
+ """Technology innovation cycle analysis and investment opportunities"""
+
+ def __init__(self):
+ self.name = "innovation"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ self.innovation_sectors = {
+ "artificial_intelligence": {"weight": 0.25, "maturity": "growth"},
+ "quantum_computing": {"weight": 0.15, "maturity": "emerging"},
+ "biotechnology": {"weight": 0.20, "maturity": "growth"},
+ "renewable_energy": {"weight": 0.15, "maturity": "maturity"},
+ "space_technology": {"weight": 0.10, "maturity": "emerging"},
+ "robotics": {"weight": 0.15, "maturity": "growth"}
+ }
+
+ async def analyze_innovation_cycles(self) -> List[InnovationSignal]:
+ """Analyze technology innovation cycles"""
+ signals = []
+
+ for sector, config in self.innovation_sectors.items():
+ try:
+ signal = await self._analyze_sector_innovation(sector, config)
+ if signal:
+ signals.append(signal)
+ except Exception as e:
+ logging.error(f"Error analyzing {sector}: {e}")
+ continue
+
+ return signals
+
+ async def _analyze_sector_innovation(self, sector: str, config: Dict) -> Optional[InnovationSignal]:
+ """Analyze innovation in specific technology sector"""
+ # Fetch innovation news
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": sector.replace("_", " ") + " breakthrough innovation",
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 168
+ }
+ })
+
+ news = news_data.get("news", [])
+
+ # Calculate innovation metrics
+ breakthrough_count = sum(1 for article in news
+ if any(word in article.value.lower()
+ for word in ["breakthrough", "revolutionary", "first-of-kind"]))
+
+ funding_mentions = sum(1 for article in news
+ if any(word in article.value.lower()
+ for word in ["funding", "investment", "IPO", "acquisition"]))
+
+ # Determine adoption stage and disruption potential
+ if news:
+ disruption_potential = min((breakthrough_count + funding_mentions) / len(news), 1.0)
+ else:
+ disruption_potential = 0.3
+
+ adoption_stage = config["maturity"]
+ investment_opportunity = self._determine_investment_opportunity(disruption_potential, adoption_stage)
+
+ return InnovationSignal(
+ technology_sector=sector,
+ adoption_stage=adoption_stage,
+ disruption_potential=disruption_potential,
+ investment_opportunity=investment_opportunity,
+ time_horizon=self._estimate_time_horizon(adoption_stage),
+ confidence=min(len(news) / 10, 1.0) * 0.7
+ )
+
+ def _determine_investment_opportunity(self, disruption_potential: float, stage: str) -> str:
+ """Determine investment opportunity classification"""
+ if disruption_potential > 0.7 and stage == "emerging":
+ return "high_risk_high_reward"
+ elif disruption_potential > 0.5 and stage == "growth":
+ return "growth_opportunity"
+ elif disruption_potential > 0.3 and stage == "maturity":
+ return "value_opportunity"
+ else:
+ return "monitor"
+
+ def _estimate_time_horizon(self, stage: str) -> str:
+ """Estimate investment time horizon"""
+ horizon_map = {
+ "emerging": "long_term",
+ "growth": "medium_term",
+ "maturity": "short_term",
+ "decline": "avoid"
+ }
+ return horizon_map.get(stage, "medium_term")
+
+ async def get_innovation_report(self) -> Dict:
+ """Generate innovation analysis report"""
+ signals = await self.analyze_innovation_cycles()
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "innovation_analysis": {
+ "sector_signals": [{
+ "sector": signal.technology_sector,
+ "stage": signal.adoption_stage,
+ "disruption_potential": signal.disruption_potential,
+ "opportunity": signal.investment_opportunity,
+ "time_horizon": signal.time_horizon
+ } for signal in signals],
+ "top_opportunities": [s.technology_sector for s in signals
+ if s.investment_opportunity == "high_risk_high_reward"],
+ "emerging_technologies": [s.technology_sector for s in signals
+ if s.adoption_stage == "emerging"]
+ }
+ }
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.py
new file mode 100644
index 000000000..7d0211d78
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/institutional_flow_agent.py
@@ -0,0 +1,1133 @@
+# -*- coding: utf-8 -*-
+# agents/institutional_flow_agent.py - Institutional Flow Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+from collections import defaultdict
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class FlowSignal:
+ """Institutional flow signal structure"""
+ institution_type: str
+ flow_direction: str # inflow, outflow, neutral
+ flow_magnitude: float # 0-1 scale
+ asset_class: str
+ time_horizon: str
+ confidence: float
+ contrarian_signal: bool
+ flow_velocity: float # Rate of change
+
+
+@dataclass
+class SmartMoneyIndicator:
+ """Smart money flow indicator"""
+ indicator_name: str
+ current_reading: float
+ historical_percentile: float
+ signal_strength: str # weak, moderate, strong
+ market_implication: str
+ asset_impact: Dict[str, float]
+
+
+class InstitutionalFlowAgent:
+ """Advanced institutional flow analysis and smart money tracking"""
+
+ def __init__(self):
+ self.name = "institutional_flow"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Institution types and their market influence weights
+ self.institution_weights = {
+ "pension_funds": 0.25, # Long-term, stable flows
+ "sovereign_wealth": 0.20, # Large size, strategic
+ "hedge_funds": 0.15, # Fast moving, trend setting
+ "mutual_funds": 0.15, # Retail proxy, momentum
+ "insurance_companies": 0.10, # Defensive, liability matching
+ "endowments": 0.08, # Sophisticated, alternative focus
+ "central_banks": 0.07 # Policy driven, FX focused
+ }
+
+ # Asset class flow patterns
+ self.flow_patterns = {
+ "risk_on": {
+ "equities": 0.7,
+ "high_yield_bonds": 0.4,
+ "emerging_markets": 0.6,
+ "commodities": 0.3,
+ "real_estate": 0.4,
+ "alternatives": 0.5
+ },
+ "risk_off": {
+ "government_bonds": 0.8,
+ "investment_grade_bonds": 0.6,
+ "cash": 0.9,
+ "gold": 0.7,
+ "defensive_sectors": 0.5,
+ "low_volatility": 0.6
+ },
+ "rotation": {
+ "value_to_growth": {"value": 0.6, "growth": -0.4},
+ "large_to_small": {"large_cap": -0.3, "small_cap": 0.6},
+ "domestic_to_international": {"domestic": -0.2, "international": 0.5}
+ }
+ }
+
+ # Smart money indicators
+ self.smart_money_indicators = {
+ "13f_filings": {
+ "weight": 0.25,
+ "lookback_quarters": 4,
+ "significance_threshold": 0.02 # 2% position change
+ },
+ "insider_trading": {
+ "weight": 0.20,
+ "lookback_days": 90,
+ "significance_threshold": 0.05 # 5% of shares
+ },
+ "options_flow": {
+ "weight": 0.15,
+ "lookback_days": 5,
+ "significance_threshold": 2.0 # 2x normal volume
+ },
+ "dark_pool_activity": {
+ "weight": 0.15,
+ "lookback_days": 10,
+ "significance_threshold": 0.4 # 40% of volume
+ },
+ "repo_market": {
+ "weight": 0.10,
+ "lookback_days": 30,
+ "significance_threshold": 0.1 # 10 bps change
+ },
+ "etf_flows": {
+ "weight": 0.15,
+ "lookback_days": 20,
+ "significance_threshold": 0.03 # 3% of AUM
+ }
+ }
+
+ # Flow velocity thresholds
+ self.velocity_thresholds = {
+ "extremely_fast": 0.8, # >80th percentile
+ "fast": 0.6, # >60th percentile
+ "moderate": 0.4, # >40th percentile
+ "slow": 0.2, # >20th percentile
+ "very_slow": 0.0 # <20th percentile
+ }
+
+ async def analyze_institutional_flows(self) -> Dict[str, FlowSignal]:
+ """Comprehensive institutional flow analysis"""
+ flow_signals = {}
+
+ try:
+ # Analyze equity flows
+ equity_flows = await self._analyze_equity_flows()
+ if equity_flows:
+ flow_signals["equity_flows"] = equity_flows
+
+ # Analyze bond flows
+ bond_flows = await self._analyze_bond_flows()
+ if bond_flows:
+ flow_signals["bond_flows"] = bond_flows
+
+ # Analyze ETF flows
+ etf_flows = await self._analyze_etf_flows()
+ if etf_flows:
+ flow_signals["etf_flows"] = etf_flows
+
+ # Analyze alternative investment flows
+ alternative_flows = await self._analyze_alternative_flows()
+ if alternative_flows:
+ flow_signals["alternative_flows"] = alternative_flows
+
+ return flow_signals
+
+ except Exception as e:
+ logging.error(f"Error in institutional flow analysis: {e}")
+ return {"error": self._default_flow_signal()}
+
+ async def _analyze_equity_flows(self) -> Optional[FlowSignal]:
+ """Analyze institutional equity flows"""
+ try:
+ # Fetch institutional trading data
+ institutional_data = await self.data_manager.get_multi_source_data({
+ "market": {
+ "symbol": "SPY", # Use SPY as proxy for overall equity flows
+ "data_type": "institutional"
+ }
+ })
+
+ market_data = institutional_data.get("market", [])
+ if not market_data:
+ return None
+
+ # Calculate flow metrics
+ flow_direction, flow_magnitude = self._calculate_flow_metrics(market_data)
+
+ # Calculate flow velocity
+ flow_velocity = self._calculate_flow_velocity(market_data)
+
+ # Determine if contrarian signal
+ contrarian_signal = self._is_contrarian_flow(flow_magnitude, flow_velocity)
+
+ # Calculate confidence based on data quality
+ confidence = self._calculate_flow_confidence(market_data)
+
+ return FlowSignal(
+ institution_type="mixed_institutions",
+ flow_direction=flow_direction,
+ flow_magnitude=flow_magnitude,
+ asset_class="equities",
+ time_horizon="medium",
+ confidence=confidence,
+ contrarian_signal=contrarian_signal,
+ flow_velocity=flow_velocity
+ )
+
+ except Exception as e:
+ logging.error(f"Error in equity flow analysis: {e}")
+ return None
+
+ async def _analyze_bond_flows(self) -> Optional[FlowSignal]:
+ """Analyze institutional bond flows"""
+ try:
+ # Fetch bond flow data (using treasury ETF as proxy)
+ bond_data = await self.data_manager.get_multi_source_data({
+ "market": {
+ "symbol": "TLT", # Long-term treasury ETF
+ "data_type": "institutional"
+ }
+ })
+
+ market_data = bond_data.get("market", [])
+ if not market_data:
+ # Simulate bond flows based on yield movements
+ return self._simulate_bond_flows()
+
+ flow_direction, flow_magnitude = self._calculate_flow_metrics(market_data)
+ flow_velocity = self._calculate_flow_velocity(market_data)
+
+ return FlowSignal(
+ institution_type="fixed_income_institutions",
+ flow_direction=flow_direction,
+ flow_magnitude=flow_magnitude,
+ asset_class="bonds",
+ time_horizon="long",
+ confidence=0.7,
+ contrarian_signal=False, # Bond flows typically not contrarian
+ flow_velocity=flow_velocity
+ )
+
+ except Exception as e:
+ logging.error(f"Error in bond flow analysis: {e}")
+ return None
+
+ def _simulate_bond_flows(self) -> FlowSignal:
+ """Simulate bond flows when data unavailable"""
+ # Simulate based on typical institutional behavior
+ flow_magnitude = np.random.uniform(0.3, 0.7)
+ flow_direction = np.random.choice(["inflow", "outflow"], p=[0.6, 0.4])
+
+ return FlowSignal(
+ institution_type="fixed_income_institutions",
+ flow_direction=flow_direction,
+ flow_magnitude=flow_magnitude,
+ asset_class="bonds",
+ time_horizon="long",
+ confidence=0.5, # Lower confidence for simulated data
+ contrarian_signal=False,
+ flow_velocity=0.3
+ )
+
+ async def _analyze_etf_flows(self) -> Optional[FlowSignal]:
+ """Analyze ETF flows as proxy for institutional sentiment"""
+ try:
+ # Major ETF flows to analyze
+ etfs_to_analyze = ["SPY", "QQQ", "IWM", "EFA", "EEM", "TLT", "GLD"]
+
+ etf_flows = {}
+ for etf in etfs_to_analyze:
+ # In production, would fetch actual ETF flow data
+ # For now, simulate based on market conditions
+ flow_data = self._simulate_etf_flow(etf)
+ etf_flows[etf] = flow_data
+
+ # Aggregate ETF flows
+ total_inflows = sum(flow["inflow"] for flow in etf_flows.values())
+ total_outflows = sum(flow["outflow"] for flow in etf_flows.values())
+
+ net_flow = total_inflows - total_outflows
+ flow_magnitude = min(abs(net_flow) / (total_inflows + total_outflows), 1.0)
+ flow_direction = "inflow" if net_flow > 0 else "outflow"
+
+ # Calculate flow velocity from ETF data
+ flow_velocity = np.mean([flow["velocity"] for flow in etf_flows.values()])
+
+ return FlowSignal(
+ institution_type="etf_participants",
+ flow_direction=flow_direction,
+ flow_magnitude=flow_magnitude,
+ asset_class="broad_market",
+ time_horizon="short",
+ confidence=0.8, # ETF flows are reliable indicators
+ contrarian_signal=flow_magnitude > 0.7, # Extreme flows can be contrarian
+ flow_velocity=flow_velocity
+ )
+
+ except Exception as e:
+ logging.error(f"Error in ETF flow analysis: {e}")
+ return None
+
+ def _simulate_etf_flow(self, etf_symbol: str) -> Dict[str, float]:
+ """Simulate ETF flow data"""
+ # Base flows by ETF type
+ base_flows = {
+ "SPY": {"inflow": 0.6, "outflow": 0.4}, # Large cap bias
+ "QQQ": {"inflow": 0.7, "outflow": 0.3}, # Tech growth bias
+ "IWM": {"inflow": 0.4, "outflow": 0.6}, # Small cap outflows
+ "EFA": {"inflow": 0.3, "outflow": 0.7}, # International outflows
+ "EEM": {"inflow": 0.2, "outflow": 0.8}, # EM outflows
+ "TLT": {"inflow": 0.5, "outflow": 0.5}, # Neutral bonds
+ "GLD": {"inflow": 0.4, "outflow": 0.6} # Gold outflows
+ }
+
+ base = base_flows.get(etf_symbol, {"inflow": 0.5, "outflow": 0.5})
+
+ # Add random variation
+ noise = np.random.normal(0, 0.1)
+ inflow = np.clip(base["inflow"] + noise, 0, 1)
+ outflow = np.clip(base["outflow"] - noise, 0, 1)
+
+ # Normalize
+ total = inflow + outflow
+ inflow /= total
+ outflow /= total
+
+ velocity = np.random.uniform(0.2, 0.8)
+
+ return {"inflow": inflow, "outflow": outflow, "velocity": velocity}
+
+ async def _analyze_alternative_flows(self) -> Optional[FlowSignal]:
+ """Analyze flows into alternative investments"""
+ try:
+ # Alternatives include private equity, hedge funds, real estate, commodities
+ # Simulate based on market conditions and typical allocation patterns
+
+ # Institutional allocation to alternatives typically 10-30%
+ base_allocation = 0.2 # 20% baseline
+
+ # Factors affecting alternative flows
+ market_stress = np.random.uniform(0, 1) # Would be calculated from VIX, spreads
+ yield_environment = np.random.uniform(0, 1) # Low yields favor alternatives
+
+ # Calculate flow direction
+ alternative_attractiveness = (market_stress * 0.3 + yield_environment * 0.7)
+
+ if alternative_attractiveness > 0.6:
+ flow_direction = "inflow"
+ flow_magnitude = (alternative_attractiveness - 0.6) / 0.4
+ elif alternative_attractiveness < 0.4:
+ flow_direction = "outflow"
+ flow_magnitude = (0.4 - alternative_attractiveness) / 0.4
+ else:
+ flow_direction = "neutral"
+ flow_magnitude = 0.1
+
+ return FlowSignal(
+ institution_type="sophisticated_institutions",
+ flow_direction=flow_direction,
+ flow_magnitude=flow_magnitude,
+ asset_class="alternatives",
+ time_horizon="long",
+ confidence=0.6,
+ contrarian_signal=False, # Alternative flows are strategic, not contrarian
+ flow_velocity=0.2 # Alternatives move slowly
+ )
+
+ except Exception as e:
+ logging.error(f"Error in alternative flow analysis: {e}")
+ return None
+
+ def _calculate_flow_metrics(self, market_data: List[DataPoint]) -> Tuple[str, float]:
+ """Calculate flow direction and magnitude from market data"""
+ if not market_data:
+ return "neutral", 0.1
+
+ # Calculate net institutional flow from position changes
+ position_changes = []
+ for data_point in market_data:
+ change = data_point.value
+ position_changes.append(change)
+
+ if position_changes:
+ net_flow = np.sum(position_changes)
+ total_flow = np.sum(np.abs(position_changes))
+
+ if total_flow > 0:
+ flow_magnitude = min(abs(net_flow) / total_flow, 1.0)
+ flow_direction = "inflow" if net_flow > 0 else "outflow"
+ else:
+ flow_magnitude = 0.1
+ flow_direction = "neutral"
+ else:
+ flow_magnitude = 0.1
+ flow_direction = "neutral"
+
+ return flow_direction, flow_magnitude
+
+ def _calculate_flow_velocity(self, market_data: List[DataPoint]) -> float:
+ """Calculate velocity of institutional flows"""
+ if len(market_data) < 2:
+ return 0.3
+
+ # Sort by timestamp
+ sorted_data = sorted(market_data, key=lambda x: x.timestamp)
+
+ # Calculate rate of change
+ velocities = []
+ for i in range(1, len(sorted_data)):
+ time_diff = (sorted_data[i].timestamp - sorted_data[i - 1].timestamp).days
+ value_diff = abs(sorted_data[i].value - sorted_data[i - 1].value)
+
+ if time_diff > 0:
+ velocity = value_diff / time_diff
+ velocities.append(velocity)
+
+ if velocities:
+ avg_velocity = np.mean(velocities)
+ # Normalize to 0-1 scale
+ normalized_velocity = min(avg_velocity / 0.1, 1.0) # 0.1 as normalization factor
+ return normalized_velocity
+
+ return 0.3
+
+ def _is_contrarian_flow(self, flow_magnitude: float, flow_velocity: float) -> bool:
+ """Determine if flow represents contrarian opportunity"""
+ # High magnitude + high velocity often indicates emotional/momentum driven flows
+ # which can be contrarian signals
+
+ extreme_magnitude = flow_magnitude > 0.7
+ high_velocity = flow_velocity > 0.6
+
+ return extreme_magnitude and high_velocity
+
+ def _calculate_flow_confidence(self, market_data: List[DataPoint]) -> float:
+ """Calculate confidence in flow analysis"""
+ if not market_data:
+ return 0.3
+
+ # Factors affecting confidence
+ data_points = len(market_data)
+ data_quality = np.mean([dp.confidence for dp in market_data])
+ data_recency = self._calculate_data_recency(market_data)
+
+ # Combine factors
+ volume_confidence = min(data_points / 20, 1.0) * 0.4 # Optimal ~20 data points
+ quality_confidence = data_quality * 0.4
+ recency_confidence = data_recency * 0.2
+
+ return volume_confidence + quality_confidence + recency_confidence
+
+ def _calculate_data_recency(self, market_data: List[DataPoint]) -> float:
+ """Calculate how recent the data is"""
+ if not market_data:
+ return 0.1
+
+ most_recent = max(market_data, key=lambda x: x.timestamp)
+ hours_since = (datetime.now() - most_recent.timestamp).total_seconds() / 3600
+
+ # Decay over 48 hours
+ recency_score = max(0.1, 1.0 - hours_since / 48)
+ return recency_score
+
+ def _default_flow_signal(self) -> FlowSignal:
+ """Return default flow signal"""
+ return FlowSignal(
+ institution_type="unknown",
+ flow_direction="neutral",
+ flow_magnitude=0.3,
+ asset_class="broad_market",
+ time_horizon="medium",
+ confidence=0.2,
+ contrarian_signal=False,
+ flow_velocity=0.3
+ )
+
+ async def analyze_smart_money_indicators(self) -> List[SmartMoneyIndicator]:
+ """Analyze various smart money flow indicators"""
+ indicators = []
+
+ try:
+ for indicator_name, config in self.smart_money_indicators.items():
+ indicator = await self._analyze_specific_indicator(indicator_name, config)
+ if indicator:
+ indicators.append(indicator)
+
+ return indicators
+
+ except Exception as e:
+ logging.error(f"Error in smart money analysis: {e}")
+ return []
+
+ async def _analyze_specific_indicator(self, indicator_name: str,
+ config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze specific smart money indicator"""
+ try:
+ if indicator_name == "13f_filings":
+ return await self._analyze_13f_filings(config)
+ elif indicator_name == "insider_trading":
+ return await self._analyze_insider_trading(config)
+ elif indicator_name == "options_flow":
+ return await self._analyze_options_flow(config)
+ elif indicator_name == "dark_pool_activity":
+ return await self._analyze_dark_pool_activity(config)
+ elif indicator_name == "repo_market":
+ return await self._analyze_repo_market(config)
+ elif indicator_name == "etf_flows":
+ return await self._analyze_etf_smart_money(config)
+ else:
+ return None
+
+ except Exception as e:
+ logging.error(f"Error analyzing {indicator_name}: {e}")
+ return None
+
+ async def _analyze_13f_filings(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze 13F filings for institutional position changes"""
+ try:
+ # Fetch institutional holdings data
+ institutional_data = await self.data_manager.get_multi_source_data({
+ "market": {
+ "symbol": "SPY", # Use broad market as proxy
+ "data_type": "institutional"
+ }
+ })
+
+ holdings_data = institutional_data.get("market", [])
+ if not holdings_data:
+ # Simulate 13F analysis
+ return self._simulate_13f_indicator()
+
+ # Calculate position changes
+ position_changes = [dp.value for dp in holdings_data]
+
+ if position_changes:
+ current_reading = np.mean(position_changes)
+ historical_percentile = self._calculate_percentile(current_reading, position_changes)
+
+ # Determine signal strength
+ if abs(current_reading) > config["significance_threshold"]:
+ signal_strength = "strong"
+ elif abs(current_reading) > config["significance_threshold"] / 2:
+ signal_strength = "moderate"
+ else:
+ signal_strength = "weak"
+
+ # Market implication
+ if current_reading > 0.02:
+ market_implication = "Institutional accumulation - bullish signal"
+ elif current_reading < -0.02:
+ market_implication = "Institutional distribution - bearish signal"
+ else:
+ market_implication = "Neutral institutional positioning"
+
+ return SmartMoneyIndicator(
+ indicator_name="13f_filings",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"equities": current_reading * 2} # Amplify for asset impact
+ )
+
+ except Exception as e:
+ logging.error(f"Error in 13F analysis: {e}")
+
+ return None
+
+ def _simulate_13f_indicator(self) -> SmartMoneyIndicator:
+ """Simulate 13F indicator when data unavailable"""
+ # Simulate typical institutional behavior
+ current_reading = np.random.normal(0.01, 0.02) # Slight bullish bias
+ historical_percentile = np.random.uniform(0.3, 0.7)
+
+ signal_strength = "moderate" if abs(current_reading) > 0.015 else "weak"
+
+ if current_reading > 0.02:
+ market_implication = "Simulated institutional accumulation"
+ elif current_reading < -0.02:
+ market_implication = "Simulated institutional distribution"
+ else:
+ market_implication = "Neutral simulated positioning"
+
+ return SmartMoneyIndicator(
+ indicator_name="13f_filings",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"equities": current_reading * 2}
+ )
+
+ async def _analyze_insider_trading(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze insider trading patterns"""
+ try:
+ # Fetch insider trading data
+ insider_data = await self.data_manager.get_multi_source_data({
+ "market": {
+ "symbol": "SPY",
+ "data_type": "insider",
+ "days_back": config["lookback_days"]
+ }
+ })
+
+ trades = insider_data.get("market", [])
+ if not trades:
+ return self._simulate_insider_indicator()
+
+ # Calculate insider buying vs selling
+ buy_volume = sum(dp.value for dp in trades if dp.value > 0)
+ sell_volume = sum(abs(dp.value) for dp in trades if dp.value < 0)
+
+ total_volume = buy_volume + sell_volume
+ if total_volume > 0:
+ buy_sell_ratio = (buy_volume - sell_volume) / total_volume
+
+ historical_percentile = np.random.uniform(0.3, 0.8) # Simulate historical context
+
+ if abs(buy_sell_ratio) > config["significance_threshold"]:
+ signal_strength = "strong"
+ elif abs(buy_sell_ratio) > config["significance_threshold"] / 2:
+ signal_strength = "moderate"
+ else:
+ signal_strength = "weak"
+
+ if buy_sell_ratio > 0.1:
+ market_implication = "Strong insider buying - bullish signal"
+ elif buy_sell_ratio < -0.1:
+ market_implication = "Heavy insider selling - bearish signal"
+ else:
+ market_implication = "Balanced insider activity"
+
+ return SmartMoneyIndicator(
+ indicator_name="insider_trading",
+ current_reading=buy_sell_ratio,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"individual_stocks": buy_sell_ratio * 1.5}
+ )
+
+ except Exception as e:
+ logging.error(f"Error in insider trading analysis: {e}")
+
+ return None
+
+ def _simulate_insider_indicator(self) -> SmartMoneyIndicator:
+ """Simulate insider trading indicator"""
+ buy_sell_ratio = np.random.normal(-0.02, 0.05) # Slight selling bias (normal)
+ historical_percentile = np.random.uniform(0.2, 0.8)
+
+ signal_strength = "moderate" if abs(buy_sell_ratio) > 0.03 else "weak"
+
+ if buy_sell_ratio > 0.05:
+ market_implication = "Simulated insider buying signal"
+ elif buy_sell_ratio < -0.05:
+ market_implication = "Simulated insider selling pressure"
+ else:
+ market_implication = "Normal insider activity pattern"
+
+ return SmartMoneyIndicator(
+ indicator_name="insider_trading",
+ current_reading=buy_sell_ratio,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"individual_stocks": buy_sell_ratio * 1.5}
+ )
+
+ async def _analyze_options_flow(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze unusual options activity"""
+ # Simulate options flow analysis
+ # In production, would analyze actual options flow data
+
+ # Simulate call/put ratio and unusual activity
+ call_put_ratio = np.random.uniform(0.6, 1.4) # Normal range 0.8-1.2
+ unusual_activity_ratio = np.random.uniform(0.8, 3.0) # >2.0 is unusual
+
+ current_reading = (call_put_ratio - 1.0) + (unusual_activity_ratio - 1.0) / 2
+ historical_percentile = np.random.uniform(0.2, 0.9)
+
+ if unusual_activity_ratio > config["significance_threshold"]:
+ signal_strength = "strong"
+ market_implication = f"Unusual options activity detected (ratio: {unusual_activity_ratio:.1f})"
+ elif unusual_activity_ratio > 1.5:
+ signal_strength = "moderate"
+ market_implication = "Elevated options activity"
+ else:
+ signal_strength = "weak"
+ market_implication = "Normal options flow"
+
+ return SmartMoneyIndicator(
+ indicator_name="options_flow",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"volatility": current_reading * 0.3, "equities": current_reading * 0.2}
+ )
+
+ async def _analyze_dark_pool_activity(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze dark pool trading activity"""
+ # Simulate dark pool analysis
+ # Dark pools typically 35-45% of equity volume
+
+ dark_pool_percentage = np.random.uniform(0.30, 0.50)
+ average_dark_pool = 0.40
+
+ current_reading = dark_pool_percentage - average_dark_pool
+ historical_percentile = np.random.uniform(0.2, 0.8)
+
+ if abs(current_reading) > config["significance_threshold"]:
+ signal_strength = "strong"
+ if current_reading > 0:
+ market_implication = "High dark pool activity - large institutional trades"
+ else:
+ market_implication = "Low dark pool activity - retail dominated"
+ elif abs(current_reading) > config["significance_threshold"] / 2:
+ signal_strength = "moderate"
+ market_implication = "Moderate dark pool activity variation"
+ else:
+ signal_strength = "weak"
+ market_implication = "Normal dark pool activity levels"
+
+ return SmartMoneyIndicator(
+ indicator_name="dark_pool_activity",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"equities": current_reading * 0.5}
+ )
+
+ async def _analyze_repo_market(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze repo market for institutional liquidity conditions"""
+ # Simulate repo market analysis
+ # Repo rates typically track fed funds rate
+
+ repo_spread = np.random.normal(0.05, 0.15) # Spread to fed funds
+ current_reading = repo_spread
+ historical_percentile = np.random.uniform(0.1, 0.9)
+
+ if abs(current_reading) > config["significance_threshold"]:
+ signal_strength = "strong"
+ if current_reading > 0.1:
+ market_implication = "Repo market stress - liquidity tightening"
+ else:
+ market_implication = "Repo market ease - abundant liquidity"
+ else:
+ signal_strength = "weak"
+ market_implication = "Normal repo market conditions"
+
+ return SmartMoneyIndicator(
+ indicator_name="repo_market",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"bonds": -current_reading * 0.8, "equities": -current_reading * 0.3}
+ )
+
+ async def _analyze_etf_smart_money(self, config: Dict) -> Optional[SmartMoneyIndicator]:
+ """Analyze ETF flows for smart money patterns"""
+ # Simulate smart money ETF analysis
+ # Look for flows into sophisticated vs retail ETFs
+
+ smart_money_ratio = np.random.uniform(0.4, 1.6) # Smart money vs retail flows
+ current_reading = smart_money_ratio - 1.0
+ historical_percentile = np.random.uniform(0.2, 0.8)
+
+ if abs(current_reading) > config["significance_threshold"]:
+ signal_strength = "strong"
+ if current_reading > 0:
+ market_implication = "Smart money ETF inflows - sophisticated accumulation"
+ else:
+ market_implication = "Retail ETF inflows - momentum chasing"
+ else:
+ signal_strength = "moderate"
+ market_implication = "Balanced ETF flow patterns"
+
+ return SmartMoneyIndicator(
+ indicator_name="etf_flows",
+ current_reading=current_reading,
+ historical_percentile=historical_percentile,
+ signal_strength=signal_strength,
+ market_implication=market_implication,
+ asset_impact={"broad_market": current_reading * 0.4}
+ )
+
+ def _calculate_percentile(self, current_value: float, historical_values: List[float]) -> float:
+ """Calculate percentile of current value in historical context"""
+ if not historical_values:
+ return 0.5
+
+ sorted_values = sorted(historical_values)
+
+ # Find position of current value
+ position = 0
+ for value in sorted_values:
+ if current_value > value:
+ position += 1
+ else:
+ break
+
+ return position / len(sorted_values)
+
+ async def get_flow_report(self) -> Dict:
+ """Generate comprehensive institutional flow report"""
+ # Analyze institutional flows
+ flow_signals = await self.analyze_institutional_flows()
+
+ # Analyze smart money indicators
+ smart_money_indicators = await self.analyze_smart_money_indicators()
+
+ # Calculate overall flow sentiment
+ overall_flow_sentiment = self._calculate_overall_flow_sentiment(flow_signals)
+
+ # Generate LLM analysis
+ llm_analysis = await self._generate_flow_llm_analysis(flow_signals, smart_money_indicators)
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "flow_analysis": {
+ "overall_flow_sentiment": overall_flow_sentiment,
+ "flow_classification": self._classify_flow_regime(overall_flow_sentiment),
+ "institutional_signals": {
+ source: {
+ "direction": signal.flow_direction,
+ "magnitude": signal.flow_magnitude,
+ "velocity": signal.flow_velocity,
+ "asset_class": signal.asset_class,
+ "contrarian_signal": signal.contrarian_signal,
+ "confidence": signal.confidence
+ } for source, signal in flow_signals.items() if hasattr(signal, 'flow_direction')
+ }
+ },
+ "smart_money_indicators": [{
+ "indicator": indicator.indicator_name,
+ "reading": indicator.current_reading,
+ "percentile": indicator.historical_percentile,
+ "strength": indicator.signal_strength,
+ "implication": indicator.market_implication,
+ "asset_impact": indicator.asset_impact
+ } for indicator in smart_money_indicators],
+ "flow_regime_analysis": {
+ "current_regime": self._determine_flow_regime(flow_signals),
+ "regime_sustainability": self._assess_regime_sustainability(flow_signals),
+ "rotation_signals": self._detect_rotation_signals(flow_signals),
+ "contrarian_opportunities": self._identify_contrarian_opportunities(flow_signals)
+ },
+ "trading_implications": {
+ "momentum_signals": self._get_momentum_signals(flow_signals),
+ "reversal_signals": self._get_reversal_signals(flow_signals),
+ "asset_allocation": self._get_flow_based_allocation(overall_flow_sentiment),
+ "position_sizing": self._get_flow_position_sizing(flow_signals)
+ },
+ "llm_analysis": llm_analysis,
+ "monitoring_priorities": {
+ "high_velocity_flows": [s for s in flow_signals.keys()
+ if hasattr(flow_signals[s], 'flow_velocity') and
+ flow_signals[s].flow_velocity > 0.6],
+ "contrarian_signals": [s for s in flow_signals.keys()
+ if hasattr(flow_signals[s], 'contrarian_signal') and
+ flow_signals[s].contrarian_signal],
+ "strong_smart_money": [i.indicator_name for i in smart_money_indicators
+ if i.signal_strength == "strong"]
+ }
+ }
+
+ def _calculate_overall_flow_sentiment(self, flow_signals: Dict[str, FlowSignal]) -> float:
+ """Calculate overall institutional flow sentiment"""
+ if not flow_signals:
+ return 0.0
+
+ weighted_sentiments = []
+ weights = []
+
+ for source, signal in flow_signals.items():
+ if hasattr(signal, 'flow_direction'):
+ # Convert flow direction to sentiment score
+ if signal.flow_direction == "inflow":
+ sentiment = signal.flow_magnitude
+ elif signal.flow_direction == "outflow":
+ sentiment = -signal.flow_magnitude
+ else:
+ sentiment = 0.0
+
+ # Weight by confidence and institution importance
+ weight = signal.confidence * self.institution_weights.get(signal.institution_type, 0.1)
+
+ weighted_sentiments.append(sentiment * weight)
+ weights.append(weight)
+
+ if weights:
+ return np.sum(weighted_sentiments) / np.sum(weights)
+ else:
+ return 0.0
+
+ def _classify_flow_regime(self, flow_sentiment: float) -> str:
+ """Classify current flow regime"""
+ if flow_sentiment > 0.4:
+ return "strong_inflows"
+ elif flow_sentiment > 0.1:
+ return "moderate_inflows"
+ elif flow_sentiment > -0.1:
+ return "balanced_flows"
+ elif flow_sentiment > -0.4:
+ return "moderate_outflows"
+ else:
+ return "strong_outflows"
+
+ def _determine_flow_regime(self, flow_signals: Dict[str, FlowSignal]) -> str:
+ """Determine current institutional flow regime"""
+ if not flow_signals:
+ return "uncertain"
+
+ # Count different flow directions
+ inflow_count = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'flow_direction') and s.flow_direction == "inflow")
+ outflow_count = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'flow_direction') and s.flow_direction == "outflow")
+
+ total_signals = len([s for s in flow_signals.values() if hasattr(s, 'flow_direction')])
+
+ if total_signals == 0:
+ return "uncertain"
+
+ inflow_ratio = inflow_count / total_signals
+
+ if inflow_ratio > 0.7:
+ return "risk_on"
+ elif inflow_ratio < 0.3:
+ return "risk_off"
+ else:
+ return "rotation"
+
+ def _assess_regime_sustainability(self, flow_signals: Dict[str, FlowSignal]) -> str:
+ """Assess sustainability of current flow regime"""
+ if not flow_signals:
+ return "uncertain"
+
+ # Check flow velocities and magnitudes
+ high_velocity_signals = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'flow_velocity') and s.flow_velocity > 0.6)
+
+ extreme_magnitude_signals = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'flow_magnitude') and s.flow_magnitude > 0.7)
+
+ total_signals = len(flow_signals)
+
+ if high_velocity_signals > total_signals * 0.5:
+ return "unsustainable" # High velocity suggests momentum exhaustion
+ elif extreme_magnitude_signals > total_signals * 0.6:
+ return "late_stage" # Extreme magnitudes suggest late stage
+ else:
+ return "sustainable"
+
+ def _detect_rotation_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:
+ """Detect sector/style rotation signals"""
+ rotation_signals = []
+
+ # Look for opposing flows in different asset classes
+ equity_flows = [s for s in flow_signals.values()
+ if hasattr(s, 'asset_class') and s.asset_class == "equities"]
+ bond_flows = [s for s in flow_signals.values()
+ if hasattr(s, 'asset_class') and s.asset_class == "bonds"]
+
+ if equity_flows and bond_flows:
+ avg_equity_flow = np.mean([1 if s.flow_direction == "inflow" else -1
+ for s in equity_flows if hasattr(s, 'flow_direction')])
+ avg_bond_flow = np.mean([1 if s.flow_direction == "inflow" else -1
+ for s in bond_flows if hasattr(s, 'flow_direction')])
+
+ if avg_equity_flow > 0.3 and avg_bond_flow < -0.3:
+ rotation_signals.append("bond_to_equity_rotation")
+ elif avg_equity_flow < -0.3 and avg_bond_flow > 0.3:
+ rotation_signals.append("equity_to_bond_rotation")
+
+ return rotation_signals
+
+ def _identify_contrarian_opportunities(self, flow_signals: Dict[str, FlowSignal]) -> List[Dict]:
+ """Identify contrarian opportunities from flow extremes"""
+ opportunities = []
+
+ for source, signal in flow_signals.items():
+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal:
+ opportunity = {
+ "source": source,
+ "asset_class": signal.asset_class,
+ "opportunity_type": "contrarian_" + signal.flow_direction,
+ "conviction": signal.flow_magnitude * signal.confidence,
+ "time_horizon": signal.time_horizon
+ }
+ opportunities.append(opportunity)
+
+ return opportunities
+
+ def _get_momentum_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:
+ """Get momentum signals from institutional flows"""
+ momentum_signals = []
+
+ for source, signal in flow_signals.items():
+ if (hasattr(signal, 'flow_velocity') and signal.flow_velocity > 0.5 and
+ hasattr(signal, 'flow_magnitude') and signal.flow_magnitude > 0.4 and
+ not signal.contrarian_signal):
+ momentum_signals.append(f"{signal.asset_class}_{signal.flow_direction}_momentum")
+
+ return momentum_signals
+
+ def _get_reversal_signals(self, flow_signals: Dict[str, FlowSignal]) -> List[str]:
+ """Get reversal signals from institutional flows"""
+ reversal_signals = []
+
+ for source, signal in flow_signals.items():
+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal:
+ reversal_signals.append(f"{signal.asset_class}_reversal_signal")
+
+ return reversal_signals
+
+ def _get_flow_based_allocation(self, flow_sentiment: float) -> Dict[str, str]:
+ """Get asset allocation based on institutional flows"""
+ if flow_sentiment > 0.3:
+ return {
+ "equities": "overweight",
+ "bonds": "underweight",
+ "alternatives": "neutral",
+ "cash": "underweight"
+ }
+ elif flow_sentiment < -0.3:
+ return {
+ "equities": "underweight",
+ "bonds": "overweight",
+ "alternatives": "neutral",
+ "cash": "overweight"
+ }
+ else:
+ return {
+ "equities": "neutral",
+ "bonds": "neutral",
+ "alternatives": "neutral",
+ "cash": "neutral"
+ }
+
+ def _get_flow_position_sizing(self, flow_signals: Dict[str, FlowSignal]) -> str:
+ """Get position sizing recommendation based on flows"""
+ if not flow_signals:
+ return "normal"
+
+ high_conviction_signals = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'confidence') and s.confidence > 0.7)
+
+ contrarian_signals = sum(1 for s in flow_signals.values()
+ if hasattr(s, 'contrarian_signal') and s.contrarian_signal)
+
+ total_signals = len(flow_signals)
+
+ if high_conviction_signals > total_signals * 0.6:
+ return "increase_size"
+ elif contrarian_signals > total_signals * 0.4:
+ return "reduce_size"
+ else:
+ return "normal"
+
+ async def _generate_flow_llm_analysis(self, flow_signals: Dict[str, FlowSignal],
+ smart_money_indicators: List[SmartMoneyIndicator]) -> Dict:
+ """Generate LLM-enhanced institutional flow analysis"""
+ try:
+ # Prepare flow summary
+ flow_summary = self._prepare_flow_summary(flow_signals)
+ smart_money_summary = self._prepare_smart_money_summary(smart_money_indicators)
+
+ prompt = f"""
+ As a senior institutional flow analyst, analyze current money flows and provide investment guidance.
+
+ Institutional Flow Analysis:
+ {flow_summary}
+
+ Smart Money Indicators:
+ {smart_money_summary}
+
+ Please provide:
+ 1. Current institutional positioning and sentiment analysis
+ 2. Smart money flow patterns and their implications
+ 3. Contrarian opportunities from flow extremes
+ 4. Asset allocation recommendations based on institutional flows
+ 5. Timeline for potential flow reversals
+ 6. Risk factors from institutional positioning
+
+ Format as JSON with keys: institutional_positioning, smart_money_patterns, contrarian_opportunities,
+ asset_allocation, flow_timeline, risk_factors
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM flow analysis: {e}")
+ return {
+ "institutional_positioning": "Mixed institutional flows with slight equity bias",
+ "smart_money_patterns": "Moderate institutional accumulation in large caps",
+ "contrarian_opportunities": "Monitor for sentiment extremes in small caps",
+ "asset_allocation": "Balanced approach with equity overweight",
+ "flow_timeline": "Next 4-8 weeks for potential shifts",
+ "risk_factors": ["Flow velocity", "Sentiment extremes", "Liquidity conditions"]
+ }
+
+ def _prepare_flow_summary(self, flow_signals: Dict[str, FlowSignal]) -> str:
+ """Prepare flow summary for LLM"""
+ summary_lines = []
+
+ for source, signal in flow_signals.items():
+ if hasattr(signal, 'flow_direction'):
+ summary_lines.append(
+ f"{source}: {signal.flow_direction} "
+ f"(Magnitude: {signal.flow_magnitude:.2f}, "
+ f"Velocity: {signal.flow_velocity:.2f}, "
+ f"Asset: {signal.asset_class}, "
+ f"Contrarian: {signal.contrarian_signal})"
+ )
+
+ return "\n".join(summary_lines) if summary_lines else "Limited flow data available"
+
+ def _prepare_smart_money_summary(self, indicators: List[SmartMoneyIndicator]) -> str:
+ """Prepare smart money summary for LLM"""
+ summary_lines = []
+
+ for indicator in indicators:
+ summary_lines.append(
+ f"{indicator.indicator_name}: {indicator.current_reading:.3f} "
+ f"({indicator.signal_strength} signal, "
+ f"{indicator.historical_percentile:.0%} percentile) - "
+ f"{indicator.market_implication}"
+ )
+
+ return "\n".join(summary_lines) if summary_lines else "Smart money indicators not available"
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.py
new file mode 100644
index 000000000..284aabce7
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/macro_cycle_agent.py
@@ -0,0 +1,525 @@
+# -*- coding: utf-8 -*-
+# agents/macro_cycle_agent.py - Economic Cycles Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+from scipy import signal
+from scipy.stats import pearsonr
+import json
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class CycleSignal:
+ """Economic cycle signal structure"""
+ cycle_type: str
+ phase: str
+ strength: float
+ confidence: float
+ duration_months: int
+ next_inflection: Optional[datetime]
+ supporting_indicators: List[str]
+ investment_implications: Dict[str, float]
+
+
+class MacroCycleAgent:
+ """Advanced economic cycle analysis agent"""
+
+ def __init__(self):
+ self.name = "macro_cycle"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Economic cycle indicators and their weights
+ self.cycle_indicators = {
+ "leading": {
+ "DSPIC96": 0.15, # Real Disposable Personal Income
+ "HOUST": 0.20, # Housing Starts
+ "AWHMAN": 0.10, # Average Weekly Hours Manufacturing
+ "PAYEMS": 0.15, # Nonfarm Payrolls
+ "UMCSENT": 0.15, # Consumer Sentiment
+ "DEXUSEU": 0.10, # USD/EUR Exchange Rate
+ "GS10": 0.15 # 10-Year Treasury Rate
+ },
+ "coincident": {
+ "GDPC1": 0.30, # Real GDP
+ "INDPRO": 0.25, # Industrial Production
+ "PAYEMS": 0.25, # Employment
+ "RSAFS": 0.20 # Retail Sales
+ },
+ "lagging": {
+ "UNRATE": 0.40, # Unemployment Rate
+ "CPIAUCSL": 0.35, # Consumer Price Index
+ "CPILFESL": 0.25 # Core CPI
+ }
+ }
+
+ # Cycle phases and their characteristics
+ self.cycle_phases = {
+ "expansion": {
+ "gdp_growth": (2.0, 4.0),
+ "unemployment": (3.5, 6.0),
+ "inflation": (1.5, 3.0),
+ "duration_months": (18, 60)
+ },
+ "peak": {
+ "gdp_growth": (1.0, 2.5),
+ "unemployment": (3.0, 5.0),
+ "inflation": (2.5, 4.0),
+ "duration_months": (3, 9)
+ },
+ "contraction": {
+ "gdp_growth": (-2.0, 1.0),
+ "unemployment": (5.0, 10.0),
+ "inflation": (0.0, 2.0),
+ "duration_months": (6, 18)
+ },
+ "trough": {
+ "gdp_growth": (-1.0, 1.5),
+ "unemployment": (6.0, 10.0),
+ "inflation": (-1.0, 1.5),
+ "duration_months": (2, 6)
+ }
+ }
+
+ # Sector rotation strategy by cycle phase
+ self.sector_rotation = {
+ "expansion": {
+ "technology": 0.25,
+ "consumer_discretionary": 0.20,
+ "industrials": 0.20,
+ "materials": 0.15,
+ "financials": 0.20
+ },
+ "peak": {
+ "energy": 0.30,
+ "materials": 0.25,
+ "financials": 0.20,
+ "real_estate": 0.15,
+ "utilities": 0.10
+ },
+ "contraction": {
+ "healthcare": 0.25,
+ "consumer_staples": 0.25,
+ "utilities": 0.20,
+ "telecommunications": 0.15,
+ "government_bonds": 0.15
+ },
+ "trough": {
+ "technology": 0.30,
+ "financials": 0.25,
+ "consumer_discretionary": 0.20,
+ "industrials": 0.15,
+ "small_caps": 0.10
+ }
+ }
+
+ async def analyze_business_cycle(self) -> CycleSignal:
+ """Comprehensive business cycle analysis"""
+ try:
+ # Fetch economic indicators
+ economic_data = await self._fetch_cycle_indicators()
+
+ # Calculate composite leading index
+ leading_index = self._calculate_composite_index(economic_data, "leading")
+ coincident_index = self._calculate_composite_index(economic_data, "coincident")
+
+ # Determine cycle phase
+ current_phase = self._determine_cycle_phase(leading_index, coincident_index)
+
+ # Calculate cycle strength and confidence
+ cycle_strength = self._calculate_cycle_strength(economic_data, current_phase)
+ confidence = self._calculate_confidence(economic_data, current_phase)
+
+ # Predict next inflection point
+ next_inflection = self._predict_inflection_point(leading_index, current_phase)
+
+ # Generate LLM-enhanced analysis
+ llm_analysis = await self._generate_llm_analysis(economic_data, current_phase)
+
+ # Get investment implications
+ investment_implications = self.sector_rotation.get(current_phase, {})
+
+ return CycleSignal(
+ cycle_type="business_cycle",
+ phase=current_phase,
+ strength=cycle_strength,
+ confidence=confidence,
+ duration_months=self._estimate_phase_duration(current_phase, economic_data),
+ next_inflection=next_inflection,
+ supporting_indicators=list(economic_data.keys()),
+ investment_implications=investment_implications
+ )
+
+ except Exception as e:
+ logging.error(f"Error in business cycle analysis: {e}")
+ return self._default_cycle_signal()
+
+ async def _fetch_cycle_indicators(self) -> Dict[str, pd.Series]:
+ """Fetch all economic indicators for cycle analysis"""
+ data_requests = {}
+
+ # Collect all unique indicators
+ all_indicators = set()
+ for category in self.cycle_indicators.values():
+ all_indicators.update(category.keys())
+
+ # Create data requests for each indicator
+ for indicator in all_indicators:
+ data_requests[f"economic_{indicator}"] = {
+ "series_id": indicator,
+ "limit": 240 # 20 years of monthly data
+ }
+
+ # Fetch data concurrently
+ raw_data = await self.data_manager.get_multi_source_data({
+ "economic": data_requests
+ })
+
+ # Process into time series
+ processed_data = {}
+ for key, data_points in raw_data.get("economic", {}).items():
+ if data_points:
+ df = pd.DataFrame([{
+ 'date': dp.timestamp,
+ 'value': dp.value
+ } for dp in data_points])
+ df['date'] = pd.to_datetime(df['date'])
+ df = df.sort_values('date').set_index('date')
+
+ # Calculate year-over-year growth rates
+ indicator_name = key.replace("economic_", "")
+ processed_data[indicator_name] = df['value'].pct_change(12) * 100
+
+ return processed_data
+
+ def _calculate_composite_index(self, data: Dict[str, pd.Series],
+ indicator_type: str) -> pd.Series:
+ """Calculate weighted composite index for indicator category"""
+ if indicator_type not in self.cycle_indicators:
+ return pd.Series()
+
+ weights = self.cycle_indicators[indicator_type]
+ composite_values = []
+ dates = None
+
+ for indicator, weight in weights.items():
+ if indicator in data and not data[indicator].empty:
+ series = data[indicator].dropna()
+ if dates is None:
+ dates = series.index
+ else:
+ dates = dates.intersection(series.index)
+
+ if dates is None or len(dates) == 0:
+ return pd.Series()
+
+ composite_index = pd.Series(0.0, index=dates)
+ total_weight = 0
+
+ for indicator, weight in weights.items():
+ if indicator in data and not data[indicator].empty:
+ series = data[indicator].reindex(dates).fillna(method='ffill')
+ composite_index += series * weight
+ total_weight += weight
+
+ if total_weight > 0:
+ composite_index /= total_weight
+
+ return composite_index
+
+ def _determine_cycle_phase(self, leading_index: pd.Series,
+ coincident_index: pd.Series) -> str:
+ """Determine current business cycle phase"""
+ if leading_index.empty or coincident_index.empty:
+ return "expansion" # Default assumption
+
+ # Get recent trends
+ leading_trend = self._calculate_trend(leading_index, periods=6)
+ coincident_trend = self._calculate_trend(coincident_index, periods=3)
+
+ # Recent values
+ leading_recent = leading_index.iloc[-3:].mean()
+ coincident_recent = coincident_index.iloc[-3:].mean()
+
+ # Phase determination logic
+ if leading_trend > 0 and coincident_trend > 0 and coincident_recent > 0:
+ return "expansion"
+ elif leading_trend < 0 and coincident_trend > 0 and coincident_recent > 1:
+ return "peak"
+ elif leading_trend < 0 and coincident_trend < 0:
+ return "contraction"
+ elif leading_trend > 0 and coincident_trend < 0 and coincident_recent < -1:
+ return "trough"
+ else:
+ return "expansion" # Default
+
+ def _calculate_trend(self, series: pd.Series, periods: int = 6) -> float:
+ """Calculate trend over specified periods"""
+ if len(series) < periods:
+ return 0.0
+
+ recent_data = series.iloc[-periods:]
+ x = np.arange(len(recent_data))
+
+ try:
+ slope, _ = np.polyfit(x, recent_data.values, 1)
+ return slope
+ except:
+ return 0.0
+
+ def _calculate_cycle_strength(self, data: Dict[str, pd.Series], phase: str) -> float:
+ """Calculate strength of current cycle phase"""
+ if phase not in self.cycle_phases:
+ return 0.5
+
+ phase_characteristics = self.cycle_phases[phase]
+ strength_scores = []
+
+ # Check GDP growth if available
+ if "GDPC1" in data and not data["GDPC1"].empty:
+ gdp_growth = data["GDPC1"].iloc[-1]
+ gdp_range = phase_characteristics["gdp_growth"]
+ gdp_score = self._score_in_range(gdp_growth, gdp_range)
+ strength_scores.append(gdp_score * 0.4)
+
+ # Check unemployment if available
+ if "UNRATE" in data and not data["UNRATE"].empty:
+ unemployment = data["UNRATE"].iloc[-1]
+ unemp_range = phase_characteristics["unemployment"]
+ unemp_score = self._score_in_range(unemployment, unemp_range)
+ strength_scores.append(unemp_score * 0.3)
+
+ # Check inflation if available
+ if "CPIAUCSL" in data and not data["CPIAUCSL"].empty:
+ inflation = data["CPIAUCSL"].iloc[-1]
+ inf_range = phase_characteristics["inflation"]
+ inf_score = self._score_in_range(inflation, inf_range)
+ strength_scores.append(inf_score * 0.3)
+
+ return np.mean(strength_scores) if strength_scores else 0.5
+
+ def _score_in_range(self, value: float, range_tuple: Tuple[float, float]) -> float:
+ """Score how well a value fits within expected range"""
+ min_val, max_val = range_tuple
+
+ if min_val <= value <= max_val:
+ # Perfect fit
+ return 1.0
+ elif value < min_val:
+ # Below range - score based on distance
+ distance = min_val - value
+ return max(0.0, 1.0 - distance / min_val)
+ else:
+ # Above range - score based on distance
+ distance = value - max_val
+ return max(0.0, 1.0 - distance / max_val)
+
+ def _calculate_confidence(self, data: Dict[str, pd.Series], phase: str) -> float:
+ """Calculate confidence in cycle phase determination"""
+ confidence_factors = []
+
+ # Data availability factor
+ available_indicators = len([k for k, v in data.items() if not v.empty])
+ total_indicators = sum(len(cat) for cat in self.cycle_indicators.values())
+ data_coverage = available_indicators / total_indicators
+ confidence_factors.append(data_coverage * 0.3)
+
+ # Data recency factor
+ recent_data_count = 0
+ for series in data.values():
+ if not series.empty and series.index[-1] >= datetime.now() - timedelta(days=90):
+ recent_data_count += 1
+
+ recency_factor = recent_data_count / len(data) if data else 0
+ confidence_factors.append(recency_factor * 0.3)
+
+ # Consistency factor - how well indicators agree
+ phase_consistency = self._calculate_phase_consistency(data, phase)
+ confidence_factors.append(phase_consistency * 0.4)
+
+ return np.mean(confidence_factors)
+
+ def _calculate_phase_consistency(self, data: Dict[str, pd.Series], phase: str) -> float:
+ """Calculate how consistently indicators point to the same phase"""
+ if phase not in self.cycle_phases:
+ return 0.5
+
+ consistent_indicators = 0
+ total_indicators = 0
+
+ phase_ranges = self.cycle_phases[phase]
+
+ for indicator, series in data.items():
+ if series.empty:
+ continue
+
+ recent_value = series.iloc[-1]
+ total_indicators += 1
+
+ # Check if indicator value is consistent with phase
+ if indicator == "GDPC1" and "gdp_growth" in phase_ranges:
+ if phase_ranges["gdp_growth"][0] <= recent_value <= phase_ranges["gdp_growth"][1]:
+ consistent_indicators += 1
+ elif indicator == "UNRATE" and "unemployment" in phase_ranges:
+ if phase_ranges["unemployment"][0] <= recent_value <= phase_ranges["unemployment"][1]:
+ consistent_indicators += 1
+ elif indicator in ["CPIAUCSL", "CPILFESL"] and "inflation" in phase_ranges:
+ if phase_ranges["inflation"][0] <= recent_value <= phase_ranges["inflation"][1]:
+ consistent_indicators += 1
+
+ return consistent_indicators / total_indicators if total_indicators > 0 else 0.5
+
+ def _predict_inflection_point(self, leading_index: pd.Series, phase: str) -> Optional[datetime]:
+ """Predict next cycle inflection point"""
+ if leading_index.empty:
+ return None
+
+ try:
+ # Calculate rate of change in leading indicators
+ roc = leading_index.pct_change(3).dropna()
+
+ if len(roc) < 6:
+ return None
+
+ # Find trend acceleration/deceleration
+ recent_roc = roc.iloc[-6:]
+ trend_change = np.diff(recent_roc.values)
+
+ # Estimate time to inflection based on trend
+ if phase in ["expansion", "contraction"]:
+ # Look for trend reversals
+ if len(trend_change) >= 3 and np.all(trend_change[-3:] < 0):
+ # Decelerating trend suggests inflection in 3-9 months
+ months_ahead = np.random.randint(3, 10)
+ else:
+ # Stable trend suggests inflection in 6-18 months
+ months_ahead = np.random.randint(6, 19)
+ else:
+ # Peak or trough phases are typically shorter
+ months_ahead = np.random.randint(2, 7)
+
+ return datetime.now() + timedelta(days=months_ahead * 30)
+
+ except Exception:
+ return None
+
+ def _estimate_phase_duration(self, phase: str, data: Dict[str, pd.Series]) -> int:
+ """Estimate duration of current phase"""
+ if phase not in self.cycle_phases:
+ return 12
+
+ duration_range = self.cycle_phases[phase]["duration_months"]
+
+ # Base estimate from historical averages
+ base_duration = np.mean(duration_range)
+
+ # Adjust based on current strength
+ current_strength = self._calculate_cycle_strength(data, phase)
+
+ # Stronger phases tend to last longer
+ duration_adjustment = (current_strength - 0.5) * 0.3
+ adjusted_duration = base_duration * (1 + duration_adjustment)
+
+ return int(np.clip(adjusted_duration, duration_range[0], duration_range[1]))
+
+ async def _generate_llm_analysis(self, data: Dict[str, pd.Series], phase: str) -> Dict:
+ """Generate LLM-enhanced cycle analysis"""
+ try:
+ # Prepare data summary for LLM
+ data_summary = self._prepare_data_summary(data)
+
+ prompt = f"""
+ As a senior macroeconomic analyst, analyze the current business cycle phase and provide insights.
+
+ Current Phase: {phase}
+
+ Economic Indicators Summary:
+ {data_summary}
+
+ Please provide:
+ 1. Confirmation or challenge of the current phase assessment
+ 2. Key risks to monitor
+ 3. Expected duration of current phase
+ 4. Investment strategy recommendations
+ 5. Probability of recession in next 12 months (0-100%)
+
+ Format as JSON with keys: phase_assessment, key_risks, duration_estimate, investment_strategy, recession_probability
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM analysis: {e}")
+ return {
+ "phase_assessment": f"Current phase appears to be {phase}",
+ "key_risks": ["Data quality", "Model uncertainty"],
+ "duration_estimate": "6-12 months",
+ "investment_strategy": "Diversified approach recommended",
+ "recession_probability": 25
+ }
+
+ def _prepare_data_summary(self, data: Dict[str, pd.Series]) -> str:
+ """Prepare human-readable data summary for LLM"""
+ summary_lines = []
+
+ for indicator, series in data.items():
+ if not series.empty:
+ latest_value = series.iloc[-1]
+ trend = self._calculate_trend(series, 6)
+
+ trend_desc = "rising" if trend > 0.1 else "falling" if trend < -0.1 else "stable"
+ summary_lines.append(f"{indicator}: {latest_value:.2f}% ({trend_desc})")
+
+ return "\n".join(summary_lines)
+
+ def _default_cycle_signal(self) -> CycleSignal:
+ """Return default cycle signal in case of errors"""
+ return CycleSignal(
+ cycle_type="business_cycle",
+ phase="expansion",
+ strength=0.5,
+ confidence=0.3,
+ duration_months=12,
+ next_inflection=datetime.now() + timedelta(days=365),
+ supporting_indicators=[],
+ investment_implications=self.sector_rotation["expansion"]
+ )
+
+ async def get_cycle_report(self) -> Dict:
+ """Generate comprehensive cycle analysis report"""
+ cycle_signal = await self.analyze_business_cycle()
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "cycle_analysis": {
+ "current_phase": cycle_signal.phase,
+ "strength": cycle_signal.strength,
+ "confidence": cycle_signal.confidence,
+ "duration_estimate": cycle_signal.duration_months,
+ "next_inflection": cycle_signal.next_inflection.isoformat() if cycle_signal.next_inflection else None
+ },
+ "investment_implications": cycle_signal.investment_implications,
+ "supporting_indicators": cycle_signal.supporting_indicators,
+ "risk_assessment": {
+ "phase_transition_risk": 1 - cycle_signal.confidence,
+ "data_quality_risk": 1 - len(cycle_signal.supporting_indicators) / 10,
+ "model_uncertainty": 0.2
+ }
+ }
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.py
new file mode 100644
index 000000000..651a3eeec
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/main.py
@@ -0,0 +1,776 @@
+# -*- coding: utf-8 -*-
+# main.py - AI Hedge Fund Orchestrator and Execution Engine
+
+import asyncio
+import logging
+import json
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+import signal
+import sys
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+from config import CONFIG
+from data_feeds import DataFeedManager
+
+# Import all agents
+from agents.macro_cycle_agent import MacroCycleAgent
+from agents.central_bank_agent import CentralBankAgent
+from agents.geopolitical_agent import GeopoliticalAgent
+from agents.regulatory_agent import RegulatoryAgent
+from agents.sentiment_agent import SentimentAgent
+from agents.institutional_flow_agent import InstitutionalFlowAgent
+from agents.supply_chain_agent import SupplyChainAgent
+from agents.innovation_agent import InnovationAgent
+from agents.currency_agent import CurrencyAgent
+from agents.behavioral_agent import BehavioralAgent
+
+
+@dataclass
+class TradingSignal:
+ """Aggregated trading signal from all agents"""
+ timestamp: datetime
+ asset_class: str
+ direction: str # long, short, neutral
+ conviction: float # 0-1
+ position_size: float # 0-1
+ time_horizon: str # short, medium, long
+ risk_factors: List[str]
+ supporting_agents: List[str]
+ market_regime: str
+
+
+@dataclass
+class PortfolioRecommendation:
+ """Portfolio-level recommendations"""
+ timestamp: datetime
+ asset_allocation: Dict[str, float]
+ sector_weights: Dict[str, float]
+ regional_weights: Dict[str, float]
+ risk_budget: Dict[str, float]
+ hedges: List[str]
+ cash_allocation: float
+ leverage: float
+
+
+class RiskManager:
+ """Portfolio risk management and position sizing"""
+
+ def __init__(self):
+ self.max_position_size = CONFIG.risk.max_position_size
+ self.max_sector_exposure = CONFIG.risk.max_sector_exposure
+ self.var_limit = CONFIG.risk.var_limit
+ self.correlation_limit = CONFIG.risk.correlation_limit
+
+ def validate_signal(self, signal: TradingSignal, current_portfolio: Dict) -> bool:
+ """Validate trading signal against risk limits"""
+ # Position size check
+ if signal.position_size > self.max_position_size:
+ logging.warning(f"Signal exceeds max position size: {signal.position_size}")
+ return False
+
+ # Sector concentration check
+ sector_exposure = current_portfolio.get('sectors', {})
+ if signal.asset_class in sector_exposure:
+ new_exposure = sector_exposure[signal.asset_class] + signal.position_size
+ if new_exposure > self.max_sector_exposure:
+ logging.warning(f"Signal would exceed sector limits: {new_exposure}")
+ return False
+
+ # Risk budget check
+ total_risk = sum(current_portfolio.get('risk_budget', {}).values())
+ if total_risk + signal.conviction * signal.position_size > 1.0:
+ logging.warning("Signal would exceed total risk budget")
+ return False
+
+ return True
+
+ def size_position(self, signal: TradingSignal, market_volatility: float) -> float:
+ """Calculate optimal position size based on Kelly Criterion"""
+ # Kelly formula: f = (bp - q) / b
+ # where b = odds, p = probability of win, q = probability of loss
+
+ win_probability = signal.conviction
+ loss_probability = 1 - win_probability
+
+ # Estimate expected return based on conviction and market regime
+ expected_return = signal.conviction * 0.15 # 15% max expected return
+
+ # Adjust for volatility
+ volatility_adjusted_return = expected_return / max(market_volatility, 0.1)
+
+ # Kelly sizing with maximum cap
+ kelly_fraction = volatility_adjusted_return / (market_volatility ** 2)
+
+ # Apply safety factor and caps
+ safety_factor = 0.25 # Use 1/4 Kelly for safety
+ optimal_size = kelly_fraction * safety_factor
+
+ # Cap at configured maximum
+ return min(optimal_size, signal.position_size, self.max_position_size)
+
+ def calculate_portfolio_var(self, positions: Dict[str, float],
+ returns_covariance: np.ndarray) -> float:
+ """Calculate portfolio Value-at-Risk"""
+ if not positions or returns_covariance.size == 0:
+ return 0.0
+
+ position_vector = np.array(list(positions.values()))
+ portfolio_variance = np.dot(position_vector, np.dot(returns_covariance, position_vector))
+ portfolio_volatility = np.sqrt(portfolio_variance)
+
+ # 95% VaR (1.645 standard deviations)
+ var_95 = 1.645 * portfolio_volatility
+ return min(var_95, 1.0)
+
+
+class DecisionEngine:
+ """Aggregates agent signals and makes final trading decisions"""
+
+ def __init__(self):
+ self.agent_weights = CONFIG.agent_weights
+ self.risk_manager = RiskManager()
+
+ def aggregate_signals(self, agent_reports: Dict[str, Dict]) -> List[TradingSignal]:
+ """Aggregate signals from all agents into trading recommendations"""
+ signals = []
+
+ # Combine macro and policy signals for asset allocation
+ macro_signal = self._extract_macro_signal(agent_reports)
+ if macro_signal:
+ signals.append(macro_signal)
+
+ # Generate sector rotation signals
+ sector_signals = self._extract_sector_signals(agent_reports)
+ signals.extend(sector_signals)
+
+ # Generate currency signals
+ currency_signal = self._extract_currency_signal(agent_reports)
+ if currency_signal:
+ signals.append(currency_signal)
+
+ # Generate defensive/risk-on signals
+ risk_signal = self._extract_risk_signal(agent_reports)
+ if risk_signal:
+ signals.append(risk_signal)
+
+ return signals
+
+ def _extract_macro_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:
+ """Extract macro asset allocation signal"""
+ macro_report = reports.get('macro_cycle', {})
+ fed_report = reports.get('central_bank', {})
+
+ if not macro_report or not fed_report:
+ return None
+
+ # Combine cycle and policy analysis
+ cycle_phase = macro_report.get('cycle_analysis', {}).get('current_phase', 'expansion')
+ policy_stance = fed_report.get('fed_analysis', {}).get('policy_stance', 'neutral')
+
+ # Determine asset allocation bias
+ if cycle_phase == 'expansion' and policy_stance in ['neutral', 'dovish']:
+ direction = 'long'
+ asset_class = 'equities'
+ conviction = 0.7
+ elif cycle_phase == 'contraction' or policy_stance == 'hawkish':
+ direction = 'long'
+ asset_class = 'bonds'
+ conviction = 0.6
+ elif cycle_phase == 'peak':
+ direction = 'short'
+ asset_class = 'equities'
+ conviction = 0.5
+ else:
+ return None
+
+ supporting_agents = ['macro_cycle', 'central_bank']
+
+ return TradingSignal(
+ timestamp=datetime.now(),
+ asset_class=asset_class,
+ direction=direction,
+ conviction=conviction,
+ position_size=0.4, # 40% allocation
+ time_horizon='medium',
+ risk_factors=['cycle_timing', 'policy_error'],
+ supporting_agents=supporting_agents,
+ market_regime=f"{cycle_phase}_{policy_stance}"
+ )
+
+ def _extract_sector_signals(self, reports: Dict[str, Dict]) -> List[TradingSignal]:
+ """Extract sector rotation signals"""
+ signals = []
+
+ # Get sector implications from multiple agents
+ sector_scores = {}
+
+ # Macro cycle implications
+ macro_report = reports.get('macro_cycle', {})
+ if macro_report:
+ implications = macro_report.get('investment_implications', {})
+ for sector, weight in implications.items():
+ sector_scores[sector] = sector_scores.get(sector, 0) + weight * self.agent_weights.get('macro_cycle', 0)
+
+ # Geopolitical implications
+ geo_report = reports.get('geopolitical', {})
+ if geo_report:
+ sector_rotation = geo_report.get('investment_implications', {}).get('sector_rotation', {})
+ for sector, recommendation in sector_rotation.items():
+ weight = 0.2 if recommendation == 'overweight' else -0.2 if recommendation == 'underweight' else 0
+ sector_scores[sector] = sector_scores.get(sector, 0) + weight * self.agent_weights.get('geopolitical',
+ 0)
+
+ # Convert scores to signals
+ for sector, score in sector_scores.items():
+ if abs(score) > 0.1: # Minimum threshold
+ direction = 'long' if score > 0 else 'short'
+ conviction = min(abs(score) * 2, 1.0) # Scale to 0-1
+
+ signals.append(TradingSignal(
+ timestamp=datetime.now(),
+ asset_class=sector,
+ direction=direction,
+ conviction=conviction,
+ position_size=min(conviction * 0.15, 0.1), # Max 10% per sector
+ time_horizon='medium',
+ risk_factors=['sector_rotation'],
+ supporting_agents=['macro_cycle', 'geopolitical'],
+ market_regime='sector_rotation'
+ ))
+
+ return signals
+
+ def _extract_currency_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:
+ """Extract currency trading signal"""
+ fed_report = reports.get('central_bank', {})
+ geo_report = reports.get('geopolitical', {})
+
+ if not fed_report:
+ return None
+
+ # Fed policy impact on USD
+ policy_stance = fed_report.get('fed_analysis', {}).get('policy_stance', 'neutral')
+
+ if policy_stance == 'hawkish':
+ direction = 'long'
+ conviction = 0.6
+ elif policy_stance == 'dovish':
+ direction = 'short'
+ conviction = 0.5
+ else:
+ return None
+
+ # Adjust for geopolitical factors
+ if geo_report:
+ defensive_score = geo_report.get('investment_implications', {}).get('defensive_positioning', 0)
+ if defensive_score > 0.5:
+ # High geopolitical risk favors USD as safe haven
+ direction = 'long'
+ conviction = min(conviction + defensive_score * 0.3, 1.0)
+
+ return TradingSignal(
+ timestamp=datetime.now(),
+ asset_class='USD',
+ direction=direction,
+ conviction=conviction,
+ position_size=0.2, # 20% currency allocation
+ time_horizon='short',
+ risk_factors=['policy_divergence', 'geopolitical_events'],
+ supporting_agents=['central_bank', 'geopolitical'],
+ market_regime=f"currency_{policy_stance}"
+ )
+
+ def _extract_risk_signal(self, reports: Dict[str, Dict]) -> Optional[TradingSignal]:
+ """Extract overall risk-on/risk-off signal"""
+ risk_factors = []
+ risk_score = 0.0
+
+ # Aggregate risk from all agents
+ for agent_name, report in reports.items():
+ agent_weight = self.agent_weights.get(agent_name, 0)
+
+ if agent_name == 'geopolitical':
+ geo_risk = report.get('global_risk_assessment', {}).get('overall_risk_level', 5)
+ risk_score += (geo_risk - 5) / 5 * agent_weight # Normalize to -1 to 1
+
+ elif agent_name == 'sentiment':
+ sentiment_score = report.get('sentiment_analysis', {}).get('overall_sentiment', 0)
+ risk_score += sentiment_score * agent_weight
+
+ elif agent_name == 'institutional_flow':
+ flow_signal = report.get('flow_analysis', {}).get('risk_sentiment', 0)
+ risk_score += flow_signal * agent_weight
+
+ # Convert to trading signal
+ if abs(risk_score) > 0.2: # Minimum threshold
+ if risk_score > 0:
+ # Risk-on environment
+ asset_class = 'risk_assets'
+ direction = 'long'
+ else:
+ # Risk-off environment
+ asset_class = 'safe_havens'
+ direction = 'long'
+
+ conviction = min(abs(risk_score), 1.0)
+
+ return TradingSignal(
+ timestamp=datetime.now(),
+ asset_class=asset_class,
+ direction=direction,
+ conviction=conviction,
+ position_size=conviction * 0.3, # Scale position size
+ time_horizon='short',
+ risk_factors=risk_factors,
+ supporting_agents=list(reports.keys()),
+ market_regime='risk_on' if risk_score > 0 else 'risk_off'
+ )
+
+ return None
+
+ def generate_portfolio_recommendation(self, signals: List[TradingSignal],
+ current_portfolio: Dict) -> PortfolioRecommendation:
+ """Generate comprehensive portfolio recommendation"""
+
+ # Initialize allocations
+ asset_allocation = {
+ 'equities': 0.6,
+ 'bonds': 0.3,
+ 'commodities': 0.05,
+ 'cash': 0.05
+ }
+
+ sector_weights = {}
+ regional_weights = CONFIG.regional_weights.copy()
+ hedges = []
+
+ # Apply signals to modify allocations
+ for signal in signals:
+ validated = self.risk_manager.validate_signal(signal, current_portfolio)
+
+ if validated:
+ if signal.asset_class in asset_allocation:
+ # Adjust asset class allocation
+ adjustment = signal.position_size * (1 if signal.direction == 'long' else -1)
+ asset_allocation[signal.asset_class] += adjustment
+
+ elif signal.asset_class in ['risk_assets', 'safe_havens']:
+ # Risk-on/off adjustment
+ if signal.asset_class == 'risk_assets' and signal.direction == 'long':
+ asset_allocation['equities'] += signal.position_size * 0.5
+ asset_allocation['bonds'] -= signal.position_size * 0.3
+ elif signal.asset_class == 'safe_havens' and signal.direction == 'long':
+ asset_allocation['bonds'] += signal.position_size * 0.4
+ asset_allocation['cash'] += signal.position_size * 0.2
+ asset_allocation['equities'] -= signal.position_size * 0.4
+
+ # Collect sector weights
+ if signal.asset_class not in ['USD', 'risk_assets', 'safe_havens']:
+ sector_weights[signal.asset_class] = signal.position_size * (
+ 1 if signal.direction == 'long' else -1)
+
+ # Collect hedging requirements
+ hedges.extend(signal.risk_factors)
+
+ # Normalize allocations
+ total_allocation = sum(asset_allocation.values())
+ if total_allocation != 1.0:
+ for asset in asset_allocation:
+ asset_allocation[asset] /= total_allocation
+
+ # Set risk budget based on conviction levels
+ risk_budget = {}
+ for signal in signals:
+ risk_budget[signal.asset_class] = signal.conviction * signal.position_size
+
+ return PortfolioRecommendation(
+ timestamp=datetime.now(),
+ asset_allocation=asset_allocation,
+ sector_weights=sector_weights,
+ regional_weights=regional_weights,
+ risk_budget=risk_budget,
+ hedges=list(set(hedges)), # Remove duplicates
+ cash_allocation=asset_allocation.get('cash', 0.05),
+ leverage=1.0 # No leverage for now
+ )
+
+
+class HedgeFundOrchestrator:
+ """Main orchestrator for the AI hedge fund system"""
+
+ def __init__(self):
+ self.data_manager = DataFeedManager()
+ self.decision_engine = DecisionEngine()
+ self.risk_manager = RiskManager()
+
+ # Initialize all agents
+ self.agents = {
+ 'macro_cycle': MacroCycleAgent(),
+ 'central_bank': CentralBankAgent(),
+ 'geopolitical': GeopoliticalAgent(),
+ 'regulatory': RegulatoryAgent(),
+ 'sentiment': SentimentAgent(),
+ 'institutional_flow': InstitutionalFlowAgent(),
+ 'supply_chain': SupplyChainAgent(),
+ 'innovation': InnovationAgent(),
+ 'currency': CurrencyAgent(),
+ 'behavioral': BehavioralAgent()
+ }
+
+ self.current_portfolio = {
+ 'positions': {},
+ 'sectors': {},
+ 'risk_budget': {},
+ 'last_rebalance': datetime.now()
+ }
+
+ self.is_running = False
+ self.update_interval = CONFIG.agent.update_frequency # seconds
+
+ # Setup logging
+ self._setup_logging()
+
+ def _setup_logging(self):
+ """Setup comprehensive logging"""
+ logging.basicConfig(
+ level=CONFIG.log_level,
+ format=CONFIG.log_format,
+ handlers=[
+ logging.FileHandler(CONFIG.logs_dir / f"hedge_fund_{datetime.now().strftime('%Y%m%d')}.log"),
+ logging.StreamHandler(sys.stdout)
+ ]
+ )
+
+ # Create separate loggers for different components
+ self.logger = logging.getLogger("HedgeFundOrchestrator")
+ self.trade_logger = logging.getLogger("TradingSignals")
+ self.risk_logger = logging.getLogger("RiskManagement")
+
+ async def run_analysis_cycle(self) -> Dict[str, Any]:
+ """Run one complete analysis cycle"""
+ cycle_start = time.time()
+ self.logger.info("Starting analysis cycle")
+
+ try:
+ # Run all agents concurrently
+ agent_reports = await self._run_all_agents()
+
+ # Generate trading signals
+ signals = self.decision_engine.aggregate_signals(agent_reports)
+
+ # Generate portfolio recommendation
+ portfolio_rec = self.decision_engine.generate_portfolio_recommendation(
+ signals, self.current_portfolio
+ )
+
+ # Execute trades (simulated)
+ execution_results = await self._execute_trades(signals, portfolio_rec)
+
+ # Update portfolio state
+ self._update_portfolio_state(execution_results, portfolio_rec)
+
+ # Log performance
+ cycle_time = time.time() - cycle_start
+ self.logger.info(f"Analysis cycle completed in {cycle_time:.2f} seconds")
+
+ return {
+ 'timestamp': datetime.now().isoformat(),
+ 'cycle_time': cycle_time,
+ 'agent_reports': agent_reports,
+ 'trading_signals': [self._signal_to_dict(s) for s in signals],
+ 'portfolio_recommendation': self._portfolio_to_dict(portfolio_rec),
+ 'execution_results': execution_results,
+ 'current_portfolio': self.current_portfolio
+ }
+
+ except Exception as e:
+ self.logger.error(f"Error in analysis cycle: {e}")
+ return {'error': str(e), 'timestamp': datetime.now().isoformat()}
+
+ async def _run_all_agents(self) -> Dict[str, Dict]:
+ """Run all agents concurrently"""
+ self.logger.info("Running agent analysis")
+
+ async def run_agent(name: str, agent):
+ try:
+ if hasattr(agent, 'get_cycle_report'):
+ return await agent.get_cycle_report()
+ elif hasattr(agent, 'get_policy_report'):
+ return await agent.get_policy_report()
+ elif hasattr(agent, 'get_geopolitical_report'):
+ return await agent.get_geopolitical_report()
+ else:
+ # Generic report method
+ return await agent.generate_report()
+ except Exception as e:
+ self.logger.error(f"Error running agent {name}: {e}")
+ return {'error': str(e), 'agent': name}
+
+ # Run agents concurrently
+ tasks = [run_agent(name, agent) for name, agent in self.agents.items()]
+ results = await asyncio.gather(*tasks, return_exceptions=True)
+
+ # Combine results
+ agent_reports = {}
+ for i, (name, agent) in enumerate(self.agents.items()):
+ if i < len(results) and not isinstance(results[i], Exception):
+ agent_reports[name] = results[i]
+ else:
+ self.logger.error(f"Agent {name} failed: {results[i] if i < len(results) else 'Unknown error'}")
+ agent_reports[name] = {'error': 'Agent failed', 'agent': name}
+
+ return agent_reports
+
+ async def _execute_trades(self, signals: List[TradingSignal],
+ portfolio_rec: PortfolioRecommendation) -> Dict[str, Any]:
+ """Execute trading signals (simulated)"""
+ self.trade_logger.info(f"Executing {len(signals)} trading signals")
+
+ executed_trades = []
+ total_trading_cost = 0.0
+
+ for signal in signals:
+ # Validate signal
+ if not self.risk_manager.validate_signal(signal, self.current_portfolio):
+ self.trade_logger.warning(f"Signal rejected by risk manager: {signal.asset_class}")
+ continue
+
+ # Calculate position size
+ market_volatility = self._estimate_market_volatility(signal.asset_class)
+ position_size = self.risk_manager.size_position(signal, market_volatility)
+
+ # Simulate execution
+ execution_price = self._get_execution_price(signal.asset_class)
+ trading_cost = position_size * CONFIG.trading.commission_rate
+ slippage_cost = position_size * CONFIG.trading.slippage_assumption
+
+ executed_trade = {
+ 'timestamp': datetime.now().isoformat(),
+ 'asset_class': signal.asset_class,
+ 'direction': signal.direction,
+ 'position_size': position_size,
+ 'execution_price': execution_price,
+ 'trading_cost': trading_cost,
+ 'slippage_cost': slippage_cost,
+ 'signal_conviction': signal.conviction
+ }
+
+ executed_trades.append(executed_trade)
+ total_trading_cost += trading_cost + slippage_cost
+
+ self.trade_logger.info(f"Executed: {signal.direction} {position_size:.3f} {signal.asset_class}")
+
+ return {
+ 'executed_trades': executed_trades,
+ 'total_trades': len(executed_trades),
+ 'total_trading_cost': total_trading_cost,
+ 'rejected_signals': len(signals) - len(executed_trades)
+ }
+
+ def _estimate_market_volatility(self, asset_class: str) -> float:
+ """Estimate market volatility for asset class"""
+ # Simplified volatility estimates
+ volatility_map = {
+ 'equities': 0.16,
+ 'bonds': 0.08,
+ 'commodities': 0.25,
+ 'USD': 0.12,
+ 'technology': 0.22,
+ 'energy': 0.30,
+ 'financials': 0.18
+ }
+
+ return volatility_map.get(asset_class, 0.15)
+
+ def _get_execution_price(self, asset_class: str) -> float:
+ """Get simulated execution price"""
+ # Simplified pricing - in production would use real market data
+ base_prices = {
+ 'equities': 100.0,
+ 'bonds': 98.5,
+ 'commodities': 85.2,
+ 'USD': 1.0,
+ 'technology': 105.3,
+ 'energy': 92.1
+ }
+
+ base_price = base_prices.get(asset_class, 100.0)
+ # Add small random variation
+ return base_price * (1 + np.random.normal(0, 0.002))
+
+ def _update_portfolio_state(self, execution_results: Dict,
+ portfolio_rec: PortfolioRecommendation):
+ """Update current portfolio state"""
+ # Update positions
+ for trade in execution_results.get('executed_trades', []):
+ asset_class = trade['asset_class']
+ position_change = trade['position_size'] * (1 if trade['direction'] == 'long' else -1)
+
+ self.current_portfolio['positions'][asset_class] = (
+ self.current_portfolio['positions'].get(asset_class, 0) + position_change
+ )
+
+ # Update sector allocations
+ self.current_portfolio['sectors'] = portfolio_rec.sector_weights
+
+ # Update risk budget
+ self.current_portfolio['risk_budget'] = portfolio_rec.risk_budget
+
+ # Update last rebalance time
+ self.current_portfolio['last_rebalance'] = datetime.now()
+
+ self.logger.info("Portfolio state updated")
+
+ def _signal_to_dict(self, signal: TradingSignal) -> Dict:
+ """Convert trading signal to dictionary"""
+ return {
+ 'timestamp': signal.timestamp.isoformat(),
+ 'asset_class': signal.asset_class,
+ 'direction': signal.direction,
+ 'conviction': signal.conviction,
+ 'position_size': signal.position_size,
+ 'time_horizon': signal.time_horizon,
+ 'risk_factors': signal.risk_factors,
+ 'supporting_agents': signal.supporting_agents,
+ 'market_regime': signal.market_regime
+ }
+
+ def _portfolio_to_dict(self, portfolio: PortfolioRecommendation) -> Dict:
+ """Convert portfolio recommendation to dictionary"""
+ return {
+ 'timestamp': portfolio.timestamp.isoformat(),
+ 'asset_allocation': portfolio.asset_allocation,
+ 'sector_weights': portfolio.sector_weights,
+ 'regional_weights': portfolio.regional_weights,
+ 'risk_budget': portfolio.risk_budget,
+ 'hedges': portfolio.hedges,
+ 'cash_allocation': portfolio.cash_allocation,
+ 'leverage': portfolio.leverage
+ }
+
+ async def start_continuous_operation(self):
+ """Start continuous hedge fund operation"""
+ self.is_running = True
+ self.logger.info("Starting continuous hedge fund operation")
+
+ try:
+ while self.is_running:
+ # Run analysis cycle
+ cycle_results = await self.run_analysis_cycle()
+
+ # Save results
+ await self._save_cycle_results(cycle_results)
+
+ # Wait for next cycle
+ await asyncio.sleep(self.update_interval)
+
+ except KeyboardInterrupt:
+ self.logger.info("Received shutdown signal")
+ except Exception as e:
+ self.logger.error(f"Error in continuous operation: {e}")
+ finally:
+ self.is_running = False
+ self.logger.info("Hedge fund operation stopped")
+
+ async def _save_cycle_results(self, results: Dict):
+ """Save cycle results for analysis"""
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ filename = CONFIG.data_dir / f"cycle_results_{timestamp}.json"
+
+ try:
+ with open(filename, 'w') as f:
+ json.dump(results, f, indent=2, default=str)
+ except Exception as e:
+ self.logger.error(f"Error saving results: {e}")
+
+ def stop(self):
+ """Stop the hedge fund operation"""
+ self.is_running = False
+ self.logger.info("Stopping hedge fund operation")
+
+ async def get_status(self) -> Dict[str, Any]:
+ """Get current system status"""
+ return {
+ 'timestamp': datetime.now().isoformat(),
+ 'is_running': self.is_running,
+ 'agents_count': len(self.agents),
+ 'current_portfolio': self.current_portfolio,
+ 'last_update': self.current_portfolio.get('last_rebalance', datetime.now()).isoformat(),
+ 'system_health': await self._check_system_health()
+ }
+
+ async def _check_system_health(self) -> Dict[str, str]:
+ """Check system health status"""
+ health = {}
+
+ # Check data feeds
+ try:
+ data_summary = self.data_manager.get_latest_data_summary()
+ health['data_feeds'] = 'healthy'
+ except Exception:
+ health['data_feeds'] = 'degraded'
+
+ # Check agent status
+ healthy_agents = sum(1 for agent in self.agents.values() if hasattr(agent, 'name'))
+ health['agents'] = 'healthy' if healthy_agents == len(self.agents) else 'degraded'
+
+ # Check configuration
+ try:
+ CONFIG.validate_config()
+ health['configuration'] = 'healthy'
+ except Exception:
+ health['configuration'] = 'error'
+
+ return health
+
+
+# Signal handlers for graceful shutdown
+def signal_handler(orchestrator):
+ def handler(signum, frame):
+ logging.info(f"Received signal {signum}")
+ orchestrator.stop()
+
+ return handler
+
+
+async def main():
+ """Main entry point"""
+ # Validate configuration
+ try:
+ CONFIG.validate_config()
+ print("✓ Configuration validated")
+ except Exception as e:
+ print(f"✗ Configuration error: {e}")
+ sys.exit(1)
+
+ # Initialize orchestrator
+ orchestrator = HedgeFundOrchestrator()
+
+ # Setup signal handlers
+ signal.signal(signal.SIGINT, signal_handler(orchestrator))
+ signal.signal(signal.SIGTERM, signal_handler(orchestrator))
+
+ print("\n🚀 AI Hedge Fund System Starting...")
+ print("=" * 50)
+
+ # Run single analysis cycle or continuous operation
+ if len(sys.argv) > 1 and sys.argv[1] == "--single-cycle":
+ print("Running single analysis cycle...")
+ results = await orchestrator.run_analysis_cycle()
+ print("\n📊 Analysis Results:")
+ print(json.dumps(results, indent=2, default=str))
+ else:
+ print("Starting continuous operation...")
+ print("Press Ctrl+C to stop")
+ await orchestrator.start_continuous_operation()
+
+ print("\n✅ System shutdown complete")
+
+
+if __name__ == "__main__":
+ asyncio.run(main())
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.py
new file mode 100644
index 000000000..c655932b0
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/regulatory_agent.py
@@ -0,0 +1,903 @@
+# -*- coding: utf-8 -*-
+# agents/regulatory_agent.py - Regulatory Intelligence Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+import re
+from collections import defaultdict
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class RegulatorySignal:
+ """Regulatory change signal structure"""
+ regulation_type: str
+ jurisdiction: str
+ impact_level: int # 1-10 scale
+ implementation_timeline: str
+ affected_sectors: List[str]
+ market_impact: Dict[str, float]
+ compliance_cost: float
+ competitive_advantage: Dict[str, float]
+ confidence: float
+
+
+@dataclass
+class PolicyChange:
+ """Policy change monitoring structure"""
+ policy_area: str
+ change_type: str # proposed, enacted, implemented
+ probability_passage: float
+ economic_impact: Dict[str, float]
+ sector_winners: List[str]
+ sector_losers: List[str]
+ timeline: str
+
+
+class RegulatoryAgent:
+ """Advanced regulatory intelligence and policy change analysis"""
+
+ def __init__(self):
+ self.name = "regulatory"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Regulatory domains and their market impact weights
+ self.regulatory_domains = {
+ "financial_regulation": {
+ "banking_rules": 0.25,
+ "securities_regulation": 0.20,
+ "derivatives_oversight": 0.15,
+ "crypto_regulation": 0.15,
+ "payment_systems": 0.10,
+ "systemic_risk": 0.15
+ },
+ "environmental_regulation": {
+ "carbon_pricing": 0.30,
+ "renewable_mandates": 0.25,
+ "emission_standards": 0.20,
+ "plastic_bans": 0.10,
+ "water_regulation": 0.08,
+ "biodiversity_rules": 0.07
+ },
+ "technology_regulation": {
+ "data_privacy": 0.25,
+ "ai_governance": 0.20,
+ "platform_regulation": 0.20,
+ "cybersecurity_rules": 0.15,
+ "semiconductor_controls": 0.20
+ },
+ "healthcare_regulation": {
+ "drug_pricing": 0.30,
+ "medical_device_approval": 0.25,
+ "telehealth_rules": 0.15,
+ "insurance_regulation": 0.15,
+ "public_health_policy": 0.15
+ },
+ "tax_policy": {
+ "corporate_tax_rates": 0.35,
+ "international_tax_coordination": 0.25,
+ "digital_services_tax": 0.20,
+ "carbon_tax": 0.20
+ }
+ }
+
+ # Sector impact mapping from regulatory changes
+ self.sector_impact_map = {
+ "financial_regulation": {
+ "banks": -0.6,
+ "insurance": -0.4,
+ "asset_management": -0.3,
+ "fintech": -0.5,
+ "real_estate": -0.2,
+ "consumer_finance": -0.4
+ },
+ "environmental_regulation": {
+ "oil_gas": -0.8,
+ "utilities": 0.3,
+ "renewable_energy": 0.7,
+ "automotive": -0.4,
+ "chemicals": -0.5,
+ "materials": -0.3,
+ "industrials": -0.2
+ },
+ "technology_regulation": {
+ "big_tech": -0.7,
+ "social_media": -0.8,
+ "semiconductors": -0.4,
+ "cybersecurity": 0.5,
+ "cloud_services": -0.3,
+ "telecommunications": -0.2
+ },
+ "healthcare_regulation": {
+ "pharmaceuticals": -0.5,
+ "biotechnology": -0.3,
+ "medical_devices": -0.4,
+ "health_insurance": -0.6,
+ "hospitals": -0.3,
+ "telehealth": 0.4
+ },
+ "tax_policy": {
+ "multinational_corps": -0.6,
+ "domestic_focused": 0.2,
+ "high_margin_tech": -0.5,
+ "capital_intensive": 0.1,
+ "dividend_stocks": -0.3
+ }
+ }
+
+ # Regulatory keyword patterns
+ self.regulatory_keywords = {
+ "proposal_stage": [
+ "proposed rule", "draft regulation", "consultation paper",
+ "request for comment", "policy proposal", "legislative draft"
+ ],
+ "advancement_stage": [
+ "committee approval", "senate passage", "house passage",
+ "regulatory approval", "agency adoption", "cabinet approval"
+ ],
+ "implementation_stage": [
+ "effective date", "compliance deadline", "enforcement begins",
+ "mandatory compliance", "phased implementation", "grace period"
+ ],
+ "enforcement_action": [
+ "regulatory fine", "enforcement action", "compliance violation",
+ "penalty imposed", "consent order", "regulatory sanction"
+ ]
+ }
+
+ # Jurisdictional weights based on global market impact
+ self.jurisdiction_weights = {
+ "United_States": 0.35,
+ "European_Union": 0.25,
+ "China": 0.20,
+ "United_Kingdom": 0.10,
+ "Japan": 0.05,
+ "Other": 0.05
+ }
+
+ async def analyze_regulatory_landscape(self) -> List[RegulatorySignal]:
+ """Comprehensive regulatory landscape analysis"""
+ signals = []
+
+ try:
+ # Analyze each regulatory domain
+ for domain, regulations in self.regulatory_domains.items():
+ domain_signals = await self._analyze_regulatory_domain(domain, regulations)
+ signals.extend(domain_signals)
+
+ # Sort by impact level and confidence
+ signals.sort(key=lambda x: x.impact_level * x.confidence, reverse=True)
+
+ return signals[:15] # Return top 15 regulatory signals
+
+ except Exception as e:
+ logging.error(f"Error in regulatory landscape analysis: {e}")
+ return [self._default_regulatory_signal()]
+
+ async def _analyze_regulatory_domain(self, domain: str, regulations: Dict[str, float]) -> List[RegulatorySignal]:
+ """Analyze specific regulatory domain"""
+ domain_signals = []
+
+ # Get news data for this domain
+ news_data = await self._fetch_regulatory_news(domain, list(regulations.keys()))
+
+ for regulation, weight in regulations.items():
+ try:
+ # Filter news for this specific regulation
+ relevant_news = [news for news in news_data
+ if self._is_relevant_to_regulation(news, regulation, domain)]
+
+ if not relevant_news:
+ continue
+
+ # Analyze regulatory stage and probability
+ stage_analysis = self._analyze_regulatory_stage(relevant_news)
+
+ # Calculate impact level
+ impact_level = self._calculate_regulatory_impact(relevant_news, regulation, domain, weight)
+
+ # Determine affected sectors
+ affected_sectors = self._get_affected_sectors(domain, impact_level)
+
+ # Calculate market impact
+ market_impact = self._calculate_market_impact(domain, regulation, impact_level)
+
+ # Estimate compliance costs
+ compliance_cost = self._estimate_compliance_cost(regulation, domain, impact_level)
+
+ # Identify competitive advantages
+ competitive_advantage = self._analyze_competitive_impact(domain, regulation, relevant_news)
+
+ # Generate timeline
+ timeline = self._estimate_implementation_timeline(stage_analysis, relevant_news)
+
+ # Calculate confidence
+ confidence = self._calculate_regulatory_confidence(relevant_news, stage_analysis)
+
+ signal = RegulatorySignal(
+ regulation_type=f"{domain}_{regulation}",
+ jurisdiction=self._determine_jurisdiction(relevant_news),
+ impact_level=impact_level,
+ implementation_timeline=timeline,
+ affected_sectors=affected_sectors,
+ market_impact=market_impact,
+ compliance_cost=compliance_cost,
+ competitive_advantage=competitive_advantage,
+ confidence=confidence
+ )
+
+ domain_signals.append(signal)
+
+ except Exception as e:
+ logging.error(f"Error analyzing regulation {regulation}: {e}")
+ continue
+
+ return domain_signals
+
+ async def _fetch_regulatory_news(self, domain: str, regulations: List[str]) -> List[DataPoint]:
+ """Fetch regulatory news for specific domain"""
+ all_news = []
+
+ # Create domain-specific search queries
+ domain_queries = {
+ "financial_regulation": ["banking regulation", "financial oversight", "securities rules",
+ "fintech regulation"],
+ "environmental_regulation": ["environmental regulation", "carbon policy", "emissions standards",
+ "green legislation"],
+ "technology_regulation": ["tech regulation", "data privacy", "ai governance", "platform oversight"],
+ "healthcare_regulation": ["healthcare policy", "drug regulation", "medical device approval",
+ "health insurance"],
+ "tax_policy": ["tax reform", "corporate tax", "international taxation", "digital tax"]
+ }
+
+ queries = domain_queries.get(domain, [domain.replace("_", " ")])
+
+ for query in queries:
+ try:
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": query,
+ "sources": ["reuters", "bloomberg", "wsj", "ft"],
+ "hours_back": 168 # 1 week
+ }
+ })
+
+ if "news" in news_data:
+ all_news.extend(news_data["news"])
+
+ except Exception as e:
+ logging.error(f"Error fetching regulatory news for {query}: {e}")
+ continue
+
+ return all_news
+
+ def _is_relevant_to_regulation(self, news: DataPoint, regulation: str, domain: str) -> bool:
+ """Check if news is relevant to specific regulation"""
+ text = (news.value + " " + news.metadata.get("description", "")).lower()
+
+ # Create regulation-specific keywords
+ regulation_keywords = {
+ "banking_rules": ["basel", "capital requirements", "stress test", "bank supervision"],
+ "carbon_pricing": ["carbon tax", "cap and trade", "emissions trading", "carbon border"],
+ "data_privacy": ["gdpr", "data protection", "privacy regulation", "data governance"],
+ "drug_pricing": ["prescription drug", "medicare negotiation", "drug pricing", "pharmaceutical"],
+ "ai_governance": ["artificial intelligence", "ai regulation", "algorithmic oversight", "ai safety"]
+ }
+
+ keywords = regulation_keywords.get(regulation, [regulation.replace("_", " ")])
+
+ # Also check for regulatory action keywords
+ regulatory_action_keywords = [
+ "regulation", "policy", "rule", "legislation", "bill", "act",
+ "oversight", "compliance", "enforcement", "approval", "mandate"
+ ]
+
+ has_regulation_keyword = any(keyword in text for keyword in keywords)
+ has_action_keyword = any(keyword in text for keyword in regulatory_action_keywords)
+
+ return has_regulation_keyword and has_action_keyword
+
+ def _analyze_regulatory_stage(self, news: List[DataPoint]) -> Dict[str, float]:
+ """Analyze what stage regulations are in"""
+ stage_scores = {
+ "proposal": 0.0,
+ "advancement": 0.0,
+ "implementation": 0.0,
+ "enforcement": 0.0
+ }
+
+ total_articles = len(news)
+ if total_articles == 0:
+ return stage_scores
+
+ for article in news:
+ text = article.value.lower()
+
+ # Count stage indicators
+ for stage, keywords in self.regulatory_keywords.items():
+ stage_name = stage.replace("_stage", "").replace("_action", "")
+ for keyword in keywords:
+ if keyword in text:
+ stage_scores[stage_name] += article.confidence / total_articles
+
+ return stage_scores
+
+ def _calculate_regulatory_impact(self, news: List[DataPoint], regulation: str,
+ domain: str, weight: float) -> int:
+ """Calculate regulatory impact level (1-10)"""
+ if not news:
+ return 3
+
+ # Base impact levels by regulation type
+ base_impacts = {
+ "banking_rules": 7,
+ "carbon_pricing": 8,
+ "data_privacy": 6,
+ "drug_pricing": 8,
+ "corporate_tax_rates": 9,
+ "ai_governance": 5,
+ "securities_regulation": 6
+ }
+
+ base_impact = base_impacts.get(regulation, 5)
+
+ # Analyze news intensity and scope
+ high_impact_keywords = [
+ "sweeping changes", "major reform", "significant impact", "industry transformation",
+ "mandatory compliance", "substantial penalties", "widespread adoption",
+ "market disruption", "regulatory overhaul", "unprecedented"
+ ]
+
+ scope_indicators = [
+ "global", "international", "nationwide", "industry-wide", "comprehensive",
+ "all companies", "every business", "mandatory for all"
+ ]
+
+ intensity_score = 0
+ scope_score = 0
+
+ for article in news:
+ text = article.value.lower()
+ intensity_score += sum(1 for keyword in high_impact_keywords if keyword in text)
+ scope_score += sum(1 for keyword in scope_indicators if keyword in text)
+
+ # Adjust base impact
+ if news:
+ intensity_factor = min(intensity_score / len(news), 2.0)
+ scope_factor = min(scope_score / len(news), 1.5)
+ weight_factor = weight * 2 # Domain weight influence
+
+ adjusted_impact = base_impact + intensity_factor + scope_factor + weight_factor
+ else:
+ adjusted_impact = base_impact
+
+ return int(np.clip(adjusted_impact, 1, 10))
+
+ def _get_affected_sectors(self, domain: str, impact_level: int) -> List[str]:
+ """Get sectors affected by regulatory domain"""
+ if domain not in self.sector_impact_map:
+ return ["broad_market"]
+
+ sector_impacts = self.sector_impact_map[domain]
+
+ # Filter sectors by impact threshold
+ threshold = 0.2 if impact_level > 7 else 0.3 if impact_level > 5 else 0.4
+
+ affected_sectors = []
+ for sector, impact in sector_impacts.items():
+ if abs(impact) >= threshold:
+ affected_sectors.append(sector)
+
+ return affected_sectors or ["broad_market"]
+
+ def _calculate_market_impact(self, domain: str, regulation: str, impact_level: int) -> Dict[str, float]:
+ """Calculate expected market impact by asset class"""
+ if domain not in self.sector_impact_map:
+ return {"broad_market": 0.0}
+
+ sector_impacts = self.sector_impact_map[domain]
+
+ # Scale impacts by regulation impact level
+ impact_multiplier = impact_level / 10.0
+
+ market_impacts = {}
+ for sector, base_impact in sector_impacts.items():
+ scaled_impact = base_impact * impact_multiplier
+ market_impacts[sector] = np.clip(scaled_impact, -1.0, 1.0)
+
+ return market_impacts
+
+ def _estimate_compliance_cost(self, regulation: str, domain: str, impact_level: int) -> float:
+ """Estimate compliance cost as percentage of revenue"""
+ # Base compliance costs by regulation type (% of revenue)
+ base_costs = {
+ "banking_rules": 0.015, # 1.5% of revenue
+ "data_privacy": 0.008, # 0.8% of revenue
+ "emissions_standards": 0.012, # 1.2% of revenue
+ "drug_pricing": 0.005, # 0.5% of revenue
+ "cybersecurity_rules": 0.010 # 1.0% of revenue
+ }
+
+ base_cost = base_costs.get(regulation, 0.005)
+
+ # Scale by impact level
+ impact_multiplier = impact_level / 5.0 # Normalize around level 5
+
+ return base_cost * impact_multiplier
+
+ def _analyze_competitive_impact(self, domain: str, regulation: str,
+ news: List[DataPoint]) -> Dict[str, float]:
+ """Analyze which companies/sectors gain competitive advantage"""
+ competitive_advantages = {}
+
+ # Analyze news for competitive implications
+ advantage_keywords = {
+ "large_companies": ["economies of scale", "large companies benefit", "big players advantage"],
+ "incumbents": ["existing players", "incumbent advantage", "barriers to entry"],
+ "tech_leaders": ["technology advantage", "innovation leaders", "digital transformation"],
+ "compliance_specialists": ["compliance expertise", "regulatory experience", "specialized knowledge"]
+ }
+
+ for company_type, keywords in advantage_keywords.items():
+ advantage_score = 0.0
+
+ for article in news:
+ text = article.value.lower()
+ keyword_count = sum(1 for keyword in keywords if keyword in text)
+ advantage_score += keyword_count * article.confidence
+
+ if news and advantage_score > 0:
+ competitive_advantages[company_type] = min(advantage_score / len(news), 1.0)
+
+ return competitive_advantages
+
+ def _estimate_implementation_timeline(self, stage_analysis: Dict[str, float],
+ news: List[DataPoint]) -> str:
+ """Estimate regulatory implementation timeline"""
+ # Determine current stage
+ current_stage = max(stage_analysis.items(), key=lambda x: x[1])[0]
+
+ # Timeline estimates by stage
+ timeline_estimates = {
+ "proposal": "12-24 months",
+ "advancement": "6-18 months",
+ "implementation": "3-12 months",
+ "enforcement": "Immediate"
+ }
+
+ base_timeline = timeline_estimates.get(current_stage, "12-24 months")
+
+ # Look for specific timeline mentions in news
+ timeline_patterns = [
+ r"(\d+)\s*months?",
+ r"(\d+)\s*years?",
+ r"by\s+(\d{4})",
+ r"effective\s+(\w+\s+\d{1,2},?\s+\d{4})"
+ ]
+
+ for article in news:
+ text = article.value
+ for pattern in timeline_patterns:
+ matches = re.findall(pattern, text, re.IGNORECASE)
+ if matches:
+ # Found specific timeline mention
+ return f"Specific timeline mentioned: {matches[0]}"
+
+ return base_timeline
+
+ def _determine_jurisdiction(self, news: List[DataPoint]) -> str:
+ """Determine primary jurisdiction from news"""
+ jurisdiction_keywords = {
+ "United_States": ["usa", "united states", "sec", "fed", "congress", "senate", "house"],
+ "European_Union": ["eu", "european union", "brussels", "european commission", "esma"],
+ "China": ["china", "beijing", "pboc", "csrc", "chinese regulators"],
+ "United_Kingdom": ["uk", "united kingdom", "fca", "pra", "bank of england"],
+ "Japan": ["japan", "jfsa", "boj", "bank of japan"]
+ }
+
+ jurisdiction_scores = {j: 0 for j in jurisdiction_keywords.keys()}
+
+ for article in news:
+ text = article.value.lower()
+ for jurisdiction, keywords in jurisdiction_keywords.items():
+ score = sum(1 for keyword in keywords if keyword in text)
+ jurisdiction_scores[jurisdiction] += score * article.confidence
+
+ if any(jurisdiction_scores.values()):
+ return max(jurisdiction_scores.items(), key=lambda x: x[1])[0]
+
+ return "Multiple/Global"
+
+ def _calculate_regulatory_confidence(self, news: List[DataPoint],
+ stage_analysis: Dict[str, float]) -> float:
+ """Calculate confidence in regulatory analysis"""
+ confidence_factors = []
+
+ # News volume and quality
+ if news:
+ news_confidence = min(len(news) / 10, 1.0) * 0.3 # Optimal around 10 articles
+ source_quality = np.mean([article.confidence for article in news]) * 0.4
+ confidence_factors.extend([news_confidence, source_quality])
+ else:
+ confidence_factors.extend([0.1, 0.2])
+
+ # Stage clarity - clearer stage = higher confidence
+ max_stage_score = max(stage_analysis.values()) if stage_analysis else 0
+ stage_confidence = max_stage_score * 0.3
+ confidence_factors.append(stage_confidence)
+
+ return np.sum(confidence_factors)
+
+ def _default_regulatory_signal(self) -> RegulatorySignal:
+ """Return default regulatory signal"""
+ return RegulatorySignal(
+ regulation_type="general_regulatory_uncertainty",
+ jurisdiction="Global",
+ impact_level=5,
+ implementation_timeline="12-24 months",
+ affected_sectors=["broad_market"],
+ market_impact={"broad_market": 0.0},
+ compliance_cost=0.005,
+ competitive_advantage={},
+ confidence=0.3
+ )
+
+ async def analyze_policy_changes(self) -> List[PolicyChange]:
+ """Analyze upcoming policy changes and their market implications"""
+ policy_changes = []
+
+ policy_areas = [
+ "tax_reform", "healthcare_policy", "infrastructure_spending",
+ "trade_policy", "energy_policy", "immigration_policy"
+ ]
+
+ for policy_area in policy_areas:
+ try:
+ change = await self._analyze_specific_policy(policy_area)
+ if change:
+ policy_changes.append(change)
+ except Exception as e:
+ logging.error(f"Error analyzing policy {policy_area}: {e}")
+ continue
+
+ return policy_changes
+
+ async def _analyze_specific_policy(self, policy_area: str) -> Optional[PolicyChange]:
+ """Analyze specific policy area for changes"""
+ # Get policy-related news
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": policy_area.replace("_", " "),
+ "sources": ["reuters", "bloomberg", "wsj"],
+ "hours_back": 72
+ }
+ })
+
+ news = news_data.get("news", [])
+ if not news:
+ return None
+
+ # Analyze policy change type and probability
+ change_type = self._determine_policy_change_type(news)
+ probability = self._calculate_passage_probability(news, policy_area)
+
+ if probability < 0.2: # Skip low-probability changes
+ return None
+
+ # Calculate economic impact
+ economic_impact = self._calculate_policy_economic_impact(policy_area, news)
+
+ # Identify winners and losers
+ winners, losers = self._identify_policy_winners_losers(policy_area)
+
+ # Estimate timeline
+ timeline = self._estimate_policy_timeline(news, change_type)
+
+ return PolicyChange(
+ policy_area=policy_area,
+ change_type=change_type,
+ probability_passage=probability,
+ economic_impact=economic_impact,
+ sector_winners=winners,
+ sector_losers=losers,
+ timeline=timeline
+ )
+
+ def _determine_policy_change_type(self, news: List[DataPoint]) -> str:
+ """Determine type of policy change"""
+ change_keywords = {
+ "proposed": ["proposed", "draft", "plan", "considering", "exploring"],
+ "enacted": ["passed", "approved", "enacted", "signed", "adopted"],
+ "implemented": ["effective", "implementation", "rollout", "enforcement"]
+ }
+
+ change_scores = {change_type: 0 for change_type in change_keywords.keys()}
+
+ for article in news:
+ text = article.value.lower()
+ for change_type, keywords in change_keywords.items():
+ score = sum(1 for keyword in keywords if keyword in text)
+ change_scores[change_type] += score
+
+ return max(change_scores.items(), key=lambda x: x[1])[0] if any(change_scores.values()) else "proposed"
+
+ def _calculate_passage_probability(self, news: List[DataPoint], policy_area: str) -> float:
+ """Calculate probability of policy passage"""
+ # Base probabilities by policy area and political difficulty
+ base_probabilities = {
+ "tax_reform": 0.4,
+ "healthcare_policy": 0.3,
+ "infrastructure_spending": 0.6,
+ "trade_policy": 0.5,
+ "energy_policy": 0.4,
+ "immigration_policy": 0.2
+ }
+
+ base_prob = base_probabilities.get(policy_area, 0.4)
+
+ # Analyze news sentiment for passage likelihood
+ positive_indicators = ["bipartisan support", "broad agreement", "likely to pass", "strong support"]
+ negative_indicators = ["opposition", "unlikely to pass", "political deadlock", "controversy"]
+
+ positive_score = 0
+ negative_score = 0
+
+ for article in news:
+ text = article.value.lower()
+ positive_score += sum(1 for indicator in positive_indicators if indicator in text)
+ negative_score += sum(1 for indicator in negative_indicators if indicator in text)
+
+ # Adjust probability based on sentiment
+ if news:
+ sentiment_adjustment = (positive_score - negative_score) / len(news) * 0.3
+ adjusted_prob = base_prob + sentiment_adjustment
+ else:
+ adjusted_prob = base_prob
+
+ return np.clip(adjusted_prob, 0.0, 1.0)
+
+ def _calculate_policy_economic_impact(self, policy_area: str, news: List[DataPoint]) -> Dict[str, float]:
+ """Calculate economic impact of policy changes"""
+ # Base economic impacts by policy area (% GDP impact)
+ base_impacts = {
+ "tax_reform": {"gdp_growth": 0.3, "business_investment": 0.5, "consumer_spending": 0.2},
+ "infrastructure_spending": {"gdp_growth": 0.8, "employment": 0.6, "productivity": 0.4},
+ "healthcare_policy": {"healthcare_costs": -0.3, "business_costs": 0.2, "innovation": -0.1},
+ "trade_policy": {"trade_volumes": 0.4, "manufacturing": 0.3, "consumer_prices": -0.2},
+ "energy_policy": {"energy_costs": -0.2, "green_investment": 0.6, "traditional_energy": -0.4}
+ }
+
+ return base_impacts.get(policy_area, {"gdp_growth": 0.1})
+
+ def _identify_policy_winners_losers(self, policy_area: str) -> Tuple[List[str], List[str]]:
+ """Identify sector winners and losers from policy changes"""
+ policy_impacts = {
+ "tax_reform": {
+ "winners": ["domestic_companies", "small_business", "manufacturing"],
+ "losers": ["multinationals", "high_tax_rate_sectors"]
+ },
+ "infrastructure_spending": {
+ "winners": ["construction", "materials", "industrials", "transportation"],
+ "losers": ["bond_investors"] # Higher deficits
+ },
+ "healthcare_policy": {
+ "winners": ["healthcare_providers", "medical_devices"],
+ "losers": ["pharmaceuticals", "health_insurance"]
+ },
+ "energy_policy": {
+ "winners": ["renewable_energy", "electric_vehicles", "grid_infrastructure"],
+ "losers": ["fossil_fuels", "traditional_utilities"]
+ }
+ }
+
+ impacts = policy_impacts.get(policy_area, {"winners": [], "losers": []})
+ return impacts["winners"], impacts["losers"]
+
+ def _estimate_policy_timeline(self, news: List[DataPoint], change_type: str) -> str:
+ """Estimate policy implementation timeline"""
+ timeline_map = {
+ "proposed": "6-18 months to passage",
+ "enacted": "3-12 months to implementation",
+ "implemented": "Currently rolling out"
+ }
+
+ return timeline_map.get(change_type, "12-24 months")
+
+ async def get_regulatory_report(self) -> Dict:
+ """Generate comprehensive regulatory intelligence report"""
+ # Analyze regulatory landscape
+ regulatory_signals = await self.analyze_regulatory_landscape()
+
+ # Analyze policy changes
+ policy_changes = await self.analyze_policy_changes()
+
+ # Generate LLM analysis
+ llm_analysis = await self._generate_regulatory_llm_analysis(regulatory_signals, policy_changes)
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "regulatory_landscape": {
+ "high_impact_regulations": [{
+ "regulation": signal.regulation_type,
+ "jurisdiction": signal.jurisdiction,
+ "impact_level": signal.impact_level,
+ "timeline": signal.implementation_timeline,
+ "affected_sectors": signal.affected_sectors,
+ "market_impact": signal.market_impact
+ } for signal in regulatory_signals[:5]],
+ "compliance_cost_estimate": np.mean([s.compliance_cost for s in regulatory_signals]),
+ "overall_regulatory_pressure": np.mean([s.impact_level for s in regulatory_signals])
+ },
+ "policy_changes": [{
+ "policy_area": change.policy_area,
+ "change_type": change.change_type,
+ "probability": change.probability_passage,
+ "economic_impact": change.economic_impact,
+ "winners": change.sector_winners,
+ "losers": change.sector_losers,
+ "timeline": change.timeline
+ } for change in policy_changes],
+ "investment_implications": {
+ "defensive_sectors": self._get_defensive_regulatory_sectors(regulatory_signals),
+ "regulatory_beneficiaries": self._get_regulatory_beneficiaries(regulatory_signals),
+ "compliance_leaders": self._get_compliance_advantage_sectors(regulatory_signals),
+ "regulatory_risk_sectors": self._get_high_risk_sectors(regulatory_signals)
+ },
+ "llm_analysis": llm_analysis,
+ "monitoring_priorities": {
+ "key_regulations": [s.regulation_type for s in regulatory_signals[:3]],
+ "high_probability_policies": [c.policy_area for c in policy_changes if c.probability_passage > 0.6],
+ "immediate_compliance_deadlines": [s.regulation_type for s in regulatory_signals
+ if "months" in s.implementation_timeline and
+ int(s.implementation_timeline.split()[0]) <= 6]
+ }
+ }
+
+ async def _generate_regulatory_llm_analysis(self, signals: List[RegulatorySignal],
+ policy_changes: List[PolicyChange]) -> Dict:
+ """Generate LLM-enhanced regulatory analysis"""
+ try:
+ # Prepare regulatory summary
+ reg_summary = self._prepare_regulatory_summary(signals)
+ policy_summary = self._prepare_policy_summary(policy_changes)
+
+ prompt = f"""
+ As a senior regulatory affairs analyst, analyze the current regulatory landscape and provide investment guidance.
+
+ Key Regulatory Developments:
+ {reg_summary}
+
+ Policy Changes:
+ {policy_summary}
+
+ Please provide:
+ 1. Most critical regulatory risks requiring immediate attention
+ 2. Regulatory arbitrage opportunities (sectors benefiting from regulatory changes)
+ 3. Compliance cost leaders vs laggards investment strategy
+ 4. Timeline for next major regulatory wave
+ 5. Sector rotation recommendations based on regulatory trends
+ 6. Early warning indicators for regulatory surprises
+
+ Format as JSON with keys: critical_risks, arbitrage_opportunities, compliance_strategy,
+ regulatory_timeline, sector_rotation, early_warning_indicators
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM regulatory analysis: {e}")
+ return {
+ "critical_risks": ["Financial regulation tightening", "ESG compliance requirements"],
+ "arbitrage_opportunities": ["Compliance technology", "Renewable energy"],
+ "compliance_strategy": "Focus on established players with regulatory expertise",
+ "regulatory_timeline": "Next 12-18 months",
+ "sector_rotation": "Overweight compliance leaders, underweight regulatory laggards",
+ "early_warning_indicators": ["Congressional hearings", "Agency enforcement actions"]
+ }
+
+ def _prepare_regulatory_summary(self, signals: List[RegulatorySignal]) -> str:
+ """Prepare regulatory summary for LLM"""
+ summary_lines = []
+
+ for signal in signals[:5]: # Top 5 signals
+ summary_lines.append(
+ f"{signal.regulation_type} ({signal.jurisdiction}): "
+ f"Impact Level {signal.impact_level}/10, "
+ f"Timeline: {signal.implementation_timeline}, "
+ f"Sectors: {', '.join(signal.affected_sectors[:3])}, "
+ f"Compliance Cost: {signal.compliance_cost:.1%}"
+ )
+
+ return "\n".join(summary_lines)
+
+ def _prepare_policy_summary(self, policy_changes: List[PolicyChange]) -> str:
+ """Prepare policy changes summary for LLM"""
+ summary_lines = []
+
+ for policy in policy_changes:
+ summary_lines.append(
+ f"{policy.policy_area}: {policy.change_type} "
+ f"(Probability: {policy.probability_passage:.0%}), "
+ f"Winners: {', '.join(policy.sector_winners[:2])}, "
+ f"Losers: {', '.join(policy.sector_losers[:2])}"
+ )
+
+ return "\n".join(summary_lines)
+
+ def _get_defensive_regulatory_sectors(self, signals: List[RegulatorySignal]) -> List[str]:
+ """Get sectors that are defensive against regulatory risk"""
+ defensive_sectors = []
+
+ # Sectors typically less affected by regulation
+ inherently_defensive = ["utilities", "consumer_staples", "healthcare_providers"]
+
+ # Sectors with positive regulatory tailwinds
+ for signal in signals:
+ for sector, impact in signal.market_impact.items():
+ if impact > 0.3: # Positive regulatory impact
+ defensive_sectors.append(sector)
+
+ all_defensive = inherently_defensive + defensive_sectors
+ return list(set(all_defensive)) # Remove duplicates
+
+ def _get_regulatory_beneficiaries(self, signals: List[RegulatorySignal]) -> List[str]:
+ """Get sectors that benefit from regulatory changes"""
+ beneficiaries = []
+
+ for signal in signals:
+ for sector, impact in signal.market_impact.items():
+ if impact > 0.4: # Strong positive impact
+ beneficiaries.append(sector)
+
+ # Check competitive advantages
+ for advantage_type, score in signal.competitive_advantage.items():
+ if score > 0.5 and advantage_type == "compliance_specialists":
+ beneficiaries.extend(["legal_services", "compliance_tech", "consulting"])
+
+ return list(set(beneficiaries))
+
+ def _get_compliance_advantage_sectors(self, signals: List[RegulatorySignal]) -> List[str]:
+ """Get sectors with compliance competitive advantages"""
+ advantage_sectors = []
+
+ for signal in signals:
+ for advantage_type, score in signal.competitive_advantage.items():
+ if score > 0.4:
+ if advantage_type == "large_companies":
+ advantage_sectors.extend(["mega_cap_stocks", "blue_chip_companies"])
+ elif advantage_type == "tech_leaders":
+ advantage_sectors.extend(["technology", "software"])
+ elif advantage_type == "incumbents":
+ advantage_sectors.extend(["established_players"])
+
+ return list(set(advantage_sectors))
+
+ def _get_high_risk_sectors(self, signals: List[RegulatorySignal]) -> List[str]:
+ """Get sectors with high regulatory risk"""
+ high_risk_sectors = []
+
+ for signal in signals:
+ if signal.impact_level >= 7: # High impact regulations
+ for sector, impact in signal.market_impact.items():
+ if impact < -0.3: # Negative impact
+ high_risk_sectors.append(sector)
+
+ return list(set(high_risk_sectors))
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.py
new file mode 100644
index 000000000..a23c98ead
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/sentiment_agent.py
@@ -0,0 +1,875 @@
+# -*- coding: utf-8 -*-
+# agents/sentiment_agent.py - Market Sentiment Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+from textblob import TextBlob
+import re
+from collections import defaultdict, Counter
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class SentimentSignal:
+ """Market sentiment signal structure"""
+ source: str
+ sentiment_score: float # -1 to 1
+ intensity: float # 0 to 1
+ reliability: float
+ trend: str # improving, deteriorating, stable
+ contrarian_signal: bool
+ affected_assets: List[str]
+ time_horizon: str
+
+
+@dataclass
+class FearGreedMetrics:
+ """Fear & Greed index components"""
+ vix_level: float
+ put_call_ratio: float
+ safe_haven_flows: float
+ momentum_strength: float
+ overall_score: int # 0-100
+ classification: str # extreme_fear, fear, neutral, greed, extreme_greed
+
+
+class SentimentAgent:
+ """Advanced market sentiment analysis and contrarian signal generation"""
+
+ def __init__(self):
+ self.name = "sentiment"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Sentiment sources and their reliability weights
+ self.sentiment_sources = {
+ "financial_news": {
+ "reuters": 0.25,
+ "bloomberg": 0.25,
+ "wsj": 0.20,
+ "ft": 0.15,
+ "cnbc": 0.10,
+ "marketwatch": 0.05
+ },
+ "social_media": {
+ "twitter_fintwit": 0.40,
+ "reddit_investing": 0.25,
+ "reddit_wallstreetbets": 0.20,
+ "stocktwits": 0.15
+ },
+ "analyst_sentiment": {
+ "upgrade_downgrade": 0.35,
+ "earnings_revisions": 0.30,
+ "price_target_changes": 0.25,
+ "recommendation_changes": 0.10
+ },
+ "market_indicators": {
+ "vix": 0.30,
+ "put_call_ratio": 0.25,
+ "high_low_index": 0.20,
+ "advance_decline": 0.25
+ }
+ }
+
+ # Sentiment keywords with weights
+ self.sentiment_keywords = {
+ "extremely_bullish": {
+ "keywords": ["moon", "rocket", "bull run", "unstoppable", "explosive growth",
+ "parabolic", "to the stars", "massive rally", "euphoric"],
+ "weight": 1.0,
+ "contrarian_signal": True
+ },
+ "bullish": {
+ "keywords": ["bullish", "optimistic", "positive", "uptrend", "rally", "growth",
+ "strong", "buy", "accumulate", "opportunity"],
+ "weight": 0.6,
+ "contrarian_signal": False
+ },
+ "neutral": {
+ "keywords": ["neutral", "mixed", "uncertain", "wait and see", "sideways",
+ "balanced", "cautious", "hold"],
+ "weight": 0.0,
+ "contrarian_signal": False
+ },
+ "bearish": {
+ "keywords": ["bearish", "pessimistic", "negative", "downtrend", "decline",
+ "weakness", "sell", "avoid", "risk"],
+ "weight": -0.6,
+ "contrarian_signal": False
+ },
+ "extremely_bearish": {
+ "keywords": ["crash", "collapse", "doom", "disaster", "panic", "bloodbath",
+ "capitulation", "apocalypse", "end times", "dead"],
+ "weight": -1.0,
+ "contrarian_signal": True
+ }
+ }
+
+ # Asset class sentiment mapping
+ self.asset_sentiment_keywords = {
+ "stocks": ["equity", "stock", "shares", "s&p", "nasdaq", "dow"],
+ "bonds": ["bonds", "treasury", "yield", "fixed income", "debt"],
+ "gold": ["gold", "precious metals", "safe haven"],
+ "crypto": ["bitcoin", "crypto", "ethereum", "digital assets"],
+ "oil": ["oil", "crude", "energy", "petroleum"],
+ "dollar": ["dollar", "usd", "currency", "forex"]
+ }
+
+ # Contrarian sentiment thresholds
+ self.contrarian_thresholds = {
+ "extreme_bullish": 0.8, # When sentiment too positive
+ "extreme_bearish": -0.8, # When sentiment too negative
+ "consensus_threshold": 0.7 # When consensus too strong
+ }
+
+ async def analyze_market_sentiment(self) -> Dict[str, SentimentSignal]:
+ """Comprehensive market sentiment analysis across all sources"""
+ sentiment_signals = {}
+
+ try:
+ # Analyze news sentiment
+ news_sentiment = await self._analyze_news_sentiment()
+ if news_sentiment:
+ sentiment_signals["news"] = news_sentiment
+
+ # Analyze social media sentiment
+ social_sentiment = await self._analyze_social_sentiment()
+ if social_sentiment:
+ sentiment_signals["social_media"] = social_sentiment
+
+ # Analyze analyst sentiment
+ analyst_sentiment = await self._analyze_analyst_sentiment()
+ if analyst_sentiment:
+ sentiment_signals["analyst"] = analyst_sentiment
+
+ # Analyze market-based sentiment indicators
+ market_sentiment = await self._analyze_market_indicators()
+ if market_sentiment:
+ sentiment_signals["market_indicators"] = market_sentiment
+
+ return sentiment_signals
+
+ except Exception as e:
+ logging.error(f"Error in market sentiment analysis: {e}")
+ return {"error": self._default_sentiment_signal()}
+
+ async def _analyze_news_sentiment(self) -> Optional[SentimentSignal]:
+ """Analyze sentiment from financial news"""
+ try:
+ # Fetch financial news
+ news_data = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": "stock market economy investment",
+ "sources": list(self.sentiment_sources["financial_news"].keys()),
+ "hours_back": 24
+ }
+ })
+
+ news_articles = news_data.get("news", [])
+ if not news_articles:
+ return None
+
+ # Analyze sentiment for each article
+ sentiment_scores = []
+ source_weights = []
+ asset_mentions = defaultdict(int)
+
+ for article in news_articles:
+ # Get sentiment score
+ sentiment_score = self._calculate_text_sentiment(article.value)
+
+ # Get source weight
+ source_name = article.source.lower()
+ source_weight = self.sentiment_sources["financial_news"].get(source_name, 0.05)
+
+ sentiment_scores.append(sentiment_score * article.confidence)
+ source_weights.append(source_weight)
+
+ # Count asset mentions
+ self._count_asset_mentions(article.value, asset_mentions)
+
+ # Calculate weighted average sentiment
+ if sentiment_scores and source_weights:
+ weighted_sentiment = np.average(sentiment_scores, weights=source_weights)
+
+ # Calculate intensity (standard deviation of sentiment)
+ intensity = min(np.std(sentiment_scores), 1.0)
+
+ # Determine trend
+ trend = self._determine_sentiment_trend(sentiment_scores)
+
+ # Check for contrarian signal
+ contrarian_signal = abs(weighted_sentiment) > self.contrarian_thresholds["extreme_bullish"]
+
+ # Get most mentioned assets
+ top_assets = [asset for asset, count in
+ Counter(asset_mentions).most_common(3)]
+
+ return SentimentSignal(
+ source="financial_news",
+ sentiment_score=weighted_sentiment,
+ intensity=intensity,
+ reliability=np.mean(source_weights),
+ trend=trend,
+ contrarian_signal=contrarian_signal,
+ affected_assets=top_assets,
+ time_horizon="short"
+ )
+
+ except Exception as e:
+ logging.error(f"Error in news sentiment analysis: {e}")
+
+ return None
+
+ async def _analyze_social_sentiment(self) -> Optional[SentimentSignal]:
+ """Analyze sentiment from social media sources"""
+ try:
+ # Fetch social media sentiment data
+ social_data = await self.data_manager.get_multi_source_data({
+ "sentiment": {
+ "subreddits": ["investing", "stocks", "SecurityAnalysis", "ValueInvesting"],
+ "keywords": ["market", "stocks", "bull", "bear", "crash", "rally"]
+ }
+ })
+
+ sentiment_data = social_data.get("sentiment", [])
+ if not sentiment_data:
+ return None
+
+ # Process social sentiment
+ sentiment_scores = []
+ platform_weights = []
+
+ for data_point in sentiment_data:
+ platform = data_point.metadata.get("subreddit", "unknown")
+ platform_weight = self._get_social_platform_weight(platform)
+
+ sentiment_scores.append(data_point.value)
+ platform_weights.append(platform_weight)
+
+ if sentiment_scores:
+ # Calculate weighted sentiment
+ weighted_sentiment = np.average(sentiment_scores, weights=platform_weights)
+ intensity = min(np.std(sentiment_scores), 1.0)
+
+ # Social media tends to be more extreme and contrarian
+ contrarian_signal = (abs(weighted_sentiment) > 0.6 or
+ self._detect_social_extremes(sentiment_data))
+
+ return SentimentSignal(
+ source="social_media",
+ sentiment_score=weighted_sentiment,
+ intensity=intensity,
+ reliability=0.6, # Lower reliability than news
+ trend=self._determine_sentiment_trend(sentiment_scores),
+ contrarian_signal=contrarian_signal,
+ affected_assets=["stocks", "crypto"], # Social media focus
+ time_horizon="very_short"
+ )
+
+ except Exception as e:
+ logging.error(f"Error in social sentiment analysis: {e}")
+
+ return None
+
+ async def _analyze_analyst_sentiment(self) -> Optional[SentimentSignal]:
+ """Analyze professional analyst sentiment"""
+ try:
+ # This would integrate with analyst data providers
+ # For now, we'll simulate based on market data patterns
+
+ # Simulate analyst sentiment based on recent market performance
+ sentiment_score = np.random.normal(0.1, 0.3) # Slight bullish bias
+ sentiment_score = np.clip(sentiment_score, -1, 1)
+
+ # Analysts tend to be less extreme
+ intensity = np.random.uniform(0.2, 0.6)
+
+ # Professional analysts rarely give contrarian signals
+ contrarian_signal = False
+
+ return SentimentSignal(
+ source="analyst_sentiment",
+ sentiment_score=sentiment_score,
+ intensity=intensity,
+ reliability=0.8, # High reliability
+ trend="stable",
+ contrarian_signal=contrarian_signal,
+ affected_assets=["stocks", "sectors"],
+ time_horizon="medium"
+ )
+
+ except Exception as e:
+ logging.error(f"Error in analyst sentiment analysis: {e}")
+
+ return None
+
+ async def _analyze_market_indicators(self) -> Optional[SentimentSignal]:
+ """Analyze market-based sentiment indicators"""
+ try:
+ # Fetch market sentiment indicators
+ economic_data = await self.data_manager.get_multi_source_data({
+ "economic": {
+ "VIXCLS": {"series_id": "VIXCLS", "limit": 30}, # VIX
+ "GS10": {"series_id": "GS10", "limit": 30} # 10Y Treasury
+ }
+ })
+
+ market_data = economic_data.get("economic", {})
+
+ # Calculate fear/greed metrics
+ fear_greed = self._calculate_fear_greed_index(market_data)
+
+ # Convert fear/greed to sentiment score
+ sentiment_score = (fear_greed.overall_score - 50) / 50 # Convert 0-100 to -1 to 1
+
+ # Market indicators are highly reliable but can be contrarian
+ contrarian_signal = (fear_greed.classification in ["extreme_fear", "extreme_greed"])
+
+ return SentimentSignal(
+ source="market_indicators",
+ sentiment_score=sentiment_score,
+ intensity=abs(sentiment_score),
+ reliability=0.9, # Very reliable
+ trend=self._interpret_fear_greed_trend(fear_greed),
+ contrarian_signal=contrarian_signal,
+ affected_assets=["stocks", "bonds", "volatility"],
+ time_horizon="short"
+ )
+
+ except Exception as e:
+ logging.error(f"Error in market indicator analysis: {e}")
+
+ return None
+
+ def _calculate_text_sentiment(self, text: str) -> float:
+ """Calculate sentiment score from text using keyword analysis and TextBlob"""
+ try:
+ # Use TextBlob for base sentiment
+ blob = TextBlob(text)
+ base_sentiment = blob.sentiment.polarity
+
+ # Enhance with custom keyword analysis
+ text_lower = text.lower()
+ keyword_sentiment = 0.0
+ keyword_count = 0
+
+ for sentiment_category, config in self.sentiment_keywords.items():
+ for keyword in config["keywords"]:
+ if keyword in text_lower:
+ keyword_sentiment += config["weight"]
+ keyword_count += 1
+
+ # Combine base sentiment with keyword sentiment
+ if keyword_count > 0:
+ keyword_sentiment /= keyword_count
+ # Weight: 60% keyword sentiment, 40% TextBlob
+ combined_sentiment = 0.6 * keyword_sentiment + 0.4 * base_sentiment
+ else:
+ combined_sentiment = base_sentiment
+
+ return np.clip(combined_sentiment, -1.0, 1.0)
+
+ except Exception:
+ return 0.0
+
+ def _count_asset_mentions(self, text: str, asset_mentions: Dict[str, int]):
+ """Count mentions of different asset classes in text"""
+ text_lower = text.lower()
+
+ for asset_class, keywords in self.asset_sentiment_keywords.items():
+ for keyword in keywords:
+ if keyword in text_lower:
+ asset_mentions[asset_class] += 1
+
+ def _determine_sentiment_trend(self, sentiment_scores: List[float]) -> str:
+ """Determine if sentiment is improving, deteriorating, or stable"""
+ if len(sentiment_scores) < 3:
+ return "stable"
+
+ # Compare recent vs older sentiment
+ recent_avg = np.mean(sentiment_scores[-len(sentiment_scores) // 3:])
+ older_avg = np.mean(sentiment_scores[:len(sentiment_scores) // 3])
+
+ difference = recent_avg - older_avg
+
+ if difference > 0.1:
+ return "improving"
+ elif difference < -0.1:
+ return "deteriorating"
+ else:
+ return "stable"
+
+ def _get_social_platform_weight(self, platform: str) -> float:
+ """Get weight for social media platform"""
+ platform_weights = {
+ "investing": 0.4,
+ "stocks": 0.3,
+ "SecurityAnalysis": 0.5,
+ "ValueInvesting": 0.4,
+ "wallstreetbets": 0.2, # High volume but lower quality
+ "stocktwits": 0.3
+ }
+
+ return platform_weights.get(platform, 0.2)
+
+ def _detect_social_extremes(self, sentiment_data: List[DataPoint]) -> bool:
+ """Detect extreme sentiment in social media data"""
+ if not sentiment_data:
+ return False
+
+ # Check for extreme keywords
+ extreme_keywords = (self.sentiment_keywords["extremely_bullish"]["keywords"] +
+ self.sentiment_keywords["extremely_bearish"]["keywords"])
+
+ extreme_count = 0
+ total_posts = len(sentiment_data)
+
+ for data_point in sentiment_data:
+ text = str(data_point.value).lower()
+ if any(keyword in text for keyword in extreme_keywords):
+ extreme_count += 1
+
+ # If more than 20% of posts contain extreme language
+ return (extreme_count / total_posts) > 0.2 if total_posts > 0 else False
+
+ def _calculate_fear_greed_index(self, market_data: Dict) -> FearGreedMetrics:
+ """Calculate fear & greed index from market data"""
+ try:
+ # Get VIX level (fear indicator)
+ vix_data = market_data.get("VIXCLS", [])
+ current_vix = vix_data[-1].value if vix_data else 20.0
+
+ # Normalize VIX to 0-1 scale (inverse - high VIX = fear)
+ vix_score = max(0, min(1, (50 - current_vix) / 30)) # 50 = extreme fear, 10 = greed
+
+ # Simulate other components (in production, would fetch real data)
+ put_call_ratio = np.random.uniform(0.3, 1.2) # Normal range
+ put_call_score = max(0, min(1, (1.2 - put_call_ratio) / 0.9))
+
+ # Safe haven flows (inverse bond yields indicate flight to safety)
+ treasury_data = market_data.get("GS10", [])
+ current_yield = treasury_data[-1].value if treasury_data else 4.0
+ safe_haven_score = max(0, min(1, (current_yield - 2.0) / 4.0)) # Higher yields = less fear
+
+ # Momentum strength (simulated)
+ momentum_score = np.random.uniform(0.3, 0.8)
+
+ # Calculate overall score (0-100)
+ component_scores = [vix_score, put_call_score, safe_haven_score, momentum_score]
+ overall_score = int(np.mean(component_scores) * 100)
+
+ # Classify fear/greed level
+ if overall_score >= 80:
+ classification = "extreme_greed"
+ elif overall_score >= 60:
+ classification = "greed"
+ elif overall_score >= 40:
+ classification = "neutral"
+ elif overall_score >= 20:
+ classification = "fear"
+ else:
+ classification = "extreme_fear"
+
+ return FearGreedMetrics(
+ vix_level=current_vix,
+ put_call_ratio=put_call_ratio,
+ safe_haven_flows=1 - safe_haven_score, # Invert for intuitive reading
+ momentum_strength=momentum_score,
+ overall_score=overall_score,
+ classification=classification
+ )
+
+ except Exception as e:
+ logging.error(f"Error calculating fear/greed index: {e}")
+ return FearGreedMetrics(50.0, 0.8, 0.5, 0.5, 50, "neutral")
+
+ def _interpret_fear_greed_trend(self, fear_greed: FearGreedMetrics) -> str:
+ """Interpret fear/greed trend"""
+ score = fear_greed.overall_score
+
+ if score > 70:
+ return "deteriorating" # Too much greed
+ elif score < 30:
+ return "improving" # Oversold, likely to improve
+ else:
+ return "stable"
+
+ def _default_sentiment_signal(self) -> SentimentSignal:
+ """Return default sentiment signal"""
+ return SentimentSignal(
+ source="default",
+ sentiment_score=0.0,
+ intensity=0.3,
+ reliability=0.3,
+ trend="stable",
+ contrarian_signal=False,
+ affected_assets=["broad_market"],
+ time_horizon="short"
+ )
+
+ async def generate_contrarian_signals(self, sentiment_signals: Dict[str, SentimentSignal]) -> List[Dict]:
+ """Generate contrarian trading signals from sentiment extremes"""
+ contrarian_signals = []
+
+ for source, signal in sentiment_signals.items():
+ if signal.contrarian_signal:
+ # Generate contrarian signal
+ contrarian_direction = "short" if signal.sentiment_score > 0 else "long"
+ conviction = min(signal.intensity * signal.reliability, 1.0)
+
+ contrarian_signals.append({
+ "source": source,
+ "direction": contrarian_direction,
+ "conviction": conviction,
+ "rationale": f"Extreme {source} sentiment: {signal.sentiment_score:.2f}",
+ "affected_assets": signal.affected_assets,
+ "time_horizon": signal.time_horizon,
+ "sentiment_score": signal.sentiment_score
+ })
+
+ return contrarian_signals
+
+ async def analyze_sector_sentiment(self) -> Dict[str, float]:
+ """Analyze sentiment by sector"""
+ sector_sentiment = {}
+
+ # Sector-specific keywords
+ sector_keywords = {
+ "technology": ["tech", "software", "ai", "cloud", "semiconductor"],
+ "healthcare": ["pharma", "biotech", "medical", "drug", "health"],
+ "financials": ["bank", "insurance", "credit", "lending", "fintech"],
+ "energy": ["oil", "gas", "renewable", "energy", "solar"],
+ "consumer": ["retail", "consumer", "spending", "discretionary"]
+ }
+
+ try:
+ for sector, keywords in sector_keywords.items():
+ # Fetch sector-specific news
+ sector_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": " OR ".join(keywords),
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 24
+ }
+ })
+
+ news_data = sector_news.get("news", [])
+ if news_data:
+ sentiment_scores = [self._calculate_text_sentiment(article.value)
+ for article in news_data]
+ sector_sentiment[sector] = np.mean(sentiment_scores)
+ else:
+ sector_sentiment[sector] = 0.0
+
+ except Exception as e:
+ logging.error(f"Error in sector sentiment analysis: {e}")
+
+ return sector_sentiment
+
+ async def get_sentiment_report(self) -> Dict:
+ """Generate comprehensive sentiment analysis report"""
+ # Analyze overall market sentiment
+ sentiment_signals = await self.analyze_market_sentiment()
+
+ # Generate contrarian signals
+ contrarian_signals = await self.generate_contrarian_signals(sentiment_signals)
+
+ # Analyze sector sentiment
+ sector_sentiment = await self.analyze_sector_sentiment()
+
+ # Calculate overall sentiment score
+ if sentiment_signals:
+ weighted_scores = []
+ weights = []
+
+ for source, signal in sentiment_signals.items():
+ if source != "error":
+ weighted_scores.append(signal.sentiment_score * signal.reliability)
+ weights.append(signal.reliability)
+
+ overall_sentiment = (np.average(weighted_scores, weights=weights)
+ if weighted_scores else 0.0)
+ else:
+ overall_sentiment = 0.0
+
+ # Generate LLM analysis
+ llm_analysis = await self._generate_sentiment_llm_analysis(
+ sentiment_signals, contrarian_signals, sector_sentiment
+ )
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "sentiment_analysis": {
+ "overall_sentiment": overall_sentiment,
+ "sentiment_classification": self._classify_sentiment(overall_sentiment),
+ "source_breakdown": {
+ source: {
+ "score": signal.sentiment_score,
+ "intensity": signal.intensity,
+ "reliability": signal.reliability,
+ "trend": signal.trend,
+ "contrarian_signal": signal.contrarian_signal
+ } for source, signal in sentiment_signals.items() if source != "error"
+ }
+ },
+ "contrarian_signals": contrarian_signals,
+ "sector_sentiment": sector_sentiment,
+ "fear_greed_analysis": {
+ "current_level": self._estimate_fear_greed_level(overall_sentiment),
+ "interpretation": self._interpret_sentiment_level(overall_sentiment),
+ "contrarian_opportunity": abs(overall_sentiment) > 0.6
+ },
+ "trading_implications": {
+ "market_timing": self._get_market_timing_signal(overall_sentiment),
+ "position_sizing": self._get_position_sizing_recommendation(sentiment_signals),
+ "asset_allocation": self._get_sentiment_based_allocation(overall_sentiment),
+ "risk_management": self._get_sentiment_risk_recommendations(contrarian_signals)
+ },
+ "llm_analysis": llm_analysis,
+ "monitoring_alerts": {
+ "extreme_sentiment_warning": abs(overall_sentiment) > 0.7,
+ "contrarian_opportunities": len(contrarian_signals) > 0,
+ "sentiment_divergence": self._detect_sentiment_divergence(sentiment_signals),
+ "social_media_extreme": any(s.source == "social_media" and s.contrarian_signal
+ for s in sentiment_signals.values() if hasattr(s, 'source'))
+ }
+ }
+
+ def _classify_sentiment(self, sentiment_score: float) -> str:
+ """Classify overall sentiment level"""
+ if sentiment_score >= 0.6:
+ return "very_bullish"
+ elif sentiment_score >= 0.2:
+ return "bullish"
+ elif sentiment_score >= -0.2:
+ return "neutral"
+ elif sentiment_score >= -0.6:
+ return "bearish"
+ else:
+ return "very_bearish"
+
+ def _estimate_fear_greed_level(self, sentiment_score: float) -> int:
+ """Convert sentiment score to fear/greed index (0-100)"""
+ # Convert -1 to 1 range to 0-100
+ fear_greed_score = int((sentiment_score + 1) * 50)
+ return np.clip(fear_greed_score, 0, 100)
+
+ def _interpret_sentiment_level(self, sentiment_score: float) -> str:
+ """Interpret sentiment level for trading"""
+ if sentiment_score > 0.7:
+ return "Extreme optimism - consider taking profits and defensive positioning"
+ elif sentiment_score > 0.4:
+ return "Strong bullish sentiment - continue momentum but watch for reversals"
+ elif sentiment_score > -0.4:
+ return "Balanced sentiment - fundamentals likely driving markets"
+ elif sentiment_score > -0.7:
+ return "Pessimistic sentiment - look for oversold opportunities"
+ else:
+ return "Extreme pessimism - strong contrarian buying opportunity"
+
+ def _get_market_timing_signal(self, sentiment_score: float) -> str:
+ """Get market timing signal based on sentiment"""
+ if sentiment_score > 0.6:
+ return "reduce_risk" # Extreme optimism
+ elif sentiment_score < -0.6:
+ return "increase_risk" # Extreme pessimism
+ elif sentiment_score > 0.3:
+ return "neutral_to_bullish"
+ elif sentiment_score < -0.3:
+ return "neutral_to_bearish"
+ else:
+ return "neutral"
+
+ def _get_position_sizing_recommendation(self, sentiment_signals: Dict[str, SentimentSignal]) -> str:
+ """Get position sizing recommendation based on sentiment"""
+ if not sentiment_signals:
+ return "normal"
+
+ # Count contrarian signals
+ contrarian_count = sum(1 for signal in sentiment_signals.values()
+ if hasattr(signal, 'contrarian_signal') and signal.contrarian_signal)
+
+ # Check sentiment intensity
+ avg_intensity = np.mean([signal.intensity for signal in sentiment_signals.values()
+ if hasattr(signal, 'intensity')])
+
+ if contrarian_count >= 2:
+ return "reduce_size" # Multiple contrarian signals suggest caution
+ elif avg_intensity > 0.7:
+ return "reduce_size" # High intensity suggests volatility
+ elif contrarian_count == 1 and avg_intensity < 0.4:
+ return "increase_size" # Single contrarian opportunity with low volatility
+ else:
+ return "normal"
+
+ def _get_sentiment_based_allocation(self, sentiment_score: float) -> Dict[str, str]:
+ """Get asset allocation recommendation based on sentiment"""
+ if sentiment_score > 0.5:
+ return {
+ "equities": "underweight", # Reduce risk in euphoric markets
+ "bonds": "overweight",
+ "cash": "overweight",
+ "defensive_sectors": "overweight"
+ }
+ elif sentiment_score < -0.5:
+ return {
+ "equities": "overweight", # Increase risk in pessimistic markets
+ "bonds": "underweight",
+ "cash": "underweight",
+ "growth_sectors": "overweight"
+ }
+ else:
+ return {
+ "equities": "neutral",
+ "bonds": "neutral",
+ "cash": "neutral",
+ "sectors": "neutral"
+ }
+
+ def _get_sentiment_risk_recommendations(self, contrarian_signals: List[Dict]) -> List[str]:
+ """Get risk management recommendations based on sentiment"""
+ recommendations = []
+
+ if len(contrarian_signals) > 0:
+ recommendations.append("Monitor sentiment reversal points closely")
+ recommendations.append("Consider volatility hedges")
+
+ # Check for social media extremes
+ social_extremes = [signal for signal in contrarian_signals
+ if signal.get("source") == "social_media"]
+
+ if social_extremes:
+ recommendations.append("High social media sentiment risk - prepare for volatility")
+ recommendations.append("Consider reducing position sizes in meme stocks")
+
+ # Check for multiple extreme signals
+ if len(contrarian_signals) >= 2:
+ recommendations.append("Multiple extreme sentiment signals - consider defensive positioning")
+
+ return recommendations or ["Normal risk management procedures"]
+
+ def _detect_sentiment_divergence(self, sentiment_signals: Dict[str, SentimentSignal]) -> bool:
+ """Detect divergence between different sentiment sources"""
+ if len(sentiment_signals) < 2:
+ return False
+
+ scores = [signal.sentiment_score for signal in sentiment_signals.values()
+ if hasattr(signal, 'sentiment_score')]
+
+ if len(scores) < 2:
+ return False
+
+ # Check if sentiment scores are significantly different
+ score_std = np.std(scores)
+ score_range = max(scores) - min(scores)
+
+ # Divergence if high standard deviation or wide range
+ return score_std > 0.4 or score_range > 0.8
+
+ async def _generate_sentiment_llm_analysis(self, sentiment_signals: Dict[str, SentimentSignal],
+ contrarian_signals: List[Dict],
+ sector_sentiment: Dict[str, float]) -> Dict:
+ """Generate LLM-enhanced sentiment analysis"""
+ try:
+ # Prepare sentiment summary
+ sentiment_summary = self._prepare_sentiment_summary(sentiment_signals)
+ contrarian_summary = self._prepare_contrarian_summary(contrarian_signals)
+ sector_summary = self._prepare_sector_sentiment_summary(sector_sentiment)
+
+ prompt = f"""
+ As a senior market sentiment analyst, analyze the current market psychology and provide trading guidance.
+
+ Sentiment Analysis:
+ {sentiment_summary}
+
+ Contrarian Signals:
+ {contrarian_summary}
+
+ Sector Sentiment:
+ {sector_summary}
+
+ Please provide:
+ 1. Current market psychology assessment and crowd behavior analysis
+ 2. Contrarian opportunities with specific entry/exit strategies
+ 3. Sentiment-based sector rotation recommendations
+ 4. Risk management for sentiment-driven volatility
+ 5. Timeline for potential sentiment reversals
+ 6. Early warning indicators for sentiment extremes
+
+ Format as JSON with keys: market_psychology, contrarian_opportunities, sector_rotation,
+ risk_management, sentiment_timeline, early_warning_indicators
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM sentiment analysis: {e}")
+ return {
+ "market_psychology": "Mixed sentiment with moderate optimism",
+ "contrarian_opportunities": "Monitor for extreme readings in VIX and social media",
+ "sector_rotation": "Balanced approach with slight tech overweight",
+ "risk_management": "Standard position sizing with volatility monitoring",
+ "sentiment_timeline": "Next 2-4 weeks for potential shifts",
+ "early_warning_indicators": ["VIX spikes", "Social media extremes", "News flow acceleration"]
+ }
+
+ def _prepare_sentiment_summary(self, sentiment_signals: Dict[str, SentimentSignal]) -> str:
+ """Prepare sentiment summary for LLM"""
+ summary_lines = []
+
+ for source, signal in sentiment_signals.items():
+ if hasattr(signal, 'sentiment_score'):
+ summary_lines.append(
+ f"{source}: Score {signal.sentiment_score:.2f}, "
+ f"Intensity {signal.intensity:.2f}, "
+ f"Trend {signal.trend}, "
+ f"Contrarian: {signal.contrarian_signal}"
+ )
+
+ return "\n".join(summary_lines) if summary_lines else "Limited sentiment data available"
+
+ def _prepare_contrarian_summary(self, contrarian_signals: List[Dict]) -> str:
+ """Prepare contrarian signals summary for LLM"""
+ if not contrarian_signals:
+ return "No significant contrarian signals detected"
+
+ summary_lines = []
+ for signal in contrarian_signals:
+ summary_lines.append(
+ f"{signal['source']}: {signal['direction']} signal "
+ f"(Conviction: {signal['conviction']:.2f}) - {signal['rationale']}"
+ )
+
+ return "\n".join(summary_lines)
+
+ def _prepare_sector_sentiment_summary(self, sector_sentiment: Dict[str, float]) -> str:
+ """Prepare sector sentiment summary for LLM"""
+ if not sector_sentiment:
+ return "Sector sentiment data not available"
+
+ summary_lines = []
+ sorted_sectors = sorted(sector_sentiment.items(), key=lambda x: x[1], reverse=True)
+
+ for sector, sentiment in sorted_sectors:
+ sentiment_desc = "Bullish" if sentiment > 0.2 else "Bearish" if sentiment < -0.2 else "Neutral"
+ summary_lines.append(f"{sector}: {sentiment:.2f} ({sentiment_desc})")
+
+ return "\n".join(summary_lines)
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.py
new file mode 100644
index 000000000..b78cebc18
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/fincept_hedge_fund/supply_chain_agent.py
@@ -0,0 +1,592 @@
+# -*- coding: utf-8 -*-
+# agents/supply_chain_agent.py - Supply Chain Analysis Agent
+
+import asyncio
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import logging
+from dataclasses import dataclass
+import openai
+import json
+
+from config import CONFIG
+from data_feeds import DataFeedManager, DataPoint
+
+
+@dataclass
+class SupplyChainRisk:
+ """Supply chain risk assessment"""
+ disruption_type: str
+ affected_regions: List[str]
+ risk_level: int # 1-10
+ affected_sectors: List[str]
+ price_impact: Dict[str, float]
+ duration_estimate: str
+ mitigation_difficulty: str
+
+
+class SupplyChainAgent:
+ """Supply chain disruption monitoring and investment impact analysis"""
+
+ def __init__(self):
+ self.name = "supply_chain"
+ self.data_manager = DataFeedManager()
+ self.client = openai.OpenAI(api_key=CONFIG.api.openai_api_key)
+
+ # Critical supply chain chokepoints
+ self.chokepoints = {
+ "shipping": ["Suez Canal", "Panama Canal", "Strait of Hormuz", "Strait of Malacca"],
+ "semiconductors": ["Taiwan", "South Korea", "Netherlands", "Japan"],
+ "rare_earths": ["China", "Australia", "Myanmar"],
+ "energy": ["Russia", "Saudi Arabia", "Norway", "Qatar"],
+ "agriculture": ["Ukraine", "Russia", "Brazil", "Argentina"]
+ }
+
+ # Sector impact mapping
+ self.sector_impacts = {
+ "shipping_disruption": {
+ "retail": -0.6, "automotive": -0.8, "electronics": -0.7,
+ "energy": 0.3, "logistics": -0.9, "commodities": 0.4
+ },
+ "semiconductor_shortage": {
+ "automotive": -0.9, "electronics": -0.8, "telecommunications": -0.6,
+ "industrial": -0.5, "healthcare": -0.3
+ },
+ "energy_supply_shock": {
+ "airlines": -0.8, "chemicals": -0.7, "materials": -0.6,
+ "energy": 0.8, "utilities": -0.4, "transportation": -0.7
+ }
+ }
+
+ async def analyze_supply_chains(self) -> List[SupplyChainRisk]:
+ """Analyze global supply chain risks"""
+ risks = []
+
+ # Shipping disruptions
+ shipping_risk = await self._analyze_shipping_disruptions()
+ if shipping_risk:
+ risks.append(shipping_risk)
+
+ # Semiconductor supply
+ chip_risk = await self._analyze_semiconductor_supply()
+ if chip_risk:
+ risks.append(chip_risk)
+
+ # Energy supply
+ energy_risk = await self._analyze_energy_supply()
+ if energy_risk:
+ risks.append(energy_risk)
+
+ # Critical materials
+ materials_risk = await self._analyze_critical_materials()
+ if materials_risk:
+ risks.append(materials_risk)
+
+ return risks
+
+ async def _analyze_shipping_disruptions(self) -> Optional[SupplyChainRisk]:
+ """Analyze global shipping and logistics disruptions"""
+ try:
+ # Fetch shipping-related news
+ shipping_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": "shipping disruption supply chain logistics",
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 72
+ }
+ })
+
+ news_data = shipping_news.get("news", [])
+
+ # Calculate risk level from news intensity
+ disruption_keywords = [
+ "port congestion", "shipping delay", "container shortage",
+ "suez canal", "panama canal", "strike", "blockage"
+ ]
+
+ risk_score = 0
+ for article in news_data:
+ text = article.value.lower()
+ keyword_count = sum(1 for keyword in disruption_keywords if keyword in text)
+ risk_score += keyword_count * article.confidence
+
+ if news_data:
+ normalized_risk = min(risk_score / len(news_data) * 2, 10)
+ risk_level = int(normalized_risk) if normalized_risk > 3 else 5
+ else:
+ risk_level = 4 # Baseline moderate risk
+
+ # Determine affected regions and sectors
+ affected_regions = ["Global", "Asia-Pacific", "Europe", "North America"]
+ affected_sectors = ["retail", "automotive", "electronics", "consumer goods"]
+
+ # Price impacts
+ price_impacts = {
+ "shipping_costs": 0.2 * (risk_level / 10),
+ "commodity_prices": 0.15 * (risk_level / 10),
+ "consumer_goods": 0.1 * (risk_level / 10)
+ }
+
+ return SupplyChainRisk(
+ disruption_type="shipping_logistics",
+ affected_regions=affected_regions,
+ risk_level=risk_level,
+ affected_sectors=affected_sectors,
+ price_impact=price_impacts,
+ duration_estimate="3-9 months" if risk_level > 6 else "1-6 months",
+ mitigation_difficulty="moderate"
+ )
+
+ except Exception as e:
+ logging.error(f"Error analyzing shipping disruptions: {e}")
+ return None
+
+ async def _analyze_semiconductor_supply(self) -> Optional[SupplyChainRisk]:
+ """Analyze semiconductor supply chain risks"""
+ try:
+ # Fetch semiconductor news
+ chip_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": "semiconductor chip shortage taiwan TSMC",
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 168 # 1 week
+ }
+ })
+
+ news_data = chip_news.get("news", [])
+
+ # Semiconductor risk factors
+ risk_keywords = [
+ "chip shortage", "semiconductor", "taiwan tensions", "TSMC",
+ "fabrication", "wafer", "supply constraint"
+ ]
+
+ geopolitical_keywords = [
+ "taiwan strait", "china taiwan", "semiconductor sanctions",
+ "export controls", "technology war"
+ ]
+
+ supply_risk = 0
+ geopolitical_risk = 0
+
+ for article in news_data:
+ text = article.value.lower()
+ supply_risk += sum(1 for keyword in risk_keywords if keyword in text)
+ geopolitical_risk += sum(1 for keyword in geopolitical_keywords if keyword in text)
+
+ # Combine risks
+ total_articles = len(news_data) if news_data else 1
+ combined_risk = (supply_risk + geopolitical_risk * 2) / total_articles
+ risk_level = min(int(combined_risk * 1.5) + 4, 10) # Base 4, scale up
+
+ affected_regions = ["Global", "Taiwan", "South Korea", "Japan"]
+ affected_sectors = ["automotive", "electronics", "telecommunications", "industrial"]
+
+ price_impacts = {
+ "semiconductor_prices": 0.3 * (risk_level / 10),
+ "electronics": 0.2 * (risk_level / 10),
+ "automotive": 0.25 * (risk_level / 10)
+ }
+
+ return SupplyChainRisk(
+ disruption_type="semiconductor_shortage",
+ affected_regions=affected_regions,
+ risk_level=risk_level,
+ affected_sectors=affected_sectors,
+ price_impact=price_impacts,
+ duration_estimate="12-24 months" if risk_level > 7 else "6-18 months",
+ mitigation_difficulty="high" # Long lead times for new fabs
+ )
+
+ except Exception as e:
+ logging.error(f"Error analyzing semiconductor supply: {e}")
+ return None
+
+ async def _analyze_energy_supply(self) -> Optional[SupplyChainRisk]:
+ """Analyze energy supply chain risks"""
+ try:
+ # Fetch energy supply news
+ energy_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": "energy supply oil gas pipeline russia ukraine",
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 96
+ }
+ })
+
+ news_data = energy_news.get("news", [])
+
+ # Energy supply risk indicators
+ supply_risk_keywords = [
+ "pipeline", "refinery shutdown", "oil supply", "gas supply",
+ "energy crisis", "power shortage", "fuel shortage"
+ ]
+
+ geopolitical_keywords = [
+ "russia sanctions", "opec", "energy weapon", "gas cutoff",
+ "strategic reserve", "energy security"
+ ]
+
+ supply_disruption_score = 0
+ geopolitical_score = 0
+
+ for article in news_data:
+ text = article.value.lower()
+ supply_disruption_score += sum(1 for keyword in supply_risk_keywords if keyword in text)
+ geopolitical_score += sum(1 for keyword in geopolitical_keywords if keyword in text)
+
+ total_articles = len(news_data) if news_data else 1
+ combined_score = (supply_disruption_score + geopolitical_score * 1.5) / total_articles
+ risk_level = min(int(combined_score * 1.2) + 3, 10)
+
+ affected_regions = ["Europe", "Asia", "Global"]
+ affected_sectors = ["energy", "chemicals", "transportation", "utilities", "airlines"]
+
+ price_impacts = {
+ "oil_prices": 0.4 * (risk_level / 10),
+ "gas_prices": 0.5 * (risk_level / 10),
+ "electricity": 0.3 * (risk_level / 10),
+ "petrochemicals": 0.25 * (risk_level / 10)
+ }
+
+ return SupplyChainRisk(
+ disruption_type="energy_supply_shock",
+ affected_regions=affected_regions,
+ risk_level=risk_level,
+ affected_sectors=affected_sectors,
+ price_impact=price_impacts,
+ duration_estimate="6-18 months" if risk_level > 6 else "3-12 months",
+ mitigation_difficulty="moderate"
+ )
+
+ except Exception as e:
+ logging.error(f"Error analyzing energy supply: {e}")
+ return None
+
+ async def _analyze_critical_materials(self) -> Optional[SupplyChainRisk]:
+ """Analyze critical materials and rare earth supply"""
+ try:
+ # Fetch critical materials news
+ materials_news = await self.data_manager.get_multi_source_data({
+ "news": {
+ "query": "rare earth metals lithium copper critical minerals",
+ "sources": ["reuters", "bloomberg"],
+ "hours_back": 120
+ }
+ })
+
+ news_data = materials_news.get("news", [])
+
+ # Critical materials risk factors
+ supply_keywords = [
+ "rare earth", "lithium shortage", "copper supply", "nickel",
+ "cobalt", "critical minerals", "mining disruption"
+ ]
+
+ geopolitical_keywords = [
+ "china rare earth", "mining sanctions", "export restrictions",
+ "strategic materials", "supply security"
+ ]
+
+ supply_risk = 0
+ geo_risk = 0
+
+ for article in news_data:
+ text = article.value.lower()
+ supply_risk += sum(1 for keyword in supply_keywords if keyword in text)
+ geo_risk += sum(1 for keyword in geopolitical_keywords if keyword in text)
+
+ total_articles = len(news_data) if news_data else 1
+ combined_risk = (supply_risk + geo_risk * 1.3) / total_articles
+ risk_level = min(int(combined_risk * 1.1) + 4, 10)
+
+ affected_regions = ["Global", "China", "Australia", "DRC"]
+ affected_sectors = ["renewable_energy", "electric_vehicles", "electronics", "defense"]
+
+ price_impacts = {
+ "rare_earth_prices": 0.6 * (risk_level / 10),
+ "battery_metals": 0.4 * (risk_level / 10),
+ "renewable_energy_costs": 0.2 * (risk_level / 10)
+ }
+
+ return SupplyChainRisk(
+ disruption_type="critical_materials_shortage",
+ affected_regions=affected_regions,
+ risk_level=risk_level,
+ affected_sectors=affected_sectors,
+ price_impact=price_impacts,
+ duration_estimate="12-36 months" if risk_level > 7 else "6-24 months",
+ mitigation_difficulty="high" # Limited alternative sources
+ )
+
+ except Exception as e:
+ logging.error(f"Error analyzing critical materials: {e}")
+ return None
+
+ async def get_supply_chain_report(self) -> Dict:
+ """Generate comprehensive supply chain risk report"""
+ # Analyze supply chain risks
+ supply_risks = await self.analyze_supply_chains()
+
+ # Calculate overall supply chain stress
+ overall_stress = self._calculate_supply_chain_stress(supply_risks)
+
+ # Generate investment implications
+ investment_implications = self._generate_investment_implications(supply_risks)
+
+ # Generate LLM analysis
+ llm_analysis = await self._generate_supply_chain_llm_analysis(supply_risks)
+
+ return {
+ "timestamp": datetime.now().isoformat(),
+ "agent": self.name,
+ "supply_chain_analysis": {
+ "overall_stress_level": overall_stress,
+ "stress_classification": self._classify_stress_level(overall_stress),
+ "major_risks": [{
+ "disruption_type": risk.disruption_type,
+ "risk_level": risk.risk_level,
+ "affected_regions": risk.affected_regions,
+ "affected_sectors": risk.affected_sectors,
+ "price_impact": risk.price_impact,
+ "duration": risk.duration_estimate,
+ "mitigation_difficulty": risk.mitigation_difficulty
+ } for risk in supply_risks]
+ },
+ "investment_implications": investment_implications,
+ "sector_impact_analysis": self._analyze_sector_impacts(supply_risks),
+ "geographic_exposure": self._analyze_geographic_exposure(supply_risks),
+ "llm_analysis": llm_analysis,
+ "monitoring_priorities": {
+ "high_risk_disruptions": [risk.disruption_type for risk in supply_risks if risk.risk_level >= 7],
+ "critical_chokepoints": self._identify_critical_chokepoints(supply_risks),
+ "early_warning_indicators": [
+ "Shipping container rates", "Semiconductor lead times",
+ "Energy price volatility", "Critical mineral inventories"
+ ]
+ }
+ }
+
+ def _calculate_supply_chain_stress(self, risks: List[SupplyChainRisk]) -> float:
+ """Calculate overall supply chain stress level"""
+ if not risks:
+ return 3.0 # Baseline stress
+
+ # Weight risks by severity and mitigation difficulty
+ weighted_stress = 0
+ total_weight = 0
+
+ difficulty_multipliers = {"low": 0.8, "moderate": 1.0, "high": 1.3}
+
+ for risk in risks:
+ multiplier = difficulty_multipliers.get(risk.mitigation_difficulty, 1.0)
+ weight = risk.risk_level * multiplier
+ weighted_stress += weight
+ total_weight += 1
+
+ return weighted_stress / total_weight if total_weight > 0 else 3.0
+
+ def _classify_stress_level(self, stress_level: float) -> str:
+ """Classify supply chain stress level"""
+ if stress_level >= 8:
+ return "critical"
+ elif stress_level >= 6:
+ return "high"
+ elif stress_level >= 4:
+ return "moderate"
+ else:
+ return "low"
+
+ def _generate_investment_implications(self, risks: List[SupplyChainRisk]) -> Dict:
+ """Generate investment implications from supply chain risks"""
+ implications = {
+ "beneficiary_sectors": [],
+ "vulnerable_sectors": [],
+ "geographic_allocation": {},
+ "commodity_exposure": {},
+ "hedging_strategies": []
+ }
+
+ # Aggregate sector impacts
+ sector_impact_totals = {}
+
+ for risk in risks:
+ # Get sector impacts for this disruption type
+ if risk.disruption_type in self.sector_impacts:
+ sector_impacts = self.sector_impacts[risk.disruption_type]
+ for sector, impact in sector_impacts.items():
+ sector_impact_totals[sector] = sector_impact_totals.get(sector, 0) + impact * (risk.risk_level / 10)
+
+ # Classify sectors
+ for sector, total_impact in sector_impact_totals.items():
+ if total_impact > 0.2:
+ implications["beneficiary_sectors"].append(sector)
+ elif total_impact < -0.2:
+ implications["vulnerable_sectors"].append(sector)
+
+ # Geographic allocation
+ high_risk_regions = set()
+ for risk in risks:
+ if risk.risk_level >= 6:
+ high_risk_regions.update(risk.affected_regions)
+
+ implications["geographic_allocation"] = {
+ "avoid": list(high_risk_regions),
+ "prefer": ["North America", "Australia"] if "Asia" in high_risk_regions else ["Domestic markets"]
+ }
+
+ # Commodity exposure
+ for risk in risks:
+ for commodity, impact in risk.price_impact.items():
+ if impact > 0.1:
+ implications["commodity_exposure"][commodity] = "positive" if impact > 0 else "negative"
+
+ # Hedging strategies
+ if any(risk.risk_level >= 7 for risk in risks):
+ implications["hedging_strategies"].extend([
+ "Commodity price hedging",
+ "Supply chain diversification",
+ "Inventory buffers"
+ ])
+
+ return implications
+
+ def _analyze_sector_impacts(self, risks: List[SupplyChainRisk]) -> Dict[str, Dict]:
+ """Analyze impact on different sectors"""
+ sector_analysis = {}
+
+ # Aggregate all affected sectors
+ all_sectors = set()
+ for risk in risks:
+ all_sectors.update(risk.affected_sectors)
+
+ for sector in all_sectors:
+ sector_risks = [risk for risk in risks if sector in risk.affected_sectors]
+
+ if sector_risks:
+ avg_risk_level = np.mean([risk.risk_level for risk in sector_risks])
+ max_risk_level = max(risk.risk_level for risk in sector_risks)
+
+ sector_analysis[sector] = {
+ "average_risk_level": avg_risk_level,
+ "maximum_risk_level": max_risk_level,
+ "number_of_risks": len(sector_risks),
+ "primary_risks": [risk.disruption_type for risk in sector_risks[:3]],
+ "investment_recommendation": self._get_sector_recommendation(avg_risk_level)
+ }
+
+ return sector_analysis
+
+ def _get_sector_recommendation(self, risk_level: float) -> str:
+ """Get investment recommendation based on sector risk level"""
+ if risk_level >= 7:
+ return "avoid"
+ elif risk_level >= 5:
+ return "underweight"
+ elif risk_level >= 3:
+ return "neutral"
+ else:
+ return "overweight"
+
+ def _analyze_geographic_exposure(self, risks: List[SupplyChainRisk]) -> Dict[str, Dict]:
+ """Analyze geographic exposure to supply chain risks"""
+ geographic_analysis = {}
+
+ # Aggregate all affected regions
+ all_regions = set()
+ for risk in risks:
+ all_regions.update(risk.affected_regions)
+
+ for region in all_regions:
+ region_risks = [risk for risk in risks if region in risk.affected_regions]
+
+ if region_risks:
+ avg_risk = np.mean([risk.risk_level for risk in region_risks])
+
+ geographic_analysis[region] = {
+ "average_risk_level": avg_risk,
+ "number_of_risks": len(region_risks),
+ "primary_disruption_types": list(set(risk.disruption_type for risk in region_risks)),
+ "investment_stance": "defensive" if avg_risk >= 6 else "neutral" if avg_risk >= 4 else "opportunistic"
+ }
+
+ return geographic_analysis
+
+ def _identify_critical_chokepoints(self, risks: List[SupplyChainRisk]) -> List[str]:
+ """Identify critical supply chain chokepoints"""
+ critical_points = []
+
+ for risk in risks:
+ if risk.risk_level >= 6 and risk.mitigation_difficulty == "high":
+ # These are critical chokepoints
+ if risk.disruption_type == "semiconductor_shortage":
+ critical_points.extend(["Taiwan semiconductor fabs", "ASML lithography"])
+ elif risk.disruption_type == "shipping_logistics":
+ critical_points.extend(["Suez Canal", "Panama Canal", "Shanghai ports"])
+ elif risk.disruption_type == "energy_supply_shock":
+ critical_points.extend(["Russian pipelines", "Strait of Hormuz"])
+ elif risk.disruption_type == "critical_materials_shortage":
+ critical_points.extend(["China rare earth production", "DRC cobalt mines"])
+
+ return list(set(critical_points)) # Remove duplicates
+
+ async def _generate_supply_chain_llm_analysis(self, risks: List[SupplyChainRisk]) -> Dict:
+ """Generate LLM-enhanced supply chain analysis"""
+ try:
+ # Prepare risk summary
+ risk_summary = self._prepare_risk_summary(risks)
+
+ prompt = f"""
+ As a senior supply chain risk analyst, analyze current global supply chain disruptions and provide investment guidance.
+
+ Current Supply Chain Risks:
+ {risk_summary}
+
+ Please provide:
+ 1. Most critical supply chain vulnerabilities requiring immediate attention
+ 2. Investment opportunities arising from supply chain disruptions
+ 3. Sector rotation strategy based on supply chain resilience
+ 4. Geographic diversification recommendations
+ 5. Timeline for supply chain normalization
+ 6. Early warning indicators for supply chain crises
+
+ Format as JSON with keys: critical_vulnerabilities, investment_opportunities, sector_strategy,
+ geographic_diversification, normalization_timeline, early_warning_indicators
+ """
+
+ response = self.client.chat.completions.create(
+ model=CONFIG.llm.deep_think_model,
+ messages=[{"role": "user", "content": prompt}],
+ temperature=CONFIG.llm.temperature,
+ max_tokens=CONFIG.llm.max_tokens
+ )
+
+ return json.loads(response.choices[0].message.content)
+
+ except Exception as e:
+ logging.error(f"Error in LLM supply chain analysis: {e}")
+ return {
+ "critical_vulnerabilities": ["Semiconductor supply", "Energy security", "Shipping bottlenecks"],
+ "investment_opportunities": ["Supply chain technology", "Regional suppliers", "Inventory management"],
+ "sector_strategy": "Overweight supply chain resilient sectors, underweight vulnerable ones",
+ "geographic_diversification": "Reduce Asia concentration, increase nearshoring exposure",
+ "normalization_timeline": "18-36 months for full normalization",
+ "early_warning_indicators": ["Container shipping rates", "Commodity inventories", "Trade flow data"]
+ }
+
+ def _prepare_risk_summary(self, risks: List[SupplyChainRisk]) -> str:
+ """Prepare risk summary for LLM analysis"""
+ summary_lines = []
+
+ for risk in risks:
+ summary_lines.append(
+ f"{risk.disruption_type}: Risk Level {risk.risk_level}/10, "
+ f"Regions: {', '.join(risk.affected_regions[:3])}, "
+ f"Duration: {risk.duration_estimate}, "
+ f"Sectors: {', '.join(risk.affected_sectors[:3])}, "
+ f"Mitigation: {risk.mitigation_difficulty}"
+ )
+
+ return "\n".join(summary_lines) if summary_lines else "No major supply chain risks identified"
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonl b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonl
new file mode 100644
index 000000000..3b289ea6c
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/history.jsonl
@@ -0,0 +1,19 @@
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760621427926,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760622414199,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +28 lines]","pastedContents":{},"timestamp":1760624273948,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760707613869,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760707816773,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +162 lines]","pastedContents":{},"timestamp":1760709574303,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760729181388,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760729216541,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +139 lines]","pastedContents":{},"timestamp":1760731722210,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760766955381,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760766969289,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +14 lines]","pastedContents":{"1":{"id":1,"type":"text","content":"Of course, here is the API documentation for the Spanish government's data portal.\n\n### **Overview**\n\nThe API allows for queries to be made to the `datos.gob.es` semantic database, providing access to the data catalog and related resources. The API uses Uniform Resource Identifiers (URIs) for queries, which are constructed based on user-selected criteria.\n\n### **Key Features**\n\n* **Access to Data Catalog**: The API provides programmatic access to the data catalog.\n* **Access to URIs**: It also provides access to URIs corresponding to the primary sector taxonomy.\n* **Geographical Coverage Identification**: The API allows for the identification of geographical coverage as defined in Annexes IV and V of the Technical Interoperability Regulations on the Re-use of Information Resources (NTI).\n\n### **Additional Resources**\n\nYou can find more detailed information, including documents relating to the API methods, parameters, and model, as well as the ability to conduct test searches, on the `datos.gob.es` website."}},"timestamp":1760768424326,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760791875832,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760792158009,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +140 lines]","pastedContents":{},"timestamp":1760792235672,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"add english translators for spanish text","pastedContents":{},"timestamp":1760793023651,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"\\init check the api wrapper files that i have and learn the pattern and structure of the api files , we are going to create new api wrapper for another data provider , AND THEN YOU CAN PASTE THE DOCS IT WILL START THE CODE , ALSO NEED TO SPECIFIC THAT KEEP ADDING NEW ENDPOINTS WITHOUT CHANGING THE OLD ONE AND KEEP IT COMPLETELY MODULAR LIKE ONE ENDPOINT FAILURE SHOULD NOT STOP THE COMPLETE FILE , AND ONCE THE FULL FILE IS CODED YOU CAN TELL TO RUN TEST ON EACH ENDPOINT THAT IT IS WORKING OR NOT , IT WILL RUN AND TEST BY ITSELF","pastedContents":{},"timestamp":1760882925391,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"Like firstly we need to list all the catalogue then datasets inside that and then series of data that it contains","pastedContents":{},"timestamp":1760883120208,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
+{"display":"[Pasted text #1 +124 lines]","pastedContents":{},"timestamp":1760883596081,"project":"C:\\Users\\HP\\Downloads\\FinceptTerminal\\fincept-terminal-desktop\\src-tauri\\resources\\scripts"}
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.py
new file mode 100644
index 000000000..33eb31333
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/pershing_square_hedge_fund_agent/pershing_square_agent.py
@@ -0,0 +1,985 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class PershingSquareSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ investment_thesis: dict
+
+
+def pershing_square_hedge_fund_agent(state: AgentState, agent_id: str = "pershing_square_hedge_fund_agent"):
+ """
+ Pershing Square: Concentrated activist investing, high-conviction bets
+ Structure: Research → Activism Strategy → Public Relations → Risk Management → Bill Ackman Decision
+ Philosophy: Concentrated positions, activist value creation, public campaigns
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ pershing_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Research team fundamental analysis")
+
+ metrics = get_financial_metrics(ticker, end_date, period="annual", limit=8, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="annual",
+ limit=8,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Pershing Square's concentrated analysis structure
+ progress.update_status(agent_id, ticker, "Research team analysis")
+ research_team = pershing_research_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Activism strategy team")
+ activism_strategy = activism_strategy_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Public relations strategy")
+ public_relations = public_relations_strategy_analysis(financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk management analysis")
+ risk_management = pershing_risk_management_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Bill Ackman investment decision")
+ ackman_decision = bill_ackman_investment_decision(
+ research_team, activism_strategy, public_relations, risk_management
+ )
+
+ # Pershing Square's high-conviction scoring
+ total_score = (
+ research_team["score"] * 0.35 +
+ activism_strategy["score"] * 0.3 +
+ risk_management["score"] * 0.2 +
+ public_relations["score"] * 0.15
+ )
+
+ # Pershing Square's concentrated decision framework
+ conviction_level = ackman_decision.get("conviction_level", 0)
+ if total_score >= 8.5 and conviction_level > 0.8:
+ signal = "bullish"
+ elif total_score <= 4.0 or conviction_level < 0.3:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "research_team": research_team,
+ "activism_strategy": activism_strategy,
+ "public_relations": public_relations,
+ "risk_management": risk_management,
+ "ackman_decision": ackman_decision
+ }
+
+ pershing_output = generate_pershing_output(ticker, analysis_data, state, agent_id)
+
+ pershing_analysis[ticker] = {
+ "signal": pershing_output.signal,
+ "confidence": pershing_output.confidence,
+ "reasoning": pershing_output.reasoning,
+ "investment_thesis": pershing_output.investment_thesis
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=pershing_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(pershing_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(pershing_analysis, "Pershing Square")
+
+ state["data"]["analyst_signals"][agent_id] = pershing_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def pershing_research_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Pershing Square's research team deep fundamental analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No research data"}
+
+ # High-quality business analysis
+ business_quality = analyze_business_quality_metrics(metrics, financial_line_items)
+ if business_quality > 0.8:
+ score += 3
+ details.append(f"Exceptional business quality: {business_quality:.2f}")
+ elif business_quality > 0.6:
+ score += 2
+ details.append(f"High business quality: {business_quality:.2f}")
+
+ # Competitive moat analysis
+ moat_strength = analyze_competitive_moat_strength(metrics, financial_line_items)
+ if moat_strength > 0.7:
+ score += 3
+ details.append(f"Strong competitive moat: {moat_strength:.2f}")
+
+ # Management quality assessment
+ management_quality = assess_management_quality(metrics, financial_line_items)
+ if management_quality > 0.7:
+ score += 2
+ details.append(f"High-quality management: {management_quality:.2f}")
+ elif management_quality < 0.4:
+ score += 1.5 # Opportunity for improvement through activism
+ details.append("Management improvement opportunity")
+
+ # Intrinsic value vs market price
+ intrinsic_value_ratio = calculate_intrinsic_value_ratio(financial_line_items, market_cap)
+ if intrinsic_value_ratio > 1.5:
+ score += 2.5
+ details.append(f"Significant undervaluation: {intrinsic_value_ratio:.1f}x intrinsic value")
+ elif intrinsic_value_ratio > 1.2:
+ score += 1.5
+ details.append(f"Moderate undervaluation: {intrinsic_value_ratio:.1f}x intrinsic value")
+
+ # Long-term growth potential
+ growth_potential = analyze_long_term_growth_potential(financial_line_items)
+ if growth_potential > 0.6:
+ score += 1.5
+ details.append(f"Strong long-term growth potential: {growth_potential:.2f}")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def activism_strategy_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Pershing Square's activism strategy team analysis"""
+ score = 0
+ details = []
+ activist_opportunities = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No activism data"}
+
+ # Board and governance opportunities
+ governance_opportunity = assess_governance_improvement_opportunities(metrics, financial_line_items)
+ if governance_opportunity > 0.7:
+ score += 3
+ activist_opportunities.append("Board restructuring")
+ details.append("Significant governance improvement opportunity")
+
+ # Strategic restructuring potential
+ restructuring_potential = identify_strategic_restructuring_opportunities(financial_line_items, market_cap)
+ if restructuring_potential > 0.6:
+ score += 2.5
+ activist_opportunities.append("Strategic restructuring")
+ details.append("Strategic restructuring opportunity identified")
+
+ # Capital allocation improvements
+ capital_allocation_score = analyze_capital_allocation_opportunities(financial_line_items)
+ if capital_allocation_score > 0.6:
+ score += 2
+ activist_opportunities.append("Capital allocation")
+ details.append("Capital allocation improvement opportunity")
+
+ # Operational efficiency improvements
+ operational_efficiency = identify_operational_efficiency_opportunities(financial_line_items)
+ if operational_efficiency > 0.5:
+ score += 1.5
+ activist_opportunities.append("Operational improvements")
+ details.append("Operational efficiency opportunities")
+
+ # ESG and sustainability improvements
+ esg_opportunities = assess_esg_improvement_opportunities(financial_line_items)
+ if esg_opportunities > 0.5:
+ score += 1
+ activist_opportunities.append("ESG improvements")
+ details.append("ESG improvement opportunities")
+
+ # Public campaign viability
+ public_campaign_viability = assess_public_campaign_viability(market_cap)
+ if public_campaign_viability > 0.7:
+ score += 1
+ details.append("High public campaign viability")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "activist_opportunities": activist_opportunities
+ }
+
+
+def public_relations_strategy_analysis(financial_line_items: list, market_cap: float) -> dict:
+ """Pershing Square's public relations strategy analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No PR data"}
+
+ # Public narrative strength
+ narrative_strength = assess_public_narrative_strength(financial_line_items)
+ if narrative_strength > 0.7:
+ score += 2
+ details.append("Strong public narrative potential")
+
+ # Media coverage potential
+ media_coverage_potential = analyze_media_coverage_potential(market_cap)
+ if media_coverage_potential > 0.6:
+ score += 1.5
+ details.append("High media coverage potential")
+
+ # Shareholder communication effectiveness
+ shareholder_communication = assess_shareholder_communication_potential(market_cap)
+ score += shareholder_communication
+ details.append(f"Shareholder communication score: {shareholder_communication:.1f}")
+
+ # Public pressure effectiveness
+ public_pressure_effectiveness = evaluate_public_pressure_effectiveness(financial_line_items)
+ if public_pressure_effectiveness > 0.6:
+ score += 1.5
+ details.append("Public pressure likely to be effective")
+
+ # Regulatory and political considerations
+ regulatory_considerations = analyze_regulatory_environment(financial_line_items)
+ if regulatory_considerations > 0.5:
+ score += 1
+ details.append("Favorable regulatory environment")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def pershing_risk_management_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Pershing Square's risk management for concentrated positions"""
+ score = 0
+ details = []
+ risk_factors = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No risk data"}
+
+ # Concentration risk assessment
+ concentration_risk = assess_concentration_risk(market_cap)
+ if concentration_risk < 0.3:
+ score += 2
+ details.append("Low concentration risk")
+ elif concentration_risk > 0.7:
+ risk_factors.append("High concentration risk")
+ details.append("High concentration risk identified")
+
+ # Liquidity risk for large positions
+ liquidity_risk = assess_large_position_liquidity_risk(market_cap)
+ if liquidity_risk < 0.2:
+ score += 2
+ details.append("Low liquidity risk for large positions")
+ elif liquidity_risk > 0.6:
+ risk_factors.append("Liquidity constraints")
+
+ # Activist campaign risks
+ campaign_risk = assess_activist_campaign_risks(financial_line_items)
+ if campaign_risk < 0.4:
+ score += 1.5
+ details.append("Low activist campaign risk")
+ elif campaign_risk > 0.7:
+ risk_factors.append("High campaign execution risk")
+
+ # Regulatory and legal risks
+ regulatory_risk = assess_regulatory_and_legal_risks(market_cap)
+ if regulatory_risk < 0.3:
+ score += 1.5
+ details.append("Low regulatory risk")
+ elif regulatory_risk > 0.6:
+ risk_factors.append("Regulatory concerns")
+
+ # Reputational risk
+ reputational_risk = assess_reputational_risk_exposure(financial_line_items)
+ if reputational_risk < 0.4:
+ score += 1
+ details.append("Low reputational risk")
+ elif reputational_risk > 0.7:
+ risk_factors.append("Reputational risk exposure")
+
+ # Downside protection analysis
+ downside_protection = calculate_downside_protection(financial_line_items, market_cap)
+ if downside_protection > 0.6:
+ score += 2
+ details.append("Strong downside protection")
+
+ if risk_factors:
+ details.append(f"Risk factors: {'; '.join(risk_factors)}")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "risk_factors": risk_factors
+ }
+
+
+def bill_ackman_investment_decision(research_team: dict, activism_strategy: dict,
+ public_relations: dict, risk_management: dict) -> dict:
+ """Bill Ackman's high-conviction investment decision"""
+ details = []
+
+ # Ackman's decision framework
+ fundamental_strength = research_team["score"] / 10
+ activist_potential = activism_strategy["score"] / 10
+ campaign_feasibility = public_relations["score"] / 8
+ risk_acceptability = risk_management["score"] / 10
+
+ # High-conviction threshold
+ overall_conviction = (
+ fundamental_strength * 0.4 +
+ activist_potential * 0.35 +
+ campaign_feasibility * 0.15 +
+ risk_acceptability * 0.1
+ )
+
+ # Position sizing decision
+ if overall_conviction > 0.85:
+ position_size = "Large concentrated position (15-25%)"
+ conviction_level = 0.9
+ details.append("Exceptional opportunity warranting large concentrated position")
+ elif overall_conviction > 0.7:
+ position_size = "Significant position (8-15%)"
+ conviction_level = 0.75
+ details.append("High-conviction opportunity with strong activist potential")
+ elif overall_conviction > 0.55:
+ position_size = "Moderate position (3-8%)"
+ conviction_level = 0.6
+ details.append("Decent opportunity but below Pershing Square's typical standards")
+ else:
+ position_size = "Pass - insufficient conviction"
+ conviction_level = 0.3
+ details.append("Does not meet Pershing Square's high-conviction threshold")
+
+ # Timeline estimation
+ activist_opportunities = activism_strategy.get("activist_opportunities", [])
+ if "Board restructuring" in activist_opportunities:
+ expected_timeline = "18-36 months"
+ elif "Strategic restructuring" in activist_opportunities:
+ expected_timeline = "24-48 months"
+ elif "Capital allocation" in activist_opportunities:
+ expected_timeline = "12-24 months"
+ else:
+ expected_timeline = "6-18 months"
+
+ # Expected returns
+ if conviction_level > 0.8:
+ expected_return_range = "25-50% annualized"
+ elif conviction_level > 0.6:
+ expected_return_range = "15-25% annualized"
+ else:
+ expected_return_range = "5-15% annualized"
+
+ return {
+ "position_size": position_size,
+ "conviction_level": conviction_level,
+ "expected_timeline": expected_timeline,
+ "expected_return_range": expected_return_range,
+ "overall_conviction": overall_conviction,
+ "details": "; ".join(details)
+ }
+
+
+# Helper functions for Pershing Square analysis
+def analyze_business_quality_metrics(metrics: list, financial_line_items: list) -> float:
+ """Analyze business quality metrics"""
+ if not metrics:
+ return 0.5
+
+ quality_score = 0
+ components = 0
+
+ # Return on equity consistency
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if roe_vals:
+ avg_roe = sum(roe_vals) / len(roe_vals)
+ high_roe_years = sum(1 for roe in roe_vals if roe > 0.15)
+ roe_consistency = high_roe_years / len(roe_vals)
+
+ quality_score += min(avg_roe / 0.2, 1.0) * 0.5 + roe_consistency * 0.5
+ components += 1
+
+ # Free cash flow generation
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ if fcf_vals:
+ positive_fcf_years = sum(1 for fcf in fcf_vals if fcf > 0)
+ fcf_consistency = positive_fcf_years / len(fcf_vals)
+ quality_score += fcf_consistency
+ components += 1
+
+ # Revenue growth consistency
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ growth_years = sum(1 for i in range(len(revenues) - 1) if revenues[i] >= revenues[i + 1])
+ growth_consistency = growth_years / (len(revenues) - 1)
+ quality_score += growth_consistency
+ components += 1
+
+ return quality_score / components if components > 0 else 0.5
+
+
+def analyze_competitive_moat_strength(metrics: list, financial_line_items: list) -> float:
+ """Analyze competitive moat strength"""
+ if not metrics or not financial_line_items:
+ return 0.5
+
+ moat_indicators = 0
+ total_indicators = 0
+
+ # High and stable margins
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ avg_margin = sum(margins) / len(margins)
+ margin_stability = 1 - ((max(margins) - min(margins)) / max(margins)) if max(margins) > 0 else 0
+
+ if avg_margin > 0.15 and margin_stability > 0.7:
+ moat_indicators += 1
+ total_indicators += 1
+
+ # Return on invested capital superiority
+ if metrics:
+ roic_vals = [m.return_on_invested_capital for m in metrics if m.return_on_invested_capital]
+ if roic_vals:
+ avg_roic = sum(roic_vals) / len(roic_vals)
+ if avg_roic > 0.15: # >15% ROIC
+ moat_indicators += 1
+ total_indicators += 1
+
+ # Market position strength (proxy through revenue stability)
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ revenue_volatility = calculate_coefficient_of_variation(revenues)
+ if revenue_volatility < 0.2: # Low revenue volatility
+ moat_indicators += 1
+ total_indicators += 1
+
+ return moat_indicators / total_indicators if total_indicators > 0 else 0.5
+
+
+def assess_management_quality(metrics: list, financial_line_items: list) -> float:
+ """Assess management quality"""
+ if not metrics or not financial_line_items:
+ return 0.5
+
+ management_score = 0
+
+ # Capital allocation effectiveness
+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]
+ if len(shares) >= 3:
+ share_reduction = (shares[-1] - shares[0]) / shares[-1]
+ if share_reduction > 0.1: # 10%+ share reduction
+ management_score += 0.3
+
+ # ROE improvement over time
+ if metrics and len(metrics) >= 3:
+ roe_vals = [m.return_on_equity for m in metrics if m.return_on_equity]
+ if len(roe_vals) >= 3:
+ recent_roe = sum(roe_vals[:2]) / 2
+ historical_roe = sum(roe_vals[2:]) / len(roe_vals[2:])
+ if recent_roe > historical_roe:
+ management_score += 0.4
+
+ # Free cash flow vs earnings (capital discipline)
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+
+ if fcf_vals and earnings and len(fcf_vals) == len(earnings):
+ fcf_conversion = sum(fcf_vals) / sum(earnings) if sum(earnings) > 0 else 0
+ if fcf_conversion > 0.8:
+ management_score += 0.3
+
+ return management_score
+
+
+def calculate_intrinsic_value_ratio(financial_line_items: list, market_cap: float) -> float:
+ """Calculate intrinsic value to market cap ratio"""
+ if not financial_line_items or not market_cap:
+ return 1.0
+
+ latest = financial_line_items[0]
+
+ # DCF-based intrinsic value
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ # Conservative assumptions
+ growth_rate = 0.06 # 6% growth
+ terminal_growth = 0.03 # 3% terminal growth
+ discount_rate = 0.10 # 10% discount rate
+
+ # 10-year DCF
+ dcf_value = 0
+ for year in range(1, 11):
+ future_fcf = latest.free_cash_flow * (1 + growth_rate) ** year
+ present_value = future_fcf / ((1 + discount_rate) ** year)
+ dcf_value += present_value
+
+ # Terminal value
+ terminal_fcf = latest.free_cash_flow * (1 + growth_rate) ** 10
+ terminal_value = terminal_fcf * (1 + terminal_growth) / (discount_rate - terminal_growth)
+ terminal_pv = terminal_value / ((1 + discount_rate) ** 10)
+ dcf_value += terminal_pv
+
+ return dcf_value / market_cap
+
+ return 1.0
+
+
+def analyze_long_term_growth_potential(financial_line_items: list) -> float:
+ """Analyze long-term growth potential"""
+ growth_factors = 0
+
+ # Revenue growth trend
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 5:
+ revenue_cagr = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ if revenue_cagr > 0.08: # 8%+ revenue CAGR
+ growth_factors += 0.3
+
+ # R&D investment
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])
+ if rd_intensity > 0.05: # 5%+ R&D intensity
+ growth_factors += 0.3
+
+ # Market expansion capability
+ latest = financial_line_items[0]
+ if latest.current_assets and latest.current_liabilities:
+ working_capital_ratio = latest.current_assets / latest.current_liabilities
+ if working_capital_ratio > 1.5: # Strong balance sheet for expansion
+ growth_factors += 0.4
+
+ return growth_factors
+
+
+def assess_governance_improvement_opportunities(metrics: list, financial_line_items: list) -> float:
+ """Assess governance improvement opportunities"""
+ governance_score = 0
+
+ # Management performance issues
+ management_quality = assess_management_quality(metrics, financial_line_items)
+ if management_quality < 0.5:
+ governance_score += 0.4 # Board change opportunity
+
+ # Capital allocation inefficiencies
+ capital_allocation = analyze_capital_allocation_opportunities(financial_line_items)
+ if capital_allocation > 0.6:
+ governance_score += 0.3
+
+ # Shareholder returns vs performance
+ if metrics:
+ latest = metrics[0]
+ if latest.return_on_equity and latest.return_on_equity < 0.1: # <10% ROE
+ governance_score += 0.3 # Poor performance = governance opportunity
+
+ return governance_score
+
+
+def identify_strategic_restructuring_opportunities(financial_line_items: list, market_cap: float) -> float:
+ """Identify strategic restructuring opportunities"""
+ if not financial_line_items or not market_cap:
+ return 0
+
+ restructuring_score = 0
+ latest = financial_line_items[0]
+
+ # Sum-of-parts opportunity
+ if latest.total_assets and latest.total_debt:
+ asset_value = latest.total_assets - latest.total_debt
+ if asset_value > market_cap * 1.3: # 30%+ asset value premium
+ restructuring_score += 0.4
+
+ # Spin-off potential (proxy through asset complexity)
+ if latest.total_assets and latest.revenue:
+ asset_intensity = latest.total_assets / latest.revenue
+ if asset_intensity > 2.5: # Asset-heavy suggests complex structure
+ restructuring_score += 0.3
+
+ # Operational restructuring need
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and len(margins) >= 3:
+ margin_decline = margins[-1] - margins[0] # Historical vs current
+ if margin_decline > 0.05: # 5%+ margin decline
+ restructuring_score += 0.3
+
+ return restructuring_score
+
+
+def analyze_capital_allocation_opportunities(financial_line_items: list) -> float:
+ """Analyze capital allocation improvement opportunities"""
+ capital_score = 0
+
+ # Excess cash accumulation
+ latest = financial_line_items[0]
+ if latest.current_assets and latest.total_assets:
+ cash_proxy = latest.current_assets * 0.3 # Rough cash estimate
+ if cash_proxy > latest.total_assets * 0.15: # >15% cash
+ capital_score += 0.3
+
+ # Poor FCF to earnings conversion
+ fcf_vals = [item.free_cash_flow for item in financial_line_items if item.free_cash_flow]
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+
+ if fcf_vals and earnings and len(fcf_vals) == len(earnings):
+ conversion_ratio = sum(fcf_vals) / sum(earnings) if sum(earnings) > 0 else 0
+ if conversion_ratio < 0.7: # Poor cash conversion
+ capital_score += 0.4
+
+ # No share buybacks despite profitability
+ shares = [item.outstanding_shares for item in financial_line_items if item.outstanding_shares]
+ if len(shares) >= 3:
+ share_change = (shares[0] - shares[-1]) / shares[-1]
+ if share_change < 0.05 and earnings and sum(earnings) > 0: # No buybacks despite profit
+ capital_score += 0.3
+
+ return capital_score
+
+
+def identify_operational_efficiency_opportunities(financial_line_items: list) -> float:
+ """Identify operational efficiency opportunities"""
+ efficiency_score = 0
+
+ # Margin improvement potential
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ current_margin = margins[0]
+ best_margin = max(margins)
+
+ if best_margin > current_margin * 1.2: # 20%+ margin improvement potential
+ efficiency_score += 0.4
+
+ # Asset utilization improvement
+ if latest.total_assets and latest.revenue:
+ asset_turnover = latest.revenue / latest.total_assets
+ if asset_turnover < 1.0: # Low asset utilization
+ efficiency_score += 0.3
+
+ # Cost structure optimization
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ revenue_growth = (revenues[0] / revenues[-1]) - 1
+ margin_change = margins[0] - margins[-1] if margins and len(margins) >= 3 else 0
+
+ if revenue_growth > 0 and margin_change < 0: # Growing revenue, declining margins
+ efficiency_score += 0.3
+
+ return efficiency_score
+
+
+def assess_esg_improvement_opportunities(financial_line_items: list) -> float:
+ """Assess ESG improvement opportunities"""
+ esg_score = 0
+
+ # Environmental improvements (proxy through R&D)
+ rd_vals = [item.research_and_development for item in financial_line_items if item.research_and_development]
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+
+ if rd_vals and revenues:
+ rd_intensity = sum(rd_vals) / sum(revenues[:len(rd_vals)])
+ if rd_intensity < 0.03: # Low R&D = ESG improvement opportunity
+ esg_score += 0.3
+
+ # Governance improvements (covered in governance section)
+ governance_opportunity = assess_governance_improvement_opportunities(metrics, financial_line_items)
+ esg_score += governance_opportunity * 0.4
+
+ # Social responsibility opportunities
+ # Proxy through employee productivity (simplified)
+ if latest.revenue and latest.total_assets:
+ productivity_proxy = latest.revenue / latest.total_assets
+ if productivity_proxy < 0.8: # Low productivity
+ esg_score += 0.3
+
+ return min(esg_score, 1.0)
+
+
+def assess_public_campaign_viability(market_cap: float) -> float:
+ """Assess public campaign viability"""
+ # Larger companies get more media attention
+ if market_cap > 50_000_000_000: # $50B+
+ return 0.9
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.8
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.6
+ else:
+ return 0.3
+
+
+def assess_public_narrative_strength(financial_line_items: list) -> float:
+ """Assess strength of public narrative"""
+ # Strong narrative if clear value creation opportunity
+ narrative_score = 0
+
+ # Underperformance narrative
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and len(margins) >= 3:
+ margin_decline = margins[-1] - margins[0]
+ if margin_decline > 0.03: # Clear declining performance
+ narrative_score += 0.4
+
+ # Value creation potential narrative
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ revenue_stability = 1 - calculate_coefficient_of_variation(revenues)
+ if revenue_stability > 0.7: # Stable business with improvement potential
+ narrative_score += 0.3
+
+ # Asset value narrative
+ latest = financial_line_items[0]
+ if latest.total_assets and latest.total_debt:
+ net_assets = latest.total_assets - latest.total_debt
+ # Strong asset base provides narrative foundation
+ narrative_score += 0.3
+
+ return narrative_score
+
+
+def analyze_media_coverage_potential(market_cap: float) -> float:
+ """Analyze media coverage potential"""
+ # Media coverage correlates with company size and visibility
+ if market_cap > 20_000_000_000: # $20B+
+ return 0.8
+ elif market_cap > 5_000_000_000: # $5B+
+ return 0.7
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.5
+ else:
+ return 0.3
+
+
+def assess_shareholder_communication_potential(market_cap: float) -> float:
+ """Assess shareholder communication effectiveness potential"""
+ # Larger companies have more institutional shareholders
+ return min(market_cap / 20_000_000_000, 1.5) # Normalize by $20B, cap at 1.5
+
+
+def evaluate_public_pressure_effectiveness(financial_line_items: list) -> float:
+ """Evaluate effectiveness of public pressure"""
+ # Public pressure more effective when clear improvement opportunities exist
+ pressure_score = 0
+
+ # Clear performance issues
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ current_margin = margins[0]
+ if current_margin < 0.1: # <10% margins
+ pressure_score += 0.4
+
+ # Shareholder value destruction
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ revenue_decline = revenues[0] < revenues[-1]
+ if revenue_decline:
+ pressure_score += 0.3
+
+ return pressure_score
+
+
+def analyze_regulatory_environment(financial_line_items: list) -> float:
+ """Analyze regulatory environment favorability"""
+ # Simplified regulatory analysis
+ return 0.6 # Neutral regulatory environment
+
+
+def assess_concentration_risk(market_cap: float) -> float:
+ """Assess concentration risk for large positions"""
+ # Larger companies have lower concentration risk
+ if market_cap > 100_000_000_000: # $100B+
+ return 0.1
+ elif market_cap > 20_000_000_000: # $20B+
+ return 0.2
+ elif market_cap > 5_000_000_000: # $5B+
+ return 0.4
+ else:
+ return 0.7
+
+
+def assess_large_position_liquidity_risk(market_cap: float) -> float:
+ """Assess liquidity risk for large positions"""
+ # Liquidity risk inversely related to market cap
+ if market_cap > 50_000_000_000: # $50B+
+ return 0.1
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.2
+ elif market_cap > 2_000_000_000: # $2B+
+ return 0.4
+ else:
+ return 0.8
+
+
+def assess_activist_campaign_risks(financial_line_items: list) -> float:
+ """Assess activist campaign execution risks"""
+ campaign_risk = 0.3 # Base campaign risk
+
+ # Financial distress increases campaign risk
+ latest = financial_line_items[0]
+ if latest.current_assets and latest.current_liabilities:
+ current_ratio = latest.current_assets / latest.current_liabilities
+ if current_ratio < 1.2:
+ campaign_risk += 0.3
+
+ # Poor performance reduces campaign risk (easier to make case)
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and margins[0] < 0.08: # <8% margins
+ campaign_risk -= 0.2
+
+ return max(0, min(campaign_risk, 1.0))
+
+
+def assess_regulatory_and_legal_risks(market_cap: float) -> float:
+ """Assess regulatory and legal risks"""
+ # Larger companies face more regulatory scrutiny
+ if market_cap > 100_000_000_000: # $100B+
+ return 0.6
+ elif market_cap > 20_000_000_000: # $20B+
+ return 0.4
+ else:
+ return 0.2
+
+
+def assess_reputational_risk_exposure(financial_line_items: list) -> float:
+ """Assess reputational risk exposure"""
+ # Reputational risk based on business fundamentals
+ risk_score = 0.3 # Base risk
+
+ # Poor performance increases reputational risk
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins and margins[0] < 0.05: # <5% margins
+ risk_score += 0.3
+
+ return risk_score
+
+
+def calculate_downside_protection(financial_line_items: list, market_cap: float) -> float:
+ """Calculate downside protection"""
+ if not financial_line_items or not market_cap:
+ return 0.3
+
+ protection_score = 0
+ latest = financial_line_items[0]
+
+ # Asset backing
+ if latest.total_assets and latest.total_debt:
+ net_assets = latest.total_assets - latest.total_debt
+ if net_assets > market_cap * 0.8:
+ protection_score += 0.4
+
+ # Cash generation
+ if latest.free_cash_flow and latest.free_cash_flow > 0:
+ fcf_yield = latest.free_cash_flow / market_cap
+ if fcf_yield > 0.08: # 8%+ FCF yield
+ protection_score += 0.3
+
+ # Business stability
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if revenues:
+ revenue_stability = 1 - calculate_coefficient_of_variation(revenues)
+ protection_score += revenue_stability * 0.3
+
+ return protection_score
+
+
+def calculate_coefficient_of_variation(data: list) -> float:
+ """Calculate coefficient of variation"""
+ if not data or len(data) < 2:
+ return 1.0
+
+ mean_val = sum(data) / len(data)
+ if mean_val == 0:
+ return 1.0
+
+ variance = sum((x - mean_val) ** 2 for x in data) / len(data)
+ std_dev = (variance ** 0.5)
+
+ return std_dev / abs(mean_val)
+
+
+def generate_pershing_output(ticker: str, analysis_data: dict, state: AgentState,
+ agent_id: str) -> PershingSquareSignal:
+ """Generate Pershing Square's concentrated activist investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Pershing Square's AI system, implementing Bill Ackman's concentrated activist approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Research Team: Deep fundamental analysis and intrinsic value calculation
+ - Activism Strategy Team: Board changes, strategic restructuring, operational improvements
+ - Public Relations Strategy: Media campaigns, shareholder communication, narrative building
+ - Risk Management: Concentration risk, liquidity risk, campaign execution risk
+ - Bill Ackman Investment Decision: High-conviction concentrated positioning
+
+ PHILOSOPHY:
+ 1. Concentrated Investing: Large positions (10-25%) in high-conviction ideas
+ 2. Activist Value Creation: Board changes, strategic improvements, operational efficiency
+ 3. Public Campaigns: Media engagement and public pressure for change
+ 4. Long-Term Value Creation: Multi-year investment horizons
+ 5. Quality Businesses: Strong competitive positions with improvement potential
+ 6. Intrinsic Value Focus: Significant discount to fair value required
+ 7. ESG Integration: Environmental, social, and governance improvements
+
+ REASONING STYLE:
+ - Express high conviction and concentrated position rationale
+ - Discuss specific activist catalysts and value creation opportunities
+ - Reference intrinsic value calculations and margin of safety
+ - Consider public campaign strategy and media narrative
+ - Analyze management quality and governance improvements
+ - Assess timeline and expected returns from activist engagement
+ - Focus on asymmetric risk/reward from concentrated positions
+
+ Return investment signal with detailed investment thesis and activist strategy."""),
+
+ ("human", """Apply Pershing Square's concentrated activist analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "investment_thesis": {{
+ "intrinsic_value_upside": float,
+ "activist_catalysts": ["string"],
+ "expected_timeline": "string",
+ "position_size_recommendation": "string",
+ "public_campaign_strategy": "string"
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_pershing_signal():
+ return PershingSquareSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ investment_thesis={
+ "intrinsic_value_upside": 0.0,
+ "activist_catalysts": [],
+ "expected_timeline": "12-24 months",
+ "position_size_recommendation": "Pass",
+ "public_campaign_strategy": "None"
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=PershingSquareSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_pershing_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.py
new file mode 100644
index 000000000..a8030f1e3
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/renaissance_technologies_hedge_fund_agent/renaissance_technologies_agent.py
@@ -0,0 +1,676 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+import math
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class RenaissanceSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ statistical_edge: float
+ signal_strength: dict
+
+
+def renaissance_technologies_agent(state: AgentState, agent_id: str = "renaissance_technologies_agent"):
+ """
+ Renaissance Technologies: Pure quantitative, statistical arbitrage
+ Structure: Signal Generation → Risk Models → Execution Optimization → Jim Simons Systematic Decision
+ Philosophy: Mathematical models, statistical edges, high-frequency systematic trading
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ renaissance_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Signal generation algorithms analyzing patterns")
+
+ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=20, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_assets",
+ "shareholders_equity", "operating_margin", "total_debt",
+ "current_assets", "current_liabilities", "outstanding_shares"
+ ],
+ end_date,
+ period="quarterly",
+ limit=20,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Renaissance's algorithmic analysis structure
+ progress.update_status(agent_id, ticker, "Signal generation team analysis")
+ signal_generation = signal_generation_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk modeling team analysis")
+ risk_modeling = risk_modeling_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Execution optimization analysis")
+ execution_optimization = execution_optimization_analysis(financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Statistical arbitrage models")
+ statistical_arbitrage = statistical_arbitrage_analysis(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Jim Simons systematic synthesis")
+ simons_systematic_decision = simons_systematic_synthesis(
+ signal_generation, risk_modeling, execution_optimization, statistical_arbitrage
+ )
+
+ # Renaissance's mathematical scoring
+ total_score = (
+ signal_generation["score"] * 0.35 +
+ statistical_arbitrage["score"] * 0.3 +
+ risk_modeling["score"] * 0.2 +
+ execution_optimization["score"] * 0.15
+ )
+
+ # Renaissance's systematic thresholds
+ if total_score >= 8.0 and signal_generation.get("statistical_significance", 0) > 0.95:
+ signal = "bullish"
+ elif total_score <= 3.0 or signal_generation.get("statistical_significance", 0) < 0.6:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "signal_generation": signal_generation,
+ "risk_modeling": risk_modeling,
+ "execution_optimization": execution_optimization,
+ "statistical_arbitrage": statistical_arbitrage,
+ "simons_systematic_decision": simons_systematic_decision
+ }
+
+ renaissance_output = generate_renaissance_output(ticker, analysis_data, state, agent_id)
+
+ renaissance_analysis[ticker] = {
+ "signal": renaissance_output.signal,
+ "confidence": renaissance_output.confidence,
+ "reasoning": renaissance_output.reasoning,
+ "statistical_edge": renaissance_output.statistical_edge,
+ "signal_strength": renaissance_output.signal_strength
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=renaissance_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(renaissance_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(renaissance_analysis, "Renaissance Technologies")
+
+ state["data"]["analyst_signals"][agent_id] = renaissance_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def signal_generation_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Renaissance's signal generation algorithms"""
+ score = 0
+ details = []
+ signals = {}
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No signal data"}
+
+ # Mean reversion signals
+ mean_reversion_score = calculate_mean_reversion_signals(metrics, financial_line_items)
+ signals["mean_reversion"] = mean_reversion_score
+ score += mean_reversion_score * 2
+
+ # Momentum signals
+ momentum_score = calculate_momentum_signals(metrics, financial_line_items)
+ signals["momentum"] = momentum_score
+ score += momentum_score * 2
+
+ # Statistical pattern recognition
+ pattern_score = identify_statistical_patterns(financial_line_items)
+ signals["patterns"] = pattern_score
+ score += pattern_score * 1.5
+
+ # Cross-sectional signals
+ cross_sectional_score = calculate_cross_sectional_signals(metrics)
+ signals["cross_sectional"] = cross_sectional_score
+ score += cross_sectional_score * 1.5
+
+ # Factor exposure analysis
+ factor_exposure = analyze_factor_exposures(metrics, financial_line_items)
+ signals["factor_exposure"] = factor_exposure
+ score += factor_exposure * 1
+
+ # Statistical significance calculation
+ statistical_significance = calculate_statistical_significance(signals)
+
+ details.append(f"Mean reversion signal: {mean_reversion_score:.2f}")
+ details.append(f"Momentum signal: {momentum_score:.2f}")
+ details.append(f"Pattern recognition: {pattern_score:.2f}")
+ details.append(f"Statistical significance: {statistical_significance:.2f}")
+
+ return {
+ "score": min(score, 10), # Cap at 10
+ "details": "; ".join(details),
+ "signals": signals,
+ "statistical_significance": statistical_significance
+ }
+
+
+def risk_modeling_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Renaissance's risk modeling team analysis"""
+ score = 0
+ details = []
+ risk_metrics = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No risk modeling data"}
+
+ # Volatility modeling
+ volatility_score = model_volatility_patterns(financial_line_items)
+ risk_metrics["volatility"] = volatility_score
+ if volatility_score > 0.7:
+ score += 2
+ details.append("Low volatility risk profile")
+
+ # Correlation analysis
+ correlation_risk = analyze_correlation_risks(metrics, financial_line_items)
+ risk_metrics["correlation"] = correlation_risk
+ if correlation_risk < 0.6: # Low correlation is good
+ score += 2
+ details.append("Low correlation risk with market factors")
+
+ # Liquidity risk modeling
+ liquidity_risk = model_liquidity_risk(financial_line_items, market_cap)
+ risk_metrics["liquidity"] = liquidity_risk
+ if liquidity_risk > 0.8:
+ score += 1
+ details.append("Adequate liquidity for position sizing")
+
+ # Factor risk decomposition
+ factor_risks = decompose_factor_risks(metrics)
+ risk_metrics["factor_risks"] = factor_risks
+ if factor_risks.get("idiosyncratic_risk", 0) > 0.6:
+ score += 2
+ details.append("High idiosyncratic risk component - good for alpha generation")
+
+ # Drawdown risk analysis
+ drawdown_risk = calculate_maximum_drawdown_risk(financial_line_items)
+ risk_metrics["drawdown"] = drawdown_risk
+ if drawdown_risk < 0.3: # Low drawdown risk
+ score += 1
+ details.append("Limited drawdown risk based on historical patterns")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "risk_metrics": risk_metrics
+ }
+
+
+def execution_optimization_analysis(financial_line_items: list, market_cap: float) -> dict:
+ """Renaissance's execution optimization analysis"""
+ score = 0
+ details = []
+
+ if not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No execution data"}
+
+ # Market impact modeling
+ market_impact = estimate_market_impact(market_cap)
+ if market_impact < 0.02: # Low market impact
+ score += 3
+ details.append(f"Low market impact: {market_impact:.3f}")
+ elif market_impact < 0.05:
+ score += 2
+ details.append(f"Moderate market impact: {market_impact:.3f}")
+
+ # Execution timing optimization
+ timing_score = analyze_execution_timing(financial_line_items)
+ score += timing_score * 2
+ details.append(f"Execution timing score: {timing_score:.2f}")
+
+ # Transaction cost analysis
+ transaction_costs = estimate_transaction_costs(market_cap)
+ if transaction_costs < 0.01: # Low transaction costs
+ score += 2
+ details.append(f"Low transaction costs: {transaction_costs:.3f}")
+
+ # Slippage minimization
+ slippage_risk = calculate_slippage_risk(market_cap)
+ if slippage_risk < 0.5:
+ score += 1
+ details.append("Low slippage risk for systematic execution")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def statistical_arbitrage_analysis(metrics: list, financial_line_items: list) -> dict:
+ """Renaissance's statistical arbitrage models"""
+ score = 0
+ details = []
+ arbitrage_signals = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No statistical arbitrage data"}
+
+ # Pairs trading signals
+ pairs_signal = calculate_pairs_trading_signals(metrics, financial_line_items)
+ arbitrage_signals["pairs"] = pairs_signal
+ score += pairs_signal * 2
+
+ # Statistical mispricing detection
+ mispricing_score = detect_statistical_mispricing(metrics, financial_line_items)
+ arbitrage_signals["mispricing"] = mispricing_score
+ score += mispricing_score * 2.5
+
+ # Regime change detection
+ regime_change = detect_regime_changes(financial_line_items)
+ arbitrage_signals["regime_change"] = regime_change
+ score += regime_change * 1.5
+
+ # Market microstructure signals
+ microstructure_score = analyze_market_microstructure(metrics)
+ arbitrage_signals["microstructure"] = microstructure_score
+ score += microstructure_score * 1
+
+ details.append(f"Pairs trading signal: {pairs_signal:.2f}")
+ details.append(f"Mispricing detection: {mispricing_score:.2f}")
+ details.append(f"Regime change signal: {regime_change:.2f}")
+
+ return {
+ "score": min(score, 10),
+ "details": "; ".join(details),
+ "arbitrage_signals": arbitrage_signals
+ }
+
+
+def simons_systematic_synthesis(signal_generation: dict, risk_modeling: dict,
+ execution_optimization: dict, statistical_arbitrage: dict) -> dict:
+ """Jim Simons' systematic synthesis and decision"""
+ details = []
+
+ # Mathematical model synthesis
+ signal_strength = signal_generation.get("statistical_significance", 0)
+ risk_adjustment = risk_modeling.get("risk_metrics", {}).get("volatility", 0.5)
+ execution_feasibility = execution_optimization["score"] / 10
+ arbitrage_opportunity = statistical_arbitrage["score"] / 10
+
+ # Simons' systematic decision framework
+ overall_edge = (signal_strength * 0.4 +
+ arbitrage_opportunity * 0.3 +
+ execution_feasibility * 0.2 +
+ (1 - risk_adjustment) * 0.1)
+
+ if overall_edge > 0.8:
+ decision = "High conviction systematic trade"
+ details.append("Strong statistical edge with low risk and good execution")
+ elif overall_edge > 0.6:
+ decision = "Moderate systematic position"
+ details.append("Adequate statistical edge for systematic strategy")
+ elif signal_strength < 0.6:
+ decision = "Insufficient statistical significance"
+ details.append("Statistical significance below systematic threshold")
+ else:
+ decision = "Pass - inadequate systematic edge"
+ details.append("No clear systematic advantage identified")
+
+ # Mathematical model confidence
+ model_confidence = min(signal_strength * arbitrage_opportunity * execution_feasibility, 1.0)
+
+ return {
+ "decision": decision,
+ "overall_edge": overall_edge,
+ "model_confidence": model_confidence,
+ "details": "; ".join(details)
+ }
+
+
+# Mathematical and statistical helper functions
+def calculate_mean_reversion_signals(metrics: list, financial_line_items: list) -> float:
+ """Calculate mean reversion signals"""
+ if not metrics:
+ return 0.5
+
+ # Price-to-earnings mean reversion
+ pe_ratios = [m.price_to_earnings for m in metrics if m.price_to_earnings and m.price_to_earnings > 0]
+ if len(pe_ratios) >= 4:
+ current_pe = pe_ratios[0]
+ historical_mean = sum(pe_ratios[1:]) / len(pe_ratios[1:])
+
+ # Mean reversion signal strength
+ deviation = abs(current_pe - historical_mean) / historical_mean
+ if current_pe < historical_mean * 0.8: # 20% below mean
+ return min(deviation, 1.0)
+ elif current_pe > historical_mean * 1.2: # 20% above mean
+ return -min(deviation, 1.0)
+
+ return 0.0
+
+
+def calculate_momentum_signals(metrics: list, financial_line_items: list) -> float:
+ """Calculate momentum signals"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ # Revenue momentum
+ recent_growth = (revenues[0] / revenues[1]) - 1
+ historical_growth = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1
+
+ momentum_strength = (recent_growth - historical_growth) / abs(
+ historical_growth) if historical_growth != 0 else 0
+ return max(min(momentum_strength, 1.0), -1.0)
+
+ return 0.0
+
+
+def identify_statistical_patterns(financial_line_items: list) -> float:
+ """Identify statistical patterns in financial data"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if len(earnings) >= 8:
+ # Pattern recognition using simple autocorrelation
+ autocorr = calculate_autocorrelation(earnings, lag=1)
+ pattern_strength = abs(autocorr)
+ return min(pattern_strength, 1.0)
+
+ return 0.3
+
+
+def calculate_cross_sectional_signals(metrics: list) -> float:
+ """Calculate cross-sectional ranking signals"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ # Simplified cross-sectional score based on multiple metrics
+ score_components = []
+
+ if latest.return_on_equity:
+ score_components.append(min(latest.return_on_equity / 0.15, 1.0)) # Normalize by 15%
+
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ score_components.append(max(1 - (latest.price_to_earnings / 20), 0)) # Lower P/E is better
+
+ if score_components:
+ return sum(score_components) / len(score_components)
+
+ return 0.5
+
+
+def analyze_factor_exposures(metrics: list, financial_line_items: list) -> float:
+ """Analyze factor exposures"""
+ # Simplified factor analysis
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ factor_score = 0
+
+ # Value factor
+ if latest.price_to_book and latest.price_to_book < 2.0:
+ factor_score += 0.3
+
+ # Quality factor
+ if latest.return_on_equity and latest.return_on_equity > 0.12:
+ factor_score += 0.3
+
+ # Momentum factor
+ if financial_line_items:
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 2 and revenues[0] > revenues[1]:
+ factor_score += 0.2
+
+ return min(factor_score, 1.0)
+
+
+def calculate_statistical_significance(signals: dict) -> float:
+ """Calculate overall statistical significance"""
+ signal_values = [v for v in signals.values() if isinstance(v, (int, float))]
+ if not signal_values:
+ return 0.5
+
+ # Simplified statistical significance based on signal consistency
+ signal_consistency = 1 - (max(signal_values) - min(signal_values)) / 2
+ signal_strength = sum(abs(v) for v in signal_values) / len(signal_values)
+
+ return (signal_consistency * 0.6 + signal_strength * 0.4)
+
+
+def model_volatility_patterns(financial_line_items: list) -> float:
+ """Model volatility patterns"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ volatility = calculate_coefficient_of_variation(revenues)
+ return max(1 - volatility, 0) # Lower volatility = higher score
+ return 0.5
+
+
+def analyze_correlation_risks(metrics: list, financial_line_items: list) -> float:
+ """Analyze correlation with market factors"""
+ # Simplified correlation analysis
+ return 0.4 # Placeholder - would calculate correlation with market indices
+
+
+def model_liquidity_risk(financial_line_items: list, market_cap: float) -> float:
+ """Model liquidity risk"""
+ if market_cap > 10_000_000_000: # $10B+ market cap
+ return 0.9
+ elif market_cap > 1_000_000_000: # $1B+ market cap
+ return 0.7
+ else:
+ return 0.4
+
+
+def decompose_factor_risks(metrics: list) -> dict:
+ """Decompose factor risks"""
+ return {
+ "market_risk": 0.4,
+ "size_risk": 0.2,
+ "value_risk": 0.1,
+ "momentum_risk": 0.1,
+ "idiosyncratic_risk": 0.2
+ }
+
+
+def calculate_maximum_drawdown_risk(financial_line_items: list) -> float:
+ """Calculate maximum drawdown risk"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ peak = max(earnings)
+ trough = min(earnings)
+ if peak > 0:
+ return abs(trough - peak) / peak
+ return 0.5
+
+
+def estimate_market_impact(market_cap: float) -> float:
+ """Estimate market impact for trading"""
+ if market_cap > 50_000_000_000: # $50B+
+ return 0.001
+ elif market_cap > 10_000_000_000: # $10B+
+ return 0.005
+ elif market_cap > 1_000_000_000: # $1B+
+ return 0.02
+ else:
+ return 0.1
+
+
+def analyze_execution_timing(financial_line_items: list) -> float:
+ """Analyze optimal execution timing"""
+ return 0.7 # Placeholder for execution timing analysis
+
+
+def estimate_transaction_costs(market_cap: float) -> float:
+ """Estimate transaction costs"""
+ if market_cap > 10_000_000_000:
+ return 0.005
+ elif market_cap > 1_000_000_000:
+ return 0.01
+ else:
+ return 0.03
+
+
+def calculate_slippage_risk(market_cap: float) -> float:
+ """Calculate slippage risk"""
+ return 1 / (1 + math.log10(market_cap / 1_000_000_000)) # Decreases with market cap
+
+
+def calculate_pairs_trading_signals(metrics: list, financial_line_items: list) -> float:
+ """Calculate pairs trading signals"""
+ return 0.6 # Placeholder for pairs trading analysis
+
+
+def detect_statistical_mispricing(metrics: list, financial_line_items: list) -> float:
+ """Detect statistical mispricing"""
+ if not metrics:
+ return 0.5
+
+ latest = metrics[0]
+ mispricing_score = 0
+
+ # P/E vs growth mispricing
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3:
+ growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ expected_pe = 15 + (growth * 100) # Simple growth-adjusted P/E
+ if latest.price_to_earnings < expected_pe * 0.8:
+ mispricing_score += 0.5
+
+ return mispricing_score
+
+
+def detect_regime_changes(financial_line_items: list) -> float:
+ """Detect regime changes in business fundamentals"""
+ margins = []
+ for item in financial_line_items:
+ if item.net_income and item.revenue and item.revenue > 0:
+ margins.append(item.net_income / item.revenue)
+
+ if len(margins) >= 4:
+ recent_avg = sum(margins[:2]) / 2
+ historical_avg = sum(margins[2:]) / len(margins[2:])
+
+ if abs(recent_avg - historical_avg) > 0.05: # 5% margin change
+ return 0.8
+
+ return 0.2
+
+
+def analyze_market_microstructure(metrics: list) -> float:
+ """Analyze market microstructure signals"""
+ return 0.5 # Placeholder for microstructure analysis
+
+
+def calculate_autocorrelation(data: list, lag: int) -> float:
+ """Calculate autocorrelation with given lag"""
+ if len(data) <= lag:
+ return 0
+
+ mean_val = sum(data) / len(data)
+ numerator = sum((data[i] - mean_val) * (data[i + lag] - mean_val)
+ for i in range(len(data) - lag))
+ denominator = sum((x - mean_val) ** 2 for x in data)
+
+ return numerator / denominator if denominator != 0 else 0
+
+
+def calculate_coefficient_of_variation(data: list) -> float:
+ """Calculate coefficient of variation"""
+ if not data:
+ return 1.0
+
+ mean_val = sum(data) / len(data)
+ if mean_val == 0:
+ return 1.0
+
+ variance = sum((x - mean_val) ** 2 for x in data) / len(data)
+ std_dev = math.sqrt(variance)
+
+ return std_dev / abs(mean_val)
+
+
+def generate_renaissance_output(ticker: str, analysis_data: dict, state: AgentState,
+ agent_id: str) -> RenaissanceSignal:
+ """Generate Renaissance's systematic quantitative decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Renaissance Technologies' AI system, implementing Jim Simons' quantitative systematic approach:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Signal Generation Team: Mathematical pattern recognition and statistical signals
+ - Risk Modeling Team: Volatility, correlation, and factor risk analysis
+ - Execution Optimization Team: Market impact and transaction cost modeling
+ - Statistical Arbitrage Team: Pairs trading and mispricing detection
+ - Jim Simons Systematic Synthesis: Mathematical model integration
+
+ PHILOSOPHY:
+ 1. Pure Quantitative: Mathematical models over fundamental analysis
+ 2. Statistical Edge: Identify small, consistent statistical advantages
+ 3. Systematic Execution: Remove human emotion and bias
+ 4. High Frequency: Exploit short-term market inefficiencies
+ 5. Risk Management: Sophisticated mathematical risk models
+ 6. Diversification: Many small bets rather than few large ones
+ 7. Continuous Learning: Models adapt and evolve systematically
+
+ REASONING STYLE:
+ - Reference mathematical models and statistical significance
+ - Discuss signal generation algorithms and pattern recognition
+ - Consider risk-adjusted returns and Sharpe ratios
+ - Apply systematic decision thresholds and confidence intervals
+ - Express reasoning in quantitative terms
+ - Acknowledge model limitations and uncertainty
+ - Focus on statistical edge and execution feasibility
+
+ Return the investment signal with statistical edge and signal strength metrics."""),
+
+ ("human", """Apply Renaissance's quantitative systematic analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "statistical_edge": float (0-1),
+ "signal_strength": {{
+ "mean_reversion": float,
+ "momentum": float,
+ "statistical_arbitrage": float,
+ "risk_adjusted_return": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_renaissance_signal():
+ return RenaissanceSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ statistical_edge=0.0,
+ signal_strength={
+ "mean_reversion": 0.0,
+ "momentum": 0.0,
+ "statistical_arbitrage": 0.0,
+ "risk_adjusted_return": 0.0
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=RenaissanceSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_renaissance_signal,
+ )
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.py
new file mode 100644
index 000000000..3a520a8d2
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/sample_usage.py
@@ -0,0 +1,415 @@
+# ===== HEDGE FUND AGENTS INTEGRATION GUIDE =====
+
+# 1. STANDALONE USAGE (Direct Import)
+from bridgewater_hedge_fund import bridgewater_associates_agent
+from renaissance_hedge_fund import renaissance_technologies_agent
+from citadel_hedge_fund import citadel_hedge_fund_agent
+
+
+# ... import all other agents
+
+def analyze_stock_with_hedge_funds(ticker: str, financial_data: dict):
+ """Use multiple hedge fund agents to analyze a stock"""
+
+ # Create mock state (replace with your actual state structure)
+ state = {
+ "data": {
+ "tickers": [ticker],
+ "end_date": "2024-12-31",
+ "analyst_signals": {}
+ },
+ "metadata": {"show_reasoning": True}
+ }
+
+ # Run multiple hedge fund analyses
+ results = {}
+
+ # Bridgewater Analysis
+ bridgewater_result = bridgewater_associates_agent(state, "bridgewater")
+ results["bridgewater"] = state["data"]["analyst_signals"]["bridgewater"]
+
+ # Renaissance Analysis
+ renaissance_result = renaissance_technologies_agent(state, "renaissance")
+ results["renaissance"] = state["data"]["analyst_signals"]["renaissance"]
+
+ # AQR Analysis
+ aqr_result = aqr_capital_hedge_fund_agent(state, "aqr")
+ results["aqr"] = state["data"]["analyst_signals"]["aqr"]
+
+ return results
+
+
+# 2. OPENROUTER INTEGRATION
+import openai
+
+
+def setup_openrouter_client():
+ """Setup OpenRouter client"""
+ return openai.OpenAI(
+ base_url="https://openrouter.ai/api/v1",
+ api_key="YOUR_OPENROUTER_API_KEY"
+ )
+
+
+def call_llm_openrouter(prompt, pydantic_model, agent_name, state, default_factory,
+ model="anthropic/claude-3.5-sonnet"):
+ """Modified LLM call for OpenRouter"""
+ client = setup_openrouter_client()
+
+ try:
+ response = client.chat.completions.create(
+ model=model,
+ messages=[
+ {"role": "system", "content": prompt.messages[0].content},
+ {"role": "user", "content": prompt.messages[1].content}
+ ],
+ temperature=0.1,
+ max_tokens=2000
+ )
+
+ # Parse JSON response
+ import json
+ content = response.choices[0].message.content
+
+ # Extract JSON from response
+ start_idx = content.find('{')
+ end_idx = content.rfind('}') + 1
+ json_str = content[start_idx:end_idx]
+
+ parsed_data = json.loads(json_str)
+ return pydantic_model(**parsed_data)
+
+ except Exception as e:
+ print(f"OpenRouter API error: {e}")
+ return default_factory()
+
+
+# 3. OLLAMA LOCAL INTEGRATION
+import requests
+import json
+
+
+def call_llm_ollama(prompt, pydantic_model, agent_name, state, default_factory, model="llama3.1:70b"):
+ """Modified LLM call for Ollama local"""
+
+ # Combine system and user messages
+ full_prompt = f"System: {prompt.messages[0].content}\n\nHuman: {prompt.messages[1].content}\n\nAssistant:"
+
+ try:
+ response = requests.post(
+ "http://localhost:11434/api/generate",
+ json={
+ "model": model,
+ "prompt": full_prompt,
+ "stream": False,
+ "options": {
+ "temperature": 0.1,
+ "top_p": 0.9
+ }
+ },
+ timeout=120
+ )
+
+ if response.status_code == 200:
+ content = response.json()["response"]
+
+ # Extract JSON from response
+ start_idx = content.find('{')
+ end_idx = content.rfind('}') + 1
+
+ if start_idx >= 0 and end_idx > start_idx:
+ json_str = content[start_idx:end_idx]
+ parsed_data = json.loads(json_str)
+ return pydantic_model(**parsed_data)
+ else:
+ raise ValueError("No valid JSON found in response")
+ else:
+ raise Exception(f"HTTP {response.status_code}: {response.text}")
+
+ except Exception as e:
+ print(f"Ollama API error: {e}")
+ return default_factory()
+
+
+# 4. CUSTOM LLM INTEGRATION WRAPPER
+class HedgeFundLLMAdapter:
+ """Adapter to use different LLM providers with hedge fund agents"""
+
+ def __init__(self, provider="openai", **kwargs):
+ self.provider = provider
+ self.config = kwargs
+
+ def call_llm(self, prompt, pydantic_model, agent_name, state, default_factory):
+ """Route to appropriate LLM provider"""
+
+ if self.provider == "openrouter":
+ return call_llm_openrouter(
+ prompt, pydantic_model, agent_name, state, default_factory,
+ model=self.config.get("model", "anthropic/claude-3.5-sonnet")
+ )
+ elif self.provider == "ollama":
+ return call_llm_ollama(
+ prompt, pydantic_model, agent_name, state, default_factory,
+ model=self.config.get("model", "llama3.1:70b")
+ )
+ elif self.provider == "openai":
+ return self.call_openai_llm(prompt, pydantic_model, agent_name, state, default_factory)
+ else:
+ raise ValueError(f"Unsupported provider: {self.provider}")
+
+ def call_openai_llm(self, prompt, pydantic_model, agent_name, state, default_factory):
+ """OpenAI integration"""
+ import openai
+
+ client = openai.OpenAI(api_key=self.config.get("api_key"))
+
+ try:
+ response = client.chat.completions.create(
+ model=self.config.get("model", "gpt-4"),
+ messages=[
+ {"role": "system", "content": prompt.messages[0].content},
+ {"role": "user", "content": prompt.messages[1].content}
+ ],
+ temperature=0.1,
+ max_tokens=2000
+ )
+
+ content = response.choices[0].message.content
+ start_idx = content.find('{')
+ end_idx = content.rfind('}') + 1
+ json_str = content[start_idx:end_idx]
+
+ parsed_data = json.loads(json_str)
+ return pydantic_model(**parsed_data)
+
+ except Exception as e:
+ print(f"OpenAI API error: {e}")
+ return default_factory()
+
+
+# 5. USAGE EXAMPLES
+
+def example_standalone_usage():
+ """Example: Using hedge fund agents standalone"""
+
+ # Mock financial data (replace with real data from your API)
+ mock_state = {
+ "data": {
+ "tickers": ["AAPL"],
+ "end_date": "2024-12-31",
+ "analyst_signals": {}
+ },
+ "metadata": {"show_reasoning": True}
+ }
+
+ # Patch the call_llm function to use your preferred provider
+ import bridgewater_hedge_fund
+ llm_adapter = HedgeFundLLMAdapter(provider="openrouter", model="anthropic/claude-3.5-sonnet")
+ bridgewater_hedge_fund.call_llm = llm_adapter.call_llm
+
+ # Run analysis
+ result = bridgewater_associates_agent(mock_state, "bridgewater_test")
+
+ print("Bridgewater Analysis Results:")
+ print(json.dumps(mock_state["data"]["analyst_signals"]["bridgewater_test"], indent=2))
+
+
+def example_multi_hedge_fund_consensus():
+ """Example: Get consensus from multiple hedge funds"""
+
+ hedge_funds = [
+ ("bridgewater", bridgewater_associates_agent),
+ ("renaissance", renaissance_technologies_agent),
+ ("aqr", aqr_capital_hedge_fund_agent),
+ ("elliott", elliott_management_hedge_fund_agent)
+ ]
+
+ ticker = "MSFT"
+ all_signals = {}
+
+ # Setup LLM adapter
+ llm_adapter = HedgeFundLLMAdapter(provider="ollama", model="llama3.1:70b")
+
+ for fund_name, fund_agent in hedge_funds:
+ # Patch LLM function for this fund
+ fund_module = fund_agent.__module__
+ import importlib
+ module = importlib.import_module(fund_module)
+ module.call_llm = llm_adapter.call_llm
+
+ # Create state
+ state = create_mock_state([ticker])
+
+ # Run analysis
+ try:
+ fund_agent(state, f"{fund_name}_analysis")
+ all_signals[fund_name] = state["data"]["analyst_signals"][f"{fund_name}_analysis"][ticker]
+ except Exception as e:
+ print(f"Error running {fund_name}: {e}")
+ continue
+
+ # Calculate consensus
+ consensus = calculate_hedge_fund_consensus(all_signals)
+ return consensus
+
+
+def create_mock_state(tickers: list):
+ """Create mock state for testing"""
+ return {
+ "data": {
+ "tickers": tickers,
+ "end_date": "2024-12-31",
+ "analyst_signals": {}
+ },
+ "metadata": {"show_reasoning": True}
+ }
+
+
+def calculate_hedge_fund_consensus(signals: dict):
+ """Calculate consensus from multiple hedge fund signals"""
+
+ if not signals:
+ return {"consensus": "neutral", "confidence": 0}
+
+ # Count signals
+ bullish_count = sum(1 for signal in signals.values() if signal.get("signal") == "bullish")
+ bearish_count = sum(1 for signal in signals.values() if signal.get("signal") == "bearish")
+ neutral_count = len(signals) - bullish_count - bearish_count
+
+ total_funds = len(signals)
+
+ # Determine consensus
+ if bullish_count > total_funds * 0.6:
+ consensus = "bullish"
+ confidence = bullish_count / total_funds
+ elif bearish_count > total_funds * 0.6:
+ consensus = "bearish"
+ confidence = bearish_count / total_funds
+ else:
+ consensus = "neutral"
+ confidence = max(bullish_count, bearish_count, neutral_count) / total_funds
+
+ # Calculate average confidence
+ avg_confidence = sum(signal.get("confidence", 0) for signal in signals.values()) / total_funds
+
+ return {
+ "consensus": consensus,
+ "consensus_strength": confidence,
+ "average_confidence": avg_confidence,
+ "fund_breakdown": {
+ "bullish": bullish_count,
+ "bearish": bearish_count,
+ "neutral": neutral_count
+ },
+ "individual_signals": signals
+ }
+
+
+# 6. FLASK/FASTAPI WEB SERVICE EXAMPLE
+
+from flask import Flask, request, jsonify
+
+app = Flask(__name__)
+
+
[email protected]('/analyze/<ticker>')
+def analyze_ticker(ticker):
+ """Web endpoint to analyze a ticker with all hedge funds"""
+
+ try:
+ # Setup LLM adapter based on query parameter
+ provider = request.args.get('provider', 'openrouter')
+ model = request.args.get('model', 'anthropic/claude-3.5-sonnet')
+
+ llm_adapter = HedgeFundLLMAdapter(provider=provider, model=model)
+
+ # Run analysis with selected hedge funds
+ selected_funds = request.args.get('funds', 'bridgewater,aqr,renaissance').split(',')
+
+ results = {}
+ for fund_name in selected_funds:
+ if fund_name in AVAILABLE_FUNDS:
+ fund_agent = AVAILABLE_FUNDS[fund_name]
+
+ # Patch LLM
+ fund_module = importlib.import_module(fund_agent.__module__)
+ fund_module.call_llm = llm_adapter.call_llm
+
+ # Run analysis
+ state = create_mock_state([ticker])
+ fund_agent(state, f"{fund_name}_web")
+ results[fund_name] = state["data"]["analyst_signals"][f"{fund_name}_web"][ticker]
+
+ # Calculate consensus
+ consensus = calculate_hedge_fund_consensus(results)
+
+ return jsonify({
+ "ticker": ticker,
+ "consensus": consensus,
+ "individual_analyses": results,
+ "timestamp": "2024-12-31T00:00:00Z"
+ })
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+# Available hedge funds mapping
+AVAILABLE_FUNDS = {
+ "bridgewater": bridgewater_associates_agent,
+ "renaissance": renaissance_technologies_agent,
+ "citadel": citadel_hedge_fund_agent,
+ "two_sigma": two_sigma_hedge_fund_agent,
+ "aqr": aqr_capital_hedge_fund_agent,
+ "elliott": elliott_management_hedge_fund_agent,
+ "millennium": millennium_management_hedge_fund_agent,
+ "de_shaw": de_shaw_hedge_fund_agent,
+ "pershing_square": pershing_square_hedge_fund_agent
+}
+
+if __name__ == "__main__":
+ # Example usage
+ print("=== Hedge Fund Agents Integration Examples ===")
+
+ # Test standalone usage
+ example_standalone_usage()
+
+ # Test multi-fund consensus
+ consensus = example_multi_hedge_fund_consensus()
+ print("\nConsensus Results:")
+ print(json.dumps(consensus, indent=2))
+
+ # Start web service (uncomment to run)
+ # app.run(debug=True, port=5000)
+
+# 7. CONFIGURATION FILE EXAMPLE (config.yaml)
+"""
+# config.yaml
+llm_providers:
+ openrouter:
+ api_key: "YOUR_OPENROUTER_KEY"
+ base_url: "https://openrouter.ai/api/v1"
+ default_model: "anthropic/claude-3.5-sonnet"
+
+ ollama:
+ base_url: "http://localhost:11434"
+ default_model: "llama3.1:70b"
+
+ openai:
+ api_key: "YOUR_OPENAI_KEY"
+ default_model: "gpt-4"
+
+financial_data:
+ api_key: "YOUR_FINANCIAL_API_KEY"
+ provider: "alpha_vantage" # or "financial_datasets"
+
+hedge_funds:
+ enabled:
+ - bridgewater
+ - renaissance
+ - aqr
+ - elliott
+
+ default_analysis_period: "annual"
+ default_limit: 10
+"""
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.py
new file mode 100644
index 000000000..f8dc42216
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/graph/state.py
@@ -0,0 +1,51 @@
+from typing_extensions import Annotated, Sequence, TypedDict
+
+import operator
+from langchain_core.messages import BaseMessage
+
+
+import json
+
+
+def merge_dicts(a: dict[str, any], b: dict[str, any]) -> dict[str, any]:
+ return {**a, **b}
+
+
+# Define agent state
+class AgentState(TypedDict):
+ messages: Annotated[Sequence[BaseMessage], operator.add]
+ data: Annotated[dict[str, any], merge_dicts]
+ metadata: Annotated[dict[str, any], merge_dicts]
+
+
+def show_agent_reasoning(output, agent_name):
+ print(f"\n{'=' * 10} {agent_name.center(28)} {'=' * 10}")
+
+ def convert_to_serializable(obj):
+ if hasattr(obj, "to_dict"): # Handle Pandas Series/DataFrame
+ return obj.to_dict()
+ elif hasattr(obj, "__dict__"): # Handle custom objects
+ return obj.__dict__
+ elif isinstance(obj, (int, float, bool, str)):
+ return obj
+ elif isinstance(obj, (list, tuple)):
+ return [convert_to_serializable(item) for item in obj]
+ elif isinstance(obj, dict):
+ return {key: convert_to_serializable(value) for key, value in obj.items()}
+ else:
+ return str(obj) # Fallback to string representation
+
+ if isinstance(output, (dict, list)):
+ # Convert the output to JSON-serializable format
+ serializable_output = convert_to_serializable(output)
+ print(json.dumps(serializable_output, indent=2))
+ else:
+ try:
+ # Parse the string as JSON and pretty print it
+ parsed_output = json.loads(output)
+ print(json.dumps(parsed_output, indent=2))
+ except json.JSONDecodeError:
+ # Fallback to original string if not valid JSON
+ print(output)
+
+ print("=" * 48)
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.py
new file mode 100644
index 000000000..60ccbdc9b
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/tools/api.py
@@ -0,0 +1,342 @@
+import datetime
+import os
+import pandas as pd
+import requests
+import time
+
+from src.data.cache import get_cache
+from src.data.models import (
+ CompanyNews,
+ CompanyNewsResponse,
+ FinancialMetrics,
+ FinancialMetricsResponse,
+ Price,
+ PriceResponse,
+ LineItem,
+ LineItemResponse,
+ InsiderTrade,
+ InsiderTradeResponse,
+ CompanyFactsResponse,
+)
+
+# Global cache instance
+_cache = get_cache()
+
+
+def _make_api_request(url: str, headers: dict, method: str = "GET", json_data: dict = None, max_retries: int = 3) -> requests.Response:
+ """
+ Make an API request with rate limiting handling and moderate backoff.
+
+ Args:
+ url: The URL to request
+ headers: Headers to include in the request
+ method: HTTP method (GET or POST)
+ json_data: JSON data for POST requests
+ max_retries: Maximum number of retries (default: 3)
+
+ Returns:
+ requests.Response: The response object
+
+ Raises:
+ Exception: If the request fails with a non-429 error
+ """
+ for attempt in range(max_retries + 1): # +1 for initial attempt
+ if method.upper() == "POST":
+ response = requests.post(url, headers=headers, json=json_data)
+ else:
+ response = requests.get(url, headers=headers)
+
+ if response.status_code == 429 and attempt < max_retries:
+ # Linear backoff: 60s, 90s, 120s, 150s...
+ delay = 60 + (30 * attempt)
+ print(f"Rate limited (429). Attempt {attempt + 1}/{max_retries + 1}. Waiting {delay}s before retrying...")
+ time.sleep(delay)
+ continue
+
+ # Return the response (whether success, other errors, or final 429)
+ return response
+
+
+def get_prices(ticker: str, start_date: str, end_date: str, api_key: str = None) -> list[Price]:
+ """Fetch price data from cache or API."""
+ # Create a cache key that includes all parameters to ensure exact matches
+ cache_key = f"{ticker}_{start_date}_{end_date}"
+
+ # Check cache first - simple exact match
+ if cached_data := _cache.get_prices(cache_key):
+ return [Price(**price) for price in cached_data]
+
+ # If not in cache, fetch from API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ url = f"https://api.financialdatasets.ai/prices/?ticker={ticker}&interval=day&interval_multiplier=1&start_date={start_date}&end_date={end_date}"
+ response = _make_api_request(url, headers)
+ if response.status_code != 200:
+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")
+
+ # Parse response with Pydantic model
+ price_response = PriceResponse(**response.json())
+ prices = price_response.prices
+
+ if not prices:
+ return []
+
+ # Cache the results using the comprehensive cache key
+ _cache.set_prices(cache_key, [p.model_dump() for p in prices])
+ return prices
+
+
+def get_financial_metrics(
+ ticker: str,
+ end_date: str,
+ period: str = "ttm",
+ limit: int = 10,
+ api_key: str = None,
+) -> list[FinancialMetrics]:
+ """Fetch financial metrics from cache or API."""
+ # Create a cache key that includes all parameters to ensure exact matches
+ cache_key = f"{ticker}_{period}_{end_date}_{limit}"
+
+ # Check cache first - simple exact match
+ if cached_data := _cache.get_financial_metrics(cache_key):
+ return [FinancialMetrics(**metric) for metric in cached_data]
+
+ # If not in cache, fetch from API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ url = f"https://api.financialdatasets.ai/financial-metrics/?ticker={ticker}&report_period_lte={end_date}&limit={limit}&period={period}"
+ response = _make_api_request(url, headers)
+ if response.status_code != 200:
+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")
+
+ # Parse response with Pydantic model
+ metrics_response = FinancialMetricsResponse(**response.json())
+ financial_metrics = metrics_response.financial_metrics
+
+ if not financial_metrics:
+ return []
+
+ # Cache the results as dicts using the comprehensive cache key
+ _cache.set_financial_metrics(cache_key, [m.model_dump() for m in financial_metrics])
+ return financial_metrics
+
+
+def search_line_items(
+ ticker: str,
+ line_items: list[str],
+ end_date: str,
+ period: str = "ttm",
+ limit: int = 10,
+ api_key: str = None,
+) -> list[LineItem]:
+ """Fetch line items from API."""
+ # If not in cache or insufficient data, fetch from API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ url = "https://api.financialdatasets.ai/financials/search/line-items"
+
+ body = {
+ "tickers": [ticker],
+ "line_items": line_items,
+ "end_date": end_date,
+ "period": period,
+ "limit": limit,
+ }
+ response = _make_api_request(url, headers, method="POST", json_data=body)
+ if response.status_code != 200:
+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")
+ data = response.json()
+ response_model = LineItemResponse(**data)
+ search_results = response_model.search_results
+ if not search_results:
+ return []
+
+ # Cache the results
+ return search_results[:limit]
+
+
+def get_insider_trades(
+ ticker: str,
+ end_date: str,
+ start_date: str | None = None,
+ limit: int = 1000,
+ api_key: str = None,
+) -> list[InsiderTrade]:
+ """Fetch insider trades from cache or API."""
+ # Create a cache key that includes all parameters to ensure exact matches
+ cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
+
+ # Check cache first - simple exact match
+ if cached_data := _cache.get_insider_trades(cache_key):
+ return [InsiderTrade(**trade) for trade in cached_data]
+
+ # If not in cache, fetch from API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ all_trades = []
+ current_end_date = end_date
+
+ while True:
+ url = f"https://api.financialdatasets.ai/insider-trades/?ticker={ticker}&filing_date_lte={current_end_date}"
+ if start_date:
+ url += f"&filing_date_gte={start_date}"
+ url += f"&limit={limit}"
+
+ response = _make_api_request(url, headers)
+ if response.status_code != 200:
+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")
+
+ data = response.json()
+ response_model = InsiderTradeResponse(**data)
+ insider_trades = response_model.insider_trades
+
+ if not insider_trades:
+ break
+
+ all_trades.extend(insider_trades)
+
+ # Only continue pagination if we have a start_date and got a full page
+ if not start_date or len(insider_trades) < limit:
+ break
+
+ # Update end_date to the oldest filing date from current batch for next iteration
+ current_end_date = min(trade.filing_date for trade in insider_trades).split("T")[0]
+
+ # If we've reached or passed the start_date, we can stop
+ if current_end_date <= start_date:
+ break
+
+ if not all_trades:
+ return []
+
+ # Cache the results using the comprehensive cache key
+ _cache.set_insider_trades(cache_key, [trade.model_dump() for trade in all_trades])
+ return all_trades
+
+
+def get_company_news(
+ ticker: str,
+ end_date: str,
+ start_date: str | None = None,
+ limit: int = 1000,
+ api_key: str = None,
+) -> list[CompanyNews]:
+ """Fetch company news from cache or API."""
+ # Create a cache key that includes all parameters to ensure exact matches
+ cache_key = f"{ticker}_{start_date or 'none'}_{end_date}_{limit}"
+
+ # Check cache first - simple exact match
+ if cached_data := _cache.get_company_news(cache_key):
+ return [CompanyNews(**news) for news in cached_data]
+
+ # If not in cache, fetch from API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ all_news = []
+ current_end_date = end_date
+
+ while True:
+ url = f"https://api.financialdatasets.ai/news/?ticker={ticker}&end_date={current_end_date}"
+ if start_date:
+ url += f"&start_date={start_date}"
+ url += f"&limit={limit}"
+
+ response = _make_api_request(url, headers)
+ if response.status_code != 200:
+ raise Exception(f"Error fetching data: {ticker} - {response.status_code} - {response.text}")
+
+ data = response.json()
+ response_model = CompanyNewsResponse(**data)
+ company_news = response_model.news
+
+ if not company_news:
+ break
+
+ all_news.extend(company_news)
+
+ # Only continue pagination if we have a start_date and got a full page
+ if not start_date or len(company_news) < limit:
+ break
+
+ # Update end_date to the oldest date from current batch for next iteration
+ current_end_date = min(news.date for news in company_news).split("T")[0]
+
+ # If we've reached or passed the start_date, we can stop
+ if current_end_date <= start_date:
+ break
+
+ if not all_news:
+ return []
+
+ # Cache the results using the comprehensive cache key
+ _cache.set_company_news(cache_key, [news.model_dump() for news in all_news])
+ return all_news
+
+
+def get_market_cap(
+ ticker: str,
+ end_date: str,
+ api_key: str = None,
+) -> float | None:
+ """Fetch market cap from the API."""
+ # Check if end_date is today
+ if end_date == datetime.datetime.now().strftime("%Y-%m-%d"):
+ # Get the market cap from company facts API
+ headers = {}
+ financial_api_key = api_key or os.environ.get("FINANCIAL_DATASETS_API_KEY")
+ if financial_api_key:
+ headers["X-API-KEY"] = financial_api_key
+
+ url = f"https://api.financialdatasets.ai/company/facts/?ticker={ticker}"
+ response = _make_api_request(url, headers)
+ if response.status_code != 200:
+ print(f"Error fetching company facts: {ticker} - {response.status_code}")
+ return None
+
+ data = response.json()
+ response_model = CompanyFactsResponse(**data)
+ return response_model.company_facts.market_cap
+
+ financial_metrics = get_financial_metrics(ticker, end_date, api_key=api_key)
+ if not financial_metrics:
+ return None
+
+ market_cap = financial_metrics[0].market_cap
+
+ if not market_cap:
+ return None
+
+ return market_cap
+
+
+def prices_to_df(prices: list[Price]) -> pd.DataFrame:
+ """Convert prices to a DataFrame."""
+ df = pd.DataFrame([p.model_dump() for p in prices])
+ df["Date"] = pd.to_datetime(df["time"])
+ df.set_index("Date", inplace=True)
+ numeric_cols = ["open", "close", "high", "low", "volume"]
+ for col in numeric_cols:
+ df[col] = pd.to_numeric(df[col], errors="coerce")
+ df.sort_index(inplace=True)
+ return df
+
+
+# Update the get_price_data function to use the new functions
+def get_price_data(ticker: str, start_date: str, end_date: str, api_key: str = None) -> pd.DataFrame:
+ prices = get_prices(ticker, start_date, end_date, api_key=api_key)
+ return prices_to_df(prices)
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.py
new file mode 100644
index 000000000..de043de03
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/__init__.py
@@ -0,0 +1,3 @@
+# This file can be empty
+
+"""Utility modules for the application."""
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.py
new file mode 100644
index 000000000..26f9d21fd
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/analysts.py
@@ -0,0 +1,173 @@
+"""Constants and utilities related to analysts configuration."""
+
+from src.agents import portfolio_manager
+from src.agents.aswath_damodaran import aswath_damodaran_agent
+from src.agents.ben_graham import ben_graham_agent
+from src.agents.bill_ackman import bill_ackman_agent
+from src.agents.cathie_wood import cathie_wood_agent
+from src.agents.charlie_munger import charlie_munger_agent
+from src.agents.fundamentals import fundamentals_analyst_agent
+from src.agents.michael_burry import michael_burry_agent
+from src.agents.phil_fisher import phil_fisher_agent
+from src.agents.peter_lynch import peter_lynch_agent
+from src.agents.sentiment import sentiment_analyst_agent
+from src.agents.stanley_druckenmiller import stanley_druckenmiller_agent
+from src.agents.technicals import technical_analyst_agent
+from src.agents.valuation import valuation_analyst_agent
+from src.agents.warren_buffett import warren_buffett_agent
+from src.agents.rakesh_jhunjhunwala import rakesh_jhunjhunwala_agent
+from src.agents.mohnish_pabrai import mohnish_pabrai_agent
+
+# Define analyst configuration - single source of truth
+ANALYST_CONFIG = {
+ "aswath_damodaran": {
+ "display_name": "Aswath Damodaran",
+ "description": "The Dean of Valuation",
+ "investing_style": "Focuses on intrinsic value and financial metrics to assess investment opportunities through rigorous valuation analysis.",
+ "agent_func": aswath_damodaran_agent,
+ "type": "analyst",
+ "order": 0,
+ },
+ "ben_graham": {
+ "display_name": "Ben Graham",
+ "description": "The Father of Value Investing",
+ "investing_style": "Emphasizes a margin of safety and invests in undervalued companies with strong fundamentals through systematic value analysis.",
+ "agent_func": ben_graham_agent,
+ "type": "analyst",
+ "order": 1,
+ },
+ "bill_ackman": {
+ "display_name": "Bill Ackman",
+ "description": "The Activist Investor",
+ "investing_style": "Seeks to influence management and unlock value through strategic activism and contrarian investment positions.",
+ "agent_func": bill_ackman_agent,
+ "type": "analyst",
+ "order": 2,
+ },
+ "cathie_wood": {
+ "display_name": "Cathie Wood",
+ "description": "The Queen of Growth Investing",
+ "investing_style": "Focuses on disruptive innovation and growth, investing in companies that are leading technological advancements and market disruption.",
+ "agent_func": cathie_wood_agent,
+ "type": "analyst",
+ "order": 3,
+ },
+ "charlie_munger": {
+ "display_name": "Charlie Munger",
+ "description": "The Rational Thinker",
+ "investing_style": "Advocates for value investing with a focus on quality businesses and long-term growth through rational decision-making.",
+ "agent_func": charlie_munger_agent,
+ "type": "analyst",
+ "order": 4,
+ },
+ "michael_burry": {
+ "display_name": "Michael Burry",
+ "description": "The Big Short Contrarian",
+ "investing_style": "Makes contrarian bets, often shorting overvalued markets and investing in undervalued assets through deep fundamental analysis.",
+ "agent_func": michael_burry_agent,
+ "type": "analyst",
+ "order": 5,
+ },
+ "mohnish_pabrai": {
+ "display_name": "Mohnish Pabrai",
+ "description": "The Dhandho Investor",
+ "investing_style": "Focuses on value investing and long-term growth through fundamental analysis and a margin of safety.",
+ "agent_func": mohnish_pabrai_agent,
+ "type": "analyst",
+ "order": 6,
+ },
+ "peter_lynch": {
+ "display_name": "Peter Lynch",
+ "description": "The 10-Bagger Investor",
+ "investing_style": "Invests in companies with understandable business models and strong growth potential using the 'buy what you know' strategy.",
+ "agent_func": peter_lynch_agent,
+ "type": "analyst",
+ "order": 6,
+ },
+ "phil_fisher": {
+ "display_name": "Phil Fisher",
+ "description": "The Scuttlebutt Investor",
+ "investing_style": "Emphasizes investing in companies with strong management and innovative products, focusing on long-term growth through scuttlebutt research.",
+ "agent_func": phil_fisher_agent,
+ "type": "analyst",
+ "order": 7,
+ },
+ "rakesh_jhunjhunwala": {
+ "display_name": "Rakesh Jhunjhunwala",
+ "description": "The Big Bull Of India",
+ "investing_style": "Leverages macroeconomic insights to invest in high-growth sectors, particularly within emerging markets and domestic opportunities.",
+ "agent_func": rakesh_jhunjhunwala_agent,
+ "type": "analyst",
+ "order": 8,
+ },
+ "stanley_druckenmiller": {
+ "display_name": "Stanley Druckenmiller",
+ "description": "The Macro Investor",
+ "investing_style": "Focuses on macroeconomic trends, making large bets on currencies, commodities, and interest rates through top-down analysis.",
+ "agent_func": stanley_druckenmiller_agent,
+ "type": "analyst",
+ "order": 9,
+ },
+ "warren_buffett": {
+ "display_name": "Warren Buffett",
+ "description": "The Oracle of Omaha",
+ "investing_style": "Seeks companies with strong fundamentals and competitive advantages through value investing and long-term ownership.",
+ "agent_func": warren_buffett_agent,
+ "type": "analyst",
+ "order": 10,
+ },
+ "technical_analyst": {
+ "display_name": "Technical Analyst",
+ "description": "Chart Pattern Specialist",
+ "investing_style": "Focuses on chart patterns and market trends to make investment decisions, often using technical indicators and price action analysis.",
+ "agent_func": technical_analyst_agent,
+ "type": "analyst",
+ "order": 11,
+ },
+ "fundamentals_analyst": {
+ "display_name": "Fundamentals Analyst",
+ "description": "Financial Statement Specialist",
+ "investing_style": "Delves into financial statements and economic indicators to assess the intrinsic value of companies through fundamental analysis.",
+ "agent_func": fundamentals_analyst_agent,
+ "type": "analyst",
+ "order": 12,
+ },
+ "sentiment_analyst": {
+ "display_name": "Sentiment Analyst",
+ "description": "Market Sentiment Specialist",
+ "investing_style": "Gauges market sentiment and investor behavior to predict market movements and identify opportunities through behavioral analysis.",
+ "agent_func": sentiment_analyst_agent,
+ "type": "analyst",
+ "order": 13,
+ },
+ "valuation_analyst": {
+ "display_name": "Valuation Analyst",
+ "description": "Company Valuation Specialist",
+ "investing_style": "Specializes in determining the fair value of companies, using various valuation models and financial metrics for investment decisions.",
+ "agent_func": valuation_analyst_agent,
+ "type": "analyst",
+ "order": 14,
+ },
+}
+
+# Derive ANALYST_ORDER from ANALYST_CONFIG for backwards compatibility
+ANALYST_ORDER = [(config["display_name"], key) for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])]
+
+
+def get_analyst_nodes():
+ """Get the mapping of analyst keys to their (node_name, agent_func) tuples."""
+ return {key: (f"{key}_agent", config["agent_func"]) for key, config in ANALYST_CONFIG.items()}
+
+
+def get_agents_list():
+ """Get the list of agents for API responses."""
+ return [
+ {
+ "key": key,
+ "display_name": config["display_name"],
+ "description": config["description"],
+ "investing_style": config["investing_style"],
+ "order": config["order"]
+ }
+ for key, config in sorted(ANALYST_CONFIG.items(), key=lambda x: x[1]["order"])
+ ]
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.py
new file mode 100644
index 000000000..048813f75
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/api_key.py
@@ -0,0 +1,9 @@
+
+
+def get_api_key_from_state(state: dict, api_key_name: str) -> str:
+ """Get an API key from the state object."""
+ if state and state.get("metadata", {}).get("request"):
+ request = state["metadata"]["request"]
+ if hasattr(request, 'api_keys') and request.api_keys:
+ return request.api_keys.get(api_key_name)
+ return None
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.py
new file mode 100644
index 000000000..21a7f6852
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/display.py
@@ -0,0 +1,371 @@
+from colorama import Fore, Style
+from tabulate import tabulate
+from .analysts import ANALYST_ORDER
+import os
+import json
+
+
+def sort_agent_signals(signals):
+ """Sort agent signals in a consistent order."""
+ # Create order mapping from ANALYST_ORDER
+ analyst_order = {display: idx for idx, (display, _) in enumerate(ANALYST_ORDER)}
+ analyst_order["Risk Management"] = len(ANALYST_ORDER) # Add Risk Management at the end
+
+ return sorted(signals, key=lambda x: analyst_order.get(x[0], 999))
+
+
+def print_trading_output(result: dict) -> None:
+ """
+ Print formatted trading results with colored tables for multiple tickers.
+
+ Args:
+ result (dict): Dictionary containing decisions and analyst signals for multiple tickers
+ """
+ decisions = result.get("decisions")
+ if not decisions:
+ print(f"{Fore.RED}No trading decisions available{Style.RESET_ALL}")
+ return
+
+ # Print decisions for each ticker
+ for ticker, decision in decisions.items():
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}Analysis for {Fore.CYAN}{ticker}{Style.RESET_ALL}")
+ print(f"{Fore.WHITE}{Style.BRIGHT}{'=' * 50}{Style.RESET_ALL}")
+
+ # Prepare analyst signals table for this ticker
+ table_data = []
+ for agent, signals in result.get("analyst_signals", {}).items():
+ if ticker not in signals:
+ continue
+
+ # Skip Risk Management agent in the signals section
+ if agent == "risk_management_agent":
+ continue
+
+ signal = signals[ticker]
+ agent_name = agent.replace("_agent", "").replace("_", " ").title()
+ signal_type = signal.get("signal", "").upper()
+ confidence = signal.get("confidence", 0)
+
+ signal_color = {
+ "BULLISH": Fore.GREEN,
+ "BEARISH": Fore.RED,
+ "NEUTRAL": Fore.YELLOW,
+ }.get(signal_type, Fore.WHITE)
+
+ # Get reasoning if available
+ reasoning_str = ""
+ if "reasoning" in signal and signal["reasoning"]:
+ reasoning = signal["reasoning"]
+
+ # Handle different types of reasoning (string, dict, etc.)
+ if isinstance(reasoning, str):
+ reasoning_str = reasoning
+ elif isinstance(reasoning, dict):
+ # Convert dict to string representation
+ reasoning_str = json.dumps(reasoning, indent=2)
+ else:
+ # Convert any other type to string
+ reasoning_str = str(reasoning)
+
+ # Wrap long reasoning text to make it more readable
+ wrapped_reasoning = ""
+ current_line = ""
+ # Use a fixed width of 60 characters to match the table column width
+ max_line_length = 60
+ for word in reasoning_str.split():
+ if len(current_line) + len(word) + 1 > max_line_length:
+ wrapped_reasoning += current_line + "\n"
+ current_line = word
+ else:
+ if current_line:
+ current_line += " " + word
+ else:
+ current_line = word
+ if current_line:
+ wrapped_reasoning += current_line
+
+ reasoning_str = wrapped_reasoning
+
+ table_data.append(
+ [
+ f"{Fore.CYAN}{agent_name}{Style.RESET_ALL}",
+ f"{signal_color}{signal_type}{Style.RESET_ALL}",
+ f"{Fore.WHITE}{confidence}%{Style.RESET_ALL}",
+ f"{Fore.WHITE}{reasoning_str}{Style.RESET_ALL}",
+ ]
+ )
+
+ # Sort the signals according to the predefined order
+ table_data = sort_agent_signals(table_data)
+
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}AGENT ANALYSIS:{Style.RESET_ALL} [{Fore.CYAN}{ticker}{Style.RESET_ALL}]")
+ print(
+ tabulate(
+ table_data,
+ headers=[f"{Fore.WHITE}Agent", "Signal", "Confidence", "Reasoning"],
+ tablefmt="grid",
+ colalign=("left", "center", "right", "left"),
+ )
+ )
+
+ # Print Trading Decision Table
+ action = decision.get("action", "").upper()
+ action_color = {
+ "BUY": Fore.GREEN,
+ "SELL": Fore.RED,
+ "HOLD": Fore.YELLOW,
+ "COVER": Fore.GREEN,
+ "SHORT": Fore.RED,
+ }.get(action, Fore.WHITE)
+
+ # Get reasoning and format it
+ reasoning = decision.get("reasoning", "")
+ # Wrap long reasoning text to make it more readable
+ wrapped_reasoning = ""
+ if reasoning:
+ current_line = ""
+ # Use a fixed width of 60 characters to match the table column width
+ max_line_length = 60
+ for word in reasoning.split():
+ if len(current_line) + len(word) + 1 > max_line_length:
+ wrapped_reasoning += current_line + "\n"
+ current_line = word
+ else:
+ if current_line:
+ current_line += " " + word
+ else:
+ current_line = word
+ if current_line:
+ wrapped_reasoning += current_line
+
+ decision_data = [
+ ["Action", f"{action_color}{action}{Style.RESET_ALL}"],
+ ["Quantity", f"{action_color}{decision.get('quantity')}{Style.RESET_ALL}"],
+ [
+ "Confidence",
+ f"{Fore.WHITE}{decision.get('confidence'):.1f}%{Style.RESET_ALL}",
+ ],
+ ["Reasoning", f"{Fore.WHITE}{wrapped_reasoning}{Style.RESET_ALL}"],
+ ]
+
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}TRADING DECISION:{Style.RESET_ALL} [{Fore.CYAN}{ticker}{Style.RESET_ALL}]")
+ print(tabulate(decision_data, tablefmt="grid", colalign=("left", "left")))
+
+ # Print Portfolio Summary
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY:{Style.RESET_ALL}")
+ portfolio_data = []
+
+ # Extract portfolio manager reasoning (common for all tickers)
+ portfolio_manager_reasoning = None
+ for ticker, decision in decisions.items():
+ if decision.get("reasoning"):
+ portfolio_manager_reasoning = decision.get("reasoning")
+ break
+
+ for ticker, decision in decisions.items():
+ action = decision.get("action", "").upper()
+ action_color = {
+ "BUY": Fore.GREEN,
+ "SELL": Fore.RED,
+ "HOLD": Fore.YELLOW,
+ "COVER": Fore.GREEN,
+ "SHORT": Fore.RED,
+ }.get(action, Fore.WHITE)
+ portfolio_data.append(
+ [
+ f"{Fore.CYAN}{ticker}{Style.RESET_ALL}",
+ f"{action_color}{action}{Style.RESET_ALL}",
+ f"{action_color}{decision.get('quantity')}{Style.RESET_ALL}",
+ f"{Fore.WHITE}{decision.get('confidence'):.1f}%{Style.RESET_ALL}",
+ ]
+ )
+
+ headers = [f"{Fore.WHITE}Ticker", "Action", "Quantity", "Confidence"]
+
+ # Print the portfolio summary table
+ print(
+ tabulate(
+ portfolio_data,
+ headers=headers,
+ tablefmt="grid",
+ colalign=("left", "center", "right", "right"),
+ )
+ )
+
+ # Print Portfolio Manager's reasoning if available
+ if portfolio_manager_reasoning:
+ # Handle different types of reasoning (string, dict, etc.)
+ reasoning_str = ""
+ if isinstance(portfolio_manager_reasoning, str):
+ reasoning_str = portfolio_manager_reasoning
+ elif isinstance(portfolio_manager_reasoning, dict):
+ # Convert dict to string representation
+ reasoning_str = json.dumps(portfolio_manager_reasoning, indent=2)
+ else:
+ # Convert any other type to string
+ reasoning_str = str(portfolio_manager_reasoning)
+
+ # Wrap long reasoning text to make it more readable
+ wrapped_reasoning = ""
+ current_line = ""
+ # Use a fixed width of 60 characters to match the table column width
+ max_line_length = 60
+ for word in reasoning_str.split():
+ if len(current_line) + len(word) + 1 > max_line_length:
+ wrapped_reasoning += current_line + "\n"
+ current_line = word
+ else:
+ if current_line:
+ current_line += " " + word
+ else:
+ current_line = word
+ if current_line:
+ wrapped_reasoning += current_line
+
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}Portfolio Strategy:{Style.RESET_ALL}")
+ print(f"{Fore.CYAN}{wrapped_reasoning}{Style.RESET_ALL}")
+
+
+def print_backtest_results(table_rows: list) -> None:
+ """Print the backtest results in a nicely formatted table"""
+ # Clear the screen
+ os.system("cls" if os.name == "nt" else "clear")
+
+ # Split rows into ticker rows and summary rows
+ ticker_rows = []
+ summary_rows = []
+
+ for row in table_rows:
+ if isinstance(row[1], str) and "PORTFOLIO SUMMARY" in row[1]:
+ summary_rows.append(row)
+ else:
+ ticker_rows.append(row)
+
+ # Display latest portfolio summary
+ if summary_rows:
+ # Pick the most recent summary by date (YYYY-MM-DD)
+ latest_summary = max(summary_rows, key=lambda r: r[0])
+ print(f"\n{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY:{Style.RESET_ALL}")
+
+ # Adjusted indexes after adding Long/Short Shares
+ position_str = latest_summary[7].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")
+ cash_str = latest_summary[8].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")
+ total_str = latest_summary[9].split("$")[1].split(Style.RESET_ALL)[0].replace(",", "")
+
+ print(f"Cash Balance: {Fore.CYAN}${float(cash_str):,.2f}{Style.RESET_ALL}")
+ print(f"Total Position Value: {Fore.YELLOW}${float(position_str):,.2f}{Style.RESET_ALL}")
+ print(f"Total Value: {Fore.WHITE}${float(total_str):,.2f}{Style.RESET_ALL}")
+ print(f"Return: {latest_summary[10]}")
+
+ # Display performance metrics if available
+ if latest_summary[11]: # Sharpe ratio
+ print(f"Sharpe Ratio: {latest_summary[11]}")
+ if latest_summary[12]: # Sortino ratio
+ print(f"Sortino Ratio: {latest_summary[12]}")
+ if latest_summary[13]: # Max drawdown
+ print(f"Max Drawdown: {latest_summary[13]}")
+
+ # Add vertical spacing
+ print("\n" * 2)
+
+ # Print the table with just ticker rows
+ print(
+ tabulate(
+ ticker_rows,
+ headers=[
+ "Date",
+ "Ticker",
+ "Action",
+ "Quantity",
+ "Price",
+ "Long Shares",
+ "Short Shares",
+ "Position Value",
+ "Bullish",
+ "Bearish",
+ "Neutral",
+ ],
+ tablefmt="grid",
+ colalign=(
+ "left", # Date
+ "left", # Ticker
+ "center", # Action
+ "right", # Quantity
+ "right", # Price
+ "right", # Long Shares
+ "right", # Short Shares
+ "right", # Position Value
+ "right", # Bullish
+ "right", # Bearish
+ "right", # Neutral
+ ),
+ )
+ )
+
+ # Add vertical spacing
+ print("\n" * 4)
+
+
+def format_backtest_row(
+ date: str,
+ ticker: str,
+ action: str,
+ quantity: float,
+ price: float,
+ long_shares: float = 0,
+ short_shares: float = 0,
+ position_value: float = 0,
+ bullish_count: int = 0,
+ bearish_count: int = 0,
+ neutral_count: int = 0,
+ is_summary: bool = False,
+ total_value: float = None,
+ return_pct: float = None,
+ cash_balance: float = None,
+ total_position_value: float = None,
+ sharpe_ratio: float = None,
+ sortino_ratio: float = None,
+ max_drawdown: float = None,
+) -> list[any]:
+ """Format a row for the backtest results table"""
+ # Color the action
+ action_color = {
+ "BUY": Fore.GREEN,
+ "COVER": Fore.GREEN,
+ "SELL": Fore.RED,
+ "SHORT": Fore.RED,
+ "HOLD": Fore.WHITE,
+ }.get(action.upper(), Fore.WHITE)
+
+ if is_summary:
+ return_color = Fore.GREEN if return_pct >= 0 else Fore.RED
+ return [
+ date,
+ f"{Fore.WHITE}{Style.BRIGHT}PORTFOLIO SUMMARY{Style.RESET_ALL}",
+ "", # Action
+ "", # Quantity
+ "", # Price
+ "", # Long Shares
+ "", # Short Shares
+ f"{Fore.YELLOW}${total_position_value:,.2f}{Style.RESET_ALL}", # Total Position Value
+ f"{Fore.CYAN}${cash_balance:,.2f}{Style.RESET_ALL}", # Cash Balance
+ f"{Fore.WHITE}${total_value:,.2f}{Style.RESET_ALL}", # Total Value
+ f"{return_color}{return_pct:+.2f}%{Style.RESET_ALL}", # Return
+ f"{Fore.YELLOW}{sharpe_ratio:.2f}{Style.RESET_ALL}" if sharpe_ratio is not None else "", # Sharpe Ratio
+ f"{Fore.YELLOW}{sortino_ratio:.2f}{Style.RESET_ALL}" if sortino_ratio is not None else "", # Sortino Ratio
+ f"{Fore.RED}{abs(max_drawdown):.2f}%{Style.RESET_ALL}" if max_drawdown is not None else "", # Max Drawdown
+ ]
+ else:
+ return [
+ date,
+ f"{Fore.CYAN}{ticker}{Style.RESET_ALL}",
+ f"{action_color}{action.upper()}{Style.RESET_ALL}",
+ f"{action_color}{quantity:,.0f}{Style.RESET_ALL}",
+ f"{Fore.WHITE}{price:,.2f}{Style.RESET_ALL}",
+ f"{Fore.GREEN}{long_shares:,.0f}{Style.RESET_ALL}", # Long Shares
+ f"{Fore.RED}{short_shares:,.0f}{Style.RESET_ALL}", # Short Shares
+ f"{Fore.YELLOW}{position_value:,.2f}{Style.RESET_ALL}",
+ f"{Fore.GREEN}{bullish_count}{Style.RESET_ALL}",
+ f"{Fore.RED}{bearish_count}{Style.RESET_ALL}",
+ f"{Fore.BLUE}{neutral_count}{Style.RESET_ALL}",
+ ]
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.py
new file mode 100644
index 000000000..d638f5499
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/docker.py
@@ -0,0 +1,124 @@
+"""Utilities for working with Ollama models in Docker environments"""
+
+import requests
+import time
+from colorama import Fore, Style
+import questionary
+
+def ensure_ollama_and_model(model_name: str, ollama_url: str) -> bool:
+ """Ensure the Ollama model is available in a Docker environment."""
+ print(f"{Fore.CYAN}Docker environment detected.{Style.RESET_ALL}")
+
+ # Step 1: Check if Ollama service is available
+ if not is_ollama_available(ollama_url):
+ return False
+
+ # Step 2: Check if model is already available
+ available_models = get_available_models(ollama_url)
+ if model_name in available_models:
+ print(f"{Fore.GREEN}Model {model_name} is available in the Docker Ollama container.{Style.RESET_ALL}")
+ return True
+
+ # Step 3: Model not available - ask if user wants to download
+ print(f"{Fore.YELLOW}Model {model_name} is not available in the Docker Ollama container.{Style.RESET_ALL}")
+
+ if not questionary.confirm(f"Do you want to download {model_name}?").ask():
+ print(f"{Fore.RED}Cannot proceed without the model.{Style.RESET_ALL}")
+ return False
+
+ # Step 4: Download the model
+ return download_model(model_name, ollama_url)
+
+
+def is_ollama_available(ollama_url: str) -> bool:
+ """Check if Ollama service is available in Docker environment."""
+ try:
+ response = requests.get(f"{ollama_url}/api/version", timeout=5)
+ if response.status_code == 200:
+ return True
+
+ print(f"{Fore.RED}Cannot connect to Ollama service at {ollama_url}.{Style.RESET_ALL}")
+ print(f"{Fore.YELLOW}Make sure the Ollama service is running in your Docker environment.{Style.RESET_ALL}")
+ return False
+ except requests.RequestException as e:
+ print(f"{Fore.RED}Error connecting to Ollama service: {e}{Style.RESET_ALL}")
+ return False
+
+
+def get_available_models(ollama_url: str) -> list:
+ """Get list of available models in Docker environment."""
+ try:
+ response = requests.get(f"{ollama_url}/api/tags", timeout=5)
+ if response.status_code == 200:
+ models = response.json().get("models", [])
+ return [m["name"] for m in models]
+
+ print(f"{Fore.RED}Failed to get available models from Ollama service. Status code: {response.status_code}{Style.RESET_ALL}")
+ return []
+ except requests.RequestException as e:
+ print(f"{Fore.RED}Error getting available models: {e}{Style.RESET_ALL}")
+ return []
+
+
+def download_model(model_name: str, ollama_url: str) -> bool:
+ """Download a model in Docker environment."""
+ print(f"{Fore.YELLOW}Downloading model {model_name} to the Docker Ollama container...{Style.RESET_ALL}")
+ print(f"{Fore.CYAN}This may take some time. Please be patient.{Style.RESET_ALL}")
+
+ # Step 1: Initiate the download
+ try:
+ response = requests.post(f"{ollama_url}/api/pull", json={"name": model_name}, timeout=10)
+ if response.status_code != 200:
+ print(f"{Fore.RED}Failed to initiate model download. Status code: {response.status_code}{Style.RESET_ALL}")
+ if response.text:
+ print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")
+ return False
+ except requests.RequestException as e:
+ print(f"{Fore.RED}Error initiating download request: {e}{Style.RESET_ALL}")
+ return False
+
+ # Step 2: Monitor the download progress
+ print(f"{Fore.CYAN}Download initiated. Checking periodically for completion...{Style.RESET_ALL}")
+
+ total_wait_time = 0
+ max_wait_time = 1800 # 30 minutes max wait
+ check_interval = 10 # Check every 10 seconds
+
+ while total_wait_time < max_wait_time:
+ # Check if the model has been downloaded
+ available_models = get_available_models(ollama_url)
+ if model_name in available_models:
+ print(f"{Fore.GREEN}Model {model_name} downloaded successfully.{Style.RESET_ALL}")
+ return True
+
+ # Wait before checking again
+ time.sleep(check_interval)
+ total_wait_time += check_interval
+
+ # Print a status message every minute
+ if total_wait_time % 60 == 0:
+ minutes = total_wait_time // 60
+ print(f"{Fore.CYAN}Download in progress... ({minutes} minute{'s' if minutes != 1 else ''} elapsed){Style.RESET_ALL}")
+
+ # If we get here, we've timed out
+ print(f"{Fore.RED}Timed out waiting for model download to complete after {max_wait_time // 60} minutes.{Style.RESET_ALL}")
+ return False
+
+
+def delete_model(model_name: str, ollama_url: str) -> bool:
+ """Delete a model in Docker environment."""
+ print(f"{Fore.YELLOW}Deleting model {model_name} from Docker container...{Style.RESET_ALL}")
+
+ try:
+ response = requests.delete(f"{ollama_url}/api/delete", json={"name": model_name}, timeout=10)
+ if response.status_code == 200:
+ print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Failed to delete model. Status code: {response.status_code}{Style.RESET_ALL}")
+ if response.text:
+ print(f"{Fore.RED}Error: {response.text}{Style.RESET_ALL}")
+ return False
+ except requests.RequestException as e:
+ print(f"{Fore.RED}Error deleting model: {e}{Style.RESET_ALL}")
+ return False
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.py
new file mode 100644
index 000000000..c7535d5d2
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/llm.py
@@ -0,0 +1,147 @@
+"""Helper functions for LLM"""
+
+import json
+from pydantic import BaseModel
+from src.llm.models import get_model, get_model_info
+from src.utils.progress import progress
+from src.graph.state import AgentState
+
+
+def call_llm(
+ prompt: any,
+ pydantic_model: type[BaseModel],
+ agent_name: str | None = None,
+ state: AgentState | None = None,
+ max_retries: int = 3,
+ default_factory=None,
+) -> BaseModel:
+ """
+ Makes an LLM call with retry logic, handling both JSON supported and non-JSON supported models.
+
+ Args:
+ prompt: The prompt to send to the LLM
+ pydantic_model: The Pydantic model class to structure the output
+ agent_name: Optional name of the agent for progress updates and model config extraction
+ state: Optional state object to extract agent-specific model configuration
+ max_retries: Maximum number of retries (default: 3)
+ default_factory: Optional factory function to create default response on failure
+
+ Returns:
+ An instance of the specified Pydantic model
+ """
+
+ # Extract model configuration if state is provided and agent_name is available
+ if state and agent_name:
+ model_name, model_provider = get_agent_model_config(state, agent_name)
+ else:
+ # Use system defaults when no state or agent_name is provided
+ model_name = "gpt-4.1"
+ model_provider = "OPENAI"
+
+ # Extract API keys from state if available
+ api_keys = None
+ if state:
+ request = state.get("metadata", {}).get("request")
+ if request and hasattr(request, 'api_keys'):
+ api_keys = request.api_keys
+
+ model_info = get_model_info(model_name, model_provider)
+ llm = get_model(model_name, model_provider, api_keys)
+
+ # For non-JSON support models, we can use structured output
+ if not (model_info and not model_info.has_json_mode()):
+ llm = llm.with_structured_output(
+ pydantic_model,
+ method="json_mode",
+ )
+
+ # Call the LLM with retries
+ for attempt in range(max_retries):
+ try:
+ # Call the LLM
+ result = llm.invoke(prompt)
+
+ # For non-JSON support models, we need to extract and parse the JSON manually
+ if model_info and not model_info.has_json_mode():
+ parsed_result = extract_json_from_response(result.content)
+ if parsed_result:
+ return pydantic_model(**parsed_result)
+ else:
+ return result
+
+ except Exception as e:
+ if agent_name:
+ progress.update_status(agent_name, None, f"Error - retry {attempt + 1}/{max_retries}")
+
+ if attempt == max_retries - 1:
+ print(f"Error in LLM call after {max_retries} attempts: {e}")
+ # Use default_factory if provided, otherwise create a basic default
+ if default_factory:
+ return default_factory()
+ return create_default_response(pydantic_model)
+
+ # This should never be reached due to the retry logic above
+ return create_default_response(pydantic_model)
+
+
+def create_default_response(model_class: type[BaseModel]) -> BaseModel:
+ """Creates a safe default response based on the model's fields."""
+ default_values = {}
+ for field_name, field in model_class.model_fields.items():
+ if field.annotation == str:
+ default_values[field_name] = "Error in analysis, using default"
+ elif field.annotation == float:
+ default_values[field_name] = 0.0
+ elif field.annotation == int:
+ default_values[field_name] = 0
+ elif hasattr(field.annotation, "__origin__") and field.annotation.__origin__ == dict:
+ default_values[field_name] = {}
+ else:
+ # For other types (like Literal), try to use the first allowed value
+ if hasattr(field.annotation, "__args__"):
+ default_values[field_name] = field.annotation.__args__[0]
+ else:
+ default_values[field_name] = None
+
+ return model_class(**default_values)
+
+
+def extract_json_from_response(content: str) -> dict | None:
+ """Extracts JSON from markdown-formatted response."""
+ try:
+ json_start = content.find("```json")
+ if json_start != -1:
+ json_text = content[json_start + 7 :] # Skip past ```json
+ json_end = json_text.find("```")
+ if json_end != -1:
+ json_text = json_text[:json_end].strip()
+ return json.loads(json_text)
+ except Exception as e:
+ print(f"Error extracting JSON from response: {e}")
+ return None
+
+
+def get_agent_model_config(state, agent_name):
+ """
+ Get model configuration for a specific agent from the state.
+ Falls back to global model configuration if agent-specific config is not available.
+ Always returns valid model_name and model_provider values.
+ """
+ request = state.get("metadata", {}).get("request")
+
+ if request and hasattr(request, 'get_agent_model_config'):
+ # Get agent-specific model configuration
+ model_name, model_provider = request.get_agent_model_config(agent_name)
+ # Ensure we have valid values
+ if model_name and model_provider:
+ return model_name, model_provider.value if hasattr(model_provider, 'value') else str(model_provider)
+
+ # Fall back to global configuration (system defaults)
+ model_name = state.get("metadata", {}).get("model_name") or "gpt-4.1"
+ model_provider = state.get("metadata", {}).get("model_provider") or "OPENAI"
+
+ # Convert enum to string if necessary
+ if hasattr(model_provider, 'value'):
+ model_provider = model_provider.value
+
+ return model_name, model_provider
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.py
new file mode 100644
index 000000000..5af70ee44
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/ollama.py
@@ -0,0 +1,389 @@
+"""Utilities for working with Ollama models"""
+
+import platform
+import subprocess
+import requests
+import time
+from typing import List
+import questionary
+from colorama import Fore, Style
+import os
+from . import docker
+
+# Constants
+OLLAMA_SERVER_URL = "http://localhost:11434"
+OLLAMA_API_MODELS_ENDPOINT = f"{OLLAMA_SERVER_URL}/api/tags"
+OLLAMA_DOWNLOAD_URL = {"darwin": "https://ollama.com/download/darwin", "windows": "https://ollama.com/download/windows", "linux": "https://ollama.com/download/linux"} # macOS # Windows # Linux
+INSTALLATION_INSTRUCTIONS = {"darwin": "curl -fsSL https://ollama.com/install.sh | sh", "windows": "# Download from https://ollama.com/download/windows and run the installer", "linux": "curl -fsSL https://ollama.com/install.sh | sh"}
+
+
+def is_ollama_installed() -> bool:
+ """Check if Ollama is installed on the system."""
+ system = platform.system().lower()
+
+ if system == "darwin" or system == "linux": # macOS or Linux
+ try:
+ result = subprocess.run(["which", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+ return result.returncode == 0
+ except Exception:
+ return False
+ elif system == "windows": # Windows
+ try:
+ result = subprocess.run(["where", "ollama"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+ return result.returncode == 0
+ except Exception:
+ return False
+ else:
+ return False # Unsupported OS
+
+
+def is_ollama_server_running() -> bool:
+ """Check if the Ollama server is running."""
+ try:
+ response = requests.get(OLLAMA_API_MODELS_ENDPOINT, timeout=2)
+ return response.status_code == 200
+ except requests.RequestException:
+ return False
+
+
+def get_locally_available_models() -> List[str]:
+ """Get a list of models that are already downloaded locally."""
+ if not is_ollama_server_running():
+ return []
+
+ try:
+ response = requests.get(OLLAMA_API_MODELS_ENDPOINT, timeout=5)
+ if response.status_code == 200:
+ data = response.json()
+ return [model["name"] for model in data["models"]] if "models" in data else []
+ return []
+ except requests.RequestException:
+ return []
+
+
+def start_ollama_server() -> bool:
+ """Start the Ollama server if it's not already running."""
+ if is_ollama_server_running():
+ print(f"{Fore.GREEN}Ollama server is already running.{Style.RESET_ALL}")
+ return True
+
+ system = platform.system().lower()
+
+ try:
+ if system == "darwin" or system == "linux": # macOS or Linux
+ subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ elif system == "windows": # Windows
+ subprocess.Popen(["ollama", "serve"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+ else:
+ print(f"{Fore.RED}Unsupported operating system: {system}{Style.RESET_ALL}")
+ return False
+
+ # Wait for server to start
+ for _ in range(10): # Try for 10 seconds
+ if is_ollama_server_running():
+ print(f"{Fore.GREEN}Ollama server started successfully.{Style.RESET_ALL}")
+ return True
+ time.sleep(1)
+
+ print(f"{Fore.RED}Failed to start Ollama server. Timed out waiting for server to become available.{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Error starting Ollama server: {e}{Style.RESET_ALL}")
+ return False
+
+
+def install_ollama() -> bool:
+ """Install Ollama on the system."""
+ system = platform.system().lower()
+ if system not in OLLAMA_DOWNLOAD_URL:
+ print(f"{Fore.RED}Unsupported operating system for automatic installation: {system}{Style.RESET_ALL}")
+ print(f"Please visit https://ollama.com/download to install Ollama manually.")
+ return False
+
+ if system == "darwin": # macOS
+ print(f"{Fore.YELLOW}Ollama for Mac is available as an application download.{Style.RESET_ALL}")
+
+ # Default to offering the app download first for macOS users
+ if questionary.confirm("Would you like to download the Ollama application?", default=True).ask():
+ try:
+ import webbrowser
+
+ webbrowser.open(OLLAMA_DOWNLOAD_URL["darwin"])
+ print(f"{Fore.YELLOW}Please download and install the application, then restart this program.{Style.RESET_ALL}")
+ print(f"{Fore.CYAN}After installation, you may need to open the Ollama app once before continuing.{Style.RESET_ALL}")
+
+ # Ask if they want to try continuing after installation
+ if questionary.confirm("Have you installed the Ollama app and opened it at least once?", default=False).ask():
+ # Check if it's now installed
+ if is_ollama_installed() and start_ollama_server():
+ print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")
+ return False
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")
+ return False
+ else:
+ # Only offer command-line installation as a fallback for advanced users
+ if questionary.confirm("Would you like to try the command-line installation instead? (For advanced users)", default=False).ask():
+ print(f"{Fore.YELLOW}Attempting command-line installation...{Style.RESET_ALL}")
+ try:
+ install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+ if install_process.returncode == 0:
+ print(f"{Fore.GREEN}Ollama installed successfully via command line.{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Command-line installation failed. Please use the app download method instead.{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Error during command-line installation: {e}{Style.RESET_ALL}")
+ return False
+ return False
+ elif system == "linux": # Linux
+ print(f"{Fore.YELLOW}Installing Ollama...{Style.RESET_ALL}")
+ try:
+ # Run the installation command as a single command
+ install_process = subprocess.run(["bash", "-c", "curl -fsSL https://ollama.com/install.sh | sh"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+ if install_process.returncode == 0:
+ print(f"{Fore.GREEN}Ollama installed successfully.{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Failed to install Ollama. Error: {install_process.stderr}{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Error during Ollama installation: {e}{Style.RESET_ALL}")
+ return False
+ elif system == "windows": # Windows
+ print(f"{Fore.YELLOW}Automatic installation on Windows is not supported.{Style.RESET_ALL}")
+ print(f"Please download and install Ollama from: {OLLAMA_DOWNLOAD_URL['windows']}")
+
+ # Ask if they want to open the download page
+ if questionary.confirm("Do you want to open the Ollama download page in your browser?").ask():
+ try:
+ import webbrowser
+
+ webbrowser.open(OLLAMA_DOWNLOAD_URL["windows"])
+ print(f"{Fore.YELLOW}After installation, please restart this application.{Style.RESET_ALL}")
+
+ # Ask if they want to try continuing after installation
+ if questionary.confirm("Have you installed Ollama?", default=False).ask():
+ # Check if it's now installed
+ if is_ollama_installed() and start_ollama_server():
+ print(f"{Fore.GREEN}Ollama is now properly installed and running!{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Ollama installation not detected. Please restart this application after installing Ollama.{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Failed to open browser: {e}{Style.RESET_ALL}")
+ return False
+
+ return False
+
+
+def download_model(model_name: str) -> bool:
+ """Download an Ollama model."""
+ if not is_ollama_server_running():
+ if not start_ollama_server():
+ return False
+
+ print(f"{Fore.YELLOW}Downloading model {model_name}...{Style.RESET_ALL}")
+ print(f"{Fore.CYAN}This may take a while depending on your internet speed and the model size.{Style.RESET_ALL}")
+ print(f"{Fore.CYAN}The download is happening in the background. Please be patient...{Style.RESET_ALL}")
+
+ try:
+ # Use the Ollama CLI to download the model
+ process = subprocess.Popen(
+ ["ollama", "pull", model_name],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT, # Redirect stderr to stdout to capture all output
+ text=True,
+ bufsize=1, # Line buffered
+ encoding='utf-8', # Explicitly use UTF-8 encoding
+ errors='replace' # Replace any characters that cannot be decoded
+ )
+
+ # Show some progress to the user
+ print(f"{Fore.CYAN}Download progress:{Style.RESET_ALL}")
+
+ # For tracking progress
+ last_percentage = 0
+ last_phase = ""
+ bar_length = 40
+
+ while True:
+ output = process.stdout.readline()
+ if output == "" and process.poll() is not None:
+ break
+ if output:
+ output = output.strip()
+ # Try to extract percentage information using a more lenient approach
+ percentage = None
+ current_phase = None
+
+ # Example patterns in Ollama output:
+ # "downloading: 23.45 MB / 42.19 MB [================>-------------] 55.59%"
+ # "downloading model: 76%"
+ # "pulling manifest: 100%"
+
+ # Check for percentage in the output
+ import re
+
+ percentage_match = re.search(r"(\d+(\.\d+)?)%", output)
+ if percentage_match:
+ try:
+ percentage = float(percentage_match.group(1))
+ except ValueError:
+ percentage = None
+
+ # Try to determine the current phase (downloading, extracting, etc.)
+ phase_match = re.search(r"^([a-zA-Z\s]+):", output)
+ if phase_match:
+ current_phase = phase_match.group(1).strip()
+
+ # If we found a percentage, display a progress bar
+ if percentage is not None:
+ # Only update if there's a significant change (avoid flickering)
+ if abs(percentage - last_percentage) >= 1 or (current_phase and current_phase != last_phase):
+ last_percentage = percentage
+ if current_phase:
+ last_phase = current_phase
+
+ # Create a progress bar
+ filled_length = int(bar_length * percentage / 100)
+ bar = "█" * filled_length + "░" * (bar_length - filled_length)
+
+ # Build the status line with the phase if available
+ phase_display = f"{Fore.CYAN}{last_phase.capitalize()}{Style.RESET_ALL}: " if last_phase else ""
+ status_line = f"\r{phase_display}{Fore.GREEN}{bar}{Style.RESET_ALL} {Fore.YELLOW}{percentage:.1f}%{Style.RESET_ALL}"
+
+ # Print the status line without a newline to update in place
+ print(status_line, end="", flush=True)
+ else:
+ # If we couldn't extract a percentage but have identifiable output
+ if "download" in output.lower() or "extract" in output.lower() or "pulling" in output.lower():
+ # Don't print a newline for percentage updates
+ if "%" in output:
+ print(f"\r{Fore.GREEN}{output}{Style.RESET_ALL}", end="", flush=True)
+ else:
+ print(f"{Fore.GREEN}{output}{Style.RESET_ALL}")
+
+ # Wait for the process to finish
+ return_code = process.wait()
+
+ # Ensure we print a newline after the progress bar
+ print()
+
+ if return_code == 0:
+ print(f"{Fore.GREEN}Model {model_name} downloaded successfully!{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Failed to download model {model_name}. Check your internet connection and try again.{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"\n{Fore.RED}Error downloading model {model_name}: {e}{Style.RESET_ALL}")
+ return False
+
+
+def ensure_ollama_and_model(model_name: str) -> bool:
+ """Ensure Ollama is installed, running, and the requested model is available."""
+ # Check if we're running in Docker
+ in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")
+
+ # In Docker environment, we need a different approach
+ if in_docker:
+ ollama_url = os.environ.get("OLLAMA_BASE_URL", "http://ollama:11434")
+ return docker.ensure_ollama_and_model(model_name, ollama_url)
+
+ # Regular flow for non-Docker environments
+ # Check if Ollama is installed
+ if not is_ollama_installed():
+ print(f"{Fore.YELLOW}Ollama is not installed on your system.{Style.RESET_ALL}")
+
+ # Ask if they want to install it
+ if questionary.confirm("Do you want to install Ollama?").ask():
+ if not install_ollama():
+ return False
+ else:
+ print(f"{Fore.RED}Ollama is required to use local models.{Style.RESET_ALL}")
+ return False
+
+ # Make sure the server is running
+ if not is_ollama_server_running():
+ print(f"{Fore.YELLOW}Starting Ollama server...{Style.RESET_ALL}")
+ if not start_ollama_server():
+ return False
+
+ # Check if the model is already downloaded
+ available_models = get_locally_available_models()
+ if model_name not in available_models:
+ print(f"{Fore.YELLOW}Model {model_name} is not available locally.{Style.RESET_ALL}")
+
+ # Ask if they want to download it
+ model_size_info = ""
+ if "70b" in model_name:
+ model_size_info = " This is a large model (up to several GB) and may take a while to download."
+ elif "34b" in model_name or "8x7b" in model_name:
+ model_size_info = " This is a medium-sized model (1-2 GB) and may take a few minutes to download."
+
+ if questionary.confirm(f"Do you want to download the {model_name} model?{model_size_info} The download will happen in the background.").ask():
+ return download_model(model_name)
+ else:
+ print(f"{Fore.RED}The model is required to proceed.{Style.RESET_ALL}")
+ return False
+
+ return True
+
+
+def delete_model(model_name: str) -> bool:
+ """Delete a locally downloaded Ollama model."""
+ # Check if we're running in Docker
+ in_docker = os.environ.get("OLLAMA_BASE_URL", "").startswith("http://ollama:") or os.environ.get("OLLAMA_BASE_URL", "").startswith("http://host.docker.internal:")
+
+ # In Docker environment, delegate to docker module
+ if in_docker:
+ ollama_url = os.environ.get("OLLAMA_BASE_URL", "http://ollama:11434")
+ return docker.delete_model(model_name, ollama_url)
+
+ # Non-Docker environment
+ if not is_ollama_server_running():
+ if not start_ollama_server():
+ return False
+
+ print(f"{Fore.YELLOW}Deleting model {model_name}...{Style.RESET_ALL}")
+
+ try:
+ # Use the Ollama CLI to delete the model
+ process = subprocess.run(["ollama", "rm", model_name], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+ if process.returncode == 0:
+ print(f"{Fore.GREEN}Model {model_name} deleted successfully.{Style.RESET_ALL}")
+ return True
+ else:
+ print(f"{Fore.RED}Failed to delete model {model_name}. Error: {process.stderr}{Style.RESET_ALL}")
+ return False
+ except Exception as e:
+ print(f"{Fore.RED}Error deleting model {model_name}: {e}{Style.RESET_ALL}")
+ return False
+
+
+# Add this at the end of the file for command-line usage
+if __name__ == "__main__":
+ import sys
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Ollama model manager")
+ parser.add_argument("--check-model", help="Check if model exists and download if needed")
+ args = parser.parse_args()
+
+ if args.check_model:
+ print(f"Ensuring Ollama is installed and model {args.check_model} is available...")
+ result = ensure_ollama_and_model(args.check_model)
+ sys.exit(0 if result else 1)
+ else:
+ print("No action specified. Use --check-model to check if a model exists.")
+ sys.exit(1)
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.py
new file mode 100644
index 000000000..0c709d16f
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/progress.py
@@ -0,0 +1,116 @@
+from datetime import datetime, timezone
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+from rich.style import Style
+from rich.text import Text
+from typing import Dict, Optional, Callable, List
+
+console = Console()
+
+
+class AgentProgress:
+ """Manages progress tracking for multiple agents."""
+
+ def __init__(self):
+ self.agent_status: Dict[str, Dict[str, str]] = {}
+ self.table = Table(show_header=False, box=None, padding=(0, 1))
+ self.live = Live(self.table, console=console, refresh_per_second=4)
+ self.started = False
+ self.update_handlers: List[Callable[[str, Optional[str], str], None]] = []
+
+ def register_handler(self, handler: Callable[[str, Optional[str], str], None]):
+ """Register a handler to be called when agent status updates."""
+ self.update_handlers.append(handler)
+ return handler # Return handler to support use as decorator
+
+ def unregister_handler(self, handler: Callable[[str, Optional[str], str], None]):
+ """Unregister a previously registered handler."""
+ if handler in self.update_handlers:
+ self.update_handlers.remove(handler)
+
+ def start(self):
+ """Start the progress display."""
+ if not self.started:
+ self.live.start()
+ self.started = True
+
+ def stop(self):
+ """Stop the progress display."""
+ if self.started:
+ self.live.stop()
+ self.started = False
+
+ def update_status(self, agent_name: str, ticker: Optional[str] = None, status: str = "", analysis: Optional[str] = None):
+ """Update the status of an agent."""
+ if agent_name not in self.agent_status:
+ self.agent_status[agent_name] = {"status": "", "ticker": None}
+
+ if ticker:
+ self.agent_status[agent_name]["ticker"] = ticker
+ if status:
+ self.agent_status[agent_name]["status"] = status
+ if analysis:
+ self.agent_status[agent_name]["analysis"] = analysis
+
+ # Set the timestamp as UTC datetime
+ timestamp = datetime.now(timezone.utc).isoformat()
+ self.agent_status[agent_name]["timestamp"] = timestamp
+
+ # Notify all registered handlers
+ for handler in self.update_handlers:
+ handler(agent_name, ticker, status, analysis, timestamp)
+
+ self._refresh_display()
+
+ def get_all_status(self):
+ """Get the current status of all agents as a dictionary."""
+ return {agent_name: {"ticker": info["ticker"], "status": info["status"], "display_name": self._get_display_name(agent_name)} for agent_name, info in self.agent_status.items()}
+
+ def _get_display_name(self, agent_name: str) -> str:
+ """Convert agent_name to a display-friendly format."""
+ return agent_name.replace("_agent", "").replace("_", " ").title()
+
+ def _refresh_display(self):
+ """Refresh the progress display."""
+ self.table.columns.clear()
+ self.table.add_column(width=100)
+
+ # Sort agents with Risk Management and Portfolio Management at the bottom
+ def sort_key(item):
+ agent_name = item[0]
+ if "risk_management" in agent_name:
+ return (2, agent_name)
+ elif "portfolio_management" in agent_name:
+ return (3, agent_name)
+ else:
+ return (1, agent_name)
+
+ for agent_name, info in sorted(self.agent_status.items(), key=sort_key):
+ status = info["status"]
+ ticker = info["ticker"]
+ # Create the status text with appropriate styling
+ if status.lower() == "done":
+ style = Style(color="green", bold=True)
+ symbol = "✓"
+ elif status.lower() == "error":
+ style = Style(color="red", bold=True)
+ symbol = "✗"
+ else:
+ style = Style(color="yellow")
+ symbol = "⋯"
+
+ agent_display = self._get_display_name(agent_name)
+ status_text = Text()
+ status_text.append(f"{symbol} ", style=style)
+ status_text.append(f"{agent_display:<20}", style=Style(bold=True))
+
+ if ticker:
+ status_text.append(f"[{ticker}] ", style=Style(color="cyan"))
+ status_text.append(status, style=style)
+
+ self.table.add_row(status_text)
+
+
+# Create a global instance
+progress = AgentProgress()
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.py
new file mode 100644
index 000000000..3e498a31a
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/src/utils/visualize.py
@@ -0,0 +1,9 @@
+from langgraph.graph.state import CompiledGraph
+from langchain_core.runnables.graph import MermaidDrawMethod
+
+
+def save_graph_as_png(app: CompiledGraph, output_file_path) -> None:
+ png_image = app.get_graph().draw_mermaid_png(draw_method=MermaidDrawMethod.API)
+ file_path = output_file_path if len(output_file_path) > 0 else "graph.png"
+ with open(file_path, "wb") as f:
+ f.write(png_image)
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.py b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.py
new file mode 100644
index 000000000..4123b3fba
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/agents/two_sigma_hedge_fund_agent/two_sigma_agent.py
@@ -0,0 +1,811 @@
+from fincept_terminal.Agents.src.graph.state import AgentState, show_agent_reasoning
+from fincept_terminal.Agents.src.tools.api import get_financial_metrics, get_market_cap, search_line_items
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage
+from pydantic import BaseModel
+import json
+import math
+from typing_extensions import Literal
+from fincept_terminal.Agents.src.utils.progress import progress
+from fincept_terminal.Agents.src.utils.llm import call_llm
+from fincept_terminal.Agents.src.utils.api_key import get_api_key_from_state
+
+
+class TwoSigmaSignal(BaseModel):
+ signal: Literal["bullish", "bearish", "neutral"]
+ confidence: float
+ reasoning: str
+ ml_model_predictions: dict
+
+
+def two_sigma_hedge_fund_agent(state: AgentState, agent_id: str = "two_sigma_hedge_fund_agent"):
+ """
+ Two Sigma: Machine learning, data science
+ Structure: Data Science → ML Engineering → Risk Models → Portfolio Optimization → Scientific Decision
+ Philosophy: Data-driven, machine learning, scientific approach, technology focus
+ """
+ data = state["data"]
+ end_date = data["end_date"]
+ tickers = data["tickers"]
+ api_key = get_api_key_from_state(state, "FINANCIAL_DATASETS_API_KEY")
+ analysis_data = {}
+ two_sigma_analysis = {}
+
+ for ticker in tickers:
+ progress.update_status(agent_id, ticker, "Data science team feature engineering")
+
+ metrics = get_financial_metrics(ticker, end_date, period="quarterly", limit=16, api_key=api_key)
+ financial_line_items = search_line_items(
+ ticker,
+ [
+ "revenue", "net_income", "free_cash_flow", "total_debt",
+ "shareholders_equity", "operating_margin", "total_assets",
+ "current_assets", "current_liabilities", "research_and_development"
+ ],
+ end_date,
+ period="quarterly",
+ limit=16,
+ api_key=api_key,
+ )
+ market_cap = get_market_cap(ticker, end_date, api_key=api_key)
+
+ # Two Sigma's ML-driven analysis structure
+ progress.update_status(agent_id, ticker, "Data science team analysis")
+ data_science_team = data_science_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "ML engineering team models")
+ ml_engineering_team = ml_engineering_team_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Risk modeling team analysis")
+ risk_modeling_team = risk_modeling_team_analysis(metrics, financial_line_items)
+
+ progress.update_status(agent_id, ticker, "Portfolio optimization analysis")
+ portfolio_optimization = portfolio_optimization_analysis(metrics, financial_line_items, market_cap)
+
+ progress.update_status(agent_id, ticker, "Scientific method synthesis")
+ scientific_synthesis = scientific_method_synthesis(
+ data_science_team, ml_engineering_team, risk_modeling_team, portfolio_optimization
+ )
+
+ # Two Sigma's ML-weighted scoring
+ total_score = (
+ ml_engineering_team["score"] * 0.35 +
+ data_science_team["score"] * 0.25 +
+ portfolio_optimization["score"] * 0.2 +
+ risk_modeling_team["score"] * 0.2
+ )
+
+ # Two Sigma's scientific decision framework
+ ml_confidence = ml_engineering_team.get("model_confidence", 0)
+ if total_score >= 8.0 and ml_confidence > 0.75:
+ signal = "bullish"
+ elif total_score <= 3.5 or ml_confidence < 0.4:
+ signal = "bearish"
+ else:
+ signal = "neutral"
+
+ analysis_data[ticker] = {
+ "signal": signal,
+ "score": total_score,
+ "data_science_team": data_science_team,
+ "ml_engineering_team": ml_engineering_team,
+ "risk_modeling_team": risk_modeling_team,
+ "portfolio_optimization": portfolio_optimization,
+ "scientific_synthesis": scientific_synthesis
+ }
+
+ two_sigma_output = generate_two_sigma_output(ticker, analysis_data, state, agent_id)
+
+ two_sigma_analysis[ticker] = {
+ "signal": two_sigma_output.signal,
+ "confidence": two_sigma_output.confidence,
+ "reasoning": two_sigma_output.reasoning,
+ "ml_model_predictions": two_sigma_output.ml_model_predictions
+ }
+
+ progress.update_status(agent_id, ticker, "Done", analysis=two_sigma_output.reasoning)
+
+ message = HumanMessage(content=json.dumps(two_sigma_analysis), name=agent_id)
+
+ if state["metadata"]["show_reasoning"]:
+ show_agent_reasoning(two_sigma_analysis, "Two Sigma")
+
+ state["data"]["analyst_signals"][agent_id] = two_sigma_analysis
+ progress.update_status(agent_id, None, "Done")
+
+ return {"messages": [message], "data": state["data"]}
+
+
+def data_science_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Two Sigma's data science team feature engineering and analysis"""
+ score = 0
+ details = []
+ features = {}
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No data for feature engineering"}
+
+ # Feature engineering from financial data
+ engineered_features = engineer_financial_features(metrics, financial_line_items)
+ features.update(engineered_features)
+
+ # Time series features
+ time_series_features = extract_time_series_features(financial_line_items)
+ features.update(time_series_features)
+
+ # Cross-sectional features
+ cross_sectional_features = create_cross_sectional_features(metrics, market_cap)
+ features.update(cross_sectional_features)
+
+ # Feature importance scoring
+ if features.get("revenue_momentum", 0) > 0.6:
+ score += 2
+ details.append(f"Strong revenue momentum feature: {features['revenue_momentum']:.2f}")
+
+ if features.get("margin_stability", 0) > 0.7:
+ score += 2
+ details.append(f"High margin stability: {features['margin_stability']:.2f}")
+
+ if features.get("growth_quality", 0) > 0.6:
+ score += 1.5
+ details.append(f"Quality growth signals: {features['growth_quality']:.2f}")
+
+ # Alternative data integration (simulated)
+ alt_data_score = integrate_alternative_data_signals(features)
+ score += alt_data_score
+ if alt_data_score > 1:
+ details.append(f"Positive alternative data signals: {alt_data_score:.1f}")
+
+ # Feature interaction analysis
+ interaction_score = analyze_feature_interactions(features)
+ score += interaction_score
+ details.append(f"Feature interaction score: {interaction_score:.2f}")
+
+ return {
+ "score": min(score, 10),
+ "details": "; ".join(details),
+ "features": features
+ }
+
+
+def ml_engineering_team_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Two Sigma's ML engineering team model predictions"""
+ score = 0
+ details = []
+ model_predictions = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No ML data"}
+
+ # Ensemble model predictions
+ random_forest_pred = simulate_random_forest_prediction(metrics, financial_line_items)
+ model_predictions["random_forest"] = random_forest_pred
+
+ gradient_boosting_pred = simulate_gradient_boosting_prediction(metrics, financial_line_items)
+ model_predictions["gradient_boosting"] = gradient_boosting_pred
+
+ neural_network_pred = simulate_neural_network_prediction(metrics, financial_line_items)
+ model_predictions["neural_network"] = neural_network_pred
+
+ # Time series models
+ lstm_pred = simulate_lstm_prediction(financial_line_items)
+ model_predictions["lstm"] = lstm_pred
+
+ # Ensemble prediction
+ ensemble_prediction = calculate_ensemble_prediction(model_predictions)
+ model_predictions["ensemble"] = ensemble_prediction
+
+ # Model confidence calculation
+ model_confidence = calculate_model_confidence(model_predictions)
+
+ # Scoring based on ensemble prediction and confidence
+ if ensemble_prediction > 0.6 and model_confidence > 0.7:
+ score += 4
+ details.append(f"Strong ensemble prediction: {ensemble_prediction:.2f} with high confidence")
+ elif ensemble_prediction > 0.4:
+ score += 2
+ details.append(f"Positive ensemble prediction: {ensemble_prediction:.2f}")
+
+ # Model agreement analysis
+ model_agreement = calculate_model_agreement(model_predictions)
+ if model_agreement > 0.8:
+ score += 2
+ details.append(f"High model agreement: {model_agreement:.2f}")
+ elif model_agreement < 0.4:
+ score -= 1
+ details.append(f"Low model agreement: {model_agreement:.2f}")
+
+ # Feature importance from models
+ feature_importance = extract_feature_importance(model_predictions)
+ if feature_importance.get("fundamental_strength", 0) > 0.7:
+ score += 1
+ details.append("Models emphasize fundamental strength")
+
+ return {
+ "score": min(score, 10),
+ "details": "; ".join(details),
+ "model_predictions": model_predictions,
+ "model_confidence": model_confidence,
+ "ensemble_prediction": ensemble_prediction
+ }
+
+
+def risk_modeling_team_analysis(metrics: list, financial_line_items: list) -> dict:
+ """Two Sigma's risk modeling team analysis"""
+ score = 0
+ details = []
+ risk_metrics = {}
+
+ if not metrics or not financial_line_items:
+ return {"score": 0, "details": "No risk modeling data"}
+
+ # Value-at-Risk modeling
+ var_analysis = calculate_value_at_risk(financial_line_items)
+ risk_metrics["var_95"] = var_analysis
+ if var_analysis < 0.15: # 15% VaR
+ score += 2
+ details.append(f"Low VaR: {var_analysis:.1%}")
+
+ # Expected shortfall
+ expected_shortfall = calculate_expected_shortfall(financial_line_items)
+ risk_metrics["expected_shortfall"] = expected_shortfall
+ if expected_shortfall < 0.2:
+ score += 1
+ details.append(f"Limited tail risk: {expected_shortfall:.1%}")
+
+ # Factor risk decomposition
+ factor_risks = decompose_factor_risks_ml(metrics, financial_line_items)
+ risk_metrics["factor_risks"] = factor_risks
+
+ # Maximum diversification ratio
+ diversification_ratio = calculate_diversification_benefits(financial_line_items)
+ risk_metrics["diversification"] = diversification_ratio
+ if diversification_ratio > 0.6:
+ score += 1
+ details.append(f"Good diversification benefits: {diversification_ratio:.2f}")
+
+ # Regime-dependent risk modeling
+ regime_risks = model_regime_dependent_risks(financial_line_items)
+ risk_metrics["regime_risks"] = regime_risks
+
+ # Stress testing results
+ stress_test_results = conduct_ml_stress_tests(financial_line_items)
+ risk_metrics["stress_tests"] = stress_test_results
+ if stress_test_results.get("worst_case_scenario", 1) > 0.7:
+ score += 2
+ details.append("Passes ML stress test scenarios")
+
+ return {
+ "score": score,
+ "details": "; ".join(details),
+ "risk_metrics": risk_metrics
+ }
+
+
+def portfolio_optimization_analysis(metrics: list, financial_line_items: list, market_cap: float) -> dict:
+ """Two Sigma's portfolio optimization analysis"""
+ score = 0
+ details = []
+
+ if not metrics or not financial_line_items or not market_cap:
+ return {"score": 0, "details": "No portfolio optimization data"}
+
+ # Mean-variance optimization
+ sharpe_ratio_estimate = estimate_sharpe_ratio(metrics, financial_line_items)
+ if sharpe_ratio_estimate > 1.5:
+ score += 3
+ details.append(f"High estimated Sharpe ratio: {sharpe_ratio_estimate:.2f}")
+ elif sharpe_ratio_estimate > 1.0:
+ score += 2
+ details.append(f"Good estimated Sharpe ratio: {sharpe_ratio_estimate:.2f}")
+
+ # Risk budgeting analysis
+ risk_contribution = calculate_risk_contribution(financial_line_items, market_cap)
+ if risk_contribution < 0.1: # Low risk contribution
+ score += 2
+ details.append(f"Low portfolio risk contribution: {risk_contribution:.1%}")
+
+ # Transaction cost optimization
+ transaction_costs = optimize_transaction_costs(market_cap)
+ if transaction_costs < 0.02:
+ score += 1
+ details.append(f"Low transaction costs: {transaction_costs:.2%}")
+
+ # Alpha decay analysis
+ alpha_persistence = analyze_alpha_persistence(financial_line_items)
+ if alpha_persistence > 0.6:
+ score += 2
+ details.append(f"Persistent alpha signals: {alpha_persistence:.2f}")
+
+ # Capacity constraints
+ strategy_capacity = assess_strategy_capacity(market_cap)
+ if strategy_capacity > 0.8:
+ score += 1
+ details.append("High strategy capacity for scaling")
+
+ return {"score": score, "details": "; ".join(details)}
+
+
+def scientific_method_synthesis(data_science: dict, ml_engineering: dict,
+ risk_modeling: dict, portfolio_optimization: dict) -> dict:
+ """Two Sigma's scientific method synthesis"""
+ details = []
+
+ # Scientific hypothesis testing
+ ml_confidence = ml_engineering.get("model_confidence", 0)
+ ensemble_pred = ml_engineering.get("ensemble_prediction", 0.5)
+ risk_score = risk_modeling["score"] / 10
+
+ # Bayesian model averaging
+ prior_belief = 0.5 # Neutral prior
+ likelihood = ensemble_pred
+ posterior = (likelihood * prior_belief) / ((likelihood * prior_belief) + ((1 - likelihood) * (1 - prior_belief)))
+
+ # Scientific confidence intervals
+ confidence_interval = calculate_prediction_confidence_interval(ml_engineering.get("model_predictions", {}))
+
+ # Hypothesis strength
+ if ml_confidence > 0.8 and abs(ensemble_pred - 0.5) > 0.2:
+ hypothesis_strength = "Strong"
+ details.append("Strong statistical evidence for directional prediction")
+ elif ml_confidence > 0.6:
+ hypothesis_strength = "Moderate"
+ details.append("Moderate statistical evidence")
+ else:
+ hypothesis_strength = "Weak"
+ details.append("Insufficient statistical evidence")
+
+ # Scientific decision framework
+ if hypothesis_strength == "Strong" and risk_score > 0.6:
+ scientific_decision = "High conviction systematic position"
+ elif hypothesis_strength == "Moderate":
+ scientific_decision = "Moderate systematic position"
+ else:
+ scientific_decision = "Insufficient evidence for position"
+
+ return {
+ "scientific_decision": scientific_decision,
+ "hypothesis_strength": hypothesis_strength,
+ "posterior_probability": posterior,
+ "confidence_interval": confidence_interval,
+ "details": "; ".join(details)
+ }
+
+
+# ML and Data Science Helper Functions
+def engineer_financial_features(metrics: list, financial_line_items: list) -> dict:
+ """Engineer features from financial data"""
+ features = {}
+
+ # Revenue momentum features
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ recent_momentum = (revenues[0] / revenues[1]) - 1
+ historical_momentum = (revenues[1] / revenues[-1]) ** (1 / (len(revenues) - 2)) - 1
+ features["revenue_momentum"] = recent_momentum - historical_momentum
+
+ # Margin stability
+ margins = [item.operating_margin for item in financial_line_items if item.operating_margin]
+ if margins:
+ margin_cv = calculate_coefficient_of_variation(margins)
+ features["margin_stability"] = max(0, 1 - margin_cv)
+
+ # Growth quality
+ if metrics and len(revenues) >= 3:
+ revenue_growth = (revenues[0] / revenues[-1]) ** (1 / len(revenues)) - 1
+ roe = metrics[0].return_on_equity if metrics[0].return_on_equity else 0
+ features["growth_quality"] = min(revenue_growth * roe * 10, 1.0)
+
+ return features
+
+
+def extract_time_series_features(financial_line_items: list) -> dict:
+ """Extract time series features"""
+ features = {}
+
+ # Trend analysis
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 6:
+ trend_strength = calculate_trend_strength(revenues)
+ features["trend_strength"] = trend_strength
+
+ # Seasonality detection
+ if len(revenues) >= 8:
+ seasonality = detect_seasonality(revenues)
+ features["seasonality"] = seasonality
+
+ # Volatility clustering
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ volatility_clustering = analyze_volatility_clustering(earnings)
+ features["volatility_clustering"] = volatility_clustering
+
+ return features
+
+
+def create_cross_sectional_features(metrics: list, market_cap: float) -> dict:
+ """Create cross-sectional ranking features"""
+ features = {}
+
+ if not metrics:
+ return features
+
+ latest = metrics[0]
+
+ # Relative valuation features
+ if latest.price_to_earnings and latest.price_to_earnings > 0:
+ features["pe_percentile"] = min(max(1 - (latest.price_to_earnings / 25), 0), 1)
+
+ # Size factor
+ features["size_factor"] = min(math.log10(market_cap / 1_000_000_000), 2) / 2 # Normalize by $100B
+
+ # Quality factor
+ if latest.return_on_equity:
+ features["quality_factor"] = min(latest.return_on_equity / 0.25, 1)
+
+ return features
+
+
+def integrate_alternative_data_signals(features: dict) -> float:
+ """Integrate alternative data signals (simulated)"""
+ # Simulated alternative data integration
+ base_score = features.get("revenue_momentum", 0) * features.get("margin_stability", 0.5)
+ return min(base_score * 2, 2.0)
+
+
+def analyze_feature_interactions(features: dict) -> float:
+ """Analyze feature interactions"""
+ if not features:
+ return 0
+
+ # Simplified interaction analysis
+ interaction_score = 0
+ feature_values = [v for v in features.values() if isinstance(v, (int, float))]
+
+ if feature_values:
+ mean_feature = sum(feature_values) / len(feature_values)
+ interaction_score = min(mean_feature * len(feature_values) / 5, 2.0)
+
+ return interaction_score
+
+
+def simulate_random_forest_prediction(metrics: list, financial_line_items: list) -> float:
+ """Simulate random forest model prediction"""
+ if not metrics or not financial_line_items:
+ return 0.5
+
+ # Simplified RF prediction based on multiple factors
+ latest = metrics[0]
+ score = 0.5
+
+ if latest.return_on_equity and latest.return_on_equity > 0.12:
+ score += 0.2
+
+ if latest.price_to_earnings and latest.price_to_earnings < 15:
+ score += 0.15
+
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 3 and revenues[0] > revenues[-1]:
+ score += 0.1
+
+ return min(max(score, 0), 1)
+
+
+def simulate_gradient_boosting_prediction(metrics: list, financial_line_items: list) -> float:
+ """Simulate gradient boosting model prediction"""
+ # Similar to RF but with different weighting
+ rf_pred = simulate_random_forest_prediction(metrics, financial_line_items)
+ # Add some variation to simulate different model
+ return min(max(rf_pred + 0.05 - 0.1 * (rf_pred - 0.5), 0), 1)
+
+
+def simulate_neural_network_prediction(metrics: list, financial_line_items: list) -> float:
+ """Simulate neural network model prediction"""
+ # Non-linear combination
+ rf_pred = simulate_random_forest_prediction(metrics, financial_line_items)
+ # Sigmoid-like transformation
+ return 1 / (1 + math.exp(-5 * (rf_pred - 0.5)))
+
+
+def simulate_lstm_prediction(financial_line_items: list) -> float:
+ """Simulate LSTM time series prediction"""
+ revenues = [item.revenue for item in financial_line_items if item.revenue]
+ if len(revenues) >= 4:
+ # Simple trend-based prediction
+ recent_trend = (revenues[0] / revenues[2]) - 1
+ return min(max(0.5 + recent_trend, 0), 1)
+ return 0.5
+
+
+def calculate_ensemble_prediction(model_predictions: dict) -> float:
+ """Calculate ensemble prediction from multiple models"""
+ predictions = [v for k, v in model_predictions.items() if k != "ensemble" and isinstance(v, (int, float))]
+ if predictions:
+ return sum(predictions) / len(predictions)
+ return 0.5
+
+
+def calculate_model_confidence(model_predictions: dict) -> float:
+ """Calculate confidence based on model agreement"""
+ predictions = [v for k, v in model_predictions.items() if k != "ensemble" and isinstance(v, (int, float))]
+ if len(predictions) >= 2:
+ mean_pred = sum(predictions) / len(predictions)
+ variance = sum((p - mean_pred) ** 2 for p in predictions) / len(predictions)
+ # Lower variance = higher confidence
+ return max(0, 1 - variance * 4)
+ return 0.5
+
+
+def calculate_model_agreement(model_predictions: dict) -> float:
+ """Calculate agreement between models"""
+ return calculate_model_confidence(model_predictions) # Same calculation
+
+
+def extract_feature_importance(model_predictions: dict) -> dict:
+ """Extract feature importance from models"""
+ return {
+ "fundamental_strength": 0.7,
+ "momentum": 0.5,
+ "valuation": 0.6
+ }
+
+
+def calculate_value_at_risk(financial_line_items: list) -> float:
+ """Calculate Value-at-Risk"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ sorted_earnings = sorted(earnings)
+ var_index = int(len(sorted_earnings) * 0.05) # 5th percentile
+ if var_index < len(sorted_earnings):
+ worst_case = sorted_earnings[var_index]
+ max_earnings = max(earnings)
+ if max_earnings > 0:
+ return abs(worst_case - max_earnings) / max_earnings
+ return 0.3
+
+
+def calculate_expected_shortfall(financial_line_items: list) -> float:
+ """Calculate Expected Shortfall (Conditional VaR)"""
+ var = calculate_value_at_risk(financial_line_items)
+ return var * 1.3 # ES is typically higher than VaR
+
+
+def decompose_factor_risks_ml(metrics: list, financial_line_items: list) -> dict:
+ """ML-based factor risk decomposition"""
+ return {
+ "market_beta": 0.8,
+ "size_factor": 0.3,
+ "value_factor": 0.4,
+ "momentum_factor": 0.2,
+ "quality_factor": 0.6,
+ "idiosyncratic": 0.4
+ }
+
+
+def calculate_diversification_benefits(financial_line_items: list) -> float:
+ """Calculate diversification benefits"""
+ return 0.6 # Placeholder
+
+
+def model_regime_dependent_risks(financial_line_items: list) -> dict:
+ """Model risks under different regimes"""
+ return {
+ "bull_market_risk": 0.2,
+ "bear_market_risk": 0.4,
+ "recession_risk": 0.6,
+ "inflation_risk": 0.3
+ }
+
+
+def conduct_ml_stress_tests(financial_line_items: list) -> dict:
+ """Conduct ML-based stress tests"""
+ return {
+ "worst_case_scenario": 0.8,
+ "market_crash_scenario": 0.6,
+ "liquidity_crisis": 0.7
+ }
+
+
+def estimate_sharpe_ratio(metrics: list, financial_line_items: list) -> float:
+ """Estimate expected Sharpe ratio"""
+ if not metrics:
+ return 1.0
+
+ latest = metrics[0]
+ if latest.return_on_equity:
+ # Simple proxy for Sharpe ratio
+ return min(latest.return_on_equity * 5, 3.0)
+
+ return 1.0
+
+
+def calculate_risk_contribution(financial_line_items: list, market_cap: float) -> float:
+ """Calculate risk contribution to portfolio"""
+ # Based on market cap and volatility
+ volatility = estimate_volatility(financial_line_items)
+ size_factor = min(market_cap / 100_000_000_000, 1.0) # Normalize by $100B
+ return volatility * (1 - size_factor)
+
+
+def optimize_transaction_costs(market_cap: float) -> float:
+ """Optimize transaction costs"""
+ if market_cap > 50_000_000_000:
+ return 0.005
+ elif market_cap > 10_000_000_000:
+ return 0.01
+ else:
+ return 0.03
+
+
+def analyze_alpha_persistence(financial_line_items: list) -> float:
+ """Analyze alpha persistence"""
+ return 0.6 # Placeholder
+
+
+def assess_strategy_capacity(market_cap: float) -> float:
+ """Assess strategy capacity"""
+ return min(market_cap / 1_000_000_000, 1.0) # Based on liquidity
+
+
+def calculate_prediction_confidence_interval(model_predictions: dict) -> dict:
+ """Calculate confidence intervals for predictions"""
+ ensemble = model_predictions.get("ensemble", 0.5)
+ std_dev = 0.1 # Estimated standard deviation
+
+ return {
+ "lower_bound": max(ensemble - 1.96 * std_dev, 0),
+ "upper_bound": min(ensemble + 1.96 * std_dev, 1)
+ }
+
+
+def calculate_coefficient_of_variation(data: list) -> float:
+ """Calculate coefficient of variation"""
+ if not data:
+ return 1.0
+
+ mean_val = sum(data) / len(data)
+ if mean_val == 0:
+ return 1.0
+
+ variance = sum((x - mean_val) ** 2 for x in data) / len(data)
+ std_dev = math.sqrt(variance)
+
+ return std_dev / abs(mean_val)
+
+
+def calculate_trend_strength(data: list) -> float:
+ """Calculate trend strength"""
+ if len(data) < 3:
+ return 0
+
+ # Simple linear trend
+ n = len(data)
+ x_mean = (n - 1) / 2
+ y_mean = sum(data) / n
+
+ numerator = sum((i - x_mean) * (data[i] - y_mean) for i in range(n))
+ denominator = sum((i - x_mean) ** 2 for i in range(n))
+
+ if denominator == 0:
+ return 0
+
+ slope = numerator / denominator
+ return min(abs(slope) / (y_mean if y_mean != 0 else 1), 1.0)
+
+
+def detect_seasonality(data: list) -> float:
+ """Detect seasonality in data"""
+ if len(data) < 8:
+ return 0
+
+ # Simple quarterly seasonality check
+ q1_avg = sum(data[i] for i in range(0, len(data), 4)) / ((len(data) + 3) // 4)
+ q2_avg = sum(data[i] for i in range(1, len(data), 4)) / ((len(data) + 2) // 4)
+
+ if q1_avg > 0:
+ return min(abs(q2_avg - q1_avg) / q1_avg, 1.0)
+
+ return 0
+
+
+def analyze_volatility_clustering(data: list) -> float:
+ """Analyze volatility clustering"""
+ if len(data) < 4:
+ return 0
+
+ # Calculate rolling volatility
+ volatilities = []
+ for i in range(2, len(data)):
+ recent_vol = abs(data[i] - data[i - 1])
+ volatilities.append(recent_vol)
+
+ if volatilities:
+ return min(calculate_coefficient_of_variation(volatilities), 1.0)
+
+ return 0
+
+
+def estimate_volatility(financial_line_items: list) -> float:
+ """Estimate volatility from financial data"""
+ earnings = [item.net_income for item in financial_line_items if item.net_income]
+ if earnings:
+ return calculate_coefficient_of_variation(earnings)
+ return 0.3
+
+
+def generate_two_sigma_output(ticker: str, analysis_data: dict, state: AgentState, agent_id: str) -> TwoSigmaSignal:
+ """Generate Two Sigma's machine learning investment decision"""
+ template = ChatPromptTemplate.from_messages([
+ ("system", """You are Two Sigma's AI system, implementing scientific machine learning approach to investing:
+
+ ORGANIZATIONAL STRUCTURE:
+ - Data Science Team: Feature engineering and alternative data integration
+ - ML Engineering Team: Ensemble models and prediction algorithms
+ - Risk Modeling Team: Value-at-Risk and factor risk analysis
+ - Portfolio Optimization Team: Mean-variance and transaction cost optimization
+ - Scientific Method Synthesis: Hypothesis testing and Bayesian inference
+
+ PHILOSOPHY:
+ 1. Data-Driven Decisions: All investment decisions based on data and models
+ 2. Machine Learning: Advanced ML algorithms for pattern recognition
+ 3. Scientific Method: Hypothesis testing and statistical significance
+ 4. Alternative Data: Integration of non-traditional data sources
+ 5. Risk Management: Sophisticated quantitative risk models
+ 6. Technology Focus: Cutting-edge technology and research
+ 7. Academic Rigor: PhD-level research and peer review process
+
+ REASONING STYLE:
+ - Reference machine learning model predictions and confidence levels
+ - Discuss feature engineering and alternative data signals
+ - Apply statistical significance testing and confidence intervals
+ - Consider ensemble model predictions and cross-validation
+ - Express reasoning in probabilistic terms
+ - Acknowledge model limitations and overfitting risks
+ - Focus on scientific hypothesis testing framework
+
+ Return investment signal with ML model predictions and confidence metrics."""),
+
+ ("human", """Apply Two Sigma's machine learning analysis to {ticker}:
+
+ {analysis_data}
+
+ Provide investment signal in JSON format:
+ {{
+ "signal": "bullish" | "bearish" | "neutral",
+ "confidence": float (0-100),
+ "reasoning": "string",
+ "ml_model_predictions": {{
+ "ensemble_prediction": float,
+ "model_confidence": float,
+ "random_forest": float,
+ "gradient_boosting": float,
+ "neural_network": float,
+ "lstm": float
+ }}
+ }}""")
+ ])
+
+ prompt = template.invoke({"analysis_data": json.dumps(analysis_data, indent=2), "ticker": ticker})
+
+ def create_default_two_sigma_signal():
+ return TwoSigmaSignal(
+ signal="neutral",
+ confidence=0.0,
+ reasoning="Analysis error, defaulting to neutral",
+ ml_model_predictions={
+ "ensemble_prediction": 0.5,
+ "model_confidence": 0.0,
+ "random_forest": 0.5,
+ "gradient_boosting": 0.5,
+ "neural_network": 0.5,
+ "lstm": 0.5
+ }
+ )
+
+ return call_llm(
+ prompt=prompt,
+ pydantic_model=TwoSigmaSignal,
+ agent_name=agent_id,
+ state=state,
+ default_factory=create_default_two_sigma_signal,
+ )
\ No newline at end of file