instructor php
1.0.0
Ekstraksi data terstruktur dalam PHP, didukung oleh LLM. Dirancang untuk kesederhanaan, transparansi, dan kontrol.
Instruktur adalah pustaka yang memungkinkan Anda mengekstrak data terstruktur dan tervalidasi dari berbagai jenis input: teks, gambar, atau susunan urutan obrolan gaya OpenAI. Ini didukung oleh Model Bahasa Besar (LLM).
Instruktur menyederhanakan integrasi LLM dalam proyek PHP. Ini menangani kompleksitas ekstraksi data terstruktur dari output LLM, sehingga Anda dapat fokus membangun logika aplikasi dan melakukan iterasi lebih cepat.
Instruktur untuk PHP terinspirasi oleh perpustakaan Instruktur untuk Python yang dibuat oleh Jason Liu.
Berikut aplikasi demo CLI sederhana menggunakan Instruktur untuk mengekstrak data terstruktur dari teks:
StructureLihat implementasi dalam bahasa lain di bawah:
Jika Anda ingin memindahkan Instruktur ke bahasa lain, silakan hubungi kami di Twitter. Kami dengan senang hati akan membantu Anda memulai!
Instruktur memperkenalkan tiga peningkatan utama dibandingkan dengan penggunaan API langsung.
Anda cukup menentukan kelas PHP untuk mengekstrak data melalui 'keajaiban' penyelesaian obrolan LLM. Dan itu saja.
Instruktur mengurangi kerapuhan kode dengan mengekstraksi informasi dari data tekstual dengan memanfaatkan respons LLM terstruktur.
Instruktur membantu Anda menulis kode yang lebih sederhana dan mudah dipahami - Anda tidak perlu lagi menentukan definisi panggilan fungsi yang panjang atau menulis kode untuk menetapkan JSON yang dikembalikan ke objek data target.
Model respons yang dihasilkan oleh LLM dapat divalidasi secara otomatis, mengikuti serangkaian aturan. Saat ini, Instruktur hanya mendukung validasi Symfony.
Anda juga dapat menyediakan objek konteks untuk menggunakan kemampuan validator yang ditingkatkan.
Anda dapat mengatur jumlah upaya percobaan ulang untuk permintaan.
Instruktur akan mengulangi permintaan jika terjadi kesalahan validasi atau deserialisasi hingga jumlah yang ditentukan, mencoba mendapatkan respons yang valid dari LLM.
Menginstal Instruktur itu sederhana. Jalankan perintah berikut di terminal Anda, dan Anda akan mendapatkan pengalaman penanganan data yang lebih lancar!
composer require cognesy/instructor-phpIni adalah contoh sederhana yang menunjukkan bagaimana Instruktur mengambil informasi terstruktur dari teks yang disediakan (atau urutan pesan obrolan).
Kelas model respons adalah kelas PHP biasa dengan petunjuk ketik yang menentukan jenis bidang objek.
use Cognesy Instructor Instructor ;
// Step 0: Create .env file in your project root:
// OPENAI_API_KEY=your_api_key
// Step 1: Define target data structure(s)
class Person {
public string $ name ;
public int $ age ;
}
// Step 2: Provide content to process
$ text = " His name is Jason and he is 28 years old. " ;
// Step 3: Use Instructor to run LLM inference
$ person = ( new Instructor )-> respond (
messages: $ text ,
responseModel: Person ::class,
);
// Step 4: Work with structured response data
assert ( $ person instanceof Person ); // true
assert ( $ person -> name === ' Jason ' ); // true
assert ( $ person -> age === 28 ); // true
echo $ person -> name ; // Jason
echo $ person -> age ; // 28
var_dump ( $ person );
// Person {
// name: "Jason",
// age: 28
// } CATATAN: Instruktur mendukung kelas/objek sebagai model respons. Jika Anda ingin mengekstrak tipe atau enum sederhana, Anda perlu membungkusnya dalam adaptor Skalar - lihat bagian di bawah: Mengekstrak Nilai Skalar.
Instruktur memungkinkan Anda menentukan beberapa koneksi API di file llm.php . Ini berguna ketika Anda ingin menggunakan LLM atau penyedia API yang berbeda dalam aplikasi Anda.
Konfigurasi default terletak di /config/llm.php di direktori root basis kode Instruktur. Ini berisi serangkaian koneksi yang telah ditentukan sebelumnya ke semua API LLM yang didukung langsung oleh Instruktur.
File konfigurasi mendefinisikan koneksi ke LLM API dan parameternya. Ini juga menentukan koneksi default yang akan digunakan saat memanggil Instruktur tanpa menentukan koneksi klien.
// This is fragment of /config/llm.php file
' defaultConnection ' => ' openai ' ,
// . . .
' connections ' => [
' anthropic ' => [ ... ],
' azure ' => [ ... ],
' cohere1 ' => [ ... ],
' cohere2 ' => [ ... ],
' fireworks ' => [ ... ],
' gemini ' => [ ... ],
' grok ' => [ ... ],
' groq ' => [ ... ],
' mistral ' => [ ... ],
' ollama ' => [
' providerType ' => LLMProviderType :: Ollama -> value ,
' apiUrl ' => ' http://localhost:11434/v1 ' ,
' apiKey ' => Env :: get ( ' OLLAMA_API_KEY ' , '' ),
' endpoint ' => ' /chat/completions ' ,
' defaultModel ' => ' qwen2.5:0.5b ' ,
' defaultMaxTokens ' => 1024 ,
' httpClient ' => ' guzzle-ollama ' , // use custom HTTP client configuration
],
' openai ' => [ ... ],
' openrouter ' => [ ... ],
' together ' => [ ... ],
// ...Untuk menyesuaikan koneksi yang tersedia, Anda dapat mengubah entri yang ada atau menambahkan entri Anda sendiri.
Menghubungkan ke LLM API melalui koneksi yang telah ditentukan semudah memanggil metode withClient dengan nama koneksi.
// ...
$ user = ( new Instructor )
-> withConnection ( ' ollama ' )
-> respond (
messages: " His name is Jason and he is 28 years old. " ,
responseModel: Person ::class,
);
// ... Anda dapat mengubah lokasi file konfigurasi untuk digunakan Instruktur melalui variabel lingkungan INSTRUCTOR_CONFIG_PATH . Anda dapat menggunakan salinan file konfigurasi default sebagai titik awal.
Instruktur menawarkan cara untuk menggunakan data terstruktur sebagai masukan. Hal ini berguna ketika ingin menggunakan data objek sebagai input dan mendapatkan objek lain dengan hasil inferensi LLM.
Bidang input metode respond() dan request() Instruktur dapat berupa objek, tetapi juga array atau hanya string.
use Cognesy Instructor Instructor ;
class Email {
public function __construct (
public string $ address = '' ,
public string $ subject = '' ,
public string $ body = '' ,
) {}
}
$ email = new Email (
address: ' joe@gmail ' ,
subject: ' Status update ' ,
body: ' Your account has been updated. '
);
$ translation = ( new Instructor )-> respond (
input: $ email ,
responseModel: Email ::class,
prompt: ' Translate the text fields of email to Spanish. Keep other fields unchanged. ' ,
);
assert ( $ translation instanceof Email ); // true
dump ( $ translation );
// Email {
// address: "joe@gmail",
// subject: "Actualización de estado",
// body: "Su cuenta ha sido actualizada."
// }
?>Instruktur memvalidasi hasil respons LLM terhadap aturan validasi yang ditentukan dalam model data Anda.
Untuk rincian lebih lanjut tentang aturan validasi yang tersedia, periksa batasan Validasi Symfony.
use Symfony Component Validator Constraints as Assert ;
class Person {
public string $ name ;
#[ Assert PositiveOrZero ]
public int $ age ;
}
$ text = " His name is Jason, he is -28 years old. " ;
$ person = ( new Instructor )-> respond (
messages: [[ ' role ' => ' user ' , ' content ' => $ text ]],
responseModel: Person ::class,
);
// if the resulting object does not validate, Instructor throws an exceptionJika parameter maxRetries disediakan dan respons LLM tidak memenuhi kriteria validasi, Instruktur akan melakukan upaya inferensi berikutnya hingga hasil memenuhi persyaratan atau maxRetries tercapai.
Instruktur menggunakan kesalahan validasi untuk memberi tahu LLM mengenai masalah yang diidentifikasi dalam respons, sehingga LLM dapat mencoba mengoreksi diri pada upaya berikutnya.
use Symfony Component Validator Constraints as Assert ;
class Person {
#[ Assert Length (min: 3 )]
public string $ name ;
#[ Assert PositiveOrZero ]
public int $ age ;
}
$ text = " His name is JX, aka Jason, he is -28 years old. " ;
$ person = ( new Instructor )-> respond (
messages: [[ ' role ' => ' user ' , ' content ' => $ text ]],
responseModel: Person ::class,
maxRetries: 3 ,
);
// if all LLM's attempts to self-correct the results fail, Instructor throws an exception Anda dapat memanggil metode request() untuk mengatur parameter permintaan dan kemudian memanggil get() untuk mendapatkan respons.
use Cognesy Instructor Instructor ;
$ instructor = ( new Instructor )-> request (
messages: " His name is Jason, he is 28 years old. " ,
responseModel: Person ::class,
);
$ person = $ instructor -> get ();Instruktur mendukung streaming hasil parsial, memungkinkan Anda untuk mulai memproses data segera setelah tersedia.
use Cognesy Instructor Instructor ;
$ stream = ( new Instructor )-> request (
messages: " His name is Jason, he is 28 years old. " ,
responseModel: Person ::class,
options: [ ' stream ' => true ]
)-> stream ();
foreach ( $ stream as $ partialPerson ) {
// process partial person data
echo $ partialPerson -> name ;
echo $ partialPerson -> age ;
}
// after streaming is done you can get the final, fully processed person object...
$ person = $ stream -> getLastUpdate ()
// . . . to, for example, save it to the database
$ db -> save ( $ person );
?> Anda dapat menentukan panggilan balik onPartialUpdate() untuk menerima sebagian hasil yang dapat digunakan untuk mulai memperbarui UI sebelum LLM menyelesaikan inferensi.
CATATAN: Pembaruan sebagian tidak divalidasi. Responsnya hanya divalidasi setelah diterima sepenuhnya.
use Cognesy Instructor Instructor ;
function updateUI ( $ person ) {
// Here you get partially completed Person object update UI with the partial result
}
$ person = ( new Instructor )-> request (
messages: " His name is Jason, he is 28 years old. " ,
responseModel: Person ::class,
options: [ ' stream ' => true ]
)-> onPartialUpdate (
fn( $ partial ) => updateUI ( $ partial )
)-> get ();
// Here you get completed and validated Person object
$ this -> db -> save ( $ person ); // ...for example: save to DB Anda dapat memberikan string, bukan array pesan. Ini berguna ketika Anda ingin mengekstrak data dari satu blok teks dan ingin membuat kode Anda tetap sederhana.
// Usually, you work with sequences of messages:
$ value = ( new Instructor )-> respond (
messages: [[ ' role ' => ' user ' , ' content ' => " His name is Jason, he is 28 years old. " ]],
responseModel: Person ::class,
);
// ...but if you want to keep it simple, you can just pass a string:
$ value = ( new Instructor )-> respond (
messages: " His name is Jason, he is 28 years old. " ,
responseModel: Person ::class,
);Terkadang kita hanya ingin mendapatkan hasil yang cepat tanpa mendefinisikan kelas untuk model respons, terutama jika kita mencoba mendapatkan jawaban yang lurus dan sederhana dalam bentuk string, integer, boolean, atau float. Instruktur menyediakan API yang disederhanakan untuk kasus seperti itu.
use Cognesy Instructor Extras Scalar Scalar ;
use Cognesy Instructor Instructor ;
$ value = ( new Instructor )-> respond (
messages: " His name is Jason, he is 28 years old. " ,
responseModel: Scalar :: integer ( ' age ' ),
);
var_dump ( $ value );
// int(28) Dalam contoh ini, kami mengekstraksi nilai integer tunggal dari teks. Anda juga dapat menggunakan Scalar::string() , Scalar::boolean() dan Scalar::float() untuk mengekstrak jenis nilai lainnya.
Selain itu, Anda dapat menggunakan adaptor Scalar untuk mengekstrak salah satu opsi yang disediakan dengan menggunakan Scalar::enum() .
use Cognesy Instructor Extras Scalar Scalar ;
use Cognesy Instructor Instructor ;
enum ActivityType : string {
case Work = ' work ' ;
case Entertainment = ' entertainment ' ;
case Sport = ' sport ' ;
case Other = ' other ' ;
}
$ value = ( new Instructor )-> respond (
messages: " His name is Jason, he currently plays Doom Eternal. " ,
responseModel: Scalar :: enum ( ActivityType ::class, ' activityType ' ),
);
var_dump ( $ value );
// enum(ActivityType:Entertainment)Urutan adalah kelas pembungkus yang dapat digunakan untuk mewakili daftar objek yang akan diekstraksi oleh Instruktur dari konteks yang disediakan.
Biasanya lebih mudah untuk tidak membuat kelas khusus dengan properti array tunggal hanya untuk menangani daftar objek dari kelas tertentu.
Fitur tambahan dan unik dari rangkaian adalah bahwa rangkaian tersebut dapat dialirkan per setiap item yang diselesaikan secara berurutan, bukan pada pembaruan properti apa pun.
class Person
{
public string $ name ;
public int $ age ;
}
$ text = <<Lihat selengkapnya tentang urutan di bagian Urutan.
Gunakan petunjuk tipe PHP untuk menentukan tipe data yang diekstraksi.
Gunakan tipe yang dapat dibatalkan untuk menunjukkan bahwa bidang tertentu bersifat opsional.
class Person {
public string $ name ;
public ? int $ age ;
public Address $ address ;
}Anda juga dapat menggunakan komentar gaya PHP DocBlock untuk menentukan jenis data yang diekstraksi. Ini berguna ketika Anda ingin menentukan tipe properti untuk LLM, namun tidak bisa atau tidak ingin menerapkan tipe pada tingkat kode.
class Person {
/** @var string */
public $ name ;
/** @var int */
public $ age ;
/** @var Address $address person's address */
public $ address ;
}Lihat dokumentasi PHPDoc untuk detail lebih lanjut di situs web DocBlock.
PHP saat ini tidak mendukung generik atau petunjuk ketik untuk menentukan tipe elemen array.
Gunakan komentar gaya PHP DocBlock untuk menentukan tipe elemen array.
class Person {
// ...
}
class Event {
// ...
/** @var Person[] list of extracted event participants */
public array $ participants ;
// ...
}Instruktur dapat mengambil struktur data kompleks dari teks. Model respons Anda dapat berisi objek bertumpuk, array, dan enum.
use Cognesy Instructor Instructor ;
// define a data structures to extract data into
class Person {
public string $ name ;
public int $ age ;
public string $ profession ;
/** @var Skill[] */
public array $ skills ;
}
class Skill {
public string $ name ;
public SkillType $ type ;
}
enum SkillType {
case Technical = ' technical ' ;
case Other = ' other ' ;
}
$ text = " Alex is 25 years old software engineer, who knows PHP, Python and can play the guitar. " ;
$ person = ( new Instructor )-> respond (
messages: [[ ' role ' => ' user ' , ' content ' => $ text ]],
responseModel: Person ::class,
); // client is passed explicitly, can specify e.g. different base URL
// data is extracted into an object of given class
assert ( $ person instanceof Person ); // true
// you can access object's extracted property values
echo $ person -> name ; // Alex
echo $ person -> age ; // 25
echo $ person -> profession ; // software engineer
echo $ person -> skills [ 0 ]-> name ; // PHP
echo $ person -> skills [ 0 ]-> type ; // SkillType::Technical
// ...
var_dump ( $ person );
// Person {
// name: "Alex",
// age: 25,
// profession: "software engineer",
// skills: [
// Skill {
// name: "PHP",
// type: SkillType::Technical,
// },
// Skill {
// name: "Python",
// type: SkillType::Technical,
// },
// Skill {
// name: "guitar",
// type: SkillType::Other
// },
// ]
// } Jika Anda ingin menentukan bentuk data saat runtime, Anda dapat menggunakan kelas Structure .
Struktur memungkinkan Anda menentukan dan memodifikasi bentuk data apa pun yang akan diekstraksi oleh LLM. Kelas mungkin bukan yang paling cocok untuk tujuan ini, karena tidak mungkin mendeklarasikan atau mengubahnya selama eksekusi.
Dengan struktur, Anda dapat menentukan bentuk data khusus secara dinamis, misalnya berdasarkan masukan pengguna atau konteks pemrosesan, untuk menentukan informasi yang Anda perlukan untuk disimpulkan oleh LLM dari pesan teks atau obrolan yang disediakan.
Contoh di bawah ini menunjukkan cara mendefinisikan struktur dan menggunakannya sebagai model respons:
use Cognesy Instructor Extras Structure Field ;
use Cognesy Instructor Extras Structure Structure ;
enum Role : string {
case Manager = ' manager ' ;
case Line = ' line ' ;
}
$ structure = Structure :: define ( ' person ' , [
Field :: string ( ' name ' ),
Field :: int ( ' age ' ),
Field :: enum ( ' role ' , Role ::class),
]);
$ person = ( new Instructor )-> respond (
messages: ' Jason is 25 years old and is a manager. ' ,
responseModel: $ structure ,
);
// you can access structure data via field API...
assert ( $ person -> field ( ' name ' ) === ' Jason ' );
// ...or as structure object properties
assert ( $ person -> age === 25 );
?>Untuk informasi lebih lanjut lihat bagian Struktur.
Anda dapat menentukan model dan opsi lain yang akan diteruskan ke titik akhir OpenAI/LLM.
use Cognesy Instructor Features LLM Data LLMConfig ;
use Cognesy Instructor Features LLM Drivers OpenAIDriver ;
use Cognesy Instructor Instructor ;
// OpenAI auth params
$ yourApiKey = Env :: get ( ' OPENAI_API_KEY ' ); // use your own API key
// Create instance of OpenAI driver initialized with custom parameters
$ driver = new OpenAIDriver ( new LLMConfig (
apiUrl: ' https://api.openai.com/v1 ' , // you can change base URI
apiKey: $ yourApiKey ,
endpoint: ' /chat/completions ' ,
metadata: [ ' organization ' => '' ],
model: ' gpt-4o-mini ' ,
maxTokens: 128 ,
));
/// Get Instructor with the default client component overridden with your own
$ instructor = ( new Instructor )-> withDriver ( $ driver );
$ user = $ instructor -> respond (
messages: " Jason (@jxnlco) is 25 years old and is the admin of this project. He likes playing football and reading books. " ,
responseModel: User ::class,
model: ' gpt-3.5-turbo ' ,
options: [ ' stream ' => true ]
);Instruktur menawarkan dukungan khusus untuk penyedia API berikut:
Untuk contoh penggunaan, periksa bagian Hub atau direktori examples di repositori kode.
Anda dapat menggunakan PHP DocBlocks (/** */) untuk memberikan instruksi tambahan untuk LLM di tingkat kelas atau bidang, misalnya untuk memperjelas apa yang Anda harapkan atau bagaimana LLM harus memproses data Anda.
Instruktur mengekstrak komentar PHP DocBlocks dari kelas dan properti yang ditentukan dan memasukkannya ke dalam spesifikasi model respons yang dikirim ke LLM.
Menggunakan instruksi PHP DocBlocks tidak diperlukan, tetapi terkadang Anda mungkin ingin memperjelas niat Anda untuk meningkatkan hasil inferensi LLM.
/**
* Represents a skill of a person and context in which it was mentioned.
*/
class Skill {
public string $ name ;
/** @var SkillType $type type of the skill, derived from the description and context */
public SkillType $ type ;
/** Directly quoted, full sentence mentioning person's skill */
public string $ context ;
}Anda dapat menggunakan sifat ValidationMixin untuk menambahkan kemampuan validasi objek data khusus yang mudah.
use Cognesy Instructor Features Validation Traits ValidationMixin ;
class User {
use ValidationMixin ;
public int $ age ;
public int $ name ;
public function validate () : array {
if ( $ this -> age < 18 ) {
return [ " User has to be adult to sign the contract. " ];
}
return [];
}
}Instruktur menggunakan komponen validasi Symfony untuk memvalidasi data yang diekstraksi. Anda dapat menggunakan anotasi #[Assert/Callback] untuk membuat logika validasi yang sepenuhnya disesuaikan.
use Cognesy Instructor Instructor ;
use Symfony Component Validator Constraints as Assert ;
use Symfony Component Validator Context ExecutionContextInterface ;
class UserDetails
{
public string $ name ;
public int $ age ;
#[ Assert Callback ]
public function validateName ( ExecutionContextInterface $ context , mixed $ payload ) {
if ( $ this -> name !== strtoupper ( $ this -> name )) {
$ context -> buildViolation ( " Name must be in uppercase. " )
-> atPath ( ' name ' )
-> setInvalidValue ( $ this -> name )
-> addViolation ();
}
}
}
$ user = ( new Instructor )-> respond (
messages: [[ ' role ' => ' user ' , ' content ' => ' jason is 25 years old ' ]],
responseModel: UserDetails ::class,
maxRetries: 2
);
assert ( $ user -> name === " JASON " );Lihat dokumen Symfony untuk detail lebih lanjut tentang cara menggunakan batasan Callback.
Saat Instruktur PHP memproses permintaan Anda, permintaan Anda melewati beberapa tahap:
Instruktur memungkinkan Anda menerima informasi terperinci di setiap tahap pemrosesan permintaan dan respons melalui peristiwa.
(new Instructor)->onEvent(string $class, callable $callback) - menerima panggilan balik ketika jenis acara tertentu dikirim(new Instructor)->wiretap(callable $callback) - menerima peristiwa apa pun yang dikirimkan oleh Instruktur, mungkin berguna untuk debugging atau analisis kinerjaMenerima peristiwa dapat membantu Anda memantau proses eksekusi dan memudahkan pengembang memahami dan menyelesaikan masalah pemrosesan apa pun.
$ instructor = ( new Instructor )
// see requests to LLM
-> onEvent ( RequestSentToLLM ::class, fn( $ e ) => dump ( $ e ))
// see responses from LLM
-> onEvent ( ResponseReceivedFromLLM ::class, fn( $ event ) => dump ( $ event ))
// see all events in console-friendly format
-> wiretap (fn( $ event ) => dump ( $ event -> toConsole ()));
$ instructor -> respond (
messages: " What is the population of Paris? " ,
responseModel: Scalar :: integer (),
);
// check your console for the details on the Instructor executionInstruktur dapat memproses beberapa jenis masukan yang diberikan sebagai model respons, memberi Anda lebih banyak fleksibilitas dalam cara Anda berinteraksi dengan perpustakaan.
Tanda tangan metode respond() dari Instruktur menyatakan bahwa responseModel dapat berupa string, objek, atau array.
Jika nilai string diberikan, maka digunakan sebagai nama kelas model respons.
Instruktur memeriksa apakah kelas itu ada dan menganalisis informasi jenis kelas & properti & komentar dokumen untuk menghasilkan skema yang diperlukan untuk menentukan batasan respons LLM.
Cara terbaik untuk memberikan nama kelas model respons adalah dengan menggunakan NameOfTheClass::class alih-alih string, sehingga memungkinkan IDE untuk menjalankan pemeriksaan tipe, menangani pemfaktoran ulang, dll.
Jika nilai object diberikan, maka itu dianggap sebagai turunan dari model respons. Instruktur memeriksa kelas instance, lalu menganalisisnya dan data tipe propertinya untuk menentukan batasan respons LLM.
Jika nilai array disediakan, maka dianggap sebagai Skema JSON mentah, oleh karena itu memungkinkan Instruktur untuk menggunakannya secara langsung dalam permintaan LLM (setelah membungkusnya dalam konteks yang sesuai - misalnya pemanggilan fungsi).
Instruktur memerlukan informasi tentang kelas setiap objek bersarang di Skema JSON Anda, sehingga dapat melakukan deserialisasi data dengan benar ke dalam tipe yang sesuai.
Informasi ini tersedia untuk Instruktur ketika Anda meneruskan $responseModel sebagai nama kelas atau sebuah instance, tetapi informasi ini hilang dari Skema JSON mentah.
Desain saat ini menggunakan bidang JSON Schema $comment di properti untuk mengatasi hal ini. Instruktur mengharapkan pengembang untuk menggunakan bidang $comment untuk memberikan nama kelas target yang sepenuhnya memenuhi syarat untuk digunakan untuk melakukan deserialisasi data properti tipe objek atau enum.
Instruktur memungkinkan Anda untuk menyesuaikan pemrosesan nilai $responseModel juga dengan melihat antarmuka yang diimplementasikan oleh kelas atau instance:
CanProvideJsonSchema - implementasi untuk dapat menyediakan Skema JSON atau model respons, menggantikan pendekatan default Instruktur, yang menganalisis informasi kelas nilai $responseModel,CanDeserializeSelf - implementasi untuk menyesuaikan cara respons dari LLM dideserialisasi dari JSON menjadi objek PHP,CanValidateSelf - implementasi untuk menyesuaikan cara validasi objek yang dideserialisasi,CanTransformSelf - implementasi untuk mengubah objek yang divalidasi menjadi nilai target yang diterima oleh pemanggil (misalnya membuka tipe sederhana dari kelas ke nilai skalar). Ekosistem PHP (belum) memiliki padanan yang kuat dari Pydantic, yang merupakan inti dari Instruktur untuk Python.
Untuk menyediakan fungsionalitas penting yang kami perlukan di sini, Instruktur untuk PHP memanfaatkan:
Instruktur untuk PHP kompatibel dengan PHP 8.2 atau lebih baru dan, karena ketergantungan minimal, dapat bekerja dengan kerangka apa pun pilihan Anda.
Ketergantungan tambahan diperlukan untuk beberapa tambahan:
Jika Anda ingin membantu, lihat beberapa masalahnya. Semua kontribusi dipersilakan - perbaikan kode, dokumentasi, laporan bug, postingan/artikel blog, atau buku masak baru dan contoh aplikasi.
Proyek ini dilisensikan berdasarkan ketentuan Lisensi MIT.
Jika Anda memiliki pertanyaan atau butuh bantuan, silakan hubungi saya di Twitter atau GitHub.
