Skapa en blob-kunskapskälla från Azure Blob Storage eller ADLS Gen2

En blobkunskapskälla importerar innehåll från Azure Blob Storage eller ADLS Gen2 till en agentbaserad hämtningspipeline i Azure AI-sökning. Kunskapskällor skapas oberoende av varandra, refereras i en kunskapsbas och används som grunddata när kunskapsbasen efterfrågas vid körning.

När du skapar en blob-kunskapskälla anger du en extern datakälla, modeller och egenskaper för att automatiskt generera följande Azure AI-sökning objekt:

• En datakälla som representerar en blobcontainer.
• En kompetensuppsättning som segmenterar och eventuellt vektoriserar multimodalt innehåll från containern.
• Ett index som lagrar berikat innehåll och uppfyller kriterierna för agentisk hämtning.
• En indexerare som använder de tidigare objekten för att driva indexerings- och berikningspipelinen.

Den genererade indexeraren följer blob indexer, vars förutsättningar, dokumentformat som stöds och begränsningar även gäller för blobkunskapskällor. Mer information finns i dokumentationen om blobindexeraren och indexerarens gränser. Om den genererade kompetensuppsättningen anropar en extern tjänst gäller även den kompetensens indata- och tjänstgränser.

Användningsstöd

Förutsättningar

• En Azure AI-sökning-tjänst i valfri region som tillhandahåller agentdriven hämtning.

• Ett Azure Blob Storage eller Azure Data Lake Storage (ADLS) Gen2 konto.

• En blobcontainer med innehållstyper som stöds för textinnehåll. För valfri bildverbalisering beror den stödda innehållstypen på om din chattkompletteringsmodell kan analysera och beskriva bildfilen.

• Om contentExtractionMode är standard, använder du en Microsoft Foundry-resurs i en region som stöds av Content Understanding i Foundry Tools med en https://<resource-name>.services.ai.azure.com slutpunkt. Resursen måste ha en driftsättning av en inbäddningsmodell och, om du aktiverar bildbeskrivning, en driftsättning av en multimodal chattmodell.

• Behörighet att skapa kunskapskällor. Konfigurera nyckellös autentisering med rollerna Search Service Contributor och Search Index Data Contributor som tilldelats ditt användarkonto (rekommenderas) eller använd en administratörs-API-nyckel.

• En hanterad identitet för söktjänsten med Storage Blob Data Reader inom källlagringskontots omfång och Cognitive Services User på Microsoft Foundry-resursen. Om du konfigurerar ett resurslager i ett annat lagringskonto, ska du även tilldela Storage Blob Data Contributor på lagringskontonivå. Om käll- och tillgångscontainrarna delar ett konto ger Storage Blob Data Contributor både läsåtkomst för källa och läs-/skrivåtkomst för tillgångsarkivet.

• Om du ställer in networkAccessMode på private, måste du uppfylla följande krav:

  • Använd söktjänsten S2, S3, L1 eller L2.

  • Aktivera en systemtilldelad eller användartilldelad hanterad identitet i söktjänsten, ge den rollen Storage Blob Data Reader på lagringskontot och använd en ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> reťazec pripojenia. För en användartilldelad identitet anger du också ingestionParameters.identity.

  • Skapa och godkänn en delad privat länk till lagringskontot med blob grupp-ID:t. För ADLS Gen2 skapar och godkänner du både blob och dfs delade privata länkar.

  • Skapa och godkänn en delad privat länk för varje skyddad modellslutpunkt. Använd grupp-IDopenai_account:t för Azure OpenAI-slutpunkter och foundry_account för Foundry-resursslutpunkter.

Sök efter befintliga kunskapskällor

En kunskapskälla är ett återanvändbart objekt på toppnivå. Att känna till befintliga kunskapskällor är användbart för återanvändning eller namngivning av nya objekt.

Kör följande kod för att lista kunskapskällor efter namn och typ.

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

Du kan också returnera en enda kunskapskälla efter namn för att granska dess JSON-definition.

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

Följande JSON är ett exempelsvar för en blob-kunskapskälla.

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

Skapa en kunskapskälla

Kör följande kod för att skapa en blob-kunskapskälla.

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

Begränsa inmatning till ett privat nätverk (förhandsversion)

Från och med API-versionen 2026-08-01-preview styr networkAccessMode nätverksmiljön som den genererade indexeraren för en kunskapskälla i Blob Storage körs i. Den här inställningen påverkar endast inmatning och ändrar inte kunskapsbasens hämtningsbegäranden eller svar.

networkAccessMode standardvärdet är public, vilket bevarar befintligt offentligt nätverksbeteende. När networkAccessMode är private körs den genererade indexeraren i en privat körningsmiljö. Den använder godkända delade privata länkar för att komma åt källanslutningen till Azure Blob Storage eller ADLS Gen2 samt Azure-beroenden som stöds, till exempel Azure OpenAI-modeller och Microsoft Foundry-resurser.

Så här konfigurerar och verifierar du åtkomst till privata nätverk:

1. Slutför kraven för det privata nätverket.

2. Ange networkAccessMode till private i begäran om att skapa kunskapskällor. Du kan bara ange den här egenskapen när du skapar den. Om du vill ändra det senare tar du bort och återskapar kunskapskällan.

   Det går inte att skapa om tjänstnivån eller körningsmiljön inte stöder privat körning eller om en obligatorisk delad privat länk saknas.

3. Bekräfta att den genererade indexerarens executionEnvironment är private.

4. Bekräfta att varje obligatorisk delad privat länk har godkänts och riktar in sig på rätt beroende. Enbart att länken har skapats innebär inte att den har godkänts eller fått målinriktning.

5. Avfråga kunskapskällans status tills lastSynchronizationState.endTime har ett värde. Bekräfta att itemsUpdatesFailed är 0, och verifiera sedan det anslutningsspecifika källinnehållet. Synkroniseringen misslyckas om ett beroende inte kan nås.

Använda automatiska analysverktyg per språk (förhandsversion)

Från och med 2026-08-01-preview API-versionen är automatiska analysverktyg per språk tillgängliga för blobbar, indexerade OneLake och indexerade SharePoint kunskapskällor. När det är aktiverat identifierar Azure AI-sökning varje källdokuments språk och tillämpar automatiskt en matchande Microsoft språkanalys. Du anger inte någon analys i kunskapskällans definition eller i en fråga.

Om du vill aktivera automatiska analysverktyg per språk anger du contentExtractionMode till minimal och konfigurerar ingestionParameters.aiServices i kunskapskällans definition.

För nyckellös autentisering utelämnar du aiServices.apiKey och tilldelar rollen Cognitive Services User på din Microsoft Foundry-resurs till den hanterade identiteten för din söktjänst. För nyckelbaserad autentisering anger du aiServices.apiKey till en giltig nyckel för din Foundry-resurs.

Följande språk stöds:

• Engelska
• Japanese
• Franska
• Spanish
• Tyska
• Dutch
• Italienska
• Brasiliansk portugisiska
• europeisk portugisiska
• Förenklad kinesiska
• Traditionell kinesiska
• Korean

För flerspråkigt innehåll väljer Azure AI-sökning ett analysverktyg baserat på det dominerande identifierade språket. Den använder standardanalysen när språket inte stöds eller är osäkert.

När du aktiverar automatiska analysverktyg per språk lägger Azure AI-sökning till språkspecifika innehållsfält för varje språk som stöds i det genererade indexschemat, oavsett om dina data innehåller dokument på dessa språk eller inte. Under inmatningen dirigeras dokument till lämpligt språkspecifikt fält baserat på deras identifierade språk.

Oanvända språkfält innehåller inte indexerat innehåll och har minimal lagringspåverkan, men de förblir en del av indexschemat och räknas mot indexfältgränsen. Tänk på de ytterligare fälten när du planerar indexdesignen, antalet fält och lagringskraven. Mer information finns i Indexgränser och Beräkna och hantera kapacitet för en söktjänst.

Språkidentifiering är fakturerbar efter den kostnadsfria tilldelningen för AI-berikning. Mer information finns i Kostnadsfria berikanden.

Kontrollera inmatningsstatus

Kör följande kod för att övervaka inmatningsförlopp och hälsa, inklusive kunskapskällans typ och detaljerade indexeringsfel för kunskapskällor som genererar en indexeringspipeline och fyller i ett sökindex.

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 

Ett svar för en begäran som innehåller inmatningsparametrar och aktivt matar in innehåll kan se ut som i följande exempel.

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

Granska de genererade objekten

När du skapar den här kunskapskällan genererar Azure AI-sökning automatiskt en datakälla, kompetensuppsättning, indexerare och index. Skapandesvaret visar varje objekt under createdResources.

Dessa objekt genereras enligt en fast mall och deras namn baseras på namnet på kunskapskällan. Du kan inte ändra objektnamnen. Undvik att redigera dessa objekt direkt, eftersom ändringar kan medföra fel eller inkompatibiliteter som bryter indexerarens pipeline.

Du kan använda Azure-portalen för att verifiera att objekt skapas. Arbetsflödet är:

1. Kontrollera indexeraren efter lyckade eller misslyckade meddelanden. Anslutnings- eller kvotfel visas här.

2. Kontrollera datakällan för att verifiera anslutningen till datalagret. Anslutningen använder antingen en reťazec pripojenia eller en hanterad identitet, beroende på hur du konfigurerade kunskapskällan.

3. Kontrollera kompetensuppsättningen för att se hur innehållet delas upp i segment och eventuellt vektoriseras.

4. Kontrollera indexet för att se hur ditt innehåll indexeras och exponeras för hämtning, inklusive vilka fält som är sökbara och filterbara och vilka fält som lagrar vektorer för likhetssökning. Använd Sökutforskaren för att köra frågor mot det genererade indexet.

Tilldela en kunskapsbas

Om du är nöjd med kunskapskällan lägger du till den i en kunskapsbas.

Sök i en kunskapsbas

När du har konfigurerat kunskapsbasen anropar du åtgärden hämta eller MCP-slutpunkten för att fråga kunskapskällan. Välj den konfiguration som matchar ditt scenario.

Framtvinga behörigheter på dokumentnivå (förhandsversion)

Om du vill framtvinga behörigheter på dokumentnivå anger ingestionPermissionOptions du när du skapar den här kunskapskällan och tar sedan med användarens åtkomsttoken i hämtningsbegäran. Mer information finns i Framtvinga behörigheter vid frågetid (förhandsversion).

Visa dokumentinbäddade bilder (förhandsversion)

Om du vill visa dokumentinbäddade bilder (till exempel diagram eller genomsökningar) i svarssyntessvar konfigurerar du assetStore på den här kunskapskällan och aktiverar sedan bildvisning på kunskapsbasen. Bildvisning stöds inte när ingestionPermissionOptions är konfigurerat. Mer information finns i Visa dokumentinbäddade bilder i agentisk hämtning (förhandsversion).

Ta bort en kunskapskälla

Innan du kan ta bort en kunskapskälla måste du ta bort alla kunskapsbaser som refererar till den eller uppdatera kunskapsbasdefinitionen för att ta bort referensen. För kunskapskällor som genererar en index- och indexeringspipeline tas även alla genererade objekt bort. Men om du använde ett befintligt index för att skapa en kunskapskälla tas inte ditt index bort.

Om du försöker ta bort en kunskapskälla som används misslyckas åtgärden och returnerar en lista över berörda kunskapsbaser.

Så här tar du bort en kunskapskälla:

Relaterat innehåll

• Agentic-hämtning i Azure AI-sökning
• Vad är en kunskapskälla?
• Skapa en kunskapsbas
• Fråga en kunskapsbas
• Python exempel: Azure AI-sökning blob-kunskapskälla