TypeScript SDK

Diese Bibliothek bietet bequemen Zugriff auf die Claude API aus TypeScript oder JavaScript.

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 (nicht-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 die Offenlegung deiner geheimen API-Zugangsdaten zu vermeiden (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, eröffne ein Issue im GitHub-Repository oder stimme für ein bestehendes ab.

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-5"
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

Authentifizierungsoptionen einschließlich Workload Identity Federation findest du unter Authentifizierung. Wenn dein API-Key ein persönlicher Key oder ein Service-Account-Key mit Zugriff auf mehrere Workspaces ist, setze die Workspace-ID im Request-Header anthropic-workspace-id; Einen Workspace auswählen zeigt die Option pro Anfrage für dieses SDK.

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-5"
};
const message: Anthropic.Message = await client.messages.create(params);

Die Dokumentation zu jeder Methode, jedem Request-Parameter und jedem 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 einen bestimmten Request über die Response-Eigenschaft usage einsehen, zum Beispiel:

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

Streaming von Antworten

Das SDK unterstützt „streaming“ (Streaming) von Antworten mithilfe von 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-5",
  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 Annehmlichkeiten für das Streaming von Nachrichten, zum Beispiel:

const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-5",
    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 dir verschiedene Helfer zur Verfügung, darunter Event-Handler und Akkumulation.

Alternativ kannst du client.messages.create({ ..., stream: true }) verwenden, das lediglich 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 das Erstellen und Ausführen von Tools in der Messages API erleichtern. 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 übernimmt die Weitergabe der vom gewählten Modell generierten Eingaben an das richtige Tool und die Rückgabe des Ergebnisses an das Modell.

Weitere Details zur „tool use“ (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-5",
  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 aus einem Tool an das Modell zurückzumelden, wirf einen ToolError aus der run-Funktion. Anders als ein einfacher Error akzeptiert ToolError Content-Blöcke, sodass du Bilder oder andere strukturierte Inhalte in die Fehlerantwort aufnehmen 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 bei, 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 unterstützt 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();

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

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

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

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

// MCP-Ressourcen als Dateien hochladen
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.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 unterstützt Batch-Verarbeitung unter dem Namespace client.messages.batches.

Einen Batch erstellen

Message Batches nimmt ein Array von Requests 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-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});

Ergebnisse aus einem Batch abrufen

Sobald ein Message Batch verarbeitet wurde, erkennbar an .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 "node:fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Wenn du Zugriff auf Node `fs` hast, verwende `fs.createReadStream()`:
await client.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.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// Du kannst auch eine `fetch`-`Response` übergeben:
await client.files.upload({
  file: await fetch("https://somesite/file")
});

// Oder einen `Buffer` / ein `Uint8Array`
await client.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.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 erfolgreichen Statuscode zurückgibt (also 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-5"
  })
  .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 Requests findest du unter Request-ID.

Alle Objekt-Responses im SDK stellen eine _request_id-Eigenschaft bereit, die aus dem Response-Header request-id übernommen wird, sodass du fehlgeschlagene Requests 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-5"
});
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 Netzwerkproblems), 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal Errors werden standardmäßig alle wiederholt.

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

// Konfiguriere den Standardwert 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-5"
  },
  { maxRetries: 5 }
);

Timeouts

Standardmäßig laufen Requests nach 10 Minuten in einen Timeout. Wenn du jedoch einen großen max_tokens-Wert angegeben hast und kein Streaming verwendest, wird der 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;

Dies führt zu einem Timeout von bis zu 60 Minuten, skaliert nach dem max_tokens-Parameter, sofern er nicht auf Request- oder Client-Ebene überschrieben wird.

Du kannst dies mit der Option timeout konfigurieren:

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

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

Bei einem Timeout wird ein APIConnectionTimeoutError geworfen.

Beachte, dass Requests, die in einen Timeout laufen, standardmäßig zweimal wiederholt werden.

Lange Requests

Vermeide es, einen großen max_tokens-Wert zu setzen, ohne Streaming zu verwenden. Manche Netzwerke trennen inaktive Verbindungen nach einer bestimmten Zeit, was dazu führen kann, dass der Request fehlschlägt oder in einen Timeout läuft, ohne eine Antwort von Anthropic zu erhalten.

Dieses SDK wirft außerdem einen Fehler, wenn ein Request ohne Streaming voraussichtlich länger als etwa 10 Minuten dauert. Das Übergeben von stream: true oder das Überschreiben der Option timeout auf Client- oder Request-Ebene deaktiviert diesen Fehler.

Eine erwartete Request-„latency“ (Latenz), die länger ist als der Timeout für einen Request ohne Streaming, führt dazu, dass der Client die Verbindung beendet und den Request wiederholt, ohne eine Antwort zu erhalten.

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

Automatische Paginierung

List-Methoden in der Claude API sind paginiert. Du kannst die Syntax for await ... of verwenden, um über Elemente aller Seiten hinweg 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);
}

// Für die manuelle Paginierung stehen Hilfsmethoden zur Verfügung:
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}

Standard-Header

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

Falls nötig, kannst du ihn überschreiben, indem du Standard-Header pro Request 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-5"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);

Erweiterte Verwendung

Zugriff auf rohe Response-Daten (zum Beispiel Header)

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

Du kannst auch die Methode .withResponse() verwenden, um die rohe Response zusammen mit den geparsten Daten zu erhalten. Anders als .asResponse() konsumiert diese Methode den Body und kehrt 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-5"
  })
  .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-5"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);

Logging

Log-Level

Du kannst das Log-Level auf zwei Arten konfigurieren:

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, vom ausführlichsten zum knappsten:

• 'debug' - Zeigt Debug-Meldungen, Infos, Warnungen und Fehler
• 'info' - Zeigt Info-Meldungen, Warnungen und Fehler
• 'warn' - Zeigt Warnungen und Fehler (Standard)
• 'error' - Zeigt nur Fehler
• 'off' - Deaktiviert das gesamte Logging

Auf dem Level 'debug' werden alle HTTP-Requests und -Responses protokolliert, einschließlich Header und Bodys. Einige authentifizierungsbezogene Header werden geschwärzt, aber sensible Daten in Request- und Response-Bodys können weiterhin sichtbar sein.

Benutzerdefinierter Logger

Standardmäßig protokolliert 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, eröffne ein Issue.

Wenn du einen benutzerdefinierten Logger bereitstellst, steuert die Option logLevel weiterhin, welche Meldungen ausgegeben werden; Meldungen 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 Requests ausführen

Diese Bibliothek ist für den 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 Requests an undokumentierte Endpunkte zu senden, kannst du client.get, client.post und andere HTTP-Verben verwenden. Optionen des Clients, wie etwa Wiederholungsversuche, werden bei diesen Requests berücksichtigt.

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

Undokumentierte Request-Parameter

Um Requests mit undokumentierten Parametern zu senden, kannst du // @ts-expect-error auf dem undokumentierten Parameter verwenden. Diese Bibliothek validiert zur Laufzeit nicht, ob der Request 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 Requests mit dem Verb GET landen alle zusätzlichen Parameter in der Query; alle anderen Requests 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 das SDK zusätzliche Eigenschaften in der Antwort der API nicht und entfernt sie auch nicht.

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 Funktion per Polyfill ersetzen:

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 beim Erstellen des Clients oder beim Ausführen eines Requests ein fetchOptions-Objekt übergeben. (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 Requests hinzufügen:

import * as undici from "undici";

const proxyAgent = new undici.ProxyAgent("http://localhost:8888");
const client = new Anthropic({
  fetchOptions: {
    dispatcher: proxyAgent
  }
});

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 „Mit Claude entwickeln“ prü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 beim Erstellen einer Nachricht den entsprechenden Beta-Header zum Feld betas hinzufügen.

Zum Beispiel, um Context Editing zu aktivieren:

const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["context-management-2025-06-27"]
});

Laufzeitunterstützung

Plattform-Integrationen

Das TypeScript SDK unterstützt die folgenden Plattformen:

• Agent Platform: npm install @anthropic-ai/vertex-sdk: Stellt den AnthropicVertex-Client bereit
• Bedrock: npm install @anthropic-ai/bedrock-sdk: Stellt den AnthropicBedrockMantle-Client bereit sowie AnthropicBedrock für den bedrock-runtime-Pfad
• Claude Platform on 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 der Beta verfügbar.
• Foundry: npm install @anthropic-ai/foundry-sdk: Stellt den AnthropicFoundry-Client bereit

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, wobei bestimmte rückwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

1. Änderungen, die nur statische Typen betreffen, ohne das Laufzeitverhalten zu brechen.
2. Änderungen an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind.
3. Änderungen, die in der Praxis voraussichtlich die überwiegende Mehrheit der Benutzer nicht betreffen.

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

Häufig gestellte Fragen

Im GitHub-Repository findest du FAQs, Issues und Community-Support.

Zusätzliche Ressourcen

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