Você provavelmente já ouviu falar sobre as últimas inovações da OpenAI, suas novas ferramentas para construir agentes. Essas ferramentas, alimentadas pela API da OpenAI, estão revolucionando a maneira como os desenvolvedores criam sistemas inteligentes e responsivos. Seja você um programador experiente ou alguém que está apenas começando, este post do blog irá guiá-lo por tudo o que você precisa saber para aproveitar as ofertas da OpenAI e construir seus próprios agentes.
Por que as Novas Ferramentas da OpenAI para Construir Agentes São uma Revolução
A OpenAI anunciou a integração de capacidades de busca na web na API da OpenAI. Essa atualização introduz respostas rápidas e atualizadas com links para fontes relevantes na web, tudo alimentado pelo mesmo modelo por trás da busca do ChatGPT. É um salto gigantesco para os desenvolvedores que buscam construir sistemas agentes, como assistentes de IA, capazes de lidar com tarefas complexas, buscar dados em tempo real e interagir de forma fluida com os usuários.
A OpenAI introduziu a API de Respostas, capacidades de busca na web, ferramentas de busca de arquivos, recursos de uso de computador e o SDK de Agentes. Juntos, eles formam uma estrutura robusta para construir agentes que parecem mais inteligentes e autônomos do que nunca. As novas ferramentas foram projetadas para ajudar os desenvolvedores a criar agentes seguros, eficientes e poderosos.
O que São Agentes, Aliás? Uma Breve Revisão
Agentes, no contexto da IA, são sistemas ou programas autônomos que podem perceber seu ambiente, tomar decisões e tomar ações para alcançar objetivos específicos. Pense neles como seus assistentes digitais capazes de responder a perguntas, executar tarefas ou até mesmo aprender com interações.
As novas ferramentas da OpenAI capacitam os desenvolvedores a construir esses agentes usando a API da OpenAI, tornando-os mais inteligentes, rápidos e mais conectados à web.
Começando: Entendendo a API de Respostas da OpenAI
A API de Respostas é uma revolução que combina os melhores recursos das APIs de Chat Completions e Assistants da OpenAI em uma ferramenta mais simples e poderosa. Se você está familiarizado com as APIs anteriores da OpenAI, você apreciará como isso simplifica o processo de construção de agentes.
Para começar, dirija-se à documentação do desenvolvedor da OpenAI. A API de Respostas permite que você integre várias ferramentas e modelos para executar tarefas complexas, tornando-a perfeita para criar agentes de IA que podem lidar com tudo, desde responder perguntas até orquestrar fluxos de trabalho em várias etapas.
Aqui está como você pode começar:
A API da OpenAI fornece uma interface simples para modelos de IA de ponta para geração de texto, processamento de linguagem natural, visão computacional e muito mais. Este exemplo gera uma saída de texto a partir de um prompt, como você poderia fazer usando ChatGPT.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: "Escreva uma história de ninar em uma frase sobre um unicórnio."
});
console.log(response.output_text);Analisar Entradas de Imagem
Você também pode fornecer entradas de imagem para o modelo. Escaneie recibos, analise capturas de tela ou encontre objetos no mundo real com visão computacional.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: [
{ role: "user", content: "Quais duas equipes estão jogando nesta foto?" },
{
role: "user",
content: [
{
type: "input_image",
image_url: "https://upload.wikimedia.org/wikipedia/commons/3/3b/LeBron_James_Layup_%28Cleveland_vs_Brooklyn_2018%29.jpg",
}
],
},
],
});
console.log(response.output_text);Expandir o Modelo com Ferramentas
Dê ao modelo acesso a novos dados e capacidades usando ferramentas. Você pode chamar seu próprio código personalizado ou usar uma das ferramentas potentes incorporadas da OpenAI. Este exemplo usa busca na web para dar ao modelo acesso às informações mais recentes na Internet.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
tools: [ { type: "web_search_preview" } ],
input: "Qual foi uma notícia positiva de hoje?",
});
console.log(response.output_text);Oferecer Experiências de IA Super Rápidas
Usando a nova API em Tempo Real ou eventos de streaming enviados pelo servidor, você pode criar experiências de alto desempenho e baixa latência para seus usuários.
import { OpenAI } from "openai";
const client = new OpenAI();
const stream = await client.responses.create({
model: "gpt-4o",
input: [
{
role: "user",
content: "Diga 'double bubble bath' dez vezes rápido.",
},
],
stream: true,
});
for await (const event of stream) {
console.log(event);
}Construir Agentes
Use a plataforma da OpenAI para construir agentes capazes de agir—como controlar computadores—em nome de seus usuários. Use o Agent SDK para Python para criar lógica de orquestração no backend.
from agents import Agent, Runner
import asyncio
spanish_agent = Agent(
name="Agente Espanhol",
instructions="Você só fala espanhol.",
)
english_agent = Agent(
name="Agente Inglês",
instructions="Você só fala inglês.",
)
triage_agent = Agent(
name="Agente de Triagem",
instructions="Transferir para o agente apropriado com base no idioma da solicitação.",
handoffs=[spanish_agent, english_agent],
)
async def main():
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())
# ¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?As ferramentas incorporadas da API executam essas tarefas com facilidade, economizando tempo e esforço. Além disso, foram projetadas com segurança e confiabilidade em mente, o que é uma grande vitória para os desenvolvedores.
Busca na Web para Agentes Mais Inteligentes
A ferramenta de busca na web da OpenAI, alimentada por modelos como GPT-4o search e GPT-4o mini search, permite que seus agentes busquem informações atualizadas na internet e citem fontes. Isso é especialmente útil para construir agentes que precisam fornecer respostas precisas e em tempo real.
A ferramenta de busca na web está disponível em prévia através da API da OpenAI, e apresenta uma precisão impressionante. No benchmark SimpleQA da OpenAI, a busca GPT-4o pontua 90%, enquanto a busca GPT-4o mini pontua 88%. Isso é uma precisão séria!
Para implementar a busca na web em seu agente, confira o guia da OpenAI. Aqui está um resumo rápido:
- Integrar a Ferramenta: Use a API de Respostas para habilitar as capacidades de busca na web em seu agente.
- Criar Consultas: Projete seu agente para enviar consultas específicas à ferramenta de busca na web, que recupera resultados relevantes.
- Exibir Resultados: Seu agente pode apresentar as descobertas aos usuários, completas com links para fontes para transparência.
Imagine construir um bot de atendimento ao cliente que usa busca na web para responder perguntas sobre disponibilidade de produtos ou tendências de mercado. Com a busca na web da OpenAI, seu agente pode fornecer respostas precisas e pontuais, aumentando a confiança e a satisfação do usuário.
Dominando a Busca de Arquivos para Acesso Eficiente a Dados
Outra ferramenta poderosa no arsenal da OpenAI é a busca de arquivos. Esse recurso permite que seus agentes de IA escaneiem rapidamente arquivos nos bancos de dados de uma empresa para recuperar informações. É ideal para aplicações empresariais onde os agentes precisam acessar documentos internos, relatórios ou conjuntos de dados.
A OpenAI enfatiza que não treinará seus modelos nesses arquivos, garantindo privacidade e segurança, uma consideração crítica para empresas. Você pode aprender mais sobre busca de arquivos na documentação.
Aqui está como incorporar a busca de arquivos em seu agente:
- Carregar Arquivos: Use a API da OpenAI para carregar seus arquivos na plataforma.
- Configurar o Agente: Configure seu agente para usar a ferramenta de busca de arquivos dentro da API de Respostas.
- Consultar os Dados: Seu agente pode buscar informações específicas dentro dos arquivos e retornar resultados relevantes.
Por exemplo, você poderia construir um agente de RH que busca registros de funcionários para fornecer detalhes de folha de pagamento ou saldos de férias. Esse nível de automação pode economizar horas de trabalho manual e melhorar a eficiência em diversos departamentos.
Automatizando Tarefas com Recursos de Uso de Computador
O modelo de Agente Usando Computador (CUA) da OpenAI, que alimenta o produto Operator, permite que agentes gerem ações de mouse e teclado. Isso significa que seus agentes podem automatizar tarefas como entrada de dados, fluxos de trabalho de aplicativos e navegação em sites.
Essa ferramenta está atualmente em prévia de pesquisa, mas já está mostrando potencial para desenvolvedores. Você pode explorar suas capacidades na documentação. A versão consumidora do CUA, disponível no Operator, foca em ações baseadas na web, mas empresas podem executá-la localmente para aplicações mais amplas.
Aqui está como começar:
- Acessar a Prévia: Inscreva-se na prévia de pesquisa para testar o modelo CUA.
- Definir Tarefas: Programe seu agente para executar tarefas específicas no computador, como preencher formulários ou clicar em botões.
- Monitorar o Desempenho: Use as ferramentas da OpenAI para depurar e otimizar as ações do seu agente.
Imagine construir um agente que automatiza tarefas de escritório repetitivas, como atualizar planilhas ou agendar reuniões. Com capacidades de uso de computador, seu agente pode lidar com essas tarefas de forma autônoma, liberando os trabalhadores humanos para atividades mais criativas.
1. Envie uma solicitação ao modelo
Primeiro, você pode querer configurar a chave da OpenAI
import openai
import os
# Defina a chave da API
openai.api_key = os.environ.get("OPENAI_API_KEY")
Envie uma solicitação para criar uma Resposta com o modelo computer-use-preview equipado com a ferramenta computer_use_preview. Esta solicitação deve incluir detalhes sobre seu ambiente, junto com um prompt de entrada inicial.
Opcionalmente, você pode incluir uma captura de tela do estado inicial do ambiente.
Para poder usar a ferramenta computer_use_preview, você precisa definir o parâmetro truncation como "auto" (por padrão, a truncagem está desativada).
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="computer-use-preview",
tools=[{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser" # outros valores possíveis: "mac", "windows", "ubuntu"
}],
input=[
{
"role": "user",
"content": "Verifique as últimas notícias da OpenAI em bing.com."
}
# Opcional: inclua uma captura de tela do estado inicial do ambiente
# {
# type: "input_image",
# image_url: f"data:image/png;base64,{screenshot_base64}"
# }
],
truncation="auto"
)
print(response.output)2. Receba uma sugestão de ação
O modelo retorna uma saída que contém um item computer_call, apenas texto ou outras chamadas de ferramentas, dependendo do estado da conversa.
Exemplos de itens computer_call são um clique, um rolamento, uma pressão de tecla ou qualquer outro evento definido na referência da API. Em nosso exemplo, o item é uma ação de clique:
"output": [
{
"type": "reasoning",
"id": "rs_67cc...",
"content": []
},
{
"type": "computer_call",
"id": "cu_67cc...",
"call_id": "call_zw3...",
"action": {
"type": "click",
"button": "left",
"x": 156,
"y": 50
},
"pending_safety_checks": [],
"status": "completed"
}
]O modelo pode retornar um item reasoning na saída da resposta para algumas ações. Se isso acontecer, você deve sempre incluir os itens de raciocínio ao enviar a próxima solicitação para o modelo CUA.
Os itens de raciocínio são compatíveis apenas com o mesmo modelo que os produziu. Se você implementar um fluxo onde usa vários modelos com o mesmo histórico de conversa, deve filtrar esses itens de raciocínio do array de entradas que você envia para outros modelos.
3. Executar a ação em seu ambiente
Execute as ações correspondentes em seu computador ou navegador. Como você mapeia uma chamada de computador para ações através do código depende do seu ambiente. Este código mostra implementações de exemplo para as ações de computador mais comuns.
def handle_model_action(page, action):
"""
Dada uma ação de computador (por exemplo, clique, duplo clique, rolamento, etc.),
execute a operação correspondente na página do Playwright.
"""
action_type = action.type
try:
match action_type:
case "click":
x, y = action.x, action.y
button = action.button
print(f"Ação: clique em ({x}, {y}) com o botão '{button}'")
# Não lidando com coisas como clique do meio, etc.
if button != "left" and button != "right":
button = "left"
page.mouse.click(x, y, button=button)
case "scroll":
x, y = action.x, action.y
scroll_x, scroll_y = action.scroll_x, action.scroll_y
print(f"Ação: rolamento em ({x}, {y}) com offsets (scroll_x={scroll_x}, scroll_y={scroll_y})")
page.mouse.move(x, y)
page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
case "keypress":
keys = action.keys
for k in keys:
print(f"Ação: pressionar tecla '{k}'")
# Um mapeamento simples para teclas comuns; expanda conforme necessário.
if k.lower() == "enter":
page.keyboard.press("Enter")
elif k.lower() == "space":
page.keyboard.press(" ")
else:
page.keyboard.press(k)
case "type":
text = action.text
print(f"Ação: digitar texto: {text}")
page.keyboard.type(text)
case "wait":
print(f"Ação: esperar")
time.sleep(2)
case "screenshot":
# Nada a fazer, pois a captura de tela é feita em cada etapa
print(f"Ação: captura de tela")
# Lide com outras ações aqui
case _:
print(f"Ação não reconhecida: {action}")
except Exception as e:
print(f"Erro ao lidar com a ação {action}: {e}")4. Capturar a captura de tela atualizada
Após executar a ação, capture o estado atualizado do ambiente como uma captura de tela, que também difere dependendo do seu ambiente.
def get_screenshot(page):
"""
Faça uma captura de tela de página inteira usando o Playwright e retorne os bytes da imagem.
"""
return page.screenshot()5. Repetir
Uma vez que você tenha a captura de tela, pode enviá-la de volta ao modelo como um computer_call_output para obter a próxima ação. Repita essas etapas enquanto você receber um item computer_call na resposta.
import time
import base64
from openai import OpenAI
client = OpenAI()
def computer_use_loop(instance, response):
"""
Execute o loop que executa ações de computador até que não haja 'computer_call' encontrado.
"""
while True:
computer_calls = [item for item in response.output if item.type == "computer_call"]
if not computer_calls:
print("Nenhuma chamada de computador encontrada. Saída do modelo:")
for item in response.output:
print(item)
break # Sair quando não houver chamadas de computador.
# Esperamos no máximo uma chamada de computador por resposta.
computer_call = computer_calls[0]
last_call_id = computer_call.call_id
action = computer_call.action
# Execute a ação (função definida na etapa 3)
handle_model_action(instance, action)
time.sleep(1) # Permita tempo para que as mudanças tenham efeito.
# Faça uma captura de tela após a ação (função definida na etapa 4)
screenshot_bytes = get_screenshot(instance)
screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
# Envie a captura de tela de volta como uma saída de computer_call
response = client.responses.create(
model="computer-use-preview",
previous_response_id=response.id,
tools=[
{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser"
}
],
input=[
{
"call_id": last_call_id,
"type": "computer_call_output",
"output": {
"type": "input_image",
"image_url": f"data:image/png;base64,{screenshot_base64}"
}
}
],
truncation="auto"
)
return responseOrquestrando Agentes com o Agents SDK
O kit de ferramentas de código aberto da OpenAI para construir e gerenciar fluxos de trabalho multi-agente. Este SDK se baseia na estrutura anterior da OpenAI, Swarm, e oferece aos desenvolvedores ferramentas gratuitas para integrar modelos, implementar salvaguardas e monitorar atividades de agentes.
O Agents SDK é prioritariamente para Python e inclui recursos como loops de agentes embutidos e verificações de segurança. É perfeito para criar sistemas complexos onde vários agentes trabalham juntos para resolver problemas.
Aqui está como usar o Agents SDK:
- Baixar o SDK: Acesse o código de código aberto em o repositório GitHub da OpenAI.
- Configurar Fluxos de Trabalho Multi-Agente: Use o SDK para orquestrar tarefas entre agentes, delegando com base em suas capacidades.
- Adicionar Salvaguardas: Implemente verificações de segurança para garantir que seus agentes operem de forma responsável e confiável.
Por exemplo, você poderia construir uma equipe de vendas de agentes de IA onde um agente lida com pesquisa na web, outro gerencia arquivos e um terceiro automatiza tarefas de computador. O Agents SDK os conecta, criando um sistema eficiente e fluido.
Conclusão
Da API de Respostas à busca na web, busca de arquivos, uso de computador e o Agents SDK, a OpenAI equipou os desenvolvedores com tudo o que precisam para criar sistemas autônomos e inteligentes. Seja automatizando tarefas empresariais, melhorando o serviço ao cliente ou explorando novas fronteiras de pesquisa, essas ferramentas abrem um mundo de possibilidades.
Então, o que você está esperando? Mergulhe na API da OpenAI, experimente suas novas ferramentas e comece a construir agentes que impressionem seus usuários. E não se esqueça de baixar o Apidog gratuitamente para agilizar seu desenvolvimento de API e tornar sua jornada ainda mais suave!