Claude Platform Docs

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/v2" // imported as anthropic
)

Installiere mit go get:

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

Anforderungen

Diese Bibliothek erfordert Go 1.25+.

Verwendung

package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go/v2"
	"github.com/anthropics/anthropic-sdk-go/v2/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.

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

Anfrage-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, das ungleich null ist, 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 Parametern

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

Wenn du Parameter aus rohem JSON rekonstruieren musst (zum Beispiel aus einer Datenbank, aus Middleware oder aus 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 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 für den API-Aufruf
// erneut gemarshalt wird, 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 Antworten 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{
		anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
	},
	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 interne Fehler.

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{
				anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
			},
			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 den Lebenszyklus einer Anfrage zu konfigurieren.

Beachte, dass das Kontext-Timeout nicht neu startet, wenn eine Anfrage 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{
				anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
			},
			Model: anthropic.ModelClaudeOpus5_5,
		},
		// Legt das Timeout pro Wiederholungsversuch fest
		option.WithRequestTimeout(20*time.Second),
	)

Lange Anfragen

Vermeide es, einen großen MaxTokens-Wert ohne Streaming festzulegen, da manche Netzwerke inaktive Verbindungen nach einer bestimmten Zeit trennen können, was dazu führen kann, dass die Anfrage fehlschlägt oder ein Timeout auftritt, ohne dass eine Antwort 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-Formular-Teil mit dem Dateinamen anonymous_file und dem Content-Type application/octet-stream gesendet. Deshalb wird empfohlen, mit dem Helper anthropic.File(reader io.Reader, filename string, contentType string) einen benutzerdefinierten Content-Type anzugeben. Dieser Helper umschließt jeden io.Reader mit dem passenden Dateinamen und Content-Type.

// 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 dem Datenträger 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 Anfragen ü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 Anfrageoption option.WithDebugLog(nil) kann beim Debuggen hilfreich sein.

Siehe die vollständige Liste der Anfrageoptionen.

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:

  • Claude Models on Google Cloud (Google managed): import "github.com/anthropics/anthropic-sdk-go/v2/vertex". Verwende vertex.WithGoogleAuth(ctx, region, projectID) oder vertex.WithCredentials(ctx, region, projectID, creds).
  • Bedrock: import "github.com/anthropics/anthropic-sdk-go/v2/bedrock". Was du verwendest, hängt vom Endpunkt ab:
    • bedrock-mantle: bedrock.NewMantleClient. Er streamt über SSE.
    • bedrock-runtime: bedrock.WithLoadDefaultConfig(ctx) oder bedrock.WithConfig(cfg), für die InvokeModel-API.
  • Claude Platform on AWS: import anthropicaws "github.com/anthropics/anthropic-sdk-go/v2/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/v2/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.

Das Go SDK unterstützt außerdem Claude Models on Google Cloud (Anthropic managed) über das Paket github.com/anthropics/anthropic-sdk-go/v2/googlecloud. Um einen Client zu erstellen, rufe googlecloud.NewClient(ctx, cfg) mit einem googlecloud.ClientConfig-Wert auf. Dieser Client befindet sich in der Beta. 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{
			anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
		},
		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 Anthropic SDK einrichten.

Benutzerdefinierte/undokumentierte Anfragen

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

Undokumentierte Endpunkte

Um Anfragen 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 Anfragen 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 Anfrageparameter

Um Anfragen mit undokumentierten Parametern zu stellen, kannst du entweder die Funktion option.WithQuerySet() oder die Funktion 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 Antworteigenschaften zuzugreifen, kannst du entweder mit result.JSON.RawJSON() auf das rohe JSON der Antwort 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

Dieses Paket folgt im Allgemeinen den SemVer-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.

Jede Anfrage an die Claude API verwendet eine API-Version. Mit diesem SDK verwenden deine Anfragen die API-Version, die aktuell war, als die Hauptversion deines SDK veröffentlicht wurde. Du wechselst also zu einer neuen API-Version, indem du auf eine neue Hauptversion aktualisierst. Version 2.0.0 ist die erste, die 2026-10-21 verwendet. Ihr Modulpfad ist github.com/anthropics/anthropic-sdk-go/v2. Unter Migration zur API-Version 2026-10-21 erfährst du, wie du aktualisierst.

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

Zusätzliche Ressourcen

War diese Seite hilfreich?