Een blobkennisbron maken op basis van Azure Blob Storage of ADLS Gen2

Een blob-kennisbron voert inhoud uit Azure Blob Storage of ADLS Gen2 in een agentische ophaalpipeline in Azure AI Zoeken in. Kennisbronnen worden onafhankelijk gemaakt, waarnaar wordt verwezen in een knowledge base en worden gebruikt als grondgegevens wanneer de knowledge base tijdens runtime wordt opgevraagd.

Wanneer u een blob-kennisbron maakt, geeft u een externe gegevensbron, modellen en eigenschappen op om automatisch de volgende Azure AI Zoeken-objecten te genereren:

• Een gegevensbron die een blobcontainer vertegenwoordigt.
• Een vaardighedenset die segmenteert en eventueel multimodale inhoud uit de container vectoriseert.
• Een index waarin verrijkte inhoud wordt opgeslagen en voldoet aan de criteria voor agentisch ophalen.
• Een indexeerfunctie die gebruikmaakt van de vorige objecten om de indexerings- en verrijkingspijplijn aan te sturen.

De gegenereerde indexeerfunctie voldoet aan de blob-indexeerfunctie, waarvan de vereisten, ondersteunde documentindelingen en beperkingen ook van toepassing zijn op blob-kennisbronnen. Zie de documentatie over de blob-indexeerfunctie en de limieten van de indexeerfunctie voor meer informatie. Als de gegenereerde vaardighedenset een externe service aanroept, zijn ook de invoer- en servicelimieten van die vaardigheid van toepassing.

Gebruiksondersteuning

Voorwaarden

• Een Azure AI Zoeken-service in elke regio die op agent gebaseerde gegevensophaling biedt.

• Een Azure Blob Storage- of Azure Data Lake Storage (ADLS) Gen2-account.

• Een blobcontainer met ondersteunde inhoudstypen voor tekstinhoud. Voor optionele afbeeldingenverbalisatie is het ondersteunde inhoudstype afhankelijk van het vermogen van uw chatvoltooiingsmodel om het afbeeldingsbestand te analyseren en in woorden te beschrijven.

• Als contentExtractionModestandard is, gebruik dan een Microsoft Foundry-resource in een regio die door Content Understanding in Foundry Tools wordt ondersteund met een https://<resource-name>.services.ai.azure.com-eindpunt. De resource moet een insluitmodelimplementatie hebben en, als u verbalisatie van afbeeldingen inschakelt, moet er een multimodale chatmodelimplementatie worden geïmplementeerd.

• Machtiging voor het maken van kennisbronnen. Configureer sleutelloze verificatie met de rollen Inzender voor zoekservice en Inzender voor zoekindexgegevens die zijn toegewezen aan uw gebruikersaccount (aanbevolen) of gebruik een beheerders-API-sleutel.

• Een beheerde identiteit voor de zoekservice met Storage Blob Data Reader op het scopeniveau van het bronopslagaccount en Cognitive Services User voor de Microsoft Foundry-resource. Als u een assetstore in een ander opslagaccount configureert, wijs dan ook Storage Blob Data Contributor toe op het bereik van dat opslagaccount. Als de bron- en assetcontainers zich in hetzelfde account bevinden, biedt Storage Blob Data Contributor zowel leestoegang tot de bron als lees-/schrijftoegang tot de assetopslag.

• Als u networkAccessMode instelt op private, moet u aan de volgende vereisten voldoen:

  • Gebruik een S2-, S3-, L1- of L2-zoekservice.

  • Schakel een door het systeem toegewezen of door de gebruiker toegewezen beheerde identiteit voor de zoekservice in, wijs deze de rol Lezer van opslagblobgegevens toe voor het opslagaccount en gebruik een verbindingsreeks van het type ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>. Stel ook een door de gebruiker toegewezen identiteit in ingestionParameters.identity.

  • Maak en keur een gedeelde privélink naar het opslagaccount met de groeps-id blob goed. Voor ADLS Gen2 maakt en keurt u beide blob en dfs gedeelde privékoppelingen goed.

  • Maak en keur een gedeelde privékoppeling voor elk beveiligd modeleindpunt goed. Gebruik de openai_account groeps-id voor Azure OpenAI-eindpunten en foundry_account voor Foundry-resource-eindpunten.

Controleren op bestaande kennisbronnen

Een kennisbron is een herbruikbaar object op het hoogste niveau. Kennis over bestaande kennisbronnen is handig voor het opnieuw gebruiken of benoemen van nieuwe objecten.

Voer de volgende code uit om kennisbronnen op naam en type weer te geven.

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

U kunt ook één kennisbron op naam retourneren om de JSON-definitie ervan te controleren.

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}}

De volgende JSON is een voorbeeldantwoord voor een blob-kennisbron.

{
  "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"
    }
  }
}

Een kennisbron maken

Voer de volgende code uit om een blobkennisbron te maken.

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

Gegevensopname beperken tot een privénetwerk (preview)

Vanaf de 2026-08-01-preview API-versie bepaalt networkAccessMode u de netwerkomgeving waarin de gegenereerde indexeerfunctie voor een blob-kennisbron wordt uitgevoerd. Deze instelling heeft alleen invloed op de gegevensinname en wijzigt geen ophaalverzoeken of -reacties van de kennisbank.

networkAccessMode is standaard ingesteld op public, waarmee het bestaande gedrag van het openbare netwerk behouden blijft. Wanneer networkAccessModeprivate is, wordt de gegenereerde indexeerfunctie uitgevoerd in de privé-uitvoeringsomgeving. Er worden goedgekeurde gedeelde privékoppelingen gebruikt voor toegang tot de Azure Blob Storage- of ADLS Gen2-bronverbinding en ondersteunde Azure afhankelijkheden, zoals Azure OpenAI-modellen en Microsoft Foundry-resources.

Toegang tot privénetwerk configureren en verifiëren:

1. Voltooi de vereisten voor het privénetwerk.

2. Stel networkAccessMode in op private in het aanmaakverzoek voor de kennisbron. U kunt deze eigenschap alleen instellen tijdens het maken. Als u deze later wilt wijzigen, verwijdert u de kennisbron en maakt u deze opnieuw.

   Het maken kan mislukken als de servicelaag of runtime geen ondersteuning biedt voor privé-uitvoering of als er geen vereiste gedeelde privékoppeling bestaat.

3. Controleer of de executionEnvironment van de gegenereerde indexer private.

4. Controleer of elke vereiste gedeelde privékoppeling is goedgekeurd en is gericht op de juiste afhankelijkheid. Het succesvol aanmaken van de koppeling bevestigt op zichzelf niet dat de koppeling is goedgekeurd of getarget.

5. Controleer de status van de kennisbron totdat lastSynchronizationState.endTime een waarde heeft. Bevestig dat itemsUpdatesFailed0 is en controleer vervolgens de connectorspecifieke broninhoud. Synchronisatie mislukt als een afhankelijkheid niet bereikbaar is.

Automatische analyse per taal gebruiken (preview)

Vanaf de 2026-08-01-preview API-versie zijn automatische analysefuncties per taal beschikbaar voor blob, geïndexeerde OneLake en geïndexeerde SharePoint kennisbronnen. Indien ingeschakeld, detecteert Azure AI Zoeken de taal van elk brondocument en past automatisch een overeenkomende Microsoft taalanalyse toe. U geeft geen analyse op in de definitie van de kennisbron of in een query.

Als u automatische analyzers per taal wilt inschakelen, stelt u contentExtractionMode in op minimal en configureert u ingestionParameters.aiServices in de definitie van de kennisbron.

Voor sleutelloze verificatie laat u weg en wijst u de rol aiServices.apiKey op uw Microsoft Foundry-resource toe aan de beheerde identiteit van uw zoekservice. Stel voor verificatie aiServices.apiKey op basis van sleutels een geldige sleutel in voor uw Foundry-resource.

De volgende talen worden ondersteund:

• Engels
• De Japanse taal
• Frans
• Spanish
• Duits
• Dutch
• Italian
• Braziliaans Portugees
• Europees Portugees
• Vereenvoudigd Chinees
• Traditioneel Chinees
• Korean

Voor meertalige inhoud selecteert Azure AI Zoeken een analyse op basis van de overheersende gedetecteerde taal. De standaardanalyse wordt gebruikt wanneer de taal niet wordt ondersteund of onzeker is.

Wanneer u automatische analyse per taal inschakelt, voegt Azure AI Zoeken taalspecifieke inhoudsvelden voor elke ondersteunde taal toe aan het gegenereerde indexschema, ongeacht of uw gegevens documenten in die talen bevatten. Tijdens de opname worden documenten doorgestuurd naar het juiste taalspecifieke veld op basis van hun gedetecteerde taal.

Ongebruikte taalvelden bevatten geen geïndexeerde inhoud en hebben minimale opslagimpact, maar blijven deel uitmaken van het indexschema en tellen mee voor de limiet van het indexveld. Houd rekening met de aanvullende velden wanneer u uw indexontwerp, veldaantal en opslagvereisten plant. Zie Indexlimieten en De capaciteit van een zoekservice schatten en beheren voor meer informatie.

Taaldetectie is factureerbaar na de gratis toewijzing voor AI-verrijking. Zie Gratis verrijkingen voor meer informatie.

Opnamestatus controleren

Voer de volgende code uit om de voortgang en status van de opname te controleren, inclusief de soort kennisbron en gedetailleerde indexeringsfouten voor kennisbronnen die een indexeerpijplijn genereren en een zoekindex vullen.

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 

Een antwoord voor een aanvraag die opnameparameters bevat en inhoud actief opneemt, kan eruitzien als in het volgende voorbeeld.

{
  "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
  }
}

De gegenereerde objecten controleren

Wanneer u deze kennisbron maakt, genereert Azure AI Zoeken automatisch een gegevensbron, vaardighedenset, indexeerfunctie en index. Het aanmaakantwoord vermeldt elk object onder createdResources.

Deze objecten worden gegenereerd volgens een vaste sjabloon en hun namen zijn gebaseerd op de naam van de kennisbron. U kunt de objectnamen niet wijzigen. Vermijd het rechtstreeks bewerken van deze objecten, omdat wijzigingen fouten of incompatibiliteit kunnen veroorzaken die de indexeerpijplijn verbreken.

U kunt de Azure-portal gebruiken om het maken van objecten te valideren. De werkstroom is:

1. Controleer de indexeerfunctie op geslaagde of mislukte berichten. Hier worden verbindings- of quotumfouten weergegeven.

2. Controleer de gegevensbron om de verbinding met uw gegevensarchief te controleren. De verbinding maakt gebruik van een verbindingsreeks of een beheerde identiteit, afhankelijk van hoe u de kennisbron hebt geconfigureerd.

3. Controleer de skillset om te bekijken hoe uw inhoud wordt opgedeeld en optioneel gevectoriseerd.

4. Controleer de index om te zien hoe uw inhoud wordt geïndexeerd en weergegeven voor het ophalen, inclusief welke velden doorzoekbaar en filterbaar zijn en welke velden vectoren opslaan voor overeenkomsten zoeken. Gebruik Search Explorer om query's uit te voeren op de gegenereerde index.

Toewijzen aan de kennisbank

Als u tevreden bent met de kennisbron, voegt u deze toe aan een knowledge base.

Een query uitvoeren op een Knowledge Base

Nadat u de knowledge base hebt geconfigureerd, roept u de actie ophalen of het MCP-eindpunt aan om een query uit te voeren op de kennisbron. Kies de configuratie die overeenkomt met uw scenario.

Machtigingen op documentniveau afdwingen (preview)

Als u machtigingen op documentniveau wilt afdwingen, stelt ingestionPermissionOptions u in wanneer u deze kennisbron maakt en neemt u vervolgens het toegangstoken van de gebruiker op in de ophaalaanvraag. Zie Machtigingen afdwingen op het moment van query (preview) voor meer informatie.

Afbeeldingen die in documenten zijn ingesloten weergeven (voorvertoning)

Als u in documenten opgenomen afbeeldingen (zoals diagrammen of scans) wilt weergeven in reacties met gesynthetiseerde antwoorden, configureert u assetStore voor deze kennisbron en schakelt u vervolgens het aanbieden van afbeeldingen in op de kennisbank. Het aanbieden van afbeeldingen wordt niet ondersteund wanneer ingestionPermissionOptions is geconfigureerd. Zie In documenten ingesloten afbeeldingen beschikbaar maken in agentische retrieval (preview) voor meer informatie.

Een kennisbron verwijderen

Voordat u een kennisbron kunt verwijderen, moet u een knowledge base verwijderen die ernaar verwijst of de knowledge base-definitie bijwerken om de verwijzing te verwijderen. Voor kennisbronnen die een index- en indexeerpijplijn genereren, worden ook alle gegenereerde objecten verwijderd. Als u echter een bestaande index hebt gebruikt om een kennisbron te maken, wordt uw index niet verwijderd.

Als u probeert een kennisbron te verwijderen die in gebruik is, mislukt de actie en wordt een lijst met betrokken knowledge bases geretourneerd.

Een kennisbron verwijderen:

Verwante inhoud

• Agentisch ophalen in Azure AI Zoeken
• Wat is een kennisbron?
• Een kennisdatabase maken
• Een query uitvoeren op een knowledge base
• Python voorbeeld: Azure AI Zoeken blob-kennisbron