Erstellen einer Blob-Wissensquelle aus Azure Blob Storage oder ADLS Gen2

Eine blob-Wissensquelle nimmt Azure Blob Storage oder ADLS Gen2-Inhalte in eine agentische Abrufpipeline in Azure KI-Suche ein. Wissensquellen werden unabhängig erstellt, in einer Wissensbasis referenziert und als Erdungsdaten verwendet, wenn die Wissensbasis zur Laufzeit abgefragt wird.

Wenn Sie eine Blob-Wissensquelle erstellen, geben Sie eine externe Datenquelle, Modelle und Eigenschaften an, um automatisch die folgenden Azure KI-Suche Objekte zu generieren:

• Eine Datenquelle, die einen Blob-Container repräsentiert.
• Ein Skillset, das multimodale Inhalte aus dem Container in Blöcke unterteilt und optional vektorisiert.
• Ein Index, der angereicherte Inhalte speichert und die Kriterien für den agentischen Abruf erfüllt.
• Ein Indexer, der die vorherigen Objekte verwendet, um die Indizierungs- und Anreicherungspipeline zu steuern.

Der generierte Indexer entspricht dem BLOB-Indexer, dessen Voraussetzungen, unterstützte Dokumentformate und Einschränkungen auch für Blob-Wissensquellen gelten. Weitere Informationen finden Sie in der Blobindexerdokumentation und in den Indexergrenzwerten. Wenn das generierte Skillset einen externen Dienst aufruft, gelten auch die Eingabe- und Dienstgrenzwerte dieser Qualifikation.

Verwendungsunterstützung

Voraussetzungen

• Einen Azure KI-Suche Dienst in einer beliebigen Region, der agentischen Abruf bereitstellt.

• Ein Azure Blob Storage- oder Azure Data Lake Storage (ADLS) Gen2Konto.

• Ein Blobcontainer mit unterstützten Inhaltstypen für Textinhalte. Bei optionaler Bildverbalisierung hängt der unterstützte Inhaltstyp davon ab, ob Ihr Chat-Vervollständigungsmodell die Bilddatei analysieren und beschreiben kann.

• Wenn contentExtractionModestandard ist, verwenden Sie eine Microsoft Foundry-Ressource in einer von Content Understanding in Foundry Tools unterstützten Region mit einem https://<resource-name>.services.ai.azure.com-Endpunkt. Die Ressource muss über eine Bereitstellung für ein Einbettungsmodell und, wenn Sie die Bildverbalisierung aktivieren, über eine Bereitstellung für ein multimodales Chatmodell verfügen.

• Berechtigung zum Erstellen von Wissensquellen. Konfigurieren Sie die schlüssellose Authentifizierung mit den Rollen "Mitwirkender des Suchdiensts " und " Indexdatenmitwirkender ", die Ihrem Benutzerkonto zugewiesen sind (empfohlen), oder verwenden Sie einen Administrator-API-Schlüssel.

• Eine verwaltete Identität für den Suchdienst mit Storage Blob Data Reader im Quellspeicherkontobereich und dem Cognitive Services-Benutzer auf der Microsoft Foundry-Ressource. Wenn Sie einen Ressourcenspeicher in einem anderen Speicherkonto konfigurieren, weisen Sie auch Storage Blob Data Contributor im Bereich dieses Speicherkontos zu. Wenn der Quellcontainer und der Assetcontainer dasselbe Konto verwenden, gewährt Storage Blob Data Contributor sowohl Lesezugriff auf die Quelle als auch Lese-/Schreibzugriff auf den Assetspeicher.

• Wenn Sie private auf networkAccessMode festlegen, müssen Sie die folgenden Anforderungen erfüllen:

  • Verwenden Sie einen S2-, S3-, L1- oder L2-Suchdienst.

  • Aktivieren Sie eine vom System zugewiesene oder vom Benutzer zugewiesene verwaltete Identität für den Suchdienst, gewähren Sie ihm die Rolle "Storage Blob Data Reader" für das Speicherkonto, und verwenden Sie eine ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> Verbindungszeichenfolge. Setzen Sie für eine benutzerzugewiesene Identität auch ingestionParameters.identity.

  • Erstellen und genehmigen Sie eine freigegebene private Verbindung zum Speicherkonto mit der blob-Gruppen-ID. Erstellen und genehmigen Sie für ADLS Gen2 blob und dfs freigegebene private Verbindungen.

  • Erstellen und genehmigen Sie für jeden geschützten Modell-Endpunkt einen gemeinsam genutzten privaten Link. Verwenden Sie die openai_account Gruppen-ID für Azure OpenAI-Endpunkte und foundry_account für Foundry-Ressourcenendpunkte.

Überprüfen auf vorhandene Wissensquellen

Eine Wissensquelle ist ein wiederverwendbares Objekt auf oberster Ebene. Das Wissen über vorhandene Wissensquellen ist hilfreich, um neue Objekte wiederzuverwenden oder zu benennen.

Führen Sie den folgenden Code aus, um Wissensquellen nach Namen und Typ auflisten.

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

Sie können auch eine einzelne Wissensquelle anhand des Namens zurückgeben, um die JSON-Definition zu überprüfen.

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

Der folgende JSON-Code ist eine Beispielantwort für eine Blob-Wissensquelle.

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

Erstellen einer Wissensquelle

Führen Sie den folgenden Code aus, um eine Blob-Wissensquelle zu erstellen.

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

Einschränken der Aufnahme in ein privates Netzwerk (Vorschau)

Ab der 2026-08-01-preview API-Version steuert networkAccessMode die Netzwerkumgebung, in der der generierte Indexer für eine Blob-Wissensquelle ausgeführt wird. Diese Einstellung betrifft nur die Datenaufnahme und ändert weder Abrufanfragen noch -antworten der Wissensdatenbank.

networkAccessMode ist standardmäßig auf public festgelegt, wodurch das vorhandene Verhalten des öffentlichen Netzwerks beibehalten wird. Wenn networkAccessModeprivate ist, wird der generierte Indexer in der privaten Ausführungsumgebung ausgeführt. Es verwendet genehmigte gemeinsam genutzte private Links für den Zugriff auf die Azure Blob Storage- oder ADLS Gen2-Quellverbindung sowie auf unterstützte Azure-Abhängigkeiten, etwa Azure OpenAI-Modelle und Microsoft Foundry-Ressourcen.

So konfigurieren und überprüfen Sie den privaten Netzwerkzugriff:

1. Erfüllen Sie die Voraussetzungen für das private Netzwerk.

2. Setzen Sie private in der Anfrage zum Erstellen der Wissensquelle auf networkAccessMode. Sie können diese Eigenschaft nur während der Erstellung festlegen. Um sie später zu ändern, löschen Sie die Wissensquelle, und erstellen Sie sie neu.

   Die Erstellung kann fehlschlagen, wenn die Dienstebene oder Laufzeit keine private Ausführung unterstützt oder wenn ein erforderlicher freigegebener privater Link nicht vorhanden ist.

3. Vergewissern Sie sich, dass executionEnvironment des generierten Indexers private ist.

4. Vergewissern Sie sich, dass jeder erforderliche freigegebene private Link genehmigt wurde und auf die richtige Abhängigkeit ausgerichtet ist. Die erfolgreiche Erstellung allein bestätigt die Genehmigung oder Zielbestimmung von Links nicht.

5. Fragen Sie den Status der Wissensquelle ab, bis lastSynchronizationState.endTime einen Wert hat. Vergewissern Sie sich, dass itemsUpdatesFailed0 ist, und überprüfen Sie dann den connectorspezifischen Quellinhalt. Die Synchronisierung schlägt fehl, wenn eine Abhängigkeit nicht erreichbar ist.

Verwenden Sie automatische sprachspezifische Analysatoren (Vorschau)

Ab der 2026-08-01-preview-API-Version stehen automatische Sprachanalysetools für Blob, indizierte OneLake- und indizierte SharePoint-Wissensquellen zur Verfügung. Wenn diese Funktion aktiviert ist, erkennt Azure KI-Suche die Sprache jedes Quelldokuments und wendet automatisch einen passenden Microsoft-Sprachanalysator an. Sie geben keinen Analyzer in der Wissensquelldefinition oder in einer Abfrage an.

Um automatische sprachspezifische Analyzer zu aktivieren, setzen Sie contentExtractionMode auf minimal und konfigurieren Sie ingestionParameters.aiServices in der Wissensquelldefinition.

Für die schlüssellose Authentifizierung lassen Sie weg und weisen die Rolle aiServices.apiKey auf Ihrer Microsoft Foundry-Ressource der verwalteten Identität Ihres Suchdiensts zu. Für die schlüsselbasierte Authentifizierung setzen Sie aiServices.apiKey auf einen gültigen Schlüssel für Ihre Foundry-Ressource.

Die folgenden Sprachen werden unterstützt:

• Englisch
• Japanese
• Französisch
• Spanisch
• Deutsch
• Dutch
• Italienisch
• Portugiesisch (Brasilien)
• Europäisches Portugiesisch
• Vereinfachtes Chinesisch
• Traditionelles Chinesisch
• Korean

Bei mehrsprachigen Inhalten wählt Azure KI-Suche einen Analyzer basierend auf der vorherrschenden erkannten Sprache aus. Er verwendet den Standardanalysator, wenn die Sprache nicht unterstützt oder unsicher ist.

Wenn Sie automatische Sprachanalysatoren aktivieren, fügt Azure KI-Suche sprachspezifische Inhaltsfelder für jede unterstützte Sprache zum generierten Indexschema hinzu, unabhängig davon, ob Ihre Daten Dokumente in diesen Sprachen enthalten. Während der Aufnahme werden Dokumente basierend auf ihrer erkannten Sprache an das entsprechende sprachspezifische Feld weitergeleitet.

Nicht verwendete Sprachfelder enthalten keinen indizierten Inhalt und haben minimale Speicherauswirkungen, bleiben aber Teil des Indexschemas und zählen zur Indexfeldgrenze. Berücksichtigen Sie die zusätzlichen Felder, wenn Sie den Indexentwurf, die Feldanzahl und die Speicheranforderungen planen. Weitere Informationen finden Sie unter "Indexbeschränkungen " und " Schätzen und Verwalten der Kapazität eines Suchdiensts".

Die Sprachenerkennung ist nach dem kostenlosen KI-Anreicherungsfreikontingent kostenpflichtig. Weitere Informationen finden Sie unter "Freie Anreicherungen".

Überprüfen des Ingestion-Status

Führen Sie den folgenden Code aus, um den Fortschritt und die Integrität der Erfassung zu überwachen, einschließlich der Wissensquelle und detaillierter Indizierungsfehler für Wissensquellen, die eine Indexerpipeline generieren und einen Suchindex auffüllen.

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 

Eine Antwort auf eine Anforderung, die Aufnahmeparameter enthält und aktiv Inhalte erfasst, kann folgendermaßen aussehen.

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

Überprüfen der generierten Objekte

Wenn Sie diese Wissensquelle erstellen, generiert Azure KI-Suche automatisch eine Datenquelle, einen Fähigkeitensatz, einen Indexer und einen Index. Die Erstellungsantwort listet jedes Objekt unter createdResources.

Diese Objekte werden gemäß einer festen Vorlage generiert, und ihre Namen basieren auf dem Namen der Wissensquelle. Sie können die Objektnamen nicht ändern. Vermeiden Sie das direkte Bearbeiten dieser Objekte, da Änderungen Fehler oder Inkompatibilitäten verursachen können, die die Indexerpipeline unterbrechen.

Sie können das Azure Portal verwenden, um die Objekterstellung zu überprüfen. Der Workflow lautet:

1. Überprüfen Sie den Indexer auf Erfolgs- oder Fehlermeldungen. Hier werden Verbindungs- oder Kontingentfehler angezeigt.

2. Überprüfen Sie die Datenquelle, um die Verbindung mit Ihrem Datenspeicher zu überprüfen. Die Verbindung verwendet entweder eine Verbindungszeichenfolge oder eine verwaltete Identität, je nachdem, wie Sie die Wissensquelle konfiguriert haben.

3. Überprüfen Sie das Skillset, um zu sehen, wie Ihre Inhalte in Blöcke unterteilt und optional vektorisiert werden.

4. Überprüfen Sie den Index, um zu sehen, wie Ihre Inhalte für den Abruf indiziert und verfügbar gemacht werden, einschließlich der durchsuchbaren und filterbaren Felder und welche Felder Vektoren für die Ähnlichkeitssuche speichern. Verwenden Sie den Such-Explorer, um Abfragen für den generierten Index auszuführen.

Zuweisen zu einer Wissensbasis

Wenn Sie mit der Wissensquelle zufrieden sind, fügen Sie sie einer Wissensbasis hinzu.

Abfragen einer Wissensbasis

Rufen Sie nach der Konfiguration der Knowledge Base die Abrufen-Aktion oder den MCP-Endpunkt auf, um die Wissensquelle abzufragen. Wählen Sie die Konfiguration aus, die Ihrem Szenario entspricht.

Berechtigungen auf Dokumentenebene erzwingen (Vorschau)

Um Berechtigungen auf Dokumentebene zu erzwingen, legen Sie fest ingestionPermissionOptions , wenn Sie diese Wissensquelle erstellen, und fügen Sie dann das Zugriffstoken des Benutzers in die Abrufanforderung ein. Weitere Informationen finden Sie unter Erzwingen von Berechtigungen zur Abfragezeit (Vorschau).

Surface in Dokumente eingebettete Bilder (Vorschau)

Um in Antworten der Antwortsynthese in Dokumente eingebettete Bilder (z. B. Diagramme oder Scans) anzuzeigen, konfigurieren Sie assetStore für diese Wissensquelle, und aktivieren Sie dann die Bildbereitstellung für die Wissensdatenbank. Die Bereitstellung von Bildern wird nicht unterstützt, wenn ingestionPermissionOptions konfiguriert ist. Weitere Informationen finden Sie unter In Dokumente eingebettete Bilder im Agent-Abruf anzeigen (Vorschau).

Löschen einer Wissensquelle

Bevor Sie eine Wissensquelle löschen können, müssen Sie alle Knowledge Basen löschen, die darauf verweisen, oder die Knowledge Base-Definition aktualisieren, um den Verweis zu entfernen. Für Wissensquellen, die eine Index- und Indexerpipeline generieren, werden auch alle generierten Objekte gelöscht. Wenn Sie jedoch einen vorhandenen Index zum Erstellen einer Wissensquelle verwendet haben, wird Ihr Index nicht gelöscht.

Wenn Sie versuchen, eine verwendete Wissensquelle zu löschen, schlägt die Aktion fehl und gibt eine Liste der betroffenen Wissensdatenbanken zurück.

So löschen Sie eine Wissensquelle:

Verwandte Inhalte

• Agentic-Abruf in Azure KI-Suche
• Was ist eine Wissensquelle?
• Erstellen einer Wissensbasis
• Abfragen einer Wissensbasis
• Python-Beispiel: Azure KI-Suche-Blob-Wissensquelle