Da primeira chamada à API até streaming, function calling, RAG e gestão de custos em produção. Um guia técnico completo para 2026, com exemplos em Python e JavaScript.
A primeira decisão impacta custo, qualidade e latência. Para a maioria dos casos: comece com um modelo mid-tier (GPT-4o-mini, Claude Haiku, Gemini Flash) e suba para frontier somente se qualidade for insuficiente.
| Critério | Escolha |
|---|---|
| Qualidade máxima | GPT-4o, Claude Sonnet 4, Gemini 2.5 Pro |
| Custo-benefício | GPT-4o-mini, Claude Haiku, Gemini Flash |
| Velocidade (chatbot real-time) | Groq (Llama), Claude Haiku, Gemini Flash |
| Privacidade / on-premises | Llama 3.1, Mistral, Qwen 2.5 via Ollama |
| Context longo (200K+) | Claude Sonnet, Gemini 2.5 Pro |
| Código e programação | Claude Sonnet, GPT-4o, DeepSeek Coder |
Dica de produção: use LiteLLM como camada de abstração. Você escreve o código uma vez e troca de modelo mudando apenas uma variável de ambiente. Economiza reescrita quando preços ou qualidade mudam.
Toda integração começa com uma chamada simples. O padrão é o mesmo em todos os provedores principais: mensagens com roles (system, user, assistant).
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Explain what RAG is in 2 paragraphs."
}
],
max_tokens=500,
temperature=0.7,
)
print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
});
const response = await client.chat.completions.create({
model: "gpt-4o-mini",
messages: [
{
role: "system",
content: "You are a helpful assistant.",
},
{
role: "user",
content: "Explain what RAG is in 2 paragraphs.",
},
],
max_tokens: 500,
temperature: 0.7,
});
console.log(response.choices[0].message.content);
console.log(`Tokens: ${response.usage.total_tokens}`);Com streaming, tokens aparecem à medida que são gerados — como o ChatGPT faz. A percepção de velocidade melhora drasticamente sem reduzir o tempo total de processamento.
with client.chat.completions.stream(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "Write a poem about AI"}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True) # prints token by token// app/api/chat/route.ts
import { OpenAIStream, StreamingTextResponse } from "ai"; // Vercel AI SDK
import OpenAI from "openai";
export const runtime = "edge";
const openai = new OpenAI();
export async function POST(req: Request) {
const { messages } = await req.json();
const response = await openai.chat.completions.create({
model: "gpt-4o-mini",
stream: true,
messages,
});
const stream = OpenAIStream(response);
return new StreamingTextResponse(stream);
}Function calling permite que o LLM decida quando e como chamar funções que você define. É a base de agentes — o modelo pode buscar dados externos, chamar APIs e executar ações.
import json
tools = [
{
"type": "function",
"function": {
"name": "get_model_price",
"description": "Retrieves the price of an LLM model by name",
"parameters": {
"type": "object",
"properties": {
"model_name": {
"type": "string",
"description": "Model name, e.g. gpt-4o-mini"
}
},
"required": ["model_name"]
}
}
}
]
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "How much does GPT-4o cost?"}],
tools=tools,
tool_choice="auto",
)
if response.choices[0].finish_reason == "tool_calls":
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
# Execute the real function here
result = get_model_price(args["model_name"])
print(f"Model called: {tool_call.function.name}({args})")RAG (Retrieval-Augmented Generation) permite que o LLM responda com base nos seus dados sem fine-tuning. Você recupera trechos relevantes de um banco vetorial e os injeta no contexto da requisição.
import numpy as np
# 1. Generate embedding for the user's question
def get_embedding(text: str) -> list[float]:
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
return response.data[0].embedding
# 2. Retrieve relevant chunks (simplified — use pgvector/Pinecone in prod)
def search_context(question: str, documents: list[dict]) -> str:
q_emb = get_embedding(question)
# Compute cosine similarity with each document
scores = []
for doc in documents:
score = np.dot(q_emb, doc["embedding"]) / (
np.linalg.norm(q_emb) * np.linalg.norm(doc["embedding"])
)
scores.append((score, doc["text"]))
# Return top-3 most relevant
top3 = sorted(scores, reverse=True)[:3]
return "\n---\n".join([t for _, t in top3])
# 3. Inject context into the prompt
question = "How much does GPT-4o cost?"
context = search_context(question, documents)
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": f"""Answer ONLY based on the context below.
If the answer is not in the context, say you don't know.
CONTEXT:
{context}"""
},
{"role": "user", "content": question}
]
)
print(response.choices[0].message.content)Em produção, cache é a ferramenta mais eficaz para cortar custos. Requisições idênticas ou muito similares não precisam chegar ao LLM.
import hashlib
import redis
import json
r = redis.Redis(host="localhost", port=6379, db=0)
def llm_with_cache(messages: list, model: str = "gpt-4o-mini", ttl: int = 3600) -> str:
# Generate deterministic cache key
cache_key = hashlib.sha256(
json.dumps({"model": model, "messages": messages}, sort_keys=True).encode()
).hexdigest()
# Check cache
cached = r.get(cache_key)
if cached:
return json.loads(cached)["content"]
# Call LLM
response = client.chat.completions.create(model=model, messages=messages)
content = response.choices[0].message.content
# Save to cache
r.setex(cache_key, ttl, json.dumps({"content": content}))
return contentmax_tokens ao mínimo necessárioConteúdo relacionado: