Anleitung: Erste Schritte mit der Gemini API


In dieser Anleitung wird gezeigt, wie Sie mit dem Google AI Go SDK auf die Gemini API für Ihre Go-Anwendung zugreifen.

In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:

Darüber hinaus enthält diese Anleitung Abschnitte zu erweiterten Anwendungsfällen (z. B. Einbettungen und Zähltokens) sowie Optionen zur Steuerung der Inhaltsgenerierung.

Voraussetzungen

In dieser Anleitung wird davon ausgegangen, dass Sie mit dem Erstellen von Anwendungen mit Go vertraut sind.

Damit Sie diese Anleitung abschließen können, muss Ihre Entwicklungsumgebung die folgenden Anforderungen erfüllen:

  • Go 1.20 oder höher

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Projekt einrichten. Dazu gehört auch das Einrichten des API-Schlüssels, die Installation des SDK-Pakets und die Initialisierung des Modells.

API-Schlüssel einrichten

Zur Verwendung der Gemini API benötigen Sie einen API-Schlüssel. Falls noch nicht geschehen, erstellen Sie einen Schlüssel in Google AI Studio.

API-Schlüssel anfordern

API-Schlüssel sichern

Es wird dringend empfohlen, keinen API-Schlüssel in das Versionsverwaltungssystem einzuchecken. Stattdessen sollten Sie einen geheimen Speicher für Ihren API-Schlüssel verwenden.

Bei allen Snippets in dieser Anleitung wird davon ausgegangen, dass Sie auf den API-Schlüssel als Umgebungsvariable zugreifen.

SDK-Paket installieren

Wenn Sie die Gemini API in Ihrer eigenen Anwendung verwenden möchten, müssen Sie das Go SDK-Paket mit get in Ihrem Modulverzeichnis platzieren:

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

Generatives Modell initialisieren

Bevor Sie API-Aufrufe ausführen können, müssen Sie das generative Modell importieren und initialisieren.

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

Beachten Sie beim Angeben eines Modells Folgendes:

  • Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B. gemini-1.5-flash für eine multimodale Eingabe). In diesem Leitfaden wird in den Anleitungen für jede Implementierung das empfohlene Modell für jeden Anwendungsfall aufgeführt.

Gängige Anwendungsfälle implementieren

Nachdem Ihr Projekt nun eingerichtet ist, können Sie ausprobieren, wie Sie mit der Gemini API verschiedene Anwendungsfälle implementieren:

Im Abschnitt zu erweiterten Anwendungsfällen finden Sie Informationen zur Gemini API und zu Einbettungen.

Text aus reiner Texteingabe generieren

Wenn der Prompt nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro-Modell mit generateContent, um die Textausgabe zu generieren:

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

Text aus Text- und Bildeingabe generieren (multimodal)

Gemini bietet verschiedene Modelle, die multimodale Eingaben verarbeiten können (Gemini 1.5-Modelle), sodass Sie sowohl Text als auch Bilder eingeben können. Lesen Sie die Bildanforderungen für Prompts.

Wenn die Prompt-Eingabe sowohl Text als auch Bilder enthält, verwenden Sie ein Gemini 1.5-Modell mit der Methode generateContent, um eine Textausgabe zu generieren:

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

Multi-Turn Conversations erstellen (Chat)

Mit Gemini kannst du Unterhaltungen im freien Format über mehrere Runden hinweg führen. Das SDK vereinfacht den Vorgang, da es den Status der Unterhaltung verwaltet. Im Gegensatz zu GenerateContent müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.

Wenn Sie eine mehrsprachige Unterhaltung (z. B. Chat) erstellen möchten, verwenden Sie ein Gemini 1.5-Modell oder Gemini 1.0 Pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen. Verwenden Sie dann sendMessage(), um eine neue Nutzernachricht zu senden. Dadurch werden auch die Nachricht und die Antwort an das Chatprotokoll angehängt.

Es gibt zwei mögliche Optionen für role, die dem Inhalt einer Unterhaltung zugeordnet sind:

  • user: Die Rolle, die die Aufforderungen bereitstellt. Dies ist der Standardwert für SendMessage-Aufrufe.

  • model: Die Rolle, die die Antworten bereitstellt. Diese Rolle kann beim Aufrufen von StartChat() mit vorhandenem history verwendet werden.

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

Streaming für schnellere Interaktionen nutzen

Standardmäßig gibt das Modell nach Abschluss des gesamten Generierungsprozesses eine Antwort zurück. Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das gesamte Ergebnis warten, sondern stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Streaming mit der Methode GenerateContentStream implementiert wird, um Text über einen Text-und-Bild-Eingabe-Prompt zu generieren.

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
}

Sie können einen ähnlichen Ansatz für reine Texteingabe und Chat-Anwendungsfälle verwenden.

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)

Erweiterte Anwendungsfälle implementieren

Die im vorherigen Abschnitt dieses Tutorials beschriebenen gängigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die möglicherweise als komplexer gelten.

Einbettungen verwenden

Einbettung ist eine Technik, mit der Informationen als Liste von Gleitkommazahlen in einem Array dargestellt werden. Mit Gemini können Sie Text (Wörter, Sätze und Textblöcke) vektorisiert darstellen. So lassen sich Einbettungen leichter vergleichen und gegenüberstellen. Beispielsweise sollten zwei Texte, die ein ähnliches Thema oder eine ähnliche Stimmung haben, ähnliche Einbettungen haben, die sich durch mathematische Vergleichstechniken wie Kosinus-Ähnlichkeit erkennen lassen.

Verwenden Sie das Modell embedding-001 mit der Methode EmbedContent (oder der Methode BatchEmbedContent), um Einbettungen zu generieren. Im folgenden Beispiel wird eine Einbettung für einen einzelnen String generiert:

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)

Funktionsaufrufe

Funktionsaufrufe erleichtern es Ihnen, Ausgaben strukturierter Daten aus generativen Modellen zu erhalten. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zurückzugeben. Mit anderen Worten: Funktionsaufrufe helfen Ihnen, generative Modelle mit externen Systemen zu verbinden, damit die generierten Inhalte aktuelle und genaue Informationen enthalten. Weitere Informationen finden Sie in der Anleitung zu Funktionsaufrufen.

Anzahl der Tokens

Bei langen Prompts kann es hilfreich sein, Tokens zu zählen, bevor Inhalte an das Modell gesendet werden. Die folgenden Beispiele zeigen, wie CountTokens() für verschiedene Anwendungsfälle verwendet wird:

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

Optionen zum Steuern der Inhaltserstellung

Sie können das Generieren von Inhalten steuern, indem Sie Modellparameter konfigurieren und Sicherheitseinstellungen verwenden.

Modellparameter konfigurieren

Jede Aufforderung, die Sie an das Modell senden, enthält Parameterwerte, die steuern, wie das Modell eine Antwort generiert. Das Modell kann für verschiedene Parameterwerte unterschiedliche Ergebnisse generieren. Weitere Informationen zu Modellparametern Die Konfiguration wird für die gesamte Lebensdauer der Modellinstanz beibehalten.

// ...

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

// ...

Sicherheitseinstellungen verwenden

Mit Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden können. Standardmäßig blockieren Sicherheitseinstellungen Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit, die als unsicher eingestuft werden, in allen Dimensionen. Weitere Informationen zu den Sicherheitseinstellungen

So legen Sie eine Sicherheitseinstellung fest:

// ...

// 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,
  },
}

// ...

Sie können auch mehrere Sicherheitseinstellungen festlegen:

// ...

// 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,
  },
}

// ...

Nächste Schritte

  • Beim Prompt-Design werden Aufforderungen erstellt, die die gewünschte Antwort aus Sprachmodellen auslösen. Gut strukturierte Eingabeaufforderungen sind wichtig, um genaue, hochwertige Antworten aus einem Sprachmodell zu gewährleisten. Best Practices für das Schreiben von Prompts

  • Gemini bietet verschiedene Modellvarianten für verschiedene Anwendungsfälle, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Sprachaufgaben für Chats und Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen