Update app.py

app.py

@@ -3,90 +3,76 @@ import os
 import json
 import requests
 from datetime import datetime
-import uuid # Necesario para generar IDs únicos para cada conversación
-from supabase import create_client, Client
+import uuid # NUEVO: Para generar IDs únicos si se necesita en el futuro
+from supabase import create_client, Client # NUEVO: Importamos el cliente de Supabase
 
-# --- CONFIGURACIÓN ---
-# Clave de la API de Groq
+# --- Credenciales de Groq (sin cambios) ---
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
 
-# Configuración del modelo y el sistema
+# --- Configuración del Modelo (sin cambios) ---
 SYSTEM_MESSAGE = os.environ.get("System_Prompt")
-MODEL_NAME = "llama3-70b-8192" # Modelo actualizado y recomendado
+MODEL_NAME = "meta-llama/llama-4-maverick-17b-128e-instruct"
 MAX_TOKENS = 4096
 TEMPERATURE = 0.7
 TOP_P = 0.95
 
-# --- NUEVA CONFIGURACIÓN DE SUPERBASE ---
+# --- NUEVO: Credenciales de Supabase ---
+# Asegúrate de haber configurado estas variables de entorno en tu Space de Hugging Face
 SUPABASE_URL = os.environ.get("SUPABASE_URL")
 SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
-TABLE_NAME = "conversations" # Asegúrate que este sea el nombre de tu tabla
-
-# Inicializar el cliente de Supabase
-# Se verifica que las credenciales existan antes de crear el cliente
-if SUPABASE_URL and SUPABASE_KEY:
-    supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-else:
-    supabase = None
-    print("Advertencia: Las credenciales de Supabase no están configuradas. El historial de chat no se guardará.")
-
-# --- FUNCIÓN DE PERSISTENCIA MODIFICADA PARA SUPABASE ---
-def persist_conversation(conversation_id: uuid.UUID, user_id: str, messages_data: list):
+
+# --- CAMBIADO: La función persist_data ahora usa Supabase ---
+def persist_data(session_data, user_identifier=None):
     """
-    Guarda o actualiza una conversación completa en la tabla de Supabase.
-    Usa 'upsert' para insertar si es nueva o actualizar si ya existe.
+    Guarda el historial de la conversación en una tabla de Supabase.
+    Cada llamada inserta una nueva fila con el estado completo de la conversación.
     """
-    if not supabase:
-        return # No hacer nada si el cliente no se inicializó
+    # Verifica que las credenciales de Supabase estén configuradas
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        print("Advertencia: Las credenciales de Supabase (URL y KEY) no están configuradas. No se guardará la conversación.")
+        return
 
     try:
-        # El método 'upsert' es ideal: inserta una nueva fila si el 'id' no existe,
-        # o la actualiza si ya existe. Esto es perfecto para guardar el estado de
-        # una conversación en curso.
-        response = supabase.table(TABLE_NAME).upsert({
-            "id": str(conversation_id),
-            "timestamp": datetime.now().isoformat(), # Usamos formato ISO 8601 que Supabase entiende
-            "user_id": str(user_id), # Basado en tu columna 'user_id'
-            "messages": messages_data # Guardamos la lista de mensajes como JSONB
-        }).execute()
-        
-        # Opcional: Verificar si hubo un error en la respuesta de Supabase
-        if hasattr(response, 'error') and response.error:
-             print(f"Error al guardar en Supabase: {response.error}")
-        else:
-             print(f"Conversación {conversation_id} guardada/actualizada en Supabase.")
+        # Inicializa el cliente de Supabase
+        supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-    except Exception as e:
-        print(f"Ocurrió una excepción al intentar guardar en Supabase: {e}")
+        # Prepara los datos para insertar. Esto debe coincidir con tus columnas.
+        # La columna 'id' (uuid) y 'timestamp' (timestamptz) se pueden generar automáticamente
+        # por Supabase si las configuras con un valor por defecto (gen_random_uuid() y now()).
+        # Aquí enviamos el timestamp explícitamente.
+        data_to_insert = {
+            "timestamp": datetime.now().isoformat(),
+            "user_id": user_identifier,  # Puedes dejarlo como None si no manejas usuarios
+            "messages": json.dumps(session_data) # Convertimos la lista de tuplas a un string JSON
+        }
 
-# --- FUNCIÓN PRINCIPAL DEL CHATBOT (MODIFICADA) ---
-def respond(message: str, history: list[tuple[str, str]], conversation_id: uuid.UUID):
-    """
-    Función principal que procesa la entrada del usuario, llama a la API de Groq y guarda la conversación.
-    """
-    # Si 'conversation_id' es None, significa que es el primer mensaje de una nueva conversación.
-    if conversation_id is None:
-        conversation_id = uuid.uuid4()
-        # Para la columna 'user_id', podemos usar el mismo ID de la conversación
-        # si no tienes un sistema de usuarios más complejo.
-        user_id = conversation_id
-    else:
-        user_id = conversation_id # Mantener el mismo user_id
+        # Inserta los datos en tu tabla. ¡CAMBIA 'conversations' POR EL NOMBRE REAL DE TU TABLA!
+        table_name = "conversations" # <--- ¡IMPORTANTE! Usa el nombre de tu tabla
+        response = supabase.table(table_name).insert(data_to_insert).execute()
+
+        print(f"Conversación guardada en Supabase exitosamente. Respuesta: {response.data}")
 
-    # Construir el payload para la API de Groq
+    except Exception as e:
+        print(f"Error al guardar datos en Supabase: {e}")
+
+# --- La función respond permanece casi igual ---
+def respond(message, history: list[tuple[str, str]]):
     messages = [{"role": "system", "content": SYSTEM_MESSAGE}]
+
     for user_msg, assistant_msg in history:
         if user_msg:
             messages.append({"role": "user", "content": user_msg})
         if assistant_msg:
             messages.append({"role": "assistant", "content": assistant_msg})
+
     messages.append({"role": "user", "content": message})
 
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {GROQ_API_KEY}"
     }
+
     payload = {
         "model": MODEL_NAME,
         "messages": messages,
@@ -96,24 +82,23 @@ def respond(message: str, history: list[tuple[str, str]], conversation_id: uuid.
         "stream": True
     }
 
-    # Llamada a la API de Groq
-    try:
-        response = requests.post(GROQ_API_URL, headers=headers, json=payload, stream=True, timeout=10)
-        response.raise_for_status() # Lanza un error si la respuesta es 4xx o 5xx
-    except requests.exceptions.RequestException as e:
-        print(f"Error en la petición a la API de Groq: {e}")
-        yield "Lo siento, no pude conectarme con el servicio en este momento. Inténtalo de nuevo más tarde."
-        return
+    response = requests.post(
+        GROQ_API_URL,
+        headers=headers,
+        json=payload,
+        stream=True
+    )
 
-    # Procesar la respuesta en streaming
     accumulated_response = ""
     for line in response.iter_lines():
         if line:
             line_text = line.decode('utf-8')
             if line_text.startswith("data: "):
                 data_str = line_text[6:]
+
                 if data_str == "[DONE]":
                     break
+
                 try:
                     data = json.loads(data_str)
                     if 'choices' in data and len(data['choices']) > 0:
@@ -123,28 +108,21 @@ def respond(message: str, history: list[tuple[str, str]], conversation_id: uuid.
                             accumulated_response += token
                             yield accumulated_response
                 except json.JSONDecodeError:
+                    print(f"Error decodificando JSON: {data_str}")
                     continue
-    
-    # Después de obtener la respuesta completa, la guardamos en Supabase
-    if accumulated_response:
-        # Formateamos el historial completo para la columna 'messages' (JSONB)
-        # Esto es mucho más útil que un archivo de texto plano.
-        full_history_for_db = messages + [{"role": "assistant", "content": accumulated_response}]
-        
-        persist_conversation(conversation_id, user_id, full_history_for_db)
-    else:
-        yield "Lo siento, ocurrió un error al procesar tu solicitud."
 
-# --- INTERFAZ DE GRADIO (MODIFICADA) ---
-# Usamos gr.State para mantener el ID de la conversación a través de múltiples turnos
-# en la misma sesión del navegador.
-conversation_id_state = gr.State(value=None)
+    if not accumulated_response:
+        yield "Lo siento, ocurrió un error al procesar tu solicitud."
+    else:
+        # Al final de una respuesta exitosa, guarda la conversación completa
+        current_session = history + [(message, accumulated_response)]
+        persist_data(current_session) # Llamamos a la nueva función
 
+# --- Interfaz de Gradio (sin cambios) ---
 demo = gr.ChatInterface(
     respond,
-    additional_inputs=[conversation_id_state], # Pasamos el estado como una entrada adicional
     title="Tu Aliado Momentum",
-    description="Chatea conmigo para saber más sobre el programa Momentum.",
+    description="Chatbot para resolver tus dudas sobre el programa Momentum.",
     examples=[["¡Bienvenido a Tu Aliado Momentum!"],
               ["¿En qué consiste el programa y para quién es?"],
               ["¿Qué beneficios obtengo y con qué empresas me conecto?"],