Présentation de l’outil de recherche de fichiers de Google | Vers la science des données

(LLM) comme Gemini ont révolutionné ce qui est possible dans le développement de logiciels. Leur capacité à comprendre, générer et raisonner sur un texte est remarquable. Cependant, ils ont une limite fondamentale : ils ne savent que sur quoi ils ont été formés. Ils ne connaissent pas la documentation interne de votre entreprise, la base de code spécifique de votre projet ou le dernier document de recherche publié hier.

Pour créer des applications intelligentes et pratiques, nous devons combler cette lacune et ancrer les vastes capacités de raisonnement du modèle dans vos propres données privées spécifiques. C’est le domaine de la génération augmentée par récupération (RAG). Cette technique puissante récupère les informations pertinentes, généralement à partir d’une base de connaissances externe. Ensuite, il le fournit au LLM comme contexte pour générer une réponse plus précise, appropriée et vérifiable aux questions.

Bien que très efficace, la création d’un pipeline RAG robuste à partir de zéro constitue un défi d’ingénierie important. Cela implique une séquence complexe d’étapes :

• Ingestion et fragmentation de données. Analyser divers formats de fichiers (PDF, DOCX, etc.) et les diviser intelligemment en morceaux plus petits et sémantiquement significatifs.
• Génération d’intégration. Utiliser un modèle d’intégration pour convertir ces morceaux de texte en représentations vectorielles numériques.
• Stockage vectoriel. Configuration, gestion et mise à l’échelle d’une base de données vectorielles dédiée pour stocker ces intégrations pour une recherche efficace.
• Logique de récupération. Implémentation d’un système pour prendre la requête d’un utilisateur, l’intégrer et effectuer une recherche de similarité dans la base de données vectorielles pour trouver les morceaux les plus pertinents.
• Injection de contexte. Insérer dynamiquement les morceaux récupérés dans une invite pour le LLM de manière à ce qu’il puisse utiliser efficacement les informations. Chacune de ces étapes nécessite un examen attentif, une gestion de l’infrastructure et une maintenance continue.

Chacune de ces étapes nécessite un examen attentif, une gestion de l’infrastructure et une maintenance continue.

Récemment, poursuivant ses efforts pour mettre fin au RAG traditionnel tel que nous le connaissons, Google a racheté un autre nouveau produit ciblant cet espace. Le nouveau de Google Recherche de fichiers Cet outil vous évite complètement de devoir fragmenter, intégrer et vectoriser vos documents avant d’y effectuer des recherches sémantiques.

Qu’est-ce que l’outil de recherche de fichiers Google ?

À la base, l’outil de recherche de fichiers est une puissante couche d’abstraction sur un pipeline RAG complet. Il gère l’intégralité du cycle de vie de vos données, de l’ingestion à la récupération, offrant un moyen simple mais puissant d’ancrer les réponses de Gemini dans vos documents.

Décomposons ses composants principaux et les problèmes qu’ils résolvent.

1) Expérience de développement simple et intégrée

La recherche de fichiers n’est pas une API distincte ni un service externe complexe que vous devez orchestrer. Il est mis en œuvre comme un Outil directement au sein du Gemini existant API. Cette intégration transparente vous permet d’ajouter de puissantes fonctionnalités RAG à votre application avec seulement quelques lignes de code supplémentaires. L’outil automatiquement…

• Stocke en toute sécurité vos documents téléchargés.
• Applique des stratégies sophistiquées pour diviser vos documents en morceaux cohérents et de taille appropriée pour obtenir les meilleurs résultats de récupération.
• Traite vos fichiers, génère des intégrations à l’aide des modèles de pointe de Google et les indexe pour une récupération rapide.
• Gère la récupération et injecte le contexte pertinent dans l’invite envoyée à Gemini.

2) Recherche de vecteurs puissante à la base

Le moteur de récupération est alimenté par le gemini-intégration-001 modèle, conçu pour une recherche sémantique haute performance. Contrairement à la recherche par mot-clé traditionnelle, qui ne trouve que des correspondances exactes, la recherche vectorielle comprend les sens et contexte d’une requête. Cela lui permet de faire apparaître des informations pertinentes à partir de vos documents même si la requête de l’utilisateur utilise une formulation totalement différente.

3) Citations intégrées pour la vérifiabilité

La confiance et la transparence sont essentielles pour les applications d’IA d’entreprise. L’outil de recherche de fichiers inclut automatiquement les métadonnées de base dans la réponse du modèle. Ces métadonnées contiennent des citations qui précisent exactement quelles parties de quels documents sources ont été utilisées pour générer la réponse.

Il s’agit d’une fonctionnalité importante qui vous permet de : –

• Vérifiez l’exactitude. Vérifiez facilement les sources du modèle pour confirmer l’exactitude de sa réponse.
• Renforcez la confiance des utilisateurs. Montrez aux utilisateurs d’où proviennent les informations, augmentant ainsi leur confiance dans le système.
• Activez une exploration plus approfondie. Fournit des liens vers les documents sources, permettant aux utilisateurs d’explorer des sujets d’intérêt plus en profondeur.

4. Prise en charge d’une large gamme de formats.

Une base de connaissances est rarement composée de simples fichiers texte. L’outil de recherche de fichiers prend en charge un large éventail de formats de fichiers standard, notamment PDF, DOCX, TXT, JSON et divers langages de programmation et formats de fichiers d’application. Cette flexibilité signifie que vous pouvez créer une base de connaissances complète à partir de vos documents existants sans avoir à effectuer de lourdes étapes de prétraitement ou de conversion de données.

5. Abordabilité

Google a rendu l’utilisation de son outil de recherche de fichiers extrêmement rentable. Le stockage et l’intégration des requêtes sont gratuits. Vous ne payez que pour toute intégration du contenu initial de votre document, qui peut coûter seulement 0,15 $ pour 1 million de jetons (sur la base, par exemple, du modèle d’intégration gemini-embedding-001).

Utiliser la recherche de fichiers

Maintenant que nous avons une meilleure idée de ce qu’est l’outil de recherche de fichiers, il est temps de voir comment nous pouvons l’utiliser dans nos flux de travail. Pour cela, je présenterai un exemple de code Python qui vous montre comment appeler et utiliser la recherche de fichiers.

Cependant, avant cela, il est préférable de mettre en place un environnement de développement distinct afin de maintenir nos différents projets isolés les uns des autres.

J’utiliserai l’outil UV pour cela et j’exécuterai mon code dans un notebook Jupyter sous WSL2 Ubuntu pour Windows. Cependant, n’hésitez pas à utiliser le gestionnaire de packages qui vous convient le mieux.

$ cd projects
$ uv init gfs
$ cd gfs
$ uv venv
$ source gfs/bin/activate
(gfs) $ uv pip install google-genai jupyter

Vous aurez également besoin d’une clé API Gemini, que vous pouvez obtenir sur la page d’accueil d’AI Studio de Google en utilisant le lien ci-dessous.

Google IA Studio

Recherchez un lien Obtenir la clé API en bas à gauche de l’écran après vous être connecté.

Exemple de code — une simple recherche sur un document PDF

À des fins de test, j’ai téléchargé le manuel d’utilisation du téléphone mobile Samsung S25 depuis leur site Web sur mon ordinateur de bureau local. Il fait plus de 180 pages. Vous pouvez l’obtenir en utilisant ce lien.

Démarrez le notebook Jupyter et saisissez le code suivant dans une cellule.

import time
from google import genai
from google.genai import types

client = genai.Client(api_key='YOUR_API_KEY')
store = client.file_search_stores.create()

upload_op = client.file_search_stores.upload_to_file_search_store(
    file_search_store_name=store.name,
    file='SM-S93X_UG_EU_15_Eng_Rev.2.0_250514.pdf'
)

while not upload_op.done:
  time.sleep(5)
  upload_op = client.operations.get(upload_op)

# Use the file search store as a tool in your generation call
response = client.models.generate_content(
    model='gemini-2.5-flash',
    contents='What models of phone does this document apply to ...',
    config=types.GenerateContentConfig(
        tools=[types.Tool(
            file_search=types.FileSearch(
                file_search_store_names=[store.name]
            )
        )]
    )
)
print(response.text)

Après avoir importé les bibliothèques requises, nous créons un « magasin de recherche de fichiers », qui est un conteneur pour les données et les index de vos fichiers téléchargés. Ensuite, nous téléchargeons notre fichier d’entrée dans le magasin et attendons la fin du téléchargement.

Ensuite, nous appelons le générer_content fonction, qui répondra à la question que nous avons posée à notre modèle choisi (Gemini 2.5 flash dans notre exemple) sur notre fichier d’entrée, avant d’imprimer la réponse du modèle.

Voici la réponse que j’ai obtenue lors de l’exécution du code ci-dessus.

This document applies to the following phone models: 
SM-S931B, 
SM-S931B/DS, 
SM-S936B, 
SM-S936B/DS, 
SM-S937B, 
SM-S937B/DS, 
SM-S938B, and SM-S938B/DS. It also specifically mentions 
Galaxy S25 Ultra, Galaxy S25 Edge, Galaxy S25+, and Galaxy S25.

Nous pouvons vérifier l’exactitude de ces informations en examinant la première page du PDF, où est fournie la liste des modèles pertinents.

Creusons un peu plus et trouvons une question plus délicate. Supposons que vous souhaitiez savoir comment éteindre automatiquement votre écran lorsqu’il n’est pas utilisé. À la page 156 du PDF, il est dit ceci :

Vous pouvez configurer l’écran pour qu’il s’éteigne automatiquement lorsque vous ne l’utilisez pas. Ouvrez Paramètres, appuyez sur Affichage → Délai d’expiration de l’écran, puis sélectionnez la durée pendant laquelle vous souhaitez que l’appareil attende avant d’éteindre l’écran.

L’outil de recherche de fichiers peut-il l’identifier ?

...
...
...

# Use the file search store as a tool in your generation call
response = client.models.generate_content(
    model='gemini-2.5-flash',
    contents='How do I set the screen to turn off automatically when not in use',
    config=types.GenerateContentConfig(
        tools=[types.Tool(
            file_search=types.FileSearch(
                file_search_store_names=[store.name]
            )
        )]
    )
)
print(response.text)

Et la réponse ?

To set your device's screen to turn off automatically when not in use, 
you can adjust the "Screen timeout" setting. This setting determines how 
long the device waits before turning off the display's backlight.

For a Samsung device (as indicated by the provided user guide), you can 
typically find this option by navigating to:
Settings → Display → Screen timeout.

There, you can select the desired length of time before the screen turns off.

Sachez que File Search peut également utiliser la propre base de connaissances interne de son modèle pour répondre aux questions, sans nécessairement consulter le magasin de documents pour trouver une réponse.

Gérer plusieurs fichiers d’entrée

Si votre corpus de documents se compose de plusieurs fichiers, il est facile de tous les incorporer à l’aide d’une simple boucle for, mais vous devez être conscient de certaines des limitations de la recherche de fichiers. D’après la propre documentation de Google, ces limites sont :

L’API File Search présente les limites suivantes pour garantir la stabilité du service :
Taille maximale du fichier / limite par document : 100 Mo
Taille totale des magasins de recherche de fichiers du projet (en fonction du niveau utilisateur) :
Gratuit : 1 Go
Niveau 1 : 10 Go
Niveau 2 : 100 Go
Niveau 3 : 1 To

Contrôler le découpage

Lorsqu’un fichier est ajouté à un magasin de recherche de fichiers, le système le divise automatiquement en morceaux plus petits, intègre et indexe le contenu, puis le télécharge. Si vous souhaitez affiner la manière dont cette segmentation se produit, vous pouvez utiliser l’outil chunking_config option pour définir des limites sur la taille des morceaux et spécifier le nombre de jetons qui doivent se chevaucher entre les morceaux. Voici un extrait de code montrant comment procéder.

...
...

operation = client.file_search_stores.upload_to_file_search_store(
    file_search_store_name=file_search_store.name,
    file='SM-S93X_UG_EU_15_Eng_Rev.2.0_250514.pdf'
    config={
        'chunking_config': {
          'white_space_config': {
            'max_tokens_per_chunk': 200,
            'max_overlap_tokens': 20
          }
        }
    }
)
...
...

En quoi la recherche de fichiers diffère-t-elle des autres outils de Google liés à RAG, tels que Context Grounding et LangExtract ?

J’ai récemment écrit des articles sur deux produits similaires de Google dans cet espace : Context Grounding et LangExtract. En apparence, ils font des choses similaires. Et c’est vrai – jusqu’à un certain point.

La principale différence est que la recherche de fichiers est un réel Produit RAG dans la mesure où il stocke vos intégrations de documents de manière permanente, contrairement aux deux autres outils. Cela signifie qu’une fois que vos intégrations sont dans le magasin de recherche de fichiers, elles y restent pour toujours ou jusqu’à ce que vous choisissiez de les supprimer. Vous n’êtes pas obligé de télécharger à nouveau vos fichiers à chaque fois que vous souhaitez répondre à une question à leur sujet.

Voici un tableau pratique des différences pour référence.

+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Feature            | Google File Search                   | Google Context Grounding              | LangExtract                          |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Primary Goal       | To answer questions and generate     | Connects model responses to verified  | Extract specific, structured data    |
|                    | content from private documents.      | sources to improve accuracy and       | (like JSON) from unstructured text.  |
|                    |                                      | reduce hallucinations.                |                                      |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Input              | User prompt and uploaded files       | User prompt and configured data       | Unstructured text plus schema or     |
|                    | (PDFs, DOCX, etc.).                  | source (e.g., Google Search, URL).    | prompt describing what to extract.   |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Output             | Conversational answer grounded in    | Fact-checked natural language answer  | Structured data (e.g., JSON) mapping |
|                    | provided files with citations.       | with links or references.             | info to original text.               |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Underlying Process | Managed RAG system that chunks,      | Connects model to info source; uses   | LLM-based library for targeted info  |
|                    | embeds, and indexes files.           | File Search, Google Search, etc.      | extraction via examples.             |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+
| Typical Use Case   | Chatbot for company knowledge base   | Answering recent events using live    | Extracting names, meds, dosages from |
|                    | or manuals.                          | Google Search results.                | clinical notes for a database.       |
+--------------------+--------------------------------------+---------------------------------------+--------------------------------------+

Suppression d’un magasin de recherche de fichiers

Google supprime automatiquement le contenu brut de votre fichier de son magasin de fichiers après 48 heures, mais il conserve les intégrations de documents, vous permettant de continuer à interroger le contenu de votre document. Si vous décidez qu’ils ne sont plus nécessaires, vous pouvez les supprimer. Cela peut être fait par programme, comme indiqué dans l’extrait de code ci-dessous.

...
...
...
# deleting the stores
# List all your file search stores
for file_search_store in client.file_search_stores.list():
    name = file_search_store.name
    print(name)

# Get a specific file search store by name
my_file_search_store = client.file_search_stores.get(name='your_file_search_store_name')

# Delete a file search store
client.file_search_stores.delete(name=my_file_search_store.name, config={'force': True})

Résumé

Traditionnellement, la création d’un pipeline RAG nécessitait des étapes complexes : ingérer des données, les diviser en morceaux, générer des intégrations, configurer des bases de données vectorielles et injecter le contexte récupéré dans les invites. Le nouvel outil de recherche de fichiers de Google résume toutes ces tâches, offrant une solution RAG de bout en bout entièrement gérée et intégrée directement dans l’API Gemini via le générer du contenu appel.

Dans cet article, j’ai décrit certaines des fonctionnalités et avantages clés de la recherche de fichiers avant de fournir un exemple de code Python entièrement fonctionnel de son utilisation. Mon exemple démontrait le téléchargement d’un gros fichier PDF (un manuel de téléphone Samsung) dans un magasin de recherche de fichiers et son interrogation via le modèle Gemini et l’API pour extraire avec précision des informations spécifiques. J’ai également montré du code que vous pouvez utiliser pour micro-gérer la stratégie de segmentation de votre document si la valeur par défaut utilisée par File Search ne répond pas à vos besoins. Enfin, pour minimiser les coûts, j’ai également fourni un extrait de code montrant comment supprimer les magasins indésirables lorsque vous en avez terminé avec eux.

Alors que j’écrivais ceci, il m’est venu à l’esprit qu’à première vue, cet outil partage de nombreuses similitudes avec d’autres produits Google dans ce domaine dont j’ai déjà parlé, à savoir LangExtract et Context Grounding. Cependant, j’ai continué en expliquant qu’il y avait des différenciateurs clés dans chacun, la recherche de fichiers étant le seul véritable système RAG des trois, et j’ai souligné les différences dans un format de tableau facile à lire.

L’outil de recherche de fichiers de Google offre bien plus que ce que j’ai pu aborder dans cet article, notamment l’utilisation des métadonnées de fichiers et des citations. Je vous encourage à explorer la documentation de l’API de Google en ligne en utilisant le lien ci-dessous pour une description complète de toutes les fonctionnalités de File Search.

https://ai.google.dev/gemini-api/docs/file-search#file-search-stores