Ruby SDK

Installiere und konfiguriere das Anthropic Ruby SDK mit Sorbet-Typen, Streaming-Helpern und Connection-Pooling

Die Anthropic Ruby-Bibliothek bietet bequemen Zugriff auf die Anthropic REST API aus jeder Ruby 3.2.0+ Anwendung. Sie wird mit umfassenden Typen und Docstrings in Yard, RBS und RBI ausgeliefert. Als HTTP-Transport wird net/http aus der Standardbibliothek verwendet, mit Connection-Pooling über das connection_pool-Gem.

Installation

Füge das Gem mit Bundler zur Gemfile deiner Anwendung hinzu:

bundle add anthropic

Anforderungen

Ruby 3.2.0 oder höher.

Verwendung

anthropic = Anthropic::Client.new(
  api_key: ENV["ANTHROPIC_API_KEY"] # This is the default and can be omitted
)

message = anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

message.content.each do |block|
  puts block.text if block.type == :text
end

Für Authentifizierungsoptionen einschließlich Workload Identity Federation siehe Authentifizierung.

Streaming

Das SDK bietet Unterstützung für Streaming-Antworten mittels Server-Sent Events (SSE).

anthropic = Anthropic::Client.new
stream = anthropic.messages.stream(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

stream.each do |message|
  puts(message.type)
end

Streaming-Helper

Diese Bibliothek bietet mehrere Hilfsfunktionen für das Streaming von Nachrichten, zum Beispiel:

anthropic = Anthropic::Client.new
stream = anthropic.messages.stream(
  max_tokens: 1024,
  messages: [{role: :user, content: "Say hello there!"}],
  model: :"claude-opus-5"
)

stream.text.each do |text|
  print(text)
end

Streaming mit anthropic.messages.stream(...) stellt verschiedene Helper bereit, einschließlich Akkumulation und SDK-spezifischer Events.

Input-Schema und Tool-Aufrufe

Das SDK bietet Hilfsmechanismen, um strukturierte Datenklassen für Tools zu definieren und Claude diese automatisch ausführen zu lassen. Für detaillierte Dokumentation zu Tool-Nutzungs-Mustern einschließlich des Tool-Runners siehe Tool Runner (SDK).

anthropic = Anthropic::Client.new
class CalculatorInput < Anthropic::BaseModel
  required :lhs, Float
  required :rhs, Float
  required :operator, Anthropic::InputSchema::EnumOf[:+, :-, :*, :/]
end

class Calculator < Anthropic::BaseTool
  input_schema CalculatorInput

  def call(expr)
    expr.lhs.public_send(expr.operator, expr.rhs)
  end
end

# Verarbeitet die Tool-Ausführungsschleife automatisch
anthropic.beta.messages.tool_runner(
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "What's 15 * 7?"}],
  tools: [Calculator.new]
).each_message { |message| puts message.content }

Strukturierte Ausgaben

Für die vollständige Dokumentation zu strukturierten Ausgaben einschließlich Ruby-Beispielen siehe Strukturierte Ausgaben.

Fehlerbehandlung

Wenn die Bibliothek keine Verbindung zur API herstellen kann oder wenn die API einen Nicht-Erfolgs-Statuscode zurückgibt (also eine 4xx- oder 5xx-Antwort), wird eine Unterklasse von Anthropic::Errors::APIError ausgelöst:

anthropic = Anthropic::Client.new
begin
  message = anthropic.messages.create(
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Claude"}],
    model: :"claude-opus-5"
  )
rescue Anthropic::Errors::APIConnectionError => e
  puts("The server could not be reached")
  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
rescue Anthropic::Errors::RateLimitError => e
  puts("A 429 status code was received; we should back off a bit.")
rescue Anthropic::Errors::APIStatusError => e
  puts("Another non-200-range status code was received")
  puts(e.status)
end

Die Fehlercodes sind wie folgt:

Ursache	Fehlertyp
HTTP 400	`BadRequestError`
HTTP 401	`AuthenticationError`
HTTP 403	`PermissionDeniedError`
HTTP 404	`NotFoundError`
HTTP 409	`ConflictError`
HTTP 422	`UnprocessableEntityError`
HTTP 429	`RateLimitError`
HTTP >= 500	`InternalServerError`
Anderer HTTP-Fehler	`APIStatusError`
Timeout	`APITimeoutError`
Netzwerkfehler	`APIConnectionError`

Wiederholungsversuche

Bestimmte Fehler werden standardmäßig automatisch 2-mal wiederholt, mit einem kurzen exponentiellen Backoff.

Verbindungsfehler (zum Beispiel aufgrund eines Netzwerkverbindungsproblems), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal-Fehler und Timeouts werden standardmäßig alle wiederholt.

Du kannst die Option max_retries verwenden, um dies zu konfigurieren oder zu deaktivieren:

# Konfiguriere den Standard für alle Anfragen:
anthropic = Anthropic::Client.new(
  max_retries: 0 # default is 2
)

# Oder konfiguriere pro Anfrage:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5",
  request_options: {max_retries: 5}
)

Timeouts

Standardmäßig laufen Anfragen nach 10 Minuten ab. Du kannst die Option timeout verwenden, um dies zu konfigurieren:

# Konfiguriere den Standard für alle Anfragen:
anthropic = Anthropic::Client.new(
  timeout: 20 # 20 seconds (default is 10 minutes)
)

# Oder konfiguriere pro Anfrage:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5",
  request_options: {timeout: 5}
)

Bei einem Timeout wird Anthropic::Errors::APITimeoutError ausgelöst.

Beachte, dass Anfragen, die ablaufen, standardmäßig wiederholt werden.

Paginierung

List-Methoden in der Claude API sind paginiert.

Diese Bibliothek stellt automatisch paginierende Iteratoren mit jeder List-Antwort bereit, sodass du aufeinanderfolgende Seiten nicht manuell anfordern musst:

anthropic = Anthropic::Client.new
page = anthropic.messages.batches.list(limit: 20)

# Rufe ein einzelnes Element von der Seite ab.
batch = page.data[0]
puts(batch.id)

# Ruft bei Bedarf automatisch weitere Seiten ab.
page.auto_paging_each do |batch|
  puts(batch.id)
end

Alternativ kannst du die Methoden #next_page? und #next_page für eine feinere Kontrolle bei der Arbeit mit Seiten verwenden.

anthropic = Anthropic::Client.new
page = anthropic.messages.batches.list(limit: 20)
loop do
  page.data&.each { |batch| puts(batch.id) }
  break unless page.next_page?
  page = page.next_page
end

Datei-Uploads

Request-Parameter, die Datei-Uploads entsprechen, können als Rohinhalte, als Pathname-Instanz, StringIO oder mehr übergeben werden.

anthropic = Anthropic::Client.new
require "pathname"

# Verwende `Pathname`, um den Dateinamen zu senden und/oder zu vermeiden, eine große Datei in den Speicher zu laden:
file_metadata = anthropic.beta.files.upload(file: Pathname("/path/to/file"))

# Alternativ kannst du Dateiinhalte oder ein `StringIO` direkt übergeben:
file_metadata = anthropic.beta.files.upload(file: File.read("/path/to/file"))

# Oder, um den Dateinamen und/oder den Content-Type zu steuern:
file = Anthropic::FilePart.new(File.read("/path/to/file"), filename: "/path/to/file", content_type: "...")
file_metadata = anthropic.beta.files.upload(file: file)

puts(file_metadata.id)

Beachte, dass du auch einen rohen IO-Deskriptor übergeben kannst, dies deaktiviert jedoch Wiederholungsversuche, da die Bibliothek nicht sicher sein kann, ob der Deskriptor eine Datei oder eine Pipe ist (die nicht zurückgespult werden kann).

Sorbet

Diese Bibliothek bietet umfassende RBI-Definitionen und hat keine Abhängigkeit von sorbet-runtime.

Du kannst typsichere Request-Parameter wie folgt bereitstellen:

anthropic = Anthropic::Client.new
anthropic.messages.create(
  max_tokens: 1024,
  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
  model: :"claude-opus-5"
)

Oder, äquivalent:

anthropic = Anthropic::Client.new
# Hashes funktionieren, sind aber nicht typsicher:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

# Du kannst auch eine vollständige Params-Klasse per Splat übergeben:
params = Anthropic::MessageCreateParams.new(
  max_tokens: 1024,
  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
  model: :"claude-opus-5"
)
anthropic.messages.create(**params)

Enums

Da diese Bibliothek nicht von sorbet-runtime abhängt, kann sie keine T::Enum-Instanzen bereitstellen. Stattdessen bietet das SDK „tagged symbols", die zur Laufzeit immer ein Primitiv sind:

# :auto
puts(Anthropic::MessageCreateParams::ServiceTier::AUTO)

# Ermittelter Typ: `T.all(Anthropic::MessageCreateParams::ServiceTier, Symbol)`
T.reveal_type(Anthropic::MessageCreateParams::ServiceTier::AUTO)

Enum-Parameter haben einen „relaxed" Typ, sodass du entweder Enum-Konstanten oder deren Literalwert übergeben kannst:

# Die Verwendung der Enum-Konstanten bewahrt die getaggten Typinformationen:
anthropic.messages.create(
  service_tier: Anthropic::MessageCreateParams::ServiceTier::AUTO,
  # ...
)

# Literalwerte sind ebenfalls zulässig:
anthropic.messages.create(
  service_tier: :auto,
  # ...
)

BaseModel

Alle Parameter- und Response-Objekte erben von Anthropic::Internal::Type::BaseModel, was mehrere Annehmlichkeiten bietet, darunter:

Alle Felder, einschließlich unbekannter, sind mit der obj[:prop]-Syntax zugänglich und können mit obj => {prop: prop} oder Pattern-Matching-Syntax destrukturiert werden.
Strukturelle Äquivalenz für Gleichheit; wenn zwei API-Aufrufe dieselben Werte zurückgeben, gibt der Vergleich der Antworten mit == true zurück.
Sowohl Instanzen als auch die Klassen selbst können mit Pretty-Print ausgegeben werden.
Helper wie #to_h, #deep_to_h, #to_json und #to_yaml.

Nebenläufigkeit und Connection-Pooling

Die Anthropic::Client-Instanzen sind threadsicher, aber nur fork-sicher, wenn keine laufenden HTTP-Anfragen vorhanden sind.

Jede Instanz von Anthropic::Client hat ihren eigenen HTTP-Connection-Pool mit einer Standardgröße von 99. Daher wird empfohlen, den Client in den meisten Fällen einmal pro Anwendung zu erstellen.

Wenn alle verfügbaren Verbindungen aus dem Pool ausgecheckt sind, warten Anfragen darauf, dass eine neue Verbindung verfügbar wird, wobei die Wartezeit in der Queue zum Request-Timeout zählt.

Sofern nicht anders angegeben, haben andere Klassen im SDK keine Locks, die ihre zugrunde liegende Datenstruktur schützen.

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Du kannst undokumentierte Parameter an jeden Endpunkt senden und undokumentierte Response-Eigenschaften lesen, wie folgt:

anthropic = Anthropic::Client.new
value = "example"
message =
  anthropic.messages.create(
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Claude"}],
    model: :"claude-opus-5",
    request_options: {
      extra_query: {my_query_parameter: value},
      extra_body: {my_body_parameter: value},
      extra_headers: {"my-header": value}
    }
  )

puts(message[:my_undocumented_property])

Undokumentierte Request-Parameter

Wenn du explizit einen zusätzlichen Parameter senden möchtest, kannst du dies mit extra_query, extra_body und extra_headers unter dem request_options:-Parameter beim Stellen einer Anfrage tun, wie in den obigen Beispielen gezeigt.

Undokumentierte Endpunkte

Um Anfragen an undokumentierte Endpunkte zu stellen und dabei die Vorteile von Authentifizierung, Wiederholungsversuchen usw. zu behalten, kannst du Anfragen mit anthropic.request stellen, wie folgt:

response = anthropic.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)

Plattform-Integrationen

Das Ruby SDK unterstützt die folgenden Plattformen:

Agent Platform: Anthropic::VertexClient. Erfordert das googleauth-Gem.
Bedrock: Anthropic::BedrockMantleClient, oder Anthropic::BedrockClient für den bedrock-runtime-Pfad. Anthropic::BedrockMantleClient erfordert das aws-sdk-core-Gem; Anthropic::BedrockClient erfordert das aws-sdk-bedrockruntime-Gem.
Claude Platform auf AWS: Teil des Haupt-anthropic-Gems (erfordert das aws-sdk-core-Gem). Stellt Anthropic::AWSClient bereit. Übergib workspace_id: an den Konstruktor oder setze die Umgebungsvariable ANTHROPIC_AWS_WORKSPACE_ID (siehe Workspaces). Als Beta verfügbar.
Foundry: Wird derzeit im Ruby SDK nicht unterstützt. Siehe Claude in Microsoft Foundry für unterstützte SDKs.

Verwende Anthropic::BedrockMantleClient für neue Projekte; Anthropic::BedrockClient bleibt für bestehende Anwendungen erhalten, die die Bedrock InvokeModel API verwenden.

Semantische Versionierung

Dieses Paket folgt den SemVer-Konventionen.

Dieses Paket betrachtet Verbesserungen an den (Nicht-Laufzeit-) *.rbi- und *.rbs-Typdefinitionen als nicht-breaking Änderungen.

Zusätzliche Ressourcen

Was this page helpful?

CLI, SDKs und BibliothekenClient-SDKs

Ruby SDK

Installiere und konfiguriere das Anthropic Ruby SDK mit Sorbet-Typen, Streaming-Helpern und Connection-Pooling

Installation

Füge das Gem mit Bundler zur Gemfile deiner Anwendung hinzu:

bundle add anthropic

Anforderungen

Ruby 3.2.0 oder höher.

Verwendung

anthropic = Anthropic::Client.new(
  api_key: ENV["ANTHROPIC_API_KEY"] # This is the default and can be omitted
)

message = anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

message.content.each do |block|
  puts block.text if block.type == :text
end

Für Authentifizierungsoptionen einschließlich Workload Identity Federation siehe Authentifizierung.

Streaming

Das SDK bietet Unterstützung für Streaming-Antworten mittels Server-Sent Events (SSE).

anthropic = Anthropic::Client.new
stream = anthropic.messages.stream(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

stream.each do |message|
  puts(message.type)
end

Streaming-Helper

Diese Bibliothek bietet mehrere Hilfsfunktionen für das Streaming von Nachrichten, zum Beispiel:

anthropic = Anthropic::Client.new
stream = anthropic.messages.stream(
  max_tokens: 1024,
  messages: [{role: :user, content: "Say hello there!"}],
  model: :"claude-opus-5"
)

stream.text.each do |text|
  print(text)
end

Streaming mit anthropic.messages.stream(...) stellt verschiedene Helper bereit, einschließlich Akkumulation und SDK-spezifischer Events.

Input-Schema und Tool-Aufrufe

anthropic = Anthropic::Client.new
class CalculatorInput < Anthropic::BaseModel
  required :lhs, Float
  required :rhs, Float
  required :operator, Anthropic::InputSchema::EnumOf[:+, :-, :*, :/]
end

class Calculator < Anthropic::BaseTool
  input_schema CalculatorInput

  def call(expr)
    expr.lhs.public_send(expr.operator, expr.rhs)
  end
end

# Verarbeitet die Tool-Ausführungsschleife automatisch
anthropic.beta.messages.tool_runner(
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [{role: "user", content: "What's 15 * 7?"}],
  tools: [Calculator.new]
).each_message { |message| puts message.content }

Strukturierte Ausgaben

Für die vollständige Dokumentation zu strukturierten Ausgaben einschließlich Ruby-Beispielen siehe Strukturierte Ausgaben.

Fehlerbehandlung

anthropic = Anthropic::Client.new
begin
  message = anthropic.messages.create(
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Claude"}],
    model: :"claude-opus-5"
  )
rescue Anthropic::Errors::APIConnectionError => e
  puts("The server could not be reached")
  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
rescue Anthropic::Errors::RateLimitError => e
  puts("A 429 status code was received; we should back off a bit.")
rescue Anthropic::Errors::APIStatusError => e
  puts("Another non-200-range status code was received")
  puts(e.status)
end

Die Fehlercodes sind wie folgt:

Ursache	Fehlertyp
HTTP 400	`BadRequestError`
HTTP 401	`AuthenticationError`
HTTP 403	`PermissionDeniedError`
HTTP 404	`NotFoundError`
HTTP 409	`ConflictError`
HTTP 422	`UnprocessableEntityError`
HTTP 429	`RateLimitError`
HTTP >= 500	`InternalServerError`
Anderer HTTP-Fehler	`APIStatusError`
Timeout	`APITimeoutError`
Netzwerkfehler	`APIConnectionError`

Wiederholungsversuche

Bestimmte Fehler werden standardmäßig automatisch 2-mal wiederholt, mit einem kurzen exponentiellen Backoff.

Du kannst die Option max_retries verwenden, um dies zu konfigurieren oder zu deaktivieren:

# Konfiguriere den Standard für alle Anfragen:
anthropic = Anthropic::Client.new(
  max_retries: 0 # default is 2
)

# Oder konfiguriere pro Anfrage:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5",
  request_options: {max_retries: 5}
)

Timeouts

Standardmäßig laufen Anfragen nach 10 Minuten ab. Du kannst die Option timeout verwenden, um dies zu konfigurieren:

# Konfiguriere den Standard für alle Anfragen:
anthropic = Anthropic::Client.new(
  timeout: 20 # 20 seconds (default is 10 minutes)
)

# Oder konfiguriere pro Anfrage:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5",
  request_options: {timeout: 5}
)

Bei einem Timeout wird Anthropic::Errors::APITimeoutError ausgelöst.

Beachte, dass Anfragen, die ablaufen, standardmäßig wiederholt werden.

Paginierung

List-Methoden in der Claude API sind paginiert.

Diese Bibliothek stellt automatisch paginierende Iteratoren mit jeder List-Antwort bereit, sodass du aufeinanderfolgende Seiten nicht manuell anfordern musst:

anthropic = Anthropic::Client.new
page = anthropic.messages.batches.list(limit: 20)

# Rufe ein einzelnes Element von der Seite ab.
batch = page.data[0]
puts(batch.id)

# Ruft bei Bedarf automatisch weitere Seiten ab.
page.auto_paging_each do |batch|
  puts(batch.id)
end

Alternativ kannst du die Methoden #next_page? und #next_page für eine feinere Kontrolle bei der Arbeit mit Seiten verwenden.

anthropic = Anthropic::Client.new
page = anthropic.messages.batches.list(limit: 20)
loop do
  page.data&.each { |batch| puts(batch.id) }
  break unless page.next_page?
  page = page.next_page
end

Datei-Uploads

Request-Parameter, die Datei-Uploads entsprechen, können als Rohinhalte, als Pathname-Instanz, StringIO oder mehr übergeben werden.

anthropic = Anthropic::Client.new
require "pathname"

# Verwende `Pathname`, um den Dateinamen zu senden und/oder zu vermeiden, eine große Datei in den Speicher zu laden:
file_metadata = anthropic.beta.files.upload(file: Pathname("/path/to/file"))

# Alternativ kannst du Dateiinhalte oder ein `StringIO` direkt übergeben:
file_metadata = anthropic.beta.files.upload(file: File.read("/path/to/file"))

# Oder, um den Dateinamen und/oder den Content-Type zu steuern:
file = Anthropic::FilePart.new(File.read("/path/to/file"), filename: "/path/to/file", content_type: "...")
file_metadata = anthropic.beta.files.upload(file: file)

puts(file_metadata.id)

Sorbet

Diese Bibliothek bietet umfassende RBI-Definitionen und hat keine Abhängigkeit von sorbet-runtime.

Du kannst typsichere Request-Parameter wie folgt bereitstellen:

anthropic = Anthropic::Client.new
anthropic.messages.create(
  max_tokens: 1024,
  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
  model: :"claude-opus-5"
)

Oder, äquivalent:

anthropic = Anthropic::Client.new
# Hashes funktionieren, sind aber nicht typsicher:
anthropic.messages.create(
  max_tokens: 1024,
  messages: [{role: "user", content: "Hello, Claude"}],
  model: :"claude-opus-5"
)

# Du kannst auch eine vollständige Params-Klasse per Splat übergeben:
params = Anthropic::MessageCreateParams.new(
  max_tokens: 1024,
  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
  model: :"claude-opus-5"
)
anthropic.messages.create(**params)

Enums

Da diese Bibliothek nicht von sorbet-runtime abhängt, kann sie keine T::Enum-Instanzen bereitstellen. Stattdessen bietet das SDK „tagged symbols", die zur Laufzeit immer ein Primitiv sind:

# :auto
puts(Anthropic::MessageCreateParams::ServiceTier::AUTO)

# Ermittelter Typ: `T.all(Anthropic::MessageCreateParams::ServiceTier, Symbol)`
T.reveal_type(Anthropic::MessageCreateParams::ServiceTier::AUTO)

Enum-Parameter haben einen „relaxed" Typ, sodass du entweder Enum-Konstanten oder deren Literalwert übergeben kannst:

# Die Verwendung der Enum-Konstanten bewahrt die getaggten Typinformationen:
anthropic.messages.create(
  service_tier: Anthropic::MessageCreateParams::ServiceTier::AUTO,
  # ...
)

# Literalwerte sind ebenfalls zulässig:
anthropic.messages.create(
  service_tier: :auto,
  # ...
)

BaseModel

Alle Parameter- und Response-Objekte erben von Anthropic::Internal::Type::BaseModel, was mehrere Annehmlichkeiten bietet, darunter:

Alle Felder, einschließlich unbekannter, sind mit der obj[:prop]-Syntax zugänglich und können mit obj => {prop: prop} oder Pattern-Matching-Syntax destrukturiert werden.
Strukturelle Äquivalenz für Gleichheit; wenn zwei API-Aufrufe dieselben Werte zurückgeben, gibt der Vergleich der Antworten mit == true zurück.
Sowohl Instanzen als auch die Klassen selbst können mit Pretty-Print ausgegeben werden.
Helper wie #to_h, #deep_to_h, #to_json und #to_yaml.

Nebenläufigkeit und Connection-Pooling

Die Anthropic::Client-Instanzen sind threadsicher, aber nur fork-sicher, wenn keine laufenden HTTP-Anfragen vorhanden sind.

Wenn alle verfügbaren Verbindungen aus dem Pool ausgecheckt sind, warten Anfragen darauf, dass eine neue Verbindung verfügbar wird, wobei die Wartezeit in der Queue zum Request-Timeout zählt.

Sofern nicht anders angegeben, haben andere Klassen im SDK keine Locks, die ihre zugrunde liegende Datenstruktur schützen.

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Du kannst undokumentierte Parameter an jeden Endpunkt senden und undokumentierte Response-Eigenschaften lesen, wie folgt:

anthropic = Anthropic::Client.new
value = "example"
message =
  anthropic.messages.create(
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Claude"}],
    model: :"claude-opus-5",
    request_options: {
      extra_query: {my_query_parameter: value},
      extra_body: {my_body_parameter: value},
      extra_headers: {"my-header": value}
    }
  )

puts(message[:my_undocumented_property])

Undokumentierte Request-Parameter

Undokumentierte Endpunkte

response = anthropic.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)

Plattform-Integrationen

Das Ruby SDK unterstützt die folgenden Plattformen:

Agent Platform: Anthropic::VertexClient. Erfordert das googleauth-Gem.
Bedrock: Anthropic::BedrockMantleClient, oder Anthropic::BedrockClient für den bedrock-runtime-Pfad. Anthropic::BedrockMantleClient erfordert das aws-sdk-core-Gem; Anthropic::BedrockClient erfordert das aws-sdk-bedrockruntime-Gem.
Claude Platform auf AWS: Teil des Haupt-anthropic-Gems (erfordert das aws-sdk-core-Gem). Stellt Anthropic::AWSClient bereit. Übergib workspace_id: an den Konstruktor oder setze die Umgebungsvariable ANTHROPIC_AWS_WORKSPACE_ID (siehe Workspaces). Als Beta verfügbar.
Foundry: Wird derzeit im Ruby SDK nicht unterstützt. Siehe Claude in Microsoft Foundry für unterstützte SDKs.

Verwende Anthropic::BedrockMantleClient für neue Projekte; Anthropic::BedrockClient bleibt für bestehende Anwendungen erhalten, die die Bedrock InvokeModel API verwenden.

Semantische Versionierung

Dieses Paket folgt den SemVer-Konventionen.

Dieses Paket betrachtet Verbesserungen an den (Nicht-Laufzeit-) *.rbi- und *.rbs-Typdefinitionen als nicht-breaking Änderungen.

Zusätzliche Ressourcen

Was this page helpful?

Installation

Anforderungen

Verwendung

Streaming

Streaming-Helper

Input-Schema und Tool-Aufrufe

Strukturierte Ausgaben

Fehlerbehandlung

Wiederholungsversuche

Timeouts

Paginierung

Datei-Uploads

Sorbet

Enums

BaseModel

Nebenläufigkeit und Connection-Pooling

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Undokumentierte Request-Parameter

Undokumentierte Endpunkte

Plattform-Integrationen

Semantische Versionierung

Zusätzliche Ressourcen

Installation

Anforderungen

Verwendung

Streaming

Streaming-Helper

Input-Schema und Tool-Aufrufe

Strukturierte Ausgaben

Fehlerbehandlung

Wiederholungsversuche

Timeouts

Paginierung

Datei-Uploads

Sorbet

Enums

BaseModel

Nebenläufigkeit und Connection-Pooling

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Undokumentierte Request-Parameter

Undokumentierte Endpunkte

Plattform-Integrationen

Semantische Versionierung

Zusätzliche Ressourcen

Installation

Anforderungen

Verwendung

Streaming

Streaming-Helper

Input-Schema und Tool-Aufrufe

Strukturierte Ausgaben

Fehlerbehandlung

Wiederholungsversuche

Timeouts

Paginierung

Datei-Uploads

Sorbet

Enums

BaseModel

Nebenläufigkeit und Connection-Pooling

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Undokumentierte Request-Parameter

Undokumentierte Endpunkte

Plattform-Integrationen

Semantische Versionierung

Zusätzliche Ressourcen

Installation

Anforderungen

Verwendung

Streaming

Streaming-Helper

Input-Schema und Tool-Aufrufe

Strukturierte Ausgaben

Fehlerbehandlung

Wiederholungsversuche

Timeouts

Paginierung

Datei-Uploads

Sorbet

Enums

BaseModel

Nebenläufigkeit und Connection-Pooling

Benutzerdefinierte oder undokumentierte Anfragen stellen

Undokumentierte Eigenschaften

Undokumentierte Request-Parameter

Undokumentierte Endpunkte

Plattform-Integrationen

Semantische Versionierung

Zusätzliche Ressourcen