Anthropic (adk-anthropic)

O pacote adk-anthropic é um cliente dedicado da Anthropic API para ADK-Rust. Ele fornece acesso direto a toda a superfície da API Messages da Anthropic API, incluindo streaming, raciocínio estendido, armazenamento em cache de prompts, citações, visão, processamento de PDF e preços de tokens.

Arquitetura

adk-anthropic é um pacote de cliente independente que adk-model encapsula por meio de seu adaptador Anthropic. Você pode usá-lo diretamente para acesso de baixo nível a API ou por meio de adk-model para a trait Llm unificada.

┌─────────────┐     ┌───────────────┐     ┌──────────────┐
│  Your Code  │────▶│   adk-model   │────▶│adk-anthropic │────▶ Anthropic API
│             │     │ (Llm trait)   │     │ (HTTP client)│
└─────────────┘     └───────────────┘     └──────────────┘

Modelos compatíveis

Configuração

Defina sua chave API:

export ANTHROPIC_API_KEY=sk-ant-...

Uso direto do cliente

use adk_anthropic::{Anthropic, MessageCreateParams, Model};

let client = Anthropic::new(None)?; // reads ANTHROPIC_API_KEY
let params = MessageCreateParams::simple("Hello!", Model::claude_sonnet_5());
let response = client.send(params).await?;

Por meio de adk-model

use adk_model::anthropic::{AnthropicClient, AnthropicConfig};

let api_key = std::env::var("ANTHROPIC_API_KEY")?;
let model = AnthropicClient::new(AnthropicConfig::new(api_key, "claude-sonnet-5"))?;

URL base personalizada (gateways, proxies, endpoints compatíveis)

Aponte o cliente para um endpoint diferente para rotear por meio de um proxy corporativo ou de um gateway compatível com Messages-API. Forneça a URL raiz sem o sufixo /v1/ — ele é anexado automaticamente. AnthropicConfig::with_base_url flui por meio de adk-model até o cliente subjacente:

use adk_model::anthropic::{AnthropicClient, AnthropicConfig};

let model = AnthropicClient::new(
    AnthropicConfig::new(api_key, "claude-sonnet-5")
        .with_base_url("https://gateway.internal/anthropic"),
)?;

Ou defina-o diretamente no cliente de baixo nível e leia o endpoint efetivo com base_url():

use adk_anthropic::Anthropic;

let client = Anthropic::new(Some(api_key))?
    .with_base_url("https://api.minimax.io/anthropic".to_string())?;
assert_eq!(client.base_url(), "https://api.minimax.io/anthropic");

Quando não definido, o cliente usa a API pública da Anthropic (https://api.anthropic.com).

with_base_url retorna Result porque o cliente anexa a chave API da Anthropic a cada solicitação. Somente https:// ou http:// com um host de loopback (localhost, 127.0.0.1, [::1]) para desenvolvimento local é aceito — qualquer outra opção é rejeitada como um erro de validação, em vez de enviar silenciosamente a chave em texto simples. A mesma regra se aplica a AnthropicConfig::with_base_url, que é validado quando AnthropicClient::new cria o cliente subjacente.

Principais recursos

Raciocínio adaptativo

O Opus 4.7 somente oferece suporte a raciocínio adaptativo — budget_tokens é rejeitado.

use adk_anthropic::{
    EffortLevel, KnownModel, MessageCreateParams, Model, OutputConfig, ThinkingConfig,
};

// Opus 4.7: use xhigh effort (recommended for coding/agentic)
let mut params = MessageCreateParams::simple("Solve this...", KnownModel::ClaudeOpus47)
    .with_thinking(ThinkingConfig::adaptive());
params.output_config = Some(OutputConfig::with_effort(EffortLevel::XHigh));

// Sonnet 5: balanced default for agentic workloads
let mut params = MessageCreateParams::simple("Solve this...", Model::claude_sonnet_5())
    .with_thinking(ThinkingConfig::adaptive());
params.output_config = Some(OutputConfig::with_effort(EffortLevel::High));

Armazenamento em cache de prompts

use adk_anthropic::{CacheControlEphemeral, MessageCreateParams, Model};

let mut params = MessageCreateParams::simple("Question", Model::claude_sonnet_5())
    .with_system("Large system prompt...");
params.cache_control = Some(CacheControlEphemeral::new());

Saída estruturada

use adk_anthropic::{MessageCreateParams, Model, OutputConfig, OutputFormat};

let mut params = MessageCreateParams::simple("Extract data", Model::claude_sonnet_5());
params.output_config = Some(OutputConfig::new(OutputFormat::json_schema(schema)));

Preços de tokens

use adk_anthropic::pricing::{ModelPricing, estimate_cost};

let cost = estimate_cost(ModelPricing::SONNET_5, &response.usage);
println!("${:.6}", cost.total());

Exemplos

Execute com cargo run -p adk-anthropic --example <name>:

• basic — chat sem streaming
• streaming — streaming de SSE
• thinking — raciocínio adaptativo + com orçamento
• tools — chamada de ferramentas
• structured_output — esquema de JSON
• caching — cache de múltiplos turnos com custos
• context_editing — limpeza de ferramentas/raciocínio (beta)
• compaction — compactação no lado do servidor
• token_counting — estimativa de tokens antes do envio
• stop_reasons — tratamento de todos os motivos de parada
• fast_mode — inferência rápida (beta)
• citations — citações de documentos
• pdf_processing — análise de PDF
• vision — compreensão de imagens