Go SDK

安装和配置 Anthropic Go SDK，支持基于上下文的取消和函数式选项

Anthropic Go 库为使用 Go 编写的应用程序提供对 Anthropic REST API 的便捷访问。

Info

有关带有代码示例的 API 功能文档，请参阅 API 参考。本页面介绍 Go 特定的 SDK 功能和配置。

安装

import (
	"github.com/anthropics/anthropic-sdk-go" // 导入为 anthropic
)

使用 go get 安装：

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

要求

此库需要 Go 1.23+。

用法

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"), // 默认为 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.ModelClaudeOpus4_7,
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", message.Content)
}

有关认证选项（包括 Workload Identity Federation），请参阅认证。

对话

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

message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus4_7,
	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.ModelClaudeOpus4_7,
	Messages:  messages,
	MaxTokens: 1024,
})
if err != nil {
	panic(err)
}

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

系统提示

messages := []anthropic.MessageParam{anthropic.NewUserMessage(anthropic.NewTextBlock("Hello"))}
message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus4_7,
	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.ModelClaudeOpus4_7,
	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())
}

工具调用

package main

import (
	"context"
	"encoding/json"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/invopop/jsonschema"
)

func main() {
	client := anthropic.NewClient()

	content := "Where is San Francisco?"

	println("[user]: " + content)

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

type GetCoordinatesInput struct {
	Location string `json:"location" jsonschema_description:"The location to look up."`
}

var GetCoordinatesInputSchema = GenerateSchema[GetCoordinatesInput]()

type GetCoordinateResponse struct {
	Long float64 `json:"long"`
	Lat  float64 `json:"lat"`
}

func GetCoordinates(location string) GetCoordinateResponse {
	return GetCoordinateResponse{
		Long: -122.4194,
		Lat:  37.7749,
	}
}

func GenerateSchema[T any]() anthropic.ToolInputSchemaParam {
	reflector := jsonschema.Reflector{
		AllowAdditionalProperties: false,
		DoNotReference:            true,
	}
	var v T

	schema := reflector.Reflect(v)

	return anthropic.ToolInputSchemaParam{
		Properties: schema.Properties,
	}
}

func color(s string) string {
	return fmt.Sprintf("\033[1;%sm%s\033[0m", "33", s)
}

请求字段

anthropic 库使用 Go 1.24+ encoding/json 版本中的 omitzero 语义处理请求字段。

必需的原始类型字段（int64、string 等）带有 `json:"...,required"` 标签。这些字段始终会被序列化，即使是零值。

可选的原始类型包装在 param.Opt[T] 中。这些字段可以使用提供的构造函数设置，如 anthropic.String(string)、anthropic.Int(int64) 等。

任何 param.Opt[T]、map、slice、struct 或 string enum 使用 `json:"...,omitzero"` 标签。其零值被视为已省略。

param.IsOmitted(any) 函数可以确认任何 omitzero 字段的存在。

p := anthropic.ExampleParams{
	ID:   "id_xxx",                // 必需属性
	Name: anthropic.String("..."), // 可选属性

	Point: anthropic.Point{
		X: 0,                // 必需字段将序列化为 0
		Y: anthropic.Int(1), // 可选字段将序列化为 1
		// ... 省略的非必需字段不会被序列化
	},

	Origin: anthropic.Origin{}, // [Origin] 的零值被视为已省略
}

要发送 null 而不是 param.Opt[T]，请使用 param.Null[T]()。要发送 null 而不是 struct T，请使用 param.NullStruct[T]()。

p.Name = param.Null[string]()       // 发送 'null' 而不是 string
p.Point = param.NullStruct[Point]() // 发送 'null' 而不是 struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

请求结构体包含 .SetExtraFields(map[string]any) 方法，可以在请求体中发送不符合规范的字段。额外字段会覆盖具有匹配键的任何结构体字段。

Warning

出于安全原因，仅在使用受信任数据时才使用 SetExtraFields。

要发送自定义值而不是结构体，请使用泛型函数 param.Override（例如 param.Override[anthropic.FooParams](12)）。

// 在 API 指定给定类型但你想发送其他内容的情况下，
// 请使用 [SetExtraFields]：
p.SetExtraFields(map[string]any{
	"x": 0.01, // 将 "x" 作为浮点数发送而不是整数
})

// 发送数字而不是对象
custom := param.Override[anthropic.FooParams](12)

请求联合类型

联合类型表示为一个结构体，每个变体的字段以 "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
}

反序列化参数

Note

param.SetJSON 需要 SDK v1.20.0 或更高版本。

参数类型（以 Param 结尾的类型，如 MessageNewParams 或 ToolUnionParam）仅用于出站请求。它们可以正确地序列化为 JSON，但不完全支持往返反序列化。如果你将原始 JSON 反序列化到参数结构体中，像 OfBashTool20250124 这样的类型化联合字段将是 nil，即使底层 JSON 是有效的。

如果你需要从原始 JSON 重建参数（例如从数据库、中间件或之前的请求），请调用 UnmarshalJSON 填充非联合字段，然后使用 param.SetJSON 附加原始字节以进行正确的重新序列化：

package main

import (
	"encoding/json"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/packages/param"
)

func main() {
	original := anthropic.MessageNewParams{
		Model:     anthropic.ModelClaudeOpus4_7,
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("hello")),
		},
		Tools: []anthropic.ToolUnionParam{{
			OfBashTool20250124: &anthropic.ToolBash20250124Param{
				Type: "bash_20250124",
				Name: "bash",
			},
		}},
	}
	// 序列化参数（例如用于存储或转发）
	b, err := json.Marshal(original)
	if err != nil {
		panic(err)
	}

	// 稍后从存储的 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（联合类型的限制），
	// 但原始 JSON 被保留。当 params 再次被序列化用于 API 调用时，
	// tools 会正确序列化。
	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:"-"`
}

要处理可选数据，请使用 JSON 字段上的 .Valid() 方法。.Valid() 在字段存在、非 null 且成功反序列化时返回 true。

如果 .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 结构体还包含一个 ExtraFields 映射，其中包含 JSON 响应中未在结构体中指定的任何属性。这对于 SDK 中尚未包含的 API 功能很有用。

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 模式：

package main

import (
	"context"
	"errors"

	"github.com/anthropics/anthropic-sdk-go"
)

func main() {
	client := anthropic.NewClient()
	_, 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.ModelClaudeOpus4_7,
	})
	if err != nil {
		var apierr *anthropic.Error
		if errors.As(err, &apierr) {
			println("Request ID:", apierr.RequestID)
			println(string(apierr.DumpRequest(true)))  // 打印序列化的 HTTP 请求
			println(string(apierr.DumpResponse(true))) // 打印序列化的 HTTP 响应
		}
		panic(err.Error()) // POST "/v1/messages": 400 Bad Request (Request-ID: req_xxx) { ... }
	}
}

当发生其他错误时，它们会以非包装形式返回；例如，如果 HTTP 传输失败，你可能会收到包装了 *net.OpError 的 *url.Error。

重试

某些错误默认会自动重试 2 次，带有短暂的指数退避。SDK 默认重试所有连接错误、408 请求超时、409 冲突、429 速率限制和 >=500 内部错误。

你可以使用 WithMaxRetries 选项来配置或禁用此功能：

package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	// 为所有请求配置默认值：
	client := anthropic.NewClient(
		option.WithMaxRetries(0), // 默认为 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.ModelClaudeOpus4_7,
			},
			option.WithMaxRetries(5),
		)
}

超时

非流式 Messages 请求默认在 10 分钟后超时；其他请求没有默认超时。使用上下文为请求生命周期配置超时。

请注意，如果请求被重试，上下文超时不会重新开始。要设置每次重试的超时，请使用 option.WithRequestTimeout()。

package main

import (
	"context"
	"time"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	client := anthropic.NewClient()
	// 这设置了请求的超时时间，包括所有重试。
	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.ModelClaudeOpus4_7,
			},
			// 这设置了每次重试的超时
			option.WithRequestTimeout(20*time.Second),
		)
}

长请求

Warning

对于较长时间运行的请求，请考虑使用流式 Messages API。

避免在不使用流式传输的情况下设置较大的 MaxTokens 值，因为某些网络可能会在一段时间后断开空闲连接，这可能导致请求失败或超时而无法收到来自 Anthropic 的响应。

如果非流式请求预计超过大约 10 分钟，SDK 也会返回错误。调用 .Messages.NewStreaming() 或设置自定义超时会禁用此错误。

文件上传

多部分请求中对应文件上传的请求参数类型为 io.Reader。io.Reader 的内容默认作为多部分表单部分发送，文件名为 "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.BetaFileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// 来自字符串的文件
anthropic.BetaFileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}

文件名和内容类型也可以通过在 io.Reader 的运行时类型上实现 Name() string 或 ContentType() string 来自定义。请注意，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.Printf("%+v\n", messageBatch)
}
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.Printf("%+v\n", batch)
	}
	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 客户端自定义

中间件

SDK 提供 option.WithMiddleware，用于将给定的中间件应用于请求。

package main

import (
	"net/http"
	"time"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

var _ = anthropic.ModelClaudeOpus4_7

func LogReq(req *http.Request)                              {}
func LogRes(res *http.Response, err error, d time.Duration) {}

func main() {
	client := anthropic.NewClient(
		option.WithMiddleware(func(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
			// 请求之前
			start := time.Now()
			LogReq(req)

			// 将请求转发给下一个处理器
			res, err = next(req)

			// 请求之后处理
			LogRes(res, err, time.Since(start))

			return res, err
		}),
	)
	_ = client
}

当提供多个中间件作为可变参数时，中间件从左到右应用。如果 option.WithMiddleware 被多次提供（例如先在客户端中，然后在方法中），客户端中的中间件将先运行，方法中给出的中间件将随后运行。

你也可以使用 option.WithHTTPClient(client) 替换默认的 http.Client。只接受一个 http 客户端（这会覆盖之前的任何客户端），并在应用任何中间件后接收请求。

平台集成

Note

有关带有代码示例的详细平台设置指南，请参阅：

Go SDK 支持以下平台：

Bedrock： import "github.com/anthropics/anthropic-sdk-go/bedrock"。使用 bedrock.NewMantleClient 访问 Messages-API Bedrock 端点（通过 SSE 流式传输），或使用 bedrock.WithLoadDefaultConfig(ctx) / bedrock.WithConfig(cfg)（bedrock-runtime 路径）。导入 bedrock 包会全局注册 application/vnd.amazon.eventstream 解码器到 SDK 的流式传输层（通过包 init()）。无论你使用 bedrock-runtime 的 WithConfig/WithLoadDefaultConfig 路径还是 NewMantleClient，这都适用。
Vertex AI： import "github.com/anthropics/anthropic-sdk-go/vertex"。使用 vertex.WithGoogleAuth(ctx, region, projectID) 或 vertex.WithCredentials(ctx, region, projectID, creds)。
Foundry： Go SDK 目前不支持。有关支持的 SDK，请参阅 Claude in Microsoft Foundry。
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 同时导入时的名称冲突。目前处于测试阶段。

新项目请使用 bedrock.NewMantleClient；bedrock.WithLoadDefaultConfig/WithConfig 保留给使用 Bedrock InvokeModel API 的现有应用程序。

高级用法

访问原始响应数据（例如响应头）

你可以使用 option.WithResponseInto() 请求选项访问原始 HTTP 响应数据。当你需要检查响应头、状态码或其他详细信息时，这很有用。

package main

import (
	"context"
	"fmt"
	"net/http"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	client := anthropic.NewClient()
	// 创建一个变量来存储 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.ModelClaudeOpus4_7,
		},
		option.WithResponseInto(&response),
	)
	if err != nil {
		// 处理错误
	}
	fmt.Printf("%+v\n", message)

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

发送自定义/未文档化的请求

此库针对已文档化 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"))

未文档化的响应属性

要访问未文档化的响应属性，你可以使用 result.JSON.RawJSON() 将响应的原始 JSON 作为字符串访问，或使用 result.JSON.Foo.Raw() 获取结果上特定字段的原始 JSON。

任何不在响应结构体上的字段都会被保存，可以通过 result.JSON.ExtraFields 访问，这是一个 map[string]respjson.Field。

语义化版本控制

此包通常遵循 SemVer 约定，但某些不向后兼容的更改可能作为次要版本发布：

对库内部的更改，这些更改在技术上是公开的，但不打算或不对外部使用进行文档化。
在实践中预计不会影响绝大多数用户的更改。

向后兼容性被认真对待，以确保你可以依赖平稳的升级体验。

欢迎你的反馈；如有问题、错误或建议，请提交 issue。

Go SDK

安装

要求

用法

请求字段

请求联合类型

反序列化参数

响应对象

响应联合类型

错误处理

重试

超时

长请求

文件上传

分页

RequestOptions

HTTP 客户端自定义

中间件

平台集成

高级用法

访问原始响应数据（例如响应头）

发送自定义/未文档化的请求

未文档化的端点

未文档化的请求参数

未文档化的响应属性

语义化版本控制

附加资源