Go SDK

Installiere und konfiguriere das Anthropic Go SDK mit kontextbasiertem Abbruch und funktionalen Optionen

Die Anthropic Go-Bibliothek bietet bequemen Zugriff auf die Claude API aus Anwendungen, die in Go geschrieben sind.

Installation

import (
	"github.com/anthropics/anthropic-sdk-go" // imported as anthropic
)

Installiere mit go get:

go get github.com/anthropics/anthropic-sdk-go

Anforderungen

Diese Bibliothek erfordert Go 1.24+.

Verwendung

package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	client := anthropic.NewClient(
		option.WithAPIKey("my-anthropic-api-key"), // defaults to os.LookupEnv("ANTHROPIC_API_KEY")
	)
	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
		},
		Model: anthropic.ModelClaudeOpus5_5,
	})
	if err != nil {
		panic(err.Error())
	}
	for _, block := range message.Content {
		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
			fmt.Println(textBlock.Text)
		}
	}
}

Informationen zu Authentifizierungsoptionen, einschließlich Workload Identity Federation, findest du unter Authentifizierung. Wenn dein API-Key ein persönlicher Key oder Service-Account-Key ist, der nicht auf einen Workspace beschränkt ist, setze die Workspace-ID im Request-Header anthropic-workspace-id; Einen Workspace auswählen zeigt die Option pro Anfrage für dieses SDK.

messages := []anthropic.MessageParam{
	anthropic.NewUserMessage(anthropic.NewTextBlock("What is my first name?")),
}

message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	Messages:  messages,
	MaxTokens: 1024,
})
if err != nil {
	panic(err)
}

fmt.Printf("%+v\n", message.Content)

messages = append(messages, message.ToParam())
messages = append(messages, anthropic.NewUserMessage(
	anthropic.NewTextBlock("My full name is John Doe"),
))

message, err = client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	Messages:  messages,
	MaxTokens: 1024,
})
if err != nil {
	panic(err)
}

fmt.Printf("%+v\n", message.Content)

message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	System: []anthropic.TextBlockParam{
		{Text: "Be very serious at all times."},
	},
	Messages: messages,
})
if err != nil {
	panic(err)
}
fmt.Printf("%+v\n", message.Content)

content := "What is a quaternion?"

stream := client.Messages.NewStreaming(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(content)),
	},
})

message := anthropic.Message{}
for stream.Next() {
	event := stream.Current()
	err := message.Accumulate(event)
	if err != nil {
		panic(err)
	}

	switch eventVariant := event.AsAny().(type) {
	case anthropic.ContentBlockDeltaEvent:
		switch deltaVariant := eventVariant.Delta.AsAny().(type) {
		case anthropic.TextDelta:
			print(deltaVariant.Text)
		}

	}
}

if stream.Err() != nil {
	panic(stream.Err())
}

messages := []anthropic.MessageParam{
	anthropic.NewUserMessage(anthropic.NewTextBlock(content)),
}

toolParams := []anthropic.ToolParam{
	{
		Name:        "get_coordinates",
		Description: anthropic.String("Accepts a place as an address, then returns the latitude and longitude coordinates."),
		InputSchema: GetCoordinatesInputSchema,
	},
}
tools := make([]anthropic.ToolUnionParam, len(toolParams))
for i, toolParam := range toolParams {
	tools[i] = anthropic.ToolUnionParam{OfTool: &toolParam}
}

for {
	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     anthropic.ModelClaudeOpus5_5,
		MaxTokens: 1024,
		Messages:  messages,
		Tools:     tools,
	})

	if err != nil {
		panic(err)
	}

	print(color("[assistant]: "))
	for _, block := range message.Content {
		switch block := block.AsAny().(type) {
		case anthropic.TextBlock:
			println(block.Text)
			println()
		case anthropic.ToolUseBlock:
			inputJSON, _ := json.Marshal(block.Input)
			println(block.Name + ": " + string(inputJSON))
			println()
		}
	}

	messages = append(messages, message.ToParam())
	toolResults := []anthropic.ContentBlockParamUnion{}

	for _, block := range message.Content {
		switch variant := block.AsAny().(type) {
		case anthropic.ToolUseBlock:
			print(color("[user (" + block.Name + ")]: "))

			var response interface{}
			switch block.Name {
			case "get_coordinates":
				var input struct {
					Location string `json:"location"`
				}

				err := json.Unmarshal([]byte(variant.JSON.Input.Raw()), &input)
				if err != nil {
					panic(err)
				}

				response = GetCoordinates(input.Location)
			}

			b, err := json.Marshal(response)
			if err != nil {
				panic(err)
			}

			println(string(b))

			toolResults = append(toolResults, anthropic.NewToolResultBlock(block.ID, string(b), false))
		}

	}
	if len(toolResults) == 0 {
		break
	}
	messages = append(messages, anthropic.NewUserMessage(toolResults...))
}

Request-Felder

Die Anthropic-Bibliothek verwendet für Request-Felder die omitzero-Semantik aus dem encoding/json-Release von Go 1.24+.

Erforderliche primitive Felder (wie int64 oder string) tragen das Tag `json:"...,required"`. Diese Felder werden immer serialisiert, auch ihre Nullwerte.

Optionale primitive Typen sind in ein param.Opt[T] eingebettet. Diese Felder können mit den bereitgestellten Konstruktoren gesetzt werden, wie anthropic.String(string) oder anthropic.Int(int64).

Jedes param.Opt[T], jede Map, jeder Slice, jedes Struct oder jedes String-Enum verwendet das Tag `json:"...,omitzero"`. Sein Nullwert gilt als ausgelassen.

Die Funktion param.IsOmitted(any) kann das Vorhandensein eines beliebigen omitzero-Felds bestätigen.

p := anthropic.ExampleParams{
	ID:   "id_xxx",                // required property
	Name: anthropic.String("..."), // optional property

	Point: anthropic.Point{
		X: 0,                // required field will serialize as 0
		Y: anthropic.Int(1), // optional field will serialize as 1
		// ... weggelassene optionale Felder werden nicht serialisiert
	},

	Origin: anthropic.Origin{}, // the zero value of [Origin] is considered omitted
}

Um null anstelle eines param.Opt[T] zu senden, verwende param.Null[T](). Um null anstelle eines Structs T zu senden, verwende param.NullStruct[T]().

p.Name = param.Null[string]()       // 'null' instead of string
p.Point = param.NullStruct[Point]() // 'null' instead of struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

Request-Structs enthalten eine Methode .SetExtraFields(map[string]any), mit der nicht konforme Felder im Request-Body gesendet werden können. Zusätzliche Felder überschreiben alle Struct-Felder mit einem übereinstimmenden Schlüssel.

Um einen benutzerdefinierten Wert anstelle eines Structs zu senden, verwende die generische Funktion param.Override (zum Beispiel param.Override[anthropic.FooParams](12)).

// In Fällen, in denen die API einen bestimmten Typ vorgibt,
// du aber etwas anderes senden willst, verwende [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Sende eine Zahl statt eines Objekts
custom := param.Override[anthropic.FooParams](12)

Request-Unions

Unions werden als Struct dargestellt, dessen Felder für jede ihrer Varianten mit „Of" beginnen. Nur ein Feld darf ungleich null sein. Das Feld ungleich null wird serialisiert.

Auf Untereigenschaften der Union kann über Methoden des Union-Structs zugegriffen werden. Diese Methoden geben einen Zeiger auf den Wert zurück, sofern vorhanden.

// Nur ein Feld darf ungleich null sein; prüfe mit param.IsOmitted(), ob ein Feld gesetzt ist
type AnimalUnionParam struct {
	OfCat *Cat `json:",omitzero,inline"`
	OfDog *Dog `json:",omitzero,inline"`
}

animal := AnimalUnionParam{
	OfCat: &Cat{
		Name: "Whiskers",
		Owner: PersonParam{
			Address: AddressParam{Street: "3333 Coyote Hill Rd", ZipCode: 0},
		},
	},
}

// Ein Feld ändern
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}

Deserialisieren von Params

Param-Typen (Typen, die auf Param enden, wie MessageNewParams oder ToolUnionParam) sind nur für ausgehende Requests vorgesehen. Sie werden korrekt zu JSON serialisiert, unterstützen aber keine vollständige Round-Trip-Deserialisierung. Wenn du rohes JSON in ein Param-Struct deserialisierst, sind typisierte Union-Felder wie OfBashTool20250124 nil, selbst wenn das zugrunde liegende JSON gültig ist.

Wenn du Params aus rohem JSON rekonstruieren musst (zum Beispiel aus einer Datenbank, einer Middleware oder einem vorherigen Request), rufe UnmarshalJSON auf, um Nicht-Union-Felder zu befüllen, und verwende dann param.SetJSON, um die rohen Bytes für eine korrekte erneute Serialisierung anzuhängen:

// Serialisiere params (zum Beispiel zum Speichern oder Weiterleiten)
b, err := json.Marshal(original)
if err != nil {
	panic(err)
}

// Rekonstruiere params später aus dem gespeicherten JSON
var params anthropic.MessageNewParams
if err := params.UnmarshalJSON(b); err != nil {
	panic(err)
}
param.SetJSON(b, &params)

// params.Model und andere skalare Felder werden von UnmarshalJSON befüllt.
// params.Tools[0].OfBashTool20250124 ist nil (die Union-Einschränkung),
// aber das rohe JSON bleibt erhalten. Wenn params erneut gemarshalt wird
// für den API-Aufruf, werden die Tools korrekt serialisiert.
b2, _ := json.Marshal(params)
fmt.Println(string(b) == string(b2)) // true

Für diesen Anwendungsfall wird param.SetJSON (verfügbar seit v1.20.0) gegenüber dem allgemeineren param.Override[T](any) bevorzugt, da es nicht erfordert, den Typparameter auszuschreiben, und die Round-Trip-Absicht explizit macht.

Response-Objekte

Alle Felder in Response-Structs sind gewöhnliche Werttypen (keine Zeiger oder Wrapper). Response-Structs enthalten außerdem ein spezielles JSON-Feld mit Metadaten zu jeder Eigenschaft.

type Animal struct {
	Name   string `json:"name,nullable"`
	Owners int    `json:"owners"`
	Age    int    `json:"age"`
	JSON   struct {
		Name        respjson.Field
		Owners      respjson.Field
		Age         respjson.Field
		ExtraFields map[string]respjson.Field
	} `json:"-"`
}

Um optionale Daten zu verarbeiten, verwende die Methode .Valid() auf dem JSON-Feld. .Valid() gibt true zurück, wenn das Feld vorhanden, nicht null und erfolgreich deserialisiert wurde.

Wenn .Valid() false ist, hat das entsprechende Feld seinen Nullwert.

raw := `{"owners": 1, "name": null}`

var res Animal
json.Unmarshal([]byte(raw), &res)

// Zugriff auf reguläre Felder

res.Owners // 1
res.Name   // ""
res.Age    // 0

// Prüfungen optionaler Felder

res.JSON.Owners.Valid() // true
res.JSON.Name.Valid()   // false
res.JSON.Age.Valid()    // false

// Rohe JSON-Werte

res.JSON.Owners.Raw()                  // "1"
res.JSON.Name.Raw() == "null"          // true
res.JSON.Name.Raw() == respjson.Null   // true
res.JSON.Age.Raw() == ""               // true
res.JSON.Age.Raw() == respjson.Omitted // true

Diese .JSON-Structs enthalten außerdem eine ExtraFields-Map mit allen Eigenschaften in der JSON-Response, die nicht im Struct angegeben wurden. Das kann für API-Funktionen nützlich sein, die noch nicht im SDK vorhanden sind.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()

Response-Unions

In Responses werden Unions durch ein abgeflachtes Struct dargestellt, das alle möglichen Felder aus jeder der Objektvarianten enthält. Um es in eine Variante umzuwandeln, verwende die Methode .AsFooVariant() oder die Methode .AsAny(), sofern vorhanden.

Wenn eine Response-Wert-Union primitive Werte enthält, stehen primitive Felder neben den Eigenschaften, sind aber mit Of präfixiert und tragen das Tag json:"...,inline".

type AnimalUnion struct {
	// Aus den Varianten [Dog], [Cat]
	Owner Person `json:"owner"`
	// Aus der Variante [Dog]
	DogBreed string `json:"dog_breed"`
	// Aus der Variante [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

	JSON struct {
		Owner respjson.Field
		// ...
	} `json:"-"`
}

// Falls Tier-Variante
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Nach der Variante verzweigen
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}

Fehlerbehandlung

Wenn die API einen Statuscode zurückgibt, der keinen Erfolg anzeigt, gibt das SDK einen Fehler vom Typ *anthropic.Error zurück. Dieser enthält die Werte StatusCode, *http.Request und *http.Response des Requests sowie das JSON des Fehler-Bodys (ähnlich wie andere Response-Objekte im SDK). Der Fehler enthält außerdem die RequestID aus den Response-Headern, die bei der Fehlerbehebung mit dem Anthropic-Support nützlich ist.

Um Fehler zu behandeln, verwende das errors.As-Muster:

_, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{{
		Content: []anthropic.ContentBlockParamUnion{{
			OfText: &anthropic.TextBlockParam{
				Text: "What is a quaternion?",
			},
		}},
		Role: anthropic.MessageParamRoleUser,
	}},
	Model: anthropic.ModelClaudeOpus5_5,
})
if err != nil {
	var apierr *anthropic.Error
	if errors.As(err, &apierr) {
		println("Request ID:", apierr.RequestID)
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // POST "/v1/messages": 400 Bad Request (Request-ID: req_xxx) { ... }
}

Wenn andere Fehler auftreten, werden sie ungewrappt zurückgegeben; wenn zum Beispiel der HTTP-Transport fehlschlägt, erhältst du möglicherweise einen *url.Error, der einen *net.OpError umschließt.

Wiederholungsversuche

Bestimmte Fehler werden standardmäßig automatisch 2-mal mit einem kurzen exponentiellen Backoff wiederholt. Das SDK wiederholt standardmäßig alle Verbindungsfehler, 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal Errors.

Du kannst die Option WithMaxRetries verwenden, um dies zu konfigurieren oder zu deaktivieren:

// Konfiguriere den Standardwert für alle Anfragen:
client := anthropic.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Pro Anfrage überschreiben:
// ...
	client.Messages.New(
		context.TODO(),
		anthropic.MessageNewParams{
			MaxTokens: 1024,
			Messages: []anthropic.MessageParam{{
				Content: []anthropic.ContentBlockParamUnion{{
					OfText: &anthropic.TextBlockParam{
						Text: "What is a quaternion?",
					},
				}},
				Role: anthropic.MessageParamRoleUser,
			}},
			Model: anthropic.ModelClaudeOpus5_5,
		},
		option.WithMaxRetries(5),
	)

Timeouts

Nicht-Streaming-Messages-Requests laufen standardmäßig nach 10 Minuten ab; andere Requests haben kein Standard-Timeout. Verwende den Kontext, um ein Timeout für den Lebenszyklus eines Requests zu konfigurieren.

Beachte, dass das Kontext-Timeout nicht neu startet, wenn ein Request wiederholt wird. Um ein Timeout pro Wiederholungsversuch festzulegen, verwende option.WithRequestTimeout().

// Legt das Timeout für die Anfrage fest, einschließlich aller Wiederholungsversuche.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// ...
	client.Messages.New(
		ctx,
		anthropic.MessageNewParams{
			MaxTokens: 1024,
			Messages: []anthropic.MessageParam{{
				Content: []anthropic.ContentBlockParamUnion{{
					OfText: &anthropic.TextBlockParam{
						Text: "What is a quaternion?",
					},
				}},
				Role: anthropic.MessageParamRoleUser,
			}},
			Model: anthropic.ModelClaudeOpus5_5,
		},
		// Legt das Timeout pro Wiederholungsversuch fest
		option.WithRequestTimeout(20*time.Second),
	)

Lange Requests

Vermeide es, einen großen MaxTokens-Wert ohne Streaming festzulegen, da einige Netzwerke inaktive Verbindungen nach einer bestimmten Zeit trennen können, was dazu führen kann, dass der Request fehlschlägt oder ein Timeout auftritt, ohne dass eine Response von Anthropic empfangen wird.

Dieses SDK gibt außerdem einen Fehler zurück, wenn erwartet wird, dass ein Nicht-Streaming-Request länger als etwa 10 Minuten dauert. Der Aufruf von .Messages.NewStreaming() oder das Festlegen eines benutzerdefinierten Timeouts deaktiviert diesen Fehler.

Datei-Uploads

Request-Parameter, die Datei-Uploads in Multipart-Requests entsprechen, sind als io.Reader typisiert. Der Inhalt des io.Reader wird standardmäßig als Multipart-Formularteil mit dem Dateinamen anonymous_file und dem Content-Type application/octet-stream gesendet. Daher wird empfohlen, einen benutzerdefinierten Content-Type mit dem Helper anthropic.File(reader io.Reader, filename string, contentType string) anzugeben, der jeden io.Reader mit dem passenden Dateinamen und Content-Type umschließt.

// Eine Datei aus dem Dateisystem
file, err := os.Open("/path/to/file.json")
anthropic.FileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// Eine Datei aus einem String
anthropic.FileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}

Dateiname und Content-Type können auch angepasst werden, indem Name() string oder ContentType() string auf dem Laufzeittyp des io.Reader implementiert wird. Beachte, dass os.File Name() string implementiert, sodass eine von os.Open zurückgegebene Datei mit dem Dateinamen auf der Festplatte gesendet wird.

Paginierung

Diese Bibliothek bietet einige Hilfsmittel für die Arbeit mit paginierten List-Endpunkten.

Du kannst .ListAutoPaging()-Methoden verwenden, um über Elemente aller Seiten zu iterieren:

iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
// Ruft bei Bedarf automatisch weitere Seiten ab.
for iter.Next() {
	messageBatch := iter.Current()
	fmt.Println(messageBatch.ID)
}
if err := iter.Err(); err != nil {
	panic(err.Error())
}

Oder du kannst einfache .List()-Methoden verwenden, um eine einzelne Seite abzurufen und ein Standard-Response-Objekt mit zusätzlichen Hilfsmethoden wie .GetNextPage() zu erhalten:

page, err := client.Messages.Batches.List(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
for page != nil {
	for _, batch := range page.Data {
		fmt.Println(batch.ID)
	}
	page, err = page.GetNextPage()
}
if err != nil {
	panic(err.Error())
}

RequestOptions

Diese Bibliothek verwendet das Functional-Options-Muster. Im Paket option definierte Funktionen geben eine RequestOption zurück, eine Closure, die eine RequestConfig verändert. Diese Optionen können dem Client oder einzelnen Requests übergeben werden. Zum Beispiel:

client := anthropic.NewClient(
	// Fügt jeder Anfrage des Clients einen Header hinzu
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Messages.New(context.TODO(), // ...,
	// Überschreibe den Header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Füge dem Request-Body ein undokumentiertes Feld hinzu, mit sjson-Syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

Die Request-Option option.WithDebugLog(nil) kann beim Debuggen hilfreich sein.

Siehe die vollständige Liste der Request-Optionen.

Anpassung des HTTP-Clients

Informationen zu Request-Middleware (option.WithMiddleware) und zum Ersetzen des Standard-http.Client (option.WithHTTPClient) findest du unter SDK-Middleware.

Plattformintegrationen

Das Go SDK unterstützt die folgenden Plattformen:

Agent Platform: import "github.com/anthropics/anthropic-sdk-go/vertex". Verwende vertex.WithGoogleAuth(ctx, region, projectID) oder vertex.WithCredentials(ctx, region, projectID, creds).
Bedrock: import "github.com/anthropics/anthropic-sdk-go/bedrock". Verwende bedrock.NewMantleClient für den Messages-API-Bedrock-Endpunkt (streamt über SSE) oder bedrock.WithLoadDefaultConfig(ctx) / bedrock.WithConfig(cfg) (bedrock-runtime-Pfad). Das Importieren des bedrock-Pakets registriert global einen Decoder für application/vnd.amazon.eventstream in der Streaming-Schicht des SDK (über das init() des Pakets). Dies gilt unabhängig davon, ob du den bedrock-runtime-Pfad mit WithConfig/WithLoadDefaultConfig oder NewMantleClient verwendest.
Claude Platform on AWS: import anthropicaws "github.com/anthropics/anthropic-sdk-go/aws". Verwende anthropicaws.NewClient(ctx, cfg) mit einem anthropicaws.ClientConfig-Wert, um einen Client zu erstellen; setze WorkspaceID in der Konfiguration oder die Umgebungsvariable ANTHROPIC_AWS_WORKSPACE_ID. Der Import-Alias anthropicaws vermeidet eine Namenskollision mit github.com/aws/aws-sdk-go-v2/aws, wenn beide importiert werden. In der Beta verfügbar.
Foundry: import "github.com/anthropics/anthropic-sdk-go/foundry". Verwende foundry.NewClient(cfg) mit einem foundry.ClientConfig-Wert, um einen Client zu erstellen; setze APIKey (oder AzureADTokenProvider für Microsoft Entra ID) und Resource in der Konfiguration oder die Umgebungsvariablen ANTHROPIC_FOUNDRY_API_KEY und ANTHROPIC_FOUNDRY_RESOURCE.

Verwende bedrock.NewMantleClient für neue Projekte; bedrock.WithLoadDefaultConfig/WithConfig bleiben für bestehende Anwendungen erhalten, die die Bedrock-InvokeModel-API verwenden.

Das Go SDK unterstützt außerdem Claude Models on Google Cloud (Anthropic managed) über das Paket github.com/anthropics/anthropic-sdk-go/googlecloud. Um einen Client zu erstellen, rufe googlecloud.NewClient(ctx, cfg) mit einem googlecloud.ClientConfig-Wert auf. Dieser Client befindet sich in der Beta-Phase. Setze WorkspaceID in der Konfiguration oder setze die Umgebungsvariable ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID. Unter Auflösung von Projekt, Standort und Workspace erfährst du, wie der Client die Workspace-ID auflöst.

Erweiterte Nutzung

Zugriff auf rohe Response-Daten (zum Beispiel Response-Header)

Du kannst auf die rohen HTTP-Response-Daten zugreifen, indem du die Request-Option option.WithResponseInto() verwendest. Das ist nützlich, wenn du Response-Header, Statuscodes oder andere Details untersuchen musst.

// Erstelle eine Variable, um die HTTP-Antwort zu speichern
var response *http.Response
message, err := client.Messages.New(
	context.TODO(),
	anthropic.MessageNewParams{
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{{
			Content: []anthropic.ContentBlockParamUnion{{
				OfText: &anthropic.TextBlockParam{
					Text: "What is a quaternion?",
				},
			}},
			Role: anthropic.MessageParamRoleUser,
		}},
		Model: anthropic.ModelClaudeOpus5_5,
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// Fehler behandeln
}
fmt.Printf("%+v\n", message.Content)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)

OpenTelemetry-Tracing

Wenn deine Anwendung einen OpenTelemetry Tracer Provider registriert, gibt das SDK für jede Anfrage, die es sendet, einen Span aus. Um die Spans an deine Observability-Plattform zu senden, siehe OpenTelemetry mit dem Claude SDK einrichten.

Benutzerdefinierte/undokumentierte Requests

Diese Bibliothek ist für den bequemen Zugriff auf die dokumentierte API typisiert. Wenn du auf undokumentierte Endpunkte, Params oder Response-Eigenschaften zugreifen musst, kann die Bibliothek trotzdem verwendet werden.

Undokumentierte Endpunkte

Um Requests an undokumentierte Endpunkte zu senden, kannst du client.Get, client.Post und andere HTTP-Verben verwenden. RequestOptions auf dem Client, wie etwa Wiederholungsversuche, werden bei diesen Requests berücksichtigt.

var (
	// params kann ein io.Reader, ein []byte, ein mit encoding/json serialisierbares Objekt
	// oder ein in dieser Bibliothek definiertes "...Params"-Struct sein.
	params map[string]any

	// result kann ein []byte, *http.Response, ein mit encoding/json deserialisierbares Objekt
	// oder ein in dieser Bibliothek definiertes Modell sein.
	result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
	// ...
}

Undokumentierte Request-Params

Um Requests mit undokumentierten Parametern zu senden, kannst du entweder die Methode option.WithQuerySet() oder die Methode option.WithJSONSet() verwenden.

params := FooNewParams{
	ID: "id_xxxx",
	Data: FooNewParamsData{
		FirstName: anthropic.String("John"),
	},
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))

Undokumentierte Response-Eigenschaften

Um auf undokumentierte Response-Eigenschaften zuzugreifen, kannst du entweder mit result.JSON.RawJSON() auf das rohe JSON der Response als String zugreifen oder mit result.JSON.Foo.Raw() das rohe JSON eines bestimmten Felds des Ergebnisses abrufen.

Alle Felder, die im Response-Struct nicht vorhanden sind, werden gespeichert und sind über result.JSON.ExtraFields zugänglich, eine map[string]respjson.Field.

Semantische Versionierung

Jede Hauptversion dieses SDK sendet standardmäßig eine API-Version im anthropic-version-Header, und mit jeder neuen API-Version erscheint eine neue Hauptversion. Die erste Hauptversion, die 2026-10-21 sendet, ist 2.0.0, deren Modulpfad github.com/anthropics/anthropic-sdk-go/v2 lautet; siehe Migration zur API-Version 2026-10-21.

Dieses Paket folgt im Allgemeinen den SemVer-Konventionen, wobei bestimmte abwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

Änderungen an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Nutzung vorgesehen oder dokumentiert sind.
Änderungen, von denen nicht erwartet wird, dass sie sich in der Praxis auf die große Mehrheit der Nutzer auswirken.

Abwärtskompatibilität wird ernst genommen, damit du dich auf ein reibungsloses Upgrade verlassen kannst.

Dein Feedback ist willkommen; eröffne ein Issue mit Fragen, Bugs oder Vorschlägen.

Installation

Anforderungen

Verwendung

Konversationen

System-Prompts

Streaming

Tool-Aufrufe

Request-Felder

Request-Unions

Deserialisieren von Params

Response-Objekte

Response-Unions

Fehlerbehandlung

Wiederholungsversuche

Timeouts

Lange Requests

Datei-Uploads

Paginierung

RequestOptions

Anpassung des HTTP-Clients

Plattformintegrationen

Erweiterte Nutzung

Zugriff auf rohe Response-Daten (zum Beispiel Response-Header)

OpenTelemetry-Tracing

Benutzerdefinierte/undokumentierte Requests

Undokumentierte Endpunkte

Undokumentierte Request-Params

Undokumentierte Response-Eigenschaften

Semantische Versionierung

Zusätzliche Ressourcen