Como Usar a API do Claude (Anthropic) com Python

Como Usar a API do Claude (Anthropic): Guia Completo Para Desenvolvedores

A API da Anthropic dá acesso ao Claude — um dos modelos de linguagem mais capazes do mercado — diretamente no seu código. Neste guia você vai aprender desde a configuração inicial até padrões avançados de uso, com exemplos práticos em Python.

---

Por Que Usar a API do Claude?

O Claude se destaca em algumas áreas específicas que fazem a API ser especialmente valiosa:

• Janela de contexto massiva: 200.000 tokens — ideal para processar documentos longos, codebases inteiros, ou múltiplos arquivos
• Seguir instruções complexas: System prompts com muitas regras são seguidos com alta fidelidade
• Computer Use: O Claude 3.5 Sonnet pode interagir com interfaces gráficas reais
• Código de alta qualidade: Frequentemente supera outros modelos em geração e revisão de código
• Menos alucinações: Treinado para dizer "não sei" em vez de inventar

---

Configuração Inicial

1. Obter Chave de API

Acesse console.anthropic.com, crie uma conta e gere uma API key. Guarde com segurança — não commitamos em código.

2. Instalar o SDK Python

pip install anthropic python-dotenv

3. Configurar Variáveis de Ambiente

# .env
ANTHROPIC_API_KEY=sk-ant-api03-...

---

Primeira Chamada à API

import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic()  # lê ANTHROPIC_API_KEY automaticamente

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explique o que é uma API REST em 3 linhas."}
    ]
)

print(message.content[0].text)

Output esperado:

Uma API REST é um conjunto de regras para comunicação entre sistemas via HTTP.
Ela usa métodos padrão (GET, POST, PUT, DELETE) para realizar operações em recursos
identificados por URLs, retornando dados geralmente em formato JSON.

---

Modelos Disponíveis e Quando Usar Cada Um

Regra prática: Use Haiku para classificação, extração simples, e tarefas em volume. Use Sonnet para a maioria das tarefas. Use Opus apenas quando Sonnet falha.

---

System Prompts: Configurando o Comportamento do Claude

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=2048,
    system="""Você é um assistente especializado em análise jurídica brasileira.
    
    Regras:
    - Sempre cite o artigo de lei quando relevar
    - Responda em linguagem acessível ao leigo
    - Se não tiver certeza, diga explicitamente
    - Nunca dê conselho jurídico definitivo — apenas informativo
    - Foque no direito brasileiro (CLT, CC, CF/88)""",
    messages=[
        {"role": "user", "content": "Tenho 12 dias de férias não tiradas. Posso receber em dinheiro?"}
    ]
)

print(message.content[0].text)

---

Conversas Multi-Turn (Histórico de Mensagens)

def chat_com_historico():
    client = anthropic.Anthropic()
    historico = []
    
    while True:
        usuario = input("Você: ")
        if usuario.lower() in ["sair", "exit"]:
            break
        
        historico.append({"role": "user", "content": usuario})
        
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            system="Você é um assistente prestativo. Lembre-se do contexto da conversa.",
            messages=historico
        )
        
        assistant_text = response.content[0].text
        historico.append({"role": "assistant", "content": assistant_text})
        
        print(f"Claude: {assistant_text}\n")

chat_com_historico()

---

Streaming de Respostas

Para interfaces que exibem texto progressivamente (como o ChatGPT faz):

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Escreva um poema sobre programação"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()  # nova linha ao final

---

Processamento de Imagens

O Claude 3.5 Sonnet aceita imagens como input:

import anthropic
import base64

def analisar_imagem(caminho_imagem: str, pergunta: str) -> str:
    with open(caminho_imagem, "rb") as f:
        imagem_base64 = base64.standard_b64encode(f.read()).decode("utf-8")
    
    # Detectar tipo de imagem
    extensao = caminho_imagem.split(".")[-1].lower()
    media_types = {"jpg": "image/jpeg", "jpeg": "image/jpeg", 
                   "png": "image/png", "gif": "image/gif", "webp": "image/webp"}
    media_type = media_types.get(extensao, "image/jpeg")
    
    client = anthropic.Anthropic()
    
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": media_type,
                            "data": imagem_base64,
                        },
                    },
                    {"type": "text", "text": pergunta}
                ],
            }
        ],
    )
    
    return message.content[0].text

# Uso:
descricao = analisar_imagem("screenshot.png", "Descreva o que está nesta imagem")
print(descricao)

---

Tool Use (Chamadas de Função)

O Claude pode chamar funções externas, similar ao function calling da OpenAI:

import anthropic
import json

# Definir as ferramentas disponíveis
tools = [
    {
        "name": "buscar_clima",
        "description": "Busca informações do clima atual para uma cidade",
        "input_schema": {
            "type": "object",
            "properties": {
                "cidade": {
                    "type": "string",
                    "description": "Nome da cidade para buscar o clima"
                },
                "unidade": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidade de temperatura"
                }
            },
            "required": ["cidade"]
        }
    }
]

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Qual o clima em São Paulo agora?"}]
)

# Verificar se o Claude quer usar uma ferramenta
if response.stop_reason == "tool_use":
    for block in response.content:
        if block.type == "tool_use":
            print(f"Claude quer chamar: {block.name}")
            print(f"Com parâmetros: {block.input}")
            # Aqui você chamaria a API real de clima
            # e retornaria o resultado para o Claude

---

Tratamento de Erros

import anthropic
from anthropic import APIConnectionError, RateLimitError, APIStatusError

def chamada_segura(mensagem: str) -> str:
    client = anthropic.Anthropic()
    
    try:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            messages=[{"role": "user", "content": mensagem}]
        )
        return response.content[0].text
        
    except RateLimitError:
        print("Limite de taxa atingido. Aguarde e tente novamente.")
        raise
    except APIConnectionError:
        print("Erro de conexão. Verifique sua internet.")
        raise
    except APIStatusError as e:
        print(f"Erro da API: {e.status_code} - {e.message}")
        raise

texto = chamada_segura("Olá, como você está?")
print(texto)

---

Calculando Custos

def calcular_custo(response: anthropic.types.Message) -> float:
    """Calcula custo em USD para Claude 3.5 Sonnet"""
    preco_input = 3.00 / 1_000_000   # $3 por 1M tokens
    preco_output = 15.00 / 1_000_000  # $15 por 1M tokens
    
    custo = (response.usage.input_tokens * preco_input + 
             response.usage.output_tokens * preco_output)
    
    print(f"Tokens: {response.usage.input_tokens} in, {response.usage.output_tokens} out")
    print(f"Custo estimado: ${custo:.6f} USD")
    
    return custo

---

Perguntas Frequentes

Como obter chave da API Anthropic?

Acesse console.anthropic.com, crie conta, vá em "API Keys" e gere uma nova chave. O crédito inicial gratuito é $5.

Qual a diferença entre a API e o Claude.ai?

Claude.ai é a interface web para usuários finais. A API é para desenvolvedores integrarem Claude em seus aplicativos, com mais controle e custo por token.

Há um plano gratuito para a API?

Não há plano gratuito, mas novos usuários recebem $5 de crédito. O custo é baixo — $5 permitem processar ~1.6M tokens de entrada com o Sonnet.

Como processar múltiplos documentos em paralelo?

Use asyncio e aiohttp com o cliente assíncrono da Anthropic para processar em paralelo:

import asyncio
import anthropic

async def processar(client, texto):
    return await client.messages.create(...)

async def main():
    client = anthropic.AsyncAnthropic()
    tarefas = [processar(client, t) for t in textos]
    resultados = await asyncio.gather(*tarefas)