Spaces:

DaniCode
/

chatbot

Sleeping

Update app.py

70b924d verified over 1 year ago

5.84 kB

import os
from langchain.memory import ConversationBufferMemory
import streamlit as st
import requests
from transformers import pipeline

# Carga las variables de entorno
api_key = os.getenv("HUGGINGFACE_API_TOKEN")

# Streamlit Settings (POner vuestro nombre en la pantalla)
st.set_page_config(
    page_title="Mi asistente personal de IA (By Daniela) 🤖", 
    page_icon="🤖")
st.title("Mi asistente personal de IA (By Daniela) 🤖")

# Inicio seción del chat
if "chat_history" not in st.session_state:
    st.session_state.chat_history = [
        {"role": "assistant", "content": "Hola soy tu asistente virtual, ¿en qué puedo ayudarte hoy?"}
    ]

# Definir la clase del modelo
# Selector de modelo LLM
model_class = st.selectbox(
    "Selecciona el modelo que deseas usar:",
    options=["ollama", "openai", "hf_hub"],
    index=0  # opción por defecto
)

temperature = st.slider("Temperatura", 0.0, 1.0, 0.5, 0.05)
max_tokens = st.slider("Longitud máxima de respuesta (tokens)", 10, 1024, 100, 10)

# estableceremos 3 maneras de conexion a LLM ( 1. con la api deHuggingFace, 2 Con CHATGPT (hay que tener un usuario de pago ) y 3 con Ollama de forma local)
 
"""def model_hf_hub(model="google/shieldgemma-2b", temperature=0.1):
  llm = HuggingFaceEndpoint(
      repo_id=model,
      temperature=temperature,
      max_new_tokens=64,
      return_full_text=False,
      huggingfacehub_api_token=api_key,
      model_kwargs={
        "stop": ["<|endoftext|>", "<|eot_id|>"],  # Tokens de parada
      }
  )
  return llm"""

def model_hf_hub(model="google/shieldgemma-2b", temperature=0.1):
    # Usamos el pipeline para la tarea de generación de texto
    llm = pipeline("text-generation", model=model, tokenizer=model)
    return llm
    
def model_openai(model="gpt-4o-mini", temperature=0.1):
    llm = ChatOpenAI(
        model=model,
        temperature=temperature,
        # other parameters...
        max_tokens=100, #número máximo de tokens a generar en una respuesta.
        frequency_penalty = 0.3 #(penaliza moderadamente la repetición de palabras)
    )
    return llm

def model_ollama(model="phi3:latest", temperature=0.1,):  # probar con 27b
    llm = ChatOllama(
        model=model,
        temperature=temperature,
        base_url="http://127.0.0.1:11434"
    )
    return llm

#Antes de generar la respuesta se comprueba el idioma del usuario que hace la consulta
def detectar_idioma(text):
    try:
        return detect(text)
    except:
        return "error"
        
def model_response(user_query,chat_history, model_class):
    
    # Detecto el idioma
    idioma = detectar_idioma(user_query)
    print(f"Idioma detectado: {idioma}")

    # Traduce códigos de idioma a nombres legibles
    idioma_nombres = {
        "es": "Spanish",
        "en": "English",
        "fr": "French",
        "de": "German",
        "it": "Italian",
        "pt": "Portuguese"
    }
    # Si el idioma detectado no está en el diccionario, por defecto será español
    language = idioma_nombres.get(idioma, "Spanish")
    
    # Mostrar el idioma detectado en la interfaz
    st.write(f"Idioma detectado: {language}")
    
    # hay que poner un if para que llame a las 3 funciones anteriores segun el valor de la variable  model_class
    #llm = model_ollama()
    # Cargar el modelo correspondiente según model_class
    if model_class == "ollama":
        llm = model_ollama()
    elif model_class == "openai":
        llm = model_openai()
    elif model_class == "hf_hub":
        llm = model_hf_hub()
    else:
        raise ValueError("Invalid model class")
    
    # Memoria del chat
    memory = ConversationBufferMemory(return_messages=True)

    # Cargar la memoria con los mensajes previos    
    for message in chat_history:
        if message['role'] == 'user':
            memory.chat_memory.add_message(HumanMessage(content=message['content']))
        elif message["role"] == "assistant":
            memory.chat_memory.add_message(AIMessage(content=message['content']))

    ## definicion del Prompt
    system_prompt = "You are a helpful assistant answering general questions. Please respond in {language}."
    # Definir el idioma de respuesta
    language = "spanish" 
    user_prompt = "{input}"
   
    prompt_template = ChatPromptTemplate.from_messages([
        ("system", system_prompt),
   #     https://python.langchain.com/docs/integrations/memory/streamlit_chat_message_history/
        ("user", user_prompt)
    ])

    # Creamos la cadena de procesamiento (chain)
    chain = prompt_template | llm | StrOutputParser()

    ## Respuesta del modelo
    response = chain.stream({
        "input": user_query,  # tambien hay que mandarle el historial
        "language": language
    })

    # Añadir la nueva respuesta al historial de memoria
    return response

#bucle para visualizar los mensajes del historial
user_query = st.chat_input("Introduce mensaje...")

# Verificar si la consulta no es nula o vacía
# Elimina los espacios vacíos o en blanco al principio o al final de la frase.
if user_query and user_query.strip():
    # Añadir mensaje del usuario al historial
    st.session_state.chat_history.append({"role": "user", "content": user_query})

    # Mostrar el mensaje del usuario en la interfaz
    with st.chat_message("Human"):
            st.write(user_query)

    # Obtener la respuesta del modelo y mostrarla
    response_stream = model_response(user_query, st.session_state.chat_history, model_class)

    # Mostrar la respuesta de la IA en la interfaz
    with st.chat_message("AI"):
        respuesta_completa = st.write_stream(response_stream) # mandar el historial a la funcion model_response

 
    # Añadir la respuesta del asistente al historial
    st.session_state.chat_history.append({"role": "assistant", "content": respuesta_completa})

	import os
	from langchain.memory import ConversationBufferMemory
	import streamlit as st
	import requests
	from transformers import pipeline

	# Carga las variables de entorno
	api_key = os.getenv("HUGGINGFACE_API_TOKEN")

	# Streamlit Settings (POner vuestro nombre en la pantalla)
	st.set_page_config(
	page_title="Mi asistente personal de IA (By Daniela) 🤖",
	page_icon="🤖")
	st.title("Mi asistente personal de IA (By Daniela) 🤖")

	# Inicio seción del chat
	if "chat_history" not in st.session_state:
	st.session_state.chat_history = [
	{"role": "assistant", "content": "Hola soy tu asistente virtual, ¿en qué puedo ayudarte hoy?"}
	]

	# Definir la clase del modelo
	# Selector de modelo LLM
	model_class = st.selectbox(
	"Selecciona el modelo que deseas usar:",
	options=["ollama", "openai", "hf_hub"],
	index=0 # opción por defecto
	)

	temperature = st.slider("Temperatura", 0.0, 1.0, 0.5, 0.05)
	max_tokens = st.slider("Longitud máxima de respuesta (tokens)", 10, 1024, 100, 10)

	# estableceremos 3 maneras de conexion a LLM ( 1. con la api deHuggingFace, 2 Con CHATGPT (hay que tener un usuario de pago ) y 3 con Ollama de forma local)

	"""def model_hf_hub(model="google/shieldgemma-2b", temperature=0.1):
	llm = HuggingFaceEndpoint(
	repo_id=model,
	temperature=temperature,
	max_new_tokens=64,
	return_full_text=False,
	huggingfacehub_api_token=api_key,
	model_kwargs={
	"stop": ["<\|endoftext\|>", "<\|eot_id\|>"], # Tokens de parada
	}
	)
	return llm"""

	def model_hf_hub(model="google/shieldgemma-2b", temperature=0.1):
	# Usamos el pipeline para la tarea de generación de texto
	llm = pipeline("text-generation", model=model, tokenizer=model)
	return llm

	def model_openai(model="gpt-4o-mini", temperature=0.1):
	llm = ChatOpenAI(
	model=model,
	temperature=temperature,
	# other parameters...
	max_tokens=100, #número máximo de tokens a generar en una respuesta.
	frequency_penalty = 0.3 #(penaliza moderadamente la repetición de palabras)
	)
	return llm

	def model_ollama(model="phi3:latest", temperature=0.1,): # probar con 27b
	llm = ChatOllama(
	model=model,
	temperature=temperature,
	base_url="http://127.0.0.1:11434"
	)
	return llm

	#Antes de generar la respuesta se comprueba el idioma del usuario que hace la consulta
	def detectar_idioma(text):
	try:
	return detect(text)
	except:
	return "error"

	def model_response(user_query,chat_history, model_class):

	# Detecto el idioma
	idioma = detectar_idioma(user_query)
	print(f"Idioma detectado: {idioma}")

	# Traduce códigos de idioma a nombres legibles
	idioma_nombres = {
	"es": "Spanish",
	"en": "English",
	"fr": "French",
	"de": "German",
	"it": "Italian",
	"pt": "Portuguese"
	}
	# Si el idioma detectado no está en el diccionario, por defecto será español
	language = idioma_nombres.get(idioma, "Spanish")

	# Mostrar el idioma detectado en la interfaz
	st.write(f"Idioma detectado: {language}")

	# hay que poner un if para que llame a las 3 funciones anteriores segun el valor de la variable model_class
	#llm = model_ollama()
	# Cargar el modelo correspondiente según model_class
	if model_class == "ollama":
	llm = model_ollama()
	elif model_class == "openai":
	llm = model_openai()
	elif model_class == "hf_hub":
	llm = model_hf_hub()
	else:
	raise ValueError("Invalid model class")

	# Memoria del chat
	memory = ConversationBufferMemory(return_messages=True)

	# Cargar la memoria con los mensajes previos
	for message in chat_history:
	if message['role'] == 'user':
	memory.chat_memory.add_message(HumanMessage(content=message['content']))
	elif message["role"] == "assistant":
	memory.chat_memory.add_message(AIMessage(content=message['content']))

	## definicion del Prompt
	system_prompt = "You are a helpful assistant answering general questions. Please respond in {language}."
	# Definir el idioma de respuesta
	language = "spanish"
	user_prompt = "{input}"

	prompt_template = ChatPromptTemplate.from_messages([
	("system", system_prompt),
	# https://python.langchain.com/docs/integrations/memory/streamlit_chat_message_history/
	("user", user_prompt)
	])

	# Creamos la cadena de procesamiento (chain)
	chain = prompt_template \| llm \| StrOutputParser()

	## Respuesta del modelo
	response = chain.stream({
	"input": user_query, # tambien hay que mandarle el historial
	"language": language
	})

	# Añadir la nueva respuesta al historial de memoria
	return response

	#bucle para visualizar los mensajes del historial
	user_query = st.chat_input("Introduce mensaje...")

	# Verificar si la consulta no es nula o vacía
	# Elimina los espacios vacíos o en blanco al principio o al final de la frase.
	if user_query and user_query.strip():
	# Añadir mensaje del usuario al historial
	st.session_state.chat_history.append({"role": "user", "content": user_query})

	# Mostrar el mensaje del usuario en la interfaz
	with st.chat_message("Human"):
	st.write(user_query)

	# Obtener la respuesta del modelo y mostrarla
	response_stream = model_response(user_query, st.session_state.chat_history, model_class)

	# Mostrar la respuesta de la IA en la interfaz
	with st.chat_message("AI"):
	respuesta_completa = st.write_stream(response_stream) # mandar el historial a la funcion model_response


	# Añadir la respuesta del asistente al historial
	st.session_state.chat_history.append({"role": "assistant", "content": respuesta_completa})