upload 5 files for deploy

Dockerfile

@@ -0,0 +1,20 @@
+# Dùng môi trường Python 3.10
+FROM python:3.10
+
+# Cài đặt quyền User (Bắt buộc trên Hugging Face để bảo mật)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Thiết lập thư mục làm việc
+WORKDIR /app
+
+# Copy và cài đặt các thư viện
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy toàn bộ code của bạn vào
+COPY --chown=user . /app
+
+# Chạy FastAPI. LƯU Ý: Hugging Face BẮT BUỘC dùng cổng 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

building_retriever.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+from typing import Optional, Dict, List, Any
+import json, re
+import unicodedata
+
+from qdrant_client.http import models as qdm
+from qdrant_client import QdrantClient
+from langchain_qdrant import QdrantVectorStore, FastEmbedSparse
+from langchain_huggingface import HuggingFaceEmbeddings
+from sentence_transformers import CrossEncoder
+from config import QDRANT_URL, QDRANT_API_KEY, COLLECTION_NAME, EMBED_MODEL, RERANK_MODEL, GROQ_API_KEY
+from groq import Groq
+
+LLM_MODEL = "llama-3.3-70b-versatile"
+
+# ========================== INIT MODELS ==========================
+
+client = Groq(api_key="GROQ_API_KEY")
+
+client_qdrant = QdrantClient(
+    url=QDRANT_URL,
+    api_key=QDRANT_API_KEY,
+)
+
+embeddings = HuggingFaceEmbeddings(
+    model_name=EMBED_MODEL,
+    encode_kwargs={"normalize_embeddings": True},
+)
+
+sparse_embeddings = FastEmbedSparse(model_name="Qdrant/bm25")
+
+for field in ["province", "type"]:
+    client_qdrant.create_payload_index(
+        collection_name=COLLECTION_NAME,
+        field_name=field,
+        field_schema=qdm.PayloadSchemaType.KEYWORD,
+    )
+
+vectorstore = QdrantVectorStore(
+    client=client_qdrant,
+    collection_name=COLLECTION_NAME,
+    embedding=embeddings,
+    sparse_embedding=sparse_embeddings,
+    vector_name="dense",
+    sparse_vector_name="sparse",
+    content_payload_key="content",
+    metadata_payload_key=None,
+)
+
+
+def get_provinces_from_qdrant(client, collection_name):
+    provinces = set()
+    points, _ = client.scroll(
+        collection_name=collection_name,
+        limit=1000,
+        with_payload=True,
+    )
+    for p in points:
+        payload = p.payload
+        if payload and "province" in payload:
+            provinces.add(payload["province"])
+    return list(provinces)
+
+
+reranker = CrossEncoder(RERANK_MODEL)
+PROVINCES = get_provinces_from_qdrant(client_qdrant, COLLECTION_NAME)
+print("Loaded provinces:", PROVINCES)
+
+
+# ====================== PRE-RETRIEVAL ======================
+
+def chat_llm(messages: List[Dict], model=LLM_MODEL) -> str:
+    resp = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=0.1,
+    )
+    return resp.choices[0].message.content.strip()
+
+
+def condense_question(query: str, chat_history: List[Dict]) -> str:
+    """
+    Nếu có lịch sử hội thoại, dùng LLM để viết lại câu hỏi thành
+    câu độc lập (standalone), không phụ thuộc ngữ cảnh trước.
+    Ví dụ: "còn ăn gì nữa không?" → "ăn gì ở Hà Nội ngoài phở?"
+    """
+    if not chat_history:
+        return query
+
+    # Chỉ lấy 6 lượt gần nhất để tránh context quá dài
+    recent = chat_history[-6:]
+    history_text = "\n".join([
+        f"{'User' if m['role'] == 'user' else 'Bot'}: {m['content'][:200]}"
+        for m in recent
+    ])
+
+    prompt = f"""Dựa vào lịch sử hội thoại bên dưới, hãy viết lại câu hỏi cuối thành câu hỏi độc lập, đầy đủ nghĩa mà không cần đọc lịch sử.
+
+Lịch sử:
+{history_text}
+
+Câu hỏi hiện tại: "{query}"
+
+Yêu cầu:
+- Nếu câu hỏi đã rõ ràng, giữ nguyên
+- Nếu câu hỏi tham chiếu đến thứ đã đề cập trước (ở đó, nơi đó, còn gì nữa...), hãy bổ sung đầy đủ
+- Chỉ trả về câu hỏi đã viết lại, không giải thích
+- Giữ nguyên tiếng Việt"""
+
+    return chat_llm([{"role": "user", "content": prompt}])
+
+
+def normalize(text: str) -> str:
+    text = text.lower()
+    text = unicodedata.normalize("NFD", text)
+    text = "".join(c for c in text if unicodedata.category(c) != "Mn")
+    return text
+
+
+def detect_province(query: str, provinces: List[str]) -> Optional[str]:
+    q = normalize(query)
+    sorted_provinces = sorted(provinces, key=lambda p: len(p), reverse=True)
+    for p in sorted_provinces:
+        name = normalize(p.replace("_", " "))
+        pattern = r'(?<![a-z])' + re.escape(name) + r'(?![a-z])'
+        if re.search(pattern, q):
+            return p
+    return None
+
+
+def _extract_json(text: str) -> Dict[str, Any]:
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+    matches = re.findall(r"\{[^{}]*\}", text)
+    for m in matches:
+        try:
+            return json.loads(m)
+        except:
+            continue
+    return {"type": None}
+
+
+def route_query_llm(query: str) -> Dict:
+    province = detect_province(query, PROVINCES)
+
+    prompt = f"""Bạn là bộ phân loại intent cho chatbot du lịch Việt Nam.
+
+YÊU CẦU:
+- Trả về JSON
+- KHÔNG dùng tiếng Anh ngoài các giá trị enum
+- KHÔNG giải thích
+
+{{"type": "destination|food|transportation|accommodation|pricing|schedule|general|null"}}
+
+Câu truy vấn: "{query}"
+"""
+    text = chat_llm([{"role": "user", "content": prompt}])
+    data = _extract_json(text)
+    detected_type = data.get("type")
+
+    must_clauses   = []
+    should_clauses = []
+
+    if province:
+        must_clauses.append(
+            qdm.FieldCondition(key="province", match=qdm.MatchValue(value=province))
+        )
+
+    if detected_type and detected_type not in ("null", "general", None):
+        should_clauses.append(
+            qdm.FieldCondition(key="type", match=qdm.MatchValue(value=detected_type))
+        )
+        should_clauses.append(
+            qdm.FieldCondition(key="type", match=qdm.MatchValue(value="general"))
+        )
+
+    qdrant_filter = None
+    if must_clauses or should_clauses:
+        qdrant_filter = qdm.Filter(
+            must=must_clauses   if must_clauses   else None,
+            should=should_clauses if should_clauses else None,
+        )
+
+    return {
+        "province": province,
+        "type":     detected_type,
+        "filter":   qdrant_filter,
+    }
+
+
+# ====================== RETRIEVAL ======================
+
+def retrieve_mmr(query: str, k=25, fetch_k=60, qdrant_filter=None):
+    docs = vectorstore.max_marginal_relevance_search(
+        query=query,
+        k=k,
+        fetch_k=fetch_k,
+        filter=qdrant_filter,
+    )
+    # Fallback nếu filter quá chặt
+    if len(docs) < 3 and qdrant_filter is not None:
+        print("⚠️  Fallback no-filter")
+        docs = vectorstore.max_marginal_relevance_search(
+            query=query, k=k, fetch_k=fetch_k
+        )
+    return docs
+
+
+# ====================== POST-RETRIEVAL ======================
+
+def rerank_bge(query: str, docs, top_n=7):
+    if not docs:
+        return []
+    pairs  = [[query, d.page_content] for d in docs]
+    scores = reranker.predict(pairs)
+    ranked = sorted(zip(docs, scores), key=lambda x: x[1], reverse=True)
+    return [doc for doc, _ in ranked[:top_n]]
+
+
+def build_context(docs, max_chars=4500) -> str:
+    result, total = [], 0
+    for i, d in enumerate(docs, 1):
+        text = d.page_content
+        if total + len(text) > max_chars:
+            break
+        result.append(f"[CHUNK {i}]\n{text}")
+        total += len(text)
+    return "\n\n".join(result)
+
+
+# ====================== GENERATION ======================
+
+def generate_answer(
+    query: str,
+    context: str,
+    chat_history: List[Dict],
+):
+    """
+    Sinh câu trả lời có stream.
+    chat_history: list các dict {"role": "user"|"assistant", "content": "..."}
+    """
+    system_prompt = (
+        "Bạn là trợ lý du lịch chuyên nghiệp, am hiểu sâu sắc về du lịch Việt Nam.\n"
+        "Hãy trả lời một cách thân thiện, chính xác, chi tiết và nhiệt tình. "
+        "Sử dụng emoji phù hợp 🏖️🍲☕🏞️.\n"
+        "Khi người dùng hỏi tiếp theo dựa trên cuộc trò chuyện, hãy nhớ ngữ cảnh trước."
+    )
+
+    rag_prompt = f"""Dưới đây là tài liệu tham khảo:
+
+<context>
+{context}
+</context>
+
+QUY TẮC:
+1. TUYỆT ĐỐI CHỈ DÙNG thông tin trong <context>. KHÔNG bịa thêm.
+2. Liệt kê rõ ràng từng ý, có địa chỉ/giá/giờ nếu context có.
+3. Nếu <context> không đủ thông tin, hãy nói: "Tôi chưa có đủ thông tin về điều này, bạn có thể hỏi cụ thể hơn không?"
+
+Câu hỏi: {query}"""
+
+    # Xây dựng messages: system + lịch sử (tối đa 6 lượt) + câu hỏi mới
+    messages = [{"role": "system", "content": system_prompt}]
+
+    # Thêm lịch sử hội thoại (chỉ giữ 6 lượt gần nhất tránh vượt context window)
+    for msg in chat_history[-6:]:
+        messages.append({"role": msg["role"], "content": msg["content"][:600]})
+
+    # Câu hỏi hiện tại kèm context
+    messages.append({"role": "user", "content": rag_prompt})
+
+    stream = client.chat.completions.create(
+        model=LLM_MODEL,
+        messages=messages,
+        temperature=0.15,
+        stream=True,
+    )
+
+    for chunk in stream:
+        delta = chunk.choices[0].delta.content
+        if delta:
+            yield delta
+
+
+# ====================== FULL PIPELINE ======================
+
+def rag_pipeline(query: str, chat_history: List[Dict] = None):
+    """
+    Args:
+        query:        Câu hỏi hiện tại của user
+        chat_history: List [{"role": "user"|"assistant", "content": "..."}]
+                      Truyền vào từ session_state của Streamlit
+    Yields:
+        str — từng chunk text để stream ra UI
+    """
+    if chat_history is None:
+        chat_history = []
+
+    print(f"\n👤 User: {query}")
+
+    # 1. Condense: viết lại câu hỏi thành standalone nếu có lịch sử
+    standalone = condense_question(query, chat_history)
+    print(f"📝 Standalone: {standalone}")
+
+    # 2. Routing
+    route_info = route_query_llm(standalone)
+    print(f"🗺️  Route: province={route_info['province']} | type={route_info['type']}")
+
+    # 3. Retrieve
+    docs = retrieve_mmr(
+        query=standalone,
+        k=25,
+        fetch_k=60,
+        qdrant_filter=route_info["filter"],
+    )
+    print(f"📚 Retrieved: {len(docs)}")
+
+    # 4. Rerank
+    reranked = rerank_bge(standalone, docs, top_n=7)
+    print(f"🔝 Reranked: {len(reranked)}")
+
+    # 5. Build context + generate
+    ctx = build_context(reranked)
+    yield from generate_answer(query, ctx, chat_history)
+
+
+# ====================== CLI ======================
+
+if __name__ == "__main__":
+    print("🤖 Travel Chatbot ready! (gõ 'exit' để thoát)\n")
+
+    history: List[Dict] = []
+
+    while True:
+        query = input("👤 Bạn: ").strip()
+        if query.lower() in ["exit", "quit", "q"]:
+            print("👋 Tạm biệt!")
+            break
+
+        print("🤖 Chatbot: ", end="", flush=True)
+        answer_chunks = []
+
+        for chunk in rag_pipeline(query, chat_history=history):
+            print(chunk, end="", flush=True)
+            answer_chunks.append(chunk) 
+
+        full_answer = "".join(answer_chunks)
+        print("\n" + "-" * 50)
+
+        # Cập nhật lịch sử
+        history.append({"role": "user",      "content": query})
+        history.append({"role": "assistant", "content": full_answer})

config.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+EMBED_MODEL = os.getenv("EMBED_MODEL")
+RERANK_MODEL = os.getenv("RERANK_MODEL")
+HF_TOKEN = os.getenv("HF_TOKEN")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+
+
+

main.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+import json
+import uuid
+import os
+from datetime import datetime
+from typing import List, Dict, Optional
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from RAG_pipeline.building_retriever import rag_pipeline
+
+# ── App ───────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Vietnam Tourism Chatbot API",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],   # production: đổi thành domain FE cụ thể
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── In-memory session store ───────────────────────────────────────────────────
+# Key: session_id  →  Value: { "history": [...], "created_at": ..., "title": ... }
+SESSIONS: Dict[str, dict] = {}
+
+SESSIONS_DIR = "chat_sessions"
+os.makedirs(SESSIONS_DIR, exist_ok=True)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# Schemas
+# ══════════════════════════════════════════════════════════════════════════════
+
+class ChatRequest(BaseModel):
+    session_id: Optional[str] = None   # None → tạo session mới
+    query: str
+
+class SessionCreateResponse(BaseModel):
+    session_id: str
+    created_at: str
+
+class SessionInfo(BaseModel):
+    session_id: str
+    title: str
+    created_at: str
+    updated_at: str
+    message_count: int
+
+class Message(BaseModel):
+    role: str   # "user" | "assistant"
+    content: str
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# Session helpers
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _get_or_create_session(session_id: Optional[str]) -> str:
+    if session_id and session_id in SESSIONS:
+        return session_id
+
+    # Tạo mới
+    sid = str(uuid.uuid4())[:8]
+    SESSIONS[sid] = {
+        "title":      "Phiên chat mới",
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "history":    [],   # [{"role": "user"|"assistant", "content": "..."}]
+    }
+    _persist_session(sid)
+    return sid
+
+
+def _persist_session(sid: str):
+    path = os.path.join(SESSIONS_DIR, f"{sid}.json")
+    data = {"id": sid, **SESSIONS[sid]}
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def _load_sessions_from_disk():
+    """Load tất cả phiên đã lưu khi server khởi động."""
+    for fname in os.listdir(SESSIONS_DIR):
+        if not fname.endswith(".json"):
+            continue
+        try:
+            with open(os.path.join(SESSIONS_DIR, fname), encoding="utf-8") as f:
+                data = json.load(f)
+            sid = data.pop("id")
+            SESSIONS[sid] = data
+        except Exception:
+            continue
+
+
+# Load sessions khi startup
+@app.on_event("startup")
+async def startup():
+    _load_sessions_from_disk()
+    print(f"✅ Loaded {len(SESSIONS)} sessions from disk")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# Endpoints
+# ══════════════════════════════════════════════════════════════════════════════
+
+@app.get("/")
+def health():
+    return {"status": "ok", "service": "Vietnam Tourism Chatbot"}
+
+
+# ── Session management ────────────────────────────────────────────────────────
+
+@app.post("/sessions", response_model=SessionCreateResponse)
+def create_session():
+    """Tạo phiên chat mới."""
+    sid = _get_or_create_session(None)
+    return {"session_id": sid, "created_at": SESSIONS[sid]["created_at"]}
+
+
+@app.get("/sessions", response_model=List[SessionInfo])
+def list_sessions():
+    """Lấy danh sách tất cả phiên, sort mới nhất lên đầu."""
+    result = []
+    for sid, s in SESSIONS.items():
+        result.append(SessionInfo(
+            session_id=    sid,
+            title=         s.get("title", "Phiên chat mới"),
+            created_at=    s.get("created_at", ""),
+            updated_at=    s.get("updated_at", ""),
+            message_count= len(s.get("history", [])),
+        ))
+    return sorted(result, key=lambda x: x.updated_at, reverse=True)
+
+
+@app.get("/sessions/{session_id}/messages", response_model=List[Message])
+def get_messages(session_id: str):
+    """Lấy toàn bộ lịch sử chat của một phiên."""
+    if session_id not in SESSIONS:
+        raise HTTPException(status_code=404, detail="Session không tồn tại")
+    return SESSIONS[session_id].get("history", [])
+
+
+@app.delete("/sessions/{session_id}")
+def delete_session(session_id: str):
+    """Xóa phiên chat."""
+    if session_id not in SESSIONS:
+        raise HTTPException(status_code=404, detail="Session không tồn tại")
+    SESSIONS.pop(session_id)
+    path = os.path.join(SESSIONS_DIR, f"{session_id}.json")
+    if os.path.exists(path):
+        os.remove(path)
+    return {"deleted": session_id}
+
+
+# ── Chat (streaming SSE) ──────────────────────────────────────────────────────
+
+@app.post("/chat")
+def chat(req: ChatRequest):
+    """
+    Gửi câu hỏi, nhận câu trả lời dạng SSE stream.
+
+    Client đọc từng event:
+        data: {"token": "Xin", "done": false}
+        data: {"token": " chào", "done": false}
+        ...
+        data: {"token": "", "done": true, "session_id": "abc12345"}
+    """
+    sid = _get_or_create_session(req.session_id)
+    session = SESSIONS[sid]
+    history: List[Dict] = session.get("history", [])
+
+    def event_stream():
+        full_answer_parts = []
+
+        try:
+            for token in rag_pipeline(query=req.query, chat_history=history):
+                full_answer_parts.append(token)
+                payload = json.dumps({"token": token, "done": False}, ensure_ascii=False)
+                yield f"data: {payload}\n\n"
+
+        except Exception as e:
+            err = json.dumps({"error": str(e), "done": True})
+            yield f"data: {err}\n\n"
+            return
+
+        # Stream xong → cập nhật history + auto-title + persist
+        full_answer = "".join(full_answer_parts)
+
+        history.append({"role": "user",      "content": req.query})
+        history.append({"role": "assistant", "content": full_answer})
+        session["history"]    = history
+        session["updated_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Auto-title từ câu hỏi đầu tiên
+        if session["title"] == "Phiên chat mới":
+            title = req.query.strip()
+            session["title"] = title[:45] + "…" if len(title) > 45 else title
+
+        _persist_session(sid)
+
+        # Done event
+        done_payload = json.dumps({
+            "token":      "",
+            "done":       True,
+            "session_id": sid,
+            "title":      session["title"],
+        }, ensure_ascii=False)
+        yield f"data: {done_payload}\n\n"
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",   # tắt nginx buffer nếu có
+        },
+    )

requirements.txt

@@ -0,0 +1,76 @@
+asttokens==3.0.0
+attrs==25.3.0
+beautifulsoup4==4.14.2
+certifi==2025.8.3
+cffi==2.0.0
+chardet==5.2.0pi
+charset-normalizer==3.4.3
+chromedriver-autoinstaller==0.6.4
+colorama==0.4.6
+comm==0.2.3
+cssselect==1.3.0
+debugpy==1.8.17
+decorator==5.2.1
+executing==2.2.1
+h11==0.16.0
+idna==3.10
+ipykernel==6.30.1
+ipython==9.6.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+lxml==6.0.2
+lxml_html_clean==0.4.2
+matplotlib-inline==0.1.7
+nest-asyncio==1.6.0
+outcome==1.3.0.post0
+packaging==25.0
+parso==0.8.5
+platformdirs==4.4.0
+prompt_toolkit==3.0.52
+psutil==7.1.0
+pure_eval==0.2.3
+pycparser==2.23
+Pygments==2.19.2
+PySocks==1.7.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+pywin32==311
+pyzmq==27.1.0
+readability-lxml==0.8.4.1
+requests==2.32.5
+selenium==4.35.0
+six==1.17.0
+sniffio==1.3.1
+sortedcontainers==2.4.0
+soupsieve==2.8
+stack-data==0.6.3
+tornado==6.5.2
+traitlets==5.14.3
+trio==0.30.0
+trio-websocket==0.12.2
+typing_extensions==4.14.1
+urllib3==2.5.0
+wcwidth==0.2.14
+webdriver-manager==4.0.2
+websocket-client==1.8.0
+wsproto==1.2.0
+markdownify
+langchain
+langchain-text-splitters
+unsloth 
+unsloth-zoo 
+torch 
+transformers 
+datasets 
+trl 
+accelerate 
+bitsandbytes 
+peft 
+sentencepiece
+matplotlib
+llmcompressor
+torch
+
+