Samouczek: pierwsze kroki z interfejsem Gemini API


Ten samouczek pokazuje, jak uzyskać dostęp do interfejsu Gemini API w języku Go za pomocą pakietu SDK AI Go od Google.

Z tego samouczka dowiesz się, jak:

Ponadto w tym samouczku znajdują się sekcje dotyczące zaawansowanych przypadków użycia (takich jak umieszczone elementy oraz tokeny liczenia) oraz opcje kontrolowanie generowania treści.

Wymagania wstępne

W tym samouczku zakładamy, że umiesz tworzyć aplikacje OK.

Aby ukończyć ten samouczek, upewnij się, że Twoje środowisko programistyczne spełnia wymagania następujące wymagania:

  • Go 1.20+

Konfigurowanie projektu

Zanim wywołasz Gemini API, musisz skonfigurować projekt, który obejmuje skonfigurować klucz interfejsu API, zainstalować pakiet SDK i zainicjować model.

Konfigurowanie klucza interfejsu API

Aby korzystać z Gemini API, potrzebujesz klucza interfejsu API. Jeśli jeszcze nie masz konta Google, utworzyć klucz w Google AI Studio.

Uzyskiwanie klucza interfejsu API

Zabezpiecz klucz interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w wersji systemu sterowania. Zamiast tego użyj magazynu obiektów tajnych dla klucza interfejsu API.

Wszystkie fragmenty kodu w tym samouczku zakładają, że używasz klucza interfejsu API jako zmienną środowiskową.

Zainstaluj pakiet SDK

Aby używać Gemini API w swojej aplikacji, musisz get pakiet SDK Go w katalogu modułów.

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

Zainicjuj model generatywny

Zanim będzie można wykonywać wywołania interfejsu 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()

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

Podczas określania modelu pamiętaj o tych kwestiach:

  • Użyj modelu dopasowanego do Twojego przypadku użycia (np. gemini-1.5-flash służy do wprowadzania danych multimodalnych). Instrukcje w tym przewodniku dla poszczególnych elementów dla każdego z nich z listą zalecanych modeli.

Wdrażanie typowych przypadków użycia

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

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

Generuj tekst na podstawie samego tekstu

Jeśli prompt zawiera tylko tekst, użyj modelu Gemini 1.5 lub Model Gemini 1.0 Pro z funkcją generateContent do generowania tekstu:

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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
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 z tekstem i obrazem (multimodalny)

Gemini udostępnia różne modele, które obsługują dane wejściowe multimodalne (modele Gemini 1.5), dzięki czemu możesz wpisywać zarówno tekst, jak i obrazy. Upewnij się, że: zapoznaj się z wymagania dotyczące obrazów w promptach.

Jeśli prompt zawiera zarówno tekst, jak i obrazy, użyj modelu Gemini 1.5 za pomocą metody generateContent do generowania tekstowych danych wyjściowych:

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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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)

Za pomocą Gemini możesz prowadzić swobodne rozmowy na różnych etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, dlatego w przeciwieństwie do dzięki GenerateContent nie musisz zapisywać historii rozmów siebie.

Aby utworzyć rozmowę wieloetapową (np. czat), użyj modelu Gemini 1.5 lub Gemini 1.0 Pro i zainicjuj czat, dzwoniąc pod numer startChat(). Następnie użyj sendMessage(), aby wysłać nową wiadomość dla użytkownika, która będzie też dołączać tag wiadomości oraz odpowiedź na nie.

Istnieją 2 opcje dla elementu role związane z treścią w rozmowa:

  • user: rola, która dostarcza prompty. Jest to wartość domyślna dla opcji SendMessage połączeń.

  • model: rola, która dostarcza odpowiedzi. Tej roli można używać, gdy Dzwonię pod numer StartChat() w istniejącej sieci 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()

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
model := client.GenerativeModel("gemini-1.5-flash")
// 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)
}

Używaj strumieniowania, aby przyspieszyć interakcje

Domyślnie model zwraca odpowiedź po zakończeniu całego generowania proces tworzenia konta. Możesz przyspieszyć interakcje, nie czekając do końca i używać strumieniowania do obsługi wyników częściowych.

Poniższy przykład pokazuje, jak wdrożyć strumieniowanie za pomocą Metoda GenerateContentStream do generowania tekstu na podstawie danych wejściowych 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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 samego tekstu i czatu.

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 sekcji tego samouczka są pomocne znasz już interfejs Gemini API. W tej sekcji opisano niektóre przypadków użycia, które można uznać za bardziej zaawansowane.

Korzystanie z wektorów dystrybucyjnych

Umieszczanie to technika używana do przedstawiania informacji. jako listę liczb zmiennoprzecinkowych w tablicy. Dzięki Gemini możesz zaprezentować tekstu (słów, zdań i bloków tekstu) w postaci wektorowej, dzięki czemu łatwiej będzie porównać reprezentacje właściwościowe. Na przykład 2 teksty o tym samym identyfikatorze tematyka lub nastawienie powinny mieć podobne wektory dystrybucyjne, zidentyfikowanych za pomocą technik porównań matematycznych, takich jak podobieństwo cosinusowe.

Użyj modelu embedding-001 z metodą EmbedContent (lub BatchEmbedContent), aby wygenerować wektory dystrybucyjne. Przykład poniżej generuje wektor dystrybucyjny dla 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()
// For embeddings, use the embedding-001 model
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łanie funkcji ułatwia pobieranie danych wyjściowych z uporządkowanych danych modeli generatywnych. Następnie możesz użyć tych danych wyjściowych do wywołania innych interfejsów API i zwrócenia odpowiednich danych odpowiedzi dla modelu. Innymi słowy, wywołanie funkcji pomaga Łączysz modele generatywne z systemami zewnętrznymi, aby wygenerowane treści zawiera najbardziej aktualne i dokładne informacje. Więcej informacji: samouczek wywoływania funkcji.

Policz tokeny

Jeśli używasz długich promptów, warto policzyć tokeny przed wysłaniem do modelu. Poniższe przykłady pokazują, jak używać atrybutu CountTokens() do różnych celów:

// 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 kontrolowania generowania treści

Generowanie treści możesz kontrolować, konfigurując parametry modelu i za pomocą funkcji ustawieniach bezpieczeństwa.

Skonfiguruj parametry modelu

Każdy prompt wysyłany do modelu zawiera wartości parametrów, które określają, model wygeneruje odpowiedź. Model może generować różne wyniki dla: różne wartości parametrów. Więcej informacji o Parametry modelu. Konfiguracja jest utrzymywane przez cały okres istnienia instancji modelu.

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

Korzystanie z ustawień bezpieczeństwa

W ustawieniach bezpieczeństwa możesz dostosować prawdopodobieństwo otrzymania odpowiedzi, mogą zostać uznane za szkodliwe. Domyślnie ustawienia bezpieczeństwa blokują treści zawierające medium lub wysokie prawdopodobieństwo, że treści te mogą być niebezpieczne we wszystkich wymiarach. Ucz się Dowiedz się więcej o Ustawieniach bezpieczeństwa.

Aby skonfigurować jedno ustawienie bezpieczeństwa:

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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ą oczekiwane działanie odpowiedzi modelowych. Tworzenie dobrze ustrukturyzowanych promptów to podstawa jest częścią zapewniania dokładnych i wysokiej jakości odpowiedzi z modelu językowego. Poznaj sprawdzone metody pisania promptów.

  • Gemini oferuje kilka wersji modelu, które można dopasować do różnych zastosowań takie jak typy danych wejściowych i złożoność, wdrożenia czatu zadania związane z językiem okien dialogowych i ograniczeniami rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.