Python Brasil —...

Python e LLMs: Como Usar APIs de IA nos Seus Projetos — 2026 | Python Brasil

Aprenda a integrar APIs de LLMs como OpenAI, Anthropic e Gemini em projetos Python. Exemplos práticos com streaming, saída estruturada e boas práticas.

6 min de leitura Equipe python.dev.br
python llm inteligência-artificial api openai anthropic gemini pydantic

Os Large Language Models (LLMs) transformaram o desenvolvimento de software nos últimos anos. Se antes integrar inteligência artificial em um projeto exigia conhecimento profundo de machine learning, hoje qualquer desenvolvedor Python consegue usar modelos como GPT, Claude e Gemini através de APIs simples e bem documentadas.

Neste guia, vamos explorar como integrar as principais APIs de LLMs nos seus projetos Python, com exemplos práticos que você pode usar imediatamente.

Panorama das APIs de LLMs em 2026

As três principais APIs de LLMs disponíveis para desenvolvedores são:

  • OpenAI (GPT-4o, o3) — a mais popular, com ecossistema amplo
  • Anthropic (Claude) — destaque em raciocínio longo e segurança
  • Google (Gemini) — forte em multimodalidade e integração com Google Cloud

Todas seguem um padrão semelhante: você envia mensagens via HTTP e recebe uma resposta gerada pelo modelo. As bibliotecas Python oficiais abstraem os detalhes HTTP, tornando tudo mais simples.

Configuração Inicial

Antes de tudo, crie um ambiente virtual e instale as bibliotecas. Com uv:

# Terminal
uv pip install openai anthropic google-genai

Guarde suas chaves de API em variáveis de ambiente — nunca hardcode credenciais no código. Veja nosso guia de boas práticas Python para mais detalhes sobre segurança.

# .env (nunca commite este arquivo!)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=AIza...

Usando a API da OpenAI

A biblioteca openai é a mais utilizada. Veja um exemplo básico:

from openai import OpenAI

client = OpenAI()  # usa OPENAI_API_KEY do ambiente

resposta = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Você é um assistente técnico especializado em Python."},
        {"role": "user", "content": "Explique list comprehension em Python em 3 frases."},
    ],
    temperature=0.7,
    max_tokens=500,
)

print(resposta.choices[0].message.content)

Os parâmetros mais importantes são:

  • model — qual modelo usar (gpt-4o, gpt-4o-mini, o3)
  • messages — histórico da conversa com roles (system, user, assistant)
  • temperature — de 0 (determinístico) a 2 (criativo), geralmente 0.3 a 0.7
  • max_tokens — limite de tokens na resposta

Usando a API da Anthropic

A API da Anthropic segue um padrão similar, com algumas diferenças na estrutura:

from anthropic import Anthropic

client = Anthropic()  # usa ANTHROPIC_API_KEY do ambiente

resposta = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Você é um assistente técnico especializado em Python.",
    messages=[
        {"role": "user", "content": "Quais as vantagens do FastAPI sobre o Flask?"},
    ],
)

print(resposta.content[0].text)

Note que na Anthropic o system prompt fica separado das messages, o que facilita a organização do código.

Streaming de Respostas

Para interfaces interativas, você não quer esperar a resposta completa — quer exibir token por token. As APIs suportam streaming, que funciona bem com programação assíncrona:

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Escreva um poema curto sobre Python."},
    ],
    stream=True,
)

for chunk in stream:
    conteudo = chunk.choices[0].delta.content
    if conteudo:
        print(conteudo, end="", flush=True)

print()  # Nova linha ao final

Para a versão assíncrona:

import asyncio
from openai import AsyncOpenAI

async def gerar_resposta(pergunta: str) -> str:
    client = AsyncOpenAI()
    partes = []

    stream = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": pergunta}],
        stream=True,
    )

    async for chunk in stream:
        conteudo = chunk.choices[0].delta.content
        if conteudo:
            partes.append(conteudo)
            print(conteudo, end="", flush=True)

    print()
    return "".join(partes)

asyncio.run(gerar_resposta("O que é um decorator em Python?"))

Saída Estruturada com Pydantic

Um dos recursos mais poderosos ao trabalhar com LLMs é forçar a resposta em um formato estruturado usando Pydantic. Isso elimina a necessidade de parsear texto livre:

from pydantic import BaseModel
from openai import OpenAI

class AnaliseCodigoPython(BaseModel):
    linguagem: str
    complexidade: str
    problemas: list[str]
    sugestoes: list[str]
    nota: int

client = OpenAI()

codigo = """
def calc(x,y):
    if x>0:
        return x+y
    else:
        return x-y
"""

resposta = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Analise o código Python fornecido."},
        {"role": "user", "content": codigo},
    ],
    response_format=AnaliseCodigoPython,
)

analise = resposta.choices[0].message.parsed
print(f"Nota: {analise.nota}/10")
print(f"Problemas: {analise.problemas}")
print(f"Sugestões: {analise.sugestoes}")

Com Pydantic e saída estruturada, você garante que a resposta do modelo sempre terá os campos esperados, com os tipos corretos — ideal para integrar LLMs em pipelines de dados.

Tratamento de Erros e Retentativas

APIs de LLMs podem falhar — rate limits, timeouts, erros de servidor. Um tratamento de erros robusto é essencial:

import time
from openai import OpenAI, RateLimitError, APITimeoutError, APIError

client = OpenAI(timeout=30.0, max_retries=3)


def chamar_llm(mensagem: str, tentativas: int = 3) -> str:
    for i in range(tentativas):
        try:
            resposta = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[{"role": "user", "content": mensagem}],
            )
            return resposta.choices[0].message.content

        except RateLimitError:
            espera = 2 ** i  # Backoff exponencial: 1s, 2s, 4s
            print(f"Rate limit atingido. Aguardando {espera}s...")
            time.sleep(espera)

        except APITimeoutError:
            print(f"Timeout na tentativa {i + 1}. Retentando...")

        except APIError as e:
            print(f"Erro da API: {e.status_code} - {e.message}")
            raise

    raise RuntimeError("Falha após todas as tentativas")

Use logging em produção para registrar cada chamada, tempo de resposta e erros — isso facilita a depuração e o monitoramento de custos.

Projeto Prático: Resumidor de Documentos

Vamos combinar tudo em um exemplo prático — um resumidor de textos longos que usa chunking para lidar com limites de contexto:

from openai import OpenAI
from pathlib import Path

client = OpenAI()


def dividir_em_chunks(texto: str, tamanho: int = 3000) -> list[str]:
    palavras = texto.split()
    chunks = []
    for i in range(0, len(palavras), tamanho):
        chunk = " ".join(palavras[i : i + tamanho])
        chunks.append(chunk)
    return chunks


def resumir_texto(texto: str) -> str:
    chunks = dividir_em_chunks(texto)
    resumos = []

    for i, chunk in enumerate(chunks, 1):
        print(f"Processando parte {i}/{len(chunks)}...")
        resposta = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": "Resuma o texto a seguir em português, "
                    "mantendo os pontos principais em 3-5 frases.",
                },
                {"role": "user", "content": chunk},
            ],
            temperature=0.3,
        )
        resumos.append(resposta.choices[0].message.content)

    if len(resumos) == 1:
        return resumos[0]

    # Resumo final combinando os parciais
    texto_combinado = "\n\n".join(resumos)
    resposta_final = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Combine os resumos parciais abaixo em um "
                "resumo final coeso de 5-8 frases em português.",
            },
            {"role": "user", "content": texto_combinado},
        ],
        temperature=0.3,
    )
    return resposta_final.choices[0].message.content


# Uso
documento = Path("relatorio.txt").read_text(encoding="utf-8")
resumo = resumir_texto(documento)
print(f"\nResumo:\n{resumo}")

Considerações de Custo

LLMs cobram por token (entrada + saída). Algumas dicas para controlar custos:

  • Use o modelo certo para a tarefa — gpt-4o-mini ou Claude Haiku para tarefas simples, modelos maiores apenas quando necessário
  • Limite max_tokens — evite respostas mais longas do que o necessário
  • Cache respostas — se a mesma pergunta aparece frequentemente, use Redis ou cache local
  • Monitore gastos — todas as APIs oferecem dashboards de uso

Como referência de preços em 2026 (valores aproximados por milhão de tokens):

ModeloEntradaSaída
GPT-4o-mini$0.15$0.60
GPT-4o$2.50$10.00
Claude Haiku$0.25$1.25
Claude Sonnet$3.00$15.00

Boas Práticas ao Trabalhar com LLMs

Para fechar, algumas práticas essenciais para projetos com LLMs em produção:

  1. Valide sempre a saída — use Pydantic para structured output e valide antes de consumir
  2. Implemente fallback — se uma API falhar, tente outra
  3. Versione seus prompts — trate prompts como código, com versionamento em Git
  4. Use tipagem — type hints facilitam a manutenção de código que interage com APIs
  5. Trabalhe com JSON — manipulação de JSON é essencial ao lidar com respostas de APIs
  6. Teste seus prompts — crie testes automatizados para verificar a qualidade das respostas

Conclusão

Integrar LLMs em projetos Python nunca foi tão acessível. Com as bibliotecas oficiais da OpenAI, Anthropic e Google, você consegue adicionar capacidades de IA em poucas linhas de código. O segredo está em usar as ferramentas certas — saída estruturada com Pydantic, tratamento de erros robusto e monitoramento de custos.

Se você trabalha com dados, vale também conferir o Polars — a nova geração de DataFrames em Python que complementa muito bem pipelines de IA.

O ecossistema Python continua sendo a melhor escolha para projetos de inteligência artificial, e dominar essas APIs é uma habilidade essencial para qualquer desenvolvedor em 2026.

E

Equipe python.dev.br

Contribuidor do Python Brasil — Aprenda Python em Português

Tags

python llm inteligência-artificial api openai anthropic gemini pydantic

Artigos Relacionados

Pydantic em Python: Validação de Dados

7 min de leitura

APIs REST com FastAPI: Tutorial Completo

7 min de leitura

Criando API GraphQL com Python — 2025 | Python Brasil

6 min de leitura