Upload 5 files

be.py

@@ -0,0 +1,115 @@
+from example import example
+from datetime import datetime
+import pandas as pd 
+# agent will directly create query and run the query in DB
+from langchain.agents import create_sql_agent 
+# Simple chain to create the SQL statements, it doesn't execute the query
+from langchain.chains import create_sql_query_chain 
+# to execute the query
+from langchain_community.tools.sql_database.tool import QuerySQLDataBaseTool 
+from langchain_community.agent_toolkits import SQLDatabaseToolkit
+from langchain.sql_database import SQLDatabase
+from langchain.agents import AgentExecutor
+from langchain.agents.agent_types import AgentType
+from langchain_experimental.sql import SQLDatabaseChain
+from langchain_community.vectorstores import Chroma
+from langchain.prompts import SemanticSimilarityExampleSelector
+# Prompt input for MYSQL
+from langchain.chains.sql_database.prompt import PROMPT_SUFFIX, _mysql_prompt
+# Create the prompt template for creating the prompt for mysqlprompt
+from langchain.prompts.prompt import PromptTemplate
+from langchain.prompts import FewShotPromptTemplate
+# to create the tools to be used by agent
+from langchain.agents import Tool
+
+# create the agent prompts
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+# Huggingface embeddings using Langchain
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.prompts import HumanMessagePromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+# Load Env parameters
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from sqlalchemy import create_engine, text, URL
+
+
+def config():
+    load_dotenv()  # load env parameters
+    llm = ChatOpenAI(temperature=0.5, model="gpt-3.5-turbo")   # create LLM
+    #llm = OpenAI(temperature=0.5)   # create LLM
+    return llm
+
+# Setting up URL parameter to connect to MySQL Database
+def get_db_chain(question):
+    db_user="root"
+    db_password="root"
+    db_host="localhost"
+    db_name="retail"
+    
+    # create LLM
+    llm = ChatOpenAI(temperature=0.5, model="gpt-3.5-turbo")
+    # Initialize SQL DB using Langchain
+    db = SQLDatabase.from_uri(f"mysql://{db_user}:{db_password}@{db_host}/{db_name}")
+    toolkit = SQLDatabaseToolkit(db=db, llm=llm)
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    # create the list with only values and ready to be vectorized 
+    to_vectorize = [" ".join(example.values()) for example in example] # use join to convert Dict to list
+    # Setup the Chroma database and vectorize
+    vectorstore = Chroma.from_texts(to_vectorize, embedding=embeddings, metadatas=example)
+    # Based on the user question, convert them to vector and take the similar looking vectors from Chroma DB
+    example_selector = SemanticSimilarityExampleSelector(
+                        vectorstore = vectorstore,
+                        k=2)
+    example_prompt = PromptTemplate(
+                        input_variables=["Question", "SQLQuery", "SQLResult", "Answer",],
+                        template="\nQuestion: {Question}\nSQLQuery: {SQLQuery}\nSQLResult: {SQLResult}\n?Answer: {Answer}",)
+    few_shot_prompt = FewShotPromptTemplate( 
+                        example_selector=example_selector,                # Hey LLM, if you dont know refer the examples giving in vector DB
+                        example_prompt=example_prompt,                    # This is the Prompt template we have created        
+                        prefix=_mysql_prompt,                             # This is prefix of the prompt
+                        suffix=PROMPT_SUFFIX,                             # This is suffix of the prompt
+                        input_variables=["input", "table_info", "top_k"], # variables used in forming the prompt to LLM
+                        )
+    chain = SQLDatabaseChain.from_llm(llm, db, verbose=True, prompt=few_shot_prompt)
+    response = chain.invoke(question)
+    return response
+    # Call the LLM with the question and the fewshotprompt
+    # write_query = create_sql_query_chain(llm=llm,db=db, prompt=few_shot_prompt)
+    #print(write_query)
+    # Execute the Query using QuerySQLDataBaseTool 
+    #execute_query = QuerySQLDataBaseTool(db=db)
+    # Chain to combine write SQL and Execute SQL 
+    #chain = write_query | execute_query | llm
+    #response = chain.invoke("Question")
+def get_store_address(store):
+    url_object = URL.create(
+    "mysql",
+    username="root",
+    password="root",  # plain (unescaped) text
+    host="localhost",
+    database="retail",
+    )
+    engine = create_engine(url_object)
+    #connect to engine
+    connection = engine.connect()
+    sql_query = "SELECT STORE_NUMBER, STORE_ADDRESS FROM STORES WHERE STORE_NUMBER = " + store
+    df = pd.read_sql(sql_query, con=engine)
+    response = df.to_string()
+    return response
+def outreach_sms_message(outreach_input):
+        # create LLM
+    llm = ChatOpenAI(temperature=0.5, model="gpt-3.5-turbo", verbose=True)
+    prompt = ChatPromptTemplate.from_template("You are a expert in writing a text message for appointment setup with less than 35 words." 
+                                              "With {outreach_input}, generate a text message for appointment to be sent to customer")
+    output_parser = StrOutputParser()
+    chain = prompt | llm | output_parser
+    response = chain.invoke({"outreach_input": outreach_input})
+    return response
+
+#if __name__ == "__main__":
+#    chain = get_db_chain()
+#    print(chain.run("List of all sales transactions for Trevor Nelson in June 2020"))
+# Setting up URL parameter to connect to MySQL Database

example.py

@@ -0,0 +1,48 @@
+# Few Shot Learnings
+example = [
+    {   'Question': "Top 10 stores with highest sales and the number of transactions",
+        'SQLQuery': "SELECT store_number, COUNT(store_number) AS num_transactions FROM sales GROUP BY store_number ORDER BY SUM(sale_price) DESC;",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"
+    },
+    {   'Question': "List of all stores transactions for Sheri Williams",
+        'SQLQuery': "SELECT customer_id, product, quantity, sale_price, sales_channel FROM sales WHERE name = 'Sheri Williams' AND sales_channel = 'st'",
+        'SQLResult': "Result of the SQL Query",
+        'Answer': "answer"
+    },
+    {   'Question': "Top customer who bought product7 the most in store",
+        'SQLQuery': "SELECT customer_id, name, count(product) as total_product7_purchases from sales where product = 'Product7' and store_number = 1365 group by customer_id, name ORDER BY total_product7_purchases DESC LIMIT 10",
+        'SQLResult': "Result of the SQL Query",
+        'Answer': "answer"
+    },
+    {
+        'Question': "List of all online transactions for Sheri Williams",
+        'SQLQuery': "SELECT customer_id, product, quantity, sale_price, sales_channel FROM sales WHERE name = 'Sheri Williams' AND sales_channel = 'ol'",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"   
+    },
+        {
+        'Question': "find the product with the highest sales in store 4057",
+        'SQLQuery': "SELECT product, SUM(sale_price) as total_sales_amount FROM sales WHERE store_number = 4057 GROUP BY product ORDER BY total_sales_amount DESC LIMIT 1;",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"   
+    },
+    {
+        'Question': "List of all sales transactions in the last 1 week",
+        'SQLQuery': "SELECT customer_id, product, quantity, sale_price, sales_channel, date FROM sales WHERE date >= CURDATE() - INTERVAL 1 WEEK;",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"   
+    },
+    {
+        'Question': "List of all sales transactions this week",
+        'SQLQuery': "SELECT customer_id, product, quantity, sale_price, sales_channel, date FROM sales WHERE date >= CURDATE() - INTERVAL DAYOFWEEK(CURDATE())-1 DAY AND date < CURDATE() + INTERVAL 1 DAY;",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"   
+    },
+    {
+        'Question': " Top 10 stores with highest sales and the number of transactions with sales amount & store associate name",
+        'SQLQuery': "SELECT s.store_number, COUNT(s.store_number) AS num_transactions, SUM(s.sale_price) AS total_sales, st.store_associate FROM sales s JOIN stores st ON s.store_number = st.store_number GROUP BY s.store_number ORDER BY total_sales DESC;",
+        'SQLResult': "Result of the SQL query",
+        'Answer': "answer"   
+    }
+]

fe.py

@@ -0,0 +1,130 @@
+from langchain.tools import DuckDuckGoSearchRun
+from langchain.agents.tools import tool
+from langchain import OpenAI
+from langchain.agents import Tool, load_tools, initialize_agent, AgentType
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+# Streamlit UI Callback
+from langchain.callbacks import StreamlitCallbackHandler
+from langchain.chains import LLMMathChain
+from langchain.memory import ConversationBufferMemory
+from langchain_openai import ChatOpenAI
+import streamlit as st
+from dotenv import load_dotenv
+from sqlalchemy import create_engine, text, URL
+from htmlTemplates import css, bot_template, user_template
+
+import openai
+import os
+import time
+
+from be import config, get_db_chain, outreach_sms_message, get_store_address
+from PIL import Image
+def conversation_agent(question):
+    llm = ChatOpenAI(temperature=0.5, model="gpt-3.5-turbo")   # create LLM
+    # search = DuckDuckGoSearchRun()
+    llm_math_chain = LLMMathChain(llm=llm, verbose=True)
+    tools = [
+        Tool(
+            name="Calculator",
+            func=llm_math_chain.run,
+            description="useful when you need to answer questions with math"
+        )
+    ]
+    #########   CREATING ALL THE TOOLS FOR THE AGENT TO USE #####################
+    # Create the final SMS message
+    outreach_sms_message_tool = Tool(
+        name="Outreach SMS Message",
+        func=outreach_sms_message,
+        description="Create an outreach SMS message for the customer. Pass both user input and the Store Address as ONE SINGLE INPUT STRING.  Use this Tool only to create an outreach SMS or Text message.  At the end always include the Store Address for appointment confirmation messages"
+    )
+    #tools.append(outreach_sms_message_tool)
+    # Creating a Query Tool - to generate SQL statements and query the database
+    get_db_chain_tool = Tool(
+        name='Query Generation Tool',
+        func=get_db_chain,
+        description="ONLY use this tool for query generation and to fetch any information.  Use this to Create MYSQL Query with the ORIGINAL User Input question to pull customer, store, product information. MySQL database connections are established within this tool.  Use this tool first"
+                "During SQL Query Generation, make sure the SELECT list of columns are in GROUP BY clause"
+                "Use this to get the store address from the database"
+    )
+    # create the tool for finding the store details
+    get_store_address_tool = Tool(
+        name="Get Store Address",
+        func=get_store_address,
+        description="Use this tool with store number to get the store address.  INPUT to this tool is Store number.  Do not use this tool if you don't have Store number as input"
+    ) 
+    #tools.append(get_db_chain_tool)
+    # List all the tools for the agent to use 
+    tools = [get_db_chain_tool, get_store_address_tool, outreach_sms_message_tool]
+    conversational_agent = initialize_agent(
+        agent="conversational-react-description",
+        tools=tools,
+        llm=llm,
+        verbose=True,
+        max_iterations=10,
+        memory=st.session_state.memory,
+        handle_parsing_errors=True
+    )
+    response = conversational_agent.invoke(question)
+    return response 
+
+def main():
+    img = Image.open('assist_logo.jpg')
+    user_avatar = Image.open('renga_profile.jpg')
+    ai_avatar = Image.open('Designer.png')
+    load_dotenv()  # load env parameters
+    st.set_page_config(page_title="Assist", page_icon=img)
+    st.write(css, unsafe_allow_html=True)
+    # Logo and image next to each other with a space column separating them out for rendering in small devices
+    st.title(':blue[Assist] Store Associates')
+    with st.sidebar:
+        st.image('assist_logo.jpg', width=120)
+        st.sidebar.header("Assist App for Store Associates")
+        st.write("Assist store associates to get information on Customers, Stores, Product, Sales Analytics, Inventory Management and help with customer outreach")
+        st.write(" ")
+        st.write("Tasks I can help with:")
+        st.write("a. Extract Data/info")
+        st.write("b. Outreach message ")
+        st.write("c. Send Text to Customers")
+        st.write("d. Search websites and look up Product prices & other info")
+        st.write("e. Generate charts for greater visualization")
+
+    if "chat_history" not in st.session_state:
+        st.session_state.memory = ConversationBufferMemory(memory_key="chat_history")
+    # ini chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    user_question = st.chat_input("Type your question")
+    if user_question:
+            
+            assistant_response = conversation_agent(user_question)
+            st.session_state.chat_history = assistant_response['chat_history']
+            chistory = assistant_response["chat_history"]
+            # Process the chat history 
+            messages = chistory.split("Human: ")
+            l = len(messages)       
+            # Step 3: Print the output
+            for i in range(1, l):
+                response = messages[i].strip()
+                response = response.split("AI:")
+            # Print the Human message from history
+                with st.chat_message("human"):
+                    st.markdown(response[0])
+            # Print the AI message from history
+                with st.chat_message("ai"):
+                    st.markdown(response[1])
+            #Print the last question from user
+            with st.chat_message("human"):
+               st.markdown(user_question)
+            #st.write(user_template.replace("{{MSG}}", user_question), unsafe_allow_html=True)
+            # Print the last answer from user
+            assistant_response_output = assistant_response["output"]
+            with st.chat_message("ai"):
+                st.write(assistant_response_output)
+            #st.write(bot_template.replace("{{MSG}}", assistant_response_output), unsafe_allow_html=True)
+
+
+if __name__== '__main__':
+    main()
+

requirements.txt

@@ -0,0 +1,15 @@
+streamlit
+google-generativeai
+python-dotenv
+langchain-community
+langchain-experimental
+mysqlclient
+sqlparse
+mysql-connector-python
+PyMySQL
+pandasai
+langchain
+transformers
+sentence-transformers
+chromadb
+langchain-openai