Fix model artifacts copying in Dockerfile and add fallback functionality for missing models

Dockerfile

@@ -31,6 +31,9 @@ COPY .env.example .env
 COPY api_mental_health.py .
 COPY run_api.sh .
 
+# Copy model artifacts directory
+COPY mental_health_model_artifacts/ mental_health_model_artifacts/
+
 # Make the script executable
 RUN chmod +x run_api.sh
 

api_mental_health.py

@@ -81,20 +81,23 @@ async def startup_event():
     
     # Check environment variables
     if not os.environ.get("OPENAI_API_KEY"):
-        logger.error("OPENAI_API_KEY not set in .env file")
-        raise HTTPException(status_code=500, detail="OPENAI_API_KEY not set in .env file")
+        logger.warning("OPENAI_API_KEY not set in .env file. Some functionality will be limited.")
     if not os.environ.get("LANGCHAIN_API_KEY"):
-        logger.error("LANGCHAIN_API_KEY not set in .env file")
-        raise HTTPException(status_code=500, detail="LANGCHAIN_API_KEY not set in .env file")
+        logger.warning("LANGCHAIN_API_KEY not set in .env file. Some functionality will be limited.")
     os.environ["LANGCHAIN_TRACING_V2"] = "true"
     os.environ["LANGCHAIN_PROJECT"] = "MentalHealthCounselorPOC"
 
-    # Initialize LangSmith client
-    logger.info("Initializing LangSmith client")
-    langsmith_client = Client()
+    # Initialize LangSmith client if API key is available
+    try:
+        logger.info("Initializing LangSmith client")
+        langsmith_client = Client()
+    except Exception as e:
+        logger.warning(f"Failed to initialize LangSmith client: {e}")
+        langsmith_client = None
 
-    # Load saved components
+    # Try to load saved components, continue with limited functionality if not available
     logger.info("Loading model artifacts")
+    models_available = True
     try:
         response_clf = joblib.load(f"{output_dir}/response_type_classifier.pkl")
         crisis_clf = joblib.load(f"{output_dir}/crisis_classifier.pkl")
@@ -111,47 +114,89 @@ async def startup_event():
             # Note: Placeholder is untrained; retrain for accurate results
             
     except FileNotFoundError as e:
-        logger.error(f"Missing model artifact: {e}")
-        raise HTTPException(status_code=500, detail=f"Missing model artifact: {e}")
+        logger.warning(f"Missing model artifact: {e}. Running with limited functionality.")
+        models_available = False
+        # Set placeholder values for models to avoid errors
+        from sklearn.ensemble import RandomForestClassifier
+        from sklearn.feature_extraction.text import TfidfVectorizer
+        from sklearn.feature_selection import SelectKBest
+        from sklearn.preprocessing import LabelEncoder
+        from sklearn.decomposition import LatentDirichletAllocation
+        
+        response_clf = RandomForestClassifier()
+        crisis_clf = RandomForestClassifier()
+        vectorizer = TfidfVectorizer()
+        le = LabelEncoder()
+        selector = SelectKBest()
+        lda = LatentDirichletAllocation(n_components=10)
 
-    # Initialize ChromaDB
+    # Initialize ChromaDB if possible
     chroma_db_path = f"{output_dir}/chroma_db"
     if not os.path.exists(chroma_db_path):
-        logger.error(f"ChromaDB not found at {chroma_db_path}. Run create_vector_db.py first.")
-        raise HTTPException(status_code=500, detail=f"ChromaDB not found at {chroma_db_path}. Run create_vector_db.py first.")
-    
-    try:
-        logger.info("Initializing ChromaDB")
-        chroma_client = chromadb.PersistentClient(
-            path=chroma_db_path,
-            settings=Settings(anonymized_telemetry=False)
-        )
+        logger.warning(f"ChromaDB not found at {chroma_db_path}. Vector search will be unavailable.")
+        vector_store = None
+    else:
+        try:
+            logger.info("Initializing ChromaDB")
+            if os.environ.get("OPENAI_API_KEY"):
+                chroma_client = chromadb.PersistentClient(
+                    path=chroma_db_path,
+                    settings=Settings(anonymized_telemetry=False)
+                )
 
-        embeddings = OpenAIEmbeddings(
-            model="text-embedding-ada-002",
-            api_key=os.environ["OPENAI_API_KEY"],
-            disallowed_special=(), 
-            chunk_size=1000  
-        )
-        global vector_store
-        vector_store = Chroma(
-            client=chroma_client,
-            collection_name="mental_health_conversations",
-            embedding_function=embeddings
-        )
-    except Exception as e:
-        logger.error(f"Error initializing ChromaDB: {e}")
-        raise HTTPException(status_code=500, detail=f"Error initializing ChromaDB: {e}")
+                embeddings = OpenAIEmbeddings(
+                    model="text-embedding-ada-002",
+                    api_key=os.environ["OPENAI_API_KEY"],
+                    disallowed_special=(), 
+                    chunk_size=1000  
+                )
+                global vector_store
+                try:
+                    vector_store = Chroma(
+                        client=chroma_client,
+                        collection_name="mental_health_conversations",
+                        embedding_function=embeddings
+                    )
+                except Exception as chroma_error:
+                    logger.warning(f"Error initializing Chroma collection: {chroma_error}")
+                    vector_store = None
+            else:
+                logger.warning("Skipping ChromaDB initialization as OPENAI_API_KEY is not set")
+                vector_store = None
+        except Exception as e:
+            logger.warning(f"Error initializing ChromaDB: {e}")
+            vector_store = None
 
-    # Initialize OpenAI client and LLM
+    # Initialize OpenAI client and LLM if API key is available
     logger.info("Initializing OpenAI client and LLM")
     global openai_client, llm
-    openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-    llm = ChatOpenAI(
-        model="gpt-4o-mini",
-        temperature=0.7,
-        api_key=os.environ["OPENAI_API_KEY"]
-    )
+    if os.environ.get("OPENAI_API_KEY"):
+        try:
+            openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+            llm = ChatOpenAI(
+                model="gpt-4o-mini",
+                temperature=0.7,
+                api_key=os.environ["OPENAI_API_KEY"]
+            )
+        except Exception as e:
+            logger.warning(f"Error initializing OpenAI client: {e}")
+            openai_client = None
+            llm = None
+    else:
+        logger.warning("OpenAI client not initialized as OPENAI_API_KEY is not set")
+        openai_client = None
+        llm = None
+        
+    # Add route to check model availability
+    @app.get("/model-status")
+    async def model_status():
+        return {
+            "models_available": models_available,
+            "vector_store_available": vector_store is not None,
+            "llm_available": llm is not None,
+            "openai_api_key_set": os.environ.get("OPENAI_API_KEY") is not None,
+            "langchain_api_key_set": os.environ.get("LANGCHAIN_API_KEY") is not None
+        }
 
 # Pydantic model for request
 class PatientContext(BaseModel):
@@ -266,6 +311,16 @@ def engineer_features(context, response=""):
 # Prediction function
 @traceable(run_type="chain", name="Predict Response Type")
 def predict_response_type(context):
+    if response_clf is None or vectorizer is None or le is None or selector is None or lda is None:
+        logger.warning("Models not available, returning dummy prediction")
+        return {
+            "response_type": "Empathetic Listening",
+            "crisis_flag": False,
+            "confidence": 0.5,
+            "features": {},
+            "models_available": False
+        }
+        
     features, feature_cols = engineer_features(context)
     selected_features = selector.transform(features[feature_cols])
     pred_encoded = response_clf.predict(selected_features)[0]
@@ -285,7 +340,8 @@ def predict_response_type(context):
         "response_type": pred_label,
         "crisis_flag": crisis_flag,
         "confidence": confidence,
-        "features": features.to_dict()
+        "features": features.to_dict(),
+        "models_available": True
     }
 
 # RAG suggestion function