Membuat konten dengan model AI

Inti dari AI generatif adalah model AI. Saat ini, dua contoh paling terkenal dari model generatif adalah model bahasa besar (LLM) dan model pembuatan gambar. Model ini menerima input, yang disebut prompt (biasanya teks, gambar, atau kombinasi keduanya), dan darinya menghasilkan teks, gambar, atau bahkan audio atau video sebagai output.

Output model ini dapat sangat meyakinkan: LLM menghasilkan teks yang tampak seperti ditulis oleh manusia, dan model pembuatan gambar dapat menghasilkan gambar yang sangat mirip dengan foto atau karya seni asli yang dibuat oleh manusia.

Selain itu, LLM telah terbukti mampu melakukan tugas di luar pembuatan teks sederhana:

  • Menulis program komputer
  • Merencanakan subtugas yang diperlukan untuk menyelesaikan tugas yang lebih besar
  • Mengatur data yang tidak teratur
  • Memahami dan mengekstrak data informasi dari korpus teks
  • Mengikuti dan melakukan aktivitas otomatis berdasarkan deskripsi teks aktivitas

Ada banyak model yang tersedia untuk Anda, dari beberapa penyedia yang berbeda. Setiap model memiliki kelebihan dan kekurangannya sendiri dan satu model mungkin unggul dalam satu tugas, tetapi berperforma kurang baik dalam tugas lainnya. Aplikasi yang menggunakan AI generatif sering kali mendapatkan manfaat dari penggunaan beberapa model yang berbeda, bergantung pada tugas yang sedang dilakukan.

Sebagai developer aplikasi, Anda biasanya tidak berinteraksi dengan model AI generatif secara langsung, tetapi melalui layanan yang tersedia sebagai API web. Meskipun layanan ini sering kali memiliki fungsi yang serupa, semuanya menyediakannya melalui API yang berbeda dan tidak kompatibel. Jika ingin menggunakan beberapa layanan model, Anda harus menggunakan setiap SDK eksklusifnya, yang mungkin tidak kompatibel satu sama lain. Selain itu, jika ingin mengupgrade dari satu model ke model terbaru dan paling canggih, Anda mungkin harus membuat integrasi tersebut lagi.

Genkit mengatasi tantangan ini dengan menyediakan satu antarmuka yang memisahkan detail akses ke layanan model AI generatif apa pun, dengan beberapa implementasi bawaan yang sudah tersedia. Mem-build aplikasi yang didukung AI di sekitar Genkit menyederhanakan proses pembuatan panggilan AI generatif pertama dan mempermudah penggabungan beberapa model atau menukar satu model dengan model lain saat model baru muncul.

Sebelum memulai

Jika Anda ingin menjalankan contoh kode di halaman ini, selesaikan langkah-langkah dalam panduan Memulai terlebih dahulu. Semua contoh mengasumsikan bahwa Anda telah menginstal Genkit sebagai dependensi dalam project.

Model yang didukung oleh Genkit

Genkit dirancang agar cukup fleksibel untuk menggunakan layanan model AI generatif apa pun. Library intinya menentukan antarmuka umum untuk menggunakan model, dan plugin model menentukan detail implementasi untuk menggunakan model tertentu dan API-nya.

Tim Genkit mengelola plugin untuk menggunakan model yang disediakan oleh Vertex AI, AI Generatif Google, dan Ollama:

  • Rangkaian LLM Gemini, melalui plugin Google Cloud Vertex AI
  • Rangkaian LLM Gemini, melalui plugin AI Google
  • Model pembuatan gambar Imagen2 dan Imagen3, melalui Google Cloud Vertex AI
  • Kelompok LLM Claude 3 dari Anthropic, melalui garden model Google Cloud Vertex AI
  • Gemma 2, Llama 3, dan banyak model terbuka lainnya, melalui plugin Ollama (Anda harus menghosting server Ollama sendiri)

Selain itu, ada juga beberapa plugin yang didukung komunitas yang menyediakan antarmuka ke model ini:

Anda dapat menemukan lebih banyak dengan menelusuri paket yang diberi tag genkit-model di npmjs.org.

Memuat dan mengonfigurasi plugin model

Sebelum dapat menggunakan Genkit untuk mulai membuat konten, Anda perlu memuat dan mengonfigurasi plugin model. Jika Anda berasal dari panduan Memulai, Anda telah melakukannya. Jika tidak, lihat panduan Memulai atau dokumentasi plugin individual dan ikuti langkah-langkah di sana sebelum melanjutkan.

Metode generate()

Di Genkit, antarmuka utama yang Anda gunakan untuk berinteraksi dengan model AI generatif adalah metode generate().

Panggilan generate() yang paling sederhana menentukan model yang ingin Anda gunakan dan perintah teks:

import { gemini15Flash, googleAI } from '@genkit-ai/googleai';
import { genkit } from 'genkit';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

(async () => {
  const { text } = await ai.generate(
    'Invent a menu item for a pirate themed restaurant.'
  );
  console.log(text);
})();

Saat Anda menjalankan contoh singkat ini, contoh ini akan mencetak beberapa informasi proses debug diikuti dengan output panggilan generate(), yang biasanya berupa teks Markdown seperti dalam contoh berikut:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

Jalankan lagi skrip dan Anda akan mendapatkan output yang berbeda.

Contoh kode sebelumnya mengirim permintaan pembuatan ke model default, yang Anda tentukan saat mengonfigurasi instance Genkit.

Anda juga dapat menentukan model untuk satu panggilan generate():

const { text } = await ai.generate({
  model: gemini15Pro,
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Contoh ini menggunakan referensi model yang diekspor oleh plugin model. Opsi lainnya adalah menentukan model menggunakan ID string:

const { text } = await ai.generate({
  model: 'googleai/gemini-1.5-pro-latest',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

ID string model terlihat seperti providerid/modelid, dengan ID penyedia (dalam hal ini, googleai) mengidentifikasi plugin, dan ID model adalah ID string khusus plugin untuk versi model tertentu.

Beberapa plugin model, seperti plugin Ollama, memberikan akses ke puluhan model yang berbeda, sehingga tidak mengekspor setiap referensi model. Dalam kasus ini, Anda hanya dapat menentukan model ke generate() menggunakan ID string-nya.

Contoh ini juga menggambarkan poin penting: saat Anda menggunakan generate() untuk melakukan panggilan model AI generatif, mengubah model yang ingin digunakan hanyalah masalah meneruskan nilai yang berbeda ke parameter model. Dengan menggunakan generate(), bukan SDK model native, Anda memberi diri Anda fleksibilitas untuk menggunakan beberapa model yang berbeda di aplikasi dengan lebih mudah dan mengubah model di masa mendatang.

Sejauh ini, Anda hanya melihat contoh panggilan generate() yang paling sederhana. Namun, generate() juga menyediakan antarmuka untuk interaksi yang lebih canggih dengan model generatif, yang akan Anda lihat di bagian berikut.

Perintah sistem

Beberapa model mendukung penyediaan perintah sistem, yang memberikan petunjuk kepada model tentang bagaimana Anda ingin model merespons pesan dari pengguna. Anda dapat menggunakan perintah sistem untuk menentukan persona yang ingin diadopsi model, nada responsnya, format responsnya, dan sebagainya.

Jika model yang Anda gunakan mendukung perintah sistem, Anda dapat memberikannya dengan parameter system:

const { text } = await ai.generate({
  system: 'You are a food industry marketing consultant.',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Parameter model

Fungsi generate() menggunakan parameter config, yang dapat Anda gunakan untuk menentukan setelan opsional yang mengontrol cara model menghasilkan konten:

const { text } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  config: {
    maxOutputTokens: 400,
    stopSequences: ['<end>', '<fin>'],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

Parameter persis yang didukung bergantung pada setiap model dan API model. Namun, parameter dalam contoh sebelumnya umum untuk hampir setiap model. Berikut adalah penjelasan parameter ini:

Parameter yang mengontrol panjang output

maxOutputTokens

LLM beroperasi pada unit yang disebut token. Token biasanya, tetapi tidak selalu, dipetakan ke urutan karakter tertentu. Saat Anda meneruskan perintah ke model, salah satu langkah pertama yang diperlukan adalah membuat token string perintah menjadi urutan token. Kemudian, LLM menghasilkan urutan token dari input yang ditokenisasi. Terakhir, urutan token dikonversi kembali menjadi teks, yang merupakan output Anda.

Parameter token output maksimum hanya menetapkan batas jumlah token yang akan dibuat menggunakan LLM. Setiap model berpotensi menggunakan tokenizer yang berbeda, tetapi sebaiknya pertimbangkan satu kata bahasa Inggris yang terdiri dari 2 hingga 4 token.

Seperti yang dinyatakan sebelumnya, beberapa token mungkin tidak dipetakan ke urutan karakter. Salah satu contohnya adalah sering kali ada token yang menunjukkan akhir urutan: saat LLM menghasilkan token ini, token tersebut berhenti menghasilkan token lainnya. Oleh karena itu, LLM mungkin dan sering kali menghasilkan lebih sedikit token daripada maksimum karena menghasilkan token "stop".

stopSequences

Anda dapat menggunakan parameter ini untuk menetapkan token atau urutan token yang, saat dibuat, menunjukkan akhir output LLM. Nilai yang benar untuk digunakan di sini umumnya bergantung pada cara model dilatih, dan biasanya ditetapkan oleh plugin model. Namun, jika Anda telah meminta model untuk membuat urutan perhentian lain, Anda dapat menentukannya di sini.

Perhatikan bahwa Anda menentukan urutan karakter, bukan token. Pada umumnya, Anda akan menentukan urutan karakter yang dipetakan oleh tokenizer model ke satu token.

Parameter yang mengontrol "materi iklan"

Parameter temperature, top-p, dan top-k bersama-sama mengontrol tingkat "kreativitas" yang Anda inginkan untuk model. Berikut adalah penjelasan singkat tentang makna parameter ini, tetapi poin yang lebih penting untuk diambil adalah ini: parameter ini digunakan untuk menyesuaikan karakter output LLM. Nilai optimal untuknya bergantung pada sasaran dan preferensi Anda, dan kemungkinan hanya ditemukan melalui eksperimen.

temperature

LLM pada dasarnya adalah mesin prediksi token. Untuk urutan token tertentu (seperti perintah), LLM memprediksi, untuk setiap token dalam kosakatanya, kemungkinan token berikutnya dalam urutan. Suhu adalah faktor penskalaan yang digunakan untuk membagi prediksi ini sebelum dinormalisasi ke kemungkinan antara 0 dan 1.

Nilai suhu rendah—antara 0,0 dan 1,0—akan memperbesar perbedaan kemungkinan antara token, sehingga model akan lebih tidak mungkin menghasilkan token yang sudah dievaluasi sebagai tidak mungkin. Hal ini sering kali dianggap sebagai output yang kurang kreatif. Meskipun secara teknis 0,0 bukan nilai yang valid, banyak model memperlakukannya sebagai indikasi bahwa model harus berperilaku deterministik, dan hanya mempertimbangkan satu token yang paling mungkin.

Nilai suhu tinggi—yang lebih besar dari 1,0—mengompresi perbedaan kemungkinan antara token, sehingga model menjadi lebih cenderung menghasilkan token yang sebelumnya dievaluasi sebagai tidak mungkin. Hal ini sering kali dianggap sebagai output yang lebih kreatif. Beberapa API model menerapkan suhu maksimum, biasanya 2,0.

topP

Top-p adalah nilai antara 0,0 dan 1,0 yang mengontrol jumlah kemungkinan token yang ingin Anda pertimbangkan oleh model, dengan menentukan probabilitas kumulatif token. Misalnya, nilai 1,0 berarti mempertimbangkan setiap kemungkinan token (tetapi tetap memperhitungkan probabilitas setiap token). Nilai 0,4 berarti hanya mempertimbangkan token yang paling mungkin, yang probabilitasnya berjumlah 0,4, dan mengecualikan token yang tersisa dari pertimbangan.

topK

Top-k adalah nilai bilangan bulat yang juga mengontrol jumlah kemungkinan token yang ingin Anda pertimbangkan oleh model, tetapi kali ini dengan menentukan jumlah token maksimum secara eksplisit. Menentukan nilai 1 berarti model harus berperilaku deterministik.

Bereksperimen dengan parameter model

Anda dapat bereksperimen dengan efek parameter ini pada output yang dihasilkan oleh berbagai kombinasi model dan perintah menggunakan UI Developer. Mulai UI developer dengan perintah genkit start dan UI akan otomatis memuat semua model yang ditentukan oleh plugin yang dikonfigurasi dalam project Anda. Anda dapat dengan cepat mencoba berbagai perintah dan nilai konfigurasi tanpa harus berulang kali membuat perubahan ini dalam kode.

Output terstruktur

Saat menggunakan AI generatif sebagai komponen dalam aplikasi, Anda sering kali menginginkan output dalam format selain teks biasa. Meskipun hanya membuat konten untuk ditampilkan kepada pengguna, Anda dapat memanfaatkan output terstruktur hanya untuk tujuan menyajikannya dengan lebih menarik kepada pengguna. Namun, untuk aplikasi AI generatif yang lebih canggih, seperti penggunaan output model secara terprogram, atau memasukkan output dari satu model ke model lain, output terstruktur adalah suatu keharusan.

Di Genkit, Anda dapat meminta output terstruktur dari model dengan menentukan skema saat memanggil generate():

import { z } from 'genkit'; // Import Zod, which is re-exported by Genkit.

const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.number(),
  allergens: z.array(z.string()),
});

const { output } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  output: { schema: MenuItemSchema },
});

Skema output model ditentukan menggunakan library Zod. Selain bahasa definisi skema, Zod juga menyediakan pemeriksaan jenis runtime, yang menjembatani kesenjangan antara jenis TypeScript statis dan output model AI generatif yang tidak dapat diprediksi. Zod memungkinkan Anda menulis kode yang dapat mengandalkan fakta bahwa panggilan generate yang berhasil akan selalu menampilkan output yang sesuai dengan jenis TypeScript Anda.

Saat Anda menentukan skema di generate(), Genkit melakukan beberapa hal di balik layar:

  • Memperkuat perintah dengan panduan tambahan tentang format output yang diinginkan. Hal ini juga memiliki efek samping untuk menentukan kepada model konten apa yang sebenarnya ingin Anda buat (misalnya, tidak hanya menyarankan item menu, tetapi juga membuat deskripsi, daftar alergen, dan sebagainya).
  • Mengurai output model menjadi objek JavaScript.
  • Memverifikasi bahwa output sesuai dengan skema.

Untuk mendapatkan output terstruktur dari panggilan generate yang berhasil, gunakan properti output objek respons:

if (output) {
  const { name, description, calories, allergens } = output;
}

Menangani error

Perhatikan dalam contoh sebelumnya bahwa properti output dapat berupa null. Hal ini dapat terjadi saat model gagal menghasilkan output yang sesuai dengan skema. Strategi terbaik untuk menangani error tersebut akan bergantung pada kasus penggunaan yang tepat, tetapi berikut adalah beberapa petunjuk umum:

  • Coba model lain. Agar output terstruktur berhasil, model harus mampu menghasilkan output dalam JSON. LLM yang paling canggih, seperti Gemini dan Claude, cukup fleksibel untuk melakukan hal ini; namun, model yang lebih kecil, seperti beberapa model lokal yang akan Anda gunakan dengan Ollama, mungkin tidak dapat menghasilkan output terstruktur secara andal kecuali jika telah dilatih secara khusus untuk melakukannya.

  • Manfaatkan kemampuan pemaksaan Zod: Anda dapat menentukan dalam skema bahwa Zod harus mencoba memaksa jenis yang tidak sesuai menjadi jenis yang ditentukan oleh skema. Jika skema Anda menyertakan jenis primitif selain string, penggunaan paksaan Zod dapat mengurangi jumlah kegagalan generate() yang Anda alami. Versi MenuItemSchema berikut menggunakan pemaksaan jenis untuk secara otomatis memperbaiki situasi saat model menghasilkan informasi kalori sebagai string, bukan angka:

    const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.coerce.number(),
  allergens: z.array(z.string()),
});

  • Coba lagi panggilan generate(). Jika model yang Anda pilih jarang gagal menghasilkan output yang sesuai, Anda dapat memperlakukan error seperti saat memperlakukan error jaringan, dan cukup coba ulang permintaan menggunakan beberapa jenis strategi back-off inkremental.

Streaming

Saat membuat teks dalam jumlah besar, Anda dapat meningkatkan pengalaman bagi pengguna dengan menampilkan output saat dibuat—me-streaming output. Contoh streaming yang sudah dikenal dapat dilihat di sebagian besar aplikasi chat LLM: pengguna dapat membaca respons model terhadap pesan mereka saat dibuat, yang meningkatkan responsivitas aplikasi yang dirasakan dan meningkatkan ilusi mengobrol dengan rekan yang cerdas.

Di Genkit, Anda dapat melakukan streaming output menggunakan metode generateStream(). Sintaksisnya mirip dengan metode generate():

const { response, stream } = await ai.generateStream(
  'Suggest a complete menu for a pirate themed restaurant.'
);

Objek respons memiliki properti stream, yang dapat Anda gunakan untuk melakukan iterasi pada output streaming permintaan saat dibuat:

for await (const chunk of stream) {
  console.log(chunk.text);
}

Anda juga bisa mendapatkan output lengkap permintaan, seperti yang dapat Anda lakukan dengan permintaan non-streaming:

const completeText = (await response).text;

Streaming juga berfungsi dengan output terstruktur:

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});

const { response, stream } = await ai.generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant.',
  output: { schema: MenuSchema },
});

for await (const chunk of stream) {
  // `output` is an object representing the entire output so far.
  console.log(chunk.output);
}

// Get the completed output.
const { output } = await response;

Streaming output terstruktur sedikit berbeda dengan streaming teks: properti output dari bagian respons adalah objek yang dibuat dari akumulasi bagian yang telah dihasilkan sejauh ini, bukan objek yang mewakili satu bagian (yang mungkin tidak valid dengan sendirinya). Setiap bagian output terstruktur pada dasarnya menggantikan bagian yang ada sebelumnya.

Misalnya, berikut tampilan lima output pertama dari contoh sebelumnya:

null

{ starters: [ {} ] }

{
  starters: [ { name: "Captain's Treasure Chest", description: 'A' } ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350
    }
  ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350,
      allergens: [Array]
    },
    { name: 'Shipwreck Salad', description: 'Fresh' }
  ]
}

Input multimodal

Contoh yang telah Anda lihat sejauh ini telah menggunakan string teks sebagai perintah model. Meskipun ini tetap menjadi cara paling umum untuk meminta model AI generatif, banyak model juga dapat menerima media lain sebagai perintah. Perintah media paling sering digunakan bersama dengan perintah teks yang menginstruksikan model untuk melakukan beberapa operasi pada media, seperti memberi teks pada gambar atau mentranskripsikan rekaman audio.

Kemampuan untuk menerima input media dan jenis media yang dapat Anda gunakan sepenuhnya bergantung pada model dan API-nya. Misalnya, rangkaian model Gemini 1.5 dapat menerima gambar, video, dan audio sebagai perintah.

Untuk memberikan perintah media ke model yang mendukungnya, alih-alih meneruskan perintah teks sederhana ke generate, teruskan array yang terdiri dari bagian media dan bagian teks:

const { text } = await ai.generate([
  { media: { url: 'https://example.com/photo.jpg' } },
  { text: 'Compose a poem about this image.' },
]);

Dalam contoh di atas, Anda menentukan gambar menggunakan URL HTTPS yang dapat diakses publik. Anda juga dapat meneruskan data media secara langsung dengan mengenkodenya sebagai URL data. Misalnya:

import { readFile } from 'node:fs/promises';

const b64Data = await readFile('photo.jpg', { encoding: 'base64url' });
const dataUrl = `data:image/jpeg;base64,${b64Data}`;

const { text } = await ai.generate([
  { media: { url: dataUrl } },
  { text: 'Compose a poem about this image.' },
]);

Semua model yang mendukung input media mendukung URL data dan URL HTTPS. Beberapa plugin model menambahkan dukungan untuk sumber media lainnya. Misalnya, plugin Vertex AI juga memungkinkan Anda menggunakan URL Cloud Storage (gs://).

Membuat media

Sejauh ini, sebagian besar contoh di halaman ini telah menangani pembuatan teks menggunakan LLM. Namun, Genkit juga dapat digunakan dengan model pembuatan gambar. Menggunakan generate() dengan model pembuatan gambar mirip dengan menggunakan LLM. Misalnya, untuk membuat gambar menggunakan model Imagen2 melalui Vertex AI:

  1. Genkit menggunakan URL data: sebagai format output standar untuk media yang dihasilkan. Ini adalah format standar dengan banyak library yang tersedia untuk menanganinya. Contoh ini menggunakan paket data-urls dari jsdom:

    npm i --save data-urls
npm i --save-dev @types/data-urls

  2. Untuk membuat gambar dan menyimpannya ke file, panggil generate(), yang menentukan model pembuatan gambar dan jenis media format output:

    import { imagen3Fast, vertexAI } from '@genkit-ai/vertexai';
import parseDataURL from 'data-urls';
import { genkit } from 'genkit';

import { writeFile } from 'node:fs/promises';

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

(async () => {
  const { media } = await ai.generate({
    model: imagen3Fast,
    prompt: 'photo of a meal fit for a pirate',
    output: { format: 'media' },
  });

  if (media === null) throw new Error('No media generated.');

  const data = parseDataURL(media.url);
  if (data === null) throw new Error('Invalid "data:" URL.');

  await writeFile(`output.${data.mimeType.subtype}`, data.body);
})();

Langkah berikutnya

Pelajari Genkit lebih lanjut

  • Sebagai developer aplikasi, cara utama Anda memengaruhi output model AI generatif adalah melalui perintah. Baca Pengelolaan perintah untuk mempelajari cara Genkit membantu Anda mengembangkan perintah yang efektif dan mengelolanya di codebase Anda.
  • Meskipun generate() adalah inti dari setiap aplikasi yang didukung AI generatif, aplikasi di dunia nyata biasanya memerlukan pekerjaan tambahan sebelum dan setelah memanggil model AI generatif. Untuk mencerminkan hal ini, Genkit memperkenalkan konsep alur, yang ditentukan seperti fungsi, tetapi menambahkan fitur tambahan seperti observabilitas dan deployment yang disederhanakan. Untuk mempelajari lebih lanjut, lihat Menentukan alur kerja.

Penggunaan LLM lanjutan

  • Salah satu cara untuk meningkatkan kemampuan LLM adalah dengan memintanya dengan daftar cara yang dapat digunakan untuk meminta informasi lebih lanjut dari Anda, atau meminta Anda untuk melakukan beberapa tindakan. Hal ini dikenal sebagai panggilan alat atau panggilan fungsi. Model yang dilatih untuk mendukung kemampuan ini dapat merespons perintah dengan respons berformat khusus, yang menunjukkan kepada aplikasi pemanggil bahwa aplikasi tersebut harus melakukan beberapa tindakan dan mengirim hasilnya kembali ke LLM beserta perintah asli. Genkit memiliki fungsi library yang mengotomatiskan pembuatan perintah dan elemen loop respons panggilan dari implementasi panggilan alat. Lihat Panggilan alat untuk mempelajari lebih lanjut.
  • Retrieval-augmented generation (RAG) adalah teknik yang digunakan untuk memasukkan informasi khusus domain ke dalam output model. Hal ini dilakukan dengan menyisipkan informasi yang relevan ke dalam perintah sebelum meneruskannya ke model bahasa. Penerapan RAG yang lengkap mengharuskan Anda menggabungkan beberapa teknologi: model pembuatan penyematan teks, database vektor, dan model bahasa besar. Lihat Retrieval-augmented generation (RAG) untuk mempelajari cara Genkit menyederhanakan proses koordinasi berbagai elemen ini.

Menguji output model

Sebagai engineer software, Anda terbiasa dengan sistem deterministik yang inputnya yang sama selalu menghasilkan output yang sama. Namun, dengan model AI yang bersifat probabilistik, output dapat bervariasi berdasarkan nuansa halus dalam input, data pelatihan model, dan bahkan keacakan yang sengaja diperkenalkan oleh parameter seperti suhu.

Evaluator Genkit adalah cara terstruktur untuk menilai kualitas respons LLM Anda, menggunakan berbagai strategi. Baca selengkapnya di halaman Evaluasi.