Fundamentos de otros SDKs oficiales

8 ejemplos para empezar con los otros SDKs oficiales de Claude: 5 básicos y 3 intermedios.

Prerrequisitos

• Una clave API de Anthropic, configurada como la variable de entorno ANTHROPIC_API_KEY.
• El paquete SDK para el lenguaje que estés usando, instalado a través del gestor de paquetes de ese lenguaje (go get, Maven/Gradle, NuGet, Composer o Bundler).
• Nada más: cada ejemplo a continuación es un programa completo e independiente.

Ejemplos básicos

1. Primera llamada en Go

La llamada más simple posible a la API de Mensajes 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("Di hola en una frase.")),
        },
    })
    if err != nil {
        panic(err)
    }
 
    fmt.Println(message.Content[0].Text)
}

• anthropic.NewClient no lee ninguna configuración más allá de la opción de clave API; no hay un paso de "conexión" separado.
• Los errores se devuelven como un valor error normal de Go, no como una excepción, así que comprueba err antes de tocar message.
• message.Content es un slice de bloques de contenido; una respuesta de texto plano es Content[0].Text.

Relacionado: Llamar a Claude desde Go con el SDK oficial - streaming y tool_use en Go

2. Primera llamada en Java

La misma llamada usando el cliente de estilo constructor del SDK de 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("Di hola en una frase.")
            .build();
 
        Message message = client.messages().create(params);
        System.out.println(message.content().get(0).text().get());
    }
}

• AnthropicOkHttpClient.fromEnv() lee ANTHROPIC_API_KEY del entorno automáticamente.
• MessageCreateParams.builder() es la forma idiomática de Java para ensamblar una solicitud con campos opcionales.
• Una llamada fallida lanza una excepción tipada en lugar de devolver un valor de error, así que envuelve esto en un try/catch en código real.

3. Primera llamada en C#

La misma llamada usando el objeto de solicitud tipado del SDK de C# y 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, "Di hola en una frase.")
    }
});
 
Console.WriteLine(response.Message);

• El cliente se construye directamente con la clave API en lugar de un objeto de opciones.
• GetClaudeMessageAsync sigue la convención asíncrona de .NET, por lo que debe ser awaited dentro de un contexto async.
• MessageParameters refleja campo por campo el cuerpo de la solicitud de la API de Mensajes, pero como un objeto C# tipado.

4. Primera llamada en PHP

La misma llamada usando el estilo de solicitud de array asociativo de 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' => 'Di hola en una frase.'],
    ],
]);
 
echo $response->content[0]->text;

• Anthropic::factory() es un constructor fluido; withApiKey() y make() producen el cliente configurado.
• Los parámetros de solicitud son un array asociativo simple, que coincide directamente con la forma JSON de la API de Mensajes.
• PHP no tiene comprobación de tipos en tiempo de compilación aquí, por lo que un error tipográfico en un nombre de clave (como max_token) falla en el momento de la solicitud, no antes.

5. Primera llamada en Ruby

La misma llamada usando el estilo de solicitud de hash de 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: "Di hola en una frase." }
  ]
)
 
puts response.content[0].text

• Anthropic::Client.new toma la clave API directamente como un argumento de palabra clave.
• Los hashes de Ruby con claves simbólicas se mapean limpiamente al cuerpo JSON de la API de Mensajes, el mismo rol que el array asociativo de PHP.
• Al igual que PHP, no hay una comprobación en tiempo de compilación de la forma de la solicitud, por lo que valida las claves cuidadosamente en bases de código más grandes.

Ejemplos intermedios

6. Lectura de la forma de la respuesta en Go

Cada SDK devuelve los mismos campos subyacentes; este ejemplo lee más de ellos.

message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    Model:     anthropic.ModelClaudeSonnet5,
    MaxTokens: 256,
    Messages: []anthropic.MessageParam{
        anthropic.NewUserMessage(anthropic.NewTextBlock("Nombra tres paquetes de la biblioteca estándar de 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 te dice por qué se detuvo la generación: end_turn, max_tokens, tool_use, etc. Compruébalo antes de asumir que la respuesta está completa.
• Usage contiene recuentos de tokens para ambos lados del intercambio, que cada SDK expone de alguna forma tipada o de diccionario.
• Content es siempre una lista de bloques incluso para una única respuesta de texto, porque el mismo campo también contiene bloques tool_use.

Relacionado: Fundamentos de la API de Mensajes - la forma de solicitud/respuesta que envuelve cada SDK

7. Establecimiento de un prompt del sistema en todos los lenguajes

El parámetro system se comporta de manera idéntica en todas partes; solo cambia la sintaxis para establecerlo.

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_SONNET_5)
    .maxTokens(512)
    .system("Eres un revisor de código técnico y conciso. Responde solo con puntos.")
    .addUserMessage("Revisa esta firma de función: 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: "Eres un revisor de código técnico y conciso. Responde solo con puntos.",
  messages: [
    { role: "user", content: "Revisa esta firma de función: func Add(a, b int) int" }
  ]
)

• El campo system es un parámetro de solicitud de nivel superior en cada SDK, nunca un mensaje en el array messages.
• Dirige el tono y las restricciones para toda la conversación, no solo para la siguiente respuesta.
• Mantenlo estable entre turnos en una conversación multivuelta; cambiarlo a mitad de la conversación puede producir un comportamiento inconsistente.

8. Manejo de errores idiomático por lenguaje

El mismo error de límite de tasa, manejado de la manera que cada lenguaje 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("Límite de tasa alcanzado, retrocede y reintenta.")
        return
    }
    panic(err)
}

try
{
    var response = await client.Messages.GetClaudeMessageAsync(parameters);
}
catch (RateLimitException)
{
    Console.WriteLine("Límite de tasa alcanzado, retrocede y reintenta.");
}

• Go expone los errores como valores que inspeccionas con errors.As, coincidiendo con la convención de Go sin excepciones.
• C# y Java lanzan excepciones tipadas que capturas por clase, coincidiendo con las convenciones de sus plataformas.
• Cualquiera que sea el lenguaje en el que te encuentres, la condición subyacente (un HTTP 429 de la API de Mensajes) es la misma; solo el mecanismo de captura difiere.

Relacionado: Uso idiomático de herramientas en Go, Java, C#, PHP y Ruby - la misma comparación entre lenguajes, aplicada a tool_use

Versiones de la pila: Escrito contra la línea de modelos de Claude actual a partir de ~junio de 2026: Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (el predeterminado) y Claude Haiku 4.5, y los SDKs oficiales actuales para Go, Java, C#, PHP y Ruby. Los nombres de los modelos, las versiones de los SDKs y los precios cambian rápidamente; verifica los detalles actuales en platform.claude.com/docs antes de confiar en ellos.