Guía de inicio rápido de la API de Gemini

En esta guía de inicio rápido, se muestra cómo comenzar a usar la API de Gemini con el SDK que elijas.

Requisitos previos

Python

Ver en la IA de Google Ejecutar en Google Colab Ver notebook en GitHub

Para completar esta guía de inicio rápido de manera local, asegúrate de que tu entorno de desarrollo cumpla con los siguientes requisitos:

  • Python 3.9 y versiones posteriores
  • Una instalación de jupyter para ejecutar el notebook

Go

En esta guía de inicio rápido, se da por sentado que estás familiarizado con la compilación de aplicaciones con Go.

Para completar esta guía de inicio rápido, asegúrate de que tu entorno de desarrollo cumpla con los siguientes requisitos:

  • Go 1.20+

Node.js

En esta guía de inicio rápido, se supone que estás familiarizado con la compilación de aplicaciones con Node.js.

Para completar esta guía de inicio rápido, asegúrate de que tu entorno de desarrollo cumpla con los siguientes requisitos:

  • Node.js v18 o versiones posteriores
  • npm

Web

En esta guía de inicio rápido, se da por sentado que estás familiarizado con el uso de JavaScript para desarrollar apps web. Esta guía es independiente del framework.

Para completar esta guía de inicio rápido, asegúrate de que tu entorno de desarrollo cumpla con los siguientes requisitos:

  • Node.js (opcional)
  • Navegador web moderno

Dart (Flutter)

En esta guía de inicio rápido, se supone que estás familiarizado con la compilación de aplicaciones con Dart.

Para completar esta guía de inicio rápido, asegúrate de que tu entorno de desarrollo cumpla con los siguientes requisitos:

  • Dart 3.2.0 o versiones posteriores

Swift

En esta guía de inicio rápido, se supone que estás familiarizado con el uso de Xcode para desarrollar apps de Swift.

Para completar esta guía de inicio rápido, asegúrate de que tu entorno de desarrollo y la app de Swift cumplan con los siguientes requisitos:

  • Xcode 15.0 o una versión más reciente
  • Tu app de Swift debe orientarse a iOS 15 o versiones posteriores, o a macOS 12 o versiones posteriores.

Android

En esta guía de inicio rápido, se asume que estás familiarizado con el uso de Android Studio para desarrollar apps para Android.

Para completar esta guía de inicio rápido, asegúrate de que el entorno de desarrollo y la app para Android cumplan con los siguientes requisitos:

  • Android Studio (versión más reciente)
  • Tu app para Android debe orientarse al nivel de API 21 o uno posterior.

Cómo configurar tu clave de API

Para usar la API de Gemini, necesitarás una clave de API. Si aún no tienes una, crea una clave en Google AI Studio.

Obtén una clave de API.

Luego, configura tu clave.

Python

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En esta guía de inicio rápido, se supone que accedes a tu clave de API como una variable de entorno.

Asigna tu clave de API a una variable de entorno:

export API_KEY=<YOUR_API_KEY>

Go

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En esta guía de inicio rápido, se supone que accedes a tu clave de API como una variable de entorno.

Asigna tu clave de API a una variable de entorno:

export API_KEY=<YOUR_API_KEY>

Node.js

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En esta guía de inicio rápido, se supone que accedes a tu clave de API como una variable de entorno.

Asigna tu clave de API a una variable de entorno:

export API_KEY=<YOUR_API_KEY>

Web

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En cambio, debes pasar la clave de API a la app justo antes de inicializar el modelo.

En esta guía de inicio rápido, se supone que accedes a tu clave de API como una constante global.

Dart (Flutter)

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En esta guía de inicio rápido, se da por sentado que accedes a la clave de API como una variable de entorno del proceso. Si estás desarrollando una app de Flutter, puedes usar String.fromEnvironment y pasar --dart-define=API_KEY=$API_KEY a flutter build o flutter run para compilar con la clave de API, ya que el entorno del proceso será diferente cuando se ejecute la app.

Swift

Te recomendamos que no registres una clave de API en tu sistema de control de versión. Una opción alternativa es almacenarla en un archivo GenerativeAI-Info.plist y, luego, leer la clave de API desde el archivo .plist. Asegúrate de colocar este archivo .plist en la carpeta raíz de tu app y de excluirlo del control de versión.

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

Te recomendamos que no registres una clave de API en tu sistema de control de versión. En cambio, debes almacenarla en un archivo local.properties (que se encuentra en el directorio raíz de tu proyecto, pero se excluye del control de versión) y, luego, usar el complemento Secrets Gradle para Android para leer tu clave de API como una variable de configuración de compilación.

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 deseas ver la implementación del complemento Secrets para Gradle, puedes revisar la app de ejemplo de este SDK o usar la versión preliminar más reciente de Android Studio Iguana, que tiene una plantilla de Gemini API Starter (que incluye el archivo local.properties para comenzar).

Cómo instalar el SDK

Python

El SDK de Python para la API de Gemini se encuentra en el paquete google-generativeai. Instala la dependencia con pip:

pip install -q -U google-generativeai

Go

Para usar la API de Gemini en tu aplicación, debes get el paquete del SDK de Go en el directorio de tu módulo:

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

Node.js

Para usar la API de Gemini en tu aplicación, debes instalar el paquete GoogleGenerativeAI para Node.js:

npm install @google/generative-ai

Web

Para usar la API de Gemini en tu propia app web, importa @google/generative-ai:

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

Dart (Flutter)

Para usar la API de Gemini en tu aplicación, debes add el paquete google_generative_ai en tu app de Dart o Flutter:

Dart:

dart pub add google_generative_ai

Flutter:

flutter pub add google_generative_ai

Swift

Para usar la API de Gemini en tu app de Swift, agrega el paquete GoogleGenerativeAI a la app:

  1. En Xcode, haz clic con el botón derecho en tu proyecto en el navegador de proyectos.

  2. Selecciona Add Packages en el menú contextual.

  3. En el diálogo Add Packages, pega la URL del paquete en la barra de búsqueda: none https://github.com/google/generative-ai-swift

  4. Haz clic en Add Package. Xcode ahora agregará el paquete GoogleGenerativeAI a tu proyecto.

Android

  1. En el archivo de configuración de Gradle del módulo (nivel de app) (como <project>/<app-module>/build.gradle.kts), agrega la dependencia del SDK de Google AI para 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:

    En el caso de Java, debes agregar dos bibliotecas adicionales.

    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. Sincroniza tu proyecto de Android con archivos Gradle.

Inicializa el modelo generativo

Python

Antes de que puedas hacer llamadas a la API, debes importar e inicializar el modelo generativo.

import google.generativeai as genai

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

Go

Antes de que puedas hacer llamadas a la API, debes importar e inicializar el modelo 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

Antes de que puedas hacer llamadas a la API, debes importar e inicializar el modelo 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

Antes de que puedas hacer llamadas a la API, debes importar e inicializar el modelo 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)

Antes de que puedas hacer llamadas a la API, debes importar e inicializar el modelo 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

Antes de realizar llamadas a la API, debes inicializar el modelo generativo.

  1. Importa el módulo GoogleAI:

    import GoogleGenerativeAI

  2. Inicializa el modelo 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

Antes de realizar llamadas a la API, debes inicializar el objeto 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:

En Java, también debes inicializar el objeto 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);

Generar texto

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:

Ten en cuenta que generateContent() es una función de suspensión y se debe llamar desde un alcance de corrutinas. Si no conoces las corrutinas, consulta Corrutinas de Kotlin en Android.

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

Java:

Ten en cuenta que generateContent() muestra un ListenableFuture. Si no conoces esta API, consulta la documentación de Android sobre Cómo usar 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);

Próximos pasos

Si quieres obtener más información para trabajar con la API de Gemini, consulta el instructivo del lenguaje que elijas.

También puedes usar los comandos de curl para probar la API de Gemini:

Si eres nuevo en los modelos de IA generativa, te recomendamos consultar la guía de conceptos y la descripción general de la API de Gemini antes de probar una guía de inicio rápido.