Update rag_api.py

rag_api.py

@@ -1,7 +1,7 @@
 import os
 import requests
-import shutil 
-from langchain_community.vectorstores import FAISS 
+import shutil
+from langchain_community.vectorstores import FAISS
 from fastapi import FastAPI
 from pydantic import BaseModel
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -9,183 +9,183 @@ from langchain_core.runnables import RunnablePassthrough
 from langchain_core.prompts import PromptTemplate
 from langchain_groq import ChatGroq
 
-
 # --------------------------------------------------------
-# ESTABLECER LA RUTA DEL CACHÉ A /tmp, donde sí hay permisos
-# Esto resuelve el PermissionError: [Errno 13] Permission denied: '/.cache'
+# CACHÉ EN /tmp
 # --------------------------------------------------------
 TEMP_CACHE_DIR = '/tmp/huggingface_cache'
-os.environ['TRANSFORMERS_CACHE'] = TEMP_CACHE_DIR 
+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
+os.makedirs(TEMP_CACHE_DIR, exist_ok=True)
 
 # --------------------------------------------------------
 # 1. CONFIGURACIÓN
 # --------------------------------------------------------
-# URLs DE DESCARGA DIRECTA DE GOOGLE DRIVE (construidas con las IDs)
 URL_FAISS = "https://drive.google.com/uc?export=download&id=1XqImFIKiuRDhSDK6Rm6dAZbHm03NdzQa"
-URL_PKL = "https://drive.google.com/uc?export=download&id=156BWHHGi-JuD9EM2Nek1mNcyitivQWAH"
-
-# Directorio donde guardaremos los archivos de la BD FAISS dentro del contenedor Docker
-DOWNLOAD_DIR = "/tmp/db_faiss" 
-DB_FAISS_PATH = DOWNLOAD_DIR 
+URL_PKL   = "https://drive.google.com/uc?export=download&id=156BWHHGi-JuD9EM2Nek1mNcyitivQWAH"
+DOWNLOAD_DIR  = "/tmp/db_faiss"
+DB_FAISS_PATH = DOWNLOAD_DIR
 
 # --------------------------------------------------------
-# 2. FUNCIONES DE DESCARGA Y CARGA DEL RAG CORE
+# 2. CLASIFICADOR DE INTENCIÓN  ← NUEVO
 # --------------------------------------------------------
+INTENT_PROMPT = PromptTemplate(
+    template="""Eres un clasificador de intenciones para un asistente de nutrición llamado NutriActive.
+
+Analiza el mensaje del usuario y clasifícalo en UNA de estas categorías:
+- SALUDO: saludos, despedidas, conversación casual ("hola", "gracias", "adiós", "¿cómo estás?")
+- NUTRICION: preguntas sobre nutrición, dieta, salud, cálculos como IMC, calorías, macros, alimentos, etc.
+- OTRO: preguntas no relacionadas con nutrición ni saludos
+
+Responde SOLO con la categoría, sin explicación.
+
+Mensaje: {query}
+Categoría:""",
+    input_variables=["query"]
+)
+
+SALUDO_PROMPT = PromptTemplate(
+    template="""Eres NutriActive, un asistente amigable especializado en nutrición y salud.
+Responde de forma natural y cálida al siguiente mensaje casual del usuario.
+Si el usuario se despide o agradece, invítalo a preguntar sobre nutrición.
 
+Mensaje: {query}
+Respuesta:""",
+    input_variables=["query"]
+)
+
+RAG_PROMPT = PromptTemplate(
+    template="""Eres NutriActive, un asistente experto en nutrición y salud.
+Tu tarea es responder basándote en el contexto proporcionado.
+Si el contexto no tiene suficiente información, usa tu conocimiento general sobre nutrición para dar una respuesta útil.
+Sé amigable, claro y conciso.
+
+Contexto de la base de datos: {context}
+Pregunta del usuario: {question}
+
+Respuesta:""",
+    input_variables=["context", "question"]
+)
+
+# --------------------------------------------------------
+# 3. FUNCIONES DE DESCARGA Y CARGA
+# --------------------------------------------------------
 class QueryRequest(BaseModel):
-    """Define el formato de la pregunta que recibirá el endpoint /query."""
     query: str
 
 def download_file(url, local_path):
-    """Descarga un archivo desde una URL y lo guarda localmente en /tmp."""
     file_name = os.path.basename(local_path)
-    print(f"Descargando: {file_name} desde la nube...")
-    
-    # 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'} 
-    
+    print(f"Descargando: {file_name}...")
+    headers = {'User-Agent': 'Mozilla/5.0'}
     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
+            raise PermissionError(f"Error 403: {file_name} no es público.")
+        response.raise_for_status()
         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.")
-        
+        print(f"�� {file_name} descargado.")
     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}")
+        raise RuntimeError(f"Fallo al descargar {file_name}: {e}")
 
 def load_and_configure_rag():
-    """
-    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
         download_file(URL_FAISS, os.path.join(DOWNLOAD_DIR, 'index.faiss'))
-        download_file(URL_PKL, os.path.join(DOWNLOAD_DIR, 'index.pkl'))
-        
-        # 2. Cargar Embeddings (el mismo modelo que usaste)
-        # 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)...")
+        download_file(URL_PKL,   os.path.join(DOWNLOAD_DIR, 'index.pkl'))
+
+        print("Cargando embeddings...")
         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
+            model_kwargs={'device': 'cpu'},
+            cache_folder=TEMP_CACHE_DIR
         )
-        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}...")
+
+        print("Cargando FAISS...")
         vectorstore = FAISS.load_local(
-            DB_FAISS_PATH, 
-            embeddings, 
-            allow_dangerous_deserialization=True
+            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 = """
-        Eres un asistente de preguntas y respuestas experto en la documentación de NutriActive. 
-        Tu tarea es responder a la pregunta del usuario basándote EXCLUSIVAMENTE en el contexto proporcionado.
-        Si la respuesta no se encuentra en el contexto, indica amablemente: "Lo siento, la información que buscas no se encuentra en la documentación de NutriActive."
-
-        Contexto: {context}
-        Pregunta: {question}
-
-        Respuesta concisa:
-        """
-        RAG_PROMPT = PromptTemplate(template=custom_prompt, input_variables=["context", "question"])
-
-        
-        # 5. Crear la cadena de RAG
-        # qa_chain = RetrievalQA.from_chain_type(
-        #     llm=llm_groq, 
-        #     chain_type="stuff", 
-        #     retriever=vectorstore.as_retriever(search_kwargs={"k": 3}), 
-        #     return_source_documents=True,
-        #     chain_type_kwargs={"prompt": RAG_PROMPT}
-        # )
-
-        # Con LCEL defines el pipeline
-        retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
-
-        qa_chain = (
+
+        llm = ChatGroq(temperature=0.3, model_name="llama-3.3-70b-versatile")
+
+        # Cadena clasificadora de intención
+        intent_chain = INTENT_PROMPT | llm
+
+        # Cadena para saludos
+        saludo_chain = SALUDO_PROMPT | llm
+
+        # Cadena RAG principal
+        retriever  = vectorstore.as_retriever(search_kwargs={"k": 4})
+        rag_chain  = (
             {"context": retriever, "question": RunnablePassthrough()}
             | RAG_PROMPT
-            | llm_groq
+            | llm
         )
-        return qa_chain,retriever
-        
+
+        return intent_chain, saludo_chain, rag_chain, retriever
+
     except Exception as 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}") 
+        print(f"Error CRÍTICO al inicializar: {type(e).__name__}: {e}")
+        raise RuntimeError(f"Falla al cargar RAG: {e}")
 
 # --------------------------------------------------------
-# 3. CONFIGURACIÓN DE FASTAPI Y ENDPOINTS
+# 4. FASTAPI
 # --------------------------------------------------------
-
-# Iniciar servidor y RAG (manejo de errores de carga)
 app = FastAPI(title="NutriActive RAG API")
-qa_chain = None # Inicializamos a None
+
+intent_chain = saludo_chain = qa_chain = retriever = None
 
 try:
-    qa_chain,retriever = load_and_configure_rag() 
+    intent_chain, saludo_chain, qa_chain, retriever = load_and_configure_rag()
 except RuntimeError:
-    # 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 o carga de embeddings."}
-    return {"message": "API de NutriActive RAG operativa. Usa el endpoint /query."}
+        return {"error": "RAG no inicializado. Revisa los logs."}
+    return {"message": "API NutriActive operativa. Usa /query."}
 
 @app.post("/query")
 async def process_query(request: QueryRequest):
-    """Endpoint principal para recibir la pregunta y devolver la respuesta."""
     if qa_chain is None:
-        return {"error": "El sistema RAG no se pudo cargar. Revisa los logs de inicio para ver el error específico."}
-    
+        return {"error": "El sistema RAG no se pudo cargar."}
+
     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']]
-        
-        # 1. Ejecutar el pipeline LCEL → devuelve solo la respuesta
-        response = qa_chain.invoke(request.query)
-
-        # 2. Obtener las fuentes directamente del retriever
-        docs = retriever.invoke(request.query)
-        sources = [doc.metadata.get("source", "N/A") for doc in docs]
-
-        return {
-            "query": request.query,
-            "response": response,
-            # "response": result['result'],
-            "sources": sources
-        }
+        # ── 1. Clasificar intención ──────────────────────────────
+        intent_result = intent_chain.invoke({"query": request.query})
+        intent = intent_result.content.strip().upper()
+        print(f"[Intent] '{request.query}' → {intent}")
+
+        # ── 2. Ruta según intención ──────────────────────────────
+        if "SALUDO" in intent:
+            respuesta = saludo_chain.invoke({"query": request.query})
+            return {
+                "query": request.query,
+                "response": respuesta.content,
+                "intent": "SALUDO",
+                "sources": []
+            }
+
+        elif "OTRO" in intent:
+            return {
+                "query": request.query,
+                "response": "Soy NutriActive, especializado en nutrición y salud. ¿Tienes alguna pregunta sobre alimentación, dietas o bienestar? 🥗",
+                "intent": "OTRO",
+                "sources": []
+            }
+
+        else:
+            # NUTRICION → RAG completo
+            respuesta  = qa_chain.invoke(request.query)
+            docs       = retriever.invoke(request.query)
+            sources    = [doc.metadata.get("source", "N/A") for doc in docs]
+            return {
+                "query":    request.query,
+                "response": respuesta.content,
+                "intent":   "NUTRICION",
+                "sources":  sources
+            }
+
     except Exception as e:
-        return {"error": f"Error al procesar la consulta: {e}"}
+        return {"error": f"Error al procesar la consulta: {e}"}