Construindo com a API do OpenAI: GPTs, Assistants e Function Calling 
Se você é desenvolvedor e ainda não integrou a API do OpenAI em algum projeto, provavelmente é apenas uma questão de tempo. O ecossistema do OpenAI em 2026 é maduro, bem documentado e oferece ferramentas específicas para diferentes tipos de aplicações: desde chatbots simples até agentes complexos com acesso a ferramentas externas.
Neste guia prático vamos explorar os três pilares principais do ecossistema developer do OpenAI: a Assistants API, o Function Calling e o GPT Builder. Com exemplos de código reais e estimativas de custos para que você possa planejar.
O ecossistema OpenAI para developers em 2026
Antes de entrar em detalhes, um mapa rápido:
- Chat Completions API — A API base. Você envia mensagens, recebe respostas. Ideal para casos simples.
- Assistants API — Para construir assistentes com memória, arquivos e ferramentas.
- Function Calling / Tool Use — Para dar aos modelos acesso a funções externas.
- GPT Builder — Interface sem código para criar GPTs personalizados (ChatGPT Plus).
- Responses API — Nova API unificada que combina o melhor do Chat Completions e Assistants.
1. A Assistants API: construa agentes com memória
A Assistants API é o componente mais poderoso para developers que querem construir aplicações com estado — ou seja, que lembram conversas anteriores e podem acessar arquivos.
Conceitos-chave
- Assistant — O agente com sua configuração (modelo, instruções, ferramentas)
- Thread — Uma conversa específica (pode durar dias ou semanas)
- Run — A execução de uma resposta dentro de um Thread
- File — Documentos que o assistente pode processar e pesquisar
Exemplo completo: assistente de suporte técnico
from openai import OpenAI
client = OpenAI(api_key="sua-chave-api")
# 1. Criar o assistente (feito uma vez)
assistant = client.beta.assistants.create(
name="Suporte Técnico yoDEV",
instructions="""
Você é um assistente de suporte para desenvolvedores da América Latina.
Responda em português, com exemplos de código quando for útil.
Se não souber a resposta, diga que vai investigar.
""",
model="gpt-4o",
tools=[
{"type": "file_search"}, # pesquisa em documentos
{"type": "code_interpreter"} # executar código
]
)
print(f"ID do Assistente: {assistant.id}")
# Salve este ID — você o reutilizará
# 2. Criar um thread para um usuário
thread = client.beta.threads.create()
# 3. Adicionar a mensagem do usuário
client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Como configuro CORS no Express para produção?"
)
# 4. Executar o assistente
run = client.beta.threads.runs.create_and_poll(
thread_id=thread.id,
assistant_id=assistant.id
)
# 5. Obter a resposta
if run.status == "completed":
messages = client.beta.threads.messages.list(thread_id=thread.id)
print(messages.data[0].content[0].text.value)
Vantagem-chave: os threads persistem
Diferentemente do Chat Completions simples, os threads mantêm o histórico automaticamente. A próxima mensagem que o usuário enviar para o mesmo thread já inclui toda a conversa anterior. O OpenAI gerencia a memória para você.
2. Function Calling: conecte o modelo com o mundo real
Function Calling (ou “Tool Use”) é o que transforma um modelo de linguagem em um agente que pode executar ações reais: consultar um banco de dados, chamar uma API externa, modificar um arquivo, enviar um email.
Como funciona o fluxo
1. Você → Define as funções disponíveis (JSON Schema)
2. Usuário → Faz uma pergunta
3. Modelo → Decide qual função chamar e com quais parâmetros
4. Seu código → Executa a função
5. Você → Devolve o resultado ao modelo
6. Modelo → Gera a resposta final usando o resultado
Exemplo: assistente com acesso a banco de dados
import json
from openai import OpenAI
client = OpenAI()
# Define as ferramentas disponíveis
tools = [
{
"type": "function",
"function": {
"name": "buscar_usuarios",
"description": "Pesquisa usuários no banco de dados por nome ou email",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Termo de pesquisa (nome ou email)"
},
"limite": {
"type": "integer",
"description": "Número máximo de resultados",
"default": 10
}
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "obter_estatisticas",
"description": "Obtém estatísticas do sistema",
"parameters": {
"type": "object",
"properties": {
"periodo": {
"type": "string",
"enum": ["hoje", "semana", "mês"],
"description": "Período das estatísticas"
}
},
"required": ["periodo"]
}
}
}
]
# Suas funções reais
def buscar_usuarios(query: str, limite: int = 10):
# Aqui vai sua lógica real de BD
return [
{"id": 1, "nome": "Maria Garcia", "email": "maria@exemplo.com"},
{"id": 2, "nome": "Carlos López", "email": "carlos@exemplo.com"}
]
def obter_estatisticas(periodo: str):
# Aqui vai sua lógica real
return {"usuarios_ativos": 1250, "registros_hoje": 45, "periodo": periodo}
# O agente em ação
def run_agent(user_message: str):
messages = [{"role": "user", "content": user_message}]
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools
)
# Se o modelo quer usar uma ferramenta
while response.choices[0].finish_reason == "tool_calls":
tool_calls = response.choices[0].message.tool_calls
messages.append(response.choices[0].message)
for call in tool_calls:
args = json.loads(call.function.arguments)
# Executar a função correspondente
if call.function.name == "buscar_usuarios":
result = buscar_usuarios(**args)
elif call.function.name == "obter_estatisticas":
result = obter_estatisticas(**args)
# Adicionar o resultado ao contexto
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result, ensure_ascii=False)
})
# Próxima chamada com os resultados
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools
)
return response.choices[0].message.content
# Uso
resultado = run_agent("Quantos usuários registramos esta semana?")
print(resultado)
# "Esta semana tiveram 45 novos registros. Os usuários ativos totais são 1.250."
3. Structured Outputs: respostas sempre no formato correto
Uma das adições mais úteis: Structured Outputs garantem que o modelo responda sempre com um JSON que segue exatamente seu esquema. Acabaram-se as respostas mal formatadas.
from pydantic import BaseModel
from typing import List
class ExtracaoCV(BaseModel):
nome: str
email: str
experiencia_anos: int
tecnologias: List[str]
nivel: str # junior, semi-senior, senior
# O modelo responde SEMPRE com este formato
resposta = client.beta.chat.completions.parse(
model="gpt-4o",
messages=[
{"role": "system", "content": "Extrai informações de CVs de desenvolvedores"},
{"role": "user", "content": cv_texto}
],
response_format=ExtracaoCV
)
candidato = resposta.choices[0].message.parsed
print(f"Nome: {candidato.nome}")
print(f"Tecnologias: {', '.join(candidato.tecnologias)}")
print(f"Nível: {candidato.nivel}")
4. GPT Builder: o caminho sem código
Se seu objetivo é criar um assistente personalizado sem escrever código, o GPT Builder do ChatGPT permite configurar tudo a partir de uma interface visual:
- Instruções de comportamento
- Arquivos de conhecimento (PDFs, documentos)
- Ações personalizadas (conecte sua API)
- Imagem e nome do GPT
Os GPTs que você cria podem ser privados (apenas você), compartilhados com link ou publicados na GPT Store.
Quando usar GPT Builder vs API: Se você precisa integrar o assistente em sua própria aplicação, a API é o caminho. Se apenas quer um assistente personalizado dentro do ChatGPT para sua equipe, o GPT Builder é muito mais rápido.
Preços em 2026: estimativas reais para LatAm
A forma mais eficiente de controlar custos é entender a relação tokens ↔ preço. Uma referência rápida:
| Modelo | Entrada (1M tokens) | Saída (1M tokens) |
|---|---|---|
| GPT-4o | $2.50 | $10.00 |
| GPT-4o mini | $0.15 | $0.60 |
| GPT-4.1 | $2.00 | $8.00 |
| o3-mini | $1.10 | $4.40 |
Quanto é 1M de tokens na prática?
1 token ≈ 0,75 palavras em inglês, ~0,6 palavras em português
- Uma conversa de chat normal (10 turnos): ~3.000-5.000 tokens
- Análise de um documento de 10 páginas: ~15.000 tokens
- Resposta gerada de extensão média: ~500-1.000 tokens
Estimativas de custo por caso de uso (GPT-4o):
| Caso de uso | Tokens aprox. | Custo aprox. |
|---|---|---|
| Chatbot (1 conversa) | 2.000 tokens | $0.002 |
| Análise de código (função média) | 1.500 tokens | $0.0015 |
| Geração de relatório (1 página) | 3.000 tokens | $0.003 |
| Processamento de 100 emails | 50.000 tokens | $0.05 |
Para a maioria das aplicações médias, o custo da API é muito gerenciável. Se sua app processa 10.000 conversas/mês com GPT-4o mini, você estaria gastando aproximadamente $15-30 USD/mês em API.
Dica LatAm: OpenAI aceita cartões internacionais. Você pode carregar créditos a partir de $5 USD para começar a experimentar. O Batch API oferece 50% de desconto para processamento assíncrono (ideal para tarefas que não são em tempo real).
Exemplo prático: extrator de dados de emails
from openai import OpenAI
from pydantic import BaseModel
from typing import Optional
client = OpenAI()
class EmailData(BaseModel):
remetente: str
assunto: str
acao_requerida: Optional[str]
urgencia: str # "alta", "média", "baixa"
resumo: str
def processar_email(conteudo_email: str) -> EmailData:
resposta = client.beta.chat.completions.parse(
model="gpt-4o-mini", # mais barato para processamento em massa
messages=[
{
"role": "system",
"content": "Extrai informações estruturadas de emails de suporte técnico"
},
{
"role": "user",
"content": f"Email a processar:\n\n{conteudo_email}"
}
],
response_format=EmailData
)
return resposta.choices[0].message.parsed
# Uso
email = """
De: juan@startup.com
Para: suporte@empresa.com
Assunto: URGENTE - Produção caída
Olá, estamos há 2 horas sem conseguir acessar o dashboard de produção.
Os usuários estão reportando erros 500. Precisamos de ajuda já.
"""
dados = processar_email(email)
print(f"Urgência: {dados.urgencia}")
print(f"Ação: {dados.acao_requerida}")
# Urgência: alta
# Ação: Revisar logs do dashboard de produção e resolver erro 500
Dicas para reduzir custos sem sacrificar qualidade
1. Use o modelo correto para cada tarefa
- GPT-4o mini para classificações, extração de dados, resumos simples
- GPT-4o para raciocínio complexo, geração de código, análise profunda
2. Cache de prompts
OpenAI cacheia prompts repetidos (desconto de 50% em tokens de entrada para prompts idênticos no início do contexto).
3. Batch API para tarefas não urgentes
# Em vez de 10.000 chamadas individuais...
# Use o Batch API com 50% de desconto
client.batches.create(
input_file_id="file-xxx",
endpoint="/v1/chat/completions",
completion_window="24h"
)
4. Streaming para melhor UX
Não reduz custos, mas faz as respostas chegarem mais rápido ao usuário:
with client.chat.completions.stream(
model="gpt-4o",
messages=[{"role": "user", "content": "Gera um README para este projeto..."}]
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
Por onde começar?
Se você está entrando no ecossistema OpenAI:
- Crie uma conta em platform.openai.com
- Carregue $5-10 USD de créditos para experimentar
- Comece com o Playground — interface web para testar modelos sem código
- Seu primeiro app: um chatbot simples com Chat Completions
- Quando precisar de memória: migre para Assistants API
- Quando precisar de ações: adicione Function Calling
A curva de aprendizado é suave. Em um fim de semana você pode ter seu primeiro assistente funcional integrado em uma app web.
Que tipo de aplicações estão construindo com a API de OpenAI em seus projetos? Têm casos de uso específicos para o mercado de LatAm que queiram compartilhar? Os comentários são o lugar perfeito para trocar ideias e aprender juntos! 
Explore e compartilhe seus experimentos de código em nosso Code Studio — o sandbox da comunidade yoDEV.