Esboço rápido
Esta postagem irá demonstrar o seguinte:
- Como adicionar memória a um agente e suas ferramentas em LangChain
- Etapa 1: instalação de estruturas
- Passo 2: Configurando Ambientes
- Passo 3: Importando Bibliotecas
- Etapa 4: adicionar ReadOnlyMemory
- Etapa 5: configurando ferramentas
- Etapa 6: Construindo o Agente
- Método 1: usando ReadOnlyMemory
- Método 2: usando a mesma memória para agente e ferramentas
- Conclusão
Como adicionar memória a um agente e suas ferramentas no LangChain?
Adicionar memória aos agentes e ferramentas permite que eles trabalhem melhor com a capacidade de usar o histórico de chat do modelo. Com memória, o agente pode decidir com eficiência qual ferramenta implantar e quando. É preferível usar o “ Memória somente leitura ”Para agentes e ferramentas, para que eles não possam modificá-lo. Para aprender o processo de adição de memória a agentes e ferramentas no LangChain, siga as etapas listadas:
Etapa 1: instalação de estruturas
Em primeiro lugar, instale o langchain-experimental módulo para obter suas dependências para construir modelos de linguagem e ferramentas para o agente. LangChain experimental é o módulo que obtém as dependências para construção de modelos que são mais utilizados para experimentos e testes:
pip instalar langchain - experimental
Pegue o resultados de pesquisa do Google módulos com dependências OpenAI para obter as respostas mais relevantes da internet:
pip instalar openai google - procurar - resultados
Passo 2: Configurando Ambientes
Para construir o modelo que obtém respostas da internet, é necessário configurar os ambientes utilizando o OpenAI e SerpAPI chaves:
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:' )
Passo 3: Importando Bibliotecas
Após configurar os ambientes, importe as bibliotecas para construir as ferramentas do agente e a memória adicional para integração com elas. O código a seguir usa agentes, memória, llms, cadeias, prompts e utilitários para obter as bibliotecas necessárias:
de langchain. agentes importar Agente ZeroShot , Ferramenta , AgenteExecutorde langchain. memória importar ConversationBufferMemory , ReadOnlySharedMemória
de langchain. llms importar OpenAI
#pegue a biblioteca para construindo a cadeia usando LangChain
de langchain. correntes importar LLMChain
de langchain. Comandos importar Modelo de prompt
#pegue a biblioteca para obtendo as informações da internet
de langchain. Serviços de utilidade pública importar SerpAPIWrapper
Etapa 4: adicionar ReadOnlyMemory
Configure o modelo para o agente começar a executar tarefas assim que o usuário fornecer a entrada. Depois disso, adicione o “ConversationBufferMemory()” para armazenar o histórico de bate-papo do modelo e inicializar o “Memória somente leitura” para os agentes e suas ferramentas:
modelo = '' 'Esta é uma conversa entre um humano e um bot:{Histórico de conversa}
#defina a estrutura para extrair o resumo preciso e fácil
Resuma o bate-papo para {input}:
' ''
incitar = Modelo de prompt ( variáveis_de_entrada = [ 'entrada' , 'Histórico de conversa' ] , modelo = modelo )
memória = ConversationBufferMemory ( chave_de_memória = 'Histórico de conversa' )
memória somente leitura = ReadOnlySharedMemória ( memória = memória )
#summary chain para integrar todos os componentes para obtendo o resumo da conversa
cadeia_de_resumo = LLMChain (
llm = OpenAI ( ) ,
incitar = incitar ,
detalhado = Verdadeiro ,
memória = memória somente leitura ,
)
Etapa 5: configurando ferramentas
Agora, configure ferramentas como busca e resumo para obter a resposta da internet junto com o resumo do chat:
procurar = SerpAPIWrapper ( )ferramentas = [
Ferramenta (
nome = 'Procurar' ,
função = procurar. correr ,
descrição = 'respostas adequadas às perguntas direcionadas sobre os eventos recentes' ,
) ,
Ferramenta (
nome = 'Resumo' ,
função = resumo_cadeia. correr ,
descrição = 'é útil resumir o chat e a entrada para esta ferramenta deve ser uma string, representando quem irá ler este resumo' ,
) ,
]
Etapa 6: Construindo o Agente
Configure o agente assim que as ferramentas estiverem prontas para realizar as tarefas necessárias e extrair as respostas da internet. O ' prefixo ”A variável é executada antes que os agentes atribuam qualquer tarefa às ferramentas e o“ sufixo ”é executado após as ferramentas extrairem a resposta:
prefixo = '' 'Converse com um humano, respondendo às seguintes perguntas da melhor maneira possível, acessando as seguintes ferramentas:' ''sufixo = '' 'Começar!'
#estrutura para o agente para começar a usar as ferramentas enquanto usa a memória
{ Histórico de conversa }
Pergunta : { entrada }
{ agente_scratchpad } '' '
prompt = ZeroShotAgent.create_prompt(
#configure modelos de prompt para entender o contexto da pergunta
ferramentas,
prefixo = prefixo,
sufixo = sufixo,
variáveis_de_entrada=[' entrada ',' Histórico de conversa ',' agente_scratchpad '],
)
Método 1: usando ReadOnlyMemory
Uma vez que o agente esteja configurado para executar as ferramentas, o modelo com ReadOnlyMemory é o preferido maneira de construir e executar as cadeias para buscar respostas e o processo é o seguinte:
Etapa 1: Construindo a Cadeia
O primeiro passo neste método é construir a cadeia e o executor para o “ZeroShotAgente()” com seus argumentos. O “LLMCain()” é usado para construir a conexão entre todos os chats no modelo de linguagem usando os argumentos llm e prompt. O agente usa llm_chain, ferramentas e verbose como argumento e constrói agent_chain para executar ambos os agentes e suas ferramentas com a memória:
llm_chain = LLMChain ( llm = OpenAI ( temperatura = 0 ) , incitar = incitar )agente = Agente ZeroShot ( llm_chain = llm_chain , ferramentas = ferramentas , detalhado = Verdadeiro )
agente_chain = AgenteExecutor. from_agent_and_tools (
agente = agente , ferramentas = ferramentas , detalhado = Verdadeiro , memória = memória
)
Etapa 2: Testando a Cadeia
Ligar para agente_chain usando o método run() para fazer a pergunta da internet:
agente_chain. correr ( entrada = 'O que é LangChain' )O agente extraiu a resposta da internet utilizando as ferramentas de busca:
O usuário pode fazer a pergunta de acompanhamento pouco clara para testar a memória anexada ao agente:
agente_chain. correr ( entrada = 'Quem o desenvolveu?' )O agente utilizou o chat anterior para entender o contexto das perguntas e obteve as respostas conforme mostrado na captura de tela a seguir:
O agente utiliza a ferramenta (summary_chain) para extrair um resumo de todas as respostas extraídas anteriormente utilizando a memória do agente:
agente_chain. correr (entrada = 'Obrigado! Resuma a conversa, para meus 5 anos'
)
Saída
O resumo das perguntas feitas anteriormente foi exibido para uma criança de 5 anos na imagem a seguir:
Etapa 3: testando a memória
Imprima a memória buffer para extrair os chats armazenados nela usando o seguinte código:
imprimir ( agente_chain. memória . amortecedor )Os chats em sua ordem correta sem qualquer modificação foram exibidos no seguinte trecho:
Método 2: usando a mesma memória para agente e ferramentas
O segundo método não recomendado pela plataforma é utilizar a memória buffer tanto para agentes quanto para ferramentas. As ferramentas podem alterar os chats armazenados na memória, o que pode retornar resultados falsos em conversas grandes:
Etapa 1: Construindo a Cadeia
Usando o código completo do modelo para construir as ferramentas e cadeias para os agentes com uma pequena alteração, já que ReadOnlyMemory não foi adicionado desta vez:
modelo = '' 'Esta é uma conversa entre um humano e um bot:{Histórico de conversa}
Escreva um resumo da conversa para {input}:
' ''
#construa a estrutura do chat interface usando o modelo de prompt adicionando a memória com a cadeia
incitar = Modelo de prompt ( variáveis_de_entrada = [ 'entrada' , 'Histórico de conversa' ] , modelo = modelo )
memória = ConversationBufferMemory ( chave_de_memória = 'Histórico de conversa' )
cadeia_de_resumo = LLMChain (
llm = OpenAI ( ) ,
incitar = incitar ,
detalhado = Verdadeiro ,
memória = memória ,
)
#construa as ferramentas ( pesquisa e resumo ) para configurando os agentes
procurar = SerpAPIWrapper ( )
ferramentas = [
Ferramenta (
nome = 'Procurar' ,
função = procurar. correr ,
descrição = 'respostas adequadas às perguntas direcionadas sobre os eventos recentes' ,
) ,
Ferramenta (
nome = 'Resumo' ,
função = resumo_cadeia. correr ,
descrição = 'útil para obter o resumo do chat e preciso da string de entrada para esta ferramenta representando quem irá ler este resumo' ,
) ,
]
#explicar os passos para o agente use as ferramentas para extrair informações para o bate-papo
prefixo = '' “Converse com um humano, respondendo às dúvidas da melhor forma possível acessando as seguintes ferramentas:” ''
sufixo = '' 'Começar!'
#estrutura para o agente para começar a usar as ferramentas enquanto usa a memória
{ Histórico de conversa }
Pergunta : { entrada }
{ agente_scratchpad } '' '
prompt = ZeroShotAgent.create_prompt(
#configure modelos de prompt para entender o contexto da pergunta
ferramentas,
prefixo = prefixo,
sufixo = sufixo,
variáveis_de_entrada=[' entrada ',' Histórico de conversa ',' agente_scratchpad '],
)
#integrar todos os componentes ao construir o executor do agente
llm_chain = LLMChain(llm=OpenAI(temperatura=0), prompt=prompt)
agente = ZeroShotAgent(llm_chain=llm_chain, ferramentas=ferramentas, detalhado=True)
agente_chain = AgentExecutor.from_agent_and_tools(
agente=agente, ferramentas=ferramentas, detalhado=True, memória=memória
)
Etapa 2: Testando a Cadeia
Execute o seguinte código:
agente_chain. correr ( entrada = 'O que é LangChain' )A resposta é exibida com sucesso e armazenada na memória:
Faça a pergunta de acompanhamento sem fornecer muito contexto:
agente_chain. correr ( entrada = 'Quem o desenvolveu?' )O agente usa a memória para entender a pergunta transformando-a e depois imprime a resposta:
Obtenha o resumo do chat usando a memória anexada ao agente:
agente_chain. correr (entrada = 'Obrigado! Resuma a conversa, para meus 5 anos'
)
Saída
O resumo foi extraído com sucesso e até agora tudo parece igual, mas a mudança vem na próxima etapa:
Etapa 3: testando a memória
Extraindo as mensagens de chat da memória usando o seguinte código:
imprimir ( agente_chain. memória . amortecedor )A ferramenta modificou o histórico adicionando outra pergunta que não foi feita originalmente. Isso acontece à medida que o modelo entende a questão usando um auto-perguntar pergunta. A ferramenta pensa erroneamente que foi feita pelo usuário e a trata como uma consulta separada. Portanto, ele também adiciona aquela pergunta adicional à memória, que será usada para obter o contexto da conversa:
É tudo por agora.
Conclusão
Para adicionar memória a um agente e suas ferramentas no LangChain, instale os módulos para obter suas dependências e importar bibliotecas deles. Depois disso, construa a memória da conversa, o modelo de linguagem, as ferramentas e o agente para adicionar a memória. O método recomendado para adicionar a memória é usar o ReadOnlyMemory para o agente e suas ferramentas para armazenar o histórico do chat. O usuário também pode usar o memória conversacional para agentes e ferramentas. Mas, eles conseguem confuso às vezes e altere os chats na memória.