init project using Cursor

.env.example

@@ -0,0 +1,19 @@
+# Facebook Configuration
+FACEBOOK_VERIFY_TOKEN=your_verify_token_here
+FACEBOOK_APP_SECRET=your_app_secret_here
+
+# Google Sheets Configuration
+GOOGLE_SHEETS_CREDENTIALS_FILE=credentials.json
+GOOGLE_SHEETS_TOKEN_FILE=token.json
+CONVERSATION_SHEET_ID=your_sheet_id_here
+
+# Supabase Configuration
+SUPABASE_URL=your_supabase_url
+SUPABASE_KEY=your_supabase_key
+
+# Logging Configuration
+LOG_LEVEL=INFO
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000 

Dockerfile

@@ -1,6 +1,10 @@
-FROM python:3.10-slim
+FROM python:3.11-slim
+
 WORKDIR /app
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+
 COPY . .
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] 

README.md

@@ -0,0 +1,124 @@
+# WeBot - Facebook Messenger Chatbot
+
+WeBot là một chatbot Facebook Messenger được xây dựng với FastAPI, tích hợp với Google Sheets để lưu trữ lịch sử hội thoại và Supabase để quản lý token cũng như tìm kiếm vector.
+
+## Tính năng
+
+- Webhook Facebook Messenger để nhận và xử lý tin nhắn
+- Phân tích nội dung tin nhắn và từ khóa
+- Tích hợp với Google Sheets để lưu trữ lịch sử hội thoại
+- Sử dụng Supabase để:
+  - Quản lý access token cho từng Facebook Page
+  - Vector similarity search với embedding
+- Xử lý bất đồng bộ với async/await
+- Logging chi tiết với loguru
+
+## Yêu cầu
+
+- Python 3.8+
+- Facebook Page và App
+- Tài khoản Google Cloud với Sheets API được kích hoạt
+- Tài khoản Supabase
+
+## Cài đặt
+
+1. Clone repository:
+```bash
+git clone https://github.com/yourusername/webot.git
+cd webot
+```
+
+2. Tạo và kích hoạt môi trường ảo:
+```bash
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# hoặc
+.\venv\Scripts\activate  # Windows
+```
+
+3. Cài đặt dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+4. Cấu hình môi trường:
+- Copy file `.env.example` thành `.env`
+- Điền các thông tin cấu hình cần thiết
+
+## Cấu hình
+
+1. Facebook:
+- Tạo Facebook App và Page
+- Cấu hình webhook với URL của ứng dụng
+- Lưu Page Access Token vào Supabase
+
+2. Google Sheets:
+- Tạo project trong Google Cloud Console
+- Kích hoạt Sheets API
+- Tải credentials.json và cấu hình trong .env
+
+3. Supabase:
+- Tạo bảng `page_tokens` để lưu trữ access token
+- Cấu hình vector similarity search
+- Tạo RPC function `match_documents`
+
+## Chạy ứng dụng
+
+### Phát triển
+
+```bash
+uvicorn app.main:app --reload
+```
+
+### Production với Docker
+
+```bash
+docker build -t webot .
+docker run -p 8000:8000 webot
+```
+
+## Deploy
+
+### Fly.io
+
+1. Cài đặt Fly CLI
+2. Đăng nhập và khởi tạo ứng dụng:
+```bash
+flyctl auth login
+flyctl launch
+```
+
+3. Deploy:
+```bash
+flyctl deploy
+```
+
+### Render
+
+1. Kết nối repository với Render
+2. Tạo Web Service mới
+3. Cấu hình các biến môi trường
+4. Deploy
+
+## Cấu trúc dự án
+
+```
+webot/
+├── app/
+│   ├── __init__.py
+│   ├── main.py           # FastAPI application
+│   ├── config.py         # Configuration management
+│   ├── facebook.py       # Facebook Messenger integration
+│   ├── sheets.py         # Google Sheets integration
+│   ├── supabase_db.py    # Supabase integration
+│   ├── embedding.py      # Text embedding
+│   └── utils.py          # Utility functions
+├── requirements.txt
+├── Dockerfile
+├── .env.example
+└── README.md
+```
+
+## Đóng góp
+
+Mọi đóng góp đều được hoan nghênh! Vui lòng tạo issue hoặc pull request. 

app/__init__.py

@@ -0,0 +1 @@
+ 

app/config.py

@@ -0,0 +1,43 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    """
+    Lưu trữ và quản lý cấu hình ứng dụng từ biến môi trường.
+    Các thuộc tính: facebook_verify_token, facebook_app_secret, ...
+    """
+    # Facebook Configuration
+    facebook_verify_token: str = os.getenv("FACEBOOK_VERIFY_TOKEN") or ""
+    facebook_app_secret: str = os.getenv("FACEBOOK_APP_SECRET") or ""
+    
+    # Google Sheets Configuration
+    google_sheets_credentials_file: str = os.getenv("GOOGLE_SHEETS_CREDENTIALS_FILE") or ""
+    google_sheets_token_file: str = os.getenv("GOOGLE_SHEETS_TOKEN_FILE") or ""
+    conversation_sheet_id: str = os.getenv("CONVERSATION_SHEET_ID") or ""
+    
+    # Supabase Configuration
+    supabase_url: str = os.getenv("SUPABASE_URL") or ""
+    supabase_key: str = os.getenv("SUPABASE_KEY") or ""
+    
+    # Server Configuration
+    host: str = os.getenv("HOST", "0.0.0.0") or ""
+    port: int = int(os.getenv("PORT", "8000")) or 8000
+    
+    # Logging Configuration
+    log_level: str = os.getenv("LOG_LEVEL", "INFO") or "INFO"
+
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings() -> Settings:
+    """
+    Lấy instance Settings đã cache (singleton).
+    Input: None
+    Output: Settings instance.
+    """
+    return Settings() 

app/constants.py

@@ -0,0 +1,3 @@
+VEHICLE_KEYWORDS = ["xe máy", "ô tô", "xe đạp", "xe hơi"]
+SHEET_RANGE = 'Conversations!A2:F'
+EMBEDDING_DIM = 1536 

app/embedding.py

@@ -0,0 +1,60 @@
+from typing import List
+import numpy as np
+from loguru import logger
+import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from .utils import timing_decorator
+
+class EmbeddingClient:
+    def __init__(self):
+        """
+        Khởi tạo EmbeddingClient.
+        Input: None
+        Output: EmbeddingClient instance.
+        """
+        self._client = httpx.AsyncClient()
+
+    @timing_decorator
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
+    async def create_embedding(self, text: str) -> List[float]:
+        """
+        Tạo embedding vector từ text bằng dịch vụ embedding (ví dụ OpenAI).
+        Input: text (str)
+        Output: list[float] embedding vector.
+        """
+        try:
+            # This is a placeholder for your actual embedding service
+            # You should replace this with your preferred embedding service (e.g., OpenAI, Cohere, etc.)
+            # For example, using OpenAI's embedding API:
+            
+            # response = await self._client.post(
+            #     "https://api.openai.com/v1/embeddings",
+            #     headers={"Authorization": f"Bearer {api_key}"},
+            #     json={
+            #         "input": text,
+            #         "model": "text-embedding-ada-002"
+            #     }
+            # )
+            # embedding = response.json()["data"][0]["embedding"]
+            
+            # For now, we'll return a random vector as a placeholder
+            embedding = np.random.normal(0, 1, 1536).tolist()  # 1536 is OpenAI's embedding dimension
+            return embedding
+        except Exception as e:
+            logger.error(f"Error creating embedding: {e}")
+            raise
+
+    def cosine_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
+        """
+        Tính cosine similarity giữa hai embedding.
+        Input: embedding1 (list[float]), embedding2 (list[float])
+        Output: float (giá trị similarity)
+        """
+        try:
+            a = np.array(embedding1)
+            b = np.array(embedding2)
+            return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
+        except Exception as e:
+            logger.error(f"Error calculating similarity: {e}")
+            return 0.0 

app/facebook.py

@@ -0,0 +1,104 @@
+import hmac
+import hashlib
+import json
+from typing import Any, Dict, Optional
+import httpx
+from fastapi import HTTPException, Request
+from loguru import logger
+
+from .utils import timing_decorator
+
+class FacebookClient:
+    def __init__(self, app_secret: str):
+        """
+        Khởi tạo FacebookClient với app_secret.
+        Input: app_secret (str) - Facebook App Secret.
+        Output: FacebookClient instance.
+        """
+        self.app_secret = app_secret
+        self._client = httpx.AsyncClient()
+
+    async def verify_webhook(self, token: str, challenge: str, verify_token: str) -> int:
+        """
+        Xác thực webhook Facebook bằng verify_token và trả về challenge.
+        Input: token (str), challenge (str), verify_token (str)
+        Output: int (challenge nếu thành công, lỗi nếu thất bại)
+        """
+        if token != verify_token:
+            raise HTTPException(status_code=403, detail="Invalid verify token")
+        return int(challenge)
+
+    def verify_signature(self, request: Request, payload: bytes) -> bool:
+        """
+        Kiểm tra chữ ký X-Hub-Signature-256 để xác thực request từ Facebook.
+        Input: request (Request), payload (bytes)
+        Output: bool (True nếu hợp lệ, False nếu không)
+        """
+        signature = request.headers.get("X-Hub-Signature-256", "")
+        if not signature.startswith("sha256="):
+            return False
+
+        expected = hmac.new(
+            self.app_secret.encode(),
+            payload,
+            hashlib.sha256
+        ).hexdigest()
+        
+        return hmac.compare_digest(signature[7:], expected)
+
+    @timing_decorator
+    async def send_message(self, page_access_token: str, recipient_id: str, message: str) -> Dict[str, Any]:
+        """
+        Gửi message tới user qua Facebook Messenger API.
+        Input: page_access_token (str), recipient_id (str), message (str)
+        Output: dict (response từ Facebook API)
+        """
+        url = f"https://graph.facebook.com/v18.0/me/messages?access_token={page_access_token}"
+        
+        payload = {
+            "recipient": {"id": recipient_id},
+            "message": {"text": message}
+        }
+
+        try:
+            async with self._client as client:
+                response = await client.post(url, json=payload)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            logger.error(f"Error sending message to Facebook: {e}")
+            raise HTTPException(status_code=500, detail="Failed to send message to Facebook")
+
+    def parse_message(self, body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Parse message từ payload Facebook webhook.
+        Input: body (dict) - payload JSON từ Facebook.
+        Output: dict chứa sender_id, page_id, timestamp, text, attachments hoặc None nếu lỗi.
+        """
+        try:
+            entry = body["entry"][0]
+            messaging = entry["messaging"][0]
+            
+            sender_id = messaging["sender"]["id"]
+            recipient_id = messaging["recipient"]["id"]
+            timestamp = messaging["timestamp"]
+            
+            message_data = {
+                "sender_id": sender_id,
+                "page_id": recipient_id,
+                "timestamp": timestamp,
+                "text": None,
+                "attachments": []
+            }
+
+            if "message" in messaging:
+                message = messaging["message"]
+                if "text" in message:
+                    message_data["text"] = message["text"]
+                if "attachments" in message:
+                    message_data["attachments"] = message["attachments"]
+
+            return message_data
+        except (KeyError, IndexError) as e:
+            logger.error(f"Error parsing Facebook message: {e}")
+            return None 

app/health.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/healthz")
+async def health_check():
+    return {"status": "ok"} 

app/main.py

@@ -0,0 +1,180 @@
+from fastapi import FastAPI, Request, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from loguru import logger
+import json
+from typing import Dict, Any, List
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+from .config import Settings, get_settings
+from .facebook import FacebookClient
+from .sheets import SheetsClient
+from .supabase_db import SupabaseClient
+from .embedding import EmbeddingClient
+from .utils import setup_logging, extract_command, extract_keywords, timing_decorator, ensure_log_dir, validate_config
+from .constants import VEHICLE_KEYWORDS, SHEET_RANGE
+from .health import router as health_router
+
+app = FastAPI(title="WeBot Facebook Messenger API")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize clients
+settings = get_settings()
+setup_logging(settings.log_level)
+
+facebook_client = FacebookClient(settings.facebook_app_secret)
+sheets_client = SheetsClient(
+    settings.google_sheets_credentials_file,
+    settings.google_sheets_token_file,
+    settings.conversation_sheet_id
+)
+supabase_client = SupabaseClient(settings.supabase_url, settings.supabase_key)
+embedding_client = EmbeddingClient()
+
+# Keywords to look for in messages
+VEHICLE_KEYWORDS = ["xe máy", "ô tô", "xe đạp", "xe hơi"]
+
+app.include_router(health_router)
+
+ensure_log_dir()
+validate_config(settings)
+executor = ThreadPoolExecutor(max_workers=4)
+
+@app.get("/webhook")
+async def verify_webhook(request: Request):
+    """
+    Xác thực webhook Facebook Messenger.
+    Input: request (Request) - request từ Facebook với các query params.
+    Output: Trả về challenge nếu verify thành công, lỗi nếu thất bại.
+    """
+    params = dict(request.query_params)
+    
+    mode = params.get("hub.mode")
+    token = str(params.get("hub.verify_token", ""))
+    challenge = str(params.get("hub.challenge", ""))
+
+    if not all([mode, token, challenge]):
+        raise HTTPException(status_code=400, detail="Missing parameters")
+
+    return await facebook_client.verify_webhook(
+        token,
+        challenge,
+        settings.facebook_verify_token
+    )
+
+@app.post("/webhook")
+@timing_decorator
+async def webhook(request: Request):
+    """
+    Nhận và xử lý message từ Facebook Messenger webhook.
+    Input: request (Request) - request chứa payload JSON từ Facebook.
+    Output: JSON status.
+    """
+    body_bytes = await request.body()
+    
+    # Verify request is from Facebook
+    if not facebook_client.verify_signature(request, body_bytes):
+        raise HTTPException(status_code=403, detail="Invalid signature")
+
+    try:
+        body = json.loads(body_bytes)
+        message_data = facebook_client.parse_message(body)
+        
+        if not message_data:
+            return {"status": "ok"}
+
+        # Process the message
+        await process_message(message_data)
+        
+        return {"status": "ok"}
+    except Exception as e:
+        logger.error(f"Error processing webhook: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+async def process_message(message_data: Dict[str, Any]):
+    """
+    Xử lý message từ người dùng Facebook, phân tích, truy vấn, gửi phản hồi và log lại.
+    Input: message_data (dict) - thông tin message đã parse từ Facebook.
+    Output: None (gửi message và log hội thoại).
+    """
+    sender_id = message_data["sender_id"]
+    page_id = message_data["page_id"]
+    message_text = message_data["text"]
+    logger.bind(user_id=sender_id, page_id=page_id, message=message_text).info("Processing message")
+    if not message_text:
+        return
+
+    # Get page access token
+    page_token = await supabase_client.get_page_token(page_id)
+    if not page_token:
+        logger.error(f"No access token found for page {page_id}")
+        return
+
+    # Extract command and keywords
+    command, remaining_text = extract_command(message_text)
+    keywords = extract_keywords(message_text, VEHICLE_KEYWORDS)
+
+    # Get conversation history (run in thread pool)
+    history = await asyncio.get_event_loop().run_in_executor(
+        executor, lambda: sheets_client.get_conversation_history(sender_id, page_id).result()
+    )
+
+    response = ""
+    if command == "xong":
+        if not keywords:
+            response = "Vui lòng cho biết loại phương tiện bạn cần tìm (xe máy, ô tô...)"
+        else:
+            # Create embedding from message
+            embedding = await embedding_client.create_embedding(message_text)
+            
+            # Search for similar documents
+            matches = await supabase_client.match_documents(embedding)
+            
+            if matches:
+                response = format_search_results(matches)
+            else:
+                response = "Xin lỗi, tôi không tìm thấy thông tin phù hợp."
+    else:
+        response = "Vui lòng cung cấp thêm thông tin và gõ lệnh \\xong khi hoàn tất."
+
+    # Send response
+    await facebook_client.send_message(page_token, sender_id, response)
+
+    # Log conversation (run in thread pool)
+    await asyncio.get_event_loop().run_in_executor(
+        executor, lambda: sheets_client.log_conversation(sender_id, page_id, message_text, keywords, response).result()
+    )
+
+def format_search_results(matches: List[Dict[str, Any]]) -> str:
+    """
+    Format kết quả truy vấn vector search thành chuỗi gửi về user.
+    Input: matches (list[dict]) - danh sách kết quả từ Supabase.
+    Output: Chuỗi kết quả đã format.
+    """
+    if not matches:
+        return "Không tìm thấy kết quả phù hợp."
+
+    result = "Đây là một số kết quả phù hợp:\n\n"
+    for i, match in enumerate(matches, 1):
+        result += f"{i}. {match['content']}\n"
+        if match.get('metadata', {}).get('url'):
+            result += f"   Link: {match['metadata']['url']}\n"
+        result += "\n"
+
+    return result.strip()
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.main:app",
+        host=settings.host,
+        port=settings.port
+    ) 

app/sheets.py

@@ -0,0 +1,133 @@
+from typing import Any, Dict, List, Optional
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+import os
+import pickle
+from datetime import datetime
+from loguru import logger
+
+from .utils import timing_decorator
+from .constants import SHEET_RANGE
+
+SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
+
+class SheetsClient:
+    def __init__(self, credentials_file: str, token_file: str, sheet_id: str):
+        """
+        Khởi tạo SheetsClient với thông tin xác thực và sheet_id.
+        Input: credentials_file (str), token_file (str), sheet_id (str)
+        Output: SheetsClient instance.
+        """
+        self.credentials_file = credentials_file
+        self.token_file = token_file
+        self.sheet_id = sheet_id
+        self.creds = None
+        self.service = None
+
+    def authenticate(self) -> None:
+        """
+        Xác thực với Google Sheets API, tạo self.service.
+        Input: None
+        Output: None (raise exception nếu lỗi)
+        """
+        if os.path.exists(self.token_file):
+            with open(self.token_file, 'rb') as token:
+                self.creds = pickle.load(token)
+
+        if not self.creds or not self.creds.valid:
+            if self.creds and self.creds.expired and self.creds.refresh_token:
+                self.creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(
+                    self.credentials_file, SCOPES)
+                self.creds = flow.run_local_server(port=0)
+
+            with open(self.token_file, 'wb') as token:
+                pickle.dump(self.creds, token)
+
+        self.service = build('sheets', 'v4', credentials=self.creds)
+
+    @timing_decorator
+    async def get_conversation_history(self, user_id: str, page_id: str) -> List[Dict[str, Any]]:
+        """
+        Lấy lịch sử hội thoại của user từ Google Sheets.
+        Input: user_id (str), page_id (str)
+        Output: list[dict] các dòng hội thoại (nếu có).
+        """
+        try:
+            if not self.service:
+                self.authenticate()
+            if not self.service:
+                raise RuntimeError("Google Sheets service not initialized")
+            range_name = SHEET_RANGE
+            result = self.service.spreadsheets().values().get(
+                spreadsheetId=self.sheet_id,
+                range=range_name
+            ).execute()
+
+            values = result.get('values', [])
+            history = []
+
+            for row in values:
+                if len(row) >= 6 and row[0] == user_id and row[1] == page_id:
+                    history.append({
+                        'user_id': row[0],
+                        'page_id': row[1],
+                        'timestamp': row[2],
+                        'message': row[3],
+                        'keywords': row[4],
+                        'response': row[5]
+                    })
+
+            return history
+        except Exception as e:
+            logger.error(f"Error getting conversation history: {e}")
+            return []
+
+    @timing_decorator
+    async def log_conversation(
+        self,
+        user_id: str,
+        page_id: str,
+        message: str,
+        keywords: List[str],
+        response: str
+    ) -> bool:
+        """
+        Ghi log hội thoại vào Google Sheets.
+        Input: user_id (str), page_id (str), message (str), keywords (list[str]), response (str)
+        Output: bool (True nếu thành công, False nếu lỗi)
+        """
+        try:
+            if not self.service:
+                self.authenticate()
+            if not self.service:
+                raise RuntimeError("Google Sheets service not initialized")
+            timestamp = datetime.now().isoformat()
+            values = [[
+                user_id,
+                page_id,
+                timestamp,
+                message,
+                ','.join(keywords),
+                response
+            ]]
+
+            body = {
+                'values': values
+            }
+
+            range_name = SHEET_RANGE
+            self.service.spreadsheets().values().append(
+                spreadsheetId=self.sheet_id,
+                range=range_name,
+                valueInputOption='RAW',
+                body=body
+            ).execute()
+
+            return True
+        except Exception as e:
+            logger.error(f"Error logging conversation: {e}")
+            return False 

app/supabase_db.py

@@ -0,0 +1,73 @@
+from typing import Any, Dict, List, Optional
+from supabase import create_client, Client
+from loguru import logger
+
+from .utils import timing_decorator
+
+class SupabaseClient:
+    def __init__(self, url: str, key: str):
+        """
+        Khởi tạo SupabaseClient với url và key.
+        Input: url (str), key (str)
+        Output: SupabaseClient instance.
+        """
+        self.client: Client = create_client(url, key)
+
+    @timing_decorator
+    def get_page_token(self, page_id: str):
+        """
+        Lấy access token của Facebook page từ Supabase.
+        Input: page_id (str)
+        Output: access_token (str) hoặc None nếu không có.
+        """
+        try:
+            response = self.client.table('page_tokens').select('access_token').eq('page_id', page_id).execute()
+            if response.data and len(response.data) > 0:
+                return response.data[0]['access_token']
+            return None
+        except Exception as e:
+            logger.error(f"Error getting page token: {e}")
+            return None
+
+    @timing_decorator
+    def match_documents(self, embedding: List[float], match_count: int = 5):
+        """
+        Truy vấn vector similarity search qua RPC match_documents.
+        Input: embedding (list[float]), match_count (int)
+        Output: list[dict] kết quả truy vấn.
+        """
+        try:
+            response = self.client.rpc(
+                'match_documents',
+                {
+                    'query_embedding': embedding,
+                    'match_threshold': 0.7,
+                    'match_count': match_count
+                }
+            ).execute()
+
+            if response.data:
+                return response.data
+            return []
+        except Exception as e:
+            logger.error(f"Error matching documents: {e}")
+            return []
+
+    @timing_decorator
+    def store_embedding(self, text: str, embedding: List[float], metadata: Dict[str, Any]):
+        """
+        Lưu embedding vào Supabase.
+        Input: text (str), embedding (list[float]), metadata (dict)
+        Output: bool (True nếu thành công, False nếu lỗi)
+        """
+        try:
+            response = self.client.table('embeddings').insert({
+                'content': text,
+                'embedding': embedding,
+                'metadata': metadata
+            }).execute()
+            
+            return bool(response.data)
+        except Exception as e:
+            logger.error(f"Error storing embedding: {e}")
+            return False 

app/utils.py

@@ -0,0 +1,87 @@
+import time
+from functools import wraps
+from loguru import logger
+from typing import Any, Callable
+import os
+
+def timing_decorator(func: Callable) -> Callable:
+    """
+    Decorator đo thời gian thực thi của hàm async, log thời lượng xử lý.
+    Input: func (Callable) - hàm async cần đo.
+    Output: Kết quả trả về của func.
+    """
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        start_time = time.time()
+        result = await func(*args, **kwargs)
+        end_time = time.time()
+        duration = end_time - start_time
+        logger.info(f"{func.__name__} took {duration:.2f} seconds to execute")
+        return result
+    return wrapper
+
+def setup_logging(log_level: str = "INFO") -> None:
+    """
+    Thiết lập logging với loguru, log ra file và console.
+    Input: log_level (str) - mức log.
+    Output: None.
+    """
+    logger.remove()  # Remove default handler
+    logger.add(
+        "logs/webot.log",
+        rotation="500 MB",
+        retention="10 days",
+        level=log_level,
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
+    )
+    logger.add(
+        lambda msg: print(msg),
+        level=log_level,
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
+    )
+
+def extract_command(text: str) -> tuple[str, str]:
+    """
+    Tách lệnh (bắt đầu bằng \) và phần còn lại từ message.
+    Input: text (str) - message từ user.
+    Output: (command, remaining_text) - tuple (str, str).
+    """
+    if not text.startswith("\\"):
+        return "", text
+    
+    parts = text.split(maxsplit=1)
+    command = parts[0][1:]  # Remove the backslash
+    remaining = parts[1] if len(parts) > 1 else ""
+    return command, remaining
+
+def extract_keywords(text: str, keywords: list[str]) -> list[str]:
+    """
+    Tìm các từ khóa xuất hiện trong message.
+    Input: text (str), keywords (list[str])
+    Output: list[str] các từ khóa tìm thấy.
+    """
+    return [keyword for keyword in keywords if keyword.lower() in text.lower()]
+
+def ensure_log_dir():
+    """
+    Đảm bảo thư mục logs tồn tại, tạo nếu chưa có.
+    Input: None
+    Output: None
+    """
+    os.makedirs("logs", exist_ok=True)
+
+def validate_config(settings) -> None:
+    """
+    Kiểm tra các biến môi trường/config bắt buộc, raise lỗi nếu thiếu.
+    Input: settings (Settings)
+    Output: None (raise RuntimeError nếu thiếu)
+    """
+    missing = []
+    for field in [
+        'facebook_verify_token', 'facebook_app_secret',
+        'google_sheets_credentials_file', 'google_sheets_token_file', 'conversation_sheet_id',
+        'supabase_url', 'supabase_key']:
+        if not getattr(settings, field, None):
+            missing.append(field)
+    if missing:
+        raise RuntimeError(f"Missing config: {', '.join(missing)}") 

config.py

@@ -1,11 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-VERIFY_TOKEN = os.getenv("VERIFY_TOKEN")
-FACEBOOK_API_VERSION = "v22.0"
-EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL")
-GOOGLE_SHEET_ID = os.getenv("GOOGLE_SHEET_ID")
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_KEY = os.getenv("SUPABASE_KEY")

main.py

@@ -1,54 +0,0 @@
-import time
-from fastapi import FastAPI, Request
-from pydantic import BaseModel
-from modules import facebook, sheets, supabase_db, embedding, vector_search, utils
-import config
-
-app = FastAPI()
-
-class FBMessagePayload(BaseModel):
-    entry: list
-
-@app.get("/facebook-webhook")
-def verify_token(mode: str, token: str, challenge: str):
-    if mode == "subscribe" and token == config.VERIFY_TOKEN:
-        return challenge
-    return {"error": "Token invalid"}
-
-@app.post("/facebook-webhook")
-async def handle_message(payload: FBMessagePayload):
-    start = time.time()
-    log = utils.create_logger("main")
-    try:
-        messaging = payload.entry[0]['messaging'][0]
-        sender_id = messaging['sender']['id']
-        page_id = messaging['recipient']['id']
-        text = messaging.get('message', {}).get('text', '')
-        attachments = messaging.get('message', {}).get('attachments', [])
-
-        log.info(f"⏱️ New message from {sender_id}: {text}")
-
-        token = supabase_db.get_page_token(page_id)
-        history = sheets.find_unfinished_conversation(page_id, sender_id)
-        parsed = utils.parse_message(text)
-        parsed.update({"recipient_id": sender_id, "page_id": page_id, "attachments": attachments})
-
-        action = utils.decide_action(parsed, history)
-
-        if action in ["insert&responsenocommand", "update&responsewithcommand"]:
-            vec = embedding.generate_embedding(text)
-            parsed["embedding"] = vec
-            columns = utils.detect_vehicle(parsed['vehicle'])
-            results = vector_search.query(vec, columns)
-            answer = utils.format_answer(results)
-            facebook.send_text(sender_id, page_id, token, answer)
-        else:
-            prompt = utils.get_instruction(action)
-            facebook.send_text(sender_id, page_id, token, prompt)
-
-        sheets.update_conversation(parsed, action, history)
-        log.info(f"✅ Handled in {time.time()-start:.2f}s")
-        return {"status": "ok"}
-    except Exception as e:
-        log.exception(f"❌ Error: {e}")
-        return {"error": str(e)}

modules/embedding.py

@@ -1,7 +0,0 @@
-from sentence_transformers import SentenceTransformer
-import config
-
-model = SentenceTransformer(config.EMBEDDING_MODEL)
-
-def generate_embedding(text):
-    return model.encode(text).tolist()

modules/facebook.py

@@ -1,13 +0,0 @@
-import httpx
-import config
-
-def send_text(recipient_id, page_id, token, message):
-    url = f"https://graph.facebook.com/{config.FACEBOOK_API_VERSION}/{page_id}/messages"
-    payload = {
-        "recipient": {"id": recipient_id},
-        "messaging_type": "RESPONSE",
-        "message": {"text": message}
-    }
-    params = {"access_token": token}
-    res = httpx.post(url, params=params, json=payload)
-    return res.json()

modules/sheets.py

@@ -1,29 +0,0 @@
-import gspread
-from oauth2client.service_account import ServiceAccountCredentials
-import config
-
-scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
-creds = ServiceAccountCredentials.from_json_keyfile_name("service_account.json", scope)
-client = gspread.authorize(creds)
-sheet = client.open_by_key(config.GOOGLE_SHEET_ID).worksheet("chat")
-
-def find_unfinished_conversation(page_id, recipient_id):
-    records = sheet.get_all_records()
-    for row in reversed(records):
-        if row['page_id'] == page_id and row['recipient_id'] == recipient_id and row['isdone'] == "FALSE":
-            return row
-    return None
-
-def update_conversation(parsed, action, history):
-    new_row = {
-        "conversation_id": parsed.get("conversation_id"),
-        "recipient_id": parsed["recipient_id"],
-        "page_id": parsed["page_id"],
-        "originaltext": parsed.get("message_text"),
-        "originalvehicle": parsed.get("vehicle"),
-        "originalcommand": parsed.get("command"),
-        "originalcontent": parsed.get("content"),
-        "originalattachments": parsed.get("attachments"),
-        "isdone": "TRUE" if "response" in action else "FALSE"
-    }
-    sheet.append_row(list(new_row.values()))

modules/supabase_db.py

@@ -1,8 +0,0 @@
-from supabase import create_client
-import config
-
-supabase = create_client(config.SUPABASE_URL, config.SUPABASE_KEY)
-
-def get_page_token(page_id: str) -> str:
-    res = supabase.table("PageToken").select("token").eq("id", page_id).execute()
-    return res.data[0]['token'] if res.data else ""

modules/utils.py

@@ -1,71 +0,0 @@
-from loguru import logger
-import uuid
-
-keywords = ["mô tô", "xe máy điện", "xe máy", "xe gắn máy", "ô tô tải", "ô tô", "xe khách", "máy kéo", "xe chuyên dùng", "xe đạp máy", "xe đạp điện", "xe thô sơ", "xích lô",  "xe bò", "súc vật kéo", "xe đạp", "đi bộ"]
-
-
-def create_logger(name: str):
-    logger.add(f"logs/{name}.log", rotation="1 day")
-    return logger
-
-def parse_message(text: str):
-    result = {"command": "", "password": "", "content": "", "vehicle": "", "message_text": text}
-    if text.startswith("\\"):
-        parts = text[1:].split("\\")
-        if len(parts) >= 2:
-            result.update({"command": parts[0], "password": parts[1], "content": "\\".join(parts[2:])})
-        else:
-            result["command"] = parts[0]
-    for kw in keywords:
-        if kw in text.lower():
-            result["vehicle"] = kw
-            break
-    return result
-
-def detect_vehicle(text):
-    return [text] if text else []
-
-def decide_action(parsed, history):
-    if not parsed['message_text'] and not parsed['attachments']:
-        return "invalidinput"
-    if not history:
-        if parsed['command']:
-            return "insert&askwithcommand"
-        elif parsed['vehicle']:
-            return "insert&responsenocommand"
-        else:
-            return "insert&asknocommand"
-    else:
-        if parsed['command'] == "xong":
-            return "update&responsewithcommand"
-        elif parsed['command']:
-            return "invalidcommand"
-        elif parsed['vehicle']:
-            return "update&asknocommand"
-        else:
-            return "update&askwithcommand"
-
-def format_answer(results):
-    if not results:
-        return "Không có kết quả phù hợp!"
-    top = max(results, key=lambda r: r.get("similarity", 0))
-    lines = [f"Thực hiện hành vi: {top.get('tieude', '').strip()} {top.get('noidung', '').strip()}"]
-    if top.get("canhantu"):
-        lines.append(f"Cá nhân bị phạt từ {top['canhantu']} đến {top.get('canhanden', '')} VNĐ")
-    if top.get("tochuctu"):
-        lines.append(f"Tổ chức bị phạt từ {top['tochuctu']} đến {top.get('tochucden', '')} VNĐ")
-    if top.get("hpbsnoidung"):
-        lines.append(f"Hình phạt bổ sung: {top['hpbsnoidung']}")
-    if top.get("bpkpnoidung"):
-        lines.append(f"Biện pháp khắc phục: {top['bpkpnoidung']}")
-    return "\n".join(lines)
-
-def get_instruction(action):
-    return {
-        "invalidinput": "Bạn chưa cung cấp nội dung hợp lệ!",
-        "insert&asknocommand": "Bạn có thể gửi thêm hình ảnh hoặc gõ '\\xong' để hoàn tất.",
-        "insert&askwithcommand": "Cảm ơn! Bạn muốn thực hiện hành động nào khác không?",
-        "update&asknocommand": "Hãy tiếp tục gửi thông tin phương tiện.",
-        "update&askwithcommand": "Vui lòng hoàn tất câu lệnh hoặc xác nhận bằng '\\xong'.",
-        "invalidcommand": "Lệnh bạn gửi chưa được hỗ trợ!"
-    }.get(action, "Tôi chưa hiểu ý bạn lắm. Bạn có thể diễn đạt lại?")

modules/vector_search.py

@@ -1,18 +0,0 @@
-import httpx
-import config
-
-def query(embedding, vehicle_columns):
-    url = f"{config.SUPABASE_URL}/rest/v1/rpc/match_documents"
-    headers = {
-        "apikey": config.SUPABASE_KEY,
-        "Authorization": f"Bearer {config.SUPABASE_KEY}",
-        "Content-Type": "application/json"
-    }
-    json_body = {
-        "query_embedding": embedding,
-        "match_threshold": 0.3,
-        "match_count": 5,
-        "vehicle_filters": vehicle_columns
-    }
-    response = httpx.post(url, headers=headers, json=json_body)
-    return response.json()

requirements.txt

@@ -1,9 +1,14 @@
-fastapi
-uvicorn
-python-dotenv
-httpx
-supabase-py
-gspread
-oauth2client
-sentence-transformers
-loguru
+fastapi==0.104.1
+uvicorn==0.24.0
+python-dotenv==1.0.0
+httpx>=0.24.0,<0.25.0
+loguru==0.7.2
+google-auth==2.23.4
+google-auth-oauthlib==1.1.0
+google-auth-httplib2==0.1.1
+google-api-python-client==2.108.0
+supabase==2.0.3
+numpy==1.26.2
+python-multipart==0.0.6
+tenacity==8.2.3 
+pydantic-settings