Analyser des documents (comme des PDF) à l'aide de l'API Gemini

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.

Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine.

// 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.

Pour Java, les méthodes de ce SDK renvoient un 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 :

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 :

Essayer d'autres fonctionnalités

Découvrez comment contrôler la génération de contenu.

Vous pouvez également tester des requêtes et des configurations de modèle, et même obtenir un extrait de code généré à l'aide de Google AI Studio.

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