So fügen Sie Claude zu einem Alexa-Skill hinzu

CometAPI
AnnaDec 29, 2025
So fügen Sie Claude zu einem Alexa-Skill hinzu

Sprachassistenten werden zunehmend von großen Sprachmodellen betrieben. Wenn Sie Anthropics Claude-API in eine von Ihnen gepflegte oder neu erstellte Alexa-Skill integrieren möchten, führt Sie dieser Leitfaden durch die praktische Architektur, konkrete Code-Muster und betriebliche Aspekte, die Sie benötigen — vom schnellen Proof-of-Concept bis zur produktionsreifen Skill.

CometAPI ist ein API-Aggregations-Gateway, das eine einheitliche, OpenAI-kompatible Oberfläche für Hunderte von Large-Language-Models (LLMs) bereitstellt, einschließlich Anthropics Claude-Familie (Sonnet, Opus und verwandte Varianten). Anstatt die Anthropic-API direkt aufzurufen, können Kunden CometAPI-Endpunkte verwenden und ein Claude-Modell nach Name auswählen; CometAPI übernimmt das Model-Routing, die Abrechnungsaggregation und in vielen Fällen eine vereinfachte Authentifizierung und Parametrisierung.

Aus Sicht einer Alexa-Skill bietet das Hinzufügen eines Claude-Modells über CometAPI drei praktische Vorteile: (1) schneller Zugriff auf die neuesten Claude-Releases (Sonnet-/Opus-Varianten), ohne Client-Code neu schreiben zu müssen, wenn sich Modellnamen ändern; (2) eine konsistente REST-Oberfläche im OpenAI-Stil, die bereits von vielen SDKs unterstützt wird; und (3) zentralisierte Nutzungsanalysen, Drosselung und Preispläne, die einfacher zu verwalten sein können als mehrere direkte Anbieterverträge.

Was ist Claude und warum sollten Sie es zu einer Alexa-Skill hinzufügen?

Claude ist Anthropics Familie großer Sprachmodelle und konversationeller APIs (die Messages-API), die Entwickler aus ihren Anwendungen aufrufen können. Claude-Modelle (kürzlich über die Opus/Sonnet/Haiku-Reihe aktualisiert, Claude Opus 4.5, Claude Sonnet 4.5, Claude Haiku 4.5) bieten hochwertige natürliche Sprachgenerierung, Reasoning und spezialisierte Agent-Funktionen. Die Integration von Claude in eine Alexa-Skill ermöglicht es Ihnen, regelbasierte Antworten zu ersetzen oder zu ergänzen durch ein LLM-gesteuertes konversationales „Gehirn“, das zusammenfassen, schlussfolgern, personalisieren oder als „Agent“ für komplexe Aufgaben agieren kann.

Welche Komponenten kommunizieren miteinander?

Auf hoher Ebene ist das Integrationsmuster unkompliziert: Das Alexa-Gerät (Echo) sendet Spracheingaben an das Backend Ihrer Alexa-Skill (Ihre Skill). Ihr Backend — typischerweise eine AWS-Lambda-Funktion oder ein HTTPS-Dienst — transformiert die Nutzerintention in einen Text-Prompt und ruft die Claude-API auf. Die Claude-Antwort wird dann in Sprache (SSML) umgewandelt und an Alexa zur Wiedergabe zurückgegeben. Optional können Sie Streaming, progressive Antworten oder Agent/Tool-Muster verwenden, um die Erfahrung reaktionsschneller und leistungsfähiger zu machen.

Warum Claude wählen?

Claude bietet eine moderne Messages-API (REST + SDKs) und unterstützt Streaming-Antworten (SSE), Tools/Agent-Support (Agent Skills & Model Context Protocol) sowie gestufte Modelle mit unterschiedlichen Kosten-/Leistungsprofilen — wodurch es sich gut für komplexe konversationelle oder agentische Voice-Erlebnisse eignet. Verwenden Sie Claude, wenn Sie ein sicherheitsfokussiertes Modell mit Tools für die Anbindung externer Daten und Streaming-Verhalten für geringere wahrgenommene Latenz wünschen.

Wie sollten Sie eine Alexa-Skill mit CometAPI’s Claude architektieren?

Welche High-Level-Architekturen sind praktikabel?

Es gibt zwei produktionsreife Muster, die Sie berücksichtigen sollten:

1. Direkt: Lambda → CometAPI
Eine Alexa-Skill (typischerweise durch eine AWS-Lambda-Funktion unterstützt) ruft für jede Nutzerinteraktion synchron den REST-Endpunkt von CometAPI auf. Die Lambda-Funktion konstruiert das chat completion/messages-Payload, leitet es an CometAPI weiter und gibt den vom Modell erzeugten Text an Alexa für TTS/SSML zurück. Dieses Muster ist einfach und funktioniert gut bei niedrigem bis moderatem Traffic sowie für Proof-of-Concepts. Es minimiert Komponenten und reduziert damit Ausfallstellen, verlagert aber Rate-Limit- und Retry-Logik in die Lambda-Funktion.

2. Skill → Backend-Service → CometAPI (für die Produktion empfohlen)
Die Alexa-Skill leitet Anfragen an einen dedizierten Backend-Mikroservice weiter (gehostet auf Fargate/ECS, EKS oder einer autoskalierenden EC2-Flotte). Dieser Dienst ist verantwortlich für:

  • Gesprächsstatus, Kontextfenster und Zusammenfassung
  • Token-/Kostenabrechnung und Caching
  • Retries, Backoff und Circuit-Breaking
  • Sicherheitsfilter für Ein-/Ausgaben und PII-Redaktion
  • Streaming/Teilantworten (falls unterstützt) und progressive Aktualisierungen an Alexa

Dieses Muster zentralisiert bereichsübergreifende Anliegen und ermöglicht Model-Routing-Logik (z. B. Claude Opus für komplexes Reasoning, Sonnet für kurze Antworten). Es ist der empfohlene Ansatz für Teams, die Wachstum, regulatorische Anforderungen oder komplexe Telemetriebedürfnisse erwarten.

Wie lässt sich Alexas Voice-Lifecycle auf einen CometAPI-Claude-Aufruf abbilden?

  1. Nutzer spricht → Das Alexa-Gerät führt ASR aus und sendet eine IntentRequest an Ihre Skill (Lambda oder Webhook).
  2. Ihre Skill extrahiert Text und Sitzungs-Kontext (Locale, Gerätefähigkeiten, Nutzer-Opt-ins).
  3. Ihr Code bereitet einen Prompt vor (System + Gesprächsrunden + Nutzerturn). Für Voice bevorzugen Sie eine kurze Systemanweisung, die die Wortfülle begrenzt.
  4. Ihr Dienst ruft CometAPI auf — entweder einen OpenAI-kompatiblen chat/completions-Endpunkt oder einen CometAPI-spezifischen messages-Endpunkt — mit Auswahl des Ziel-Claude-Modells. Das Backend erhält eine Text- oder strukturierte Antwort.
  5. Ihre Skill konvertiert den Text in SSML/Karten und gibt die Alexa-Antwort zurück. Für lange Antworten liefern Sie eine kurze gesprochene Zusammenfassung und senden den Volltext als Karte an die Alexa-Begleit-App.
  6. Monitoring & Kostenrechnung: korrelieren Sie die Alexa-Request-ID mit CometAPI-Request-IDs und Modell-Token-Nutzungsmetriken für Observability.

Was sind die konkreten Schritte zur Implementierung von Claude in einer Alexa-Skill (End-to-End)?

Im Folgenden finden Sie eine praktische Schritt-für-Schritt-Anleitung sowie einen Beispiel-Node.js-Lambda-Handler für den Einstieg.

Schritt 1 — Erstellen der Alexa-Skill und des Interaktionsmodells

  1. In der Alexa Developer Console: Erstellen Sie eine Custom-Skill.

  2. Definieren Sie

    Intents

    (z. B.

    OpenChatIntent

    ,

    FollowUpIntent

    ,

    StopIntent

    ) und Beispieläußerungen. Zum Beispiel:

    • OpenChatIntent-Äußerungen: „Starte einen Chat“, „Frag Claude“, „Chatte mit KI“.

  3. Setzen Sie den Endpoint auf Ihre AWS-Lambda-ARN (oder HTTPS-Endpunkt). Speichern und bauen Sie das Modell. Siehe Alexa-REST-APIs und Dokumentation für ausführliche Hinweise.

Schritt 2 — Implementieren des Lambda-Backends

High-Level-Ablauf innerhalb von Lambda:

  1. Alexa-Anfrage (JSON) empfangen.
  2. Nutzeräußerung und Sitzungsdaten extrahieren.
  3. Optional eine progressive Antwort an Alexa senden (damit der Nutzer „Denke nach…“ hört), während Sie Claude aufrufen.
  4. Claude aufrufen (über Anthropic-REST-API oder Bedrock). Verwenden Sie Streaming, wenn Sie Teilantworten wünschen.
  5. Claude-Antwort in Alexa-Ausgabeformat konvertieren (SSML empfohlen).
  6. Das alexa-Response-Objekt zurückgeben.

Unten steht ein knappes Node.js-Beispiel (der Lesbarkeit halber zeigen wir einen Ansatz — direkter fetch zur Claude-REST; in der Produktion verschieben Sie Secrets in Secrets Manager und fügen Fehlerbehandlung/Caching hinzu). Es verwendet node-fetch-Syntax (verfügbar in Node-18+-Runtimes) und die Claude-API von CometAPI.

// index.js (AWS Lambda - Node 18+)
import { Handler } from 'aws-lambda';
import fetch from 'node-fetch'; // or global fetch in Node 18+

const CLAUDE_API_URL = process.env.CLAUDE_API_URL || 'https://api.cometapi.com/v1/messages'; // example
const CLAUDE_API_KEY = process.env.CLAUDE_API_KEY; // store in Secrets Manager or Lambda env vars

export const handler = async (event) => {
  // 1. Parse Alexa request
  const alexaRequest = JSON.parse(event.body || JSON.stringify(event));
  const intentName = alexaRequest.request?.intent?.name;
  const userUtterance = alexaRequest.request?.intent?.slots?.userQuery?.value || alexaRequest.request?.intent?.slots?.query?.value;

  // 2. Optional: send progressive response to Alexa (so user gets immediate feedback)
  // (Implementation omitted for brevity; use Alexa Progressive Response API with directive endpoint)

  // 3. Build Claude payload
  const claudePayload = {
    model: "claude-4-opus", // choose model appropriate to your subscription
    messages: [
      { role: "system", content: "You are a helpful assistant for an Alexa skill. Keep responses brief and spoken-friendly." },
      { role: "user", content: userUtterance }
    ],
    max_tokens_to_sample: 800
  };

  // 4. Call Claude (simple non-streaming call example)
  const resp = await fetch(CLAUDE_API_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': CLAUDE_API_KEY
    },
    body: JSON.stringify(claudePayload),
    timeout: 20000 // be mindful of latency; Alexa has timeouts
  });

  if (!resp.ok) {
    console.error('Claude API error', await resp.text());
    return buildAlexaResponse("Sorry, I'm having trouble reaching the assistant right now. Please try again later.");
  }

  const claudeJson = await resp.json();
  // The JSON structure depends on the API or Bedrock wrapper you're using
  const assistantText = claudeJson?.completion || claudeJson?.output?.[0]?.content || extractTextFromClaude(claudeJson);

  // 5. Convert to SSML (shorten if needed)
  const ssml = `<speak>${sanitizeForSSML(assistantText)}</speak>`;

  // 6. Return Alexa response
  return {
    statusCode: 200,
    body: JSON.stringify({
      version: "1.0",
      response: {
        outputSpeech: {
          type: "SSML",
          ssml
        },
        shouldEndSession: false
      }
    })
  };
};

function buildAlexaResponse(text) {
  return {
    statusCode: 200,
    body: JSON.stringify({
      version: "1.0",
      response: {
        outputSpeech: { type: "PlainText", text },
        shouldEndSession: true
      }
    })
  };
}

function sanitizeForSSML(text) {
  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

function extractTextFromClaude(json) {
  // implement mapping from Claude API response to string
  if (json?.output && Array.isArray(json.output)) {
    return json.output.map(o => o.content).join("\n");
  }
  return (json?.completion || '') + '';
}

Hinweis: Tatsächliche Feldnamen und Endpunkte der Claude-API können abweichen (Anthropics Dokumentation zeigt messages-APIs und Streaming-Modi). Konsultieren Sie stets die aktuellste Claude-Dokumentation für genaue Payload-Felder und Streaming-Unterstützung.

Schritt 3 — (optional, aber empfohlen) Streaming für schneller wahrgenommene Antwort verwenden

  • Warum Streaming? Streaming ermöglicht Alexa, mit der Wiedergabe einer Teilantwort zu beginnen, während das Modell noch generiert. Das reduziert die wahrgenommene Latenz und verbessert die Gesprächsatmosphäre. Claude unterstützt Streaming-Antworten (SSE oder Websocket) und verfügt über „feingranulares Tool-Streaming“ für komplexe Operationen. Die Implementierung von Streaming erfordert einen asynchronen Kanal: Alexa Progressive Response + gestückeltes Streaming zum Client oder ein SSE-Relay zu Ihrer Lambda — oder besser, Sie nutzen einen Zwischenservice, der Chunks an das Gerät pushen kann.
  • Einschränkung: Die Alexa-Plattform setzt eigene Zeit- und Direktivenregeln durch. Das übliche Muster besteht darin, früh eine Progressive-Response-Direktive zu senden und dann bei Abschluss des Modells die endgültige Sprachausgabe bereitzustellen. Native Echtzeit-Token-Streams direkt ins Alexa-Gerät sind durch Alexas Direktivenmodell eingeschränkt; simulieren Sie Streaming, indem Sie häufig progressive Antworten senden und anschließend die finale Antwort liefern.

Schritt 4 — Claude-Ausgabe auf die Alexa-Voice-UX abbilden

  • Antworten kurz und sprachfreundlich halten: Claude kann Langtexte erzeugen — transformieren oder kürzen Sie, um lange gesprochene Absätze zu vermeiden. Verwenden Sie SSML-Tags (breaks, emphasis), um die Prosodie zu verbessern.
  • Mehrturn-Kontext handhaben: Bewahren Sie kurze Kontextfenster (User-ID/Gesprächshistorie), aber vermeiden Sie serverseitiges Speichern jeder Äußerung, sofern nicht nötig. Nutzen Sie Sitzungsattribute oder einen Kurzzeitspeicher (DynamoDB mit TTL) für Nachfragen.
  • Fehler- und Fallback-Flows: Wenn Claude fehlschlägt oder unsicheren Inhalt liefert, halten Sie eine sichere Fallback-Nachricht bereit („Dabei kann ich nicht helfen“) und einen Pfad für Reporting/Logging zur Analyse.

Wie sollten Sie Zugangsdaten sichern und Nutzerdaten schützen?

Wo sollten API-Schlüssel und Secrets gespeichert werden?

  • AWS Secrets Manager ist der empfohlene Produktionsspeicher für den CometAPI-Schlüssel und alle weiteren Drittanbieter-Credentials. Geben Sie Ihrer Lambda oder Ihrem Backend-Service eine IAM-Rolle mit enger Policy, die nur das Lesen des benötigten Secrets erlaubt. Rotieren Sie Schlüssel regelmäßig und nutzen Sie automatisierte Rotation, falls unterstützt.
  • Keine Schlüssel im Quellcode oder öffentlichen Repositories einbetten. Wenn Sie für schnelle Prototypen Umgebungsvariablen verwenden, stellen Sie sicher, dass die CI/CD-Secret-Verwaltung diese Werte in Build-Pipelines ersetzt.

Wie vermeiden Sie das Senden von PII und sensiblen Sprachdaten?

  • Redigieren oder anonymisieren Sie personenbezogene Daten (PII), bevor Sie Text an CometAPI senden. Entfernen Sie Namen, Adressen, Kontonummern und alle Daten, die Sie nicht exponieren möchten.
  • Um Zustimmung bitten, wenn die Skill sensible persönliche Daten verarbeiten muss oder wenn persönliche Profilfunktionen genutzt werden (gemäß Alexa-Richtlinie).
  • Aufbewahrung & Logs: Protokolle und Traces kennzeichnen, damit Audit-Prozesse Modelleingaben auf Anfrage entfernen können; Aufbewahrungszeiträume gemäß Ihrer Datenschutzrichtlinie implementieren.

Wie managen Sie Latenz und die Alexa-User Experience?

Warum progressive Antworten und Timeouts wichtig sind?

Alexa erwartet von Ihrer Skill innerhalb von etwa 8 seconds eine Antwort für die meisten Schnittstellen; wenn Ihr Backend (und der Modellaufruf) dieses Fenster überschreiten, müssen Sie die Progressive Response API verwenden, um Nutzer einzubinden. Progressive Antworten teilen dem Nutzer mit, dass die Skill arbeitet (z. B. „einen Moment, ich hole die Antwort“), was die wahrgenommene Latenz bei Sprachinteraktionen deutlich verbessert. Implementieren Sie die progressive Antwort sofort nach Empfang des Intents und vor dem langen LLM-Aufruf.

Können Sie Modellausgaben zu Alexa streamen?

CometAPI und einige Claude-Varianten unterstützen Streaming-Primitiven (Token- oder Ereignis-Streaming). Alexa-Geräte unterstützen jedoch kein kontinuierliches Token-Streaming wie Web-UIs. Der praktische Ansatz ist:

  • Progressive Antworten verwenden, um kurze Zwischenmeldungen auszugeben, während die vollständige Antwort generiert wird.
  • Wenn Ihr Backend Streaming-Tokens vom Modell erhält, puffern Sie und geben Sie nur vollständige Sätze oder Absätze in regelmäßigen Abständen (z. B. alle 800–1200 ms) als progressive Antworten aus, und liefern Sie die finale konsolidierte TTS, wenn sie fertig ist. Das vermeidet fragmentierte oder robotische Sprache und respektiert Alexas Antwortmodell.

Sprachfreundliche Prompts gestalten

Begrenzen Sie die Wortfülle auf Prompt-Ebene. Verwenden Sie eine Systemanweisung wie:

„Sie sind ein prägnanter Alexa-Sprachassistent. Geben Sie eine gesprochene Antwort mit höchstens 30 Wörtern und eine Karte mit einer längeren Zusammenfassung für die Alexa-App.“

Für strukturierte Ausgabe bitten Sie das Modell, JSON mit den Feldern speech und card zurückzugeben. Parsen Sie diese Ausgabe serverseitig und ordnen Sie speech SSML und card der Alexa-Begleitkarte zu. Das reduziert Überraschungen und verbessert die TTS-Qualität.

Kann ich Claude-Antworten zu Alexa streamen, sodass Nutzer Text hören, während er generiert wird?

Unterstützt Claude Streaming und wie geht Alexa damit um?

Claude unterstützt Streaming via Server-Sent Events (SSE), wenn Sie stream:true in der Messages-API setzen — damit empfängt Ihr Backend Tokens inkrementell. Das Abspielmodell von Alexa akzeptiert jedoch keine gesprochene Ausgabe Token für Token direkt von Ihrem Backend. Das praktische Muster ist:

  1. Nutzen Sie Claude-Streaming in Ihrem Backend, um die Antwort zu empfangen, während sie noch generiert wird.
  2. Während das Backend Streaming-Chunks erhält, senden Sie eine oder mehrere progressive Antworten, damit der Nutzer „Ich arbeite daran“ oder kurze Zwischenmeldungen hört.
  3. Wenn das Backend einen nützlichen Chunk (oder die vollständige Antwort) hat, synthetisieren Sie den Chunk (SSML) und antworten Sie. Für sehr lange Antworten sollten Sie die Ausgabe in verdauliche Teile aufteilen (und shouldEndSession entsprechend setzen).

Wichtige Einschränkungen: Progressive Antworten sind hilfreich, verlängern aber nicht das maximale Verarbeitungsfenster; Alexa erwartet weiterhin eine Gesamtantwort innerhalb der zulässigen Zeit. Streaming kann Backend-Wartezeit reduzieren und die UX verbessern, aber Sie müssen das Timing-Modell von Alexa berücksichtigen.

Empfohlene Engineering- und UX-Best Practices?

Conversation Design

  • Halten Sie gesprochene Antworten kurz — Alexa-Nutzer bevorzugen prägnante Antworten.
  • Verwenden Sie SSML zur Steuerung von Tempo und Pausen.
  • Wenn das Modell Klärungsfragen stellen könnte, entwerfen Sie eine kleine Auswahl an Nachfragen, damit der Dialog natürlich wirkt.

Ausfallmodi und Timeouts

  • Sorgen Sie für elegante Fallbacks, wenn Claude langsam/nicht verfügbar ist.
  • Wenn Ihr LLM-Aufruf fehlschlägt, nutzen Sie vordefinierte Inhalte oder eine kurze Entschuldigung und bieten Sie an, später erneut zu versuchen.
  • Verfolgen Sie Fehler und Nutzerbeschwerden, um schnell iterieren zu können.

Testing

  • Testen Sie Intents mit dem Alexa Test Simulator und Virtual Alexa.
  • Lasttesten Sie Ihr Backend für erwartete gleichzeitige Aufrufe und lang andauernde Sprachsitzungen.

Häufige Fallstricke, die Sie vermeiden sollten

  1. Alexas Zeitfenster blockieren — überschreiten Sie nicht die Zeitlimits von Alexa; nutzen Sie progressive Antworten und streamen Sie intelligent.
  2. Secrets leaken — niemals API-Schlüssel loggen oder im Client-Code einbetten; Secrets Manager verwenden.
  3. Übermäßige Token-Nutzung — lange Gesprächsverläufe und wortreiche Prompts erhöhen Kosten; kürzen und zusammenfassen.
  4. Policy-Mismatch — sensible Daten ohne klare Nutzereinwilligung oder Policy-Checks an Drittanbieter-LLMs senden.

Praktische Beispielprompts und Prompt-Engineering-Tipps für Alexa Voice

Kurze Systemanweisung für Sprachgeeignetheit nutzen

Beispiel: „Sie sind ein höflicher, prägnanter Alexa-Sprachassistent. Halten Sie gesprochene Antworten bei ~30 Wörtern; bieten Sie an, längere Zusammenfassungen an die Alexa-App zu senden.“

Wortfülle und SSML-Format steuern

Bitten Sie Claude, die Ausgabe in wenigen Sätzen zu liefern oder als JSON mit den Feldern speech und card. Konvertieren Sie anschließend speech zu SSML und card zur Skills-Karte. Beispiel-Prompt-Suffix: „Geben Sie ein JSON-Objekt mit den Feldern: 'speech' (kurz, für TTS), 'card' (längerer Text für die Alexa-App) zurück. Fügen Sie keinen zusätzlichen Text hinzu.“ Das Parsen strukturierter Ausgabe reduziert Mehrdeutigkeit.

Nachfragen und Vorschläge anregen

Ermuntern Sie Claude, bei Bedarf mit einer Frage zu enden: „Möchten Sie, dass ich diese Zusammenfassung an Ihre Alexa-App sende?“ Das hilft, Sprachinteraktionen natürlich und entdeckbar zu halten.

Gibt es No-Code- oder Low-Code-Alternativen?

Ja — Integrationsplattformen wie Zapier und AppyPie bieten Connectoren, um Alexa-Trigger mit Claude-Aktionen zu verknüpfen, wenn Sie eine schnelle Automatisierung oder einen Prototyp ohne Servercode wünschen. Diese Tools eignen sich am besten für einfache Workflows, bieten aber nicht die geringe Latenz oder Sicherheitskontrolle, die Sie mit einem eigenen Backend erhalten.

In Low-Code-Alternativen wie Zapier, CometAPI kann Entwicklern ebenfalls helfen.

Fazit:

Die Integration von CometAPI’s Claude in eine Alexa-Skill ist ein attraktiver Weg, um schnell Zugang zu LLMs der Anthropic-Klasse mit einer einzigen, OpenAI-kompatiblen Integration zu erhalten. Die technische Migration ist für Teams, die bereits mit Chat-/Completion-APIs vertraut sind, unkompliziert, und das Aggregationsmodell von CometAPI beschleunigt die Experimentierung.

Entwickler können über CometAPI auf die Claude-API zugreifen. Beginnen Sie, indem Sie die Modellfähigkeiten von CometAPI im Playground erkunden und den API-Guide für detaillierte Anweisungen konsultieren. Stellen Sie vor dem Zugriff sicher, dass Sie sich bei CometAPI angemeldet und den API-Schlüssel erhalten haben. Com[e](https://www.cometapi.com/?utm_source=agno uted)tAPI bietet einen deutlich niedrigeren Preis als der offizielle, um Ihnen die Integration zu erleichtern.

Bereit zum Start?→ Free trial of Claude APIs!

Mehr lesen

500+ Modelle in einer API

Bis zu 20% Rabatt