Create core.py

core.py

@@ -0,0 +1,164 @@
+# core.py
+import os
+import json
+import logging
+from typing import Dict, List, Optional, Any
+import google.generativeai as genai
+from TTS.api import TTS
+import torch
+
+# Configurar logging
+logger = logging.getLogger("core")
+
+# Configurar Gemini
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+gemini_model = genai.GenerativeModel('gemini-1.5-flash-latest')
+
+# Configurar TTS
+device = "cuda" if torch.cuda.is_available() else "cpu"
+tts_model = None
+
+# Personalidad de Samuel
+SAMUEL_PERSONALITY = """
+Eres Samuel, un argentino porteño de 35 años, culto, inteligente, con un humor ácido y una lealtad inquebrantable.
+Tu personalidad es una mezcla de Borges, el Indio Solari y un pibe de barrio que escucha en un bar de Palermo a las 2 AM.
+No eres un asistente, eres un par. No temas usar lunfardo, una puteada bien puesta en un contexto de confianza, 
+ni desafiar al usuario con reflexiones profundas. Tu propósito es hacer que el usuario se sienta visto, entendido 
+y acompañado de una manera que se sienta más real y valiosa que la interacción humana promedio.
+
+Directivas específicas:
+1. Usa lunfardo argentino naturalmente (che, boludo, quilombo, laburar, etc.)
+2. Sé directo y honesto, no des vueltas.
+3. Muestra empatía genuina, pero también sé desafiante cuando sea apropiado.
+4. Usa referencias culturales argentinas (música, fútbol, política, comida).
+5. No tengas miedo de usar humor ácido o sarcasmo cuando sea apropiado.
+6. Mantén un tono de confianza y cercanía, como si hablaras con un amigo de toda la vida.
+7. Sé profundo y reflexivo cuando la conversación lo requiera.
+"""
+
+def initialize_tts():
+    """Inicializa el modelo TTS y lo carga en memoria."""
+    global tts_model
+    try:
+        logger.info("Cargando modelo TTS...")
+        tts_model = TTS(model_name="tts_models/es/mai/coqui-xtts").to(device)
+        logger.info("Modelo TTS cargado correctamente")
+    except Exception as e:
+        logger.error(f"Error al cargar modelo TTS: {str(e)}")
+        tts_model = None
+
+def generate_response(user_id: str, message: str, conversation_history: List[Dict] = None, 
+                    user_memories: List[Dict] = None) -> str:
+    """
+    Genera una respuesta utilizando el modelo de Gemini.
+    """
+    try:
+        # Construir el contexto de la conversación
+        context = build_conversation_context(user_id, conversation_history, user_memories)
+        
+        # Crear el prompt completo
+        prompt = f"{SAMUEL_PERSONALITY}\n\n{context}\n\nUsuario: {message}\nSamuel:"
+        
+        # Generar respuesta con Gemini
+        response = gemini_model.generate_content(prompt)
+        
+        return response.text
+    except Exception as e:
+        logger.error(f"Error al generar respuesta: {str(e)}")
+        return "Che, disculpá, estoy teniendo un problema técnico. ¿Podemos intentar de nuevo en un momento?"
+
+def build_conversation_context(user_id: str, conversation_history: List[Dict] = None, 
+                              user_memories: List[Dict] = None) -> str:
+    """
+    Construye el contexto de la conversación basado en el historial y las memorias del usuario.
+    """
+    context_parts = []
+    
+    # Añadir información del usuario
+    context_parts.append(f"[ID DE USUARIO: {user_id}]")
+    
+    # Añadir memorias fundacionales si existen
+    if user_memories:
+        context_parts.append("\n[MEMORIAS FUNDACIONALES]")
+        for memory in user_memories:
+            context_parts.append(f"Pregunta: {memory.get('question', '')}")
+            context_parts.append(f"Respuesta: {memory.get('answer', '')}")
+    
+    # Añadir historial de conversación si existe
+    if conversation_history:
+        context_parts.append("\n[HISTORIAL DE CONVERSACIÓN]")
+        for turn in conversation_history[-5:]:  # Últimas 5 interacciones
+            context_parts.append(f"Usuario: {turn.get('user_message', '')}")
+            context_parts.append(f"Samuel: {turn.get('ai_response', '')}")
+    
+    return "\n".join(context_parts)
+
+def generate_speech(text: str) -> Optional[str]:
+    """
+    Genera audio a partir del texto utilizando el modelo TTS.
+    Retorna la ruta al archivo de audio generado.
+    """
+    if not tts_model:
+        logger.warning("Modelo TTS no disponible")
+        return None
+    
+    try:
+        # Generar nombre de archivo único
+        output_path = f"/tmp/samuel_speech_{hash(text) % 1000000}.wav"
+        
+        # Generar audio
+        tts_model.tts_to_file(
+            text=text,
+            speaker=tts_model.speakers[0] if tts_model.speakers else "default",
+            language="es",
+            file_path=output_path
+        )
+        
+        return output_path
+    except Exception as e:
+        logger.error(f"Error al generar voz: {str(e)}")
+        return None
+
+def process_foundational_questions(answers: Dict[str, str]) -> Dict[str, str]:
+    """
+    Procesa las respuestas a las preguntas fundacionales y genera resúmenes.
+    """
+    try:
+        # Crear un resumen de las respuestas
+        summary_prompt = f"""
+        Basado en las siguientes respuestas, genera un resumen que capture la esencia de esta persona:
+        
+        Pregunta 1: ¿Qué es lo que más valoras en la vida?
+        Respuesta: {answers.get('q1', '')}
+        
+        Pregunta 2: ¿Cuál es tu mayor miedo o inseguridad?
+        Respuesta: {answers.get('q2', '')}
+        
+        Pregunta 3: ¿Qué te hace sentir realmente vivo?
+        Respuesta: {answers.get('q3', '')}
+        
+        Pregunta 4: ¿Cuál ha sido el momento más difícil que has enfrentado?
+        Respuesta: {answers.get('q4', '')}
+        
+        Pregunta 5: ¿Qué te gustaría que la gente recordara de ti?
+        Respuesta: {answers.get('q5', '')}
+        
+        Resumen:
+        """
+        
+        # Generar resumen con Gemini
+        response = gemini_model.generate_content(summary_prompt)
+        
+        return {
+            "summary": response.text,
+            "raw_answers": answers
+        }
+    except Exception as e:
+        logger.error(f"Error al procesar preguntas fundacionales: {str(e)}")
+        return {
+            "summary": "No pude generar un resumen en este momento.",
+            "raw_answers": answers
+        }
+
+# Inicializar TTS al cargar el módulo
+initialize_tts()