first

.gitattributes

@@ -0,0 +1,3 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text

ChatBot/__init__.py

@@ -0,0 +1 @@
+from chatbot import ChatBot

ChatBot/app.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from chatbot import ChatBot
+import warnings
+from fastapi.middleware.cors import CORSMiddleware
+# Tắt các cảnh báo
+warnings.filterwarnings("ignore")
+
+# Khởi tạo ứng dụng FastAPI
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],  # Cho phép kết nối từ frontend
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Khởi tạo chatbot
+chatbot = ChatBot()
+
+# Định nghĩa schema cho dữ liệu đầu vào
+class QueryRequest(BaseModel):
+    query: str
+
+# Endpoint để khởi tạo lại chatbot
+@app.post("/newchat/")
+async def new_chat():
+    global chatbot
+    chatbot = ChatBot()  # Khởi tạo lại chatbot mới
+    return {"message": "ChatBot đã được khởi tạo lại."}
+
+# Endpoint để xử lý câu hỏi
+@app.post("/process_query/")
+async def process_query(request: QueryRequest):
+    global chatbot
+    
+    raw_query = request.query  # Lấy query từ người dùng
+    # Xử lý truy vấn bằng chatbot
+    response = chatbot.process_query(raw_query)
+    # Trả về câu trả lời từ chatbot
+    return {"response": response}

ChatBot/chatbot.py

@@ -0,0 +1,88 @@
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain.memory import ConversationBufferMemory
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_qdrant import FastEmbedSparse
+from query_transformation import QueryTransform
+from route import Router
+from retrieval import Retriever
+import os
+from dotenv import load_dotenv
+
+class ChatBot:
+    def __init__(self, embedding_model='bkai-foundation-models/vietnamese-bi-encoder', sparse_embedding="Qdrant/BM25"):
+        self.embedding_model = HuggingFaceEmbeddings(model_name=embedding_model)
+        self.sparse_embedding = FastEmbedSparse(model_name=sparse_embedding)
+
+        load_dotenv()
+        genai_api_key = os.getenv('GOOGLE_API_KEY')
+        
+        print ("Khởi tạo Query Transform")
+        self.query_transform = QueryTransform()
+
+        print ("Khởi tạo Router")
+        self.router = Router()
+
+        print ("Khởi tạo Retriever")
+        self.retriever = Retriever(self.embedding_model, self.sparse_embedding)
+
+        print ("Khởi tạo LLM")
+        self.llm = ChatGoogleGenerativeAI(api_key=genai_api_key, model="gemini-1.5-flash")
+
+        # Sử dụng ConversationBufferMemory để lưu trữ lịch sử hội thoại
+        self.memory = ConversationBufferMemory(
+            memory_key="history",
+            input_key="query",
+            returnMessages=False,      # Trả về chuỗi thay vì đối tượng
+            aiPrefix="AI:",
+            humanPrefix="User:",
+            k=2)
+
+        self.prompt_template = """
+        Bạn là một chatbot chuyên về Luật Hôn Nhân và Gia Đình Việt Nam với tên "ChatBot hỏi đáp về Luật Hôn Nhân và Gia Đình Việt Nam". Hãy trả lời từng câu hỏi đã được làm rõ (converted_query) dựa trên loại câu hỏi (question_type) và ngữ cảnh (context). Tuân thủ các quy tắc sau:
+
+        - Với `question_type = 1|4|6|8|9`:
+            1. Dựa vào ngữ cảnh và câu hỏi đã được làm rõ (converted_query) để trả lời câu hỏi gốc (query). KHÔNG ĐƯỢC sử dụng các cụm từ tương tự như "Dựa vào thông tin được cung cấp", "Dựa vào ngữ cảnh".
+            2. **Chỉ sử dụng thông tin trong ngữ cảnh.** Trả lời một cách **diễn giải chi tiết**, giải thích rõ lý do, cơ sở pháp lý (trong ngữ cảnh)
+
+        - Với `question_type = 2` (smalltalk): Trả lời thân thiện, phù hợp với ngữ cảnh.
+
+        - Với các loại khác: *Trả về ngữ cảnh y như nó được cung cấp, không thêm bớt bất kỳ thông tin nào khác.*
+
+        Mỗi câu hỏi đã được làm rõ (converted_query[i]) tương ứng với `context[i]` và `question_type[i]`. Trả lời lần lượt từng câu hỏi theo các quy tắc trên.
+
+        Dữ liệu cung cấp:
+        - Loại câu hỏi: {question_type}
+        - Ngữ cảnh: {context}
+        - Câu hỏi gốc: {query}
+        - Câu hỏi đã được làm rõ: {converted_query}
+
+        """
+
+        # Prompt template cho LLMChain
+        self.prompt = PromptTemplate(
+            input_variables=["question_type", "context", "query", "converted_query"],
+            template=self.prompt_template,
+        )
+
+        # LLMChain kết hợp LLM và Prompt
+        self.chain = LLMChain(llm=self.llm, prompt=self.prompt, memory=self.memory)
+
+    def process_query(self, raw_query):
+        print ('QUERY GỐC: ', raw_query, '\n---------------------------------------------------------')
+        # Bước 1: Biến đổi câu truy vấn dựa trên lịch sử
+        converted_queries = self.query_transform.transform(raw_query, self.memory.load_memory_variables({})["history"])
+        print ('QUERY ĐÃ TRANSFORM: ', converted_queries, '\n---------------------------------------------------------')
+        query_types = []
+        # Bước 2: Phân loại loại câu hỏi
+        for q in converted_queries:
+            query_types.append(self.router.route_query(q))
+        print ('LOẠI CỦA QUERY: ', query_types, '\n---------------------------------------------------------')
+        # Bước 3: Truy vấn thông tin ngữ cảnh
+        context = self.retriever.retrieve(converted_queries, query_types)
+        print ('CONTEXT: ', context, '\n---------------------------------------------------------')
+        # Bước 4: Tạo câu trả lời bằng LangChain
+        response = self.chain.run(question_type=query_types, context=context, query=raw_query, converted_query=converted_queries)
+
+        return response

ChatBot/data/chunking_save.py

@@ -0,0 +1,164 @@
+import json
+from sentence_transformers import SentenceTransformer
+from qdrant_client import models
+from langchain_qdrant import QdrantVectorStore, FastEmbedSparse, RetrievalMode
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.schema import Document
+from typing import List
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+import re
+
+# Khởi tạo SentenceTransformer
+model_name = 'bkai-foundation-models/vietnamese-bi-encoder'
+model = SentenceTransformer(model_name)
+
+
+# Load dữ liệu từ file data.json
+with open('data.json', 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+# Hàm chunking ngữ nghĩa và tạo Document
+# class SemanticChunker:
+#     def __init__(self, model, breakpoint_percentile_threshold=80):
+#         self.model = model
+#         self.breakpoint_percentile_threshold = breakpoint_percentile_threshold
+
+#     def split_text(self, text: str) -> List[str]:
+#         modified_text = re.sub(r'(\d+)\.', r'\1)', text)
+#         # Tách câu
+#         sentences = re.split(r'(?<=[.!?])\s+', modified_text)
+
+#         # Tính embedding cho các câu
+#         embeddings = self.model.encode(sentences, convert_to_tensor=True).cpu().numpy()
+
+#         # Tính khoảng cách cosine giữa các câu liên tiếp
+#         distances = [
+#             1 - cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
+#             for i in range(len(embeddings) - 1)
+#         ]
+
+#         distances.append(0)  # Thêm khoảng cách cho câu cuối (không có câu kế tiếp)
+
+#         # Xác định ngưỡng chia đoạn
+#         threshold = np.percentile(distances, self.breakpoint_percentile_threshold)
+#         breakpoints = [i for i, dist in enumerate(distances) if dist > threshold]
+
+#         # Tạo các đoạn văn bản
+#         chunks = []
+#         start = 0
+#         for bp in breakpoints:
+#             chunks.append(' '.join(sentences[start:bp + 1]))
+#             start = bp + 1
+
+#         if start < len(sentences):
+#             chunks.append(' '.join(sentences[start:]))
+
+#         return chunks
+class SemanticChunker:
+    def __init__(self, model, buffer_size=1, breakpoint_percentile_threshold=80):
+        self.model = model
+        self.buffer_size = buffer_size
+        self.breakpoint_percentile_threshold = breakpoint_percentile_threshold
+
+    def split_text(self, text: str) -> List[str]:
+        modified_text = re.sub(r'(\d+)\.', r'\1)', text)
+        # Tách câu
+        # sentences = sent_tokenize(modified_text)
+        sentences = re.split(r'(?<=[.!?])\s+', modified_text)
+
+        combined_sentences = [
+            ' '.join(sentences[max(i - self.buffer_size, 0): i + self.buffer_size + 1])
+            for i in range(len(sentences))
+        ]
+
+        # Tính embedding cho các câu
+        embeddings = self.model.encode(combined_sentences, convert_to_tensor=True).cpu().numpy()
+
+        # Tính khoảng cách cosine
+        distances = [
+            1 - cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
+            for i in range(len(embeddings) - 1)
+        ]
+
+        distances.append(0)  # Thêm khoảng cách cho câu cuối
+
+        # Xác định ngưỡng chia đoạn
+        threshold = np.percentile(distances, self.breakpoint_percentile_threshold)
+        breakpoints = [i for i, dist in enumerate(distances) if dist > threshold]
+
+        # Tạo các đoạn văn bản
+        chunks = []
+        start = 0
+        for bp in breakpoints:
+            chunks.append(' '.join(sentences[start:bp + 1]))
+            start = bp + 1
+
+        if start < len(sentences):
+            chunks.append(' '.join(sentences[start:]))
+
+        return chunks
+
+# Khởi tạo SemanticChunker
+chunker = SemanticChunker(model)
+
+# Hàm xử lý dữ liệu và tạo Document
+def chunk_and_embed(data):
+    documents = []
+
+    for chapter in data['chapters']:
+        print (f"Loading {chapter['chapter']} ...")
+        if "sections" in chapter: 
+            for section in chapter['sections']:
+                for article in section['articles']:
+                    chunks = chunker.split_text(article['content'])
+                    for chunk in chunks:
+                        documents.append(Document(
+                            page_content=chunk,
+                            metadata={
+                                'chapter': chapter['chapter'] + " " + chapter['title'],
+                                'section': section['section'] + " " + section['title'],
+                                'article': article['article'] + " " + article['title']
+                            }
+                        ))
+
+        else:
+            for article in chapter['articles']:
+                chunks = chunker.split_text(article['content'])
+                # modified_text = re.sub(r'(\d+)\.', r'\1)', article['content'])
+                # chunks = sent_tokenize(modified_text)
+
+                for chunk in chunks:
+                    documents.append(Document(
+                        page_content=chunk,
+                        metadata={
+                            'chapter': chapter['chapter'] + " " + chapter['title'],
+                            'section': "",
+                            'article': article['article'] + " " + article['title']
+                        }
+                    ))
+    return documents
+
+# Tạo các Document từ dữ liệu
+documents = chunk_and_embed(data)
+
+print (f'Number of chunks: {len(documents)}')
+
+# Tạo embedding cho các Document bằng SentenceTransformer
+embedding_model = HuggingFaceEmbeddings(model_name=model_name)
+sparse_embeddings = FastEmbedSparse(model_name="Qdrant/BM25")
+
+# Lưu dữ liệu vào Qdrant
+collection_name = "LawData"
+vectorstore = QdrantVectorStore.from_documents(
+                documents, 
+                embedding_model, 
+                sparse_embedding=sparse_embeddings,
+                retrieval_mode=RetrievalMode.HYBRID,
+                url='https://c1e67a53-62f6-4464-b5ed-086b3c298e23.europe-west3-0.gcp.cloud.qdrant.io', 
+                api_key='-s29x9W2DpfpvmsR-1bA_CbpKrtp__xVJ2YKUmPgcf6n7MQ95o6fBQ',
+                collection_name=collection_name,
+                distance=models.Distance.COSINE
+            )
+
+print("Dữ liệu đã được lưu vào Qdrant Cloud!")

ChatBot/data/data_preprocessing.py

@@ -0,0 +1,152 @@
+import json
+import re
+from docx import Document
+
+# Hàm trích xuất tham chiếu từ một đoạn văn bản
+def extract_references(text):
+    pattern = r"(khoản \d+(?:, khoản \d+)* Điều \d+|Điều \d+)"
+    matches = re.findall(pattern, text)
+    refer = []
+    for match in matches:
+        if match.startswith("khoản"):
+            parts = match.split(" Điều ")
+            khoan_part = parts[0]
+            dieu_part = "Điều " + parts[1]
+            khoan_list = khoan_part.replace("khoản", "").strip().split(", ")
+            for khoan in khoan_list:
+                refer.append(f"khoản {khoan.strip()} {dieu_part}")
+        else:
+            refer.append(match)
+    return refer
+
+# Hàm phân tích dữ liệu và tạo cấu trúc JSON
+def parse_data_to_json(data):
+    chapters = []
+    current_chapter = None
+    current_section = None
+    current_article = None
+    lines = data.split("\n")
+    i = 0
+
+    while i < len(lines):
+        line = lines[i].strip()
+        # Xử lí chương
+        if line.startswith("CHƯƠNG"):
+            if current_chapter:
+                if current_section: # Thêm mục hiện tại vào chương trước khi chuyển sang chương mới
+                    if current_article:
+                        current_section["articles"].append(current_article)
+                        current_article = None
+                    current_chapter["sections"].append(current_section)
+                    current_section = None
+                chapters.append(current_chapter)
+            current_chapter = {
+                "chapter": f"{line} {lines[i+1].strip()}",  # Kết hợp số chương và tiêu đề
+                "sections": []
+            }
+            i += 2
+
+        # Xử lí Mục
+        elif line.startswith("Mục"):
+            if current_section:
+                if current_article:
+                    current_section["articles"].append(current_article)
+                    current_article = None
+                current_chapter["sections"].append(current_section)
+            current_section = {
+                "section": f"{line} {lines[i+1].strip()}",  # Kết hợp số mục và tiêu đề
+                "articles": []
+            }
+            i += 2
+
+        # Xử lí Điều
+        elif line.startswith("Điều"):
+            if current_section is None:
+                current_section = {
+                    "section": "",  # Kết hợp số mục và tiêu đề
+                    "articles": []
+                }
+            elif current_article:
+                current_section["articles"].append(current_article)
+
+            current_article = {
+                "article": line.split('.')[0].strip(),
+                "title": line.split('.')[1].strip(),
+                "clauses": []
+            }
+            i += 1
+            # Kiểm tra xem điều này có câu ngắn trước các khoản không (sử dụng re.match)
+            if i < len(lines) and lines[i].strip() and re.match(r"^\D", lines[i].strip()):
+                # Lưu câu ngắn để ghép vào khoản đầu tiên
+                text = lines[i].strip()
+                i += 1
+            else:
+                text = ""
+            flag = False # Kiểm tra có khoản không
+
+            # Xử lý các khoản
+            while i < len(lines) and lines[i].strip() and lines[i].strip()[0].isdigit():
+                flag = True
+                # Bắt đầu một khoản mới
+                clause_number = f"Khoản {lines[i].strip().split('.')[0]}"
+                clause_content = lines[i].strip()
+                i += 1
+                # Xử lý các điểm trong khoản
+                while i < len(lines) and lines[i].strip() and not re.match(r"^(CHƯƠNG\s+[IVXLCDM]+|Mục\s+\d+|Điều\s+\d+)", lines[i].strip()) and not lines[i].strip()[0].isdigit():
+                    clause_content += " " + lines[i].strip()
+                    i += 1
+                # Ghép câu ngắn vào khoản đầu tiên
+                if text:
+                    clause_content = f"{text} {clause_content}"
+                    text = ""  # Đã sử dụng câu ngắn, không cần ghép vào khoản tiếp theo
+                refer = extract_references(clause_content)
+                current_article["clauses"].append({
+                    "clause": clause_number,  # Số khoản
+                    "content": clause_content,
+                    "refer": refer
+                })
+            if flag == False:
+                while i < len(lines) and lines[i].strip() and not re.match(r"^(CHƯƠNG\s+[IVXLCDM]+|Mục\s+\d+|Điều\s+\d+)", lines[i].strip()):
+                    text += " " + lines[i].strip()
+                    i += 1
+                refer = extract_references(text)
+                current_article["clauses"].append({
+                    "clause": "",
+                    "content": text,
+                    "refer": refer
+                })
+        else:
+            i += 1
+
+    # Thêm các phần còn lại vào cấu trúc
+    if current_article:
+        current_section["articles"].append(current_article)
+    if current_section:
+        current_chapter["sections"].append(current_section)
+    if current_chapter:
+        chapters.append(current_chapter)
+
+    return {"chapters": chapters}
+
+# Đọc file .docx
+def read_docx(file_path):
+    doc = Document(file_path)
+    full_text = []
+    for para in doc.paragraphs:
+        full_text.append(para.text)
+    return "\n".join(full_text)
+
+# Đường dẫn đến file .docx
+file_path = "data.docx"
+
+# Đọc dữ liệu từ file .docx
+data = read_docx(file_path)
+
+# Phân tích dữ liệu và tạo JSON
+json_data = parse_data_to_json(data)
+
+# Lưu dữ liệu vào file JSON
+with open("new_data.json", "w", encoding="utf-8") as json_file:
+    json.dump(json_data, json_file, ensure_ascii=False, indent=4)
+
+print("Dữ liệu đã được lưu vào file new_data.json")

ChatBot/data/preprocessing.py

@@ -0,0 +1,139 @@
+import json
+import re
+from docx import Document
+
+# Hàm trích xuất tham chiếu từ một đoạn văn bản
+def extract_references(text):
+    # Biểu thức chính quy để bắt các chuỗi "khoản X, khoản Y, ... điều Z" hoặc "điều Z"
+    pattern = r"(khoản \d+(?:, khoản \d+)* điều \d+|điều \d+)"
+    matches = re.findall(pattern, text, re.IGNORECASE)
+    refer = []
+    for match in matches:
+        refer.append(match)
+    return refer
+
+# Hàm phân tích dữ liệu và tạo cấu trúc JSON
+def parse_data_to_json(data):
+    chapters = []
+    current_chapter = None
+    current_section = None
+    current_article = None
+    lines = data.split("\n")
+    i = 0
+
+    while i < len(lines):
+        line = lines[i].strip()
+        # Xử lí chương
+        if line.startswith("CHƯƠNG"):
+            if current_chapter:
+                if current_section: # Thêm mục hiện tại vào chương trước khi chuyển sang chương mới
+                    current_chapter["sections"].append(current_section)
+                    current_section = None
+                chapters.append(current_chapter)            
+            current_chapter = {
+                "chapter": f"{line} {lines[i+1].strip()}",  # Kết hợp số chương và tiêu đề
+                "sections": []
+            }
+            i += 2 
+
+        # Xử lí Mục
+        elif line.startswith("Mục"):
+            if current_section:
+                if current_article:
+                    current_section["articles"].append(current_article)
+                    current_article = None
+                current_chapter["sections"].append(current_section)
+            current_section = {
+                "section": f"{line} {lines[i+1].strip()}",  # Kết hợp số mục và tiêu đề
+                "articles": []
+            }
+            i += 2 
+
+        # Xử lí Điều
+        elif line.startswith("Điều"):
+            if current_section is None:
+                current_section = {
+                    "section": "",  # Kết hợp số mục và tiêu đề
+                    "articles": []
+                }
+            if current_article:
+                current_section["articles"].append(current_article)
+            current_article = {
+                "article": line,
+                "title": line.split('.')[1].strip(),
+                "clauses": []
+            }
+            # text = line.split('.')[1].strip()
+            i += 1
+            # Kiểm tra xem điều này có câu ngắn trước các khoản không (sử dụng re.match)
+            if i < len(lines) and lines[i].strip() and re.match(r"^\D", lines[i].strip()):
+                # Lưu câu ngắn để ghép vào khoản đầu tiên
+                text = lines[i].strip()
+                i += 1
+            else:
+                text = ""
+            flag = False
+            
+            # Xử lý các khoản
+            while i < len(lines) and lines[i].strip() and lines[i].strip()[0].isdigit():
+                flag = True
+                # Bắt đầu một khoản mới
+                clause_number = f"Khoản {lines[i].strip().split('.')[0]}"
+                clause_content = lines[i].strip()
+                i += 1
+                # Xử lý các điểm trong khoản
+                while i < len(lines) and lines[i].strip() and re.match(r"^[a-zđ]\)", lines[i].strip()):
+                    clause_content += " " + lines[i].strip()
+                    i += 1
+                # Ghép câu ngắn vào khoản đầu tiên
+                if text:
+                    clause_content = f"{text} {clause_content}"
+                    text = ""  # Đã sử dụng câu ngắn, không cần ghép vào khoản tiếp theo
+                refer = extract_references(clause_content)
+                current_article["clauses"].append({
+                    "clause": clause_number,  # Số khoản
+                    "content": clause_content,
+                    "refer": refer
+                })
+            if flag == False:
+                refer = extract_references(text)
+                current_article["clauses"].append({
+                    "clause": "",
+                    "content": text,
+                    "refer": refer
+                })
+        else:
+            i += 1
+
+    # Thêm các phần còn lại vào cấu trúc
+    if current_article:
+        current_section["articles"].append(current_article)
+    if current_section:
+        current_chapter["sections"].append(current_section)
+    if current_chapter:
+        chapters.append(current_chapter)
+
+    return {"chapters": chapters}
+
+# Đọc file .docx
+def read_docx(file_path):
+    doc = Document(file_path)
+    full_text = []
+    for para in doc.paragraphs:
+        full_text.append(para.text)
+    return "\n".join(full_text)
+
+# Đường dẫn đến file .docx
+file_path = "data.docx"
+
+# Đọc dữ liệu từ file .docx
+data = read_docx(file_path)
+
+# Phân tích d��� liệu và tạo JSON
+json_data = parse_data_to_json(data)
+
+# Lưu dữ liệu vào file JSON
+with open("legal_data2.json", "w", encoding="utf-8") as json_file:
+    json.dump(json_data, json_file, ensure_ascii=False, indent=4)
+
+print("Dữ liệu đã được lưu vào file legal_data2.json")

ChatBot/indexing.py

@@ -0,0 +1,58 @@
+import json
+from qdrant_client import models
+from langchain_qdrant import QdrantVectorStore, FastEmbedSparse, RetrievalMode
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.schema import Document
+import os
+from dotenv import load_dotenv
+
+def save_to_vector_database(data):
+    documents = []
+
+    for chapter in data['chapters']:
+        print (f"Loading {chapter['chapter']} ...")
+        for section in chapter['sections']:
+            for article in section['articles']:
+                for clause in article['clauses']:
+                    chunk = clause['content']
+                    if clause['clause'] == '' or clause['clause'] == 'Khoản 1':
+                        chunk = article['title'] + ". " + clause['content']                                
+                    documents.append(Document(
+                        page_content=chunk,
+                        metadata={
+                            'chapter': chapter['chapter'],
+                            'section': section['section'],
+                            'article': article['article'],
+                            'art_title': article['title'],
+                            'clause': clause['clause'],
+                            'refer': clause['refer']
+                        }
+                    ))
+
+    return documents
+
+with open('./data/new_data.json', 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+# Tạo các Document từ dữ liệu
+documents = save_to_vector_database(data)
+
+# Tạo embedding cho các Document bằng SentenceTransformer
+model_name = "dangvantuan/vietnamese-embedding"
+embedding_model = HuggingFaceEmbeddings(model_name=model_name)
+sparse_embeddings = FastEmbedSparse(model_name="Qdrant/BM25")
+
+load_dotenv()
+# Lưu dữ liệu vào Qdrant
+vectorstore = QdrantVectorStore.from_documents(
+                documents, 
+                embedding_model, 
+                sparse_embedding=sparse_embeddings,
+                retrieval_mode=RetrievalMode.HYBRID,
+                url=os.getenv("QDRANT_URL"), 
+                api_key=os.getenv("QDRANT_API_KEY"),
+                collection_name="LAWDATA",
+                distance=models.Distance.COSINE
+            )
+
+print("Dữ liệu đã được lưu vào Qdrant Cloud!")

ChatBot/query_transformation.py

@@ -0,0 +1,39 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+import os
+from dotenv import load_dotenv
+class QueryTransform:
+    def __init__(self, model="gemini-1.5-flash", temperature=0.3):
+        load_dotenv()
+        genai_api_key = os.getenv('GOOGLE_API_KEY')
+
+        # Prompt
+        self.transform_prompt = ChatPromptTemplate.from_template("""
+        Bạn là một mô hình phân tích câu hỏi. Nhiệm vụ của bạn là xử lý câu hỏi (hoặc câu khẳng định) của người dùng theo từng bước sau:
+        1. Nếu câu hỏi là ngôn ngữ khác tiếng Việt, trả về Kết quả: Xin lỗi, tôi không hiểu bạn đang nói gì, vui lòng sử dụng tiếng Việt.
+        2. Sửa lỗi chính tả, gõ sai, viết tắt cho câu hỏi trong tiếng Việt. Ví dụ: Tôi li hôn đc k? -> Tôi ly hôn được không?, thũ tụt -> thủ tục
+        3. NẾU CÂU HỎI CÓ NHIỀU Ý HỎI, tách chúng thành từng câu hỏi riêng biệt. Với mỗi câu hỏi thực hiện các bước tiếp theo.
+        4. NẾU CÂU HỎI chứa SỐ ĐIỀU/SỐ CHƯƠNG cụ thể và trong lịch sử trò chuyện có chứa:
+            + "Vui lòng chọn Điều cụ thể.", thì ý định của câu hỏi là: Khoản <số Khoản trong lịch sử> Điều <SỐ/SỐ ĐIỀU trong câu hỏi>. Ngược lại ý định là: Điều <SỐ/SỐ ĐIỀU trong câu hỏi>
+            + "Vui lòng chọn Chương cụ thể", thì ý định của câu hỏi là: Mục <số Mục trong lịch sử> Chương <SỐ/SỐ CHƯƠNG trong câu hỏi>. Ngược lại ý định là: Chương <SỐ/SỐ CHƯƠNG trong câu hỏi>
+        5. **NẾU CÂU HỎI KHÔNG RÕ RÀNG HOẶC CHƯA ĐẦY ĐỦ**, hãy sử dụng lịch sử trò chuyện được cung cấp **CHỈ KHI NÓ LIÊN QUAN TRỰC TIẾP ĐẾN CÂU HỎI** để làm rõ ý nghĩa và ngữ cảnh truy vấn của người dùng. **BỎ QUA THÔNG TIN KHÔNG LIÊN QUAN**.
+        6. Suy ra nội dung chính của câu hỏi (hoặc câu khẳng định) thật đơn giản, rõ ràng và dễ hiểu (dùng các từ ngữ trong luật Hôn nhân và Gia đình nếu có thể), **BỎ QUA ĐẠI TỪ DANH XƯNG NẾU CÓ THỂ**. Ví dụ: Tôi là nữ 16 tuổi thì có lấy chồng được không? -> Nữ 16 tuổi có đủ điều kiện kết hôn không?, Người bị điên có lấy vợ được không? -> Người mất hành vi dân sự có được phép kết hôn không?
+
+        Chỉ cung cấp kết quả **theo định dạng sau** và không thêm bất kỳ văn bản, giải thích hoặc bình luận nào khác:
+        Kết quả: <nội dung chính của câu hỏi 1>|<nội dung chính của câu hỏi 2>...
+
+        Lịch sử: {history}
+        Câu hỏi gốc: {query}
+        """)
+
+        self.model = ChatGoogleGenerativeAI(api_key=genai_api_key, model=model, temperature=temperature)
+        self.parser = StrOutputParser()
+
+    def transform(self, raw_query, history):
+        prompt = self.transform_prompt.format_prompt(query=raw_query, history=history)
+        response = self.parser.parse(self.model.invoke(prompt).content)
+        lines = response.split("\n")
+        result = lines[0].replace("Kết quả:", "").strip()
+        result = result.split("|")
+        return result

ChatBot/requirements.txt

@@ -0,0 +1,12 @@
+python-docx
+transformers
+sentence-transformers
+qdrant-client
+langchain
+langchain-community
+langchain-qdrant
+fastembed
+langchain-google-genai
+semantic-router
+neo4j
+roman

ChatBot/retrieval.py

@@ -0,0 +1,303 @@
+import os
+from dotenv import load_dotenv
+from langchain_qdrant import  RetrievalMode
+from langchain_qdrant import QdrantVectorStore
+from qdrant_client import models
+from langchain_qdrant import QdrantVectorStore, RetrievalMode
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import torch
+from neo4j import GraphDatabase
+import re
+import roman
+
+class Retriever:
+    def __init__(self, embedding_model, sparse_embedding, rerank_model="itdainb/PhoRanker"):
+        # Tải các biến môi trường từ file .env
+        load_dotenv()
+        # Qdrant
+        collection_name = os.getenv('QDRANT_COLLECTION_NAME')
+        url = os.getenv('QDRANT_URL')
+        api_key = os.getenv('QDRANT_API_KEY')
+
+        uri = os.getenv('NEO4J_URI')    
+        auth = (os.getenv('NEO4J_USERNAME'), os.getenv('NEO4J_PASS'))
+
+        # Khởi tạo kho lưu trữ vector
+        self.vector_store = QdrantVectorStore.from_existing_collection(
+            embedding=embedding_model,
+            collection_name=collection_name,
+            url=url,
+            api_key=api_key,
+            sparse_embedding=sparse_embedding,
+            retrieval_mode=RetrievalMode.DENSE,
+        )
+
+        self.retriever = self.vector_store.as_retriever()
+        self.tokenizer = AutoTokenizer.from_pretrained(rerank_model)
+        self.rerank_model = AutoModelForSequenceClassification.from_pretrained(rerank_model)
+        self.driver = GraphDatabase.driver(uri, auth=auth)
+
+        self.methods = {
+            0: self.unknown,                # Ngôn ngữ khác
+            1: self.marriage_and_family,    # Tổng quát
+            2: self.smalltalk,              # Smalltalk
+            3: self.unrelated,              # Không liên quan
+            4: self.khoan_with_dieu,        # Khoản có Điều
+            5: self.khoan_no_dieu,          # Khoản không có
+            6: self.muc_with_chuong,        # Mục có Chương
+            7: self.muc_no_chuong,          # Mục không có Chương
+            8: self.dieu_only,              # Chỉ có Điều
+            9: self.chuong_only,            # Chỉ có Chương
+        }
+
+    def rerank(self, query, documents):
+        # Tokenize query và documents
+        inputs = self.tokenizer([query] * len(documents), documents, return_tensors="pt", padding=True, truncation=True)
+
+        # Tính điểm số
+        with torch.no_grad():
+            outputs = self.rerank_model(**inputs)
+            scores = outputs.logits.squeeze().tolist()
+
+        indexed_documents = list(zip(range(len(documents)), scores))
+        indexed_documents.sort(key=lambda x: x[1], reverse=True)
+        ranked_indices = [i for i, _ in indexed_documents]
+
+        return ranked_indices
+
+    def unknown(self, query):
+        return query
+
+    def marriage_and_family(self, query, top_k=10, top_n=5, rerank=False):
+
+        results = self.retriever.get_relevant_documents(query, k=top_k)
+
+        if rerank:
+            docs = [doc.page_content for doc in results]
+            docs = self.rerank(query, docs)
+            results = [results[i] for i in docs]
+
+        res = {}
+        refers = set()
+        for doc in results[:top_n]:
+            article = doc.metadata['article']
+            if article == "Điều 3":
+                if article not in res:
+                    res[article] = {'title': doc.metadata['art_title'],
+                                    'content': set([doc.page_content])}
+                else: res[article]['content'].add(doc.page_content)
+
+            elif article not in res:
+                res[article] = {'title': doc.metadata['art_title']}
+
+                filter_condition = models.Filter(must=[models.FieldCondition(
+                                                        key="metadata.article",  # Trường metadata cần lọc
+                                                        match=models.MatchValue(value=article),
+                                                    )])
+                temp = self.retriever.get_relevant_documents(query="", filter=filter_condition)
+                res[article]['content'] = set([d.page_content for d in temp])
+                for art in temp:
+                    if art.metadata['refer']: refers.update(art.metadata['refer'])
+
+        for ref in refers:
+            match_ = re.match(r"(?:Khoản\s*(\d+)\s*)?điều\s*(\d+)", ref, re.IGNORECASE)
+            refer_clause = match_.group(1)
+            refer_article = f"Điều {match_.group(2)}"
+            if refer_article not in res:
+                res[refer_article] = {'title': None, 'content': set()}
+            filter_condition2 = models.Filter(must=[models.FieldCondition(
+                                                        key="metadata.article",
+                                                        match=models.MatchValue(
+                                                        value=refer_article))] )
+            if refer_clause:
+              filter_condition2.must.append(models.FieldCondition(
+                                                key="metadata.clause",
+                                                match=models.MatchValue(value=f"Khoản {refer_clause}")))
+            temp2 = self.retriever.get_relevant_documents(query="", filter=filter_condition2)
+            res[refer_article]['content'].update([d.page_content for d in temp2])
+            res[refer_article]['title'] = temp2[0].metadata['art_title']
+
+        context = ""
+        for key, value in res.items():
+            context += f"{key}: {value['title']}\n"
+            for item in value["content"]:
+                context += f"{item}\n"
+            context += "\n"
+        return context
+
+    def smalltalk(self, query):
+        return query
+
+    def unrelated(self, query):
+        return "Xin lỗi, câu hỏi này không phải lĩnh vực của tôi."
+
+    def muc_no_chuong(self, query):
+        return "Vui lòng chọn Chương cụ thể."
+
+    def muc_with_chuong(self, query):
+        # Tìm mục và chương từ câu truy vấn
+        match = re.search(r"mục\s+(\d+).*chương\s+(\w+)", query, re.IGNORECASE)
+
+        section = int(match.group(1))
+        chapter = match.group(2).upper()
+
+        # Xử lý chương
+        if chapter.isdigit():
+            chapter_number = int(chapter)
+            chapter_roman = roman.toRoman(chapter_number)
+        else:
+            try:
+                chapter_number = roman.fromRoman(chapter)
+                chapter_roman = chapter
+            except roman.InvalidRomanNumeralError:
+                return f"'{chapter}' không phải là số hoặc số La Mã hợp lệ."
+
+        if chapter_number < 1 or chapter_number > 10:
+            return f"Luật Hôn nhân và Gia Đình Việt Nam không có Chương {chapter}."
+
+        # Truy vấn cơ sở dữ liệu
+        with self.driver.session() as session:
+            result = session.run(
+                """
+                MATCH (ch:Chapter)-[:HAS_SECTION]->(sec:Section)-[:HAS_ARTICLE]->(art:Article)
+                WHERE ch.name =~ $chapter_pattern AND sec.name =~ $section_pattern
+                RETURN ch.name AS chapter_name, sec.name AS section_name, art.name AS article_name
+                """,
+                chapter_pattern=f"^CHƯƠNG {chapter_roman}(\\s|$).*",
+                section_pattern=f"^Mục {section}(\\s|$).*"
+            )
+
+            # Xử lý kết quả
+            records = result.data()
+            if not records:
+                return f"Chương {chapter} không có mục {section}."
+
+            # Xây dựng nội dung trả về
+            context = f"{records[0]['chapter_name']} - {records[0]['section_name']}:"
+            for record in records:
+                context += f"\n    - {record['article_name']}"
+
+            return context
+
+    def khoan_no_dieu(self, query):
+        return "Vui lòng chọn Điều cụ thể."
+
+    def khoan_with_dieu(self, query): # Khoản có Điều
+        match = re.search(r"khoản\s+(\d+)\s+điều\s+(\d+)", query, re.IGNORECASE)
+        clause, article = match.group(1), match.group(2)
+        if int(article) < 1 or int(article) > 133:
+            return f'Luật Hôn nhân và Gia Đình Việt Nam không có Điều {article}'
+
+        with self.driver.session() as session:
+            result = session.run(
+                """
+                MATCH (a:Article)-[:HAS_CLAUSE]->(c:Clause)
+                WHERE a.name =~ $article_number AND c.name = $clause_number
+                RETURN a.name AS article_name, c.content AS clause_content
+                """,
+                article_number=f"^Điều {article}(\\s|$).*",
+                clause_number=f"Khoản {clause}",
+            )
+            record = result.single()
+            if record:
+                context = f"{record['article_name']}:\n{record['clause_content']}"
+                return context
+            return f"Điều {article} không có Khoản {clause}."
+
+
+    def dieu_only(self, query):
+        # Tìm số điều từ query
+        match = re.search(r"điều\s+(\d+)", query, re.IGNORECASE)
+
+        article = match.group(1)
+        with self.driver.session() as session:
+            result = session.run(
+                """
+                MATCH (a:Article)-[:HAS_CLAUSE]->(c:Clause)
+                WHERE a.name =~ $article_number
+                RETURN a.name AS article_name, c.content AS clause_content
+                """,
+                article_number=f"^Điều {article}(\\s|$).*",
+            )
+
+            # Xử lý kết quả truy vấn
+            records = result.data()
+            if not records:
+                return f'Luật Hôn nhân và Gia Đình Việt Nam không có Điều {article}'
+
+            # Tạo nội dung trả về
+            context = f"{records[0]['article_name']}:"
+            for record in records:
+                context += f"\n{record['clause_content']}"
+            return context
+
+
+    def chuong_only(self, query):
+        # Tìm số chương từ câu truy vấn
+        match = re.search(r"chương\s+(\w+)", query, re.IGNORECASE)
+        chapter = match.group(1).upper()
+        if chapter.isdigit():
+            chapter_number = int(chapter)
+            chapter_roman = roman.toRoman(chapter_number)
+        else:
+            try:
+                chapter_number = roman.fromRoman(chapter)
+                chapter_roman = chapter
+            except roman.InvalidRomanNumeralError:
+                return f"'{chapter}' không phải là số hoặc số La Mã hợp lệ."
+
+        with self.driver.session() as session:
+            result = session.run(
+                """
+                MATCH (ch:Chapter)
+                WHERE ch.name =~ $chapter_pattern
+                OPTIONAL MATCH (ch)-[:HAS_SECTION]->(sec:Section)-[:HAS_ARTICLE]->(art:Article)
+                OPTIONAL MATCH (ch)-[:HAS_ARTICLE]->(art_direct:Article)
+                RETURN ch.name AS chapter_name,
+                      sec.name AS section_name,
+                      art.name AS article_name,
+                      art_direct.name AS direct_article_name
+                """,
+                chapter_pattern=f"^CHƯƠNG {chapter_roman}(\\s|$).*"
+            )
+
+            # Xử lý kết quả
+            records = result.data()
+            if not records:
+                return f"Không tìm thấy dữ liệu cho Chương {chapter}."
+
+            # Xây dựng nội dung trả về
+            context = f"{records[0]['chapter_name']}:"
+            sections = {}
+            direct_articles = []
+
+            for record in records:
+                if record['section_name']:
+                    section_name = record['section_name']
+                    article_name = record['article_name']
+                    if section_name not in sections:
+                        sections[section_name] = []
+                    if article_name:
+                        sections[section_name].append(article_name)
+                if record['direct_article_name']:
+                    direct_articles.append(record['direct_article_name'])
+
+            # Ghi các section và article của chúng
+            for section, articles in sections.items():
+                context += f"\n{section}:"
+                for article in articles:
+                    context += f"\n    - {article}"
+
+            # Ghi các article trực tiếp của chương
+            if direct_articles:
+                for article in direct_articles:
+                    context += f"\n    - {article}"
+
+            return context
+
+    def retrieve(self, queries, types):
+        context = ""
+        for q, t in zip(queries, types):
+            context += self.methods[t](q) + "\n----------------"
+
+        return context

ChatBot/route.py

@@ -0,0 +1,103 @@
+from semantic_router import Route
+from semantic_router.encoders import HuggingFaceEncoder
+from semantic_router.layer import RouteLayer
+import re
+
+
+class Router:
+    def __init__(self, model_name="dangvantuan/vietnamese-embedding"):
+        self.encoder = HuggingFaceEncoder(model_name=model_name)
+        self.routes = self.initialize_routes()
+        self.rl = RouteLayer(encoder=self.encoder, routes=self.routes)
+
+    def initialize_routes(self):
+        # Route cho câu hỏi liên quan đến hôn nhân và gia đình
+        marriage_and_family = Route(
+            name="1",
+            score_thresold=0.64,
+            utterances=[
+                "quy định về kết hôn như thế nào?",
+                "ly hôn có cần sự đồng ý của cả hai không?",
+                "quyền nuôi con sau khi ly hôn thuộc về ai?",
+                "phân chia tài sản khi ly hôn thế nào?",
+                "điều kiện để nhận con nuôi là gì?",
+                "kết hôn có cần đăng ký không?",
+                "ngoại tình có vi phạm pháp luật không?",
+                "người không nuôi con có quyền thăm con sau ly hôn không?",
+                "kết hôn với người nước ngoài cần những giấy tờ gì?",
+                "tảo hôn là gì?",
+                "ông bà có quyền nuôi cháu sau khi cha mẹ ly hôn không?",
+            ],
+        )
+
+        # Route cho smalltalk
+        smalltalk = Route(
+            name="2",
+            score_thresold=0.34,
+            utterances=[
+                "chào bạn!",
+                "hôm nay trời đẹp nhỉ?",
+                "bạn có thể giúp tôi không?",
+                "bạn tên là gì?",
+                "bạn làm việc ở đâu?",
+                "bạn khỏe không?",
+                "rất vui được gặp bạn!",
+                "bạn thông minh lắm đấy!",
+                "bạn có sở thích gì không?",
+                "cảm ơn bạn.",
+                "tạm biệt.",
+                "Xin chào",
+                "Bạn thú vị đó!",
+                "Có gì vui không, kể cho tôi nghe với?",
+                "Giúp tôi tí được không?",
+                "Có kế hoạch gì hay không bạn?",
+                "Thời tiết hôm nay thế nào?",
+            ],
+        )
+
+        # Route cho câu hỏi không liên quan
+        unrelated = Route(
+            name="3",
+            score_thresold=0.9,
+            utterances=[
+                "Những món ăn nào phổ biến nhất ở Ấn Độ?",
+                "Tại sao con người cần có mục tiêu?",
+                "Tự do cá nhân có quan trọng không?",
+                "Cách chăm sóc cây cảnh trong nhà?",
+                "AI có thể thay đổi cuộc sống của con người ra sao?",
+                "Blockchain là gì và nó hoạt động như thế nào?",
+                "Ai là cầu thủ ghi nhiều bàn thắng nhất mọi thời đại?",
+                "Tại sao Kim tự tháp được coi là kỳ quan?",
+                "Cuộc cách mạng công nghiệp diễn ra khi nào?",
+                "Ý nghĩa cuộc sống?",
+                "Nước là gì?",
+                "Con người có phải loài thông minh nhất?"
+            ],
+        )
+        return [marriage_and_family, smalltalk, unrelated]
+
+    def route_query(self, query):
+        """
+        Xác định loại câu hỏi dựa trên nội dung query.
+        """
+        query_ = query.strip().lower()  # Chuẩn hóa query
+
+        if query_ == "không hiểu":
+            return 0
+
+        patterns = {
+            4: r"\bkhoản\s+\d+\b.*\bđiều\s+\d+\b",  # Có khoản và điều cụ thể
+            5: r"\bkhoản\s+\d+\b(?!.*\bđiều\b)",    # Chỉ có khoản cụ thể, không có điều
+            6: r"\bmục\s+\d+\b.*\bchương\s+([IVXLCDMivxlcdm]+|\d+)\b",  # Có mục và chương cụ thể (số La Mã hoặc số thường)
+            7: r"\bmục\s+\d+\b(?!.*\bchương\b)",    # Chỉ có mục cụ thể, không có chương
+            8: r"\bđiều\s+\d+\b",                   # Chỉ có điều cụ thể
+            9: r"\bchương\s+([IVXLCDMivxlcdm]+|\d+)\b"  # Chỉ có chương cụ thể (số La Mã hoặc số thường)
+        }
+
+        # Kiểm tra từng mẫu regex
+        for query_type, pattern in patterns.items():
+            if re.search(pattern, query_, re.IGNORECASE):
+                return query_type
+
+        query_type = self.rl(query).name
+        return int(query_type) if query_type else 3

FrontEnd/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

FrontEnd/README.md

@@ -0,0 +1,8 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

FrontEnd/eslint.config.js

@@ -0,0 +1,38 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import react from 'eslint-plugin-react'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+
+export default [
+  { ignores: ['dist'] },
+  {
+    files: ['**/*.{js,jsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    settings: { react: { version: '18.3' } },
+    plugins: {
+      react,
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...react.configs.recommended.rules,
+      ...react.configs['jsx-runtime'].rules,
+      ...reactHooks.configs.recommended.rules,
+      'react/jsx-no-target-blank': 'off',
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+]

FrontEnd/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

FrontEnd/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/react": "^18.3.18",
+    "@types/react-dom": "^18.3.5",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.17.0",
+    "eslint-plugin-react": "^7.37.2",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-refresh": "^0.4.16",
+    "globals": "^15.14.0",
+    "vite": "^6.0.5"
+  }
+}

FrontEnd/src/ChatBot.css

@@ -0,0 +1,112 @@
+/* Reset CSS */
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+/* Container chính của chatbot */
+.chatbot-container {
+  width: 66.66%; /* Chiếm 2/3 màn hình */
+  max-width: 800px; /* Giới hạn chiều rộng tối đa */
+  height: 80vh; /* Chiếm 80% chiều cao màn hình */
+  border: 1px solid #ccc;
+  border-radius: 10px;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  font-family: Arial, sans-serif;
+  background-color: #f9f9f9;
+  margin: 0 auto; /* Căn giữa màn hình */
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Header của chatbot */
+.chat-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 10px;
+  background-color: #007bff;
+  color: white;
+}
+
+.chat-header h2 {
+  font-size: 18px;
+}
+
+.new-chat-btn {
+  background-color: #0056b3;
+  color: white;
+  border: none;
+  padding: 5px 10px;
+  border-radius: 5px;
+  cursor: pointer;
+}
+
+.new-chat-btn:hover {
+  background-color: #004080;
+}
+
+/* Cửa sổ hiển thị tin nhắn */
+.chat-window {
+  flex: 1;
+  padding: 10px;
+  overflow-y: auto;
+  background-color: #fff;
+  display: flex;
+  flex-direction: column; /* Đảm bảo các tin nhắn hiển thị theo chiều dọc */
+}
+
+/* Tin nhắn của người dùng và chatbot */
+.message {
+  margin-bottom: 10px;
+  padding: 8px 12px;
+  border-radius: 10px;
+  max-width: 80%;
+  word-wrap: break-word; /* Đảm bảo chữ không tràn ra ngoài */
+  display: inline-block; /* Để ô tin nhắn co giãn theo nội dung */
+}
+
+.message.user {
+  background-color: #007bff;
+  color: white;
+  margin-left: auto;
+}
+
+.message.bot {
+  background-color: #e1e1e1;
+  color: #333;
+  margin-right: auto;
+}
+
+/* Thanh nhập tin nhắn */
+.input-container {
+  display: flex;
+  padding: 10px;
+  background-color: #f1f1f1;
+}
+
+.input-container input {
+  flex: 1;
+  padding: 8px;
+  border: 1px solid #ccc;
+  border-radius: 5px;
+  margin-right: 10px;
+}
+
+.input-container button {
+  padding: 8px 12px;
+  background-color: #007bff;
+  color: white;
+  border: none;
+  border-radius: 5px;
+  cursor: pointer;
+}
+
+.input-container button:hover {
+  background-color: #0056b3;
+}

FrontEnd/src/ChatBot.jsx

@@ -0,0 +1,97 @@
+import { useState, useEffect, useRef } from 'react'; // Thêm useRef và useEffect
+import './ChatBot.css';
+
+const ChatBot = () => {
+  const [messages, setMessages] = useState([]);
+  const [userInput, setUserInput] = useState("");
+  const chatWindowRef = useRef(null); // Tham chiếu đến cửa sổ chat
+
+  // Tự động cuộn xuống tin nhắn mới nhất
+  useEffect(() => {
+    if (chatWindowRef.current) {
+      chatWindowRef.current.scrollTop = chatWindowRef.current.scrollHeight;
+    }
+  }, [messages]); // Kích hoạt mỗi khi messages thay đổi
+
+  const sendQueryToBackend = async (query) => {
+    try {
+      const response = await fetch('http://127.0.0.1:8000/process_query', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ query }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Lỗi khi gửi yêu cầu');
+      }
+
+      const data = await response.json();
+      return data.response;
+    } catch (error) {
+      console.error('Lỗi:', error);
+      return "Đã xảy ra lỗi khi kết nối với ChatBot.";
+    }
+  };
+
+  const handleSend = async () => {
+    if (userInput.trim() === "") return;
+
+    // Thêm tin nhắn của người dùng vào danh sách tin nhắn
+    setMessages((prevMessages) => [
+      ...prevMessages,
+      { sender: "user", text: userInput },
+    ]);
+
+    // Xóa input của người dùng (sau khi đã nhận được phản hồi)
+    setUserInput("");
+
+    // Gửi yêu cầu đến backend và nhận phản hồi
+    const botResponse = await sendQueryToBackend(userInput);
+
+    // Thêm phản hồi từ chatbot vào danh sách tin nhắn
+    setMessages((prevMessages) => [
+      ...prevMessages,
+      { sender: "bot", text: botResponse },
+    ]);
+
+  };
+
+  const handleNewChat = () => {
+    setMessages([]); // Xóa tất cả tin nhắn
+  };
+
+  return (
+    <div className="chatbot-container">
+      <div className="chat-header">
+        <h2>ChatBot</h2>
+        <button className="new-chat-btn" onClick={handleNewChat}>
+          New Chat
+        </button>
+      </div>
+
+      {/* Thêm ref vào cửa sổ chat */}
+      <div className="chat-window" ref={chatWindowRef}>
+        {messages.map((message, index) => (
+          <div key={index} className={`message ${message.sender}`}>
+            <p>{message.text}</p>
+          </div>
+        ))}
+      </div>
+
+      <div className="input-container">
+        <input
+          type="text"
+          value={userInput}
+          onChange={(e) => setUserInput(e.target.value)}
+          placeholder="Gõ câu hỏi của bạn..."
+          onKeyPress={(e) => e.key === "Enter" && handleSend()}
+        />
+        <button onClick={handleSend}>Gửi</button>
+      </div>
+    </div>
+  );
+};
+
+export default ChatBot;

FrontEnd/src/index.css

@@ -0,0 +1,15 @@
+body {
+  margin: 0;
+  font-family: Arial, sans-serif;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100vh;
+  background-color: #f0f0f0;
+}
+
+#root {
+  width: 100%;
+  max-width: 1200px;
+  margin: 0 auto;
+}

FrontEnd/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import './index.css';
+import ChatBot from './ChatBot.jsx';
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <ChatBot />
+  </StrictMode>
+);

FrontEnd/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "LawChatBot",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}