Cara menambahkan Claude ke skill Alexa

CometAPI
AnnaDec 29, 2025
Cara menambahkan Claude ke skill Alexa

Asisten suara semakin banyak didukung oleh model bahasa besar. Jika Anda ingin menghadirkan API Claude dari Anthropic ke dalam skill Alexa yang Anda kelola atau bangun, panduan ini akan memandu Anda melalui arsitektur praktis, pola kode konkret, dan pertimbangan operasional yang Anda perlukan — dari bukti konsep cepat hingga skill tingkat produksi.

CometAPI adalah gateway agregasi API yang menyediakan antarmuka terpadu yang kompatibel dengan OpenAI untuk ratusan model bahasa besar (LLM), termasuk keluarga Claude dari Anthropic (Sonnet, Opus, dan varian terkait). Alih-alih memanggil API Anthropic secara langsung, pelanggan dapat memanggil endpoint CometAPI dan memilih model Claude berdasarkan nama; CometAPI menangani perutean model, agregasi penagihan, dan dalam banyak kasus menyederhanakan autentikasi serta permukaan parameter.

Dari perspektif skill Alexa, menambahkan model Claude melalui CometAPI menawarkan tiga manfaat praktis: (1) akses cepat ke rilis Claude terbaru (varian Sonnet/Opus) tanpa menulis ulang kode klien saat nama model berubah; (2) permukaan REST bergaya OpenAI yang konsisten dan sudah didukung banyak SDK; serta (3) analitik penggunaan, throttling, dan paket harga yang terpusat sehingga lebih mudah dikelola dibandingkan banyak kontrak vendor langsung.

Apa itu Claude dan mengapa menambahkannya ke skill Alexa?

Claude adalah keluarga model bahasa besar dan API percakapan (Messages API) dari Anthropic yang dapat dipanggil pengembang dari aplikasi mereka. Model Claude (baru-baru ini diperbarui pada seri Opus/Sonnet/Haiku, Claude Opus 4.5, Claude Sonnet 4.5, Claude Haiku 4.5) menyediakan generasi bahasa alami berkualitas tinggi, penalaran, dan kapabilitas agen khusus. Mengintegrasikan Claude ke skill Alexa memungkinkan Anda mengganti atau melengkapi respons berbasis aturan dengan “otak” percakapan yang didukung LLM yang dapat merangkum, bernalar, mempersonalisasi, atau bertindak sebagai “agen” untuk tugas kompleks.

Komponen apa yang saling berkomunikasi?

Secara garis besar, pola integrasi cukup sederhana: perangkat Alexa (Echo) mengirim masukan suara ke backend Alexa Skills (skill Anda). Backend Anda — biasanya fungsi AWS Lambda atau layanan HTTPS — mengubah intent pengguna menjadi prompt teks dan memanggil API Claude. Respons Claude kemudian diubah menjadi ucapan (SSML) dan dikembalikan ke Alexa untuk diputar. Opsional, Anda dapat menggunakan streaming, progressive responses, atau pola Agent/Tool untuk membuat pengalaman lebih responsif dan kuat.

Mengapa memilih Claude?

Claude menyediakan Messages API modern (REST + SDK) dan mendukung respons streaming (SSE), dukungan tools/Agent (Agent Skills & Model Context Protocol), serta model bertingkat dengan profil biaya/kinerja beragam — menjadikannya sangat cocok untuk pengalaman suara percakapan atau agen yang kompleks. Gunakan Claude jika Anda menginginkan model yang berfokus pada keselamatan dengan tooling untuk terhubung ke data eksternal dan perilaku streaming guna menurunkan latensi yang dirasakan.

Bagaimana sebaiknya mengarsiteki skill Alexa yang menggunakan Claude dari CometAPI?

Arsitektur tingkat tinggi apa yang layak?

Ada dua pola tingkat produksi yang patut dipertimbangkan:

1. Lambda langsung → CometAPI
Skill Alexa (biasanya didukung oleh fungsi AWS Lambda) memanggil endpoint REST CometAPI secara sinkron untuk setiap giliran pengguna. Lambda membangun payload chat completion/messages, meneruskannya ke CometAPI, dan mengembalikan teks model ke Alexa untuk TTS/SSML. Pola ini sederhana dan cocok untuk trafik rendah-menengah dan bukti konsep. Komponen minimal berarti titik kegagalan lebih sedikit, tetapi penanganan rate-limit dan retry berada di Lambda.

2. Skill → Layanan backend → CometAPI (direkomendasikan untuk produksi)
Skill Alexa meneruskan permintaan ke layanan backend khusus (di-host di Fargate/ECS, EKS, atau fleet EC2 yang autoscaling). Layanan tersebut bertanggung jawab atas:

  • status percakapan, context window, dan perangkuman;
  • akuntansi token/biaya dan caching;
  • retry, backoff, dan circuit-breaking;
  • penyaringan keselamatan input/output serta redaksi PII;
  • streaming/respons parsial (jika didukung) dan pembaruan progresif ke Alexa.

Pola ini memusatkan concern lintas domain dan memungkinkan logika perutean model (mis. pilih Claude Opus untuk penalaran kompleks, Sonnet untuk jawaban singkat). Ini adalah pendekatan yang direkomendasikan untuk tim yang memperkirakan pertumbuhan, persyaratan regulasi, atau kebutuhan telemetri yang kompleks.

Bagaimana siklus suara Alexa dipetakan ke panggilan Claude via CometAPI?

  1. Pengguna berbicara → perangkat Alexa melakukan ASR dan mengirim IntentRequest ke skill Anda (Lambda atau webhook).
  2. Skill Anda mengekstrak teks dan konteks sesi (locale, kapabilitas perangkat, opt-in pengguna).
  3. Kode Anda menyiapkan prompt (instruksi sistem + giliran percakapan + giliran pengguna). Untuk suara, gunakan instruksi sistem singkat yang membatasi verbosity.
  4. Layanan Anda memanggil CometAPI — baik endpoint chat/completions yang kompatibel OpenAI atau endpoint messages khusus CometAPI — dengan memilih model Claude yang dituju. Backend menerima respons berupa teks atau terstruktur.
  5. Skill Anda mengonversi teks menjadi SSML/kartu dan mengembalikan respons Alexa. Untuk jawaban panjang, berikan ringkasan singkat yang diucapkan dan kirimkan teks lengkap ke aplikasi pendamping Alexa sebagai kartu.
  6. Pemantauan & akuntansi biaya: korelasikan ID permintaan Alexa dengan ID permintaan CometAPI dan metrik penggunaan token model untuk observabilitas.

Langkah konkret untuk mengimplementasikan Claude di skill Alexa (end-to-end)

Di bawah ini adalah panduan langkah demi langkah yang praktis plus contoh handler Lambda Node.js untuk memulai.

Langkah 1 — Buat skill Alexa dan model interaksi

  1. Di Alexa Developer Console: buat skill Custom.

  2. Definisikan

    Intents

    (mis.,

    OpenChatIntent

    ,

    FollowUpIntent

    ,

    StopIntent

    ) dan contoh ucapan. Contoh:

    • Ucapan untuk OpenChatIntent: “mulai obrolan”, “tanya Claude”, “ngobrol dengan AI”.

  3. Setel Endpoint ke ARN AWS Lambda Anda (atau endpoint HTTPS). Simpan dan bangun model. Lihat Alexa REST API dan dokumentasi untuk panduan lengkap.

Langkah 2 — Implementasikan backend Lambda

Alur tingkat tinggi di dalam Lambda:

  1. Terima permintaan Alexa (JSON).
  2. Ekstrak ucapan pengguna dan data sesi.
  3. Opsional kirim progressive response Alexa (agar pengguna mendengar “Sedang memproses…”) saat Anda memanggil Claude.
  4. Panggil Claude (melalui Anthropic REST API atau Bedrock). Gunakan streaming jika Anda menginginkan respons parsial.
  5. Konversi respons Claude ke format output Alexa (SSML direkomendasikan).
  6. Kembalikan objek respons alexa.

Di bawah ini contoh Node.js yang ringkas (untuk keterbacaan kami menampilkan satu pendekatan — fetch langsung ke REST Claude; di produksi pindahkan rahasia ke Secrets Manager dan tambahkan penanganan error/caching). Ini menggunakan sintaks ala node-fetch (tersedia di runtime Node 18+) dan API Claude 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 || '') + '';
}

Catatan: Nama bidang dan endpoint API Claude yang sebenarnya dapat berbeda (dokumentasi Anthropic menunjukkan API messages dan mode streaming). Selalu lihat dokumentasi Claude terbaru untuk detail payload dan dukungan streaming.

Langkah 3 — (Opsional namun direkomendasikan) Gunakan streaming untuk respons yang terasa lebih cepat

  • Mengapa streaming? Streaming memungkinkan Alexa mulai mengucapkan output parsial saat model masih menghasilkan. Ini mengurangi persepsi latensi dan meningkatkan nuansa percakapan. Claude mendukung respons streaming (SSE atau websocket) dan memiliki “tool streaming yang terperinci” untuk operasi kompleks. Implementasi streaming memerlukan saluran asinkron: Progressive Response Alexa + streaming chunk ke klien atau relay SSE ke Lambda Anda, atau lebih baik lagi gunakan layanan perantara yang bisa mendorong chunk ke perangkat.
  • Catatan: Platform Alexa memiliki aturan waktu dan directive-nya sendiri. Pola yang umum adalah mengirim directive Progressive Response lebih awal, lalu saat model selesai, berikan output ucapan final. Streaming real-time langsung ke perangkat Alexa dibatasi oleh model directive Alexa, jadi simulasikan streaming dengan sering mengirim progressive responses dan kemudian respons final.

Langkah 4 — Petakan output Claude ke UX suara Alexa

  • Jaga jawaban tetap singkat dan ramah suara: Claude dapat menghasilkan teks panjang — transformasikan atau pangkas untuk menghindari paragraf panjang yang diucapkan. Gunakan tag SSML (jedas, penekanan) untuk meningkatkan prosodi.
  • Tangani konteks multi-giliran: Pertahankan context window pendek (ID pengguna/riwayat percakapan) tetapi hindari menyimpan setiap ucapan di server kecuali perlu. Gunakan atribut sesi atau penyimpanan memori jangka pendek (DynamoDB dengan TTL) untuk tindak lanjut.
  • Alur error dan fallback: Jika Claude gagal atau mengembalikan konten tidak aman, miliki pesan fallback yang aman (“Saya tidak bisa membantu dengan itu”) dan jalur pelaporan/log untuk analisis.

Bagaimana cara mengamankan kredensial dan melindungi data pengguna?

Di mana menyimpan API key dan rahasia?

  • AWS Secrets Manager adalah penyimpanan produksi yang direkomendasikan untuk key CometAPI dan kredensial pihak ketiga lainnya. Berikan Lambda atau layanan backend Anda peran IAM dengan kebijakan sempit yang hanya mengizinkan membaca rahasia yang diperlukan. Putar key secara terjadwal dan gunakan rotasi otomatis jika didukung.
  • Jangan menanam key di kode sumber atau repositori publik. Jika Anda menggunakan variabel lingkungan untuk prototipe cepat, pastikan manajemen rahasia di CI/CD mengganti nilai tersebut dalam pipeline build.

Bagaimana menghindari pengiriman PII dan data suara sensitif?

  • Redaksikan atau anonimisasi PII sebelum mengirim teks ke CometAPI. Hapus nama, alamat, nomor akun, dan data apa pun yang tidak ingin Anda ekspose.
  • Minta persetujuan saat skill harus memproses data pribadi sensitif atau saat menggunakan fitur profil pribadi (sesuai kebijakan Alexa).
  • Retensi & log: tag log dan trace sehingga proses audit dapat menghapus input model atas permintaan; terapkan jendela retensi selaras dengan kebijakan privasi Anda.

Bagaimana mengelola latensi dan pengalaman pengguna Alexa?

Mengapa progressive responses dan timeout penting?

Alexa mengharapkan respons dari skill Anda dalam sekitar 8 detik untuk sebagian besar antarmuka; jika backend (dan panggilan model) akan melampaui jendela itu, Anda harus menggunakan Progressive Response API untuk menjaga keterlibatan pengguna. Progressive responses memberi tahu pengguna bahwa skill sedang bekerja (misalnya, “sebentar, saya sedang mencari jawabannya”), yang secara signifikan meningkatkan latensi yang dirasakan untuk interaksi suara. Implementasikan progressive response segera setelah Anda menerima intent dan sebelum panggilan LLM yang panjang.

Dapatkah Anda men-stream output model ke Alexa?

CometAPI dan beberapa varian Claude mendukung primitif streaming (token atau event streaming). Namun, perangkat Alexa tidak mendukung streaming token berkelanjutan seperti UI web. Pendekatan praktis adalah:

  • Gunakan progressive responses untuk memublikasikan pesan singkat sementara saat menghasilkan jawaban lengkap.
  • Jika backend Anda menerima token streaming dari model, buffer dan tampilkan hanya kalimat atau paragraf lengkap secara berkala (misalnya setiap 800–1200 ms) sebagai progressive responses, lalu kirim TTS final yang terkonsolidasi saat siap. Ini menghindari ucapan terfragmentasi atau terdengar robotik dan menghormati model respons Alexa.

Rancang prompt yang ramah suara

Batasi verbosity di tingkat prompt. Gunakan instruksi sistem seperti:

“Anda adalah asisten suara Alexa yang ringkas. Berikan jawaban yang diucapkan maksimal 30 kata dan kartu dengan ringkasan lebih panjang untuk aplikasi Alexa.”

Untuk output terstruktur, minta model mengembalikan JSON dengan field speech dan card. Parse output ini di server dan petakan speech ke SSML serta card ke kartu aplikasi Alexa. Ini mengurangi kejutan dan meningkatkan kualitas TTS.

Bisakah saya men-stream respons Claude ke Alexa agar pengguna mendengar teks saat dihasilkan?

Apakah streaming didukung oleh Claude, dan bagaimana Alexa menanganinya?

Claude mendukung streaming via Server-Sent Events (SSE) saat Anda menyetel stream:true pada Messages API — ini memungkinkan backend Anda menerima token secara bertahap. Namun, model pemutaran perangkat Alexa tidak menerima ucapan token-demi-token langsung dari backend Anda. Pola praktisnya adalah:

  1. Gunakan streaming Claude di backend untuk mulai menerima respons saat masih dihasilkan.
  2. Saat backend menerima chunk streaming, kirim satu atau lebih progressive responses Alexa sehingga pengguna mendengar “Saya sedang mengerjakannya” atau pesan singkat sementara.
  3. Saat backend memiliki chunk yang berguna (atau jawaban penuh), sintesis chunk tersebut (SSML) dan balas. Untuk jawaban sangat panjang, pertimbangkan memecah respons menjadi bagian yang mudah dicerna (dan gunakan shouldEndSession sebagaimana mestinya).

Batasan penting: progressive responses membantu tetapi tidak memperpanjang jendela pemrosesan maksimum; Alexa tetap mengharapkan respons keseluruhan dalam waktu yang diizinkan. Streaming dapat mengurangi waktu tunggu backend dan meningkatkan UX, tetapi Anda harus merancang sesuai model waktu Alexa.

Rekomendasi praktik terbaik teknik dan UX?

Desain percakapan

  • Jaga jawaban yang diucapkan tetap singkat — pengguna Alexa lebih suka respons ringkas.
  • Gunakan SSML untuk mengontrol tempo dan jeda.
  • Jika model mungkin mengajukan pertanyaan klarifikasi, rancang set kecil prompt tindak lanjut agar dialog terasa natural.

Mode kegagalan dan timeout

  • Sediakan fallback yang baik saat Claude lambat/tidak tersedia.
  • Jika panggilan LLM gagal, gunakan konten siap pakai atau permintaan maaf singkat dan tawarkan untuk mencoba lagi nanti.
  • Lacak error dan keluhan pengguna untuk iterasi cepat.

Pengujian

  • Unit test intents dengan Alexa Test Simulator dan Virtual Alexa.
  • Load test backend Anda untuk panggilan bersamaan yang diharapkan dan sesi suara berekor panjang.

Kesalahan umum yang perlu dihindari

  1. Memblokir jendela waktu Alexa — jangan melampaui batas waktu Alexa; gunakan progressive responses dan stream secara cerdas.
  2. Membocorkan rahasia — jangan pernah me-log API key atau menanamnya di kode klien; gunakan Secrets Manager.
  3. Penggunaan token berlebihan — riwayat percakapan panjang dan prompt yang verbose meningkatkan biaya; pangkas dan rangkum.
  4. Ketidaksesuaian kebijakan — mengirim data sensitif ke LLM pihak ketiga tanpa persetujuan pengguna yang jelas atau pemeriksaan kebijakan.

Contoh prompt praktis dan kiat rekayasa prompt untuk suara Alexa

Gunakan instruksi sistem singkat yang sesuai suara

Contoh: "Anda adalah asisten suara Alexa yang sopan dan ringkas. Batasi jawaban yang diucapkan hingga ~30 kata; tawarkan untuk mengirim ringkasan lebih panjang ke aplikasi Alexa."

Kendalikan verbosity dan format untuk SSML

Minta Claude menghasilkan output dalam beberapa kalimat atau dalam JSON dengan field speech dan card. Kemudian konversi speech ke SSML dan card ke kartu Skills. Contoh sufiks prompt: "Kembalikan objek JSON dengan field: 'speech' (singkat, untuk TTS), 'card' (teks lebih panjang untuk aplikasi Alexa). Jangan sertakan teks tambahan apa pun." Parsing output terstruktur mengurangi ambiguitas.

Prompt untuk tindak lanjut dan saran

Dorong Claude untuk mengakhiri dengan pertanyaan bila tepat: "Apakah Anda ingin saya mengirimkan ringkasan ini ke aplikasi Alexa Anda?" Itu membantu menjaga interaksi suara tetap natural dan dapat ditemukan.

Apakah ada alternatif no-code atau low-code?

Ada — platform integrasi seperti Zapier dan AppyPie menawarkan konektor untuk menghubungkan pemicu Alexa ke aksi Claude jika Anda menginginkan automasi cepat atau prototipe tanpa menulis kode server. Alat tersebut paling baik untuk alur kerja sederhana tetapi tidak akan memberikan latensi rendah atau kontrol keamanan yang Anda dapatkan dengan backend kustom.

Dalam alternatif low-code seperti Zapier, CometAPI juga dapat membantu pengembang.

Kesimpulan:

Mengintegrasikan Claude dari CometAPI ke dalam skill Alexa adalah jalur menarik untuk dengan cepat memperoleh akses ke LLM kelas Anthropic dengan satu integrasi yang kompatibel OpenAI. Migrasi teknisnya lugas bagi tim yang sudah familiar dengan API chat/completion, dan model agregasi CometAPI mempercepat eksperimen.

Pengembang dapat mengakses API Claude melalui CometAPI. Untuk memulai, jelajahi kapabilitas model di CometAPI dalam Playground dan lihat panduan API untuk instruksi terperinci. Sebelum mengakses, pastikan Anda telah masuk ke CometAPI dan memperoleh API key. Com[e](https://www.cometapi.com/?utm_source=agno uted)tAPI menawarkan harga yang jauh lebih rendah dibandingkan harga resmi untuk membantu Anda berintegrasi.

Siap mulai?→ Uji coba gratis API Claude!

Baca Selengkapnya

500+ Model dalam Satu API

Diskon hingga 20%