Fin-R1: a Financial Reasoning LLM with Reinforcement Learning and CoT

mkdir -p ~/models
huggingface-cli login
huggingface-cli download SUFE-AIFLM-Lab/Fin-R1 --local-dir "~/models" --include "*"

#Convert to GGUF
docker run --rm -v "~/models":/repo ghcr.io/ggerganov/llama.cpp:full --convert "/repo" --outtype f32
ls ~/models | grep .gguf
#> ggml-model-f32.gguf

#Quantize from F32.gguf to Q4_K_M.bin
docker run --rm -v "~/models":/repo ghcr.io/ggerganov/llama.cpp:full --quantize "/repo/ggml-model-f32.gguf" "/repo/ggml-model-Q4_K_M.bin" "Q4_K_M"
ls ~/models | grep .bin
#> ggml-model-Q4_K_M.bin

 ollama pull hf.co/ernanhughes/Fin-R1-Q8_0-GGUF

from transformers import AutoConfig
from huggingface_hub import HfApi
import requests
import json
import os

def config_to_markdown(config_dict):
    # Priority ordered keys
    priority_keys = [
        "model_type", "architectures", "hidden_size", "num_attention_heads",
        "num_hidden_layers", "intermediate_size", "vocab_size", "type_vocab_size",
        "max_position_embeddings", "hidden_act", "initializer_range",
        "layer_norm_eps", "attention_probs_dropout_prob", "hidden_dropout_prob",
        "pad_token_id", "bos_token_id", "eos_token_id"
    ]
    all_keys = list(config_dict.keys())
    
    # Sort by priority first, then append any other keys
    ordered_keys = [k for k in priority_keys if k in config_dict] + \
                   [k for k in all_keys if k not in priority_keys]

    # Create markdown table
    markdown = "| Key | Value |\n|-----|-------|\n"
    for k in ordered_keys:
        v = config_dict[k]
        if isinstance(v, list):
            v = ", ".join(map(str, v))
        elif isinstance(v, dict):
            v = json.dumps(v)
        markdown += f"| `{k}` | `{v}` |\n"
    return markdown

def inspect_model_config(model_name_or_path, source="autoconfig"):
    """
    Inspect a Hugging Face model's configuration and output as markdown.

    Parameters:
        model_name_or_path (str): model name from Hugging Face hub or local path.
        source (str): One of ["autoconfig", "api", "rest", "local_json"]
    """
    config_dict = None

    if source == "autoconfig":
        print("Using AutoConfig (local or remote)...")
        config = AutoConfig.from_pretrained(model_name_or_path)
        config_dict = config.to_dict()

    elif source == "api":
        print("Using huggingface_hub HfApi...")
        api = HfApi()
        model_info = api.model_info(model_name_or_path)
        config_dict = model_info.config if hasattr(model_info, 'config') else {}

    elif source == "rest":
        print("Using Hugging Face REST API...")
        url = f"https://huggingface.co/api/models/{model_name_or_path}"
        response = requests.get(url)
        if response.status_code == 200:
            data = response.json()
            config_dict = data.get("config", {})
        else:
            print("Failed to retrieve model metadata from REST API.")

    elif source == "local_json":
        print("Loading config.json from local directory...")
        path = os.path.join(model_name_or_path, "config.json")
        if os.path.exists(path):
            with open(path, "r") as f:
                config_dict = json.load(f)
        else:
            print(f"config.json not found at {path}")

    else:
        print("Invalid source. Choose from: autoconfig, api, rest, local_json.")

    if config_dict:
        print("\n### Model Configuration (Markdown Table)\n")
        print(config_to_markdown(config_dict))


model_name = "SUFE-AIFLM-Lab/Fin-R1"
model_config = inspect_model_config(model_name, source="autoconfig")
config_to_markdown(model_config)

import os
import sqlite3
from typing import Optional, Tuple, Dict
from pprint import pprint
from dotenv import load_dotenv

import litellm

class Config:
    def __init__(self):
        load_dotenv()
        self.model1_name = os.getenv("MODEL_1", "ollama/hf.co/ernanhughes/Fin-R1-Q8_0-GGUF")
        self.model2_name = os.getenv("MODEL_2", "ollama/phi3")
        self.evaluator_model = os.getenv("EVAL_MODEL", "ollama/qwen2.5")
        self.db_path = os.getenv("DB_PATH", "fin_r1_advisory.db")
        self.debug = os.getenv("DEBUG", "true").lower() == "true"
        if self.debug:
            litellm._turn_on_debug()

def query_litellm(model_name: str, prompt: str) -> str:
    response = litellm.completion(
        model=model_name,
        messages=[{"role": "user", "content": prompt}]
    )
    return response['choices'][0]['message']['content']

def call_models(prompt: str, config: Config) -> tuple[str, str]:
    return (
        query_litellm(config.model1_name, prompt),
        query_litellm(config.model2_name, prompt)
    )

def build_comparison_prompt(question: str, response_a: str, response_b: str) -> str:
    return f"""
### Task:
You are a financial reasoning expert. Two models have provided investment advice in CoT format.
Evaluate which advice is more helpful, complete, and appropriate based on reasoning and financial knowledge.

### Instructions:
1. Assess each response based on:
- Accuracy and factual correctness
- Clarity and coherence
- Depth of explanation
- Relevance to the question
2. Assign each response a score from **0 to 10**.
3. Provide a short justification for your scoring.
---
### Question:
{question}
---
### Response A:
{response_a}
---
### Response B:
{response_b}
---
### Output Format:
Response A Score: X/10  
Response B Score: Y/10  
Winner: Response A or Response B or Tie  
Justification: <your analysis here>
"""

class UserProfile:
    def __init__(self, name, age, gender, risk_tolerance, investment_goal, investment_horizon_years, current_portfolio, economic_context):
        self.name = name
        self.age = age
        self.gender = gender
        self.risk_tolerance = risk_tolerance
        self.investment_goal = investment_goal
        self.investment_horizon_years = investment_horizon_years
        self.current_portfolio = current_portfolio
        self.economic_context = economic_context

    def to_dict(self):
        return self.__dict__

def gen_robo_request(user_profile: UserProfile) -> str:
    profile = user_profile.to_dict()
    return (
        f"<think>{profile['name']} is {profile['age']} years old with a {profile['risk_tolerance']} risk tolerance. "
        f"Goal is {profile['investment_goal']} in {profile['investment_horizon_years']} years. "
        f"Current portfolio: {profile['current_portfolio']}. "
        f"Economic context: {profile['economic_context']}."
    )

class DatabaseManager:
    def __init__(self, db_path: str):
        self.conn = sqlite3.connect(db_path)
        self._initialize_schema()

    def _initialize_schema(self):
        cursor = self.conn.cursor()
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS user_profiles (
                name TEXT PRIMARY KEY,
                age INTEGER,
                gender TEXT,
                risk_tolerance TEXT,
                investment_goal TEXT,
                horizon_years INTEGER,
                economic_context TEXT,
                current_portfolio TEXT
            )
        """)
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS advisory_results (
                user_name TEXT,
                request TEXT,
                fin_r1_output TEXT,
                model_output TEXT,
                report_prompt TEXT,
                report TEXT,
                FOREIGN KEY(user_name) REFERENCES user_profiles(name)
            )
        """)
        self.conn.commit()

    def insert_user_profile(self, profile: Dict):
        cursor = self.conn.cursor()
        cursor.execute("""
            INSERT OR REPLACE INTO user_profiles (
                name, age, gender, risk_tolerance, investment_goal,
                horizon_years, economic_context, current_portfolio
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            profile['name'], profile['age'], profile['gender'], profile['risk_tolerance'],
            profile['investment_goal'], profile['investment_horizon_years'],
            profile['economic_context'], str(profile['current_portfolio'])
        ))

    def insert_advisory_result(self, user_name: str, request: str,
                               fin_r1_output: str, model_output: str,
                               report_prompt: str, report: str):
        cursor = self.conn.cursor()
        cursor.execute("""
            INSERT INTO advisory_results (
                user_name, request, fin_r1_output, model_output, report_prompt, report
            ) VALUES (?, ?, ?, ?, ?, ?)
        """, (user_name, request, fin_r1_output, model_output, report_prompt, report))

    def commit(self):
        self.conn.commit()

    def close(self):
        self.conn.close()

def main():
    config = Config()
    db = DatabaseManager(config.db_path)

    user_profiles = [
        UserProfile(
            name="User A", age=35, gender="female", risk_tolerance="moderate",
            investment_goal="retirement", investment_horizon_years=20,
            current_portfolio={"stocks": 6000, "bonds": 300, "cash": 1000},
            economic_context="Fed is expected to raise interest rates next quarter"
        ),
        UserProfile(
            name="User B", age=25, gender="male", risk_tolerance="high",
            investment_goal="wealth_growth", investment_horizon_years=10,
            current_portfolio={"stocks": 20000, "bonds": 10000, "cash": 300000},
            economic_context="Inflation is steady and market volatility is growing"
        )
    ]

    for profile in user_profiles:
        db.insert_user_profile(profile.to_dict())

        request = gen_robo_request(profile)
        fin_r1_output, model_output = call_models(request, config)
        report_prompt = build_comparison_prompt(request, fin_r1_output, model_output)
        report = query_litellm(config.evaluator_model, report_prompt)

        db.insert_advisory_result(
            user_name=profile.name,
            request=request,
            fin_r1_output=fin_r1_output,
            model_output=model_output,
            report_prompt=report_prompt,
            report=report
        )

        print(f"\n--- Report for {profile.name} ---\n")
        print(report)

    db.commit()
    db.close()

compliance_rules = [
    "Basel III requires banks to maintain a minimum capital adequacy ratio (CAR) of 8% to ensure financial stability.",
    "Basel III mandates that the Liquidity Coverage Ratio (LCR) must be at least 100% to ensure banks can meet short-term obligations.",
    "Under Basel III, the leverage ratio must be at least 3% to prevent excessive on- and off-balance sheet leverage."
]
policy_statements = [
    "The capital adequacy ratio of the bank fell below 8% in Q2 due to increased exposure to high-risk loans.",
    "The bank’s liquidity coverage ratio dropped to 87% in the last quarter as it increased its long-term asset holdings to chase yield.",
    "The bank reported a leverage ratio of 2.5% after an aggressive expansion in derivatives trading and structured financing."
]

def generate_prompt(policy_input: str, compliance_rule: str, model: str) -> str:
    instruction = f"""
        You are a financial reasoning assistant. Read the compliance rule and the bank's policy statement, then determine whether the bank is compliant. Provide your response in Chain-of-Thought format using <think> and <answer> tags.
        Compliance Rule:
        \"\"\"{compliance_rule}\"\"\"
        Policy Statement:
        \"\"\"{policy_input}\"\"\"
        """
    return instruction

def build_comparison_prompt(policy_input: str, compliance_rule: str, output_a: str, output_b: str) -> str:
    return f"""
        You are a highly qualified financial compliance analyst with expertise in Basel III regulations.

        Two AI models were given a compliance rule and a policy statement. They were asked to reason through the scenario using a Chain-of-Thought (CoT) format and provide a final compliance assessment.

        Your task is to critically evaluate both responses and score them based on:
        1. **Regulatory accuracy**  how well the model understands and applies the compliance rule
        2. **Reasoning clarity**  how logically the model arrives at its conclusion
        3. **Financial insight**  how deep and appropriate the explanation is
        4. **Output structure**  correct use of <think> and <answer> tags (important for interpretability)
        ---
        ### Compliance Rule:
        \"\"\"{compliance_rule}\"\"\"
        ### Policy Statement:
        \"\"\"{policy_input}\"\"\"
        ---
        ### Model A Response:
        {output_a}
        ### Model B Response:
        {output_b}
        ---
        Please evaluate each model independently and respond in the following format:
        Model A Score: <score>/10  
        Justification A: <explanation of how well it reasoned, applied the rule, and used CoT formatting>
        Model B Score: <score>/10  
        Justification B: <same as above>
        Preferred Model: Model A or Model B
        Only select the preferred model if one is clearly better overall.
        """

exam_questions = [
    "A company's revenue is $500,000 and expenses are $350,000. What is the net income?",
    "An investor buys a bond for $950 and receives $1,000 at maturity in one year. What is the yield?",
    "A project requires an initial investment of $10,000 and is expected to return $2,500 annually for 5 years. What is the payback period?"
]

# --- Step 2: Shared prompt template for both models ---
def generate_exam_prompt(question: str) -> str:
    return f"""
You are a finance tutor helping a student prepare for an exam.
Answer the following question using Chain-of-Thought (CoT) reasoning format.
Wrap your reasoning in <think> tags and your final answer in <answer> tags.

Question:
"{question}"
"""

def judge_exam_answers(question, output_a, output_b):
    return f"""
    You are a finance instructor evaluating student responses to an exam question. Two models have answered using a Chain-of-Thought format.

    Question:
    "{question}"

    ---
    Model A:
    {output_a}

    Model B:
    {output_b}

    Evaluate each model on:
    1. Correctness of the answer
    2. Accuracy and completeness of the reasoning
    3. Use of <think> and <answer> tags

    Please respond in this format:

    Model A Score: <score>/10
    Justification A: <reasoning>

    Model B Score: <score>/10
    Justification B: <reasoning>

    Preferred Model: Model A or Model B
    """

risk_scenarios = [
    "An investor is heavily invested in Nvidia. A new AI paradigm called DeepSeek emerges out of China, dramatically reducing the need for GPUs. Assess the risk to Nvidia's stock.",
    "An investor holds a concentrated position in Tesla. BYD announces a new solid-state battery that doubles range, halves cost, and enables near-instant charging, removing the need for most public charging infrastructure. Analyze the potential impact on Tesla."
]

# --- Step 2: Shared prompt for both models ---
def generate_risk_prompt(scenario: str) -> str:
    return f"""
You are a financial analyst evaluating the impact of a company-specific market scenario.
Explain how this scenario might affect the investor's portfolio using Chain-of-Thought (CoT) reasoning.
Wrap your reasoning in <think> tags and provide a summary inside <answer> tags.

Scenario:
"{scenario}"
"""

def judge_risk_outputs(scenario, output_a, output_b):
    return f"""
You are a senior equity analyst comparing two CoT reasoning outputs for a company-specific risk scenario.
Evaluate which response is more insightful, realistic, and helpful for an investor.
Scenario:
"{scenario}"
---
Model A:
{output_a}
---
Model B:
{output_b}
---
Evaluate each model on:
1. Accuracy of market and company-specific reasoning
2. Clarity and insight of explanation
3. Proper structure using <think> and <answer> tags
Respond in this format:
Model A Score: <score>/10
Justification A: <reasoning>

Model B Score: <score>/10
Justification B: <reasoning>

Preferred Model: Model A or Model B
"""

kpi_scenarios = [
    {
        "kpi": "Net Income",
        "change": "dropped by 15% in Q4 2024",
        "context": "due to rising input costs and slower sales in Europe"
    },
    {
        "kpi": "Gross Margin",
        "change": "improved by 3% in Q1 2025",
        "context": "following a successful shift to in-house component manufacturing"
    }
]

def generate_kpi_prompt(scenario):
    return f"""
        You are a financial analyst preparing a quarterly report for executive stakeholders.
        Analyze the following KPI change using Chain-of-Thought (CoT) reasoning.
        Wrap your reasoning in <think> tags and summarize the implications in <answer> tags.

        KPI: {scenario['kpi']}  
        Change: {scenario['change']}  
    """

def judge_kpi_outputs(scenario, output_a, output_b):
    prompt = f"""
    You are a CFO reviewing two model-generated CoT analyses for a KPI shift.
    Evaluate which is more insightful, executive-ready, and grounded in financial reasoning.

    KPI: {scenario['kpi']}  
    Change: {scenario['change']}  
    Context: {scenario['context']}

    ---
    Model A:
    {output_a}

    Model B:
    {output_b}

    Evaluate each model on:
    1. Business relevance
    2. Reasoning clarity
    3. Correct use of <think> and <answer> tags

    Respond in this format:

    Model A Score: <score>/10
    Justification A: <reasoning>

    Model B Score: <score>/10
    Justification B: <reasoning>

    Preferred Model: Model A or Model B
    """

quant_tasks = [
    "Write Python code to calculate the Sharpe Ratio for a stock given a list of daily returns and a risk-free rate.",
    "Generate Python code to backtest a moving average crossover strategy using two different windows.",
    "Create Python code to compute Value at Risk (VaR) using historical simulation for a portfolio of returns.",
    "Write Python code to price a European call option using the Black-Scholes formula.",
    "Generate code to simulate a geometric Brownian motion for an asset price.",
    "Write Python code to calculate the duration and convexity of a bond given its cash flows and yield.",
    "Generate Monte Carlo simulation code to price a European call option.",
    "Write Python code to calculate Delta and Gamma for a European call option using the Black-Scholes model."
]

# --- Step 2: Prompt format ---
def generate_code_prompt(task: str) -> str:
    return f"""
    You are a quantitative financial developer. Write clean, documented Python code to solve the following problem:

    {task}

    Instructions:
    - Explain your approach in <think> tags.
    - Include all Python code within <code> tags.
    - Use comments to clarify logic and assumptions.
    - Ensure the code runs correctly and handles potential edge cases.
    - Prefer standard libraries like NumPy, pandas, and SciPy where applicable.
    - Avoid excessive complexity; prioritize clarity and correctness.
    """

def generate_validation_prompt(task: str, code_output: str) -> str:
    return f"""
    You are a senior quantitative engineer reviewing Python code for accuracy.
    The code was written to address the following financial task:

    """{task}"""

    Here is the model's output:
    {code_output}

    Instructions:
    1. Verify that the code correctly solves the stated task.
    2. Identify any bugs, logical flaws, or poor practices.
    3. Comment on use of financial logic, edge case handling, and numerical stability.
    4. Score the solution out of 10 for correctness and clarity.

    Respond with:
    - Score: <X>/10
    - Critique: <brief assessment>
    - Recommendations: <concrete fixes or improvements>
    """

<code>
import numpy as np
from scipy.stats import norm

def black_scholes_call(S, X, r, T, sigma):
    """
    Calculate the price of a European call option using the Black-Scholes formula.

    Parameters:
    S (float): Current stock price
    X (float): Exercise price (strike price)
    r (float): Risk-free interest rate (annualized)
    T (float): Time to expiration (years)
    sigma (float): Volatility of the underlying asset

    Returns:
    float: Price of the European call option
    """
    
    # Check for negative inputs that don't make sense in financial context
    if S < 0 or X < 0:
        raise ValueError("Stock price and strike price must be non-negative.")
    if T <= 0:
        raise ValueError("Time to expiration must be positive.")

    # Calculate d1 and d2
    d1 = (np.log(S / X) + (r + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    
    # Ensure numerical stability for extreme values of d2
    if d2 > 20:
        d2 = 20.0
    elif d2 < -20:
        d2 = -20.0
    
    # Calculate the call option price using Black-Scholes formula
    call_price = S * norm.cdf(d1) - X * np.exp(-r * T) * norm.cdf(d2)
    
    return call_price

# Example usage
if __name__ == "__main__":
    S = 100.0  # Current stock price
    X = 110.0  # Strike price
    r = 0.05   # Risk-free rate (5% annual)
    T = 1.0    # Time to expiration (1 year)
    sigma = 0.2 # Volatility (20% annual)

    try:
        call_option_price = black_scholes_call(S, X, r, T, sigma)
        print(f"The price of the European call option is: ${call_option_price:.4f}")
    except ValueError as e:
        print(e)
</code>

def test_context_limit(token_multiplier=50):
    base = "The quick brown fox jumps over the lazy dog. "
    for i in range(1, 1000):
        try:
            prompt = base * (i * token_multiplier)
            print(f"Trying length {len(prompt)}...")
            query_litellm(prompt)  # or however you call your local model
        except Exception as e:
            print(f"Failed at length {len(prompt)}: {e}")
            break

from sec_api import QueryApi
from sec_api import ExtractorApi
from dotenv import load_dotenv
import os
load_dotenv()

import os
import logging
from sec_api import QueryApi

logger = logging.getLogger(__name__)

def get_latest_filing_url(ticker: str, form_type: str = "10-K"):
    """
    Get the CIK accessionNo and url for the last filing of a from.

    Args:
        ticker (str): The stock.
        form_type (str): The form.

    Returns:
        str: The text of the section.
    """
    api_key = os.getenv("SEC_API_KEY")
    query = {
        "query": {
            "query_string": {
                "query": f'formType:"{form_type}" AND ticker:{ticker}'
            }
        },
        "from": "0",
        "size": "1",
        "sort": [{ "filedAt": { "order": "desc" } }]
    }
    try:
        queryApi = QueryApi(api_key=api_key)
        filings = queryApi.get_filings(query)
        filing = filings['filings'][0]
        accession_number = filing['accessionNo'].replace("-", "")
        cik = filing['cik']
        url = filing['linkToHtml']
        logger.info(f"CIK: {cik} Accession Number: {accession_number} Filing URL: {url}")
        return cik, accession_number, url
    except Exception as e:
        logger.error("Failed to fetch filing info", exc_info=True)
        raise

def get_section_text(filing_url: str, section: str = "1A") -> str:
    """
    Get the text of a specific section from a filing URL.

    Args:
        filing_url (str): The URL of the filing.
        section (str): The section to extract.

    Returns:
        str: The text of the section.
    """
    api_key = os.getenv("SEC_API_KEY")
    extractorApi = ExtractorApi(api_key)
    text = extractorApi.get_section(filing_url, section, "text")
    return text

import re
# --- Step 2: Chunk text on paragraphs with approximate size limit ---
def chunk_text(text, chunk_size=20000):
    paragraphs = [p.strip() for p in text.split('\n') if p.strip()]
    chunks = []
    current_chunk = ""
    for para in paragraphs:
        if len(current_chunk) + len(para) <= chunk_size:
            current_chunk += para + "\n"
        else:
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = para + "\n"
    if current_chunk:
        chunks.append(current_chunk.strip())
    return chunks

# --- Step 3: Perform sentiment analysis using Fin-R1
def analyze_sentiment_with_fin_r1(report_text: str):
    prompt = f"""
You are Fin-R1, a financial language model.
Analyze the following portion of an SEC filing and extract key sentiment and guidance.

<document>
{chunk}
</document>


Respond in Chain-of-Thought format:
- Begin with <think> for detailed reasoning
- Include a long descriptive summary
- End with a clearly labeled section: "Final Summary:" that gives a 1-2 sentence overall summary.
- End with a clearly labeled section:  "Sentiment Score:" from 0 (completely negative) to 10 (completely positive). Surround the score with <sentiment_score> tags.
Wrap everything in <answer> tags.
"""
    content = query_litellm(prompt, model_name='ollama/hf.co/ernanhughes/Fin-R1-Q8_0-GGUF')
    logger.info(f"content: {content}")  
    score = extract_sentiment_score_from_tags(content)
    final_summary = extract_final_summary(content)
    logger.info(f"score: {score}, final_summary: {final_summary}")
    return content, final_summary, score

def extract_sentiment_score_from_tags(text):
    match = re.search(r"<sentiment_score>(\d+(?:\.\d+)?)</sentiment_score>", text, re.IGNORECASE)
    res = match.group(1) if match else None
    if res is None: 
        logger.info(f"Error: score not found in {text}")
        return 5
    return float(match.group(1)) if match else None

def extract_final_summary(text):
    match = re.search(r"Final Summary:\s*(.*?)\n?(Sentiment Score:|</answer>|$)", text, re.DOTALL)
    res = match.group(1).strip() if match else None
    if res is None:
        logger.info(f"Error: final_summary not found in {text}")
        return text
    logger.info(f"final_summary: {res}")
    return res

# --- Step 4: Summarize all chunk responses ---
def summarize_all_chunks(all_summaries: list):
    combined = "\n\n".join(all_summaries)
    prompt = f"""
You are Fin-R1.
Summarize the overall sentiment and financial outlook from the following collection of analysis outputs from an SEC 10-K filing.
Focus on key trends, risks, tone, and forward-looking statements.

"{combined}"

Respond with a concise <answer> summary followed by optional <insight> sections.
"""
    return query_litellm(prompt, model_name='ollama/hf.co/ernanhughes/Fin-R1-Q8_0-GGUF')

import pandas as pd
import matplotlib.pyplot as plt

results = []
ticker = "TSLA"
form = "10-K" 
chunk_size = 20000
cik, accession_number, url = get_latest_filing_url(ticker, form)
filing_text = get_section_text(url, "1A")

logger.info(f"Processing Filing Text: {filing_text[:100]}...")
if filing_text:
    chunks = chunk_text(filing_text, chunk_size=chunk_size)
    all_summaries = []
    for idx, chunk in enumerate(chunks):
        try:
            content, summary, score = analyze_sentiment_with_fin_r1(chunk)
            all_summaries.append(summary)
            cursor.execute("""
                INSERT INTO edgar_sentiment_chunks (cik, accession, chunk_index, chunk_text, chunk_sentiment, chunk_final_sentiment, sentiment_score)
                VALUES (?, ?, ?, ?, ?, ?, ?)""",
                (cik, accession_number, idx, chunk, content, summary, score))
            conn.commit()
        except Exception as e:
            logger.info(f"Error analyzing chunk: {e}")
    full_summary = summarize_all_chunks(all_summaries)
    cursor.execute("""
    INSERT INTO edgar_sentiment (cik, accession, sentiment_summary)
    VALUES (?, ?, ?)""", (cik, accession_number, full_summary))
    conn.commit()
    results.append({"cik": cik, "summary": full_summary})
conn.close()