push updated backend changes and auto start buiding

Dockerfile

@@ -3,23 +3,30 @@ FROM python:3.10-slim
 # Install system dependencies
 RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
 
-# Set Hugging Face cache to a writable directory
-ENV HF_HOME=/app/.cache/huggingface
-ENV TRANSFORMERS_CACHE=/app/.cache/huggingface/transformers
-ENV HF_HUB_CACHE=/app/.cache/huggingface/hub
+# Set Hugging Face cache to a writable directory in /tmp
+ENV HF_HOME=/tmp/huggingface
+ENV TRANSFORMERS_CACHE=/tmp/huggingface
+ENV HUGGINGFACE_HUB_CACHE=/tmp/huggingface
+ENV HF_HUB_CACHE=/tmp/huggingface
+
+# Create cache directory with proper permissions
+RUN mkdir -p /tmp/huggingface && chmod 777 /tmp/huggingface
 
 # Set working directory
 WORKDIR /app
 
-# Copy project files
-COPY . /app
+# Copy requirements first for better caching
+COPY requirements.txt .
 
 # Install Python dependencies
 RUN pip install --no-cache-dir --upgrade pip \
     && pip install --no-cache-dir -r requirements.txt
 
+# Copy project files
+COPY . /app
+
 # Expose the port Hugging Face Spaces expects
 EXPOSE 7860
 
-# Run FastAPI with Uvicorn
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Run FastAPI with Uvicorn (with reload disabled for production)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

agents.py

@@ -1,99 +1,195 @@
-# bioinformatics_ai/agents.py
+
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from autogen import AssistantAgent, UserProxyAgent
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
 from config import LLM_MODEL, CONFIDENCE_THRESHOLD, VECTORSTORE_DIR
-from rag import RAGAgent
 import os
 import sys
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-#  Ensure Hugging Face cache is in a writable directory (important on HF Spaces)
-if "HF_HOME" not in os.environ:
-    hf_cache = "/home/user/.cache/huggingface"
-    os.environ["HF_HOME"] = hf_cache
-    os.environ["TRANSFORMERS_CACHE"] = os.path.join(hf_cache, "transformers")
-    os.environ["HF_HUB_CACHE"] = os.path.join(hf_cache, "hub")
+hf_cache = "/tmp/huggingface"
+os.environ["HF_HOME"] = hf_cache
+os.environ["TRANSFORMERS_CACHE"] = hf_cache
+os.environ["HUGGINGFACE_HUB_CACHE"] = hf_cache
+os.makedirs(hf_cache, exist_ok=True)
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 if BASE_DIR not in sys.path:
     sys.path.insert(0, BASE_DIR)
 
-
 # Load BioMistral once
 class BioMistralModel:
     def __init__(self, model_name=LLM_MODEL, device=None):
-        print(f"[BioMistralModel] Loading model: {model_name}")
+        logger.info(f"Loading model: {model_name}")
         self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.model = AutoModelForCausalLM.from_pretrained(
-            model_name,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto"
-        )
-
-    def generate_answer(self, query: str) -> str:
-        prompt = f"You are a helpful bioinformatics tutor. Answer clearly:\n\nQuestion: {query}\nAnswer:"
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
-
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_new_tokens=512,
-                do_sample=True,
-                top_p=0.95,
-                temperature=0.7,
-                pad_token_id=self.tokenizer.eos_token_id
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_name,
+                cache_dir=hf_cache
             )
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                cache_dir=hf_cache
+            )
+            logger.info("Model loaded successfully")
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            # Fallback to pipeline
+            self.pipeline = pipeline(
+                "text-generation",
+                model=model_name,
+                device=0 if self.device == "cuda" else -1,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            )
+            self.use_pipeline = True
+        else:
+            self.use_pipeline = False
 
-        text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return text.split("Answer:", 1)[-1].strip()
-
-
-# Formatting Agent
-class FormattingAgent(AssistantAgent):
-    def __init__(self, name="FormattingAgent", **kwargs):
-        super().__init__(name=name, **kwargs)
+    def generate_answer(self, query: str) -> str:
+        prompt = f"""You are a helpful bioinformatics tutor. Answer clearly and concisely.
 
-    def format_text(self, text: str) -> str:
+Question: {query}
+Answer:"""
+        
+        try:
+            if hasattr(self, 'use_pipeline') and self.use_pipeline:
+                # Use pipeline fallback
+                result = self.pipeline(
+                    prompt,
+                    max_new_tokens=256,
+                    do_sample=True,
+                    top_p=0.9,
+                    temperature=0.7,
+                    pad_token_id=self.pipeline.tokenizer.eos_token_id
+                )
+                full_text = result[0]['generated_text']
+            else:
+                # Use model directly
+                inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+                
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_new_tokens=256,
+                        do_sample=True,
+                        top_p=0.9,
+                        temperature=0.7,
+                        pad_token_id=self.tokenizer.eos_token_id
+                    )
+                
+                full_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract only the answer part
+            if "Answer:" in full_text:
+                return full_text.split("Answer:", 1)[-1].strip()
+            else:
+                return full_text.replace(prompt, "").strip()
+                
+        except Exception as e:
+            logger.error(f"Error generating answer: {e}")
+            return f"I apologize, but I encountered an error while processing your question: {str(e)}"
+
+# Formatting utility
+class TextFormatter:
+    @staticmethod
+    def format_text(text: str) -> str:
+        """Clean and format text output"""
+        if not text:
+            return "I don't have an answer for that question. Could you please rephrase or ask something else?"
+        
+        # Basic cleaning
         cleaned = " ".join(text.split())
         if cleaned:
             cleaned = cleaned[0].upper() + cleaned[1:]
+            # Ensure it ends with punctuation
+            if not cleaned[-1] in {'.', '!', '?'}:
+                cleaned += '.'
         return cleaned
 
-
-# Tutor Agent
-class TutorAgent(AssistantAgent):
-    def __init__(self, name="TutorAgent", **kwargs):
-        super().__init__(name=name, **kwargs)
+# Tutor Agent 
+class TutorAgent:
+    def __init__(self):
+        logger.info("Initializing TutorAgent")
         self.model = BioMistralModel()
-        self.format_agent = FormattingAgent()
-        self.rag_agent = RAGAgent(vectorstore_dir=str(VECTORSTORE_DIR))  # safe conversion
+        self.formatter = TextFormatter()
+        
+        # Initialize RAG 
+        self.rag_agent = None
+        try:
+            from rag import RAGAgent
+            self.rag_agent = RAGAgent(vectorstore_dir=str(VECTORSTORE_DIR))
+            logger.info("RAG agent initialized")
+        except ImportError as e:
+            logger.warning(f"RAG not available: {e}")
+        except Exception as e:
+            logger.warning(f"Failed to initialize RAG: {e}")
 
     def process_query(self, query: str) -> str:
-        print(f"[TutorAgent] Received query: {query}")
+        logger.info(f"Processing query: {query}")
+        
+        if not query or len(query.strip()) < 2:
+            return "Please ask a meaningful question about bioinformatics."
         
+        # Generate answer
         answer = self.model.generate_answer(query)
         confidence = self.estimate_confidence(answer)
+        
+        logger.info(f"Confidence: {confidence:.2f}")
+        
+        # If confidence is low and RAG is available, try to enhance
+        if confidence < CONFIDENCE_THRESHOLD and self.rag_agent:
+            logger.info("Low confidence, attempting RAG enhancement")
+            try:
+                rag_answer = self._enhance_with_rag(query)
+                if rag_answer and len(rag_answer) > len(answer):
+                    answer = rag_answer
+            except Exception as e:
+                logger.warning(f"RAG enhancement failed: {e}")
+        
+        return self.formatter.format_text(answer)
 
-        print(f"[TutorAgent] Confidence: {confidence:.2f}")
-        if confidence < CONFIDENCE_THRESHOLD:
-            print("[TutorAgent] Confidence low, but still using BioMistral (RAG unused).")
-
-        return self.format_agent.format_text(answer)
+    def _enhance_with_rag(self, query: str) -> str:
+        """Enhance answer using RAG if available"""
+        if not self.rag_agent:
+            return ""
+        
+        try:
+            # Assuming RAGAgent has an answer method
+            if hasattr(self.rag_agent, 'answer'):
+                result = self.rag_agent.answer(query)
+                return result.get('answer', '') if isinstance(result, dict) else str(result)
+            else:
+                return ""
+        except Exception as e:
+            logger.error(f"RAG error: {e}")
+            return ""
 
     def estimate_confidence(self, answer: str) -> float:
-        length = len(answer.strip())
-        if length > 100:
-            return 0.9
-        elif length > 50:
-            return 0.75
-        else:
+        """Simple confidence estimation"""
+        answer = answer.strip()
+        if not answer:
+            return 0.0
+        
+        length = len(answer)
+        if length > 150:
+            return 0.85
+        elif length > 80:
+            return 0.7
+        elif length > 30:
             return 0.5
-
-
-# User Agent
-class BioUser(UserProxyAgent):
-    def __init__(self, name="BioUser", **kwargs):
-        #  disable docker-based execution (not available in HF Spaces)
-        kwargs.setdefault("code_execution_config", {"use_docker": False})
-        super().__init__(name=name, **kwargs)
+        else:
+            return 0.3
+
+# User class (
+class BioUser:
+    def __init__(self, name="BioUser"):
+        self.name = name
+    
+    def ask_question(self, question: str, tutor: TutorAgent) -> str:
+        return tutor.process_query(question)

app.py

@@ -1,15 +1,31 @@
-# main.py
+# app.py 
+import os
 import uvicorn
 from fastapi import FastAPI
 from pydantic import BaseModel
+
+
+os.environ['HF_HOME'] = '/tmp/huggingface'
+os.environ['TRANSFORMERS_CACHE'] = '/tmp/huggingface'
+os.environ['HUGGINGFACE_HUB_CACHE'] = '/tmp/huggingface'
+
+# Create cache directory
+os.makedirs('/tmp/huggingface', exist_ok=True)
+
+
 from agents import TutorAgent, BioUser
 
 # Initialize FastAPI
 app = FastAPI(title="Bioinformatics Tutor API")
 
-# Initialize agents
-user_agent = BioUser()
-tutor_agent = TutorAgent()
+# Initialize agents 
+try:
+    user_agent = BioUser()
+    tutor_agent = TutorAgent()
+    agents_loaded = True
+except Exception as e:
+    print(f"Error loading agents: {e}")
+    agents_loaded = False
 
 # Request model
 class QueryRequest(BaseModel):
@@ -24,10 +40,19 @@ def ask_tutor(request: QueryRequest):
     """
     Ask the Bioinformatics Tutor a question.
     """
-    answer = tutor_agent.process_query(request.question)
-    return QueryResponse(answer=answer)
+    if not agents_loaded:
+        return QueryResponse(answer="Error: Agents not loaded. Please check the server logs.")
+    
+    try:
+        answer = tutor_agent.process_query(request.question)
+        return QueryResponse(answer=answer)
+    except Exception as e:
+        return QueryResponse(answer=f"Error processing query: {str(e)}")
 
 @app.get("/")
 def root():
-    return {"message": "Bioinformatics Tutor API is running."}
+    return {"message": "Bioinformatics Tutor API is running.", "agents_loaded": agents_loaded}
 
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "agents_loaded": agents_loaded}