phenomenal ai

? AI fenomenal

Fenomenal AI adalah paket naskah untuk membangun generator prompt percakapan berbasis giliran untuk model bahasa besar. Paket ini menyediakan blok bangunan untuk mensimulasikan interaksi percakapan antara banyak entitas, yang disebut sebagai aktor. Aktor dapat berbagi informasi, terlibat dalam dialog, dan secara dinamis menyesuaikan arah percakapan berdasarkan aturan yang telah ditentukan.

? Fitur

• Abstraksi tingkat tinggi : AI fenomenal memberikan tingkat abstraksi yang tinggi untuk model percakapan berbasis AI. Ini memungkinkan Anda untuk fokus pada logika percakapan dan bukan model yang mendasarinya.
• ? Beberapa aktor : Paket ini mendukung interaksi antara beberapa aktor, memungkinkan untuk skenario percakapan yang kompleks. Setiap aktor dapat memiliki kepribadian dan preferensi mereka sendiri.
• Sejarah Percakapan : Setiap percakapan memiliki sejarah yang melacak jalan dialog dari waktu ke waktu. Sejarah digunakan untuk menghasilkan respons terhadap garis dialog baru.
• ? Konteks Bersama : Aktor dalam percakapan berbagi konteks yang memungkinkan mereka untuk menyimpan dan mengambil informasi yang relevan dengan diskusi yang sedang berlangsung. Konteksnya dapat digunakan untuk menyimpan informasi seperti topik percakapan, lokasi, waktu, dll.
• Penjadwalan : Paket menyediakan mekanisme untuk memutuskan urutan belokan antara aktor menggunakan penjadwal. Paket ini dilengkapi dengan penjadwal default yang dijadwalkan berubah dengan cara round-robin.
• ? Manajemen Turn Conversation : Mengontrol aliran pembicaraan dan menyediakan metode untuk menyuntikkan pesan baru ke dalam percakapan. Paket ini juga menyediakan metode untuk menanyakan percakapan dengan pertanyaan dan mendapat tanggapan.
• Manajemen Jendela Konteks : Paket menyediakan mekanisme untuk mengelola jendela konteks. Jendela konteks adalah jumlah token untuk membuka kedok dalam sejarah saat menghasilkan respons. Ini memungkinkan Anda untuk mengontrol ukuran cepat dan jumlah konteks yang diberikan kepada model.
• ? Ringan : Paket hanya memiliki satu ketergantungan eksternal ( mustache ), membuatnya ringan dan mudah digunakan.
• ? Extensible : Paket ini dirancang agar dapat diperluas. Anda dapat memberikan fungsi pembuatan teks Anda sendiri, penjadwal, dll.

? Memulai

Anda dapat menginstal paket melalui npm :

npm install @wecandobetter/phenomenal-ai

Atau melalui benang:

yarn add @wecandobetter/phenomenal-ai

Contoh penggunaan

Kelas Conversation merangkum semua aktor dan mengelola sejarah, konteks, dan penjadwalan belokan aktor. Kelas Actor mewakili aktor dalam percakapan.

Contoh berikut menunjukkan cara menggunakan kelas Conversation untuk mensimulasikan percakapan antara dua aktor.

 import { Actor , Conversation } from "@wecandobetter/phenomenal-ai" ;
import { generateText } from "./text-generation" ; // provide your own text generation function

// Define your actors
const actors = [
  new Actor ( "John" ) ,
  new Actor ( "Emma" ) ,
] ;

// Initialize a conversation
const conversation = new Conversation ( "Morning Talk" , { actors } ) ;

// Add a context entry
conversation . context . set ( "topic" , "Current topic of conversation" , "AI Ethics" ) ;

// Make a query:

const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;

// Moderate the conversation by injecting a new message:

conversation . inject ( "Let's get back to the topic of conversation." , {
  speaker : "Moderator" , // the speaker of the message (defaults to `System`)
  ephemeral : true , // this message will not be stored in the history
} ) ;

// Make one turn:

const turn = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;

// or use an async generator:

const ac = new AbortController ( ) ;

const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
  scheduler : conversation . scheduler , // provide your own scheduler
} ) ;

for await ( const turn of loop ) {
  console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;
} 

Referensi API

Kelas utama dari paket ini adalah Conversation , ConversationHistory , dan Actor .

Percakapan

Kelas Conversation merupakan percakapan yang berkelanjutan antara banyak aktor.

Properti

• id : Pengidentifikasi unik untuk percakapan.
• name : Nama percakapan.
• actors : Array Actor berpartisipasi dalam percakapan.
• history : Sejarah Percakapan.
• context : Konteks bersama antara semua aktor dalam percakapan.

Metode

Ini adalah metode yang tersedia di kelas Conversation .

new Conversation(name: string, { actors: Actor[], generateText?: GenerateText, scheduler?: Scheduler, messages?: Message[], windowss?: { history?: number } })

Menginisialisasi instance baru dari kelas Conversation .

 const conversation = new Conversation ( "Morning Talk" , {
  actors : [
    new Actor ( "John" ) ,
    new Actor ( "Emma" ) ,
  ] ,
  generateText : generateText , // provide your own text generation function
  scheduler : RoundRobinScheduler , // provide your own scheduler
  messages : [ ] , // bootstrap the conversation with messages
  windows : { // configure the conversation window
    max : 1024 , // the maximum number of tokens to unmask in the history
  } ,
} ) ; 

conversation.inject(text: string, { speaker = "System" embeddings?: number[][], ephemeral?: true })

Menyuntikkan pesan baru ke dalam percakapan. Mengembalikan pesan yang disuntikkan.

 const message = conversation . inject (
  "Let's get back to the topic of conversation." ,
  {
    speaker : "Moderator" ,
    ephemeral : true , // if true, the message will not be stored in the history after the next turn
  } ,
) ; 

conversation.query({ speaker: Actor, answerer: Actor, query: string, generateText?: GenerateText, store = false })

Mengembalikan janji yang diselesaikan menjadi respons giliran.

 const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.turn({ actor: Actor, generateText?: GenerateText })

Mengembalikan janji yang diselesaikan menjadi respons giliran.

 const response = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.loop({ signal: AbortSignal; generateText?: GenerateText })

Generator async yang menghasilkan speaker, teks, dan secara opsional embeddings dari setiap belokan dalam percakapan.

 const ac = new AbortController ( ) ;

// start the loop, which will yield the responses
const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
} ) ;

for await ( const response of loop ) {
  console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;
} 

conversation.toJSON()

Mengembalikan representasi percakapan JSON.

 const json = conversation . toJSON ( ) ;

ConversationHistory

Kelas ConversationHistory mewakili sejarah percakapan.

Properti

• messages : Array pesan dalam percakapan.

Metode

Ini adalah metode yang tersedia di kelas ConversationHistory .

new ConversationHistory(messages?: Message[])

Menginisialisasi instance baru dari kelas ConversationHistory .

 const history = new ConversationHistory ( [
  { speaker : "John" , text : "Hello, Emma!" } ,
  { speaker : "Emma" , text : "Hi, John!" } ,
] ) ; 

history.push(message: PartialBy<Message, "feedback">)

Mendorong pesan baru ke sejarah.

 history . push ( { actor : "John" , text : "Hello, Emma!" } ) ; 

history.getMessagesFor(actor: string)

Mengembalikan peta indeks dan pesan untuk aktor yang diberikan.

 const messages = history . getMessagesFor ( "John" ) ; 

history.getStats()

Mengembalikan statistik tentang sejarah. Statistik dikelompokkan berdasarkan aktor.

 const stats = history . getStats ( ) ;

console . log ( stats ) ;

// {
//   "Bob": {
//     count: 2, // total number of messages
//     textCount: 22, // total number of characters
//     percentage: 0.5, // percentage of messages in the conversation
//     textPercentage: 0.5, // percentage of characters in the conversation
//   },
// } 

history.cleanEphemeral()

Menghapus pesan fana dari sejarah.

 history . cleanEphemeral ( ) ; 

history.up(message: Message)

Tambahkan umpan balik positif ke pesan yang diberikan.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . up ( message ) ; 

history.down(message: Message)

Tambahkan umpan balik negatif ke pesan yang diberikan.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . down ( message ) ; 

history.first(): Message

Mengembalikan pesan pertama dalam sejarah.

history.last(): Message

Mengembalikan pesan terakhir dalam sejarah.

history.toJSON()

Mengembalikan representasi sejarah JSON.

history.clear()

Membersihkan sejarah.

Aktor

Kelas Actor mewakili entitas yang mengambil bagian dalam percakapan.

Properti

• id : Pengidentifikasi unik untuk aktor.
• name : Nama aktor.
• template : Templat untuk petunjuk aktor.
• context : Konteks bersama antara semua aktor dalam percakapan.
• persona : Persona aktor.
• knowledge : Pengetahuan tentang Aktor.
• memory : Memori aktor.

Metode

Ini adalah metode yang tersedia di kelas Actor .

new Actor(name: string, { template?: string, persona?: Persona, knowledge?: Knowledge, memory?: Memory })

Menginisialisasi instance baru dari kelas Actor . Jika tidak ada template yang disediakan, template default akan digunakan.

 const actor = new Actor ( "John" , {
  template : "Hello, my name is {{name}}." ,
) ; 

actor.render(conversation: Conversation)

Membuat template aktor menjadi prompt. Prompt adalah pesan yang dapat digunakan oleh model bahasa besar yang Anda pilih untuk menghasilkan respons.

 const prompt = actor . render ( conversation ) ; 

actor.toJSON()

Mengembalikan representasi aktor JSON.

❤️ berkontribusi

Permintaan tarik dipersilakan. Untuk perubahan besar, buka masalah terlebih dahulu untuk membahas apa yang ingin Anda ubah. Jangan ragu untuk memeriksa halaman masalah.

Lisensi

Proyek ini dilisensikan di bawah lisensi MIT. Jangan ragu untuk menggunakannya untuk proyek Anda sendiri.

Catatan

Happy Coding! ?

Jika Anda mengalami masalah atau memiliki saran untuk perbaikan, jangan ragu untuk membuka masalah atau permintaan tarik.

Berikan ️ jika Anda menyukai proyek ini!

Dikode dengan ❤️ oleh kita bisa melakukan yang lebih baik.