Vous pouvez demander à un modèle Gemini d'analyser les fichiers de documents (comme les fichiers PDF et en texte brut) que vous fournissez de manière intégrée (encodés en base64) ou via une URL. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette demande directement depuis votre application.
Cette fonctionnalité vous permet, entre autres, de :
- Analyser des diagrammes, des graphiques et des tableaux dans des documents
- Extraire des informations dans des formats de sortie structurés
- Répondre à des questions sur le contenu visuel et textuel des documents
- Résumer des documents
- Transcrire le contenu d'un document (par exemple, au format HTML), en conservant la mise en page et la mise en forme, pour l'utiliser dans des applications en aval (par exemple, dans des pipelines RAG)
Accéder aux exemples de code Accéder au code pour les réponses en flux continu
Consultez d'autres guides pour découvrir d'autres options permettant de travailler avec des documents (comme des PDF). Générer une sortie structurée Chat en plusieurs tours |
Avant de commencer
Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page. |
Si ce n'est pas déjà fait, suivez le guide de démarrage, qui décrit comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel
.
Pour tester et effectuer des itérations de vos requêtes, et même obtenir un extrait de code généré, nous vous recommandons d'utiliser Google AI Studio.
Générer du texte à partir de fichiers PDF (encodés en base64)
Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide
pour configurer votre projet et votre application. Dans cette section, vous devez également cliquer sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. |
Vous pouvez demander à un modèle Gemini de générer du texte en fournissant du texte et des PDF comme requêtes. Pour cela, vous devez fournir le mimeType
de chaque fichier d'entrée et le fichier lui-même. Vous trouverez les exigences et les recommandations concernant les fichiers d'entrée plus loin sur cette page.
Swift
Vous pouvez appeler generateContent()
pour générer du texte à partir d'une entrée multimodale de texte et de PDF.
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
Vous pouvez appeler generateContent()
pour générer du texte à partir d'une entrée multimodale de texte et de PDF.
// 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
Vous pouvez appeler generateContent()
pour générer du texte à partir d'une entrée multimodale de texte et de PDF.
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
Vous pouvez appeler generateContent()
pour générer du texte à partir d'une entrée multimodale de texte et de PDF.
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
Vous pouvez appeler generateContent()
pour générer du texte à partir d'entrées multimodales de texte et de PDF.
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
Vous pouvez appeler GenerateContentAsync()
pour générer du texte à partir d'une entrée multimodale de texte et de PDF.
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.");
Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.
Diffuser la réponse
Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide
pour configurer votre projet et votre application. Dans cette section, vous devez également cliquer sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. |
Vous pouvez obtenir des interactions plus rapides en n'attendant pas le résultat complet de la génération du modèle et en utilisant plutôt le streaming pour gérer les résultats partiels.
Pour diffuser la réponse, appelez generateContentStream
.
Exigences et recommandations concernant les documents d'entrée
Notez qu'un fichier fourni en tant que données intégrées est encodé en base64 lors du transfert, ce qui augmente la taille de la requête. Vous recevez une erreur HTTP 413 si une requête est trop volumineuse.
Consultez "Fichiers d'entrée et exigences concernant Vertex AI Gemini API" pour en savoir plus sur les éléments suivants :
- Différentes options pour fournir un fichier dans une requête (en ligne ou à l'aide de l'URL ou de l'URI du fichier)
- Exigences et bonnes pratiques concernant les fichiers de documents
Types MIME vidéo acceptés
Les modèles multimodaux Gemini sont compatibles avec les types MIME suivants associés aux documents :
Type MIME du document | Gemini 2.0 Flash | Gemini 2.0 Flash‑Lite |
---|---|---|
PDF - application/pdf |
||
Texte - text/plain |
Limites par requête
Les PDF sont traités comme des images. Ainsi, une page individuelle d'un PDF est traitée comme une image individuelle. Le nombre de pages autorisées dans une requête est limité au nombre d'images que le modèle peut accepter :
- Gemini 2.0 Flash et Gemini 2.0 Flash‑Lite :
- Nombre maximal de fichiers par requête : 3 000
- Nombre maximal de pages par fichier : 1 000
- Taille maximale par fichier : 50 Mo
Qu'est-ce que tu sais faire d'autre ?
- Découvrez comment compter les jetons avant d'envoyer de longues requêtes au modèle.
- Configurez Cloud Storage for Firebase pour pouvoir inclure des fichiers volumineux dans vos requêtes multimodales et bénéficier d'une solution plus gérée pour fournir des fichiers dans les requêtes. Les fichiers peuvent inclure des images, des PDF, des vidéos et des fichiers audio.
-
Commencez à réfléchir à la préparation de la production (consultez la checklist de production), y compris :
- Configurer Firebase App Check pour protéger Gemini API contre toute utilisation abusive par des clients non autorisés.
- Intégrer Firebase Remote Config pour mettre à jour les valeurs de votre application (comme le nom du modèle) sans publier de nouvelle version de l'application.
Essayer d'autres fonctionnalités
- Créez des conversations multitours (chat).
- Générez du texte à partir de requêtes textuelles uniquement.
- Générez des sorties structurées (comme JSON) à partir de requêtes textuelles et multimodales.
- Générer des images à partir de requêtes textuelles (Gemini ou Imagen).
- Utilisez l'appel de fonction pour connecter des modèles génératifs à des systèmes et des informations externes.
Découvrez comment contrôler la génération de contenu.
- Comprendre la conception des requêtes, y compris les bonnes pratiques, les stratégies et des exemples de requêtes.
- Configurez les paramètres du modèle, comme la température et le nombre maximal de jetons de sortie (pour Gemini), ou le format et la génération de personnes (pour Imagen).
- Utilisez les paramètres de sécurité pour ajuster la probabilité d'obtenir des réponses qui peuvent être considérées comme dangereuses.
En savoir plus sur les modèles compatibles
Découvrez les modèles disponibles pour différents cas d'utilisation, ainsi que leurs quotas et leurs tarifs.Envoyer des commentaires sur votre expérience avec Firebase AI Logic