Créer une source de connaissances blob à partir d’Stockage Blob Azure ou d’ADLS Gen2

Une source de connaissances Blob ingère du contenu Stockage Blob Azure ou ADLS Gen2 dans un pipeline de récupération agentique dans Recherche Azure AI. Les sources de connaissances sont créées indépendamment, référencées dans une base de connaissances et utilisées comme données de base lorsque la base de connaissances est interrogée lors de l’exécution.

Lorsque vous créez une source de connaissances d’objet blob, vous spécifiez une source de données externe, des modèles et des propriétés pour générer automatiquement les objets Recherche Azure AI suivants :

• Source de données qui représente un conteneur d’objets blob.
• Ensemble de compétences qui segmente et vectorise éventuellement le contenu modal du conteneur.
• Index qui stocke du contenu enrichi et répond aux critères de récupération agentique.
• Indexeur qui utilise les objets précédents pour piloter l’indexation et le pipeline d’enrichissement.

L’indexeur généré est conforme à l’indexeur d’objets blob, dont les prérequis, les formats de documents pris en charge et les limitations s’appliquent également aux sources de connaissances blob. Pour plus d’informations, consultez la documentation de l’indexeur d’objets BLOB et les limites de l’indexeur. Si l’ensemble de compétences généré appelle un service externe, les limites d’entrée et de service de cette compétence s’appliquent également.

Support d'utilisation

Conditions préalables

• Un service Recherche Azure AI dans n’importe quelle région qui fournit une recherche agentique.

• Un compte Stockage Blob Azure ou Azure Data Lake Storage (ADLS) Gen2.

• Conteneur de blobs avec des types de contenu pris en charge pour le contenu textuel. Pour une verbalisation d’image facultative, le type de contenu pris en charge dépend de la capacité de votre modèle de complétion de chat à analyser et décrire le fichier image.

• Si contentExtractionMode correspond à standard, utilisez une ressource Microsoft Foundry dans une région prise en charge par Content Understanding dans Foundry Tools avec un point de terminaison https://<resource-name>.services.ai.azure.com. La ressource doit disposer d’un déploiement de modèle d’incorporation et, si vous activez la verbalisation d’image, d’un déploiement de modèle de conversation multimodal.

• Autorisation de créer des sources de connaissances. Configurez l’authentification sans clé avec les rôles Contributeur du service de recherche et Contributeur de données d’index de recherche affectés à votre compte d’utilisateur (recommandé) ou utilisez une clé API d’administration.

• Une identité managée pour le service de recherche, avec le rôle Lecteur des données blob du stockage dans l’étendue du compte de stockage source et le rôle Utilisateur de services cognitifs sur la ressource Microsoft Foundry. Si vous configurez un magasin d’artefacts dans un autre compte de stockage, attribuez également le rôle Contributeur de données blob de stockage au niveau de ce compte de stockage. Si les conteneurs source et d’éléments multimédias partagent un compte, Storage Blob Data Contributor accorde à la fois un accès en lecture à la source et un accès en lecture/écriture au stockage des éléments multimédias.

• Si vous définissez networkAccessMode sur private, remplissez les conditions suivantes :

  • Utilisez un service de recherche S2, S3, L1 ou L2.

  • Activez une identité managée attribuée par le système ou attribuée par l’utilisateur pour le service de recherche, accordez-lui le rôle Storage Blob Data Reader sur le compte de stockage et utilisez une chaîne de connexion ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>. Pour une identité attribuée par l’utilisateur, définissez également ingestionParameters.identity.

  • Créez et approuvez une liaison privée partagée vers le compte de stockage avec l’ID de groupe blob. Pour ADLS Gen2, créez et approuvez les deux liaisons privées partagées blob et dfs.

  • Créez et approuvez une liaison privée partagée pour chaque point de terminaison de modèle protégé. Utilisez l’ID de groupe openai_account pour les points de terminaison Azure OpenAI et foundry_account pour les points de terminaison de ressource Foundry.

Rechercher les sources de connaissances existantes

Une source de connaissances est un objet réutilisable de niveau supérieur. Connaître les sources de connaissances existantes est utile pour réutiliser ou nommer de nouveaux objets.

Exécutez le code suivant pour répertorier les sources de connaissances par nom et par type.

// List knowledge sources by name and type
using Azure.Search.Documents.Indexes;

var indexClient = new SearchIndexClient(new Uri(searchEndpoint), credential);
var knowledgeSources = indexClient.GetKnowledgeSourcesAsync();

Console.WriteLine("Knowledge Sources:");

await foreach (var ks in knowledgeSources)
{
    Console.WriteLine($"  Name: {ks.Name}, Type: {ks.GetType().Name}");
}

# List knowledge sources by name and type
from azure.core.credentials import AzureKeyCredential
from azure.search.documents.indexes import SearchIndexClient

index_client = SearchIndexClient(endpoint = "search_url", credential = AzureKeyCredential("api_key"))

for ks in index_client.list_knowledge_sources():
    print(f"  - {ks.name} ({ks.kind})")

### List knowledge sources by name and type
GET {{search-url}}/knowledgesources?api-version={{api-version}}&$select=name,kind
Authorization: Bearer {{token}}

Vous pouvez également retourner une source de connaissances unique par nom pour passer en revue sa définition JSON.

using Azure.Search.Documents.Indexes;
using System.Text.Json;

var indexClient = new SearchIndexClient(new Uri(searchEndpoint), credential);

// Specify the knowledge source name to retrieve
string ksNameToGet = "earth-knowledge-source";

// Get its definition
var knowledgeSourceResponse = await indexClient.GetKnowledgeSourceAsync(ksNameToGet);
var ks = knowledgeSourceResponse.Value;

// Serialize to JSON for display
var jsonOptions = new JsonSerializerOptions 
{ 
    WriteIndented = true,
    DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.Never
};
Console.WriteLine(JsonSerializer.Serialize(ks, ks.GetType(), jsonOptions));

# Get a knowledge source definition
from azure.core.credentials import AzureKeyCredential
from azure.search.documents.indexes import SearchIndexClient
import json

index_client = SearchIndexClient(endpoint = "search_url", credential = AzureKeyCredential("api_key"))

ks = index_client.get_knowledge_source("knowledge_source_name")
print(json.dumps(ks.as_dict(), indent = 2))

### Get a knowledge source definition
GET {{search-url}}/knowledgesources/{{knowledge-source-name}}?api-version={{api-version}}
Authorization: Bearer {{token}}

Le JSON suivant est un exemple de réponse pour une source de connaissances blob.

{
  "name": "my-blob-ks",
  "kind": "azureBlob",
  "description": "A sample blob knowledge source.",
  "encryptionKey": null,
  "azureBlobParameters": {
    "connectionString": "<REDACTED>",
    "containerName": "blobcontainer",
    "folderPath": null,
    "isADLSGen2": false,
    "ingestionParameters": {
      "disableImageVerbalization": false,
      "ingestionPermissionOptions": [],
      "contentExtractionMode": "standard",
      "identity": null,
      "embeddingModel": {
        "kind": "azureOpenAI",
        "azureOpenAIParameters": {
          "resourceUri": "<REDACTED>",
          "deploymentId": "text-embedding-3-large",
          "modelName": "text-embedding-3-large",
          "authIdentity": null
        }
      },
      "chatCompletionModel": {
        "kind": "azureOpenAI",
        "azureOpenAIParameters": {
          "resourceUri": "<aoai-endpoint>",
          "deploymentId": "gpt-5-mini",
          "modelName": "gpt-5-mini",
          "authIdentity": null
        }
      },
      "ingestionSchedule": null,
      "assetStore": null,
      "aiServices": {
        "uri": "<aoai-endpoint>",
      }
    },
    "createdResources": {
      "datasource": "my-blob-ks-datasource",
      "indexer": "my-blob-ks-indexer",
      "skillset": "my-blob-ks-skillset",
      "index": "my-blob-ks-index"
    }
  }
}

Créer une source de connaissances

Exécutez le code suivant pour créer une source d'informations blob.

// Create a blob knowledge source
using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;
using Azure.Search.Documents.KnowledgeBases.Models;
using Azure.Search.Documents.Models;
using Azure.Identity;

var indexClient = new SearchIndexClient(new Uri(searchEndpoint), new DefaultAzureCredential());

var chatCompletionParams = new AzureOpenAIVectorizerParameters
{
    ResourceUri = new Uri(aoaiEndpoint),
    DeploymentName = aoaiGptDeployment,
    ModelName = aoaiGptModel
};

var embeddingParams = new AzureOpenAIVectorizerParameters
{
    ResourceUri = new Uri(aoaiEndpoint),
    DeploymentName = aoaiEmbeddingDeployment,
    ModelName = aoaiEmbeddingModel
};

var ingestionParams = new KnowledgeSourceIngestionParameters
{
    NetworkAccessMode = KnowledgeSourceNetworkAccessMode.Public,
    DisableImageVerbalization = false,
    ChatCompletionModel = new KnowledgeBaseAzureOpenAIModel(azureOpenAIParameters: chatCompletionParams),
    EmbeddingModel = new KnowledgeSourceAzureOpenAIVectorizer
    {
        AzureOpenAIParameters = embeddingParams
    },
    IngestionPermissionOptions = new List<KnowledgeSourceIngestionPermissionOption>
    {
        KnowledgeSourceIngestionPermissionOption.UserIds,
        KnowledgeSourceIngestionPermissionOption.GroupIds
    }
};

var blobParams = new AzureBlobKnowledgeSourceParameters(
    connectionString: connectionString,
    containerName: containerName
)
{
    IsAdlsGen2 = false,
    IngestionParameters = ingestionParams
};

var knowledgeSource = new AzureBlobKnowledgeSource(
    name: "my-blob-ks",
    azureBlobParameters: blobParams
)
{
    Description = "This knowledge source pulls from a blob storage container."
};

await indexClient.CreateOrUpdateKnowledgeSourceAsync(knowledgeSource);
Console.WriteLine($"Knowledge source '{knowledgeSource.Name}' created or updated successfully.");

// Create a blob knowledge source
using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;
using Azure.Search.Documents.KnowledgeBases.Models;
using Azure.Identity;

var indexClient = new SearchIndexClient(new Uri(searchEndpoint), new DefaultAzureCredential());

var chatCompletionParams = new AzureOpenAIVectorizerParameters
{
    ResourceUri = new Uri(aoaiEndpoint),
    DeploymentName = aoaiGptDeployment,
    ModelName = aoaiGptModel
};

var embeddingParams = new AzureOpenAIVectorizerParameters
{
    ResourceUri = new Uri(aoaiEndpoint),
    DeploymentName = aoaiEmbeddingDeployment,
    ModelName = aoaiEmbeddingModel
};

var ingestionParams = new KnowledgeSourceIngestionParameters
{
    DisableImageVerbalization = false,
    ChatCompletionModel = new KnowledgeBaseAzureOpenAIModel(azureOpenAIParameters: chatCompletionParams),
    EmbeddingModel = new KnowledgeSourceAzureOpenAIVectorizer
    {
        AzureOpenAIParameters = embeddingParams
    }
};

var blobParams = new AzureBlobKnowledgeSourceParameters(
    connectionString: connectionString,
    containerName: containerName
)
{
    IsADLSGen2 = false,
    IngestionParameters = ingestionParams
};

var knowledgeSource = new AzureBlobKnowledgeSource(
    name: "my-blob-ks",
    azureBlobParameters: blobParams
)
{
    Description = "This knowledge source pulls from a blob storage container."
};

await indexClient.CreateOrUpdateKnowledgeSourceAsync(knowledgeSource);
Console.WriteLine($"Knowledge source '{knowledgeSource.Name}' created or updated successfully.");

# Create a blob knowledge source
from azure.identity import DefaultAzureCredential
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import AzureBlobKnowledgeSource, AzureBlobKnowledgeSourceParameters, KnowledgeBaseAzureOpenAIModel, AzureOpenAIVectorizerParameters, KnowledgeSourceAzureOpenAIVectorizer, KnowledgeSourceContentExtractionMode, KnowledgeSourceIngestionParameters
from azure.search.documents.knowledgebases.models import KnowledgeSourceNetworkAccessMode

index_client = SearchIndexClient(endpoint = "<search-endpoint>", credential = DefaultAzureCredential())

knowledge_source = AzureBlobKnowledgeSource(
    name = "my-blob-ks",
    description = "This knowledge source pulls from a blob storage container.",
    encryption_key = None,
    azure_blob_parameters = AzureBlobKnowledgeSourceParameters(
        connection_string = "blob_connection_string",
        container_name = "blob_container_name",
        folder_path = None,
        is_adls_gen2 = False,
        ingestion_parameters = KnowledgeSourceIngestionParameters(
            network_access_mode = KnowledgeSourceNetworkAccessMode.PUBLIC,
            identity = None,
            disable_image_verbalization = False,
            chat_completion_model = KnowledgeBaseAzureOpenAIModel(
                azure_open_ai_parameters = AzureOpenAIVectorizerParameters(
                    resource_url = "<aoai-endpoint>",
                    deployment_name = "<aoai-gpt-deployment>",
                    model_name = "<aoai-gpt-model>",
                )
            ),
            embedding_model = KnowledgeSourceAzureOpenAIVectorizer(
                azure_open_ai_parameters=AzureOpenAIVectorizerParameters(
                    resource_url = "<aoai-endpoint>",
                    deployment_name = "<aoai-embedding-deployment>",
                    model_name = "<aoai-embedding-model>",
                )
            ),
            content_extraction_mode = KnowledgeSourceContentExtractionMode.MINIMAL,
            ingestion_schedule = None,
            ingestion_permission_options = ["user_ids", "group_ids"]
        )
    )
)

index_client.create_or_update_knowledge_source(knowledge_source)
print(f"Knowledge source '{knowledge_source.name}' created or updated successfully.")

# Create a blob knowledge source
from azure.identity import DefaultAzureCredential
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import AzureBlobKnowledgeSource, AzureBlobKnowledgeSourceParameters, KnowledgeBaseAzureOpenAIModel, AzureOpenAIVectorizerParameters, KnowledgeSourceContentExtractionMode
from azure.search.documents.knowledgebases.models import KnowledgeSourceIngestionParameters, KnowledgeSourceAzureOpenAIVectorizer

index_client = SearchIndexClient(endpoint = "<search-endpoint>", credential = DefaultAzureCredential())

knowledge_source = AzureBlobKnowledgeSource(
    name = "my-blob-ks",
    description = "This knowledge source pulls from a blob storage container.",
    encryption_key = None,
    azure_blob_parameters = AzureBlobKnowledgeSourceParameters(
        connection_string = "blob_connection_string",
        container_name = "blob_container_name",
        folder_path = None,
        is_adls_gen2 = False,
        ingestion_parameters = KnowledgeSourceIngestionParameters(
            identity = None,
            disable_image_verbalization = False,
            chat_completion_model = KnowledgeBaseAzureOpenAIModel(
                azure_open_ai_parameters = AzureOpenAIVectorizerParameters(
                    resource_url = "<aoai-endpoint>",
                    deployment_name = "<aoai-gpt-deployment>",
                    model_name = "<aoai-gpt-model>",
                )
            ),
            embedding_model = KnowledgeSourceAzureOpenAIVectorizer(
                azure_open_ai_parameters=AzureOpenAIVectorizerParameters(
                    resource_url = "<aoai-endpoint>",
                    deployment_name = "<aoai-embedding-deployment>",
                    model_name = "<aoai-embedding-model>",
                )
            ),
            content_extraction_mode = KnowledgeSourceContentExtractionMode.MINIMAL,
            ingestion_schedule = None
        )
    )
)

index_client.create_or_update_knowledge_source(knowledge_source)
print(f"Knowledge source '{knowledge_source.name}' created or updated successfully.")

### Create a blob knowledge source
PUT {{search-endpoint}}/knowledgesources/my-blob-ks?api-version=2026-08-01-preview
Authorization: Bearer {{search-access-token}}
Content-Type: application/json

{
  "name": "my-blob-ks",
  "kind": "azureBlob",
  "description": "This knowledge source pulls from a blob storage container.",
  "encryptionKey": null,
  "azureBlobParameters": {
  "connectionString": "ResourceId=<storage-resource-id>",
    "containerName": "<blob-container-name>",
    "folderPath": null,
    "isADLSGen2": false,
    "ingestionParameters": {
        "networkAccessMode": "public",
        "identity": null,
        "disableImageVerbalization": null,
        "chatCompletionModel": {
            "kind": "azureOpenAI",
            "azureOpenAIParameters": {
                "resourceUri": "{{aoai-endpoint}}",
                "deploymentId": "{{aoai-gpt-deployment}}",
                "modelName": "{{aoai-gpt-model}}"
            }
        },
        "embeddingModel": {
            "kind": "azureOpenAI",
            "azureOpenAIParameters": {
                "resourceUri": "{{aoai-endpoint}}",
                "deploymentId": "{{aoai-embedding-deployment}}",
                "modelName": "{{aoai-embedding-model}}"
            }
        },
        "contentExtractionMode": "minimal",
        "ingestionSchedule": null,
        "ingestionPermissionOptions": ["userIds", "groupIds"]
    }
  }
}

### Create a blob knowledge source
PUT {{search-endpoint}}/knowledgesources/my-blob-ks?api-version=2026-04-01
Authorization: Bearer {{search-access-token}}
Content-Type: application/json

{
  "name": "my-blob-ks",
  "kind": "azureBlob",
  "description": "This knowledge source pulls from a blob storage container.",
  "encryptionKey": null,
  "azureBlobParameters": {
  "connectionString": "ResourceId=<storage-resource-id>",
    "containerName": "<blob-container-name>",
    "folderPath": null,
    "isADLSGen2": false,
    "ingestionParameters": {
        "identity": null,
        "disableImageVerbalization": null,
        "chatCompletionModel": {
            "kind": "azureOpenAI",
            "azureOpenAIParameters": {
                "resourceUri": "{{aoai-endpoint}}",
                "deploymentId": "{{aoai-gpt-deployment}}",
                "modelName": "{{aoai-gpt-model}}"
            }
        },
        "embeddingModel": {
            "kind": "azureOpenAI",
            "azureOpenAIParameters": {
                "resourceUri": "{{aoai-endpoint}}",
                "deploymentId": "{{aoai-embedding-deployment}}",
                "modelName": "{{aoai-embedding-model}}"
            }
        },
        "contentExtractionMode": "minimal",
        "ingestionSchedule": null
    }
  }
}

Restreindre l’ingestion à un réseau privé (version préliminaire)

À compter de la version de l’API 2026-08-01-preview , networkAccessMode contrôle l’environnement réseau dans lequel l’indexeur généré pour une source de connaissances d’objet blob s’exécute. Ce paramètre affecte uniquement l’ingestion et ne modifie pas la base de connaissances pour récupérer les demandes ou les réponses.

networkAccessMode est défini par défaut sur public, ce qui préserve le comportement existant du réseau public. Lorsque networkAccessMode est private, l’indexeur généré s’exécute dans l’environnement d’exécution privé. Il utilise des liens privés partagés approuvés pour accéder à la connexion source Stockage Blob Azure ou ADLS Gen2 et aux dépendances Azure prises en charge, telles que les modèles OpenAI Azure et les ressources Foundry Microsoft.

Pour configurer et vérifier l’accès au réseau privé :

1. Remplissez les conditions préalables au réseau privé.

2. Définissez networkAccessMode sur private dans la demande de création de la source de connaissances. Vous ne pouvez définir cette propriété que lors de la création. Pour la modifier ultérieurement, supprimez et recréez la source de connaissances.

   La création peut échouer si le niveau de service ou le runtime ne prend pas en charge l’exécution privée ou si une liaison privée partagée requise n’existe pas.

3. Vérifiez que l’indexeur executionEnvironment généré est private.

4. Vérifiez que chaque liaison privée partagée requise est approuvée et cible la dépendance correcte. La création réussie ne confirme pas l’approbation ou le ciblage du lien.

5. Interrogez régulièrement l’état de la source de connaissances jusqu’à ce que lastSynchronizationState.endTime ait une valeur. Confirmez que itemsUpdatesFailed est 0, puis vérifiez le contenu source spécifique au connecteur. La synchronisation échoue si une dépendance n’est pas accessible.

Utiliser des analyseurs automatiques pour chaque langue (préversion)

À compter de la version de l’API2026-08-01-preview, les analyseurs automatiques par langage sont disponibles pour les objets blob, OneLake indexés et les sources de connaissances SharePoint indexées. Lorsqu'elle est activée, Recherche Azure AI détecte la langue de chaque document source et applique automatiquement un analyseur de langage Microsoft correspondant. Vous ne spécifiez pas d’analyseur dans la définition de la source de connaissances ou dans une requête.

Pour activer les analyseurs automatiques par langage, définissez et configurez contentExtractionModeminimalingestionParameters.aiServices dans la définition de la source de connaissances.

Pour l’authentification sans clé, omettez aiServices.apiKey et affectez le rôle d’utilisateur Cognitive Services sur votre ressource Microsoft Foundry à l’identité managée de votre service de recherche. Pour l’authentification basée sur des clés, définissez aiServices.apiKey sur une clé valide pour votre ressource Foundry.

Les langues suivantes sont prises en charge :

• Anglais
• Japonais
• Français
• espagnol
• Allemand
• Néerlandais
• Italian
• Portugais brésilien
• Portugais européen
• Chinois simplifié
• Chinois traditionnel
• Coréen

Pour le contenu multilingue, Recherche Azure AI sélectionne un analyseur en fonction de la langue détectée prédominante. Il utilise l’analyseur standard lorsque la langue n’est pas prise en charge ou n’est pas connue avec certitude.

Lorsque vous activez des analyseurs automatiques par langue, Recherche Azure AI ajoute des champs de contenu spécifiques à la langue pour chaque langue prise en charge au schéma d’index généré, que vos données contiennent ou non des documents dans ces langues. Pendant l’ingestion, les documents sont routés vers le champ propre à la langue appropriée en fonction de leur langue détectée.

Les champs de langue inutilisés ne contiennent pas de contenu indexé et ont un impact minimal sur le stockage, mais ils restent dans le schéma d’index et comptent vers la limite de champ d’index. Tenez compte des champs supplémentaires lorsque vous planifiez la conception de votre index, le nombre de champs et les exigences de stockage. Pour plus d’informations, consultez Les limitesd’index et Estimer et gérer la capacité d’un service de recherche.

La détection de langue est facturable après l’allocation gratuite d’enrichissement par IA. Pour plus d’informations, consultez Enrichissements gratuits.

Vérifier l’état d’ingestion

Exécutez le code suivant pour surveiller la progression et l’intégrité de l’ingestion, notamment le type de source de connaissances et les erreurs d’indexation détaillées pour les sources de connaissances qui génèrent un pipeline d’indexeur et remplissent un index de recherche.

using Azure.Search.Documents.Indexes;
using System.Text.Json;

var indexClient = new SearchIndexClient(new Uri(searchEndpoint), new AzureKeyCredential(apiKey));

// Get knowledge source ingestion status
var statusResponse = await indexClient.GetKnowledgeSourceStatusAsync(knowledgeSourceName);
var status = statusResponse.Value;

// Serialize to JSON for display
var json = JsonSerializer.Serialize(status, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

# Check knowledge source ingestion status
from azure.core.credentials import AzureKeyCredential
from azure.search.documents.indexes import SearchIndexClient
import json

index_client = SearchIndexClient(endpoint="search_url", credential=AzureKeyCredential("api_key"))

status = index_client.get_knowledge_source_status("knowledge_source_name")
print(json.dumps(status.as_dict(), indent=2))

### Check knowledge source ingestion status
GET {{search-url}}/knowledgesources/{{knowledge-source-name}}/status?api-version={{api-version}}
Authorization: Bearer {{token}}
Content-Type: application/json 

Une réponse pour une demande qui inclut des paramètres d’ingestion et qui ingère activement du contenu peut ressembler à l’exemple suivant.

{
  "kind": "azureBlob",
  "synchronizationStatus": "active",
  "synchronizationInterval": "1d",
  "currentSynchronizationState": {
    "startTime": "2026-04-10T19:30:00Z",
    "itemUpdatesProcessed": 1100,
    "itemsUpdatesFailed": 100,
    "itemsSkipped": 1100,
    "errors": [
      {
        "key": "Item id 1",
        "docURL": "https://contoso.blob.core.windows.net/contracts/2024/Q4/doc-00023.csv",
        "statusCode": 400,
        "componentName": "DocumentExtraction.AzureBlob.MyDataSource",
        "errorMessage": "Could not read the value of column 'foo' at index '0'.",
        "details": "The file could not be parsed.",
        "documentationLink": "https://go.microsoft.com/fwlink/?linkid=2049388"
      }
    ]
  },
  "lastSynchronizationState": {
    "status": "partialSuccess",
    "startTime": "2026-04-09T19:30:00Z",
    "endTime": "2026-04-09T19:40:01Z",
    "itemUpdatesProcessed": 1100,
    "itemsUpdatesFailed": 100,
    "itemsSkipped": 1100,
    "errors": null
  },
  "statistics": {
    "totalSynchronizations": 25,
    "averageSynchronizationDuration": "00:15:20",
    "averageItemsProcessedPerSynchronization": 500
  }
}

Passer en revue les objets générés

Lorsque vous créez cette source de connaissances, Recherche Azure AI génère automatiquement une source de données, un ensemble de compétences, un indexeur et un index. La réponse de création répertorie chaque objet sous createdResources.

Ces objets sont générés en fonction d’un modèle fixe, et leurs noms sont basés sur le nom de la source de connaissances. Vous ne pouvez pas modifier les noms d’objets. Évitez de modifier ces objets directement, car les modifications peuvent introduire des erreurs ou des incompatibilités qui interrompent le pipeline d’indexeur.

Vous pouvez utiliser le portail Azure pour valider la création d’objets. Le flux de travail est le suivant :

1. Vérifiez les messages de réussite ou d’échec de l'indexeur. Les erreurs de connexion ou de quota s’affichent ici.

2. Vérifiez la source de données pour vérifier la connexion à votre magasin de données. La connexion utilise une chaîne de connexion ou une identité managée, selon la façon dont vous avez configuré la source de connaissances.

3. Vérifiez l’ensemble de compétences pour voir comment votre contenu est segmenté et éventuellement vectorisé.

4. Vérifiez l’index pour voir comment votre contenu est indexé et exposé pour la récupération, y compris les champs pouvant faire l’objet d’une recherche et filtrables et quels champs stockent des vecteurs pour la recherche de similarité. Utilisez l’Explorateur de recherche pour exécuter des requêtes sur l’index généré.

Attribuer à une base de connaissances

Si vous êtes satisfait de la source de connaissances, ajoutez-la à une base de connaissances.

Interroger une base de connaissances

Après avoir configuré la base de connaissances, appelez l’action de récupération ou le point de terminaison MCP pour interroger la source de connaissances. Choisissez la configuration qui correspond à votre scénario.

Appliquer des autorisations au niveau du document (Aperçu)

Pour appliquer des autorisations au niveau du document, définissez ingestionPermissionOptions lorsque vous créez cette source de connaissances, puis incluez le jeton d’accès de l’utilisateur dans la demande de récupération. Pour plus d’informations, consultez Appliquer les autorisations au moment de la requête (préversion).

Afficher les images intégrées aux documents (version préliminaire)

Pour afficher des images intégrées aux documents (telles que des diagrammes ou des documents numérisés) dans les réponses générées par la synthèse de réponses, configurez assetStore sur cette source de connaissances, puis activez la diffusion d’images sur la base de connaissances. La diffusion d’images n’est pas prise en charge lorsque ingestionPermissionOptions est configuré. Pour plus d’informations, consultez Afficher les images intégrées au document dans la récupération agentique (préversion).

Supprimer une source de connaissances

Avant de pouvoir supprimer une source de connaissances, vous devez supprimer toute base de connaissances qui la référence ou mettre à jour la définition de la base de connaissances pour supprimer la référence. Pour les sources de connaissances qui génèrent un pipeline d’index et d’indexeur, tous les objets générés sont également supprimés . Toutefois, si vous avez utilisé un index existant pour créer une source de connaissances, votre index n’est pas supprimé.

Si vous essayez de supprimer une source de connaissances en cours d’utilisation, l’action échoue et retourne une liste de bases de connaissances affectées.

Pour supprimer une source de connaissances :

Contenu connexe

• Recherche agentique dans Recherche Azure AI
• Qu’est-ce qu’une source de connaissances ?
• Créer une base de connaissances
• Interroger une base de connaissances
• Exemple Python : source de connaissances Blob Recherche Azure AI