Update rag_api.py

rag_api.py

@@ -3,15 +3,23 @@ import requests
 import shutil 
 from fastapi import FastAPI
 from pydantic import BaseModel
+# Nota: La importación de LangChain ha sido actualizada para usar los paquetes comunitarios
+# y el nuevo paquete langchain_huggingface para evitar la advertencia de deprecación.
 from langchain_community.vectorstores import FAISS
-from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_huggingface import HuggingFaceEmbeddings # Importación recomendada
 from langchain.chains import RetrievalQA
 from langchain.prompts import PromptTemplate
 from langchain_groq import ChatGroq
 
+# --------------------------------------------------------
 # ESTABLECER LA RUTA DEL CACHÉ A /tmp, donde sí hay permisos
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/huggingface_cache' 
-os.environ['HF_HOME'] = '/tmp/huggingface_cache' 
+# Esto resuelve el PermissionError: [Errno 13] Permission denied: '/.cache'
+# --------------------------------------------------------
+TEMP_CACHE_DIR = '/tmp/huggingface_cache'
+os.environ['TRANSFORMERS_CACHE'] = TEMP_CACHE_DIR 
+os.environ['HF_HOME'] = TEMP_CACHE_DIR
+os.environ['SENTENCE_TRANSFORMERS_HOME'] = TEMP_CACHE_DIR
+os.makedirs(TEMP_CACHE_DIR, exist_ok=True) # Aseguramos que el directorio exista
 
 # --------------------------------------------------------
 # 1. CONFIGURACIÓN
@@ -20,7 +28,7 @@ os.environ['HF_HOME'] = '/tmp/huggingface_cache'
 URL_FAISS = "https://drive.google.com/uc?export=download&id=1bFLDqk0fEsdJlxjYPnxIqOUxagO7qcy3" 
 URL_PKL = "https://drive.google.com/uc?export=download&id=1D0JGeRft3798x-rsTam1s_2lVhjC9yTR"
 
-# Directorio donde guardaremos los archivos dentro del contenedor Docker
+# Directorio donde guardaremos los archivos de la BD FAISS dentro del contenedor Docker
 DOWNLOAD_DIR = "/tmp/db_faiss" 
 DB_FAISS_PATH = DOWNLOAD_DIR 
 
@@ -34,26 +42,36 @@ class QueryRequest(BaseModel):
 
 def download_file(url, local_path):
     """Descarga un archivo desde una URL y lo guarda localmente en /tmp."""
-    print(f"Descargando: {os.path.basename(local_path)} desde la nube...")
-    # Usar headers de agente de usuario para evitar bloqueos 403 de Google Drive
-    headers = {'User-Agent': 'Mozilla/5.0'} 
-    response = requests.get(url, stream=True, headers=headers)
+    file_name = os.path.basename(local_path)
+    print(f"Descargando: {file_name} desde la nube...")
     
-    # Manejar errores de descarga (ej. si el archivo no es público)
-    if response.status_code == 403:
-        raise PermissionError(f"Error 403: El archivo {os.path.basename(local_path)} no es público en Google Drive.")
-    response.raise_for_status() 
-    
-    # Asegurar que el directorio de destino exista
-    os.makedirs(os.path.dirname(local_path), exist_ok=True)
+    # Usar headers de agente de usuario para evitar bloqueos 403 de Google Drive
+    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'} 
     
-    with open(local_path, 'wb') as f:
-        shutil.copyfileobj(response.raw, f)
-    print("Descarga completada.")
+    try:
+        response = requests.get(url, stream=True, headers=headers, timeout=30)
+        
+        # Manejar errores de descarga (ej. si el archivo no es público)
+        if response.status_code == 403:
+            raise PermissionError(f"Error 403: El archivo {file_name} no es público en Google Drive.")
+        response.raise_for_status() 
+        
+        # Asegurar que el directorio de destino exista
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        
+        with open(local_path, 'wb') as f:
+            shutil.copyfileobj(response.raw, f)
+        print(f"Descarga de {file_name} completada.")
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Error en la descarga de {file_name}: {e}")
+        # Si la descarga falla, volvemos a lanzar un error para detener la inicialización.
+        raise RuntimeError(f"Fallo de conexión o timeout al descargar {file_name}: {e}")
 
 def load_and_configure_rag():
     """
-    Descarga la base de datos FAISS de la nube y la configura.
+    Descarga la base de datos FAISS de la nube, carga el modelo de embeddings 
+    y configura la cadena de RAG.
     """
     try:
         # 1. Descargar los archivos y guardarlos en /tmp/db_faiss
@@ -61,16 +79,26 @@ def load_and_configure_rag():
         download_file(URL_PKL, os.path.join(DOWNLOAD_DIR, 'index.pkl'))
         
         # 2. Cargar Embeddings (el mismo modelo que usaste)
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+        # Se pasa 'cache_folder' para asegurar que el modelo se guarde en /tmp si se descarga
+        print("Cargando modelo de embeddings (all-MiniLM-L6-v2)...")
+        embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2",
+            model_kwargs={'device': 'cpu'}, # Forzar a usar CPU si no hay GPU, estándar en Spaces
+            cache_folder=TEMP_CACHE_DIR # Se pasa la ruta de caché directamente
+        )
+        print("Modelo de embeddings cargado con éxito.")
         
         # 3. Cargar Vector Store (desde la ruta temporal /tmp/db_faiss)
+        print(f"Cargando FAISS desde: {DB_FAISS_PATH}...")
         vectorstore = FAISS.load_local(
             DB_FAISS_PATH, 
             embeddings, 
             allow_dangerous_deserialization=True
         )
+        print("Vector Store FAISS cargada con éxito.")
         
         # 4. Configurar LLM y Prompt
+        # Nota: Asegúrate de tener la variable de entorno GROQ_API_KEY configurada en tu Space.
         llm_groq = ChatGroq(temperature=0.0, model_name="llama-3.1-8b-instant")
         
         custom_prompt = """
@@ -96,9 +124,13 @@ def load_and_configure_rag():
         return qa_chain
         
     except Exception as e:
-        print(f"Error CRÍTICO al descargar/cargar FAISS desde la nube: {e}") 
-        # Esta es la excepción que verás en los logs si falla la descarga
-        raise RuntimeError(f"Falla al cargar FAISS: {e}") 
+        # Imprime un mensaje de error claro en los logs
+        print("-------------------------------------------------------------------------")
+        print(f"Error CRÍTICO al inicializar el RAG: {type(e).__name__}: {e}") 
+        print("Asegúrate de que los archivos de Google Drive sean públicos y que tengas 'langchain-huggingface' en requirements.txt.")
+        print("-------------------------------------------------------------------------")
+        # Esta excepción detendrá la carga de FastAPI
+        raise RuntimeError(f"Falla al cargar FAISS o Embeddings: {e}") 
 
 # --------------------------------------------------------
 # 3. CONFIGURACIÓN DE FASTAPI Y ENDPOINTS
@@ -106,16 +138,20 @@ def load_and_configure_rag():
 
 # Iniciar servidor y RAG (manejo de errores de carga)
 app = FastAPI(title="NutriActive RAG API")
+qa_chain = None # Inicializamos a None
+
 try:
     qa_chain = load_and_configure_rag() 
 except RuntimeError:
-    qa_chain = None 
+    # Si load_and_configure_rag falla con RuntimeError, qa_chain se queda en None, 
+    # y el endpoint / lo reportará. No es necesario hacer nada más aquí.
+    pass
 
 @app.get("/")
 def home():
     """Verifica que el servidor está corriendo."""
     if qa_chain is None:
-        return {"error": "El servidor está activo, pero el RAG no se pudo inicializar. Revisa los logs de inicio para ver el error de descarga."}
+        return {"error": "El servidor está activo, pero el RAG no se pudo inicializar. Revisa los logs de inicio para ver el error de descarga o carga de embeddings."}
     return {"message": "API de NutriActive RAG operativa. Usa el endpoint /query."}
 
 @app.post("/query")
@@ -125,6 +161,7 @@ async def process_query(request: QueryRequest):
         return {"error": "El sistema RAG no se pudo cargar. Revisa los logs de inicio para ver el error específico."}
     
     try:
+        # Aquí usamos .invoke() para LangChain Expression Language (LCEL)
         result = qa_chain.invoke({"query": request.query})
         sources = [doc.metadata.get('source', 'N/A') for doc in result['source_documents']]
         
@@ -134,4 +171,5 @@ async def process_query(request: QueryRequest):
             "sources": sources
         }
     except Exception as e:
-        return {"error": f"Error al procesar la consulta: {e}"}
+        # En caso de error durante la ejecución (no durante el setup)
+        return {"error": f"Error al procesar la consulta: {e}"}