Go SDK

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.

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,
	})
	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. Wenn dein API-Key ein persönlicher Key oder ein Service-Account-Key mit Zugriff auf mehrere Workspaces 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,
	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,
	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,
	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,
	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,
		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-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 jeder 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.

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]().

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.

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 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 kann 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.

// 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-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:

// 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, &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, 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.

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.

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.

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".

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:

_, 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,
})
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:

// Konfiguriere den Standard 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,
		},
		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 Anfrage das Kontext-Timeout nicht von vorne beginnt. Um ein Timeout pro Wiederholung festzulegen, verwende option.WithRequestTimeout().

// Dies 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,
		},
		// Dies legt das Timeout pro Wiederholungsversuch fest
		option.WithRequestTimeout(20*time.Second),
	)

Lange 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 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 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 ist der empfohlene Ansatz, 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.

// 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:

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:

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:

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.

Anpassung des HTTP-Clients

Für Anfrage-Middleware (option.WithMiddleware) und das Ersetzen des Standard-http.Client (option.WithHTTPClient) siehe SDK-Middleware.

Plattform-Integrationen

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: Derzeit nicht im Go SDK unterstützt. Siehe Claude in Microsoft Foundry für unterstützte SDKs.

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.

// 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,
	},
	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.

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.

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-Konventionen, obwohl bestimmte rückwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

Änderungen an Bibliotheks-Internas, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind.
Ä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 mit Fragen, Bugs oder Vorschlägen.

Installation

Anforderungen

Verwendung

Gespräche

System-Prompts

Streaming

Tool-Aufrufe

Anfragefelder

Anfrage-Unions

Deserialisieren von Params

Antwortobjekte

Antwort-Unions

Fehlerbehandlung

Wiederholungen

Timeouts

Lange Anfragen

Datei-Uploads

Paginierung

RequestOptions

Anpassung des HTTP-Clients

Plattform-Integrationen

Erweiterte Verwendung

Zugriff auf rohe Antwortdaten (zum Beispiel Antwort-Header)

Benutzerdefinierte/undokumentierte Anfragen stellen

Undokumentierte Endpunkte

Undokumentierte Anfrageparameter

Undokumentierte Antworteigenschaften

Semantische Versionierung

Zusätzliche Ressourcen