Update app.py

app.py

@@ -2,6 +2,7 @@ import os
 import nltk
 import requests
 import datetime
+
 # Use a directory within the user's home directory
 nltk_data_dir = os.path.expanduser("~/.nltk_data")
 os.makedirs(nltk_data_dir, exist_ok=True)
@@ -9,6 +10,7 @@ nltk.data.path.append(nltk_data_dir)
 
 # Download NLTK data
 nltk.download('punkt', download_dir=nltk_data_dir, quiet=True)
+
 import chainlit as cl
 from llama_index.core import VectorStoreIndex, Document
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
@@ -21,15 +23,15 @@ import pandas as pd
 
 load_dotenv()
 
-# Fetch the API keys from environment variables
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 FMP_API_KEY = os.getenv("FMP_API_KEY")
 
-# Initialize models
+print("DEBUG: GROQ_API_KEY ->", GROQ_API_KEY)
+print("DEBUG: FMP_API_KEY ->", FMP_API_KEY)
+
 embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
 llm = Groq(model="llama3-70b-8192", api_key=GROQ_API_KEY)
 
-# Create service context
 service_context = ServiceContext.from_defaults(
     llm=llm,
     embed_model=embed_model,
@@ -37,27 +39,26 @@ service_context = ServiceContext.from_defaults(
 )
 
 def fetch_annual_report_10k(symbol: str) -> str:
-    """
-    Fetch the latest annual report on Form 10-K for a specific company.
-    Args:
-    - symbol (str): The stock ticker symbol (e.g., 'AAPL').
-    Returns:
-    - str: The entire JSON response as a string or an error message.
-    """
+    print("DEBUG: fetch_annual_report_10k called with symbol:", symbol)
     current_year = datetime.datetime.now().year
     url = f"https://financialmodelingprep.com/api/v4/financial-reports-json?symbol={symbol}&year={current_year}&period=FY&apikey={FMP_API_KEY}"
+    print("DEBUG: URL ->", url)
     try:
         response = requests.get(url, timeout=10)
         response.raise_for_status()
-        return response.text
+        text_data = response.text
+        print("DEBUG: 10-K API response length ->", len(text_data))
+        return text_data
     except requests.exceptions.HTTPError as http_err:
+        print("DEBUG: HTTPError ->", http_err)
         return f"HTTP error occurred: {http_err}"
     except requests.exceptions.RequestException as req_err:
+        print("DEBUG: RequestError ->", req_err)
         return f"Request error occurred: {req_err}"
     except Exception as err:
+        print("DEBUG: UnexpectedError ->", err)
         return f"An unexpected error occurred: {err}"
 
-# Prompts
 summary_prompt = (
     "You are a world-class financial analyst with extensive experience analyzing annual reports. "
     "Provide a comprehensive summary of the 10-K report. Focus on Strategic Insights, Key Financial Figures, and Risk Factors. "
@@ -73,7 +74,6 @@ question_prompt = (
 
 @cl.on_chat_start
 async def on_chat_start():
-    # Ask user for the ticker symbol
     ticker_response = await cl.AskUserMessage(
         content=(
             "This tool is designed to analyze 10-K annual reports for publicly traded companies. "
@@ -83,82 +83,83 @@ async def on_chat_start():
         )
     ).send()
 
-    # Check user input
+    print("DEBUG: ticker_response ->", ticker_response)
+
     if not ticker_response or 'content' not in ticker_response:
         await cl.Message(content="No ticker symbol provided. Please enter a valid ticker symbol to proceed.").send()
         return
 
-    # Process user ticker
     ticker_symbol = ticker_response['content'].upper()
+    print("DEBUG: ticker_symbol ->", ticker_symbol)
 
     msg = cl.Message(content=f"Retrieving the latest 10-K report for {ticker_symbol}...")
     await msg.send()
 
     try:
-        # Fetch the 10-K report
         annual_report_text = fetch_annual_report_10k(ticker_symbol)
+        print("DEBUG: annual_report_text snippet ->", annual_report_text[:200])
 
-        # Check if an error or empty result is returned
         if annual_report_text.startswith("HTTP error") or \
            annual_report_text.startswith("Request error") or \
            annual_report_text.startswith("An unexpected error occurred"):
             await cl.Message(content=annual_report_text).send()
             return
 
-        # Create a Document object with the raw JSON response
         document = Document(text=annual_report_text, metadata={"company": ticker_symbol})
+        print("DEBUG: Document created for ticker:", ticker_symbol)
 
-        # Build the index
-        index = VectorStoreIndex.from_documents(
-            [document],
-            service_context=service_context
-        )
+        index = VectorStoreIndex.from_documents([document], service_context=service_context)
+        print("DEBUG: Index built for ticker:", ticker_symbol)
 
-        # Store the index in the user session
         cl.user_session.set("index", index)
-
-        # Run summary prompt
         query_engine = index.as_query_engine()
+
         summary_response = await cl.make_async(query_engine.query)(summary_prompt)
+        print("DEBUG: summary_response snippet ->", summary_response[:200])
+
         await cl.Message(content=f"**Summary:**\n{summary_response}").send()
 
-        # Run questions prompt
         questions_response = await cl.make_async(query_engine.query)(question_prompt)
+        print("DEBUG: questions_response snippet ->", questions_response[:200])
+
         questions_format = str(questions_response).split('\n')
         relevant_questions = [
             question.strip() for question in questions_format
             if question.strip() and question.strip()[0].isdigit()
         ]
 
-        # Display and answer each generated question
         await cl.Message(content="Generated strategic questions and answers:").send()
         for question in relevant_questions:
             await cl.Message(content=f"**{question}**").send()
             answer = await cl.make_async(query_engine.query)(question)
+            print(f"DEBUG: Answer for '{question[:30]}' snippet ->", answer[:200])
             await cl.Message(content=f"**Answer:**\n{answer}").send()
 
         msg.content = "Processing done. You can now ask more questions about the 10-K report!"
         await msg.update()
 
     except Exception as e:
+        print("DEBUG: Exception ->", str(e))
         await cl.Message(content=f"An error occurred during processing: {str(e)}").send()
 
 @cl.on_message
 async def main(message: cl.Message):
-    # Retrieve the index from user session
     index = cl.user_session.get("index")
-    
-    # If there's no index, the user hasn't entered a ticker yet
+    print("DEBUG: user_session index ->", bool(index))
+
     if index is None:
         await cl.Message(content="Please provide a ticker symbol first before asking questions.").send()
         return
 
-    # Query the index
     query_engine = index.as_query_engine()
-    response = await cl.make_async(query_engine.query)(message.content)
+    user_query = message.content
+    print("DEBUG: user_query ->", user_query)
+
+    response = await cl.make_async(query_engine.query)(user_query)
+    print("DEBUG: response snippet ->", str(response)[:200])
 
-    # Stream back the response
     response_message = cl.Message(content="")
     for token in str(response):
         await response_message.stream_token(token=token)
+
     await response_message.send()