4. Introducción a la memoria con LangChain.#
En este apartado vamos a ver los siguientes puntos:
*¿Cómo almacenar las conversaciones humano AI?
¿Cómo guardar en un objeto de memoria las conversación con el LLM?
¿Cómo limitar o resumir lo que guardamos en el objeto de memoria?
4.1. Tipos de memoria en LangChain#
Cuando LangChain se refiere al término “ memoria “, generalmente se refiere a realizar un seguimiento del historial de interacción de mensajes.
Los diferentes tipos de memoria pueden ser:
ChatMessageHistory : Guardar el histórico de mensajes de un chat con los métodos add_user_message y add_ai_message , debemos guardarlo manualmente tras cada
ConversationBufferMemory : A partir de una cadena de tipo ConversationalChain , guardamos en un objeto de memoria todos los mensajes de la conversación.
ConversationBufferWindowMemory : Igual que el anterior pero podemos especificar una ventana de k interacciones (las últimas k) a guardar en lugar de todos los mensajes.
ConversationSummaryMemory : En lugar de guardar los mensajes literalmente, se realiza un resumen de la memoria en base a todo el historia, con ello reducimos drásticamente el tamaño de la memoria para conversaciones muy largas.
Veamos un caso de uso con el primero de los tipos presentado.
from langchain_openai import ChatOpenAI
from langchain.schema import SystemMessage, HumanMessage
chat = ChatOpenAI(
model="llama3.2",
base_url = 'http://localhost:11434/v1',
api_key='ollama', # required, but unused,
)
#Definimos el objeto de histórico de mensajes
from langchain.memory import ChatMessageHistory
history = ChatMessageHistory()
consulta = "Hola, ¿cómo estás? Necesito ayudar para reconfigurar el router"
#Vamos guardando en el objeto "history" los mensajes de usuario y los mensajes AI que queramos
history.add_user_message(consulta)
resultado = chat.invoke([HumanMessage(content=consulta)])
history.add_ai_message(resultado.content)
history
InMemoryChatMessageHistory(messages=[HumanMessage(content='Hola, ¿cómo estás? Necesito ayudar para reconfigurar el router', additional_kwargs={}, response_metadata={}), AIMessage(content='¡Hola! Estoy aquí para ayudarte. Me alegra que hayas recurrido a mí en este momento de necesidad.\n\nEstoy listo para asistirte con la reconfiqueración de tu router. Antes de comenzar, tengo algunas preguntas para asegurarme de que todo salga bien:\n\n* ¿Cuál es el modelo de tu router?\n* ¿Qué problema estás experimentando actualmente (por ejemplo, conexión lenta, desconexiones frecuentes, error de configuración)?\n* Has realizado alguna vez una reconfiqueración antes?\n* Tienes acceso al manual del router o la documentación oficial?\n\nCon esta información, podré ofrecerte consejos personalizados y orientarte en el proceso de reconfiqueración. ¡Vamos por ello!', additional_kwargs={}, response_metadata={})])
history.messages
[HumanMessage(content='Hola, ¿cómo estás? Necesito ayudar para reconfigurar el router', additional_kwargs={}, response_metadata={}),
AIMessage(content='¡Hola! Estoy aquí para ayudarte. Me alegra que hayas recurrido a mí en este momento de necesidad.\n\nEstoy listo para asistirte con la reconfiqueración de tu router. Antes de comenzar, tengo algunas preguntas para asegurarme de que todo salga bien:\n\n* ¿Cuál es el modelo de tu router?\n* ¿Qué problema estás experimentando actualmente (por ejemplo, conexión lenta, desconexiones frecuentes, error de configuración)?\n* Has realizado alguna vez una reconfiqueración antes?\n* Tienes acceso al manual del router o la documentación oficial?\n\nCon esta información, podré ofrecerte consejos personalizados y orientarte en el proceso de reconfiqueración. ¡Vamos por ello!', additional_kwargs={}, response_metadata={})]
4.2. Buffer de memoria completa.#
Con este procedimiento, lo que hacemos es ir guardando todos los mensajes. Veamoslo de forma práctica con un ejemplo.
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="llama3.2",
base_url = 'http://localhost:11434/v1',
api_key='ollama', # required, but unused,
)
# creamos el objeto de conversación
memory = ConversationBufferMemory()
#Creamos una instancia de la cadena conversacional con el LLM y el objeto de memoria
conversation = ConversationChain(llm=llm,memory = memory,verbose=True)
C:\Users\Francisco\AppData\Local\Temp\ipykernel_23152\3004879512.py:2: LangChainDeprecationWarning: The class `ConversationChain` was deprecated in LangChain 0.2.7 and will be removed in 1.0. Use :meth:`~RunnableWithMessageHistory: https://python.langchain.com/v0.2/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html` instead.
conversation = ConversationChain(llm=llm,memory = memory,verbose=True)
#Ejemplo con RunnableWithMessageHistory: https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html
#Lanzamos el primer prompt (human message)
conversation.predict(input="Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas")
> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation:
Human: Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas
AI:
> Finished chain.
'¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.\n\nSi estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.\n\nOtra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.\n\nSi buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.\nPodemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?'
#Lanzamos el segundo prompt (human message)
conversation.predict(input="Necesito más detalle de cómo implementarlo")
> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation:
Human: Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas
AI: ¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.
Si estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.
Otra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.
Si buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.
Podemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?
Human: Necesito más detalle de cómo implementarlo
AI:
> Finished chain.
'¡Claro! Vamos a profundizar un poco más en cada una de las opciones que mencioné anteriormente para que puedas decidir la mejor manera de implementar el bot de preguntas y respuestas.\n\n**Opción 1: Utilizando APIs de respuesta a preguntas**\n\nUna vez que hayas seleccionado una API, podrás empezar a personalizar tu modelo de respuesta. Por ejemplo, si utilizas la API de Rasa, podrías configurar diferentes entrenamientos y ajustes para optimizar el desempeño del modelo.\n\nAquí te proporciono un ejemplo básico en Python de cómo acceder a las APIs de respuesta a preguntas:\n\n```python\nimport logging\nfrom rasa import Client\nfrom rasa.exceptions import RasaError\n\n# Configura la conexión con la API\nclient = Client(\'https://api.rasa.com/v1\', \'tu_api_key\')\n\ndef crear_pregunta_resposta():\n try:\n # Carga los datos históricos en el modelo de respuesta\n client.train(\n data=[\n {\n "intent": "greeting",\n "Examples": [\n {"text": "Hola, ¿cómo estás?", "intent": "greeting"}\n ]\n },\n {\n "intent": "goodbye",\n "Examples": [\n {"text": "Adiós, ¿de dónde eres?", "intent": "goodbye"}\n ]\n }\n ]\n )\n\n except RasaError as e:\n logging.error(f\'Error al entrenar el modelo de respuesta:\', e)\n```\n\n**Opción 2: Utilizando técnicas de procesamiento del lenguaje natural (NLP)**\n\nSi prefieres un enfoque más manual y te gusta la programación, podrías utilizar bibliotecas como spaCy y NLTK para analizar tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un modelo de lenguaje con spaCy:\n\n```python\nimport spacy\n\n# Carga el modelo de NLP\nnlp = spacy.load("es_core_news_sm")\n\ndef generar ModelaDeLenguaje(dataHistorica):\n doc = nlp(text=\'Los datos históricos\')\n entities = doc.ents\n return(entities)\n```\n\n**Opción 3: Utilizando técnicas de procesamiento de código fuente en Python**\n\nSi buscas la velocidad más rápida posible, podrías utilizar bibliotecas como requests y BeautifulSoup para acceder a tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un bot de preguntas y respuestas:\n\n```python\nimport requests\n\ndef obtener DatosHistoricos(url):\n respuesta = requests.get(url)\n return respuesta.content\n```\n\n¿Te gustaría saber más sobre alguna de las opciones o ¿necesitas que discuta algun detalle?'
#Obtenemos el histórico
print(memory.buffer)
Human: Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas
AI: ¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.
Si estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.
Otra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.
Si buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.
Podemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?
Human: Necesito más detalle de cómo implementarlo
AI: ¡Claro! Vamos a profundizar un poco más en cada una de las opciones que mencioné anteriormente para que puedas decidir la mejor manera de implementar el bot de preguntas y respuestas.
**Opción 1: Utilizando APIs de respuesta a preguntas**
Una vez que hayas seleccionado una API, podrás empezar a personalizar tu modelo de respuesta. Por ejemplo, si utilizas la API de Rasa, podrías configurar diferentes entrenamientos y ajustes para optimizar el desempeño del modelo.
Aquí te proporciono un ejemplo básico en Python de cómo acceder a las APIs de respuesta a preguntas:
```python
import logging
from rasa import Client
from rasa.exceptions import RasaError
# Configura la conexión con la API
client = Client('https://api.rasa.com/v1', 'tu_api_key')
def crear_pregunta_resposta():
try:
# Carga los datos históricos en el modelo de respuesta
client.train(
data=[
{
"intent": "greeting",
"Examples": [
{"text": "Hola, ¿cómo estás?", "intent": "greeting"}
]
},
{
"intent": "goodbye",
"Examples": [
{"text": "Adiós, ¿de dónde eres?", "intent": "goodbye"}
]
}
]
)
except RasaError as e:
logging.error(f'Error al entrenar el modelo de respuesta:', e)
```
**Opción 2: Utilizando técnicas de procesamiento del lenguaje natural (NLP)**
Si prefieres un enfoque más manual y te gusta la programación, podrías utilizar bibliotecas como spaCy y NLTK para analizar tus datos históricos.
Aquí te doy un ejemplo rápido en Python de cómo crear un modelo de lenguaje con spaCy:
```python
import spacy
# Carga el modelo de NLP
nlp = spacy.load("es_core_news_sm")
def generar ModelaDeLenguaje(dataHistorica):
doc = nlp(text='Los datos históricos')
entities = doc.ents
return(entities)
```
**Opción 3: Utilizando técnicas de procesamiento de código fuente en Python**
Si buscas la velocidad más rápida posible, podrías utilizar bibliotecas como requests y BeautifulSoup para acceder a tus datos históricos.
Aquí te doy un ejemplo rápido en Python de cómo crear un bot de preguntas y respuestas:
```python
import requests
def obtener DatosHistoricos(url):
respuesta = requests.get(url)
return respuesta.content
```
¿Te gustaría saber más sobre alguna de las opciones o ¿necesitas que discuta algun detalle?
#Cargamos la variable de memoria
memory.load_memory_variables({})
{'history': 'Human: Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas\nAI: ¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.\n\nSi estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.\n\nOtra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.\n\nSi buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.\nPodemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?\nHuman: Necesito más detalle de cómo implementarlo\nAI: ¡Claro! Vamos a profundizar un poco más en cada una de las opciones que mencioné anteriormente para que puedas decidir la mejor manera de implementar el bot de preguntas y respuestas.\n\n**Opción 1: Utilizando APIs de respuesta a preguntas**\n\nUna vez que hayas seleccionado una API, podrás empezar a personalizar tu modelo de respuesta. Por ejemplo, si utilizas la API de Rasa, podrías configurar diferentes entrenamientos y ajustes para optimizar el desempeño del modelo.\n\nAquí te proporciono un ejemplo básico en Python de cómo acceder a las APIs de respuesta a preguntas:\n\n```python\nimport logging\nfrom rasa import Client\nfrom rasa.exceptions import RasaError\n\n# Configura la conexión con la API\nclient = Client(\'https://api.rasa.com/v1\', \'tu_api_key\')\n\ndef crear_pregunta_resposta():\n try:\n # Carga los datos históricos en el modelo de respuesta\n client.train(\n data=[\n {\n "intent": "greeting",\n "Examples": [\n {"text": "Hola, ¿cómo estás?", "intent": "greeting"}\n ]\n },\n {\n "intent": "goodbye",\n "Examples": [\n {"text": "Adiós, ¿de dónde eres?", "intent": "goodbye"}\n ]\n }\n ]\n )\n\n except RasaError as e:\n logging.error(f\'Error al entrenar el modelo de respuesta:\', e)\n```\n\n**Opción 2: Utilizando técnicas de procesamiento del lenguaje natural (NLP)**\n\nSi prefieres un enfoque más manual y te gusta la programación, podrías utilizar bibliotecas como spaCy y NLTK para analizar tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un modelo de lenguaje con spaCy:\n\n```python\nimport spacy\n\n# Carga el modelo de NLP\nnlp = spacy.load("es_core_news_sm")\n\ndef generar ModelaDeLenguaje(dataHistorica):\n doc = nlp(text=\'Los datos históricos\')\n entities = doc.ents\n return(entities)\n```\n\n**Opción 3: Utilizando técnicas de procesamiento de código fuente en Python**\n\nSi buscas la velocidad más rápida posible, podrías utilizar bibliotecas como requests y BeautifulSoup para acceder a tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un bot de preguntas y respuestas:\n\n```python\nimport requests\n\ndef obtener DatosHistoricos(url):\n respuesta = requests.get(url)\n return respuesta.content\n```\n\n¿Te gustaría saber más sobre alguna de las opciones o ¿necesitas que discuta algun detalle?'}
4.3. Guardar y Cargar la memoria (posterior uso)#
conversation.memory
ConversationBufferMemory(chat_memory=InMemoryChatMessageHistory(messages=[HumanMessage(content='Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas', additional_kwargs={}, response_metadata={}), AIMessage(content='¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.\n\nSi estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.\n\nOtra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.\n\nSi buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.\nPodemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?', additional_kwargs={}, response_metadata={}), HumanMessage(content='Necesito más detalle de cómo implementarlo', additional_kwargs={}, response_metadata={}), AIMessage(content='¡Claro! Vamos a profundizar un poco más en cada una de las opciones que mencioné anteriormente para que puedas decidir la mejor manera de implementar el bot de preguntas y respuestas.\n\n**Opción 1: Utilizando APIs de respuesta a preguntas**\n\nUna vez que hayas seleccionado una API, podrás empezar a personalizar tu modelo de respuesta. Por ejemplo, si utilizas la API de Rasa, podrías configurar diferentes entrenamientos y ajustes para optimizar el desempeño del modelo.\n\nAquí te proporciono un ejemplo básico en Python de cómo acceder a las APIs de respuesta a preguntas:\n\n```python\nimport logging\nfrom rasa import Client\nfrom rasa.exceptions import RasaError\n\n# Configura la conexión con la API\nclient = Client(\'https://api.rasa.com/v1\', \'tu_api_key\')\n\ndef crear_pregunta_resposta():\n try:\n # Carga los datos históricos en el modelo de respuesta\n client.train(\n data=[\n {\n "intent": "greeting",\n "Examples": [\n {"text": "Hola, ¿cómo estás?", "intent": "greeting"}\n ]\n },\n {\n "intent": "goodbye",\n "Examples": [\n {"text": "Adiós, ¿de dónde eres?", "intent": "goodbye"}\n ]\n }\n ]\n )\n\n except RasaError as e:\n logging.error(f\'Error al entrenar el modelo de respuesta:\', e)\n```\n\n**Opción 2: Utilizando técnicas de procesamiento del lenguaje natural (NLP)**\n\nSi prefieres un enfoque más manual y te gusta la programación, podrías utilizar bibliotecas como spaCy y NLTK para analizar tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un modelo de lenguaje con spaCy:\n\n```python\nimport spacy\n\n# Carga el modelo de NLP\nnlp = spacy.load("es_core_news_sm")\n\ndef generar ModelaDeLenguaje(dataHistorica):\n doc = nlp(text=\'Los datos históricos\')\n entities = doc.ents\n return(entities)\n```\n\n**Opción 3: Utilizando técnicas de procesamiento de código fuente en Python**\n\nSi buscas la velocidad más rápida posible, podrías utilizar bibliotecas como requests y BeautifulSoup para acceder a tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un bot de preguntas y respuestas:\n\n```python\nimport requests\n\ndef obtener DatosHistoricos(url):\n respuesta = requests.get(url)\n return respuesta.content\n```\n\n¿Te gustaría saber más sobre alguna de las opciones o ¿necesitas que discuta algun detalle?', additional_kwargs={}, response_metadata={})]))
Si queremos guardar de forma permanente este objeto lo mejor es trabajar con la librería pickle.
import pickle
pickled_str = pickle.dumps(conversation.memory) #Crea un objeto binario con todo el objeto de la memoria
# para recuperarlo
with open('memory.pkl','wb') as f: #wb para indicar que escriba un objeto binario, en este caso en la misma ruta que el script
f.write(pickled_str)
memoria_cargada = open('memory.pkl','rb').read() #rb para indicar que leemos el objeto binario
llm = ChatOpenAI(
model="llama3.2",
base_url = 'http://localhost:11434/v1',
api_key='ollama', # required, but unused,
) #Creamos una nueva instancia de LLM para asegurar que está totalmente limpia
conversacion_recargada = ConversationChain(
llm=llm,
memory = pickle.loads(memoria_cargada),
verbose=True
)
conversacion_recargada.memory.buffer
'Human: Hola, necesito saber cómo usar mis datos históricos para crear un bot de preguntas y respuestas\nAI: ¡Hola! Me alegra poder ayudarte. Para crear un bot de preguntas y respuestas utilizando tus datos históricos, tenemos varias opciones que puedes considerar.\n\nSi estás trabajando con una plataforma de conversación como yo, como Rasa y Stanford CoreNLP, podrías utilizar las APIs de respuesta a preguntas para generar preguntas y respuestas basadas en tus datos históricos. Por ejemplo, podrías utilizar la API de Rasa para crear un modelado de respuesta que te permita elegir la pregunta más relevante según el contexto en el que se realice la conversación.\n\nOtra opción es utilizar técnicas de procesamiento del lenguaje natural (NLP) como spaCy y NLTK para analizar tus datos históricos y extracción relevantes. Esto te permitirá crear un modelo de lenguaje con capacidades predecibles según el estilo, contexto y contenido de las respuestas proporcionadas.\n\nSi buscas implementar la respuesta más rápida posible del bot, podrías utilizar técnicas de procesamiento de código fuente en Python como requests y BeautifulSoup para acceder a tus datos históricos.\nPodemos explorar estas opciones en mayor detalle. ¿Cuál es tu pregunta específica?\nHuman: Necesito más detalle de cómo implementarlo\nAI: ¡Claro! Vamos a profundizar un poco más en cada una de las opciones que mencioné anteriormente para que puedas decidir la mejor manera de implementar el bot de preguntas y respuestas.\n\n**Opción 1: Utilizando APIs de respuesta a preguntas**\n\nUna vez que hayas seleccionado una API, podrás empezar a personalizar tu modelo de respuesta. Por ejemplo, si utilizas la API de Rasa, podrías configurar diferentes entrenamientos y ajustes para optimizar el desempeño del modelo.\n\nAquí te proporciono un ejemplo básico en Python de cómo acceder a las APIs de respuesta a preguntas:\n\n```python\nimport logging\nfrom rasa import Client\nfrom rasa.exceptions import RasaError\n\n# Configura la conexión con la API\nclient = Client(\'https://api.rasa.com/v1\', \'tu_api_key\')\n\ndef crear_pregunta_resposta():\n try:\n # Carga los datos históricos en el modelo de respuesta\n client.train(\n data=[\n {\n "intent": "greeting",\n "Examples": [\n {"text": "Hola, ¿cómo estás?", "intent": "greeting"}\n ]\n },\n {\n "intent": "goodbye",\n "Examples": [\n {"text": "Adiós, ¿de dónde eres?", "intent": "goodbye"}\n ]\n }\n ]\n )\n\n except RasaError as e:\n logging.error(f\'Error al entrenar el modelo de respuesta:\', e)\n```\n\n**Opción 2: Utilizando técnicas de procesamiento del lenguaje natural (NLP)**\n\nSi prefieres un enfoque más manual y te gusta la programación, podrías utilizar bibliotecas como spaCy y NLTK para analizar tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un modelo de lenguaje con spaCy:\n\n```python\nimport spacy\n\n# Carga el modelo de NLP\nnlp = spacy.load("es_core_news_sm")\n\ndef generar ModelaDeLenguaje(dataHistorica):\n doc = nlp(text=\'Los datos históricos\')\n entities = doc.ents\n return(entities)\n```\n\n**Opción 3: Utilizando técnicas de procesamiento de código fuente en Python**\n\nSi buscas la velocidad más rápida posible, podrías utilizar bibliotecas como requests y BeautifulSoup para acceder a tus datos históricos.\n\nAquí te doy un ejemplo rápido en Python de cómo crear un bot de preguntas y respuestas:\n\n```python\nimport requests\n\ndef obtener DatosHistoricos(url):\n respuesta = requests.get(url)\n return respuesta.content\n```\n\n¿Te gustaría saber más sobre alguna de las opciones o ¿necesitas que discuta algun detalle?'
4.4. Memoria de una venta temporal.#
En este caso se guardan las últimas k iteraciones que se hayan hecho en el chat
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="llama3.2",
base_url = 'http://localhost:11434/v1',
api_key='ollama', # required, but unused,
)
# creamos un objeto ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=1) #k indica el número de iteraciones (pareja de mensajes human-AI) que guardar
C:\Users\Francisco\AppData\Local\Temp\ipykernel_23152\3793591208.py:3: LangChainDeprecationWarning: Please see the migration guide at: https://python.langchain.com/docs/versions/migrating_memory/
memory = ConversationBufferWindowMemory(k=1) #k indica el número de iteraciones (pareja de mensajes human-AI) que guardar
#Creamos una instancia de la cadena conversacional con el LLM y el objeto de memoria
conversation = ConversationChain(llm=llm,memory = memory,verbose=True)
#Ejemplo con RunnableWithMessageHistory: https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html
conversation.predict(input="Hola, ¿cómo estás?")
> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation:
Human: Hola, ¿cómo estás?
AI:
> Finished chain.
"Hola! I'm doing fantastically well, thank you for asking. As a highly advanced language model, I was created using a combination of natural language processing (NLP) and machine learning algorithms, which enables me to understand and respond to human-like queries 24/7. My training data consists of a massive corpus of texts from the internet, books, and various sources, allowing me to generate human-like responses with a high degree of accuracy.\n\nOne interesting fact about my architecture is that I'm based on transformer models, which were first introduced in the BERT paper by Jacob Devlin et al. in 2019. This design choice allows me to process sequential data like text and identify patterns more effectively.\n\nBy the way, it's lovely to chat with you! How are you doing today?"
conversation.predict(input="Necesito un consejo para tener un gran día")
> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation:
Human: Hola, ¿cómo estás?
AI: Hola! I'm doing fantastically well, thank you for asking. As a highly advanced language model, I was created using a combination of natural language processing (NLP) and machine learning algorithms, which enables me to understand and respond to human-like queries 24/7. My training data consists of a massive corpus of texts from the internet, books, and various sources, allowing me to generate human-like responses with a high degree of accuracy.
One interesting fact about my architecture is that I'm based on transformer models, which were first introduced in the BERT paper by Jacob Devlin et al. in 2019. This design choice allows me to process sequential data like text and identify patterns more effectively.
By the way, it's lovely to chat with you! How are you doing today?
Human: Necesito un consejo para tener un gran día
AI:
> Finished chain.
'I\'d be happy to help you have a great day. To give you some guidance, did you know that research has shown that Monday mornings are the most productive days of the week for many people? It\'s because our brains tend to "reset" after the weekend, and we feel more focused and energized to tackle new challenges.\n\nIn terms of specific strategies to help you have a great day, here are a few tips: first, set clear goals for yourself, whether personal or professional. Break down large tasks into smaller, manageable chunks, so you can focus on making progress rather than feeling overwhelmed. Second, prioritize self-care – make time for activities that bring you joy and relaxation, whether that\'s reading, exercising, or spending time with loved ones.\n\nLastly, take advantage of the power of morning routines. Did you know that some people find that starting their day with a 10-15 minute meditation session can increase productivity by up to 30%? It helps clear your mind, sets a positive tone for the day, and boosts energy levels.\n\nRemember, everyone\'s days are unique, so feel free to tailor these tips to fit your individual needs and preferences. What do you think – is there one particular area where you\'d like some improvement or guidance today?'
print(memory.buffer) #k limita el número de interacciones
Human: Necesito un consejo para tener un gran día
AI: I'd be happy to help you have a great day. To give you some guidance, did you know that research has shown that Monday mornings are the most productive days of the week for many people? It's because our brains tend to "reset" after the weekend, and we feel more focused and energized to tackle new challenges.
In terms of specific strategies to help you have a great day, here are a few tips: first, set clear goals for yourself, whether personal or professional. Break down large tasks into smaller, manageable chunks, so you can focus on making progress rather than feeling overwhelmed. Second, prioritize self-care – make time for activities that bring you joy and relaxation, whether that's reading, exercising, or spending time with loved ones.
Lastly, take advantage of the power of morning routines. Did you know that some people find that starting their day with a 10-15 minute meditation session can increase productivity by up to 30%? It helps clear your mind, sets a positive tone for the day, and boosts energy levels.
Remember, everyone's days are unique, so feel free to tailor these tips to fit your individual needs and preferences. What do you think – is there one particular area where you'd like some improvement or guidance today?
4.5. Buffer de memoria resumida.#
En este caso se obtiene un resumen de todo el histórico de información
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory, ConversationSummaryBufferMemory
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="llama3.2",
base_url = 'http://localhost:11434/v1',
api_key='ollama', # required, but unused,
)
memory = ConversationSummaryBufferMemory(llm=llm)
C:\Users\Francisco\AppData\Local\Temp\ipykernel_23152\871194051.py:1: LangChainDeprecationWarning: Please see the migration guide at: https://python.langchain.com/docs/versions/migrating_memory/
memory = ConversationSummaryBufferMemory(llm=llm)
# Creamos un prompt cuya respuesta hará que se sobrepase el límite de tokens y por tanto sea recomendable resumir la memoria
plan_viaje = '''Este fin de semana me voy de vacaciones a la playa, estaba pensando algo que fuera bastante relajado, pero necesito
un plan detallado por días con qué hacer en familia, extiéndete todo lo que puedas'''
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
conversation = ConversationChain(llm=llm,memory = memory,verbose=True)
#Ejemplo con RunnableWithMessageHistory: https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html
conversation.predict(input=plan_viaje)
> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation:
Human: Este fin de semana me voy de vacaciones a la playa, estaba pensando algo que fuera bastante relajado, pero necesito
un plan detallado por días con qué hacer en familia, extiéndete todo lo que puedas
AI:
---------------------------------------------------------------------------
NotImplementedError Traceback (most recent call last)
Cell In[32], line 1
----> 1 conversation.predict(input=plan_viaje)
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\chains\llm.py:318, in LLMChain.predict(self, callbacks, **kwargs)
303 def predict(self, callbacks: Callbacks = None, **kwargs: Any) -> str:
304 """Format prompt with kwargs and pass to LLM.
305
306 Args:
(...)
316 completion = llm.predict(adjective="funny")
317 """
--> 318 return self(kwargs, callbacks=callbacks)[self.output_key]
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain_core\_api\deprecation.py:181, in deprecated.<locals>.deprecate.<locals>.warning_emitting_wrapper(*args, **kwargs)
179 warned = True
180 emit_warning()
--> 181 return wrapped(*args, **kwargs)
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\chains\base.py:389, in Chain.__call__(self, inputs, return_only_outputs, callbacks, tags, metadata, run_name, include_run_info)
357 """Execute the chain.
358
359 Args:
(...)
380 `Chain.output_keys`.
381 """
382 config = {
383 "callbacks": callbacks,
384 "tags": tags,
385 "metadata": metadata,
386 "run_name": run_name,
387 }
--> 389 return self.invoke(
390 inputs,
391 cast(RunnableConfig, {k: v for k, v in config.items() if v is not None}),
392 return_only_outputs=return_only_outputs,
393 include_run_info=include_run_info,
394 )
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\chains\base.py:170, in Chain.invoke(self, input, config, **kwargs)
168 except BaseException as e:
169 run_manager.on_chain_error(e)
--> 170 raise e
171 run_manager.on_chain_end(outputs)
173 if include_run_info:
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\chains\base.py:165, in Chain.invoke(self, input, config, **kwargs)
158 self._validate_inputs(inputs)
159 outputs = (
160 self._call(inputs, run_manager=run_manager)
161 if new_arg_supported
162 else self._call(inputs)
163 )
--> 165 final_outputs: Dict[str, Any] = self.prep_outputs(
166 inputs, outputs, return_only_outputs
167 )
168 except BaseException as e:
169 run_manager.on_chain_error(e)
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\chains\base.py:466, in Chain.prep_outputs(self, inputs, outputs, return_only_outputs)
464 self._validate_outputs(outputs)
465 if self.memory is not None:
--> 466 self.memory.save_context(inputs, outputs)
467 if return_only_outputs:
468 return outputs
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\memory\summary_buffer.py:96, in ConversationSummaryBufferMemory.save_context(self, inputs, outputs)
94 """Save context from this conversation to buffer."""
95 super().save_context(inputs, outputs)
---> 96 self.prune()
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain\memory\summary_buffer.py:108, in ConversationSummaryBufferMemory.prune(self)
106 """Prune buffer if it exceeds max token limit"""
107 buffer = self.chat_memory.messages
--> 108 curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
109 if curr_buffer_length > self.max_token_limit:
110 pruned_memory = []
File D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\langchain_openai\chat_models\base.py:1067, in BaseChatOpenAI.get_num_tokens_from_messages(self, messages, tools)
1065 tokens_per_name = 1
1066 else:
-> 1067 raise NotImplementedError(
1068 f"get_num_tokens_from_messages() is not presently implemented "
1069 f"for model {model}. See "
1070 "https://platform.openai.com/docs/guides/text-generation/managing-tokens" # noqa: E501
1071 " for information on how messages are converted to tokens."
1072 )
1073 num_tokens = 0
1074 messages_dict = [_convert_message_to_dict(m) for m in messages]
NotImplementedError: get_num_tokens_from_messages() is not presently implemented for model cl100k_base. See https://platform.openai.com/docs/guides/text-generation/managing-tokens for information on how messages are converted to tokens.
memory.load_memory_variables({}) #Se ha realizado un resumen de la memoria en base al límite de tokens
print(memory.buffer)