Noções Básicas de Outros SDKs Oficiais

8 exemplos para você começar com os outros SDKs oficiais do Claude - 5 básicos e 3 intermediários.

Pré-requisitos

• Uma chave de API da Anthropic, definida como a variável de ambiente ANTHROPIC_API_KEY.
• O pacote SDK para a linguagem que você está usando, instalado através do gerenciador de pacotes dessa linguagem (go get, Maven/Gradle, NuGet, Composer ou Bundler).
• Nada mais - cada exemplo abaixo é um programa completo e independente.

Exemplos Básicos

1. Primeira Chamada em Go

A chamada mais simples possível da API Messages usando anthropic-sdk-go.

package main
 
import (
    "context"
    "fmt"
    "os"
 
    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
)
 
func main() {
    client := anthropic.NewClient(
        option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")),
    )
 
    message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
        Model:     anthropic.ModelClaudeSonnet5,
        MaxTokens: 1024,
        Messages: []anthropic.MessageParam{
            anthropic.NewUserMessage(anthropic.NewTextBlock("Diga olá em uma frase.")),
        },
    })
    if err != nil {
        panic(err)
    }
 
    fmt.Println(message.Content[0].Text)
}

• anthropic.NewClient não lê nenhuma configuração além da opção de chave de API; não há uma etapa separada de "conexão".
• Erros retornam como um valor error normal do Go, não como uma exceção, portanto, verifique err antes de tocar em message.
• message.Content é uma fatia de blocos de conteúdo; uma resposta de texto simples é Content[0].Text.

Relacionado: Chamando Claude do Go com o SDK Oficial - streaming e tool_use em Go

2. Primeira Chamada em Java

A mesma chamada usando o cliente estilo builder do SDK Java.

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
 
public class FirstCall {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.fromEnv();
 
        MessageCreateParams params = MessageCreateParams.builder()
            .model(Model.CLAUDE_SONNET_5)
            .maxTokens(1024)
            .addUserMessage("Diga olá em uma frase.")
            .build();
 
        Message message = client.messages().create(params);
        System.out.println(message.content().get(0).text().get());
    }
}

• AnthropicOkHttpClient.fromEnv() lê ANTHROPIC_API_KEY do ambiente automaticamente.
• MessageCreateParams.builder() é a maneira idiomática do Java de montar uma requisição com campos opcionais.
• Uma chamada falha lança uma exceção tipada em vez de retornar um valor de erro, então envolva isso em um try/catch em código real.

3. Primeira Chamada em C#

A mesma chamada usando o objeto de requisição tipado do SDK C# e async/await.

using Anthropic.SDK;
using Anthropic.SDK.Messaging;
 
var client = new AnthropicClient(Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY"));
 
var response = await client.Messages.GetClaudeMessageAsync(new MessageParameters
{
    Model = AnthropicModels.ClaudeSonnet5,
    MaxTokens = 1024,
    Messages = new List<Message>
    {
        new Message(RoleType.User, "Diga olá em uma frase.")
    }
});
 
Console.WriteLine(response.Message);

• O cliente é construído diretamente com a chave de API em vez de um objeto de opções.
• GetClaudeMessageAsync segue a convenção assíncrona do .NET, portanto, deve ser aguardado dentro de um contexto async.
• MessageParameters espelha o corpo da requisição da API Messages campo a campo, apenas como um objeto C# tipado.

4. Primeira Chamada em PHP

A mesma chamada usando o estilo de requisição de array associativo do PHP.

<?php
require 'vendor/autoload.php';
 
use Anthropic\Anthropic;
 
$client = Anthropic::factory()
    ->withApiKey(getenv('ANTHROPIC_API_KEY'))
    ->make();
 
$response = $client->messages()->create([
    'model' => 'claude-sonnet-5',
    'max_tokens' => 1024,
    'messages' => [
        ['role' => 'user', 'content' => 'Diga olá em uma frase.'],
    ],
]);
 
echo $response->content[0]->text;

• Anthropic::factory() é um builder fluente; withApiKey() e make() produzem o cliente configurado.
• Parâmetros de requisição são um array associativo simples, correspondendo diretamente à forma JSON da API Messages.
• PHP não tem verificação de tipo em tempo de compilação aqui, então um erro de digitação em um nome de chave (como max_token) falha no momento da requisição, não antes.

5. Primeira Chamada em Ruby

A mesma chamada usando o estilo de requisição de hash do Ruby.

require "anthropic"
 
client = Anthropic::Client.new(api_key: ENV["ANTHROPIC_API_KEY"])
 
response = client.messages.create(
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Diga olá em uma frase." }
  ]
)
 
puts response.content[0].text

• Anthropic::Client.new recebe a chave de API diretamente como um argumento de palavra-chave.
• Hashes Ruby com chaves de símbolo mapeiam de forma limpa para o corpo JSON da API Messages, o mesmo papel do array associativo do PHP.
• Assim como o PHP, não há verificação em tempo de compilação na forma da requisição, então valide as chaves cuidadosamente em bases de código maiores.

Exemplos Intermediários

6. Lendo a Forma da Resposta em Go

Todo SDK retorna os mesmos campos subjacentes; este exemplo lê mais deles.

message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    Model:     anthropic.ModelClaudeSonnet5,
    MaxTokens: 256,
    Messages: []anthropic.MessageParam{
        anthropic.NewUserMessage(anthropic.NewTextBlock("Nomeie três pacotes da biblioteca padrão do Go.")),
    },
})
if err != nil {
    panic(err)
}
 
fmt.Println("Stop reason:", message.StopReason)
fmt.Println("Input tokens:", message.Usage.InputTokens)
fmt.Println("Output tokens:", message.Usage.OutputTokens)
for _, block := range message.Content {
    if block.Type == "text" {
        fmt.Println(block.Text)
    }
}

• StopReason informa por que a geração parou: end_turn, max_tokens, tool_use, e assim por diante - verifique-o antes de assumir que a resposta está completa.
• Usage carrega contagens de tokens para ambos os lados da troca, que todo SDK expõe de alguma forma tipada ou de dicionário.
• Content é sempre uma lista de blocos mesmo para uma única resposta de texto, porque o mesmo campo também carrega blocos tool_use.

Relacionado: Noções Básicas da API Messages - a forma de requisição/resposta que todo SDK encapsula

7. Definindo um Prompt do Sistema em Várias Linguagens

O parâmetro system se comporta identicamente em todos os lugares; apenas a sintaxe para defini-lo muda.

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_SONNET_5)
    .maxTokens(512)
    .system("Você é um revisor de código técnico e conciso. Responda apenas em bullet points.")
    .addUserMessage("Revise esta assinatura de função: func Add(a, b int) int")
    .build();
 
Message message = client.messages().create(params);
System.out.println(message.content().get(0).text().get());

response = client.messages.create(
  model: "claude-sonnet-5",
  max_tokens: 512,
  system: "Você é um revisor de código técnico e conciso. Responda apenas em bullet points.",
  messages: [
    { role: "user", content: "Revise esta assinatura de função: func Add(a, b int) int" }
  ]
)

• O campo system é um parâmetro de requisição de nível superior em todos os SDKs, nunca uma mensagem no array messages.
• Ele direciona o tom e as restrições para toda a conversa, não apenas para a próxima resposta.
• Mantenha-o estável entre turnos em uma conversa com múltiplos turnos; mudar no meio da conversa pode produzir comportamento inconsistente.

8. Lidando com Erros Idiomaticamente por Linguagem

A mesma falha de limite de taxa, tratada da maneira que cada linguagem espera.

message, err := client.Messages.New(ctx, params)
if err != nil {
    var apiErr *anthropic.Error
    if errors.As(err, &apiErr) && apiErr.StatusCode == 429 {
        fmt.Println("Limite de taxa atingido, aguarde e tente novamente.")
        return
    }
    panic(err)
}

try
{
    var response = await client.Messages.GetClaudeMessageAsync(parameters);
}
catch (RateLimitException)
{
    Console.WriteLine("Limite de taxa atingido, aguarde e tente novamente.");
}

• Go expõe erros como valores que você inspeciona com errors.As, correspondendo à convenção de não exceções do Go.
• C# e Java lançam exceções tipadas que você captura por classe, correspondendo às convenções de suas plataformas.
• Independentemente da linguagem em que você esteja, a condição subjacente (um HTTP 429 da API Messages) é a mesma - apenas o mecanismo de captura difere.

Relacionado: Uso Idiomático de Ferramentas em Go, Java, C#, PHP e Ruby - a mesma comparação entre linguagens, aplicada a tool_use

Versões da Pilha: Escrito contra a linha de modelos Claude atual em ~junho de 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (o padrão) e Claude Haiku 4.5 - e os SDKs oficiais atuais para Go, Java, C#, PHP e Ruby. Nomes de modelos, versões de SDK e preços mudam rapidamente - verifique os detalhes atuais em platform.claude.com/docs antes de confiar neles.