TH ▾
รับคีย์ API

การตั้งค่า API Character AI ใน JS: Node และเว็บแอป

การตั้งค่า Character AI API JS ขึ้นอยู่กับแพ็กเกจ npm ทางการของ openai, base URL และเส้นทางเซิร์ฟเวอร์ที่เก็บคีย์ของคุณไว้จากเบราว์เซอร์ หน้าเว็บนี้แสดงโค้ด Node, เอนด์พอยต์สตรีมมิง Express และการเรียก fetch ด้านหน้าเว็บที่สอดคล้องกัน

แผงเบราว์เซอร์ที่เชื่อมต่อกับกล่องเซิร์ฟเวอร์ด้วยท่อเรืองแสงพร้อมฟองแชท แสดงการออกแบบพร็อกซี JS

ประเด็นสำคัญ

  1. แพ็กเกจ openai npm ทำงานได้ทันที: เปลี่ยน baseURL, apiKey และโมเดลเป็น uncensored
  2. อย่าส่งคีย์ไปกับโค้ดเบราว์เซอร์ ให้เรียกใช้เส้นทางของเซิร์ฟเวอร์ขนาดเล็กแทน
  3. การสตรีมใช้ server-sent events และการเปิดสตรีมหนึ่งรายการจะใช้ช่อง concurrent หนึ่งช่อง
  4. การใช้ fetch ธรรมดาก็ใช้งานได้เช่นกันหากคุณต้องการไม่ต้องพึ่งพาไลบรารี

สรุปสั้นๆ

คุณสามารถเข้าถึงเอนด์พอยต์จาก JavaScript ได้สามวิธี: แพ็คเกจ npm openai, การใช้ fetch แบบธรรมดา หรือไลบรารีใดๆ ที่รองรับรูปแบบแชทของ OpenAI อยู่แล้ว Base URL คือ https://api.characteraiapi.com/v1, ID ของโมเดลคือ uncensored, และทุกคำขอจะมี Authorization: Bearer <key> หากคุณยังไม่มีคีย์ หน้าคีย์ API อธิบายวิธีการสมัครและเครดิตทดลองใช้ $0.50 แบบคลิกเดียว

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

Node ด้วยแพ็กเกจ openai

สร้างโปรเจกต์ ติดตั้งแพ็กเกจ และใช้ ES modules ตัวอย่างสมมติว่าใช้ Node 18 ขึ้นไป

mkdir persona-chat && cd persona-chat
npm init -y
npm pkg set type=module
npm install openai express
export API_KEY="paste-your-key-here"

สคริปต์แรกใน chat.js:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.characteraiapi.com/v1",
  apiKey: process.env.API_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "system", content: "You are Juno, a sarcastic lighthouse keeper. Stay in character." },
    { role: "user", content: "A boat is signalling in the fog. Thoughts?" },
  ],
  temperature: 0.9,
});

console.log(completion.choices[0].message.content);
console.log(completion.usage);

รันด้วยคำสั่ง node chat.js วัตถุ usage บอกจำนวนโทเคนพรอมต์และโทเคนคำตอบที่ใช้ ซึ่งคุณสามารถคูณด้วย $0.15 และ $0.50 ต่อล้านโทเคนเพื่อดูราคาจริง

อย่าใส่คีย์ไว้ในโค้ดเบราว์เซอร์

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

วิธีนี้ยังให้คุณมีจุดบังคับใช้กฎที่ API ไม่รู้จัก เช่น บุคลิกภาพที่ผู้ใช้ไม่สามารถเขียนทับได้ ขีดจำกัดจำนวนข้อความต่อผู้ใช้ และการตัดประวัติที่ยาวเกินไป เบราว์เซอร์ควรส่งเฉพาะข้อความใหม่ของผู้ใช้และ ID การสนทนา ไม่ใช่ system prompt

เอนด์พอยต์สตรีมมิงของ Express

นี่คือเซิร์ฟเวอร์ขนาดเล็กที่มีเส้นทางเดียว มันเก็บเซสชันไว้ในหน่วยความจำสำหรับตัวอย่าง; ใช้ฐานข้อมูลสำหรับการใช้งานจริง

import express from "express";
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.characteraiapi.com/v1",
  apiKey: process.env.API_KEY,
});

const PERSONA = "You are Juno, a sarcastic lighthouse keeper. Stay in character, two to four sentences.";
const sessions = new Map();

const app = express();
app.use(express.json({ limit: "100kb" }));
app.use(express.static("public"));

app.post("/api/chat", async (req, res) => {
  const { id, text } = req.body;
  if (!id || !text) return res.status(400).json({ error: "id and text required" });

  const history = sessions.get(id) ?? [{ role: "system", content: PERSONA }];
  history.push({ role: "user", content: text });

  res.setHeader("Content-Type", "text/plain; charset=utf-8");

  try {
    const stream = await client.chat.completions.create({
      model: "uncensored",
      messages: [history[0], ...history.slice(-20)],
      stream: true,
    });
    let reply = "";
    for await (const chunk of stream) {
      const piece = chunk.choices[0]?.delta?.content ?? "";
      if (piece) {
        reply += piece;
        res.write(piece);
      }
    }
    history.push({ role: "assistant", content: reply });
    sessions.set(id, history);
    res.end();
  } catch (err) {
    res.status(err.status === 429 ? 429 : 500).end("error");
  }
});

app.listen(3000);

การตัดรายการนี้จะเก็บข้อความระบบและข้อความล่าสุด 20 ข้อความไว้ ข้อความเก่าจะถูกตัดทิ้งจะช่วยรักษาต้นทุนให้คงที่ การส่งเฉพาะข้อความธรรมดาของแต่ละชิ้นส่วนทำให้ฝั่งเบราว์เซอร์เรียบง่าย หากต้องการเหตุการณ์ที่ละเอียดขึ้น ให้ส่ง server-sent events แทนและแยกวิเคราะห์ที่ไคลเอนต์

Server-sent events สำหรับการสตรีมที่ซับซ้อนขึ้น

การส่งข้อความธรรมดาใช้งานได้สำหรับตัวอย่าง แต่อินเทอร์เฟซแชทจริงมักต้องการมากกว่าข้อความ: สัญญาณเมื่อการตอบกลับเสร็จสิ้น ข้อผิดพลาดระหว่างสตรีม หรือการใช้โทเคนที่สิ้นสุด Server-sent events ให้ข้อความที่มีชื่อผ่านการเชื่อมต่อ HTTP เดียว เส้นทางของคุณเขียนบรรทัดในรูปแบบ SSE และเบราว์เซอร์อ่านด้วยโปรแกรมแยกวิเคราะห์ขนาดเล็ก

// server: inside the route, after setting headers
res.setHeader("Content-Type", "text/event-stream");
res.setHeader("Cache-Control", "no-cache");

for await (const chunk of stream) {
  const piece = chunk.choices[0]?.delta?.content ?? "";
  if (piece) res.write(`data: ${JSON.stringify({ token: piece })}\n\n`);
}
res.write(`data: ${JSON.stringify({ done: true })}\n\n`);
res.end();

การเข้ารหัสแต่ละ token เป็น JSON ช่วยหลีกเลี่ยงข้อบกพร่องคลาสสิก: token ที่มีการขึ้นบรรทัดใหม่ จะทำลายโครงสร้าง SSE บนไคลเอนต์ ให้อ่าน body การตอบกลับ แยกบรรทัดว่าง ลบ prefix data: และแยกวิเคราะห์ JSON ข้อความ done บอกอินเทอร์เฟซให้เปิดใช้งานกล่อง input และเปิดใช้งานปุ่มส่งอีกครั้ง

จัดการการตัดการเชื่อมต่อ เมื่อผู้ใช้ปิดแท็บ ออบเจกต์การตอบกลับบนเซิร์ฟเวอร์จะปล่อยอีเวนต์ close ให้ฟังอีเวนต์นี้และยกเลิกคำขอ upstream มิฉะนั้นเซิร์ฟเวอร์จะดึงโทเคนที่ไม่มีใครอ่าน และสตรีมจะยึดช่อง concurrent ไว้หนึ่งช่อง SDK ของ OpenAI รับค่า AbortSignal ในตัวเลือกคำขอเพื่อจุดประสงค์นี้

ฝั่งเบราว์เซอร์

หน้าเว็บเรียกเส้นทางของคุณเอง ไม่ใช่โฮสต์ API การอ่านการตอบกลับแบบสตรีมด้วย fetch ใช้เพียงไม่กี่บรรทัด:

const id = crypto.randomUUID();

async function send(text, onToken) {
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ id, text }),
  });
  if (!res.ok) throw new Error("request failed: " + res.status);

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    onToken(decoder.decode(value, { stream: true }));
  }
}

send("Is the lamp lit?", (t) => { document.querySelector("#out").textContent += t; });

ปิดปุ่มส่งขณะการตอบกลับกำลังสตรีม ป้องกันการส่งซ้ำและเคารพขีดจำกัด concurrent เพราะคำขอสตรีมจะยึดช่องของมันจนกว่าจะสิ้นสุด

จัดการเซสชันให้ถูกต้อง

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

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

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

fetch ธรรมดา เครื่องมือ และโหมด JSON

หากคุณไม่ต้องการพึ่งพา dependency การเรียกแบบ raw ทำงานในลักษณะเดียวกัน รันสิ่งนี้จากเซิร์ฟเวอร์ worker หรือสคริปต์ ไม่ใช่จากโค้ดหน้าเว็บสาธารณะ

const r = await fetch("https://api.characteraiapi.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + process.env.API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "uncensored",
    response_format: { type: "json_object" },
    messages: [
      { role: "system", content: "Reply with JSON only: {\"mood\": string, \"line\": string}" },
      { role: "user", content: "Juno sees a light on the water." },
    ],
  }),
});
const data = await r.json();
console.log(JSON.parse(data.choices[0].message.content));

การเรียกใช้ฟังก์ชันทำงานด้วยฟิลด์ tools และ tool_choice เดียวกันที่ SDK ส่ง เมื่อโมเดลส่งคืน tool_calls ให้เรียกใช้ฟังก์ชันและส่งผลลัพธ์กลับเป็นข้อความด้วย role: "tool" และ tool_call_id ที่ตรงกัน ในเกมสิ่งนี้มีประโยชน์สำหรับการทอดลูกเต๋า การค้นหาสินค้าคงคลัง หรือการค้นหาสิ่งที่ตัวละครจำเกี่ยวกับผู้เล่น เมื่อสตรีมมิง การเรียกใช้ฟังก์ชันจะมาถึงเป็นชิ้นส่วนย่อยที่คุณต้องรวมก่อนแยกวิเคราะห์อาร์กิวเมนต์

โฮสติ้ง ขีดจำกัด และต้นทุน

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

สำหรับพร็อกซีย้อนกลับเช่น nginx การบัฟเฟอร์ response เป็นสาเหตุทั่วไปและมีค่าตั้งค่าเพื่อปิดใช้งานต่อ location สำหรับฟังก์ชัน serverless ให้มองหาโหมดการตอบกลับแบบสตรีมในเอกสารแพลตฟอร์ม หากโฮสต์ของคุณไม่สามารถสตรีมมิงได้ โปรเซส Nodeที่ทำงานตลอดเวลาบนเซิร์ฟเวอร์ราคาถูกเป็นตัวเลือกสำรองที่เชื่อถือได้

สุดท้าย ให้ใส่ secret ในที่เก็บตัวแปรสภาพแวดล้อมของโฮสต์และเก็บมันไว้จากผลลัพธ์การ build เครื่องมือ build หน้าเว็บมักรวมตัวแปรใดๆ ที่มี prefix สาธารณะลงในบุนเดิลเบราว์เซอร์ ดังนั้นใช้ชื่อที่ไม่มี prefix นั้น และอ่านเฉพาะในโค้ดเซิร์ฟเวอร์ การตรวจสอบอย่างรวดเร็วคือการค้นหาไฟล์ที่ build แล้วสำหรับอักขระไม่กี่ตัวแรกของคีย์

ขีดจำกัด การลองซ้ำ และต้นทุน

คีย์เต็มจำนวนอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้ทำ 2 และ 60 เมื่อเกินขีดจำกัด API จะตอบกลับด้วย HTTP 429 และโค้ด rate_limited หรือ concurrency การโอเวอร์โหลดชั่วคราวก็เป็น 429 เช่นกันและรวม Retry-After: 5 ใน JavaScript SDK จะโยนข้อผิดพลาดด้วย status === 429; จับมัน รอ และลองอีกครั้ง SDK ยังลองใหม่โดยอัตโนมัติซึ่งคุณสามารถปรับแต่งได้ด้วยตัวเลือก maxRetries บนไคลเอนต์

ต้นทุนต่อรอบประมาณได้ง่าย การแชทที่มี 2,000 input tokens และ 250 output tokens มีต้นทุน 2,000 x $0.15 / 1,000,000 = $0.0003 สำหรับ input และ 250 x $0.50 / 1,000,000 = $0.000125 สำหรับ output ดังนั้น $0.000425 หนึ่งพันรอบมีต้นทุน $0.425 คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดู หน้าราคา สำหรับการเติมเงินตั้งแต่ $20 ถึง $500 และระดับโบนัส และ เอกสาร สำหรับรายการพารามิเตอร์ครบถ้วน

ถาม-ตอบ

ฉันสามารถเรียก API โดยตรงจากแอป React หรือ Vue ได้หรือไม่?

ในทางเทคนิคใช่ แต่คีย์จะปรากฏต่อผู้เยี่ยมชมทุกคน ใช้เส้นทางเซิร์ฟเวอร์ขนาดเล็กที่เพิ่มคีย์และส่งต่อคำขอ

ฉันควรใช้แพ็คเกจ npm ตัวใด?

แพ็คเกจ openai ทางการใช้งานได้ ตั้ง baseURL เป็น endpoint ใช้คีย์ของคุณเป็น apiKey และโมเดล uncensored การ fetch ธรรมดาก็ใช้ได้เช่นกัน

มันทำงานบน Deno, Bun หรือ Cloudflare Workers ได้หรือไม่?

รันไทม์ใดๆ ที่สามารถสร้างคำขอ HTTPS พร้อมเฮดเดอร์ Bearer สามารถเรียกใช้ได้ แพ็คเกจ openai รองรับรันไทม์หลายตัว ดังนั้นตรวจสอบเอกสารของมันสำหรับรันไทม์ของคุณ

ฉันจะสตรีมโทเคนไปยังหน้าเว็บได้อย่างไร?

ตั้งค่า stream: true บนเซิร์ฟเวอร์ ส่งต่อแต่ละชิ้นส่วนไปยังเบราว์เซอร์ และอ่านด้วยตัวอ่าน fetch แต่ละสตรีมที่เปิดอยู่จะครอบครองช่อง concurrent หนึ่งช่อง

นี่คือ API ทางการของ Character.ai หรือไม่?

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

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API