---
title: Go SDK
url: https://platform.claude.com/docs/ru/cli-sdks-libraries/sdks/go
description: Установка и настройка Anthropic Go SDK с отменой на основе контекста и функциональными опциями
---

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

<Info>
  Документацию по функциям API с примерами кода см. в [справочнике API](https://platform.claude.com/docs/ru/api/overview). На этой странице описаны функции и настройка SDK, специфичные для Go.
</Info>

## Установка

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

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

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

## Требования

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

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

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

Сведения о вариантах аутентификации, включая Workload Identity Federation, см. в разделе [Аутентификация](https://platform.claude.com/docs/ru/manage-claude/authentication). Если ваш ключ API является [ключом персональной или сервисной учётной записи](https://platform.claude.com/docs/ru/manage-claude/authentication#key-types), который не привязан к рабочему пространству, укажите идентификатор рабочего пространства в заголовке запроса `anthropic-workspace-id`; в разделе [Выбор рабочего пространства](https://platform.claude.com/docs/ru/manage-claude/authentication#select-a-workspace) показан вариант указания для каждого запроса в этом SDK.

<AccordionGroup>
  <Accordion title="Диалоги">
    ```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)
    ```
  </Accordion>

  <Accordion title="Системные подсказки">
    ```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)
    ```
  </Accordion>

  <Accordion title="Потоковая передача">
    ```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())
    }
    ```
  </Accordion>

  <Accordion title="Вызов инструментов">
    ```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...))
    }
    ```
  </Accordion>
</AccordionGroup>

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

Библиотека Anthropic использует для полей запроса семантику [`omitzero`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson) из выпуска `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`.

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

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

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

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

<Warning>
  По соображениям безопасности используйте `SetExtraFields` только с доверенными данными.
</Warning>

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

```go
// В случаях, когда 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» для каждого из вариантов. Ненулевым может быть только одно поле. Сериализуется именно ненулевое поле.

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

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

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

<Note>
  Для `param.SetJSON` требуется SDK версии v1.20.0 или новее.
</Note>

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

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

```go
// Сериализуйте 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`, содержащее метаданные о каждом свойстве.

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

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

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

```go
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.

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

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

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

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

```go
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`:

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

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

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

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

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

```go
// Настройте значение по умолчанию для всех запросов:
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 минут; для других запросов тайм-аут по умолчанию не задан. Используйте контекст, чтобы настроить тайм-аут для жизненного цикла запроса.

Обратите внимание, что если запрос [повторяется](https://platform.claude.com/docs/ru/cli-sdks-libraries/sdks/go#retries), тайм-аут контекста не начинается заново. Чтобы задать тайм-аут для каждой попытки, используйте `option.WithRequestTimeout()`.

```go
// Задаёт тайм-аут для запроса с учётом всех повторных попыток.
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),
	)
```

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

<Warning>
  Для длительных запросов рекомендуется использовать Messages API с потоковой передачей.
</Warning>

Не задавайте большое значение `MaxTokens` без использования потоковой передачи, поскольку некоторые сети могут разрывать неактивные соединения через определённое время, что может привести к сбою запроса или [тайм-ауту](https://platform.claude.com/docs/ru/cli-sdks-libraries/sdks/go#timeouts) без получения ответа от Anthropic.

Этот SDK также вернёт ошибку, если ожидается, что запрос без потоковой передачи будет длиться дольше примерно 10 минут. Вызов `.Messages.NewStreaming()` или [установка пользовательского тайм-аута](https://platform.claude.com/docs/ru/cli-sdks-libraries/sdks/go#timeouts) отключает эту ошибку.

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

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

```go
// Файл из файловой системы
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()` для перебора элементов на всех страницах:

```go
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()`:

```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

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

```go
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)`.

См. [полный список опций запроса](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/option).

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

О промежуточном ПО запросов (`option.WithMiddleware`) и замене стандартного `http.Client` (`option.WithHTTPClient`) см. [промежуточное ПО SDK](https://platform.claude.com/docs/ru/cli-sdks-libraries/middleware).

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

<Note>
  Подробные руководства по настройке платформ с примерами кода см.:

  * [Amazon Bedrock](https://platform.claude.com/docs/ru/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock (Opus 4.6 и более ранние)](https://platform.claude.com/docs/ru/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws)
  * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/google-managed)
  * [Microsoft Foundry](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry)

  См. также [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed).
</Note>

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`. О том, как клиент определяет идентификатор рабочего пространства, см. в разделе [Определение проекта, расположения и рабочего пространства](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).

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

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

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

```go
// Создаём переменную для хранения 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](https://platform.claude.com/docs/ru/manage-claude/opentelemetry/sdk).

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

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

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

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

```go
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()`.

```go
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](https://platform.claude.com/docs/ru/api/migration-2026-10-21#upgrade).

Этот пакет в целом следует соглашениям [SemVer](https://semver.org/spec/v2.0.0.html), однако некоторые обратно несовместимые изменения могут выпускаться в минорных версиях:

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

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

Мы будем рады вашим отзывам; создайте [issue](https://github.com/anthropics/anthropic-sdk-go/issues) с вопросами, сообщениями об ошибках или предложениями.

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

* [Репозиторий GitHub](https://github.com/anthropics/anthropic-sdk-go)
* [Документация пакета Go](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go)
* [Справочник API](https://platform.claude.com/docs/ru/api/overview)
* [Потоковая передача сообщений](https://platform.claude.com/docs/ru/build-with-claude/streaming)