Update pipeline.py

pipeline.py

@@ -1,211 +1,212 @@
+import os
+from langchain.chains import ConversationChain
 from langchain.chat_models import ChatOpenAI
 from langchain.memory import ConversationBufferMemory
 from langchain.prompts import PromptTemplate
+from langchain.sql_database import SQLDatabase
 from langchain.chains import LLMChain
 from langchain.utilities import SQLDatabase
-from sqlalchemy import create_engine  # Import create_engine
+from langchain_experimental.sql import SQLDatabaseChain
+from sqlalchemy import create_engine
 
-# --- Initialize Core Components ---
+# --- Environment Setup ---
+# Set your OpenAI API key (replace with your actual key)
+os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
 
-# 1. Dialogue Context (Memory)
-memory = ConversationBufferMemory()
+# --- 1. Dialogue Context (Memory) ---
+memory = ConversationBufferMemory(return_messages=True)
 
-# 2. LLM (for routing, service selection, state tracking, and response generation)
-llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")  # Or another suitable model
+# --- 2. Router (Intent Classifier) ---
+llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")  # Or another suitable model
 
-# 3. Database (using SQLite in-memory for demonstration)
-engine = create_engine("sqlite:///:memory:")  # Create an in-memory SQLite engine
-db = SQLDatabase(engine)  # Pass the engine to SQLDatabase
-
-# --- Define Prompts ---
-
-# Router Prompt
 router_template = """
-You are a helpful assistant that classifies user input into two categories:
-
-1. open-domain: General conversation, chit-chat, or questions not related to a specific task.
-2. task-oriented: The user wants to perform a specific action or get information related to a predefined service.
-
-Based on the dialogue history, classify the latest user input:
+Given the following conversation and a follow-up user input, determine if the user is asking a general question or trying to perform a specific task related to Viettel's services.
 
-{chat_history}
+Conversation History:
+{history}
 
-User: {user_input}
+User Input: {input}
 
-Classification:
+Is the user input "open-domain" (general conversation) or "task-oriented" (specific service request)?
+Answer with "open-domain" or "task-oriented".
 """
 router_prompt = PromptTemplate(
-    input_variables=["chat_history", "user_input"], template=router_template
+    input_variables=["history", "input"], template=router_template
 )
-
-# Service Selection Prompt
+router_chain = LLMChain(llm=llm, prompt=router_prompt)
+
+# --- 3. LLM (Open-Domain Dialogue Handler) ---
+# Assuming you have set up your ChatOpenAI instance as 'llm'
+conversation_chain = ConversationChain(llm=llm, memory=memory)
+
+# --- 4. Service Selection (Task Classifier) ---
+services = [
+    "dịch vụ di động gói cước data của Viettel (data 3G/4G/5G)",
+    "dịch vụ di động gói cước combo của Viettel (combo)",
+    "dịch vụ di động gói cước thoại của Viettel (call)",
+    "dịch vụ di động gói cước tin nhắn SMS của Viettel (SMS)",
+    "dịch vụ di động gói cước ở nước ngoài ở Viettel (roaming)",
+    "dịch vụ lắp đặt Internet cố định (internet)",
+]
 service_selection_template = """
-You are a helpful assistant that classifies user input into one of the following predefined services:
-
-Services:
-- book_flight: For booking flight tickets.
-- check_order_status: For checking the status of an order.
-- find_restaurants: For finding restaurants based on criteria.
+Given the following conversation and a follow-up user input, classify the user's request into one of the following Viettel services:
 
-Based on the dialogue history, which service best matches the user's intent?
+{services}
 
-{chat_history}
+Conversation History:
+{history}
 
-User: {user_input}
+User Input: {input}
 
-Selected Service:
+Which service best matches the user's request?
+Answer with the name of the service.
 """
 service_selection_prompt = PromptTemplate(
-    input_variables=["chat_history", "user_input"],
+    input_variables=["services", "history", "input"],
     template=service_selection_template,
 )
+service_selection_chain = LLMChain(llm=llm, prompt=service_selection_prompt)
 
-# Dialogue State Tracking Prompt
-state_tracking_template = """
-You are a helpful assistant that extracts information from user input to fill in the slots for a specific service.
+# --- 5. Dialogue State Tracking (Slot Filling) ---
+slot_filling_template = """
+You are an AI assistant helping users with Viettel's services.
+Based on the conversation history and the selected service, extract the values for the following slots.
+Return the extracted information in a JSON format. If a slot's value is not found, set it to null.
 
-Service: {service}
-Slots: {slots}
+Selected Service: {service}
+Required Slots: {slots}
 
-Based on the dialogue history, extract the values for each slot from the conversation. 
-Return the output in JSON format. If a slot is not filled, use null as the value.
+Conversation History:
+{history}
 
-{chat_history}
+User Input: {input}
 
-User: {user_input}
-
-Extracted Information (JSON):
+JSON Output:
 """
-state_tracking_prompt = PromptTemplate(
-    input_variables=["service", "slots", "chat_history", "user_input"],
-    template=state_tracking_template,
+slot_filling_prompt = PromptTemplate(
+    input_variables=["service", "slots", "history", "input"],
+    template=slot_filling_template,
 )
+slot_filling_chain = LLMChain(llm=llm, prompt=slot_filling_prompt)
+
+# --- Define Slots for Each Service ---
+service_slots = {
+    "data 3G/4G/5G": ["data_package", "duration"],  # Example slots
+    "combo": ["data_amount", "call_minutes", "sms_count", "duration"],
+    "call": ["call_minutes", "duration"],
+    "SMS": ["sms_count", "duration"],
+    "roaming": ["destination_country", "duration", "data_package"],
+    "internet": ["internet_speed", "address"],
+}
+
+# --- 6. Database (Data Retrieval) ---
+# Replace with your database connection details
+engine = create_engine("mysql+mysqldb://user:password@host:port/database")
+db = SQLDatabase(engine)
+# db = SQLDatabase.from_uri("your_database_uri")
+
+db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)
 
-# Response Generation Prompt
+# --- 8. Response Generation (System Response) ---
 response_generation_template = """
-You are a helpful assistant that generates natural language responses to the user.
+You are an AI assistant helping users with Viettel's services.
+You have completed the following steps:
+1. Classified the user's intent.
+2. Identified the relevant service (if task-oriented).
+3. Extracted slot values (if task-oriented).
+4. Retrieved information from the database (if applicable).
 
-Dialogue History:
-{chat_history}
+Now, generate a natural language response to the user based on the following information:
 
-User: {user_input}
+Conversation History:
+{history}
 
-{slot_info}
+User Input: {input}
 
-{db_results}
+Selected Service: {service}
+
+Slot Values: {slot_values}
+
+Database Results: {db_results}
 
 Response:
 """
 response_generation_prompt = PromptTemplate(
-    input_variables=["chat_history", "user_input", "slot_info", "db_results"],
+    input_variables=["history", "input", "service", "slot_values", "db_results"],
     template=response_generation_template,
 )
+response_generation_chain = LLMChain(llm=llm, prompt=response_generation_prompt)
 
-# --- Define Chains ---
-
-router_chain = LLMChain(llm=llm, prompt=router_prompt, output_key="classification")
-service_selection_chain = LLMChain(
-    llm=llm, prompt=service_selection_prompt, output_key="service"
-)
-state_tracking_chain = LLMChain(
-    llm=llm, prompt=state_tracking_prompt, output_key="slot_json"
-)
-response_generation_chain = LLMChain(
-    llm=llm, prompt=response_generation_prompt, output_key="response"
-)
-
-# --- Define Service Slots ---
-# (In a real application, this would likely be loaded from a configuration file or database)
-service_slots = {
-    "book_flight": ["destination", "departure_date", "num_passengers"],
-    "check_order_status": ["order_id"],
-    "find_restaurants": ["cuisine", "location", "price_range"],
-}
-
-# --- Main Dialogue Loop ---
-
+# --- Main Pipeline Function ---
 def process_user_input(user_input):
-    # 1. Add user input to memory
+    # 1. Add input to memory (Dialogue Context)
     memory.chat_memory.add_user_message(user_input)
 
-    # 2. Route the input
-    router_output = router_chain(
-        {"chat_history": memory.load_memory_variables({}), "user_input": user_input}
-    )
-    classification = router_output["classification"].strip()
-
-    print(f"Router Classification: {classification}")
+    # 2. Route (Intent Classification)
+    intent = router_chain.run({"history": memory.load_memory_variables({})["history"], "input": user_input})
 
-    if classification == "open-domain":
-        # 3. Handle open-domain conversation
-        llm_response = llm(memory.load_memory_variables({})["history"])
-        response = llm_response.content
+    if intent == "open-domain":
+        # 3. Handle Open-Domain Conversation
+        response = conversation_chain.predict(input=user_input)
+        memory.chat_memory.add_ai_message(response)
     else:
-        # 4. Select the service
-        service_output = service_selection_chain(
-            {"chat_history": memory.load_memory_variables({}), "user_input": user_input}
+        # 4. Service Selection
+        selected_service = service_selection_chain.run(
+            {
+                "services": str(services),
+                "history": memory.load_memory_variables({})["history"],
+                "input": user_input,
+            }
+        )
+
+        # 5. Slot Filling
+        slots = service_slots.get(selected_service, [])
+        slot_values_json = slot_filling_chain.run(
+            {
+                "service": selected_service,
+                "slots": str(slots),
+                "history": memory.load_memory_variables({})["history"],
+                "input": user_input,
+            }
         )
-        service = service_output["service"].strip()
-
-        print(f"Selected Service: {service}")
-
-        if service not in service_slots:
-            response = "I'm sorry, I cannot understand that service request yet. We currently support booking flights, checking order status and finding restaurants only."
-        else:
-            # 5. Track the dialogue state (slot filling)
-            slots = service_slots[service]
-            state_output = state_tracking_chain(
-                {
-                    "service": service,
-                    "slots": ", ".join(slots),
-                    "chat_history": memory.load_memory_variables({}),
-                    "user_input": user_input,
-                }
-            )
-            slot_json_str = state_output["slot_json"].strip()
-
-            print(f"Slot Filling Output (JSON): {slot_json_str}")
 
+        # Convert JSON string to dictionary
+        import json
+
+        try:
+            slot_values = json.loads(slot_values_json)
+        except json.JSONDecodeError:
+            slot_values = {}  # Handle cases where JSON decoding fails
+
+        # 6. Database Interaction (if needed)
+        db_results = "N/A"  # Default if no database interaction is needed
+        if selected_service == "data 3G/4G/5G" and slot_values.get("data_package"):
+            # Example: Query database for data package details
             try:
-                import json
-                slot_values = json.loads(slot_json_str)
-            except json.JSONDecodeError:
-                slot_values = {}  # Handle cases where JSON decoding fails
-                response = "I'm sorry, there seems to be a problem understanding your request details."
-
-            # (Optional) 6. Database interaction (based on service and filled slots)
-            db_results = ""  # Initialize db_results as an empty string
-            if service == "check_order_status" and "order_id" in slot_values:
-                try:
-                    order_id = slot_values["order_id"]
-                    # Basic query without table information
-                    db_results = db.run(f"SELECT * FROM orders WHERE order_id = '{order_id}'")
-                    db_results = f"Database Results: {db_results}"
-                except Exception as e:
-                    print(f"Error during database query: {e}")
-                    db_results = ""
-
-            # 7. Generate the response
-            response_output = response_generation_chain(
-                {
-                    "chat_history": memory.load_memory_variables({}),
-                    "user_input": user_input,
-                    "slot_info": f"Slots: {slot_json_str}",
-                    "db_results": db_results,
-                }
-            )
-            response = response_output["response"]
-
-    # 8. Add the system response to memory
-    memory.chat_memory.add_ai_message(response)
+                db_results = db_chain.run(
+                    f"What are the details of the {slot_values['data_package']} data package?"
+                )
+            except Exception as e:
+                db_results = f"Error querying the database: {e}"
+
+        # 8. Response Generation
+        response = response_generation_chain.run(
+            {
+                "history": memory.load_memory_variables({})["history"],
+                "input": user_input,
+                "service": selected_service,
+                "slot_values": slot_values,
+                "db_results": db_results,
+            }
+        )
+        memory.chat_memory.add_ai_message(response)
 
     return response
 
 # --- Example Usage ---
-
-while True:
-    user_input = input("You: ")
-    if user_input.lower() == "exit":
-        break
-    response = process_user_input(user_input)
-    print(f"AI: {response}")
+print(process_user_input("Hello, how are you?"))
+print(
+    process_user_input(
+        "I want to buy a data package for my phone, what is the best option of data package in 30 days"
+    )
+)