Chat con historial

 ### 1. **Langchain Chat History**: * El historial del chat es la pieza central que almacena todas las interacciones entre el usuario y el modelo. 2. **System Message**: * Si el historial está vacío, se agrega un mensaje de sistema como "Eres un asistente útil" para proporcionar un contexto inicial para el modelo. 3. **User Input**: * Cada mensaje del usuario se guarda en el historial, lo que garantiza que el contexto de la conversación se mantenga y se use en interacciones futuras. 4. **Model Response**: * El modelo genera una respuesta basada en todo el historial, lo que permite que las respuestas estén más alineadas con el contexto previo. La respuesta también se almacena en el historial. 5. **Chat History**: * El historial completo de la conversación se va acumulando, manteniendo un registro de todas las interacciones. Esto asegura que la inteligencia artificial pueda proporcionar respuestas más precisas y personalizadas en función de todo lo discutido anteriormente.

Es aqui donde entendí el : " por qué?"

Si les gusta crear un nuevo colab por cada clase y tienen error al importar la librería, lo resuelven con: `!pip install -qU langchain-openai langchain`

Fue retador pero se logro , en los modelos de memoria me llamaron la atención 3 * BufferWindowMemory, Es ideal para mantener el hilo de la conversación actual, pero tiene la limitación de que los mensajes más antiguos se pierden definitivamente. * ConversationEntityMemory, Es útil para aplicaciones que necesitan persistir datos específicos a lo largo del tiempo, como fechas o preferencias. y el mejor/peor de de todos * CombinedMemory, permite combinar memorias , lo pensaba en usar para combinar lo mejor de los 2 modelos anteriores, ejemplo quiero que el modelo recuerde lo max posible pero que no sea tan costoso , si quieres que sea fiel y recuerde todo usas BufferWindowMemory y defines un limite de 100 pero aunque recuerda todo, que pasa si tenia algo muy importante hace 101 mensajes, no lo va a recordar, para solucionar este problema que tal si lo fusionamos con ConversationEntityMemory para que aquellos mensajes que no recuerde el modelo tengamos un resumen de ellos y tenemos lo mejor de los 2 mundos, contexto importante antiguo y buen hilo de la conversación actual, pero un problema al fusionar los modelos que no logre solucionar fue que entraban en conflicto con history, a pesar de modificar su memory\_key, seguian en conflicto, luego de mirar mas en la documentación encontré la solucion Cómo agregar memoria a los chatbots <https://python.langchain.com/docs/how_to/chatbots_memory/#automatic-history-management> Usa LangGraph para poder manejar la persistencia de la información y se le puede definir al modelo quiero que recuerdes los ultimos 4 mensajes de la conversación y haz un resumen de los anteriores y funciona !!, dejo el code por si lo quieren probar %pip install --upgrade --quiet langchain langchain-openai langgraph ```python %pip install --upgrade --quiet langchain langchain-openai langgraph !pip install --upgrade langchain openai langchain-openai tiktoken import getpass import os if not os.environ.get("OPENAI_API_KEY"): os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ") from langchain_openai import ChatOpenAI model = ChatOpenAI( model_name='gpt-4o', temperature=0.7 ) from langchain_core.messages import AIMessage, HumanMessage, SystemMessage demo_ephemeral_chat_history = [ HumanMessage(content="Excelente, recuerda el número 3"), AIMessage(content="¡Entendido! Número 3 recordado"), HumanMessage(content="Hola, ¿cómo estás?"), AIMessage(content="¡Hola! Estoy aquí y listo para ayudarte. ¿Y tú?"), HumanMessage(content="Me gusta el color azul"), AIMessage(content="Genial recordare esto"), HumanMessage(content="Mi dia especial es el viernes, 6 de diciembre de 2024"), AIMessage(content="Entendido recordare esto") ] from langchain_core.messages import HumanMessage, RemoveMessage from langgraph.checkpoint.memory import MemorySaver from langgraph.graph import START, MessagesState, StateGraph workflow = StateGraph(state_schema=MessagesState) # Define the function that calls the model def call_model(state: MessagesState): system_prompt = ( "Tu eres un asistente virtual" "Recordaras lo mas relevante del usuario" ) system_message = SystemMessage(content=system_prompt) message_history = state["messages"][:-1] # exclude the most recent user input # Summarize the messages if the chat history reaches a certain size if len(message_history) >= 2: last_human_message = state["messages"][-1] # Invoke the model to generate conversation summary summary_prompt = ( "Resume los mensajes de chat anteriores en una lista con los detalles importantes a recordar del usuario " "Incluye los mas relevante del usuario" ) summary_message = model.invoke( message_history + [HumanMessage(content=summary_prompt)] ) # Delete messages that we no longer want to show up delete_messages = [RemoveMessage(id=m.id) for m in state["messages"]] # Re-add user message human_message = HumanMessage(content=last_human_message.content) # Call the model with summary & response response = model.invoke([system_message, summary_message, human_message]) message_updates = [summary_message, human_message, response] + delete_messages else: message_updates = model.invoke([system_message] + state["messages"]) return {"messages": message_updates} # Define the node and edge workflow.add_node("model", call_model) workflow.add_edge(START, "model") # Add simple in-memory checkpointer memory = MemorySaver() app = workflow.compile(checkpointer=memory) app.invoke( { "messages": demo_ephemeral_chat_history + [HumanMessage("Cual es mi numero importante")] }, config={"configurable": {"thread_id": "1"}}, ) ```Os dejo una imagen del code  

Y todo esa conversacion se puede enlazar a whatsapp por asi decirlo? En el caso sea whatsapp bussiness de esa manera un cliente si pregunta por algun producto no solo le dira opciones si no tambien podria responder cosas del producto o cualquier pregunta aleatoria del cliente.

en estás últimas clases se ha usado openai, mi pregunta es se puede hacer esto mismo usando hugginface?

LangChain no proporciona una metodología específica para mantener un resumen de la conversación, pero puedes implementar una estrategia a través del historial de chat. Almacena cada interacción en una lista y, en cada nuevo mensaje, puedes generar un resumen basado en el contenido previo. Esto permite mantener un contexto dinámico y el seguimiento de la conversación. La personalización de respuestas se puede lograr utilizando "chains" para mejorar los resultados basados en el historial.

Hola, inclui un Prompt Template, variables dinamicas y el chat history en un solo codigo para consolidar conceptos y hacer el reto. Al principio pense que podia utilizar un chain, pero no fue necesario (Con lo que hemos visto del curso, me di cuenta que se requiere quiza unos tipos de chat memory mas avanzados que permitan crear el chain, por ahora pienso que esta bien para consolidar las bases) ```python #Paso 1 Importamos las librerias #Importamos el chatmodel con sus hiperparametros from langchain_google_genai import ChatGoogleGenerativeAI llm = ChatGoogleGenerativeAI( model = "gemini-1.5-pro", temperature= 0, max_tokens= None, timeout=None, max_retries= 2 ) # Aca los esquemas de roles y el prompt Template, son importantes from langchain_core.messages import AIMessage, HumanMessage, SystemMessage from langchain.prompts import SystemMessagePromptTemplate #Esta libreria para indicar place holders dinamicos cuando solo definimos el system Message from langchain_core.prompts import ChatPromptTemplate #Paso 2 Creamos el prompt Template #Establecer el System Message y el Humman Message de esta manera es mucho mejor puesto que genera mejor legibilidad, una manipulación mas facil (mas adelante se necesitaria) prompt = SystemMessagePromptTemplate.from_template("Eres un profesor de {input_language}. Ayuda a los estudiantes a hablar fluidamente desde el español. Ellos te pasarán frases en español, y tú las traducirás correctamente a {input_language}. Sé formal y servicial en todo momento.") #Paso 3 Creamos el historial del chat chat_history = [] #Paso 4 definimos los place holders dinamicos y les damos formato prompt_with_context= prompt.format( input_language = "Frances" ) #Paso 5 añade el mensaje del sistema difinido en el prompt template al chat history chat_history.append(prompt_with_context) #Paso 6 Capturamos la entrada del usuario query = input('Escribe una pregunta: ') #Paso 7 Añadimos esta entrada del usuario al chat history como Humman Message chat_history.append(HumanMessage(content=query)) #Paso 8 Generar la respuesta utilizando el LLM #Cuando invokamos chat_history, se debe Mantener un orden en el chat history, debe ser primero System message, Human Message y ya despues se agrea AI message response = llm.invoke(chat_history) chat_history.append(AIMessage(content= response.content)) print(response.content) #Paso 9 nueva pregunta #Paso 9.1 Capturamos la entrada del usuario query = input('Nueva pregunta: ') #Paso 9.2 Añadimos esta entrada del usuario al chat history como Humman Message chat_history.append(HumanMessage(content=query)) #Paso 10 saber si el modelo tiene memoria response = llm.invoke(chat_history) chat_history.append(AIMessage(content= response.content)) print(response.content) #Paso 11 validas todo lo que hay en chat_history ````#Paso 1 Importamos las librerias #Importamos el chatmodel con sus hiperparametros` `from langchain_google_genai import` ChatGoogleGenerativeAI `llm = ChatGoogleGenerativeAI(` ` model = "gemini-1.5-pro",` ` temperature= 0,` ` max_tokens= None,` ` timeout=None,` ` max_retries= 2` `)` `# Aca los esquemas de roles y el prompt Template, son importantes` `from langchain_core.messages import AIMessage, HumanMessage,` SystemMessage `from langchain.prompts import SystemMessagePromptTemplate #Esta libreria para indicar place holders dinamicos cuando solo definimos el system Message` `from langchain_core.prompts import` ChatPromptTemplate `#Paso 2 Creamos el prompt Template` `#Establecer el System Message y el Humman Message de esta manera es mucho mejor puesto que genera mejor legibilidad, una manipulación mas facil (mas adelante se necesitaria)` `prompt = SystemMessagePromptTemplate.from_template("Eres un profesor de {input_language}. Ayuda a los estudiantes a hablar fluidamente desde el español. Ellos te pasarán frases en español, y tú las traducirás correctamente a {input_language}. Sé formal y servicial en todo momento.")` `#Paso 3 Creamos el historial del chat` `chat_history = []` `#Paso 4 definimos los place holders dinamicos y les damos formato` `prompt_with_context= prompt.format(` ` input_language = "Frances"` `)` `#Paso 5 añade el mensaje del sistema difinido en el prompt template al chat history` `chat_history.append(prompt_with_context)` `#Paso 6 Capturamos la entrada del usuario` `query = input('Escribe una pregunta: ')` `#Paso 7 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 8 Generar la respuesta utilizando el LLM` `#Cuando invokamos chat_history, se debe Mantener un orden en el chat history, debe ser primero System message, Human Message y ya despues se agrea AI message` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 9 nueva pregunta` `#Paso 9.1 Capturamos la entrada del usuario` `query = input('Nueva pregunta: ')` `#Paso 9.2 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 10 saber si el modelo tiene memoria` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 11 validas todo lo que hay en chat_history`

Hola, inclui un Prompt Template, variables dinamicas y el chat history en un solo codigo para consolidar conceptos y hacer el reto. Al principio pense que podia utilizar un chain, pero no fue necesario (Con lo que hemos visto del curso, me di cuenta que se requiere quiza unos tipos de chat memory mas avanzados que permitan crear el chain, por ahora pienso que esta bien para consolidar las bases) `#Paso 1 Importamos las librerias ` `#Importamos el chatmodel con sus hiperparametros` `from langchain_google_genai import` ChatGoogleGenerativeAI `llm = ChatGoogleGenerativeAI(` ` model = "gemini-1.5-pro",` ` temperature= 0,` ` max_tokens= None,` ` timeout=None,` ` max_retries= 2` `)` `# Aca los esquemas de roles y el prompt Template, son importantes` `from langchain_core.messages import AIMessage, HumanMessage,` SystemMessage `from langchain.prompts import SystemMessagePromptTemplate #Esta libreria para indicar place holders dinamicos cuando solo definimos el system Message` `from langchain_core.prompts import` ChatPromptTemplate `#Paso 2 Creamos el prompt Template` `#Establecer el System Message y el Humman Message de esta manera es mucho mejor puesto que genera mejor legibilidad, una manipulación mas facil (mas adelante se necesitaria)` `prompt = SystemMessagePromptTemplate.from_template("Eres un profesor de {input_language}. Ayuda a los estudiantes a hablar fluidamente desde el español. Ellos te pasarán frases en español, y tú las traducirás correctamente a {input_language}. Sé formal y servicial en todo momento.")` `#Paso 3 Creamos el historial del chat` `chat_history = []` `#Paso 4 definimos los place holders dinamicos y les damos formato` `prompt_with_context= prompt.format(` ` input_language = "Frances"` `)` `#Paso 5 añade el mensaje del sistema difinido en el prompt template al chat history` `chat_history.append(prompt_with_context)` `#Paso 6 Capturamos la entrada del usuario` `query = input('Escribe una pregunta: ')` `#Paso 7 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 8 Generar la respuesta utilizando el LLM` `#Cuando invokamos chat_history, se debe Mantener un orden en el chat history, debe ser primero System message, Human Message y ya despues se agrea AI message` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 9 nueva pregunta` `#Paso 9.1 Capturamos la entrada del usuario` `query = input('Nueva pregunta: ')` `#Paso 9.2 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 10 saber si el modelo tiene memoria` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 11 validas todo lo que hay en chat_history`

Hola, inclui un Prompt Template, variables dinamicas y el chat history en un solo codigo para consolidar conceptos y hacer el reto. Al principio pense que podia utilizar un chain, pero no fue necesario (Con lo que hemos visto del curso, me di cuenta que se requiere quiza unos tipos de chat memory mas avanzados que permitan crear el chain, por ahora pienso que esta bien para consolidar las bases) ```python #Paso 1 Importamos las librerias #Importamos el chatmodel con sus hiperparametros from langchain_google_genai import ChatGoogleGenerativeAI llm = ChatGoogleGenerativeAI( model = "gemini-1.5-pro", temperature= 0, max_tokens= None, timeout=None, max_retries= 2 ) # Aca los esquemas de roles y el prompt Template, son importantes from langchain_core.messages import AIMessage, HumanMessage, SystemMessage from langchain.prompts import SystemMessagePromptTemplate #Esta libreria para indicar place holders dinamicos cuando solo definimos el system Message from langchain_core.prompts import ChatPromptTemplate #Paso 2 Creamos el prompt Template #Establecer el System Message y el Humman Message de esta manera es mucho mejor puesto que genera mejor legibilidad, una manipulación mas facil (mas adelante se necesitaria) prompt = SystemMessagePromptTemplate.from_template("Eres un profesor de {input_language}. Ayuda a los estudiantes a hablar fluidamente desde el español. Ellos te pasarán frases en español, y tú las traducirás correctamente a {input_language}. Sé formal y servicial en todo momento.") #Paso 3 Creamos el historial del chat chat_history = [] #Paso 4 definimos los place holders dinamicos y les damos formato prompt_with_context= prompt.format( input_language = "Frances" ) #Paso 5 añade el mensaje del sistema difinido en el prompt template al chat history chat_history.append(prompt_with_context) #Paso 6 Capturamos la entrada del usuario query = input('Escribe una pregunta: ') #Paso 7 Añadimos esta entrada del usuario al chat history como Humman Message chat_history.append(HumanMessage(content=query)) #Paso 8 Generar la respuesta utilizando el LLM #Cuando invokamos chat_history, se debe Mantener un orden en el chat history, debe ser primero System message, Human Message y ya despues se agrea AI message response = llm.invoke(chat_history) chat_history.append(AIMessage(content= response.content)) print(response.content) #Paso 9 nueva pregunta #Paso 9.1 Capturamos la entrada del usuario query = input('Nueva pregunta: ') #Paso 9.2 Añadimos esta entrada del usuario al chat history como Humman Message chat_history.append(HumanMessage(content=query)) #Paso 10 saber si el modelo tiene memoria response = llm.invoke(chat_history) chat_history.append(AIMessage(content= response.content)) print(response.content) #Paso 11 validas todo lo que hay en chat_history ````#Paso 1 Importamos las librerias ` `#Importamos el chatmodel con sus hiperparametros` `from langchain_google_genai import` ChatGoogleGenerativeAI `llm = ChatGoogleGenerativeAI(` ` model = "gemini-1.5-pro",` ` temperature= 0,` ` max_tokens= None,` ` timeout=None,` ` max_retries= 2` `)` `# Aca los esquemas de roles y el prompt Template, son importantes` `from langchain_core.messages import AIMessage, HumanMessage,` SystemMessage `from langchain.prompts import SystemMessagePromptTemplate #Esta libreria para indicar place holders dinamicos cuando solo definimos el system Message` `from langchain_core.prompts import` ChatPromptTemplate `#Paso 2 Creamos el prompt Template` `#Establecer el System Message y el Humman Message de esta manera es mucho mejor puesto que genera mejor legibilidad, una manipulación mas facil (mas adelante se necesitaria)` `prompt = SystemMessagePromptTemplate.from_template("Eres un profesor de {input_language}. Ayuda a los estudiantes a hablar fluidamente desde el español. Ellos te pasarán frases en español, y tú las traducirás correctamente a {input_language}. Sé formal y servicial en todo momento.")` `#Paso 3 Creamos el historial del chat` `chat_history = []` `#Paso 4 definimos los place holders dinamicos y les damos formato` `prompt_with_context= prompt.format(` ` input_language = "Frances"` `)` `#Paso 5 añade el mensaje del sistema difinido en el prompt template al chat history` `chat_history.append(prompt_with_context)` `#Paso 6 Capturamos la entrada del usuario` `query = input('Escribe una pregunta: ')` `#Paso 7 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 8 Generar la respuesta utilizando el LLM` `#Cuando invokamos chat_history, se debe Mantener un orden en el chat history, debe ser primero System message, Human Message y ya despues se agrea AI message` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 9 nueva pregunta` `#Paso 9.1 Capturamos la entrada del usuario` `query = input('Nueva pregunta: ')` `#Paso 9.2 Añadimos esta entrada del usuario al chat history como Humman Message` `chat_history.append(HumanMessage(content=query))` `#Paso 10 saber si el modelo tiene memoria` `response = llm.invoke(chat_history)` `chat_history.append(AIMessage(content= response.content))` `print(response.content)` `#Paso 11 validas todo lo que hay en chat_history` ```js ```


Me dio por hacer lo mismo pero en JS: ```js require('dotenv').config(); const { ChatOpenAI } = require("@langchain/openai"); const { AIMessage, SystemMessage, HumanMessage, trimMessages } = require("@langchain/core/messages"); async function main() { const llm = new ChatOpenAI({ openAIApiKey: process.env.OPENAI_API_KEY, model: "gpt-4", temperature: 0 }); try { const response = await llm.invoke([ { role: "user", content: "Hi im bob" }, { role: "assistant", content: "Hello bob! How can I help you today?" }, { role: "user", content: "Can you tell me a joke?" }, ]); console.log('Respuesta:', response.content); } catch (error) { console.error('Error:', error); } let chat_history = []; if (chat_history.length === 0) { const systemMessage = new SystemMessage("Eres un asistente útil."); chat_history.push(systemMessage); } // console.log('Haz una pregunta'); let input = 'Cual es la masa de la tierra?'; chat_history.push(new HumanMessage(input)); try { const response = (await llm.invoke(chat_history)).content; chat_history.push(new AIMessage(response)); chat_history.forEach((message) => { console.log(`${message.role}: ${message.content}`); }); } catch (error) { console.error('Error:', error); } console.log(chat_history); } main().catch(console.error); ```