Update app.py

app.py

@@ -1,12 +1,8 @@
-import openai
-import streamlit as st
-import smtplib
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-import os
-import asyncio
 import logging
+import os
+import requests
 from dotenv import load_dotenv
+import openai
 from langchain_openai import ChatOpenAI
 from langchain_community.vectorstores import FAISS
 from langchain_openai import OpenAIEmbeddings
@@ -17,6 +13,8 @@ from langchain.agents.format_scratchpad.openai_tools import format_to_openai_too
 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)
@@ -25,97 +23,161 @@ logger = logging.getLogger(__name__)
 # Load environment variables from .env file
 load_dotenv()
 
-# API Keys
+# Define and validate API keys
 openai_api_key = os.getenv("OPENAI_API_KEY")
-EMAIL_ADDRESS = os.getenv("EMAIL_ADDRESS")
-EMAIL_PASSWORD = os.getenv("EMAIL_PASSWORD")
-SMTP_SERVER = "mail.privateemail.com"
-SMTP_PORT = 587
+serper_api_key = os.getenv("SERPER_API_KEY")
 
-# Validate API keys
-if not openai_api_key:
-    st.error("API keys are not set properly.")
-    raise ValueError("API key for OpenAI must be set in the .env file.")
+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()
 
 # Initialize OpenAI client
-openai.api_key = openai_api_key
-
-# Define email function
-def send_feedback_email(name, email, feedback):
-    msg = MIMEMultipart()
-    msg['From'] = EMAIL_ADDRESS
-    msg['To'] = "wajahat698@gmail.com"
-    msg['Subject'] = "Feedback"
-    msg.attach(MIMEText(feedback, 'plain'))
-    
+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()
+
+# Load knowledge base
+def load_knowledge_base():
     try:
-        with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
-            server.starttls()
-            server.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
-            server.sendmail(EMAIL_ADDRESS, msg['To'], msg.as_string())
+        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:
-        st.error(f"Error sending email: {e}")
+        logger.error(f"Error loading knowledge base: {e}")
+        st.error(f"Error loading knowledge base: {e}")
+        st.stop()
 
-# Function to load and split knowledge base documents
-@st.cache_resource
-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)
+knowledge_base = load_knowledge_base()
 
 # Initialize embeddings and FAISS index
-knowledge_base = load_knowledge_base()
-embeddings = OpenAIEmbeddings()
-db = FAISS.from_documents(knowledge_base, embeddings)
+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()
+
+# 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"]
+
+# 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"]
 
-# Define RAG response generation
+# RAG response function
 def rag_response(query):
-    retrieved_docs = db.similarity_search(query)
-    context = "\n".join(doc.page_content for doc in retrieved_docs)
-    prompt = f"Context:\n{context}\n\nQuestion: {query}\nAnswer:"
+    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"
+
+# Define tools using LangChain's `tool` decorator
+@tool
+def knowledge_base_tool(query: str):
+    return rag_response(query)
+
+@tool
+def google_search_tool(query: str):
+    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)
-    response = llm.invoke(prompt)
-    return response.content
-
-# Define chatbot interaction
-async def chatbot_response_async(message, history):
-    message += " Always be specific with facts, examples, names like programs and locations, and dollar numbers."
-    output = await asyncio.to_thread(agent_executor.invoke, {"input": message, "chat_history": history})
-    return {"response": output["output"]}
-
-# Sidebar with feedback form
-with st.sidebar.form(key='feedback_form'):
-    st.image("Trust Logic_Wheel_RGB_Standard.png")
-    st.header("Let's create something great.")
-    st.markdown("TrustAI® helps you identify reasons why your audience can trust you.")
-    
-    feedback_name = st.text_input("Name")
-    feedback_email_input = st.text_input("Email")
-    feedback_text = st.text_area("Feedback")
-
-    if st.form_submit_button("Submit Feedback"):
-        if feedback_name and feedback_email_input and feedback_text:
-            send_feedback_email(feedback_name, feedback_email_input, feedback_text)
-            st.success("Thank you for your feedback!")
-        else:
-            st.error("Please fill in all fields.")
-
-# Chat interface
-if 'chat_started' not in st.session_state:
-    st.session_state.chat_started = False
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-
-if not st.session_state.chat_started:
-    st.markdown("<h1 style='text-align: center;'>How can I help you today?</h1>", unsafe_allow_html=True)
-
-if prompt := st.chat_input("Type your prompt here"):
-    st.session_state.chat_started = True
-    st.session_state.chat_history.append({"role": "user", "content": prompt})
-    response = asyncio.run(chatbot_response_async(prompt, st.session_state.chat_history))
-    st.session_state.chat_history.append({"role": "assistant", "content": response["response"]})
-
-if st.session_state.chat_started:
-    for msg in st.session_state.chat_history:
-        st.chat_message(msg["role"]).write(msg["content"])
+    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()
+    )
+
+    # 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(f"Error defining agent pipeline: {e}")
+    st.stop()
+
+# Initialize chat history
+chat_history = []
+
+def chatbot_response(message, history):
+    try:
+        output = agent_executor.invoke({"input": message, "chat_history": chat_history})
+        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
+st.title("Instant Insight-2-Action")
+
+# User input
+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.")