Update space

README.md

@@ -1,13 +1,37 @@
----
-title: Fastlane
-emoji: 📈
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 4.36.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## FastLane E-commerce Chatbot
+
+This project provides a Retrieval-Augmented Generation (RAG) system that involves Elastisearch, OpenAI, FastAPI and Gradio components. The system is about an e-commerce chatbot for product and orders searches and leverages Natural Language Processing (NLP) for understanding user intent.  
+
+**Modular Structure for Maintainability:**
+
+The system was designed with a focus on maintainability and scalability. Here's a breakdown of the core components:
+
+* **main.py:**  The entry point for the application, where the FastAPI app is defined and run.
+* **models/ (Directory):**  Contains Pydantic models for data validation and defining data structures used throughout the application.  
+    - `query.py`:  Defines models for user queries.
+    - `product.py`:  Defines models for representing product data.
+    - `customer.py`:  Defines models for representing customer data.
+    - `order.py`:  Defines models for representing order data. 
+* **services/ (Directory):**  Encapsulates the core business logic of the application.  
+    - `elasticsearch.py`:  Handles interactions with the Elasticsearch instance for product searches.
+    - `nlp.py`:  Provides functionalities for Natural Language Processing (NLP) to understand user intent.
+    - `utils.py`: Provides functions that are used by several components of the system. 
+* **routes/ (Directory):**  Defines API endpoints for interacting with the chatbot functionalities. Each feature has its dedicated module:  
+    - `search_products.py`:  Handles routes related to product search functionalities.
+    - `query_handler`:  Handles routes related to the processing of the query introduced by users. 
+    - `purchase.py`:  Handles routes related to purchase functionalities (add to cart, checkout, etc.).
+    - `order_management.py`:  Handles routes related to managing orders (tracking, history).
+    - `account_management.py`:  Handles routes related to account management (sign-in, update information).
+    - `customer_support.py`:  Handles routes related to customer support functionalities (returns, payments, etc.).
+
+This modular structure promotes separation of concerns, making the code easier to understand, maintain, and extend in the future. 
+
+**Getting Started:**
+
+(Provide instructions on how to set up and run the application, including any dependencies or environment variables required.)
+
+**Further Development:**
+
+* Generating more comprehensive responses based on intent, entities, and search results.
+* Enhance security features for handling sensitive user data.
+* Implement user authentication and authorization mechanisms.

gradio_app.py

@@ -0,0 +1,41 @@
+import gradio as gr
+import requests
+
+
+def fastlane_agent(message, history):
+
+    history_openai_format = [
+        {"role": "system", "content": "You are an assistant for an eCommerce store."}]
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append(
+            {"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = requests.post(
+        "http://localhost:8000/query-handler/", json={"text": message, "history": history_openai_format})
+    if response.status_code == 200:
+        return  response.json().get("generative response")
+    else:
+        return "Error: Could not fetch response."
+
+
+iface = gr.ChatInterface(
+    fn=fastlane_agent,
+    chatbot=gr.Chatbot(height=400),
+    textbox=gr.Textbox(
+        placeholder="How can I help you?", container=False, scale=7
+    ),
+    title="Fastlane Chat GPT",
+    description="AI sales assistance for e-commmerce",
+    theme="soft",
+    examples=["Hello", "What is the status of my order?",
+              "Recommend me products"],
+    cache_examples=True,
+    retry_btn=None,
+    undo_btn="Delete Previous",
+    clear_btn="Clear"
+)
+
+if __name__ == "__main__":
+    iface.launch()

gradio_cached_examples/15/log.csv

@@ -0,0 +1,4 @@
+component 0,flag,username,timestamp
+"[[""Hello"", ""Hello! How can I assist you today?""]]",,,2024-06-11 20:45:46.202912
+"[[""What is the status of my order?"", ""Could you please provide me with your order number so I can check the status for you?""]]",,,2024-06-11 20:45:50.095791
+"[[""Recommend me products"", ""Error: Could not fetch response.""]]",,,2024-06-11 20:46:01.780475

main.py

@@ -0,0 +1,20 @@
+from fastapi import FastAPI
+from routes import query_handler, purchase, order_management, account_management, customer_support, search_products
+
+app = FastAPI()
+
+app.include_router(purchase.router, prefix="/purchase", tags=["purchase"])
+app.include_router(order_management.router,
+                   prefix="/order-management", tags=["order-management"])
+app.include_router(account_management.router,
+                   prefix="/account-management", tags=["account-management"])
+app.include_router(customer_support.router,
+                   prefix="/customer-support", tags=["customer-support"])
+app.include_router(search_products.router,
+                   prefix="/search-products", tags=["search-products"])
+app.include_router(query_handler.router,
+                   prefix="/query-handler", tags=["query-handler"])
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models/customer.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class Customer(BaseModel):
+    customer_id: str
+    name: str
+    email: str
+    address: str
+    phone: Optional[str] = None
+    orders: Optional[List[str]] = None

models/order.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class Order(BaseModel):
+    order_id: str
+    product_ids: list
+    quantities: list
+    status: str

models/product.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class Product(BaseModel):
+    product_id: str
+    title: str
+    description: str
+    price: float
+    category: str
+    tags: Optional[List[str]] = None

models/query.py

@@ -0,0 +1,10 @@
+from typing import Optional, List, Dict
+from pydantic import BaseModel
+
+
+class Query(BaseModel):
+    text: str
+    intent: Optional[str] = None
+    entities: Optional[Dict] = None
+    keywords: Optional[List] = None
+    history: Optional[List[Dict[str, str]]] = None

requirements.txt

@@ -0,0 +1,11 @@
+elasticsearch
+en-core-web-lg @ https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.0.0/en_core_web_lg-3.0.0.tar.gz
+fastapi
+gradio
+nltk
+openai
+pydantic
+spacy
+torch
+transformers
+uvicorn[standard]

routes/account_management.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, status, HTTPException
+from models.query import Query
+from services.elasticsearch import get_customer, update_customer
+
+router = APIRouter()
+
+
+@router.post("/sign-in-up")
+def handle_sign_in_up(query: Query):
+    customer_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'customer_id'), None)
+    if customer_id:
+        customer = get_customer(customer_id)
+        if not customer:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Customer not found")
+        return customer
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer ID not provided.")
+
+
+@router.post("/update-account")
+def handle_update_account(query: Query):
+    customer_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'customer_id'), None)
+    updates = {entity['entity']: entity['value'] for entity in query.entities}
+    if customer_id:
+        update_customer(customer_id, updates)
+        return {"message": "Account information updated successfully"}
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer ID not provided.")

routes/customer_support.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from models.query import Query
+from services.nlp import generate_response
+
+router = APIRouter()
+
+
+@router.post("/get-help")
+def handle_get_help(query: Query):
+    response_text = generate_response(
+        {"query": query.text, "intent": "Get help"})
+    return {"response": response_text[0]['generated_text']}
+
+
+@router.get("/return-exchange-policy")
+def handle_return_exchange_policy():
+    return {"policy": "Our return/exchange policy details go here"}
+
+
+@router.get("/payment-options")
+def handle_payment_options():
+    return {"payment_options": ["Credit Card", "PayPal", "Bank Transfer"]}
+
+
+@router.get("/shipping-information")
+def handle_shipping_information():
+    return {"shipping_info": "Shipping costs and delivery times details go here"}

routes/order_management.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, status, HTTPException
+from services.elasticsearch import get_order_details, get_customer
+
+router = APIRouter()
+
+
+@router.get("/track-order/{order_id}")
+def handle_track_order(order_id: str):
+    order = get_order_details(order_id)
+    if not order:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Order not found")
+    return order
+
+
+@router.get("/order-history")
+def view_order_history(customer_id: str):
+    customer = get_customer(customer_id)
+    if not customer:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer not found")
+    # Retrieve order history from customer data
+    return {"order_history": customer.get("orders", [])}

routes/purchase.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, status, HTTPException
+from models.query import Query
+from services.elasticsearch import add_to_cart, view_cart, remove_from_cart, checkout
+
+router = APIRouter()
+
+
+@router.post("/add-to-cart")
+def handle_add_to_cart(query: Query):
+    customer_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'customer_id'), None)
+    product_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'product_id'), None)
+    quantity = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'quantity'), 1)
+    if customer_id and product_id:
+        cart = add_to_cart(customer_id, product_id, int(quantity))
+        return cart
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer ID or Product ID not provided.")
+
+
+@router.get("/view-cart/{customer_id}")
+def handle_view_cart(customer_id: str):
+    cart = view_cart(customer_id)
+    if not cart:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cart not found")
+    return cart
+
+
+@router.post("/remove-from-cart")
+def handle_remove_from_cart(query: Query):
+    customer_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'customer_id'), None)
+    product_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'product_id'), None)
+    if customer_id and product_id:
+        cart = remove_from_cart(customer_id, product_id)
+        return cart
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer ID or Product ID not provided.")
+
+
+@router.post("/checkout")
+def handle_checkout(query: Query):
+    customer_id = next(
+        (entity['value'] for entity in query.entities if entity['entity'] == 'customer_id'), None)
+    if customer_id:
+        order = checkout(customer_id)
+        return order
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Customer ID not provided.")

routes/query_handler.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, status, HTTPException
+from models.query import Query
+from routes import search_products, purchase, order_management, account_management, customer_support
+from services.nlp import recognize_intent, recognize_entities, extract_keywords, generate_response
+from services.utils import clean_text, encode_and_normalize, extract_order_id_from_query
+
+
+router = APIRouter()
+
+
+FUNCTION_DESCRIPTIONS_FOR_PRODUCTS = {
+    "search_products_by_keywords": "User wants to find products based on keywords",
+    "search_products_by_filters": "User wants to refine search results with filters",
+    "get_product_details": "User wants detailed information about a specific product"
+}
+
+FUNCTION_DESCRIPTIONS_FOR_ORDERS = {
+    "get_order_location": "Find the location (city or state) of a specific order using an identification number order",
+    "get_recent_order": "Track the most recent order of a customer",
+    "get_order_details": "Get details about a specific order using an identification number order",
+    "get_order_quantity": "Calculate the total number of products in a specific order",
+    "get_order_amount": "Calculate the total amount spent in a specific order",
+    "cancel_order": "Process order cancellation requests"
+}
+
+
+def query_processing(query: Query):
+    cleaned_text = clean_text(query.text)
+    query.intent = recognize_intent(cleaned_text)
+    query.entities = recognize_entities(cleaned_text)
+    query.keywords = extract_keywords(cleaned_text)
+    encoded_query = encode_and_normalize(cleaned_text)
+
+    if query.intent == "search for products":
+        return {"products": search_products.handle_search_products_by_keywords(encoded_query)}
+
+    elif query.intent == "order management":
+        order_id = extract_order_id_from_query(query.text)
+        if order_id:
+            return order_management.handle_track_order(order_id)
+        else:
+            return "Please provide an Order Number"
+    else:
+        return None
+
+
+@router.post("/")
+async def handle_response(query: Query):
+    context_from_elasticsearch = query_processing(query)
+    return {"generative response": generate_response(query, context_from_elasticsearch)}

routes/search_products.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter, HTTPException
+from services.elasticsearch import search_products_by_keywords, search_products_by_filters, get_product_details
+
+router = APIRouter()
+
+
+@router.post("/")
+def handle_search_products_by_keywords(encoded_query: list):
+    products = search_products_by_keywords(encoded_query)
+    if not products:
+        raise HTTPException(status_code=404, detail="No products to recommend")
+    return products

services/elasticsearch.py

@@ -0,0 +1,137 @@
+import os
+from elasticsearch import Elasticsearch
+from elasticsearch_dsl import Search
+from models.product import Product
+from models.customer import Customer
+from models.order import Order
+
+cloud_id = os.getenv("ELASTICSEARCH_CLOUD_ID")
+api_key = os.getenv("ELASTICSEARCH_API_KEY")
+
+try:
+    es = Elasticsearch(cloud_id=cloud_id, api_key=api_key)
+
+except ConnectionError as e:
+    print("Error:", e)
+
+
+def search_elasticsearch(index, query):
+    response = es.search(index=index, body={
+        "query": {
+            "multi_match": {
+                "query": query,
+                "fields": ["title", "description", "category", "tags"]
+            }
+        }
+    })
+    return response['hits']['hits']
+
+
+def search_products_by_keywords(encoded_query):
+    body_query = {
+        "_source": ["ProductName", "Description", "Gender", "Price (INR)", "PrimaryColor"],
+        "knn": {
+            "field": "DescriptionVector",
+            "query_vector": encoded_query,
+            "k": 4,
+            "num_candidates": 500
+        }
+    }
+
+    response = es.search(index='products', body=body_query)
+    return response['hits']['hits']
+
+
+def search_products_by_filters(filters):
+    response = es.search(index='products', body={
+        "query": {
+            "bool": {
+                "filter": filters
+            }
+        }
+    })
+    return response['hits']['hits']
+
+
+def get_product_details(product_id):
+    response = es.get(index='products', id=product_id)
+    return response['_source']
+
+
+def index_product(product: Product):
+    es.index(index="products", id=product.product_id, body=product.dict())
+
+
+def index_customer(customer: Customer):
+    es.index(index="customers", id=customer.customer_id, body=customer.dict())
+
+
+def get_customer(customer_id: str):
+    response = es.get(index="customers", id=customer_id)
+    return response['_source']
+
+
+def update_customer(customer_id: str, updates: dict):
+    es.update(index="customers", id=customer_id, body={"doc": updates})
+
+
+def index_order(order: Order):
+    es.index(index="orders", id=order.order_id, body=order.dict())
+
+
+def track_order(order_id: str):
+    response = es.get(index="orders", id=order_id)
+    return response['_source']
+
+
+def get_order_details(order_id):
+    s_order = Search(using=es, index='orders').query(
+        'match', **{'Order ID': order_id})
+    s_details = Search(using=es, index='order_details').query(
+        'match', **{'Order ID': order_id})
+    order_response = s_order.execute()
+    details_response = s_details.execute()
+
+    if order_response.hits.total.value > 0 and details_response.hits.total.value > 0:
+        order = order_response.hits[0].to_dict()
+        details = [detail.to_dict() for detail in details_response.hits]
+        return {
+            "order": order,
+            "details": details
+        }
+    else:
+        return "Order not found"
+
+
+def add_to_cart(customer_id: str, product_id: str, quantity: int):
+    cart = es.get(index="carts", id=customer_id)['_source']
+    if 'items' not in cart:
+        cart['items'] = []
+    cart['items'].append({"product_id": product_id, "quantity": quantity})
+    es.index(index="carts", id=customer_id, body=cart)
+    return cart
+
+
+def view_cart(customer_id: str):
+    response = es.get(index="carts", id=customer_id)
+    return response['_source']
+
+
+def remove_from_cart(customer_id: str, product_id: str):
+    cart = es.get(index="carts", id=customer_id)['_source']
+    cart['items'] = [item for item in cart['items']
+                     if item['product_id'] != product_id]
+    es.index(index="carts", id=customer_id, body=cart)
+    return cart
+
+
+def checkout(customer_id: str):
+    cart = es.get(index="carts", id=customer_id)['_source']
+    order = {
+        "customer_id": customer_id,
+        "items": cart['items'],
+        "status": "processing"
+    }
+    es.index(index="orders", body=order)
+    es.delete(index="carts", id=customer_id)
+    return order

services/nlp.py

@@ -0,0 +1,71 @@
+import os
+from openai import OpenAI
+from models.query import Query
+import re
+from transformers import pipeline
+from services.utils import clean_text, encode_and_normalize
+
+intent_recognizer = pipeline(
+    "zero-shot-classification", model="facebook/bart-large-mnli")
+
+ner_recognizer = pipeline(
+    'ner', model='dbmdz/bert-large-cased-finetuned-conll03-english')
+
+openai_key = os.environ.get("OPENAI_KEY")
+openai_client = OpenAI(api_key=openai_key)
+
+# Define regex patterns for entities
+patterns = {
+    'Product': r'\b(iphone|samsung|macbook|ps5|galaxy|pixel|shoes|shampoo|cellphone|smartphone|tablet|laptop|headphones|console|tv|camera)\b',
+    'Brand': r'\b(apple|samsung|google|sony|microsoft|dell|hp|lenovo|asus|nintendo|canon|nikon)\b',
+    'Category': r'\b(laptops|dresses|phones|electronics|clothing|footwear|accessories|home appliances|furniture)\b',
+    'Color': r'\b(red|black|yellow|blue|green|white|grey|pink|purple|orange|brown)\b',
+    'Price Range': r'\b(under \$?\d+|below \$?\d+|less than \$?\d+|more than \$?\d+|above \$?\d+|between \$?\d+ and \$?\d+)\b',
+    'Quantity': r'\b(\d+ bottles|\d+ items|\d+ pieces|\d+ units|\d+)\b',
+    'Order Number': r'\bB-\d+\b',
+    'Issue': r'\b(account help|payment issue|order problem|shipping delay|return request|product complaint|technical support)\b'
+}
+
+INTENTS = [
+    "search for products",
+    "order management",
+    "checkout",
+    "customer support",
+    "account management"
+]
+
+
+def recognize_intent(text):
+    cleaned_text = clean_text(text)
+    intent = intent_recognizer(cleaned_text, INTENTS)
+    return intent['labels'][0]
+
+
+def recognize_entities(text):
+    cleaned_text = clean_text(text)
+    entities_from_ner = ner_recognizer(cleaned_text)
+    entities_from_re = {entity: re.findall(pattern, text.lower(
+    )) for entity, pattern in patterns.items() if re.findall(pattern, text.lower())}
+
+    return entities_from_re
+
+
+def extract_keywords(text):
+    cleaned_text = clean_text(text)
+    return cleaned_text.split()
+
+
+def generate_response(query: Query, context_from_elasticsearch):
+    prompt = query.history
+    prompt.append({"role": "assistant", "content": str(context_from_elasticsearch)})
+
+    print(prompt)
+
+    response = openai_client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=prompt
+    )
+
+    return response.choices[0].message.content
+
+    

services/utils.py

@@ -0,0 +1,37 @@
+import re
+import numpy as np
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from sentence_transformers import SentenceTransformer
+
+stop_words = set(stopwords.words('english'))
+lemmatizer = WordNetLemmatizer()
+model = SentenceTransformer('all-mpnet-base-v2')
+
+
+def clean_text(text):
+    # Lowercase
+    text = text.lower()
+    # Remove special characters and digits
+    text = re.sub(r'[^a-z\s]', '', text)
+    # Tokenize
+    words = word_tokenize(text)
+    # Remove stopwords and lemmatize
+    words = [lemmatizer.lemmatize(word)
+             for word in words if word not in stop_words]
+    # Join words back to a single string
+    cleaned_text = ' '.join(words)
+    return cleaned_text
+
+
+def encode_and_normalize(text):
+    vector = model.encode(text)
+    normalized_vector = vector / np.linalg.norm(vector)
+    return normalized_vector
+
+def extract_order_id_from_query(text):
+    match = re.search(r'\bB-\d+\b', text)
+    if match:
+        return match.group(0)
+    return None