Guida rapida dell'API Gemini

Questa guida rapida mostra come iniziare a utilizzare l'API Gemini con l'SDK che preferisci.

Prerequisiti

Python

Visualizza sull'IA di Google Esegui in Google Colab Visualizza blocco note su GitHub

Per completare questa guida rapida a livello locale, assicurati che il tuo ambiente di sviluppo soddisfi i seguenti requisiti:

  • Python 3.9 e versioni successive
  • Un'installazione di jupyter per eseguire il blocco note.

Go

Questa guida rapida presuppone che tu abbia familiarità con la creazione di applicazioni con Go.

Per completare questa guida rapida, assicurati che il tuo ambiente di sviluppo soddisfi i requisiti seguenti:

  • Passa a 1.20+

Node.js

Questa guida rapida presuppone che tu abbia familiarità con la creazione di applicazioni con Node.js.

Per completare questa guida rapida, assicurati che il tuo ambiente di sviluppo soddisfi i requisiti seguenti:

  • Node.js v18+
  • npm

Web

Questa guida rapida presuppone che tu abbia familiarità con l'uso di JavaScript per sviluppare app web. La guida è indipendente dal framework.

Per completare questa guida rapida, assicurati che il tuo ambiente di sviluppo soddisfi i requisiti seguenti:

  • (Facoltativo) Node.js
  • Browser web moderno

Dart (Flutter)

Questa guida rapida presuppone che tu abbia familiarità con la creazione di applicazioni con Dart.

Per completare questa guida rapida, assicurati che il tuo ambiente di sviluppo soddisfi i requisiti seguenti:

  • Dart 3.2.0 o versioni successive

Swift

Questa guida rapida presuppone che tu abbia dimestichezza con l'uso di Xcode per sviluppare app Swift.

Per completare questa guida rapida, assicurati che l'ambiente di sviluppo e l'app Swift soddisfino i seguenti requisiti:

  • Xcode 15.0 o versioni successive
  • L'app Swift deve avere come target iOS 15 o versioni successive oppure macOS 12 o versioni successive.

Android

Questa guida rapida presuppone che tu abbia dimestichezza con l'uso di Android Studio per sviluppare app per Android.

Per completare questa guida rapida, assicurati che l'ambiente di sviluppo e l'app per Android soddisfino i seguenti requisiti:

  • Android Studio (versione più recente)
  • La tua app per Android deve avere il livello API target 21 o versioni successive.

Configura la chiave API

Per utilizzare l'API Gemini, hai bisogno di una chiave API. Se non ne hai già una, crea una chiave in Google AI Studio.

Ottenere una chiave API

Quindi, configura la chiave.

Python

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Questa guida rapida presuppone che tu stia accedendo alla chiave API come variabile di ambiente.

Assegna la chiave API a una variabile di ambiente:

export API_KEY=<YOUR_API_KEY>

Go

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Questa guida rapida presuppone che tu stia accedendo alla chiave API come variabile di ambiente.

Assegna la chiave API a una variabile di ambiente:

export API_KEY=<YOUR_API_KEY>

Node.js

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Questa guida rapida presuppone che tu stia accedendo alla chiave API come variabile di ambiente.

Assegna la chiave API a una variabile di ambiente:

export API_KEY=<YOUR_API_KEY>

Web

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Devi passare la chiave API all'app direttamente prima di inizializzare il modello.

Questa guida rapida presuppone che tu stia accedendo alla chiave API come costante globale.

Dart (Flutter)

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Questa guida rapida presuppone che tu stia accedendo alla chiave API come variabile di ambiente di processo. Se stai sviluppando un'app Flutter, puoi usare String.fromEnvironment e passare --dart-define=API_KEY=$API_KEY a flutter build o flutter run per compilare con la chiave API, poiché l'ambiente di processo sarà diverso durante l'esecuzione dell'app.

Swift

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Un'opzione alternativa è archiviarla in un file GenerativeAI-Info.plist, quindi leggere la chiave API dal file .plist. Assicurati di inserire questo file .plist nella cartella principale dell'app ed escludilo dal controllo della versione.

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

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Dovresti invece archiviarla in un file local.properties (che si trova nella directory root del progetto, ma escluso dal controllo della versione), quindi utilizzare il plug-in Gradle Secrets per Android per leggere la chiave API come variabile di configurazione della build.

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;

Se vuoi vedere l'implementazione del plug-in Secrets Gradle, puoi consultare l'app di esempio per questo SDK o utilizzare l'ultima anteprima di Android Studio Iguana che ha un modello Gemini API Starter (che include il file local.properties per iniziare).

Installa l'SDK

Python

L'SDK Python per l'API Gemini è contenuto nel pacchetto google-generativeai. Installa la dipendenza utilizzando pip:

pip install -q -U google-generativeai

Go

Per utilizzare l'API Gemini nella tua applicazione, devi get il pacchetto SDK Go nella directory del modulo:

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

Node.js

Per utilizzare l'API Gemini nella tua applicazione, devi installare il pacchetto GoogleGenerativeAI per Node.js:

npm install @google/generative-ai

Web

Per utilizzare l'API Gemini nella tua app web, importa @google/generative-ai:

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

Dart (Flutter)

Per utilizzare l'API Gemini nella tua applicazione, devi add il pacchetto google_generative_ai all'app Dart o Flutter:

Dart:

dart pub add google_generative_ai

Flutter:

flutter pub add google_generative_ai

Swift

Per utilizzare l'API Gemini nella tua app Swift, aggiungi il pacchetto GoogleGenerativeAI all'app:

  1. In Xcode, fai clic con il tasto destro del mouse sul progetto nella barra di navigazione dei progetti.

  2. Seleziona Aggiungi pacchetti dal menu contestuale.

  3. Nella finestra di dialogo Aggiungi pacchetti, incolla l'URL del pacchetto nella barra di ricerca: none https://github.com/google/generative-ai-swift

  4. Fai clic su Aggiungi pacchetto. Xcode ora aggiungerà il pacchetto GoogleGenerativeAI al tuo progetto.

Android

  1. Nel file di configurazione Gradle del modulo (a livello di app) (ad esempio <project>/<app-module>/build.gradle.kts), aggiungi la dipendenza per l'SDK IA di Google per 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:

    Per Java, devi aggiungere altre due librerie.

    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. Sincronizza il tuo progetto Android con i file Gradle.

Inizializzare il modello generativo

Python

Prima di poter effettuare chiamate API, devi importare e inizializzare il modello generativo.

import google.generativeai as genai

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

Go

Prima di poter effettuare chiamate API, devi importare e inizializzare il modello generativo.

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

Prima di poter effettuare chiamate API, devi importare e inizializzare il modello generativo.

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

Prima di poter effettuare chiamate API, devi importare e inizializzare il modello generativo.

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

Prima di poter effettuare chiamate API, devi importare e inizializzare il modello generativo.

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

Prima di poter effettuare chiamate API, devi inizializzare il modello generativo.

  1. Importa il modulo GoogleAI:

    import GoogleGenerativeAI

  2. Inizializza il modello generativo:

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

Prima di poter effettuare chiamate API, devi inizializzare l'oggetto 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:

Per Java, devi inizializzare l'oggetto 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);

Genera testo

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:

Tieni presente che generateContent() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non le conosci, leggi Kotlin Coroutines su Android.

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

Java:

Tieni presente che generateContent() restituisce ListenableFuture. Se non hai dimestichezza con questa API, consulta la documentazione per Android sull'utilizzo di 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);

Passaggi successivi

Per scoprire di più sull'utilizzo dell'API Gemini, guarda il tutorial per la lingua preferita.

Puoi anche utilizzare i comandi curl per provare l'API Gemini:

Se non hai mai utilizzato i modelli di IA generativa, ti consigliamo di dare un'occhiata alla guida ai concetti e alla panoramica dell'API Gemini prima di provare la guida rapida.