Pierwsze kroki z interfejsem Gemini API w aplikacjach w języku Go

W tym samouczku pokazujemy, jak uzyskać dostęp do interfejsu Gemini API w aplikacji w języku Go za pomocą pakietu SDK Google AI Go.

Z tego samouczka dowiesz się, jak:

Ten samouczek zawiera też sekcje dotyczące zaawansowanych przypadków użycia (takich jak umieszczanie na stronie i tokeny zliczania) oraz opcje kontrolowania generowania treści.

Wymagania wstępne

W tym samouczku zakładamy, że umiesz tworzyć aplikacje w języku Go.

Aby ukończyć ten samouczek, sprawdź, czy Twoje środowisko programistyczne spełnia te wymagania:

  • Go 1.20+

Konfigurowanie projektu

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt, który obejmuje skonfigurowanie klucza interfejsu API, zainstalowanie pakietu SDK i zainicjowanie modelu.

Konfigurowanie klucza interfejsu API

Aby korzystać z interfejsu Gemini API, potrzebujesz klucza interfejsu API. Jeśli nie masz jeszcze klucza, utwórz go w Google AI Studio.

Uzyskiwanie klucza interfejsu API

Zabezpieczanie klucza interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w systemie kontroli wersji. Zamiast tego używaj magazynu obiektów tajnych klucza interfejsu API.

Wszystkie fragmenty kodu w tym samouczku zakładają, że uzyskujesz dostęp do klucza interfejsu API jako zmiennej środowiskowej.

Zainstaluj pakiet SDK

Aby użyć interfejsu Gemini API we własnej aplikacji, musisz get pakiet SDK Go w katalogu modułów:

go get github.com/google/generative-ai-go

Inicjowanie modelu generatywnego

Zanim zaczniesz wywoływać interfejs API, musisz zaimportować i zainicjować model generatywny.

import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("MODEL_NAME")

Określając model, pamiętaj o tych kwestiach:

  • Użyj modelu, który odpowiada Twojemu przypadkowi użycia (np. gemini-pro-vision jest używany w przypadku multimodalnych danych wejściowych). W tym przewodniku w instrukcjach dotyczących poszczególnych implementacji wymieniono model zalecany dla każdego przypadku użycia.

Wdrażanie typowych przypadków użycia

Po skonfigurowaniu projektu możesz zacząć korzystać z interfejsu Gemini API, aby wdrażać różne przypadki użycia:

W sekcji zaawansowanych przypadków użycia znajdziesz informacje o interfejsie Gemini API i umieszczaniu.

Generuj tekst na podstawie samego tekstu

Jeśli dane wejściowe promptu zawierają tylko tekst, użyj modelu gemini-pro z metodą GenerateContent, aby wygenerować dane wyjściowe tekstowe:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Generuj tekst na podstawie danych wejściowych typu tekst i obraz (multimodalne)

Gemini udostępnia model multimodalny (gemini-pro-vision), który umożliwia wpisywanie zarówno tekstu, jak i obrazów. Zapoznaj się z wymaganiami dotyczącymi obrazów w promptach.

Jeśli dane wejściowe promptu zawierają zarówno tekst, jak i obrazy, do wygenerowania danych wyjściowych tekstowych użyj modelu gemini-pro-vision z metodą GenerateContent:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imgData1, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

imgData2, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.ImageData("jpeg", imgData1),
  genai.ImageData("jpeg", imgData2),
  genai.Text("What's different between these two pictures?"),
}
resp, err := model.GenerateContent(ctx, prompt...)

if err != nil {
  log.Fatal(err)
}

Tworzenie rozmów wieloetapowych (czat)

Dzięki Gemini możesz swobodnie prowadzić rozmowy w wielu etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, więc w przeciwieństwie do pakietu GenerateContent nie musisz samodzielnie przechowywać historii rozmowy.

Aby utworzyć rozmowę wieloetapową (taką jak czat), użyj modelu gemini-pro i zainicjuj czat, wywołując metodę StartChat(). Następnie za pomocą polecenia SendMessage() możesz wysłać nową wiadomość do użytkownika, która również dołączy tę wiadomość i odpowiedź do historii czatu.

Atrybut role może być powiązany z treścią rozmowy na 2 sposoby:

  • user: rola, która udostępnia prompty. Jest to wartość domyślna w przypadku wywołań funkcji SendMessage.

  • model: rola, która udziela odpowiedzi. Tej roli można używać przy wywoływaniu funkcji StartChat() za pomocą istniejącej funkcji history.

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
// Initialize the chat
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
  log.Fatal(err)
}

Strumieniowanie zapewnia szybsze interakcje

Domyślnie model zwraca odpowiedź po zakończeniu całego procesu generowania. Możesz przyspieszyć interakcje, nie czekając na cały wynik. Zamiast tego możesz używać strumieniowania do obsługi częściowych wyników.

Z przykładu poniżej dowiesz się, jak wdrożyć strumieniowanie za pomocą metody GenerateContentStream, aby generować tekst na podstawie promptu z tekstem i obrazem.

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imageBytes, err := os.ReadFile(pathToImage)

img := genai.ImageData("jpeg", imageBytes)
prompt := genai.Text("Tell me a story about this animal")
iter := model.GenerateContentStream(ctx, img, prompt)

for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // ... print resp
}

Podobne podejście możesz zastosować w przypadkach użycia związanych tylko z tekstem i na czacie.

prompt := genai.Text("Tell me a story about a lumberjack and his giant ox")
iter := model.GenerateContentStream(ctx, prompt)

prompt := genai.Text("And how do you feel about that?")
iter := cs.SendMessageStream(ctx, prompt)

Wdrażanie zaawansowanych przypadków użycia

Typowe przypadki użycia opisane w poprzedniej części tego samouczka pomogą Ci zapoznać się z interfejsem Gemini API. W tej sekcji opisujemy kilka przypadków użycia, które mogą być bardziej zaawansowane.

Użyj wektorów dystrybucyjnych

Umieszczanie to technika używana do przedstawiania informacji w postaci listy liczb zmiennoprzecinkowych w tablicy. Gemini możesz reprezentować tekst (słowa, zdania i bloki tekstu) w formie wektorowej, co ułatwia porównywanie i różnicowanie reprezentacji właściwościowych. Na przykład 2 teksty o podobnej tematyce lub uczuciach powinny mieć podobne osadzenia, co można zidentyfikować za pomocą matematycznych technik porównywania, takich jak podobieństwo cosinusowe.

Do generowania wektorów dystrybucyjnych użyj modelu embedding-001 z metodą EmbedContent (lub metody BatchEmbedContent). Ten przykład generuje umieszczenie pojedynczego ciągu znaków:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()
em := client.EmbeddingModel("embedding-001")
res, err := em.EmbedContent(ctx, genai.Text("The quick brown fox jumps over the lazy dog."))

if err != nil {
  panic(err)
}
fmt.Println(res.Embedding.Values)

Wywoływanie funkcji

Wywoływanie funkcji ułatwia uzyskiwanie uporządkowanych danych wyjściowych z modeli generatywnych. Następnie możesz użyć tych danych wyjściowych, aby wywoływać inne interfejsy API i zwracać odpowiednie dane odpowiedzi do modelu. Inaczej mówiąc, wywołania funkcji pomagają połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały aktualne i dokładne informacje. Więcej informacji znajdziesz w samouczku wywoływania funkcji.

Policz tokeny

W przypadku używania długich promptów warto zliczać tokeny przed wysłaniem jakiejkolwiek treści do modelu. Poniższe przykłady pokazują, jak używać właściwości CountTokens() w różnych przypadkach użycia:

// For text-only input
text := "Parrots can be green and live a long time."
resp, err := model.CountTokens(ctx, genai.Text(text))
if err != nil {
  log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

// For text-and-image input (multimodal)
text := "Parrots can be green and live a long time."
imageBytes, err := os.ReadFile(pathToImage)
if err != nil {
  log.Fatal(err)
}

resp, err := model.CountTokens(
    ctx,
    genai.Text(text),
    genai.ImageData("png", imageBytes))
  if err != nil {
    log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

Opcje sterowania generowaniem treści

Możesz kontrolować generowanie treści, konfigurując parametry modelu i używając ustawień bezpieczeństwa.

Skonfiguruj parametry modelu

Każdy prompt, który wysyłasz do modelu, zawiera wartości parametrów, które kontrolują sposób generowania odpowiedzi przez model. Model może generować różne wyniki dla różnych wartości parametrów. Dowiedz się więcej o parametrach modelu. Konfiguracja jest zachowywana przez cały okres istnienia instancji modelu.

// ...

model := client.GenerativeModel("MODEL_NAME")

// Configure model parameters by invoking Set* methods on the model.
model.SetTemperature(0.9)
model.SetTopK(1)

// ...

Korzystanie z ustawień bezpieczeństwa

Za pomocą ustawień bezpieczeństwa możesz dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą zostać uznane za szkodliwe. Ustawienia bezpieczeństwa domyślnie blokują treści o średnim lub wysokim prawdopodobieństwie, że mogą być niebezpieczne we wszystkich wymiarach. Dowiedz się więcej o ustawieniach bezpieczeństwa.

Aby skonfigurować jedno ustawienie bezpieczeństwa:

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
}

// ...

Możesz też skonfigurować więcej niż jedno ustawienie bezpieczeństwa:

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
  {
    Category:  genai.HarmCategoryHateSpeech,
    Threshold: genai.HarmBlockMediumAndAbove,
  },
}

// ...

Co dalej

  • Projektowanie promptów to proces tworzenia promptów, które wywołują pożądaną odpowiedź od modeli językowych. Tworzenie dobrze uporządkowanych promptów to klucz do zapewnienia dokładnych i wysokiej jakości odpowiedzi z modelu językowego. Poznaj sprawdzone metody pisania promptów.

  • Gemini oferuje kilka wersji modelu, które spełniają różne potrzeby dotyczące na przykład typów danych wejściowych i złożoności, implementacji czatu lub innych zadań związanych z językiem okna czy ograniczeń rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.

  • Gemini udostępnia opcje, dzięki którym możesz poprosić o zwiększenie limitu częstotliwości. Dla modeli Gemini Pro limit szybkości wynosi 60 żądań na minutę (RPM).