Anthropic (adk-anthropic)

Le crate adk-anthropic est un client Anthropic API dédié pour ADK-Rust. Il fournit un accès direct à l’ensemble de la surface d’API Anthropic Messages API, y compris le streaming, la réflexion étendue, la mise en cache des prompts, les citations, la vision, le traitement PDF et le tarification des tokens.

Architecture

adk-anthropic est un crate client autonome qui adk-model encapsule via son adaptateur Anthropic. Vous pouvez l’utiliser directement pour un accès API de bas niveau, ou via adk-model pour le trait Llm unifié.

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

Modèles pris en charge

Configuration

Définissez votre clé API :

export ANTHROPIC_API_KEY=sk-ant-...

Utilisation directe du client

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

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

Via 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-4-6"))?;

Base URL personnalisée (passerelles, proxies, points de terminaison compatibles)

Orientez le client vers un point de terminaison différent pour passer par un proxy d’entreprise ou une passerelle compatible Messages-API. Fournissez la URL racine sans le suffixe /v1/ — il est ajouté automatiquement. AnthropicConfig::with_base_url s’écoule via adk-model jusqu’au client sous-jacent :

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

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

Ou définissez-la directement sur le client de bas niveau, et lisez le point de terminaison effectif avec 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");

Lorsqu’il n’est pas défini, le client utilise le API public d’Anthropic (https://api.anthropic.com).

with_base_url renvoie Result parce que le client attache la clé Anthropic API à chaque requête. Seul https://, ou http:// avec un hôte de loopback (localhost, 127.0.0.1, [::1]) pour le développement local, est accepté — tout autre cas est rejeté comme erreur de validation plutôt que d’envoyer silencieusement la clé en clair. La même règle s’applique à AnthropicConfig::with_base_url, qui est validé lorsque AnthropicClient::new construit le client sous-jacent.

Fonctionnalités clés

Réflexion adaptative (modèles 4.6+)

Opus 4.7 prend uniquement en charge la réflexion adaptative — budget_tokens est rejeté.

use adk_anthropic::{ThinkingConfig, OutputConfig, EffortLevel};

// 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 4.6: any effort level works
let mut params = MessageCreateParams::simple("Solve this...", KnownModel::ClaudeSonnet46)
    .with_thinking(ThinkingConfig::adaptive());
params.output_config = Some(OutputConfig::with_effort(EffortLevel::High));

Mise en cache des prompts

use adk_anthropic::CacheControlEphemeral;

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

Sortie structurée

use adk_anthropic::{OutputConfig, OutputFormat};

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

Tarification des jetons

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

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

Exemples

Exécutez avec cargo run -p adk-anthropic --example <name> :

• basic — chat sans streaming
• streaming — streaming SSE
• thinking — réflexion adaptative + budget
• tools — appel d’outil
• structured_output — schéma JSON
• caching — mise en cache multi-tours avec coûts
• context_editing — suppression des outils/de la réflexion (bêta)
• compaction — compaction côté serveur
• token_counting — estimation des jetons avant envoi
• stop_reasons — gestion de toutes les raisons d’arrêt
• fast_mode — inférence rapide (bêta)
• citations — citations de documents
• pdf_processing — analyse PDF
• vision — compréhension d’images