인용

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
messages:
  - role: user
    content:
      - type: document
        source:
          type: text
          media_type: text/plain
          data: The grass is green. The sky is blue.
        title: My Document
        context: This is a trustworthy document.
        citations:
          enabled: true
      - type: text
        text: What color is the grass and sky?
YAML

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "text",
                        "media_type": "text/plain",
                        "data": "The grass is green. The sky is blue.",
                    },
                    "title": "My Document",
                    "context": "This is a trustworthy document.",
                    "citations": {"enabled": True},
                },
                {"type": "text", "text": "What color is the grass and sky?"},
            ],
        }
    ],
)
print(response)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "text",
            media_type: "text/plain",
            data: "The grass is green. The sky is blue."
          },
          title: "My Document",
          context: "This is a trustworthy document.",
          citations: { enabled: true }
        },
        {
          type: "text",
          text: "What color is the grass and sky?"
        }
      ]
    }
  ]
});
console.log(response);

var client = new AnthropicClient();

var response = await client.Messages.Create(
    new()
    {
        Model = Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = new MessageParamContent(new List<ContentBlockParam>
                {
                    new ContentBlockParam(new DocumentBlockParam(
                        new DocumentBlockParamSource(new PlainTextSource()
                        {
                            Data = "The grass is green. The sky is blue.",
                        })
                    )
                    {
                        Title = "My Document",
                        Context = "This is a trustworthy document.",
                        Citations = new CitationsConfigParam { Enabled = true },
                    }),
                    new ContentBlockParam(new TextBlockParam("What color is the grass and sky?")),
                }),
            },
        ],
    }
);

Console.WriteLine(response);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(
			anthropic.ContentBlockParamUnion{
				OfDocument: &anthropic.DocumentBlockParam{
					Source: anthropic.DocumentBlockParamSourceUnion{
						OfText: &anthropic.PlainTextSourceParam{
							Data: "The grass is green. The sky is blue.",
						},
					},
					Title:     anthropic.String("My Document"),
					Context:   anthropic.String("This is a trustworthy document."),
					Citations: anthropic.CitationsConfigParam{Enabled: anthropic.Bool(true)},
				},
			},
			anthropic.NewTextBlock("What color is the grass and sky?"),
		),
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

PlainTextSource source = PlainTextSource.builder()
    .data("The grass is green. The sky is blue.")
    .build();

DocumentBlockParam documentParam = DocumentBlockParam.builder()
    .source(source)
    .title("My Document")
    .context("This is a trustworthy document.")
    .citations(CitationsConfigParam.builder().enabled(true).build())
    .build();

TextBlockParam textBlockParam = TextBlockParam.builder()
    .text("What color is the grass and sky?")
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
        List.of(
            ContentBlockParam.ofDocument(documentParam),
            ContentBlockParam.ofText(textBlockParam)
        )
    )
    .build();

Message message = client.messages().create(params);
System.out.println(message);

$client = new Client();

$response = $client->messages->create(
    maxTokens: 1024,
    messages: [
        [
            'role' => 'user',
            'content' => [
                [
                    'type' => 'document',
                    'source' => [
                        'type' => 'text',
                        'media_type' => 'text/plain',
                        'data' => 'The grass is green. The sky is blue.',
                    ],
                    'title' => 'My Document',
                    'context' => 'This is a trustworthy document.',
                    'citations' => ['enabled' => true],
                ],
                [
                    'type' => 'text',
                    'text' => 'What color is the grass and sky?',
                ],
            ],
        ],
    ],
    model: 'claude-opus-5-5',
);

echo json_encode($response, JSON_PRETTY_PRINT);

client = Anthropic::Client.new

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "text",
            media_type: "text/plain",
            data: "The grass is green. The sky is blue."
          },
          title: "My Document",
          context: "This is a trustworthy document.",
          citations: { enabled: true }
        },
        {
          type: "text",
          text: "What color is the grass and sky?"
        }
      ]
    }
  ]
)

puts response

ant messages create --model claude-opus-5-5 --max-tokens 1024 <<'YAML'
messages:
  - role: user
    content:
      - type: document
        source:
          type: text
          media_type: text/plain
          data: This is a very long document with thousands of words...
        citations:
          enabled: true
        cache_control:
          type: ephemeral
      - type: text
        text: What does this document say about API features?
YAML

client = anthropic.Anthropic()

# Long document content (for example, technical documentation)
long_document = (
    "This is a very long document with thousands of words..." + " ... " * 1000
)  # Minimum cacheable length

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "text",
                        "media_type": "text/plain",
                        "data": long_document,
                    },
                    "citations": {"enabled": True},
                    "cache_control": {
                        "type": "ephemeral"
                    },  # Cache the document content
                },
                {
                    "type": "text",
                    "text": "What does this document say about API features?",
                },
            ],
        }
    ],
)
print(response)

const client = new Anthropic();

// Long document content (for example, technical documentation)
const longDocument =
  "This is a very long document with thousands of words..." + " ... ".repeat(1000); // Minimum cacheable length

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "text",
            media_type: "text/plain",
            data: longDocument
          },
          citations: { enabled: true },
          cache_control: { type: "ephemeral" } // Cache the document content
        },
        {
          type: "text",
          text: "What does this document say about API features?"
        }
      ]
    }
  ]
});
console.log(response);

var client = new AnthropicClient();

// Long document content (for example, technical documentation)
var longDocument =
    "This is a very long document with thousands of words..."
    + string.Concat(Enumerable.Repeat(" ... ", 1000)); // Minimum cacheable length

var response = await client.Messages.Create(
    new()
    {
        Model = Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = new MessageParamContent(new List<ContentBlockParam>
                {
                    new ContentBlockParam(new DocumentBlockParam(
                        new DocumentBlockParamSource(new PlainTextSource() { Data = longDocument })
                    )
                    {
                        Citations = new CitationsConfigParam { Enabled = true },
                        CacheControl = new CacheControlEphemeral(), // Cache the document content
                    }),
                    new ContentBlockParam(new TextBlockParam("What does this document say about API features?")),
                }),
            },
        ],
    }
);

Console.WriteLine(response);

client := anthropic.NewClient()

// Long document content (for example, technical documentation)
longDocument := "This is a very long document with thousands of words..." +
	strings.Repeat(" ... ", 1000) // Minimum cacheable length

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(
			anthropic.ContentBlockParamUnion{
				OfDocument: &anthropic.DocumentBlockParam{
					Source: anthropic.DocumentBlockParamSourceUnion{
						OfText: &anthropic.PlainTextSourceParam{Data: longDocument},
					},
					Citations:    anthropic.CitationsConfigParam{Enabled: anthropic.Bool(true)},
					CacheControl: anthropic.NewCacheControlEphemeralParam(), // Cache the document content
				},
			},
			anthropic.NewTextBlock("What does this document say about API features?"),
		),
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

// Long document content (for example, technical documentation)
String longDocument =
    "This is a very long document with thousands of words..."
        + " ... ".repeat(1000); // Minimum cacheable length

DocumentBlockParam documentParam = DocumentBlockParam.builder()
    .source(PlainTextSource.builder().data(longDocument).build())
    .citations(CitationsConfigParam.builder().enabled(true).build())
    .cacheControl(CacheControlEphemeral.builder().build()) // Cache the document content
    .build();

TextBlockParam textBlockParam = TextBlockParam.builder()
    .text("What does this document say about API features?")
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
        List.of(
            ContentBlockParam.ofDocument(documentParam),
            ContentBlockParam.ofText(textBlockParam)
        )
    )
    .build();

Message message = client.messages().create(params);
System.out.println(message);

$client = new Client();

// Long document content (for example, technical documentation)
$longDocument =
    'This is a very long document with thousands of words...'
    . str_repeat(' ... ', 1000); // Minimum cacheable length

$response = $client->messages->create(
    maxTokens: 1024,
    messages: [
        [
            'role' => 'user',
            'content' => [
                [
                    'type' => 'document',
                    'source' => [
                        'type' => 'text',
                        'media_type' => 'text/plain',
                        'data' => $longDocument,
                    ],
                    'citations' => ['enabled' => true],
                    'cache_control' => ['type' => 'ephemeral'], // Cache the document content
                ],
                [
                    'type' => 'text',
                    'text' => 'What does this document say about API features?',
                ],
            ],
        ],
    ],
    model: 'claude-opus-5-5',
);

echo json_encode($response, JSON_PRETTY_PRINT);

client = Anthropic::Client.new

# Long document content (for example, technical documentation)
long_document =
  "This is a very long document with thousands of words..." +
  " ... " * 1000 # Minimum cacheable length

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "text",
            media_type: "text/plain",
            data: long_document
          },
          citations: { enabled: true },
          cache_control: { type: "ephemeral" } # Cache the document content
        },
        {
          type: "text",
          text: "What does this document say about API features?"
        }
      ]
    }
  ]
)

puts response

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
messages:
  - role: user
    content:
      - type: document
        source:
          type: content
          content:
            - type: text
              text: First chunk
            - type: text
              text: Second chunk
        title: Document Title
        context: Context about the document that will not be cited from
        citations:
          enabled: true
      - type: text
        text: Summarize this document.
YAML

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "content",
                        "content": [
                            {"type": "text", "text": "First chunk"},
                            {"type": "text", "text": "Second chunk"},
                        ],
                    },
                    "title": "Document Title",
                    "context": "Context about the document that will not be cited from",
                    "citations": {"enabled": True},
                },
                {"type": "text", "text": "Summarize this document."},
            ],
        }
    ],
)
print(response)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "content",
            content: [
              { type: "text", text: "First chunk" },
              { type: "text", text: "Second chunk" }
            ]
          },
          title: "Document Title",
          context: "Context about the document that will not be cited from",
          citations: { enabled: true }
        },
        {
          type: "text",
          text: "Summarize this document."
        }
      ]
    }
  ]
});
console.log(response);

var client = new AnthropicClient();

var response = await client.Messages.Create(
    new()
    {
        Model = Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = new MessageParamContent(new List<ContentBlockParam>
                {
                    new ContentBlockParam(new DocumentBlockParam(
                        new DocumentBlockParamSource(new ContentBlockSource()
                        {
                            Content = new ContentBlockSourceContent(new List<MessageContentBlockSourceContent>
                            {
                                new TextBlockParam("First chunk"),
                                new TextBlockParam("Second chunk"),
                            }),
                        })
                    )
                    {
                        Title = "Document Title",
                        Context = "Context about the document that will not be cited from",
                        Citations = new CitationsConfigParam { Enabled = true },
                    }),
                    new ContentBlockParam(new TextBlockParam("Summarize this document.")),
                }),
            },
        ],
    }
);

Console.WriteLine(response);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(
			anthropic.ContentBlockParamUnion{
				OfDocument: &anthropic.DocumentBlockParam{
					Source: anthropic.DocumentBlockParamSourceUnion{
						OfContent: &anthropic.ContentBlockSourceParam{
							Content: anthropic.ContentBlockSourceContentUnionParam{
								OfContentBlockSourceContent: []anthropic.ContentBlockSourceContentItemUnionParam{
									{OfText: &anthropic.TextBlockParam{Text: "First chunk"}},
									{OfText: &anthropic.TextBlockParam{Text: "Second chunk"}},
								},
							},
						},
					},
					Title:     anthropic.String("Document Title"),
					Context:   anthropic.String("Context about the document that will not be cited from"),
					Citations: anthropic.CitationsConfigParam{Enabled: anthropic.Bool(true)},
				},
			},
			anthropic.NewTextBlock("Summarize this document."),
		),
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

DocumentBlockParam documentParam = DocumentBlockParam.builder()
    .source(ContentBlockSource.builder()
        .contentOfBlockSource(
            List.of(
                ContentBlockSourceContent.ofText(TextBlockParam.builder().text("First chunk").build()),
                ContentBlockSourceContent.ofText(TextBlockParam.builder().text("Second chunk").build())
            )
        )
        .build())
    .title("Document Title")
    .context("Context about the document that will not be cited from")
    .citations(CitationsConfigParam.builder().enabled(true).build())
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
        List.of(
            ContentBlockParam.ofDocument(documentParam),
            ContentBlockParam.ofText(TextBlockParam.builder().text("Summarize this document.").build())
        )
    )
    .build();

Message message = client.messages().create(params);
System.out.println(message);

$client = new Client();

$response = $client->messages->create(
    maxTokens: 1024,
    messages: [
        [
            'role' => 'user',
            'content' => [
                [
                    'type' => 'document',
                    'source' => [
                        'type' => 'content',
                        'content' => [
                            ['type' => 'text', 'text' => 'First chunk'],
                            ['type' => 'text', 'text' => 'Second chunk'],
                        ],
                    ],
                    'title' => 'Document Title',
                    'context' => 'Context about the document that will not be cited from',
                    'citations' => ['enabled' => true],
                ],
                [
                    'type' => 'text',
                    'text' => 'Summarize this document.',
                ],
            ],
        ],
    ],
    model: 'claude-opus-5-5',
);

echo json_encode($response, JSON_PRETTY_PRINT);

client = Anthropic::Client.new

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "document",
          source: {
            type: "content",
            content: [
              { type: "text", text: "First chunk" },
              { type: "text", text: "Second chunk" }
            ]
          },
          title: "Document Title",
          context: "Context about the document that will not be cited from",
          citations: { enabled: true }
        },
        {
          type: "text",
          text: "Summarize this document."
        }
      ]
    }
  ]
)

puts response