วิธีใช้ GPT-Realtime-2.1-mini API

ตัวแทนเสียงในอดีตต้องใช้ส่วนประกอบสามส่วน: การแปลงเสียงเป็นข้อความ (speech-to-text), โมเดลภาษา (language model), จากนั้นการแปลงข้อความเป็นเสียง (text-to-speech) ทุกขั้นตอนที่เพิ่มเข้ามาทำให้เกิดความหน่วงและเสียโทนเสียงไป แต่ OpenAI Realtime API ยุบรวมสิ่งเหล่านี้เข้าเป็นโมเดลเสียงต่อเสียงเดียว และ gpt-realtime-2.1-mini เป็นโมเดลในกลุ่มนั้นที่มีราคาถูกกว่าและเร็วกว่า มันจะรับฟังเสียง คิด และพูดโต้ตอบกลับผ่านการเชื่อมต่อแบบสตรีมมิ่งเดียว

คู่มือนี้จะแสดงวิธีเรียกใช้แบบครบวงจร: รหัสโมเดลใดที่จะใช้ วิธีเชื่อมต่อผ่าน WebSocket และ WebRTC วิธีการกำหนดรูปแบบเซสชัน และวิธีทดสอบทั้งหมดด้วย Apidog ก่อนที่คุณจะนำไปใช้ในแอปพลิเคชัน ทุกสิ่งที่อยู่ในที่นี้อ้างอิงกับ คู่มือ OpenAI Realtime อย่างเป็นทางการ

อันดับแรก ตรวจสอบชื่อโมเดลให้ถูกต้อง

การตั้งชื่อมักทำให้คนสับสน ดังนั้นเรามาทำความเข้าใจให้ชัดเจนก่อนที่จะลงโค้ด มีตัวระบุสองแบบสำหรับโมเดล mini ตัวเดียวกัน:

• gpt-realtime-2.1-mini: รหัสเวอร์ชัน นี่คือสิ่งที่จะแสดงบน หน้าการกำหนดราคาของ OpenAI และผูกคุณไว้กับรุ่น 2.1
• gpt-realtime-mini: ชื่อเรียกแบบทั่วไป มันจะชี้ไปยังสแนปช็อตล่าสุดเสมอ ซึ่งปัจจุบันคือ gpt-realtime-mini-2025-12-15

สแนปช็อตช่วยให้คุณสามารถล็อกพฤติกรรมในการใช้งานจริง:

ใช้ชื่อเรียกทั่วไปในขณะที่คุณสร้าง แล้วกำหนดสแนปช็อตที่มีวันที่ก่อนที่คุณจะนำไปใช้งานจริง เพื่อให้การอัปเดตโมเดลจะไม่เปลี่ยนพฤติกรรมของเอเจนต์ของคุณในชั่วข้ามคืน

gpt-realtime-2.1-mini ทำอะไรได้บ้าง

เป็นโมเดลเสียงต่อเสียง คุณสตรีมเสียงเข้ามา และมันจะสตรีมเสียงกลับพร้อมกับน้ำเสียงที่เป็นธรรมชาติ โดยไม่จำเป็นต้องมีการถอดความหรือขั้นตอน TTS แยกต่างหาก นอกจากนี้ยังจัดการข้อความได้ด้วย ดังนั้นคุณสามารถผสมอินพุตแบบพิมพ์และเอาต์พุตแบบพูดในเซสชันเดียวกันได้

นี่คือรายละเอียดคุณสมบัติจาก หน้าโมเดล:

marin และ cedar เป็นเสียงใหม่ล่าสุดและเป็นเอกสิทธิ์ของ Realtime API; OpenAI แนะนำให้ใช้สำหรับเอาต์พุตที่เป็นธรรมชาติที่สุด เสียงเก่าก็ยังคงใช้ได้หากคุณต้องการโทนเสียงเฉพาะ

โมเดล "mini" แลกเปลี่ยนความลึกในการให้เหตุผลเล็กน้อยเพื่อลดความหน่วงและค่าใช้จ่ายที่ต่ำลงมาก สำหรับบอทสนับสนุนส่วนใหญ่, ระบบรับออเดอร์, และส่วนหน้าของเสียง ถือเป็นค่าเริ่มต้นที่เหมาะสม ใช้ gpt-realtime-2.1 เต็มรูปแบบก็ต่อเมื่อการสนทนาต้องการการให้เหตุผลที่ซับซ้อนมากขึ้น

ค่าใช้จ่าย

โมเดล Mini มีราคาประมาณหนึ่งในสามของโมเดลเต็มรูปแบบ อัตราโทเค็นจาก หน้าการกำหนดราคา:

เสียงเป็นส่วนที่ทำให้เกิดค่าใช้จ่ายส่วนใหญ่ และปัจจัยสำคัญที่สุดในการควบคุมค่าใช้จ่ายคือปริมาณการพูดของเอเจนต์ของคุณ เอเจนต์ที่พูด 35 วินาทีต่อนาทีจะมีค่าใช้จ่ายประมาณสองเท่าของเอเจนต์ที่พูด 15 วินาทีต่อนาที ค่าใช้จ่ายต่อนาทีในโลกแห่งความเป็นจริงสำหรับ mini อยู่ที่ประมาณ $0.06 ถึง $0.15 ขึ้นอยู่กับความละเอียดในการพูด ดังนั้นให้คุณสั่งให้โมเดลกระชับในคำแนะนำ แล้วคุณจะลดค่าใช้จ่ายลงได้โดยตรง อัตราอาจมีการเปลี่ยนแปลง ดังนั้นโปรดยืนยันกับหน้าการกำหนดราคาปัจจุบันก่อนที่จะคาดการณ์

สิ่งที่ต้องมี

คุณต้องมีสามสิ่งนี้:

1. คีย์ API ของ OpenAI ที่มีสิทธิ์เข้าถึง Realtime โดยตั้งค่าเป็น OPENAI_API_KEY
2. Node.js 18+ สำหรับตัวอย่างเซิร์ฟเวอร์ (แพ็กเกจ ws สำหรับ WebSocket ดิบ หรือ SDK openai อย่างเป็นทางการ)
3. สำหรับเสียงในเบราว์เซอร์ หน้าเว็บที่ให้บริการผ่าน HTTPS หรือ localhost เพื่อให้ getUserMedia ทำงานได้

กฎข้อหนึ่งก่อนที่คุณจะแตะเบราว์เซอร์: อย่าเปิดเผยคีย์ API ที่แท้จริงของคุณกับไคลเอ็นต์เด็ดขาด แอปพลิเคชันเบราว์เซอร์และมือถือใช้โทเค็นชั่วคราวที่มีอายุสั้นแทน รายละเอียดเพิ่มเติมด้านล่าง

เลือกวิธีการเชื่อมต่อ

โมเดล mini รองรับการส่งข้อมูลสามวิธี เลือกตามตำแหน่งที่เก็บข้อมูลเสียงของคุณ

คนส่วนใหญ่เริ่มต้นด้วย WebSocket เพื่อสร้างต้นแบบฝั่งเซิร์ฟเวอร์ จากนั้นจึงย้ายไป WebRTC สำหรับไคลเอ็นต์จริง มาลองทำทั้งสองแบบกัน

เริ่มต้นอย่างรวดเร็ว 1: WebSocket จากเซิร์ฟเวอร์ของคุณ

WebSocket เป็นวิธีที่เร็วที่สุดในการดูการตอบสนองของโมเดล จุดสิ้นสุดคือ URL เดียวพร้อมกับโมเดลใน query string:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini

เนื่องจากนี่คืออินเทอร์เฟซ GA คุณจะยืนยันตัวตนด้วย Authorization: Bearer header ธรรมดา และคุณไม่จำเป็นต้องใช้ OpenAI-Beta header แบบเก่าอีกต่อไป นี่คือ "hello world" แบบข้อความเข้า ข้อความออก เพื่อให้คุณสามารถทดสอบได้โดยไม่ต้องใช้ไมโครโฟน:

import WebSocket from "ws";

const url = "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini";
const ws = new WebSocket(url, {
  headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
});

ws.on("open", () => {
  // 1. กำหนดค่าเซสชัน
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      type: "realtime",
      model: "gpt-realtime-2.1-mini",
      output_modalities: ["text"],
      instructions: "You are a concise API support agent. Keep answers short.",
    },
  }));

  // 2. เพิ่มข้อความผู้ใช้
  ws.send(JSON.stringify({
    type: "conversation.item.create",
    item: {
      type: "message",
      role: "user",
      content: [{ type: "input_text", text: "What is an idempotent request?" }],
    },
  }));

  // 3. ร้องขอการตอบกลับ
  ws.send(JSON.stringify({ type: "response.create" }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());
  if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
  if (event.type === "response.done") ws.close();
});

ขั้นตอนจะเหมือนเดิมเสมอ: กำหนดค่า, เพิ่มอินพุต, ร้องขอการตอบกลับ, รอรับเดลต้า เหตุการณ์จากเซิร์ฟเวอร์จะถูกสตรีมกลับมาเป็น JSON เหตุการณ์ที่คุณสนใจมากที่สุด:

• session.created / session.updated: การกำหนดค่าของคุณได้รับการยอมรับ
• response.output_text.delta: ส่วนหนึ่งของข้อความ
• response.output_audio.delta: ส่วนหนึ่งของเสียง base64
• response.output_audio_transcript.delta: บทถอดเสียงสิ่งที่โมเดลกำลังพูด
• response.done: การสนทนาสิ้นสุดลง

หากต้องการเปลี่ยนจากข้อความเป็นเสียง ให้เปลี่ยน output_modalities เป็น ["audio"] และเพิ่มการกำหนดค่าเสียง (ส่วนถัดไป) เสียงจะมาถึงในเหตุการณ์ response.output_audio.delta เป็นส่วนของข้อมูล PCM ที่เข้ารหัสแบบ base64 ซึ่งคุณต้องถอดรหัสและเล่น

เริ่มต้นอย่างรวดเร็ว 2: WebRTC ในเบราว์เซอร์

สำหรับแอปพลิเคชันเสียงจริง เบราว์เซอร์จะบันทึกไมโครโฟนและเล่นการตอบกลับโดยตรง ซึ่งช่วยลดความหน่วง ข้อเสียคือการยืนยันตัวตน: คุณไม่สามารถเปิดเผยคีย์ API ของคุณได้ ดังนั้นเซิร์ฟเวอร์ของคุณจะต้องสร้างโทเค็นชั่วคราวก่อน

ขั้นตอนที่ 1: สร้างโทเค็นชั่วคราวบนเซิร์ฟเวอร์ของคุณ เรียกใช้เอนด์พอยต์ client-secrets ด้วยคีย์จริงของคุณ:

// ฝั่งเซิร์ฟเวอร์
const r = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    session: { type: "realtime", model: "gpt-realtime-2.1-mini" },
  }),
});
const { value } = await r.json(); // คีย์ชั่วคราว, ขึ้นต้นด้วย "ek_"

ส่ง value ไปยังเบราว์เซอร์ มันจะหมดอายุอย่างรวดเร็ว ดังนั้นความเสี่ยงจากการรั่วไหลจึงต่ำ

ขั้นตอนที่ 2: เชื่อมต่อจากเบราว์เซอร์ ด้วย WebRTC คุณจับภาพไมโครโฟน เปิดช่องข้อมูลสำหรับเหตุการณ์ และแลกเปลี่ยน SDP กับเอนด์พอยต์ /v1/realtime/calls:

// ฝั่งเบราว์เซอร์: `EPHEMERAL_KEY` มาจากเซิร์ฟเวอร์ของคุณ
const pc = new RTCPeerConnection();

// เล่นเสียงของโมเดล
pc.ontrack = (e) => (document.getElementById("audio").srcObject = e.streams[0]);

// ส่งไมโครโฟน
const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
pc.addTrack(mic.getTracks()[0]);

// เหตุการณ์จะไหลผ่าน Data Channel
const channel = pc.createDataChannel("oai-events");
channel.onmessage = (e) => console.log(JSON.parse(e.data));

// การจับมือ SDP
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);

const sdpResp = await fetch(
  "https://api.openai.com/v1/realtime/calls?model=gpt-realtime-2.1-mini",
  {
    method: "POST",
    body: offer.sdp,
    headers: {
      Authorization: `Bearer ${EPHEMERAL_KEY}`,
      "Content-Type": "application/sdp",
    },
  }
);
await pc.setRemoteDescription({ type: "answer", sdp: await sdpResp.text() });

เมื่อการเชื่อมต่อทำงาน โมเดลจะรับฟังจากแทร็กไมโครโฟนและพูดผ่าน pc.ontrack คุณส่งการกำหนดค่าและข้อความผ่าน Data Channel oai-events เดียวกัน โดยใช้เหตุการณ์ JSON แบบเดียวกับตัวอย่าง WebSocket ทุกประการ

การกำหนดรูปแบบเซสชัน

ออบเจกต์ session คือที่ที่คุณควบคุมพฤติกรรม นี่คือเวอร์ชันเสียงเต็มรูปแบบที่คุณเห็นข้างต้น:

{
  type: "session.update",
  session: {
    type: "realtime",
    model: "gpt-realtime-2.1-mini",
    output_modalities: ["audio"],
    instructions: "You are a friendly booking assistant. Confirm details before acting.",
    audio: {
      input: {
        format: { type: "audio/pcm", rate: 24000 },
        turn_detection: { type: "semantic_vad" },
      },
      output: {
        format: { type: "audio/pcm", rate: 24000 },
        voice: "marin",
      },
    },
  },
}

ฟิลด์ที่สำคัญ:

• instructions: พรอมต์ระบบของคุณ กำหนดบุคลิก, กฎเกณฑ์, และ "พูดให้สั้น" หากคุณกังวลเรื่องค่าใช้จ่าย
• output_modalities: ["audio"] สำหรับเอเจนต์ที่พูดได้, ["text"] สำหรับบอทที่ถอดเสียงเท่านั้น
• audio.output.voice: เลือกจากเสียงสิบเสียง; marin หรือ cedar จะฟังดูเป็นธรรมชาติที่สุด
• audio.input.turn_detection: วิธีที่โมเดลตัดสินว่าคุณหยุดพูดแล้ว semantic_vad จะรอหยุดพักอย่างเป็นธรรมชาติในความหมาย; server_vad จะทำงานเมื่อเงียบ การตรวจจับเชิงความหมายจะขัดจังหวะน้อยลงและให้ความรู้สึกราบรื่นกว่าในการสนทนา

เปลี่ยนฟิลด์ใดก็ได้ระหว่างการโทรโดยส่ง session.update อีกครั้ง คุณไม่จำเป็นต้องเชื่อมต่อใหม่

การเพิ่มเครื่องมือเพื่อให้เอเจนต์ดำเนินการได้

เอเจนต์เสียงที่ทำได้แค่แชทเป็นเพียงแค่ตัวอย่าง หากต้องการจองโต๊ะหรือตรวจสอบคำสั่งซื้อ โมเดลจำเป็นต้องมีเครื่องมือ Realtime ใช้สัญญาการเรียกฟังก์ชันแบบเดียวกับแพลตฟอร์มส่วนที่เหลือ: คุณประกาศฟังก์ชันในเซสชัน โมเดลจะส่งการเรียก คุณรันมัน และคุณป้อนผลลัพธ์กลับไป หากคุณเคยผูกเครื่องมือเข้ากับ Chat API มาก่อน นี่คือโมเดลความคิดแบบเดียวกัน; คำแนะนำของเราเกี่ยวกับ การเรียกฟังก์ชันของ OpenAI ครอบคลุม Schema อย่างละเอียด และ เอาต์พุตที่มีโครงสร้าง ช่วยเมื่อคุณต้องการให้ Arguments ตรงกับรูปแบบที่เข้มงวด

ประกาศเครื่องมือภายในเซสชัน จากนั้นจัดการเหตุการณ์ response.function_call_arguments.done รันโค้ดของคุณ และโพสต์ conversation.item.create พร้อมผลลัพธ์ก่อน response.create ถัดไป สำหรับสิ่งใดๆ ที่ซับซ้อนกว่าฟังก์ชันสองสามฟังก์ชัน OpenAI's AgentKit จะให้วิธีการจัดการเอเจนต์เสียงแบบหลายขั้นตอนในระดับที่สูงขึ้น

ทดสอบเอนด์พอยต์ด้วย Apidog ก่อนที่คุณจะเริ่มสร้าง

คุณไม่ต้องการดีบั๊กการเรียก REST และการจับมือ WebSocket โดยการอ่านล็อกคอนโซลในแอปที่สร้างไม่เสร็จ ทดสอบส่วนต่างๆ แยกกันก่อน นี่คือที่ที่ Apidog มีบทบาทสำคัญในเวิร์กโฟลว์ Realtime

มีสองสิ่งที่คุณควรตรวจสอบก่อนที่จะเขียนโค้ดไคลเอ็นต์:

1. เอนด์พอยต์โทเค็น POST https://api.openai.com/v1/realtime/client_secrets คือการเรียก REST ธรรมดา สร้างคำขอใน Apidog เพิ่ม Authorization: Bearer header ของคุณ ใส่ JSON body พร้อม ID โมเดลของคุณ แล้วส่ง คุณจะเห็นโทเค็น ek_ และวันหมดอายุทันที ดังนั้นคุณจะรู้ว่าคีย์และการเข้าถึงบัญชีของคุณถูกต้องก่อนที่ WebRTC จะเข้ามาเกี่ยวข้องด้วยซ้ำ เป็นวิธีการเดียวกันกับที่คุณจะใช้เพื่อทดสอบพื้นผิว REST อื่นๆ ของ OpenAI เช่น Responses API
2. การไหลของข้อความ WebSocket Apidog มีไคลเอ็นต์ WebSocket ดังนั้นคุณสามารถเปิดการเชื่อมต่อไปยัง wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini เพิ่ม auth header และส่งข้อความ session.update, conversation.item.create และ response.create ทีละรายการ การดูเหตุการณ์จากเซิร์ฟเวอร์กลับมาในแผงที่อ่านง่ายทำให้ลำดับเหตุการณ์ชัดเจน และคุณสามารถบันทึกข้อความเป็นตัวอย่างสำหรับทีมของคุณได้ หากคุณอาศัย กลยุทธ์การทดสอบ API ที่แข็งแกร่ง อยู่แล้ว สิ่งนี้จะเข้ากันได้ดี

การทดสอบเลเยอร์การส่งข้อมูลด้วยตัวเองหมายความว่าเมื่อมีบางอย่างพังในแอป คุณจะรู้แล้วว่าไม่ใช่ปัญหาของสัญญา API ดาวน์โหลด Apidog หากคุณต้องการทำตาม

ควบคุมค่าใช้จ่าย

เอาต์พุตเสียงเป็นส่วนที่มีราคาแพง ดังนั้นพฤติกรรมบางอย่างจึงช่วยประหยัดได้:

• บอกให้โมเดลพูดสั้นๆ "ตอบกลับแค่หนึ่งหรือสองประโยค" ในคำแนะนำจะช่วยลดโทเค็นเอาต์พุตเสียงโดยตรง
• ปักหมุดสแนปช็อตในการผลิต gpt-realtime-mini-2025-12-15 จะไม่เปลี่ยนแปลง; ชื่อเรียก gpt-realtime-mini สามารถเปลี่ยนแปลงได้
• ใช้ semantic_vad การขัดจังหวะผิดพลาดน้อยลงหมายถึงการตอบกลับที่ไม่สมบูรณ์ที่คุณต้องจ่ายไปลดลง
• แคชพรอมต์ระบบของคุณ อินพุตที่แคชมีราคา $0.30 ต่อ 1M เทียบกับ $0.60 สำหรับอินพุตข้อความใหม่ ดังนั้นบล็อกคำแนะนำที่เสถียรจึงมีราคาถูกกว่าในทุกๆ ตา
• ปิดเซสชันที่ไม่ได้ใช้งาน การเชื่อมต่อที่เปิดอยู่กับผู้ใช้ที่ไม่ได้ใช้งานยังคงเป็นเซสชันที่คุณอาจถูกเรียกเก็บเงิน

ข้อผิดพลาดที่พบบ่อยและการแก้ไข

• 401 Unauthorized: คีย์ไม่ถูกต้อง หรือคุณส่งโทเค็นชั่วคราวที่หมดอายุ คีย์ชั่วคราวมีอายุสั้นตามการออกแบบ; สร้างอันใหม่สำหรับแต่ละเซสชัน
• Model not found: ตรวจสอบ ID ให้ถูกต้อง มันคือ gpt-realtime-2.1-mini ไม่ใช่ gpt-realtime-mini-2.1
• ไม่มีเสียงในเบราว์เซอร์: คุณอาจไม่ได้แนบสตรีมระยะไกลใน pc.ontrack หรือหน้าเว็บไม่ได้อยู่บน HTTPS/localhost ทำให้ไมโครโฟนไม่เปิด
• โมเดลไม่หยุดพูดแทรกผู้ใช้: เปลี่ยน turn_detection เป็น semantic_vad และยืนยันว่าแทร็กไมโครโฟนไปถึงการเชื่อมต่อ
• ส่ง Beta header: เอนด์พอยต์ GA ไม่ต้องการ OpenAI-Beta: realtime=v1 ลบทิ้งไป

คำถามที่พบบ่อย

gpt-realtime-2.1-mini เหมือนกับ gpt-realtime-mini หรือไม่? โดยรวมแล้วใช่ gpt-realtime-2.1-mini เป็น ID เวอร์ชัน ส่วน gpt-realtime-mini เป็นชื่อเรียกที่ชี้ไปยังสแนปช็อตล่าสุด (gpt-realtime-mini-2025-12-15) ใช้ชื่อเรียกเพื่อสร้าง, ปักหมุดสแนปช็อตเพื่อใช้งานจริง

ฉันสามารถใช้สำหรับการถอดเสียงธรรมดาแทนที่จะเป็นเอเจนต์เสียงได้หรือไม่? Realtime API ถูกสร้างขึ้นมาสำหรับการสนทนาแบบโต้ตอบเสียงต่อเสียง สำหรับการถอดเสียงแบบครั้งเดียว โมเดลถอดเสียงเฉพาะของ OpenAI จะเหมาะสมกว่า ใช้โมเดล realtime mini เมื่อคุณต้องการการสนทนาแบบสองทางที่มีความหน่วงต่ำ

ฉันจำเป็นต้องใช้ WebRTC หรือ WebSocket ก็เพียงพอแล้ว? WebSocket ก็เพียงพอสำหรับไปป์ไลน์ฝั่งเซิร์ฟเวอร์และต้นแบบที่รวดเร็ว ใช้ WebRTC เมื่อเบราว์เซอร์หรือแอปพลิเคชันมือถือบันทึกและเล่นเสียงโดยตรง เนื่องจากมันจัดการสตรีมสื่อและ jitter ให้คุณ

ฉันควรเลือกเสียงใด? marin และ cedar เป็นเสียงใหม่ล่าสุดและเป็นธรรมชาติที่สุด และเป็นเอกสิทธิ์ของ Realtime API อีกแปดเสียง (alloy, ash, ballad, coral, echo, sage, shimmer, verse) ยังคงใช้งานได้หากคุณต้องการเสียงเฉพาะ

คิดค่าบริการอย่างไร? คิดเป็นโทเค็น แยกตามรูปแบบ สำหรับ mini: $0.60 ต่อ 1M อินพุตข้อความ, $10 ต่อ 1M อินพุตเสียง, และ $20 ต่อ 1M เอาต์พุตเสียง เอาต์พุตเสียงเป็นต้นทุนหลัก ดังนั้นความละเอียดในการพูดคือปัจจัยหลักของคุณ

มันสามารถเรียกใช้ฟังก์ชันเหมือนโมเดลแชทได้หรือไม่? ได้ Realtime ใช้สัญญาการเรียกฟังก์ชันแบบเดียวกัน ดังนั้นเอเจนต์เสียงสามารถค้นหาคำสั่งซื้อ, ตรวจสอบสินค้าคงคลัง, หรือเรียกใช้การกระทำกลางการสนทนาได้

จะไปต่อที่ไหนดี

ตอนนี้คุณมีวงจรที่สมบูรณ์แล้ว: ID โมเดลที่ถูกต้อง, ต้นแบบ WebSocket, ไคลเอ็นต์ WebRTC สำหรับเบราว์เซอร์, การกำหนดค่าเซสชัน, เครื่องมือ, และวิธีทดสอบแต่ละส่วนใน Apidog ก่อนที่จะนำไปใช้งานจริง เริ่มต้นด้วยตัวอย่าง WebSocket ที่เป็นข้อความเท่านั้นเพื่อยืนยันการเข้าถึง, เปลี่ยน output_modalities เป็นเสียง, จากนั้นย้ายไป WebRTC เมื่อคุณพร้อมสำหรับไมโครโฟนจริง ปักหมุดสแนปช็อต, บอกให้โมเดลพูดสั้นๆ, แล้วคุณก็จะมีเอเจนต์เสียงที่มีความหน่วงต่ำซึ่งจะไม่ทำให้คุณประหลาดใจในใบแจ้งหนี้