Gemini API – Kurzanleitung

Python

Auf Google AI ansehen

In Google Colab ausführen

Notebook auf GitHub ansehen

Wenn Sie diese Kurzanleitung lokal ausführen möchten, achten Sie darauf, dass Ihre Entwicklungsumgebung die folgenden Anforderungen erfüllt:

• Python 3.9 oder höher
• Eine Installation von jupyter zum Ausführen des Notebooks.

Ok

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

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

• Go 1.20 oder höher

Node.js

In dieser Kurzanleitung wird davon ausgegangen, dass Sie mit dem Erstellen von Anwendungen mit Node.js vertraut sind.

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

• Node.js v18 und höher
• npm

Web

In dieser Kurzanleitung wird davon ausgegangen, dass Sie mit der Verwendung von JavaScript zum Entwickeln von Webanwendungen vertraut sind. Diese Anleitung ist vom Framework unabhängig.

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

• (Optional) Node.js
• Moderner Webbrowser

Dart (Flutter)

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

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

• Dart 3.2.0 oder höher

Swift

In dieser Kurzanleitung wird davon ausgegangen, dass Sie mit der Verwendung von Xcode zum Entwickeln von Swift-Apps vertraut sind.

Achten Sie für diese Kurzanleitung darauf, dass Ihre Entwicklungsumgebung und die Swift-Anwendung die folgenden Anforderungen erfüllen:

• Xcode 15.0 oder höher
• Ihre Swift-App muss auf iOS 15 oder höher bzw. macOS 12 oder höher ausgerichtet sein.

Android

In dieser Kurzanleitung wird davon ausgegangen, dass Sie mit der Entwicklung von Android-Apps mit Android Studio vertraut sind.

Achten Sie für diese Kurzanleitung darauf, dass Ihre Entwicklungsumgebung und Android-App die folgenden Anforderungen erfüllen:

• Android Studio (neueste Version)
• Deine Android-App muss auf API-Level 21 oder höher ausgerichtet sein.

Python

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. In dieser Kurzanleitung wird davon ausgegangen, dass Sie auf Ihren API-Schlüssel als Umgebungsvariable zugreifen.

Weisen Sie Ihren API-Schlüssel einer Umgebungsvariablen zu:

export API_KEY=<YOUR_API_KEY>

Ok

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. In dieser Kurzanleitung wird davon ausgegangen, dass Sie auf Ihren API-Schlüssel als Umgebungsvariable zugreifen.

Weisen Sie Ihren API-Schlüssel einer Umgebungsvariablen zu:

export API_KEY=<YOUR_API_KEY>

Node.js

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. In dieser Kurzanleitung wird davon ausgegangen, dass Sie auf Ihren API-Schlüssel als Umgebungsvariable zugreifen.

Weisen Sie Ihren API-Schlüssel einer Umgebungsvariablen zu:

export API_KEY=<YOUR_API_KEY>

Web

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. Stattdessen sollten Sie Ihren API-Schlüssel direkt vor der Initialisierung des Modells an Ihre Anwendung übergeben.

In dieser Kurzanleitung wird davon ausgegangen, dass Sie auf Ihren API-Schlüssel als globale Konstante zugreifen.

Dart (Flutter)

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. In dieser Kurzanleitung 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 mit dem API-Schlüssel zu kompilieren, da sich die Prozessumgebung bei der Ausführung der Anwendung unterscheidet.

Swift

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. Eine alternative Option besteht darin, den API-Schlüssel in der Datei GenerativeAI-Info.plist zu speichern und dann aus der Datei .plist zu lesen. Legen Sie diese .plist-Datei in den Stammordner Ihrer Anwendung ab und schließen Sie sie von der Versionsverwaltung aus.

enum APIKey {
   // Fetch the API key from `GenerativeAI-Info.plist`
   static var `default`: String {
      guard let filePath = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist")
      else {
         fatalError("Couldn't find file 'GenerativeAI-Info.plist'.")
      }
      let plist = NSDictionary(contentsOfFile: filePath)
      guard let value = plist?.object(forKey: "API_KEY") as? String else {
         fatalError("Couldn't find key 'API_KEY' in 'GenerativeAI-Info.plist'.")
      }
      if value.starts(with: "_") {
         fatalError(
           "Follow the instructions at https://ai.google.dev/tutorials/setup to get an API key."
         )
      }
      return value
   }
}

Android

Es wird dringend empfohlen, einen API-Schlüssel nicht in das Versionsverwaltungssystem einzuchecken. Speichern Sie ihn stattdessen in einer local.properties-Datei, die sich im Stammverzeichnis Ihres Projekts befindet, von der Versionsverwaltung ausgeschlossen ist, und verwenden Sie dann das Secrets Gradle-Plug-in für Android, um Ihren API-Schlüssel als Build-Konfigurationsvariable zu lesen.

Kotlin:

// Access your API key as a Build Configuration variable
val apiKey = BuildConfig.apiKey

Java:

// Access your API key as a Build Configuration variable
String apiKey = BuildConfig.apiKey;

Wenn Sie sich die Implementierung des Secrets Gradle-Plug-ins ansehen möchten, können Sie sich die Beispiel-App für dieses SDK ansehen oder die neueste Vorschau von Android Studio Iguana verwenden. Dort gibt es eine Gemini API Starter-Vorlage, die für den Einstieg die Datei local.properties enthält.

Python

Das Python SDK für die Gemini API ist im Paket google-generativeai enthalten. Installieren Sie die Abhängigkeit mit „Pip“:

pip install -q -U google-generativeai

Ok

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

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

Node.js

Wenn Sie die Gemini API in Ihrer eigenen Anwendung verwenden möchten, müssen Sie das Paket GoogleGenerativeAI für Node.js installieren:

npm install @google/generative-ai

Web

Importieren Sie @google/generative-ai, um die Gemini API in Ihrer eigenen Web-App zu verwenden:

<script type="importmap">
   {
     "imports": {
       "@google/generative-ai": "https://esm.run/@google/generative-ai"
     }
   }
</script>

Dart (Flutter)

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

Swift

Wenn Sie die Gemini API in Ihrer eigenen Swift-App verwenden möchten, fügen Sie Ihrer App das Paket GoogleGenerativeAI hinzu:

1. Klicken Sie in Xcode in der Projektnavigation mit der rechten Maustaste auf Ihr Projekt.

2. Wählen Sie im Kontextmenü Pakete hinzufügen aus.

3. Fügen Sie im Dialogfeld Add Packages (Pakete hinzufügen) die Paket-URL in die Suchleiste ein: none https://github.com/google/generative-ai-swift

4. Klicken Sie auf Paket hinzufügen. Xcode fügt Ihrem Projekt nun das Paket GoogleGenerativeAI hinzu.

Android

1. Fügen Sie in der Gradle-Konfigurationsdatei des Moduls (auf App-Ebene) (z. B. <project>/<app-module>/build.gradle.kts) die Abhängigkeit für das Google AI SDK for Android hinzu:

   Kotlin:

   dependencies {
   
      // add the dependency for the Google AI client SDK for Android
      implementation("com.google.ai.client.generativeai:generativeai:0.3.0")
   }
   

   Java:

   Für Java müssen Sie zwei weitere Bibliotheken hinzufügen.

   dependencies {
   
       // add the dependency for the Google AI client SDK for Android
       implementation("com.google.ai.client.generativeai:generativeai:0.3.0")
   
       // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
       implementation("com.google.guava:guava:31.0.1-android")
   
       // Required for streaming operations (to use `Publisher` from Reactive Streams)
       implementation("org.reactivestreams:reactive-streams:1.0.4")
   }
   

2. Synchronisiere dein Android-Projekt mit Gradle-Dateien.

Python

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

import google.generativeai as genai

genai.configure(api_key=os.environ["API_KEY"])
model = genai.GenerativeModel('gemini-pro')

Ok

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

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")

Node.js

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

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// ...

// For text-only input, use the gemini-pro model
const model = genAI.getGenerativeModel({ model: "gemini-pro"});

// ...

Web

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

<html>
<body>
   <!-- ... Your HTML and CSS -->
   <!-- Import @google/generative-ai, as shown above. -->
   <script type="module">
      import { GoogleGenerativeAI } from "@google/generative-ai";

      // Fetch your API_KEY
      const API_KEY = "...";

      // Access your API key (see "Set up your API key" above)
      const genAI = new GoogleGenerativeAI(API_KEY);

      // ...

      // For text-only input, use the gemini-pro model
      const model = genAI.getGenerativeModel({ model: "gemini-pro"});

      // ...
   </script>
</body>
</html>

Dart (Flutter)

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

// For text-only input, use the gemini-pro model
final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);

Swift

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

1. Importieren Sie das Modul GoogleAI:

   import GoogleGenerativeAI
   

2. Initialisieren Sie das generative Modell:

   // For text-only input, use the gemini-pro model
   // Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
   let model = GenerativeModel(name: "gemini-pro", apiKey: APIKey.default)
   

Android

Bevor Sie API-Aufrufe ausführen können, müssen Sie das GenerativeModel-Objekt initialisieren:

Kotlin:

val generativeModel = GenerativeModel(
      // For text-only input, use the gemini-pro model
      modelName = "gemini-pro",
      // Access your API key as a Build Configuration variable (see "Set up your API key" above)
      apiKey = BuildConfig.apiKey
)

Java:

Für Java müssen Sie außerdem das GenerativeModelFutures-Objekt initialisieren.

// For text-only input, use the gemini-pro model
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-pro",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
      /* apiKey */ BuildConfig.apiKey);

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Python

response = model.generate_content("Write a story about a magic backpack.")
print(response.text)

Ok

resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Node.js

async function run() {
  const prompt = "Write a story about a magic backpack."

  const result = await model.generateContent(prompt);
  const response = await result.response;
  const text = response.text();
  console.log(text);
}

run();

Web

async function run() {
  const prompt = "Write a story about a magic backpack."

  const result = await model.generateContent(prompt);
  const response = await result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart (Flutter)

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

Swift

let prompt = "Write a story about a magic backpack."
let response = try await model.generateContent(prompt)
if let text = response.text {
  print(text)
}

Android

Kotlin:

Beachten Sie, dass generateContent() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter Android.

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Java:

Beachten Sie, dass generateContent() einen ListenableFuture zurückgibt. Wenn Sie mit dieser API nicht vertraut sind, lesen Sie die Android-Dokumentation zur Verwendung eines ListenableFuture.

Content content = new Content.Builder()
      .addText("Write a story about a magic backpack.")
      .build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
      @Override
      public void onSuccess(GenerateContentResponse result) {
         String resultText = result.getText();
         System.out.println(resultText);
      }

      @Override
      public void onFailure(Throwable t) {
         t.printStackTrace();
      }
}, executor);