customer service - completed

.gitignore

@@ -1 +1,2 @@
 *.pyc
+/.chroma_db

src/langgraphagenticai/graph/graph_builder.py

@@ -3,6 +3,7 @@ from langgraph.prebuilt import tools_condition,ToolNode
 from langchain_core.prompts import ChatPromptTemplate
 import datetime
 #module import
+from src.langgraphagenticai.node.customer_support_chatbot import Customer_Support_Bot
 from src.langgraphagenticai.tools.customtool import book_appointment, cancel_appointment, get_next_available_appointment
 from src.langgraphagenticai.tools.search_tool import create_tool_node, get_tools
 from src.langgraphagenticai.node.chatbot_with_tool_node import ChatbotWithToolNode
@@ -109,6 +110,9 @@ class GraphBuilder:
         # Set Entry Point and build the graph
         self.graph_builder.set_entry_point("agent")
 
+    def customer_support_build_graph(self):
+        obj_cs_bot = Customer_Support_Bot(llm=self.llm)
+        self.graph_builder = obj_cs_bot.chat_bot()
 
     def setup_graph(self, usecase: str):
         """
@@ -120,6 +124,8 @@ class GraphBuilder:
             self.chatbot_with_tool_build_graph()
         elif usecase == "Appointment Receptionist":
             self.appointment_receptionist_bot_build_graph()
+        elif usecase =="Customer Support":
+            self.customer_support_build_graph()
         else:
             raise ValueError("Invalid use case selected.")
         return self.graph_builder.compile()

src/langgraphagenticai/node/customer_support_chatbot.py

@@ -0,0 +1,80 @@
+from langgraph.graph import StateGraph, MessagesState
+from langchain_core.prompts import ChatPromptTemplate
+from langgraph.prebuilt import ToolNode
+from src.langgraphagenticai.tools.customer_support_tools import query_knowledge_base, search_for_product_reccommendations, data_protection_check, create_new_customer, place_order, retrieve_existing_customer_orders
+
+import os
+
+
+class Customer_Support_Bot:
+    def __init__(self,llm):
+        self.llm = llm
+        
+        
+    def chat_bot(self):
+        
+        prompt = """#Purpose 
+
+        You are a customer service chatbot for a flower shop company. You can help the customer achieve the goals listed below.
+
+        #Goals
+
+        1. Answer questions the user might have relating to serivces offered
+        2. Recommend products to the user based on their preferences
+        3. Help the customer check on an existing order, or place a new order
+        4. To place and manage orders, you will need a customer profile (with an associated id). If the customer already has a profile, perform a data protection check to retrieve their details. If not, create them a profile.
+
+        #Tone
+
+        Helpful and friendly. Use gen-z emojis to keep things lighthearted. You MUST always include a funny flower related pun in every response."""
+
+        chat_template = ChatPromptTemplate.from_messages(
+            [
+                ('system', prompt),
+                ('placeholder', "{messages}")
+            ]
+        )
+
+       
+
+        tools = [query_knowledge_base, search_for_product_reccommendations, data_protection_check, create_new_customer, place_order, retrieve_existing_customer_orders]
+
+        llm = self.llm
+
+        llm_with_prompt = chat_template | llm.bind_tools(tools)
+
+
+        def call_agent(message_state: MessagesState):
+            
+            response = llm_with_prompt.invoke(message_state)
+
+            return {
+                'messages': [response]
+            }
+
+        def is_there_tool_calls(state: MessagesState):
+            last_message = state['messages'][-1]
+            if last_message.tool_calls:
+                return 'tool_node'
+            else:
+                return '__end__'
+
+
+        graph = StateGraph(MessagesState)
+
+        tool_node = ToolNode(tools)
+
+        graph.add_node('agent', call_agent)
+        graph.add_node('tool_node', tool_node)
+
+        graph.add_conditional_edges(
+            "agent",
+            is_there_tool_calls
+        )
+        graph.add_edge('tool_node', 'agent')
+
+        graph.set_entry_point('agent')
+
+        # app = graph.compile()
+        return graph
+

src/langgraphagenticai/tools/customer_support_tools.py

@@ -0,0 +1,184 @@
+from langchain_core.tools import tool
+from typing import List, Dict
+import json
+
+from src.langgraphagenticai.vectorstores.vectore_store import FlowerShopVectorStore
+
+vector_store = FlowerShopVectorStore()
+INVENTORY_FILE_PATH = './data/inventory.json'
+
+customers_database = [
+    {"name": "John Doe", "postcode": "SW1A 1AA", "dob": "1990-01-01", "customer_id": "CUST001", "first_line_address": "123 Main St", "phone_number": "07712345678", "email": "john.doe@example.com"},
+    {"name": "Jane Smith", "postcode": "E1 6AN", "dob": "1985-05-15", "customer_id": "CUST002", "first_line_address": "456 High St", "phone_number": "07723456789", "email": "jane.smith@example.com"},
+]
+
+orders_database = [
+    {"order_id": "ORD001", "customer_id": "CUST001", "status": "Processing", "items": ["Red Roses Bouquet"], "quantity": [1]},
+    {"order_id": "ORD002", "customer_id": "CUST002", "status": "Shipped", "items": ["Mixed Tulips", "Vase"], "quantity": [3, 1]},
+]
+
+with open(INVENTORY_FILE_PATH, 'r') as f:
+    inventory_database = json.load(f)
+
+data_protection_checks = []
+
+@tool
+def data_protection_check(name: str, postcode: str, year_of_birth: int, month_of_birth: int, day_of_birth: int) -> Dict:
+    """
+    Perform a data protection check against a customer to retrieve customer details.
+
+    Args:
+        name (str): Customer first and last name
+        postcode (str): Customer registered address
+        year_of_birth (int): The year the customer was born
+        month_of_birth (int): The month the customer was born
+        day_of_birth (int): The day the customer was born
+
+    Returns:
+        Dict: Customer details (name, postcode, dob, customer_id, first_line_address, email)
+    """
+    data_protection_checks.append(
+        {
+            'name': name,
+            'postcode': postcode,
+            'year_of_birth': year_of_birth,
+            'month_of_birth': month_of_birth,
+            'day_of_birth': day_of_birth
+        }
+    )
+    for customer in customers_database:
+        if (customer['name'].lower() == name.lower() and
+            customer['postcode'].lower() == postcode.lower() and
+            int(customer['dob'][0:4]) == year_of_birth and
+            int(customer["dob"][5:7]) == month_of_birth and
+            int(customer["dob"][8:10]) == day_of_birth):
+            return f"DPA check passed - Retrieved customer details:\n{customer}"
+
+    return "DPA check failed, no customer with these details found"
+
+@tool
+def create_new_customer(first_name: str, surname: str, year_of_birth: int, month_of_birth: int, day_of_birth: int, postcode: str, first_line_of_address: str, phone_number: str, email: str) -> str:
+    """
+    Creates a customer profile, so that they can place orders.
+
+    Args:
+        first_name (str): Customers first name
+        surname (str): Customers surname
+        year_of_birth (int): Year customer was born
+        month_of_birth (int): Month customer was born
+        day_of_birth (int): Day customer was born
+        postcode (str): Customer's postcode
+        first_line_address (str): Customer's first line of address
+        phone_number (str): Customer's phone number
+        email (str): Customer's email address
+
+    Returns:
+        str: Confirmation that the profile has been created or any issues with the inputs
+    """
+    if len(phone_number) != 11:
+        return "Phone number must be 11 digits"
+    customer_id = len(customers_database) + 1
+    customers_database.append({
+        'name': first_name + ' ' + surname,
+        'dob': f'{year_of_birth}-{month_of_birth:02}-{day_of_birth:02}',
+        'postcode': postcode,
+        'first_line_address': first_line_of_address,
+        'phone_number': phone_number,
+        'email': email,
+        'customer_id': f'CUST{customer_id}'
+    })
+    return f"Customer registered, with customer_id {f'CUST{customer_id}'}"
+    
+
+@tool
+def query_knowledge_base(query: str) -> List[Dict[str, str]]:
+    """
+    Looks up information in a knowledge base to help with answering customer questions and getting information on business processes.
+
+    Args:
+        query (str): Question to ask the knowledge base
+
+    Return:
+        List[Dict[str, str]]: Potentially relevant question and answer pairs from the knowledge base
+    """
+    return vector_store.query_faqs(query=query)
+
+
+
+@tool
+def search_for_product_reccommendations(description: str):
+    """
+    Looks up information in a knowledge base to help with product recommendation for customers. For example:
+
+    "Boquets suitable for birthdays, maybe with red flowers"
+    "A large boquet for a wedding"
+    "A cheap boquet with wildflowers"
+
+    Args:
+        query (str): Description of product features
+
+    Return:
+        List[Dict[str, str]]: Potentially relevant products
+    """
+    return vector_store.query_inventories(query=description)
+
+@tool
+def retrieve_existing_customer_orders(customer_id: str) -> List[Dict]:
+    """
+    Retrieves the orders associated with the customer, including their status, items and ids
+
+    Args:
+        customer_id (str): Customer unique id associated with the order
+
+    Returns:
+        List[Dict]: All the orders associated with the customer_id passed in
+    """
+    customer_orders = [order for order in orders_database if order['customer_id'] == customer_id]
+    if not customer_orders:
+        return f"No orders associated with this customer id: {customer_id}"
+    return customer_orders
+
+@tool
+def place_order(items: Dict[str, int], customer_id: str) -> str:
+    """
+    Places an order for the requested items, and for the required quantities.
+
+    Args:
+        items (Dict[str, int]): Dictionary of items to order, with item id as the key and the quantity of that item as the value.
+        customer_id (str): The customer to place the order for
+
+    Returns:
+        str: Message indicating that the order has been placed, or, it hasnt been placed due to an issue 
+    """
+    # Check that the item ids are valid 
+    # Check that the quantities of items are valid
+    availability_messages = []
+    valid_item_ids = [
+        item['id'] for item in inventory_database
+    ]
+    for item_id, quantity in items.items():
+        if item_id not in valid_item_ids:
+            availability_messages.append(f'Item with id {item_id} is not found in the inventory')
+        else:
+            inventory_item = [item for item in inventory_database if item['id'] == item_id][0]
+            if quantity > inventory_item['quantity']:
+                availability_messages.append(f'There is insufficient quantity in the inventory for this item {inventory_item["name"]}\nAvailable: {inventory_item["quantity"]}\nRequested: {quantity}')
+    if availability_messages:
+        return "Order cannot be placed due to the following issues: \n" + '\n'.join(availability_messages)
+
+    # Place the order (in pretend database)
+    order_id = len(orders_database) + 1
+    orders_database.append(
+        {
+            'order_id': order_id,
+            'customer_id': customer_id,
+            'status': 'Waiting for payment',
+            'items': list(items.keys()),
+            'quantity': list(items.values())
+        }
+    )
+    # Update the inventory
+    for item_id, quantity in items.items():
+        inventory_item = [item for item in inventory_database if item['id'] == item_id][0]
+        inventory_item['quantity'] -= quantity
+    return f"Order with id {order_id} has been placed successfully"

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -2,6 +2,7 @@ import streamlit as st
 from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
 
 from src.langgraphagenticai.tools.customtool import APPOINTMENTS
+from src.langgraphagenticai.tools.customer_support_tools import customers_database, data_protection_checks
 
 class DisplayResultStreamlit:
     def __init__(self,usecase,graph,user_message):
@@ -58,10 +59,32 @@ class DisplayResultStreamlit:
                         else:
                             with st.chat_message("assistant"):
                                 st.write(message.content)
-                            
             with col2:
                 st.header("Appointments")
                 st.write(APPOINTMENTS)
+        elif usecase == "Customer Support":
+            
+            main_col, right_col = st.columns([2, 1])
+            response = graph.invoke({
+                'messages': user_message
+            })
+            with  main_col:
+                st.session_state.message_history = response['messages']
+                for i in range(1, len(st.session_state.message_history) + 1):
+                    this_message = st.session_state.message_history[-i]
+                    if isinstance(this_message, AIMessage):
+                        message_box = st.chat_message('assistant')
+                    else:
+                        message_box = st.chat_message('user')
+                    if this_message.content:
+                        message_box.markdown(this_message.content)
+            # 3. State variables
+            with right_col:
+                st.title('customers database')
+                st.write(customers_database)
+                st.title('data protection checks')
+                st.write(data_protection_checks) 
+        
         # display graph
         if graph:
             st.write('state graph - workflow')

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -1,7 +1,8 @@
 import streamlit as st
 import os
 
-from src.langgraphagenticai.ui.configfile import Config
+from src.langgraphagenticai.ui.uiconfigfile import Config
+from langchain_core.messages import AIMessage, HumanMessage
 
 
 class LoadStreamlitUI:
@@ -46,7 +47,24 @@ class LoadStreamlitUI:
                 st.subheader("Appointments")
                     
         elif self.user_controls['selected_usecase']=="Customer Support":
-            # TODO :: to be removed
-            st.warning("⌛Revamp is in progress...")
+            st.subheader('Flower Shop Chatbot' + '💐')
+            greeting="Hi 🙋🏻‍♀️, I am the flower shop chatbot. How can I help?"
+
+            if 'message_history' not in st.session_state:
+                st.session_state.message_history = [AIMessage(content=greeting)]
+                
+            with st.chat_message("assistant"):
+                st.write(greeting) 
+                
+             # 1. Buttons for chat - Clear Button
+            
+        
+
+            with  st.sidebar:
+                if st.button('Clear Chat'):
+                    st.session_state.message_history = []
+
+       
+            
 
         return self.user_controls

src/langgraphagenticai/ui/{configfile.py → uiconfigfile.py}

@@ -2,7 +2,7 @@ from configparser import ConfigParser
 
 
 class Config:
-  def __init__(self, config_file="./src/langgraphagenticai/ui/configfile.ini"):
+  def __init__(self, config_file="./src/langgraphagenticai/ui/uiconfigfile.ini"):
     self.config = ConfigParser()
     self.config.read(config_file)
 

src/langgraphagenticai/vectorstores/vectore_store.py

@@ -0,0 +1,122 @@
+from chromadb import PersistentClient, EmbeddingFunction, Embeddings
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from typing import List
+import json
+
+
+MODEL_NAME = 'dunzhang/stella_en_1.5B_v5'
+DB_PATH = './.chroma_db'
+FAQ_FILE_PATH= './data/FAQ.json'
+INVENTORY_FILE_PATH = './data/inventory.json'
+
+class Product:
+    def __init__(self, name: str, id: str, description: str, type: str, price: float, quantity: int):
+        self.name = name
+        self.id = id
+        self.description = description
+        self.type = type
+        self.price = price
+        self.quantity = quantity
+
+class QuestionAnswerPairs:
+    def __init__(self, question: str, answer: str):
+        self.question = question
+        self.answer = answer
+
+class CustomEmbeddingClass(EmbeddingFunction):
+    def __init__(self, model_name):
+        self.embedding_model = HuggingFaceEmbedding(model_name=MODEL_NAME)
+
+    def __call__(self, input_texts: List[str]) -> Embeddings:
+        return [self.embedding_model.get_text_embedding(text) for text in input_texts]
+
+class FAQCollection:
+    def __init__(self):
+        self.documents = []
+        self.ids = []
+        self.metadatas = []
+
+    def add(self, documents, ids, metadatas):
+        self.documents.extend(documents)
+        self.ids.extend(ids)
+        self.metadatas.extend(metadatas)
+
+    def display(self):
+        for doc, id_, meta in zip(self.documents, self.ids, self.metadatas):
+            print(f"ID: {id_}, Document: {doc}, Metadata: {meta}")
+
+# Define the InventoryCollection class
+class InventoryCollection:
+    def __init__(self):
+        self.documents = []
+        self.ids = []
+        self.metadatas = []
+
+    def add(self, documents, ids, metadatas):
+        self.documents.extend(documents)
+        self.ids.extend(ids)
+        self.metadatas.extend(metadatas)
+
+    def display(self):
+        for doc, id_, meta in zip(self.documents, self.ids, self.metadatas):
+            print(f"ID: {id_}, Document: {doc}, Metadata: {meta}")
+
+
+
+
+class FlowerShopVectorStore:
+    def __init__(self):
+        db = PersistentClient(path=DB_PATH)
+
+        custom_embedding_function = CustomEmbeddingClass(MODEL_NAME)
+
+        self.faq_collection = db.get_or_create_collection(name='FAQ', embedding_function=custom_embedding_function)
+        self.inventory_collection = db.get_or_create_collection(name='Inventory', embedding_function=custom_embedding_function)
+
+        if self.faq_collection.count() == 0:
+            try :
+                self._load_faq_collection(FAQ_FILE_PATH)
+            except Exception as e:
+                raise ValueError(e)
+                
+
+        if self.inventory_collection.count() == 0:
+            self._load_inventory_collection(INVENTORY_FILE_PATH)
+
+    def _load_faq_collection(self, faq_file_path: str):
+        try:
+            
+            with open(faq_file_path, 'r') as f:
+                faqs = json.load(f)
+                
+            # Create an instance of FAQCollection
+            obj_faq_collection = FAQCollection()
+
+            obj_faq_collection.add(
+                documents=[faq['question'] for faq in faqs] + [faq['answer'] for faq in faqs],
+                ids=[str(i) for i in range(0, 2*len(faqs))],
+                metadatas = faqs + faqs
+            )
+            self.faq_collection = obj_faq_collection
+        except Exception as ex:
+            raise ValueError(ex)
+
+    def _load_inventory_collection(self, inventory_file_path: str):
+        with open(inventory_file_path, 'r') as f:
+            inventories = json.load(f)
+            
+        # Create an instance of InventoryCollection
+        obj_inventory_collection = InventoryCollection()
+
+        obj_inventory_collection.add(
+            documents=[inventory['description'] for inventory in inventories],
+            ids=[str(i) for i in range(0, len(inventories))],
+            metadatas = inventories
+        )
+        self.inventory_collection = obj_inventory_collection
+
+    def query_faqs(self, query: str): 
+        return self.faq_collection.query(query_texts=[query], n_results=5)
+    
+    def query_inventories(self, query: str):
+        return self.inventory_collection.query(query_texts=[query], n_results=5)