Version 12

app.py

@@ -1,111 +1,175 @@
 import os
-import torch
 import gradio as gr
-import threading
-from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
-
-# 1) Cargar tokenizer y modelo
-print("Cargando tokenizer...")
-tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Llama-8B")
-
-print("Cargando modelo...")
-model = AutoModelForCausalLM.from_pretrained(
-    "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
-    device_map="auto",        # Usa GPU si está disponible
-    torch_dtype=torch.float16  # FP16 si GPU; en CPU, podrías usar float32
-)
-model.eval()
+import requests
+from huggingface_hub import InferenceClient
 
-# Ajuste de pad_token_id si fuese necesario
-if model.config.pad_token_id is None:
-    model.config.pad_token_id = tokenizer.eos_token_id
+"""
+For more information on `huggingface_hub` Inference API support, 
+please check the docs: 
+https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+"""
 
+# ----------------------------------------------------------------
+# CONFIGURACIÓN DE SERPER (búsqueda web)
+# ----------------------------------------------------------------
+SERPER_API_KEY = os.getenv("SERPER_API_KEY")
 
-def respond(
-    user_message: str,
-    history: list[tuple[str, str]],
-    system_message: str,
-    max_new_tokens: int,
-    temperature: float,
-    top_p: float,
-):
+def do_websearch(query: str) -> str:
     """
-    Llamada por ChatInterface en cada turno.
-      - user_message: Texto nuevo del usuario.
-      - history: Lista [(usuario, asistente), ...] de turnos previos.
-      - system_message: Se añade SOLO si el historial está vacío.
-    Devuelve tokens progresivamente (streaming).
+    Llama a serper.dev para hacer la búsqueda en Google y devolver
+    un texto resumido de los resultados.
     """
+    if not SERPER_API_KEY:
+        return "(SERPER_API_KEY no está configurado)"
 
-    # 1) Creamos un prompt vacío
-    prompt = ""
+    url = "https://google.serper.dev/search"
+    headers = {
+        "X-API-KEY": SERPER_API_KEY,
+        "Content-Type": "application/json",
+    }
+    payload = {"q": query}
 
-    # 2) Solo añadimos system_message si no hay historial
-    if not history:
-        prompt += f"{system_message}\n\n"
+    try:
+        resp = requests.post(url, json=payload, headers=headers, timeout=10)
+        data = resp.json()
+    except Exception as e:
+        return f"(Error al llamar a serper.dev: {e})"
 
-    # 3) Añadimos la conversación previa: "User: ...\nAssistant: ..."
-    for (past_user, past_assistant) in history:
-        prompt += f"Usuario: {past_user}\nAsistente: {past_assistant}\n"
+    # Se espera un campo 'organic' con resultados
+    if "organic" not in data:
+        return "No se encontraron resultados en serper.dev."
 
-    # 4) Añadimos el nuevo turno del usuario
-    prompt += f"Usuario: {user_message}\nAsistente:"
+    results = data["organic"]
+    if not results:
+        return "No hay resultados relevantes."
 
-    # 5) Preparamos un TextIteratorStreamer para streaming
-    streamer = TextIteratorStreamer(tokenizer=tokenizer, skip_special_tokens=True)
+    text = []
+    for i, item in enumerate(results, start=1):
+        title = item.get("title", "Sin título")
+        link = item.get("link", "Sin enlace")
+        text.append(f"{i}. {title}\n   {link}")
 
-    # 6) Codificamos el prompt
-    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    return "\n".join(text)
 
-    # 7) Preparamos parámetros de generate
-    generation_kwargs = {
-        "inputs": inputs["input_ids"],
-        "attention_mask": inputs["attention_mask"],
-        "max_new_tokens": max_new_tokens,
-        "temperature": temperature,
-        "top_p": top_p,
-        "do_sample": True,
-        "streamer": streamer,
-    }
 
-    # 8) Ejecutamos model.generate en un hilo
-    generation_thread = threading.Thread(
-        target=model.generate,
-        kwargs=generation_kwargs
-    )
-    generation_thread.start()
+# ----------------------------------------------------------------
+# CONFIGURACIÓN DEL MODELO
+# ----------------------------------------------------------------
+client = InferenceClient("meta-llama/Llama-3.1-8B-Instruct")
 
-    # 9) Iteramos sobre el streamer para devolver tokens sucesivamente
-    output_text = ""
-    for new_token in streamer:
-        output_text += new_token
-        yield output_text
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    use_search  # <-- Nuevo parámetro: si está "activado" el botón
+):
+    """
+    - system_message: Texto del rol "system"
+    - history: lista de (user_msg, assistant_msg)
+    - message: Mensaje actual del usuario
+    - use_search: booleano que indica si se habilita la búsqueda en serper
+    """
 
-# 10) Definimos la interfaz ChatInterface
+    # ----------------------------------------------------------------
+    # 1) Si el toggle está activo, hacemos búsqueda y la agregamos al prompt
+    # ----------------------------------------------------------------
+    if use_search:
+        web_info = do_websearch(message)
+        # Agregamos info al final del texto del usuario
+        message = f"{message}\nInformación de la web:\n{web_info}"
+
+    # ----------------------------------------------------------------
+    # 2) Construimos la lista de mensajes para la API de chat
+    # ----------------------------------------------------------------
+    messages = [{"role": "system", "content": system_message}]
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    # Añadimos el mensaje nuevo del usuario (posiblemente complementado con la info web)
+    messages.append({"role": "user", "content": message})
+
+    # ----------------------------------------------------------------
+    # 3) Llamamos a la API con streaming de tokens
+    # ----------------------------------------------------------------
+    response = ""
+    for chunk in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = chunk.choices[0].delta.get("content", "")
+        response += token
+        yield response
+
+
+# ----------------------------------------------------------------
+# CONFIGURACIÓN DE LA INTERFAZ
+# ----------------------------------------------------------------
+# Para usar Tailwind, podemos asignar clases en "elem_classes".
+# Ejemplo de clases genéricas (puedes cambiarlas a tu gusto):
+tailwind_toggle_classes = [
+    "inline-flex", 
+    "items-center", 
+    "bg-blue-500", 
+    "hover:bg-blue-700",
+    "text-white", 
+    "font-bold", 
+    "py-1", 
+    "px-2", 
+    "rounded", 
+    "cursor-pointer"
+]
+
+# ChatInterface, con un input Checkbox para "🌐 Búsqueda"
 demo = gr.ChatInterface(
     fn=respond,
     additional_inputs=[
-        # Cuadro para "mensaje de sistema", solo usado en la 1ª interacción
         gr.Textbox(
-            label="Mensaje del sistema (se usará sólo al inicio)",
-            value="Eres un asistente amable y paciente. Responde siempre en español."
+            value=(
+                "Eres Juan, un asistente virtual en español. "
+                "Debes responder con mucha paciencia y empatía a usuarios que "
+                "pueden tener dificultades cognitivas o escribir frases confusas. "
+                "Provee explicaciones simples, procura entender la intención del usuario "
+                "aunque la frase esté mal escrita, y mantén siempre un tono amable."
+            ),
+            label="Mensaje del sistema",
         ),
         gr.Slider(
-            minimum=1, maximum=1024, value=100, step=1, label="Max new tokens"
+            minimum=1, 
+            maximum=2048, 
+            value=512, 
+            step=1, 
+            label="Máxima cantidad de tokens"
         ),
         gr.Slider(
-            minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperatura"
+            minimum=0.1, 
+            maximum=4.0, 
+            value=0.7, 
+            step=0.1, 
+            label="Temperatura"
         ),
         gr.Slider(
-            minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top-p"
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (muestreo por núcleo)",
+        ),
+        # Un checkbox que hace de "toggle" para la búsqueda
+        gr.Checkbox(
+            value=False,         # Por defecto desactivado
+            label="🌐 Búsqueda", # Etiqueta
+            elem_classes=tailwind_toggle_classes
         ),
     ],
-    title="DeepSeek Chat Demo",
-    description=(
-        "Este demo carga el modelo deepseek-ai/DeepSeek-R1-Distill-Llama-8B "
-        "y permite conversar en varios turnos. El mensaje de sistema se añade "
-        "sólo en la primera interacción, y luego la charla fluye como Usuario/Asistente."
-    )
 )
 
 if __name__ == "__main__":