Comienza a usar la API de Prompt

En esta página, se describe cómo hacer lo siguiente:

  • Configura tu proyecto para usar la API de Prompt
  • Proporciona una entrada de solo texto y recibe una respuesta
  • Proporcionar entradas de imagen con entradas de texto relacionadas y recibir una respuesta

Para obtener más detalles sobre la API de Prompt, consulta la documentación de referencia para Kotlin (com.google.mlkit.genai.prompt) y Java (com.google.mlkit.genai.prompt.java, com.google.mlkit.genai.prompt).

Configurar proyecto

Agrega la API de Prompt de ML Kit como una dependencia en tu configuración de build.gradle:

implementation("com.google.mlkit:genai-prompt:1.0.0-beta4")

Si necesitas tus respuestas en un formato determinado con la API de Structured Output, debes configurar KSP y agregar dependencias adicionales. Para obtener más detalles, consulta Genera un resultado estructurado.

Implementa el modelo generativo

Para implementar el código en tu proyecto, sigue estos pasos:

  • Crea un objeto generativeModel:

    Kotlin

    // Get a GenerativeModel instance
val generativeModel = Generation.getClient()

    Java

    // Get a GenerativeModel instance
GenerativeModelFutures generativeModelFutures = GenerativeModelFutures
    .from(Generation.INSTANCE.getClient());

  • Verifica si Gemini Nano es AVAILABLE,, DOWNLOADABLE o UNAVAILABLE. Luego, descarga el atributo si se puede descargar:

    Kotlin

    val status = generativeModel.checkStatus()
when (status) {
    FeatureStatus.UNAVAILABLE -> {
        // Gemini Nano not supported on this device or device hasn't fetched the latest configuration to support it
    }

    FeatureStatus.DOWNLOADABLE -> {
        // Gemini Nano can be downloaded on this device, but is not currently downloaded
        generativeModel.download().collect { status ->
            when (status) {
                is DownloadStatus.DownloadStarted ->
                    Log.d(TAG, "starting download for Gemini Nano")

                is DownloadStatus.DownloadProgress ->
                    Log.d(TAG, "Nano ${status.totalBytesDownloaded} bytes downloaded")

                DownloadStatus.DownloadCompleted -> {
                    Log.d(TAG, "Gemini Nano download complete")
                    modelDownloaded = true
                }

                is DownloadStatus.DownloadFailed -> {
                    Log.e(TAG, "Nano download failed ${status.e.message}")
                }
            }
        }
    }

    FeatureStatus.DOWNLOADING -> {
        // Gemini Nano currently being downloaded
    }

    FeatureStatus.AVAILABLE -> {
        // Gemini Nano currently downloaded and available to use on this device
    }
}

    Java

    ListenableFuture<Integer> status = generativeModelFutures.checkStatus();
Futures.addCallback(generativeModelFutures.checkStatus(), new FutureCallback<>() {
    @Override
    public void onSuccess(Integer featureStatus) {
        switch (featureStatus) {
            case FeatureStatus.AVAILABLE - > {
                // Gemini Nano currently downloaded and available to use on this device
            }
            case FeatureStatus.UNAVAILABLE - > {
                // Gemini Nano not supported on this device or device hasn't fetched the latest configuration to support it
            }
            case FeatureStatus.DOWNLOADING - > {
                // Gemini Nano currently being downloaded
            }
            case FeatureStatus.DOWNLOADABLE - > {
                generativeModelFutures.download(new DownloadCallback() {
                    @Override
                    public void onDownloadStarted(long l) {
                        Log.d(TAG, "starting download for Gemini Nano");
                    }
                    @Override
                    public void onDownloadProgress(long l) {
                        Log.d(TAG, "Nano " + l + " bytes downloaded");
                    }
                    @Override
                    public void onDownloadCompleted() {
                        Log.d(TAG, "Gemini Nano download complete");
                    }
                    @Override
                    public void onDownloadFailed(@NonNull GenAiException e) {
                        Log.e(TAG, "Nano download failed: " + e.getMessage());
                    }
                });
            }
        }
    }
    @Override
    public void onFailure(@NonNull Throwable t) {
        // Failed to check status
    }
}, ContextCompat.getMainExecutor(context));

Proporciona una entrada de solo texto

Kotlin

val response = generativeModel.generateContent("Write a 3 sentence story about a magical dog.")

Java

GenerateContentResponse response = generativeModelFutures.generateContent(
  new GenerateContentRequest.Builder(
    new TextPart("Write a 3 sentence story about a magical dog."))
  .build())
  .get();

Como alternativa, agrega parámetros opcionales:

Kotlin

val response = generativeModel.generateContent(
    generateContentRequest(
        TextPart("Write a 3 sentence story about a magical dog."),
    ) {
        // Optional parameters
        temperature = 0.2f
        topK = 10
        candidateCount = 3
    },
)

Java

GenerateContentRequest.Builder requestBuilder =
        new GenerateContentRequest.Builder(
                new TextPart("Write a 3 sentence story about a magical dog."));
requestBuilder.setTemperature(.2f);
requestBuilder.setTopK(10);
requestBuilder.setCandidateCount(3);

GenerateContentResponse response =
        generativeModelFutures.generateContent(requestBuilder.build()).get();

Para obtener más información sobre los parámetros opcionales, consulta Parámetros de configuración opcionales.

Proporciona entradas multimodales (imagen y texto)

Agrupa varias imágenes y una entrada de texto en la función generateContentRequest(), con la instrucción de texto como una pregunta o un comando relacionado con la imagen. Puedes agrupar hasta 10 imágenes en la misma solicitud.

Kotlin

val response = generativeModel.generateContent(
    generateContentRequest(ImagePart(bitmap1), ImagePart(bitmap2), TextPart(textPrompt)) {
        // optional parameters
        ...
    },
)

Java

GenerateContentResponse response = generativeModelFutures.generateContent(
    new GenerateContentRequest.Builder(
        new Content.Builder()
            .addPart(new ImagePart(bitmap1))
            .addPart(new ImagePart(bitmap2))
            .addPart(new TextPart("textPrompt"))
            .build())
    // optional parameters
    .build())
.get();

Procesa el resultado de la inferencia

  • Ejecuta la inferencia y recupera el resultado. Puedes elegir esperar el resultado completo o transmitir la respuesta a medida que se genera para las instrucciones multimodales y de solo texto.

    • Esto usa la inferencia sin transmisión, que recupera todo el resultado del modelo de IA antes de devolverlo:

    Kotlin

    // Call the AI model to generate content and store the complete
// in a new variable named 'response' once it's finished
val response = generativeModel.generateContent("Write a 3 sentence story about a magical dog")

    Java

    GenerateContentResponse response = generativeModelFutures.generateContent(
        new GenerateContentRequest.Builder(
                new TextPart("Write a 3 sentence story about a magical dog."))
                .build())
        .get();

    • Los siguientes fragmentos son ejemplos de uso de la inferencia de transmisión, que recupera el resultado en fragmentos a medida que se genera:

    Kotlin

    // Streaming inference
var fullResponse = ""
generativeModel.generateContentStream("Write a 3 sentence story about a magical dog").collect { chunk ->
    val newChunkReceived = chunk.candidates[0].text
    print(newChunkReceived)
    fullResponse += newChunkReceived
}

    Java

    // Streaming inference
StringBuilder fullResponse = new StringBuilder();
generativeModelFutures.generateContent(new GenerateContentRequest.Builder(
    (new TextPart("Write a 3 sentence story about a magical dog"))).build(),
        chunk -> {
            Log.d(TAG, chunk);
            fullResponse.append(chunk);
        });

Para obtener más información sobre la inferencia de transmisión y sin transmisión, consulta Transmisión frente a sin transmisión.

Optimización de latencia

Para optimizar la primera llamada de inferencia, tu aplicación puede llamar a warmup() de forma opcional. Esto carga Gemini Nano en la memoria y, además, inicializa los componentes del entorno de ejecución.

Configuración opcional

Como parte de cada GenerateContentRequest, puedes establecer los siguientes parámetros opcionales:

  • temperature : Controla el grado de aleatorización en la selección de tokens.
  • seed : Permite generar resultados estables y determinísticos.
  • topK : Controla la aleatoriedad y la diversidad en los resultados.
  • candidateCount : Solicita la cantidad de respuestas únicas que se devolvieron. Ten en cuenta que la cantidad exacta de respuestas puede no ser la misma que candidateCount, ya que las respuestas duplicadas se quitan automáticamente.
  • maxOutputTokens : Define la cantidad máxima de tokens que se pueden generar en la respuesta.

Para obtener más orientación sobre cómo establecer parámetros de configuración opcionales, consulta GenerateContentRequest.

Funciones y limitaciones admitidas

  • La entrada debe tener menos de 4,000 tokens (o aproximadamente 3,000 palabras en inglés). Para obtener más información, consulta la referencia de countTokens.
  • Se deben evitar los casos de uso que requieran un resultado largo (más de 4,000 tokens).
  • AICore aplica una cuota de inferencia por app. Para obtener más información, consulta Cuota por aplicación.

Problemas comunes de configuración

Las APIs de IA generativa de ML Kit dependen de la app de AICore de Android para acceder a Gemini Nano. Cuando un dispositivo se acaba de configurar (incluido el restablecimiento) o la app de AICore se acaba de restablecer (p.ej., se borraron los datos, se desinstaló y se reinstaló), es posible que la app de AICore no tenga suficiente tiempo para finalizar la inicialización (incluida la descarga de las configuraciones más recientes del servidor). Como resultado, es posible que las APIs de IA generativa de ML Kit no funcionen como se espera. Estos son los mensajes de error de configuración comunes que podrías ver y cómo solucionarlos:

Ejemplo de mensaje de error Cómo manejar esta situación
AICore falló con el tipo de error 4-CONNECTION_ERROR y el código de error 601-BINDING_FAILURE: No se pudo vincular el servicio de AICore. Esto puede suceder cuando instalas la app con las APIs de IA generativa de ML Kit inmediatamente después de configurar el dispositivo o cuando se desinstala AICore después de instalar la app. Actualizar la app de AICore y, luego, reinstalar tu app debería solucionar el problema.
AICore falló con el tipo de error 3-PREPARATION_ERROR y el código de error 606-FEATURE_NOT_FOUND: La función ... no está disponible. Esto puede suceder cuando AICore no terminó de descargar los parámetros de configuración más recientes. Cuando el dispositivo está conectado a Internet, suele tardar entre unos minutos y unas horas en actualizarse. Reiniciar el dispositivo puede acelerar la actualización.

Ten en cuenta que, si el bootloader del dispositivo está desbloqueado, también verás este error, ya que esta API no admite dispositivos con bootloaders desbloqueados.
AICore falló con el tipo de error 1-DOWNLOAD_ERROR y el código de error 0-UNKNOWN: La función ... falló con el estado de error 0 y el error esz: UNAVAILABLE: No se puede resolver el host ... Mantén la conexión de red, espera unos minutos y vuelve a intentarlo.