Introduction: From Passive Language Models to Autonomous Financial Agents

Few-Shot Prompt Structure:
┌─────────────────────────────────────────────────────────────────────┐
|  System: "You are a financial data extractor. Return only JSON."  |
|                                                                  |
|  Example 1:                                                      |
|  Input: "Apple reported EPS of $1.50 for Q1 2024."              |
|  Output: {"ticker": "AAPL", "metric": "EPS", "value": 1.50,    |
|           "quarter": "Q1 2024"}                                 |
|                                                                  |
|  Example 2:                                                      |
|  Input: "JPM revenue surged to $40B in Q4."                   |
|  Output: {"ticker": "JPM", "metric": "Revenue", "value": 40,   |
|           "quarter": "Q4"}                                     |
|                                                                  |
|  New Input: "GS trading revenue fell 5%."                       |
|  → Model infers the JSON schema and outputs structured data.   |
└─────────────────────────────────────────────────────────────────────┘

Chain-of-Thought (CoT) Linear Decomposition:
┌─────────────────────────────────────────────────────────────────────┐
|  Problem: "Calculate the fair CDS spread for Company X."         |
|                                                                  |
|  Step 1: Estimate the 5-year cumulative default probability.    |
|          → PD = 3.5%                                            |
|                                                                  |
|  Step 2: Calculate the expected loss given default.            |
|          → LGD = 60%                                            |
|                                                                  |
|  Step 3: Compute the expected annual loss.                     |
|          → EL = PD × LGD = 2.1%                                 |
|                                                                  |
|  Step 4: Discount the expected loss cash flows.                |
|          → Fair CDS Spread ≈ 210 bps.                          |
|                                                                  |
|  Final Answer: 210 bps.                                         |
└─────────────────────────────────────────────────────────────────────┘

Tree-of-Thought (ToT) Branching Exploration:
┌─────────────────────────────────────────────────────────────────────┐
|  Problem: "Should we increase allocation to Tech sector?"        |
|                                                                  |
|  Branch A: Bullish Macro                                         |
|  ├─ AI boom drives earnings.                                    |
|  ├─ Valuations are stretched.                                   |
|  └─ Verdict: Proceed cautiously.                                |
|                                                                  |
|  Branch B: Bearish Rates                                         |
|  ├─ Fed maintains high rates.                                   |
|  ├─ Tech growth stocks suffer.                                  |
|  └─ Verdict: Reduce allocation.                                 |
|                                                                  |
|  Branch C: Neutral/Contrarian                                    |
|  ├─ Selective AI winners exist.                                 |
|  ├─ Market already priced in cuts.                              |
|  └─ Verdict: Equal-weight approach.                             |
|                                                                  |
|  → ToT evaluates all branches via self-consistency checks       |
|    before selecting "Branch C" as the most robust strategy.    |
└─────────────────────────────────────────────────────────────────────┘

Hybrid RAG Pipeline:
┌─────────────────────────────────────────────────────────────────────┐
|  User Query: "What are the off-balance-sheet liabilities?"       |
|                              ▼                                    |
|  1. Dense Retrieval (Semantic):                                 |
|     → Finds concepts like "SPVs", "securitization".             |
|                              ▼                                    |
|  2. Sparse Retrieval (Keyword):                                |
|     → Finds exact phrase "Off-balance-sheet".                   |
|                              ▼                                    |
|  3. Fusion (Reciprocal Rank Fusion):                            |
|     → Combines results from both retrievers.                   |
|                              ▼                                    |
|  4. Cross-Encoder Re-Ranking:                                  |
|     → A neural model jointly evaluates (query, doc) pairs.     |
|     → Keeps only the top-3 most relevant chunks.              |
|                              ▼                                    |
|  5. LLM Generation:                                            |
|     → Grounded answer with citations.                         |
└─────────────────────────────────────────────────────────────────────┘

Multi-Agent Financial Architecture:
┌─────────────────────────────────────────────────────────────────────┐
|  Orchestrator (Router)                                            |
|                              │                                    |
|  ┌───────────────────────────┴───────────────────────────┐       |
|  │                                                       │       |
|  ▼                                                       ▼       |
|  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐   |
|  │ Quant Research  │  │  Risk Manager   │  │  Code Auditor   │   |
|  │ Agent           │  │  Agent          │  │  Agent          │   |
|  ├─────────────────┤  ├─────────────────┤  ├─────────────────┤   |
|  │ • Generates     │  │ • VaR/ES calcs │  │ • Sandbox exec  │   |
|  │   hypotheses    │  │ • Stress tests │  │ • Syntax check  │   |
|  │ • Writes code   │  │ • Drawdown     │  │ • Data leakage  │   |
|  │ • Backtesting   │  │   limits       │  │   validation    │   |
|  └─────────────────┘  └─────────────────┘  └─────────────────┘   |
|           │                    │                    │             |
|           └────────────────────┼────────────────────┘             |
|                                ▼                                  |
|                     ┌─────────────────────┐                       |
|                     │ Compliance Agent   │                       |
|                     │ (Regulatory Check) │                       |
|                     └─────────────────────┘                       |
|                                ▼                                  |
|                         Final Report/Execution                    |
└─────────────────────────────────────────────────────────────────────┘

LangGraph Workflow Definition:
┌─────────────────────────────────────────────────────────────────────┐
|  State: { "hypothesis": str, "code": str, "risk_approved": bool,  |
|           "backtest_results": dict }                              |
|                                                                  |
|  Nodes:                                                          |
|  • `researcher` ───► `risk_evaluator`                            |
|  • `risk_evaluator` ──(if approved)─► `code_executor`           |
|  • `risk_evaluator` ──(if rejected)─► `researcher` (Loop)       |
|  • `code_executor` ──► `compliance_checker`                     |
|  • `compliance_checker` ──► `report_generator`                  |
└─────────────────────────────────────────────────────────────────────┘

tools = [
    {
        "name": "execute_backtest",
        "description": "Runs a backtest on a given strategy code.",
        "parameters": {"code": "str", "start_date": "str", "end_date": "str"}
    },
    {
        "name": "fetch_market_data",
        "description": "Retrieves OHLCV data for a ticker.",
        "parameters": {"ticker": "str", "period": "str"}
    }
]

import os
import json
from typing import TypedDict, Annotated, Literal
from langgraph.graph import StateGraph, END
from langgraph.checkpoint import MemorySaver
from langchain_openai import ChatOpenAI
from langchain_community.tools import tool
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import TextLoader

# Initialize LLM
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)

# -------------------- 1. DEFINE STATE --------------------
class QuantAgentState(TypedDict):
    hypothesis: str
    generated_code: str
    backtest_results: dict
    risk_score: float
    risk_approved: bool
    compliance_passed: bool
    final_report: str
    iteration: int

# -------------------- 2. DEFINE TOOLS --------------------
@tool
def execute_backtest(code: str, ticker: str = "AAPL") -> dict:
    """
    Simulates a backtest execution. In production, this runs in a sandbox.
    """
    print(f"Executing backtest for {ticker}...")
    # Mock results
    return {
        "sharpe_ratio": 1.25,
        "max_drawdown": -0.12,
        "total_return": 0.34,
        "volatility": 0.18
    }

@tool
def calculate_var(returns: list) -> float:
    """Calculates Value at Risk (95% confidence)."""
    # Mock calculation
    return 0.05

tools = [execute_backtest, calculate_var]
llm_with_tools = llm.bind_tools(tools)

# -------------------- 3. DEFINE AGENT NODES --------------------
def quant_researcher(state: QuantAgentState) -> dict:
    """Generates Python code from a natural language hypothesis."""
    prompt = f"""
    You are a Quant Researcher. Generate Python code (using pandas/numpy)
    to test the following hypothesis:
    {state['hypothesis']}
    Return only the code block.
    """
    response = llm.invoke(prompt)
    return {"generated_code": response.content, "iteration": state.get("iteration", 0) + 1}

def risk_manager(state: QuantAgentState) -> dict:
    """Evaluates the risk of the proposed strategy."""
    prompt = f"""
    You are a Risk Manager. Review this strategy code and estimate its risk.
    Provide a risk score between 0 and 1 (1 = max risk).
    Code: {state['generated_code']}
    """
    response = llm.invoke(prompt)
    # Parse response to extract score (simplified)
    risk_score = 0.35
    approved = risk_score < 0.6
    return {"risk_score": risk_score, "risk_approved": approved}

def code_executor(state: QuantAgentState) -> dict:
    """Executes the generated code (if approved)."""
    if state["risk_approved"]:
        # In production: exec in restricted Docker container
        results = execute_backtest.invoke({"code": state["generated_code"]})
        return {"backtest_results": results}
    return {"backtest_results": {"error": "Risk rejected"}}

def compliance_checker(state: QuantAgentState) -> dict:
    """Checks regulatory compliance."""
    # Mock check
    return {"compliance_passed": True}

def report_generator(state: QuantAgentState) -> dict:
    """Generates the final investment memo."""
    if state["compliance_passed"] and state["risk_approved"]:
        prompt = f"""
        Generate a professional investment memo based on:
        Hypothesis: {state['hypothesis']}
        Backtest Results: {json.dumps(state['backtest_results'])}
        """
        report = llm.invoke(prompt)
        return {"final_report": report.content}
    return {"final_report": "Strategy rejected due to risk/compliance."}

# -------------------- 4. BUILD THE GRAPH (LANGGRAPH) --------------------
builder = StateGraph(QuantAgentState)

# Add nodes
builder.add_node("researcher", quant_researcher)
builder.add_node("risk_manager", risk_manager)
builder.add_node("executor", code_executor)
builder.add_node("compliance", compliance_checker)
builder.add_node("reporter", report_generator)

# Add edges
builder.set_entry_point("researcher")
builder.add_edge("researcher", "risk_manager")

# Conditional routing
def route_after_risk(state: QuantAgentState) -> Literal["executor", "reporter"]:
    return "executor" if state["risk_approved"] else "reporter"

builder.add_conditional_edges("risk_manager", route_after_risk)
builder.add_edge("executor", "compliance")
builder.add_edge("compliance", "reporter")
builder.add_edge("reporter", END)

# Compile with memory (for persistence)
memory = MemorySaver()
graph = builder.compile(checkpointer=memory)

# -------------------- 5. RAG SETUP (Knowledge Base) --------------------
# Load financial documents
loader = TextLoader("sec_filings.txt")  # Dummy file
documents = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

# Create FAISS vector store
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

def rag_query(query: str) -> str:
    """Retrieve relevant documents and generate a grounded answer."""
    docs = retriever.invoke(query)
    context = "\n".join([d.page_content for d in docs])
    prompt = f"Based on the following SEC documents, answer:\n{query}\n\nContext:\n{context}"
    return llm.invoke(prompt).content

# -------------------- 6. EXECUTE THE WORKFLOW --------------------
if __name__ == "__main__":
    # Run the multi-agent quant research
    initial_state = {
        "hypothesis": "Test a mean-reversion strategy on S&P 500 stocks using RSI(14).",
        "iteration": 0
    }
    config = {"configurable": {"thread_id": "quant_research_1"}}
    
    final_state = graph.invoke(initial_state, config)
    print("\n--- FINAL REPORT ---")
    print(final_state["final_report"])

    # RAG example
    print("\n--- RAG QUERY ---")
    answer = rag_query("What is the SEC's stance on off-balance-sheet entities?")
    print(answer)