Update app.py

app.py

@@ -1,48 +1,24 @@
-import logging
 import os
-import requests
-from dotenv import load_dotenv
-import gradio as gr
+import streamlit as st
 import openai
-from langchain_openai import ChatOpenAI
-from langchain_community.vectorstores import FAISS
-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_core.messages import AIMessage, HumanMessage
-from langchain_community.document_loaders import TextLoader
-from langchain_text_splitters import CharacterTextSplitter
-import serpapi
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores.faiss import FAISS
+from langchain.document_loaders import TextLoader
+from langchain.chains import LLMChain
+from langchain.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage, AIMessage
+from serpapi import GoogleSearch
+import logging
 
-# Initialize logging
-logging.basicConfig(level=logging.INFO)
+# Configure logging
+logging.basicConfig(level=logging.ERROR)
 logger = logging.getLogger(__name__)
 
-# Load environment variables from .env file
-load_dotenv()
-
-# Define and validate API keys
+# Load environment variables
 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.")
-    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
-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
-
+openai.api_key = openai_api_key
 
 # Load knowledge base
 def load_knowledge_base():
@@ -56,7 +32,6 @@ def load_knowledge_base():
         logger.error(f"Error loading knowledge base: {e}")
         raise e
 
-
 knowledge_base = load_knowledge_base()
 
 # Initialize embeddings and FAISS index
@@ -67,7 +42,6 @@ except Exception as e:
     logger.error(f"Error initializing FAISS index: {e}")
     raise e
 
-
 # Define search function for knowledge base
 def search_knowledge_base(query):
     try:
@@ -77,17 +51,11 @@ def search_knowledge_base(query):
         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,
-            }
-        )
+        search_client = GoogleSearch({"q": query, "api_key": serper_api_key})
+        results = search_client.get_dict()
         snippets = [result["snippet"] for result in results.get("organic_results", [])]
         return snippets
     except requests.exceptions.HTTPError as http_err:
@@ -97,149 +65,47 @@ def google_search(query):
         logger.error(f"General Error: {e}")
         return ["Error occurred during Google search"]
 
-
 # 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)
+        google_results = google_search(query)
+        combined_context = context + "\n" + "\n".join(google_results)
+
+        prompt = f"Context:\n{combined_context}\n\nQuestion: {query}\nAnswer:"
+        llm = ChatOpenAI(model="gpt-4", 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"
 
-
-# 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,
-]
-
-# Create the prompt template
-prompt_message = """
-Act as an expert copywriter who specializes in creating compelling marketing copy using AI technologies.
-Engage in a friendly and informative conversation based on the knowledge base.
-Only proceed to create sales materials when the user explicitly requests it.
-Work together with the user to update the outcome of the sales material.
-"""
-prompt_template = ChatPromptTemplate.from_messages(
-    [
-        ("system", prompt_message),
-        MessagesPlaceholder(variable_name="chat_history"),
-        ("user", "{input}"),
-        MessagesPlaceholder(variable_name="agent_scratchpad"),
-    ]
-)
-
-# 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}")
-
-# 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()
-    )
-
-    # 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}")
-
 # Initialize chat history
-chat_history = []
-
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
 
-def chatbot_response(message, history):
+# Function to handle chat responses
+def chatbot_response(message):
     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"]
+        response = rag_response(message)
+        st.session_state.chat_history.append(HumanMessage(content=message))
+        st.session_state.chat_history.append(AIMessage(content=response))
+        return response
     except Exception as e:
         logger.error(f"Error generating chatbot response: {e}")
         return "Error occurred during response generation"
 
+# Streamlit UI setup
+st.title("Instant Insight-2-Action")
 
-# # 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()
+prompt = st.chat_input("Type your prompt here...", key="unique_chat_input_key")
+if prompt:
+    response = chatbot_response(prompt)
 
-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
+# Display chat history
+for msg in st.session_state.chat_history:
+    if isinstance(msg, HumanMessage):
+        st.write(f"You: {msg.content}")
+    elif isinstance(msg, AIMessage):
+        st.write(f"Bot: {msg.content}")