Guide de démarrage rapide de l'API Gemini

Ce guide de démarrage rapide vous explique comment utiliser l'API Gemini à l'aide du SDK de votre choix.

Prérequis

Python

Afficher dans l'IA de Google Exécuter dans Google Colab Afficher le notebook sur GitHub

Pour suivre ce guide de démarrage rapide en local, assurez-vous que votre environnement de développement répond aux exigences suivantes:

  • Python 3.9 ou version ultérieure
  • Une installation de jupyter pour exécuter le notebook.

Go

Dans ce guide de démarrage rapide, nous partons du principe que vous savez comment créer des applications avec Go.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement répond aux exigences suivantes:

  • Go 1.20+

Node.js

Dans ce guide, nous partons du principe que vous savez comment créer des applications avec Node.js.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement répond aux exigences suivantes:

  • Node.js v18 et versions ultérieures
  • npm

Web

Dans ce guide, nous partons du principe que vous savez utiliser JavaScript pour développer des applications Web. Ce guide est indépendant du framework.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement répond aux exigences suivantes:

  • (Facultatif) Node.js
  • Navigateur Web récent

Dart (Flutter)

Dans ce guide, nous partons du principe que vous savez comment créer des applications avec Dart.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement répond aux exigences suivantes:

  • Dart 3.2.0 et versions ultérieures

Swift

Dans ce guide de démarrage rapide, nous partons du principe que vous savez utiliser Xcode pour développer des applications Swift.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement et votre application Swift répondent aux exigences suivantes:

  • Xcode 15.0 ou version ultérieure
  • Votre application Swift doit cibler iOS 15 ou version ultérieure, ou macOS 12 ou version ultérieure.

Android

Dans ce guide de démarrage rapide, nous partons du principe que vous savez utiliser Android Studio pour développer des applications Android.

Pour suivre ce guide de démarrage rapide, assurez-vous que votre environnement de développement et votre application Android répondent aux exigences suivantes:

  • Android Studio (dernière version)
  • Votre application Android doit cibler le niveau d'API 21 ou supérieur.

Configurer votre clé API

Pour utiliser l'API Gemini, vous avez besoin d'une clé API. Si vous n'en avez pas, créez-en une dans Google AI Studio.

Obtenir une clé API

Ensuite, configurez votre clé.

Python

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Dans ce guide, nous partons du principe que vous accédez à votre clé API en tant que variable d'environnement.

Attribuez votre clé API à une variable d'environnement:

export API_KEY=<YOUR_API_KEY>

Go

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Dans ce guide, nous partons du principe que vous accédez à votre clé API en tant que variable d'environnement.

Attribuez votre clé API à une variable d'environnement:

export API_KEY=<YOUR_API_KEY>

Node.js

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Dans ce guide, nous partons du principe que vous accédez à votre clé API en tant que variable d'environnement.

Attribuez votre clé API à une variable d'environnement:

export API_KEY=<YOUR_API_KEY>

Web

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Vous devez transmettre votre clé API à votre application juste avant d'initialiser le modèle.

Ce guide de démarrage rapide part du principe que vous accédez à votre clé API en tant que constante globale.

Dart (Flutter)

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Dans ce guide de démarrage rapide, nous partons du principe que vous accédez à votre clé API en tant que variable d'environnement de processus. Si vous développez une application Flutter, vous pouvez utiliser String.fromEnvironment et transmettre --dart-define=API_KEY=$API_KEY à flutter build ou flutter run pour la compiler avec la clé API, car l'environnement de processus sera différent lors de l'exécution de l'application.

Swift

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Une autre option consiste à la stocker dans un fichier GenerativeAI-Info.plist, puis à lire la clé API à partir du fichier .plist. Veillez à placer ce fichier .plist dans le dossier racine de votre application et à l'exclure du contrôle des versions.

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

Nous vous recommandons vivement de ne pas vérifier une clé API dans votre système de contrôle des versions. Stockez-la plutôt dans un fichier local.properties (situé dans le répertoire racine de votre projet, mais exclu du contrôle des versions), puis utilisez le plug-in Secrets Gradle pour Android afin de lire votre clé API en tant que variable de configuration de compilation.

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;

Si vous souhaitez voir l'implémentation du plug-in Secrets Gradle, vous pouvez consulter l'application exemple pour ce SDK ou utiliser la dernière version preview d'Android Studio Iguana, qui propose un modèle Gemini API Starter (qui inclut le fichier local.properties pour vous aider à démarrer).

Installer le SDK

Python

Le SDK Python pour l'API Gemini est contenu dans le package google-generativeai. Installez la dépendance à l'aide de pip:

pip install -q -U google-generativeai

Go

Pour utiliser l'API Gemini dans votre propre application, vous devez get le package SDK Go dans le répertoire de votre module:

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

Node.js

Pour utiliser l'API Gemini dans votre propre application, vous devez installer le package GoogleGenerativeAI pour Node.js:

npm install @google/generative-ai

Web

Pour utiliser l'API Gemini dans votre propre application Web, importez @google/generative-ai:

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

Dart (Flutter)

Pour utiliser l'API Gemini dans votre application, vous devez add le package google_generative_ai sur votre application Dart ou Flutter:

Dart:

dart pub add google_generative_ai

Flutter :

flutter pub add google_generative_ai

Swift

Pour utiliser l'API Gemini dans votre propre application Swift, ajoutez le package GoogleGenerativeAI à votre application:

  1. Dans Xcode, effectuez un clic droit sur votre projet dans le navigateur de projets.

  2. Sélectionnez Add Packages (Ajouter des packages) dans le menu contextuel.

  3. Dans la boîte de dialogue Add Packages (Ajouter des packages), collez l'URL du package dans la barre de recherche : none https://github.com/google/generative-ai-swift

  4. Cliquez sur Add Package (Ajouter un package). Xcode va maintenant ajouter le package GoogleGenerativeAI à votre projet.

Android

  1. Dans le fichier de configuration Gradle de votre module (au niveau de l'application) (comme <project>/<app-module>/build.gradle.kts), ajoutez la dépendance du SDK Google AI pour Android:

    Kotlin:

    dependencies {

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

    Java :

    Pour Java, vous devez ajouter deux bibliothèques supplémentaires.

    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. Synchronisez votre projet Android avec des fichiers Gradle.

Initialiser le modèle génératif

Python

Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.

import google.generativeai as genai

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

Go

Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.

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

Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.

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

Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.

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

Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.

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

Avant de pouvoir effectuer des appels d'API, vous devez initialiser le modèle génératif.

  1. Importez le module GoogleAI:

    import GoogleGenerativeAI

  2. Initialisez le modèle génératif:

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

Avant de pouvoir effectuer des appels d'API, vous devez initialiser l'objet GenerativeModel:

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 :

Pour Java, vous devez également initialiser l'objet GenerativeModelFutures.

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

Générer du texte

Python

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

Go

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:

Notez que generateContent() est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur Android.

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

Java :

Notez que generateContent() renvoie un ListenableFuture. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un 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);

Étapes suivantes

Pour en savoir plus sur l'utilisation de l'API Gemini, consultez le tutoriel correspondant au langage de votre choix.

Vous pouvez également utiliser les commandes curl pour essayer l'API Gemini:

Si vous débutez avec les modèles d'IA générative, vous pouvez consulter le guide des concepts et la présentation de l'API Gemini avant de vous lancer dans le guide de démarrage rapide.