Agent Strategies for Financial Applications with Fin-R1

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

def get_latest_filing_url(ticker: str, form_type: str = "10-K") -> str:
    api_key = os.getenv("SEC_API_KEY")
    query = {
        "query": {You so support you can get the data take care A multiple assumptions
            "query_string": {
                "query": f"formType:\"{form_type}\" AND ticker:{ticker}"
            }
        },
        "from": "0",
        "size": "1",
        "sort": [{ "filedAt": { "order": "desc" } }]
    }    
    queryApi = QueryApi(api_key=api_key)
    filings = queryApi.get_filings(query)
    accession_number = filings['filings'][0]['accessionNo']
    logger.info(f"Accession number: {accession_number}")    
    cik = filings['filings'][0]['cik']
    logger.info(f"CIK: {cik}")
    url = filings['filings'][0]['linkToHtml']
    return cik, accession_number, url

import requests
import json

_, _, url = get_latest_filing_url("TSLA")

xbrl_converter_api_endpoint = "https://api.sec-api.io/xbrl-to-json"
api_key = os.getenv("SEC_API_KEY")
final_url = xbrl_converter_api_endpoint + "?htm-url=" + url + "&token=" + api_key

# make request to the API
response = requests.get(final_url)

# load JSON into memory
xbrl_json = json.loads(response.text)

import pandas as pd
# convert XBRL-JSON of income statement to pandas dataframe
def get_income_statement(xbrl_json):
    income_statement_store = {}

    # iterate over each US GAAP item in the income statement
    for usGaapItem in xbrl_json['StatementsOfIncome']:
        values = []
        indicies = []

        for fact in xbrl_json['StatementsOfIncome'][usGaapItem]:
            # only consider items without segment. not required for our analysis.
            if 'segment' not in fact:
                index = fact['period']['startDate'] + '-' + fact['period']['endDate']
                # ensure no index duplicates are created
                if index not in indicies:
                    values.append(fact['value'])
                    indicies.append(index)                    

        income_statement_store[usGaapItem] = pd.Series(values, index=indicies) 
    income_statement = pd.DataFrame(income_statement_store)
    return income_statement

# convert XBRL-JSON of balance sheet to pandas dataframe
def get_balance_sheet(xbrl_json):
    balance_sheet_store = {}

    for usGaapItem in xbrl_json['BalanceSheets']:
        values = []
        indicies = []

        for fact in xbrl_json['BalanceSheets'][usGaapItem]:
            # only consider items without segment.
            if 'segment' not in fact:
                index = fact['period']['instant']

                # avoid duplicate indicies with same values
                if index in indicies:
                    continue
                    
                # add 0 if value is nil
                if "value" not in fact:
                    values.append(0)
                else:
                    values.append(fact['value'])

                indicies.append(index)                    

            balance_sheet_store[usGaapItem] = pd.Series(values, index=indicies) 

    balance_sheet = pd.DataFrame(balance_sheet_store)
    return balance_sheet

def get_cash_flow_statement(xbrl_json):
    cash_flows_store = {}

    for usGaapItem in xbrl_json['StatementsOfCashFlows']:
        values = []
        indicies = []

        for fact in xbrl_json['StatementsOfCashFlows'][usGaapItem]:        
            # only consider items without segment.
            if 'segment' not in fact:
                # check if date instant or date range is present
                if "instant" in fact['period']:
                    index = fact['period']['instant']
                else:
                    index = fact['period']['startDate'] + '-' + fact['period']['endDate']

                # avoid duplicate indicies with same values
                if index in indicies:
                    continue

                if "value" not in fact:
                    values.append(0)
                else:
                    values.append(fact['value'])

                indicies.append(index)                    

        cash_flows_store[usGaapItem] = pd.Series(values, index=indicies) 


    cash_flows = pd.DataFrame(cash_flows_store)
    return cash_flows

def clean_financial_df(df):
    """
    Cleans a DataFrame where:
    - The index represents a 'date' column so we merge this back to the dataframe as data.
    - The date colum is the start and end date merged so we split to two new columns
    - Drop the date
    - Reorder
    - Fill the NaN with 0
      Returns a cleaned, ready-to-use DataFrame.
    """
    # Step 1: Move index to a column
    df = df.reset_index()
    df = df.rename(columns={"index": "date"})
    # Step 3: Parse date column
    df['start_date'] = df['date'].str[:10]
    df['end_date'] = df['date'].str[-10:]
    df = df.drop(columns=['date'])
    # List the columns you want first
    first_cols = ['start_date', 'end_date']
    # Add the rest of the columns (excluding the first ones to avoid duplication)
    remaining_cols = [col for col in df.columns if col not in first_cols]

    # Reorder the DataFrame
    df = df[first_cols + remaining_cols]
    return df.fillna(0)  

import sqlite3

income_statement = get_income_statement(xbrl_json)
income_statement = clean_financial_df(income_statement)
income_statement
...

# Connect to SQLite database (or create one)
conn = sqlite3.connect("financial_data.db")

# Write the dataframe to a new table
income_statement.to_sql("income_statement", conn, if_exists="replace", index=False)
balance_sheet.to_sql("balance_sheet", conn, if_exists="replace", index=False)
cash_flow.to_sql("cash_flow", conn, if_exists="replace", index=False)

# Close the connection
conn.close()

task = "Create a retirement plan for a 35-year-old earning €80,000/year."

agent.call_tool("compound_interest", principal=10000, rate=0.05, years=10)

feedback = agent.get_feedback("Recommended investing all savings into crypto.")

agent.memory.remember("risk_profile", "moderate")

agent.run_task("Find latest 10-K for Tesla from sec.gov")

agent.generate_code("Build a Python function that computes Sharpe Ratio")

agent.design_experiment("Test correlation between FED rates and NASDAQ performance")

User: "I want to retire by 60 with €1M saved. Can you help me plan?"

class ComplianceAgent:
    def __init__(self, fin_r1, compliance_rules):
        self.fin_r1 = fin_r1
        self.rules = compliance_rules

    def review_advice(self, user_profile, query):
        advice = self.fin_r1.query(user_profile, query)
        is_compliant = self.evaluate_against_rules(advice, user_profile)
        return {
            "advice": advice,
            "compliance": "✅" if is_compliant else "⚠️ Not suitable"
        }

    def evaluate_against_rules(self, advice, profile):
        if profile['risk'] == "conservative" and "crypto" in advice.lower():
            return False
        return True