Esquema rápido
Esta publicación demostrará lo siguiente:
- Cómo agregar memoria tanto a un agente como a sus herramientas en LangChain
- Paso 1: instalar marcos
- Paso 2: configurar entornos
- Paso 3: Importar bibliotecas
- Paso 4: Agregar memoria de solo lectura
- Paso 5: configurar herramientas
- Paso 6: construir el agente
- Método 1: usar ReadOnlyMemory
- Método 2: usar la misma memoria tanto para el agente como para las herramientas
- Conclusión
¿Cómo agregar memoria tanto a un agente como a sus herramientas en LangChain?
Agregar memoria a los agentes y herramientas les permite trabajar mejor con la capacidad de utilizar el historial de chat del modelo. Con la memoria, el agente puede decidir de manera eficiente qué herramienta implementar y cuándo. Se prefiere utilizar el “ Memoria de sólo lectura ”tanto para los agentes como para las herramientas, por lo que no podrán modificarlo. Para conocer el proceso de agregar memoria tanto a los agentes como a las herramientas en LangChain, siga los pasos enumerados:
Paso 1: instalar marcos
En primer lugar, instale el langchain-experimental módulo para obtener sus dependencias para construir modelos de lenguaje y herramientas para el agente. LangChain experimental es el módulo que obtiene las dependencias para construir modelos que se utilizan principalmente para experimentos y pruebas:
pip instalar cadena larga - experimental
Consigue el resultados-de-búsqueda-de-google módulos con las dependencias de OpenAI para obtener las respuestas más relevantes de Internet:
pip instalar openai google - buscar - resultados
Paso 2: configurar entornos
Para construir el modelo que obtiene respuestas de Internet, es necesario configurar los entornos utilizando el AbiertoAI y SerpAPi llaves:
importar tú
importar conseguir pase
tú. alrededor de [ 'OPENAI_API_KEY' ] = conseguir pase. conseguir pase ( 'Clave API de OpenAI:' )
tú. alrededor de [ 'SERPAPI_API_KEY' ] = conseguir pase. conseguir pase ( 'Clave API de Serpapi:' )
Paso 3: Importar bibliotecas
Después de configurar los entornos, importe las bibliotecas para crear las herramientas para el agente y la memoria adicional para integrarlas con ellas. El siguiente código utiliza los agentes, la memoria, los llms, las cadenas, los mensajes y las utilidades para obtener las bibliotecas necesarias:
de cadena larga. agentes importar Agente ZeroShot , Herramienta , AgentExecutorde cadena larga. memoria importar ConversaciónBufferMemoria , Memoria compartida de solo lectura
de cadena larga. llms importar AbiertoAI
#obtener la biblioteca para construyendo la cadena usando LangChain
de cadena larga. cadenas importar LLMChain
de cadena larga. indicaciones importar Plantilla de aviso
#obtener la biblioteca para obtener la información de internet
de cadena larga. utilidades importar SerpAPIWrapper
Paso 4: Agregar memoria de solo lectura
Configure la plantilla para que el agente comience a realizar tareas tan pronto como el usuario proporcione la entrada. Después de eso, agregue el “Memoria del búfer de conversación()” para almacenar el historial de chat del modelo e inicializar el 'Memoria de sólo lectura' para los agentes y sus herramientas:
plantilla = '' 'Esta es una conversación entre un humano y un robot:{historia_chat}
#establecer la estructura para extraer el resumen preciso y sencillo
Resuma el chat de {input}:
' ''
inmediato = Plantilla de aviso ( variables_entrada = [ 'aporte' , 'historial_chat' ] , plantilla = plantilla )
memoria = ConversaciónBufferMemoria ( clave_memoria = 'historial_chat' )
memoria de sólo lectura = Memoria compartida de solo lectura ( memoria = memoria )
#cadena resumen para integrar todos los componentes para obteniendo el resumen de la conversación
cadena_resumen = LLMChain (
llm = AbiertoAI ( ) ,
inmediato = inmediato ,
verboso = Verdadero ,
memoria = memoria de sólo lectura ,
)
Paso 5: configurar herramientas
Ahora, configura herramientas como búsqueda y resumen para obtener la respuesta de Internet junto con el resumen del chat:
buscar = SerpAPIWrapper ( )herramientas = [
Herramienta (
nombre = 'Buscar' ,
función = buscar. correr ,
descripción = 'respuestas adecuadas a las consultas específicas sobre los acontecimientos recientes' ,
) ,
Herramienta (
nombre = 'Resumen' ,
función = cadena_resumen. correr ,
descripción = 'Es útil resumir el chat y la entrada a esta herramienta debe ser una cadena que represente quién leerá este resumen' ,
) ,
]
Paso 6: construir el agente
Configure el agente tan pronto como las herramientas estén listas para realizar las tareas requeridas y extraer las respuestas de Internet. El ' prefijo 'La variable se ejecuta antes de que los agentes asignen cualquier tarea a las herramientas y el' sufijo ”se ejecuta después de que las herramientas hayan extraído la respuesta:
prefijo = '' 'Ten una conversación con un humano y responde las siguientes preguntas lo mejor que puedas accediendo a las siguientes herramientas:' ''sufijo = '' '¡Comenzar!'
#estructura para El agente comienza a usar las herramientas mientras usa la memoria.
{ historial_chat }
Pregunta : { aporte }
{ agente_scratchpad } '' '
indicador = ZeroShotAgent.create_prompt(
#configurar plantillas de mensajes para comprender el contexto de la pregunta
herramientas,
prefijo = prefijo,
sufijo=sufijo,
variables_entrada=[' aporte ', ' historial_chat ', ' agente_scratchpad '],
)
Método 1: usar ReadOnlyMemory
Una vez que el agente está configurado para ejecutar las herramientas, el modelo con ReadOnlyMemory es el privilegiado La forma de construir y ejecutar las cadenas para obtener respuestas y el proceso es el siguiente:
Paso 1: construir la cadena
El primer paso en este método es construir la cadena y el ejecutor para el “Agente ZeroShot()” con sus argumentos. El “LLMCadena()” se utiliza para construir la conexión entre todos los chats en el modelo de lenguaje usando llm y argumentos rápidos. El agente utiliza llm_chain, tools y verbose como argumento y construye agent_chain para ejecutar tanto los agentes como sus herramientas con la memoria:
cadena_llm = LLMChain ( llm = AbiertoAI ( temperatura = 0 ) , inmediato = inmediato )agente = Agente ZeroShot ( cadena_llm = cadena_llm , herramientas = herramientas , verboso = Verdadero )
cadena_agente = AgentExecutor. from_agent_and_tools (
agente = agente , herramientas = herramientas , verboso = Verdadero , memoria = memoria
)
Paso 2: probar la cadena
Llama a cadena_agente usando el método run() para hacer la pregunta desde Internet:
cadena_agente. correr ( aporte = '¿Qué es LangChain?' )El agente ha extraído la respuesta de Internet mediante las herramientas de búsqueda:
El usuario puede hacer la pregunta de seguimiento poco clara para probar la memoria adjunta al agente:
cadena_agente. correr ( aporte = '¿Quién lo desarrolló?' )El agente utilizó el chat anterior para comprender el contexto de las preguntas y obtuvo las respuestas como se muestra en la siguiente captura de pantalla:
El agente utiliza la herramienta (summary_chain) para extraer un resumen de todas las respuestas extraídas previamente utilizando la memoria del agente:
cadena_agente. correr (aporte = '¡Gracias! Resume la conversación, para mis 5 años'
)
Producción
El resumen de las preguntas formuladas anteriormente se muestra para un niño de 5 años en la siguiente captura de pantalla:
Paso 3: probar la memoria
Imprime la memoria buffer para extraer los chats almacenados en ella usando el siguiente código:
imprimir ( cadena_agente. memoria . buffer )Los chats en su orden correcto sin ninguna modificación se han mostrado en el siguiente fragmento:
Método 2: usar la misma memoria tanto para el agente como para las herramientas
El segundo método que no recomienda la plataforma es utilizar la memoria intermedia tanto para los agentes como para las herramientas. Las herramientas pueden cambiar los chats almacenados en la memoria, lo que podría generar resultados falsos en conversaciones grandes:
Paso 1: construir la cadena
Usando el código completo de la plantilla para construir las herramientas y cadenas para los agentes con un pequeño cambio ya que esta vez no se agrega ReadOnlyMemory:
plantilla = '' 'Esta es una conversación entre un humano y un robot:{historia_chat}
Escriba un resumen de la conversación para {input}:
' ''
#construir la estructura del chat interfaz usando la plantilla de aviso agregando la memoria con la cadena
inmediato = Plantilla de aviso ( variables_entrada = [ 'aporte' , 'historial_chat' ] , plantilla = plantilla )
memoria = ConversaciónBufferMemoria ( clave_memoria = 'historial_chat' )
cadena_resumen = LLMChain (
llm = AbiertoAI ( ) ,
inmediato = inmediato ,
verboso = Verdadero ,
memoria = memoria ,
)
#construir las herramientas ( búsqueda y resumen ) para configurando los agentes
buscar = SerpAPIWrapper ( )
herramientas = [
Herramienta (
nombre = 'Buscar' ,
función = buscar. correr ,
descripción = 'respuestas adecuadas a las consultas específicas sobre los acontecimientos recientes' ,
) ,
Herramienta (
nombre = 'Resumen' ,
función = cadena_resumen. correr ,
descripción = 'Es útil obtener el resumen del chat y se necesita la entrada de cadena en esta herramienta que representa quién leerá este resumen' ,
) ,
]
#explica los pasos para El agente utiliza las herramientas para extraer información. para el chat
prefijo = '' 'Conversa con un humano, respondiendo las consultas de la mejor manera posible accediendo a las siguientes herramientas:' ''
sufijo = '' '¡Comenzar!'
#estructura para El agente comienza a usar las herramientas mientras usa la memoria.
{ historial_chat }
Pregunta : { aporte }
{ agente_scratchpad } '' '
indicador = ZeroShotAgent.create_prompt(
#configurar plantillas de mensajes para comprender el contexto de la pregunta
herramientas,
prefijo = prefijo,
sufijo=sufijo,
variables_entrada=[' aporte ', ' historial_chat ', ' agente_scratchpad '],
)
#integrar todos los componentes mientras se construye el agente ejecutor
llm_chain = LLMChain(llm=OpenAI(temperatura=0), mensaje=mensaje)
agente = ZeroShotAgent(llm_chain=llm_chain, herramientas=herramientas, detallado=Verdadero)
cadena_agente = AgentExecutor.from_agent_and_tools(
agente=agente, herramientas=herramientas, detallado=Verdadero, memoria=memoria
)
Paso 2: probar la cadena
Ejecute el siguiente código:
cadena_agente. correr ( aporte = '¿Qué es LangChain?' )La respuesta se muestra con éxito y se almacena en la memoria:
Haga la pregunta de seguimiento sin dar mucho contexto:
cadena_agente. correr ( aporte = '¿Quién lo desarrolló?' )El agente usa la memoria para comprender la pregunta transformándola y luego imprime la respuesta:
Obtenga el resumen del chat utilizando la memoria adjunta al agente:
cadena_agente. correr (aporte = '¡Gracias! Resume la conversación, para mis 5 años'
)
Producción
El resumen se ha extraído correctamente y hasta ahora todo parece igual pero el cambio llega en el siguiente paso:
Paso 3: probar la memoria
Extrayendo los mensajes del chat de la memoria usando el siguiente código:
imprimir ( cadena_agente. memoria . buffer )La herramienta ha modificado el historial añadiendo otra pregunta que no se hizo originalmente. Esto sucede cuando el modelo comprende la pregunta utilizando un autopreguntar pregunta. La herramienta piensa erróneamente que la pregunta el usuario y la trata como una consulta separada. Por lo tanto, también agrega esa pregunta adicional a la memoria que luego se usará para obtener el contexto de la conversación:
Eso es todo por ahora.
Conclusión
Para agregar memoria tanto a un agente como a sus herramientas en LangChain, instale los módulos para obtener sus dependencias e importar bibliotecas desde ellos. Después de eso, cree la memoria de conversación, el modelo de lenguaje, las herramientas y el agente para agregar la memoria. El método recomendado para agregar la memoria se utiliza ReadOnlyMemory para el agente y sus herramientas para almacenar el historial de chat. El usuario también puede utilizar el memoria conversacional tanto para agentes como para herramientas. Pero obtienen confundido a veces y cambiar los chats en la memoria.