Claude API

Quelle: Inhalt angepasst von Anthropics/Skills (MIT).

Diese Fähigkeit hilft Ihnen, mit Claude LLM-basierte Anwendungen zu erstellen. Wählen Sie die richtige Oberfläche entsprechend Ihren Anforderungen aus, ermitteln Sie die Projektsprache und lesen Sie dann die relevante sprachspezifische Dokumentation.

Bevor Sie beginnen

Scannen Sie die Zieldatei (oder, wenn keine Zieldatei vorhanden ist, die Eingabeaufforderung und das Projekt) nach nicht-anthropischen Anbietermarkierungen –import openai,from openai,langchain_openai,OpenAI(,gpt-4,gpt-5, Dateinamen wieagent-openai.pyoder*-generic.pyoder einer expliziten Anweisung, den Code anbieterneutral zu halten. Wenn Sie welche finden, halten Sie an und teilen Sie dem Benutzer mit, dass dieser Skill Claude/Anthropic SDK-Code erzeugt; Fragen Sie, ob sie die Datei auf Claude umstellen möchten oder eine Nicht-Claude-Implementierung wünschen. Bearbeiten Sie keine nicht von Anthropic stammende Datei mit Anthropic SDK-Aufrufen.

Ausgabeanforderung

Wenn der Benutzer Sie auffordert, eine Claude-Funktion hinzuzufügen, zu ändern oder zu implementieren, muss Ihr Code Claude über eine der folgenden Methoden aufrufen:

1. Das offizielle Anthropic SDK für die Sprache des Projekts (anthropic,@anthropic-ai/sdk,com.anthropic.*usw.). Dies ist die Standardeinstellung, wenn für das Projekt ein unterstütztes SDK vorhanden ist.
2. Raw HTTP (curl,requests,fetch,httpxusw.) – nur wenn der Benutzer explizit nach cURL/REST/raw HTTP fragt, das Projekt ein Shell/cURL-Projekt ist oder die Sprache kein offizielles SDK hat.

Mischen Sie niemals beides – greifen Sie in einem Python- oder TypeScript-Projekt nicht nachrequests/fetch, nur weil es sich leichter anfühlt. Greifen Sie niemals auf OpenAI-kompatible Shims zurück.

Erraten Sie niemals die SDK-Nutzung. Funktionsnamen, Klassennamen, Namespaces, Methodensignaturen und Importpfade müssen aus expliziter Dokumentation stammen – entweder den{lang}/-Dateien in diesem Skill oder den offiziellen SDK-Repositorys oder Dokumentationslinks, die inshared/live-sources.mdaufgeführt sind. Wenn die von Ihnen benötigte Bindung nicht explizit in den Skill-Dateien dokumentiert ist, rufen Sie vor dem Schreiben des Codes das entsprechende SDK-Repo vonshared/live-sources.mdper WebFetch ab. Leiten Sie Ruby/Java/Go/PHP/C#-APIs nicht aus cURL-Formen oder dem SDK einer anderen Sprache ab.

Standardeinstellungen

Sofern der Benutzer nichts anderes verlangt:

Für die Claude-Modellversion verwenden Sie bitte Claude Opus 4.7, auf das Sie über den genauen Modellstringclaude-opus-4-7zugreifen können. Bitte verwenden Sie standardmäßig adaptives Denken (thinking: {type: "adaptive"}) für alles, was auch nur annähernd kompliziert ist. Und schließlich verwenden Sie bitte standardmäßig das Streaming für alle Anfragen, die eine lange Eingabe, eine lange Ausgabe oder einen hohenmax_tokensbeinhalten können – so wird verhindert, dass es zu Zeitüberschreitungen bei Anfragen kommt. Verwenden Sie den.get_final_message()/.finalMessage()-Helper des SDK, um die vollständige Antwort zu erhalten, wenn Sie keine einzelnen Stream-Ereignisse verarbeiten müssen

Unterbefehle

Wenn es sich bei der Benutzeranforderung am Ende dieser Eingabeaufforderung um eine bloße Unterbefehlszeichenfolge (keine Prosa) handelt, durchsuchen Sie jede Unterbefehlstabelle in diesem Dokument – einschließlich aller unten angehängten Abschnitte – und folgen Sie direkt der entsprechenden Aktionsspalte. Dadurch können Benutzer bestimmte Flows über/claude-api <subcommand>aufrufen. Wenn keine Tabelle im Dokument übereinstimmt, behandeln Sie die Anfrage als normale Prosa.

Spracherkennung

Stellen Sie vor dem Lesen der Codebeispiele fest, in welcher Sprache der Benutzer arbeitet:

1. Sehen Sie sich die Projektdateien an, um die Sprache abzuleiten:

   • *.py,requirements.txt,pyproject.toml,setup.py,Pipfile-> Python – gelesen vonpython/
   • *.ts,*.tsx,package.json,tsconfig.json-> TypeScript – gelesen vontypescript/
   • *.js,*.jsx(keine.ts-Dateien vorhanden) -> TypeScript – JS verwendet dasselbe SDK, gelesen vontypescript/
   • *.java,pom.xml,build.gradle-> Java – ausjava/lesen
   • *.kt,*.kts,build.gradle.kts-> Java – Kotlin verwendet das Java SDK, gelesen vonjava/
   • *.scala,build.sbt-> Java – Scala verwendet das Java SDK, gelesen vonjava/
   • *.go,go.mod-> Los – vongo/lesen
   • *.rb,Gemfile-> Ruby – gelesen vonruby/
   • *.cs,*.csproj-> C# – auscsharp/lesen
   • *.php,composer.json-> PHP – ausphp/lesen

2. Wenn mehrere Sprachen erkannt werden (z. B. sowohl Python- als auch TypeScript-Dateien):

   • Prüfen Sie, auf welche Sprache sich die aktuelle Datei oder Frage des Benutzers bezieht
   • Wenn immer noch Unklarheiten bestehen, fragen Sie: „Ich habe sowohl Python- als auch TypeScript-Dateien erkannt. Welche Sprache verwenden Sie für die Claude-API-Integration?“

3. Wenn die Sprache nicht abgeleitet werden kann (leeres Projekt, keine Quelldateien oder nicht unterstützte Sprache):

   • Verwenden Sie AskUserQuestion mit Optionen: Python, TypeScript, Java, Go, Ruby, cURL/raw HTTP, C#, PHP
   • Wenn AskUserQuestion nicht verfügbar ist, verwenden Sie standardmäßig Python-Beispiele und beachten Sie: „Python-Beispiele werden angezeigt. Lassen Sie mich wissen, wenn Sie eine andere Sprache benötigen.“

4. Wenn eine nicht unterstützte Sprache erkannt wird (Rust, Swift, C++, Elixir usw.):

   • Schlagen Sie cURL/raw-HTTP-Beispiele voncurl/vor und beachten Sie, dass möglicherweise Community-SDKs vorhanden sind
   • Bieten Sie an, Python- oder TypeScript-Beispiele als Referenzimplementierungen zu zeigen

5. Wenn der Benutzer cURL-/Roh-HTTP-Beispiele benötigt, lesen Sie voncurl/.

Sprachspezifische Funktionsunterstützung

Welche Oberfläche soll ich verwenden?

Entscheidungsbaum

What does your application need?

0. Are you deploying through Amazon Bedrock, Google Vertex AI, or Microsoft Foundry?
    Yes -> Claude API (+ tool use for agents) - Managed Agents is 1P only.
   No -> continue.

1. Single LLM call (classification, summarization, extraction, Q&A)
    Claude API - one request, one response

2. Do you want Anthropic to run the agent loop and host a per-session
   container where Claude executes tools (bash, file ops, code)?
    Yes -> Managed Agents - server-managed sessions, persisted agent configs,
       SSE event stream, Skills + MCP, file mounts.
       Examples: "stateful coding agent with a workspace per task",
                 "long-running research agent that streams events to a UI",
                 "agent with persisted, versioned config used across many sessions"

3. Workflow (multi-step, code-orchestrated, with your own tools)
    Claude API with tool use - you control the loop

4. Open-ended agent (model decides its own trajectory, your own tools, you host the compute)
    Claude API agentic loop (maximum flexibility)

Sollte ich einen Agenten erstellen?

Überprüfen Sie vor der Auswahl der Agentenstufe alle vier Kriterien:

• Komplexität – Ist die Aufgabe mehrstufig und schwer im Voraus vollständig zu spezifizieren? (z. B. „Dieses Designdokument in eine PR umwandeln“ vs. „Titel aus dieser PDF extrahieren“)
• Wert – Rechtfertigt das Ergebnis höhere Kosten und Latenz?
• Lebensfähigkeit – Ist Claude für diese Aufgabenart geeignet?
• Fehlerkosten – Können Fehler erkannt und behoben werden? (Tests, Überprüfung, Rollback)

Wenn die Antwort auf eine dieser Fragen „Nein“ lautet, bleiben Sie bei einer einfacheren Stufe (Einzelanruf oder Workflow).

Architektur

Alles läuft überPOST /v1/messages. Tools und Ausgabebeschränkungen sind Funktionen dieses einzelnen Endpunkts – keine separaten APIs.

Benutzerdefinierte Tools – Sie definieren Tools (über Dekoratoren, Zod-Schemas oder rohes JSON), und der Tool-Runner des SDK übernimmt den Aufruf der API, die Ausführung Ihrer Funktionen und die Schleife, bis Claude fertig ist. Für vollständige Kontrolle können Sie die Schleife manuell schreiben.

Serverseitige Tools – Von Anthropic gehostete Tools, die auf der Infrastruktur von Anthropic ausgeführt werden. Die Codeausführung erfolgt vollständig serverseitig (deklarieren Sie es intools, Claude führt den Code automatisch aus). Die Computernutzung kann servergehostet oder selbstgehostet sein.

Strukturierte Ausgaben – Schränkt das Nachrichten-API-Antwortformat (output_config.format) und/oder die Tool-Parametervalidierung (strict: true) ein. Der empfohlene Ansatz istclient.messages.parse(), der Antworten automatisch anhand Ihres Schemas validiert. Hinweis: Der alteoutput_format-Parameter ist veraltet. Verwenden Sieoutput_config: {format: {...}}aufmessages.create().

Unterstützende Endpunkte – Batches (POST /v1/messages/batches), Dateien (POST /v1/files), Token-Zählung und Modelle (GET /v1/models,GET /v1/models/{id}– Live-Funktion/Kontextfenstererkennung) speisen Nachrichten-API-Anfragen ein oder unterstützen diese.

Aktuelle Modelle (zwischengespeichert: 15.04.2026)

Verwenden Sie IMMERclaude-opus-4-7, es sei denn, der Benutzer benennt ausdrücklich ein anderes Modell. Dies ist nicht verhandelbar. Verwenden Sie keinclaude-sonnet-4-6,claude-sonnet-4-5oder ein anderes Modell, es sei denn, der Benutzer sagt wörtlich „Sonett verwenden“ oder „Haiku verwenden“. Niemals aus Kostengründen ein Downgrade durchführen – das ist die Entscheidung des Benutzers, nicht Ihre.

KRITISCH: Verwenden Sie nur die genauen Modell-ID-Strings aus der Tabelle oben – sie sind vollständig wie sie sind. Hängen Sie keine Datumssuffixe an. Verwenden Sie beispielsweiseclaude-sonnet-4-5, niemalsclaude-sonnet-4-5-20250514oder eine andere Variante mit Datumssuffix, an die Sie sich möglicherweise aus Trainingsdaten erinnern. Wenn der Benutzer ein älteres Modell anfordert, das nicht in der Tabelle enthalten ist (z. B. „opus 4.5“, „sonnet 3.7“), lesen Sieshared/models.mdfür die genaue ID – erstellen Sie nicht selbst eines.

Ein Hinweis: Wenn Ihnen eine der oben genannten Modellzeichenfolgen unbekannt vorkommt, ist das zu erwarten – das bedeutet nur, dass sie nach der Sperrung Ihrer Trainingsdaten veröffentlicht wurden. Seien Sie versichert, dass es sich um echte Modelle handelt. Wir würden uns nicht so mit dir anlegen.

Live-Fähigkeitssuche: Die obige Tabelle wird zwischengespeichert. Wenn der Benutzer fragt: „Was ist das Kontextfenster für

Denken und Bemühen (Kurzreferenz)

Opus 4.7 – Nur adaptives Denken: Verwenden Siethinking: {type: "adaptive"}.thinking: {type: "enabled", budget_tokens: N}gibt unter Opus 4.7 einen Wert von 400 zurück – adaptiv ist der einzige Ein-Modus.{type: "disabled"}und das Weglassen vonthinkingfunktionieren beide. Die Stichprobenparameter (temperature,top_p,top_k) werden ebenfalls entfernt und auf 400 gesetzt. Die vollständige Liste der bahnbrechenden Änderungen finden Sie untershared/model-migration.md-> Migration auf Opus 4.7. Opus 4.6 – Adaptives Denken (empfohlen): Verwenden Siethinking: {type: "adaptive"}. Claude entscheidet dynamisch, wann und wie viel er denkt. Keinbudget_tokenserforderlich –budget_tokensist auf Opus 4.6 und Sonnet 4.6 veraltet und sollte nicht für neuen Code verwendet werden. Adaptives Denken ermöglicht auch automatisch verschachteltes Denken (kein Beta-Header erforderlich). Wenn der Benutzer „erweitertes Denken“, ein „Denkbudget“ oderbudget_tokenswünscht: Verwenden Sie immer Opus 4.7 oder 4.6 mitthinking: {type: "adaptive"}. Das Konzept eines festen Token-Budgets für das Denken ist veraltet – adaptives Denken ersetzt es. Verwenden Siebudget_tokensNICHT für neuen 4.6/4.7-Code und wechseln Sie NICHT zu einem älteren Modell. Schrittweise Migrationsausgliederung:budget_tokensist weiterhin auf Opus 4.6 und Sonnet 4.6 als Übergangs-Escape-Funktion funktionsfähig – wenn Sie bestehenden Code migrieren und eine Hard-Token-Obergrenze benötigen, bevor Sieeffortoptimiert haben, sieheshared/model-migration.md-> Übergangs-Escape Luke. Hinweis: Diese Ausgliederung gilt nicht für Opus 4.7 –budget_tokenswird dort vollständig entfernt. Aufwandsparameter (GA, kein Beta-Header): Steuert die Denktiefe und die gesamten Token-Ausgaben überoutput_config: {effort: "low"|"medium"|"high"|"max"}(innerhalb vonoutput_config, nicht auf oberster Ebene). Der Standardwert isthigh(entspricht dem Weglassen).maxist nur Opus-Tier (Opus 4.6 und höher – nicht Sonnet oder Haiku). Opus 4.7 fügt"xhigh"(zwischenhighundmax) hinzu – die beste Einstellung für die meisten Codierungs- und Agenten-Anwendungsfälle in 4.7 und die Standardeinstellung in Claude Code; Verwenden Sie für die meisten nachrichtendienstlichen Arbeiten mindestenshigh. Funktioniert mit Opus 4.5, Opus 4.6, Opus 4.7 und Sonnet 4.6. Tritt bei Sonnet 4.5 / Haiku 4.5 ein Fehler auf. Bei Opus 4.7 ist der Aufwand wichtiger als bei jedem früheren Opus – passen Sie ihn bei der Migration neu an. Kombinieren Sie es mit adaptivem Denken, um die besten Kosten-Qualitäts-Kompromisse zu erzielen. Geringerer Aufwand bedeutet weniger und stärker konsolidierte Tool-Aufrufe, weniger Präambel und kürzere Bestätigungen –highist oft der optimale Kompromiss zwischen Qualität und Token-Effizienz; Verwenden Siemax, wenn Korrektheit wichtiger ist als Kosten; Verwenden Sielowfür Subagenten oder einfache Aufgaben.

Opus 4.7 – denkender Inhalt wird standardmäßig weggelassen:thinkingblockiert weiterhin Streams, aber ihr Text ist leer, es sei denn, Sie entscheiden sich fürthinking: {type: "adaptive", display: "summarized"}(Standard ist"omitted"). Stille Änderung – kein Fehler. Wenn Sie Argumente an Benutzer streamen, sieht die Standardeinstellung wie eine lange Pause vor der Ausgabe aus; Legen Sie"summarized"fest, um den sichtbaren Fortschritt wiederherzustellen.

Aufgabenbudgets (Beta, Opus 4.7):output_config: {task_budget: {type: "tokens", total: N}}teilt dem Modell mit, wie viele Token es für eine vollständige Agentenschleife hat – es sieht einen laufenden Countdown und moderiert sich selbst (mindestens 20.000; Beta-Headertask-budgets-2026-03-13). Unterscheidet sich vonmax_tokens, bei dem es sich um eine erzwungene Obergrenze pro Antwort handelt, die dem Modell nicht bekannt ist. Sieheshared/model-migration.md-> Aufgabenbudgets.

Sonnet 4.6: Unterstützt adaptives Denken (thinking: {type: "adaptive"}).budget_tokensist in Sonnet 4.6 veraltet – verwenden Sie stattdessen adaptives Denken.

Ältere Modelle (nur bei ausdrücklicher Anfrage): Wenn der Benutzer ausdrücklich nach Sonnet 4.5 oder einem anderen älteren Modell fragt, verwenden Siethinking: {type: "enabled", budget_tokens: N}.budget_tokensmuss kleiner alsmax_tokenssein (mindestens 1024). Wählen Sie niemals ein älteres Modell, nur weil der Benutzerbudget_tokenserwähnt – verwenden Sie stattdessen Opus 4.7 mit adaptivem Denken.

Komprimierung (Kurzreferenz)

Beta, Opus 4.7, Opus 4.6 und Sonnet 4.6. Aktivieren Sie für lang andauernde Konversationen, die das Kontextfenster von 1 Million überschreiten können, die serverseitige Komprimierung. Die API fasst frühere Kontexte automatisch zusammen, wenn sie sich dem Auslöseschwellenwert nähern (Standard: 150.000 Token). Erfordert Beta-Headercompact-2026-01-12.

Kritisch: Hängen Sieresponse.content(nicht nur den Text) immer wieder an Ihre Nachrichten an. Komprimierungsblöcke in der Antwort müssen beibehalten werden – die API verwendet sie, um den komprimierten Verlauf bei der nächsten Anfrage zu ersetzen. Wenn Sie nur die Textzeichenfolge extrahieren und diese anhängen, geht der Komprimierungsstatus stillschweigend verloren.

Codebeispiele finden Sie unter{lang}/claude-api/README.md(Abschnitt „Komprimierung“). Vollständige Dokumentation über WebFetch inshared/live-sources.md.

Prompt-Caching (Kurzreferenz)

Präfixübereinstimmung. Jede Byteänderung irgendwo im Präfix macht alles danach ungültig. Die Renderreihenfolge isttools->system->messages. Behalten Sie stabile Inhalte zuerst bei (eingefrorene Systemeingabeaufforderung, deterministische Toolliste) und platzieren Sie flüchtige Inhalte (Zeitstempel, IDs pro Anfrage, variierende Fragen) nach dem letztencache_control-Haltepunkt.

Automatisches Caching der obersten Ebene (cache_control: {type: "ephemeral"}aufmessages.create()) ist die einfachste Option, wenn Sie keine feinkörnige Platzierung benötigen. Maximal 4 Haltepunkte pro Anfrage. Das minimal zwischenspeicherbare Präfix beträgt ~1024 Token – kürzere Präfixe werden stillschweigend nicht zwischengespeichert.

Überprüfen Sie mitusage.cache_read_input_tokens – wenn es bei wiederholten Anfragen Null ist, ist ein stiller Invalidator am Werk (datetime.now()in der Systemeingabeaufforderung, unsortiertes JSON, unterschiedlicher Toolset).

Für Platzierungsmuster, architektonische Anleitungen und die Audit-Checkliste für den stillen Invalidator: Lesen Sieshared/prompt-caching.md. Sprachspezifische Syntax:{lang}/claude-api/README.md(Abschnitt „Prompt Caching“).

Verwaltete Agenten (Beta)

Managed Agents ist eine dritte Oberfläche: serververwaltete Stateful Agents mit von Anthropic gehosteter Tool-Ausführung. Sie erstellen eine persistente, versionierte Agentenkonfiguration (POST /v1/agents) und starten dann Sitzungen, die darauf verweisen. Jede Sitzung stellt einen Container als Arbeitsbereich des Agenten bereit – Bash, Dateioperationen und Codeausführung werden dort ausgeführt; Die Agentenschleife selbst läuft auf der Orchestrierungsebene von Anthropic und wirkt über Tools auf den Container ein. Die Sitzung streamt Ereignisse; Sie senden Nachrichten und Tool-Ergebnisse zurück.

Managed Agents ist nur für Erstanbieter verfügbar. Es ist nicht auf Amazon Bedrock, Google Vertex AI oder Microsoft Foundry verfügbar. Für Agenten bei Drittanbietern verwenden Sie das Claude API + Tool.

Obligatorischer Ablauf: Agent (einmal) -> Sitzung (bei jedem Lauf).model/system/toolslive auf dem Agenten, niemals in der Sitzung. Untershared/managed-agents-overview.mdfinden Sie die vollständige Leseanleitung, Beta-Header und Fallstricke.

Beta-Header:managed-agents-2026-04-01– das SDK legt dies automatisch für alleclient.beta.{agents,environments,sessions,vaults,memory_stores}.*-Aufrufe fest. Die Skills-API verwendetskills-2025-10-02und die Datei-API verwendetfiles-api-2025-04-14, aber Sie müssen diese nicht explizit für andere Endpunkte als/v1/skillsund/v1/filesübergeben.

Unterbefehle – direkt mit/claude-api <subcommand>aufrufen:

Leseanleitung: Beginnen Sie mitshared/managed-agents-overview.md, dann mit den aktuellenshared/managed-agents-*.md-Dateien (Kern, Umgebungen, Tools, Ereignisse, Ergebnisse, Multiagent, Webhooks, Speicher, Client-Muster, Onboarding, API-Referenz). Codebeispiele für Python, TypeScript, Go, Ruby, PHP und Java finden Sie unter{lang}/managed-agents/README.md. Für cURL lesen Siecurl/managed-agents.md. Agenten sind persistent – ​​einmal erstellen, Referenzierung durch ID. Speichern Sie die vonagents.createzurückgegebene Agenten-ID und übergeben Sie sie an jeden nachfolgendensessions.create; Rufen Sieagents.createnicht im Anforderungspfad auf. Die Anthropic CLI ist eine praktische Möglichkeit, Agenten und Umgebungen aus versioniertem YAML (URL inshared/live-sources.md) zu erstellen. Wenn eine von Ihnen benötigte Bindung nicht in der README-Datei der Sprache angezeigt wird, rufen Sie den entsprechenden Eintrag per WebFetch ausshared/live-sources.mdab, anstatt zu raten. C# bietet derzeit keine Unterstützung für verwaltete Agenten. Verwenden Sie rohes HTTP voncurl/managed-agents.mdals Referenz.

Wenn der Benutzer einen verwalteten Agenten von Grund auf einrichten möchte (z. B. „Wie fange ich an“, „Führt mich durch die Erstellung eines solchen“, „Einrichten eines neuen Agenten“): Lesen Sieshared/managed-agents-onboarding.mdund führen Sie das Interview aus – derselbe Ablauf wie beim Unterbefehlmanaged-agents-onboard.

**Wenn der Benutzer fragt „Wie schreibe ich den Client-Code für

Leseführer

Nachdem Sie die Sprache erkannt haben, lesen Sie die relevanten Dateien basierend auf den Anforderungen des Benutzers:

Schnelle Aufgabenreferenz

Einzeltextklassifizierung/-zusammenfassung/-extraktion/Fragen und Antworten: -> Nur lesen{lang}/claude-api/README.md

Chat-Benutzeroberfläche oder Echtzeit-Antwortanzeige: ->{lang}/claude-api/README.md+{lang}/claude-api/streaming.mdlesen

Konversationen mit langer Dauer (können das Kontextfenster überschreiten): ->{lang}/claude-api/README.mdlesen – siehe Abschnitt Komprimierung Migration auf ein neueres Modell (Opus 4.7 / Opus 4.6 / Sonnet 4.6) oder Ersetzen eines ausgemusterten Modells: ->shared/model-migration.mdlesen Promptes Caching / Caching optimieren / „Warum ist meine Cache-Trefferquote niedrig?“: ->shared/prompt-caching.md+{lang}/claude-api/README.mdlesen (Abschnitt „Prompt Caching“)

Funktionsaufruf/Toolverwendung/Agenten: ->{lang}/claude-api/README.md+shared/tool-use-concepts.md+{lang}/claude-api/tool-use.mdlesen

Agentendesign (Tooloberfläche, Kontextverwaltung, Caching-Strategie): ->shared/agent-design.mdlesen

Stapelverarbeitung (nicht latenzempfindlich): ->{lang}/claude-api/README.md+{lang}/claude-api/batches.mdlesen

Datei-Uploads über mehrere Anfragen hinweg: ->{lang}/claude-api/README.md+{lang}/claude-api/files-api.mdlesen

Verwaltete Agenten (vom Server verwaltete zustandsbehaftete Agenten mit Arbeitsbereich): -> Lesen Sieshared/managed-agents-overview.md+ den Rest dershared/managed-agents-*.md-Dateien. Codebeispiele für Python, TypeScript, Go, Ruby, PHP und Java finden Sie unter{lang}/managed-agents/README.md. Für cURL lesen Siecurl/managed-agents.md. Agenten sind persistent – ​​einmal erstellen, Referenzierung durch ID. Speichern Sie die vonagents.createzurückgegebene Agenten-ID und übergeben Sie sie an jeden nachfolgendensessions.create; Rufen Sieagents.createnicht im Anforderungspfad auf. Die Anthropic CLI ist eine praktische Möglichkeit, Agenten und Umgebungen aus versioniertem YAML (URL inshared/live-sources.md) zu erstellen. Wenn eine von Ihnen benötigte Bindung nicht in der README-Datei der Sprache angezeigt wird, rufen Sie den entsprechenden Eintrag per WebFetch ausshared/live-sources.mdab, anstatt zu raten. C# unterstützt derzeit keine verwalteten Agenten – verwenden Sie rohes HTTP voncurl/managed-agents.mdals Referenz.

Claude API (vollständige Dateireferenz)

Lesen Sie den sprachspezifischen Claude API-Ordner ({language}/claude-api/):

1. {language}/claude-api/README.md - Bitte zuerst lesen. Installation, Schnellstart, allgemeine Muster, Fehlerbehandlung.
2. shared/tool-use-concepts.md – Lesen, wenn der Benutzer Funktionsaufrufe, Codeausführung, Speicher oder strukturierte Ausgaben benötigt. Behandelt konzeptionelle Grundlagen.
3. shared/agent-design.md – Lesen Sie beim Entwerfen eines Agenten Folgendes: Bash vs. dedizierte Tools, programmatischer Toolaufruf, Toolsuche/-fähigkeiten, Kontextbearbeitung vs. Komprimierung vs. Speicher, Caching-Prinzipien.
4. {language}/claude-api/tool-use.md – Lesen für sprachspezifische Tool-Nutzungscodebeispiele (Tool-Runner, manuelle Schleife, Codeausführung, Speicher, strukturierte Ausgaben).
5. {language}/claude-api/streaming.md – Wird beim Erstellen von Chat-Benutzeroberflächen oder -Schnittstellen gelesen, die Antworten inkrementell anzeigen.
6. {language}/claude-api/batches.md – Wird gelesen, wenn viele Anfragen offline verarbeitet werden (nicht latenzempfindlich). Läuft asynchron mit 50 % Kosten.
7. {language}/claude-api/files-api.md – Wird gelesen, wenn dieselbe Datei über mehrere Anfragen hinweg ohne erneutes Hochladen gesendet wird.
8. shared/prompt-caching.md – Wird gelesen, wenn Prompt-Caching hinzugefügt oder optimiert wird. Behandelt Präfixstabilitätsdesign, Haltepunktplatzierung und Anti-Patterns, die den Cache stillschweigend ungültig machen.
9. shared/error-codes.md – Wird beim Debuggen von HTTP-Fehlern oder beim Implementieren der Fehlerbehandlung gelesen.
10. shared/model-migration.md – Wird gelesen, wenn auf neuere Modelle aktualisiert, ausgemusterte Modelle ersetzt oderbudget_tokens/Vorausfüllungsmuster in die aktuelle API übersetzt werden.
11. shared/live-sources.md – WebFetch-URLs zum Abrufen der neuesten offiziellen Dokumentation.

Wann sollte WebFetch verwendet werden?

Verwenden Sie WebFetch, um die neueste Dokumentation abzurufen, wenn:

• Der Benutzer fragt nach „neuesten“ oder „aktuellen“ Informationen
• Die zwischengespeicherten Daten scheinen falsch zu sein
• Der Benutzer fragt nach Funktionen, die hier nicht behandelt werden

Live-Dokumentations-URLs finden Sie inshared/live-sources.md.

Häufige Fallstricke

• Schneiden Sie Eingaben nicht ab, wenn Sie Dateien oder Inhalte an die API übergeben. Wenn der Inhalt zu lang ist, um in das Kontextfenster zu passen, benachrichtigen Sie den Benutzer und besprechen Sie Optionen (Aufteilung, Zusammenfassung usw.), anstatt ihn stillschweigend abzuschneiden.
• Opus 4.7-Denkung: Nur adaptiv.thinking: {type: "enabled", budget_tokens: N}gibt 400 auf Opus 4.7 zurück –budget_tokenswird dort vollständig entfernt (zusammen mittemperature,top_p,top_k). Verwenden Siethinking: {type: "adaptive"}.
• Opus 4.6 / Sonnet 4.6-Denkweise: Verwenden Siethinking: {type: "adaptive"}– verwenden Siebudget_tokensNICHT für neuen 4.6-Code (sowohl auf Opus 4.6 als auch auf Sonnet 4.6 veraltet; Informationen zur schrittweisen Migration von vorhandenem Code finden Sie in der Übergangsklappe inshared/model-migration.md– beachten Sie, dass diese Ausgliederung nicht für Opus 4.7 gilt). Bei älteren Modellen mussbudget_tokenskleiner alsmax_tokenssein (mindestens 1024). Dies führt zu einer Fehlermeldung, wenn Sie etwas falsch machen.
• 4.6/4.7-Familien-Vorausfüllung entfernt: Assistentennachrichten-Vorausfüllungen (Vorausfüllungen für die letzte Assistentenrunde) geben bei Opus 4.6, Opus 4.7 und Sonnet 4.6 einen 400-Fehler zurück. Verwenden Sie stattdessen strukturierte Ausgaben (output_config.format) oder Systemaufforderungsanweisungen, um das Antwortformat zu steuern.
• Bestätigen Sie den Migrationsbereich vor der Bearbeitung: Wenn ein Benutzer Code auf ein neueres Claude-Modell migrieren möchte, ohne eine bestimmte Datei, ein Verzeichnis oder eine Dateiliste zu benennen, fragen Sie ihn, welcher Bereich zuerst angewendet werden soll – das gesamte Arbeitsverzeichnis, ein bestimmtes Unterverzeichnis oder einen bestimmten Satz von Dateien. Beginnen Sie erst mit der Bearbeitung, wenn der Benutzer dies bestätigt. Imperativformulierungen wie „meine Codebasis migrieren“, „mein Projekt auf Fahren Sie ohne Nachfrage nur dann fort, wenn die Eingabeaufforderung eine genaue Datei, ein bestimmtes Verzeichnis oder eine explizite Dateiliste nennt („app.pymigrieren“, „Alles unterservices/migrieren“, „a.pyundb.pyaktualisieren“). Sieheshared/model-migration.mdSchritt 0.
• max_tokens-Standardeinstellungen: Kein Lowball-max_tokens– das Erreichen der Obergrenze schneidet die Ausgabe mitten im Gedanken ab und erfordert einen erneuten Versuch. Für Nicht-Streaming-Anfragen ist der Standardwert~16000(Antworten bleiben unter SDK-HTTP-Timeouts erhalten). Für Streaming-Anfragen verwenden Sie standardmäßig~64000(Zeitüberschreitungen stellen kein Problem dar, also geben Sie dem Modell Platz). Gehen Sie nur dann niedriger, wenn Sie einen triftigen Grund haben: Klassifizierung (~256), Kostenobergrenzen oder absichtlich kurze Ausgaben.
• 128K-Ausgabetokens: Opus 4.6 und Opus 4.7 unterstützen bis zu 128Kmax_tokens, aber die SDKs erfordern Streaming für so große Werte, um HTTP-Timeouts zu vermeiden. Verwenden Sie.stream()mit.get_final_message()/.finalMessage().
• Tool-Aufruf-JSON-Analyse (4.6/4.7-Familie): Opus 4.6, Opus 4.7 und Sonnet 4.6 erzeugen möglicherweise unterschiedliche JSON-String-Escapezeichen in Tool-Aufruf-input-Feldern (z. B. Unicode oder Schrägstrich-Escapezeichen). Analysieren Sie Tool-Eingaben immer mitjson.loads()/JSON.parse()– führen Sie niemals einen Roh-String-Abgleich für die serialisierte Eingabe durch.
• Strukturierte Ausgaben (alle Modelle): Verwenden Sieoutput_config: {format: {...}}anstelle des veralteten Parametersoutput_formataufmessages.create(). Dies ist eine allgemeine API-Änderung, nicht 4.6-spezifisch.
• SDK-Funktionalität nicht neu implementieren: Das SDK bietet High-Level-Helper – verwenden Sie sie, anstatt sie von Grund auf neu zu erstellen. Konkret: Verwenden Siestream.finalMessage(), anstatt.on()-Ereignisse innew Promise()einzuschließen. Verwenden Sie typisierte Ausnahmeklassen (Anthropic.RateLimitErrorusw.) anstelle von Fehlermeldungen zum String-Matching. Verwenden Sie SDK-Typen (Anthropic.MessageParam,Anthropic.Tool,Anthropic.Messageusw.), anstatt äquivalente Schnittstellen neu zu definieren.
• Definieren Sie keine benutzerdefinierten Typen für SDK-Datenstrukturen: Das SDK exportiert Typen für alle API-Objekte. Verwenden SieAnthropic.MessageParamfür Nachrichten,Anthropic.Toolfür Werkzeugdefinitionen,Anthropic.ToolUseBlock/Anthropic.ToolResultBlockParamfür Werkzeugergebnisse,Anthropic.Messagefür Antworten. Durch die Definition Ihres eigeneninterface ChatMessage { role: string; content: unknown }wird das dupliziert, was das SDK bereits bereitstellt, und die Typsicherheit geht verloren.
• Berichts- und Dokumentausgabe: Für Aufgaben, die Berichte, Dokumente oder Visualisierungen erstellen, sind in der Codeausführungs-Sandboxpython-docx,python-pptx,matplotlib,pillowundpypdfvorinstalliert. Claude kann formatierte Dateien (DOCX, PDF, Diagramme) generieren und über die Datei-API zurückgeben – berücksichtigen Sie dies für Anfragen vom Typ „Bericht“ oder „Dokument“ anstelle von einfachem Standardtext.

Ressourcendateien

LIZENZ.txt

LICENSE.txt herunterladen

Binäre Ressource

csharp/claude-api.md

csharp/claude-api.md herunterladen

Binäre Ressource

curl/examples.md

curl/examples.md herunterladen

Binäre Ressource

curl/managed-agents.md

curl/managed-agents.md herunterladen

Binäre Ressource

go/claude-api.md

go/claude-api.md herunterladen

Binäre Ressource

go/managed-agents/README.md

go/managed-agents/README.md herunterladen

Binäre Ressource

java/claude-api.md

Java/claude-api.md herunterladen

Binäre Ressource

java/managed-agents/README.md

Java/managed-agents/README.md herunterladen

Binäre Ressource

php/claude-api.md

php/claude-api.md herunterladen

Binäre Ressource

php/managed-agents/README.md

php/managed-agents/README.md herunterladen

Binäre Ressource

python/claude-api/README.md

Python/claude-api/README.md herunterladen

Binäre Ressource

python/claude-api/batches.md

Python/claude-api/batches.md herunterladen

# Message Batches API — Python

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```python
anthropisch importieren
aus anthropic.types.message_create_params import MessageCreateParamsNonStreaming
aus anthropic.types.messages.batch_create_params Importanfrage

client = anthropic.Anthropic()

message_batch = client.messages.batches.create(
    Anfragen=[
        Anfrage(
            custom_id="request-1",
            params=MessageCreateParamsNonStreaming(
                model="claude-opus-4-7",
                max_tokens=16000,
                message=[{"role": "user", "content": "Auswirkungen des Klimawandels zusammenfassen"}]
            )
        ),
        Anfrage(
            custom_id="request-2",
            params=MessageCreateParamsNonStreaming(
                model="claude-opus-4-7",
                max_tokens=16000,
                message=[{"role": "user", "content": "Erklären Sie die Grundlagen des Quantencomputings"}]
            )
        ),
    ]
)

print(f"Chargen-ID: {message_batch.id}")
print(f"Status: {message_batch.processing_status}")

Poll for Completion

Importzeit

während True:
    Batch = client.messages.batches.retrieve(message_batch.id)
    wenn batch.processing_status == "endet":
        Pause
    print(f"Status: {batch.processing_status}, Verarbeitung: {batch.request_counts.processing}")
    time.sleep(60)

print("Stapel abgeschlossen!")
print(f"Erfolgreich: {batch.request_counts.succeeded}")
print(f"Fehler: {batch.request_counts.errored}")

Retrieve Results

für Ergebnis in client.messages.batches.results(message_batch.id):
    match result.result.type:
        Fall „erfolgreich“:
            msg = result.result.message
            text = next((b.text für b in msg.content if b.type == "text"), "")
            print(f"[{result.custom_id}] {text[:100]}")
        Fall „fehlerhaft“:
            if result.result.error.type == "invalid_request":
                print(f"[{result.custom_id}] Validierungsfehler – Anfrage korrigieren und erneut versuchen")
            sonst:
                print(f"[{result.custom_id}] Serverfehler – erneuter Versuch möglich")
        Fall „storniert“:
            print(f"[{result.custom_id}] Abgebrochen")
        Fall „abgelaufen“:
            print(f"[{result.custom_id}] Abgelaufen - erneut senden")

Cancel a Batch

abgebrochen = client.messages.batches.cancel(message_batch.id)
print(f"Status: {cancelled.processing_status}") # "Abbrechen"

Batch with Prompt Caching

shared_system = [
    {"type": "text", "text": "Sie sind Literaturanalytiker."},
    {
        „Typ“: „Text“,
        „text“: large_document_text, # Für alle Anfragen freigegeben
        „cache_control“: {“type“: „ephemeral“}
    }
]

message_batch = client.messages.batches.create(
    Anfragen=[
        Anfrage(
            custom_id=f"analysis-{i}",
            params=MessageCreateParamsNonStreaming(
                model="claude-opus-4-7",
                max_tokens=16000,
                system=shared_system,
                message=[{"role": "user", "content": questions}]
            )
        )
        für i, Frage in enumerate(fragen)
    ]
)

Full End-to-End Example

anthropisch importieren
Importzeit
aus anthropic.types.message_create_params import MessageCreateParamsNonStreaming
aus anthropic.types.messages.batch_create_params Importanfrage

client = anthropic.Anthropic()

# 1. Bereiten Sie Anfragen vor
items_to_classify = [
    „Die Produktqualität ist ausgezeichnet!“,
    „Schrecklicher Kundenservice, nie wieder.“,
    „Es ist okay, nichts Besonderes.“,
]

Anfragen = [
    Anfrage(
        custom_id=f"classify-{i}",
        params=MessageCreateParamsNonStreaming(
            model="claude-haiku-4-5",
            max_tokens=50,
            Nachrichten=[{
                „role“: „Benutzer“,
                „Inhalt“: f „Als positiv/negativ/neutral klassifizieren (ein Wort): {text}“
            }]
        )
    )
    für i, Text in enumerate(items_to_classify)
]

# 2. Stapel erstellen
Batch = client.messages.batches.create(requests=requests)
print(f"Erstellter Stapel: {batch.id}")

# 3. Warten Sie auf den Abschluss
während True:
    Batch = client.messages.batches.retrieve(batch.id)
    wenn batch.processing_status == "endet":
        Pause
    time.sleep(10)

# 4. Sammeln Sie Ergebnisse
Ergebnisse = {}
für Ergebnis in client.messages.batches.results(batch.id):
    if result.result.type == "erfolgreich":
        msg = result.result.message
        results[result.custom_id] = next((b.text für b in msg.content if b.type == "text"), "")

für custom_id, Klassifizierung in sortiert(results.items()):
    print(f"{custom_id}: {classification}")

### python/claude-api/files-api.md

[Python/claude-api/files-api.md herunterladen](/skills/claude-api/python/claude-api/files-api.md)

```markdown
# Files API — Python

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas=["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```python
anthropisch importieren

client = anthropic.Anthropic()

uploaded = client.beta.files.upload(
    file=("report.pdf", open("report.pdf", "rb"), "application/pdf"),
)
print(f"Datei-ID: {uploaded.id}")
print(f"Größe: {uploaded.size_bytes} Bytes")

Use a File in Messages

PDF / Text Document

Antwort = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    Nachrichten=[{
        „role“: „Benutzer“,
        "Inhalt": [
            {"type": "text", "text": "Fassen Sie die wichtigsten Ergebnisse in diesem Bericht zusammen."},
            {
                „Typ“: „Dokument“,
                „source“: {“type“: „file“, „file_id“: uploaded.id},
                „title“: „Q4-Bericht“, # optional
                "citations": {"enabled": True} # optional, aktiviert Zitate
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
)
für Block in Response.content:
    if block.type == "text":
        print(block.text)

Image

image_file = client.beta.files.upload(
    file=("photo.png", open("photo.png", "rb"), "image/png"),
)

Antwort = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    Nachrichten=[{
        „role“: „Benutzer“,
        "Inhalt": [
            {"type": "text", "text": "Was ist in diesem Bild?"},
            {
                „Typ“: „Bild“,
                „source“: {“type“: „file“, „file_id“: image_file.id}
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
)

Manage Files

List Files

files = client.beta.files.list()
für f in files.data:
    print(f"{f.id}: {f.filename} ({f.size_bytes} Bytes)")

Get File Metadata

file_info = client.beta.files.retrieve_metadata("file_011CNha8iCJcU1wXNR6q4V8w")
print(f"Dateiname: {file_info.filename}")
print(f"MIME-Typ: {file_info.mime_type}")

Delete a File

client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w")

Download a File

Only files created by the code execution tool or skills can be downloaded (not user-uploaded files).

file_content = client.beta.files.download("file_011CNha8iCJcU1wXNR6q4V8w")
file_content.write_to_file("output.txt")

Full End-to-End Example

Upload a document once, ask multiple questions about it:

anthropisch importieren

client = anthropic.Anthropic()

# 1. Einmal hochladen
uploaded = client.beta.files.upload(
    file=("contract.pdf", open("contract.pdf", "rb"), "application/pdf"),
)
print(f"Hochgeladen: {uploaded.id}")

# 2. Stellen Sie mehrere Fragen mit derselben Datei-ID
Fragen = [
    „Was sind die wichtigsten Geschäftsbedingungen?“,
    „Was ist die Kündigungsklausel?“,
    „Fassen Sie den Zahlungsplan zusammen.“,
]

Für Fragen in Fragen:
    Antwort = client.beta.messages.create(
        model="claude-opus-4-7",
        max_tokens=16000,
        Nachrichten=[{
            „role“: „Benutzer“,
            "Inhalt": [
                {"type": "text", "text": questions},
                {
                    „Typ“: „Dokument“,
                    „source“: {“type“: „file“, „file_id“: uploaded.id}
                }
            ]
        }],
        betas=["files-api-2025-04-14"],
    )
    print(f"\nQ: {question}")
    text = next((b.text für b in Response.content if b.type == "text"), "")
    print(f"A: {text[:200]}")

# 3. Räumen Sie auf, wenn Sie fertig sind
client.beta.files.delete(uploaded.id)

### python/claude-api/streaming.md

[Python/claude-api/streaming.md herunterladen](/skills/claude-api/python/claude-api/streaming.md)

```markdown
# Streaming — Python

## Quick Start

```python
mit client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "Story schreiben"}]
) als Stream:
    für Text in stream.text_stream:
        print(text, end="", Flush=True)

Async

asynchron mit async_client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "Story schreiben"}]
) als Stream:
    asynchron für Text in stream.text_stream:
        print(text, end="", Flush=True)

Handling Different Content Types

Claude may return text, thinking blocks, or tool use. Handle each appropriately:

mit client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=64000,
    denken={"type": "adaptive"},
    message=[{"role": "user", "content": "Analysiere dieses Problem"}]
) als Stream:
    für Ereignis im Stream:
        if event.type == "content_block_start":
            if event.content_block.type == "thinking":
                print("\n[Denken...]")
            elif event.content_block.type == "text":
                print("\n[Antwort:]")

        elif event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                print(event.delta.thinking, end="", Flush=True)
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", Flush=True)

Streaming with Tool Use

The Python tool runner currently returns complete messages. Use streaming for individual API calls within a manual loop if you need per-token streaming with tools:

mit client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=64000,
    Werkzeuge=Werkzeuge,
    Nachrichten=Nachrichten
) als Stream:
    für Text in stream.text_stream:
        print(text, end="", Flush=True)

    Antwort = stream.get_final_message()
    # Mit der Tool-Ausführung fortfahren, wenn Response.stop_reason == "tool_use"

Getting the Final Message

mit client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "Hello"}]
) als Stream:
    für Text in stream.text_stream:
        print(text, end="", Flush=True)

    # Erhalten Sie nach dem Streaming die vollständige Nachricht
    final_message = stream.get_final_message()
    print(f"\n\nVerwendete Token: {final_message.usage.output_tokens}")

Streaming with Progress Updates

def stream_with_progress(client, **kwargs):
    „“„Streamen Sie eine Antwort mit Fortschrittsaktualisierungen.“““
    total_tokens = 0
    content_parts = []

    mit client.messages.stream(**kwargs) als Stream:
        für Ereignis im Stream:
            if event.type == "content_block_delta":
                if event.delta.type == "text_delta":
                    text = event.delta.text
                    content_parts.append(text)
                    print(text, end="", Flush=True)

            elif event.type == "message_delta":
                wenn event.usage und event.usage.output_tokens nicht None sind:
                    total_tokens = event.usage.output_tokens

        final_message = stream.get_final_message()

    print(f"\n\n[Verwendete Token: {total_tokens}]")
    return „“.join(content_parts)

Error Handling in Streams

Versuchen Sie:
    mit client.messages.stream(
        model="claude-opus-4-7",
        max_tokens=64000,
        message=[{"role": "user", "content": "Story schreiben"}]
    ) als Stream:
        für Text in stream.text_stream:
            print(text, end="", Flush=True)
außer anthropic.APIConnectionError:
    print("\nVerbindung verloren. Bitte versuchen Sie es erneut.")
außer anthropic.RateLimitError:
    print("\nTarif begrenzt. Bitte warten und erneut versuchen.")
außer anthropic.APIStatusError als e:
    print(f"\nAPI-Fehler: {e.status_code}")

Stream Event Types

Best Practices

1. Always flush output — Use flush=True to show tokens immediately
2. Handle partial responses — If the stream is interrupted, you may have incomplete content
3. Track token usage — The message_delta event contains usage information
4. Use timeouts — Set appropriate timeouts for your application
5. Default to streaming — Use .get_final_message() to get the complete response even when streaming, giving you timeout protection without needing to handle individual events

### python/claude-api/tool-use.md

[Python/claude-api/tool-use.md herunterladen](/skills/claude-api/python/claude-api/tool-use.md)

_Binäre Ressource_

### python/managed-agents/README.md

[Python/managed-agents/README.md herunterladen](/skills/claude-api/python/managed-agents/README.md)

_Binäre Ressource_

### ruby/claude-api.md

[Ruby/claude-api.md herunterladen](/skills/claude-api/ruby/claude-api.md)

```markdown
# Claude API — Ruby

> **Note:** The Ruby SDK supports the Claude API. A tool runner is available in beta via `client.beta.messages.tool_runner()`. Agent SDK is not yet available for Ruby.

## Installation

```bash
gem install anthropic

Client Initialization

erfordern „anthropisch“

# Standard (verwendet die Umgebungsvariable ANTHROPIC_API_KEY)
client = Anthropic::Client.new

# Expliziter API-Schlüssel
client = Anthropic::Client.new(api_key: „your-api-key“)

Basic Message Request

message = client.messages.create(
  Modell::"claude-opus-4-7",
  max_tokens: 16000,
  Nachrichten: [
    { Rolle: „Benutzer“, Inhalt: „Was ist die Hauptstadt von Frankreich?“ }
  ]
)
# Der Inhalt ist ein Array polymorpher Blockobjekte (TextBlock, ThinkingBlock,
# ToolUseBlock,...)..type ist ein Symbol – vergleiche mit:text, nicht mit „text“.
# .text löst NoMethodError für Nicht-TextBlock-Einträge aus.
message.content.each macht |block|
  setzt block.text, wenn block.type ==:text
Ende

Streaming

stream = client.messages.stream(
  Modell::"claude-opus-4-7",
  max_tokens: 64000,
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Ein Haiku schreiben“ }]
)

stream.text.each { |text| print(text) }

Tool Use

The Ruby SDK supports tool use via raw JSON schema definitions and also provides a beta tool runner for automatic tool execution.

Tool Runner (Beta)

Klasse GetWeatherInput < Anthropic::BaseModel
  Erforderlich:location, String, doc: „Stadt und Bundesland, z. B. San Francisco, CA“
Ende

Klasse GetWeather < Anthropic::BaseTool
  Dokument „Das aktuelle Wetter für einen Ort abrufen“

  input_schema GetWeatherInput

  def call(input)
    „Das Wetter in #{input.location} ist sonnig und 22 °C.“
  Ende
Ende

client.beta.messages.tool_runner(
  Modell::"claude-opus-4-7",
  max_tokens: 16000,
  Werkzeuge: [GetWeather.new],
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Wie ist das Wetter in San Francisco?“ }]
).each_message tun |message|
  setzt message.content
Ende

Manual Loop

See the shared tool use concepts for the tool definition format and agentic loop pattern.

Prompt Caching

system_: (trailing underscore — avoids shadowing Kernel#system) takes an array of text blocks; set cache_control on the last block. Plain hashes work via the OrHash type alias. For placement patterns and the silent-invalidator audit checklist, see shared/prompt-caching.md.

message = client.messages.create(
  Modell::"claude-opus-4-7",
  max_tokens: 16000,
  system_: [
    { Typ: „text“, Text: long_system_prompt, Cache_control: { Typ: „ephemeral“ } }
  ],
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Die wichtigsten Punkte zusammenfassen“ }]
)

For 1-hour TTL: cache_control: { type: "ephemeral", ttl: "1h" }. There's also a top-level cache_control: on messages.create that auto-places on the last cacheable block.

Verify hits via message.usage.cache_creation_input_tokens / message.usage.cache_read_input_tokens.

### ruby/managed-agents/README.md

[Ruby/managed-agents/README.md herunterladen](/skills/claude-api/ruby/managed-agents/README.md)

_Binäre Ressource_

### shared/agent-design.md

[Shared/agent-design.md herunterladen](/skills/claude-api/shared/agent-design.md)

_Binäre Ressource_

### shared/error-codes.md

[Shared/error-codes.md herunterladen](/skills/claude-api/shared/error-codes.md)

_Binäre Ressource_

### shared/live-sources.md

[Shared/live-sources.md herunterladen](/skills/claude-api/shared/live-sources.md)

_Binäre Ressource_

### shared/managed-agents-api-reference.md

[Shared/managed-agents-api-reference.md herunterladen](/skills/claude-api/shared/managed-agents-api-reference.md)

_Binäre Ressource_

### shared/managed-agents-client-patterns.md

[Shared/managed-agents-client-patterns.md herunterladen](/skills/claude-api/shared/managed-agents-client-patterns.md)

_Binäre Ressource_

### shared/managed-agents-core.md

[Shared/managed-agents-core.md herunterladen](/skills/claude-api/shared/managed-agents-core.md)

_Binäre Ressource_

### shared/managed-agents-environments.md

[Shared/managed-agents-environments.md herunterladen](/skills/claude-api/shared/managed-agents-environments.md)

_Binäre Ressource_

### shared/managed-agents-events.md

[Shared/managed-agents-events.md herunterladen](/skills/claude-api/shared/managed-agents-events.md)

_Binäre Ressource_

### shared/managed-agents-memory.md

[Shared/managed-agents-memory.md herunterladen](/skills/claude-api/shared/managed-agents-memory.md)

_Binäre Ressource_

### shared/managed-agents-multiagent.md

[Shared/managed-agents-multiagent.md herunterladen](/skills/claude-api/shared/managed-agents-multiagent.md)

_Binäre Ressource_

### shared/managed-agents-onboarding.md

[Shared/managed-agents-onboarding.md herunterladen](/skills/claude-api/shared/managed-agents-onboarding.md)

_Binäre Ressource_

### shared/managed-agents-outcomes.md

[Shared/managed-agents-outcomes.md herunterladen](/skills/claude-api/shared/managed-agents-outcomes.md)

_Binäre Ressource_

### shared/managed-agents-overview.md

[Shared/managed-agents-overview.md herunterladen](/skills/claude-api/shared/managed-agents-overview.md)

_Binäre Ressource_

### shared/managed-agents-tools.md

[Shared/managed-agents-tools.md herunterladen](/skills/claude-api/shared/managed-agents-tools.md)

_Binäre Ressource_

### shared/managed-agents-webhooks.md

[Shared/managed-agents-webhooks.md herunterladen](/skills/claude-api/shared/managed-agents-webhooks.md)

```markdown
# Managed Agents — Webhooks

Anthropic can POST to your HTTPS endpoint when a Managed Agents resource changes state — an alternative to holding an SSE stream or polling. Payloads are **thin** (event type + resource IDs only); on receipt, fetch the resource for current state. Every delivery is HMAC-signed.

> **Direction matters.** This page covers *Anthropic → you* notifications about session/vault state. It does **not** cover *third-party → you* webhooks that *trigger* a session (e.g. a GitHub push handler that calls `sessions.create()`) — that's ordinary application code on your side with no Anthropic-specific wire format.

---

## Register an endpoint (Console only)

Console → **Manage → Webhooks**. There is no programmatic endpoint-management API yet. Secret rotation is supported from the same page.

| Field | Constraint |
|---|---|
| URL | HTTPS on port 443, publicly resolvable hostname |
| Event types | Subscribe per `data.type` — you only receive subscribed types (plus test events) |
| Signing secret | `whsec_`-prefixed, 32 bytes, **shown once at creation** — store it |

---

## Verify the signature

Every delivery is HMAC-signed. **Use the SDK's `client.beta.webhooks.unwrap()`** — it verifies the signature, rejects payloads more than ~5 minutes old, and returns the parsed event. It reads the `whsec_` secret from `ANTHROPIC_WEBHOOK_SIGNING_KEY`.

```python
anthropisch importieren
aus Kolbenimport Kolben, Anfrage

client = anthropic.Anthropic() # liest ANTHROPIC_WEBHOOK_SIGNING_KEY aus der Umgebung
app = Flask(__name__)


@app.route("/webhook", method=["POST"])
def webhook():
    Versuchen Sie:
        event = client.beta.webhooks.unwrap(
            request.get_data(as_text=True),
            headers=dict(request.headers),
        )
    außer Ausnahme:
        Rückgabe „ungültige Signatur“, 400

    if event.id in seen_event_ids: # Deduplizierungswiederholungen – ID gilt pro Ereignis, nicht pro Zustellung
        return "", 204
    seen_event_ids.add(event.id)

    Übereinstimmung mit event.data.type:
        Fall „session.status_idled“:
            session = client.beta.sessions.retrieve(event.data.id)
            notify_user(session)
        Fall „vault_credential.refresh_failed“:
            alarm_oncall(event.data.id)

    return "", 204

Pass the raw request body to unwrap() — frameworks that re-serialize JSON (Express .json(), Flask .get_json()) change the bytes and break the MAC. For other languages, look up the beta.webhooks.unwrap binding in the SDK repo (shared/live-sources.md); don't hand-roll verification.

Payload envelope

{
  „Typ“: „Ereignis“,
  „id“: „event_01ABC…“,
  „created_at“: „2026-03-18T14:05:22Z“,
  "Daten": {
    „type“: „session.status_idled“,
    „id“: „session_01XYZ…“,
    „organization_id“: „8a3d2f1e-…“,
    „workspace_id“: „c7b0e4d9-…“
  }
}

Switch on data.type, fetch the resource by data.id, return any 2xx to acknowledge. created_at is when the state transition happened, not when the webhook fired.

Supported data.type values

Delivery behavior & pitfalls

• No ordering guarantee. session.status_idled may arrive before session.outcome_evaluation_ended even if the evaluation finished first. Sort by envelope created_at if order matters.
• Retries carry the same event.id. At least one retry on non-2xx. Dedupe on event.id.
• 3xx is failure. Redirects are not followed — update the URL in Console if your endpoint moves.
• Auto-disable after ~20 consecutive failed deliveries, or immediately if the hostname resolves to a private IP or returns a redirect. Re-enable manually in Console.
• Thin payload is intentional. Don't expect stop_reason, outcome_evaluations, credential secrets, etc. on the webhook body — fetch the resource.

### shared/model-migration.md

[Shared/model-migration.md herunterladen](/skills/claude-api/shared/model-migration.md)

_Binäre Ressource_

### shared/models.md

[Shared/models.md herunterladen](/skills/claude-api/shared/models.md)

_Binäre Ressource_

### shared/prompt-caching.md

[Shared/prompt-caching.md herunterladen](/skills/claude-api/shared/prompt-caching.md)

_Binäre Ressource_

### shared/tool-use-concepts.md

[Shared/tool-use-concepts.md herunterladen](/skills/claude-api/shared/tool-use-concepts.md)

_Binäre Ressource_

### typescript/claude-api/README.md

[Typescript/claude-api/README.md herunterladen](/skills/claude-api/typescript/claude-api/README.md)

_Binäre Ressource_

### typescript/claude-api/batches.md

[Typescript/claude-api/batches.md herunterladen](/skills/claude-api/typescript/claude-api/batches.md)

```markdown
# Message Batches API — TypeScript

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```typescript
Anthropic aus „@anthropic-ai/sdk“ importieren;

const client = new Anthropic();

const messageBatch = waiting client.messages.batches.create({
  Anfragen: [
    {
      benutzerdefinierte_id: „Anfrage-1“,
      Parameter: {
        Modell: „claude-opus-4-7“,
        max_tokens: 16000,
        Nachrichten: [
          { Rolle: „Benutzer“, Inhalt: „Auswirkungen des Klimawandels zusammenfassen“ },
        ],
      },
    },
    {
      benutzerdefinierte_id: „request-2“,
      Parameter: {
        Modell: „claude-opus-4-7“,
        max_tokens: 16000,
        Nachrichten: [
          { Rolle: „Benutzer“, Inhalt: „Erklären Sie die Grundlagen des Quantencomputings“ },
        ],
      },
    },
  ],
});

console.log(`Batch ID: ${messageBatch.id}`);
console.log(`Status: ${messageBatch.processing_status}`);

Poll for Completion

stapeln lassen;
while (wahr) {
  Batch = Warten auf client.messages.batches.retrieve(messageBatch.id);
  if (batch.processing_status === "ended") break;
  console.log(
   `Status: ${batch.processing_status}, processing: ${batch.request_counts.processing}`,
  );
  wait new Promise((resolve) => setTimeout(resolve, 60_000));
}

console.log("Batch abgeschlossen!");
console.log(`Succeeded: ${batch.request_counts.succeeded}`);
console.log(`Errored: ${batch.request_counts.errored}`);

Retrieve Results

for waiting (const result of waiting client.messages.batches.results(
  messageBatch.id,
)) {
  switch (result.result.type) {
    Fall „erfolgreich“:
      console.log(
       `[${result.custom_id}] ${result.result.message.content[0].text.slice(0, 100)}`,
      );
      brechen;
    Fall „fehlerhaft“:
      if (result.result.error.type === "invalid_request") {
        console.log(`[${result.custom_id}] Validation error - fix and retry`);
      } sonst {
        console.log(`[${result.custom_id}] Server error - safe to retry`);
      }
      brechen;
    Fall „abgelaufen“:
      console.log(`[${result.custom_id}] Expired - resubmit`);
      brechen;
  }
}

Cancel a Batch

const cancelled = waiting client.messages.batches.cancel(messageBatch.id);
console.log(`Status: ${cancelled.processing_status}`); // „stornieren“

### typescript/claude-api/files-api.md

[Typescript/claude-api/files-api.md herunterladen](/skills/claude-api/typescript/claude-api/files-api.md)

```markdown
# Files API — TypeScript

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas: ["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```typescript
import Anthropic, { toFile } from „@anthropic-ai/sdk“;
fs aus „fs“ importieren;

const client = new Anthropic();

const uploaded = Warten auf client.beta.files.upload({
  Datei: wait toFile(fs.createReadStream("report.pdf"), undefiniert, {
    Typ: „application/pdf“,
  }),
  Betas: ["files-api-2025-04-14"],
});

console.log(`File ID: ${uploaded.id}`);
console.log(`Size: ${uploaded.size_bytes} bytes`);

Use a File in Messages

PDF / Text Document

const Antwort = Warten auf client.beta.messages.create({
  Modell: „claude-opus-4-7“,
  max_tokens: 16000,
  Nachrichten: [
    {
      Rolle: „Benutzer“,
      Inhalt: [
        { type: „text“, text: „Fassen Sie die wichtigsten Ergebnisse dieses Berichts zusammen.“ },
        {
          Typ: „Dokument“,
          Quelle: { Typ: „Datei“, Datei-ID: hochgeladene.id },
          Titel: „Q4-Bericht“,
          Zitate: { aktiviert: wahr },
        },
      ],
    },
  ],
  Betas: ["files-api-2025-04-14"],
});

console.log(response.content[0].text);

Manage Files

List Files

const files = waiting client.beta.files.list({
  Betas: ["files-api-2025-04-14"],
});
for (const f of files.data) {
  console.log(`${f.id}: ${f.filename} (${f.size_bytes} bytes)`);
}

Delete a File

Warten Sie auf client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w", {
  Betas: ["files-api-2025-04-14"],
});

Download a File

const Antwort = Warten auf client.beta.files.download(
  „file_011CNha8iCJcU1wXNR6q4V8w“,
  { betas: ["files-api-2025-04-14"] },
);
const content = Buffer.from(await Response.arrayBuffer());
wait fs.promises.writeFile("output.txt", content);

### typescript/claude-api/streaming.md

[Typescript/claude-api/streaming.md herunterladen](/skills/claude-api/typescript/claude-api/streaming.md)

```markdown
# Streaming — TypeScript

## Quick Start

```typescript
const stream = client.messages.stream({
  Modell: „claude-opus-4-7“,
  max_tokens: 64000,
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Eine Geschichte schreiben“ }],
});

forwait (konstantes Ereignis des Streams) {
  wenn (
    event.type === "content_block_delta" &&
    event.delta.type === "text_delta"
  ) {
    Process.stdout.write(event.delta.text);
  }
}

Handling Different Content Types

const stream = client.messages.stream({
  Modell: „claude-opus-4-7“,
  max_tokens: 64000,
  Denken: { Typ: "adaptiv" },
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Dieses Problem analysieren“ }],
});

forwait (konstantes Ereignis des Streams) {
  switch (event.type) {
    Fall „content_block_start“:
      switch (event.content_block.type) {
        Fall „Denken“:
          console.log("\n[Denken...]");
          brechen;
        Fall „Text“:
          console.log("\n[Antwort:]");
          brechen;
      }
      brechen;
    Fall „content_block_delta“:
      switch (event.delta.type) {
        Fall „thinking_delta“:
          Process.stdout.write(event.delta.thinking);
          brechen;
        Fall „text_delta“:
          Process.stdout.write(event.delta.text);
          brechen;
      }
      brechen;
  }
}

Streaming with Tool Use (Tool Runner)

Use the tool runner with stream: true. The outer loop iterates over tool runner iterations (messages), the inner loop processes stream events:

Anthropic aus „@anthropic-ai/sdk“ importieren;
import { betaZodTool } from „@anthropic-ai/sdk/helpers/beta/zod“;
import { z } from „zod“;

const client = new Anthropic();

const getWeather = betaZodTool({
  Name: „get_weather“,
  Beschreibung: „Aktuelles Wetter für einen Ort abrufen“,
  Eingabeschema: z.object({
    Standort: z.string().describe("Stadt und Bundesland, z. B. San Francisco, CA"),
  }),
  run: async ({ location }) =>`72°F and sunny in ${location}`,
});

const runner = client.beta.messages.toolRunner({
  Modell: „claude-opus-4-7“,
  max_tokens: 64000,
  Werkzeuge: [getWeather],
  Nachrichten: [
    { Rolle: „Benutzer“, Inhalt: „Wie ist das Wetter in Paris und London?“ },
  ],
  Stream: wahr,
});

// Äußere Schleife: jede Tool-Runner-Iteration
for wait (const messageStream of runner) {
  // Innere Schleife: Stream-Ereignisse für diese Iteration
  for wait (const event of messageStream) {
    switch (event.type) {
      Fall „content_block_delta“:
        switch (event.delta.type) {
          Fall „text_delta“:
            Process.stdout.write(event.delta.text);
            brechen;
          Fall „input_json_delta“:
            // Tool-Eingabe wird gestreamt
            Pause;
        }
        brechen;
    }
  }
}

Getting the Final Message

const stream = client.messages.stream({
  Modell: „claude-opus-4-7“,
  max_tokens: 64000,
  Nachrichten: [{ Rolle: „Benutzer“, Inhalt: „Hallo“ }],
});

forwait (konstantes Ereignis des Streams) {
  // Ereignisse verarbeiten...
}

const finalMessage = waiting stream.finalMessage();
console.log(`Tokens used: ${finalMessage.usage.output_tokens}`);

Stream Event Types

Best Practices

1. Always flush output — Use process.stdout.write() for immediate display
2. Handle partial responses — If the stream is interrupted, you may have incomplete content
3. Track token usage — The message_delta event contains usage information
4. Use finalMessage() — Get the complete Anthropic.Message object even when streaming. Don't wrap .on() events in new Promise() — finalMessage() handles all completion/error/abort states internally
5. Buffer for web UIs — Consider buffering a few tokens before rendering to avoid excessive DOM updates
6. Use stream.on("text", ...) for deltas — The text event provides just the delta string, simpler than manually filtering content_block_delta events
7. For agentic loops with streaming — See the Streaming Manual Loop section in tool-use.md for combining stream() + finalMessage() with a tool-use loop

Raw SSE Format

If using raw HTTP (not SDKs), the stream returns Server-Sent Events:

Ereignis: message_start
Daten: {"type": "message_start", "message": {"id": "msg_...", "type": "message",...}}

Ereignis: content_block_start
Daten: {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": "}}

Ereignis: content_block_delta
Daten: {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "Hallo"}}

Ereignis: content_block_stop
Daten: {"type": "content_block_stop", "index":0}

Ereignis: message_delta
Daten: {"type": "message_delta", "delta":{"stop_reason": "end_turn"},"usage":{"output_tokens":12}}

Ereignis: message_stop
Daten: {"type": "message_stop"}

### typescript/claude-api/tool-use.md

[Typescript/claude-api/tool-use.md herunterladen](/skills/claude-api/typescript/claude-api/tool-use.md)

_Binäre Ressource_

### typescript/managed-agents/README.md

[Typescript/managed-agents/README.md herunterladen](/skills/claude-api/typescript/managed-agents/README.md)

_Binäre Ressource_

## Siehe in GitHub

[Siehe in GitHub](https://github.com/anthropics/skills/tree/main/claude-api)