Deepgram Nova からの移行（手動ファイナライズ）

pip install cartesia

npm i @cartesia/cartesia-js

import os
from cartesia import AsyncCartesia

client = AsyncCartesia(api_key=os.getenv("CARTESIA_API_KEY"))

async with client.stt.manual_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=16000
) as connection:
    ...

import os
from cartesia import Cartesia

client = Cartesia(api_key=os.getenv("CARTESIA_API_KEY"))

with client.stt.manual_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=16000
) as connection:
    ...

import Cartesia from "@cartesia/cartesia-js";

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

const connection = client.stt.manualFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_s16le",
  sample_rate: 16000,
});

// Server-side: Generate access-tokens using your API key
import Cartesia from '@cartesia/cartesia-js';

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

export async function GET() {
  const { token } = await client.accessToken.create({
    grants: { stt: true, tts: false, agent: false },
    // How long the token lasts in seconds
    // Allowed values: 0–3600
    expires_in: 3600,
  });
  return Response.json({ token });
}


// Client-side
// 1. Fetch an access token from your server
// 2. Connect to Cartesia via WebSocket
import Cartesia from "@cartesia/cartesia-js";

async function getToken(): Promise<string> {
  const res = await fetch('/replace-with-your-server');
  const { token } = await res.json();
  return token;
}
const audioContext = new AudioContext();

const client = new Cartesia({ token: await getToken() });

const connection = client.stt.manualFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_f32le",
  sample_rate: audioContext.sampleRate,
});

# Equivalent to 
# deepgram_connection.send_media(audio_chunk)
await connection.send_raw(audio_chunk)

# Equivalent to
# deepgram_connection.send_finalize()
await connection.send("finalize")

# Equivalent to
# deepgram_connection.send_close_stream()
await connection.send("close")

# Equivalent to 
# deepgram_connection.send_media(audio_chunk)
connection.send_raw(audio_chunk)

# Equivalent to
# deepgram_connection.send_finalize()
connection.send("finalize")

# Equivalent to
# deepgram_connection.send_close_stream()
connection.send("close")

// Equivalent to deepgramConnection.sendMedia(audioChunk)
// @param {ArrayBufferLike} audioChunk - Note: Blob is not accepted
connection.sendRaw(audioChunk);

// Equivalent to
// deepgramConnection.sendFinalize({ type: "Finalize" })
connection.send("finalize");

// Equivalent to
// deepgramConnection.sendCloseStream({ type: "CloseStream" })
connection.send("close");

import asyncio
from cartesia.types.stt import STTManualFinalizeWebsocketResponse

final_transcript = ""

def on_message(message: STTManualFinalizeWebsocketResponse) -> None:
    global final_transcript
    if message.type == "transcript" and message.is_final:
        # Do not strip or add whitespace!
        final_transcript += message.text
    elif message.type == "flush_done":
        print("All audio up until 'finalize' was transcribed")
    elif message.type == "done":
        print("All audio up until 'close' was transcribed")
    elif message.type == "error":
        print(f"Error: {message.message}")

# Equivalent to
# deepgram_connection.on(EventType.MESSAGE, on_message)
connection.on("event", on_message)

# Equivalent to
# asyncio.create_task(deepgram_connection.start_listening())
recv_task = asyncio.create_task(connection.dispatch_events())

import threading
from cartesia.types.stt import STTManualFinalizeWebsocketResponse

final_transcript = ""

def on_message(message: STTManualFinalizeWebsocketResponse) -> None:
    global final_transcript
    if message.type == "transcript" and message.is_final:
        # Do not strip or add whitespace!
        final_transcript += message.text
    elif message.type == "flush_done":
        print("All audio up until 'finalize' was transcribed")
    elif message.type == "done":
        print("All audio up until 'close' was transcribed")
    elif message.type == "error":
        print(f"Error: {message.message}")

# Equivalent to
# deepgram_connection.on(EventType.MESSAGE, on_message)
connection.on("event", on_message)

# Equivalent to
# threading.Thread(target=deepgram_connection.start_listening, daemon=True).start()
threading.Thread(target=connection.dispatch_events, daemon=True).start()

import Cartesia from '@cartesia/cartesia-js';

let finalTranscript = '';

// Equivalent to
// deepgramConnection.on("message", (message) => { ... });
connection.on("event", (message: Cartesia.STT.ManualFinalize.STTManualFinalizeWebsocketResponse) => {
  switch (message.type) {
    case "transcript":
      if (message.is_final) {
        // Do not trim or add whitespace!
        finalTranscript += message.text;
        console.log(`Transcript so far: ${finalTranscript}`);
      }
      break;
    case "flush_done":
      console.log("All audio up until 'finalize' was transcribed");
      break;
    case "done":
      console.log("All audio up until 'close' was transcribed");
      break;
  }
});

// Equivalent to
// deepgramConnection.on("error", (error) => { ... });
connection.on("error", (error) => {
  if (error.error) {
    // Server sent error (may be a bad request or internal server error)
    console.error(`Server sent an error: ${error.error.message}`);
  } else {
    // Client error
    console.error(`Client had an error: ${error.message}`);
  }
});