คู่มือและชุมชนอิสระสำหรับนักพัฒนา
ข้อมูลทางการเกี่ยวกับ Jev: typesafe.ai

โมเดล Jev AI.
จากแนวคิดสู่การเขียนโค้ด

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

เลือกตามงาน

ปัญญาอีกรูปแบบหนึ่ง

TypeSafe เรียก Jev ว่าโมเดล System One เพราะส่งคืนตัวเลือกแบบมีชนิดข้อมูลและค่าความน่าจะเป็น แทนการสร้างข้อความปลายเปิด ลองเปรียบเทียบว่าแนวทางนี้เหมาะกับงานใดเมื่อใช้ร่วมกับโมเดลเชิงกำเนิดและโค้ดแบบอิงกฎ

ด้านJevLLM กำเนิดโค้ดแบบอิงกฎ
เอาท์พุตตัวเลือกแบบมีชนิดข้อมูล คะแนน และค่าความน่าจะเป็นที่กำหนดไว้ล่วงหน้าข้อความ โค้ด หรือเอาต์พุตที่มีโครงสร้างแบบยืดหยุ่นค่ากำหนดจากเงื่อนไขที่ชัดเจน
ความเร็วปรับให้เหมาะสมสำหรับการตัดสินใจที่มีความหน่วงต่ำ TypeSafe รายงาน 70–500 ms ในการทดสอบขึ้นอยู่กับโมเดล พรอมต์ และความยาวของผลลัพธ์มักจะเร็วมากสำหรับเงื่อนไขที่ทราบ
เหมาะที่สุดสำหรับการตัดสินใจซ้ำๆ ที่ต้องอาศัยความเข้าใจในข้อมูลนำเข้าการเขียน การใช้เหตุผลที่ซับซ้อน และงานปลายเปิดเงื่อนไขที่ชัดเจนพร้อมคำจำกัดความที่มั่นคง
ข้อจำกัดสำคัญไม่สามารถสร้างข้อความอิสระได้ และคำตอบที่มีชนิดข้อมูลถูกต้องก็ยังอาจตัดสินใจผิดเอาต์พุตที่ยืดหยุ่นอาจต้องมีการแยกวิเคราะห์และการตรวจสอบความถูกต้องยากที่จะครอบคลุมทุกกรณีเมื่ออินพุตไม่ชัดเจน
i

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

ความแตกต่างในทางปฏิบัติ

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

แนวคิดหลัก

สร้างขึ้นเพื่อการตัดสินใจภายในซอฟต์แวร์

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

Jev ในสามขั้นตอนตัวอย่างประกอบ · ไม่ใช่ผลลัพธ์จริงจากโมเดล
01ข้อความจากลูกค้า

“ฉันถูกเรียกเก็บค่าสมาชิกซ้ำสองครั้ง ช่วยตรวจสอบให้หน่อยได้ไหม”

02คำถามและทางเลือก

ทีมไหนควรจัดการเรื่องนี้?

คำตอบที่อนุญาต: ฝ่ายเรียกเก็บเงิน · ฝ่ายเทคนิค · ฝ่ายขาย
03ผลลัพธ์ที่มีโครงสร้าง
การเรียกเก็บเงินJev

ตัวอย่างความน่าจะเป็น 0.92

01

ให้ข้อมูลบริบท

ระบุข้อความที่เกี่ยวข้อง สถานะ JSON หรือรายการข้อความ ขณะนี้ Jev ยอมรับข้อความ ไม่ใช่รูปภาพ เสียง หรือวิดีโอ

02

กำหนดพื้นที่คำตอบ

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

03

ให้โค้ดของคุณตัดสินใจว่าอะไรจะเกิดขึ้นต่อไป

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

อ้างอิงจาก เอกสาร TypeSafe อย่างเป็นทางการ

เหมาะกับงานแบบใด

การตัดสินใจเล็กๆ น้อยๆ ในขั้นตอนการทำงานจริง

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

01

การสนับสนุนลูกค้า

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

ตัวอย่างการตัดสินใจนี่เป็นปัญหาการเรียกเก็บเงินหรือปัญหาทางเทคนิคหรือไม่
02

คำแนะนำและการจัดอันดับ

กรองฟีดตามความสนใจที่ผู้ใช้ระบุ และให้คะแนนความเกี่ยวข้องของเนื้อหาโดยใช้สัญญาณการจัดอันดับของคุณร่วมด้วย

ตัวอย่างการตัดสินใจรายการนี้เกี่ยวข้องกับคำขอนี้มากน้อยเพียงใด
03

การประสานงานเอเจนต์

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

ตัวอย่างการตัดสินใจคำขอนี้ควรไปที่โมเดลผู้เชี่ยวชาญหรือไม่
04

ความไว้วางใจและความปลอดภัย

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

ตัวอย่างการตัดสินใจข้อความนี้ละเมิดนโยบายนี้หรือไม่
GitHubjev-guard
05

เกมและการจำลอง

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

ตัวอย่างการตัดสินใจคู่ต่อสู้ควรเลือกท่าที่ถูกกติกาใดต่อไป
06

ระบบอัตโนมัติส่วนตัว

จัดอีเมลและการแจ้งเตือนตามกฎของคุณเอง ประเมินสถานะบ้านอัจฉริยะ หรือตัดสินใจว่าเมื่อใดควรเริ่มกิจวัตรอัตโนมัติ

ตัวอย่างการตัดสินใจการแจ้งเตือนนี้สำคัญพอที่จะขัดจังหวะฉันตอนนี้ไหม
GitHubHA-Jev
เริ่มต้นเลย

จากความอยากรู้ไปจนถึงการตัดสินใจครั้งแรกของคุณ

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

01

เลือกการตัดสินใจ

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

02

กำหนดทางเลือก

กำหนดอินพุต คำถาม และคำตอบที่อนุญาตก่อนเรียกใช้ API

03

จัดการกับความไม่แน่นอน

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

วิธีเชื่อมต่อ API

เพิ่ม Jev ลงในโค้ดของคุณ

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

ลองใช้ Jev ฟรี
TypeScript ฝั่งเซิร์ฟเวอร์typesafe/jev-1.13
const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("Set OPENROUTER_API_KEY");

const response = await fetch("https://openrouter.ai/api/alpha/decisions", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + apiKey,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "typesafe/jev-1.13",
    state: "My card was charged twice. Please help ASAP.",
    questions: {
      department: {
        type: "choice",
        instructions: "Which team should handle this?",
        criteria: {
          billing: "Payments and refunds",
          technical: "Bugs and integrations"
        }
      },
      urgent: {
        type: "noul",
        instructions: "Does this message need urgent attention?"
      }
    }
  })
});

if (!response.ok) throw new Error("Jev request failed: " + response.status);
const {answers} = await response.json();

if (answers.department.choice === "billing" && answers.urgent.noul > 0.8) {
  // Route to the billing review queue.
}
เอนด์พอยต์POST /api/alpha/decisions
อินพุตstate + questions
เอาท์พุตanswers

อ่านคำตอบ

choice ระบุทีมที่เลือก ส่วน noul ส่งคืนค่าตั้งแต่ 0 ถึง 1 สำหรับคำถามแบบใช่/ไม่ใช่ โค้ดของคุณนำทั้งสองค่าไปใช้ร่วมกับกฎการจัดเส้นทางของระบบ

ก่อนที่จะนำไปใช้ในการผลิต

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

การอ้างอิง API: OpenRouter · TypeSafe

LangChain · Python

ใช้ Jev ใน harness ของเอเจนต์ LangChain

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

ModelRouterMiddlewarebefore_agent → wrap_model_call

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

AutoModeMiddlewarewrap_tool_call

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

TypeSafeClassifierChoice · Score · Noul

เพิ่มจุดตรวจของคุณเองได้ด้วย middleware แบบกำหนดเอง: ส่งข้อความหรือสถานะเอเจนต์ให้ TypeSafeClassifier แล้วใช้ผล Choice, Score หรือ Noul เพื่อแยกทางในโค้ดหรือส่งกรณีไม่แน่ชัดให้คนตรวจ

แต่ละช่องหมายถึงอะไร

คำขอกำหนดรูปแบบคำถามและคำตอบ การตอบกลับจะส่งกลับผลลัพธ์สำหรับแต่ละรายการ นี่คือช่อง JSON ที่ใช้ในตัวอย่าง

ฟิลด์คำขอ

model
รหัสโมเดล ตัวอย่างนี้ล็อกไว้ที่ Jev 1.13 เพื่อระบุเวอร์ชันให้ชัดเจน
state
ข้อความหรือข้อมูลที่มีโครงสร้างสำหรับประเมิน เช่น ข้อความที่ส่งถึงฝ่ายสนับสนุน
questions
กลุ่มการตัดสินใจที่ตั้งชื่อไว้ โดยชื่อเหล่านี้จะปรากฏในฟิลด์ answers ของผลลัพธ์ด้วย
type
รูปแบบคำตอบ: choice เลือกหนึ่งตัวเลือก ส่วน noul ประเมินคำถามแบบใช่/ไม่ใช่
instructions
การตัดสินเฉพาะเจาะจงที่คุณต้องการให้โมเดลทำ
criteria
สำหรับ choice: คีย์ตัวเลือกที่อนุญาต พร้อมคำอธิบายสั้น ๆ ของแต่ละตัวเลือก

ฟิลด์ตอบกลับ

answers
หนึ่งผลลัพธ์ต่อคำถาม ส่งคืนภายใต้ชื่อเดียวกัน
choice
คีย์ตัวเลือกที่ choice เลือก ซึ่งเป็นตัวเลือกที่มีค่าความน่าจะเป็นสูงสุด
probabilities
ความน่าจะเป็นของทุกตัวเลือก ค่าเหล่านี้รวมกันเป็น 1
confidence
ค่าความเชื่อมั่นแยกต่างหากที่คำนวณจากการแจกแจงความน่าจะเป็น ไม่ใช่ความน่าจะเป็นของตัวเลือกที่เลือก
noul
ตัวเลขตั้งแต่ 0 (ไม่) ถึง 1 (ใช่) สำหรับคำถามใช่/ไม่ใช่

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

โปรเจกต์

System One.

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

ผลงานอิสระจากชุมชน ไม่ใช่ Jev เวอร์ชันทางการ

คู่มือ System One สำหรับนักพัฒนา ดูโครงการทั้งหมดบน GitHub
ข้อมูลเปิดและข่าวจากชุมชน เปิด Jev AI Radar บน GitHub
เรื่องราวรอบโมเดล

สิ่งที่นักพัฒนากำลังพูด

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

X

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

ดูต้นฉบับ

GitHub

SDK อย่างเป็นทางการสำหรับ JavaScript และ TypeScript แสดงรูปแบบ API ตัวอย่าง และความเคลื่อนไหวของแต่ละรุ่น เหมาะสำหรับตรวจสอบว่าคำขอของ Jev ถูกเขียนในโค้ดอย่างไร

ดูต้นฉบับ

Hacker News

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

ดูต้นฉบับ
ThursdAI · TypeSafe AI

Jev ในการใช้งานจริง: พูดคุยกับทีม TypeSafe

Allie Laabs จาก TypeSafe อธิบาย System One และผลลัพธ์แบบ Choice, Score และ Noul ในรายการ ThursdAI ผู้ดำเนินรายการทดลองจัดประเภทโพสต์ สาธิต Doom และพูดถึงข้อจำกัดของ Jev

ดูต้นฉบับ
ดูวิดีโอบนหน้านี้

ทำความเข้าใจ Jev: การตัดสินใจแบบมีโครงสร้างและข้อจำกัด

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

ดูต้นฉบับ
ทีมเบื้องหลัง Jev

ทำให้การตัดสินใจของ AI ง่ายต่อการใช้งานในซอฟต์แวร์

TypeSafe AI เปิดตัว Jev เป็นโมเดล System One รุ่นแรก เป้าหมายที่ระบุไว้คือการตัดสินใจที่รวดเร็วและมีโครงสร้างซึ่งสามารถใช้งานได้ภายในเวิร์กโฟลว์ซอฟต์แวร์ทั่วไป

Diogo Almeida ผู้ก่อตั้ง เคยทำงานที่ OpenAI และ Google Brain โดย TypeSafe ระบุว่างานของเขาด้าน instruction following และ RLHF มีส่วนต่อยอดงานวิจัยเบื้องหลัง ChatGPT

คำถามที่ดี

คำถามที่ควรค่าแก่การถาม

เจฟเป็นแชทบอทหรือเปล่า?

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

Jev ใช้กับระบบแนะนำได้หรือไม่

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

ผลลัพธ์ที่มีชนิดข้อมูลถูกต้องหมายความว่าการตัดสินใจถูกต้องหรือไม่

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

ฉันจะเรียนรู้วิธีใช้ Jev ได้ที่ไหน

เริ่มจากเอกสารและ SDK อย่างเป็นทางการของ TypeSafe นอกจากนี้ยังเข้าถึง Jev ผ่านหน้าโมเดลบน OpenRouter ได้

เริ่มต้นด้วยคำถามเดียว

ลองใช้ Jev กับการตัดสินใจที่ชัดเจน

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

อัปเดตจากชุมชน

ติดตามระบบนิเวศ Jev ในแบบที่เหมาะกับคุณ

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

อัปเดตสาธารณะอย่างสม่ำเสมอ

Jev AI Radar

คลังโอเพนซอร์สที่นักพัฒนา สคริปต์ และ AI Agent สามารถอ่าน นำไปใช้ต่อ และติดตามการเปลี่ยนแปลงได้

ให้ดาวบน GitHub
เนื้อหาคัดสรรเป็นครั้งคราว

จดหมายข่าว

รับอีเมลเป็นครั้งคราวที่คัดสรรโปรเจกต์จากชุมชน โปรเจกต์ GitHub ที่กำลังได้รับความสนใจ ตัวอย่างโค้ดที่ใช้ได้จริง และแนวทางนำ Jev ไปใช้

เมื่อสมัคร คุณยินยอมรับอีเมลจาก Jev AI Dev เป็นครั้งคราว