Compila conversaciones de varios turnos (chat) con la API de Gemini

Con Gemini API, puedes crear conversaciones de formato libre en varios turnos. El SDK de Vertex AI in Firebase simplifica el proceso administrando el estado de la conversación, por lo que, a diferencia de generateContent() (o generateContentStream()), no tienes que almacenar el historial de conversaciones por tu cuenta.

Otras opciones para trabajar con Gemini API

• De manera opcional, experimenta con una versión alternativa "Google AI" de la función Gemini API
  Obtén acceso sin costo (dentro de los límites y cuando esté disponible) con los SDKs de cliente Google AI Studio y Google AI. Estos SDKs deben usarse solo para crear prototipos en apps web y para dispositivos móviles.

  Una vez que estés familiarizado con el funcionamiento de un Gemini API, migra a nuestros SDKs de Vertex AI in Firebase (esta documentación), que tienen muchas funciones adicionales importantes para las apps web y para dispositivos móviles, como proteger la API del abuso con Firebase App Check y compatibilidad con archivos multimedia grandes en las solicitudes.

• Opcionalmente, llama al Vertex AI Gemini API del servidor (como con Python, Node.js o Go)
  Usa los SDK de Vertex AI del servidor, Genkit o Firebase Extensions para Gemini API.

Antes de comenzar

Si aún no lo has hecho, completa la guía de introducción, en la que se describe cómo configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK, inicializar el servicio Vertex AI y crear una instancia de GenerativeModel.

Cómo enviar una solicitud de instrucción de chat

Para compilar una conversación de varios turnos (como un chat), primero inicializa el chat llamando a startChat(). Luego, usa sendMessage() para enviar un nuevo mensaje del usuario, que también adjuntará el mensaje y la respuesta al historial de chat.

Hay dos opciones posibles para role asociadas con el contenido de una conversación:

• user: Es el rol que proporciona las instrucciones. Este valor es el predeterminado para las llamadas a sendMessage(), y la función arroja una excepción si se pasa un rol diferente.

• model: Es el rol que proporciona las respuestas. Este rol se puede usar cuando se llama a startChat() con history existente.

Nota: Si deseas proporcionar más contexto inicial para que el modelo ayude a dirigir su comportamiento según tus necesidades y casos de uso específicos, considera configurar instrucciones del sistema.

Swift

Puedes llamar a startChat() y a sendMessage() para enviar un mensaje a un usuario nuevo:

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-flash")

// Optionally specify existing chat history
let history = [
  ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
  ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]

// Initialize the chat with optional chat history
let chat = model.startChat(history: history)

// To generate text output, call sendMessage and pass in the message
let response = try await chat.sendMessage("How many paws are in my house?")
print(response.text ?? "No text in response.")

Kotlin

Puedes llamar a startChat() y a sendMessage() para enviar un mensaje a un usuario nuevo:

^{En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutinas.}

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")

// Initialize the chat
val chat = generativeModel.startChat(
  history = listOf(
    content(role = "user") { text("Hello, I have 2 dogs in my house.") },
    content(role = "model") { text("Great to meet you. What would you like to know?") }
  )
)

val response = chat.sendMessage("How many paws are in my house?")
print(response.text)

Java

Puedes llamar a startChat() y a sendMessage() para enviar un mensaje a un usuario nuevo:

^{En Java, los métodos de este SDK muestran un ListenableFuture.}

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// (optional) Create previous chat history for context
Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
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);

Web

Puedes llamar a startChat() y a sendMessage() para enviar un mensaje a un usuario nuevo:

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-flash" });

async function run() {
  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";

  const result = await chat.sendMessage(msg);

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

run();

Dart

Puedes llamar a startChat() y a sendMessage() para enviar un mensaje a un usuario nuevo:

import 'package:firebase_vertexai/firebase_vertexai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-flash');

final chat = model.startChat();
// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

final response = await chat.sendMessage(prompt);
print(response.text);

Aprende a elegir un modelo y, de manera opcional, una ubicación adecuada para tu caso de uso y app.

Transmite la respuesta

Asegúrate de haber completado la sección Antes de comenzar de esta guía antes de probar este ejemplo.

Puedes lograr interacciones más rápidas si no esperas a que se genere todo el resultado del modelo y, en su lugar, usas la transmisión para controlar los resultados parciales. Para transmitir la respuesta, llama a sendMessageStream().

Ver ejemplo: Cómo transmitir respuestas de chat

Swift

Puedes llamar a startChat() y sendMessageStream() para transmitir respuestas del modelo:

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-flash")

// Optionally specify existing chat history
let history = [
  ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
  ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]

// Initialize the chat with optional chat history
let chat = model.startChat(history: history)

// To stream generated text output, call sendMessageStream and pass in the message
let contentStream = try chat.sendMessageStream("How many paws are in my house?")
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

Puedes llamar a startChat() y sendMessageStream() para transmitir respuestas del modelo:

^{En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutinas.}

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")

// Initialize the chat
val chat = generativeModel.startChat(
  history = listOf(
    content(role = "user") { text("Hello, I have 2 dogs in my house.") },
    content(role = "model") { text("Great to meet you. What would you like to know?") }
  )
)

chat.sendMessageStream("How many paws are in my house?").collect { chunk ->
  print(chunk.text)
}

Java

Puedes llamar a startChat() y sendMessageStream() para transmitir respuestas del modelo:

^{En Java, los métodos de transmisión de este SDK muestran un tipo Publisher de la biblioteca Reactive Streams.}

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// (optional) Create previous chat history for context
Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
Publisher<GenerateContentResponse> streamingResponse =
        chat.sendMessageStream(message);

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
            fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    // ... other methods omitted for brevity
});

Web

Puedes llamar a startChat() y sendMessageStream() para transmitir respuestas del modelo:

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-flash" });

async function run() {
  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";
  const result = await chat.sendMessageStream(msg);

  let text = '';
  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
    text += chunkText;
  }
}

run();

Dart

Puedes llamar a startChat() y sendMessageStream() para transmitir respuestas del modelo:

import 'package:firebase_vertexai/firebase_vertexai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-flash');

final chat = model.startChat();
// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

final response = await chat.sendMessageStream(prompt);
await for (final chunk in response) {
  print(chunk.text);
}

---

¿Qué más puedes hacer?

• Obtén más información para contar tokens antes de enviar instrucciones largas al modelo.
• Configura Cloud Storage for Firebase para que puedas incluir archivos grandes en tus solicitudes multimodales y tener una solución más administrada para proporcionar archivos en instrucciones. Los archivos pueden incluir imágenes, archivos PDF, videos y audio.
• Comienza a pensar en prepararte para la producción, lo que incluye configurar Firebase App Check para proteger el Gemini API del abuso de clientes no autorizados. Además, asegúrate de revisar la lista de tareas de producción.

Prueba otras funciones

• Generar texto a partir de instrucciones de solo texto
• Genera texto con instrucciones de varios tipos de archivos, como imágenes, PDF, video y audio.
• Genera resultados estructurados (como JSON) a partir de instrucciones multimodales y de texto.
• Genera imágenes a partir de instrucciones de texto.
• Usa las llamadas a función para conectar los modelos generativos a sistemas y datos externos.

Aprende a controlar la generación de contenido

• Comprende el diseño de instrucciones, incluidas las prácticas recomendadas, las estrategias y los ejemplos de instrucciones.
• Configura los parámetros del modelo, como la temperatura y la cantidad máxima de tokens de salida (para Gemini) o la relación de aspecto y la generación de personas (para Imagen).
• Usa la configuración de seguridad para ajustar la probabilidad de recibir respuestas que se puedan considerar dañinas.

También puedes experimentar con instrucciones y parámetros de configuración de modelos con Vertex AI Studio.

Más información sobre los modelos compatibles

Obtén información sobre los modelos disponibles para varios casos de uso y sus cuotas y precios.

Envía comentarios sobre tu experiencia con Vertex AI in Firebase