Puedes pedirle a un modelo de Gemini que analice archivos de documentos (como archivos PDF y de texto sin formato) que proporciones de forma intercalada (codificados en base64) o a través de una URL. Cuando usas Firebase AI Logic, puedes realizar esta solicitud directamente desde tu app.
Con esta capacidad, puedes hacer lo siguiente:
- Analizar diagramas, gráficos y tablas dentro de documentos
- Extrae información en formatos de salida estructurados
- Responde preguntas sobre el contenido visual y de texto en documentos
- Resume documentos
- Transcribir el contenido de documentos (por ejemplo, a HTML), conservando los diseños y el formato, para usar en aplicaciones posteriores (como en las canalizaciones de RAG)
Ir a muestras de código Ir al código de respuestas transmitidas
Consulta otras guías para obtener más opciones para trabajar con documentos (como PDFs) Generar resultados estructurados Chat de varias turnos |
Antes de comenzar
Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página. |
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 de backend para el proveedor de Gemini API que elijas y crear una instancia de GenerativeModel
.
Para probar y, luego, iterar tus instrucciones, e incluso obtener un fragmento de código generado, te recomendamos usar Google AI Studio.
Genera texto a partir de archivos PDF (codificados en Base64)
Antes de probar esta muestra, completa la sección
Antes de comenzar de esta guía
para configurar tu proyecto y tu app. En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página. |
Puedes pedirle a un modelo Gemini que genere texto proporcionándole instrucciones con texto y archivos PDF, y proporcionando el mimeType
de cada archivo de entrada y el archivo en sí. Más adelante en esta página, encontrarás los requisitos y las recomendaciones para los archivos de entrada.
Swift
Puedes llamar a generateContent()
para generar texto a partir de entradas multimodales de texto y PDFs.
import FirebaseAI
// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")
// Provide the PDF as `Data` with the appropriate MIME type
let pdf = try InlineDataPart(data: Data(contentsOf: pdfURL), mimeType: "application/pdf")
// Provide a text prompt to include with the PDF file
let prompt = "Summarize the important results in this report."
// To generate text output, call `generateContent` with the PDF file and text prompt
let response = try await model.generateContent(pdf, prompt)
// Print the generated text, handling the case where it might be nil
print(response.text ?? "No text in response.")
Kotlin
Puedes llamar a generateContent()
para generar texto a partir de entradas multimodales de texto y PDFs.
// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel("gemini-2.5-flash")
val contentResolver = applicationContext.contentResolver
// Provide the URI for the PDF file you want to send to the model
val inputStream = contentResolver.openInputStream(pdfUri)
if (inputStream != null) { // Check if the PDF file loaded successfully
inputStream.use { stream ->
// Provide a prompt that includes the PDF file specified above and text
val prompt = content {
inlineData(
bytes = stream.readBytes(),
mimeType = "application/pdf" // Specify the appropriate PDF file MIME type
)
text("Summarize the important results in this report.")
}
// To generate text output, call `generateContent` with the prompt
val response = generativeModel.generateContent(prompt)
// Log the generated text, handling the case where it might be null
Log.d(TAG, response.text ?: "")
}
} else {
Log.e(TAG, "Error getting input stream for file.")
// Handle the error appropriately
}
Java
Puedes llamar a generateContent()
para generar texto a partir de entradas multimodales de texto y PDFs.
ListenableFuture
.
// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel("gemini-2.5-flash");
// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
ContentResolver resolver = getApplicationContext().getContentResolver();
// Provide the URI for the PDF file you want to send to the model
try (InputStream stream = resolver.openInputStream(pdfUri)) {
if (stream != null) {
byte[] audioBytes = stream.readAllBytes();
stream.close();
// Provide a prompt that includes the PDF file specified above and text
Content prompt = new Content.Builder()
.addInlineData(audioBytes, "application/pdf") // Specify the appropriate PDF file MIME type
.addText("Summarize the important results in this report.")
.build();
// To generate text output, call `generateContent` with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String text = result.getText();
Log.d(TAG, (text == null) ? "" : text);
}
@Override
public void onFailure(Throwable t) {
Log.e(TAG, "Failed to generate a response", t);
}
}, executor);
} else {
Log.e(TAG, "Error getting input stream for file.");
// Handle the error appropriately
}
} catch (IOException e) {
Log.e(TAG, "Failed to read the pdf file", e);
} catch (URISyntaxException e) {
Log.e(TAG, "Invalid pdf file", e);
}
Web
Puedes llamar a generateContent()
para generar texto a partir de entradas multimodales de texto y PDFs.
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";
// 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 Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });
// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
const base64EncodedDataPromise = new Promise((resolve) => {
const reader = new FileReader();
reader.onloadend = () => resolve(reader.result.split(','));
reader.readAsDataURL(file);
});
return {
inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
};
}
async function run() {
// Provide a text prompt to include with the PDF file
const prompt = "Summarize the important results in this report.";
// Prepare PDF file for input
const fileInputEl = document.querySelector("input[type=file]");
const pdfPart = await fileToGenerativePart(fileInputEl.files);
// To generate text output, call `generateContent` with the text and PDF file
const result = await model.generateContent([prompt, pdfPart]);
// Log the generated text, handling the case where it might be undefined
console.log(result.response.text() ?? "No text in response.");
}
run();
Dart
Puedes llamar a generateContent()
para generar texto a partir de entradas multimodales de texto y PDFs.
import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
// Initialize FirebaseApp
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');
// Provide a text prompt to include with the PDF file
final prompt = TextPart("Summarize the important results in this report.");
// Prepare the PDF file for input
final doc = await File('document0.pdf').readAsBytes();
// Provide the PDF file as `Data` with the appropriate PDF file MIME type
final docPart = InlineDataPart('application/pdf', doc);
// To generate text output, call `generateContent` with the text and PDF file
final response = await model.generateContent([
Content.multi([prompt,docPart])
]);
// Print the generated text
print(response.text);
Unity
Puedes llamar a GenerateContentAsync()
para generar texto a partir de entradas multimodales de texto y PDFs.
using Firebase;
using Firebase.AI;
// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");
// Provide a text prompt to include with the PDF file
var prompt = ModelContent.Text("Summarize the important results in this report.");
// Provide the PDF file as `data` with the appropriate PDF file MIME type
var doc = ModelContent.InlineData("application/pdf",
System.IO.File.ReadAllBytes(System.IO.Path.Combine(
UnityEngine.Application.streamingAssetsPath, "document0.pdf")));
// To generate text output, call `GenerateContentAsync` with the text and PDF file
var response = await model.GenerateContentAsync(new [] { prompt, doc });
// Print the generated text
UnityEngine.Debug.Log(response.Text ?? "No text in response.");
Aprende a elegir un modelo adecuados para tu caso de uso y tu app.
Transmite la respuesta
Antes de probar esta muestra, completa la sección
Antes de comenzar de esta guía
para configurar tu proyecto y tu app. En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página. |
Puedes lograr interacciones más rápidas sin esperar el resultado completo de la generación del modelo y, en cambio, usar la transmisión para controlar los resultados parciales.
Para transmitir la respuesta, llama a generateContentStream
.
Requisitos y recomendaciones para los documentos de entrada
Ten en cuenta que un archivo proporcionado como datos intercalados se codifica en base64 durante la transmisión, lo que aumenta el tamaño de la solicitud. Recibirás un error HTTP 413 si una solicitud es demasiado grande.
Consulta "Archivos de entrada y requisitos compatibles para Vertex AI Gemini API" para obtener información detallada sobre lo siguiente:
- Diferentes opciones para proporcionar un archivo en una solicitud (ya sea de forma intercalada o con la URL o el URI del archivo)
- Requisitos y prácticas recomendadas para los archivos de documentos
Tipos de MIME de video admitidos
Los modelos multimodales de Gemini admiten los siguientes tipos de MIME de documento:
Tipo de documento MIME | Gemini 2.0 Flash | Gemini 2.0 Flash‑Lite |
---|---|---|
PDF - application/pdf |
||
Texto - text/plain |
Límites por solicitud
Los PDFs se tratan como imágenes, por lo que una sola página de un PDF se considera una sola imagen. La cantidad de páginas permitidas en una instrucción se limita a la cantidad de imágenes que el modelo puede admitir:
- Gemini 2.0 Flash y Gemini 2.0 Flash‑Lite:
- Cantidad máxima de archivos por solicitud: 3,000
- Cantidad máxima de páginas por archivo: 1,000
- Tamaño máximo por archivo: 50 MB
¿Qué más puedes hacer?
- Aprende a contar tokens antes de enviar instrucciones largas al modelo.
- Configura Cloud Storage for Firebase para poder incluir archivos grandes en tus solicitudes multimodales y tener una solución más administrada para proporcionar archivos en las instrucciones. Los archivos pueden incluir imágenes, PDFs, videos y audio.
-
Comienza a pensar en la preparación para la producción (consulta la lista de tareas de producción), que incluye lo siguiente:
- Configura Firebase App Check para proteger Gemini API contra el abuso de clientes no autorizados.
- Integra Firebase Remote Config para actualizar valores en tu app (como el nombre del modelo) sin lanzar una nueva versión de la app.
Prueba otras capacidades
- Crea conversaciones de varios turnos (chat).
- Generar texto a partir de instrucciones solo de texto
- Genera resultados estructurados (como JSON) a partir de instrucciones tanto de texto como multimodales.
- Generar imágenes a partir de instrucciones de texto (Gemini o Imagen)
- Usa la llamada a función para conectar modelos generativos a sistemas e información externos.
Más información para 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).
- Usar la configuración de seguridad para ajustar la probabilidad de obtener respuestas que se puedan considerar dañinas
Más información sobre los modelos compatibles
Obtén información sobre los modelos disponibles para diversos casos de uso, sus cuotas y sus precios.Envía comentarios sobre tu experiencia con Firebase AI Logic