Upload 14 files

.env

@@ -0,0 +1,3 @@
+QDRANT_URL=https://88e64c74-84e7-47a9-a40a-3a305d6dc703.us-west-2-0.aws.cloud.qdrant.io
+GEMINI_API_KEY=AIzaSyBQ3_xDvD3cVDICrPT4qlVmGZlPHkKWrYA
+QDRANT_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.n0rHOwXrpWXrhOw9DClu5VjucscB81JLQ40nIwkKuLY

Dockerfile

@@ -1 +1,16 @@
-FROM ukielz/cocacola-chatbot:latest
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir -r requirements_product.txt
+
+# Set env để Streamlit & HuggingFace không ghi vào /
+ENV HF_HOME=/app/.cache
+ENV TRANSFORMERS_CACHE=/app/.cache
+ENV STREAMLIT_HOME=/app/.streamlit
+
+EXPOSE 7860
+
+CMD ["bash", "-c", "uvicorn server:app --host 0.0.0.0 --port 8000 & streamlit run app.py --server.port 7860 --server.address 0.0.0.0"]

app.py

@@ -0,0 +1,39 @@
+import streamlit as st
+import requests
+
+API_URL = "http://localhost:8000/chat"  # FastAPI server của bạn
+
+st.set_page_config(page_title="Coca-Cola Chatbot", page_icon="🥤", layout="wide")
+st.title("🥤 Coca-Cola Vietnam Chatbot")
+
+if "messages" not in st.session_state:
+    st.session_state["messages"] = []
+
+# Hiển thị lịch sử chat
+for msg in st.session_state["messages"]:
+    with st.chat_message(msg["role"]):
+        st.markdown(msg["content"])
+
+# Input từ người dùng
+if user_input := st.chat_input("Nhập tin nhắn..."):
+    # Hiển thị ngay trên UI
+    st.session_state["messages"].append({"role": "user", "content": user_input})
+    with st.chat_message("user"):
+        st.markdown(user_input)
+
+    # Gửi request đến FastAPI
+    try:
+        response = requests.post(API_URL, json={"message": user_input}, params={"session_id": "default"}, timeout=60)
+        if response.status_code == 200:
+            data = response.json()
+            bot_reply = data.get("response", "⚠️ Không có phản hồi")
+        else:
+            bot_reply = f"❌ Lỗi API: {response.status_code}"
+
+    except Exception as e:
+        bot_reply = f"⚠️ Không kết nối được API: {e}"
+
+    # Hiển thị phản hồi bot
+    st.session_state["messages"].append({"role": "assistant", "content": bot_reply})
+    with st.chat_message("assistant"):
+        st.markdown(bot_reply)

backend/config.py

@@ -0,0 +1,17 @@
+import os
+import torch
+from dotenv import load_dotenv
+
+load_dotenv()
+
+COLLECTION_NAME = "cocacola_vietname_data"
+EMBEDDING_MODEL_NAME = "AITeamVN/Vietnamese_Embedding"
+MAX_LENGTH = 512
+TOP_K = 5
+MIN_SIMILARITY_SCORE = 0.5
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")

backend/models.py

@@ -0,0 +1,25 @@
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel
+
+
+class ChatRequest(BaseModel):
+    message: str
+    feedback: Optional[str] = None
+
+
+class NLUResult(BaseModel):
+    intent: str
+    confidence: float
+
+
+class ActionResponse(BaseModel):
+    type: str
+    parameters: Optional[Dict[str, Any]] = {}
+
+
+class ChatResponse(BaseModel):
+    response: str
+    context: str
+    nlu: NLUResult
+    action: Optional[ActionResponse] = None
+    images: Optional[List[str]] = None

backend/routes/chat.py

@@ -0,0 +1,96 @@
+import os
+from typing import Dict, List
+from fastapi import APIRouter, HTTPException
+from backend.models import ChatRequest, ChatResponse, NLUResult
+from backend.services.embeddings import get_embeddings, combine_embeddings, process_chunk_data
+from backend.services.qdrant import search_in_qdrant
+from backend.services.utils import validate_image_base64
+from backend.services.nlu import NLUPipeline
+from backend.config import COLLECTION_NAME, GEMINI_API_KEY, QDRANT_API_KEY, QDRANT_URL, TOP_K
+import google.generativeai as genai
+from qdrant_client import QdrantClient
+
+
+router = APIRouter(tags=["Chat"])
+
+qdrant = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY, timeout=120.0)
+genai.configure(api_key=GEMINI_API_KEY)
+
+gemini = genai.GenerativeModel("gemini-2.5-flash")
+nlu_pipeline = NLUPipeline(gemini)
+
+
+## Ghi nhớ hội dung cuộc hội thoại
+conversation_history = {}
+
+
+def get_conversation_history(session_id: str) -> List[Dict]:
+    return conversation_history.get(session_id, [])
+
+
+def add_to_conversation_history(session_id: str, role: str, content: str):
+    if session_id not in conversation_history:
+        conversation_history[session_id] = []
+
+    conversation_history[session_id].append({"role": role, "content": content, "timestamp": os.time.time() if hasattr(os, "time") else 0})
+
+    if len(conversation_history[session_id]) > 10:
+        conversation_history[session_id] = conversation_history[session_id][-10:]
+
+
+@router.post("/chat", response_model=ChatResponse, tags=["Chat"])
+async def chat_endpoint(request: ChatRequest, session_id: str = "default"):
+    user_query = request.message
+
+    try:
+        history = get_conversation_history(session_id)
+
+        nlu_result = nlu_pipeline.analyze_user_input(user_query, history)
+
+        content_emb = get_embeddings([user_query])
+        query_vector = combine_embeddings(content_emb[0])
+
+        results = qdrant.search(collection_name=COLLECTION_NAME, query_vector=query_vector.tolist(), limit=TOP_K, with_payload=True)
+
+        context_parts = []
+        valid_images = []
+
+        for idx, r in enumerate(results):
+            payload = r.payload or {}
+            markdown_content, images = process_chunk_data(payload)
+
+            context_part = f"### Tài liệu tham khảo #{idx + 1}\n"
+            context_part += f"**Độ tương đồng:** {r.score:.2f}\n"
+            context_part += markdown_content
+
+            if images:
+                context_part += "\n\n**Ảnh liên quan:**\n"
+                for i, img_base64 in enumerate(images):
+                    if validate_image_base64(img_base64):
+                        img_ref = f"image_{idx}_{i}"
+                        valid_images.append(img_base64)
+                        context_part += f"![{img_ref}](attachment://{img_ref})\n"
+                    else:
+                        context_part += "⚠️ Ảnh không hợp lệ (bỏ qua)\n"
+
+            context_parts.append(context_part)
+
+        context = "\n---\n".join(context_parts)
+
+        text_response = nlu_pipeline.generate_response(user_query, context, nlu_result, history)
+
+        add_to_conversation_history(session_id, "user", user_query)
+        add_to_conversation_history(session_id, "assistant", text_response)
+
+        return {
+            "response": text_response,
+            "context": context,
+            "nlu": NLUResult(
+                intent=nlu_result["intent"],
+                confidence=nlu_result["confidence"],
+            ),
+            "images": valid_images if valid_images else None,
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi xử lý yêu cầu: {str(e)}")

backend/services/embeddings.py

@@ -0,0 +1,50 @@
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModel
+from typing import Dict, Any, List, Optional, Tuple
+from backend.config import EMBEDDING_MODEL_NAME, MAX_LENGTH, DEVICE
+
+tokenizer = AutoTokenizer.from_pretrained(EMBEDDING_MODEL_NAME)
+model = AutoModel.from_pretrained(EMBEDDING_MODEL_NAME).to(DEVICE).eval()
+
+
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0]
+    mask = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * mask, 1) / torch.clamp(mask.sum(1), min=1e-9)
+
+
+def get_embeddings(texts):
+    inputs = tokenizer(texts, padding=True, truncation=True, max_length=MAX_LENGTH, return_tensors="pt").to(DEVICE)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    emb = mean_pooling(outputs, inputs["attention_mask"])
+    return torch.nn.functional.normalize(emb, p=2, dim=1).cpu().numpy()
+
+
+def combine_embeddings(content_emb: np.ndarray) -> np.ndarray:
+    combined = content_emb
+    norm = np.linalg.norm(combined)
+    if norm > 1e-8:
+        return combined / norm
+    return combined
+
+
+def process_chunk_data(payload: Dict[str, Any]) -> Tuple[str, List[str]]:
+    markdown_content = ""
+    images = []
+
+    if payload.get("source_file"):
+        markdown_content += f"\n\n**File gốc:** {payload['source_file']}\n\n"
+    if payload.get("markdown_data"):
+        markdown_content += payload["markdown_data"]
+
+    if payload.get("images"):
+        if isinstance(payload["images"], list):
+            for img_data in payload["images"]:
+                if isinstance(img_data, str):
+                    images.append(img_data)
+                elif isinstance(img_data, dict) and img_data.get("data"):
+                    images.append(img_data["data"])
+
+    return markdown_content, images

backend/services/nlu.py

@@ -0,0 +1,113 @@
+from typing import Dict, Any, List, Optional, Tuple
+import json
+import re
+
+
+class NLUPipeline:
+    def __init__(self, llm_model):
+        self.llm = llm_model
+
+    def analyze_user_input(self, text: str, conversation_history: Optional[List] = None) -> Dict[str, Any]:
+
+        history_context = ""
+        if conversation_history:
+            history_context = "Lịch sử hội thoại gần đây:\n"
+            for i, msg in enumerate(conversation_history[-3:]):
+                history_context += f"- {msg.get('role', 'user')}: {msg.get('content', '')}\n"
+            history_context += "\n"
+
+        nlu_prompt = f"""
+                    Bạn là một chuyên gia phân tích ngôn ngữ tự nhiên cho hệ thống AI hỗ trợ bán hàng Coca-Cola Việt Nam.
+
+                    {history_context}
+
+                    Tin nhắn cần phân tích: "{text}"
+
+                    Hãy phân tích và trả về kết quả theo định dạng JSON chính xác sau:
+
+                    {{
+                        "intent": "tên_intent",
+                        "confidence": số_từ_0_đến_1,
+                        "entities": {{
+                            "product": "tên_sản_phẩm_nếu_có",
+                            "quantity": "số_lượng_nếu_có", 
+                            "city": "tên_thành_phố_nếu_có",
+                            "price_range": "khoảng_giá_nếu_có",
+                            "time": "thời_gian_nếu_có",ml_model.pkl
+                            "contact_info": "thông_tin_liên_lạc_nếu_có"
+                        }},
+                    }}
+
+                    **Danh sách Intent có thể:**
+                    - "order": Muốn đặt hàng, mua sản phẩm
+                    - "check_inventory": Kiểm tra tồn kho, hàng còn không
+                    - "product_info": Hỏi thông tin sản phẩm, giá cả, tính năng
+                    - "promotion": Hỏi về khuyến mãi, ưu đãi, giảm giá
+                    - "delivery": Hỏi về giao hàng, vận chuyển, thời gian
+                    - "complaint": Phàn nàn, khiếu nại, không hài lòng
+                    - "support": Cần hỗ trợ kỹ thuật, giải đáp thắc mắc
+                    - "greeting": Chào hỏi, làm quen
+                    - "goodbye": Chào tạm biệt, kết thúc cuộc trò chuyện
+                    - "payment": Hỏi về thanh toán, phương thức trả tiền
+                    - "cancel_order": Hủy đơn hàng
+                    - "track_order": Theo dõi đơn hàng
+                    - "feedback": Góp ý, đánh giá
+                    - "other": Các ý định khác
+
+                    **Sản phẩm Coca-Cola phổ biến:**
+                    - Coca Cola, Coke (các loại: Classic, Zero, Light)
+                    - Sprite, 7Up
+                    - Fanta (cam, nho, dứa)
+                    - Nutriboost (sữa có gas)
+                    - Nước suối Dasani
+                    - Schweppes
+                    - Aquarius
+
+                    **Thành phố chính:**
+                    - Hà Nội, Thành phố Hồ Chí Minh, Đà Nẵng, Cần Thơ, Hải Phòng, Nha Trang, Huế, Vũng Tàu
+
+                    CHỈ trả về JSON, không có text khác.
+                    """
+        try:
+            result_text = self.llm.generate_content(nlu_prompt).text.strip()
+            json_match = re.search(r"\{[\s\S]*\}", result_text)
+            return json.loads(json_match.group())
+        except Exception as e:
+            print(f"Error in LLM NLU analysis: {e}")
+            return
+
+    def generate_response(self, user_query: str, context: str, nlu_result: Dict, conversation_history: Optional[List] = None) -> Tuple[str, Optional[Dict]]:
+        entities = nlu_result.get("entities", {})
+
+        adaptive_prompt = f"""
+            Bạn là AI Agent thông minh của Coca-Cola Việt Nam. Hãy trả lời một cách
+            "tone": "nhiệt tình và vui vẻ",
+            "style": "hỗ trợ năng động",
+            "guidelines":
+            - Thể hiện sự vui mừng khi được hỗ trợ
+            - Sử dụng emoji và ngôn ngữ tích cực
+            - Cung cấp thông tin chi tiết và hữu ích
+            - Gợi ý thêm sản phẩm/dịch vụ phù hợp
+      
+            **Câu hỏi:** {user_query}
+
+            **Thông tin tham khảo:**
+            {context}
+
+            **Entities được nhận diện:**
+            {json.dumps(entities, ensure_ascii=False, indent=2)}
+
+
+            **Định dạng trả lời:**
+            1. Câu trả lời chính (thích ứng với sentiment)
+            Trả lời:
+        """
+
+        try:
+            response = self.llm.generate_content(adaptive_prompt)
+            raw_output = response.text.strip()
+            return raw_output
+
+        except Exception as e:
+            print(f"Error in adaptive response generation: {e}")
+            return "Xin lỗi, tôi đang gặp sự cố kỹ thuật. Vui lòng thử lại sau.", None

backend/services/qdrant.py

@@ -0,0 +1,8 @@
+from qdrant_client import QdrantClient
+from backend.config import QDRANT_URL, QDRANT_API_KEY, COLLECTION_NAME, TOP_K
+
+qdrant = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY, timeout=120.0)
+
+
+def search_in_qdrant(query_vector, limit=TOP_K):
+    return qdrant.search(collection_name=COLLECTION_NAME, query_vector=query_vector.tolist(), limit=limit, with_payload=True)

backend/services/utils.py

@@ -0,0 +1,11 @@
+import base64
+from io import BytesIO
+from PIL import Image
+
+
+def validate_image_base64(image_base64: str) -> bool:
+    try:
+        Image.open(BytesIO(base64.b64decode(image_base64)))
+        return True
+    except:
+        return False

requirements_product.txt

@@ -0,0 +1,18 @@
+numpy
+pillow
+python-dotenv
+
+# AI / NLP
+torch
+transformers
+google-generativeai
+
+# DB / Vector DB
+qdrant-client
+
+# Web / API
+fastapi
+uvicorn
+
+streamlit
+requests

server.py

@@ -0,0 +1,15 @@
+from fastapi import FastAPI
+from backend.routes import chat
+
+app = FastAPI(
+    title="Coca-Cola Vietnam AI Agent",
+    version="1.0.0",
+)
+
+# Đăng ký router
+app.include_router(chat.router)
+
+# if __name__ == "__main__":
+#     import uvicorn
+
+#     uvicorn.run("server:app", host="127.0.0.1", port=8000, reload=True)