¿Cómo implementar la lógica ReAct usando un agente en LangChain?

Como Implementar La Logica React Usando Un Agente En Langchain



LangChain es el marco para crear modelos de lenguaje y chatbots que pueden comprender y generar texto en lenguaje humano. El desempeño del modelo se basa en la comprensión del lenguaje y sus complejidades durante la fase de entrenamiento del proceso. La siguiente fase es generar datos o texto en lenguaje natural que pueda ser fácilmente legible y comprensible. Estas fases se denominan “ Razonamiento ' y ' Interino ”respectivamente en el dominio de Procesamiento del Lenguaje Natural.

Esquema rápido

Esta publicación demostrará:

¿Cómo implementar la lógica ReAct usando un agente en LangChain?

El ' Reaccionar ' es la combinación de las fases de Razón y Acción para mejorar el rendimiento del modelo de lenguaje como ' Re ” se refiere a la razón y “ Acto ' a la acción. Una lógica ReAct a menudo se considera la más optimizada para crear LLM o chatbots para comprender y generar texto. El agente es quien decide qué acciones realizar y en qué orden se realizarán.







Para conocer el proceso de implementación de la lógica ReAct usando un agente en LangChain, simplemente consulte la siguiente guía:



Paso 1: instalar marcos

En primer lugar, instale LangChain para comenzar con el proceso de implementación de la lógica ReAct:



pip instalar cadena larga





Instale el módulo google-search-results para obtener las dependencias para crear el agente que puede obtener los resultados de búsqueda de Google:

pip instalar openai resultados de búsqueda de google



Después de eso, instale los módulos OpenAI que se pueden usar para cargar los modelos de lenguajes grandes o LLM para implementar la lógica de ReAct:

instalación de pip en openai

Después de obtener todos los módulos necesarios, simplemente configure el Entorno abierto de IA para construir LLM y Entorno SerpAPI para usar el agente en el modelo:

importar

importar conseguir pase

. alrededor de [ 'OPENAI_API_KEY' ] = conseguir pase . conseguir pase ( 'Clave API de OpenAI:' )

. alrededor de [ 'SERPAPI_API_KEY' ] = conseguir pase . conseguir pase ( 'Clave API de Serpapi:' )

Paso 2: cargar el modelo de lenguaje

El siguiente paso es cargar los modelos de lenguaje importando las bibliotecas necesarias utilizando el marco LangChain:

de cadena larga. agentes importar herramientas_carga

de cadena larga. agentes importar agente_inicializar

de cadena larga. agentes importar Tipo de agente

de cadena larga. llms importar Abierto AI

Utilice el método OpenAI() para construir el modelo de lenguaje (llm) y luego configure las herramientas para los agentes usando SerpAPI:

llm = Abierto AI ( temperatura = 0 )

herramientas = herramientas_carga ( [ 'serpapi' , 'llm-matemáticas' ] , llm = llm )

Método 1: uso del lenguaje de expresión LandChain

LCEL es el proceso de integrar o componer cadenas mientras se construyen los modelos de lenguaje en LangChain. Inicie el proceso instalando LangChainHub para obtener sus dependencias para crear y usar la lógica ReAct con agentes en LangChain:

pip instalar langchainhub

Importar las bibliotecas de LangChain como ReActSingleInputOutputParser para construir el modelo que puede usar el modelo ReAct:

de cadena larga. herramientas . prestar importar render_text_descripción

de cadena larga. agentes . analizadores_de_salida importar ReActSingleInputOutputParser

de cadena larga. agentes . formato_scratchpad importar formato_log_to_str

de cadena larga importar centro

Cargue el modelo de lenguaje para diseñar la lógica de ReAct usando el método pull() y guárdelo en la variable de solicitud. Defina algunas herramientas que se pueden utilizar para implementar la lógica en el conjunto de datos cargado para implementar su funcionamiento con un agente:

inmediato = centro. jalar ( 'hwchase17/reaccionar' )

inmediato = inmediato. parcial (

herramientas = render_text_descripción ( herramientas ) ,

nombres_herramientas = ', ' . unirse ( [ t. nombre para t en herramientas ] ) ,

)

Agente de construcción

Ahora, configure el agente y sus herramientas integrándolo con el modelo de lenguaje cargado en el paso 2 de esta guía:

llm_con_parada = llm. unir ( detener = [ ' \norte Observación' ] )

Defina una variable de agente para proporcionar los argumentos y herramientas para configurar el agente que explican su funcionamiento. Las partes previamente configuradas como el método llm_with_stop y ReActSingleInputOutputParser() se están integrando con el agente:

agente = {

  'aporte' : lambda x:x [ 'aporte' ] ,

  'agente_scratchpad' : lambda x: formato_log_to_str ( X [ 'pasos_intermedios' ] )

} | rápido | llm_with_stop | ReActSingleInputOutputParser ( )

Obtenga la biblioteca AgentExecutor y configure su método usando argumentos como agente, herramientas y detallado para obtener un resultado más legible:

de cadena larga. agentes importar AgentExecutor

agente_ejecutor = AgentExecutor ( agente = agente , herramientas = herramientas , verboso = Verdadero )

Invoque el método agent_executor() con la consulta de cadena como entrada, lo que hará que el agente extraiga la salida:

agente_ejecutor. invocar ( { 'aporte' : '¿Quién es la novia de Leo DiCaprio?' } )

Producción

La siguiente captura de pantalla muestra que el agente extrajo la información utilizando la lógica ReAct y generó el texto en lenguaje natural:

Método 2: usar ZeroShotReactAgent

La lógica de ReAct también se puede implementar utilizando otro agente como ZeroShotReactAgent mientras se configura la variable agent_executor. Después de eso, simplemente llame a la variable agent_executor con la pregunta como entrada para invocar al agente:

agente_ejecutor = agente_inicializar ( herramientas , llm , agente = Tipo de agente. ZERO_SHOT_REACT_DESCRIPTION , verboso = Verdadero )

agente_ejecutor. invocar ( { 'aporte' : '¿Cuál es la edad de la novia de Leo DiCaprio elevada a la potencia 0,21?' } )

Producción

El agente ha extraído la información basándose en la entrada solicitada al invocar al agente_ejecutor:

Método 3: usar modelos de chat

Otro proceso que se puede utilizar para implementar la lógica de ReAct utilizando los modelos de chat después de importar la biblioteca ChatOpenAI:

de cadena larga. modelos_chat importar ChatOpenAI

Construya el modelo de chat usando el método ChatOpenAI() con el valor de temperatura igual a 0 que puede controlar la aleatoriedad en los resultados del modelo:

modelo_chat = ChatOpenAI ( temperatura = 0 )

Cargue el modelo en el que el usuario puede implementar la lógica de ReAct para almacenarlo en la variable de solicitud y configurar las herramientas que se utilizarán en el proceso:

inmediato = centro. jalar ( 'hwchase17/reaccionar-json' )

inmediato = inmediato. parcial (

herramientas = render_text_descripción ( herramientas ) ,

nombres_herramientas = ', ' . unirse ( [ t. nombre para t en herramientas ] ) ,

)

Construyendo el agente

Utilice el modelo de chat para almacenar las observaciones o mensajes recientes cuando el modelo deje de generar el texto:

chat_modelo_con_parada = modelo_chat. unir ( detener = [ ' \norte Observación' ] )

Obtenga la biblioteca ReActJsonSingleInputOutputParser para implementar la lógica de ReAct y producir los resultados en formato JSON:

de cadena larga. agentes . analizadores_de_salida importar ReActJsonSingleInputOutputParser

Cree y configure el agente utilizando la variable y el método chat_model para producir resultados llamando al agente:

agente = {

  'aporte' : lambda x:x [ 'aporte' ] ,

  'agente_scratchpad' : lambda x: formato_log_to_str ( X [ 'pasos_intermedios' ] )

} | rápido | chat_modelo_con_parada | ReActJsonSingleInputOutputParser ( )

Configure agent_executor y ejecútelo para obtener los resultados según la consulta proporcionada en la variable de entrada:

agente_ejecutor = AgentExecutor ( agente = agente , herramientas = herramientas , verboso = Verdadero )

agente_ejecutor. invocar ( { 'aporte' : '¿Cuál es la edad de la novia de Leo DiCaprio elevada a la potencia 0,21?' } )

Producción

El agente extrajo el resultado como se muestra en la siguiente captura de pantalla:

Método 4: usar ChatZeroShotReactAgent

Cambiar el valor del agente también se puede utilizar para implementar la lógica de ReAct con el marco LangChain:

agente = agente_inicializar ( herramientas , modelo_chat , agente = Tipo de agente. CHAT_ZERO_SHOT_REACT_DESCRIPTION , verboso = Verdadero )

agente. correr ( '¿Cuál es la edad de la novia de Leo DiCaprio elevada a la potencia 0,21?' )

Producción

La estructura de salida contiene información detallada sobre el funcionamiento del agente a partir de los tokens y el modelo utilizado para extraer la información:

Se trata del proceso de implementación de la lógica de ReAct utilizando un agente en LangChain.

Conclusión

Para implementar la lógica de ReAct con un agente que utiliza el marco LangChain, instale módulos como google-search-results para configurar el agente. Después de eso, configure el entorno utilizando las credenciales OpenAI y SerpAPI de sus cuentas para comenzar a usar el modelo. La lógica de ReAct se puede implementar utilizando LCEL y los modelos de chat con múltiples agentes que ofrece el módulo LangChain. Esta guía ha explicado detalladamente la implementación de la lógica de ReAct utilizando el agente en LangChain.