changes

Dockerfile

@@ -1,18 +1,36 @@
-# Use a minimal Python base image
 FROM python:3.10-slim
 
-# Set working directory
 WORKDIR /app
 
-# Install dependencies
+# Install system dependencies + filelock for TinyDB
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends g++ && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create directory structure with fail-safes
+RUN mkdir -p /.cache/huggingface/hub && \
+    mkdir -p /tmp/hf_cache && \
+    chmod -R 777 /tmp/hf_cache && \
+    chmod -R 777 /.cache  # Full permissions
+
+
+# Install Python dependencies (add filelock)
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt filelock
 
-# Copy app code
-COPY . .
+# Copy app code (ensure proper permissions)
+COPY --chmod=777 . .
 
-# Expose the port expected by Hugging Face (usually 7860)
-EXPOSE 7860
+# Environment configuration
+ENV HF_HOME=/tmp/hf_cache \
+    PYTHONUNBUFFERED=1
 
-# Run the FastAPI app using uvicorn on the exposed port
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+ENV ONNX_MODELS_DIR=/tmp
+ENV HF_HOME=/.cache/huggingface/hub  
+
+# Health check (optional but recommended)
+HEALTHCHECK --interval=30s --timeout=3s \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/app/database/base.py

@@ -1,8 +1,26 @@
 from tinydb import TinyDB
+from filelock import FileLock
 import os
+import json
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 class BaseDB:
     def __init__(self):
-        if not os.path.exists("/tmp/db"):
-            os.makedirs("/tmp/db", exist_ok=True)
-        self.db = TinyDB('/tmp/db/database.json')
+        self.db_path = "/.cache/huggingface/hub/my_app_data/db/database.json"
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        
+        try:
+            with FileLock(f"{self.db_path}.lock"):
+                # Handle corruption
+                try:
+                    self.db = TinyDB(self.db_path)
+                except json.JSONDecodeError:
+                    logger.warning("DB corrupted - resetting")
+                    os.rename(self.db_path, f"{self.db_path}.bak")
+                    self.db = TinyDB(self.db_path)
+        except Exception as e:
+            logger.error(f"DB init failed: {e}")
+            raise

backend/app/database/chatbot.py

@@ -1,9 +0,0 @@
-from pydantic import BaseModel
-from typing import List, Optional
-
-class ChatRequest(BaseModel):
-    message: str
-
-class ChatResponse(BaseModel):
-    response: str
-    recommendations: List[str]

backend/app/helper/dependencies.py

@@ -1,5 +1,5 @@
 from services.embedding_models.MiniLM_L12_v2_model import ONNXMiniLMModel
-from services.vector_db.similarity_model import VectorDB
+from services.vector_db.optimized_vector_db import VectorDB
 from backend.app.database.users import UserDB
 from backend.app.database.events import EventDB
 from backend.app.database.travels import TravelDB
@@ -12,8 +12,8 @@ import os
 embedding_lock = asyncio.Lock()
 assistant = BilingualTravelAssistant()
 embedding_model = ONNXMiniLMModel()
-events_vector_db = VectorDB(db_path="./vector_db/events")
-travels_vector_db = VectorDB(db_path="./vector_db/travels")
+events_vector_db = VectorDB()
+travels_vector_db = VectorDB()
 event_db = EventDB()
 travel_db = TravelDB()
 user_db = UserDB()

requirements.txt

@@ -18,7 +18,6 @@ Deprecated==1.2.18
 distro==1.9.0
 durationpy==0.9
 exceptiongroup==1.2.2
-faiss-cpu==1.10.0
 fastapi==0.115.9
 filelock==3.18.0
 flatbuffers==25.2.10
@@ -54,7 +53,6 @@ networkx==3.2.1
 numpy==1.26.4
 oauthlib==3.2.2
 onnx==1.16.2
-onnxruntime==1.16.3
 opentelemetry-api==1.32.1
 opentelemetry-exporter-otlp-proto-common==1.32.1
 opentelemetry-exporter-otlp-proto-grpc==1.32.1
@@ -91,7 +89,6 @@ rich==14.0.0
 rpds-py==0.24.0
 rsa==4.9.1
 safetensors==0.5.3
-sentence_transformers==4.1.0
 shellingham==1.5.4
 six==1.17.0
 sniffio==1.3.1
@@ -102,9 +99,7 @@ tenacity==9.1.2
 tinydb==4.8.2
 tokenizers==0.21.1
 tomli==2.2.1
-torch==2.6.0
 tqdm==4.67.1
-transformers==4.51.3
 typer==0.15.2
 typing-inspection==0.4.0
 typing_extensions==4.13.2
@@ -115,3 +110,9 @@ websocket-client==1.8.0
 websockets==15.0.1
 wrapt==1.17.2
 zipp==3.21.0
+sentence-transformers>=2.7.0
+transformers>=4.41.0
+onnxruntime>=1.17.0
+torch>=2.2.0
+huggingface-hub>=0.20.0
+faiss-cpu>=1.7.4

services/embedding_models/MiniLM_L12_v2_model.py

@@ -2,75 +2,148 @@ import os
 import numpy as np
 import onnxruntime as ort
 from pathlib import Path
-from transformers.onnx import export
-from transformers.onnx.features import FeaturesManager
-from transformers.utils import logging
-from transformers import AutoTokenizer, AutoModel
+import logging
+from typing import List, Union
 
-logging.set_verbosity_error()
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-class ONNXMiniLMModel: 
+class ONNXMiniLMModel:
     def __init__(self,
-                 model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
-                 onnx_path="/tmp/onnx_model/minilm.onnx"):  # Different ONNX path
-
+                 model_name="sentence-transformers/paraphrase-multilingual-minilm-l12-v2",
+                 onnx_path="/tmp/minilm.onnx",
+                 dimension=384):  # Matching VectorDB dimension
+        
         self.model_name = model_name
         self.onnx_path = onnx_path
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.dimension = dimension
         
-
-
-        if not os.path.exists(onnx_path):
-            print("[INFO] ONNX model not found. Exporting to ONNX...")
-            self.export_to_onnx()
-
-        print("[INFO] Loading ONNX model...")
-        self.session = ort.InferenceSession(onnx_path)
+        try:
+            # Configure cache and model paths
+            cache_dir = "/tmp/hf_cache"
+            os.makedirs(cache_dir, exist_ok=True)
+            os.environ["HF_HOME"] = cache_dir
+            
+            # Initialize model
+            logger.info(f"Loading model {model_name}...")
+            from sentence_transformers import SentenceTransformer
+            self.st_model = SentenceTransformer(
+                model_name,
+                cache_folder=cache_dir,
+                device="cpu"
+            )
+            self.tokenizer = self.st_model.tokenizer
+            self.model = self.st_model._first_module().auto_model
+            self.model.eval()
+            
+            # Convert to ONNX if needed
+            if not os.path.exists(onnx_path):
+                self.export_to_onnx()
+                
+            # Initialize ONNX runtime
+            logger.info("Creating ONNX inference session...")
+            self.session = ort.InferenceSession(
+                onnx_path,
+                providers=['CPUExecutionProvider']
+            )
+            
+            logger.info(f"Model initialized with dimension {dimension}")
+            
+        except Exception as e:
+            logger.error(f"Model initialization failed: {str(e)}")
+            raise
 
     def export_to_onnx(self):
-        model = AutoModel.from_pretrained(self.model_name)
-        save_dir = Path(self.onnx_path).parent
-        save_dir.mkdir(parents=True, exist_ok=True)
-
-        _, model_onnx_config = FeaturesManager.check_supported_model_or_raise(model)
-        onnx_config = model_onnx_config(model.config)
-
-        export(preprocessor=self.tokenizer,
-               model=model,
-               config=onnx_config,
-               opset=14,
-               output=Path(self.onnx_path))
+        """Export the model to ONNX format with proper configuration"""
+        import torch
+        logger.info(f"Exporting model to ONNX at {self.onnx_path}...")
+        
+        # Create dummy inputs with correct dimensions and types
+        dummy_input = (
+            torch.randint(0, 100, (1, 128), dtype=torch.long),  # input_ids
+            torch.ones((1, 128), dtype=torch.long),              # attention_mask
+            torch.zeros((1, 128), dtype=torch.long)              # token_type_ids
+        )
+        
+        # Export configuration
+        torch.onnx.export(
+            self.model,
+            dummy_input,
+            self.onnx_path,
+            opset_version=14,
+            input_names=["input_ids", "attention_mask", "token_type_ids"],
+            output_names=["output"],
+            dynamic_axes={
+                'input_ids': {0: 'batch', 1: 'sequence'},
+                'attention_mask': {0: 'batch', 1: 'sequence'},
+                'token_type_ids': {0: 'batch', 1: 'sequence'},
+                'output': {0: 'batch'}
+            },
+            do_constant_folding=True
+        )
+        logger.info("ONNX export completed successfully")
 
     def mean_pooling(self, token_embeddings, attention_mask):
+        """Apply mean pooling to get sentence embeddings"""
         input_mask_expanded = np.expand_dims(attention_mask, -1).astype(np.float32)
-        pooled = np.sum(token_embeddings * input_mask_expanded, axis=1) / np.clip(np.sum(input_mask_expanded, axis=1), 1e-9, None)
-        return pooled
-
-    def encode(self, texts, normalize=True, debug=False):
-        # Tokenize with return_token_type_ids=True
-        tokens = self.tokenizer(
-            texts, 
-            padding=True, 
-            truncation=True, 
-            return_tensors="np",
-            return_token_type_ids=True  # Critical addition
-        )
-
-        if debug:
-            print("[DEBUG] Tokens:", self.tokenizer.convert_ids_to_tokens(tokens["input_ids"][0]))
+        sum_embeddings = np.sum(token_embeddings * input_mask_expanded, axis=1)
+        sum_mask = np.clip(np.sum(input_mask_expanded, axis=1), 1e-9, None)
+        return sum_embeddings / sum_mask
 
-        # Prepare all required inputs
-        inputs = {
-            "input_ids": tokens["input_ids"].astype(np.int64),
-            "attention_mask": tokens["attention_mask"].astype(np.int64),
-            "token_type_ids": tokens["token_type_ids"].astype(np.int64)  # New required input
-        }
-
-        outputs = self.session.run(None, inputs)
-        embeddings = self.mean_pooling(outputs[0], tokens["attention_mask"])
-
-        if normalize:
-            norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
-            embeddings = embeddings / np.clip(norms, 1e-9, None)
-
-        return embeddings
+    def encode(self, texts: Union[str, List[str]], normalize: bool = True) -> np.ndarray:
+        """
+        Generate embeddings for input text(s)
+        
+        Args:
+            texts: Single text string or list of texts
+            normalize: Whether to normalize embeddings to unit length
+            
+        Returns:
+            numpy.ndarray: Embeddings array of shape (num_texts, dimension)
+        """
+        try:
+            # Ensure input is a list
+            if isinstance(texts, str):
+                texts = [texts]
+            
+            # Tokenize with proper settings for multilingual model
+            tokens = self.tokenizer(
+                texts,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors="np",
+                return_token_type_ids=True
+            )
+            
+            # Prepare ONNX inputs
+            inputs = {
+                "input_ids": tokens["input_ids"].astype(np.int64),
+                "attention_mask": tokens["attention_mask"].astype(np.int64),
+                "token_type_ids": tokens["token_type_ids"].astype(np.int64)
+            }
+            
+            # Run inference
+            outputs = self.session.run(None, inputs)
+            embeddings = self.mean_pooling(outputs[0], tokens["attention_mask"])
+            
+            # Normalize if requested
+            if normalize:
+                norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+                embeddings = embeddings / np.clip(norms, 1e-9, None)
+            
+            # Ensure correct dimensionality
+            if embeddings.shape[1] != self.dimension:
+                logger.warning(f"Embedding dimension mismatch: {embeddings.shape[1]} != {self.dimension}")
+                embeddings = embeddings[:, :self.dimension]  # Truncate if needed
+                
+            return embeddings.astype(np.float32)  # Ensure float32 for FAISS
+
+        except Exception as e:
+            logger.error(f"Embedding generation failed: {str(e)}")
+            raise
+
+    def get_dimension(self) -> int:
+        """Return the embedding dimension"""
+        return self.dimension

services/vector_db/optimized_vector_db.py

@@ -6,15 +6,13 @@ from typing import List
 
 
 class VectorDB:
-    def __init__(self, db_path="./vector_db", dimension=384):
+    def __init__(self, db_path="/.cache/huggingface/hub/my_app_data/vector_db", dimension=384):
         self.db_path = os.path.join(db_path)
         self.index_path = os.path.join(self.db_path, "faiss_index.bin")
-        self.mapping_path = os.path.join(self.db_path, "id_mapping.pkl")
+        self.metadata_path = os.path.join(self.db_path, "metadata.pkl")
         self.dimension = dimension
         self.index = None
-        self.id_to_int = {}  # {"your_str_id": faiss_int_id}
-        self.int_to_id = {}  # {faiss_int_id: "your_str_id"}
-        self.vectors = {}    # {int_id: vector} for fast access
+        self.metadata = {}
         self._initialize_storage()
 
     def _initialize_storage(self):
@@ -23,16 +21,13 @@ class VectorDB:
             if not os.path.exists(self.db_path):
                 os.makedirs(self.db_path)
 
-            if os.path.exists(self.index_path) and os.path.exists(self.mapping_path):
+            if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
                 self.index = faiss.read_index(self.index_path)
-                with open(self.mapping_path, 'rb') as f:
-                    data = pickle.load(f)
-                    self.id_to_int = data.get('id_to_int', {})
-                    self.int_to_id = data.get('int_to_id', {})
-                    self.vectors = data.get('vectors', {})
+                with open(self.metadata_path, 'rb') as f:
+                    self.metadata = pickle.load(f)
             else:
-                base_index = faiss.IndexFlatL2(self.dimension)
-                self.index = faiss.IndexIDMap(base_index)
+                self.index = faiss.IndexFlatL2(self.dimension)
+                self.metadata = {}
 
             print(f"Storage initialized. Current size: {self.index.ntotal}")
         except Exception as e:
@@ -55,61 +50,78 @@ class VectorDB:
         self.update_embeddings(data, model)
 
     def update_embeddings(self, data, model):
-        str_ids = [str(item['id']) for item in data]
-        descriptions = [self._format_description(item) for item in data]
-
-        embeddings = model.encode(descriptions).astype("float32")
-
-        existing_mask = np.array([sid in self.id_to_int for sid in str_ids])
-        existing_ids = np.array(str_ids)[existing_mask]
-        new_ids = np.array(str_ids)[~existing_mask]
-        existing_embeddings = embeddings[existing_mask]
-        new_embeddings = embeddings[~existing_mask]
-
-        # Process updates
-        if len(existing_ids) > 0:
-            int_ids = np.array([self.id_to_int[sid] for sid in existing_ids], dtype=np.int64)
-            self.index.remove_ids(int_ids)
-            self.index.add_with_ids(existing_embeddings, int_ids)
-            for iid, vec in zip(int_ids, existing_embeddings):
-                self.vectors[iid] = vec
-
-        # Process inserts
-        if len(new_ids) > 0:
-            next_int_id = len(self.id_to_int)
-            new_int_ids = np.arange(next_int_id, next_int_id + len(new_ids), dtype=np.int64)
-
-            for sid, iid in zip(new_ids, new_int_ids):
-                self.id_to_int[sid] = iid
-                self.int_to_id[iid] = sid
-                self.vectors[iid] = new_embeddings[np.where(new_ids == sid)[0][0]]
+        try:
+            input_ids = {str(item['id']) for item in data}
+            existing_ids = set(self.metadata.keys())
+
+            update_ids = input_ids & existing_ids
+            create_ids = input_ids - existing_ids
+
+            update_items = [item for item in data if str(item['id']) in update_ids]
+            create_items = [item for item in data if str(item['id']) in create_ids]
+
+            # Batch process descriptions and embeddings
+            all_items = update_items + create_items
+            descriptions = [self._format_description(item) for item in all_items]
+            embeddings = model.encode(descriptions).astype('float32')
+
+            # Split embeddings back to update/create
+            update_embeddings = embeddings[:len(update_items)]
+            create_embeddings = embeddings[len(update_items):]
+
+            # Update existing items
+            for i, item in enumerate(update_items):
+                item_id = str(item['id'])
+                self.metadata[item_id].update({
+                    'vector': update_embeddings[i]
+                })
+
+            # Add new items
+            for i, item in enumerate(create_items):
+                item_id = str(item['id'])
+                self.metadata[item_id] = {
+                    'id': item_id,
+                    'vector': create_embeddings[i]
+                }
+
+            # Rebuild index only once
+            all_vectors = [self.metadata[id]['vector'] for id in self.metadata]
+            all_vectors_np = np.array(all_vectors).astype('float32')
+            self.index = faiss.IndexFlatL2(self.dimension)
+            self.index.add(all_vectors_np)
 
-            self.index.add_with_ids(new_embeddings, new_int_ids)
+            self._save_to_disk()
+            print(f"Successfully processed {len(data)} items: "
+                  f"{len(update_items)} updated, {len(create_items)} created")
 
-        self._save_to_disk()
-        print(f"Processed {len(data)} items: {len(existing_ids)} updated, {len(new_ids)} created")
+        except Exception as e:
+            print(f"Error in update_embeddings: {e}")
+            raise
 
     def delete_items(self, item_ids):
         try:
-            str_ids = list(map(str, item_ids))
-            valid_str_ids = [sid for sid in str_ids if sid in self.id_to_int]
-            if not valid_str_ids:
-                print("No valid IDs to delete.")
+            ids_to_delete = {str(id) for id in item_ids}
+            existing_ids = set(self.metadata.keys())
+            valid_ids = ids_to_delete & existing_ids
+
+            if not valid_ids:
+                print("No valid items to delete.")
                 return
 
-            int_ids = np.array([self.id_to_int[sid] for sid in valid_str_ids], dtype=np.int64)
-            self.index.remove_ids(int_ids)
+            for item_id in valid_ids:
+                del self.metadata[item_id]
 
-            for sid in valid_str_ids:
-                del self.id_to_int[sid]
-            for iid in int_ids:
-                if iid in self.int_to_id:
-                    del self.int_to_id[iid]
-                if iid in self.vectors:
-                    del self.vectors[iid]
+            if self.metadata:
+                remaining_vectors = [self.metadata[id]['vector'] for id in self.metadata]
+                remaining_vectors_np = np.array(remaining_vectors).astype('float32')
+                self.index = faiss.IndexFlatL2(self.dimension)
+                self.index.add(remaining_vectors_np)
+            else:
+                self.index = faiss.IndexFlatL2(self.dimension)
 
             self._save_to_disk()
-            print(f"Successfully deleted {len(valid_str_ids)} items")
+            print(f"Successfully deleted {len(valid_ids)} items")
+
         except Exception as e:
             print(f"Error in delete_items: {e}")
             raise
@@ -117,12 +129,8 @@ class VectorDB:
     def _save_to_disk(self):
         try:
             faiss.write_index(self.index, self.index_path)
-            with open(self.mapping_path, 'wb') as f:
-                pickle.dump({
-                    'id_to_int': self.id_to_int,
-                    'int_to_id': self.int_to_id,
-                    'vectors': self.vectors
-                }, f, protocol=pickle.HIGHEST_PROTOCOL)
+            with open(self.metadata_path, 'wb') as f:
+                pickle.dump(self.metadata, f)
         except Exception as e:
             print(f"Error saving to disk: {e}")
             raise
@@ -130,41 +138,37 @@ class VectorDB:
     def get_similar_by_ids(self, item_ids: List[str], top_k: int = 5):
         try:
             all_recommendations = []
+            id_list = list(self.metadata.keys())
 
             for item_id in item_ids:
-                if item_id not in self.id_to_int:
-                    continue
-                int_id = self.id_to_int[item_id]
-                if int_id not in self.vectors:
-                    print(f"Warning: Vector for ID {item_id} not found in cache.")
+                if item_id not in self.metadata:
                     continue
 
-                query_vector = self.vectors[int_id].reshape(1, -1).astype("float32")
-                distances, indices = self.index.search(
-                    query_vector,
-                    top_k + len(item_ids)
-                )
+                query_vector = self.metadata[item_id]['vector'].reshape(1, -1).astype('float32')
+                distances, indices = self.index.search(query_vector, top_k + len(item_ids))
 
                 for idx, distance in zip(indices[0], distances[0]):
-                    current_id = self.int_to_id.get(idx)
-                    if current_id and current_id not in item_ids:
+                    if idx < 0 or idx >= len(id_list):
+                        continue
+                    current_id = id_list[idx]
+                    if current_id not in item_ids:
                         all_recommendations.append({
                             'id': current_id,
                             'distance': float(distance)
                         })
 
-            seen_ids = set()
-            unique_recommendations = []
+            seen = set()
+            recommendations = []
             for rec in sorted(all_recommendations, key=lambda x: x['distance']):
-                if rec['id'] not in seen_ids:
-                    seen_ids.add(rec['id'])
-                    unique_recommendations.append(rec)
-                if len(seen_ids) >= top_k:
+                if rec['id'] not in seen:
+                    seen.add(rec['id'])
+                    recommendations.append(rec)
+                if len(seen) >= top_k:
                     break
 
             return {
                 "query_ids": item_ids,
-                "recommendations": unique_recommendations[:top_k]
+                "recommendations": recommendations[:top_k]
             }
 
         except Exception as e:
@@ -173,21 +177,28 @@ class VectorDB:
 
     def search_by_query(self, query: str, model, top_k: int):
         try:
-            query_embedding = model.encode(query).astype("float32").reshape(1, -1)
+            query_embedding = model.encode(query).astype('float32').reshape(1, -1)
             actual_top_k = min(top_k, self.index.ntotal) if self.index.ntotal > 0 else 0
+
             if actual_top_k == 0:
                 return []
 
-            distances, indices = self.index.search(
-                query_embedding,
-                actual_top_k
-            )
+            distances, indices = self.index.search(query_embedding, actual_top_k)
+            id_list = list(self.metadata.keys())
+            results = []
+
+            for i in range(actual_top_k):
+                idx = indices[0][i]
+                if idx < 0 or idx >= len(id_list):
+                    continue
+                item_id = id_list[idx]
+                results.append({
+                    "id": item_id,
+                    "similarity_score": 1 - (distances[0][i] / 2)
+                })
+
+            return results
 
-            recommendations = [
-                {"id": self.int_to_id.get(idx), "similarity_score": 1 - (dist / 2)}
-                for idx, dist in zip(indices[0], distances[0]) if self.int_to_id.get(idx)
-            ]
-            return recommendations[:top_k]
         except Exception as e:
             print(f"Error in search_by_query: {e}")
             raise

services/vector_db/similarity_model.py

@@ -5,7 +5,7 @@ import pickle
 from typing import List
 
 class VectorDB:
-    def __init__(self, db_path="./vector_db", dimension=384):
+    def __init__(self, db_path="/.cache/huggingface/hub/my_app_data/vector_db", dimension=384):
         self.db_path = db_path
         self.index_path = os.path.join(db_path, "faiss_index.bin")
         self.metadata_path = os.path.join(db_path, "metadata.pkl")