Il est possible qu'une partie ou l'ensemble des informations de cette page ne s'appliquent pas au Cloud de confiance S3NS. Pour en savoir plus, consultez Différences par rapport à Google Cloud.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Utiliser l'ingestion de données avec le moteur RAG

Cette page explique comment effectuer l'ingestion de données à l'aide d'une source de données compatible, telle que Cloud Storage, Google Drive, Slack, Jira ou SharePoint, et comment utiliser ces données avec le moteur RAG. La ragFiles.import ragFiles.import fournit des connecteurs de données à ces sources de données.

Sources de données compatibles avec le RAG

Les sources de données suivantes sont compatibles :

Importer un fichier local : importation d'un seul fichier à l'aide de upload_file (jusqu'à 25 Mo), qui est un appel synchrone.
Cloud Storage : importez un ou plusieurs fichiers depuis Cloud Storage.
Google Drive : importez un répertoire depuis Google Drive.

Le compte de service doit disposer des autorisations nécessaires pour importer des fichiers. Sinon, aucun fichier n'est importé et aucun message d'erreur ne s'affiche. Pour en savoir plus sur les limites de taille des fichiers, consultez Types de documents compatibles.

Pour vous authentifier et accorder des autorisations, procédez comme suit :
1. Accédez à la page IAM de votre Cloud de Confiance by S3NS projet.
2. Sélectionnez Inclure les attributions de rôles fournies par Google.
3. Recherchez le compte de service Agent de service de données RAG Agent Platform.
4. Cliquez sur Partager dans le dossier du Drive et partagez le contenu avec le compte de service.
5. Accordez l'autorisation Viewer au compte de service sur votre dossier ou fichier Google Drive. L'ID de ressource Google Drive se trouve dans l'URL Web.
Slack : importez des fichiers depuis Slack à l'aide d'un connecteur de données.
Jira: importez des fichiers depuis Jira à l'aide d'un connecteur de données.

Déduplication des données

Si le même fichier est importé plusieurs fois sans modification, il est ignoré, car il existe déjà. Par conséquent, response.skipped_rag_files_count fait référence au nombre de fichiers ignorés lors du processus d'importation.

Un fichier est ignoré lorsque les conditions suivantes sont remplies :

Le fichier a été importé.
Le fichier n'a pas changé.
La configuration de fragmentation du fichier n'a pas changé.

Comprendre les échecs d'importation

Pour comprendre les échecs d'importation, cette section explique les métadonnées d'une réponse à une requête d'importation et un récepteur de données, qui est la destination des données que vous importez.

Métadonnées de réponse

Vous pouvez utiliser response.metadata (un objet de réponse dans le SDK) pour afficher les résultats de l'importation, le temps de requête et le temps de réponse.

Récepteur de résultats d'importation

Dans le SDK, import_result_sink est un paramètre de fonction facultatif qui peut être défini sur une valeur de chaîne valide.

Si import_result_sink est fourni, les résultats des fichiers réussis et ayant échoué sont écrits dans le récepteur. Le fait d'écrire tous les résultats dans le récepteur permet de comprendre plus facilement pourquoi certains fichiers n'ont pas pu être importés et quels fichiers n'ont pas été importés.

import_result_sink doit être un chemin d'accès Cloud Storage ou une table BigQuery.

Si import_result_sink est un chemin d'accès Cloud Storage, il doit utiliser le format gs://my-bucket/my/object.ndjson, et l'objet ne doit pas exister. Une fois le job d'importation terminé, chaque ligne de l'objet Cloud Storage contient un objet JSON, qui comporte un ID d'opération, un horodatage de création, un nom de fichier, un état et un ID de fichier.
Si import_result_sink est une table BigQuery, il doit utiliser le format bq://my-project.my-dataset.my-table. La table n'a pas besoin d'exister. Si la table n'existe pas, elle est créée. Si la table existe, le schéma est vérifié. La première fois que le récepteur de résultats d'importation BigQuery est fourni, vous fournissez une table inexistante. Sinon, vous pouvez réutiliser la table existante.

Importer des fichiers depuis Cloud Storage ou Google Drive

Pour importer des fichiers depuis Cloud Storage ou Google Drive dans votre corpus, procédez comme suit :

Créez un corpus RAG. Pour en savoir plus, consultez Méthode : ragCorpora.create.
Pour importer vos fichiers depuis Cloud Storage ou Google Drive, utilisez la ragFiles.import.

Le système vérifie automatiquement le chemin d'accès, le nom de fichier et le version_id de votre fichier. Le version_id est un hachage de fichier calculé à l'aide du contenu du fichier, ce qui empêche le fichier d'être réindexé.

Si un fichier portant le même nom et le même chemin d'accès est mis à jour, il est réindexé.

Importer des fichiers depuis Slack

Pour importer des fichiers depuis Slack dans votre corpus, procédez comme suit :

Créez un corpus, qui est un index qui structure et optimise vos données pour la recherche. Pour en savoir plus, consultez Méthode : ragCorpora.create.
Obtenez votre CHANNEL_ID à partir de l'ID du canal Slack.
Créez et configurez une application à utiliser avec le moteur RAG.
1. Dans l'interface utilisateur de Slack, dans la section Ajouter des fonctionnalités, cliquez sur Autorisations.
2. Ajoutez les autorisations suivantes :
  - channels:history
  - groups:history
  - im:history
  - mpim:history
3. Cliquez sur Installer dans Workspace pour installer l'application dans votre espace de travail Slack.
Cliquez sur Copier pour obtenir votre jeton d'API, qui authentifie votre identité et vous donne accès à une API.
Ajoutez votre jeton d'API à votre Secret Manager.
Pour afficher le secret stocké, attribuez le rôle Accesseur de secrets du gestionnaire de secrets au compte de service du moteur RAG de votre projet.

Les exemples de code curl et Python suivants montrent comment importer des fichiers à partir de vos ressources Slack.

curl

Si vous souhaitez recevoir des messages d'un canal spécifique, modifiez CHANNEL_ID.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://ENDPOINT/v1beta1/projects/PROJECT_ID/locations/REGION/ragCorpora/RAG_CORPUS_ID/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "slack_source": {
      "channels": [
        {
          "apiKeyConfig": {
            "apiKeySecretVersion": "API_KEY_SECRET_VERSION"
          },
          "channels": [
            {
              "channel_id": "CHANNEL_ID"
            }
          ]
        }
      ]
    }
  }
}'

Python

Si vous souhaitez recevoir des messages pour une période donnée ou à partir d'un canal spécifique, modifiez l'un des champs suivants :

START_TIME
END_TIME
CHANNEL1 ou CHANNEL2

    # Slack example
    start_time = protobuf.timestamp_pb2.Timestamp()
    start_time.GetCurrentTime()
    end_time = protobuf.timestamp_pb2.Timestamp()
    end_time.GetCurrentTime()
    source = rag.SlackChannelsSource(
        channels = [
            SlackChannel("CHANNEL1", "api_key1"),
            SlackChannel("CHANNEL2", "api_key2", START_TIME, END_TIME)
        ],
    )

    response = rag.import_files(
        corpus_name=(
            "projects/PROJECT_ID/locations/"
            "REGION/ragCorpora/RAG_CORPUS_ID"
        ),
        source=source,
        chunk_size=512,
        chunk_overlap=100,
    )

Importer des fichiers depuis Jira

Pour importer des fichiers depuis Jira dans votre corpus, procédez comme suit :

Créez un corpus, qui est un index qui structure et optimise vos données pour la recherche. Pour en savoir plus, consultez Méthode : ragCorpora.create.
Pour créer un jeton d'API, connectez-vous au site Atlassian.
Utilisez {YOUR_ORG_ID}.atlassian.net comme SERVER_URI dans la requête.
Utilisez votre adresse e-mail Atlassian comme EMAIL dans la requête.
Fournissez projects ou customQueries avec votre requête. Pour en savoir plus sur les requêtes personnalisées, consultez Utiliser la recherche avancée avec le langage JQL (Jira Query Language).

Lorsque vous importez projects, projects est développé dans les requêtes correspondantes pour obtenir l'intégralité du projet. Par exemple, MyProject est développé en project = MyProject.
Cliquez sur Copier pour obtenir votre jeton d'API, qui authentifie votre identité et vous donne accès à une API.
Ajoutez votre jeton d'API à votre Secret Manager.
Accordez le rôle Accesseur de secrets du gestionnaire de secrets au compte de service du moteur RAG de votre projet.

curl

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://ENDPOINT/v1beta1/projects/PROJECT_ID/locations/REGION/ragCorpora/RAG_CORPUS_ID/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "jiraSource": {
      "jiraQueries": [{
        "projects": ["JIRA_PROJECT"],
        "customQueries": ["CUSTOM_QUERY"],
        "email": "EMAIL",
        "serverUri": "SERVER_URI",
        "apiKeyConfig": {
          "apiKeySecretVersion": "API_KEY_SECRET_VERSION"
        }
      }]
    }
  }
}'

Python

    # Jira Example
    jira_query = rag.JiraQuery(
        email="EMAIL",
        jira_projects=["JIRA_PROJECT"],
        custom_queries=["CUSTOM_QUERY"],
        api_key="API_KEY_SECRET_VERSION",
        server_uri="SERVER_URI"
    )
    source = rag.JiraSource(
        queries=[jira_query],
    )

    response = rag.import_files(
        corpus_name=(
            "projects/PROJECT_ID/locations/"
            "REGION/ragCorpora/RAG_CORPUS_ID"
        ),
        source=source,
        chunk_size=512,
        chunk_overlap=100,
    )

Importer des fichiers depuis SharePoint

Pour importer des fichiers depuis votre site SharePoint dans votre corpus, procédez comme suit :

Créez un corpus, qui est un index qui structure et optimise vos données pour la recherche. Pour en savoir plus, consultez Méthode : ragCorpora.create.
Créez une application Azure pour accéder à votre site SharePoint.
1. Pour créer un enregistrement, accédez à Inscriptions d'applications.
  1. Fournissez un nom pour l'application.
  2. Sélectionnez l'option Comptes dans cet annuaire organisationnel uniquement.
  3. Vérifiez que les URI de redirection sont vides.
2. Dans la section Vue d'ensemble , utilisez votre ID (client) de l'application comme CLIENT_ID et votre "ID (de locataire) de l'annuaire" comme TENANT_ID.
3. Dans la section Gérer, mettez à jour les autorisations de l'API en procédant comme suit :
  1. Ajoutez l'autorisation SharePoint Sites.Read.All.
  2. Ajoutez les autorisations Microsoft Graph Files.Read.All et Browser SiteLists.Read.All.
  3. Accordez le consentement de l'administrateur pour que ces modifications d'autorisation prennent effet.
4. Dans la section Gérer, procédez comme suit :
  1. Mettez à jour Certificats et codes secrets avec un nouveau code secret du client.
  2. Utilisez le API_KEY_SECRET_VERSION pour ajouter la valeur secrète au Secret Manager.
Accordez le rôle Accesseur de secrets du gestionnaire de secrets au compte de service du moteur RAG de votre projet.
Utilisez {YOUR_ORG_ID}.sharepoint.com comme le SHAREPOINT_SITE_NAME.
Un nom de lecteur ou un ID de lecteur dans le site SharePoint doit être spécifié dans la requête.
Facultatif : vous pouvez spécifier un chemin d'accès ou un ID de dossier sur le lecteur. Si le chemin d'accès ou l'ID de dossier n'est pas spécifié, tous les dossiers et fichiers du lecteur sont importés.

Localiser l'ID du site

Ouvrez votre navigateur et accédez à l'URL de votre site SharePoint cible.
Ajoutez /_api/site/id/ à la fin de cette URL.

Exemple : https://example-sp.sharepoint.com/sites/example-site/_api/site/id/

La page renvoie une charge utile XML. Notez la chaîne après Edm.Guid. Il s'agit de votre ID de site.

Localiser l'ID du lecteur

Avec l'ID de site que vous avez collecté, effectuez une requête GET authentifiée à l'aide de l'explorateur Microsoft Graph ou de votre client API :

GET https://graph.microsoft.com/v1.0/sites/SITE_ID/drive

Obtenez le SHAREPOINT_DRIVE_ID. La valeur est indiquée dans le champ id de la réponse JSON.

Localiser un ID de dossier spécifique

Utilisez votre ID de lecteur pour lister les enfants du répertoire racine :

GET https://graph.microsoft.com/v1.0/drives/SHAREPOINT_DRIVE_ID/root/children

Recherchez l'objet correspondant au nom de dossier sélectionné dans la réponse JSON et copiez la chaîne id correspondante. Il s'agit de votre SHAREPOINT_FOLDER_ID.

curl

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://ENDPOINT/v1beta1/projects/PROJECT_ID/locations/REGION/ragCorpora/RAG_CORPUS_ID/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "sharePointSources": {
      "sharePointSource": [{
        "clientId": "CLIENT_ID",
        "apiKeyConfig": {
          "apiKeySecretVersion": "API_KEY_SECRET_VERSION"
        },
        "tenantId": "SHAREPOINT_TENANT_ID",
        "sharepointSiteName": "SHAREPOINT_SITE_NAME",
        "sharepointFolderId": "SHAREPOINT_FOLDER_ID",
        "driveId": "SHAREPOINT_DRIVE_ID"
      }]
    }
  }
}'

Python

    from vertexai.preview import rag
    from vertexai.preview.rag.utils import resources
    import vertexai

    vertexai.init(
        project="PROJECT_ID",
        location="REGION",
    )

    # SharePoint Example.
    source = resources.SharePointSources(
        share_point_sources=[
            resources.SharePointSource(
                client_id="CLIENT_ID",
                client_secret="API_KEY_SECRET_VERSION",
                tenant_id="SHAREPOINT_TENANT_ID",
                sharepoint_site_name="SHAREPOINT_SITE_NAME",
                sharepoint_folder_id="SHAREPOINT_FOLDER_ID",
                drive_id="SHAREPOINT_DRIVE_ID",
            )
        ]
    )

    response = rag.import_files(
        corpus_name=(
            "projects/PROJECT_ID/locations/"
            "REGION/ragCorpora/RAG_CORPUS_ID"
        ),
        source=source,
        chunk_size=512,
        chunk_overlap=100,
    )

Étape suivante

Choix de bases de données vectorielles dans le moteur RAG sur Gemini Enterprise Agent Platform