Erste Schritte mit der Gemini API in Dart- oder Flutter-Anwendungen

In dieser Anleitung wird gezeigt, wie Sie mit dem Google AI Dart SDK auf die Gemini API für Ihre Dart- oder Flutter-Anwendung zugreifen. Sie können dieses SDK verwenden, wenn Sie für den Zugriff auf Gemini-Modelle in Ihrer Anwendung nicht direkt mit REST APIs arbeiten möchten.

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ählmethoden) sowie Optionen zur Steuerung der Inhaltsgenerierung.

Voraussetzungen

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

Achten Sie beim Durcharbeiten dieser Anleitung darauf, dass Ihre Entwicklungsumgebung die folgenden Anforderungen erfüllt:

  • Dart 3.2.0 oder höher

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Projekt einrichten. Dazu müssen Sie Ihren API-Schlüssel einrichten, das SDK den Pub-Abhängigkeiten hinzufügen und das Modell initialisieren.

API-Schlüssel einrichten

Sie benötigen einen API-Schlüssel, um die Gemini API zu verwenden. Erstellen Sie einen Schlüssel in Google AI Studio, falls noch nicht geschehen.

API-Schlüssel anfordern

API-Schlüssel sichern

Bewahren Sie Ihren API-Schlüssel sicher auf. Wir empfehlen dringend, den API-Schlüssel nicht direkt in den Code einzufügen oder Dateien, die den Schlüssel enthalten, in Versionsverwaltungssysteme einzuchecken. Verwenden Sie stattdessen einen Secrets-Speicher für Ihren API-Schlüssel.

Bei allen Snippets in dieser Anleitung wird davon ausgegangen, dass Sie auf Ihren API-Schlüssel als Prozessumgebungsvariablen zugreifen. Wenn Sie eine Flutter-Anwendung entwickeln, können Sie String.fromEnvironment verwenden und --dart-define=API_KEY=$API_KEY an flutter build oder flutter run übergeben, um sie mit dem API-Schlüssel zu kompilieren, da sich die Prozessumgebung bei der Ausführung der Anwendung unterscheidet.

SDK-Paket installieren

Wenn Sie die Gemini API in Ihrer eigenen Anwendung verwenden möchten, müssen Sie das google_generative_ai-Paket mit add an Ihre Dart- oder Flutter-App anhängen:

Dart 

dart pub add google_generative_ai

Flutter 

flutter pub add google_generative_ai

Generatives Modell initialisieren

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

import 'package:google_generative_ai/google_generative_ai.dart';

// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
  print('No \$API_KEY environment variable');
  exit(1);
}

final model = GenerativeModel(model: 'MODEL_NAME', apiKey: apiKey);

Beachten Sie bei der Angabe eines Modells Folgendes:

  • Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B. gemini-pro-vision ist für die multimodale Eingabe vorgesehen). In diesem Leitfaden ist in den Anleitungen für jede Implementierung das empfohlene Modell für den jeweiligen Anwendungsfall aufgeführt.

Gängige Anwendungsfälle implementieren

Nachdem Ihr Projekt nun eingerichtet ist, können Sie die Verwendung der Gemini API zum Implementieren verschiedener Anwendungsfälle kennenlernen:

Im Abschnitt „Erweiterte Anwendungsfälle“ finden Sie Informationen zur Gemini API und zu Einbettungen.

Text aus reiner Texteingabe generieren

Wenn die Eingabe nur Text enthält, verwenden Sie das Modell gemini-pro mit der Methode generateContent, um eine Textausgabe zu generieren:

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

void main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // For text-only input, use the gemini-pro model
  final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
  final content = [Content.text('Write a story about a magic backpack.')];
  final response = await model.generateContent(content);
  print(response.text);
}

Text aus Text- und Bildeingabe generieren (multimodal)

Gemini bietet ein multimodales Modell (gemini-pro-vision), sodass Sie sowohl Text als auch Bilder eingeben können. Lies dir die Anforderungen an Bilder für die Eingabe durch.

Wenn die Eingabe der Aufforderung sowohl Text als auch Bilder enthält, verwenden Sie das Modell gemini-pro-vision mit der Methode generateContent, um die Textausgabe zu generieren:

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

void main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // For text-and-image input (multimodal), use the gemini-pro-vision model
  final model = GenerativeModel(model: 'gemini-pro-vision', apiKey: apiKey);
  final (firstImage, secondImage) = await (
    File('image0.jpg').readAsBytes(),
    File('image1.jpg').readAsBytes()
  ).wait;
  final prompt = TextPart("What's different between these pictures?");
  final imageParts = [
    DataPart('image/jpeg', firstImage),
    DataPart('image/jpeg', secondImage),
  ];
  final response = await model.generateContent([
    Content.multi([prompt, ...imageParts])
  ]);
  print(response.text);
}

Multi-Turn Conversations (Chat)

Mit Gemini können Sie frei formulierte Unterhaltungen über mehrere Runden hinweg erstellen. Das SDK vereinfacht den Prozess, indem es den Status der Unterhaltung verwaltet. Im Gegensatz zu generateContent müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.

Verwenden Sie das Modell gemini-pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen, um eine Unterhaltung mit mehreren Themen (z. B. Chat) zu erstellen. 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 mit dem Inhalt einer Unterhaltung verknüpft sind:

  • user: die Rolle, die die Prompts bereitstellt. Dieser Wert ist der Standardwert für sendMessage-Aufrufe und die Funktion gibt eine Ausnahme aus, wenn eine andere Rolle übergeben wird.

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

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

Future<void> main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // For text-only input, use the gemini-pro model
  final model = GenerativeModel(
      model: 'gemini-pro',
      apiKey: apiKey,
      generationConfig: GenerationConfig(maxOutputTokens: 100));
  // Initialize the chat
  final chat = model.startChat(history: [
    Content.text('Hello, I have 2 dogs in my house.'),
    Content.model([TextPart('Great to meet you. What would you like to know?')])
  ]);
  var content = Content.text('How many paws are in my house?');
  var response = await chat.sendMessage(content);
  print(response.text);
}

Streaming für schnellere Interaktionen

Standardmäßig gibt das Modell eine Antwort zurück, nachdem der gesamte Generierungsprozess abgeschlossen ist. Sie können Interaktionen beschleunigen, indem Sie nicht auf das gesamte Ergebnis warten und stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Sie Streaming mit der Methode generateContentStream implementieren, um Text aus einer Eingabeaufforderung für Text und Bilder zu generieren.

// ...

final response = model.generateContentStream([
  Content.multi([prompt, ...imageParts])
]);
await for (final chunk in response) {
  print(chunk.text);
}

// ...

Ein ähnlicher Ansatz kann für reine Texteingaben und Chats verwendet werden.

// Use streaming with text-only input
final response = model.generateContentStream(content);

// Use streaming with multi-turn conversations (like chat)
final response = chat.sendMessageStream(content);

Erweiterte Anwendungsfälle implementieren

Die im vorherigen Abschnitt dieser Anleitung beschriebenen häufigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die als komplexer gelten.

Einbettungen verwenden

Das Einbetten ist eine Methode, um Informationen als Liste von Gleitkommazahlen in einem Array darzustellen. Mit Gemini können Sie Text (Wörter, Sätze und Textblöcke) in einer vektorisierten Form darstellen, was das Vergleichen und Gegenüberstellen von Einbettungen erleichtert. Zum Beispiel sollten zwei Texte, die ein ähnliches Thema oder eine ähnliche Stimmung haben, ähnliche Einbettungen haben, die durch mathematische Vergleichstechniken wie Kosinus-Ähnlichkeit identifiziert werden können.

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:

final model = GenerativeModel(model: 'embedding-001', apiKey: apiKey);
final content = Content.text('The quick brown fox jumps over the lazy dog.');
final result = await model.embedContent(content);
print(result.embedding.values);

Anzahl der Tokens

Bei der Verwendung langer Aufforderungen 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
final tokenCount = await model.countTokens(Content.text(prompt));
print('Token count: ${tokenCount.totalTokens}');

// For text-and-image input (multimodal)
final tokenCount = await model.countTokens([
  Content.multi([prompt, ...imageParts])
]);
print('Token count: ${tokenCount.totalTokens}');

// For multi-turn conversations (like chat)
final prompt = Content.text(message);
final allContent = [...chat.history, prompt];
final tokenCount = await model.countTokens(allContent);
print('Token count: ${tokenCount.totalTokens}');

Optionen zum Steuern der Inhaltsgenerierung

Sie können die Inhaltsgenerierung steuern, indem Sie Modellparameter konfigurieren und Sicherheitseinstellungen verwenden.

Wenn Sie generationConfig oder safetySettings an eine Modellanfragemethode wie generateContent übergeben, wird das Konfigurationsobjekt mit demselben Namen, der in getGenerativeModel übergeben wurde, vollständig überschrieben.

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 Lebensdauer der Modellinstanz beibehalten.

final generationConfig = GenerationConfig(
  stopSequences: ["red"],
  maxOutputTokens: 200,
  temperature: 0.9,
  topP: 0.1,
  topK: 16,
);
final model = GenerativeModel(
  model: 'MODEL_NAME',
  apiKey: apiKey,
  generationConfig: generationConfig,
);

Sicherheitseinstellungen verwenden

In den Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden könnten. Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit werden standardmäßig durch Sicherheitseinstellungen in allen Dimensionen blockiert. Weitere Informationen zu Sicherheitseinstellungen

So legen Sie eine Sicherheitseinstellung fest:

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high)
];
final model = GenerativeModel(
  model: 'MODEL_NAME',
  apiKey: apiKey,
  safetySettings: safetySettings,
);

Sie können auch mehrere Sicherheitseinstellungen festlegen:

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high),
  SafetySetting(HarmCategory.hateSpeech, HarmBlockThreshold.high),
];

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 Modellvariationen, um den Anforderungen verschiedener Anwendungsfälle gerecht zu werden, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Dialogsprachaufgaben sowie Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen

  • Gemini bietet Optionen zum Anfordern von Erhöhungen der Ratenbegrenzung. Das Ratenlimit für Gemini Pro-Modelle beträgt 60 Anfragen pro Minute (RPM).