การแนะนำ

ในเวลาเพียง 30 นาที ผู้ช่วย AI ภาษาสเปนที่สามารถสร้างแบบฝึกหัดได้ไม่จำกัดจำนวนและให้เกรดอัจฉริยะแบบเรียลไทม์ก็เปิดตัวได้สำเร็จ ระบบแบ็กเอนด์ไม่ได้ทำงานบนคลาวด์กลางที่มีราคาแพง แต่ทำงานบน Gonka ซึ่งเป็นเครือข่ายคอมพิวเตอร์ AI แบบกระจายศูนย์ที่กำลังเติบโต ด้านล่างนี้คือบันทึกการปฏิบัติจริง โค้ดหลัก และการสาธิตออนไลน์ฉบับสมบูรณ์

แนวคิดใหม่สำหรับการประมวลผล AI แบบกระจายอำนาจ

Gonka คือเครือข่ายประมวลผล AI แบบ Proof-of-Work ที่สร้างระบบนิเวศบริการ AI แบบกระจายศูนย์รูปแบบใหม่ โดยการนำระบบ Load Balancing มาใช้กับงานอนุมานแบบ OpenAI ในกลุ่มผู้ให้บริการฮาร์ดแวร์ที่ได้รับการรับรอง เครือข่าย Gonka ใช้โทเค็น GNK เพื่อจูงใจในการชำระเงิน และป้องกันการฉ้อโกงได้อย่างมีประสิทธิภาพผ่านการตรวจสอบแบบสุ่ม สำหรับนักพัฒนา ตราบใดที่พวกเขาเข้าใจวิธีการเรียกใช้ OpenAI API พวกเขาสามารถผสานรวมกับเครือข่าย Gonka เพื่อปรับใช้แอปพลิเคชันได้อย่างรวดเร็ว

กรณีศึกษาในโลกแห่งความเป็นจริง: แอปพลิเคชันการเรียนรู้ภาษาสเปนอัจฉริยะ

เราจะสร้างแอปพลิเคชันการเรียนรู้ภาษาสเปนที่สร้างแบบฝึกหัดเฉพาะบุคคลอย่างต่อเนื่อง ลองนึกภาพกรณีการใช้งานนี้:

• หลังจากที่ผู้ใช้คลิก "เริ่มแบบฝึกหัดใหม่" AI จะสร้างประโยคเติมคำที่มีช่องว่างเพียงช่องเดียว
• ผู้ใช้เพียงป้อนคำตอบและคลิก "ตรวจสอบ" จากนั้น AI จะให้คะแนนและวิเคราะห์เฉพาะบุคคลทันที
• ระบบจะดำเนินการไปยังแบบฝึกหัดถัดไปโดยอัตโนมัติ เพื่อสร้างวงจรการเรียนรู้ที่สมจริง

การสาธิตออนไลน์: carrera.gonka.ai

การวิเคราะห์สถาปัตยกรรมทางเทคนิค

แอปพลิเคชันใช้สถาปัตยกรรมการแยกส่วน front-end และ back-end แบบคลาสสิก:

• React frontend: สร้างขึ้นบน Vite เข้ากันได้อย่างสมบูรณ์กับมาตรฐานอินเทอร์เฟซ OpenAI
• เลเยอร์พร็อกซีโหนด: โค้ดหลักเพียง 50 บรรทัด รับผิดชอบการลงนามและส่งต่อคำขอ

ความแตกต่างเพียงอย่างเดียวจากการผสานรวม OpenAI แบบดั้งเดิมคือการเพิ่มขั้นตอนการลงนามฝั่งเซิร์ฟเวอร์ ซึ่งรับประกันความปลอดภัยที่สำคัญ การดำเนินการอื่นๆ ทั้งหมดยังคงสอดคล้องกับการเรียกแชทเสร็จสิ้น OpenAI มาตรฐาน

คู่มือเริ่มต้นอย่างรวดเร็ว

ข้อกำหนดสภาพแวดล้อม: Node.js 20+

โคลนที่เก็บข้อมูล

git clone git@github.com:product-science/carrera.git

ซีดี คาร์เรร่า

สร้างบัญชี Gonka และตั้งค่าตัวแปรสภาพแวดล้อม

# สร้างบัญชีโดยใช้ CLI ที่อนุมานได้

# ดูคู่มือเริ่มต้นใช้งานฉบับย่อสำหรับข้อมูล CLI วิธีการดาวน์โหลด:

# https://gonka.ai/developer/quickstart/#2-สร้างบัญชี

# ACCOUNT_NAME สามารถเป็นชื่อเฉพาะในพื้นที่ใดๆ ก็ได้ โดยทำหน้าที่เป็นตัวระบุที่อ่านได้สำหรับคู่คีย์บัญชี

ACCOUNT_NAME="carrera-quickstart"

NODE_URL=http://node2.gonka.ai:8000

อนุมานสร้างไคลเอนต์ "$ACCOUNT_NAME" \

--node-address "$NODE_URL

# ส่งออกคีย์ส่วนตัว (ใช้ฝั่งเซิร์ฟเวอร์เท่านั้น)

ส่งออก GONKA_PRIVATE_KEY=$(คีย์อนุมานส่งออก "$ACCOUNT_NAME" --unarmored-hex --unsafe)

เริ่มบริการพร็อกซี

ซีดี กอนก้า-พร็อกซี

npm ติดตั้ง && npm รันบิลด์

NODE_URL=http://node2.gonka.ai:8000 ALLOWED_ORIGINS=http://localhost:5173 PORT=8080 npm เริ่มต้น

การตรวจสุขภาพ

ขด http://localhost:8080/healthz

# ค่าส่งคืนที่คาดหวัง: {"ok":true,"ready":true}

การรันแอปพลิเคชันส่วนหน้า

เว็บซีดี

การติดตั้ง npm

VITE_DEFAULT_API_BASE_URL=http://localhost:8080/v1 npm รัน dev

ในแอปพลิเคชัน ให้เปิด "การตั้งค่า" → URL พื้นฐานจะถูกกรอกไว้ล่วงหน้า เลือกโมเดล (เช่น Qwen/Qwen3-235B-A22B-Instruct-2507-FP8; คุณสามารถเข้าไปที่ https://node1.gonka.ai:8443/api/v1/models เพื่อดูรายการโมเดลที่มีอยู่ในปัจจุบัน) แล้วคลิก "ทดสอบการเชื่อมต่อ"

การนำเทคโนโลยีหลักมาใช้

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

ตัวแปรสภาพแวดล้อมที่ใช้โดยบริการพร็อกซี:

// gonka-proxy/src/env.ts

ส่งออก const env = {

พอร์ต: num("พอร์ต", 8080),

GONKA_PRIVATE_KEY: str("GONKA_PRIVATE_KEY"),

NODE_URL: str("NODE_URL"),

ALLOWED_ORIGINS: (process.env.ALLOWED_ORIGINS ?? "*")

.แยก(",")

.แผนที่((s) => s.trim())

.filter(บูลีน),

-

ใช้ Gonka OpenAI TypeScript SDK (gonka-openai) เพื่อสร้างไคลเอนต์ (มีเวอร์ชัน Go และ Python ให้ด้วย และมีการรองรับภาษาอื่นๆ เพิ่มเติมอย่างต่อเนื่อง ดังนั้นโปรดใส่ใจกับฐานโค้ด):

// gonka-proxy/src/gonka.ts

นำเข้า { GonkaOpenAI, solveEndpoints } จาก "gonka-openai";

นำเข้า { env } จาก "./env";

ส่งออกฟังก์ชัน async createGonkaClient() {

const endpoints = รอ resolveEndpoints({ sourceUrl: env.NODE_URL });

ส่งคืน GonkaOpenAI ใหม่({ gonkaPrivateKey: env.GONKA_PRIVATE_KEY, endpoints });

-

เปิดเผยจุดสิ้นสุดการแชทที่เข้ากันได้กับ OpenAI (/v1/chat/completions):

// gonka-proxy/src/server.ts

app.get("/healthz", (_req, res) => res.json({ ok: true, ready }));

app.post("/v1/chat/completions", async (req, res) => {

หากพบ `!ready` หรือ `!client` ให้ส่งคืน `res.status(503).json({ error: { message: "Proxy not ready" } });`

const body = req.body เป็น ChatCompletionRequest;

หาก (!body || !body.model || !Array.isArray(ข้อความร่างกาย)) {

return res.status(400).json({ error: { message: "ต้องระบุพารามิเตอร์ 'model' และ 'messages'" } });

-

พยายาม {

const streamRequested = Boolean(กระแสข้อมูลของร่างกาย);

const { stream: _ignored, ...rest } = body;

หาก (!streamRequested) {

const response = รอ client.chat.completions.create({ ...rest, stream: false });

ส่งคืน res.status(200).json(การตอบสนอง);

-

-

ไฟล์ server.ts ยังรองรับการรองรับ pass-through สำหรับบริการสตรีมมิ่ง (SSE) ซึ่งนักพัฒนาสามารถเปิดใช้งานได้ในไคลเอนต์ที่รองรับการสตรีมมิ่งโดยตั้งค่า `stream: true` นอกจากนี้ Gonka ยังมี Dockerfile เพื่อให้มั่นใจว่าสามารถสร้างซ้ำได้และปรับใช้ได้ง่าย

# gonka-proxy/Dockerfile

# ---- เฟสการสร้าง ----

จากโหนด: 20-alpine AS build

WORKDIR /แอป

คัดลอกแพ็กเกจ*.json tsconfig.json ./

คัดลอก src ./src

รัน npm ci && npm run build

# ---- ระยะปฏิบัติการ ----

จากโหนด: 20-อัลไพน์

WORKDIR /แอป

ENV NODE_ENV=การผลิต

คัดลอก --จาก=สร้าง /app/package*.json ./

รัน npm ci --omit=dev

คัดลอก --จาก=สร้าง /app/dist ./dist

เปิดเผย 8080

CMD ["โหนด", "dist/server.js"]

การวิเคราะห์ทางเทคนิค: Front-end (การออกแบบอิสระจากผู้ขาย)

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

การโต้ตอบแบ็กเอนด์ทั้งหมดดำเนินการใน web/src/llmClient.ts ซึ่งจะเรียกจุดสิ้นสุดการแชทเพียงครั้งเดียว:

// เว็บ/src/llmClient.ts

const url = `${s.baseUrl.replace(/\/+$/, "")}/แชท/การเสร็จสิ้น`;

const headers: Record<string, string> = { "Content-Type": "application/json" };

หาก (s.apiKey) headers.Authorization = `Bearer ${s.apiKey}`; // พารามิเตอร์เสริม

const res = รอการดึงข้อมูล (url, {

วิธีการ: "โพสต์"

ส่วนหัว,

เนื้อหา: JSON.stringify({ model: s.model, messages, temperature }),

สัญญาณ

-

หาก (!res.ok) {

const body = รอ res.text().catch(() => "");

โยนข้อผิดพลาดใหม่(`LLM ข้อผิดพลาด ${res.status}: ${body}`);

-

const data = รอ res.json();

const text = data?.choices?.[0]?.message?.content ?? "";

กลับ { ข้อความ, ข้อมูลดิบ };

หากต้องการระบุผู้ให้บริการ API เพียงกำหนดค่า URL พื้นฐานในป๊อปอัป "การตั้งค่า" ที่ด้านบน คุณยังสามารถตั้งค่าโมเดลได้ที่นี่ โดยค่าเริ่มต้นคือ Qwen/Qwen3-235B-A22B-Instruct-2507-FP8 สำหรับการทดสอบภายในเครื่องในสภาพแวดล้อมออฟไลน์ ให้ตั้งค่า URL พื้นฐานเป็น mock:; สำหรับการเรียกใช้งานจริง ให้ตั้งค่าเป็นที่อยู่พร็อกซีของนักพัฒนา (กรอกไว้ล่วงหน้าในส่วนการเริ่มต้นใช้งานด่วน):

// เว็บ/src/settings.ts

ฟังก์ชันการส่งออก getDefaultSettings(): การตั้งค่า {

const prodBase = (import.meta เป็นใด ๆ ).env?.VITE_DEFAULT_API_BASE_URL || "";

const baseUrlDefault = prodBase || "mock:";

ส่งคืน { baseUrl: baseUrlDefault, apiKey: "", model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8" };

-

การแจ้งเตือนการใช้งานและกลไกการให้คะแนน

เราใช้เทมเพลตคำเตือนสองแบบ:

ข้อความแจ้งเตือนเครื่องกำเนิด: "คุณเป็นครูสอนภาษาสเปน... เอาท์พุตเฉพาะรูปแบบ JSON ที่เข้มงวด... สร้างประโยคทดสอบเติมคำที่มีช่องว่าง (____) เพียงหนึ่งช่อง โดยรวมทั้งคำตอบ คำแนะนำ และระดับความยาก"

เคล็ดลับการให้คะแนน: "คุณเป็นครูสอนภาษาสเปนที่กำลังให้คะแนนการบ้าน... เอาต์พุตเป็นรูปแบบ JSON ที่เข้มงวด รวมถึงสถานะผ่าน/ไม่ผ่านและคำแนะนำในการแยกวิเคราะห์"

ตัวอย่างโค้ดสำหรับกระบวนการสร้าง:

// เว็บ/src/App.tsx

const sys: ChatMsg = {

บทบาท: "ระบบ"

เนื้อหา: คุณเป็นครูสอนภาษาสเปนที่กำลังออกแบบแบบฝึกหัดแบบโต้ตอบ

เอาต์พุตเฉพาะในรูปแบบ JSON ที่เข้มงวด (ไม่มีข้อความอธิบาย ไม่มีมาร์กอัปโค้ด) อ็อบเจ็กต์ต้องมีคีย์ต่อไปนี้:

-

"ประเภท": "เติมคำ"

"ข้อความ": "<ประโยคภาษาสเปนที่มีช่องว่างหนึ่งช่องที่ทำเครื่องหมายด้วย ____>",

"คำตอบ": "<คำตอบที่ถูกต้องเพียงคำตอบเดียวในช่องว่าง>",

"คำแนะนำ": "<คำแนะนำที่ชัดเจน>",

"ความยาก": "ผู้เริ่มต้น|ระดับกลาง|ระดับสูง"

-

แนวทางเนื้อหา:

- การใช้ฉากชีวิตที่เป็นธรรมชาติ

- เว้นว่างไว้เพียงช่องเดียว (ใช้เครื่องหมาย ____ ในประโยคอย่างแม่นยำ)

- ความยาวของประโยคควรอยู่ระหว่าง 8 ถึง 20 คำ

- ประโยคเป็นภาษาสเปนเท่านั้น คำอธิบายอาจเป็นภาษาอังกฤษ

- การฝึกฝนที่หลากหลายมุ่งเน้นไปที่: ser/estar, กาลอดีตและกาลไม่สมบูรณ์, อารมณ์สมมติ, por/para, ความสอดคล้อง, คำบุพบททั่วไป, คำศัพท์หลัก

-

เราได้เพิ่มตัวอย่างแบบ Few-shot หลายตัวอย่างเพื่อช่วยให้โมเดลเข้าใจรูปแบบผลลัพธ์ จากนั้นจึงวิเคราะห์ JSON และแสดงผลแบบฝึกหัด กระบวนการให้คะแนนยังใช้รูปแบบ JSON ที่เข้มงวดเพื่อแสดงผลการทดสอบผ่าน/ไม่ผ่าน พร้อมคำอธิบายสั้นๆ

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

// เว็บ/src/App.tsx

// ตัวแยก JSON ที่ทนทานต่อความผิดพลาด ปรับเอาต์พุตของโมเดลที่อาจมีข้อความอธิบายหรือมาร์กอัปโค้ด

ฟังก์ชัน extractJsonObject<TExpected>(raw: string): TExpected {

const trimmed = String(ดิบ ?? "").trim();

const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);

const candidate = fence ? fence[1] : ตัดแต่งแล้ว;

const tryParse = (s: string) => {

พยายาม {

ส่งคืน JSON.parse(s) เป็น TExpected

} จับ {

กลับไม่กำหนด;

-

-

const direct = tryParse(ผู้สมัคร);

ถ้า (direct) กลับเป็น direct;

const start = candidate.indexOf("{");

const end = candidate.lastIndexOf("}");

ถ้า (เริ่มต้น !== -1 และสิ้นสุด !== -1 และสิ้นสุด > เริ่มต้น) {

const block = candidate.slice(เริ่มต้น, สิ้นสุด + 1);

const parsed = tryParse(บล็อก);

ถ้าแยกวิเคราะห์แล้ว ให้ส่งคืน pared;

-

โยนข้อผิดพลาดใหม่ ("ไม่สามารถแยกวิเคราะห์ JSON จากการตอบสนองของโมเดล");

-

ข้อเสนอแนะติดตามสำหรับนักพัฒนา:

• เพิ่มประเภทการออกกำลังกายที่กำหนดเองและกฎการให้คะแนน

• เปิดใช้งาน UI ของเหลว (SSE ได้รับการรองรับโดยพร็อกซีแล้ว)

• เพิ่มการตรวจสอบสิทธิ์และการจำกัดอัตราให้กับโบรกเกอร์ Gonka

• ปรับใช้พร็อกซีกับโครงสร้างพื้นฐานของนักพัฒนาและตั้งค่า VITE_DEFAULT_API_BASE_URL เมื่อสร้างแอปพลิเคชันเว็บ

บทสรุปและแนวโน้ม

ทำไมต้องเลือก Gonka?

1. ข้อได้เปรียบด้านต้นทุน: เมื่อเปรียบเทียบกับบริการคลาวด์แบบดั้งเดิม การประมวลผลแบบกระจายอำนาจจะช่วยลดต้นทุนการอนุมานได้อย่างมาก
2. การปกป้องความเป็นส่วนตัว: คำขอจะได้รับการลงนามผ่านพร็อกซี และคีย์จะไม่ถูกเปิดเผย
3. ความเข้ากันได้: เข้ากันได้อย่างสมบูรณ์กับระบบนิเวศ OpenAI ด้วยต้นทุนการไมเกรชันที่ต่ำมาก
4. ความน่าเชื่อถือ: เครือข่ายแบบกระจายช่วยให้มั่นใจได้ว่ามีบริการที่มีความพร้อมใช้งานสูง

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

ลิงก์ต้นฉบับ: https://what-is-gonka.hashnode.dev/build-a-productionready-ai-app-on-gonka-endtoend-guide

เกี่ยวกับ Gonka.ai

Gonka คือเครือข่ายแบบกระจายศูนย์ที่ออกแบบมาเพื่อมอบพลังการประมวลผล AI ที่มีประสิทธิภาพ เพิ่มประสิทธิภาพการใช้พลังการประมวลผล GPU ทั่วโลกให้สูงสุดเพื่อบรรลุภาระงาน AI ที่สำคัญ ด้วยการขจัดระบบเกตเวย์แบบรวมศูนย์ Gonka จึงมอบสิทธิ์การเข้าถึงทรัพยากรการประมวลผลแบบไม่ต้องขออนุญาตแก่นักพัฒนาและนักวิจัย ขณะเดียวกันก็มอบรางวัลแก่ผู้เข้าร่วมทุกคนผ่านโทเค็นดั้งเดิม GNK

Gonka ได้รับการบ่มเพาะโดย Product Science Inc. ผู้พัฒนา AI สัญชาติอเมริกัน ก่อตั้งโดยพี่น้องตระกูล Liberman ผู้คร่ำหวอดในวงการ Web 2 และอดีตผู้อำนวยการฝ่ายผลิตภัณฑ์หลักของ Snap Inc. บริษัทประสบความสำเร็จในการระดมทุน 18 ล้านดอลลาร์ในปี 2023 นักลงทุนประกอบด้วย Coatue Management ซึ่งเป็นนักลงทุนใน OpenAI, Slow Ventures ซึ่งเป็นนักลงทุนใน Solana, K5 และพันธมิตรจาก Insight และ Benchmark ผู้ร่วมก่อตั้งโครงการในช่วงแรก ๆ ได้แก่ บริษัทชั้นนำในสาขา Web 2-Web 3 เช่น 6blocks, Hard Yaka, Gcore และ Bitfury

เว็บไซต์อย่างเป็นทางการ | Github | X | Discord | เอกสารเผยแพร่ | แบบจำลองเศรษฐกิจ | คู่มือผู้ใช้