--- title: Go SDK url: https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go description: Installiere und konfiguriere das Anthropic Go SDK mit kontextbasierter Abbruchsteuerung und funktionalen Optionen --- Die Anthropic Go-Bibliothek bietet bequemen Zugriff auf die Claude API aus Anwendungen, die in Go geschrieben sind. Für die API-Feature-Dokumentation mit Codebeispielen siehe die [API-Referenz](https://platform.claude.com/docs/de/api/overview). Diese Seite behandelt Go-spezifische SDK-Features und -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) } } } ``` 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 ein Service-Account-Key](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) mit Zugriff auf mehrere Workspaces 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...)) } ``` ## Anfragefelder Die Anthropic-Bibliothek verwendet die [`omitzero`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson)-Semantik aus dem Go 1.24+ `encoding/json`-Release für Anfragefelder. Erforderliche primitive Felder (wie `int64` oder `string`) tragen das Tag `` `json:"...,required"` ``. Diese Felder werden immer serialisiert, auch ihre Nullwerte. Optionale primitive Typen werden in ein `param.Opt[T]` eingeschlossen. 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`-Feldes 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 // ... ausgelassene nicht erforderliche 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 ``` Anfrage-Structs enthalten eine `.SetExtraFields(map[string]any)`-Methode, die nicht-konforme Felder im Anfragekörper senden kann. Zusätzliche Felder überschreiben alle Struct-Felder mit einem passenden 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 möchtest, verwende [SetExtraFields]: p.SetExtraFields(map[string]any{ "x": 0.01, // send "x" as a float instead of int }) // Sende eine Zahl anstelle eines Objekts custom := param.Override[anthropic.FooParams](12) ``` ### Anfrage-Unions Unions werden als Struct mit Feldern dargestellt, die für jede ihrer Varianten mit „Of“ präfixiert sind. 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 veränderbaren Zeiger auf die zugrunde liegenden Daten zurück, falls vorhanden. ```go // Nur ein Feld darf ungleich null sein, verwende param.IsOmitted(), um zu prüfen, 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 verändern if address := animal.GetOwner().GetAddress(); address != nil { address.ZipCode = 94304 } ``` ### Deserialisieren von Params `param.SetJSON` erfordert SDK v1.20.0 oder höher. Param-Typen (Typen, die auf `Param` enden, wie `MessageNewParams` oder `ToolUnionParam`) sind nur für ausgehende Anfragen konzipiert. Sie werden korrekt zu JSON marshalled, unterstützen aber keine vollständige Round-Trip-Deserialisierung. Wenn du rohes JSON in ein Param-Struct unmarshallst, 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, Middleware oder einer vorherigen Anfrage), rufe `UnmarshalJSON` auf, um Nicht-Union-Felder zu befüllen, und verwende dann `param.SetJSON`, um die rohen Bytes für eine korrekte Re-Serialisierung anzuhängen: ```go // Serialisiere params (zum Beispiel zur Speicherung oder Weiterleitung) 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 für den API-Aufruf // erneut gemarshalt wird, serialisieren die Tools korrekt. 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. ## Antwortobjekte Alle Felder in Antwort-Structs sind gewöhnliche Werttypen (keine Zeiger oder Wrapper). Antwort-Structs enthalten außerdem ein spezielles `JSON`-Feld mit Metadaten über jede 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 `.Valid()`-Methode auf dem JSON-Feld. `.Valid()` gibt true zurück, wenn das Feld vorhanden, nicht `null` und erfolgreich unmarshalled 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-Antwort, die nicht im Struct angegeben wurden. Dies kann für API-Features nützlich sein, die noch nicht im SDK vorhanden sind. ```go body := res.JSON.ExtraFields["my_unexpected_field"].Raw() ``` ### Antwort-Unions In Antworten werden Unions durch ein abgeflachtes Struct dargestellt, das alle möglichen Felder aus jeder der Objektvarianten enthält. Um es in eine Variante zu konvertieren, verwende die `.AsFooVariant()`-Methode oder die `.AsAny()`-Methode, falls vorhanden. Wenn eine Antwortwert-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:"-"` } // Wenn Tiervariante if animal.Owner.Address.ZipCode == "" { panic("missing zip code") } // Auf die Variante umschalten switch variant := animal.AsAny().(type) { case Dog: case Cat: default: panic("unexpected type") } ``` ## Fehlerbehandlung Wenn die API einen Nicht-Erfolgs-Statuscode zurückgibt, gibt das SDK einen Fehler vom Typ `*anthropic.Error` zurück. Dieser enthält die Werte `StatusCode`, `*http.Request` und `*http.Response` der Anfrage sowie das JSON des Fehlerkörpers (ähnlich wie andere Antwortobjekte im SDK). Der Fehler enthält außerdem die `RequestID` aus den Antwort-Headern, was für die 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 unverpackt zurückgegeben; zum Beispiel könntest du, wenn der HTTP-Transport fehlschlägt, `*url.Error` erhalten, das `*net.OpError` umschließt. ## Wiederholungen Bestimmte Fehler werden standardmäßig automatisch 2-mal wiederholt, mit einem kurzen exponentiellen Backoff. Das SDK wiederholt standardmäßig alle Verbindungsfehler, 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal-Fehler. 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-Anfragen laufen standardmäßig nach 10 Minuten ab; andere Anfragen haben kein Standard-Timeout. Verwende den Kontext, um ein Timeout für einen Anfrage-Lebenszyklus zu konfigurieren. Beachte, dass bei einer [wiederholten](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go#retries) Anfrage das Kontext-Timeout nicht von vorne beginnt. Um ein Timeout pro Wiederholung festzulegen, verwende `option.WithRequestTimeout()`. ```go // Legt das Timeout für die Anfrage fest, einschließlich aller Wiederholungen. 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 Wiederholung fest option.WithRequestTimeout(20*time.Second), ) ``` ## Lange Anfragen Erwäge die Verwendung der Streaming-Messages-API für länger laufende Anfragen. Vermeide es, einen großen `MaxTokens`-Wert ohne Streaming zu setzen, da einige Netzwerke inaktive Verbindungen nach einer bestimmten Zeit trennen können, was dazu führen kann, dass die Anfrage fehlschlägt oder ein [Timeout](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/go#timeouts) auftritt, ohne eine Antwort von Anthropic zu erhalten. Dieses SDK gibt außerdem einen Fehler zurück, wenn erwartet wird, dass eine Nicht-Streaming-Anfrage 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 Anfrageparameter, die Datei-Uploads in Multipart-Anfragen entsprechen, sind als `io.Reader` typisiert. Der Inhalt des `io.Reader` wird standardmäßig als Multipart-Formular-Teil mit dem Dateinamen `anonymous_file` und dem Content-Type `application/octet-stream` gesendet. Daher wird empfohlen, einen benutzerdefinierten Content-Type mit dem Helfer `anthropic.File(reader io.Reader, filename string, contentType string)` anzugeben, der jeden `io.Reader` mit dem entsprechenden 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"), } ``` Der Dateiname und der Content-Type können auch durch die Implementierung von `Name() string` oder `ContentType() string` auf dem Laufzeittyp von `io.Reader` angepasst werden. 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 Annehmlichkeiten für die Arbeit mit paginierten Listen-Endpunkten. Du kannst `.ListAutoPaging()`-Methoden verwenden, um über Elemente auf allen 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-Antwortobjekt 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 funktionale Optionsmuster. Funktionen, die im `option`-Paket definiert sind, geben eine `RequestOption` zurück, die ein Closure ist, das eine `RequestConfig` mutiert. Diese Optionen können dem Client oder einzelnen Anfragen bereitgestellt werden. Zum Beispiel: ```go client := anthropic.NewClient( // Fügt jeder vom Client gestellten Anfrage 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 Anfragetext ein undokumentiertes Feld hinzu, mit sjson-Syntax option.WithJSONSet("some.json.path", map[string]string{"my": "object"}), ) ``` Die Anfrageoption `option.WithDebugLog(nil)` kann beim Debuggen hilfreich sein. Siehe die [vollständige Liste der Anfrageoptionen](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/option). ## Anpassung des HTTP-Clients Für Anfrage-Middleware (`option.WithMiddleware`) und das Ersetzen des Standard-`http.Client` (`option.WithHTTPClient`) siehe [SDK-Middleware](https://platform.claude.com/docs/de/cli-sdks-libraries/middleware). ## Plattform-Integrationen Für detaillierte Plattform-Einrichtungsanleitungen mit Codebeispielen siehe: * [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 auf AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) * [Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai) * [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) 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). Der globale Import des `bedrock`-Pakets registriert einen Decoder für `application/vnd.amazon.eventstream` bei der Streaming-Schicht des SDK (über das Paket `init()`). Dies gilt unabhängig davon, ob du den `bedrock-runtime`-`WithConfig`/`WithLoadDefaultConfig`-Pfad oder `NewMantleClient` verwendest. * **Claude Platform auf AWS:** `import anthropicaws "github.com/anthropics/anthropic-sdk-go/aws"`. Verwende `anthropicaws.NewClient(ctx, cfg)` mit einem `anthropicaws.ClientConfig`-Wert, um einen Client zu konstruieren; 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. Verfügbar in der Beta. * **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, die die Bedrock-`InvokeModel`-API verwenden. ## Erweiterte Verwendung ### Zugriff auf rohe Antwortdaten (zum Beispiel Antwort-Header) Du kannst auf die rohen HTTP-Antwortdaten zugreifen, indem du die Anfrageoption `option.WithResponseInto()` verwendest. Dies ist nützlich, wenn du Antwort-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) ``` ### Benutzerdefinierte/undokumentierte Anfragen stellen Diese Bibliothek ist für den bequemen Zugriff auf die dokumentierte API typisiert. Wenn du auf undokumentierte Endpunkte, Params oder Antworteigenschaften zugreifen musst, kann die Bibliothek dennoch verwendet werden. #### Undokumentierte Endpunkte Um Anfragen an undokumentierte Endpunkte zu stellen, kannst du `client.Get`, `client.Post` und andere HTTP-Verben verwenden. `RequestOptions` auf dem Client, wie Wiederholungen, werden bei diesen Anfragen berücksichtigt. ```go var ( // params kann ein io.Reader, ein []byte, ein mit encoding/json serialisierbares Objekt // oder eine in dieser Bibliothek definierte "...Params"-Struktur 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 Anfrageparameter Um Anfragen mit undokumentierten Parametern zu stellen, kannst du entweder die Methoden `option.WithQuerySet()` oder `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 Antworteigenschaften Um auf undokumentierte Antworteigenschaften zuzugreifen, kannst du entweder auf das rohe JSON der Antwort als String mit `result.JSON.RawJSON()` zugreifen oder das rohe JSON eines bestimmten Feldes im Ergebnis mit `result.JSON.Foo.Raw()` abrufen. Alle Felder, die nicht im Antwort-Struct vorhanden sind, werden gespeichert und können über `result.JSON.ExtraFields` abgerufen werden, was eine `map[string]respjson.Field` ist. ## Semantische Versionierung Dieses Paket folgt im Allgemeinen den [SemVer](https://semver.org/spec/v2.0.0.html)-Konventionen, obwohl bestimmte rückwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können: 1. Änderungen an Bibliotheks-Internas, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind. 2. Änderungen, von denen nicht erwartet wird, dass sie die überwiegende Mehrheit der Benutzer in der Praxis betreffen. Rückwärtskompatibilität wird ernst genommen, um sicherzustellen, dass du dich auf ein reibungsloses Upgrade-Erlebnis verlassen kannst. Dein Feedback ist willkommen; ö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 Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming)