fix model loader error

Dockerfile

@@ -13,8 +13,9 @@ RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 # Copy the rest of the application code
 COPY . /code/app
 
-# Make port 8000 available to the world outside this container
-EXPOSE 8000
+# Set the working directory to where your app is
+WORKDIR /code/app
 
 # Run uvicorn when the container launches
-CMD ["uvicorn", "app.main.api:app", "--host", "0.0.0.0", "--port", "8000"]
+# This now correctly points to the 'app' instance in your 'main.py' file
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

main.py

@@ -1,49 +1,94 @@
+# main.py
+
+import os
 from fastapi import FastAPI
 from pydantic import BaseModel
 from pymongo import MongoClient
-from model_loader import ModelLoader
 import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from sentence_transformers import SentenceTransformer
+
+# --- 1. Configuration and Initialization ---
 
 # Initialize FastAPI app
 app = FastAPI(title="AI Legal Aid Chatbot")
 
-# Load model once at startup
-loader = ModelLoader()
-tokenizer = loader.tokenizer
-model = loader.model
+# It's good practice to load environment variables for sensitive data
+# For this example, we'll use the hardcoded connection string from your original file.
+MONGO_URI = "mongodb+srv://saisunil22ecs:9m2ajd0GxVn43Fbu@majorproject.g0g1as0.mongodb.net/?retryWrites=true&w=majority&appName=MajorProject"
+DB_NAME = "legal_chatbot_db"
+COLLECTION_NAME = "datasets"
+MODEL_PATH = "./final_bert_model_pdf" # Make sure this folder is uploaded
+
+# --- 2. Load Models and Database Connection (Consolidated from model_loader.py) ---
+
+def load_all_resources():
+    """
+    A single function to load all necessary models and connect to the database.
+    This runs once when the API starts up.
+    """
+    try:
+        print("🔄 Loading classifier model and tokenizer...")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+        model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
+        print("✅ Classifier loaded successfully!")
+
+        print("🔄 Connecting to MongoDB Atlas...")
+        client = MongoClient(MONGO_URI)
+        db = client[DB_NAME]
+        collection = db[COLLECTION_NAME]
+        # Test connection
+        db.command('ping')
+        print("✅ MongoDB connection successful!")
+
+        return tokenizer, model, collection
+    except Exception as e:
+        print(f"❌ Critical Error during startup: {e}")
+        return None, None, None
+
+# Load everything into global variables
+tokenizer, model, collection = load_all_resources()
+
+# --- 3. Define API Request and Response Schemas ---
 
-# MongoDB Atlas connection
-client = MongoClient("mongodb+srv://saisunil22ecs:9m2ajd0GxVn43Fbu@majorproject.g0g1as0.mongodb.net/?retryWrites=true&w=majority&appName=MajorProject")
-db = client["legal_chatbot_db"]
-collection = db["datasets"]
-# Request schema
 class QueryRequest(BaseModel):
     question: str
 
+# You can add a response model for better documentation and validation
+class ChatResponse(BaseModel):
+    predicted_intent: str
+    answer: str
+
+# --- 4. Create API Endpoints ---
+
 @app.get("/")
 async def root():
+    """A simple endpoint to check if the API is running."""
     return {"message": "AI Legal Aid Chatbot is running ✅"}
 
-@app.post("/chat")
+@app.post("/chat", response_model=ChatResponse)
 async def chat(req: QueryRequest):
-    # Step 1: Predict intent
+    """
+    Main chat endpoint to get a legal answer for a given question.
+    """
+    if not model or not tokenizer or not collection:
+        return {"predicted_intent": "Error", "answer": "Server is not ready. Resources could not be loaded."}
+
+    # Step 1: Predict the intent using the fine-tuned model
     inputs = tokenizer(req.question, return_tensors="pt", truncation=True, padding=True)
     with torch.no_grad():
         outputs = model(**inputs)
         predicted_label_id = torch.argmax(outputs.logits, dim=1).item()
 
-    label = model.config.id2label[predicted_label_id]
+    predicted_intent = model.config.id2label[predicted_label_id]
 
-    # Step 2: Try to fetch an answer from MongoDB (vector search / fallback query)
-    doc = collection.find_one({"Intent": label})
+    # Step 2: Retrieve the answer from your MongoDB knowledge base
+    # This uses a simple find_one, but can be replaced with your vector search logic
+    doc = collection.find_one({"Intent": predicted_intent})
+    
     if doc and "Answer" in doc:
         answer = doc["Answer"]
     else:
-        answer = "Sorry, I couldn't find an answer for that. Please try rephrasing your question."
-
-    # Step 3: Always return with "answer"
-    return {
-        "question": req.question,
-        "predicted_intent": label,
-        "answer": answer
-    }
+        answer = "I have identified the intent, but could not find a specific answer in the knowledge base."
+
+    return {"predicted_intent": predicted_intent, "answer": answer}

model_loader.py

@@ -1,19 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-from sentence_transformers import SentenceTransformer
-import numpy as np
-
-class ModelLoader:
-    def __init__(self, model_path="./final_bert_model_pdf"):
-        print(f"🔄 Loading classifier from {model_path} ...")
-        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
-        self.model = AutoModelForSequenceClassification.from_pretrained(model_path)
-        print("✅ Classifier model & tokenizer loaded successfully!")
-
-        print("🔄 Loading embedding model (all-MiniLM-L6-v2) ...")
-        self.embedding_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
-        print("✅ Embedding model loaded successfully!")
-
-    def embed(self, text: str) -> list:
-        """Convert text into a vector embedding (list of floats)."""
-        embedding = self.embedding_model.encode(text)
-        return embedding.tolist()  # MongoDB needs list, not numpy array