Esta é a primeira parte de uma série de várias partes sobre a construção de agentes com a API Assistant da OpenAI usando o Python SDK. O que são agentes? Do jeito que gosto de ver, um agente é, na verdade, apenas um software que aproveita um LLM (Large Language Model) e tenta imitar o comportamento humano. Isso significa que ele pode não apenas conversar e compreender a linguagem, mas também realizar ações que tenham impacto no mundo real. Essas ações normalmente são chamadas de ferramentas. Nesta postagem do blog, exploraremos como construir um agente usando a API Assistant da OpenAI usando seu SDK Python. A Parte 1 será apenas o esqueleto do assistente. Ou seja, apenas a parte conversacional. Optei por construir um aplicativo CLI propositalmente para ser independente de estrutura. Chamaremos propositalmente nossa implementação de Agente e nos referiremos à implementação do OpenAI SDK como Assistente para distinguir facilmente entre os dois. Eu uso os termos e de forma intercambiável quando se trata de funções que o Agente pode chamar. A Parte 2 abordará a chamada de função com mais detalhes. ferramentas funções Pré-requisitos Para acompanhar este tutorial, você precisará do seguinte: Python3 instalado em sua máquina Uma chave de API OpenAI Conhecimento básico de programação Python Conceitos do assistente OpenAI : Um Assistant na API Assistants é uma entidade configurada para responder às mensagens do usuário. Ele usa instruções, um modelo escolhido e ferramentas para interagir com funções e fornecer respostas. Assistant : Um Thread representa uma conversa ou diálogo na API Assistants. Ele é criado para cada interação do usuário e pode conter diversas mensagens, servindo como contêiner para a conversa em andamento. Thread : Uma mensagem é uma unidade de comunicação em um Thread. Ele contém texto (e potencialmente arquivos no futuro) e é usado para transmitir dúvidas do usuário ou respostas do assistente dentro de um Thread. Mensagem : Uma Run é uma instância do Assistant processando um Thread. Envolve ler o Thread, decidir se deve chamar ferramentas e gerar respostas com base na interpretação do modelo das mensagens do Thread. Run Configurando o Ambiente de Desenvolvimento O primeiro passo é criar um ambiente virtual usando e ativá-lo. Isso garantirá que nossas dependências sejam isoladas da instalação do sistema Python: venv python3 -m venv venv source venv/bin/activate Vamos instalar nossa única dependência: o pacote : openai pip install openai Crie um arquivo Vamos preencher alguma lógica básica de tempo de execução para nosso aplicativo CLI: main.py while True: user_input = input("User: ") if user_input.lower() == 'exit': print("Exiting the assistant...") break print(f"Assistant: You said {user_input}") Experimente executando : python3 main.py python3 main.py User: hi Assistant: You said hi Como você pode ver, a CLI aceita uma mensagem do usuário como entrada, e nosso assistente genial ainda não tem cérebro 🧠, então ele apenas repete a mensagem de volta. Ainda não é tão inteligente. O agente Agora começa a diversão 😁 (ou dores de cabeça 🤕). Fornecerei todas as importações necessárias para a aula final agora, para que você não fique pensando de onde as coisas estão vindo, já que mantive as importações fora dos exemplos de código por questões de brevidade. Vamos começar construindo uma classe em um novo arquivo : Agent agent.py import time import openai from openai.types.beta.threads.run import Run class Agent: def __init__(self, name: str, personality: str): self.name = name self.personality = personality self.client = openai.OpenAI(api_key="sk-*****") self.assistant = self.client.beta.assistants.create( name=self.name, model="gpt-4-turbo-preview" ) No construtor da classe, inicializamos o cliente OpenAI como uma propriedade de classe, passando nossa chave de API OpenAI. A seguir, criamos uma propriedade de classe que mapeia para nosso Assistente recém-criado. Armazenamos e como propriedades de classe para uso posterior. assistant name personality O argumento que estamos passando para o método create serve apenas para identificar o Assistant no painel OpenAI, e a IA não está realmente ciente disso neste momento. Na verdade, você tem que passar o nome para as que veremos mais tarde. name instructions Você já pode definir ao criar o Assistente, mas na verdade isso tornará seu Assistente menos flexível para alterações dinâmicas. instructions Você pode atualizar um Assistente chamando , mas há um lugar melhor para passar valores dinâmicos que veremos quando chegarmos às Execuções. client.beta.assistants.update Observe que se você passar aqui e novamente ao criar uma corrida, as do Assistente serão substituídas pelas da corrida. Eles não se complementam, então escolha um com base em suas necessidades: nível Assistant para instruções estáticas ou nível Run para instruções dinâmicas. instructions instructions instructions Para o modelo, escolhi o modelo para que possamos adicionar chamadas de função na parte 2 desta série. Você poderia usar se quiser economizar algumas frações de centavo e ao mesmo tempo ter uma enxaqueca de pura frustração no futuro quando implementarmos ferramentas. gpt-4-turbo-preview gpt-3.5-turbo O GPT 3.5 é péssimo para chamar ferramentas; as horas que perdi tentando lidar com isso me permitem dizer isso. 😝 Vou deixar por isso mesmo e falaremos mais sobre isso mais tarde. Criando um tópico, adicionando mensagens e recuperando a última mensagem Depois de criarmos um agente, precisaremos iniciar uma conversa. class Agent: # ... (rest of code) def create_thread(self): self.thread = self.client.beta.threads.create() E vamos querer uma maneira de adicionar mensagens a esse tópico: class Agent: # ... (rest of code) def add_message(self, message): self.client.beta.threads.messages.create( thread_id=self.thread.id, role="user", content=message ) Observe que no momento só é possível adicionar mensagens com a função . Acredito que a OpenAI planeja mudar isso em uma versão futura, pois isso é bastante limitante. user Agora, podemos obter a última mensagem do tópico: class Agent: # ... (rest of code) def get_last_message(self): return self.client.beta.threads.messages.list( thread_id=self.thread.id ).data[0].content[0].text.value A seguir, criamos um método de ponto de entrada para testar o que temos até agora. Atualmente, o método apenas retorna a última mensagem do thread. Na verdade, ele não executa uma corrida. Ainda não tem cérebro. run_agent run_agent class Agent: # ... (rest of code) def run_agent(self): message = self.get_last_message() return message De volta a , criamos o agente e nosso primeiro thread. Adicionamos uma mensagem ao tópico. Em seguida, retorne a mesma mensagem ao usuário, mas desta vez, vindo daquele tópico ativo. main.py from agent import Agent agent = Agent(name="Bilbo Baggins", personality="You are the accomplished and renowned adventurer from The Hobbit. You act like you are a bit of a homebody, but you are always up for an adventure. You worry a bit too much about breakfast.") agent.create_thread() while True: user_input = input("User: ") if user_input.lower() == 'exit': print("Exiting the agent...") break agent.add_message(user_input) answer = agent.run_agent() print(f"Assistant: {answer}") Vamos executá-lo: python3 main.py User: hi Assistant: hi Ainda não é muito inteligente. Mais perto de um papagaio 🦜 do que de um hobbit. Na próxima seção, a verdadeira diversão começa. Criando e pesquisando uma execução Ao criar uma execução, você precisa recuperar periodicamente o objeto para verificar o status da execução. Isso se chama votação e é uma droga. Você precisa fazer uma pesquisa para determinar o que seu agente deve fazer a seguir. A OpenAI planeja adicionar suporte para streaming para tornar isso mais simples. Enquanto isso, mostrarei como configurar a votação na próxima seção. Run Observe o nos nomes dos métodos a seguir, que é o padrão em Python para indicar que o método se destina ao uso interno e não deve ser acessado diretamente por código externo. _ Primeiro, vamos criar um método auxiliar para criar um e atualizar para chamar este método: _create_run Run run_agent class Agent: # ... (rest of code) def get_breakfast_count_from_db(self): return 1 def _create_run(self): count = self.get_breakfast_count_from_db() return self.client.beta.threads.runs.create( thread_id=self.thread.id, assistant_id=self.assistant.id, instructions=f""" Your name is: {self.name} Your personality is: {self.personality} Metadata related to this conversation: {{ "breakfast_count": {count} }} """, ) def run_agent(self): run = self._create_run() # add this line message = self.get_last_message() return message Observe como passamos e para criar uma execução. thread.id assistant.id Lembra como eu disse no início que havia um lugar melhor para passar instruções e dados dinâmicos? Esse seria o parâmetro ao criar o Run. No nosso caso, poderíamos fazer com que a do café da manhã fosse obtida de um banco de dados. Isso permitirá que você transmita facilmente diferentes dados dinâmicos relevantes sempre que desejar acionar uma resposta. instructions count Agora, seu agente está ciente das mudanças no mundo ao seu redor e pode agir de acordo. Gosto de ter um objeto JSON de metadados em minhas instruções que mantenha o contexto dinâmico relevante. Isso me permite transmitir dados sendo menos detalhado e em um formato que o LLM entende muito bem. Não execute isso ainda; não funcionará porque não estamos aguardando a conclusão da execução quando recebermos a última mensagem, portanto, ainda será a última mensagem do usuário. Vamos resolver isso construindo nosso mecanismo de votação. Primeiro, precisaremos de uma maneira de recuperar uma execução de forma fácil e repetida, então vamos adicionar um método : _retrieve_run class Agent: # ... (rest of code) def _retrieve_run(self, run: Run): return self.client.beta.threads.runs.retrieve( run_id=run.id, thread_id=self.thread.id) Observe como precisamos passar e para encontrar uma execução específica. run.id thread.id Adicione um método à nossa classe Agent: _poll_run class Agent: # ... (rest of code) def _cancel_run(self, run: Run): self.client.beta.threads.runs.cancel( run_id=run.id, thread_id=self.thread.id) def _poll_run(self, run: Run): status = run.status start_time = time.time() while status != "completed": if status == 'failed': raise Exception(f"Run failed with error: {run.last_error}") if status == 'expired': raise Exception("Run expired.") time.sleep(1) run = self._retrieve_run(run) status = run.status elapsed_time = time.time() - start_time if elapsed_time > 120: # 2 minutes self._cancel_run(run) raise Exception("Run took longer than 2 minutes.") 🥵 Ufa, é muita coisa... Vamos desempacotar. recebe um objeto como argumento e extrai o atual da execução. Todos os status disponíveis podem ser encontrados nos OpenAI. Usaremos apenas alguns que atendam ao nosso propósito atual. _poll_run Run status documentos Agora executamos um loop while para verificar o status de concluído enquanto lidamos com alguns cenários de erro. O faturamento real da API Assistant é um pouco obscuro, então, para garantir, optei por cancelar minhas execuções após 2 minutos. Mesmo que haja um status para quando o OpenAI cancela a execução após 10 minutos. Se uma corrida demorar mais de 2 minutos, você provavelmente terá um problema de qualquer maneira. expired Como também não quero fazer pesquisas a cada poucos milissegundos, acelero minha solicitação pesquisando apenas a cada 1 segundo até atingir a marca de 2 minutos e cancelar minha execução. Você pode ajustar isso para o que achar melhor. Cada iteração após o atraso, buscamos novamente o status Run. Agora, vamos inserir tudo isso em nosso método . Você notará que primeiro criamos a execução com depois pesquisamos com até obtermos uma resposta ou um erro for gerado e, finalmente, quando a pesquisa terminar, recuperamos a última mensagem do thread que agora será do agente. run_agent _create_run _poll_run Em seguida, retornamos a mensagem ao nosso loop de tempo de execução, para que ela possa ser enviada de volta ao usuário. class Agent: # ... (rest of code) def run_agent(self): run = self._create_run() self._poll_run(run) # add this line message = self.get_last_message() return message Voilà, agora quando você executar seu agente novamente, receberá uma resposta de nosso amigável Agente: python3 main.py User: hi Assistant: Hello there! What adventure can we embark on today? Or perhaps, before we set out, we should think about breakfast. Have you had yours yet? I've had mine, of course – can't start the day without a proper breakfast, you know. User: how many breakfasts have you had? Assistant: Ah, well, I've had just 1 breakfast today. But the day is still young, and there's always room for a second, isn't there? What about you? How can I assist you on this fine day? Na parte 2, adicionaremos a capacidade de nosso Agente chamar ferramentas. Você pode encontrar o código completo no meu . GitHub Obrigado pela sua leitura. Fico feliz em ouvir quaisquer opiniões e comentários nos comentários. Siga-me no Linkedin para mais conteúdos como este: https://www.linkedin.com/in/jean-marie-dalmasso-1b5473141/

Este áudio é produzido no idioma original da história!

Como construir um agente com um assistente OpenAI em Python - Parte 1: Conversacional

Muito longo; Para ler

Jean-Marie Dalmasso

About Author

Rótulos

Languages

ESTE ARTIGO FOI APRESENTADO EM...