Go SDK

Установка и настройка Anthropic Go SDK с отменой на основе контекста и функциональными опциями

Библиотека Anthropic для Go обеспечивает удобный доступ к Claude API из приложений, написанных на Go.

Установка

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

Установите с помощью go get:

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

Требования

Для этой библиотеки требуется Go 1.24+.

Использование

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)
		}
	}
}

Сведения о вариантах аутентификации, включая Workload Identity Federation, см. в разделе Аутентификация. Если ваш ключ API является ключом персональной или сервисной учётной записи, который не привязан к рабочему пространству, укажите идентификатор рабочего пространства в заголовке запроса anthropic-workspace-id; в разделе Выбор рабочего пространства показан вариант указания для каждого запроса в этом SDK.

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

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

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

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

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

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

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

content := "What is a quaternion?"

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

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

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

	}
}

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

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

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

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

	if err != nil {
		panic(err)
	}

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

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

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

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

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

				response = GetCoordinates(input.Location)
			}

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

			println(string(b))

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

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

Поля запроса

Библиотека Anthropic использует для полей запроса семантику omitzero из выпуска encoding/json в Go 1.24+.

Обязательные примитивные поля (такие как int64 или string) имеют тег `json:"...,required"`. Эти поля всегда сериализуются, даже если имеют нулевые значения.

Необязательные примитивные типы обёрнуты в param.Opt[T]. Эти поля можно задать с помощью предоставленных конструкторов, таких как anthropic.String(string) или anthropic.Int(int64).

Любые param.Opt[T], map, slice, struct или строковое перечисление используют тег `json:"...,omitzero"`. Их нулевое значение считается опущенным.

Функция param.IsOmitted(any) позволяет проверить наличие любого поля omitzero.

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
		// ... опущенные необязательные поля не будут сериализованы
	},

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

Чтобы отправить null вместо param.Opt[T], используйте param.Null[T](). Чтобы отправить null вместо структуры T, используйте 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

Структуры запросов содержат метод .SetExtraFields(map[string]any), который позволяет отправлять нестандартные поля в теле запроса. Дополнительные поля перезаписывают любые поля структуры с совпадающим ключом.

Чтобы отправить пользовательское значение вместо структуры, используйте обобщённую функцию param.Override (например, param.Override[anthropic.FooParams](12)).

// В случаях, когда API задаёт определённый тип,
// но вы хотите отправить что-то другое, используйте [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Отправить число вместо объекта
custom := param.Override[anthropic.FooParams](12)

Объединения в запросах

Объединения (unions) представлены в виде структуры с полями с префиксом «Of» для каждого из вариантов. Ненулевым может быть только одно поле. Сериализуется именно ненулевое поле.

Доступ к подсвойствам объединения осуществляется через методы структуры объединения. Эти методы возвращают указатель на значение, если оно присутствует.

// Ненулевым может быть только одно поле; чтобы проверить, задано ли поле, используйте param.IsOmitted()
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},
		},
	},
}

// Изменение поля
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}

Десериализация параметров

Типы параметров (типы, оканчивающиеся на Param, такие как MessageNewParams или ToolUnionParam) предназначены только для исходящих запросов. Они корректно сериализуются в JSON, но не полностью поддерживают обратную десериализацию. Если вы десериализуете необработанный JSON в структуру параметров, типизированные поля объединений, такие как OfBashTool20250124, будут равны nil, даже если исходный JSON корректен.

Если вам нужно восстановить параметры из необработанного JSON (например, из базы данных, промежуточного ПО или предыдущего запроса), вызовите UnmarshalJSON, чтобы заполнить поля, не являющиеся объединениями, а затем используйте param.SetJSON, чтобы прикрепить необработанные байты для корректной повторной сериализации:

// Сериализуйте params (например, для хранения или пересылки)
b, err := json.Marshal(original)
if err != nil {
	panic(err)
}

// Позже восстановите params из сохранённого JSON
var params anthropic.MessageNewParams
if err := params.UnmarshalJSON(b); err != nil {
	panic(err)
}
param.SetJSON(b, &params)

// params.Model и другие скалярные поля заполняются методом UnmarshalJSON.
// params.Tools[0].OfBashTool20250124 равно nil (ограничение union-типов),
// но исходный JSON сохраняется. При повторной сериализации params
// для вызова API инструменты сериализуются корректно.
b2, _ := json.Marshal(params)
fmt.Println(string(b) == string(b2)) // true

Для этого сценария param.SetJSON (доступна начиная с v1.20.0) предпочтительнее более общей param.Override[T](any), поскольку не требует явного указания параметра типа и делает намерение обратного преобразования явным.

Объекты ответа

Все поля в структурах ответа являются обычными типами значений (а не указателями или обёртками). Структуры ответа также включают специальное поле JSON, содержащее метаданные о каждом свойстве.

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:"-"`
}

Для обработки необязательных данных используйте метод .Valid() поля JSON. .Valid() возвращает true, если поле присутствует, не равно null и было успешно десериализовано.

Если .Valid() возвращает false, соответствующее поле будет иметь нулевое значение.

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

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

// Доступ к обычным полям

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

// Проверки необязательных полей

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

// Необработанные значения JSON

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

Эти структуры .JSON также включают map ExtraFields, содержащую все свойства JSON-ответа, которые не были указаны в структуре. Это может быть полезно для функций API, которые ещё не поддерживаются в SDK.

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

Объединения в ответах

В ответах объединения представлены плоской структурой, содержащей все возможные поля каждого из вариантов объекта. Чтобы преобразовать её в конкретный вариант, используйте метод .AsFooVariant() или метод .AsAny(), если он есть.

Если объединение в значении ответа содержит примитивные значения, примитивные поля будут располагаться рядом со свойствами, но с префиксом Of и тегом json:"...,inline".

type AnimalUnion struct {
	// Из вариантов [Dog], [Cat]
	Owner Person `json:"owner"`
	// Из варианта [Dog]
	DogBreed string `json:"dog_breed"`
	// Из варианта [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

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

// Если вариант animal
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Ветвление по варианту
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}

Обработка ошибок

Когда API возвращает код состояния, отличный от успешного, SDK возвращает ошибку типа *anthropic.Error. Она содержит значения StatusCode, *http.Request и *http.Response запроса, а также JSON тела ошибки (аналогично другим объектам ответа в SDK). Ошибка также включает RequestID из заголовков ответа, который полезен при устранении неполадок со службой поддержки Anthropic.

Для обработки ошибок используйте шаблон errors.As:

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

Другие ошибки возвращаются без обёртки; например, при сбое HTTP-транспорта вы можете получить *url.Error, оборачивающую *net.OpError.

Повторные попытки

Некоторые ошибки по умолчанию автоматически повторяются 2 раза с короткой экспоненциальной задержкой. По умолчанию SDK повторяет все ошибки соединения, 408 Request Timeout, 409 Conflict, 429 Rate Limit и внутренние ошибки >=500.

Для настройки или отключения этого поведения используйте опцию WithMaxRetries:

// Настройте значение по умолчанию для всех запросов:
client := anthropic.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Переопределение для отдельного запроса:
// ...
	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),
	)

Тайм-ауты

Запросы Messages без потоковой передачи по умолчанию завершаются по тайм-ауту через 10 минут; для других запросов тайм-аут по умолчанию не задан. Используйте контекст, чтобы настроить тайм-аут для жизненного цикла запроса.

Обратите внимание, что если запрос повторяется, тайм-аут контекста не начинается заново. Чтобы задать тайм-аут для каждой попытки, используйте option.WithRequestTimeout().

// Задаёт тайм-аут для запроса с учётом всех повторных попыток.
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,
		},
		// Задаёт тайм-аут для каждой повторной попытки
		option.WithRequestTimeout(20*time.Second),
	)

Длительные запросы

Не задавайте большое значение MaxTokens без использования потоковой передачи, поскольку некоторые сети могут разрывать неактивные соединения через определённое время, что может привести к сбою запроса или тайм-ауту без получения ответа от Anthropic.

Этот SDK также вернёт ошибку, если ожидается, что запрос без потоковой передачи будет длиться дольше примерно 10 минут. Вызов .Messages.NewStreaming() или установка пользовательского тайм-аута отключает эту ошибку.

Загрузка файлов

Параметры запроса, соответствующие загрузке файлов в multipart-запросах, имеют тип io.Reader. Содержимое io.Reader по умолчанию отправляется как часть multipart-формы с именем файла anonymous_file и типом содержимого application/octet-stream, поэтому рекомендуется указывать пользовательский тип содержимого с помощью вспомогательной функции anthropic.File(reader io.Reader, filename string, contentType string), которая оборачивает любой io.Reader с соответствующим именем файла и типом содержимого.

// Файл из файловой системы
file, err := os.Open("/path/to/file.json")
anthropic.FileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// Файл из строки
anthropic.FileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}

Имя файла и тип содержимого также можно настроить, реализовав Name() string или ContentType() string для типа io.Reader во время выполнения. Обратите внимание, что os.File реализует Name() string, поэтому файл, возвращённый os.Open, будет отправлен с именем файла на диске.

Пагинация

Эта библиотека предоставляет ряд удобных средств для работы с конечными точками постраничных списков.

Вы можете использовать методы .ListAutoPaging() для перебора элементов на всех страницах:

iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
// Автоматически загружает дополнительные страницы по мере необходимости.
for iter.Next() {
	messageBatch := iter.Current()
	fmt.Println(messageBatch.ID)
}
if err := iter.Err(); err != nil {
	panic(err.Error())
}

Или вы можете использовать простые методы .List(), чтобы получить одну страницу и стандартный объект ответа с дополнительными вспомогательными методами, такими как .GetNextPage():

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

Эта библиотека использует шаблон функциональных опций. Функции, определённые в пакете option, возвращают RequestOption — замыкание, изменяющее RequestConfig. Эти опции можно передавать клиенту или отдельным запросам. Например:

client := anthropic.NewClient(
	// Добавляет заголовок к каждому запросу, выполняемому клиентом
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Messages.New(context.TODO(), // ...,
	// Переопределить заголовок
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Добавить недокументированное поле в тело запроса с помощью синтаксиса sjson
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

При отладке может быть полезна опция запроса option.WithDebugLog(nil).

См. полный список опций запроса.

Настройка HTTP-клиента

О промежуточном ПО запросов (option.WithMiddleware) и замене стандартного http.Client (option.WithHTTPClient) см. промежуточное ПО SDK.

Интеграции с платформами

Go SDK поддерживает следующие платформы:

Agent Platform: import "github.com/anthropics/anthropic-sdk-go/vertex". Используйте vertex.WithGoogleAuth(ctx, region, projectID) или vertex.WithCredentials(ctx, region, projectID, creds).
Bedrock: import "github.com/anthropics/anthropic-sdk-go/bedrock". Используйте bedrock.NewMantleClient для конечной точки Bedrock с Messages API (потоковая передача через SSE) или bedrock.WithLoadDefaultConfig(ctx) / bedrock.WithConfig(cfg) (путь bedrock-runtime). Импорт пакета bedrock глобально регистрирует декодер для application/vnd.amazon.eventstream в слое потоковой передачи SDK (через init() пакета). Это происходит независимо от того, используете ли вы путь bedrock-runtime с WithConfig/WithLoadDefaultConfig или NewMantleClient.
Claude Platform on AWS: import anthropicaws "github.com/anthropics/anthropic-sdk-go/aws". Используйте anthropicaws.NewClient(ctx, cfg) со значением anthropicaws.ClientConfig для создания клиента; задайте WorkspaceID в конфигурации или переменную окружения ANTHROPIC_AWS_WORKSPACE_ID. Псевдоним импорта anthropicaws позволяет избежать конфликта имён с github.com/aws/aws-sdk-go-v2/aws, когда импортируются оба пакета. Доступно в бета-версии.
Foundry: import "github.com/anthropics/anthropic-sdk-go/foundry". Используйте foundry.NewClient(cfg) со значением foundry.ClientConfig для создания клиента; задайте APIKey (или AzureADTokenProvider для Microsoft Entra ID) и Resource в конфигурации либо переменные окружения ANTHROPIC_FOUNDRY_API_KEY и ANTHROPIC_FOUNDRY_RESOURCE.

Для новых проектов используйте bedrock.NewMantleClient; bedrock.WithLoadDefaultConfig/WithConfig сохраняются для существующих приложений, использующих API Bedrock InvokeModel.

Go SDK также поддерживает Claude Models on Google Cloud (Anthropic managed) через пакет github.com/anthropics/anthropic-sdk-go/googlecloud. Чтобы создать клиент, вызовите googlecloud.NewClient(ctx, cfg) со значением googlecloud.ClientConfig. Этот клиент находится в стадии бета-тестирования. Задайте WorkspaceID в конфигурации или установите переменную окружения ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID. О том, как клиент определяет идентификатор рабочего пространства, см. в разделе Определение проекта, расположения и рабочего пространства.

Расширенное использование

Доступ к необработанным данным ответа (например, к заголовкам ответа)

Вы можете получить доступ к необработанным данным HTTP-ответа с помощью опции запроса option.WithResponseInto(). Это полезно, когда нужно изучить заголовки ответа, коды состояния или другие сведения.

// Создаём переменную для хранения HTTP-ответа
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 {
	// обработка ошибки
}
fmt.Printf("%+v\n", message.Content)

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

Трассировка OpenTelemetry

Когда ваше приложение регистрирует провайдер трассировщика OpenTelemetry, SDK создаёт спан для каждого отправляемого запроса. Чтобы отправлять спаны на вашу платформу наблюдаемости, см. Настройка OpenTelemetry с Claude SDK.

Выполнение пользовательских/недокументированных запросов

Эта библиотека типизирована для удобного доступа к документированному API. Если вам нужен доступ к недокументированным конечным точкам, параметрам или свойствам ответа, библиотеку всё равно можно использовать.

Недокументированные конечные точки

Для запросов к недокументированным конечным точкам можно использовать client.Get, client.Post и другие HTTP-методы. RequestOptions клиента, такие как повторные попытки, будут учитываться при выполнении этих запросов.

var (
	// params может быть io.Reader, []byte, объектом, сериализуемым через encoding/json,
	// или структурой "...Params", определённой в этой библиотеке.
	params map[string]any

	// result может быть []byte, *http.Response, объектом, десериализуемым через encoding/json,
	// или моделью, определённой в этой библиотеке.
	result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
	// ...
}

Недокументированные параметры запроса

Для запросов с недокументированными параметрами можно использовать методы option.WithQuerySet() или option.WithJSONSet().

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

Недокументированные свойства ответа

Чтобы получить доступ к недокументированным свойствам ответа, можно либо получить необработанный JSON ответа в виде строки с помощью result.JSON.RawJSON(), либо получить необработанный JSON конкретного поля результата с помощью result.JSON.Foo.Raw().

Все поля, отсутствующие в структуре ответа, сохраняются и доступны через result.JSON.ExtraFields, который имеет тип map[string]respjson.Field.

Семантическое версионирование

Каждая мажорная версия этого SDK по умолчанию отправляет одну версию API в заголовке anthropic-version, и с каждой новой версией API выходит новая мажорная версия. Первая мажорная версия, отправляющая 2026-10-21, — 2.0.0, путь модуля которой — github.com/anthropics/anthropic-sdk-go/v2; см. Переход на версию API 2026-10-21.

Этот пакет в целом следует соглашениям SemVer, однако некоторые обратно несовместимые изменения могут выпускаться в минорных версиях:

Изменения во внутренних компонентах библиотеки, которые технически являются публичными, но не предназначены и не документированы для внешнего использования.
Изменения, которые, как ожидается, на практике не затронут подавляющее большинство пользователей.

Мы серьёзно относимся к обратной совместимости, чтобы вы могли рассчитывать на беспроблемное обновление.

Мы будем рады вашим отзывам; создайте issue с вопросами, сообщениями об ошибках или предложениями.

Установка

Требования

Использование

Диалоги

Системные подсказки

Потоковая передача

Вызов инструментов

Поля запроса

Объединения в запросах

Десериализация параметров

Объекты ответа

Объединения в ответах

Обработка ошибок

Повторные попытки

Тайм-ауты

Длительные запросы

Загрузка файлов

Пагинация

RequestOptions

Настройка HTTP-клиента

Интеграции с платформами

Расширенное использование

Доступ к необработанным данным ответа (например, к заголовкам ответа)

Трассировка OpenTelemetry

Выполнение пользовательских/недокументированных запросов

Недокументированные конечные точки

Недокументированные параметры запроса

Недокументированные свойства ответа

Семантическое версионирование

Дополнительные ресурсы