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

ประเด็นสำคัญ
- แพ็กเกจ openai npm ทำงานได้ทันที: เปลี่ยน baseURL, apiKey และโมเดลเป็น
uncensored - อย่าส่งคีย์ไปกับโค้ดเบราว์เซอร์ ให้เรียกใช้เส้นทางของเซิร์ฟเวอร์ขนาดเล็กแทน
- การสตรีมใช้ server-sent events และการเปิดสตรีมหนึ่งรายการจะใช้ช่อง concurrent หนึ่งช่อง
- การใช้ 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 และระดับโบนัส และ เอกสาร สำหรับรายการพารามิเตอร์ครบถ้วน