Możesz poprosić model Gemini o przeanalizowanie plików dokumentów (np. PDF i plików tekstowych) podanych w treści (zakodowanych w formacie base64) lub za pomocą adresu URL. Gdy używasz Firebase AI Logic, możesz wysłać to żądanie bezpośrednio z aplikacji.
Dzięki tej funkcji możesz m.in.:
- analizować diagramy, wykresy i tabele w dokumentach;
- Wyodrębnianie informacji do uporządkowanych formatów wyjściowych
- odpowiadać na pytania dotyczące treści wizualnych i tekstowych w dokumentach;
- streszczać dokumenty,
- Transkrypcja zawartości dokumentu (np. do formatu HTML) z zachowaniem układu i formatowania do wykorzystania w aplikacjach podrzędnych (np. w potokach RAG).
Przejdź do przykładowych fragmentów kodu Przejdź do kodu dla odpowiedzi przesyłanych strumieniowo
Więcej opcji pracy z dokumentami (np. PDF-ami) znajdziesz w innych przewodnikach Generowanie danych wyjściowych w formacie strukturalnym Czat wieloetapowy |
Zanim zaczniesz
Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy. |
Jeśli jeszcze tego nie zrobisz, zapoznaj się z przewodnikiem dla początkujących, w którym znajdziesz informacje o tym, jak skonfigurować projekt Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel
.
Do testowania i ulepszania promptów, a nawet uzyskiwania wygenerowanego fragmentu kodu zalecamy używanie Google AI Studio.
Generowanie tekstu z plików PDF (zakodowanych w standardzie base64)
Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy. |
Możesz poprosić model Gemini o wygenerowanie tekstu, podając mu tekst i pliki PDF – w przypadku każdego pliku wejściowego podaj mimeType
i sam plik. Wymagania i rekomendacje dotyczące plików wejściowych znajdziesz w dalszej części tej strony.
Swift
Możesz wywołać funkcję generateContent()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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
Możesz wywołać funkcję generateContent()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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
Możesz wywołać funkcję generateContent()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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
Możesz wywołać funkcję generateContent()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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
Możesz wywołać funkcję generateContent()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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
Możesz wywołać funkcję GenerateContentAsync()
, aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i plików 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.");
Dowiedz się, jak wybrać model odpowiednie do Twojego przypadku użycia i aplikacji.
Wyświetlanie odpowiedzi stopniowo
Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy. |
Możesz uzyskać szybsze interakcje, nie czekając na pełny wynik generowania modelu, i zamiast tego używać przesyłania strumieniowego do obsługi częściowych wyników.
Aby przesyłać strumieniowo odpowiedź, wywołaj funkcję generateContentStream
.
Wymagania i zalecenia dotyczące dokumentów wejściowych
Pamiętaj, że plik podany jako dane wbudowane jest kodowany do formatu base64 podczas przesyłania, co zwiększa rozmiar żądania. Jeśli żądanie jest zbyt duże, otrzymasz błąd HTTP 413.
Więcej informacji o tych kwestiach znajdziesz w artykule „Obsługiwane pliki wejściowe i wymagania dotyczące Vertex AI Gemini API”:
- Różne opcje przesyłania pliku w żądaniu (wbudowanego lub za pomocą adresu URL lub URI pliku)
- Wymagania i sprawdzone metody dotyczące plików dokumentów
Obsługiwane typy MIME filmów
Gemini Modele multimodalne obsługują te typy MIME dokumentów:
Typ MIME dokumentu | Gemini 2.0 Flash | Gemini 2.0 Flash‑Lite |
---|---|---|
PDF – application/pdf |
||
Tekst – text/plain |
Limity na żądanie
Pliki PDF są traktowane jako obrazy, więc jedna strona pliku PDF jest traktowana jako 1 obraz. Liczba stron dozwolonych w prompcie jest ograniczona do liczby obrazów, które może obsługiwać model:
- Gemini 2.0 Flash i Gemini 2.0 Flash‑Lite:
- Maksymalna liczba plików w żądaniu: 3000
- Maksymalna liczba stron w pliku: 1000
- Maksymalny rozmiar pliku: 50 MB
Co jeszcze możesz zrobić?
- Dowiedz się, jak liczyć tokeny przed wysłaniem do modelu długich promptów.
- Skonfiguruj Cloud Storage for Firebase, aby móc uwzględniać duże pliki w żądaniach multimodalnych i korzystać z bardziej zarządzanego rozwiązania do udostępniania plików w promptach. Mogą to być obrazy, pliki PDF, wideo i audio.
-
Zacznij myśleć o przygotowaniu do udostępnienia wersji produkcyjnej (patrz lista kontrolna produkcji), w tym:
- Skonfiguruj Firebase App Check, aby chronić Gemini API przed nadużyciami ze strony nieautoryzowanych klientów.
- Integrowanie Firebase Remote Config w celu aktualizowania wartości w aplikacji (np. nazwy modelu) bez publikowania nowej wersji aplikacji.
Wypróbuj inne funkcje
- Twórz rozmowy wieloetapowe (czat).
- generować tekst na podstawie promptów tekstowych,
- Generowanie danych wyjściowych o strukturze (np. JSON) na podstawie promptów tekstowych i multimodalnych.
- Generuj obrazy na podstawie promptów tekstowych (Gemini lub Imagen).
- Używaj wywoływania funkcji, aby łączyć modele generatywne z systemami zewnętrznymi i informacjami.
Dowiedz się, jak kontrolować generowanie treści
- Poznaj projektowanie promptów, w tym sprawdzone metody, strategie i przykładowe prompty.
- Skonfiguruj parametry modelu, takie jak temperatura i maksymalna liczba tokenów wyjściowych (w przypadku Gemini) lub format obrazu i generowanie osób (w przypadku Imagen).
- Użyj ustawień bezpieczeństwa, aby dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą być uznane za szkodliwe.
Więcej informacji o obsługiwanych modelach
Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia, ich limitach i cenach.Prześlij opinię o korzystaniu z usługi Firebase AI Logic