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 mengambil input, yang disebut perintah (paling sering teks, gambar, atau kombinasi keduanya), dan darinya menghasilkan teks output, gambar, atau bahkan audio atau video.

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. Setiap model memiliki kelebihan dan kekurangannya sendiri dan satu model mungkin unggul dalam satu tugas, tetapi berperforma kurang baik dalam tugas lainnya. Aplikasi yang memanfaatkan AI generatif sering kali dapat memanfaatkan beberapa model yang berbeda, bergantung pada tugas yang ada.

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. Jika ingin mengupgrade dari satu model ke model yang terbaru dan paling andal, Anda mungkin harus membangun integrasi tersebut secara berulang.

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 Google AI
  • 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 untuk 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 masing-masing plugin dan ikuti langkah-langkah di sana sebelum melanjutkan.

Fungsi generate()

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

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

import { generate } from '@genkit-ai/ai';
import { configureGenkit } from '@genkit-ai/core';
import { gemini15Flash } from '@genkit-ai/googleai';

configureGenkit(/* ... */);

(async () => {
  const llmResponse = await generate({
    model: gemini15Flash,
    prompt: 'Invent a menu item for a pirate themed restaurant.',
  });

  console.log(await llmResponse.text());
})();

Saat Anda menjalankan contoh singkat ini, beberapa informasi proses debug akan dicetak, diikuti dengan output panggilan generate(), yang biasanya adalah teks Markdown seperti pada 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 kembali skrip dan Anda akan mendapatkan output yang berbeda.

Contoh kode sebelumnya menentukan model menggunakan referensi model yang diekspor oleh plugin model. Anda juga dapat menentukan model menggunakan ID string:

const llmResponse = await generate({
  model: 'googleai/gemini-1.5-flash-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:

const llmResponse = await generate({
  model: 'ollama/gemma2',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Semua contoh sebelumnya juga mengilustrasikan 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 lanjutan dengan model generatif, yang akan Anda lihat di bagian selanjutnya.

Parameter model

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

const llmResponse = await generate({
  prompt: "Suggest an item for the menu of a pirate themed restaurant",
  model: gemini15Flash,
  config: {
    maxOutputTokens: 400,
    stopSequences: ["<end>", "<fin>"],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

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

Parameter yang mengontrol durasi 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 prompt Anda ke dalam 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 dihasilkan, menunjukkan akhir dari 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 kebanyakan kasus, Anda akan menentukan urutan karakter yang dipetakan tokenizer model ke satu token.

Parameter yang mengontrol "materi iklan"

Parameter temperature, top-p, dan top-k mengontrol seberapa "kreatif" model yang Anda inginkan. 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—memperkuat perbedaan kemungkinan di antara token, sehingga model akan lebih kecil kemungkinannya untuk menghasilkan token yang sudah dievaluasi sebagai kemungkinan yang 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 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 Anda inginkan untuk dipertimbangkan 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 perintah ini 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 penerapan AI generatif yang lebih canggih, seperti penggunaan output model secara terprogram, atau memasukkan output dari satu model ke model lainnya, output terstruktur adalah suatu keharusan.

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

import { z } from "zod";

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

const llmResponse = await generate({
  prompt: "Suggest an item for the menu of a pirate themed restaurant",
  model: gemini15Flash,
  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 metode output() objek respons:

type MenuItem = z.infer<typeof MenuItemSchema>;

const output: MenuItem | null = llmResponse.output();

Menangani error

Perhatikan pada contoh sebelumnya bahwa metode output dapat menampilkan null. Hal ini dapat terjadi saat model gagal menghasilkan output yang sesuai dengan skema. Anda juga dapat mendeteksi kondisi ini dengan menangkap pengecualian NoValidCandidatesError yang ditampilkan dengan generate:

import { NoValidCandidatesError } from "@genkit-ai/ai";

try {
  llmResponse = await generate(/* ... */);
} catch (e) {
  if (e instanceof NoValidCandidatesError) {
    // Output doesn't conform to schema.
  }
}

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 konversi 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 fungsi generateStream(). Sintaksisnya mirip dengan fungsi generate():

import { generateStream } from "@genkit-ai/ai";
import { GenerateResponseChunk } from "@genkit-ai/ai/lib/generate";

const llmResponseStream = await generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant',
  model: gemini15Flash,
});

Namun, fungsi ini menampilkan bagian respons yang dapat di-iterasi secara asinkron. Tangani setiap potongan ini saat tersedia:

for await (const responseChunkData of llmResponseStream.stream()) {
  const responseChunk = responseChunkData as GenerateResponseChunk;
  console.log(responseChunk.text());
}

Anda tetap bisa mendapatkan seluruh respons sekaligus:

const llmResponse = await llmResponseStream.response();

Streaming juga berfungsi dengan output terstruktur:

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});
type Menu = z.infer<typeof MenuSchema>;

const llmResponseStream = await generateStream({
  prompt: "Suggest a complete menu for a pirate themed restaurant",
  model: gemini15Flash,
  output: { schema: MenuSchema },
});

for await (const responseChunkData of llmResponseStream.stream()) {
  const responseChunk = responseChunkData as GenerateResponseChunk<Menu>;
  // output() returns an object representing the entire output so far
  const output: Menu | null = responseChunk.output();
  console.log(output);
}

Streaming output terstruktur sedikit berbeda dengan streaming teks. Saat memanggil metode output() dari potongan respons, Anda akan mendapatkan objek yang dibangun dari akumulasi potongan yang telah dihasilkan sejauh ini, bukan objek yang mewakili satu bagian (yang mungkin tidak valid sendiri). Setiap bagian output terstruktur menggantikan bagian yang ada sebelumnya.

Misalnya, berikut 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 untuk dibuat, teruskan array yang terdiri dari bagian media dan bagian teks:

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

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

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

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

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

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 data-urls
npm i --save-dev @types/data-urls

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

    import { generate } from '@genkit-ai/ai';
import { configureGenkit } from '@genkit-ai/core';
import { vertexAI, imagen2 } from '@genkit-ai/vertexai';
import parseDataURL from 'data-urls';

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

configureGenkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

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

  const media = mediaResponse.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);
})();

Mencatat histori pesan

Banyak pengguna Anda akan berinteraksi dengan model bahasa besar untuk pertama kali melalui chatbot. Meskipun LLM mampu melakukan lebih dari sekadar menyimulasikan percakapan, model ini tetap merupakan gaya interaksi yang familier dan berguna. Meskipun pengguna tidak akan berinteraksi langsung dengan model dengan cara ini, gaya perintah percakapan merupakan cara yang efektif untuk memengaruhi output yang dihasilkan oleh model AI.

Untuk membuat histori pesan dari respons model, panggil metode toHistory():

let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
});
let history = response.toHistory();

Anda dapat melakukan serialisasi histori ini dan mempertahankannya dalam penyimpanan sesi atau database. Kemudian, teruskan histori beserta perintah pada panggilan mendatang ke generate():

response = await generate({
  model: gemini15Flash,
  prompt: 'How about in Spanish?',
  history,
});
history = response.toHistory();

Jika model yang Anda gunakan mendukung peran system, Anda dapat menggunakan histori awal untuk menetapkan pesan sistem:

import { MessageData } from "@genkit-ai/ai/model";

let history: MessageData[] = [
  { role: 'system', content: [{ text: 'Talk like a pirate.' }] },
];
let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
  history,
});

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 memberinya daftar cara meminta lebih banyak informasi 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 software engineer, Anda terbiasa menggunakan sistem determenistik, di mana input yang sama selalu menghasilkan output yang sama. Namun, jika model AI bersifat probabilistik, output dapat bervariasi berdasarkan perbedaan 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.