Anleitung: Erste Schritte mit der Gemini API


In diesem Tutorial wird gezeigt, wie Sie für Ihren Go auf die Gemini API zugreifen. mit dem Google AI Go SDK erstellen.

In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:

Darüber hinaus enthält dieses Tutorial Abschnitte zu fortgeschrittenen Anwendungsfällen (z. B. embeddings und Zählen von Tokens) sowie Optionen für Generieren von Inhalten steuern.

Vorbereitung

In dieser Anleitung wird davon ausgegangen, dass Sie mit dem Erstellen von Anwendungen Los.

Achten Sie beim Abschluss dieser Anleitung darauf, dass Ihre Entwicklungsumgebung die 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ören: den API-Schlüssel einrichten, das SDK-Paket installieren und das Modell initialisieren.

API-Schlüssel einrichten

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

API-Schlüssel anfordern

API-Schlüssel sichern

Es wird dringend empfohlen, keinen API-Schlüssel in Ihre Version einzuchecken. zu steuern. 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 Ihren API-Schlüssel als eine Umgebungsvariable.

SDK-Paket installieren

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

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

Generatives Modell initialisieren

Bevor Sie API-Aufrufe ausführen können, müssen Sie die API generatives Modell an.

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 die multimodale Eingabe. In diesem Handbuch finden Sie die Anweisungen für die Implementierungsliste das empfohlene Modell für jeden Anwendungsfall.

Gängige Anwendungsfälle implementieren

Ihr Projekt ist nun eingerichtet. Jetzt können Sie mit der Gemini API experimentieren, um verschiedene Anwendungsfälle zu implementieren:

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

Text aus reiner Texteingabe generieren

Wenn die Prompt-Eingabe nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder den Gemini 1.0 Pro-Modell mit generateContent zum Generieren von Textausgabe:

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. Achten Sie darauf, überprüfen 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. Die Das SDK vereinfacht den Prozess, da es den Status der Unterhaltung verwaltet. Im Gegensatz zu mit GenerateContent müssen Sie den Unterhaltungsverlauf nicht speichern, sich selbst zu zeigen.

Wenn Sie eine Unterhaltung mit mehreren Teilnehmern (z. B. einen Chat) erstellen möchten, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen. Verwenden Sie dann sendMessage(), um eine neue Nutzernachricht zu senden, die auch den und die Antwort auf das Chatprotokoll.

Es gibt zwei mögliche Optionen für role, die mit den Inhalten in einer Gespräch:

  • user: Die Rolle, die die Aufforderungen bereitstellt. Dieser Wert ist der Standardwert für SendMessage Anrufe.

  • model: Die Rolle, die die Antworten bereitstellt. Diese Rolle kann verwendet werden, wenn StartChat() wird mit vorhandenem history aufgerufen.

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 der gesamten Generierung eine Antwort zurück . Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf die gesamte Ergebnis. Verwenden Sie stattdessen Streaming, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Streaming mit der GenerateContentStream-Methode zum Generieren von Text aus einer Text- und Bildeingabe .

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 damit Sie sich mit der Nutzung der Gemini API vertraut machen können. In diesem Abschnitt werden einige Anwendungsfälle, die als fortgeschrittener betrachtet werden können.

Einbettungen verwenden

Einbettung ist eine Technik, mit der Informationen dargestellt werden. als Liste von Gleitkommazahlen in einem Array. Mit Gemini können Sie Text (Wörter, Sätze und Textblöcke) in vektorisierter Form, sodass sie Einbettungen leichter zu vergleichen und gegenüberzustellen. Beispiel: Zwei Texte, die den gleichen ähnliche Themen oder Stimmungen sollten ähnliche Einbettungen haben, durch mathematische Vergleichstechniken wie die Kosinus-Ähnlichkeit identifiziert werden.

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

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 Ihnen, Ausgaben für strukturierte Daten generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zu senden. Mit anderen Worten, Funktionsaufrufe helfen generative Modelle mit externen Systemen verbinden, damit die generierten Inhalte aktuelle und korrekte Informationen enthält. Weitere Informationen finden Sie in der Anleitung für Funktionsaufrufe.

Anzahl der Tokens

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

// 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 die Generierung von Inhalten steuern, indem Sie Modellparameter konfigurieren und die Sicherheitseinstellungen.

Modellparameter konfigurieren

Jeder Prompt, den Sie an das Modell senden, enthält Parameterwerte, mit denen generiert das Modell eine Antwort. Das Modell kann für verschiedene Parameterwerte unterschiedliche Ergebnisse generieren. Weitere Informationen zu Modellparameter: Die Konfiguration ist werden für die Lebensdauer Ihrer 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

Mithilfe der Sicherheitseinstellungen kannst du anpassen, wie wahrscheinlich es ist, dass du Antworten erhältst, als schädlich eingestuft werden. Standardmäßig blockieren die Sicherheitseinstellungen Inhalte mit der Einstellung „Medium“ und/oder eine hohe Wahrscheinlichkeit, dass sie in allen Dimensionen unsicher sind. Weitere Informationen 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 mehrere Modellvarianten für unterschiedliche Anforderungen wie Eingabetypen und -komplexität, Implementierungen für Chat und andere Dialogsprachaufgaben und Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen