--- title: "Python e LLMs: Como Usar APIs de IA nos Seus Projetos — 2026 | Python Brasil" url: "https://python.dev.br/blog/python-e-llms-apis-inteligencia-artificial/" markdown_url: "https://python.dev.br/blog/python-e-llms-apis-inteligencia-artificial.MD" description: "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." date: "2026-03-25" author: "Equipe python.dev.br" --- # 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. 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. Depois que a integração básica funciona, o próximo passo é operar isso com segurança: logs, custo, avaliação, timeouts e limites de uso. Para essa etapa, veja também o guia de [LLMOps com Python em produção](/blog/llmops-python-producao/). 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](/blog/virtual-environments-python/) e instale as bibliotecas. Com [uv](/blog/uv-gerenciador-pacotes-python/): ```python # 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](/blog/boas-praticas-python-2026/) para mais detalhes sobre segurança. ```python # .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: ```python 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: ```python 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](/blog/python-async-await/): ```python 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: ```python 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](/blog/pydantic-validacao-dados-python/). Isso elimina a necessidade de parsear texto livre: ```python 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](/glossario/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](/blog/tratamento-de-erros-python/) robusto é essencial: ```python 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](/blog/logging-em-python/) 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: ```python 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](/blog/python-e-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): | Modelo | Entrada | Saí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](/blog/pydantic-validacao-dados-python/) 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](/glossario/git/) 4. **Use tipagem** — [type hints](/blog/tipagem-estatica-python-mypy/) facilitam a manutenção de código que interage com [APIs](/blog/python-e-apis-consumindo-dados/) 5. **Trabalhe com JSON** — [manipulação de JSON](/blog/trabalhando-com-json-python/) é 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](/blog/polars-alternativa-pandas-python/) — 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. > **IA e infraestrutura**: muitas bibliotecas de IA modernas como Candle e llama.cpp usam Rust para inferencia de alta performance. Go tambem aparece bastante em ferramentas de orquestracao e serving de modelos, como o Ollama.