Criação de um agente de IA com memória usando MongoDB, Fireworks AI e LangChain
Avalie esse Tutorial
Este tutorial fornece um guia passo a passo sobre como criar um agente assistente de pesquisa de IA que usa o MongoDB como provedor de memória, o Fireworks AI para chamadas de funções e o LangChain para integrar e gerenciar componentes conversacionais.
Esse agente pode ajudar os pesquisadores, permitindo que eles pesquisem trabalhos de pesquisa com semelhança semântica e pesquisa vetorial, usando o MongoDB como uma base de conhecimento estruturada e um armazenamento de dados para histórico de conversação.
Este repositório contém todas as etapas para implementar o agente neste tutorial, incluindo trechos de código e explicações para configurar a memória do agente, integrar ferramentas e configurar o modelo de linguagem para interagir efetivamente com humanos e outros sistemas.
O que esperar deste tutorial:
- Definições e conceitos fundamentais de um agente
- Competência detalhada dos componentes do agente
- Guia passo a passo de implementação para construir um agente de assistência à pesquisa
- Insights sobre como equipar os agentes com sistemas de memória e gerenciamento de conhecimento eficazes
Um agente é uma entidade computacional artificial com consciência de seu ambiente. Ele é equipado com faculdades que permitem a percepção por meio de entrada, ação por meio do uso de ferramentas e habilidades cognitivas por meio de modelos básicos apoiados por memória de longo e curto prazo. Na AI, os agentes são entidades artificiais que podem tomar decisões inteligentes seguidas de ações baseadas na percepção do ambiente, possibilitadas por grandes modelos de linguagem.
Antes de discutir a pilha e a implementação de um agente, é útil entender os componentes e as características do novo formato dos aplicativos de AI. Esta seção explora os principais aspectos dos agentes.
Um agente é uma entidade computacional composta de vários componentes integrados, incluindo o encéfalo, a percepção e a ação. Esses componentes trabalham de forma coesa para permitir que o agente atinja seus objetivos e metas.
- Cérebre: esse componente é crucial para as funções1 do agente, como argumento, planejamento e tomada de decisão. Isso é implementado com um LLM. O encéfalo consiste em vários módulos: memória, analisador e conhecimento. O módulo de memória armazena interações passadas, permitindo que o agente utilize dados históricos para planejamento e ações futuras. O módulo de perfil adapta o comportamento do agente para se ajustar a funções definidas, enquanto o módulo de conhecimento armazena e recupera informações específicas do domínio que ajudam no planejamento e na ação.
- Ação: o componente de ação permite que o agente React ao seu ambiente e a novas informações. Inclui módulos que ajudam o agente a gerar respostas e interagir com outros sistemas. Usando os processos do memória, um agente baseado em LLM pode decompor tarefas em etapas, cada uma associada a ferramentas específicas do inventário do agente, permitindo a utilização eficaz em momentos apropriados.
- Perceção: este componente lida com a captura e o processamento de entradas do ambiente geradas por humanos e outros agentes. As entradas são principalmente Auditivas, textuais e visuais, que o agente processa para informar ações e decisões.
O agente implementado neste tutorial terá todos os três componentes principais descritos acima, incluindo acesso a ferramentas para ajudar o agente a atingir um objetivo definido.
Os agentes baseados em LLM demonstram comportamentos e capacidades que lhes permitem executar tarefas complexas de forma autônoma. Cada características dota os agentes de capacidades únicas, desde a tomada de decisões e a resolução de problemas até a interação dinâmica com o ambiente e outras entidades.
Abaixo está um resumo das principais características dos agentes:
- Os agentes são autônomos e independentes.
- Os agentes são introspectivos e proativos.
- Os agentes são reativos.
- Os agentes são interativos.
Os agentes são autônomos e independentes, com suas ações e decisões orientadas por um objetivo bem definido, normalmente definido por humanos. No entanto, suas instruções não especificam as ferramentas a serem usadas ou as etapas a serem executadas, exigindo que os agentes planejem e raciocinam de forma independente. Os agentes de idioma, aprimorados por grandes modelos de idioma, são particularmente hábeis no uso de habilidades avançadas de planejamento e argumentos.
Os agentes baseados em LLM são introspectivos e proativos. Eles podem responder a gatilhos usando metodologias como o ReAct e a cadeia de ideias, que os ajudam a resolver problemas e planejar ações de forma eficaz. Esses agentes também são reativos, usando o uso de ferramentas e capacidades de consumo de entradas para agir com base em observações internas e externas sem influencia externa. Isso inclui o processamento de várias formas de entrada, como dados de texto, visuais e auditórios.
Além disso, os agentes são altamente interativos e, muitas vezes, precisam se comunicar com outros agentes ou humanos em seus sistemas. Eles podem entender o feedback e gerar respostas, o que os ajuda a adaptar suas ações de acordo com as necessidades. Em ambientes com vários agentes, sua capacidade de assumir funções e imitar comportamentos sociais facilita a colaboração e cumpre objetivos abrangentes.
Esta seção aborda as ferramentas e bibliotecas usadas para criar o agente projetado para o caso de uso específico de um assistente de pesquisa AI.
As habilidades do assistente de pesquisa AI são as seguintes:
- Fornecer uma lista de artigos de pesquisa relacionados a tópicos e assuntos de consultas de usuários.
- Forneça resumos de artigos de pesquisa mediante solicitação.
- Utilize sua base de conhecimento para recuperar metadados em documentos de pesquisa armazenados.
- Use essas informações para atender às consultas dos usuários e atingir seus objetivos de forma eficaz.
O FireFunction V1 do Fireworks AI permite que o cerebra do agente responda às queries do usuário, decida quando usar as ferramentas e gere entradas estruturadas para as ferramentas disponíveis. A percepção do agente sobre seu ambiente é habilitada somente por meio da entrada de texto. Este componente lida com as entradas de texto bruto dos usuários.
Os LLMs são capazes de usar ferramentas, e o agente neste tutorial está focado na recuperação de informações por meio de vários métodos.
Retriever
e Arxiv Document Loader
da LangChain implementam ferramentas para recuperar informações. O agente usa o Retriever
para pesquisar e buscar informações relevantes em um armazenamento de dados e o Arxiv Document Loader
para acessar e recuperar documentos científicos conforme necessário.O MongoDB é o provedor de memória do agente e fornece armazenamento e gerenciamento de dados de longo prazo para histórico de conversação, um banco de dados vetorial para armazenar e recuperar dados de incorporação vetorial e armazenamento de dados para os dados operacionais do agente. Os recursos de pesquisa vetorial do MongoDB permitem a recuperação de informações com base em semelhanças semânticas entre consultas de usuários e itens no banco de dados vetorial, que simula o conhecimento inerente do agente.
A primeira etapa no processo de implementação é instalar as bibliotecas necessárias para acessar classes, métodos e funcionalidades necessárias para implementar vários componentes do sistema do agente.
- langchain: Fornece ferramentas e funcionalidades para a integração de vários componentes de aplicativos LLM, como modelos, fontes de dados e soluções de banco de dados. Também fornece métodos para a construção de sistemas de bate-papo, agentes e modelos de prompt usando vários formatos e estruturando entradas para LLMs.
- langchain-openai: pacote Python para usar modelos OpenAI com LangChain.
- langchain-fireworks: estende a biblioteca LangChain fornecendo soluções específicas para o provedor de modelos FireworksAI.
- langchain-mongodb: pacote Python para usar o MongoDB como armazenamento de vetores, cache semântico, armazenamento de histórico de chat etc. em LangChain.
- arxiv: Biblioteca Python para baixar documentos do repositório arXiv.
- pyducf: ativa o que permite a extração de texto, imagens e metadados de arquivos PDF.
- datasets: biblioteca Python para obter acesso a conjuntos de dados disponíveis no Hugging Face Hub.
- PyMongo: fornece métodos e funcionalidades para se conectar ao cluster de MongoDB database e executar operações em collections mantidas em bancos de dados.
O trecho de código abaixo instala todas as bibliotecas necessárias para as etapas de implementação subsequentes.
1 !pip install langchain langchain_openai langchain-fireworks langchain-mongodb arxiv pymupdf datasets `pymongo`
Esta etapa abrange a configuração e a recuperação de variáveis de ambiente. Para este tutorial, as variáveis de ambiente são chaves de API e identificadores exclusivos de modelos e provedores de soluções de banco de dados. Essas informações são atribuídas a variáveis acessadas no ambiente de desenvolvimento.
- Obtenha instruções sobre como obter uma connection string de URI do MongoDB, que é fornecida logo após a criação do banco de dadosMongoDB.
1 import os 2 3 # Be sure to have all the API keys in your local environment as shown below 4 # Do not publish environment keys in production 5 # os.environ["OPENAI_API_KEY"] = "sk" 6 # os.environ["FIREWORKS_API_KEY"] = "" 7 # os.environ["MONGO_URI"] = "" 8 9 FIREWORKS_API_KEY = os.environ.get("FIREWORKS_API_KEY") 10 OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY") 11 MONGO_URI = os.environ.get("MONGO_URI")
O trecho de código acima faz o seguinte:
- Recuperando as variáveis de ambiente: o
os.environ.get()
permite recuperar o valor atribuído a uma variável de ambiente por referência de nome.
Este tutorial usa um subconjunto especializado do conjunto de dados arXiv hospedado no MongoDB, derivado da extensiva coleção original na plataforma Hugging Face. Essa versão de subconjunto engloba mais 50,000 artigos específicos obtidos diretamente do arXiv. Cada registro no conjunto de dados do subconjunto tem um campo de incorporação, que encapsula uma representação -dimensional 256do texto derivado da combinação dos nomes dos autores, dos resumos e do título de cada documento.
Esses embeddings são gerados usando o
text-embedding-3-small model
da OpenAI , que foi selecionado principalmente devido ao seu tamanho mínimo de dimensão que ocupa menos espaço de armazenamento. Leia o tutorial, que explora maneiras de selecionar modelos de incorporação apropriados para vários casos de uso.Esse conjunto de dados atuará como a base de conhecimento do agente. O objetivo é que, antes de usar qualquer ferramenta do Atlas Search da Internet, o agente tente inicialmente responder a uma pergunta usando sua base de conhecimento ou memória de longo prazo que, neste caso, são os registros arXiv armazenados no banco de dados vetorial do MongoDB .
A etapa seguinte desta seção carrega o conjunto de dados, cria uma conexão com o banco de dados e ingere os registros no banco de dados.
O código abaixo é a etapa de implementação para obter o subconjunto do conjunto de dados arXiv usando a biblioteca
datasets
do Hugging Face. Antes de executar o trecho de código abaixo, certifique-se de que um HF_TOKEN
esteja presente em seu ambiente de desenvolvimento; este é o token de acesso do usuário necessário para acesso autorizado aos recursos do Hugging Face. Siga as instruções para obter o token associado à sua conta.1 import pandas as pd 2 from datasets import load_dataset 3 4 data = load_dataset("MongoDB/subset_arxiv_papers_with_embeddings") 5 dataset_df = pd.DataFrame(data["train"])
- Importe a biblioteca de Pandas utilizando o namespace
pd
para referenciar a biblioteca e acessar funcionalidades. - Importe a biblioteca de conjuntos de dados para usar o método
load_dataset
, que permite acesso a conjuntos de dados hospedados na plataforma Hugging Face fazendo referência ao seu caminho. - Atribua o conjunto de dados carregado aos dados variáveis.
- Converta o subconjunto de treinamento do conjunto de dados para um DataFrame de Pandas e atribua o resultado à variável
dataset_df
.
Antes de executar as operações no seguinte bloco de código abaixo, certifique-se de ter criado um banco de MongoDB database com uma coleção e obter a string URI para o cluster de MongoDB database . A criação de um banco de dados e de uma collection no MongoDB é simplificada com MongoDB Atlas. Registre uma conta Atlas gratuita ou entre na sua conta Atlas existente. Siga as instruções (selecione Atlas UI como o procedimento) para implantar seu primeiro cluster.
O banco de dados para este tutorial é chamado
agent_demo
, e a collection que manterá os registros dos metadados dos artigos Científicos do ArXiv e suas incorporações é chamada knowledge
.Para habilitar os recursos de pesquisa vetorial do MongoDB, uma definição de índice vetorial deve ser definida para o campo que contém as incorporações. Siga as instruções aqui para criar um índice de busca vetorial. Certifique-se de que o nome do seu índice de pesquisa vetorial seja
vector_index
.A definição do seu índice de pesquisa de vetores deve ser semelhante ao que é mostrado abaixo:
1 { 2 "fields": [ 3 { 4 "numDimensions": 256, 5 "path": "embedding", 6 "similarity": "cosine", 7 "type": "vector" 8 } 9 ] 10 }
Depois que o banco de dados, a collection e o índice de pesquisa vetorial estiverem totalmente configurados, conecte-se ao banco de dados e execute tarefas de ingestão de dados com apenas algumas linhas de código com o PyMongo.
1 from pymongo import MongoClient 2 3 # Initialize MongoDB python client 4 client = MongoClient(MONGO_URI) 5 6 DB_NAME = "agent_demo" 7 COLLECTION_NAME = "knowledge" 8 ATLAS_VECTOR_SEARCH_INDEX_NAME = "vector_index" 9 collection = client.get_database(DB_NAME).get_collection(COLLECTION_NAME)
- Importe a classe
MongoClient
da biblioteca PyMongo para habilitar as conexões do MongoDB em seu aplicativo Python. - Utilize o MongoClient com seu
MONGO_URI
para estabelecer uma conexão com seu MongoDB database. SubstituaMONGO_URI
pela sua string de conexão real. - Defina o nome do banco de dados como
agent_demo
, atribuindo-o à variávelDB_NAME
. - Defina o nome da sua collection como
knowledge
atribuindo-o à variávelCOLLECTION_NAME
. - Acesse a coleção de conhecimento dentro do banco de dados do
agent_demo
utilizando oclient.get_database(DB_NAME).get_collection(COLLECTION_NAME)
e atribuindo-o a uma variável para fácil referência. - Defina o nome do índice da pesquisa vetorial como
vector_index
atribuindo-o à variávelATLAS_VECTOR_SEARCH_INDEX_NAME
, preparação para possíveis operações de pesquisa baseadas em vetores em sua collection.
O trecho de código abaixo descreve o processo de ingestão. Primeiro, a coleção é esvaziada para garantir que o tutorial seja concluído com uma coleção limpa. A próxima etapa é converter o DataFrame do pandas em uma lista de dicionários e, por fim, o processo de ingestão é executado usando o método
insert_many()
disponível no objeto de coleção do PyMongo.1 # Delete any existing records in the collection 2 collection.delete_many({}) 3 4 # Data Ingestion 5 records = dataset_df.to_dict('records') 6 collection.insert_many(records) 7 8 print("Data ingestion into MongoDB completed")
A biblioteca de código aberto LangChain tem uma implementação de interface que se comunica entre a query do usuário e um armazenamento de dados. Essa interface é chamada de retriever.
Um retriever é uma interface simples e leve dentro do ecossistema do LangChain que usa uma string de query como entrada e retorna uma lista de documentos ou registros que correspondem à query com base em alguma medida de similaridade e limite de pontuação.
O armazenamento de dados para o backend do recuperador para este tutorial será um armazenamento de vetor habilitado pelo MongoDB database. O trecho de código abaixo mostra a implementação necessária para inicializar um armazenamento de vetores MongoDB usando a string de conexão MongoDB e especificando outros argumentos. A operação final usa a instância do armazenamento de vetores como recuperador.
1 from langchain_openai import OpenAIEmbeddings 2 from langchain_mongodb import MongoDBAtlasVectorSearch 3 4 embedding_model = OpenAIEmbeddings(model="text-embedding-3-small", dimensions=256) 5 6 # Vector Store Creation 7 vector_store = MongoDBAtlasVectorSearch.from_connection_string( 8 connection_string=MONGO_URI, 9 namespace=DB_NAME + "." + COLLECTION_NAME, 10 embedding= embedding_model, 11 index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME, 12 text_key="abstract" 13 ) 14 15 `retriever` = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
- Comece importando
OpenAIEmbeddings
de langchain_openai eMongoDBAtlasVectorSearch
de langchain_mongodb. Essas importações permitirão a você gerar incorporações de texto e interface com o MongoDB Atlas para operações de pesquisa vetorial. - Instancie um objeto
OpenAIEmbeddings
especificando o parâmetro do modelo como "text-embedding-3-small" e as dimensões como 256. Essa etapa prepara o modelo para gerar 256-dimensional vector embeddings a partir da consulta passada para o recuperador. - Utilize o método
MongoDBAtlasVectorSearch.from_connection_string
para configurar a conexão com seu banco de dados MongoDB Atlas. Os parâmetros para esta função são os seguintes:connection_string
Esta é a string de conexão do MongoDB.namespace
: Concatene seu nome de banco de dados (DB_NAME) e nome da coleção (COLLECTION_NAME) para formar o namespace onde os registros são armazenados.embedding
: Passe o embedding_model inicializado anteriormente como parâmetro de incorporação. Certifique-se de que o modelo de incorporação especificado neste parâmetro seja o mesmo usado para codificar o campo de incorporação nos registros da collection de banco de dados.index_name
: Indique o nome do seu índice de pesquisa vetorial. Esse índice facilita operações de pesquisa eficientes no banco de dados.text_key
: especifique "abstract" como o parâmetro text_key. Isso indica que o campo abstrato em seus documentos será o foco para gerar e pesquisar incorporações.
- Crie um
retriever
a partir do seu vector_store usando o métodoas_retriever
, personalizado para pesquisas de similaridade semântica. Essa configuração permite a recuperação dos cinco documentos principais que mais se aproximam da consulta do usuário com base na similaridade vetorial, usando os recursos de pesquisa vetorial do MongoDB para a recuperação eficiente de documentos de sua collection.
O agente para este tutorial requer um LLM como seu fornecedor de conhecimento paramétrico e de argumentos. O fornecedor do modelo do agente é o Fireworks AI. Mais especificamente, o modelo FireFunction V1 , que é o modelo de chamada de função do Fireworks AI, tem uma janela de contexto de 32,768 tokens.
O que é chamada de função?
A chamada de função refere-se à capacidade dos modelos de linguagem grandes (LLMs) de selecionar e usar as ferramentas disponíveis para concluir tarefas específicas. Primeiro, o LLM escolhe uma ferramenta por uma referência de nome que, neste contexto, é uma função. Em seguida, ele constrói a entrada estruturada apropriada para essa função, normalmente no JSON schema que contém campos e valores correspondentes aos argumentos da função esperada e seus valores. Esse processo envolve a invocação de uma função selecionada ou uma API com a entrada preparada pelo LLM. O resultado desta invocação de função pode então ser usado como entrada para processamento posterior pelo LLM.
A chamada de função transforma a natureza probabilística condicional dos LLMs em um modelo previsível e explicável, principalmente porque as funções acessíveis pelos LLMs são construídas, determinísticas e implementadas com restrições de entrada e saída.
O modelo de função de disparo do Fireworks AI é baseado no Mixtral e é de código aberto. Ele se integra à biblioteca LangChain, que abstrai alguns dos detalhes de implementação da chamada de funções com LLMs com recursos de chamada de ferramentas. A biblioteca LangChain fornece uma interface fácil para integrar e interagir com o modelo de chamada de função do Fireworks AI.
O trecho de código abaixo inicializa o modelo de idioma com recursos de chamada de função. A classe
Fireworks
é instanciada com um modelo específico, "accounts/fireworks/models/firefunction-v1 ", e configurada para usar um máximo de 256 tokens.1 import os 2 from langchain_fireworks import Fireworks 3 4 llm = Fireworks( 5 model="accounts/fireworks/models/firefunction-v1", 6 max_tokens=256)
Isso é tudo para configurar um LLM para o agente LangChain usando o Fireworks AI. O agente poderá selecionar uma função em uma lista de funções fornecidas para concluir uma tarefa. Ele gera entrada de função como um JSON schema estruturado, que pode ser invocado e a saída processada.
Neste ponto, fizemos o seguinte:
- Dados ingeridos em nossa base de conhecimento, que é mantida em um banco de dados vetorial MongoDB
- Criou um objeto retriever para fazer a interface entre as consultas e o banco de dados de vetores
- Configurou o LLM para o agente
Essa etapa se concentra na especificação das ferramentas que o agente pode usar ao tentar executar operações para atingir o objetivo especificado. A biblioteca LangChain tem vários métodos para especificar e configurar ferramentas para um agente. Neste tutorial, dois métodos são usados:
- Definição de ferramenta personalizada com o decorador
@tool
- Criador de ferramentas incorporadas ao LangChain usando a interface
Tool
A LangChain tem uma collection de ferramentas integradas para fornecer aos seus agentes. Um agente pode aproveitar várias ferramentas especificadas durante sua implementação. Ao implementar ferramentas para agentes usando o LangChain, é essencial configurar o nome e a descrição do modelo. O nome e a descrição da ferramenta permitem que o LLM saiba quando e como aproveitá-la. Outra observação importante é que as ferramentas LangChain geralmente esperam uma entrada de string única.
O trecho de código abaixo importa as classes e os métodos necessários para a configuração da ferramenta de vários módulos da estrutura LangChain.
1 from langchain.agents import tool 2 from langchain.tools.retriever import create_retriever_tool 3 from langchain_community.document_loaders import ArxivLoader
- Importe o construtor
tool
dolangchain.agents
. Eles são usados para definir e instanciar ferramentas personalizadas dentro da estrutura LangChain, que permite a criação de componentes de ferramentas modulares e reutilizáveis. - Por último,
create_retriever_tool
delangchain.tools.retriever
é importado. Este método fornece a capacidade de usar recuperadores configurados como ferramentas para um agente. - Importar
ArxivLoader
delangchain_community.document_loaders
. Essa classe fornece um carregador de documentos projetado especificamente para buscar e carregar documentos do repositório arXiv.
Depois que todas as classes e métodos necessários para criar uma ferramenta forem importados para o ambiente de desenvolvimento, a próxima etapa é criar as ferramentas.
O trecho de código abaixo descreve a criação de uma ferramenta usando o decorador de ferramentas LangChain. O principal objetivo dessa ferramenta é receber uma consulta do usuário, que pode ser um termo de pesquisa ou, para o nosso caso de uso específico, um termo para a base de exploração de pesquisa e, em seguida, usar o
ArxivLoader
para extrair pelo menos 10 documentos que correspondam a artigos do arXiv que correspondam à consulta de pesquisa.O
get_metadata_information_from_arxiv
retorna uma lista contendo os metadados de cada documento retornado pelo Atlas Search. Os metadados incluem informações suficientes para o LLM iniciar a Exploração de Pesquisa ou utilizar ferramentas adicionais para uma Exploração mais detalhada de um documento específico.1 @tool 2 def get_metadata_information_from_arxiv(word: str) -> list: 3 """ 4 Fetches and returns metadata for a maximum of ten documents from arXiv matching the given query word. 5 6 Args: 7 word (str): The search query to find relevant documents on arXiv. 8 9 Returns: 10 list: Metadata about the documents matching the query. 11 """ 12 docs = ArxivLoader(query=word, load_max_docs=10).load() 13 # Extract just the metadata from each document 14 metadata_list = [doc.metadata for doc in docs] 15 return metadata_list
Para obter mais informações sobre um papel específico, a ferramenta
get_information_from_arxiv
criada com o decoradortool
retorna o documento completo de um único papel usando a ID do papel, inserida como entrada na ferramenta como consulta para o carregador de documentosArxivLoader
. O trecho de código abaixo fornece as etapas de implementação para criar a ferramentaget_information_from_arxiv
.1 @tool 2 def get_information_from_arxiv(word: str) -> list: 3 """ 4 Fetches and returns metadata for a single research paper from arXiv matching the given query word, which is the ID of the paper, for example: 704.0001. 5 6 Args: 7 word (str): The search query to find the relevant paper on arXiv using the ID. 8 9 Returns: 10 list: Data about the paper matching the query. 11 """ 12 doc = ArxivLoader(query=word, load_max_docs=1).load() 13 return doc
A ferramenta final para o agente neste tutorial é a ferramenta de recuperação. Essa ferramenta encapsula a capacidade do agente de usar alguma forma de base de conhecimento para responder às queries inicialmente. Isso é análogo aos humanos que usam informações obtidas anteriormente para responder a perguntas antes de realizar alguma pesquisa na Internet ou em fontes de informação alternativas.
O
create_retriever_tool
recebe três argumentos:- retriever: esse argumento deve ser uma instância de uma classe derivada de BaseRetriever, responsável pela lógica por trás da recuperação de documentos. Nesse caso de uso, este é o recuperador configurado anteriormente que usa o recurso de banco de dados vetorial do MongoDB.
- name: Esse é um nome exclusivo e descritivo dado à ferramenta retriever. O LLM usa esse nome para identificar a ferramenta, o que também indica seu uso na busca de uma base de conhecimento.
- description (descrição): O terceiro parâmetro fornece uma descrição detalhada da finalidade da ferramenta. Para este tutorial e nosso caso de uso, a ferramenta atua como fonte de conhecimento fundamental para o agente e contém registros de trabalhos de pesquisa do arXiv.
1 retriever_tool = create_retriever_tool( 2 retriever=retriever, 3 name="knowledge_base", 4 description="This serves as the base knowledge source of the agent and contains some records of research papers from Arxiv. This tool is used as the first step for exploration and research efforts." 5 )
Os agentes LangChain exigem a especificação das ferramentas disponíveis para uso como uma lista Python. O trecho de código abaixo cria uma lista chamada
tools
que consiste nas três ferramentas criadas nas etapas de implementação anteriores.1 tools = [get_metadata_information_from_arxiv, get_information_from_arxiv, retriever_tool]
Esta etapa do tutorial especifica a instrução recebida para instruir o agente usando prompts definidos. O conteúdo passado para o prompt estabelece o fluxo e o objetivo de execução do agente, tornando a solicitação do agente uma etapa crucial para garantir que o comportamento e a saída do agente sejam os esperados.
A construção de prompts para condicionar LLMs e modelos de chat é genuinamente uma forma de arte. Vários métodos imediatos surgiram nos últimos anos, como o ReACT e a estruturação rápida da cadeia de pensamento, para amplificar a capacidade dos LLMs de decompor um problema e agir de acordo. A biblioteca LangChain transforma o que poderia ser um processo de exploração problemático de engenharia imediata em um processo sistemático e programático.
O LangChain oferece o método de classe
ChatPromptTemplate.from_message()
para construir prompts básicos com funções predefinidas como "sistema", "Humano" e "ai". Cada função corresponde a um tipo de orador diferente no chat, permitindo diálogos estruturados. Os espaços reservados nos modelos de mensagem (como {name}
ou {user_input}
) são substituídos por valores reais passados para o métodoinvoke()
, que usa um dicionário de variáveis para ser substituído no modelo.O modelo de prompt inclui uma variável para fazer referência ao histórico de bate-papo ou à conversa anterior que o agente teve com outras entidades, sejam elas humanas ou sistemas. A classe
MessagesPlaceholder
oferece uma maneira flexível de adicionar e gerenciar mensagens de bate-papo históricas ou contextuais em prompts de bate-papo estruturados.Neste tutorial, a função " system " divide o modelo de bate-papo na função especificada de um assistente de pesquisa útil; o modelo de bate-papo, nesse caso, é FireFunction V1 do Fireworks AI. O trecho de código abaixo descreve as etapas para implementar um modelo de prompt estruturado com funções e variáveis definidas para as entradas do usuário e alguma forma de registro do histórico de conversação.
1 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder 2 agent_purpose = "You are a helpful research assistant" 3 prompt = ChatPromptTemplate.from_messages( 4 [ 5 ("system", agent_purpose), 6 ("human", "{input}"), 7 MessagesPlaceholder("agent_scratchpad") 8 ] 9 )
O
{agent_scratchpad}
representa o mecanismo de memória de curto prazo do agente. Esse é um componente essencial do agente especificado no modelo de prompt. O scratchpad do agente é responsável por anexar as etapas intermediárias das operações, pensamentos e ações do agente ao componente de pensamento do prompt. A vantagem desse mecanismo de memória de curto prazo é a manutenção do contexto e da coerência ao longo de uma interação, incluindo a capacidade de revisitar e revisar decisões com base em novas informações.A integração do LangChain e do MongoDB torna a incorporação de memória de longo prazo para os agentes um processo de implementação simples. O trecho de código abaixo demonstra como o MongoDB pode armazenar e recuperar o histórico de chat em um sistema de agente.
O LangChain fornece a interface
ConversationBufferMemory
para armazenar interações entre um LLM e o usuário dentro de um armazenamento de dados especificado, o MongoDB, que é usado para este tutorial. Essa interface também fornece métodos para extrair interações anteriores e formatar a conversa armazenada como uma lista de mensagens. O ConversationBufferMemory
é o componente de memória de longo prazo do agente.A principal vantagem da memória de longo prazo em um sistema agêntico é ter alguma forma de armazenamento persistente que atue como um estado, aumentando a relevância das respostas e da execução da tarefa usando interações anteriores. Embora seja útil usar o scratchpad de um agente, que atua como um mecanismo de memória de curto prazo, esse estado temporário é removido quando a conversa termina ou outra sessão é iniciada com o agente.
Um mecanismo de memória de longo prazo fornece um extenso registro de interação que pode ser recuperado em várias interações que ocorrem em vários momentos. Portanto, sempre que o agente é invocado para executar uma tarefa, ele também recebe uma lembrança de interações anteriores.
1 from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory 2 from langchain.memory import ConversationBufferMemory 3 4 def get_session_history(session_id: str) -> MongoDBChatMessageHistory: 5 return MongoDBChatMessageHistory(MONGO_URI, session_id, database_name=DB_NAME, collection_name="history") 6 7 memory = ConversationBufferMemory( 8 memory_key="chat_history", 9 chat_memory=get_session_history("my-session") 10 )
- A função
get_session_history
recebe umsession_id
como entrada e retorna uma instância deMongoDBChatMessageHistory
. Esta instância é configurada com um URI MongoDB (MONGO_URI), o ID da sessão, o nome do banco de dados (DB_NAME) e o nome da collection (history). - Uma instância
ConversationBufferMemory
é criada e atribuída à memória variável. Esta instância foi especificamente projetada para acompanhar o chat_history. - O parâmetro chat_memory de ConversationBufferMemory é definido usando a função
get_session_history
, o que significa que o histórico de bate-papo é carregado do MongoDB com base no ID de sessão especificado ("my-session" ).
Essa configuração permite a recuperação dinâmica do histórico de chat de uma determinada sessão, usando o MongoDB como o backend do armazenamento de vetores do agente.
Esta é uma etapa crucial da implementação neste tutorial. Essa etapa abrange a criação de seu agente e a configuração de seu cérebro, que é o LLM, as ferramentas disponíveis para execução de tarefas e o prompt de objetivo que direciona os agentes para a conclusão de uma tarefa ou objetivo específico. Esta seção também aborda a inicialização de uma interface de tempo de execução LangChain,
AgentExecutor
, que permite a execução dos agentes com propriedades configuradas, como memória e tratamento de erros.1 from langchain.agents import AgentExecutor, create_tool_calling_agent 2 agent = create_tool_calling_agent(llm, tools, prompt) 3 4 agent_executor = AgentExecutor( 5 agent=agent, 6 tools=tools, 7 verbose=True, 8 handle_parsing_errors=True, 9 memory=memory, 10 )
- A função
create_tool_calling_agent
inicializa um agente especificando um modelo de linguagem (llm), um conjunto de ferramentas (tools) e um modelo de prompt (prompt). Esse agente foi projetado para interagir com base no prompt estruturado e aproveitar ferramentas externas em sua estrutura operacional. - Uma instância
AgentExecutor
é criada com o agente Tool Calling. A classeAgentExecutor
é responsável pelo gerenciamento da execução do agente, facilitando a interação com as entradas e as etapas intermediárias, como tratamento de erros e registro. AAgentExecutor
também é responsável pela criação de um ambiente recursivo para a execução do agente e passa a saída de uma iteração anterior como entrada para a próxima iteração da execução do agente.- agente: O agente de chamada de ferramentas
- ferramentas: uma sequência de ferramentas que o agente pode usar. Essas ferramentas são habilidades ou integrações predefinidas que aumentam os recursos do agente.
- handle_parsing_errors: certifique-se de que o agente trate os erros de análise normalmente. Isso aumenta a robustez do agente, permitindo que ele se recupere ou ignore erros na análise de entradas ou saídas.
- memória: especifica o mecanismo de memória que o agente usa para lembrar interações ou dados passados. Essa integração fornece ao agente contexto adicional ou interação histórica para garantir que as interações contínuas sejam relevantes e baseadas na verdade relativa.
As etapas anteriores criaram o agente, solicitaram e iniciaram uma interface de tempo de execução para sua execução. Esta etapa final da implementação abrange o método para iniciar a execução do agente e seus processos.
Na estrutura LangChain, objetos nativos como modelos, recuperadores e modelos de prompt herdam o protocolo
Runnable
. Este protocolo dota os componentes nativos do LangChain com a capacidade de realizar suas operações internas. Os objetos que implementam o protocolo Runnable são reconhecidos como executáveis e introduzem métodos adicionais para iniciar a execução do processo por meio de um método.invoke()
, modificando seu comportamento, registrando sua configuração interna e muito mais.O executor do agente desenvolvido neste tutorial modela um objeto Runnable. Usamos o método
.invoke()
no objetoAgentExecutor
para chamar o agente. O executor do agente inicializou-o com uma entrada de string no código de exemplo fornecido. Essa entrada é usada como {input}
no componente de pergunta do modelo ou no prompt do agente.1 agent_chain.invoke({"input": "Get me a list of research papers on the topic Prompt Compression"})
Na primeira invocação inicial do agente, os passos ideais seriam os seguintes:
- O agente usa a ferramenta retriever para acessar sua base de conhecimento inerente e verificar se há documentos de pesquisa semanticamente semelhantes à entrada/instrução do usuário usando a pesquisa vetorial habilitada pelo MongoDB Atlas.
- Se o agente recuperar trabalhos de pesquisa de sua base de conhecimento, ele o fornecerá como resposta.
- Se o agente não encontrar artigos de pesquisa em sua base de conhecimento, ele deverá usar a ferramenta
get_metadata_information_from_arxiv()
para recuperar uma lista de documentos que correspondam ao termo na entrada do usuário e retorná-la como resposta.
1 agent_executor.invoke({"input":"Get me the abstract of the first paper on the list"})
A próxima invocação do agente demonstra a capacidade do agente de fazer referência ao histórico de conversas, que é recuperado do MongoDB database da coleção
chat_history
e usado como entrada no modelo.Na segunda invocação do agente, o resultado ideal seria o seguinte:
- O agente faz referência a documentos de pesquisa em sua história ou memória de curto prazo e recupera os detalhes do primeiro documento da lista.
- O agente usa os detalhes do primeiro documento de pesquisa da lista como entrada na ferramenta
get_information_from_arxiv()
para extrair o resumo do documento de query.
Este tutorial orientou você na criação de um agente assistente de pesquisa de AI, aproveitando ferramentas como MongoDB, Fireworks AI e LangChain. É mostrado como essas tecnologias se combinam para criar um agente sofisticado capaz de auxiliar os pesquisadores gerenciando e recuperando informações de um extenso banco de dados de trabalhos de pesquisa.
Ou, se você simplesmente deseja obter uma compreensão completa da AI Stack na era GenAI, leia esta peça.
- O que é um agente? Um agente é uma entidade computacional artificial com consciência de seu ambiente. É equipado com faculdades que permitem a percepção por meio de entrada, ação por meio do uso de ferramentas e habilidades cognitivas por meio de modelos básicos apoiados por memória de longo e curto prazo. Dentro da AI, os agentes são entidades artificiais que podem tomar decisões inteligentes seguidas de ações baseadas na percepção ambiental, habilitadas por grandes modelos de linguagem.
- Qual é a principal função do MongoDB no agente de AI? O MongoDB serve como o provedor de memória para o agente, armazenando o histórico de conversação, dados de incorporação de vetor e dados operacionais. Ele suporta a recuperação de informações por meio de seus recursos de banco de dados vetorial, permitindo pesquisas semânticas entre queries de usuários e dados armazenados.
- Como a AI do Fireworks aprimora a funcionalidade do agente? A AI do Fireworks , por meio de seu modelo FireFunction V1, permite que o agente gere respostas às consultas dos usuários e decida quando usar ferramentas específicas, fornecendo uma entrada estruturada para as ferramentas disponíveis.
- Quais são algumas das principais características dos agentes de AI? Os agentes são autônomos, introspectivos, proativos, reativos e interativos. Eles podem planejar e raciocinar de forma independente, responder a estímulos com metodologias avançadas e interagir dinamicamente em seus ambientes.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.