TypeScript SDK

Diese Bibliothek bietet bequemen Zugriff auf die Anthropic REST API von TypeScript oder JavaScript aus.

Installation

npm install @anthropic-ai/sdk

Anforderungen

TypeScript >= 4.9 wird unterstützt.

Die folgenden Laufzeitumgebungen werden unterstützt:

• Node.js 20 LTS oder neuere (non-EOL) Versionen.
• Deno v1.28.0 oder höher.
• Bun 1.0 oder neuer.
• Cloudflare Workers.
• Vercel Edge Runtime.
• Jest 28 oder höher mit der "node"-Umgebung ("jsdom" wird derzeit nicht unterstützt).
• Nitro v2.6 oder höher.
• Webbrowser: standardmäßig deaktiviert, um zu vermeiden, dass deine geheimen API-Anmeldedaten offengelegt werden (siehe Best Practices für API-Keys). Aktiviere die Browser-Unterstützung, indem du dangerouslyAllowBrowser explizit auf true setzt.

Beachte, dass React Native derzeit nicht unterstützt wird.

Wenn du an anderen Laufzeitumgebungen interessiert bist, öffne oder unterstütze ein Issue auf GitHub.

Verwendung

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-4-8"
});

console.log(message.content);

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

Request- und Response-Typen

Diese Bibliothek enthält TypeScript-Definitionen für alle Request-Parameter und Response-Felder. Du kannst sie wie folgt importieren und verwenden:

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const params: Anthropic.MessageCreateParams = {
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-4-8"
};
const message: Anthropic.Message = await client.messages.create(params);

Dokumentation für jede Methode, jeden Request-Parameter und jedes Response-Feld ist in Docstrings verfügbar und wird in den meisten modernen Editoren beim Hovern angezeigt.

Token zählen

Du kannst die genaue Nutzung für eine bestimmte Anfrage über die usage-Response-Eigenschaft einsehen, z. B.

const message = await client.messages.create(/* ... */);
console.log(message.usage);
// { input_tokens: 25, output_tokens: 13 }

Streaming-Antworten

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

const client = new Anthropic();

const stream = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-4-8",
  stream: true
});
for await (const messageStreamEvent of stream) {
  console.log(messageStreamEvent.type);
}

Wenn du einen Stream abbrechen musst, kannst du mit break aus der Schleife ausbrechen oder stream.controller.abort() aufrufen.

Streaming-Helfer

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

const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Say hello there!"
      }
    ]
  })
  .on("text", (text) => {
    console.log(text);
  });

const message = await stream.finalMessage();
console.log(message);

Streaming mit client.messages.stream(...) stellt verschiedene Helfer zur Verfügung, darunter Event-Handler und Akkumulation.

Alternativ kannst du client.messages.create({ ..., stream: true }) verwenden, was nur ein asynchrones Iterable der Events im Stream zurückgibt und daher weniger Speicher verbraucht (es baut kein finales Message-Objekt für dich auf).

Tool-Helfer

Dieses SDK bietet Helfer, die es einfach machen, Tools in der Messages API zu erstellen und auszuführen. Du kannst Zod-Schemas oder JSON-Schemas verwenden, um die Eingabe für ein Tool zu beschreiben. Anschließend kannst du diese Tools mit der Methode client.beta.messages.toolRunner() ausführen. Diese Methode kümmert sich darum, die vom gewählten Modell generierten Eingaben an das richtige Tool zu übergeben und das Ergebnis an das Modell zurückzugeben.

Weitere Details zur Tool-Nutzung findest du unter Tool-Nutzung mit Claude.

import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const weatherTool = betaZodTool({
  name: "get_weather",
  inputSchema: z.object({
    location: z.string()
  }),
  description: "Get the current weather in a given location",
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  }
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-4-8",
  max_tokens: 1000,
  messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
  tools: [weatherTool]
});

console.log(finalMessage.content);

Tool-Fehler

Um einen Fehler von einem Tool an das Modell zurückzumelden, wirf einen ToolError aus der run-Funktion. Im Gegensatz zu einem einfachen Error akzeptiert ToolError Content-Blöcke, sodass du Bilder oder andere strukturierte Inhalte in die Fehlerantwort einfügen kannst:

import { ToolError } from "@anthropic-ai/sdk/lib/tools/BetaRunnableTool";

const screenshotTool = betaZodTool({
  name: "take_screenshot",
  inputSchema: z.object({ url: z.string() }),
  run: async (input) => {
    if (!isValidUrl(input.url)) {
      throw new ToolError(`Invalid URL: ${input.url}`);
    }
    const result = await takeScreenshot(input.url);
    if (result.error) {
      // Füge den Fehler-Screenshot hinzu, damit das Modell sehen kann, was schiefgelaufen ist
      throw new ToolError([
        { type: "text", text: `Failed to load page: ${result.error}` },
        {
          type: "image",
          source: { type: "base64", data: result.screenshot, media_type: "image/png" }
        }
      ]);
    }
    return {
      type: "image",
      source: { type: "base64", data: result.screenshot, media_type: "image/png" }
    };
  }
});

Wenn ein einfacher Error geworfen wird, wird die Nachricht in einen Text-Content-Block umgewandelt.

Tool-Nutzung

Dieses SDK bietet Unterstützung für „tool use" (Tool-Nutzung), auch bekannt als Function Calling. Weitere Details findest du unter Tool-Nutzung mit Claude.

MCP-Helfer

Dieses SDK bietet Helfer für die Integration mit Model Context Protocol (MCP)-Servern. Diese Helfer konvertieren MCP-Typen in Claude-API-Typen und reduzieren so Boilerplate-Code bei der Arbeit mit MCP-Tools, -Prompts und -Ressourcen.

import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// Verbinde dich mit einem MCP-Server
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// Verwende MCP-Prompts
const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});
console.log(response.content);

// Verwende MCP-Tools mit toolRunner
const { tools } = await mcpClient.listTools();
const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Use the available tools" }],
  tools: mcpTools(tools, mcpClient)
});
console.log(finalMessage.content);

// Verwende MCP-Ressourcen als Inhalt
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
await anthropic.beta.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});

// Lade MCP-Ressourcen als Dateien hoch
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.beta.files.upload({ file: mcpResourceToFile(fileResource) });

MCP-Fehlerbehandlung

Die Konvertierungsfunktionen werfen UnsupportedMCPValueError, wenn ein MCP-Wert von der Claude API nicht unterstützt wird (zum Beispiel nicht unterstützter Content-Typ, nicht unterstützter MIME-Typ, Ressourcen-Link ohne http/https).

Message Batches

Dieses SDK bietet Unterstützung für die Message Batches API unter dem Namespace client.messages.batches.

Einen Batch erstellen

Message Batches nimmt ein Array von Anfragen entgegen, wobei jedes Objekt einen custom_id-Bezeichner und exakt dieselben Request-params wie die Standard-Messages-API hat:

const batch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "my-first-request",
      params: {
        model: "claude-opus-4-8",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-4-8",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});

Ergebnisse aus einem Batch abrufen

Sobald ein Message Batch verarbeitet wurde, angezeigt durch .processing_status === 'ended', kannst du mit .batches.results() auf die Ergebnisse zugreifen

const results = await client.messages.batches.results(batch.id);
for await (const entry of results) {
  if (entry.result.type === "succeeded") {
    console.log(entry.result.message.content);
  }
}

Datei-Uploads

Request-Parameter, die Datei-Uploads entsprechen, können in vielen verschiedenen Formen übergeben werden:

• File (oder ein Objekt mit derselben Struktur)
• eine fetch-Response (oder ein Objekt mit derselben Struktur)
• ein fs.ReadStream
• der Rückgabewert des toFile-Helfers

Setze den Content-Type explizit, da die Files API ihn nicht für dich ableitet:

import fs from "fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Wenn du Zugriff auf Node `fs` hast, verwende `fs.createReadStream()`:
await client.beta.files.upload({
  file: await toFile(fs.createReadStream("/path/to/file"), undefined, {
    type: "application/json"
  })
});

// Oder wenn du die Web-`File`-API hast, kannst du eine `File`-Instanz übergeben:
await client.beta.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// Du kannst auch eine `fetch`-`Response` übergeben:
await client.beta.files.upload({
  file: await fetch("https://somesite/file")
});

// Oder einen `Buffer` / `Uint8Array`
await client.beta.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.beta.files.upload({
  file: await toFile(new Uint8Array([0, 1, 2]), "file", { type: "text/plain" })
});

Fehlerbehandlung

Wenn die Bibliothek keine Verbindung zur API herstellen kann oder wenn die API einen Nicht-Erfolgs-Statuscode zurückgibt (d. h. eine 4xx- oder 5xx-Antwort), wird eine Unterklasse von APIError geworfen:

const message = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  })
  .catch(async (err) => {
    if (err instanceof Anthropic.APIError) {
      console.log(err.status); // 400
      console.log(err.name); // BadRequestError
      console.log(err.headers); // {server: 'nginx', ...}
    } else {
      throw err;
    }
  });

Die Fehlercodes sind wie folgt:

Request-IDs

Weitere Informationen zum Debuggen von Anfragen findest du unter Request-ID.

Alle Objekt-Antworten im SDK stellen eine _request_id-Eigenschaft bereit, die aus dem request-id-Response-Header hinzugefügt wird, damit du fehlgeschlagene Anfragen schnell protokollieren und an Anthropic melden kannst.

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-4-8"
});
console.log(message._request_id); // req_018EeWyXxfu5pfWkrYcMdjWG

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 und >=500 Internal-Fehler werden alle standardmäßig wiederholt.

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

// Konfiguriere den Standard für alle Anfragen:
const client = new Anthropic({
  maxRetries: 0 // default is 2
});

// Oder konfiguriere pro Anfrage:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  },
  { maxRetries: 5 }
);

Timeouts

Standardmäßig laufen Anfragen nach 10 Minuten ab. Wenn du jedoch einen großen max_tokens-Wert angegeben hast und nicht streamst, wird das Standard-Timeout dynamisch mit folgender Formel berechnet:

const minimum = 10 * 60;
const calculated = (60 * 60 * maxTokens) / 128_000;
return calculated < minimum ? minimum * 1000 : calculated * 1000;

was zu einem Timeout von bis zu 60 Minuten führt, skaliert durch den max_tokens-Parameter, sofern nicht auf Request- oder Client-Ebene überschrieben.

Du kannst dies mit einer timeout-Option konfigurieren:

// Konfiguriere den Standard für alle Anfragen:
const client = new Anthropic({
  timeout: 20 * 1000 // 20 seconds (default is 10 minutes)
});

// Überschreibe pro Anfrage:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  },
  { timeout: 5 * 1000 }
);

Bei einem Timeout wird ein APIConnectionTimeoutError geworfen.

Beachte, dass Anfragen, die ein Timeout erreichen, standardmäßig zweimal wiederholt werden.

Lange Anfragen

Vermeide es, einen großen max_tokens-Wert ohne Streaming zu setzen. Einige Netzwerke können inaktive Verbindungen nach einer bestimmten Zeit trennen, was dazu führen kann, dass die Anfrage fehlschlägt oder ein Timeout erreicht, ohne eine Antwort von Anthropic zu erhalten.

Dieses SDK wirft auch einen Fehler, wenn erwartet wird, dass eine Nicht-Streaming-Anfrage ungefähr länger als 10 Minuten dauert. Das Übergeben von stream: true oder das Überschreiben der timeout-Option auf Client- oder Request-Ebene deaktiviert diesen Fehler.

Eine erwartete Request-Latenz, die länger als das Timeout für eine Nicht-Streaming-Anfrage ist, führt dazu, dass der Client die Verbindung beendet und einen Wiederholungsversuch startet, ohne eine Antwort zu erhalten.

Wenn von der fetch-Implementierung unterstützt, setzt das SDK eine TCP-Socket-Keep-Alive-Option, um die Auswirkungen von Timeouts bei inaktiven Verbindungen in einigen Netzwerken zu reduzieren. Dies kann durch die Konfiguration eines benutzerdefinierten Proxys überschrieben werden.

Automatische Paginierung

Listenmethoden in der Claude API sind paginiert. Du kannst die for await ... of-Syntax verwenden, um über Elemente auf allen Seiten zu iterieren:

async function fetchAllMessageBatches() {
  const allMessageBatches = [];
  // Ruft bei Bedarf automatisch weitere Seiten ab.
  for await (const messageBatch of client.messages.batches.list({ limit: 20 })) {
    allMessageBatches.push(messageBatch);
  }
  return allMessageBatches;
}

Alternativ kannst du jeweils eine einzelne Seite anfordern:

let page = await client.messages.batches.list({ limit: 20 });
for (const messageBatch of page.data) {
  console.log(messageBatch);
}

// Komfortmethoden werden für die manuelle Paginierung bereitgestellt:
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}

Standard-Header

Das SDK sendet automatisch den anthropic-version-Header mit dem Wert 2023-06-01.

Falls nötig, kannst du ihn überschreiben, indem du Standard-Header auf Request-Basis setzt.

Beachte, dass dies zu falschen Typen und anderem unerwarteten oder undefinierten Verhalten im SDK führen kann.

const client = new Anthropic();

const message = await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);

Erweiterte Verwendung

Zugriff auf rohe Response-Daten (z. B. Header)

Auf die „rohe" Response, die von fetch() zurückgegeben wird, kann über die .asResponse()-Methode des APIPromise-Typs zugegriffen werden, den alle Methoden zurückgeben. Diese Methode gibt zurück, sobald die Header für eine erfolgreiche Antwort empfangen wurden, und konsumiert den Response-Body nicht, sodass du eigene Parsing- oder Streaming-Logik schreiben kannst.

Du kannst auch die .withResponse()-Methode verwenden, um die rohe Response zusammen mit den geparsten Daten zu erhalten. Im Gegensatz zu .asResponse() konsumiert diese Methode den Body und gibt zurück, sobald er geparst ist.

const client = new Anthropic();

const response = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  })
  .asResponse();
console.log(response.headers.get("X-My-Header"));
console.log(response.statusText); // access the underlying Response object

const { data: message, response: raw } = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-4-8"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);

Logging

Log-Level

Das Log-Level kann auf zwei Arten konfiguriert werden:

1. Über die Umgebungsvariable ANTHROPIC_LOG
2. Über die Client-Option logLevel (überschreibt die Umgebungsvariable, falls gesetzt)

const client = new Anthropic({
  logLevel: "debug" // Show all log messages
});

Verfügbare Log-Level, von am ausführlichsten bis am wenigsten ausführlich:

• 'debug' – Zeige Debug-Nachrichten, Infos, Warnungen und Fehler
• 'info' – Zeige Info-Nachrichten, Warnungen und Fehler
• 'warn' – Zeige Warnungen und Fehler (Standard)
• 'error' – Zeige nur Fehler
• 'off' – Deaktiviere alles Logging

Auf dem 'debug'-Level werden alle HTTP-Anfragen und -Antworten protokolliert, einschließlich Header und Bodies. Einige authentifizierungsbezogene Header werden unkenntlich gemacht, aber sensible Daten in Request- und Response-Bodies können weiterhin sichtbar sein.

Benutzerdefinierter Logger

Standardmäßig loggt diese Bibliothek nach globalThis.console. Du kannst auch einen benutzerdefinierten Logger bereitstellen. Die meisten Logging-Bibliotheken werden unterstützt, darunter pino, winston, bunyan, consola, signale und @std/log. Wenn dein Logger nicht funktioniert, öffne ein Issue.

Wenn du einen benutzerdefinierten Logger bereitstellst, steuert die logLevel-Option weiterhin, welche Nachrichten ausgegeben werden; Nachrichten unterhalb des konfigurierten Levels werden nicht an deinen Logger gesendet.

import pino from "pino";

const logger = pino();

const client = new Anthropic({
  logger: logger.child({ name: "Anthropic" }),
  logLevel: "debug" // Send all messages to pino, allowing it to filter
});

Benutzerdefinierte/undokumentierte Anfragen stellen

Diese Bibliothek ist für bequemen Zugriff auf die dokumentierte API typisiert. Wenn du auf undokumentierte Endpunkte, Parameter oder Response-Eigenschaften zugreifen musst, kann die Bibliothek trotzdem verwendet werden.

Undokumentierte Endpunkte

Um Anfragen an undokumentierte Endpunkte zu stellen, kannst du client.get, client.post und andere HTTP-Verben verwenden. Optionen auf dem Client, wie Wiederholungsversuche, werden bei diesen Anfragen berücksichtigt.

await client.post("/some/path", {
  body: { some_prop: "foo" },
  query: { some_query_arg: "bar" }
});

Undokumentierte Request-Parameter

Um Anfragen mit undokumentierten Parametern zu stellen, kannst du // @ts-expect-error auf dem undokumentierten Parameter verwenden. Diese Bibliothek validiert zur Laufzeit nicht, ob die Anfrage dem Typ entspricht, daher werden alle zusätzlichen Werte, die du sendest, unverändert gesendet.

client.messages.create({
  // ...
  // @ts-expect-error baz is not yet public
  baz: "undocumented option"
});

Bei Anfragen mit dem GET-Verb werden alle zusätzlichen Parameter in der Query übergeben, alle anderen Anfragen senden den zusätzlichen Parameter im Body.

Wenn du explizit ein zusätzliches Argument senden möchtest, kannst du dies mit den Request-Optionen query, body und headers tun.

Undokumentierte Response-Eigenschaften

Um auf undokumentierte Response-Eigenschaften zuzugreifen, kannst du mit // @ts-expect-error auf das Response-Objekt zugreifen oder das Response-Objekt in den erforderlichen Typ casten. Wie bei den Request-Parametern validiert oder entfernt das SDK keine zusätzlichen Eigenschaften aus der Antwort der API.

Den fetch-Client anpassen

Standardmäßig erwartet diese Bibliothek, dass eine globale fetch-Funktion definiert ist.

Wenn du eine andere fetch-Funktion verwenden möchtest, kannst du entweder die globale polyfillen:

import fetch from "my-fetch";

globalThis.fetch = fetch;

Oder sie an den Client übergeben:

import fetch from "my-fetch";

const client = new Anthropic({ fetch });

Fetch-Optionen

Wenn du benutzerdefinierte fetch-Optionen setzen möchtest, ohne die fetch-Funktion zu überschreiben, kannst du ein fetchOptions-Objekt beim Erstellen des Clients oder beim Stellen einer Anfrage bereitstellen. (Request-spezifische Optionen überschreiben Client-Optionen.)

const client = new Anthropic({
  fetchOptions: {
    // `RequestInit`-Optionen
  }
});

Proxys konfigurieren

Um das Proxy-Verhalten zu ändern, kannst du benutzerdefinierte fetchOptions bereitstellen, die laufzeitspezifische Proxy-Optionen zu Anfragen hinzufügen:

Beta-Funktionen

Beta-Funktionen sind vor der allgemeinen Veröffentlichung verfügbar, um frühes Feedback zu erhalten und neue Funktionalität zu testen. Du kannst die Verfügbarkeit aller Fähigkeiten und Tools von Claude in der Übersicht zum Entwickeln mit Claude überprüfen.

Du kannst auf die meisten Beta-API-Funktionen über die beta-Eigenschaft des Clients zugreifen. Um eine bestimmte Beta-Funktion zu aktivieren, musst du den entsprechenden Beta-Header zum betas-Feld hinzufügen, wenn du eine Nachricht erstellst.

Zum Beispiel, um die Files API zu verwenden:

const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Please summarize this document for me." },
        {
          type: "document",
          source: {
            type: "file",
            file_id: "file_abc123"
          }
        }
      ]
    }
  ],
  betas: ["files-api-2025-04-14"]
});

Laufzeitunterstützung

Plattform-Integrationen

Das TypeScript SDK unterstützt die folgenden Plattformen:

• Bedrock: npm install @anthropic-ai/bedrock-sdk: Stellt den AnthropicBedrockMantle-Client bereit sowie AnthropicBedrock für den bedrock-runtime-Pfad
• Vertex AI: npm install @anthropic-ai/vertex-sdk: Stellt den AnthropicVertex-Client bereit
• Foundry: npm install @anthropic-ai/foundry-sdk: Stellt den AnthropicFoundry-Client bereit
• Claude Platform auf AWS: npm install @anthropic-ai/aws-sdk: Stellt den AnthropicAws-Client bereit. Übergib workspaceId an den Konstruktor oder setze die Umgebungsvariable ANTHROPIC_AWS_WORKSPACE_ID. In Beta verfügbar.

Verwende AnthropicBedrockMantle für neue Projekte; AnthropicBedrock bleibt für bestehende Anwendungen erhalten, die die Bedrock-InvokeModel-API verwenden.

Semantische Versionierung

Dieses Paket folgt im Allgemeinen den SemVer-Konventionen, obwohl bestimmte rückwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

1. Änderungen, die nur statische Typen betreffen, ohne das Laufzeitverhalten zu beeinträchtigen.
2. Änderungen an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind.
3. Änderungen, von denen nicht erwartet wird, dass sie die überwiegende Mehrheit der Benutzer in der Praxis betreffen.

Rückwärtskompatibilität wird ernst genommen, um sicherzustellen, dass du dich auf ein reibungsloses Upgrade-Erlebnis verlassen kannst.

Häufig gestellte Fragen

Siehe das GitHub-Repository für FAQs, Issues und Community-Support.

Zusätzliche Ressourcen

• GitHub-Repository
• API-Referenz
• Streaming-Nachrichten
• Tool-Nutzung mit Claude