Update app.py

app.py

@@ -1,7 +1,8 @@
-
 import logging
 import os
+import requests
 from dotenv import load_dotenv
+import gradio as gr
 import openai
 from langchain_openai import ChatOpenAI
 from langchain_community.vectorstores import FAISS
@@ -9,12 +10,13 @@ from langchain_openai import OpenAIEmbeddings
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain.agents import tool, AgentExecutor
 from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
-from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
+from langchain.agents.format_scratchpad.openai_tools import (
+    format_to_openai_tool_messages,
+)
 from langchain_core.messages import AIMessage, HumanMessage
 from langchain_community.document_loaders import TextLoader
 from langchain_text_splitters import CharacterTextSplitter
 import serpapi
-import streamlit as st
 
 # Initialize logging
 logging.basicConfig(level=logging.INFO)
@@ -28,12 +30,19 @@ openai_api_key = os.getenv("OPENAI_API_KEY")
 serper_api_key = os.getenv("SERPER_API_KEY")
 
 if not openai_api_key or not serper_api_key:
-    st.error("API keys for OpenAI and SERPER must be set in the .env file.")
-    logger.error("API keys for OpenAI and SERPER must be set in the .env file.")
-    st.stop()
+    logger.error("API keys are not set properly.")
+    raise ValueError("API keys for OpenAI and SERPER must be set in the .env file.")
+else:
+    logger.info("API keys loaded successfully.")
 
 # Initialize OpenAI client
-openai.api_key = openai_api_key
+try:
+    openai.api_key = openai_api_key
+    logger.info("OpenAI client initialized successfully.")
+except Exception as e:
+    logger.error(f"Error initializing OpenAI client: {e}")
+    raise e
+
 
 # Load knowledge base
 def load_knowledge_base():
@@ -41,11 +50,12 @@ def load_knowledge_base():
         loader = TextLoader("./data_source/time_to_rethink_trust_book.md")
         documents = loader.load()
         text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-        return text_splitter.split_documents(documents)
+        docs = text_splitter.split_documents(documents)
+        return docs
     except Exception as e:
         logger.error(f"Error loading knowledge base: {e}")
-        st.error("Error loading knowledge base.")
-        st.stop()
+        raise e
+
 
 knowledge_base = load_knowledge_base()
 
@@ -55,30 +65,39 @@ try:
     db = FAISS.from_documents(knowledge_base, embeddings)
 except Exception as e:
     logger.error(f"Error initializing FAISS index: {e}")
-    st.error("Error initializing FAISS index.")
-    st.stop()
+    raise e
+
 
 # Define search function for knowledge base
 def search_knowledge_base(query):
     try:
-        return db.similarity_search(query)
+        output = db.similarity_search(query)
+        return output
     except Exception as e:
         logger.error(f"Error searching knowledge base: {e}")
         return ["Error occurred during knowledge base search"]
 
+
 # SERPER API Google Search function
 def google_search(query):
     try:
         search_client = serpapi.Client(api_key=serper_api_key)
-        results = search_client.search({"engine": "google", "q": query})
-        return [result["snippet"] for result in results.get("organic_results", [])]
+        results = search_client.search(
+            {
+                "engine": "google",
+                "q": query,
+            }
+        )
+        snippets = [result["snippet"] for result in results.get("organic_results", [])]
+        return snippets
     except requests.exceptions.HTTPError as http_err:
         logger.error(f"HTTP error occurred: {http_err}")
         return ["HTTP error occurred during Google search"]
     except Exception as e:
-        logger.error(f"Error during Google search: {e}")
+        logger.error(f"General Error: {e}")
         return ["Error occurred during Google search"]
 
+
 # RAG response function
 def rag_response(query):
     try:
@@ -92,6 +111,7 @@ def rag_response(query):
         logger.error(f"Error generating RAG response: {e}")
         return "Error occurred during RAG response generation"
 
+
 # Define tools using LangChain's `tool` decorator
 @tool
 def knowledge_base_tool(query: str):
@@ -140,54 +160,86 @@ prompt_template = ChatPromptTemplate.from_messages(
 
 # Create Langchain Agent with specific model and temperature
 try:
-    llm = ChatOpenAI(model="gpt-4o", temperature=0.5)
+    llm = ChatOpenAI(model="gpt-4o", temperature=0.5)  # Set temperature to 0.5
     llm_with_tools = llm.bind_tools(tools)
 except Exception as e:
     logger.error(f"Error creating Langchain Agent: {e}")
-    st.error("Error creating Langchain Agent.")
-    st.stop()
 
 # Define the agent pipeline to handle the conversation flow
 try:
     agent = (
         {
             "input": lambda x: x["input"],
-            "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]),
+            "agent_scratchpad": lambda x: format_to_openai_tool_messages(
+                x["intermediate_steps"]
+            ),
             "chat_history": lambda x: x["chat_history"],
         }
         | prompt_template
         | llm_with_tools
         | OpenAIToolsAgentOutputParser()
     )
+
+    # Instantiate an AgentExecutor to execute the defined agent pipeline
     agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 except Exception as e:
     logger.error(f"Error defining agent pipeline: {e}")
-    st.error("Error defining agent pipeline.")
-    st.stop()
 
 # Initialize chat history
 chat_history = []
 
+
 def chatbot_response(message, history):
     try:
+        # Generate response using the agent executor
         output = agent_executor.invoke({"input": message, "chat_history": chat_history})
+
+        # Save the interaction context
         chat_history.extend(
             [
                 HumanMessage(content=message),
                 AIMessage(content=output["output"]),
             ]
         )
+
         return output["output"]
     except Exception as e:
         logger.error(f"Error generating chatbot response: {e}")
         return "Error occurred during response generation"
 
-# Streamlit app
 
-user_input = st.text_input("You:", "")
-if st.button("Submit"):
-    if user_input:
-        response = chatbot_response(user_input, chat_history)
-        st.write("AI:", response)
-    else:
-        st.warning("Please enter a message.")
+# # Define CSS for Gradio interface
+# CSS = """
+# .contain { display: flex; flex-direction: column; height: 100vh; }
+# #component-0 { height: 90%; }
+# """
+
+# # Gradio interface
+# with gr.Blocks(css=CSS) as demo:
+
+submit_button = gr.Button("Submit")
+
+bot = gr.Chatbot()
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        "<span style='font-size:20px; font-weight:bold;'>Instant Insight-2-Action</span>",
+        visible=True,
+    )
+
+    chatbot = gr.ChatInterface(
+        fn=chatbot_response,
+        stop_btn=None,
+        retry_btn=None,
+        undo_btn=None,
+        clear_btn=None,
+        submit_btn=submit_button,
+        chatbot=bot,
+    )
+
+# Launch the Gradio app
+try:
+    demo.launch(server_name="0.0.0.0")
+except Exception as e:
+    logger.error(f"Error launching Gradio app: {e}")
+    raise e