หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

อาจารย์ผู้สอน

การสกัดที่มีโครงสร้างใน typeScript ขับเคลื่อนโดย LLMs ออกแบบมาเพื่อความเรียบง่ายความโปร่งใสและการควบคุม

ดำดิ่งลงสู่โลกของการสกัดที่มีโครงสร้างตาม typeScript โดยฟังก์ชั่นการเรียก API และ ZOD ของ OpenAI, การตรวจสอบสคีมา TypeScript-First-First ด้วยการอนุมานแบบคงที่ ผู้สอนโดดเด่นสำหรับความเรียบง่ายความโปร่งใสและการออกแบบผู้ใช้เป็นศูนย์กลาง ไม่ว่าคุณจะเป็นนักพัฒนาที่มีประสบการณ์หรือเพิ่งเริ่มต้นคุณจะพบวิธีการของผู้สอนที่ใช้งานง่าย

การติดตั้ง 

bun add @instructor-ai/instructor zod openai
npm i @instructor-ai/instructor zod openai
pnpm add @instructor-ai/instructor zod openai

การใช้งานขั้นพื้นฐาน

หากต้องการตรวจสอบเคล็ดลับและกลเม็ดทั้งหมดเพื่อแจ้งและดึงข้อมูลให้ตรวจสอบเอกสาร 

 import Instructor from "@instructor-ai/instructor" ;
import OpenAI from "openai"
import { z } from "zod"

const oai = new OpenAI ( {
  apiKey : process . env . OPENAI_API_KEY ?? undefined ,
  organization : process . env . OPENAI_ORG_ID ?? undefined
} )

const client = Instructor ( {
  client : oai ,
  mode : "TOOLS"
} )

const UserSchema = z . object ( {
  // Description will be used in the prompt
  age : z . number ( ) . describe ( "The age of the user" ) , 
  name : z . string ( )
} )


// User will be of type z.infer<typeof UserSchema>
const user = await client . chat . completions . create ( {
  messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
  model : "gpt-3.5-turbo" ,
  response_model : { 
    schema : UserSchema , 
    name : "User"
  }
} )

console . log ( user )
// { age: 30, name: "Jason Liu" }

การอ้างอิง API

ชั้นเรียน

คลาสหลักสำหรับการสร้างไคลเอนต์ผู้สอน

CreateInstructor 

 function createInstructor < C extends GenericClient | OpenAI > ( args : {
  client : OpenAILikeClient < C > ;
  mode : Mode ;
  debug ?: boolean ;
} ) : InstructorClient < C >

สร้างอินสแตนซ์ของคลาสผู้สอน

  • ลูกค้า: ไคลเอนต์ที่มีลักษณะคล้าย OpenAI
  • โหมด: โหมดการทำงาน
  • DEBUG: จะบันทึกข้อความแก้ไขข้อบกพร่องหรือไม่

ส่งคืนไคลเอนต์ที่มีลักษณะคล้าย OpenAI

chat.completions.create 

 chat . completions . create <
        T extends z . AnyZodObject ,
        P extends T extends z . AnyZodObject ? ChatCompletionCreateParamsWithModel < T >
        : ClientTypeChatCompletionParams < OpenAILikeClient < C > > & { response_model : never }
      > (
        params : P
      ) : Promise < ReturnTypeBasedOnParams < typeof this . client , P > >

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

  • พารามิเตอร์: พารามิเตอร์การแชทเสร็จสมบูรณ์รวมถึงสคีมาแบบจำลองการตอบสนอง
  • ส่งคืนสัญญาการแก้ไขข้อมูลที่แยกออกจากสคีมา

โหมด

ผู้สอนรองรับโหมดที่แตกต่างกันสำหรับการกำหนดโครงสร้างและรูปแบบของการตอบสนองจากรูปแบบภาษา โหมดเหล่านี้ถูกกำหนดไว้ในแพ็คเกจ zod-stream และมีดังนี้:

  • FUNCTIONS ( เลิกใช้แล้ว ): สร้างการตอบสนองโดยใช้ฟังก์ชั่นการเรียกใช้ API ของ OpenAI มันแมปกับพารามิเตอร์ที่จำเป็นสำหรับฟังก์ชั่นการเรียก API รวมถึงคุณสมบัติ function_call และ functions

  • TOOLS : สร้างการตอบสนองโดยใช้ข้อกำหนดเครื่องมือของ OpenAI มันสร้างพารามิเตอร์ที่ต้องการสำหรับข้อกำหนดของเครื่องมือรวมถึงคุณสมบัติ tool_choice และ tools

  • JSON : มันตั้ง response_format เป็น json_object และรวมถึง JSON Schema ในข้อความระบบเพื่อเป็นแนวทางในการสร้างการตอบกลับ (ร่วมกัน & ทุกอย่าง)

  • MD_JSON : สร้างการตอบสนองในรูปแบบ JSON ที่ฝังอยู่ภายในบล็อกรหัส Markdown มันมีสคีมา JSON ในข้อความระบบและคาดว่าการตอบสนองจะเป็นวัตถุ JSON ที่ถูกต้องห่อหุ้มด้วยรหัสรหัส

  • JSON_SCHEMA : สร้างการตอบสนองโดยใช้ "โหมด JSON" ที่สอดคล้องกับสคีมา JSON ที่ให้ไว้ มันตั้ง response_format เป็น json_object ด้วยสคีมาที่ให้ไว้และรวมถึงคำอธิบายสคีมาในข้อความระบบ

ตัวอย่าง

การสตรีมเสร็จสมบูรณ์

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

 import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"

const textBlock = `
  In our recent online meeting, participants from various backgrounds joined to discuss the upcoming tech conference. 
  The names and contact details of the participants were as follows:

  - Name: John Doe, Email: [email protected], Twitter: @TechGuru44
  - Name: Jane Smith, Email: [email protected], Twitter: @DigitalDiva88
  - Name: Alex Johnson, Email: [email protected], Twitter: @CodeMaster2023

  During the meeting, we agreed on several key points. The conference will be held on March 15th, 2024, at the Grand Tech Arena located at 4521 Innovation Drive. Dr. Emily Johnson, a renowned AI researcher, will be our keynote speaker. The budget for the event is set at $50,000, covering venue costs, speaker fees, and promotional activities. 

  Each participant is expected to contribute an article to the conference blog by February 20th. A follow-up meeting is scheduled for January 25th at 3 PM GMT to finalize the agenda and confirm the list of speakers.
`

async function extractData ( ) {
  const ExtractionSchema = z . object ( {
    users : z . array (
      z . object ( {
        name : z . string ( ) ,
        handle : z . string ( ) ,
        twitter : z . string ( )
      } )
    ) . min ( 3 ) ,
    location : z . string ( ) ,
    budget : z . number ( )
  } )

  const oai = new OpenAI ( {
    apiKey : process . env . OPENAI_API_KEY ?? undefined ,
    organization : process . env . OPENAI_ORG_ID ?? undefined
  } )

  const client = Instructor ( {
    client : oai ,
    mode : "TOOLS"
  } )

  const extractionStream = await client . chat . completions . create ( {
    messages : [ { role : "user" , content : textBlock } ] ,
    model : "gpt-3.5-turbo" ,
    response_model : {
      schema : ExtractionSchema ,
      name : "Extraction"
    } ,
    max_retries : 3 ,
    stream : true
  } )

  let extractedData = { }
  for await ( const result of extractionStream ) {
    extractedData = result
    console . log ( "Partial extraction:" , result )
  }
  
  console . log ( "Final extraction:" , extractedData )
}

extractData ( )

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

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

ในที่สุดเราเข้าสู่ระบบข้อมูลที่แยกออกมาอย่างสมบูรณ์เมื่อสตรีมหมด

การใช้ผู้ให้บริการที่แตกต่างกันผ่านพร็อกซี

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

ทุกอย่าง 

 import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"

const UserSchema = z . object ( {
  age : z . number ( ) ,
  name : z . string ( ) . refine ( name => name . includes ( " " ) , {
    message : "Name must contain a space"
  } )
} )

async function extractUser ( ) {
  const client = new OpenAI ( {
    baseURL : "https://api.endpoints.anyscale.com/v1" ,
    apiKey : process . env . ANYSCALE_API_KEY
  } )

  const instructor = Instructor ( {
    client : client ,
    mode : "TOOLS"
  } )

  const user = await instructor . chat . completions . create ( {
    messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
    model : "mistralai/Mixtral-8x7B-Instruct-v0.1" ,
    response_model : {
      schema : UserSchema ,
      name : "User"
    } ,
    max_retries : 4
  } )

  return user
}

const anyscaleUser = await extractUser ( )
console . log ( "Anyscale user:" , anyscaleUser )

ด้วยกัน 

 import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"

const UserSchema = z . object ( {
  age : z . number ( ) ,
  name : z . string ( ) . refine ( name => name . includes ( " " ) , {
    message : "Name must contain a space"
  } )
} )

async function extractUser ( ) {
  const client = new OpenAI ( {
    baseURL : "https://api.together.xyz/v1" ,
    apiKey : process . env . TOGETHER_API_KEY
  } )

  const instructor = Instructor ( {
    client : client ,
    mode : "TOOLS"
  } )

  const user = await instructor . chat . completions . create ( {
    messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
    model : "mistralai/Mixtral-8x7B-Instruct-v0.1" ,
    response_model : {
      schema : UserSchema ,
      name : "User"
    } ,
    max_retries : 4
  } )

  return user
}

const togetherUser = await extractUser ( )
console . log ( "Together user:" , togetherUser )

ในตัวอย่างเหล่านี้เราระบุ URL ฐานเฉพาะและคีย์ API จาก AnyScale และร่วมกัน ..

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

จากนั้นเราโทรหาอาจารย์ผู้สอน chat.completions.create ด้วยโมเดลที่ต้องการสคีมาตอบสนองและพารามิเตอร์อื่น ๆ เพื่อแยกข้อมูลผู้ใช้

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

การใช้ผู้ให้บริการที่ไม่ใช่ Openai กับ LLM-Polyglot

ผู้สอนสนับสนุนการรวมเข้ากับผู้ให้บริการที่ไม่ปฏิบัติตาม OpenAI SDK เช่นมานุษยวิทยา Azure และ Cohere ผ่านห้องสมุด llm-polyglot ที่ดูแลโดย @dimitrikennedy ไลบรารีนี้มีอินเทอร์เฟซแบบครบวงจรสำหรับการโต้ตอบกับรูปแบบภาษาต่าง ๆ ในผู้ให้บริการที่แตกต่างกัน 

 import { createLLMClient } from "llm-polyglot"
import Instructor from "@instructor-ai/instructor"
import { z } from "zod"

const anthropicClient = createLLMClient ( {
  provider : "anthropic" ,
  apiKey : process . env . ANTHROPIC_API_KEY
} )

const UserSchema = z . object ( {
  age : z . number ( ) ,
  name : z . string ( )
} )

const instructor = Instructor < typeof anthropicClient > ( {
  client : anthropicClient ,
  mode : "TOOLS"
} )

async function extractUser ( ) {
  const user = await instructor . chat . completions . create ( {
    model : "claude-3-opus-20240229" ,
    max_tokens : 1000 ,
    messages : [
      {
        role : "user" ,
        content : "My name is Dimitri Kennedy."
      }
    ] ,
    response_model : {
      name : "extract_name" ,
      schema : UserSchema
    }
  } )

  return user
}

// Example usage
const extractedUser = await extractUser ( )
console . log ( "Extracted user:" , extractedUser )

ในตัวอย่างนี้เราใช้ฟังก์ชั่น CreateLmClient จากไลบรารี LLM-Polyglot เพื่อสร้างไคลเอนต์สำหรับผู้ให้บริการมานุษยวิทยา เราผ่านชื่อผู้ให้บริการ ("มานุษยวิทยา") และคีย์ API ที่สอดคล้องกันไปยังฟังก์ชัน

ต่อไปเราจะกำหนด Userschema โดยใช้ ZOD เพื่อระบุโครงสร้างของข้อมูลผู้ใช้ที่เราต้องการแยก

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

ฟังก์ชั่น ExtractUser แสดงวิธีการใช้อินสแตนซ์ของผู้สอนเพื่อแยกข้อมูลผู้ใช้จากอินพุตที่กำหนด เราเรียกผู้สอน. chat.completions.create ด้วยโมเดลที่เหมาะสม ("Claude-3-Opus-201240229" ในกรณีนี้) พารามิเตอร์และ Response_model ที่มีผู้ใช้ของเรา

ในที่สุดเราบันทึกข้อมูลผู้ใช้ที่แยกออกมา

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

สำหรับการสนับสนุนเพิ่มเติมและข้อมูลเกี่ยวกับการใช้ผู้ให้บริการรายอื่นกับ LLM-Polyglot โปรดดูเอกสารและตัวอย่างของห้องสมุด

ตัวอย่างเพิ่มเติม

หากคุณต้องการดูเพิ่มเติมให้ตรวจสอบตำราอาหารของเรา

การติดตั้งผู้สอนเป็นเรื่องง่าย

สร้างขึ้นบนเกาะ AI

ผู้สอนถูกสร้างขึ้นบนแพ็คเกจที่ทรงพลังหลายอย่างจากชุดเครื่องมือ AI Island พัฒนาและดูแลโดย Dimitri Kennedy แพ็คเกจเหล่านี้ให้ฟังก์ชั่นที่จำเป็นสำหรับการจัดการข้อมูลที่มีโครงสร้างและสตรีมมิ่งด้วยโมเดลภาษาขนาดใหญ่

zod-stream

Zod-Stream เป็นโมดูลไคลเอนต์ที่เชื่อมต่อโดยตรงกับสตรีม LLM มันใช้สคีมาสตรีมสำหรับการแยกวิเคราะห์ที่มีประสิทธิภาพและติดตั้งเครื่องมือสำหรับการประมวลผลการตอบสนองแบบดิบจาก OpenAI จัดหมวดหมู่ตามโหมด (ฟังก์ชั่นเครื่องมือ JSON ฯลฯ ) และสร้างความมั่นใจในการจัดการข้อผิดพลาดที่เหมาะสมและการแปลงสตรีม เหมาะอย่างยิ่งสำหรับการรวม API ที่ส่งมอบสตรีมตอบสนอง LLM ที่มีโครงสร้าง

สคีมาสตรีม

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

llm-polyglot

LLM-Polyglot เป็นห้องสมุดที่ให้อินเทอร์เฟซแบบครบวงจรสำหรับการโต้ตอบกับแบบจำลองภาษาต่าง ๆ ในผู้ให้บริการที่แตกต่างกันเช่น OpenAI, มานุษยวิทยา, Azure และ Cohere มันทำให้กระบวนการทำงานกับผู้ให้บริการ LLM หลายรายง่ายขึ้นและช่วยให้การรวมเข้ากับผู้สอนได้อย่างราบรื่น

ผู้สอนใช้ประโยชน์จากพลังของแพ็คเกจ AI เกาะเหล่านี้เพื่อมอบประสบการณ์ที่ราบรื่นและมีประสิทธิภาพสำหรับการสกัดข้อมูลที่มีโครงสร้างและสตรีมมิ่งด้วย LLMS การทำงานร่วมกันระหว่าง Dimitri Kennedy ผู้สร้าง Island AI และ Jason Liu ผู้เขียนแพ็คเกจ Python ผู้สอนดั้งเดิมได้นำไปสู่การพัฒนาของผู้สอนรุ่น TypeScript ซึ่งแนะนำแนวคิดของการสตรีม JSON บางส่วนจาก LLM

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Island AI และแพ็คเกจโปรดดูที่ที่เก็บ AI Island

ทำไมต้องใช้อาจารย์ผู้สอน?

คำถามของการใช้ผู้สอนเป็นคำถามพื้นฐานว่าทำไมต้องใช้ ZOD

  1. ทำงานร่วมกับ OpenAI SDK - ผู้สอนติดตาม API ของ OpenAI ซึ่งหมายความว่าคุณสามารถใช้ API เดียวกันสำหรับการแจ้งเตือนและการสกัดผ่านผู้ให้บริการหลายรายที่รองรับ OpenAI API

  2. ปรับแต่งได้ - Zod สามารถปรับแต่งได้สูง คุณสามารถกำหนดตัวตรวจสอบความถูกต้องของคุณเองข้อความแสดงข้อผิดพลาดที่กำหนดเองและอื่น ๆ

  3. ระบบนิเวศ ZOD เป็นไลบรารีการตรวจสอบข้อมูลที่ใช้กันอย่างแพร่หลายมากที่สุดสำหรับ TypeScript

  4. Battle Tested - ZOD ดาวน์โหลดมากกว่า 24 เมตรต่อเดือนและได้รับการสนับสนุนจากชุมชนผู้มีส่วนร่วมขนาดใหญ่

การบริจาค

หากคุณต้องการความช่วยเหลือให้ตรวจสอบปัญหาบางอย่างที่ทำเครื่องหมายว่าเป็น good-first-issue หรือ help-wanted พบที่นี่ พวกเขาอาจเป็นอะไรก็ได้จากการปรับปรุงรหัสโพสต์บล็อกของแขกหรือหนังสือทำอาหารเล่มใหม่

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

เคล็ดลับ: สนับสนุนในภาษาอื่น ๆ 

 Check out ports to other languages below:

- [Python](https://www.github.com/jxnl/instructor)
- [Elixir](https://github.com/thmsmlr/instructor_ex/)

If you want to port Instructor to another language, please reach out to us on [Twitter](https://twitter.com/jxnlco) we'd love to help you get started!

ใบอนุญาต

โครงการนี้ได้รับใบอนุญาตภายใต้ข้อกำหนดของใบอนุญาต MIT

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด