Membuat konten

Firebase Genkit menyediakan antarmuka yang mudah untuk menghasilkan konten dengan LLM.

Model

Model di Firebase Genkit adalah library dan abstraksi yang memberikan akses ke berbagai LLM Google dan non-Google.

Model sepenuhnya diinstrumentasikan untuk kemampuan observasi dan dilengkapi dengan alat integrasi yang disediakan oleh UI Developer Genkit -- Anda dapat mencoba model apa pun menggunakan model runner.

Saat menangani model di Genkit, Anda harus terlebih dahulu mengonfigurasi model Anda ingin kerjakan. Konfigurasi model dilakukan oleh sistem plugin. Di beberapa dalam contoh ini Anda mengonfigurasi plugin Vertex AI, yang menyediakan jaringan.

Go

import "github.com/firebase/genkit/go/ai"
import "github.com/firebase/genkit/go/plugins/vertexai"

// Default to the value of GCLOUD_PROJECT for the project,
// and "us-central1" for the location.
// To specify these values directly, pass a vertexai.Config value to Init.
if err := vertexai.Init(ctx, nil); err != nil {
  return err
}

Untuk menggunakan model yang disediakan oleh plugin, Anda memerlukan referensi ke model tertentu dan versi:

Go

gemini15pro := vertexai.Model("gemini-1.5-pro")

Model yang didukung

Genkit memberikan dukungan model melalui sistem plugin-nya. Plugin berikut didukung secara resmi:

{i>Plugin<i} Model
AI Generatif Google Gemini Pro, Gemini Pro Vision
Vertex AI Google Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
Ollama Banyak model lokal, termasuk Gemma, Llama 2, Mistral, dan lainnya

Lihat dokumen untuk setiap plugin untuk mendapatkan informasi penyiapan dan penggunaan.

Cara membuat konten

Genkit menyediakan fungsi bantuan yang sederhana untuk membuat konten dengan model.

Untuk memanggil model saja:

Go

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")}},
}}
response, err := gemini15pro.Generate(ctx, &request, nil)
if err != nil {
  return err
}

responseText, err := response.Text()
if err != nil {
  return err
}
fmt.Println(responseText)

Anda dapat meneruskan opsi bersama dengan panggilan model. Opsi yang didukung bergantung pada model dan API-nya.

Go

request := ai.GenerateRequest{
  Messages: []*ai.Message{
      {Content: []*ai.Part{ai.NewTextPart("Tell me a joke about dogs.")}},
  },
  Config: ai.GenerationCommonConfig{
      Temperature:     1.67,
      StopSequences:   []string{"abc"},
      MaxOutputTokens: 3,
  },
}

Respons aliran data

Genkit mendukung streaming respons model yang terpotong:

Go

Untuk menggunakan streaming potongan, teruskan fungsi callback ke Generate():

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{ai.NewTextPart("Tell a long story about robots and ninjas.")}},
}}
response, err := gemini15pro.Generate(
  ctx,
  &request,
  func(ctx context.Context, grc *ai.GenerateResponseChunk) error {
      text, err := grc.Text()
      if err != nil {
          return err
      }
      fmt.Printf("Chunk: %s\n", text)
      return nil
  })
if err != nil {
  return err
}

// You can also still get the full response.
responseText, err := response.Text()
if err != nil {
  return err
}
fmt.Println(responseText)

Input multimodal

Jika model mendukung input multimodal, Anda dapat meneruskan perintah gambar:

Go

imageBytes, err := os.ReadFile("img.jpg")
if err != nil {
  return err
}
encodedImage := base64.StdEncoding.EncodeToString(imageBytes)

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{
      ai.NewTextPart("Describe the following image."),
      ai.NewMediaPart("", "data:image/jpeg;base64,"+encodedImage),
  }},
}}
gemini15pro.Generate(ctx, &request, nil)

Format yang tepat untuk perintah gambar (URL https, URL gs, URI data) adalah bergantung pada model.

Panggilan fungsi (alat)

Model genkit menyediakan antarmuka untuk panggilan fungsi, untuk model yang mendukung anotasi.

Go

myJoke := &ai.ToolDefinition{
  Name:        "myJoke",
  Description: "useful when you need a joke to tell",
  InputSchema: make(map[string]any),
  OutputSchema: map[string]any{
      "joke": "string",
  },
}
ai.DefineTool(
  myJoke,
  nil,
  func(ctx context.Context, input map[string]any) (map[string]any, error) {
      return map[string]any{"joke": "haha Just kidding no joke! got you"}, nil
  },
)

request := ai.GenerateRequest{
  Messages: []*ai.Message{
      {Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")},
          Role: ai.RoleUser},
  },
  Tools: []*ai.ToolDefinition{myJoke},
}
response, err := gemini15pro.Generate(ctx, &request, nil)

Tindakan ini akan secara otomatis memanggil alat untuk memenuhi perintah pengguna.

Merekam histori pesan

Model genkit mendukung pemeliharaan histori pesan yang dikirim ke model dan responsnya, yang dapat Anda gunakan untuk membangun pengalaman interaktif, seperti chatbot.

Go

Pada dialog pertama sesi, "history" hanyalah prompt pengguna:

history := []*ai.Message{{
  	Content: []*ai.Part{ai.NewTextPart(prompt)},
  	Role:    ai.RoleUser,
  }}

request := ai.GenerateRequest{Messages: history}
response, err := gemini15pro.Generate(context.Background(), &request, nil)

Saat menerima respons, tambahkan respons tersebut ke histori:

history = append(history, response.Candidates[0].Message)

Anda dapat melakukan serialisasi histori ini dan mempertahankannya dalam penyimpanan sesi atau database. Untuk perintah pengguna berikutnya, tambahkan percakapan tersebut ke histori sebelum menelepon Generate():

history = append(history, &ai.Message{
  Content: []*ai.Part{ai.NewTextPart(prompt)},
  Role:    ai.RoleUser,
})

request = ai.GenerateRequest{Messages: history}
response, err = gemini15pro.Generate(ctx, &request, nil)

Jika model yang Anda gunakan mendukung peran sistem, Anda dapat menggunakan untuk menyetel pesan sistem:

Go

history = []*ai.Message{{
  	Content: []*ai.Part{ai.NewTextPart("Talk like a pirate.")},
  	Role:    ai.RoleSystem,
  }}