app.py

import gradio as gr
from huggingface_hub import InferenceClient
import os

# Obtén el token de manera segura desde el entorno
hf_token = os.getenv("HF_API_TOKEN")

# Clase para manejar múltiples modelos
class ModelHandler:
    def __init__(self, model_names, token):
        """
        Inicializa el manejador de modelos con los nombres de los modelos y el token de API.
        """
        self.clients = {
            model_name: InferenceClient(model_name, token=token)
            for model_name in model_names
        }
        self.current_model = model_names[0]

    def switch_model(self, model_name):
        """
        Cambia el modelo actual.
        """
        if model_name in self.clients:
            self.current_model = model_name
        else:
            raise ValueError(f"Modelo {model_name} no está disponible.")

    def generate_response(self, input_text):
        """
        Genera una respuesta utilizando el modelo actual.
        """
        prompt = f"Debes de responder a cualquier pregunta:\nPregunta: {input_text}"
        try:
            messages = [{"role": "user", "content": prompt}]
            client = self.clients[self.current_model]
            response = client.chat_completion(messages=messages, max_tokens=500)
            if hasattr(response, 'choices') and response.choices:
                return response.choices[0].message.content
            else:
                return str(response)
        except Exception as e:
            return f"Error al realizar la inferencia: {e}"

# Lista de modelos disponibles
model_names = [
    "microsoft/Phi-3-mini-4k-instruct",
    "bigscience/bloomz-560m",
    "tiiuae/falcon-7b-instruct"
]

# Inicializa el manejador de modelos
model_handler = ModelHandler(model_names, hf_token)

# Configura la interfaz en Gradio con selección de modelos
with gr.Blocks(title="Multi-Model LLM Chatbot") as demo:
    gr.Markdown(
        """
        ## Chatbot Multi-Modelo LLM
        Este chatbot permite elegir entre múltiples modelos de lenguaje para responder preguntas. 
        Selecciona un modelo, escribe tu consulta, y presiona el botón de enviar para obtener una respuesta.
        """
    )
    with gr.Row():
        model_dropdown = gr.Dropdown(
            choices=model_names,
            value=model_names[0],
            label="Seleccionar Modelo",
            interactive=True
        )
    with gr.Row():
        with gr.Column():
            input_text = gr.Textbox(
                lines=5,
                placeholder="Escribe tu pregunta aquí...",
                label="Pregunta"
            )
        with gr.Column():
            output_text = gr.Textbox(
                lines=5,
                label="Respuesta",
                interactive=False
            )
    submit_button = gr.Button("Enviar")
    
    # Define la función de actualización
    def process_input(selected_model, user_input):
        model_handler.switch_model(selected_model)
        return model_handler.generate_response(user_input)
    
    # Conecta la función a los componentes
    submit_button.click(
        fn=process_input,
        inputs=[model_dropdown, input_text],
        outputs=output_text
    )

# Lanza la interfaz
demo.launch()