Testing completely new code

README.md

@@ -1,11 +1,243 @@
+# 🦙 Llama 3.2 3B Chat - Hugging Face Space
+
+Un Space de Hugging Face para chatear con Meta Llama 3.2 3B Instruct con sistema de colas, streaming y API para cliente Python.
+
+## ✨ Características
+
+- 🔄 **Sistema de colas**: Solo procesa una petición a la vez para evitar sobrecargar el modelo
+- 📡 **Streaming en tiempo real**: Ve la respuesta generándose en tiempo real
+- 🐍 **Cliente Python**: API completa para integración con aplicaciones Python
+- 💬 **Interfaz web**: Chat interactivo con sistema de prompts y configuración
+- 📊 **Monitoreo**: Estado de cola en tiempo real
+- 🔐 **Autenticación**: Soporte para modelos restringidos con HF token
+
+## 🚀 Configuración del Space
+
+### 1. Crear el Space
+
+1. Ve a [Hugging Face Spaces](https://huggingface.co/new-space)
+2. Elige **Gradio** como SDK
+3. Selecciona **T4 small** o superior como hardware
+4. Nombra tu Space (ej: `tu-usuario/llama-chat`)
+
+### 2. Configurar el token HF
+
+1. Ve a **Settings** de tu Space
+2. En **Repository secrets**, agrega:
+   - **Name**: `HF_TOKEN`
+   - **Value**: Tu token de Hugging Face (con acceso a Llama)
+
+### 3. Subir archivos
+
+Sube estos archivos a tu Space:
+- `app.py` (aplicación principal)
+- `requirements.txt` (dependencias)
+
+### 4. Verificar el despliegue
+
+Una vez que el Space esté corriendo, deberías ver:
+- Una interfaz de chat en la pestaña principal
+- Un endpoint API en la segunda pestaña
+- Estado de cola actualizado automáticamente
+
+## 📱 Uso de la interfaz web
+
+### Chat Principal
+- **System Prompt**: Define el comportamiento del asistente
+- **Mensaje**: Tu pregunta o mensaje
+- **Max Tokens**: Longitud máxima de la respuesta (50-1024)
+- **Temperature**: Creatividad de la respuesta (0.1-2.0)
+
+### Estado de Cola
+- **queue_size**: Número de peticiones en espera
+- **is_processing**: Si está procesando actualmente
+- **timestamp**: Última actualización
+
+## 🐍 Cliente Python
+
+### Instalación
+
+```bash
+pip install requests
+```
+
+### Uso Básico
+
+```python
+from client import LlamaClient
+
+# Inicializar cliente con la URL de tu Space
+client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+# Chat simple
+response = client.chat(
+    message="¿Qué es la inteligencia artificial?",
+    system_prompt="Eres un profesor experto."
+)
+
+print(response["response"])
+```
+
+### Chat con Streaming
+
+```python
+# Ver respuesta generándose en tiempo real
+for chunk in client.chat_stream(
+    message="Explica la física cuántica",
+    system_prompt="Eres un divulgador científico.",
+    max_tokens=300
+):
+    print(f"\r{chunk['response']}", end="", flush=True)
+
+    if chunk.get("is_complete", False):
+        print("\n[Completo]")
+        break
+```
+
+### Chat con Historial
+
+```python
+# Mantener conversación
+history = [
+    ["Hola", "¡Hola! ¿En qué puedo ayudarte?"],
+    ["Explica el machine learning", "El machine learning es..."]
+]
+
+response = client.chat(
+    message="¿Puedes dar un ejemplo práctico?",
+    history=history
+)
+```
+
+## 🔧 API Endpoints
+
+### POST /call/api_chat
+Respuesta completa sin streaming.
+
+**Payload:**
+```json
+{
+    "data": [
+        "system_prompt",
+        "message", 
+        [["user", "assistant"], ...],
+        512,
+        0.7
+    ]
+}
+```
+
+**Respuesta:**
+```json
+{
+    "data": [{
+        "response": "Respuesta del modelo",
+        "queue_status": {
+            "queue_size": 0,
+            "is_processing": false,
+            "timestamp": "2025-10-16T17:30:00"
+        }
+    }]
+}
+```
+
+### POST /call/api_chat_stream
+Respuesta con streaming.
+
+Misma estructura de payload, pero responde con eventos SSE.
+
+## 📊 Monitoreo y Debugging
+
+### Logs del Space
+Revisa los logs en la interfaz de HF Spaces para debugging.
+
+### Estado de Cola
+Usa `client.get_queue_status()` para monitorear la cola:
+
+```python
+status = client.get_queue_status()
+print(f"Cola: {status['queue_size']} peticiones")
+print(f"Procesando: {status['is_processing']}")
+```
+
+### Manejo de Errores
+
+```python
+response = client.chat("Hola")
+
+if "error" in response:
+    print(f"Error: {response['error']}")
+else:
+    print(f"Respuesta: {response['response']}")
+```
+
+## ⚙️ Configuración Avanzada
+
+### Parámetros del Modelo
+
+- **max_tokens**: 50-1024 (recomendado: 512)
+- **temperature**: 0.1-2.0 (recomendado: 0.7)
+- **repetition_penalty**: Automático (1.1)
+
+### Optimización de Performance
+
+1. **Hardware**: Usa GPU T4 small mínimo
+2. **Batch size**: Sistema de colas evita problemas de memoria
+3. **Context length**: Máximo 2048 tokens de entrada
+
+### System Prompts Útiles
+
+```python
+# Para tareas académicas
+system_prompt = "Eres un tutor experto que explica conceptos complejos de forma clara y pedagógica."
+
+# Para programación
+system_prompt = "Eres un desarrollador senior que ayuda con código Python, explicando paso a paso."
+
+# Para creatividad
+system_prompt = "Eres un escritor creativo que ayuda a generar ideas originales y contenido engagente."
+```
+
+## 🐛 Troubleshooting
+
+### Error: HF_TOKEN no encontrado
+- Verifica que agregaste el token en Repository secrets
+- Asegúrate que el nombre sea exactamente `HF_TOKEN`
+
+### Error: Modelo no disponible
+- Tu token debe tener acceso a Llama 3.2 3B
+- Solicita acceso en la página del modelo si es necesario
+
+### Timeouts en cliente Python
+- Aumenta el timeout: `requests.post(..., timeout=600)`
+- El modelo puede tardar en cargar la primera vez
+
+### Cola muy larga
+- El sistema procesa una petición a la vez
+- Considera usar hardware más potente
+
+## 🤝 Contribuciones
+
+¿Mejoras sugeridas?
+1. Fork el código
+2. Implementa mejoras
+3. Prueba con tu propio Space
+4. Comparte tu versión
+
+## 📝 Licencia
+
+Este código es de uso libre. Respeta los términos de uso de:
+- Hugging Face Spaces
+- Meta Llama 3.2 License
+- Gradio License
+
+## 🔗 Enlaces Útiles
+
+- [Hugging Face Spaces](https://huggingface.co/spaces)
+- [Meta Llama 3.2 3B Instruct](https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [Transformers Library](https://huggingface.co/docs/transformers)
+
 ---
-title: Llama 3.2-3B Chat Server
-emoji: 🦙
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: llama3.2
----
+
+**¡Disfruta chateando con Llama! 🦙**

RESUMEN.md

@@ -0,0 +1,60 @@
+
+🦙 RESUMEN DEL PROYECTO - Llama 3.2 3B Chat Space
+================================================================
+
+✅ ARCHIVOS GENERADOS:
+
+📱 CORE APPLICATION:
+- app.py          → Aplicación principal de Gradio con cola y streaming
+- requirements.txt → Dependencias del proyecto  
+- config.py       → Configuración centralizada
+- utils.py        → Utilidades y monitoreo de rendimiento
+
+🐍 CLIENTE PYTHON:
+- client.py       → Cliente Python para API del Space
+- examples.py     → Ejemplos avanzados de uso
+- tests.py        → Suite de pruebas automáticas
+
+📚 DOCUMENTACIÓN:
+- README.md       → Instrucciones completas de setup y uso
+
+🚀 CARACTERÍSTICAS IMPLEMENTADAS:
+
+✓ Sistema de colas (una petición a la vez)
+✓ Streaming en tiempo real  
+✓ API completa para cliente Python
+✓ Soporte para system prompt, message e history
+✓ Interfaz web con Gradio
+✓ Monitoreo de estado de cola
+✓ Manejo de errores robusto
+✓ Configuración para hf_token
+✓ Validación de parámetros
+✓ Estimación de tokens
+✓ Historial de conversación
+✓ Múltiples temperaturas
+✓ Límites configurables
+
+🔧 PASOS SIGUIENTES:
+
+1. Crear Space en Hugging Face:
+   - Ve a https://huggingface.co/new-space
+   - Selecciona Gradio SDK
+   - Elige hardware T4 small o superior
+
+2. Configurar HF_TOKEN:
+   - Settings → Repository secrets
+   - Agregar HF_TOKEN con tu token de acceso
+
+3. Subir archivos:
+   - app.py y requirements.txt son obligatorios
+   - Los demás archivos son opcionales pero recomendados
+
+4. Probar funcionalidad:
+   - Usar tests.py para verificar el funcionamiento
+   - Usar examples.py para casos de uso avanzados
+
+📖 DOCUMENTACIÓN COMPLETA:
+Revisar README.md para instrucciones detalladas de configuración,
+uso de la API, troubleshooting y ejemplos de integración.
+
+¡Tu Space está listo para ser desplegado! 🚀

app.py

@@ -1,291 +1,374 @@
+
 import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
-import os
-import threading
+import asyncio
 import queue
+import threading
 import time
-from typing import Generator, List, Tuple
+import os
+from typing import List, Dict, Optional, Generator, Tuple
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+import torch
 import json
+from datetime import datetime
+
+class LlamaChat:
+    def __init__(self):
+        self.model_name = "meta-llama/Llama-3.2-3B-Instruct"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.tokenizer = None
+        self.model = None
+        self.request_queue = queue.Queue()
+        self.is_processing = False
+        self.current_streamer = None
+
+        # Inicializar modelo
+        self._load_model()
+
+        # Iniciar worker thread para procesar colas
+        self.worker_thread = threading.Thread(target=self._queue_worker, daemon=True)
+        self.worker_thread.start()
+
+    def _load_model(self):
+        """Cargar el modelo y tokenizer con el token de HF"""
+        try:
+            hf_token = os.environ.get("HF_TOKEN")
+            if not hf_token:
+                raise ValueError("HF_TOKEN no encontrado en variables de entorno")
+
+            print(f"Cargando modelo {self.model_name}...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name, 
+                token=hf_token,
+                trust_remote_code=True
+            )
 
-# Variables globales para el modelo
-model = None
-tokenizer = None
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-def load_model():
-    """Carga el modelo Llama 3.2-3B de forma eficiente"""
-    global model, tokenizer
-
-    model_name = "meta-llama/Llama-3.2-3B-Instruct"
-
-    # Configuración optimizada para el tier gratuito
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForCausalLM.from_pretrained(
-        model_name,
-        torch_dtype=torch.bfloat16 if device == "cuda" else torch.float32,
-        device_map="auto" if device == "cuda" else None,
-        low_cpu_mem_usage=True,
-        trust_remote_code=True
-    )
-
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
-
-    print(f"Modelo cargado en: {device}")
-
-def format_chat_prompt(message: str, history: List[List[str]] = None) -> str:
-    """Formatea el prompt usando el template de chat de Llama 3.2"""
-    messages = []
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                token=hf_token,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True
+            )
 
-    # Agregar historial de conversación
-    if history:
-        for user_msg, assistant_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
-                messages.append({"role": "assistant", "content": assistant_msg})
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
 
-    # Agregar mensaje actual
-    messages.append({"role": "user", "content": message})
+            print("Modelo cargado exitosamente!")
 
-    # Usar el template de chat del tokenizer
-    formatted_prompt = tokenizer.apply_chat_template(
-        messages, 
-        tokenize=False, 
-        add_generation_prompt=True
-    )
+        except Exception as e:
+            print(f"Error cargando modelo: {e}")
+            raise
 
-    return formatted_prompt
+    def _format_messages(self, system_prompt: str, message: str, history: List[List[str]]) -> str:
+        """Formatear mensajes para Llama-3.2-Instruct"""
+        messages = []
 
-def generate_stream(message: str, history: List[List[str]] = None, 
-                   max_tokens: int = 512, temperature: float = 0.7, 
-                   top_p: float = 0.9) -> Generator[str, None, None]:
-    """Genera respuesta con streaming usando TextIteratorStreamer"""
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
 
-    if model is None or tokenizer is None:
-        yield "Error: Modelo no cargado correctamente"
-        return
+        # Agregar historial
+        for user_msg, assistant_msg in history:
+            messages.append({"role": "user", "content": user_msg})
+            messages.append({"role": "assistant", "content": assistant_msg})
 
-    try:
-        # Formatear el prompt
-        formatted_prompt = format_chat_prompt(message, history)
+        # Agregar mensaje actual
+        messages.append({"role": "user", "content": message})
 
-        # Tokenizar
-        inputs = tokenizer(
-            formatted_prompt, 
-            return_tensors="pt", 
-            truncation=True, 
-            max_length=2048
-        )
-        inputs = inputs.to(device)
-
-        # Configurar streaming
-        streamer = TextIteratorStreamer(
-            tokenizer, 
-            timeout=30.0, 
-            skip_prompt=True, 
-            skip_special_tokens=True
+        # Usar el chat template del tokenizer
+        formatted_prompt = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
         )
 
-        # Parámetros de generación
-        generation_kwargs = {
-            "input_ids": inputs["input_ids"],
-            "attention_mask": inputs["attention_mask"],
-            "max_new_tokens": max_tokens,
+        return formatted_prompt
+
+    def _queue_worker(self):
+        """Worker thread para procesar cola de requests"""
+        while True:
+            try:
+                if not self.request_queue.empty():
+                    request = self.request_queue.get()
+                    self.is_processing = True
+                    self._process_request(request)
+                    self.is_processing = False
+                    self.request_queue.task_done()
+                else:
+                    time.sleep(0.1)
+            except Exception as e:
+                print(f"Error en queue worker: {e}")
+                self.is_processing = False
+
+    def _process_request(self, request: Dict):
+        """Procesar una request individual"""
+        try:
+            system_prompt = request["system_prompt"]
+            message = request["message"]
+            history = request["history"]
+            max_tokens = request.get("max_tokens", 512)
+            temperature = request.get("temperature", 0.7)
+            response_callback = request["callback"]
+
+            # Formatear prompt
+            formatted_prompt = self._format_messages(system_prompt, message, history)
+
+            # Tokenizar
+            inputs = self.tokenizer(
+                formatted_prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=2048
+            ).to(self.device)
+
+            # Configurar streamer
+            streamer = TextIteratorStreamer(
+                self.tokenizer,
+                timeout=60,
+                skip_prompt=True,
+                skip_special_tokens=True
+            )
+            self.current_streamer = streamer
+
+            # Configurar parámetros de generación
+            generation_kwargs = {
+                **inputs,
+                "max_new_tokens": max_tokens,
+                "temperature": temperature,
+                "do_sample": True,
+                "pad_token_id": self.tokenizer.eos_token_id,
+                "streamer": streamer,
+                "repetition_penalty": 1.1
+            }
+
+            # Generar en thread separado
+            def generate():
+                with torch.no_grad():
+                    self.model.generate(**generation_kwargs)
+
+            generation_thread = threading.Thread(target=generate)
+            generation_thread.start()
+
+            # Stream respuesta
+            full_response = ""
+            for new_text in streamer:
+                if new_text:
+                    full_response += new_text
+                    response_callback(full_response, False)
+
+            response_callback(full_response, True)
+            generation_thread.join()
+
+        except Exception as e:
+            print(f"Error procesando request: {e}")
+            response_callback(f"Error: {str(e)}", True)
+        finally:
+            self.current_streamer = None
+
+    def chat_stream(self, system_prompt: str, message: str, history: List[List[str]], 
+                   max_tokens: int = 512, temperature: float = 0.7) -> Generator[Tuple[str, bool], None, None]:
+        """Método principal para chatear con streaming"""
+        if not message.strip():
+            yield "Por favor, escribe un mensaje.", True
+            return
+
+        # Crear evento para comunicación con el worker
+        response_queue = queue.Queue()
+        response_complete = threading.Event()
+        current_response = [""]
+
+        def response_callback(text: str, is_complete: bool):
+            current_response[0] = text
+            response_queue.put((text, is_complete))
+            if is_complete:
+                response_complete.set()
+
+        # Agregar request a la cola
+        request = {
+            "system_prompt": system_prompt or "",
+            "message": message,
+            "history": history or [],
+            "max_tokens": max_tokens,
             "temperature": temperature,
-            "top_p": top_p,
-            "do_sample": True,
-            "streamer": streamer,
-            "pad_token_id": tokenizer.eos_token_id,
-            "eos_token_id": tokenizer.eos_token_id,
+            "callback": response_callback
         }
 
-        # Generar en hilo separado
-        generation_thread = threading.Thread(
-            target=model.generate, 
-            kwargs=generation_kwargs
-        )
-        generation_thread.start()
-
-        # Stream de tokens
-        partial_text = ""
-        for new_token in streamer:
-            if new_token:
-                partial_text += new_token
-                yield partial_text
-
-        generation_thread.join()
-
-    except Exception as e:
-        yield f"Error en la generación: {str(e)}"
-
-def chat_interface(message: str, history: List[List[str]],
-                  max_tokens: int, temperature: float, top_p: float) -> Generator[Tuple[str, List[List[str]]], None, None]:
-    """Función principal para la interfaz de chat con streaming"""
-
-    if not message.strip():
-        yield "", history
-        return
-
-    # Generar respuesta con streaming
-    partial_response = ""
-    for token in generate_stream(message, history, max_tokens, temperature, top_p):
-        partial_response = token
-        # Actualizar historial con respuesta parcial
-        new_history = history + [[message, partial_response]]
-        yield "", new_history
-
-# Función para API endpoint
-def api_generate(message: str, max_tokens: int = 512, temperature: float = 0.7, 
-                top_p: float = 0.9, stream: bool = True) -> dict:
-    """Endpoint de API para generar respuestas"""
-
-    if stream:
-        # Para streaming, devolver generator
-        def generate():
-            for partial in generate_stream(message, None, max_tokens, temperature, top_p):
-                yield f"data: {json.dumps({'text': partial, 'finished': False})}\n\n"
-            yield f"data: {json.dumps({'text': '', 'finished': True})}\n\n"
-        return generate()
-    else:
-        # Para respuesta completa
-        full_response = ""
-        for partial in generate_stream(message, None, max_tokens, temperature, top_p):
-            full_response = partial
-        return {"text": full_response, "finished": True}
-
-# Cargar modelo al iniciar
-print("Cargando modelo Llama 3.2-3B...")
-load_model()
-print("Modelo cargado exitosamente!")
-
-# Crear interfaz Gradio
-with gr.Blocks(
-    title="Llama 3.2-3B Server",
-    theme=gr.themes.Soft(),
-    css="""
-    .gradio-container {
-        max-width: 1000px !important;
+        self.request_queue.put(request)
+
+        # Esperar y streamear respuesta
+        while not response_complete.is_set():
+            try:
+                text, is_complete = response_queue.get(timeout=0.1)
+                yield text, is_complete
+                if is_complete:
+                    break
+            except queue.Empty:
+                # Si no hay nuevos tokens, yield el último estado
+                if current_response[0]:
+                    yield current_response[0], False
+                continue
+
+    def get_queue_status(self) -> Dict[str, any]:
+        """Obtener estado de la cola"""
+        return {
+            "queue_size": self.request_queue.qsize(),
+            "is_processing": self.is_processing,
+            "timestamp": datetime.now().isoformat()
+        }
+
+# Inicializar el chat
+chat_instance = LlamaChat()
+
+# Función para la interfaz de Gradio
+def chat_interface(message: str, history: List[List[str]], system_prompt: str, 
+                  max_tokens: int, temperature: float):
+    """Interfaz de chat para Gradio"""
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        if not is_complete:
+            # Para Gradio, necesitamos devolver el historial completo
+            new_history = history + [[message, response]]
+            yield new_history, ""
+        else:
+            final_history = history + [[message, response]]
+            yield final_history, ""
+
+# Función para API Python
+def api_chat(system_prompt: str = "", message: str = "", history: List[List[str]] = None, 
+            max_tokens: int = 512, temperature: float = 0.7) -> Dict:
+    """API para cliente Python"""
+    if history is None:
+        history = []
+
+    full_response = ""
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        full_response = response
+        if is_complete:
+            break
+
+    return {
+        "response": full_response,
+        "queue_status": chat_instance.get_queue_status()
     }
-    """
-) as demo:
 
-    gr.Markdown("""
-    # 🦙 Llama 3.2-3B Instruct Server
+# Función para streaming API
+def api_chat_stream(system_prompt: str = "", message: str = "", history: List[List[str]] = None,
+                   max_tokens: int = 512, temperature: float = 0.7):
+    """API streaming para cliente Python"""
+    if history is None:
+        history = []
+
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        yield {
+            "response": response,
+            "is_complete": is_complete,
+            "queue_status": chat_instance.get_queue_status()
+        }
 
-    Servidor gratuito con streaming y API para integración con Flutter
-    """)
+# Crear interfaz de Gradio
+with gr.Blocks(title="Llama 3.2 3B Chat", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🦙 Llama 3.2 3B Instruct Chat")
+    gr.Markdown("Chat con Meta Llama 3.2 3B con sistema de colas y streaming")
 
     with gr.Row():
         with gr.Column(scale=3):
-            chatbot = gr.Chatbot(
-                height=500,
-                show_label=False,
-                container=False,
-                bubble_full_width=False
-            )
-
+            chatbot = gr.Chatbot(height=500, show_label=False)
             msg = gr.Textbox(
+                label="Mensaje",
                 placeholder="Escribe tu mensaje aquí...",
-                show_label=False,
-                container=False,
-                scale=7
+                lines=2
             )
 
             with gr.Row():
-                submit_btn = gr.Button("Enviar", variant="primary", scale=2)
-                clear_btn = gr.Button("Limpiar", scale=1)
+                send_btn = gr.Button("Enviar", variant="primary")
+                clear_btn = gr.Button("Limpiar")
 
         with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Configuración")
+            system_prompt = gr.Textbox(
+                label="System Prompt",
+                placeholder="Eres un asistente útil...",
+                lines=5,
+                value="Eres un asistente de IA útil y amigable. Responde de manera clara y concisa."
+            )
 
             max_tokens = gr.Slider(
                 minimum=50,
                 maximum=1024,
                 value=512,
                 step=50,
-                label="Máximo tokens"
+                label="Max Tokens"
             )
 
             temperature = gr.Slider(
                 minimum=0.1,
-                maximum=1.0,
+                maximum=2.0,
                 value=0.7,
                 step=0.1,
-                label="Temperatura"
+                label="Temperature"
             )
 
-            top_p = gr.Slider(
-                minimum=0.1,
-                maximum=1.0,
-                value=0.9,
-                step=0.1,
-                label="Top-p"
-            )
+            gr.Markdown("### Estado de la Cola")
+            queue_status = gr.JSON(label="Queue Status", value={})
 
-            gr.Markdown("""
-            ### 🔗 API Usage
-
-            **Endpoint:** `/api/generate`
-
-            **Parámetros:**
-            - `message`: Mensaje de entrada
-            - `max_tokens`: Máximo tokens (50-1024)
-            - `temperature`: Creatividad (0.1-1.0)
-            - `top_p`: Diversidad (0.1-1.0)
-            - `stream`: true/false para streaming
-
-            **Ejemplo Flutter:**
-            ```dart
-            final response = await dio.post(
-              'https://tu-space.hf.space/api/generate',
-              data: {
-                'message': 'Hola',
-                'stream': true
-              }
-            );
-            ```
-            """)
-
-    # Eventos
-    msg.submit(
-        chat_interface,
-        inputs=[msg, chatbot, max_tokens, temperature, top_p],
-        outputs=[msg, chatbot],
-        queue=True
-    )
+            # Botón para actualizar estado
+            refresh_btn = gr.Button("Actualizar Estado")
 
-    submit_btn.click(
-        chat_interface,
-        inputs=[msg, chatbot, max_tokens, temperature, top_p],
-        outputs=[msg, chatbot],
-        queue=True
-    )
+    # Event handlers
+    def send_message(message, history, sys_prompt, max_tok, temp):
+        if not message.strip():
+            return history, ""
 
-    clear_btn.click(
-        lambda: ([], ""),
-        outputs=[chatbot, msg],
-        queue=False
-    )
+        yield from chat_interface(message, history, sys_prompt, max_tok, temp)
 
-# Configurar la cola con límites para el tier gratuito y api abierta
-# Línea 272 corregida
-demo.queue(default_concurrency_limit=1, max_size=10, api_open=True)
+    def clear_chat():
+        return [], ""
 
+    def update_queue_status():
+        return chat_instance.get_queue_status()
 
+    # Conectar eventos
+    send_btn.click(
+        send_message,
+        inputs=[msg, chatbot, system_prompt, max_tokens, temperature],
+        outputs=[chatbot, msg]
+    )
 
+    msg.submit(
+        send_message,
+        inputs=[msg, chatbot, system_prompt, max_tokens, temperature],
+        outputs=[chatbot, msg]
+    )
 
-# Agregar endpoint personalizado para API usando gr.api()
-with demo:
-    gr.api(api_generate, api_name="generate")
+    clear_btn.click(clear_chat, outputs=[chatbot, msg])
+    refresh_btn.click(update_queue_status, outputs=[queue_status])
+
+    # Actualizar estado cada 5 segundos
+    app.load(update_queue_status, outputs=[queue_status], every=5)
+
+# Crear API endpoints
+api_app = gr.Interface(
+    fn=api_chat,
+    inputs=[
+        gr.Textbox(label="System Prompt"),
+        gr.Textbox(label="Message"),
+        gr.JSON(label="History"),
+        gr.Slider(50, 1024, 512, label="Max Tokens"),
+        gr.Slider(0.1, 2.0, 0.7, label="Temperature")
+    ],
+    outputs=gr.JSON(label="Response"),
+    title="Llama Chat API",
+    description="API endpoint para cliente Python"
+)
+
+# Combinar apps
+final_app = gr.TabbedInterface(
+    [app, api_app],
+    ["💬 Chat Interface", "🔌 API Endpoint"]
+)
 
-    
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        quiet=False,
-        mcp_server=True
-    )
+    final_app.launch(server_name="0.0.0.0", server_port=7860, share=True)

apuntes-filosofia-antigua-completos.md

@@ -1,417 +0,0 @@
-# FILOSOFÍA ANTIGUA - APUNTES COMPLETOS Y ORGANIZADOS
-
-## 1. INTRODUCCIÓN AL RELATIVISMO Y EL CONOCIMIENTO
-
-### Relativismo Cultural
-El **relativismo cultural** establece que los resultados del conocimiento humano son convencionales, no universales[11][13]. Este concepto fundamental distingue entre:
-- **Conocimiento aparente**: Lo que percibimos a través de los sentidos
-- **Conocimiento real**: La verdadera realidad que trasciende las apariencias
-
-### La Dialéctica como Método
-La **dialéctica** constituye el método de búsqueda de definiciones a través del diálogo estructurado[11]. Su objetivo principal es alcanzar la verdad mediante la confrontación de ideas opuestas.
-
----
-
-## 2. SÓCRATES (470-399 a.C.)
-
-### Contexto Histórico
-Sócrates vivió en Atenas durante la época dorada de los sofistas[13][17]. Fue **condenado a muerte** por dos acusaciones principales:
-- Corromper a los jóvenes
-- Introducir nuevos dioses en la ciudad
-
-### Filosofía Socrática
-
-#### El Método Dialéctico
-Sócrates desarrolló un revolucionario **método dialéctico** conocido como **elenchus** (ἔλεγχος)[11][17]:
-
-1. **Establecimiento de tesis**: Un interlocutor presenta una afirmación
-2. **Cuestionamiento**: Sócrates introduce premisas adicionales 
-3. **Demostración de contradicciones**: Se muestra que las premisas implican lo contrario de la tesis original
-4. **Refutación**: Se demuestra la falsedad de la tesis inicial
-
-#### Principios Fundamentales
-
-**Ironía Socrática**: "Solo sé que no sé nada"[17][26]
-- Reconocimiento de la propia ignorancia como punto de partida del conocimiento
-- Método para hacer que el interlocutor reconozca su ignorancia
-
-**Mayéutica**: El arte de "dar a luz" ideas[17][26]
-- Proceso de ayudar al interlocutor a descubrir verdades por sí mismo
-- Sócrates se comparaba con una partera que ayuda en el parto del conocimiento
-
-**Intelectualismo Moral**: El conocimiento de la realidad conduce necesariamente a la virtud[11][17]
-- Quien conoce verdaderamente el bien, actúa bien
-- La maldad surge de la ignorancia
-
----
-
-## 3. LOS SOFISTAS: PROTÁGORAS Y GORGIAS
-
-### Características Generales de los Sofistas
-Los sofistas eran **maestros itinerantes** que cobraban por sus enseñanzas[13][16]:
-- Ciudadanos extranjeros que enseñaban en Atenas
-- Especialistas en retórica y arte de la persuasión
-- Promovían la igualdad como principio pedagógico[28]
-
-### Diferencias Fundamentales con Sócrates
-| Aspecto | Sócrates | Sofistas |
-|---------|----------|----------|
-| **Objetivo** | Búsqueda de la verdad absoluta | Persuasión y éxito práctico |
-| **Método** | Dialéctica para alcanzar conocimiento | Retórica para convencer |
-| **Epistemología** | Existe verdad objetiva | Relativismo: no hay verdades absolutas |
-| **Enseñanza** | Gratuita, por amor a la sabiduría | De pago, profesionalizada |
-
-### Protágoras de Abdera (485-411 a.C.)
-
-#### Relativismo Antropológico
-**Frase célebre**: *"El hombre es la medida de todas las cosas, de las que son en cuanto que son y de las que no son en cuanto que no son"*[13][16][22][25]
-
-**Interpretación**:
-- El conocimiento es relativo al individuo o comunidad que conoce
-- No existen verdades absolutas independientes del sujeto cognoscente
-- Las valoraciones éticas y estéticas dependen de la perspectiva humana
-
-#### Teoría del Nomos vs. Physis
-- **Nomos** (ley humana): Convención social modificable según intereses comunitarios
-- **Physis** (ley natural): Ley universal e inmutable de los presocráticos
-- Protágoras defendía que el nomos complementa y beneficia a la naturaleza[25]
-
-### Gorgias de Leontinos
-
-#### Las Tres Tesis Fundamentales
-Gorgias defendía un **relativismo radical** basado en tres proposiciones[16][25]:
-
-1. **"Nada existe"**: Negación del ser
-2. **"Si algo existiera, sería inconcebible para el hombre"**: Imposibilidad del conocimiento
-3. **"Si fuera concebible, no se podría transmitir o explicar a otros"**: Incomunicabilidad del conocimiento
-
-#### Poder de la Retórica
-Para Gorgias, la **palabra** tiene poder transformador:
-- La retórica puede modificar la realidad percibida
-- El discurso es instrumento de persuasión y elevación moral[28]
-- La habilidad argumentativa es virtud esencial en la democracia
-
----
-
-## 4. PLATÓN: TEORÍA DE LAS IDEAS
-
-### Dualismo Ontológico
-Platón establece una división fundamental de la realidad en **dos mundos**[12][15][18][21]:
-
-#### Mundo Inteligible (Mundo de las Ideas)
-**Características**:
-- **Inmaterial**, eterno, inmutable
-- Accesible solo mediante la **razón**
-- Constituye la **auténtica realidad**
-- Existe fuera del espacio y del tiempo
-- Contiene las **Ideas** como arquetipos perfectos
-
-#### Mundo Sensible (Mundo Visible)
-**Características**:
-- **Material**, temporal, mutable
-- Accesible mediante los **sentidos**
-- Es **copia imperfecta** del mundo inteligible
-- Sujeto a generación y corrupción
-- Solo permite **opinión (doxa)**, no conocimiento verdadero
-
-### El Mito de la Caverna
-
-#### Estructura Alegórica
-La famosa alegoría platónica ilustra el proceso del conocimiento[46][49]:
-
-**Niveles de la Caverna**:
-1. **Sombras en la pared**: Mundo de las apariencias sensibles
-2. **Objetos que proyectan sombras**: Realidades físicas del mundo sensible
-3. **Sol exterior**: La **Idea del Bien**, fuente de todo conocimiento
-
-#### Proceso de la Paideia (Educación)
-El **ascenso desde la caverna** representa:
-- Liberación de la ignorancia sensible
-- Proceso educativo hacia el conocimiento racional
-- Acceso progresivo al mundo de las Ideas
-- Culminación en la contemplación del Bien
-
-### Relación entre los Mundos: Participación e Imitación
-
-#### Participación (Methexis)
-- Las cosas sensibles **participan** de las Ideas
-- Reciben su ser y características de las Ideas correspondientes
-- Relación de dependencia ontológica[18][30]
-
-#### Imitación (Mimesis)
-- El mundo sensible es **copia** del mundo inteligible
-- Las Ideas funcionan como **modelos** o arquetipos
-- La realidad física imita imperfectamente la perfección ideal[18][30]
-
----
-
-## 5. EPISTEMOLOGÍA PLATÓNICA: GRADOS DEL CONOCIMIENTO
-
-### Dualismo Epistemológico
-Platón distingue fundamentalmente entre **dos tipos de conocimiento**[45][48][49]:
-
-- **Doxa (δόχα)**: Opinión o conocimiento sensible del mundo visible
-- **Episteme (ἐπιστήμη)**: Ciencia o conocimiento inteligible del mundo de las Ideas
-
-### El Símil de la Línea
-
-#### División de los Grados de Conocimiento
-Platón representa los niveles de conocimiento mediante una **línea dividida en cuatro segmentos**[48][54][57]:
-
-| **Mundo** | **Tipo de Conocimiento** | **Objeto** | **Facultad** |
-|-----------|-------------------------|------------|--------------|
-| **INTELIGIBLE** | **Noesis (νόησις)** | Ideas, Principios | Intuición intelectual |
-| | **Dianoia (διάνοια)** | Objetos matemáticos | Pensamiento discursivo |
-| **SENSIBLE** | **Pistis (πίστις)** | Objetos físicos | Creencia |
-| | **Eikasia (εἰκασία)** | Sombras, reflejos | Imaginación |
-
-#### Características de cada grado
-
-**1. Eikasia (εἰκασία) - Imaginación**[48][49]:
-- **Grado más bajo** de conocimiento
-- Objeto: sombras, reflejos, imágenes de las cosas sensibles
-- Conocimiento conjetural e inseguro
-- Correspondiente a los prisioneros en la caverna
-
-**2. Pistis (πίστις) - Creencia**[48][49]:
-- Conocimiento de **objetos sensibles** directamente
-- Mayor certeza que la imaginación
-- Actitud libre de titubeo pero no científica
-- Conocimiento del mundo físico cotidiano
-
-**3. Dianoia (διάνοια) - Pensamiento discursivo**[48][51][49]:
-- **Conocimiento matemático** y geométrico
-- Utiliza hipótesis sin justificar racionalmente
-- Se apoya en figuras sensibles para demostrar
-- Razonamiento lógico pero no intuitivo
-
-**4. Noesis (νόησις) - Intuición intelectual**[48][51][49]:
-- **Conocimiento superior** de las Ideas
-- Acceso directo mediante la razón pura
-- No requiere apoyo en imágenes sensibles
-- Conocimiento de principios no hipotéticos
-
-### La Dialéctica como Método Superior
-
-#### Dialéctica Ascendente[48][63]:
-- Proceso de **elevación** desde lo sensible hacia las Ideas
-- Utiliza la razón para superar las limitaciones de los sentidos
-- Búsqueda de principios no hipotéticos
-- Método específico de la filosofía
-
-#### Dialéctica Descendente:
-- **Aplicación** del conocimiento de las Ideas al mundo sensible
-- Comprensión de la realidad empírica desde los principios universales
-- Función pedagógica y política del filósofo
-
-### La Teoría de la Reminiscencia (Anamnesis)
-
-#### Fundamentos de la Anamnesis[49][57]:
-- El **alma es inmortal** y preexiste al cuerpo
-- El alma ha **contemplado las Ideas** antes del nacimiento
-- **Aprender es recordar** lo que el alma ya conocía
-- El conocimiento verdadero surge desde el interior
-
-#### Eros y el Conocimiento:
-- **Eros (amor)** impulsa al alma hacia el conocimiento
-- La **belleza sensible** despierta el recuerdo de la Belleza en sí
-- El amor filosófico conduce hacia las Ideas supremas
-- Proceso de ascensión desde lo particular hacia lo universal
-
----
-
-## 6. ANTROPOLOGÍA PLATÓNICA
-
-### Dualismo Antropológico
-El ser humano participa de ambos mundos:
-- **Cuerpo**: Pertenece al mundo sensible, mortal
-- **Alma**: Pertenece al mundo inteligible, inmortal
-
-### Teoría Tripartita del Alma
-
-#### Estructura del Alma
-1. **Alma Racional (Logos)**:
-   - Sede de la razón y el conocimiento
-   - Localizada en la cabeza
-   - Inmortal, regresa al mundo inteligible tras la muerte
-
-2. **Alma Irascible (Thymos)**:
-   - Sede del valor y las emociones nobles
-   - Localizada en el pecho
-   - Impulsa hacia la acción y la defensa
-
-3. **Alma Concupiscible (Epithymia)**:
-   - Sede de los deseos y apetitos corporales
-   - Localizada en el abdomen
-   - Busca placeres sensibles y satisfacciones materiales
-
-### Teorías del Alma
-
-#### Teoría Soma-Sema
-- **"El cuerpo es la cárcel del alma"**
-- El alma está **aprisionada** en el cuerpo material
-- La filosofía busca la liberación del alma mediante el conocimiento
-
-#### Metempsicosis (Transmigración)
-- El alma es **inmortal** y preexiste al cuerpo
-- Tras la muerte, el alma se reencarna en otros cuerpos
-- El destino del alma depende de la vida filosófica llevada
-
----
-
-## 7. FILOSOFÍA POLÍTICA PLATÓNICA: LA REPÚBLICA IDEAL
-
-### La Polis Justa y las Virtudes
-
-#### Correspondencia Alma-Estado
-Platón establece un **paralelismo** entre la estructura del alma individual y la organización del Estado ideal[47][50][56]:
-
-| **Parte del Alma** | **Virtud Individual** | **Clase Social** | **Virtud Política** | **Función** |
-|-------------------|---------------------|------------------|-------------------|-------------|
-| **Racional** | Sabiduría (Sophia) | Filósofos-Reyes | Sabiduría | Gobernar |
-| **Irascible** | Fortaleza (Andreia) | Guardianes | Valor | Defender |
-| **Concupiscible** | Templanza (Sophrosyne) | Productores | Templanza | Producir |
-
-#### La Justicia como Armonía
-- **Justicia individual**: Cada parte del alma cumple su función propia
-- **Justicia política**: Cada clase social desempeña su rol específico
-- **Armonía**: Resultado del equilibrio entre las partes
-- **Virtud = Función**: Cada elemento alcanza la excelencia en su ámbito
-
-### El Filósofo-Rey
-
-#### Características del Gobernante Ideal[44][47][56]:
-- **Conocimiento de la Idea del Bien**: Única fuente de legitimidad para gobernar
-- **Educación especializada**: Formación en matemáticas, dialéctica y filosofía
-- **Desinterés material**: Libre de ambiciones personales y posesiones
-- **Amor a la sabiduría**: Motivación genuina por el conocimiento de la verdad
-
-#### Justificación del Gobierno Filosófico[47][59]:
-1. **Argumento epistemológico**: Solo el filósofo conoce objetivamente el Bien
-2. **Argumento moral**: El conocimiento del bien implica su práctica
-3. **Argumento técnico**: Gobernar es un arte que requiere conocimiento especializado
-4. **Argumento de eficiencia**: El filósofo logra la armonía del conjunto
-
-### Sistema Educativo (Paideia)
-
-#### Educación por Estamentos:
-- **Educación común**: Base compartida para todos los ciudadanos
-- **Selección progresiva**: Identificación de aptitudes naturales según el alma dominante
-- **Especialización**: Formación específica según la función social destinada
-
-#### Contenido Educativo:
-- **Productores**: Artes y oficios técnicos, educación básica
-- **Guardianes**: Educación física, musical y militar
-- **Filósofos-Reyes**: Matemáticas, dialéctica, filosofía (hasta los 50 años)
-
-#### Restricciones Educativas:
-- **Censura poética**: Los poetas pueden crear confusión moral en los guardianes
-- **Control de contenidos**: Solo se enseña lo que promueve la virtud y el orden
-- **Filosofía reservada**: Solo los mejores acceden al conocimiento supremo
-
-### Degeneración de los Regímenes Políticos
-
-#### Secuencia de Decadencia según Platón[56][59]:
-
-1. **ARISTOCRACIA** (Gobierno ideal):
-   - Gobierno de los mejores (filósofos)
-   - Basado en el conocimiento y la virtud
-   - Justicia y armonía social perfectas
-
-2. **TIMOCRACIA**:
-   - Gobierno basado en el **honor** y la ambición
-   - Dominan los guardianes (parte irascible)
-   - Búsqueda de gloria militar y reconocimiento
-
-3. **OLIGARQUÍA**:
-   - Gobierno de los **ricos** (pocos)
-   - Motivado por la acumulación de riquezas
-   - División social entre ricos y pobres
-
-4. **DEMOCRACIA**:
-   - Gobierno de la **mayoría** 
-   - Libertad excesiva y relativismo moral
-   - Ausencia de criterios objetivos de valor
-
-5. **TIRANÍA**:
-   - Gobierno de **uno** sin límites legales
-   - Peor forma de gobierno posible
-   - Dominación total de los apetitos descontrolados
-
-### El Estado de las Leyes
-
-#### Evolución del Pensamiento Político Platónico[56][59]:
-- En **"Las Leyes"** (obra tardía), Platón adopta una perspectiva más pragmática
-- Reconoce la dificultad de encontrar verdaderos filósofos-reyes
-- Propone un **"segundo Estado"** basado en el imperio de la ley
-- **Gobierno mixto**: Combinación de elementos monárquicos y democráticos
-
----
-
-## 8. ONTOLOGÍA PLATÓNICA: LA TEORÍA DE LAS IDEAS
-
-### Naturaleza de las Ideas (Eidos)
-
-#### Características Fundamentales
-- **Únicas**: Cada Idea es singular y no admite multiplicidad
-- **Eternas**: Existen fuera del tiempo, sin generación ni corrupción
-- **Inmutables**: No cambian ni se alteran
-- **Universales**: Se aplican a múltiples casos particulares
-- **Perfectas**: Representan la máxima perfección de cada concepto
-
-#### Tipos de Ideas
-
-**Ideas de Valores Morales y Estéticos**:
-- Justicia, Belleza, Bondad
-- Proporcionan criterios normativos absolutos
-
-**Ideas de Realidades Naturales**:
-- Hombre en sí, Caballo en sí, Mesa en sí
-- Arquetipos de las especies y objetos del mundo sensible
-
-**Ideas Matemáticas**:
-- Números, figuras geométricas perfectas
-- Fundamento de la ciencia matemática
-
-#### La Idea del Bien
-**Supremacía ontológica y epistemológica**:
-- **Idea suprema** que da valor y realidad a las demás Ideas
-- **Fuente de conocimiento**: Permite conocer las otras Ideas
-- **Fundamento del ser**: Confiere existencia al mundo inteligible
-- **Sol del mundo inteligible**: Ilumina y hace posible el conocimiento racional
-
-### Relación de las Ideas con el Conocimiento
-
-#### Epistemología Platónica
-- **Episteme** (conocimiento verdadero): Solo del mundo inteligible
-- **Doxa** (opinión): Conocimiento imperfecto del mundo sensible
-- La **dialéctica** es el método para ascender al conocimiento de las Ideas
-
-#### Características del Dualismo Ontológico
-
-| **Mundo Inteligible** | **Mundo Sensible** |
-|----------------------|-------------------|
-| Eterno, inmutable | Temporal, mutable |
-| Universal | Particular |
-| Inmaterial | Material |
-| Auténtica realidad | Copia, apariencia |
-| Conocimiento (episteme) | Opinión (doxa) |
-| Acceso por la razón | Acceso por los sentidos |
-| Necesario | Contingente |
-| Inmóvil | Móvil |
-
----
-
-## CONCLUSIÓN: LEGADO DE LA FILOSOFÍA ANTIGUA
-
-La filosofía antigua establece los fundamentos conceptuales que perduran hasta nuestros días. **Sócrates** introduce el método dialéctico como búsqueda rigurosa de la verdad, oponiéndose al relativismo sofístico. **Los sofistas** aportan la reflexión sobre el poder del lenguaje y la relatividad cultural del conocimiento. **Platón** construye el primer gran sistema metafísico occidental, estableciendo las bases de:
-
-### Contribuciones Fundamentales:
-
-1. **Epistemológicas**: La distinción entre conocimiento verdadero (episteme) y opinión (doxa)
-2. **Ontológicas**: El dualismo entre mundo inteligible e mundo sensible
-3. **Políticas**: La teoría del Estado ideal y la figura del filósofo-rey
-4. **Antropológicas**: La concepción tripartita del alma y su inmortalidad
-5. **Metodológicas**: La dialéctica como método de acceso a la verdad
-
-Este desarrollo intelectual marca el paso del pensamiento mítico al racional, estableciendo las bases de la epistemología, la ética, la política y la metafísica como disciplinas filosóficas autónomas. La influencia de estos conceptos se extiende a través de toda la historia de la filosofía occidental, desde el neoplatonismo hasta la filosofía contemporánea.

client.py

@@ -0,0 +1,167 @@
+
+import requests
+import json
+import time
+from typing import List, Dict, Generator, Optional
+
+class LlamaClient:
+    def __init__(self, base_url: str):
+        """
+        Cliente para interactuar con el Hugging Face Space de Llama Chat
+
+        Args:
+            base_url: URL base del Space (ej: "https://tu-usuario-llama-chat.hf.space")
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_endpoint = f"{self.base_url}/call/api_chat"
+        self.stream_endpoint = f"{self.base_url}/call/api_chat_stream"
+
+    def chat(self, message: str, system_prompt: str = "", history: List[List[str]] = None,
+             max_tokens: int = 512, temperature: float = 0.7) -> Dict:
+        """
+        Enviar un mensaje y recibir respuesta completa
+
+        Args:
+            message: Mensaje del usuario
+            system_prompt: Prompt del sistema (opcional)
+            history: Historial de conversación [[user, assistant], ...]
+            max_tokens: Máximo número de tokens a generar
+            temperature: Temperatura para la generación
+
+        Returns:
+            Dict con 'response' y 'queue_status'
+        """
+        if history is None:
+            history = []
+
+        payload = {
+            "data": [system_prompt, message, history, max_tokens, temperature]
+        }
+
+        try:
+            response = requests.post(self.api_endpoint, json=payload, timeout=300)
+            response.raise_for_status()
+
+            result = response.json()
+            return result.get("data", [{}])[0]
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Error de conexión: {str(e)}"}
+        except json.JSONDecodeError as e:
+            return {"error": f"Error decodificando JSON: {str(e)}"}
+
+    def chat_stream(self, message: str, system_prompt: str = "", history: List[List[str]] = None,
+                   max_tokens: int = 512, temperature: float = 0.7) -> Generator[Dict, None, None]:
+        """
+        Enviar un mensaje y recibir respuesta en streaming
+
+        Args:
+            message: Mensaje del usuario
+            system_prompt: Prompt del sistema (opcional)
+            history: Historial de conversación
+            max_tokens: Máximo número de tokens a generar
+            temperature: Temperatura para la generación
+
+        Yields:
+            Dict con 'response', 'is_complete' y 'queue_status'
+        """
+        if history is None:
+            history = []
+
+        payload = {
+            "data": [system_prompt, message, history, max_tokens, temperature]
+        }
+
+        try:
+            response = requests.post(self.stream_endpoint, json=payload, stream=True, timeout=300)
+            response.raise_for_status()
+
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        data = json.loads(line.decode('utf-8'))
+                        if "data" in data:
+                            yield data["data"][0]
+                    except json.JSONDecodeError:
+                        continue
+
+        except requests.exceptions.RequestException as e:
+            yield {"error": f"Error de conexión: {str(e)}", "is_complete": True}
+
+    def get_queue_status(self) -> Dict:
+        """
+        Obtener estado actual de la cola
+
+        Returns:
+            Dict con información del estado de la cola
+        """
+        try:
+            # Hacer una request vacía solo para obtener el estado
+            result = self.chat("", max_tokens=1)
+            return result.get("queue_status", {})
+        except Exception as e:
+            return {"error": str(e)}
+
+# Ejemplo de uso del cliente
+def example_usage():
+    """Ejemplo de cómo usar el cliente"""
+
+    # Inicializar cliente (reemplaza con tu URL del Space)
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+    print("=== Ejemplo 1: Chat simple ===")
+    response = client.chat(
+        message="¿Qué es la inteligencia artificial?",
+        system_prompt="Eres un profesor de informática experto."
+    )
+
+    if "error" in response:
+        print(f"Error: {response['error']}")
+    else:
+        print(f"Respuesta: {response['response']}")
+        print(f"Estado cola: {response['queue_status']}")
+
+    print("\n=== Ejemplo 2: Chat con historial ===")
+    history = [
+        ["Hola", "¡Hola! ¿En qué puedo ayudarte?"],
+        ["¿Cuál es tu nombre?", "Soy un asistente de IA basado en Llama 3.2."]
+    ]
+
+    response = client.chat(
+        message="¿Puedes explicarme conceptos de física?",
+        system_prompt="Eres un tutor de física para estudiantes de bachillerato.",
+        history=history
+    )
+
+    if "error" in response:
+        print(f"Error: {response['error']}")
+    else:
+        print(f"Respuesta: {response['response']}")
+
+    print("\n=== Ejemplo 3: Chat con streaming ===")
+    print("Pregunta: Explica la teoría de la relatividad")
+    print("Respuesta (streaming):")
+
+    for chunk in client.chat_stream(
+        message="Explica la teoría de la relatividad de forma simple",
+        system_prompt="Eres un divulgador científico.",
+        max_tokens=300,
+        temperature=0.8
+    ):
+        if "error" in chunk:
+            print(f"Error: {chunk['error']}")
+            break
+
+        print(f"\r{chunk['response']}", end="", flush=True)
+
+        if chunk.get("is_complete", False):
+            print("\n[Respuesta completa]")
+            print(f"Estado cola: {chunk['queue_status']}")
+            break
+
+    print("\n=== Ejemplo 4: Verificar estado de cola ===")
+    status = client.get_queue_status()
+    print(f"Estado actual: {status}")
+
+if __name__ == "__main__":
+    example_usage()

config.py

@@ -0,0 +1,83 @@
+# config.py - Configuración del Space
+
+import os
+
+class Config:
+    """Configuración centralizada para el Space"""
+
+    # Modelo
+    MODEL_NAME = "meta-llama/Llama-3.2-3B-Instruct"
+    DEVICE = "cuda" if os.environ.get("SPACES_GPU") else "cpu"
+
+    # Tokens y autenticación
+    HF_TOKEN = os.environ.get("HF_TOKEN")
+
+    # Límites de generación
+    MAX_TOKENS_LIMIT = 1024
+    MIN_TOKENS_LIMIT = 50
+    DEFAULT_MAX_TOKENS = 512
+
+    # Temperatura
+    MAX_TEMPERATURE = 2.0
+    MIN_TEMPERATURE = 0.1
+    DEFAULT_TEMPERATURE = 0.7
+
+    # Cola y concurrencia
+    MAX_QUEUE_SIZE = 10
+    QUEUE_TIMEOUT = 300  # 5 minutos
+
+    # Context length
+    MAX_CONTEXT_LENGTH = 2048
+
+    # Interface
+    CHAT_HEIGHT = 500
+    DEFAULT_SYSTEM_PROMPT = "Eres un asistente de IA útil y amigable. Responde de manera clara y concisa."
+
+    # API
+    API_TIMEOUT = 300
+    ENABLE_API_LOGGING = True
+
+    @classmethod
+    def validate(cls):
+        """Validar configuración"""
+        errors = []
+
+        if not cls.HF_TOKEN:
+            errors.append("HF_TOKEN no configurado en variables de entorno")
+
+        if cls.MAX_TOKENS_LIMIT < cls.MIN_TOKENS_LIMIT:
+            errors.append("MAX_TOKENS_LIMIT debe ser mayor que MIN_TOKENS_LIMIT")
+
+        if cls.MAX_TEMPERATURE < cls.MIN_TEMPERATURE:
+            errors.append("MAX_TEMPERATURE debe ser mayor que MIN_TEMPERATURE")
+
+        return errors
+
+    @classmethod
+    def get_model_config(cls):
+        """Configuración específica del modelo"""
+        return {
+            "torch_dtype": "float16" if cls.DEVICE == "cuda" else "float32",
+            "device_map": "auto" if cls.DEVICE == "cuda" else None,
+            "trust_remote_code": True,
+            "token": cls.HF_TOKEN
+        }
+
+    @classmethod
+    def get_generation_config(cls, max_tokens=None, temperature=None):
+        """Configuración de generación"""
+        return {
+            "max_new_tokens": max_tokens or cls.DEFAULT_MAX_TOKENS,
+            "temperature": temperature or cls.DEFAULT_TEMPERATURE,
+            "do_sample": True,
+            "repetition_penalty": 1.1,
+            "top_p": 0.9,
+            "top_k": 50
+        }
+
+# Validar configuración al importar
+config_errors = Config.validate()
+if config_errors:
+    print("⚠️ Errores de configuración:")
+    for error in config_errors:
+        print(f"  - {error}")

examples.py

@@ -0,0 +1,339 @@
+# examples.py - Ejemplos avanzados de uso del cliente
+
+from client import LlamaClient
+import asyncio
+import time
+from typing import List
+import json
+
+class AdvancedLlamaClient:
+    """Cliente extendido con funcionalidades avanzadas"""
+
+    def __init__(self, base_url: str):
+        self.client = LlamaClient(base_url)
+        self.conversation_history = []
+
+    def continuous_chat(self):
+        """Chat interactivo continuo"""
+        print("🦙 Chat con Llama 3.2 3B - Escribe 'salir' para terminar")
+        print("=" * 50)
+
+        system_prompt = input("System prompt (opcional): ").strip()
+        if not system_prompt:
+            system_prompt = "Eres un asistente útil y amigable."
+
+        while True:
+            try:
+                message = input("\nTú: ").strip()
+
+                if message.lower() in ['salir', 'exit', 'quit']:
+                    print("¡Hasta luego! 👋")
+                    break
+
+                if not message:
+                    continue
+
+                print("🦙: ", end="", flush=True)
+                full_response = ""
+
+                for chunk in self.client.chat_stream(
+                    message=message,
+                    system_prompt=system_prompt,
+                    history=self.conversation_history,
+                    max_tokens=512,
+                    temperature=0.7
+                ):
+                    if "error" in chunk:
+                        print(f"Error: {chunk['error']}")
+                        break
+
+                    # Mostrar solo el texto nuevo
+                    new_text = chunk['response'][len(full_response):]
+                    print(new_text, end="", flush=True)
+                    full_response = chunk['response']
+
+                    if chunk.get("is_complete", False):
+                        print()  # Nueva línea al final
+                        break
+
+                # Agregar al historial
+                if full_response and not full_response.startswith("Error:"):
+                    self.conversation_history.append([message, full_response])
+
+                    # Limitar historial a 10 intercambios
+                    if len(self.conversation_history) > 10:
+                        self.conversation_history = self.conversation_history[-10:]
+
+            except KeyboardInterrupt:
+                print("\n\n¡Hasta luego! 👋")
+                break
+            except Exception as e:
+                print(f"\nError inesperado: {e}")
+
+    def batch_questions(self, questions: List[str], system_prompt: str = ""):
+        """Procesar múltiples preguntas en lote"""
+        print(f"Procesando {len(questions)} preguntas...")
+        results = []
+
+        for i, question in enumerate(questions, 1):
+            print(f"\nPregunta {i}/{len(questions)}: {question}")
+            print("-" * 40)
+
+            response = self.client.chat(
+                message=question,
+                system_prompt=system_prompt,
+                max_tokens=300
+            )
+
+            if "error" in response:
+                print(f"Error: {response['error']}")
+                results.append({"question": question, "error": response['error']})
+            else:
+                print(f"Respuesta: {response['response']}")
+                results.append({
+                    "question": question,
+                    "response": response['response'],
+                    "queue_status": response['queue_status']
+                })
+
+            # Pequeña pausa entre preguntas
+            time.sleep(1)
+
+        return results
+
+    def compare_temperatures(self, message: str, temperatures: List[float] = [0.3, 0.7, 1.2]):
+        """Comparar respuestas con diferentes temperaturas"""
+        print(f"Comparando respuestas para: '{message}'")
+        print("=" * 60)
+
+        results = {}
+
+        for temp in temperatures:
+            print(f"\n🌡️ Temperature: {temp}")
+            print("-" * 30)
+
+            response = self.client.chat(
+                message=message,
+                temperature=temp,
+                max_tokens=200
+            )
+
+            if "error" in response:
+                print(f"Error: {response['error']}")
+                results[temp] = {"error": response['error']}
+            else:
+                print(response['response'])
+                results[temp] = {"response": response['response']}
+
+        return results
+
+    def roleplay_scenario(self, scenario: str, turns: int = 5):
+        """Escenario de roleplay interactivo"""
+        print(f"🎭 Escenario: {scenario}")
+        print("=" * 50)
+
+        system_prompt = f"Actúa como {scenario}. Mantén el rol consistentemente y responde de manera inmersiva."
+        history = []
+
+        for turn in range(turns):
+            user_input = input(f"\nTurno {turn + 1} - Tú: ").strip()
+
+            if not user_input or user_input.lower() == 'salir':
+                break
+
+            print("🎭: ", end="", flush=True)
+
+            for chunk in self.client.chat_stream(
+                message=user_input,
+                system_prompt=system_prompt,
+                history=history,
+                temperature=0.8,
+                max_tokens=300
+            ):
+                if "error" in chunk:
+                    print(f"Error: {chunk['error']}")
+                    break
+
+                print(f"\r🎭: {chunk['response']}", end="", flush=True)
+
+                if chunk.get("is_complete", False):
+                    history.append([user_input, chunk['response']])
+                    print()
+                    break
+
+        return history
+
+def academic_tutor_example():
+    """Ejemplo: Tutor académico para física"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+    system_prompt = """Eres un tutor de física especializado en bachillerato español. 
+    Explicas conceptos de forma clara, usas ejemplos cotidianos y siempre verificas 
+    que el estudiante entienda antes de avanzar. Puedes resolver problemas paso a paso."""
+
+    physics_questions = [
+        "¿Qué es la velocidad angular y cómo se relaciona con la velocidad lineal?",
+        "Explica el principio de conservación de la energía con un ejemplo",
+        "¿Cómo funciona el efecto Doppler?",
+        "Diferencia entre masa y peso físicamente"
+    ]
+
+    print("🔬 Tutor de Física - Bachillerato")
+    print("=" * 40)
+
+    for question in physics_questions:
+        print(f"\n📚 Pregunta: {question}")
+        print("-" * 50)
+
+        full_response = ""
+        for chunk in client.chat_stream(
+            message=question,
+            system_prompt=system_prompt,
+            max_tokens=400,
+            temperature=0.6
+        ):
+            if "error" in chunk:
+                print(f"Error: {chunk['error']}")
+                break
+
+            print(f"\r👨‍🏫: {chunk['response']}", end="", flush=True)
+            full_response = chunk['response']
+
+            if chunk.get("is_complete", False):
+                print("\n")
+                break
+
+        input("Presiona Enter para la siguiente pregunta...")
+
+def programming_assistant_example():
+    """Ejemplo: Asistente de programación"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+    system_prompt = """Eres un desarrollador senior especializado en Python y Flutter. 
+    Ayudas a estudiantes con código, debugging y mejores prácticas. Siempre explicas 
+    el código línea por línea y sugieres mejoras."""
+
+    code_questions = [
+        "¿Cómo implementar un patrón Singleton en Python?",
+        "Explica la diferencia entre async/await y threading",
+        "¿Cómo manejo errores de API en Flutter?",
+        "Mejores prácticas para estructurar un proyecto Flutter"
+    ]
+
+    print("💻 Asistente de Programación")
+    print("=" * 35)
+
+    for question in code_questions:
+        print(f"\n🤔 {question}")
+        print("-" * 60)
+
+        response = client.chat(
+            message=question,
+            system_prompt=system_prompt,
+            max_tokens=600,
+            temperature=0.4  # Menor temperatura para código
+        )
+
+        if "error" in response:
+            print(f"❌ Error: {response['error']}")
+        else:
+            print(f"💡 {response['response']}")
+
+        print("\n" + "="*60)
+        time.sleep(2)
+
+def creative_writing_example():
+    """Ejemplo: Escritura creativa colaborativa"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+    system_prompt = """Eres un escritor creativo experto. Ayudas a desarrollar historias, 
+    personajes y narrativas. Puedes continuar historias, sugerir tramas y crear diálogos 
+    naturales. Eres imaginativo pero coherente."""
+
+    print("✍️ Escritura Creativa Colaborativa")
+    print("=" * 40)
+
+    story_start = input("Escribe el inicio de una historia (2-3 líneas): ")
+
+    current_story = story_start
+    history = []
+
+    for chapter in range(3):
+        print(f"\n📖 Capítulo {chapter + 1}")
+        print("-" * 30)
+
+        prompt = f"Continúa esta historia de manera creativa e interesante:\n\n{current_story}"
+
+        print("✨ Continuando la historia...")
+        continuation = ""
+
+        for chunk in client.chat_stream(
+            message=prompt,
+            system_prompt=system_prompt,
+            history=history,
+            max_tokens=400,
+            temperature=1.0  # Alta creatividad
+        ):
+            if "error" in chunk:
+                print(f"Error: {chunk['error']}")
+                break
+
+            continuation = chunk['response']
+            print(f"\r{continuation}", end="", flush=True)
+
+            if chunk.get("is_complete", False):
+                print("\n")
+                break
+
+        current_story += "\n\n" + continuation
+        history.append([prompt, continuation])
+
+        # Opción de dirigir la historia
+        direction = input("\n¿Quieres sugerir una dirección para la historia? (opcional): ")
+        if direction.strip():
+            current_story += "\n\n[Dirección sugerida: " + direction + "]"
+
+    print("\n📚 Historia completa:")
+    print("=" * 50)
+    print(current_story)
+
+def main():
+    """Menú principal de ejemplos"""
+    examples = {
+        "1": ("Chat Continuo", lambda: AdvancedLlamaClient("https://tu-usuario-llama-chat.hf.space").continuous_chat()),
+        "2": ("Tutor de Física", academic_tutor_example),
+        "3": ("Asistente de Programación", programming_assistant_example),
+        "4": ("Escritura Creativa", creative_writing_example),
+        "5": ("Comparar Temperaturas", lambda: AdvancedLlamaClient("https://tu-usuario-llama-chat.hf.space").compare_temperatures(
+            "Explica la inteligencia artificial", [0.3, 0.7, 1.2]
+        )),
+    }
+
+    print("🦙 Ejemplos Avanzados - Llama 3.2 Chat")
+    print("=" * 45)
+    print("IMPORTANTE: Cambia la URL por tu Space real")
+    print("=" * 45)
+
+    while True:
+        print("\nSelecciona un ejemplo:")
+        for key, (name, _) in examples.items():
+            print(f"{key}. {name}")
+        print("0. Salir")
+
+        choice = input("\nOpción: ").strip()
+
+        if choice == "0":
+            print("¡Hasta luego! 🦙")
+            break
+        elif choice in examples:
+            try:
+                print(f"\n🚀 Ejecutando: {examples[choice][0]}")
+                print("=" * 50)
+                examples[choice][1]()
+            except Exception as e:
+                print(f"Error ejecutando ejemplo: {e}")
+        else:
+            print("Opción no válida")
+
+if __name__ == "__main__":
+    main()

exported-assets.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8609046f903919fb1ee14e368371096c2c51a6ca518af32af7c05c9fce4f7252
+size 36209

requirements.txt

@@ -1,7 +1,8 @@
+gradio>=4.0.0
+transformers>=4.35.0
 torch>=2.0.0
-transformers>=4.45.0
-gradio>=4.44.0
 accelerate>=0.20.0
 bitsandbytes>=0.41.0
-scipy
-
+sentencepiece>=0.1.99
+protobuf>=3.20.0
+requests>=2.28.0

script.py

@@ -0,0 +1,381 @@
+# Primero, voy a crear el código completo para el Hugging Face Space
+# que cumpla con todos los requisitos mencionados
+
+app_py_code = '''
+import gradio as gr
+import asyncio
+import queue
+import threading
+import time
+import os
+from typing import List, Dict, Optional, Generator, Tuple
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+import torch
+import json
+from datetime import datetime
+
+class LlamaChat:
+    def __init__(self):
+        self.model_name = "meta-llama/Llama-3.2-3B-Instruct"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.tokenizer = None
+        self.model = None
+        self.request_queue = queue.Queue()
+        self.is_processing = False
+        self.current_streamer = None
+        
+        # Inicializar modelo
+        self._load_model()
+        
+        # Iniciar worker thread para procesar colas
+        self.worker_thread = threading.Thread(target=self._queue_worker, daemon=True)
+        self.worker_thread.start()
+    
+    def _load_model(self):
+        """Cargar el modelo y tokenizer con el token de HF"""
+        try:
+            hf_token = os.environ.get("HF_TOKEN")
+            if not hf_token:
+                raise ValueError("HF_TOKEN no encontrado en variables de entorno")
+            
+            print(f"Cargando modelo {self.model_name}...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name, 
+                token=hf_token,
+                trust_remote_code=True
+            )
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                token=hf_token,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True
+            )
+            
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+            print("Modelo cargado exitosamente!")
+            
+        except Exception as e:
+            print(f"Error cargando modelo: {e}")
+            raise
+    
+    def _format_messages(self, system_prompt: str, message: str, history: List[List[str]]) -> str:
+        """Formatear mensajes para Llama-3.2-Instruct"""
+        messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # Agregar historial
+        for user_msg, assistant_msg in history:
+            messages.append({"role": "user", "content": user_msg})
+            messages.append({"role": "assistant", "content": assistant_msg})
+        
+        # Agregar mensaje actual
+        messages.append({"role": "user", "content": message})
+        
+        # Usar el chat template del tokenizer
+        formatted_prompt = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        return formatted_prompt
+    
+    def _queue_worker(self):
+        """Worker thread para procesar cola de requests"""
+        while True:
+            try:
+                if not self.request_queue.empty():
+                    request = self.request_queue.get()
+                    self.is_processing = True
+                    self._process_request(request)
+                    self.is_processing = False
+                    self.request_queue.task_done()
+                else:
+                    time.sleep(0.1)
+            except Exception as e:
+                print(f"Error en queue worker: {e}")
+                self.is_processing = False
+    
+    def _process_request(self, request: Dict):
+        """Procesar una request individual"""
+        try:
+            system_prompt = request["system_prompt"]
+            message = request["message"]
+            history = request["history"]
+            max_tokens = request.get("max_tokens", 512)
+            temperature = request.get("temperature", 0.7)
+            response_callback = request["callback"]
+            
+            # Formatear prompt
+            formatted_prompt = self._format_messages(system_prompt, message, history)
+            
+            # Tokenizar
+            inputs = self.tokenizer(
+                formatted_prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=2048
+            ).to(self.device)
+            
+            # Configurar streamer
+            streamer = TextIteratorStreamer(
+                self.tokenizer,
+                timeout=60,
+                skip_prompt=True,
+                skip_special_tokens=True
+            )
+            self.current_streamer = streamer
+            
+            # Configurar parámetros de generación
+            generation_kwargs = {
+                **inputs,
+                "max_new_tokens": max_tokens,
+                "temperature": temperature,
+                "do_sample": True,
+                "pad_token_id": self.tokenizer.eos_token_id,
+                "streamer": streamer,
+                "repetition_penalty": 1.1
+            }
+            
+            # Generar en thread separado
+            def generate():
+                with torch.no_grad():
+                    self.model.generate(**generation_kwargs)
+            
+            generation_thread = threading.Thread(target=generate)
+            generation_thread.start()
+            
+            # Stream respuesta
+            full_response = ""
+            for new_text in streamer:
+                if new_text:
+                    full_response += new_text
+                    response_callback(full_response, False)
+            
+            response_callback(full_response, True)
+            generation_thread.join()
+            
+        except Exception as e:
+            print(f"Error procesando request: {e}")
+            response_callback(f"Error: {str(e)}", True)
+        finally:
+            self.current_streamer = None
+    
+    def chat_stream(self, system_prompt: str, message: str, history: List[List[str]], 
+                   max_tokens: int = 512, temperature: float = 0.7) -> Generator[Tuple[str, bool], None, None]:
+        """Método principal para chatear con streaming"""
+        if not message.strip():
+            yield "Por favor, escribe un mensaje.", True
+            return
+        
+        # Crear evento para comunicación con el worker
+        response_queue = queue.Queue()
+        response_complete = threading.Event()
+        current_response = [""]
+        
+        def response_callback(text: str, is_complete: bool):
+            current_response[0] = text
+            response_queue.put((text, is_complete))
+            if is_complete:
+                response_complete.set()
+        
+        # Agregar request a la cola
+        request = {
+            "system_prompt": system_prompt or "",
+            "message": message,
+            "history": history or [],
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "callback": response_callback
+        }
+        
+        self.request_queue.put(request)
+        
+        # Esperar y streamear respuesta
+        while not response_complete.is_set():
+            try:
+                text, is_complete = response_queue.get(timeout=0.1)
+                yield text, is_complete
+                if is_complete:
+                    break
+            except queue.Empty:
+                # Si no hay nuevos tokens, yield el último estado
+                if current_response[0]:
+                    yield current_response[0], False
+                continue
+    
+    def get_queue_status(self) -> Dict[str, any]:
+        """Obtener estado de la cola"""
+        return {
+            "queue_size": self.request_queue.qsize(),
+            "is_processing": self.is_processing,
+            "timestamp": datetime.now().isoformat()
+        }
+
+# Inicializar el chat
+chat_instance = LlamaChat()
+
+# Función para la interfaz de Gradio
+def chat_interface(message: str, history: List[List[str]], system_prompt: str, 
+                  max_tokens: int, temperature: float):
+    """Interfaz de chat para Gradio"""
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        if not is_complete:
+            # Para Gradio, necesitamos devolver el historial completo
+            new_history = history + [[message, response]]
+            yield new_history, ""
+        else:
+            final_history = history + [[message, response]]
+            yield final_history, ""
+
+# Función para API Python
+def api_chat(system_prompt: str = "", message: str = "", history: List[List[str]] = None, 
+            max_tokens: int = 512, temperature: float = 0.7) -> Dict:
+    """API para cliente Python"""
+    if history is None:
+        history = []
+    
+    full_response = ""
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        full_response = response
+        if is_complete:
+            break
+    
+    return {
+        "response": full_response,
+        "queue_status": chat_instance.get_queue_status()
+    }
+
+# Función para streaming API
+def api_chat_stream(system_prompt: str = "", message: str = "", history: List[List[str]] = None,
+                   max_tokens: int = 512, temperature: float = 0.7):
+    """API streaming para cliente Python"""
+    if history is None:
+        history = []
+    
+    for response, is_complete in chat_instance.chat_stream(
+        system_prompt, message, history, max_tokens, temperature
+    ):
+        yield {
+            "response": response,
+            "is_complete": is_complete,
+            "queue_status": chat_instance.get_queue_status()
+        }
+
+# Crear interfaz de Gradio
+with gr.Blocks(title="Llama 3.2 3B Chat", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🦙 Llama 3.2 3B Instruct Chat")
+    gr.Markdown("Chat con Meta Llama 3.2 3B con sistema de colas y streaming")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(height=500, show_label=False)
+            msg = gr.Textbox(
+                label="Mensaje",
+                placeholder="Escribe tu mensaje aquí...",
+                lines=2
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("Enviar", variant="primary")
+                clear_btn = gr.Button("Limpiar")
+        
+        with gr.Column(scale=1):
+            system_prompt = gr.Textbox(
+                label="System Prompt",
+                placeholder="Eres un asistente útil...",
+                lines=5,
+                value="Eres un asistente de IA útil y amigable. Responde de manera clara y concisa."
+            )
+            
+            max_tokens = gr.Slider(
+                minimum=50,
+                maximum=1024,
+                value=512,
+                step=50,
+                label="Max Tokens"
+            )
+            
+            temperature = gr.Slider(
+                minimum=0.1,
+                maximum=2.0,
+                value=0.7,
+                step=0.1,
+                label="Temperature"
+            )
+            
+            gr.Markdown("### Estado de la Cola")
+            queue_status = gr.JSON(label="Queue Status", value={})
+            
+            # Botón para actualizar estado
+            refresh_btn = gr.Button("Actualizar Estado")
+    
+    # Event handlers
+    def send_message(message, history, sys_prompt, max_tok, temp):
+        if not message.strip():
+            return history, ""
+        
+        yield from chat_interface(message, history, sys_prompt, max_tok, temp)
+    
+    def clear_chat():
+        return [], ""
+    
+    def update_queue_status():
+        return chat_instance.get_queue_status()
+    
+    # Conectar eventos
+    send_btn.click(
+        send_message,
+        inputs=[msg, chatbot, system_prompt, max_tokens, temperature],
+        outputs=[chatbot, msg]
+    )
+    
+    msg.submit(
+        send_message,
+        inputs=[msg, chatbot, system_prompt, max_tokens, temperature],
+        outputs=[chatbot, msg]
+    )
+    
+    clear_btn.click(clear_chat, outputs=[chatbot, msg])
+    refresh_btn.click(update_queue_status, outputs=[queue_status])
+    
+    # Actualizar estado cada 5 segundos
+    app.load(update_queue_status, outputs=[queue_status], every=5)
+
+# Crear API endpoints
+api_app = gr.Interface(
+    fn=api_chat,
+    inputs=[
+        gr.Textbox(label="System Prompt"),
+        gr.Textbox(label="Message"),
+        gr.JSON(label="History"),
+        gr.Slider(50, 1024, 512, label="Max Tokens"),
+        gr.Slider(0.1, 2.0, 0.7, label="Temperature")
+    ],
+    outputs=gr.JSON(label="Response"),
+    title="Llama Chat API",
+    description="API endpoint para cliente Python"
+)
+
+# Combinar apps
+final_app = gr.TabbedInterface(
+    [app, api_app],
+    ["💬 Chat Interface", "🔌 API Endpoint"]
+)
+
+if __name__ == "__main__":
+    final_app.launch(server_name="0.0.0.0", server_port=7860, share=True)
+'''
+
+print("Código generado para app.py")
+print("=" * 50)

script_1.py

@@ -0,0 +1,202 @@
+# Crear requirements.txt
+requirements_txt = '''gradio>=4.0.0
+transformers>=4.35.0
+torch>=2.0.0
+accelerate>=0.20.0
+bitsandbytes>=0.41.0
+sentencepiece>=0.1.99
+protobuf>=3.20.0
+requests>=2.28.0
+'''
+
+print("Requirements.txt:")
+print(requirements_txt)
+print("=" * 50)
+
+# Crear cliente Python de ejemplo
+client_code = '''
+import requests
+import json
+import time
+from typing import List, Dict, Generator, Optional
+
+class LlamaClient:
+    def __init__(self, base_url: str):
+        """
+        Cliente para interactuar con el Hugging Face Space de Llama Chat
+        
+        Args:
+            base_url: URL base del Space (ej: "https://tu-usuario-llama-chat.hf.space")
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_endpoint = f"{self.base_url}/call/api_chat"
+        self.stream_endpoint = f"{self.base_url}/call/api_chat_stream"
+    
+    def chat(self, message: str, system_prompt: str = "", history: List[List[str]] = None,
+             max_tokens: int = 512, temperature: float = 0.7) -> Dict:
+        """
+        Enviar un mensaje y recibir respuesta completa
+        
+        Args:
+            message: Mensaje del usuario
+            system_prompt: Prompt del sistema (opcional)
+            history: Historial de conversación [[user, assistant], ...]
+            max_tokens: Máximo número de tokens a generar
+            temperature: Temperatura para la generación
+            
+        Returns:
+            Dict con 'response' y 'queue_status'
+        """
+        if history is None:
+            history = []
+        
+        payload = {
+            "data": [system_prompt, message, history, max_tokens, temperature]
+        }
+        
+        try:
+            response = requests.post(self.api_endpoint, json=payload, timeout=300)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result.get("data", [{}])[0]
+            
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Error de conexión: {str(e)}"}
+        except json.JSONDecodeError as e:
+            return {"error": f"Error decodificando JSON: {str(e)}"}
+    
+    def chat_stream(self, message: str, system_prompt: str = "", history: List[List[str]] = None,
+                   max_tokens: int = 512, temperature: float = 0.7) -> Generator[Dict, None, None]:
+        """
+        Enviar un mensaje y recibir respuesta en streaming
+        
+        Args:
+            message: Mensaje del usuario
+            system_prompt: Prompt del sistema (opcional)
+            history: Historial de conversación
+            max_tokens: Máximo número de tokens a generar
+            temperature: Temperatura para la generación
+            
+        Yields:
+            Dict con 'response', 'is_complete' y 'queue_status'
+        """
+        if history is None:
+            history = []
+        
+        payload = {
+            "data": [system_prompt, message, history, max_tokens, temperature]
+        }
+        
+        try:
+            response = requests.post(self.stream_endpoint, json=payload, stream=True, timeout=300)
+            response.raise_for_status()
+            
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        data = json.loads(line.decode('utf-8'))
+                        if "data" in data:
+                            yield data["data"][0]
+                    except json.JSONDecodeError:
+                        continue
+                        
+        except requests.exceptions.RequestException as e:
+            yield {"error": f"Error de conexión: {str(e)}", "is_complete": True}
+    
+    def get_queue_status(self) -> Dict:
+        """
+        Obtener estado actual de la cola
+        
+        Returns:
+            Dict con información del estado de la cola
+        """
+        try:
+            # Hacer una request vacía solo para obtener el estado
+            result = self.chat("", max_tokens=1)
+            return result.get("queue_status", {})
+        except Exception as e:
+            return {"error": str(e)}
+
+# Ejemplo de uso del cliente
+def example_usage():
+    """Ejemplo de cómo usar el cliente"""
+    
+    # Inicializar cliente (reemplaza con tu URL del Space)
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+    
+    print("=== Ejemplo 1: Chat simple ===")
+    response = client.chat(
+        message="¿Qué es la inteligencia artificial?",
+        system_prompt="Eres un profesor de informática experto."
+    )
+    
+    if "error" in response:
+        print(f"Error: {response['error']}")
+    else:
+        print(f"Respuesta: {response['response']}")
+        print(f"Estado cola: {response['queue_status']}")
+    
+    print("\\n=== Ejemplo 2: Chat con historial ===")
+    history = [
+        ["Hola", "¡Hola! ¿En qué puedo ayudarte?"],
+        ["¿Cuál es tu nombre?", "Soy un asistente de IA basado en Llama 3.2."]
+    ]
+    
+    response = client.chat(
+        message="¿Puedes explicarme conceptos de física?",
+        system_prompt="Eres un tutor de física para estudiantes de bachillerato.",
+        history=history
+    )
+    
+    if "error" in response:
+        print(f"Error: {response['error']}")
+    else:
+        print(f"Respuesta: {response['response']}")
+    
+    print("\\n=== Ejemplo 3: Chat con streaming ===")
+    print("Pregunta: Explica la teoría de la relatividad")
+    print("Respuesta (streaming):")
+    
+    for chunk in client.chat_stream(
+        message="Explica la teoría de la relatividad de forma simple",
+        system_prompt="Eres un divulgador científico.",
+        max_tokens=300,
+        temperature=0.8
+    ):
+        if "error" in chunk:
+            print(f"Error: {chunk['error']}")
+            break
+        
+        print(f"\\r{chunk['response']}", end="", flush=True)
+        
+        if chunk.get("is_complete", False):
+            print("\\n[Respuesta completa]")
+            print(f"Estado cola: {chunk['queue_status']}")
+            break
+    
+    print("\\n=== Ejemplo 4: Verificar estado de cola ===")
+    status = client.get_queue_status()
+    print(f"Estado actual: {status}")
+
+if __name__ == "__main__":
+    example_usage()
+'''
+
+print("Cliente Python (client.py):")
+print(client_code)
+
+# Escribir los archivos
+with open("app.py", "w", encoding="utf-8") as f:
+    f.write(app_py_code)
+
+with open("requirements.txt", "w", encoding="utf-8") as f:
+    f.write(requirements_txt)
+
+with open("client.py", "w", encoding="utf-8") as f:
+    f.write(client_code)
+
+print("\\nArchivos creados:")
+print("- app.py (aplicación principal)")
+print("- requirements.txt (dependencias)")
+print("- client.py (cliente Python de ejemplo)")

script_2.py

@@ -0,0 +1,535 @@
+# Crear README.md con instrucciones completas
+readme_content = '''# 🦙 Llama 3.2 3B Chat - Hugging Face Space
+
+Un Space de Hugging Face para chatear con Meta Llama 3.2 3B Instruct con sistema de colas, streaming y API para cliente Python.
+
+## ✨ Características
+
+- 🔄 **Sistema de colas**: Solo procesa una petición a la vez para evitar sobrecargar el modelo
+- 📡 **Streaming en tiempo real**: Ve la respuesta generándose en tiempo real
+- 🐍 **Cliente Python**: API completa para integración con aplicaciones Python
+- 💬 **Interfaz web**: Chat interactivo con sistema de prompts y configuración
+- 📊 **Monitoreo**: Estado de cola en tiempo real
+- 🔐 **Autenticación**: Soporte para modelos restringidos con HF token
+
+## 🚀 Configuración del Space
+
+### 1. Crear el Space
+
+1. Ve a [Hugging Face Spaces](https://huggingface.co/new-space)
+2. Elige **Gradio** como SDK
+3. Selecciona **T4 small** o superior como hardware
+4. Nombra tu Space (ej: `tu-usuario/llama-chat`)
+
+### 2. Configurar el token HF
+
+1. Ve a **Settings** de tu Space
+2. En **Repository secrets**, agrega:
+   - **Name**: `HF_TOKEN`
+   - **Value**: Tu token de Hugging Face (con acceso a Llama)
+
+### 3. Subir archivos
+
+Sube estos archivos a tu Space:
+- `app.py` (aplicación principal)
+- `requirements.txt` (dependencias)
+
+### 4. Verificar el despliegue
+
+Una vez que el Space esté corriendo, deberías ver:
+- Una interfaz de chat en la pestaña principal
+- Un endpoint API en la segunda pestaña
+- Estado de cola actualizado automáticamente
+
+## 📱 Uso de la interfaz web
+
+### Chat Principal
+- **System Prompt**: Define el comportamiento del asistente
+- **Mensaje**: Tu pregunta o mensaje
+- **Max Tokens**: Longitud máxima de la respuesta (50-1024)
+- **Temperature**: Creatividad de la respuesta (0.1-2.0)
+
+### Estado de Cola
+- **queue_size**: Número de peticiones en espera
+- **is_processing**: Si está procesando actualmente
+- **timestamp**: Última actualización
+
+## 🐍 Cliente Python
+
+### Instalación
+
+```bash
+pip install requests
+```
+
+### Uso Básico
+
+```python
+from client import LlamaClient
+
+# Inicializar cliente con la URL de tu Space
+client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+
+# Chat simple
+response = client.chat(
+    message="¿Qué es la inteligencia artificial?",
+    system_prompt="Eres un profesor experto."
+)
+
+print(response["response"])
+```
+
+### Chat con Streaming
+
+```python
+# Ver respuesta generándose en tiempo real
+for chunk in client.chat_stream(
+    message="Explica la física cuántica",
+    system_prompt="Eres un divulgador científico.",
+    max_tokens=300
+):
+    print(f"\\r{chunk['response']}", end="", flush=True)
+    
+    if chunk.get("is_complete", False):
+        print("\\n[Completo]")
+        break
+```
+
+### Chat con Historial
+
+```python
+# Mantener conversación
+history = [
+    ["Hola", "¡Hola! ¿En qué puedo ayudarte?"],
+    ["Explica el machine learning", "El machine learning es..."]
+]
+
+response = client.chat(
+    message="¿Puedes dar un ejemplo práctico?",
+    history=history
+)
+```
+
+## 🔧 API Endpoints
+
+### POST /call/api_chat
+Respuesta completa sin streaming.
+
+**Payload:**
+```json
+{
+    "data": [
+        "system_prompt",
+        "message", 
+        [["user", "assistant"], ...],
+        512,
+        0.7
+    ]
+}
+```
+
+**Respuesta:**
+```json
+{
+    "data": [{
+        "response": "Respuesta del modelo",
+        "queue_status": {
+            "queue_size": 0,
+            "is_processing": false,
+            "timestamp": "2025-10-16T17:30:00"
+        }
+    }]
+}
+```
+
+### POST /call/api_chat_stream
+Respuesta con streaming.
+
+Misma estructura de payload, pero responde con eventos SSE.
+
+## 📊 Monitoreo y Debugging
+
+### Logs del Space
+Revisa los logs en la interfaz de HF Spaces para debugging.
+
+### Estado de Cola
+Usa `client.get_queue_status()` para monitorear la cola:
+
+```python
+status = client.get_queue_status()
+print(f"Cola: {status['queue_size']} peticiones")
+print(f"Procesando: {status['is_processing']}")
+```
+
+### Manejo de Errores
+
+```python
+response = client.chat("Hola")
+
+if "error" in response:
+    print(f"Error: {response['error']}")
+else:
+    print(f"Respuesta: {response['response']}")
+```
+
+## ⚙️ Configuración Avanzada
+
+### Parámetros del Modelo
+
+- **max_tokens**: 50-1024 (recomendado: 512)
+- **temperature**: 0.1-2.0 (recomendado: 0.7)
+- **repetition_penalty**: Automático (1.1)
+
+### Optimización de Performance
+
+1. **Hardware**: Usa GPU T4 small mínimo
+2. **Batch size**: Sistema de colas evita problemas de memoria
+3. **Context length**: Máximo 2048 tokens de entrada
+
+### System Prompts Útiles
+
+```python
+# Para tareas académicas
+system_prompt = "Eres un tutor experto que explica conceptos complejos de forma clara y pedagógica."
+
+# Para programación
+system_prompt = "Eres un desarrollador senior que ayuda con código Python, explicando paso a paso."
+
+# Para creatividad
+system_prompt = "Eres un escritor creativo que ayuda a generar ideas originales y contenido engagente."
+```
+
+## 🐛 Troubleshooting
+
+### Error: HF_TOKEN no encontrado
+- Verifica que agregaste el token en Repository secrets
+- Asegúrate que el nombre sea exactamente `HF_TOKEN`
+
+### Error: Modelo no disponible
+- Tu token debe tener acceso a Llama 3.2 3B
+- Solicita acceso en la página del modelo si es necesario
+
+### Timeouts en cliente Python
+- Aumenta el timeout: `requests.post(..., timeout=600)`
+- El modelo puede tardar en cargar la primera vez
+
+### Cola muy larga
+- El sistema procesa una petición a la vez
+- Considera usar hardware más potente
+
+## 🤝 Contribuciones
+
+¿Mejoras sugeridas?
+1. Fork el código
+2. Implementa mejoras
+3. Prueba con tu propio Space
+4. Comparte tu versión
+
+## 📝 Licencia
+
+Este código es de uso libre. Respeta los términos de uso de:
+- Hugging Face Spaces
+- Meta Llama 3.2 License
+- Gradio License
+
+## 🔗 Enlaces Útiles
+
+- [Hugging Face Spaces](https://huggingface.co/spaces)
+- [Meta Llama 3.2 3B Instruct](https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [Transformers Library](https://huggingface.co/docs/transformers)
+
+---
+
+**¡Disfruta chateando con Llama! 🦙**
+'''
+
+# Crear archivo de configuración adicional
+config_py_content = '''# config.py - Configuración del Space
+
+import os
+
+class Config:
+    """Configuración centralizada para el Space"""
+    
+    # Modelo
+    MODEL_NAME = "meta-llama/Llama-3.2-3B-Instruct"
+    DEVICE = "cuda" if os.environ.get("SPACES_GPU") else "cpu"
+    
+    # Tokens y autenticación
+    HF_TOKEN = os.environ.get("HF_TOKEN")
+    
+    # Límites de generación
+    MAX_TOKENS_LIMIT = 1024
+    MIN_TOKENS_LIMIT = 50
+    DEFAULT_MAX_TOKENS = 512
+    
+    # Temperatura
+    MAX_TEMPERATURE = 2.0
+    MIN_TEMPERATURE = 0.1
+    DEFAULT_TEMPERATURE = 0.7
+    
+    # Cola y concurrencia
+    MAX_QUEUE_SIZE = 10
+    QUEUE_TIMEOUT = 300  # 5 minutos
+    
+    # Context length
+    MAX_CONTEXT_LENGTH = 2048
+    
+    # Interface
+    CHAT_HEIGHT = 500
+    DEFAULT_SYSTEM_PROMPT = "Eres un asistente de IA útil y amigable. Responde de manera clara y concisa."
+    
+    # API
+    API_TIMEOUT = 300
+    ENABLE_API_LOGGING = True
+    
+    @classmethod
+    def validate(cls):
+        """Validar configuración"""
+        errors = []
+        
+        if not cls.HF_TOKEN:
+            errors.append("HF_TOKEN no configurado en variables de entorno")
+        
+        if cls.MAX_TOKENS_LIMIT < cls.MIN_TOKENS_LIMIT:
+            errors.append("MAX_TOKENS_LIMIT debe ser mayor que MIN_TOKENS_LIMIT")
+        
+        if cls.MAX_TEMPERATURE < cls.MIN_TEMPERATURE:
+            errors.append("MAX_TEMPERATURE debe ser mayor que MIN_TEMPERATURE")
+        
+        return errors
+    
+    @classmethod
+    def get_model_config(cls):
+        """Configuración específica del modelo"""
+        return {
+            "torch_dtype": "float16" if cls.DEVICE == "cuda" else "float32",
+            "device_map": "auto" if cls.DEVICE == "cuda" else None,
+            "trust_remote_code": True,
+            "token": cls.HF_TOKEN
+        }
+    
+    @classmethod
+    def get_generation_config(cls, max_tokens=None, temperature=None):
+        """Configuración de generación"""
+        return {
+            "max_new_tokens": max_tokens or cls.DEFAULT_MAX_TOKENS,
+            "temperature": temperature or cls.DEFAULT_TEMPERATURE,
+            "do_sample": True,
+            "repetition_penalty": 1.1,
+            "top_p": 0.9,
+            "top_k": 50
+        }
+
+# Validar configuración al importar
+config_errors = Config.validate()
+if config_errors:
+    print("⚠️ Errores de configuración:")
+    for error in config_errors:
+        print(f"  - {error}")
+'''
+
+# Crear archivo con utils adicionales
+utils_py_content = '''# utils.py - Utilidades para el Space
+
+import time
+import functools
+import logging
+from typing import List, Dict, Callable, Any
+from datetime import datetime
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def timing_decorator(func: Callable) -> Callable:
+    """Decorator para medir tiempo de ejecución"""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        
+        logger.info(f"{func.__name__} ejecutado en {end_time - start_time:.2f}s")
+        return result
+    return wrapper
+
+def sanitize_input(text: str, max_length: int = 2000) -> str:
+    """Sanitizar entrada del usuario"""
+    if not isinstance(text, str):
+        return ""
+    
+    # Truncar si es muy largo
+    text = text[:max_length]
+    
+    # Limpiar caracteres problemáticos
+    text = text.replace('\\x00', '')  # Null bytes
+    text = text.strip()
+    
+    return text
+
+def format_history(history: List[List[str]]) -> List[List[str]]:
+    """Formatear y validar historial de chat"""
+    if not history:
+        return []
+    
+    formatted_history = []
+    for item in history:
+        if isinstance(item, list) and len(item) == 2:
+            user_msg = sanitize_input(str(item[0]))
+            assistant_msg = sanitize_input(str(item[1]))
+            
+            if user_msg and assistant_msg:
+                formatted_history.append([user_msg, assistant_msg])
+    
+    # Limitar historial a últimas 10 conversaciones
+    return formatted_history[-10:]
+
+def estimate_tokens(text: str) -> int:
+    """Estimación aproximada de tokens"""
+    # Aproximación: ~4 caracteres por token en español
+    return len(text) // 4
+
+def validate_parameters(max_tokens: int, temperature: float) -> Dict[str, Any]:
+    """Validar parámetros de generación"""
+    from config import Config
+    
+    errors = []
+    
+    # Validar max_tokens
+    if not isinstance(max_tokens, int):
+        max_tokens = Config.DEFAULT_MAX_TOKENS
+        errors.append("max_tokens debe ser un entero")
+    elif max_tokens < Config.MIN_TOKENS_LIMIT:
+        max_tokens = Config.MIN_TOKENS_LIMIT
+        errors.append(f"max_tokens mínimo es {Config.MIN_TOKENS_LIMIT}")
+    elif max_tokens > Config.MAX_TOKENS_LIMIT:
+        max_tokens = Config.MAX_TOKENS_LIMIT
+        errors.append(f"max_tokens máximo es {Config.MAX_TOKENS_LIMIT}")
+    
+    # Validar temperature
+    if not isinstance(temperature, (int, float)):
+        temperature = Config.DEFAULT_TEMPERATURE
+        errors.append("temperature debe ser un número")
+    elif temperature < Config.MIN_TEMPERATURE:
+        temperature = Config.MIN_TEMPERATURE
+        errors.append(f"temperature mínima es {Config.MIN_TEMPERATURE}")
+    elif temperature > Config.MAX_TEMPERATURE:
+        temperature = Config.MAX_TEMPERATURE
+        errors.append(f"temperature máxima es {Config.MAX_TEMPERATURE}")
+    
+    return {
+        "max_tokens": max_tokens,
+        "temperature": float(temperature),
+        "errors": errors
+    }
+
+def create_error_response(error_msg: str) -> Dict[str, Any]:
+    """Crear respuesta de error estandarizada"""
+    return {
+        "response": f"Error: {error_msg}",
+        "queue_status": {
+            "queue_size": 0,
+            "is_processing": False,
+            "timestamp": datetime.now().isoformat(),
+            "error": True
+        }
+    }
+
+def truncate_context(text: str, max_length: int = 1800) -> str:
+    """Truncar contexto manteniendo coherencia"""
+    if len(text) <= max_length:
+        return text
+    
+    # Truncar por párrafos si es posible
+    paragraphs = text.split('\\n\\n')
+    truncated = ""
+    
+    for paragraph in paragraphs:
+        if len(truncated + paragraph) <= max_length:
+            truncated += paragraph + '\\n\\n'
+        else:
+            break
+    
+    # Si no hay párrafos, truncar por oraciones
+    if not truncated:
+        sentences = text.split('. ')
+        for sentence in sentences:
+            if len(truncated + sentence) <= max_length:
+                truncated += sentence + '. '
+            else:
+                break
+    
+    # Último recurso: truncar directamente
+    if not truncated:
+        truncated = text[:max_length]
+    
+    return truncated.strip()
+
+class PerformanceMonitor:
+    """Monitor de rendimiento simple"""
+    
+    def __init__(self):
+        self.stats = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "total_tokens_generated": 0,
+            "average_response_time": 0,
+            "start_time": datetime.now()
+        }
+    
+    def record_request(self, success: bool, tokens_generated: int = 0, response_time: float = 0):
+        """Registrar una request"""
+        self.stats["total_requests"] += 1
+        
+        if success:
+            self.stats["successful_requests"] += 1
+            self.stats["total_tokens_generated"] += tokens_generated
+        else:
+            self.stats["failed_requests"] += 1
+        
+        # Actualizar tiempo promedio de respuesta
+        if response_time > 0:
+            current_avg = self.stats["average_response_time"]
+            total_requests = self.stats["total_requests"]
+            
+            self.stats["average_response_time"] = (
+                (current_avg * (total_requests - 1) + response_time) / total_requests
+            )
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Obtener estadísticas"""
+        uptime = datetime.now() - self.stats["start_time"]
+        
+        return {
+            **self.stats,
+            "uptime_seconds": uptime.total_seconds(),
+            "success_rate": (
+                self.stats["successful_requests"] / max(self.stats["total_requests"], 1)
+            ) * 100,
+            "tokens_per_minute": (
+                self.stats["total_tokens_generated"] / max(uptime.total_seconds() / 60, 1)
+            )
+        }
+
+# Instancia global del monitor
+performance_monitor = PerformanceMonitor()
+'''
+
+# Escribir todos los archivos
+with open("README.md", "w", encoding="utf-8") as f:
+    f.write(readme_content)
+
+with open("config.py", "w", encoding="utf-8") as f:
+    f.write(config_py_content)
+
+with open("utils.py", "w", encoding="utf-8") as f:
+    f.write(utils_py_content)
+
+print("Archivos adicionales creados:")
+print("- README.md (instrucciones completas)")
+print("- config.py (configuración centralizada)")
+print("- utils.py (utilidades y monitoreo)")
+print("\\n¡Todo listo para subir a Hugging Face Spaces! 🚀")

script_3.py

@@ -0,0 +1,637 @@
+# Crear archivo con ejemplos avanzados
+examples_py_content = '''# examples.py - Ejemplos avanzados de uso del cliente
+
+from client import LlamaClient
+import asyncio
+import time
+from typing import List
+import json
+
+class AdvancedLlamaClient:
+    """Cliente extendido con funcionalidades avanzadas"""
+    
+    def __init__(self, base_url: str):
+        self.client = LlamaClient(base_url)
+        self.conversation_history = []
+    
+    def continuous_chat(self):
+        """Chat interactivo continuo"""
+        print("🦙 Chat con Llama 3.2 3B - Escribe 'salir' para terminar")
+        print("=" * 50)
+        
+        system_prompt = input("System prompt (opcional): ").strip()
+        if not system_prompt:
+            system_prompt = "Eres un asistente útil y amigable."
+        
+        while True:
+            try:
+                message = input("\\nTú: ").strip()
+                
+                if message.lower() in ['salir', 'exit', 'quit']:
+                    print("¡Hasta luego! 👋")
+                    break
+                
+                if not message:
+                    continue
+                
+                print("🦙: ", end="", flush=True)
+                full_response = ""
+                
+                for chunk in self.client.chat_stream(
+                    message=message,
+                    system_prompt=system_prompt,
+                    history=self.conversation_history,
+                    max_tokens=512,
+                    temperature=0.7
+                ):
+                    if "error" in chunk:
+                        print(f"Error: {chunk['error']}")
+                        break
+                    
+                    # Mostrar solo el texto nuevo
+                    new_text = chunk['response'][len(full_response):]
+                    print(new_text, end="", flush=True)
+                    full_response = chunk['response']
+                    
+                    if chunk.get("is_complete", False):
+                        print()  # Nueva línea al final
+                        break
+                
+                # Agregar al historial
+                if full_response and not full_response.startswith("Error:"):
+                    self.conversation_history.append([message, full_response])
+                    
+                    # Limitar historial a 10 intercambios
+                    if len(self.conversation_history) > 10:
+                        self.conversation_history = self.conversation_history[-10:]
+                
+            except KeyboardInterrupt:
+                print("\\n\\n¡Hasta luego! 👋")
+                break
+            except Exception as e:
+                print(f"\\nError inesperado: {e}")
+    
+    def batch_questions(self, questions: List[str], system_prompt: str = ""):
+        """Procesar múltiples preguntas en lote"""
+        print(f"Procesando {len(questions)} preguntas...")
+        results = []
+        
+        for i, question in enumerate(questions, 1):
+            print(f"\\nPregunta {i}/{len(questions)}: {question}")
+            print("-" * 40)
+            
+            response = self.client.chat(
+                message=question,
+                system_prompt=system_prompt,
+                max_tokens=300
+            )
+            
+            if "error" in response:
+                print(f"Error: {response['error']}")
+                results.append({"question": question, "error": response['error']})
+            else:
+                print(f"Respuesta: {response['response']}")
+                results.append({
+                    "question": question,
+                    "response": response['response'],
+                    "queue_status": response['queue_status']
+                })
+            
+            # Pequeña pausa entre preguntas
+            time.sleep(1)
+        
+        return results
+    
+    def compare_temperatures(self, message: str, temperatures: List[float] = [0.3, 0.7, 1.2]):
+        """Comparar respuestas con diferentes temperaturas"""
+        print(f"Comparando respuestas para: '{message}'")
+        print("=" * 60)
+        
+        results = {}
+        
+        for temp in temperatures:
+            print(f"\\n🌡️ Temperature: {temp}")
+            print("-" * 30)
+            
+            response = self.client.chat(
+                message=message,
+                temperature=temp,
+                max_tokens=200
+            )
+            
+            if "error" in response:
+                print(f"Error: {response['error']}")
+                results[temp] = {"error": response['error']}
+            else:
+                print(response['response'])
+                results[temp] = {"response": response['response']}
+        
+        return results
+    
+    def roleplay_scenario(self, scenario: str, turns: int = 5):
+        """Escenario de roleplay interactivo"""
+        print(f"🎭 Escenario: {scenario}")
+        print("=" * 50)
+        
+        system_prompt = f"Actúa como {scenario}. Mantén el rol consistentemente y responde de manera inmersiva."
+        history = []
+        
+        for turn in range(turns):
+            user_input = input(f"\\nTurno {turn + 1} - Tú: ").strip()
+            
+            if not user_input or user_input.lower() == 'salir':
+                break
+            
+            print("🎭: ", end="", flush=True)
+            
+            for chunk in self.client.chat_stream(
+                message=user_input,
+                system_prompt=system_prompt,
+                history=history,
+                temperature=0.8,
+                max_tokens=300
+            ):
+                if "error" in chunk:
+                    print(f"Error: {chunk['error']}")
+                    break
+                
+                print(f"\\r🎭: {chunk['response']}", end="", flush=True)
+                
+                if chunk.get("is_complete", False):
+                    history.append([user_input, chunk['response']])
+                    print()
+                    break
+        
+        return history
+
+def academic_tutor_example():
+    """Ejemplo: Tutor académico para física"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+    
+    system_prompt = """Eres un tutor de física especializado en bachillerato español. 
+    Explicas conceptos de forma clara, usas ejemplos cotidianos y siempre verificas 
+    que el estudiante entienda antes de avanzar. Puedes resolver problemas paso a paso."""
+    
+    physics_questions = [
+        "¿Qué es la velocidad angular y cómo se relaciona con la velocidad lineal?",
+        "Explica el principio de conservación de la energía con un ejemplo",
+        "¿Cómo funciona el efecto Doppler?",
+        "Diferencia entre masa y peso físicamente"
+    ]
+    
+    print("🔬 Tutor de Física - Bachillerato")
+    print("=" * 40)
+    
+    for question in physics_questions:
+        print(f"\\n📚 Pregunta: {question}")
+        print("-" * 50)
+        
+        full_response = ""
+        for chunk in client.chat_stream(
+            message=question,
+            system_prompt=system_prompt,
+            max_tokens=400,
+            temperature=0.6
+        ):
+            if "error" in chunk:
+                print(f"Error: {chunk['error']}")
+                break
+            
+            print(f"\\r👨‍🏫: {chunk['response']}", end="", flush=True)
+            full_response = chunk['response']
+            
+            if chunk.get("is_complete", False):
+                print("\\n")
+                break
+        
+        input("Presiona Enter para la siguiente pregunta...")
+
+def programming_assistant_example():
+    """Ejemplo: Asistente de programación"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+    
+    system_prompt = """Eres un desarrollador senior especializado en Python y Flutter. 
+    Ayudas a estudiantes con código, debugging y mejores prácticas. Siempre explicas 
+    el código línea por línea y sugieres mejoras."""
+    
+    code_questions = [
+        "¿Cómo implementar un patrón Singleton en Python?",
+        "Explica la diferencia entre async/await y threading",
+        "¿Cómo manejo errores de API en Flutter?",
+        "Mejores prácticas para estructurar un proyecto Flutter"
+    ]
+    
+    print("💻 Asistente de Programación")
+    print("=" * 35)
+    
+    for question in code_questions:
+        print(f"\\n🤔 {question}")
+        print("-" * 60)
+        
+        response = client.chat(
+            message=question,
+            system_prompt=system_prompt,
+            max_tokens=600,
+            temperature=0.4  # Menor temperatura para código
+        )
+        
+        if "error" in response:
+            print(f"❌ Error: {response['error']}")
+        else:
+            print(f"💡 {response['response']}")
+        
+        print("\\n" + "="*60)
+        time.sleep(2)
+
+def creative_writing_example():
+    """Ejemplo: Escritura creativa colaborativa"""
+    client = LlamaClient("https://tu-usuario-llama-chat.hf.space")
+    
+    system_prompt = """Eres un escritor creativo experto. Ayudas a desarrollar historias, 
+    personajes y narrativas. Puedes continuar historias, sugerir tramas y crear diálogos 
+    naturales. Eres imaginativo pero coherente."""
+    
+    print("✍️ Escritura Creativa Colaborativa")
+    print("=" * 40)
+    
+    story_start = input("Escribe el inicio de una historia (2-3 líneas): ")
+    
+    current_story = story_start
+    history = []
+    
+    for chapter in range(3):
+        print(f"\\n📖 Capítulo {chapter + 1}")
+        print("-" * 30)
+        
+        prompt = f"Continúa esta historia de manera creativa e interesante:\\n\\n{current_story}"
+        
+        print("✨ Continuando la historia...")
+        continuation = ""
+        
+        for chunk in client.chat_stream(
+            message=prompt,
+            system_prompt=system_prompt,
+            history=history,
+            max_tokens=400,
+            temperature=1.0  # Alta creatividad
+        ):
+            if "error" in chunk:
+                print(f"Error: {chunk['error']}")
+                break
+            
+            continuation = chunk['response']
+            print(f"\\r{continuation}", end="", flush=True)
+            
+            if chunk.get("is_complete", False):
+                print("\\n")
+                break
+        
+        current_story += "\\n\\n" + continuation
+        history.append([prompt, continuation])
+        
+        # Opción de dirigir la historia
+        direction = input("\\n¿Quieres sugerir una dirección para la historia? (opcional): ")
+        if direction.strip():
+            current_story += "\\n\\n[Dirección sugerida: " + direction + "]"
+    
+    print("\\n📚 Historia completa:")
+    print("=" * 50)
+    print(current_story)
+
+def main():
+    """Menú principal de ejemplos"""
+    examples = {
+        "1": ("Chat Continuo", lambda: AdvancedLlamaClient("https://tu-usuario-llama-chat.hf.space").continuous_chat()),
+        "2": ("Tutor de Física", academic_tutor_example),
+        "3": ("Asistente de Programación", programming_assistant_example),
+        "4": ("Escritura Creativa", creative_writing_example),
+        "5": ("Comparar Temperaturas", lambda: AdvancedLlamaClient("https://tu-usuario-llama-chat.hf.space").compare_temperatures(
+            "Explica la inteligencia artificial", [0.3, 0.7, 1.2]
+        )),
+    }
+    
+    print("🦙 Ejemplos Avanzados - Llama 3.2 Chat")
+    print("=" * 45)
+    print("IMPORTANTE: Cambia la URL por tu Space real")
+    print("=" * 45)
+    
+    while True:
+        print("\\nSelecciona un ejemplo:")
+        for key, (name, _) in examples.items():
+            print(f"{key}. {name}")
+        print("0. Salir")
+        
+        choice = input("\\nOpción: ").strip()
+        
+        if choice == "0":
+            print("¡Hasta luego! 🦙")
+            break
+        elif choice in examples:
+            try:
+                print(f"\\n🚀 Ejecutando: {examples[choice][0]}")
+                print("=" * 50)
+                examples[choice][1]()
+            except Exception as e:
+                print(f"Error ejecutando ejemplo: {e}")
+        else:
+            print("Opción no válida")
+
+if __name__ == "__main__":
+    main()
+'''
+
+# Crear archivo de pruebas
+tests_py_content = '''# tests.py - Pruebas para verificar el funcionamiento
+
+from client import LlamaClient
+import time
+import json
+
+def test_basic_functionality(base_url: str):
+    """Pruebas básicas de funcionalidad"""
+    print("🧪 Ejecutando pruebas básicas...")
+    client = LlamaClient(base_url)
+    
+    tests = []
+    
+    # Test 1: Chat simple
+    print("\\n1. Test chat simple...")
+    try:
+        response = client.chat(
+            message="Hola, ¿puedes presentarte en una línea?",
+            max_tokens=50
+        )
+        
+        if "error" in response:
+            tests.append(("Chat simple", False, response['error']))
+        else:
+            tests.append(("Chat simple", True, f"Respuesta: {response['response'][:50]}..."))
+    except Exception as e:
+        tests.append(("Chat simple", False, str(e)))
+    
+    # Test 2: Chat con system prompt
+    print("2. Test system prompt...")
+    try:
+        response = client.chat(
+            message="¿Cuánto es 2+2?",
+            system_prompt="Eres una calculadora. Solo responde con números.",
+            max_tokens=20
+        )
+        
+        success = "error" not in response and "4" in response.get('response', '')
+        tests.append(("System prompt", success, response.get('response', 'No response')))
+    except Exception as e:
+        tests.append(("System prompt", False, str(e)))
+    
+    # Test 3: Chat con historial
+    print("3. Test historial...")
+    try:
+        history = [["¿Cómo te llamas?", "Soy un asistente de IA."]]
+        response = client.chat(
+            message="¿Recuerdas cómo te llamas?",
+            history=history,
+            max_tokens=50
+        )
+        
+        success = "error" not in response
+        tests.append(("Historial", success, response.get('response', 'Error')[:50]))
+    except Exception as e:
+        tests.append(("Historial", False, str(e)))
+    
+    # Test 4: Streaming
+    print("4. Test streaming...")
+    try:
+        chunks_received = 0
+        final_response = ""
+        
+        for chunk in client.chat_stream(
+            message="Cuenta del 1 al 5",
+            max_tokens=30
+        ):
+            chunks_received += 1
+            if "error" in chunk:
+                tests.append(("Streaming", False, chunk['error']))
+                break
+            
+            final_response = chunk['response']
+            if chunk.get("is_complete", False):
+                break
+        
+        success = chunks_received > 1 and final_response
+        tests.append(("Streaming", success, f"{chunks_received} chunks, respuesta: {final_response[:30]}"))
+    except Exception as e:
+        tests.append(("Streaming", False, str(e)))
+    
+    # Test 5: Estado de cola
+    print("5. Test estado de cola...")
+    try:
+        status = client.get_queue_status()
+        success = "queue_size" in status and "is_processing" in status
+        tests.append(("Estado cola", success, str(status)))
+    except Exception as e:
+        tests.append(("Estado cola", False, str(e)))
+    
+    # Mostrar resultados
+    print("\\n" + "="*60)
+    print("📊 RESULTADOS DE PRUEBAS")
+    print("="*60)
+    
+    passed = 0
+    for test_name, success, details in tests:
+        status = "✅ PASS" if success else "❌ FAIL"
+        print(f"{status} {test_name}: {details}")
+        if success:
+            passed += 1
+    
+    print(f"\\n🎯 Resultado: {passed}/{len(tests)} pruebas pasaron")
+    return passed == len(tests)
+
+def stress_test(base_url: str, num_requests: int = 5):
+    """Prueba de estrés con múltiples requests"""
+    print(f"\\n⚡ Prueba de estrés ({num_requests} requests)...")
+    client = LlamaClient(base_url)
+    
+    start_time = time.time()
+    results = []
+    
+    for i in range(num_requests):
+        print(f"Request {i+1}/{num_requests}...", end=" ")
+        
+        try:
+            request_start = time.time()
+            response = client.chat(
+                message=f"Esta es la request número {i+1}. Responde brevemente.",
+                max_tokens=50
+            )
+            request_time = time.time() - request_start
+            
+            if "error" in response:
+                print(f"❌ Error: {response['error']}")
+                results.append({"success": False, "time": request_time, "error": response['error']})
+            else:
+                print(f"✅ {request_time:.2f}s")
+                results.append({"success": True, "time": request_time, "response_length": len(response['response'])})
+        
+        except Exception as e:
+            print(f"❌ Exception: {e}")
+            results.append({"success": False, "time": 0, "error": str(e)})
+    
+    total_time = time.time() - start_time
+    
+    # Análisis de resultados
+    successful = [r for r in results if r['success']]
+    failed = [r for r in results if not r['success']]
+    
+    print(f"\\n📈 Análisis de estrés:")
+    print(f"  • Total: {total_time:.2f}s")
+    print(f"  • Exitosas: {len(successful)}/{num_requests}")
+    print(f"  • Fallidas: {len(failed)}/{num_requests}")
+    
+    if successful:
+        avg_time = sum(r['time'] for r in successful) / len(successful)
+        print(f"  • Tiempo promedio: {avg_time:.2f}s")
+    
+    return len(successful) == num_requests
+
+def performance_benchmark(base_url: str):
+    """Benchmark de rendimiento"""
+    print("\\n🏁 Benchmark de rendimiento...")
+    client = LlamaClient(base_url)
+    
+    test_cases = [
+        ("Respuesta corta", "Hola", 20),
+        ("Respuesta media", "Explica qué es Python en un párrafo", 100),
+        ("Respuesta larga", "Describe la historia de la programación", 300),
+    ]
+    
+    for test_name, message, max_tokens in test_cases:
+        print(f"\\n{test_name} ({max_tokens} tokens)...")
+        
+        # Test sin streaming
+        start_time = time.time()
+        response = client.chat(message=message, max_tokens=max_tokens)
+        normal_time = time.time() - start_time
+        
+        if "error" in response:
+            print(f"  ❌ Error: {response['error']}")
+            continue
+        
+        # Test con streaming
+        start_time = time.time()
+        for chunk in client.chat_stream(message=message, max_tokens=max_tokens):
+            if chunk.get("is_complete", False):
+                break
+        stream_time = time.time() - start_time
+        
+        print(f"  • Sin streaming: {normal_time:.2f}s")
+        print(f"  • Con streaming: {stream_time:.2f}s")
+        print(f"  • Tokens generados: ~{len(response['response'])} chars")
+
+def main():
+    """Ejecutar todas las pruebas"""
+    base_url = input("Ingresa la URL de tu Space: ").strip()
+    
+    if not base_url:
+        print("❌ URL requerida")
+        return
+    
+    if not base_url.startswith(('http://', 'https://')):
+        base_url = f"https://{base_url}"
+    
+    print(f"🧪 Probando Space: {base_url}")
+    print("="*60)
+    
+    # Ejecutar pruebas
+    basic_ok = test_basic_functionality(base_url)
+    
+    if basic_ok:
+        print("\\n✅ Pruebas básicas exitosas. Continuando...")
+        stress_ok = stress_test(base_url, 3)
+        performance_benchmark(base_url)
+        
+        if stress_ok:
+            print("\\n🎉 ¡Todas las pruebas pasaron! El Space funciona correctamente.")
+        else:
+            print("\\n⚠️ Algunas pruebas de estrés fallaron. Verifica el rendimiento.")
+    else:
+        print("\\n❌ Pruebas básicas fallaron. Verifica la configuración del Space.")
+
+if __name__ == "__main__":
+    main()
+'''
+
+# Escribir archivos finales
+with open("examples.py", "w", encoding="utf-8") as f:
+    f.write(examples_py_content)
+
+with open("tests.py", "w", encoding="utf-8") as f:
+    f.write(tests_py_content)
+
+# Crear resumen final
+summary = """
+🦙 RESUMEN DEL PROYECTO - Llama 3.2 3B Chat Space
+================================================================
+
+✅ ARCHIVOS GENERADOS:
+
+📱 CORE APPLICATION:
+- app.py          → Aplicación principal de Gradio con cola y streaming
+- requirements.txt → Dependencias del proyecto  
+- config.py       → Configuración centralizada
+- utils.py        → Utilidades y monitoreo de rendimiento
+
+🐍 CLIENTE PYTHON:
+- client.py       → Cliente Python para API del Space
+- examples.py     → Ejemplos avanzados de uso
+- tests.py        → Suite de pruebas automáticas
+
+📚 DOCUMENTACIÓN:
+- README.md       → Instrucciones completas de setup y uso
+
+🚀 CARACTERÍSTICAS IMPLEMENTADAS:
+
+✓ Sistema de colas (una petición a la vez)
+✓ Streaming en tiempo real  
+✓ API completa para cliente Python
+✓ Soporte para system prompt, message e history
+✓ Interfaz web con Gradio
+✓ Monitoreo de estado de cola
+✓ Manejo de errores robusto
+✓ Configuración para hf_token
+✓ Validación de parámetros
+✓ Estimación de tokens
+✓ Historial de conversación
+✓ Múltiples temperaturas
+✓ Límites configurables
+
+🔧 PASOS SIGUIENTES:
+
+1. Crear Space en Hugging Face:
+   - Ve a https://huggingface.co/new-space
+   - Selecciona Gradio SDK
+   - Elige hardware T4 small o superior
+
+2. Configurar HF_TOKEN:
+   - Settings → Repository secrets
+   - Agregar HF_TOKEN con tu token de acceso
+
+3. Subir archivos:
+   - app.py y requirements.txt son obligatorios
+   - Los demás archivos son opcionales pero recomendados
+
+4. Probar funcionalidad:
+   - Usar tests.py para verificar el funcionamiento
+   - Usar examples.py para casos de uso avanzados
+
+📖 DOCUMENTACIÓN COMPLETA:
+Revisar README.md para instrucciones detalladas de configuración,
+uso de la API, troubleshooting y ejemplos de integración.
+
+¡Tu Space está listo para ser desplegado! 🚀
+"""
+
+print(summary)
+
+# Guardar resumen
+with open("RESUMEN.md", "w", encoding="utf-8") as f:
+    f.write(summary)

tests.py

@@ -0,0 +1,217 @@
+# tests.py - Pruebas para verificar el funcionamiento
+
+from client import LlamaClient
+import time
+import json
+
+def test_basic_functionality(base_url: str):
+    """Pruebas básicas de funcionalidad"""
+    print("🧪 Ejecutando pruebas básicas...")
+    client = LlamaClient(base_url)
+
+    tests = []
+
+    # Test 1: Chat simple
+    print("\n1. Test chat simple...")
+    try:
+        response = client.chat(
+            message="Hola, ¿puedes presentarte en una línea?",
+            max_tokens=50
+        )
+
+        if "error" in response:
+            tests.append(("Chat simple", False, response['error']))
+        else:
+            tests.append(("Chat simple", True, f"Respuesta: {response['response'][:50]}..."))
+    except Exception as e:
+        tests.append(("Chat simple", False, str(e)))
+
+    # Test 2: Chat con system prompt
+    print("2. Test system prompt...")
+    try:
+        response = client.chat(
+            message="¿Cuánto es 2+2?",
+            system_prompt="Eres una calculadora. Solo responde con números.",
+            max_tokens=20
+        )
+
+        success = "error" not in response and "4" in response.get('response', '')
+        tests.append(("System prompt", success, response.get('response', 'No response')))
+    except Exception as e:
+        tests.append(("System prompt", False, str(e)))
+
+    # Test 3: Chat con historial
+    print("3. Test historial...")
+    try:
+        history = [["¿Cómo te llamas?", "Soy un asistente de IA."]]
+        response = client.chat(
+            message="¿Recuerdas cómo te llamas?",
+            history=history,
+            max_tokens=50
+        )
+
+        success = "error" not in response
+        tests.append(("Historial", success, response.get('response', 'Error')[:50]))
+    except Exception as e:
+        tests.append(("Historial", False, str(e)))
+
+    # Test 4: Streaming
+    print("4. Test streaming...")
+    try:
+        chunks_received = 0
+        final_response = ""
+
+        for chunk in client.chat_stream(
+            message="Cuenta del 1 al 5",
+            max_tokens=30
+        ):
+            chunks_received += 1
+            if "error" in chunk:
+                tests.append(("Streaming", False, chunk['error']))
+                break
+
+            final_response = chunk['response']
+            if chunk.get("is_complete", False):
+                break
+
+        success = chunks_received > 1 and final_response
+        tests.append(("Streaming", success, f"{chunks_received} chunks, respuesta: {final_response[:30]}"))
+    except Exception as e:
+        tests.append(("Streaming", False, str(e)))
+
+    # Test 5: Estado de cola
+    print("5. Test estado de cola...")
+    try:
+        status = client.get_queue_status()
+        success = "queue_size" in status and "is_processing" in status
+        tests.append(("Estado cola", success, str(status)))
+    except Exception as e:
+        tests.append(("Estado cola", False, str(e)))
+
+    # Mostrar resultados
+    print("\n" + "="*60)
+    print("📊 RESULTADOS DE PRUEBAS")
+    print("="*60)
+
+    passed = 0
+    for test_name, success, details in tests:
+        status = "✅ PASS" if success else "❌ FAIL"
+        print(f"{status} {test_name}: {details}")
+        if success:
+            passed += 1
+
+    print(f"\n🎯 Resultado: {passed}/{len(tests)} pruebas pasaron")
+    return passed == len(tests)
+
+def stress_test(base_url: str, num_requests: int = 5):
+    """Prueba de estrés con múltiples requests"""
+    print(f"\n⚡ Prueba de estrés ({num_requests} requests)...")
+    client = LlamaClient(base_url)
+
+    start_time = time.time()
+    results = []
+
+    for i in range(num_requests):
+        print(f"Request {i+1}/{num_requests}...", end=" ")
+
+        try:
+            request_start = time.time()
+            response = client.chat(
+                message=f"Esta es la request número {i+1}. Responde brevemente.",
+                max_tokens=50
+            )
+            request_time = time.time() - request_start
+
+            if "error" in response:
+                print(f"❌ Error: {response['error']}")
+                results.append({"success": False, "time": request_time, "error": response['error']})
+            else:
+                print(f"✅ {request_time:.2f}s")
+                results.append({"success": True, "time": request_time, "response_length": len(response['response'])})
+
+        except Exception as e:
+            print(f"❌ Exception: {e}")
+            results.append({"success": False, "time": 0, "error": str(e)})
+
+    total_time = time.time() - start_time
+
+    # Análisis de resultados
+    successful = [r for r in results if r['success']]
+    failed = [r for r in results if not r['success']]
+
+    print(f"\n📈 Análisis de estrés:")
+    print(f"  • Total: {total_time:.2f}s")
+    print(f"  • Exitosas: {len(successful)}/{num_requests}")
+    print(f"  • Fallidas: {len(failed)}/{num_requests}")
+
+    if successful:
+        avg_time = sum(r['time'] for r in successful) / len(successful)
+        print(f"  • Tiempo promedio: {avg_time:.2f}s")
+
+    return len(successful) == num_requests
+
+def performance_benchmark(base_url: str):
+    """Benchmark de rendimiento"""
+    print("\n🏁 Benchmark de rendimiento...")
+    client = LlamaClient(base_url)
+
+    test_cases = [
+        ("Respuesta corta", "Hola", 20),
+        ("Respuesta media", "Explica qué es Python en un párrafo", 100),
+        ("Respuesta larga", "Describe la historia de la programación", 300),
+    ]
+
+    for test_name, message, max_tokens in test_cases:
+        print(f"\n{test_name} ({max_tokens} tokens)...")
+
+        # Test sin streaming
+        start_time = time.time()
+        response = client.chat(message=message, max_tokens=max_tokens)
+        normal_time = time.time() - start_time
+
+        if "error" in response:
+            print(f"  ❌ Error: {response['error']}")
+            continue
+
+        # Test con streaming
+        start_time = time.time()
+        for chunk in client.chat_stream(message=message, max_tokens=max_tokens):
+            if chunk.get("is_complete", False):
+                break
+        stream_time = time.time() - start_time
+
+        print(f"  • Sin streaming: {normal_time:.2f}s")
+        print(f"  • Con streaming: {stream_time:.2f}s")
+        print(f"  • Tokens generados: ~{len(response['response'])} chars")
+
+def main():
+    """Ejecutar todas las pruebas"""
+    base_url = input("Ingresa la URL de tu Space: ").strip()
+
+    if not base_url:
+        print("❌ URL requerida")
+        return
+
+    if not base_url.startswith(('http://', 'https://')):
+        base_url = f"https://{base_url}"
+
+    print(f"🧪 Probando Space: {base_url}")
+    print("="*60)
+
+    # Ejecutar pruebas
+    basic_ok = test_basic_functionality(base_url)
+
+    if basic_ok:
+        print("\n✅ Pruebas básicas exitosas. Continuando...")
+        stress_ok = stress_test(base_url, 3)
+        performance_benchmark(base_url)
+
+        if stress_ok:
+            print("\n🎉 ¡Todas las pruebas pasaron! El Space funciona correctamente.")
+        else:
+            print("\n⚠️ Algunas pruebas de estrés fallaron. Verifica el rendimiento.")
+    else:
+        print("\n❌ Pruebas básicas fallaron. Verifica la configuración del Space.")
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,185 @@
+# utils.py - Utilidades para el Space
+
+import time
+import functools
+import logging
+from typing import List, Dict, Callable, Any
+from datetime import datetime
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def timing_decorator(func: Callable) -> Callable:
+    """Decorator para medir tiempo de ejecución"""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+
+        logger.info(f"{func.__name__} ejecutado en {end_time - start_time:.2f}s")
+        return result
+    return wrapper
+
+def sanitize_input(text: str, max_length: int = 2000) -> str:
+    """Sanitizar entrada del usuario"""
+    if not isinstance(text, str):
+        return ""
+
+    # Truncar si es muy largo
+    text = text[:max_length]
+
+    # Limpiar caracteres problemáticos
+    text = text.replace('\x00', '')  # Null bytes
+    text = text.strip()
+
+    return text
+
+def format_history(history: List[List[str]]) -> List[List[str]]:
+    """Formatear y validar historial de chat"""
+    if not history:
+        return []
+
+    formatted_history = []
+    for item in history:
+        if isinstance(item, list) and len(item) == 2:
+            user_msg = sanitize_input(str(item[0]))
+            assistant_msg = sanitize_input(str(item[1]))
+
+            if user_msg and assistant_msg:
+                formatted_history.append([user_msg, assistant_msg])
+
+    # Limitar historial a últimas 10 conversaciones
+    return formatted_history[-10:]
+
+def estimate_tokens(text: str) -> int:
+    """Estimación aproximada de tokens"""
+    # Aproximación: ~4 caracteres por token en español
+    return len(text) // 4
+
+def validate_parameters(max_tokens: int, temperature: float) -> Dict[str, Any]:
+    """Validar parámetros de generación"""
+    from config import Config
+
+    errors = []
+
+    # Validar max_tokens
+    if not isinstance(max_tokens, int):
+        max_tokens = Config.DEFAULT_MAX_TOKENS
+        errors.append("max_tokens debe ser un entero")
+    elif max_tokens < Config.MIN_TOKENS_LIMIT:
+        max_tokens = Config.MIN_TOKENS_LIMIT
+        errors.append(f"max_tokens mínimo es {Config.MIN_TOKENS_LIMIT}")
+    elif max_tokens > Config.MAX_TOKENS_LIMIT:
+        max_tokens = Config.MAX_TOKENS_LIMIT
+        errors.append(f"max_tokens máximo es {Config.MAX_TOKENS_LIMIT}")
+
+    # Validar temperature
+    if not isinstance(temperature, (int, float)):
+        temperature = Config.DEFAULT_TEMPERATURE
+        errors.append("temperature debe ser un número")
+    elif temperature < Config.MIN_TEMPERATURE:
+        temperature = Config.MIN_TEMPERATURE
+        errors.append(f"temperature mínima es {Config.MIN_TEMPERATURE}")
+    elif temperature > Config.MAX_TEMPERATURE:
+        temperature = Config.MAX_TEMPERATURE
+        errors.append(f"temperature máxima es {Config.MAX_TEMPERATURE}")
+
+    return {
+        "max_tokens": max_tokens,
+        "temperature": float(temperature),
+        "errors": errors
+    }
+
+def create_error_response(error_msg: str) -> Dict[str, Any]:
+    """Crear respuesta de error estandarizada"""
+    return {
+        "response": f"Error: {error_msg}",
+        "queue_status": {
+            "queue_size": 0,
+            "is_processing": False,
+            "timestamp": datetime.now().isoformat(),
+            "error": True
+        }
+    }
+
+def truncate_context(text: str, max_length: int = 1800) -> str:
+    """Truncar contexto manteniendo coherencia"""
+    if len(text) <= max_length:
+        return text
+
+    # Truncar por párrafos si es posible
+    paragraphs = text.split('\n\n')
+    truncated = ""
+
+    for paragraph in paragraphs:
+        if len(truncated + paragraph) <= max_length:
+            truncated += paragraph + '\n\n'
+        else:
+            break
+
+    # Si no hay párrafos, truncar por oraciones
+    if not truncated:
+        sentences = text.split('. ')
+        for sentence in sentences:
+            if len(truncated + sentence) <= max_length:
+                truncated += sentence + '. '
+            else:
+                break
+
+    # Último recurso: truncar directamente
+    if not truncated:
+        truncated = text[:max_length]
+
+    return truncated.strip()
+
+class PerformanceMonitor:
+    """Monitor de rendimiento simple"""
+
+    def __init__(self):
+        self.stats = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "total_tokens_generated": 0,
+            "average_response_time": 0,
+            "start_time": datetime.now()
+        }
+
+    def record_request(self, success: bool, tokens_generated: int = 0, response_time: float = 0):
+        """Registrar una request"""
+        self.stats["total_requests"] += 1
+
+        if success:
+            self.stats["successful_requests"] += 1
+            self.stats["total_tokens_generated"] += tokens_generated
+        else:
+            self.stats["failed_requests"] += 1
+
+        # Actualizar tiempo promedio de respuesta
+        if response_time > 0:
+            current_avg = self.stats["average_response_time"]
+            total_requests = self.stats["total_requests"]
+
+            self.stats["average_response_time"] = (
+                (current_avg * (total_requests - 1) + response_time) / total_requests
+            )
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Obtener estadísticas"""
+        uptime = datetime.now() - self.stats["start_time"]
+
+        return {
+            **self.stats,
+            "uptime_seconds": uptime.total_seconds(),
+            "success_rate": (
+                self.stats["successful_requests"] / max(self.stats["total_requests"], 1)
+            ) * 100,
+            "tokens_per_minute": (
+                self.stats["total_tokens_generated"] / max(uptime.total_seconds() / 60, 1)
+            )
+        }
+
+# Instancia global del monitor
+performance_monitor = PerformanceMonitor()