Update app.py

app.py

@@ -1,46 +1,69 @@
 import streamlit as st
-from gpt_researcher import GPTResearcher
-import nest_asyncio
+import openai
 import asyncio
-import os
+import re
 
-# Access secrets
-openai_api_key = st.secrets["OPENAI_API_KEY"]
-tavily_api_key = st.secrets["TAVILY_API_KEY"]
+# Apply the asyncio patch if required
+import nest_asyncio
 
-# Apply the asyncio patch from nest_asyncio if required
 nest_asyncio.apply()
 
-# Set the document path environment variable
-os.environ["DOC_PATH"] = "./local"  # Path to the folder with documents
+# OpenAI Client Initialization with API Key from Streamlit secrets
+client = openai.OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
 
-# Constants
-REPORT_TYPE = "research_report"
+# Assistant ID
+ASSISTANT_ID = "asst_jNEWFnROZxSI8ZnL9WDI2yCp"
 
 
-# Define the asynchronous function to fetch the report
-async def fetch_report(query: str, report_type: str) -> str:
+# Define the asynchronous function to interact with the OpenAI assistant
+async def fetch_report(query: str) -> str:
     """
-    Fetch a research report based on the provided query and report type.
-    Research is conducted on a local document.
+    Interact with OpenAI Assistant to generate a report based on the provided query.
+    Clean the text by removing source annotations.
     """
     try:
-        researcher = GPTResearcher(
-            query=query, report_type=report_type, report_source="local"
+        # Create a Thread with an initial user message
+        thread = client.beta.threads.create(
+            messages=[{"role": "user", "content": query}]
+        )
+
+        # Start the Assistant
+        run = client.beta.threads.runs.create(
+            thread_id=thread.id, assistant_id=ASSISTANT_ID
         )
-        research_result = await researcher.conduct_research()
-        report = await researcher.write_report()
-        return report
+
+        # Wait for the run to complete
+        while run.status != "completed":
+            run = client.beta.threads.runs.retrieve(thread_id=thread.id, run_id=run.id)
+            await asyncio.sleep(5)  # Delay to prevent excessive polling
+
+        # Retrieve the Messages added by the Assistant to the Thread
+        thread_messages = client.beta.threads.messages.list(thread.id)
+
+        # Initialize an empty string to collect the cleaned report
+        report = []
+        for message in thread_messages.data:
+            if message.role == "assistant":
+                for content_block in message.content:
+                    if "text" in dir(content_block) and "value" in dir(
+                        content_block.text
+                    ):
+                        # Remove source citations
+                        cleaned_text = re.sub(
+                            r"【\d+:\d+†source】", "", content_block.text.value
+                        )
+                        report.append(cleaned_text)
+        return "\n".join(report)
     except Exception as e:
         return f"Error during research: {str(e)}"
 
 
-def run_report_generation(query, report_type):
+def run_report_generation(query):
     """
     Helper function to run async fetch_report function.
     """
     loop = asyncio.get_event_loop()
-    report = loop.run_until_complete(fetch_report(query, report_type))
+    report = loop.run_until_complete(fetch_report(query))
     return report
 
 
@@ -60,8 +83,8 @@ if st.button("Generate Report"):
         st.warning("Please enter a query to generate a report.")
     else:
         with st.spinner("Generating report..."):
-            report = run_report_generation(query, REPORT_TYPE)
-            if "Error during research" not in report:
+            report = run_report_generation(query)
+            if report:
                 st.success("Report generated successfully!")
                 st.write(report)  # Display the report in the app
                 # Create a download button for the report
@@ -72,4 +95,4 @@ if st.button("Generate Report"):
                     mime="text/plain",
                 )
             else:
-                st.error(report)  # Show the error message if any
+                st.error("Failed to generate report or report is empty.")