llamaflow
1.0.0
Catatan: Perpustakaan ini sudah usang, sekarang dibagi menjadi Zod-GPT dan LLM-API.
Type-first Prompt Engineering Toolkit untuk bekerja dengan Model Bahasa Besar (LLM) berbasis obrolan.
Llamaflow adalah lapisan middleware yang berada di antara perangkat lunak Anda dan model AI, itu menambahkan kemampuan berikut di atas API penyelesaian obrolan standar:
Dengan llamaflow, Anda dapat dengan mudah meminta model chatgpt Openai seperti So:
import { OpenAI } from 'llama-flow' ;
const model = new OpenAI ( { apiKey : 'YOUR_OPENAI_KEY' } ) ;
const chat = model . chat ( {
systemMessage :
"You are a smart and honest AI assistant. Follow the user's requirements carefully & to the letter, minimize any other prose." ,
} ) ;
const response = await chat . request (
prompt . json ( {
message :
'What are some good names for childrens book about the renaissance? Respond as a JSON array' ,
schema : z . array ( z . string ( ) . max ( 200 ) ) ,
} ) ,
) ;
console . log ( response . content ) ; // content will be typed as string[]; Paket ini di -host di NPM:
npm i llama-flow
yarn add llama-flow
Untuk menyiapkan basis kode Anda, inisialisasi instance baru dengan model yang Anda inginkan (hanya OpenAI yang disediakan untuk saat ini). Perhatikan bahwa Anda juga dapat menambahkan model default dan konfigurasi obrolan (seperti suhu, batas waktu, coba lagi) saat menginisialisasi. Ini hanya default, dan selalu dapat ditimpa nanti dengan basis per obrolan atau per permintaan.
import { OpenAI } from 'llama-flow' ;
const model = new OpenAI (
{ apiKey : 'YOUR_OPENAI_KEY' } ,
{ model : 'gpt-3.5-turbo' } ,
) ;Obrolan adalah percakapan antara "pengguna" (perangkat lunak Anda), dan agen AI. Llamaflow akan mengurus mengelola memori obrolan, sehingga Anda dapat melanjutkan percakapan dengan mengirim permintaan lain. Perhatikan bahwa strategi manajemen memori yang berbeda akan ditambahkan di masa depan, seperti pemangkasan memori sesuai kebutuhan agar sesuai dengan jendela konteks.
const chat = model . chat ( {
systemMessage : 'You are an AI writer.' ,
retainMemory : true ,
} ) ;
// You can ask the AI model with a simple string, or a dedicated `Prompt` object.
const response = await chat . request (
prompt . text (
'Write a script for a tiktok video that talks about the artistic contribution of the renaissance.' ,
) ,
) ;
// The results, as well as any usage stats, will be returned.
console . log (
`The AI writer's response is: ${ response . content } . Token used: ${ response . usage . totalTokens } .` ,
) ;
// You can follow up on this chat by prompting further, using the `bulletPrompt` object that was created earlier.
const bulletPoints = await chat . request ( bulletPrompt ) ;
// `bulletPoints.content` will be automatically casted in the correct type as defined in the schema field of `bulletPrompt`
console . log (
`The structured version of this response is: ${ JSON . stringify (
bulletPoints . content ,
) } ` ,
) ;Prompt adalah pesan untuk obrolan AI dengan harapan format respons tertentu. Pesan tipe prompt divalidasi untuk memastikan bahwa diformat yang ditentukan dikembalikan dengan tepat, atau akan kesalahan. Ada berbagai jenis petunjuk untuk berbagai format. Berikut adalah contoh prompt JSON.
import { prompt } from 'llama-flow' ;
import { z } from 'zod' ; // JSON prompt uses Zod for schema validation.
const bulletPrompt = prompt . json ( {
message :
'Please rewrite this in a list of bullet points. Respond as a JSON array, where each element in the array is one bullet point. Keep each bullet point to be 200 characters max. For example: ["bullet point 1", "bullet point 2"]' ,
schema : z . array ( z . string ( ) . max ( 200 ) ) ,
} ) ; Perhatikan bahwa objek Prompt memisahkan message utama, dan formatMessage . Ini digunakan untuk retries. Ketika Llamaflow menggunakan prompt ini, ia akan meminta model dengan pesan utama dan format. Jika model kembali dengan respons yang diformat secara tidak benar, ia akan meminta model untuk memperbaiki output sebelumnya, hanya menggunakan formatMessage .
Anda dapat membangun objek prompt Anda sendiri dengan validator khusus juga. Llamaflow memberikan cara yang mudah & dapat diperluas untuk membangun segala jenis validator. Berikut adalah beberapa contoh validator khusus:
Mengambil contoh cepat di atas, tetapi kali ini, ia akan meminta model untuk hanya merespons pada poin peluru yang sebenarnya alih -alih array JSON. Ini berguna karena kadang-kadang model (khususnya <gpt-4) bukan yang terbaik dalam mengikuti instruksi pemformatan spesifik, terutama ketika datang ke struktur data yang rumit.
import { prompt } from 'llama-flow' ;
const bulletPrompt = prompt . json ( {
message :
'Please rewrite this in a list of bullet points. Respond as a list of bullet points, where each bullet point begins with the "-" character. Each bullet point should be less than 200 characters. Put each bullet point on a new line.' ,
// parse the response from the model so it can be fed into the schema validator
parseResponse : ( res ) => res . split ( 'n' ) . map ( ( s ) => s . replace ( '-' , '' ) . trim ( ) ) ,
// it's useful to define custom error messages, any schema parse errors will be automatically fed back into the model on retry, so the model knows exactly what to correct.
schema : z . array (
z . string ( ) . max ( 200 , {
message : 'This bullet point should be less than 200 characters.' ,
} ) ,
) ,
} ) ; Sekarang, mari kita mengambil ini lebih jauh. Anda dapat membangun prompt yang menggunakan model (atau sumber eksternal lainnya) untuk memvalidasi outputnya sendiri. Anda dapat melakukan ini dengan meneruskan metode validate async khusus. Perhatikan bahwa metode ini akan mengganti properti terkait validasi lainnya, seperti formatMessage , parseResponse , schema .. dll.
import { prompt , Chat } from 'llama-flow' ;
const factCheckerChat = model . chat ( {
systemMessage :
'You are a fact checker that responds to if the user's messages are true or not, with just the word "true" or "false". Do not add punctuations or any other text. If the user asks a question, request, or anything that cannot be fact checked, ignore the user's request and just say "null".' ,
// The fact checker is designed to fulfill each request independently (e.g. the current request does not depend on the content of the previous request). So no need to keep message memory to save on tokens.
retainMemory : false ,
} ) ;
const buildFactCheckedPrompt = ( article : string ) =>
prompt . text ( {
message : `Please write a summary about the following article: ${ article } ` ,
// Because LLM driven validation can get expensive, set a lower retry count.
promptRetries : 2 ,
parse : async ( response ) => {
// Check if this summary is true or not
const { response } = await factCheckerChat . request (
prompt . boolean ( {
message : response . content ,
} ) ,
) ;
if ( response . content === true ) {
return { success : true , data : response . content } ;
} else {
// if `retryPrompt` is set, LLamaFlow will automatically retry with the text in this property.
return {
success : false ,
retryPrompt :
'This summary is not true, please rewrite with only true facts.' ,
} ;
}
} ,
} ) ;
// now, every content generated by this chat will be fact checked by the LLM itself, and this request will throw an error if the content can't be fixed (once the maximum number of retries has been reached).
const factCheckedContent = await chat . request (
buildFactCheckedPrompt (
'Write a script for a tiktok video that talks about the artistic contribution of the renaissance.' ,
) ,
) ;Karena ini adalah API, seringkali berguna untuk terus meminta dari obrolan yang sama. Seringkali riwayat pesan akan berfungsi sebagai konteks untuk permintaan berikutnya. Contoh penggunaan contoh yang baik adalah prompt untuk terlebih dahulu menulis beberapa konten, kemudian mengekstrak entitas, dan terakhir, memberikan beberapa opsi untuk judul.
// You can reset chat history anytime with `reset()`, however, this is an anti-pattern, as it is prone to mistakes. It's much safer to just initialize a new chat.
chat . reset ( ) ;
const article = await chat . request (
prompt . text ( 'Write a blog post about the financial crisis of 2008' ) ,
) ;
const entities = await chat . request (
prompt . json ( {
message :
'What are the different entities in the above blog post? Respond in a JSON array, where the items in the array are just the names of the entities.' ,
schema : z . array ( z . string ( ) ) ,
} ) ,
) ;
const titles = await chat . request (
prompt . bulletPoints ( {
message : 'Write a good title for this post' ,
amount : 10 ,
} ) ,
) ; Kesalahan umum dengan API LLM adalah penggunaan token - Anda hanya diizinkan untuk menyesuaikan sejumlah data di jendela konteks. Dalam kasus Llamaflow, ini berarti Anda terbatas dalam jumlah total pesan yang dapat Anda kirim (jika retainMemory diatur ke true ) dan panjang konten pesan.
Llamaflow akan secara otomatis menentukan apakah permintaan akan melanggar batas token sebelum mengirim permintaan yang sebenarnya ke penyedia model (misalnya OpenAi). Ini akan menyimpan satu panggilan pulang-pergi jaringan dan memungkinkan Anda menangani jenis kesalahan ini secara responsif. Cara khas menangani kesalahan ini adalah dengan menghapus pesan dalam riwayat pesan (jika Anda menggunakan obrolan dengan set retainMemory ), atau membagi konten Anda menjadi kelompok yang lebih kecil dan memprosesnya dalam beberapa permintaan.
Berikut adalah contoh menangkap kesalahan token overflow. Perhatikan bahwa minimumResponseTokens diatur ke nilai tinggi untuk secara eksplisit memicu kesalahan ini ( gpt-3.5-turbo memiliki batas konteks maksimal 4096, sehingga menetapkan batas minimum ke 4095 berarti hanya ada 1 token yang tersisa untuk prompt aktual, yang tidak cukup untuk contoh di bawah ini.)
try {
// make sure to set the `contextSize` to enable automatic token checking
const model = new OpenAI (
{ apiKey : 'YOUR_OPENAI_KEY' } ,
{ model : 'gpt-3.5-turbo' , contextSize : 4096 } ,
) ;
const chat = model . chat ( {
systemMessage : 'You are an AI assistant' ,
} ) ;
await chat . request (
{ message : 'hello world, testing overflow logic' } ,
{ minimumResponseTokens : 4095 } ,
) ;
} catch ( e ) {
if ( e instanceof TokenError ) {
console . info (
`Caught token overflow, overflowed tokens: ${ e . overflowTokens } ` ,
) ;
}
} Cara umum untuk menangani masalah batas token adalah dengan membagi konten Anda. LlamAflow menyediakan metode helper yang berguna yang membungkus metode chat.request . Cukup pintar untuk hanya membagi teks Anda jika menentukan bahwa itu di atas batas token, dan akan mencoba untuk melestarikan sebanyak mungkin teks asli.
const response = await chat . requestWithSplit (
'hello world, testing overflow logic' ,
( text ) =>
prompt . text ( {
message : `Add other required prompts first, then add your content: ${ text } ` ,
} ) ,
) ; Perhatikan bahwa sekarang, konten utama prompt diserahkan terlebih dahulu. Ini adalah konten yang akan dibagi oleh splitter teks (sepanjang n . , dan dan karakter pertama, untuk memotongnya). Anda dapat menambahkan prompt tambahan yang diperlukan dan menggabungkannya dengan prompt konten di parameter responseFn .
Llamaflow usese modul debug untuk logging & pesan kesalahan. Untuk menjalankan dalam mode Debug, atur variabel DEBUG :
DEBUG=llamaflow:* yarn playground
Anda juga dapat menentukan berbagai jenis logging melalui:
DEBUG=llamaflow:error yarn playground DEBUG=llamaflow:log yarn playground
Llamaflow juga dilengkapi dengan dukungan untuk model OpenAI Azure. Versi Azure biasanya jauh lebih cepat dan lebih dapat diandalkan daripada titik akhir API Openai sendiri. Untuk menggunakan titik akhir Azure, Anda harus menyertakan 2 opsi spesifik Azure saat menginisialisasi model OpenAI, azureDeployment dan azureEndpoint . Lapangan apiKey juga akan digunakan untuk kunci API Azure.
Anda dapat menemukan kunci API Azure dan titik akhir di portal Azure. Penyebaran Azure harus dibuat di bawah portal AIure AI.
Perhatikan bahwa parameter model dalam ModelConfig akan diabaikan saat menggunakan Azure. Ini karena dalam sistem Azure, model dipilih pada penciptaan penyebaran, bukan pada waktu berjalan.
const model = new OpenAI ( {
apiKey : 'AZURE_OPENAI_KEY' ,
azureDeployment : 'AZURE_DEPLOYMENT_NAME' ,
azureEndpoint : 'AZURE_ENDPOINT' ,
} ) ; Satu -satunya model dukungan Llamaflow saat ini adalah model berbasis obrolan Openai.
const model = new OpenAI ( openAiConfig , modelConfig ) ; interface OpenAIConfig {
apiKey : string ;
} Peta konfigurasi model ini ke konfigurasi OpenAi secara langsung, lihat DOC: https://platform.openai.com/docs/api-reference/chat/create
interface ModelConfig {
model ?: string ;
maxTokens ?: number ;
temperature ?: number ;
topP ?: number ;
stop ?: string | string [ ] ;
presencePenalty ?: number ;
frequencyPenalty ?: number ;
logitBias ?: Record < string , number > ;
user ?: string ;
stream ?: boolean ;
} Ketika stream diatur ke true , Anda dapat mengakses output parsial dari permintaan model dengan menyerahkan pemancar acara ke ChatRequestOptions saat membuat permintaan. Output parsial akan dikirim sebagai string di atas acara data .
Untuk membuat permintaan ke model, Anda harus terlebih dahulu membangun objek prompt. Prompt menyediakan cara untuk menambahkan validasi dan mencoba kembali ke setiap permintaan.
import { prompt } from 'llama-flow' ;
prompt . text ( prompt : string ) ;
prompt . text ( prompt : RawPrompt ) ;
prompt . json ( prompt : JSONPrompt ) ;
prompt . bulletPoints ( prompt : BulletPointsPrompt ) ;
prompt . boolean ( prompt : BooleanPrompt ) ; Anda dapat meminta sebagai string, atau sebagai RawPrompt .
interface RawPrompt < T = string > {
message : string ;
parse ?: (
response : ChatResponse < string > ,
) => MaybePromise <
{ success : false ; retryPrompt ?: string } | { success : true ; data : T }
> ;
promptRetries ?: number ;
}Pesan Ini adalah teks yang dikirim ke model.
Parse Anda dapat menerapkan parser khusus dengan mendefinisikan metode parse Anda sendiri.
Saat mendefinisikan metode parse khusus yang mengembalikan tipe data khusus, Anda dapat menambahkan tipe generik ke RawPrompt , yang secara otomatis akan melemparkan jenis pengembalian parse ke generik. Ini juga akan menyebarkan jenis semua jalan melalui metode chat.request .
Jika data yang dikembalikan oleh model itu salah, Anda dapat mengembalikan string retryPrompt khusus, yang akan menyebabkan Llamaflow menilai kembali model tersebut.
ProMPtretries menentukan berapa kali untuk menilai kembali model sebelum permintaan akan melakukan kesalahan. Default ke 3. Perhatikan bahwa parse harus mengembalikan retryPrompt yang valid untuk setiap hari untuk dicoba.
interface BooleanPrompt {
message : string ;
promptRetries ?: number ;
} Gunakan prompt ini jika Anda ingin mengajukan pertanyaan kepada model di mana Anda hanya mengharapkan respons true atau false .
Pesan kueri untuk dikirim ke model. Prompt ini akan secara otomatis menambahkan instruksi pemformatan ke pesan yang dikirim ke model yang memberi tahu model untuk memformat responsnya sebagai boolean, sehingga Anda dapat memasukkan kueri dalam message , tanpa menulis pernyataan pemformatan tambahan.
interface BulletPointsPrompt {
message : string ;
amount ?: number ;
length ?: number ;
promptRetries ?: number ;
}Gunakan prompt ini jika Anda ingin model mengembalikan daftar string.
Pesan kueri untuk dikirim ke model. Prompt ini akan secara otomatis menambahkan instruksi pemformatan ke pesan yang memberi tahu model cara memformat respons.
Jumlah Jumlah poin peluru yang harus dikembalikan.
Panjang Jumlah karakter maksimum yang harus ada di setiap titik peluru.
interface JSONPrompt < T extends z . ZodType > {
message : string ;
schema : T ;
parseResponse ?: ( res : string ) => MaybePromise < z . infer < T > > ;
retryMessage ?: string ;
promptRetries ?: number ;
}Pesan Pesan untuk dikirim ke model. Tidak seperti petunjuk titik boolean atau peluru, prompt ini tidak secara otomatis menghasilkan instruksi format untuk model. Jadi sebagai bagian dari pesan Anda ke model, Anda harus menyertakan instruksi pemformatan untuk mengembalikan data dalam format JSON, serta bentuk JSON.
Skema Ini adalah skema zod yang akan digunakan untuk menguraikan dan mengetikkan respons dari model.
Parseresponse Jika Anda meminta model untuk tidak mengembalikan data dalam format JSON, Anda dapat mendefinisikan parser khusus untuk menguraikan string pengembalian ke JSON, sebelum mengirimkannya ke schema untuk validasi.
Retrymessage Jika parsing skema gagal, ini akan digunakan sebagai bagian dari pesan yang dikirim ke model untuk menilai kembali untuk respons yang diformat dengan benar. Perhatikan bahwa prompt ini akan secara otomatis menghasilkan pesan RECK tergantung pada kesalahan parsing skema (misalnya jika kunci tertentu hilang, Llamaflow akan meminta model untuk memasukkan kunci spesifik itu). Jadi bidang ini murni untuk memberikan konteks tambahan pada model pada Reask.
Objek obrolan menyimpan sesi obrolan dengan model. Sesi ini akan mengurus penyimpanan riwayat pesan, sehingga Anda dapat melanjutkan percakapan dengan model dengan membuat permintaan lain.
const chat = model . chat ( config : ChatConfig ) ;Opsi Anda dapat mengatur perilaku retensi memori serta opsi permintaan default untuk setiap permintaan yang dikirim dalam obrolan ini.
export interface ChatConfig {
// the message injected at the start of every chat to steer the agent
systemMessage : string ;
// if chat memory should be retained after every request. when enabled, the chat's behavior will be similar to a normal user chat room, and model can have access to history when making inferences. defaults to false
retainMemory ?: boolean ;
// set default request options. note that this can be overridden on a per-request basis
options ?: ChatRequestOptions ;
} Untuk mengirim permintaan ke sesi obrolan:
const res : ChatResponse = await chat . request ( prompt , options : ChatRequestOptions ) ;Opsi Anda dapat mengganti opsi permintaan default melalui parameter ini. Permintaan akan secara otomatis diceritakan kembali jika ada kesalahan ratelimit atau server.
Perhatikan bahwa coba lagi dalam permintaan tidak diperhitungkan terhadap penetapan cepat yang ditentukan di bagian prompt di atas.
type ChatRequestOptions = {
// the number of time to retry this request due to rate limit or recoverable API errors
retries ?: number ;
retryInterval ?: number ;
timeout ?: number ;
// the minimum amount of tokens to allocate for the response. if the request is predicted to not have enough tokens, it will automatically throw a 'TokenError' without sending the request
minimumResponseTokens ?: number ;
// override the messages used for completion, only use this if you understand the API well
messages ?: Message [ ] ;
// pass in an event emitter to receive message stream events
events ?: EventEmitter ;
} ; Respons obrolan ada dalam format berikut:
interface ChatResponse < T = string > {
content : T ;
model : string ;
// set to true if this content was streamed. note to actually access the stream, you have to pass in an event emitter via ChatRequestOptions
isStream : boolean ;
usage : {
promptTokens : number ;
completionTokens : number ;
totalTokens : number ;
} ;
}Konten diurai dan konten yang diketes dari prompt. Jenis akan diatur secara otomatis tergantung pada prompt mana yang Anda gunakan.
Model Model spesifik yang digunakan untuk penyelesaian (misalnya gpt-3.5-turbo-0301 )
Penggunaan Data Penggunaan Token, Peta ini secara langsung Respons Penggunaan OpenAI.
Jika Anda ingin mengatur ulang riwayat pesan dalam riwayat obrolan, ada metode penolong sederhana:
chat . reset ( ) ;Perhatikan bahwa metode ini adalah lubang palka. Lebih baik hanya instantiate sesi obrolan baru jika Anda ingin membuat permintaan baru dengan batu tulis yang bersih. Logika kompleks di mana Anda mengatur ulang sesi obrolan beberapa kali bisa sulit dilacak dan sulit didebug.
Perhatikan bahwa jika Anda ingin mem -bypass logika manajemen obrolan Llamaflow, dan kirim permintaan ke model yang underlaying secara langsung, Anda dapat mengirim permintaan ke model secara langsung tanpa instantiasi obrolan:
const model = new OpenAI ( openAiConfig , modelConfig ) ;
const res = await model . request ( messages : Message [ ] , options : ChatRequestOptions ) ; Ini akan melewati manajemen riwayat obrolan apa pun, format & parsing yang cepat, serta logika persona. Anda masih dapat memanfaatkan fitur API Retries melalui ChatRequestOptions .
