Actualizar app.py

app.py

@@ -1,255 +1,113 @@
 import gradio as gr
-import os
-import json
-from datetime import datetime
+import requests
+from transformers import pipeline
 import logging
 import threading
 
-# Configuración de logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Importar módulos personalizados
-from model_manager import ModelManager
-from api_agent import APIAgent
-from prompt_generator import PromptGenerator
-
-# Inicializar componentes
-model_manager = ModelManager()
-api_agent = APIAgent()
-prompt_generator = PromptGenerator()
-
-class BATUTOChatbot:
+class SimpleChatbot:
     def __init__(self):
         self.conversation_history = []
-        self.config = {
-            'deepseek_api_key': '',
-            'openai_api_key': '', 
-            'max_tokens': 400,
-            'temperature': 0.7
-        }
-    
-    def update_config(self, deepseek_key, openai_key, max_tokens, temperature):
-        """Actualiza la configuración desde la UI"""
-        updated = False
+        self.models_loaded = False
+        self.chat_model = None
         
-        if deepseek_key:
-            self.config['deepseek_api_key'] = deepseek_key
-            updated = True
-        if openai_key:
-            self.config['openai_api_key'] = openai_key
-            updated = True
-        if max_tokens:
-            self.config['max_tokens'] = int(max_tokens)
-            updated = True
-        if temperature:
-            self.config['temperature'] = float(temperature)
-            updated = True
-            
-        # Actualizar agentes
-        model_manager.set_config(self.config)
-        api_agent.set_config(self.config)
-        
-        return 'Configuración actualizada' if updated else 'Sin cambios'
-    
-    def get_system_status(self):
-        """Obtiene el estado del sistema"""
-        has_deepseek = bool(self.config.get('deepseek_api_key'))
-        has_openai = bool(self.config.get('openai_api_key'))
-        models_loaded = model_manager.loaded
-        
-        status_html = f'''
-        <div style='padding: 15px; border-radius: 10px; background: #f8f9fa; border: 2px solid #e9ecef;'>
-            <h4 style='margin-top: 0;'>Estado del Sistema</h4>
-            <p><strong>Modelos locales:</strong> {'Cargados' if models_loaded else 'Cargando...'}</p>
-            <p><strong>DeepSeek API:</strong> {'Configurada' if has_deepseek else 'No configurada'}</p>
-            <p><strong>OpenAI API:</strong> {'Configurada' if has_openai else 'No configurada'}</p>
-            <p><strong>Mensajes en sesión:</strong> {len(self.conversation_history)}</p>
-        </div>
-        '''
-        return status_html
+    def load_models(self):
+        try:
+            logger.info('Loading DialoGPT model...')
+            self.chat_model = pipeline(
+                "text-generation",
+                model="microsoft/DialoGPT-small",
+                device="cpu"
+            )
+            self.models_loaded = True
+            logger.info('Model loaded successfully')
+            return True
+        except Exception as e:
+            logger.error(f'Error loading model: {e}')
+            return False
     
     def chat_response(self, message, history):
-        """Genera respuesta del chatbot optimizado para HF"""
         if not message.strip():
-            return ''
+            return ""
         
-        # Mostrar indicador de typing
-        yield 'Procesando...'
+        yield "Procesando..."
         
         try:
-            # Detectar intención y mejorar prompt
-            intent = prompt_generator.detect_intent(message)
-            enhanced_prompt = prompt_generator.enhance_prompt(message, intent)
+            if not self.models_loaded:
+                self.load_models()
             
-            # Intentar usar APIs primero
-            api_result = api_agent.generate_response(enhanced_prompt, intent['is_code'])
+            # Generar respuesta con el modelo local
+            result = self.chat_model(
+                message,
+                max_length=150,
+                num_return_sequences=1,
+                temperature=0.7,
+                do_sample=True
+            )
             
-            if api_result['response']:
-                # Usar respuesta de API
-                response_text = api_result['response']
-                source = api_result['source']
-            else:
-                # Usar modelo local como fallback
-                response_text = model_manager.generate_local_response(
-                    enhanced_prompt, 
-                    intent['is_code'],
-                    max_length=200
-                )
-                source = 'local'
+            response = result[0]['generated_text']
             
-            # Agregar metadata a la respuesta
-            metadata = f'\n\n---\nFuente: {source.upper()}'
-            if intent['is_code']:
-                metadata += f' | Tipo: Código'
-            else:
-                metadata += f' | Tipo: Conversación'
+            # Limpiar respuesta
+            if response.startswith(message):
+                response = response[len(message):].strip()
             
-            full_response = response_text + metadata
+            full_response = response + "\n\n---\nFuente: Modelo Local"
             
-            # Guardar en historial
             self.conversation_history.append({
-                'timestamp': datetime.now().isoformat(),
-                'user': message,
-                'bot': response_text,
-                'source': source,
-                'intent': intent
+                "user": message,
+                "bot": response
             })
             
             yield full_response
             
         except Exception as e:
-            error_msg = f'Error: {str(e)}'
-            logger.error(f'Error en chat_response: {e}')
+            error_msg = f"Error: {str(e)}"
             yield error_msg
-    
-    def clear_conversation(self):
-        """Limpia la conversación"""
-        self.conversation_history.clear()
-        return None, []
 
-# Crear instancia del chatbot
-chatbot = BATUTOChatbot()
+# Crear instancia
+chatbot = SimpleChatbot()
 
-# Cargar modelos al inicio (async)
+# Cargar modelos en segundo plano
 def load_models_async():
-    logger.info('Cargando modelos en segundo plano...')
-    model_manager.load_models()
-    logger.info('Modelos cargados exitosamente')
+    chatbot.load_models()
 
-# Iniciar carga de modelos
 model_loader = threading.Thread(target=load_models_async, daemon=True)
 model_loader.start()
 
-# Configuración de la interfaz Gradio para HF
-with gr.Blocks(
-    title='BATUTO Chatbot - Asistente Educativo',
-    theme=gr.themes.Soft(),
-    css='''
-    .gradio-container {
-        max-width: 1000px !important;
-        margin: auto;
-    }
-    .chat-container {
-        height: 500px;
-    }
-    .status-panel {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        padding: 20px;
-        border-radius: 10px;
-        color: white;
-    }
-    '''
-) as demo:
-    
-    gr.Markdown('''
-    # BATUTO Chatbot - Asistente Educativo
-    **Sistema inteligente con modelos locales y APIs externas**  
-    *Desplegado en Hugging Face Spaces - Versión Optimizada*
-    ''')
+# Interfaz simple
+with gr.Blocks(title="BATUTO Chatbot") as demo:
+    gr.Markdown("# BATUTO Chatbot - Asistente Educativo")
     
     with gr.Row():
         with gr.Column(scale=2):
-            # Área de chat
-            gr.Markdown('### Conversación')
-            chatbot_interface = gr.Chatbot(
-                label='Chat con BATUTO',
-                height=400,
-                show_copy_button=True,
-                container=True
-            )
+            chatbot_interface = gr.Chatbot(label="Conversación", height=400)
             msg = gr.Textbox(
-                label='Escribe tu mensaje',
-                placeholder='Pregunta sobre programación, explica conceptos, pide ejemplos...',
-                lines=2,
-                max_lines=4
+                label="Escribe tu mensaje",
+                placeholder="Pregunta sobre programación...",
+                lines=2
             )
             
             with gr.Row():
-                submit_btn = gr.Button('Enviar', variant='primary')
-                clear_btn = gr.Button('Limpiar', variant='secondary')
+                submit_btn = gr.Button("Enviar", variant="primary")
+                clear_btn = gr.Button("Limpiar", variant="secondary")
         
         with gr.Column(scale=1):
-            # Panel de estado
-            gr.Markdown('### Estado del Sistema')
-            status_display = gr.HTML()
-            
-            # Configuración rápida
-            with gr.Accordion('Configuración Rápida', open=False):
-                with gr.Group():
-                    deepseek_key = gr.Textbox(
-                        label='DeepSeek API Key',
-                        type='password',
-                        placeholder='sk-...',
-                        info='Opcional - para respuestas mejoradas'
-                    )
-                    openai_key = gr.Textbox(
-                        label='OpenAI API Key', 
-                        type='password',
-                        placeholder='sk-...',
-                        info='Opcional - alternativa'
-                    )
-                    
-                    with gr.Row():
-                        max_tokens = gr.Slider(
-                            label='Tokens máx',
-                            minimum=100,
-                            maximum=800,
-                            value=400,
-                            step=50
-                        )
-                        temperature = gr.Slider(
-                            label='Temperatura',
-                            minimum=0.1,
-                            maximum=1.0,
-                            value=0.7,
-                            step=0.1
-                        )
-                    
-                    save_config_btn = gr.Button('Guardar Config', size='sm')
-                    config_output = gr.Textbox(label='Estado', interactive=False)
-            
-            # Información
-            with gr.Accordion('Cómo usar', open=True):
-                gr.Markdown('''
-                **Ejemplos:**
-                - Muéstrame una función Python para ordenar listas
-                - Explica qué es machine learning
-                - Corrige este código: [tu código]
-                
-                **Fuentes:**
-                1. DeepSeek API (si se configura)
-                2. OpenAI API (si se configura)  
-                3. Modelos locales (fallback)
-                ''')
+            gr.Markdown("### Información")
+            gr.Markdown("""
+            **Ejemplos:**
+            - Explica qué es Python
+            - Muestra función para ordenar listas  
+            - Corrige código Python
+            """)
     
     # Event handlers
     def handle_submit(message, history):
         if not message.strip():
-            return '', history
-        return '', history + [[message, None]]
+            return "", history
+        return "", history + [[message, None]]
     
-    # Conectar el botón de enviar
     submit_btn.click(
         handle_submit,
         inputs=[msg, chatbot_interface],
@@ -260,7 +118,6 @@ with gr.Blocks(
         outputs=[chatbot_interface]
     )
     
-    # Enter también envía
     msg.submit(
         handle_submit,
         inputs=[msg, chatbot_interface],
@@ -271,34 +128,10 @@ with gr.Blocks(
         outputs=[chatbot_interface]
     )
     
-    # Limpiar chat
     clear_btn.click(
-        chatbot.clear_conversation,
+        lambda: (None, []),
         outputs=[msg, chatbot_interface]
     )
-    
-    # Configuración
-    save_config_btn.click(
-        chatbot.update_config,
-        inputs=[deepseek_key, openai_key, max_tokens, temperature],
-        outputs=[config_output]
-    ).then(
-        chatbot.get_system_status,
-        outputs=[status_display]
-    )
-    
-    # Actualizar estado al cargar
-    demo.load(
-        chatbot.get_system_status,
-        outputs=[status_display]
-    )
 
-# Configuración específica para Hugging Face Spaces
-if __name__ == '__main__':
-    demo.launch(
-        server_name='0.0.0.0',
-        server_port=7860,
-        share=True,
-        show_error=True,
-        debug=False
-    )
+if __name__ == "__main__":
+    demo.launch()