"LOL"

app.py

@@ -0,0 +1,31 @@
+import gradio as gr
+from src.chatbot import RestaurantChatbot
+
+chatbot = RestaurantChatbot()
+chat_history = []
+
+def respond(user_message, history):
+    response, retrieved_docs = chatbot.answer(user_message)
+
+    bot_response = f"{response}\n\n**Nhà hàng gợi ý:**\n"
+    if retrieved_docs:
+        for doc in retrieved_docs:
+            bot_response += (
+                f"- **{doc['name']} ({doc['cuisine']})**\n"
+                f"  - Món ăn: {', '.join(doc['dishes'])}\n"
+                f"  - Giá: {doc['price_range']}\n"
+                f"  - Khoảng cách: {doc['distance']} km\n"
+                f"  - Đánh giá: {doc['rating']}\n"
+                f"  - Địa chỉ: {doc['address']}\n"
+                f"  - Mô tả: {doc['description']}\n"
+            )
+    else:
+        bot_response += "- Không tìm thấy nhà hàng phù hợp."
+
+    return bot_response
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Chatbot Gợi ý Quán ăn")
+    chatbot_ui = gr.ChatInterface(fn=respond, chatbot=gr.Chatbot())
+
+demo.launch()

chatbot.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from typing import Tuple, List, Dict, Any
+from src.utils.data_loader import load_restaurant_data
+from src.utils.query_parser import QueryParser
+from src.embeddings.embedder import Embedder
+from src.retrieval.vector_store import VectorStore
+from src.retrieval.keyword_filter import filter_restaurants
+from src.retrieval.hybrid_search import HybridRetriever
+from src.generation.llm import LLM
+from langchain_core.embeddings import Embeddings
+
+class LangChainEmbeddingWrapper(Embeddings):
+    def __init__(self, embedder):
+        self.embedder = embedder
+    
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self.embedder.embed(texts).tolist()
+    
+    def embed_query(self, text: str) -> List[float]:
+        return self.embedder.embed([text])[0].tolist()
+
+class RestaurantChatbot:
+    def __init__(self, data_path: str = "data/restaurants.json"):
+        """
+        Initialize the restaurant chatbot.
+        
+        Args:
+            data_path (str): Path to the restaurant JSON file.
+        """
+        self.df = load_restaurant_data(data_path)
+        self.embedder = Embedder()
+        self.embedding_wrapper = LangChainEmbeddingWrapper(self.embedder)
+        self.vector_store = VectorStore(embedding_function=self.embedding_wrapper)
+        self.llm = LLM()
+        self.parser = QueryParser(self.df)
+        
+        embeddings = self.embedder.embed(self.df['text'].tolist())
+        self.vector_store.add_documents(
+            documents=self.df['text'].tolist(),
+            embeddings=embeddings.tolist(),
+            ids=[str(i) for i in self.df['id']]
+        )
+        
+        self.retriever = HybridRetriever(self.df, self.vector_store, self.embedder)
+    
+    def answer(self, query: str) -> Tuple[str, List[Dict[str, Any]]]:
+        """
+        Process a user query and return a natural, concise response with recommended restaurants.
+        
+        Args:
+            query (str): User query.
+        
+        Returns:
+            Tuple[str, List[Dict[str, Any]]]: Natural response text and list of recommended restaurants.
+        """
+        parsed_query = self.parser.parse_query(query)
+        filtered_df = filter_restaurants(self.df, parsed_query)
+        description = parsed_query["description"] if parsed_query["description"] else query
+        
+        if filtered_df.empty:
+            retrieved_docs = self.retriever.retrieve(description, self.df, top_k=3)
+        else:
+            retrieved_docs = self.retriever.retrieve(description, filtered_df, top_k=3)
+        
+        if not retrieved_docs:
+            return "Mình không tìm được nhà hàng nào phù hợp. Bạn thử đổi tiêu chí xem, như mở rộng khoảng cách hoặc loại món ăn nhé!", []
+        
+        # Create context for LLM
+        context = "\n".join([
+            f"- {doc['name']} ({doc['cuisine']}): {', '.join(doc['dishes'])}. "
+            f"Price: {doc['price_range']}, Distance: {doc['distance']} km, Rating: {doc['rating']}. "
+            f"Description: {doc['description']}"
+            for doc in retrieved_docs
+        ])
+        
+        # Prompt for natural, consultant-like response
+        prompt = (
+            f"Bạn là một người tư vấn nhà hàng thân thiện. Dựa trên truy vấn và danh sách nhà hàng, hãy gợi ý ngắn gọn, tự nhiên, như trò chuyện với bạn bè, giải thích tại sao chọn các nhà hàng này (tập trung vào món ăn, giá, khoảng cách, hoặc đánh giá phù hợp với truy vấn). Không lặp lại truy vấn hoặc dùng ngôn ngữ kỹ thuật. Chỉ dùng thông tin từ danh sách nhà hàng.\n\n"
+            f"Truy vấn: {query}\n\n"
+            f"Danh sách nhà hàng:\n{context}\n\n"
+            f"Phản hồi:"
+        )
+        
+        response = self.llm.generate(prompt, max_length=200)
+        return response, retrieved_docs

data/restaurants.json

@@ -0,0 +1,162 @@
+[
+    {
+        "id": 1,
+        "name": "Phở Hà Nội",
+        "cuisine": "Vietnamese",
+        "distance": 1.2,
+        "price_range": "medium",
+        "dishes": ["phở", "bún chả", "bánh mì", "gỏi cuốn"],
+        "rating": 4.5,
+        "address": "123 Nguyễn Huệ, Quận 1, TP.HCM, Việt Nam",
+        "description": "A cozy spot offering authentic Vietnamese phở with rich broth and fresh herbs.",
+        "dietary_options": ["vegetarian"],
+        "service_type": ["dine-in", "takeout"],
+        "kid_friendly": true,
+        "outdoor_seating": false,
+        "alcohol": false
+    },
+    {
+        "id": 2,
+        "name": "Pizza 4P's",
+        "cuisine": "Italian",
+        "distance": 2.5,
+        "price_range": "high",
+        "dishes": ["pizza", "pasta", "tiramisu", "salad"],
+        "rating": 4.8,
+        "address": "8/15 Lê Thánh Tôn, Quận 1, TP.HCM, Việt Nam",
+        "description": "Upscale Italian dining with artisanal pizzas and a vibrant atmosphere.",
+        "dietary_options": ["vegetarian", "gluten-free"],
+        "service_type": ["dine-in", "delivery"],
+        "kid_friendly": true,
+        "outdoor_seating": true,
+        "alcohol": true
+    },
+    {
+        "id": 3,
+        "name": "Sushi Bar",
+        "cuisine": "Japanese",
+        "distance": 3.0,
+        "price_range": "high",
+        "dishes": ["sushi", "sashimi", "ramen", "tempura"],
+        "rating": 4.3,
+        "address": "45 Lý Tự Trọng, Quận 1, TP.HCM, Việt Nam",
+        "description": "Authentic Japanese sushi with fresh fish and a modern ambiance.",
+        "dietary_options": [],
+        "service_type": ["dine-in"],
+        "kid_friendly": false,
+        "outdoor_seating": false,
+        "alcohol": true
+    },
+    {
+        "id": 4,
+        "name": "Bún Bò Huế An Nam",
+        "cuisine": "Vietnamese",
+        "distance": 0.8,
+        "price_range": "low",
+        "dishes": ["bún bò huế", "bánh bèo", "bánh nậm"],
+        "rating": 4.0,
+        "address": "78 Pasteur, Quận 1, TP.HCM, Việt Nam",
+        "description": "A local favorite for spicy Huế-style noodle soups with bold flavors.",
+        "dietary_options": [],
+        "service_type": ["dine-in", "takeout"],
+        "kid_friendly": true,
+        "outdoor_seating": false,
+        "alcohol": false
+    },
+    {
+        "id": 5,
+        "name": "Thai Spice",
+        "cuisine": "Thai",
+        "distance": 4.5,
+        "price_range": "medium",
+        "dishes": ["tom yum", "pad thai", "green curry", "mango sticky rice"],
+        "rating": 4.2,
+        "address": "12 Nguyễn Đình Chiểu, Đa Kao, Quận 1, TP.HCM, Việt Nam",
+        "description": "Vibrant Thai restaurant with spicy curries and refreshing tropical desserts.",
+        "dietary_options": ["vegetarian", "vegan"],
+        "service_type": ["dine-in", "delivery", "takeout"],
+        "kid_friendly": true,
+        "outdoor_seating": true,
+        "alcohol": true
+    },
+    {
+        "id": 6,
+        "name": "La Fiesta",
+        "cuisine": "Mexican",
+        "distance": 2.0,
+        "price_range": "medium",
+        "dishes": ["tacos", "burrito", "quesadilla", "guacamole"],
+        "rating": 4.1,
+        "address": "33 Tôn Thất Thiệp, Quận 1, TP.HCM, Việt Nam",
+        "description": "Lively Mexican eatery with colorful decor and flavorful tacos.",
+        "dietary_options": ["vegetarian"],
+        "service_type": ["dine-in", "delivery"],
+        "kid_friendly": true,
+        "outdoor_seating": true,
+        "alcohol": true
+    },
+    {
+        "id": 7,
+        "name": "The Vegan Garden",
+        "cuisine": "Vegan",
+        "distance": 5.0,
+        "price_range": "medium",
+        "dishes": ["vegan phở", "tofu curry", "quinoa salad"],
+        "rating": 4.6,
+        "address": "20 Võ Văn Tần, Quận 3, TP.HCM, Việt Nam",
+        "description": "A serene vegan restaurant offering plant-based Vietnamese and international dishes.",
+        "dietary_options": ["vegan", "gluten-free"],
+        "service_type": ["dine-in", "takeout"],
+        "kid_friendly": true,
+        "outdoor_seating": false,
+        "alcohol": false
+    },
+    {
+        "id": 8,
+        "name": "Le Petit Paris",
+        "cuisine": "French",
+        "distance": 1.5,
+        "price_range": "high",
+        "dishes": ["croissant", "coq au vin", "crème brûlée"],
+        "rating": 4.7,
+        "address": "56 Đồng Khởi, Quận 1, TP.HCM, Việt Nam",
+        "description": "Elegant French bistro with classic dishes and a romantic ambiance.",
+        "dietary_options": [],
+        "service_type": ["dine-in"],
+        "kid_friendly": false,
+        "outdoor_seating": true,
+        "alcohol": true
+    },
+    {
+        "id": 9,
+        "name": "Chaat House",
+        "cuisine": "Indian",
+        "distance": 3.8,
+        "price_range": "medium",
+        "dishes": ["butter chicken", "naan", "paneer tikka", "biryani"],
+        "rating": 4.4,
+        "address": "15 Lê Lợi, Quận 1, TP.HCM, Việt Nam",
+        "description": "Authentic Indian cuisine with rich spices and a warm atmosphere.",
+        "dietary_options": ["vegetarian", "vegan"],
+        "service_type": ["dine-in", "delivery", "takeout"],
+        "kid_friendly": true,
+        "outdoor_seating": false,
+        "alcohol": false
+    },
+    {
+        "id": 10,
+        "name": "BBQ Haven",
+        "cuisine": "American",
+        "distance": 6.0,
+        "price_range": "medium",
+        "dishes": ["ribs", "burger", "fries", "coleslaw"],
+        "rating": 4.0,
+        "address": "88 Nguyễn Trãi, Quận 5, TP.HCM, Việt Nam",
+        "description": "Casual American BBQ spot with smoky ribs and hearty burgers.",
+        "dietary_options": [],
+        "service_type": ["dine-in", "delivery"],
+        "kid_friendly": true,
+        "outdoor_seating": true,
+        "alcohol": true
+    }
+]

embeddings/embedder.py

@@ -0,0 +1,17 @@
+from transformers import AutoTokenizer, AutoModel
+import torch
+import numpy as np
+from typing import List
+
+class Embedder:
+    def __init__(self, model_name: str = "BAAI/bge-m3"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+
+    def embed(self, texts: List[str]) -> np.ndarray:
+        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        embeddings = outputs.last_hidden_state[:, 0]  # lấy embedding từ CLS token
+        embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+        return embeddings.cpu().numpy()

generation/llm.py

@@ -0,0 +1,149 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from langchain_core.prompts import PromptTemplate
+import os
+from typing import List
+
+class LLM:
+    def __init__(self, model_repo: str = "Qwen/Qwen2-1.5B-Instruct", 
+                 local_path: str = "models"):
+        """
+        Initialize the LLM with Qwen2-1.5B-Instruct using Hugging Face Transformers.
+
+        Args:
+            model_repo (str): Hugging Face repository ID for the model.
+            local_path (str): Local directory to store the model.
+        """
+        os.makedirs(local_path, exist_ok=True)
+        
+        try:
+            # Load the model
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                model_repo,
+                device_map="auto",  # Automatically map to CPU
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            
+            # Load the tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_repo,
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            print(f"Model successfully loaded from {model_repo}")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to initialize model from {model_repo}. "
+                f"Please ensure the model is available at https://huggingface.co/{model_repo}. "
+                f"Error: {str(e)}"
+            )
+        
+        # Define prompt template for query parsing (used in query_parser.py)
+        self.prompt_template = PromptTemplate(
+            template="""Bạn là một trợ lý phân tích truy vấn nhà hàng. Phân tích truy vấn sau và trích xuất các đặc trưng: cuisine, menu, price_range, distance, rating, và description. Chỉ trích xuất các giá trị khớp chính xác với danh sách giá trị hợp lệ. Nếu không tìm thấy giá trị khớp, trả về null (hoặc [] cho menu). Loại bỏ các từ khóa đã trích xuất khỏi description. Trả về kết quả dưới dạng JSON.
+
+                    **Danh sách giá trị hợp lệ**:
+                    - cuisine: {cuisines}
+                    - menu: {dishes}
+                    - price_range: {price_ranges}
+
+                    **Hướng dẫn**:
+                    - cuisine: Chỉ chọn giá trị từ danh sách cuisine. Ví dụ, "Viet" → "Vietnamese".
+                    - menu: Chỉ chọn các món khớp chính xác với danh sách menu. Ví dụ, "phở bò" → "phở", "sushi" → [].
+                    - price_range: Chỉ chọn {price_ranges}. Ví dụ, "cheap" → "low".
+                    - distance: Trích xuất số km (e.g., "2 km" → 2.0) hoặc từ khóa ["nearby", "close" → 2.0, "far" → 10.0]. Nếu không rõ, trả về null.
+                    - rating: Trích xuất số (e.g., "4 stars" → 4.0). Nếu không rõ, trả về null.
+                    - description: Phần còn lại sau khi loại bỏ các từ khóa đã trích xuất. Nếu rỗng, trả về truy vấn gốc.
+
+                    **Truy vấn**: {query}
+
+                    **Định dạng đầu ra**:
+                    {{
+                    "cuisine": null | "tên loại ẩm thực",
+                    "menu": [],
+                    "price_range": null | "low" | "medium" | "high",
+                    "distance": null | số km | "nearby" | "close" | "far",
+                    "rating": null | số,
+                    "description": "phần mô tả còn lại"
+                    }}
+                    """,
+            input_variables=["cuisines", "dishes", "price_ranges", "query"]
+        )
+    
+    def generate(self, prompt: str, max_length: int = 1000) -> str:
+        """
+        Generate text using the LLM.
+        
+        Args:
+            prompt (str): Input prompt.
+            max_length (int): Maximum length of the generated text.
+        
+        Returns:
+            str: Generated text.
+        """
+        try:
+            # Apply chat template for instruction-tuned Qwen model
+            messages = [{"role": "user", "content": prompt}]
+            prompt_with_template = self.tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            # Tokenize input prompt
+            inputs = self.tokenizer(prompt_with_template, return_tensors="pt").to(self.llm.device)
+            # Generate text
+            outputs = self.llm.generate(
+                **inputs,
+                max_new_tokens=max_length,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            # Decode the generated tokens
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            print("Response generated successfully!")
+            return response.strip()
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate response: {str(e)}")
+    
+    def format_query_prompt(self, query: str, cuisines: List[str], dishes: List[str], price_ranges: List[str]) -> str:
+        """
+        Format the prompt for query parsing using the prompt template.
+        
+        Args:
+            query (str): User query.
+            cuisines (list): List of valid cuisines.
+            dishes (list): List of valid dishes.
+            price_ranges (list): List of valid price ranges.
+        
+        Returns:
+            str: Formatted prompt.
+        """
+        return self.prompt_template.format(
+            cuisines=cuisines,
+            dishes=dishes,
+            price_ranges=price_ranges,
+            query=query
+        )
+
+if __name__ == "__main__":
+    # Khởi tạo đối tượng LLM với model_repo và local_path
+    local_path = 'models'
+    
+    try:
+        # Khởi tạo đối tượng LLM
+        llm = LLM(local_path=local_path)
+
+        # Định nghĩa một truy vấn và các tham số cần thiết
+        query = "Tìm quán ăn Việt Nam gần đây, giá rẻ với món phở và cơm tấm"
+        cuisines = ["Vietnamese", "Chinese", "Italian"]
+        dishes = ["phở", "sushi", "pasta", "cơm tấm"]
+        price_ranges = ["low", "medium", "high"]
+
+        # Sử dụng hàm generate để tạo câu trả lời từ truy vấn
+        generated_text = llm.generate(query, max_length=300)
+
+        # In kết quả ra màn hình
+        print("Generated text:")
+        print(generated_text)
+
+    except Exception as e:
+        print(f"Error: {str(e)}")

llm.py

@@ -0,0 +1,149 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from langchain_core.prompts import PromptTemplate
+import os
+from typing import List
+
+class LLM:
+    def __init__(self, model_repo: str = "Qwen/Qwen2-1.5B-Instruct", 
+                 local_path: str = "models"):
+        """
+        Initialize the LLM with Qwen2-1.5B-Instruct using Hugging Face Transformers.
+
+        Args:
+            model_repo (str): Hugging Face repository ID for the model.
+            local_path (str): Local directory to store the model.
+        """
+        os.makedirs(local_path, exist_ok=True)
+        
+        try:
+            # Load the model
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                model_repo,
+                device_map="auto",  # Automatically map to CPU
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            
+            # Load the tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_repo,
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            print(f"Model successfully loaded from {model_repo}")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to initialize model from {model_repo}. "
+                f"Please ensure the model is available at https://huggingface.co/{model_repo}. "
+                f"Error: {str(e)}"
+            )
+        
+        # Define prompt template for query parsing (used in query_parser.py)
+        self.prompt_template = PromptTemplate(
+            template="""Bạn là một trợ lý phân tích truy vấn nhà hàng. Phân tích truy vấn sau và trích xuất các đặc trưng: cuisine, menu, price_range, distance, rating, và description. Chỉ trích xuất các giá trị khớp chính xác với danh sách giá trị hợp lệ. Nếu không tìm thấy giá trị khớp, trả về null (hoặc [] cho menu). Loại bỏ các từ khóa đã trích xuất khỏi description. Trả về kết quả dưới dạng JSON.
+
+                    **Danh sách giá trị hợp lệ**:
+                    - cuisine: {cuisines}
+                    - menu: {dishes}
+                    - price_range: {price_ranges}
+
+                    **Hướng dẫn**:
+                    - cuisine: Chỉ chọn giá trị từ danh sách cuisine. Ví dụ, "Viet" → "Vietnamese".
+                    - menu: Chỉ chọn các món khớp chính xác với danh sách menu. Ví dụ, "phở bò" → "phở", "sushi" → [].
+                    - price_range: Chỉ chọn {price_ranges}. Ví dụ, "cheap" → "low".
+                    - distance: Trích xuất số km (e.g., "2 km" → 2.0) hoặc từ khóa ["nearby", "close" → 2.0, "far" → 10.0]. Nếu không rõ, trả về null.
+                    - rating: Trích xuất số (e.g., "4 stars" → 4.0). Nếu không rõ, trả về null.
+                    - description: Phần còn lại sau khi loại bỏ các từ khóa đã trích xuất. Nếu rỗng, trả về truy vấn gốc.
+
+                    **Truy vấn**: {query}
+
+                    **Định dạng đầu ra**:
+                    {{
+                    "cuisine": null | "tên loại ẩm thực",
+                    "menu": [],
+                    "price_range": null | "low" | "medium" | "high",
+                    "distance": null | số km | "nearby" | "close" | "far",
+                    "rating": null | số,
+                    "description": "phần mô tả còn lại"
+                    }}
+                    """,
+            input_variables=["cuisines", "dishes", "price_ranges", "query"]
+        )
+    
+    def generate(self, prompt: str, max_length: int = 1000) -> str:
+        """
+        Generate text using the LLM.
+        
+        Args:
+            prompt (str): Input prompt.
+            max_length (int): Maximum length of the generated text.
+        
+        Returns:
+            str: Generated text.
+        """
+        try:
+            # Apply chat template for instruction-tuned Qwen model
+            messages = [{"role": "user", "content": prompt}]
+            prompt_with_template = self.tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            # Tokenize input prompt
+            inputs = self.tokenizer(prompt_with_template, return_tensors="pt").to(self.llm.device)
+            # Generate text
+            outputs = self.llm.generate(
+                **inputs,
+                max_new_tokens=max_length,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            # Decode the generated tokens
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            print("Response generated successfully!")
+            return response.strip()
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate response: {str(e)}")
+    
+    def format_query_prompt(self, query: str, cuisines: List[str], dishes: List[str], price_ranges: List[str]) -> str:
+        """
+        Format the prompt for query parsing using the prompt template.
+        
+        Args:
+            query (str): User query.
+            cuisines (list): List of valid cuisines.
+            dishes (list): List of valid dishes.
+            price_ranges (list): List of valid price ranges.
+        
+        Returns:
+            str: Formatted prompt.
+        """
+        return self.prompt_template.format(
+            cuisines=cuisines,
+            dishes=dishes,
+            price_ranges=price_ranges,
+            query=query
+        )
+
+if __name__ == "__main__":
+    # Khởi tạo đối tượng LLM với model_repo và local_path
+    local_path = 'models'
+    
+    try:
+        # Khởi tạo đối tượng LLM
+        llm = LLM(local_path=local_path)
+
+        # Định nghĩa một truy vấn và các tham số cần thiết
+        query = "Tìm quán ăn Việt Nam gần đây, giá rẻ với món phở và cơm tấm"
+        cuisines = ["Vietnamese", "Chinese", "Italian"]
+        dishes = ["phở", "sushi", "pasta", "cơm tấm"]
+        price_ranges = ["low", "medium", "high"]
+
+        # Sử dụng hàm generate để tạo câu trả lời từ truy vấn
+        generated_text = llm.generate(query, max_length=300)
+
+        # In kết quả ra màn hình
+        print("Generated text:")
+        print(generated_text)
+
+    except Exception as e:
+        print(f"Error: {str(e)}")

requirements.txt

@@ -0,0 +1,7 @@
+gradio 
+pandas
+torch
+transformers
+chromadb
+langchain-core
+rank-bm25

retrieval/hybrid_search.py

@@ -0,0 +1,49 @@
+# src/retrieval/hybrid_search.py
+
+import numpy as np
+from rank_bm25 import BM25Okapi
+from typing import List, Dict, Any
+import pandas as pd
+from src.embeddings.embedder import Embedder
+from src.retrieval.vector_store import VectorStore
+
+class HybridRetriever:
+    def __init__(self, df: pd.DataFrame, vector_store: VectorStore, embedder: Embedder, alpha: float = 0.5):
+        self.df = df
+        self.vector_store = vector_store
+        self.embedder = embedder
+        self.alpha = alpha
+        tokenized_corpus = [doc.lower().split() for doc in df['description']]
+        self.bm25 = BM25Okapi(tokenized_corpus)
+    
+    def retrieve(self, query: str, filtered_df: pd.DataFrame, top_k: int = 3) -> List[Dict[str, Any]]:
+        filtered_indices = filtered_df.index.tolist()
+        filtered_texts = filtered_df['description'].tolist()
+        filtered_ids = [str(row['id']) for _, row in filtered_df.iterrows()]
+        
+        if not filtered_texts:
+            return []
+        
+        query_embedding = self.embedder.embed([query])[0]
+        dense_results = self.vector_store.query(query_embedding, top_k=top_k * 2)
+        dense_ids = [id for id in dense_results['ids'][0] if id in filtered_ids]
+        dense_scores = [1 - dist for dist, id in zip(dense_results['distances'][0], dense_results['ids'][0]) if id in filtered_ids]
+        
+        tokenized_query = query.lower().split()
+        bm25_scores = self.bm25.get_scores(tokenized_query)
+        bm25_scores_filtered = [bm25_scores[i] for i in filtered_indices]
+        bm25_top_k = np.argsort(bm25_scores_filtered)[::-1][:top_k * 2]
+        bm25_ids = [filtered_ids[i] for i in bm25_top_k]
+        bm25_scores = [bm25_scores_filtered[i] for i in bm25_top_k]
+        
+        dense_scores = np.array(dense_scores) / np.max(dense_scores) if dense_scores else dense_scores
+        bm25_scores = np.array(bm25_scores) / np.max(bm25_scores) if bm25_scores else bm25_scores
+        
+        combined_scores = {}
+        for idx, dense_id in enumerate(dense_ids):
+            combined_scores[int(dense_id)] = combined_scores.get(int(dense_id), 0) + self.alpha * dense_scores[idx]
+        for idx, bm25_id in enumerate(bm25_ids):
+            combined_scores[int(bm25_id)] = combined_scores.get(int(bm25_id), 0) + (1 - self.alpha) * bm25_scores[idx]
+        
+        sorted_ids = sorted(combined_scores, key=combined_scores.get, reverse=True)[:top_k]
+        return [self.df[self.df['id'] == id].iloc[0].to_dict() for id in sorted_ids]

retrieval/keyword_filter.py

@@ -0,0 +1,41 @@
+# src/retrieval/keyword_filter.py
+
+import pandas as pd
+from typing import Dict, Any
+
+def filter_restaurants(df: pd.DataFrame, parsed_query: Dict[str, Any]) -> pd.DataFrame:
+    """
+    Filter restaurants based on extracted features from the query.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing restaurant data.
+        parsed_query (Dict[str, Any]): Parsed query with features.
+    
+    Returns:
+        pd.DataFrame: Filtered DataFrame.
+    """
+    filtered_df = df.copy()
+    
+    if parsed_query.get("cuisine"):
+        filtered_df = filtered_df[filtered_df["cuisine"].str.lower() == parsed_query["cuisine"].lower()]
+    
+    if parsed_query.get("menu"):
+        filtered_df = filtered_df[filtered_df["dishes"].apply(
+            lambda dishes: any(item.lower() in [d.lower() for d in dishes] for item in parsed_query["menu"])
+        )]
+    
+    if parsed_query.get("price_range"):
+        filtered_df = filtered_df[filtered_df["price_range"].str.lower() == parsed_query["price_range"].lower()]
+    
+    distance = parsed_query.get("distance")
+    if isinstance(distance, (int, float)):
+        filtered_df = filtered_df[filtered_df["distance"] <= distance]
+    elif distance in ["nearby", "close"]:
+        filtered_df = filtered_df[filtered_df["distance"] <= 2.0]
+    elif distance == "far":
+        filtered_df = filtered_df[filtered_df["distance"] <= 10.0]
+    
+    if parsed_query.get("rating"):
+        filtered_df = filtered_df[filtered_df["rating"] >= parsed_query["rating"]]
+    
+    return filtered_df

retrieval/vector_store.py

@@ -0,0 +1,34 @@
+# src/retrieval/vector_store.py
+
+from langchain_community.vectorstores import Chroma
+from langchain_core.documents import Document
+import numpy as np
+from typing import List, Dict, Any
+
+class VectorStore:
+    def __init__(self, embedding_function):
+        self.embedding_function = embedding_function
+        self.collection = None
+    
+    def add_documents(self, documents: List[str], embeddings: List[np.ndarray], ids: List[str]):
+        langchain_docs = [Document(page_content=doc, metadata={"id": id}) for doc, id in zip(documents, ids)]
+        self.collection = Chroma.from_documents(
+            documents=langchain_docs,
+            embedding=self.embedding_function,
+            ids=ids,
+            persist_directory="./chroma_db"
+        )
+        self.collection.persist()
+    
+    def query(self, query_embedding: np.ndarray, top_k: int = 5) -> Dict[str, Any]:
+        results = self.collection.similarity_search_by_vector(
+            embedding=query_embedding,
+            k=top_k
+        )
+        ids = [doc.metadata["id"] for doc in results]
+        distances = [1 - np.dot(query_embedding, doc.vector) / (np.linalg.norm(query_embedding) * np.linalg.norm(doc.vector)) 
+                     if hasattr(doc, "vector") else 1.0 for doc in results]
+        return {
+            "ids": [ids],
+            "distances": [distances]
+        }

src/chatbot.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from typing import Tuple, List, Dict, Any
+from src.utils.data_loader import load_restaurant_data
+from src.utils.query_parser import QueryParser
+from src.embeddings.embedder import Embedder
+from src.retrieval.vector_store import VectorStore
+from src.retrieval.keyword_filter import filter_restaurants
+from src.retrieval.hybrid_search import HybridRetriever
+from src.generation.llm import LLM
+from langchain_core.embeddings import Embeddings
+
+class LangChainEmbeddingWrapper(Embeddings):
+    def __init__(self, embedder):
+        self.embedder = embedder
+    
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self.embedder.embed(texts).tolist()
+    
+    def embed_query(self, text: str) -> List[float]:
+        return self.embedder.embed([text])[0].tolist()
+
+class RestaurantChatbot:
+    def __init__(self, data_path: str = "data/restaurants.json"):
+        """
+        Initialize the restaurant chatbot.
+        
+        Args:
+            data_path (str): Path to the restaurant JSON file.
+        """
+        self.df = load_restaurant_data(data_path)
+        self.embedder = Embedder()
+        self.embedding_wrapper = LangChainEmbeddingWrapper(self.embedder)
+        self.vector_store = VectorStore(embedding_function=self.embedding_wrapper)
+        self.llm = LLM()
+        self.parser = QueryParser(self.df)
+        
+        embeddings = self.embedder.embed(self.df['text'].tolist())
+        self.vector_store.add_documents(
+            documents=self.df['text'].tolist(),
+            embeddings=embeddings.tolist(),
+            ids=[str(i) for i in self.df['id']]
+        )
+        
+        self.retriever = HybridRetriever(self.df, self.vector_store, self.embedder)
+    
+    def answer(self, query: str) -> Tuple[str, List[Dict[str, Any]]]:
+        """
+        Process a user query and return a natural, concise response with recommended restaurants.
+        
+        Args:
+            query (str): User query.
+        
+        Returns:
+            Tuple[str, List[Dict[str, Any]]]: Natural response text and list of recommended restaurants.
+        """
+        parsed_query = self.parser.parse_query(query)
+        filtered_df = filter_restaurants(self.df, parsed_query)
+        description = parsed_query["description"] if parsed_query["description"] else query
+        
+        if filtered_df.empty:
+            retrieved_docs = self.retriever.retrieve(description, self.df, top_k=3)
+        else:
+            retrieved_docs = self.retriever.retrieve(description, filtered_df, top_k=3)
+        
+        if not retrieved_docs:
+            return "Mình không tìm được nhà hàng nào phù hợp. Bạn thử đổi tiêu chí xem, như mở rộng khoảng cách hoặc loại món ăn nhé!", []
+        
+        # Create context for LLM
+        context = "\n".join([
+            f"- {doc['name']} ({doc['cuisine']}): {', '.join(doc['dishes'])}. "
+            f"Price: {doc['price_range']}, Distance: {doc['distance']} km, Rating: {doc['rating']}. "
+            f"Description: {doc['description']}"
+            for doc in retrieved_docs
+        ])
+        
+        # Prompt for natural, consultant-like response
+        prompt = (
+            f"Bạn là một người tư vấn nhà hàng thân thiện. Dựa trên truy vấn và danh sách nhà hàng, hãy gợi ý ngắn gọn, tự nhiên, như trò chuyện với bạn bè, giải thích tại sao chọn các nhà hàng này (tập trung vào món ăn, giá, khoảng cách, hoặc đánh giá phù hợp với truy vấn). Không lặp lại truy vấn hoặc dùng ngôn ngữ kỹ thuật. Chỉ dùng thông tin từ danh sách nhà hàng.\n\n"
+            f"Truy vấn: {query}\n\n"
+            f"Danh sách nhà hàng:\n{context}\n\n"
+            f"Phản hồi:"
+        )
+        
+        response = self.llm.generate(prompt, max_length=200)
+        return response, retrieved_docs

src/embeddings/embedder.py

@@ -0,0 +1,17 @@
+from transformers import AutoTokenizer, AutoModel
+import torch
+import numpy as np
+from typing import List
+
+class Embedder:
+    def __init__(self, model_name: str = "BAAI/bge-m3"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+
+    def embed(self, texts: List[str]) -> np.ndarray:
+        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        embeddings = outputs.last_hidden_state[:, 0]  # lấy embedding từ CLS token
+        embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+        return embeddings.cpu().numpy()

src/generation/llm.py

@@ -0,0 +1,149 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from langchain_core.prompts import PromptTemplate
+import os
+from typing import List
+
+class LLM:
+    def __init__(self, model_repo: str = "Qwen/Qwen2-1.5B-Instruct", 
+                 local_path: str = "models"):
+        """
+        Initialize the LLM with Qwen2-1.5B-Instruct using Hugging Face Transformers.
+
+        Args:
+            model_repo (str): Hugging Face repository ID for the model.
+            local_path (str): Local directory to store the model.
+        """
+        os.makedirs(local_path, exist_ok=True)
+        
+        try:
+            # Load the model
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                model_repo,
+                device_map="auto",  # Automatically map to CPU
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            
+            # Load the tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_repo,
+                cache_dir=local_path,
+                trust_remote_code=True
+            )
+            print(f"Model successfully loaded from {model_repo}")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to initialize model from {model_repo}. "
+                f"Please ensure the model is available at https://huggingface.co/{model_repo}. "
+                f"Error: {str(e)}"
+            )
+        
+        # Define prompt template for query parsing (used in query_parser.py)
+        self.prompt_template = PromptTemplate(
+            template="""Bạn là một trợ lý phân tích truy vấn nhà hàng. Phân tích truy vấn sau và trích xuất các đặc trưng: cuisine, menu, price_range, distance, rating, và description. Chỉ trích xuất các giá trị khớp chính xác với danh sách giá trị hợp lệ. Nếu không tìm thấy giá trị khớp, trả về null (hoặc [] cho menu). Loại bỏ các từ khóa đã trích xuất khỏi description. Trả về kết quả dưới dạng JSON.
+
+                    **Danh sách giá trị hợp lệ**:
+                    - cuisine: {cuisines}
+                    - menu: {dishes}
+                    - price_range: {price_ranges}
+
+                    **Hướng dẫn**:
+                    - cuisine: Chỉ chọn giá trị từ danh sách cuisine. Ví dụ, "Viet" → "Vietnamese".
+                    - menu: Chỉ chọn các món khớp chính xác với danh sách menu. Ví dụ, "phở bò" → "phở", "sushi" → [].
+                    - price_range: Chỉ chọn {price_ranges}. Ví dụ, "cheap" → "low".
+                    - distance: Trích xuất số km (e.g., "2 km" → 2.0) hoặc từ khóa ["nearby", "close" → 2.0, "far" → 10.0]. Nếu không rõ, trả về null.
+                    - rating: Trích xuất số (e.g., "4 stars" → 4.0). Nếu không rõ, trả về null.
+                    - description: Phần còn lại sau khi loại bỏ các từ khóa đã trích xuất. Nếu rỗng, trả về truy vấn gốc.
+
+                    **Truy vấn**: {query}
+
+                    **Định dạng đầu ra**:
+                    {{
+                    "cuisine": null | "tên loại ẩm thực",
+                    "menu": [],
+                    "price_range": null | "low" | "medium" | "high",
+                    "distance": null | số km | "nearby" | "close" | "far",
+                    "rating": null | số,
+                    "description": "phần mô tả còn lại"
+                    }}
+                    """,
+            input_variables=["cuisines", "dishes", "price_ranges", "query"]
+        )
+    
+    def generate(self, prompt: str, max_length: int = 1000) -> str:
+        """
+        Generate text using the LLM.
+        
+        Args:
+            prompt (str): Input prompt.
+            max_length (int): Maximum length of the generated text.
+        
+        Returns:
+            str: Generated text.
+        """
+        try:
+            # Apply chat template for instruction-tuned Qwen model
+            messages = [{"role": "user", "content": prompt}]
+            prompt_with_template = self.tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            # Tokenize input prompt
+            inputs = self.tokenizer(prompt_with_template, return_tensors="pt").to(self.llm.device)
+            # Generate text
+            outputs = self.llm.generate(
+                **inputs,
+                max_new_tokens=max_length,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            # Decode the generated tokens
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            print("Response generated successfully!")
+            return response.strip()
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate response: {str(e)}")
+    
+    def format_query_prompt(self, query: str, cuisines: List[str], dishes: List[str], price_ranges: List[str]) -> str:
+        """
+        Format the prompt for query parsing using the prompt template.
+        
+        Args:
+            query (str): User query.
+            cuisines (list): List of valid cuisines.
+            dishes (list): List of valid dishes.
+            price_ranges (list): List of valid price ranges.
+        
+        Returns:
+            str: Formatted prompt.
+        """
+        return self.prompt_template.format(
+            cuisines=cuisines,
+            dishes=dishes,
+            price_ranges=price_ranges,
+            query=query
+        )
+
+if __name__ == "__main__":
+    # Khởi tạo đối tượng LLM với model_repo và local_path
+    local_path = 'models'
+    
+    try:
+        # Khởi tạo đối tượng LLM
+        llm = LLM(local_path=local_path)
+
+        # Định nghĩa một truy vấn và các tham số cần thiết
+        query = "Tìm quán ăn Việt Nam gần đây, giá rẻ với món phở và cơm tấm"
+        cuisines = ["Vietnamese", "Chinese", "Italian"]
+        dishes = ["phở", "sushi", "pasta", "cơm tấm"]
+        price_ranges = ["low", "medium", "high"]
+
+        # Sử dụng hàm generate để tạo câu trả lời từ truy vấn
+        generated_text = llm.generate(query, max_length=300)
+
+        # In kết quả ra màn hình
+        print("Generated text:")
+        print(generated_text)
+
+    except Exception as e:
+        print(f"Error: {str(e)}")

src/retrieval/hybrid_search.py

@@ -0,0 +1,49 @@
+# src/retrieval/hybrid_search.py
+
+import numpy as np
+from rank_bm25 import BM25Okapi
+from typing import List, Dict, Any
+import pandas as pd
+from src.embeddings.embedder import Embedder
+from src.retrieval.vector_store import VectorStore
+
+class HybridRetriever:
+    def __init__(self, df: pd.DataFrame, vector_store: VectorStore, embedder: Embedder, alpha: float = 0.5):
+        self.df = df
+        self.vector_store = vector_store
+        self.embedder = embedder
+        self.alpha = alpha
+        tokenized_corpus = [doc.lower().split() for doc in df['description']]
+        self.bm25 = BM25Okapi(tokenized_corpus)
+    
+    def retrieve(self, query: str, filtered_df: pd.DataFrame, top_k: int = 3) -> List[Dict[str, Any]]:
+        filtered_indices = filtered_df.index.tolist()
+        filtered_texts = filtered_df['description'].tolist()
+        filtered_ids = [str(row['id']) for _, row in filtered_df.iterrows()]
+        
+        if not filtered_texts:
+            return []
+        
+        query_embedding = self.embedder.embed([query])[0]
+        dense_results = self.vector_store.query(query_embedding, top_k=top_k * 2)
+        dense_ids = [id for id in dense_results['ids'][0] if id in filtered_ids]
+        dense_scores = [1 - dist for dist, id in zip(dense_results['distances'][0], dense_results['ids'][0]) if id in filtered_ids]
+        
+        tokenized_query = query.lower().split()
+        bm25_scores = self.bm25.get_scores(tokenized_query)
+        bm25_scores_filtered = [bm25_scores[i] for i in filtered_indices]
+        bm25_top_k = np.argsort(bm25_scores_filtered)[::-1][:top_k * 2]
+        bm25_ids = [filtered_ids[i] for i in bm25_top_k]
+        bm25_scores = [bm25_scores_filtered[i] for i in bm25_top_k]
+        
+        dense_scores = np.array(dense_scores) / np.max(dense_scores) if dense_scores else dense_scores
+        bm25_scores = np.array(bm25_scores) / np.max(bm25_scores) if bm25_scores else bm25_scores
+        
+        combined_scores = {}
+        for idx, dense_id in enumerate(dense_ids):
+            combined_scores[int(dense_id)] = combined_scores.get(int(dense_id), 0) + self.alpha * dense_scores[idx]
+        for idx, bm25_id in enumerate(bm25_ids):
+            combined_scores[int(bm25_id)] = combined_scores.get(int(bm25_id), 0) + (1 - self.alpha) * bm25_scores[idx]
+        
+        sorted_ids = sorted(combined_scores, key=combined_scores.get, reverse=True)[:top_k]
+        return [self.df[self.df['id'] == id].iloc[0].to_dict() for id in sorted_ids]

src/retrieval/keyword_filter.py

@@ -0,0 +1,41 @@
+# src/retrieval/keyword_filter.py
+
+import pandas as pd
+from typing import Dict, Any
+
+def filter_restaurants(df: pd.DataFrame, parsed_query: Dict[str, Any]) -> pd.DataFrame:
+    """
+    Filter restaurants based on extracted features from the query.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing restaurant data.
+        parsed_query (Dict[str, Any]): Parsed query with features.
+    
+    Returns:
+        pd.DataFrame: Filtered DataFrame.
+    """
+    filtered_df = df.copy()
+    
+    if parsed_query.get("cuisine"):
+        filtered_df = filtered_df[filtered_df["cuisine"].str.lower() == parsed_query["cuisine"].lower()]
+    
+    if parsed_query.get("menu"):
+        filtered_df = filtered_df[filtered_df["dishes"].apply(
+            lambda dishes: any(item.lower() in [d.lower() for d in dishes] for item in parsed_query["menu"])
+        )]
+    
+    if parsed_query.get("price_range"):
+        filtered_df = filtered_df[filtered_df["price_range"].str.lower() == parsed_query["price_range"].lower()]
+    
+    distance = parsed_query.get("distance")
+    if isinstance(distance, (int, float)):
+        filtered_df = filtered_df[filtered_df["distance"] <= distance]
+    elif distance in ["nearby", "close"]:
+        filtered_df = filtered_df[filtered_df["distance"] <= 2.0]
+    elif distance == "far":
+        filtered_df = filtered_df[filtered_df["distance"] <= 10.0]
+    
+    if parsed_query.get("rating"):
+        filtered_df = filtered_df[filtered_df["rating"] >= parsed_query["rating"]]
+    
+    return filtered_df

src/retrieval/vector_store.py

@@ -0,0 +1,34 @@
+# src/retrieval/vector_store.py
+
+from langchain_community.vectorstores import Chroma
+from langchain_core.documents import Document
+import numpy as np
+from typing import List, Dict, Any
+
+class VectorStore:
+    def __init__(self, embedding_function):
+        self.embedding_function = embedding_function
+        self.collection = None
+    
+    def add_documents(self, documents: List[str], embeddings: List[np.ndarray], ids: List[str]):
+        langchain_docs = [Document(page_content=doc, metadata={"id": id}) for doc, id in zip(documents, ids)]
+        self.collection = Chroma.from_documents(
+            documents=langchain_docs,
+            embedding=self.embedding_function,
+            ids=ids,
+            persist_directory="./chroma_db"
+        )
+        self.collection.persist()
+    
+    def query(self, query_embedding: np.ndarray, top_k: int = 5) -> Dict[str, Any]:
+        results = self.collection.similarity_search_by_vector(
+            embedding=query_embedding,
+            k=top_k
+        )
+        ids = [doc.metadata["id"] for doc in results]
+        distances = [1 - np.dot(query_embedding, doc.vector) / (np.linalg.norm(query_embedding) * np.linalg.norm(doc.vector)) 
+                     if hasattr(doc, "vector") else 1.0 for doc in results]
+        return {
+            "ids": [ids],
+            "distances": [distances]
+        }

src/utils/data_loader.py

@@ -0,0 +1,29 @@
+# src/utils/data_loader.py
+
+import pandas as pd
+import json
+
+def load_restaurant_data(file_path: str) -> pd.DataFrame:
+    """
+    Load restaurant data from JSON file into a DataFrame.
+    
+    Args:
+        file_path (str): Path to the JSON file.
+    
+    Returns:
+        pd.DataFrame: DataFrame containing restaurant data.
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    df = pd.DataFrame(data)
+    # Create a text field for embedding and BM25
+    df['text'] = df.apply(
+        lambda row: f"{row['name']} ({row['cuisine']}): {', '.join(row['dishes'])}. "
+                    f"Price: {row['price_range']}, Distance: {row['distance']} km, "
+                    f"Rating: {row['rating']}. Description: {row['description']}",
+        axis=1
+    )
+    return df
+if __name__ == "__main__":
+    print(load_restaurant_data("./data/restaurants.json"))

src/utils/query_parser.py

@@ -0,0 +1,76 @@
+# src/utils/query_parser.py
+import pandas as pd
+import json
+from typing import Dict, Any
+from src.generation.llm import LLM
+
+class QueryParser:
+    def __init__(self, df: pd.DataFrame):
+        """
+        Initialize the query parser with restaurant data.
+        
+        Args:
+            df (pd.DataFrame): DataFrame containing restaurant data.
+        """
+        self.llm = LLM()
+        self.df = df
+        self.valid_cuisines = sorted(self.df['cuisine'].unique().tolist())
+        self.valid_price_ranges = sorted(self.df['price_range'].unique().tolist())
+        self.valid_dishes = sorted(set([dish for dishes in self.df['dishes'] for dish in dishes]))
+    
+    def parse_query(self, query: str) -> Dict[str, Any]:
+        """
+        Parse the query to extract features.
+        
+        Args:
+            query (str): User query.
+        
+        Returns:
+            Dict[str, Any]: Parsed features.
+        """
+        # Format prompt using LLM's prompt template
+        prompt = self.llm.format_query_prompt(
+            query=query,
+            cuisines=self.valid_cuisines,
+            dishes=self.valid_dishes,
+            price_ranges=self.valid_price_ranges
+        )
+        
+        # Generate response
+        response = self.llm.generate(prompt)
+        
+        # Parse JSON response
+        try:
+            json_start = response.find("{")
+            json_end = response.rfind("}") + 1
+            parsed = json.loads(response[json_start:json_end])
+            return parsed
+        except json.JSONDecodeError:
+            return {
+                "cuisine": None,
+                "menu": [],
+                "price_range": None,
+                "distance": None,
+                "rating": None,
+                "description": query
+            }
+
+
+# Quick test block for QueryParser
+if __name__ == "__main__":
+    import pandas as pd
+
+    sample_data = {
+        "cuisine": ["Italian", "Japanese"],
+        "price_range": ["$", "$$"],
+        "dishes": [["pizza", "pasta"], ["sushi", "ramen"]]
+    }
+    df = pd.DataFrame(sample_data)
+    parser = QueryParser(df)
+
+    user_query = "I want cheap sushi"
+    result = parser.parse_query(user_query)
+
+    print("Parsed Query Result:")
+    print(result)
+            

utils/data_loader.py

@@ -0,0 +1,29 @@
+# src/utils/data_loader.py
+
+import pandas as pd
+import json
+
+def load_restaurant_data(file_path: str) -> pd.DataFrame:
+    """
+    Load restaurant data from JSON file into a DataFrame.
+    
+    Args:
+        file_path (str): Path to the JSON file.
+    
+    Returns:
+        pd.DataFrame: DataFrame containing restaurant data.
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    df = pd.DataFrame(data)
+    # Create a text field for embedding and BM25
+    df['text'] = df.apply(
+        lambda row: f"{row['name']} ({row['cuisine']}): {', '.join(row['dishes'])}. "
+                    f"Price: {row['price_range']}, Distance: {row['distance']} km, "
+                    f"Rating: {row['rating']}. Description: {row['description']}",
+        axis=1
+    )
+    return df
+if __name__ == "__main__":
+    print(load_restaurant_data("./data/restaurants.json"))

utils/query_parser.py

@@ -0,0 +1,76 @@
+# src/utils/query_parser.py
+import pandas as pd
+import json
+from typing import Dict, Any
+from src.generation.llm import LLM
+
+class QueryParser:
+    def __init__(self, df: pd.DataFrame):
+        """
+        Initialize the query parser with restaurant data.
+        
+        Args:
+            df (pd.DataFrame): DataFrame containing restaurant data.
+        """
+        self.llm = LLM()
+        self.df = df
+        self.valid_cuisines = sorted(self.df['cuisine'].unique().tolist())
+        self.valid_price_ranges = sorted(self.df['price_range'].unique().tolist())
+        self.valid_dishes = sorted(set([dish for dishes in self.df['dishes'] for dish in dishes]))
+    
+    def parse_query(self, query: str) -> Dict[str, Any]:
+        """
+        Parse the query to extract features.
+        
+        Args:
+            query (str): User query.
+        
+        Returns:
+            Dict[str, Any]: Parsed features.
+        """
+        # Format prompt using LLM's prompt template
+        prompt = self.llm.format_query_prompt(
+            query=query,
+            cuisines=self.valid_cuisines,
+            dishes=self.valid_dishes,
+            price_ranges=self.valid_price_ranges
+        )
+        
+        # Generate response
+        response = self.llm.generate(prompt)
+        
+        # Parse JSON response
+        try:
+            json_start = response.find("{")
+            json_end = response.rfind("}") + 1
+            parsed = json.loads(response[json_start:json_end])
+            return parsed
+        except json.JSONDecodeError:
+            return {
+                "cuisine": None,
+                "menu": [],
+                "price_range": None,
+                "distance": None,
+                "rating": None,
+                "description": query
+            }
+
+
+# Quick test block for QueryParser
+if __name__ == "__main__":
+    import pandas as pd
+
+    sample_data = {
+        "cuisine": ["Italian", "Japanese"],
+        "price_range": ["$", "$$"],
+        "dishes": [["pizza", "pasta"], ["sushi", "ramen"]]
+    }
+    df = pd.DataFrame(sample_data)
+    parser = QueryParser(df)
+
+    user_query = "I want cheap sushi"
+    result = parser.parse_query(user_query)
+
+    print("Parsed Query Result:")
+    print(result)
+