--- title: Go SDK url: https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go description: 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. Eine Dokumentation der API-Funktionen mit Codebeispielen findest du in der [API-Referenz](https://platform.claude.com/docs/de/api/overview). Diese Seite behandelt Go-spezifische SDK-Funktionen und die Konfiguration. ## Installation ```go import ( "github.com/anthropics/anthropic-sdk-go" // imported as anthropic ) ``` Installiere mit `go get`: ```bash go get github.com/anthropics/anthropic-sdk-go ``` ## Anforderungen Diese Bibliothek erfordert Go 1.24+. ## Verwendung ```go 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](https://platform.claude.com/docs/de/manage-claude/authentication). Wenn dein API-Key ein [persönlicher Key oder Service-Account-Key](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) ist, der nicht auf einen Workspace beschränkt ist, setze die Workspace-ID im Request-Header `anthropic-workspace-id`; [Einen Workspace auswählen](https://platform.claude.com/docs/de/manage-claude/authentication#select-a-workspace) zeigt die Option pro Anfrage für dieses SDK. ```go 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) ``` ```go 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) ``` ```go 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()) } ``` ```go 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`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson)-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. ```go 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]()`. ```go 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. Verwende `SetExtraFields` aus Sicherheitsgründen nur mit vertrauenswürdigen Daten. Um einen benutzerdefinierten Wert anstelle eines Structs zu senden, verwende die generische Funktion `param.Override` (zum Beispiel `param.Override[anthropic.FooParams](12)`). ```go // 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. ```go // 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.SetJSON` erfordert SDK v1.20.0 oder neuer. 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: ```go // 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, ¶ms) // 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. ```go 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. ```go 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. ```go 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"`. ```go 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: ```go _, 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: ```go // 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go#retries) wird. Um ein Timeout pro Wiederholungsversuch festzulegen, verwende `option.WithRequestTimeout()`. ```go // 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 Erwäge, für länger laufende Requests die Streaming-Messages-API zu verwenden. 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go#timeouts) 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go#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. ```go // 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: ```go 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: ```go 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: ```go 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](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/option). ## Anpassung des HTTP-Clients Informationen zu Request-Middleware (`option.WithMiddleware`) und zum Ersetzen des Standard-`http.Client` (`option.WithHTTPClient`) findest du unter [SDK-Middleware](https://platform.claude.com/docs/de/cli-sdks-libraries/middleware). ## Plattformintegrationen Detaillierte Anleitungen zur Plattformeinrichtung mit Codebeispielen findest du hier: * [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) * [Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) * [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed) * [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) Siehe auch [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed). 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](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) 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. ```go // 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](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk). ### 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. ```go 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. ```go 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](https://platform.claude.com/docs/de/api/migration-2026-10-21#upgrade). Dieses Paket folgt im Allgemeinen den [SemVer](https://semver.org/spec/v2.0.0.html)-Konventionen, wobei bestimmte abwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können: 1. Änderungen an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Nutzung vorgesehen oder dokumentiert sind. 2. Ä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](https://github.com/anthropics/anthropic-sdk-go/issues) mit Fragen, Bugs oder Vorschlägen. ## Zusätzliche Ressourcen * [GitHub-Repository](https://github.com/anthropics/anthropic-sdk-go) * [Go-Paketdokumentation](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go) * [API-Referenz](https://platform.claude.com/docs/de/api/overview) * [Streaming von Messages](https://platform.claude.com/docs/de/build-with-claude/streaming)