Update app.py

app.py

@@ -4,9 +4,8 @@ import torch
 import json
 import time
 import gc
-import re
 from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from huggingface_hub import snapshot_download
@@ -31,10 +30,11 @@ if DEVICE == "cpu":
 
 torch.set_grad_enabled(False)
 
-MODEL_REPO = "TeszenAI/MTP-3"
+# CAMBIA ESTO POR EL NOMBRE DE TU REPO EN HUGGING FACE
+MODEL_REPO = "TeszenAI/MTP-3"  # <-- CAMBIA A TU REPO
 
 # ======================
-# ARQUITECTURA DEL MODELO MEJORADA
+# DEFINIR ARQUITECTURA DEL MODELO (MTP)
 # ======================
 class LayerNorm(nn.Module):
     def __init__(self, d_model: int, eps: float = 1e-5):
@@ -42,6 +42,7 @@ class LayerNorm(nn.Module):
         self.weight = nn.Parameter(torch.ones(d_model))
         self.bias = nn.Parameter(torch.zeros(d_model))
         self.eps = eps
+    
     def forward(self, x):
         mean = x.mean(-1, keepdim=True)
         std = x.std(-1, keepdim=True)
@@ -60,6 +61,7 @@ class MultiHeadAttention(nn.Module):
         self.w_o = nn.Linear(d_model, d_model)
         self.dropout = nn.Dropout(dropout)
         self.scale = math.sqrt(self.d_k)
+        
     def forward(self, x, mask=None):
         batch_size, seq_len, _ = x.shape
         Q = self.w_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
@@ -80,6 +82,7 @@ class FeedForward(nn.Module):
         self.linear1 = nn.Linear(d_model, d_ff)
         self.linear2 = nn.Linear(d_ff, d_model)
         self.dropout = nn.Dropout(dropout)
+        
     def forward(self, x):
         return self.linear2(self.dropout(F.gelu(self.linear1(x))))
 
@@ -92,6 +95,7 @@ class TransformerBlock(nn.Module):
         self.norm2 = LayerNorm(d_model)
         self.dropout1 = nn.Dropout(dropout)
         self.dropout2 = nn.Dropout(dropout)
+        
     def forward(self, x, mask=None):
         attn_output = self.attention(x, mask)
         x = x + self.dropout1(attn_output)
@@ -110,6 +114,7 @@ class PositionalEncoding(nn.Module):
         pe[:, 0::2] = torch.sin(position * div_term)
         pe[:, 1::2] = torch.cos(position * div_term)
         self.register_buffer('pe', pe.unsqueeze(0))
+        
     def forward(self, x):
         return x + self.pe[:, :x.size(1), :]
 
@@ -122,7 +127,9 @@ class MTPModel(nn.Module):
         self.max_len = max_len
         self.token_embedding = nn.Embedding(vocab_size, d_model)
         self.pos_encoding = PositionalEncoding(d_model, max_len)
-        self.blocks = nn.ModuleList([TransformerBlock(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)])
+        self.blocks = nn.ModuleList([
+            TransformerBlock(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)
+        ])
         self.norm = LayerNorm(d_model)
         self.lm_head = nn.Linear(d_model, vocab_size)
         
@@ -134,147 +141,54 @@ class MTPModel(nn.Module):
         for block in self.blocks:
             x = block(x, mask)
         x = self.norm(x)
-        return self.lm_head(x)
-
-# ======================
-# NLP UTILITIES - PROCESAMIENTO DE LENGUAJE NATURAL
-# ======================
-class NLPProcessor:
-    """Procesador de lenguaje natural para entender mejor las intenciones"""
+        logits = self.lm_head(x)
+        return logits
     
-    @staticmethod
-    def detect_intent(text):
-        """Detecta la intención del usuario"""
-        text_lower = text.lower()
-        
-        intents = {
-            'saludo': ['hola', 'buenas', 'que tal', 'cómo estás', 'hey', 'saludos'],
-            'despedida': ['adiós', 'chao', 'hasta luego', 'nos vemos', 'bye'],
-            'agradecimiento': ['gracias', 'gracias por', 'te agradezco', 'muchas gracias'],
-            'pregunta': ['qué es', 'cómo funciona', 'por qué', 'cuándo', 'dónde', 'quién'],
-            'ayuda': ['ayuda', 'necesito ayuda', 'puedes ayudarme', 'me ayudas'],
-            'presentacion': ['quién eres', 'qué eres', 'presentate', 'eres'],
-            'capacidad': ['qué puedes hacer', 'funciones', 'capacidades', 'que sabes hacer'],
-            'sentimiento': ['estoy triste', 'estoy feliz', 'me siento', 'emocionado']
-        }
-        
-        for intent, keywords in intents.items():
-            for keyword in keywords:
-                if keyword in text_lower:
-                    return intent
-        return 'general'
-    
-    @staticmethod
-    def should_stop(response, min_length=30, max_length=200):
-        """Determina si la respuesta debe terminar"""
-        
-        # Palabras que indican final de respuesta
-        stop_phrases = [
-            '¿alguna otra pregunta?', '¿en qué más puedo ayudarte?',
-            '¿necesitas ayuda con algo más?', '¿tienes alguna otra duda?',
-            'espero haberte ayudado', 'que tengas un buen día',
-            'hasta luego', 'adiós', 'saludos', 'gracias por consultar'
-        ]
-        
-        # Si es demasiado corta, continuar
-        if len(response) < min_length:
-            return False
-        
-        # Si excede el máximo, cortar
-        if len(response) > max_length:
-            return True
-        
-        # Verificar frases de parada
-        for phrase in stop_phrases:
-            if phrase in response.lower():
-                return True
+    def generate(self, input_ids, max_new_tokens=100, temperature=0.8, top_k=50, top_p=0.9, repetition_penalty=1.1):
+        """Método de generación compatible con la interfaz"""
+        generated = input_ids
         
-        # Verificar si termina con puntuación adecuada
-        if len(response) > 50:
-            last_chars = response[-10:]
-            # Termina con punto, signo de interrogación o exclamación
-            if any(last_chars.rstrip().endswith(p) for p in ['.', '?', '!', '…']):
-                # Contar oraciones completas
-                sentences = re.split(r'[.!?]+', response)
-                if len(sentences) >= 2:  # Al menos 2 oraciones completas
-                    return True
-        
-        return False
-    
-    @staticmethod
-    def clean_response(text):
-        """Limpia y mejora la respuesta"""
-        # Eliminar repeticiones excesivas
-        text = re.sub(r'(\b\w+\b)(?:\s+\1\b)+', r'\1', text)
-        
-        # Corregir espaciado
-        text = re.sub(r'\s+([.,!?;:])', r'\1', text)
-        
-        # Asegurar mayúscula al inicio
-        if text and text[0].islower():
-            text = text[0].upper() + text[1:]
-        
-        # Agregar punto final si no tiene
-        if text and not text[-1] in '.!?':
-            text += '.'
-        
-        return text.strip()
-    
-    @staticmethod
-    def extract_key_info(text):
-        """Extrae información clave del texto"""
-        # Detectar números
-        numbers = re.findall(r'\d+(?:\.\d+)?', text)
-        
-        # Detectar emails
-        emails = re.findall(r'[\w\.-]+@[\w\.-]+\.\w+', text)
-        
-        # Detectar URLs
-        urls = re.findall(r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+', text)
+        for _ in range(max_new_tokens):
+            with torch.no_grad():
+                logits = self(generated)
+                next_logits = logits[0, -1, :] / temperature
+            
+            if repetition_penalty != 1.0:
+                for token_id in set(generated[0].tolist()):
+                    next_logits[token_id] /= repetition_penalty
+            
+            if top_k > 0:
+                indices_to_remove = next_logits < torch.topk(next_logits, top_k)[0][..., -1, None]
+                next_logits[indices_to_remove] = float('-inf')
+            
+            if top_p < 1.0:
+                sorted_logits, sorted_indices = torch.sort(next_logits, descending=True)
+                cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                sorted_indices_to_remove = cumulative_probs > top_p
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                indices_to_remove = sorted_indices[sorted_indices_to_remove]
+                next_logits[indices_to_remove] = float('-inf')
+            
+            probs = F.softmax(next_logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1).item()
+            
+            if next_token == 3:  # EOS ID para SentencePiece
+                break
+            
+            generated = torch.cat([generated, torch.tensor([[next_token]], device=generated.device)], dim=1)
         
-        return {
-            'has_numbers': bool(numbers),
-            'has_emails': bool(emails),
-            'has_urls': bool(urls),
-            'numbers': numbers,
-            'emails': emails,
-            'urls': urls
-        }
+        return generated
 
 # ======================
 # DESCARGA Y CARGA DEL MODELO
 # ======================
-def download_with_retry(repo_id, local_dir, max_retries=3):
-    for attempt in range(max_retries):
-        try:
-            print(f"📦 Intento {attempt + 1}/{max_retries} - Descargando modelo...")
-            repo_path = snapshot_download(
-                repo_id=repo_id,
-                repo_type="model",
-                local_dir=local_dir,
-                resume_download=True,
-                local_files_only=False
-            )
-            print(f"✅ Modelo descargado")
-            return repo_path
-        except Exception as e:
-            print(f"⚠️ Error: {str(e)[:100]}")
-            if attempt < max_retries - 1:
-                time.sleep(3)
-            else:
-                raise
-    return local_dir
-
-print(f"🚀 Cargando modelo...")
-
-if os.path.exists("mtp_repo") and os.path.exists("mtp_repo/mtp_model.pt"):
-    print("📁 Modelo en caché")
-    repo_path = "mtp_repo"
-else:
-    try:
-        repo_path = download_with_retry(MODEL_REPO, "mtp_repo", max_retries=3)
-    except:
-        repo_path = "mtp_repo"
+print(f"📦 Descargando modelo desde {MODEL_REPO}...")
+repo_path = snapshot_download(
+    repo_id=MODEL_REPO,
+    repo_type="model",
+    local_dir="mtp_repo"
+)
 
 # Cargar configuración
 config_path = os.path.join(repo_path, "config.json")
@@ -283,7 +197,7 @@ if os.path.exists(config_path):
         config = json.load(f)
 else:
     config = {
-        "vocab_size": 2000,
+        "vocab_size": 5000,
         "d_model": 256,
         "n_heads": 8,
         "n_layers": 6,
@@ -294,43 +208,56 @@ else:
 
 # Cargar tokenizador
 tokenizer_path = os.path.join(repo_path, "mtp_tokenizer.model")
-if os.path.exists(tokenizer_path):
-    sp = spm.SentencePieceProcessor()
-    sp.load(tokenizer_path)
-    VOCAB_SIZE = sp.get_piece_size()
-    config["vocab_size"] = VOCAB_SIZE
-    print(f"✅ Tokenizador: {VOCAB_SIZE} tokens")
-else:
-    sp = None
-    VOCAB_SIZE = config.get("vocab_size", 2000)
+sp = spm.SentencePieceProcessor()
+sp.load(tokenizer_path)
+VOCAB_SIZE = sp.get_piece_size()
 
-print(f"🧠 Inicializando modelo...")
+# Actualizar vocab_size en config
+config["vocab_size"] = VOCAB_SIZE
+
+print(f"🧠 Inicializando modelo MTP...")
 print(f"   → Vocabulario: {VOCAB_SIZE}")
 print(f"   → Dimensión: {config['d_model']}")
 print(f"   → Capas: {config['n_layers']}")
+print(f"   → Heads: {config['n_heads']}")
 
 model = MTPModel(**config)
 model.to(DEVICE)
 
-# Cargar pesos
+# Cargar pesos del modelo
 model_path = os.path.join(repo_path, "mtp_model.pt")
 if os.path.exists(model_path):
-    try:
-        state_dict = torch.load(model_path, map_location=DEVICE)
-        model.load_state_dict(state_dict)
-        print("✅ Pesos cargados")
-    except Exception as e:
-        print(f"⚠️ Error cargando pesos: {e}")
+    state_dict = torch.load(model_path, map_location=DEVICE)
+    model.load_state_dict(state_dict)
+    print("✅ Pesos del modelo cargados")
+else:
+    print("⚠️ No se encontró mtp_model.pt, usando pesos aleatorios")
 
 model.eval()
 
+# Cuantización para CPU
+if DEVICE == "cpu":
+    print("⚡ Aplicando cuantización dinámica para CPU...")
+    try:
+        model = torch.quantization.quantize_dynamic(
+            model, 
+            {nn.Linear}, 
+            dtype=torch.qint8
+        )
+    except Exception as e:
+        print(f"⚠️ No se pudo aplicar cuantización: {e}")
+
 param_count = sum(p.numel() for p in model.parameters())
-print(f"✅ Modelo listo: {param_count:,} parámetros ({param_count/1e6:.1f}M)")
+print(f"✅ Modelo cargado: {param_count:,} parámetros ({param_count/1e6:.1f}M)")
 
 # ======================
 # API CONFIG
 # ======================
-app = FastAPI(title="MTP API - Versión Mejorada", description="API con NLP integrado", version="2.0")
+app = FastAPI(
+    title="MTP API",
+    description="API para modelo de lenguaje MTP",
+    version="1.0"
+)
 
 app.add_middleware(
     CORSMiddleware,
@@ -340,210 +267,117 @@ app.add_middleware(
 )
 
 class PromptRequest(BaseModel):
-    text: str = Field(..., max_length=2000)
-    max_tokens: int = Field(default=150, ge=10, le=300)
-    temperature: float = Field(default=0.7, ge=0.1, le=2.0)
-    top_k: int = Field(default=50, ge=1, le=100)
-    top_p: float = Field(default=0.9, ge=0.1, le=1.0)
+    text: str = Field(..., max_length=2000, description="Texto de entrada")
+    max_tokens: int = Field(default=150, ge=10, le=300, description="Tokens máximos a generar")
+    temperature: float = Field(default=0.7, ge=0.1, le=2.0, description="Temperatura de muestreo")
+    top_k: int = Field(default=50, ge=1, le=100, description="Top-k sampling")
+    top_p: float = Field(default=0.9, ge=0.1, le=1.0, description="Top-p (nucleus) sampling")
+    repetition_penalty: float = Field(default=1.1, ge=1.0, le=2.0, description="Penalización por repetición")
 
-# Inicializar NLP
-nlp = NLPProcessor()
+def build_prompt(user_input: str) -> str:
+    """Construye el prompt en el formato del modelo"""
+    return f"### Instrucción:\n{user_input}\n\n### Respuesta:\n"
 
 # ======================
-# GENERACIÓN INTELIGENTE MEJORADA
-# ======================
-def generate_response_intelligent(model, tokenizer, prompt, max_length=150, temperature=0.7, top_k=50, top_p=0.9, device='cpu'):
-    model.eval()
-    
-    # Detectar intención para ajustar comportamiento
-    intent = nlp.detect_intent(prompt)
-    
-    # Ajustar temperatura según intención
-    if intent == 'despedida':
-        temperature = 0.5  # Más determinista
-        max_length = min(max_length, 60)  # Respuestas cortas
-    elif intent == 'pregunta':
-        temperature = 0.6  # Más preciso
-    elif intent == 'agradecimiento':
-        temperature = 0.5
-        max_length = min(max_length, 50)
-    
-    formatted_prompt = f"### Instrucción:\n{prompt}\n\n### Respuesta:\n"
-    input_ids = tokenizer.encode(formatted_prompt)
-    generated = input_ids.copy()
-    eos_id = tokenizer.eos_id()
-    
-    # Contadores para control de parada
-    consecutive_punctuation = 0
-    last_chars = []
-    
-    for step in range(max_length):
-        input_tensor = torch.tensor([generated[-model.max_len:]], dtype=torch.long).to(device)
-        with torch.no_grad():
-            logits = model(input_tensor)
-            next_logits = logits[0, -1, :] / temperature
-        
-        # Top-k filtering
-        if top_k > 0:
-            indices_to_remove = next_logits < torch.topk(next_logits, top_k)[0][..., -1, None]
-            next_logits[indices_to_remove] = float('-inf')
-        
-        # Top-p filtering
-        if top_p < 1.0:
-            sorted_logits, sorted_indices = torch.sort(next_logits, descending=True)
-            cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
-            sorted_indices_to_remove = cumulative_probs > top_p
-            sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
-            sorted_indices_to_remove[..., 0] = 0
-            indices_to_remove = sorted_indices[sorted_indices_to_remove]
-            next_logits[indices_to_remove] = float('-inf')
-        
-        probs = F.softmax(next_logits, dim=-1)
-        next_token = torch.multinomial(probs, 1).item()
-        
-        # Detener en EOS
-        if next_token == eos_id:
-            break
-        
-        # Detener si hay demasiados signos de puntuación seguidos
-        token_str = tokenizer.decode([next_token]) if hasattr(tokenizer, 'decode') else str(next_token)
-        if token_str in '.!?':
-            consecutive_punctuation += 1
-            if consecutive_punctuation >= 3:
-                break
-        else:
-            consecutive_punctuation = 0
-        
-        # Guardar últimos caracteres para análisis
-        last_chars.append(token_str)
-        if len(last_chars) > 20:
-            last_chars.pop(0)
-        
-        # Detectar bucles de repetición
-        if len(last_chars) >= 10:
-            last_str = ''.join(last_chars[-5:])
-            if last_str in ''.join(last_chars[:-5]):
-                break
-        
-        generated.append(next_token)
-        
-        # Verificar si ya es suficiente (para respuestas cortas)
-        current_response = tokenizer.decode(generated)
-        if "### Respuesta:" in current_response:
-            response_part = current_response.split("### Respuesta:")[-1].strip()
-            if nlp.should_stop(response_part, min_length=20, max_length=max_length):
-                break
-    
-    # Decodificar respuesta
-    response = tokenizer.decode(generated)
-    
-    # Extraer la parte de la respuesta
-    if "### Respuesta:" in response:
-        response = response.split("### Respuesta:")[-1].strip()
-    elif "Respuesta:" in response:
-        response = response.split("Respuesta:")[-1].strip()
-    elif "[/INST]" in response:
-        response = response.split("[/INST]")[-1].strip()
-    
-    # Limpiar y mejorar respuesta
-    garbage_words = ['foompañances', 'ciudadores', 'mejtedon', 'calportedon', 'rápidodcor', 'baon', 'domol']
-    for word in garbage_words:
-        response = response.replace(word, '')
-    
-    # Limpiar caracteres especiales
-    response = re.sub(r'[^\w\s\u00C0-\u00FF\u0100-\u017F.,!?¿¡()\-:;"\']+', ' ', response)
-    response = re.sub(r'\s+', ' ', response).strip()
-    
-    # Aplicar NLP a la respuesta
-    response = nlp.clean_response(response)
-    
-    # Respuestas por defecto según intención si está vacía
-    if len(response) < 3:
-        default_responses = {
-            'saludo': "¡Hola! ¿En qué puedo ayudarte hoy?",
-            'despedida': "¡Hasta luego! Que tengas un excelente día.",
-            'agradecimiento': "¡De nada! Estoy aquí para ayudarte cuando lo necesites.",
-            'ayuda': "Claro, estoy aquí para ayudarte. ¿Qué necesitas saber?",
-            'presentacion': "Soy MTP, un asistente virtual creado para responder preguntas y ayudarte con información.",
-            'general': "Entendido. ¿Hay algo específico en lo que pueda ayudarte?"
-        }
-        response = default_responses.get(intent, default_responses['general'])
-    
-    return response
-
-# ======================
-# ENDPOINTS
+# GESTIÓN DE CARGA
 # ======================
 ACTIVE_REQUESTS = 0
 
-class TokenizerWrapper:
+class MTPTokenizer:
+    """Wrapper para el tokenizador de SentencePiece"""
     def __init__(self, sp_model):
         self.sp = sp_model
+    
     def encode(self, text):
-        if self.sp is None:
-            return [ord(c) % 1000 for c in text[:200]]
         return self.sp.encode(text)
+    
     def decode(self, tokens):
-        if self.sp is None:
-            return ''.join([chr(t % 128) if 32 <= t % 128 < 127 else ' ' for t in tokens])
         return self.sp.decode(tokens)
-    def eos_id(self):
-        return self.sp.eos_id() if self.sp else 3
+    
     def bos_id(self):
-        return self.sp.bos_id() if self.sp else 2
+        return self.sp.bos_id()
+    
+    def eos_id(self):
+        return self.sp.eos_id()
+    
     def pad_id(self):
-        return self.sp.pad_id() if self.sp else 0
+        return self.sp.pad_id()
 
-tokenizer_wrapper = TokenizerWrapper(sp)
+tokenizer_wrapper = MTPTokenizer(sp)
 
 @app.post("/generate")
 async def generate(req: PromptRequest):
+    """Endpoint principal de generación de texto"""
     global ACTIVE_REQUESTS
     ACTIVE_REQUESTS += 1
     
+    dyn_max_tokens = req.max_tokens
+    dyn_temperature = req.temperature
+    
+    if ACTIVE_REQUESTS > 2:
+        print(f"⚠️ Carga alta ({ACTIVE_REQUESTS} requests). Ajustando parámetros.")
+        dyn_max_tokens = min(dyn_max_tokens, 120)
+        dyn_temperature = max(0.5, dyn_temperature * 0.9)
+
     user_input = req.text.strip()
     if not user_input:
         ACTIVE_REQUESTS -= 1
-        return {"reply": "", "tokens_generated": 0, "intent": None}
-    
-    # Detectar intención
-    intent = nlp.detect_intent(user_input)
-    
+        return {"reply": "", "tokens_generated": 0}
+
+    full_prompt = build_prompt(user_input)
+    tokens = [tokenizer_wrapper.bos_id()] + tokenizer_wrapper.encode(full_prompt)
+    input_ids = torch.tensor([tokens], device=DEVICE)
+
     try:
-        response = generate_response_intelligent(
-            model, tokenizer_wrapper, user_input,
-            max_length=req.max_tokens,
-            temperature=req.temperature,
-            top_k=req.top_k,
-            top_p=req.top_p,
-            device=DEVICE
-        )
+        with torch.no_grad():
+            output_ids = model.generate(
+                input_ids,
+                max_new_tokens=dyn_max_tokens,
+                temperature=dyn_temperature,
+                top_k=req.top_k,
+                top_p=req.top_p,
+                repetition_penalty=req.repetition_penalty
+            )
+
+        gen_tokens = output_ids[0, len(tokens):].tolist()
+        
+        safe_tokens = [
+            t for t in gen_tokens 
+            if 0 <= t < VOCAB_SIZE and t != tokenizer_wrapper.eos_id()
+        ]
         
-        # Extraer información clave
-        key_info = nlp.extract_key_info(response)
+        response = tokenizer_wrapper.decode(safe_tokens).strip()
         
+        if "###" in response:
+            response = response.split("###")[0].strip()
+
         return {
             "reply": response,
-            "tokens_generated": len(response.split()),
-            "model": "MTP-Intelligent",
-            "intent": intent,
-            "has_numbers": key_info['has_numbers'],
-            "has_emails": key_info['has_emails']
+            "tokens_generated": len(safe_tokens),
+            "model": "MTP"
         }
+    
     except Exception as e:
-        print(f"❌ Error: {e}")
-        return {"reply": "Lo siento, ocurrió un error.", "error": str(e), "intent": intent}
+        print(f"❌ Error durante generación: {e}")
+        return {
+            "reply": "Lo siento, ocurrió un error al procesar tu solicitud.",
+            "error": str(e)
+        }
+    
     finally:
         ACTIVE_REQUESTS -= 1
         if DEVICE == "cuda":
             torch.cuda.empty_cache()
         gc.collect()
 
+# ======================
+# ENDPOINTS DE INFORMACIÓN
+# ======================
 @app.get("/health")
 def health_check():
     return {
         "status": "healthy",
-        "model": "MTP-Intelligent",
+        "model": "MTP",
         "device": DEVICE,
         "active_requests": ACTIVE_REQUESTS,
         "vocab_size": VOCAB_SIZE
@@ -552,26 +386,15 @@ def health_check():
 @app.get("/info")
 def model_info():
     return {
-        "model_name": "MTP-Intelligent",
-        "version": "2.0",
+        "model_name": "MTP",
+        "version": "1.0",
         "architecture": config,
         "parameters": sum(p.numel() for p in model.parameters()),
-        "device": DEVICE,
-        "nlp_enabled": True
-    }
-
-@app.post("/analyze")
-async def analyze_intent(req: PromptRequest):
-    """Endpoint para analizar intención sin generar respuesta"""
-    intent = nlp.detect_intent(req.text)
-    return {
-        "text": req.text,
-        "intent": intent,
-        "confidence": 0.85  # Por ahora fijo, se puede mejorar
+        "device": DEVICE
     }
 
 # ======================
-# INTERFAZ WEB MEJORADA
+# INTERFAZ WEB (MODERNA)
 # ======================
 @app.get("/", response_class=HTMLResponse)
 def chat_ui():
@@ -581,7 +404,7 @@ def chat_ui():
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-<title>MTP - Asistente Inteligente</title>
+<title>MTP - Asistente IA</title>
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
 <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600&display=swap" rel="stylesheet">
@@ -593,7 +416,6 @@ def chat_ui():
     --text-primary: #e3e3e3;
     --text-secondary: #9aa0a6;
     --user-bubble: #282a2c;
-    --success-color: #00c853;
 }
 * { box-sizing: border-box; outline: none; -webkit-tap-highlight-color: transparent; }
 body {
@@ -629,7 +451,12 @@ header {
     width: 32px;
     height: 32px;
     border-radius: 50%;
-    background: linear-gradient(135deg, #4a9eff, #00c853);
+    background: linear-gradient(135deg, #4a9eff, #7c3aed);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: bold;
+    font-size: 14px;
 }
 .brand-text {
     font-weight: 500;
@@ -696,7 +523,12 @@ header {
     height: 34px;
     min-width: 34px;
     border-radius: 50%;
-    background: linear-gradient(135deg, #4a9eff, #00c853);
+    background: linear-gradient(135deg, #4a9eff, #7c3aed);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: bold;
+    font-size: 14px;
     box-shadow: 0 2px 6px rgba(0,0,0,0.2);
 }
 .bot-actions {
@@ -723,14 +555,9 @@ header {
 }
 .action-btn svg { width: 16px; height: 16px; fill: currentColor; }
 .typing-cursor::after {
-    content: '';
+    content: '▊';
     display: inline-block;
-    width: 10px;
-    height: 10px;
-    background: var(--accent-color);
-    border-radius: 50%;
-    margin-left: 5px;
-    vertical-align: middle;
+    margin-left: 2px;
     animation: blink 1s infinite;
 }
 .footer-container {
@@ -764,8 +591,8 @@ header {
     padding: 10px 0;
 }
 #mainBtn {
-    background: var(--accent-color);
-    color: white;
+    background: white;
+    color: black;
     border: none;
     width: 36px;
     height: 36px;
@@ -777,7 +604,7 @@ header {
     margin-left: 8px;
     transition: transform 0.2s;
 }
-#mainBtn:hover { transform: scale(1.05); background: #3a7ed4; }
+#mainBtn:hover { transform: scale(1.05); }
 .disclaimer {
     text-align: center;
     font-size: 0.75rem;
@@ -795,15 +622,6 @@ header {
     100% { box-shadow: 0 0 0 0 rgba(74, 158, 255, 0); }
 }
 .pulsing { animation: pulseAvatar 1.5s infinite; }
-.intent-badge {
-    font-size: 0.7rem;
-    background: rgba(0, 200, 83, 0.15);
-    color: #00c853;
-    padding: 2px 8px;
-    border-radius: 12px;
-    display: inline-block;
-    margin-top: 5px;
-}
 ::-webkit-scrollbar { width: 8px; }
 ::-webkit-scrollbar-track { background: transparent; }
 ::-webkit-scrollbar-thumb { background: #333; border-radius: 4px; }
@@ -812,29 +630,29 @@ header {
 <body>
 <header>
     <div class="brand-wrapper" onclick="location.reload()">
-        <div class="brand-logo"></div>
+        <div class="brand-logo">MTP</div>
         <div class="brand-text">
-            MTP <span class="version-badge">Inteligente</span>
+            MTP <span class="version-badge">v1</span>
         </div>
     </div>
 </header>
 <div id="chatScroll" class="chat-scroll">
     <div class="msg-row bot" style="animation-delay: 0.1s;">
-        <div class="bot-avatar"></div>
+        <div class="bot-avatar">M</div>
         <div class="msg-content-wrapper">
             <div class="msg-text">
-                ¡Hola! Soy MTP, tu asistente inteligente. ¿En qué puedo ayudarte hoy?
+                ¡Hola! Soy MTP, tu asistente de IA. ¿En qué puedo ayudarte hoy?
             </div>
         </div>
     </div>
 </div>
 <div class="footer-container">
     <div class="input-box">
-        <input type="text" id="userInput" placeholder="Escribe tu mensaje..." autocomplete="off">
+        <input type="text" id="userInput" placeholder="Escribe un mensaje..." autocomplete="off">
         <button id="mainBtn" onclick="handleBtnClick()">➤</button>
     </div>
     <div class="disclaimer">
-        MTP usa NLP para entender mejor tu consulta • Respuestas inteligentes
+        MTP puede cometer errores. Considera verificar la información importante.
     </div>
 </div>
 <script>
@@ -852,10 +670,10 @@ function scrollToBottom() {
 
 function setBtnState(state) {
     if (state === 'sending') {
-        mainBtn.innerHTML = "⏹";
+        mainBtn.innerHTML = '⏹';
         isGenerating = true;
     } else {
-        mainBtn.innerHTML = "➤";
+        mainBtn.innerHTML = '➤';
         isGenerating = false;
         abortController = null;
     }
@@ -882,21 +700,19 @@ function stopGeneration() {
 
 async function sendMessage(textOverride = null) {
     const text = textOverride || userInput.value.trim();
-    if (!text || isGenerating) return;
-    
+    if (!text) return;
     lastUserPrompt = text;
     if (!textOverride) {
         userInput.value = '';
         addMessage(text, 'user');
     }
-    
     setBtnState('sending');
     abortController = new AbortController();
-    
     const botRow = document.createElement('div');
     botRow.className = 'msg-row bot';
     const avatar = document.createElement('div');
-    avatar.className = 'bot-avatar pulsing'; 
+    avatar.className = 'bot-avatar pulsing';
+    avatar.textContent = 'M';
     const wrapper = document.createElement('div');
     wrapper.className = 'msg-content-wrapper';
     const msgText = document.createElement('div');
@@ -906,35 +722,17 @@ async function sendMessage(textOverride = null) {
     botRow.appendChild(wrapper);
     chatScroll.appendChild(botRow);
     scrollToBottom();
-    
     try {
         const response = await fetch('/generate', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ 
-                text: text, 
-                max_tokens: 200,
-                temperature: 0.7,
-                top_k: 50,
-                top_p: 0.9
-            }),
+            body: JSON.stringify({ text: text }),
             signal: abortController.signal
         });
-        
         const data = await response.json();
         if (!isGenerating) return; 
-        
         avatar.classList.remove('pulsing');
         const reply = data.reply || "No entendí eso.";
-        
-        // Mostrar intención detectada si está disponible
-        if (data.intent && data.intent !== 'general') {
-            const intentSpan = document.createElement('div');
-            intentSpan.className = 'intent-badge';
-            intentSpan.textContent = `🎯 Intención: ${data.intent}`;
-            wrapper.appendChild(intentSpan);
-        }
-        
         await typeWriter(msgText, reply);
         if (isGenerating) {
             addActions(wrapper, reply);
@@ -945,7 +743,7 @@ async function sendMessage(textOverride = null) {
             msgText.textContent += " [Detenido]";
         } else {
             avatar.classList.remove('pulsing');
-            msgText.textContent = "Error de conexión. Intenta de nuevo.";
+            msgText.textContent = "Error de conexión.";
             msgText.style.color = "#ff8b8b";
             setBtnState('idle');
         }
@@ -963,7 +761,7 @@ function addMessage(text, sender) {
     scrollToBottom();
 }
 
-function typeWriter(element, text, speed = 10) {
+function typeWriter(element, text, speed = 12) {
     return new Promise(resolve => {
         let i = 0;
         element.classList.add('typing-cursor');
@@ -990,17 +788,18 @@ function typeWriter(element, text, speed = 10) {
 function addActions(wrapperElement, textToCopy) {
     const actionsDiv = document.createElement('div');
     actionsDiv.className = 'bot-actions';
-    
     const copyBtn = document.createElement('button');
     copyBtn.className = 'action-btn';
-    copyBtn.innerHTML = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
-    copyBtn.onclick = () => { navigator.clipboard.writeText(textToCopy); };
-    
+    copyBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
+    copyBtn.onclick = () => {
+        navigator.clipboard.writeText(textToCopy);
+    };
     const regenBtn = document.createElement('button');
     regenBtn.className = 'action-btn';
-    regenBtn.innerHTML = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M23 4v6h-6"></path><path d="M1 20v-6h6"></path><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path></svg>`;
-    regenBtn.onclick = () => { sendMessage(lastUserPrompt); };
-    
+    regenBtn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M23 4v6h-6"></path><path d="M1 20v-6h6"></path><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path></svg>`;
+    regenBtn.onclick = () => {
+        sendMessage(lastUserPrompt);
+    };
     actionsDiv.appendChild(copyBtn);
     actionsDiv.appendChild(regenBtn);
     wrapperElement.appendChild(actionsDiv);
@@ -1011,7 +810,6 @@ function addActions(wrapperElement, textToCopy) {
 userInput.addEventListener('keydown', (e) => {
     if (e.key === 'Enter') handleBtnClick();
 });
-
 window.onload = () => userInput.focus();
 </script>
 </body>
@@ -1020,7 +818,13 @@ window.onload = () => userInput.focus();
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    print(f"\n🚀 MTP Inteligente iniciado en puerto {port}")
-    print(f"🌐 http://0.0.0.0:{port}")
+    print(f"\n🚀 Iniciando servidor MTP en puerto {port}...")
+    print(f"🌐 Interfaz web: http://0.0.0.0:{port}")
+    print(f"📡 API docs: http://0.0.0.0:{port}/docs")
     
-    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )