Update app.py

app.py

@@ -1,4 +1,4 @@
-import logging
+mport logging
 import os
 import requests
 from dotenv import load_dotenv
@@ -28,102 +28,51 @@ 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:
-    logger.error("API keys are not set properly.")
     st.error("API keys for OpenAI and SERPER must be set in the .env file.")
     st.stop()
-else:
-    logger.info("API keys loaded successfully.")
 
 # Initialize OpenAI client
-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}")
-    st.error(f"Error initializing OpenAI client: {e}")
-    st.stop()
+openai.api_key = openai_api_key
 
 # Load knowledge base
 def load_knowledge_base():
-    try:
-        loader = TextLoader("./data_source/time_to_rethink_trust_book.md")
-        documents = loader.load()
-        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-        docs = text_splitter.split_documents(documents)
-        return docs
-    except Exception as e:
-        logger.error(f"Error loading knowledge base: {e}")
-        st.error(f"Error loading knowledge base: {e}")
-        st.stop()
+    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)
 
 knowledge_base = load_knowledge_base()
 
 # Initialize embeddings and FAISS index
-try:
-    embeddings = OpenAIEmbeddings()
-    db = FAISS.from_documents(knowledge_base, embeddings)
-except Exception as e:
-    logger.error(f"Error initializing FAISS index: {e}")
-    st.error(f"Error initializing FAISS index: {e}")
-    st.stop()
+embeddings = OpenAIEmbeddings()
+db = FAISS.from_documents(knowledge_base, embeddings)
 
 # Define search function for knowledge base
 def search_knowledge_base(query):
-    try:
-        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"]
+    return db.similarity_search(query)
 
 # 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})
-        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"General Error: {e}")
-        return ["Error occurred during Google search"]
+    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", [])]
 
 # RAG response function
 def rag_response(query):
-    try:
-        retrieved_docs = search_knowledge_base(query)
-        context = "\n".join(doc.page_content for doc in retrieved_docs)
-        prompt = f"Context:\n{context}\n\nQuestion: {query}\nAnswer:"
-        llm = ChatOpenAI(model="gpt-4o", temperature=0.5, api_key=openai_api_key)
-        response = llm.invoke(prompt)
-        return response.content
-    except Exception as e:
-        logger.error(f"Error generating RAG response: {e}")
-        return "Error occurred during RAG response generation"
+    retrieved_docs = search_knowledge_base(query)
+    context = "\n".join(doc.page_content for doc in retrieved_docs)
+    prompt = f"Context:\n{context}\n\nQuestion: {query}\nAnswer:"
+    llm = ChatOpenAI(model="gpt-4o", temperature=0.5, api_key=openai_api_key)
+    response = llm.invoke(prompt)
+    return response.content
 
 # Define tools using LangChain's `tool` decorator
 @tool
 def knowledge_base_tool(query: str):
-    """
-    Tool function to query the knowledge base and retrieve a response.
-    Args:
-        query (str): The query to search the knowledge base.
-    Returns:
-        str: The response retrieved from the knowledge base.
-    """
     return rag_response(query)
 
 @tool
 def google_search_tool(query: str):
-    """
-    Tool function to perform a Google search using the SERPER API.
-    Args:
-        query (str): The query to search on Google.
-    Returns:
-        list: List of snippets extracted from search results.
-    """
     return google_search(query)
 
 tools = [knowledge_base_tool, google_search_tool]
@@ -144,62 +93,39 @@ prompt_template = ChatPromptTemplate.from_messages(
     ]
 )
 
-# Create Langchain Agent with specific model and temperature
-try:
-    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(f"Error creating Langchain Agent: {e}")
-    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"]),
-            "chat_history": lambda x: x["chat_history"],
-        }
-        | prompt_template
-        | llm_with_tools
-        | OpenAIToolsAgentOutputParser()
-    )
+llm = ChatOpenAI(model="gpt-4o", temperature=0.5)
+llm_with_tools = llm.bind_tools(tools)
+
+agent = (
+    {
+        "input": lambda x: x["input"],
+        "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()
+)
 
-    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-except Exception as e:
-    logger.error(f"Error defining agent pipeline: {e}")
-    st.error(f"Error defining agent pipeline: {e}")
-    st.stop()
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
 # 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"
+    output = agent_executor.invoke({"input": message, "chat_history": chat_history})
+    chat_history.extend(
+        [
+            HumanMessage(content=message),
+            AIMessage(content=output["output"]),
+        ]
+    )
+    return output["output"]
 
 # Streamlit app
+st.title("Chatbot")
 
-
-# Create input field for user message
 user_input = st.text_input("You:", "")
-
-# Create a button for submitting the message
 if st.button("Submit"):
     if user_input:
         response = chatbot_response(user_input, chat_history)