Como implementar a lógica ReAct usando um agente em LangChain?

Como Implementar A Logica React Usando Um Agente Em Langchain



LangChain é a estrutura para a construção de modelos de linguagem e chatbots que podem compreender e gerar texto em linguagem humana. O desempenho do modelo é baseado na compreensão da linguagem e de suas complexidades durante a fase de treinamento do processo. A próxima fase é gerar os dados ou texto em linguagem natural que possa ser facilmente legível e compreensível. Essas fases são chamadas de “ Raciocínio ' e ' Atuando ”Respectivamente no domínio Processamento de Linguagem Natural.

Esboço rápido

Esta postagem irá demonstrar:

Como implementar a lógica ReAct usando um agente em LangChain?

O ' Reagir ”é a combinação das fases Razão e Ação para melhorar o desempenho do modelo de linguagem como“ ”refere-se à razão e“ Agir ”à ação. Uma lógica ReAct é frequentemente considerada a mais otimizada para construir LLMs ou chatbots para compreender e gerar texto. O agente é o tomador de decisão que decide quais ações realizar e em que ordem serão executadas.







Para aprender o processo de implementação da lógica ReAct usando um agente no LangChain, basta seguir o seguinte guia:



Etapa 1: instalação de estruturas

Em primeiro lugar, instale o LangChain para iniciar o processo de implementação da lógica ReAct:



pip instalar langchain





Instale o módulo google-search-results para obter as dependências para construir o agente que pode obter os resultados da pesquisa do google:

pip instalar openai resultados de pesquisa do Google



Depois disso, instale os módulos OpenAI que podem ser usados ​​para carregar os Large Language Models ou LLMs para implementar a lógica ReAct:

pip instalar openai

Depois de obter todos os módulos necessários, basta configurar o Ambiente OpenAI para construir LLM e Ambiente SerpAPI para usar o agente no modelo:

importar os

importar Obter passagem

os . aproximadamente [ 'OPENAI_API_KEY' ] = Obter passagem . Obter passagem ( 'Chave de API OpenAI:' )

os . aproximadamente [ 'SERPAPI_API_KEY' ] = Obter passagem . Obter passagem ( 'Chave de API Serpapi:' )

Etapa 2: Carregando modelo de linguagem

A próxima etapa é carregar os modelos de linguagem importando as bibliotecas necessárias usando a estrutura LangChain:

de cadeia longa. agentes importar carregar_ferramentas

de cadeia longa. agentes importar agente_de_inicialização

de cadeia longa. agentes importar Tipo de agente

de cadeia longa. llms importar OpenAI

Use o método OpenAI() para construir o Modelo de Linguagem (llm) e depois configure as ferramentas para os agentes usando SerpAPI:

llm = OpenAI ( temperatura = 0 )

ferramentas = carregar_ferramentas ( [ 'serpapi' , 'llm-matemática' ] , llm = llm )

Método 1: usando a linguagem de expressão LandChain

LCEL é o processo de integração ou composição de cadeias durante a construção dos modelos de linguagem em LangChain. Inicie o processo instalando o LangChainHub para obter suas dependências para construir e usar a lógica ReAct com agentes no LangChain:

pip instalar langchainhub

Importando as bibliotecas do LangChain como ReActSingleInputOutputParser para construir o modelo que pode usar o modelo ReAct:

de cadeia longa. ferramentas . renderizar importar render_text_description

de cadeia longa. agentes . analisadores de saída importar ReActSingleInputOutputParser

de cadeia longa. agentes . format_scratchpad importar format_log_to_str

de cadeia de idiomas importar eixo

Carregue o modelo de linguagem para projetar a lógica ReAct usando o método pull() e armazene-o na variável prompt. Defina algumas ferramentas que podem ser usadas para implementar a lógica no conjunto de dados carregado para implementar seu trabalho com um agente:

incitar = eixo. puxar ( 'hwchase17/reação' )

incitar = incitar. parcial (

ferramentas = render_text_description ( ferramentas ) ,

nomes_ferramentas = ',' . juntar ( [ t. nome para t em ferramentas ] ) ,

)

Agente de construção

Agora, configure o agente e suas ferramentas integrando-o ao modelo de linguagem carregado na etapa 2 deste guia:

llm_with_stop = sim. vincular ( parar = [ ' \n Observação' ] )

Defina uma variável de agente para fornecer os argumentos e ferramentas para configurar o agente que explique seu funcionamento. As partes configuradas anteriormente como o método llm_with_stop e ReActSingleInputOutputParser() estão sendo integradas ao agente:

agente = {

'entrada' : lambda x:x [ 'entrada' ] ,

'agente_scratchpad' : lambda x: format_log_to_str ( x [ 'etapas_intermediárias' ] )

} | alerta | llm_com_stop | ReActSingleInputOutputParser ( )

Obtenha a biblioteca AgentExecutor e configure seu método usando argumentos como agente, ferramentas e verbose para obter uma saída mais legível:

de cadeia longa. agentes importar AgenteExecutor

agente_executor = AgenteExecutor ( agente = agente , ferramentas = ferramentas , detalhado = Verdadeiro )

Invoque o método agent_executor() com a consulta de string como entrada que acionará o agente para extrair a saída:

agente_executor. invocar ( { 'entrada' : 'Quem é a namorada de Leo DiCaprio' } )

Saída

A captura de tela a seguir mostra que o agente extraiu as informações usando a lógica ReAct e gerou o texto em linguagem natural:

Método 2: usando ZeroShotReactAgent

A lógica ReAct também pode ser implementada usando outro agente como ZeroShotReactAgent ao configurar a variável agent_executor. Depois disso, basta chamar a variável agent_executor com a pergunta como entrada para invocar o agente:

agente_executor = agente_de_inicialização ( ferramentas , llm , agente = Tipo de agente. ZERO_SHOT_REACT_DESCRIPTION , detalhado = Verdadeiro )

agente_executor. invocar ( { 'entrada' : 'Qual é a idade da namorada de Leo DiCaprio elevada à potência de 0,21' } )

Saída

O agente extraiu as informações com base na entrada solicitada ao invocar o agente_executor:

Método 3: usando modelos de chat

Outro processo que pode ser usado para implementar a lógica ReAct usando os modelos de chat após importar a biblioteca ChatOpenAI:

de cadeia longa. chat_models importar ChatOpenAI

Construa o modelo de chat usando o método ChatOpenAI() com valor de temperatura igual a 0 que pode controlar a aleatoriedade nos resultados do modelo:

chat_model = ChatOpenAI ( temperatura = 0 )

Carregue o modelo no qual o usuário pode implementar a lógica ReAct para armazená-la na variável prompt e configure as ferramentas a serem utilizadas no processo:

incitar = eixo. puxar ( 'hwchase17/react-json' )

incitar = incitar. parcial (

ferramentas = render_text_description ( ferramentas ) ,

nomes_ferramentas = ',' . juntar ( [ t. nome para t em ferramentas ] ) ,

)

Construindo o Agente

Use o modelo de chat para armazenar as observações ou mensagens recentes quando o modelo parar de gerar o texto:

chat_model_with_stop = chat_model. vincular ( parar = [ ' \n Observação' ] )

Obtenha a biblioteca ReActJsonSingleInputOutputParser para implementar a lógica ReAct e produzir os resultados no formato JSON:

de cadeia longa. agentes . analisadores de saída importar ReActJsonSingleInputOutputParser

Crie e configure o agente usando a variável e o método chat_model para produzir resultados chamando o agente:

agente = {

'entrada' : lambda x:x [ 'entrada' ] ,

'agente_scratchpad' : lambda x: format_log_to_str ( x [ 'etapas_intermediárias' ] )

} | alerta | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Configure o agent_executor e execute-o para obter os resultados com base na consulta fornecida na variável de entrada:

agente_executor = AgenteExecutor ( agente = agente , ferramentas = ferramentas , detalhado = Verdadeiro )

agente_executor. invocar ( { 'entrada' : 'Qual é a idade da namorada de Leo DiCaprio elevada à potência de 0,21' } )

Saída

O agente extraiu a saída conforme exibido na captura de tela a seguir:

Método 4: usando ChatZeroShotReactAgent

A alteração do valor do agente também pode ser usada para implementar a lógica ReAct com a estrutura LangChain:

agente = agente_de_inicialização ( ferramentas , chat_model , agente = Tipo de agente. CHAT_ZERO_SHOT_REACT_DESCRIPTION , detalhado = Verdadeiro )

agente. correr ( 'Qual é a idade da namorada de Leo DiCaprio elevada à potência de 0,21' )

Saída

A estrutura de saída contém informações detalhadas sobre o funcionamento do agente a partir dos tokens e do modelo usado para extrair as informações:

Isso é tudo sobre o processo de implementação da lógica ReAct usando um agente no LangChain.

Conclusão

Para implementar a lógica ReAct com um agente usando a estrutura LangChain, instale módulos como google-search-results para configurar o agente. Depois disso, configure o ambiente usando as credenciais OpenAI e SerpAPI de suas contas para começar a usar o modelo. A lógica ReAct pode ser implementada usando os modelos LCEL e chat com múltiplos agentes oferecidos pelo módulo LangChain. Este guia elaborou a implementação da lógica ReAct usando o agente em LangChain.