Blob-tudásbázis létrehozása Azure Blob Storage vagy ADLS Gen2-ből

Egy blobismeretforrás az Azure Blob Storage vagy az ADLS Gen2 tartalmát az Azure AI Keresés ügynökalapú visszakeresési folyamatába olvassa be. A tudásbázisok egymástól függetlenül jönnek létre, egy tudásbázisban hivatkoznak rá, és földi adatként használják, amikor a tudásbázist futtatókörnyezetben kérdezik le.

Blob-tudásbázis létrehozásakor meg kell adnia egy külső adatforrást, modelleket és tulajdonságokat a következő Azure AI Keresés objektumok automatikus létrehozásához:

• Egy blobtárolót jelképező adatforrás.
• Egy készségkészlet, amely a tárolóból származó multimodális tartalmat darabolja és igény szerint vektorizálja.
• Gazdagított tartalmat tároló index, amely megfelel az ügynöki lekérés feltételeinek.
• Egy indexelő, amely az előző objektumokat használja az indexelési és bővítési folyamat vezetésére.

A létrehozott indexelő megfelel a blobindexelőnek, amelynek előfeltételei, támogatott dokumentumformátumai és korlátozásai a blob-tudásbázisokra is vonatkoznak. További információkért tekintse meg a blobindexelő dokumentációját és az indexelő korlátait. Ha a létrehozott képességkészlet külső szolgáltatást hív meg, az adott képesség bemeneti és szolgáltatási korlátai is érvényesek.

Használat támogatása

Előfeltételek

• Egy Azure AI Keresés szolgáltatás bármely régióban, amely lehetővé teszi az intelligens adatlekérést.

• Azure Blob Storage vagy Azure Data Lake Storage (ADLS) Gen2-fiók.

• A szöveges tartalom támogatott tartalomtípusaival rendelkező blobtároló. Választható képi verbális megjelenítés esetén a támogatott tartalomtípus attól függ, hogy a csevegés befejező modellje képes-e elemezni és leírni a képfájlt.

• Ha a(z) contentExtractionMode értéke standard, használjon Microsoft Foundry-erőforrást a Content Understanding által a Foundry Toolsban támogatott régióban, https://<resource-name>.services.ai.azure.com-végponttal. Az erőforrásnak rendelkeznie kell beágyazásimodell-telepítéssel, és ha engedélyezi a képek szöveges leírását, multimodális csevegőmodell-telepítéssel is.

• Engedély tudásbázisok létrehozásához. Konfigurálja a kulcs nélküli hitelesítést a keresési szolgáltatás közreműködője és a keresési index adatszolgáltatói szerepköreivel a felhasználói fiókjához rendelve (ajánlott), vagy használjon rendszergazdai API-kulcsot.

• A keresési szolgáltatás számára létrehozott felügyelt identitás, Storage Blob Data Reader szerepkörrel a forrástárfiók hatókörében, valamint Cognitive Services User szerepkörrel a Microsoft Foundry-erőforráson. Ha egy másik tárfiókban konfigurál egy eszköztárolót, akkor a tárfiók hatókörében is rendelje hozzá a Storage Blob Data Közreműködőt . Ha a forrás- és eszköztárolók egy fiókkal osztoznak, a Storage Blob Data Közreműködője a forrás olvasási hozzáférését és az eszköztároló olvasási/írási hozzáférését is biztosítja.

• Ha a(z) private beállítást networkAccessMode értékre állítja, teljesítse a következő követelményeket:

  • Használjon S2, S3, L1 vagy L2 keresési szolgáltatást.

  • Engedélyezze a rendszer által hozzárendelt vagy a felhasználó által hozzárendelt felügyelt identitást a keresési szolgáltatáson, rendelje hozzá a tárfiókon a Storage Blob Data Reader szerepkört, és használjon ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> kapcsolati sztringet. Felhasználó által hozzárendelt identitás esetén is állítsa be a következőt ingestionParameters.identity:

  • Hozzon létre és hagyjon jóvá egy megosztott privát hivatkozást a tárfiókhoz a blob csoportazonosítóval. Az ADLS Gen2 esetében hozzon létre és hagyjon jóvá mindkét blob és dfs megosztott privát hivatkozást.

  • Hozzon létre és hagyjon jóvá egy megosztott privát hivatkozást minden védett modellvégponthoz. Használja a csoportazonosítót Azure openai_account OpenAI-végpontokhoz és foundry_account az Foundry-erőforrásvégpontokhoz.

Meglévő tudásbázisok keresése

A tudásbázis egy legfelső szintű, újrafelhasználható objektum. A meglévő tudásbázisok ismerete hasznos lehet az új objektumok újbóli felhasználásához vagy elnevezéséhez.

Futtassa az alábbi kódot a tudásbázisok név és típus szerinti listázásához.

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

A JSON-definíció áttekintéséhez lekérdezhet egyetlen tudásforrást a név megadásával.

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

Az alábbi JSON egy példaválasz egy blob-tudásbázisra.

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

Tudásbázis létrehozása

Futtassa az alábbi kódot egy blob-tudásbázis létrehozásához.

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

Privát hálózatba való betöltés korlátozása (előzetes verzió)

A 2026-08-01-preview API-verziótól kezdve a networkAccessMode szabályozza azt a hálózati környezetet, amelyben a blob tudásforráshoz létrehozott indexelő fut. Ez a beállítás csak az adatbeolvasást érinti, és nem változtatja meg a tudásbázis-lekérdezési kéréseket vagy válaszokat.

networkAccessMode alapértelmezett értéke public, amely megőrzi a meglévő nyilvános hálózati működést. Ha a(z) networkAccessMode értéke private igaz, a létrehozott indexelő a privát végrehajtási környezetben fut. Jóváhagyott megosztott privát hivatkozásokat használ a Azure Blob Storage vagy az ADLS Gen2 forráskapcsolat eléréséhez, valamint támogatott Azure függőségekhez, például Azure OpenAI-modellekhez és Microsoft Foundry-erőforrásokhoz.

A magánhálózati hozzáférés konfigurálása és ellenőrzése:

1. A magánhálózat előfeltételeinek teljesítése.

2. Állítsa a(z) private értékét networkAccessMode értékre a tudásforrás létrehozási kérésben. Ezt a tulajdonságot csak a létrehozás során állíthatja be. Ha később módosítani szeretné, törölje és hozza létre újra a tudásbázist.

   A létrehozás meghiúsulhat, ha a szolgáltatási szint vagy a futtatókörnyezet nem támogatja a privát végrehajtást, vagy ha nem létezik egy szükséges megosztott privát kapcsolat.

3. Győződjön meg arról, hogy a létrehozott indexelő az executionEnvironmentprivate.

4. Győződjön meg arról, hogy minden szükséges megosztott privát kapcsolat jóvá van hagyva, és a megfelelő függőséget célozza meg. A sikeres létrehozás önmagában nem erősíti meg a hivatkozás jóváhagyását vagy a célzást.

5. Kérdezze le a tudásforrás állapotát, amíg a(z) lastSynchronizationState.endTime értéket nem kap. Győződjön meg róla, majd itemsUpdatesFailed0ellenőrizze az összekötő-specifikus forrástartalmat. A szinkronizálás meghiúsul, ha egy függőség nem érhető el.

Automatikus nyelvenkénti elemzők használata (előzetes verzió)

Az API-verziótól kezdve a 2026-08-01-preview nyelvenkénti automatikus elemzők blobokhoz, indexelt OneLake-hez és indexelt SharePoint tudásbázisokhoz érhetők el. Ha engedélyezve van, Azure AI Keresés észleli az egyes forrásdokumentumok nyelvét, és automatikusan alkalmazza a megfelelő Microsoft nyelvelemzőt. A tudásbázis-definícióban és a lekérdezésben nem ad meg elemzőt.

Az automatikus nyelvenkénti elemzők engedélyezéséhez állítsa be contentExtractionModeminimal és konfigurálja ingestionParameters.aiServices a tudásbázis definícióját.

Kulcs nélküli hitelesítéshez hagyja el a(z) aiServices.apiKey elemet, és rendelje hozzá a Cognitive Services User szerepkört a keresési szolgáltatás felügyelt identitásához a Microsoft Foundry-erőforráson. Kulcsalapú hitelesítéshez állítson be aiServices.apiKey érvényes kulcsot az Foundry-erőforráshoz.

A következő nyelvek támogatottak:

• English
• Japanese
• French
• Spanyol
• Német
• Holland
• Italian
• brazíliai portugál
• európai portugál
• Egyszerűsített kínai
• Hagyományos kínai
• Korean

Többnyelvű tartalom esetén Azure AI Keresés kiválaszt egy elemzőt az elsődlegesen észlelt nyelv alapján. A standard elemzőt használja, ha a nyelv nem támogatott vagy bizonytalan.

Ha engedélyezi az automatikus nyelvenkénti elemzőket, Azure AI Keresés nyelvspecifikus tartalommezőket ad hozzá minden támogatott nyelvhez a létrehozott indexsémához, függetlenül attól, hogy az adatok ezekben a nyelveken tartalmaznak-e dokumentumokat. A betöltés során a dokumentumok az észlelt nyelv alapján a megfelelő nyelvspecifikus mezőre lesznek irányítva.

A nem használt nyelvi mezők nem tartalmaznak indexelt tartalmat, és minimális tárolási hatással vannak rájuk, de továbbra is az indexséma része maradnak, és az indexmezőkorlát felé számlálnak. Az indexterv, a mezőszám és a tárolási követelmények tervezésekor vegye figyelembe a további mezőket. További információ: Indexkorlátok , keresési szolgáltatás kapacitásának becslése és kezelése.

A nyelvfelismerés az ingyenes AI-bővítési kiosztás után számlázható. További információ: Ingyenes bővítés.

Adatbetöltési állapot ellenőrzése

Futtassa az alábbi kódot a betöltési folyamat és az állapot figyeléséhez, beleértve a tudásbázistípust és az indexelő folyamatot létrehozó és a keresési indexet feltöltő tudásbázisok részletes indexelési hibáit.

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 

A betöltési paramétereket tartalmazó és tartalombetöltést aktívan betöltő kérésekre adott válasz az alábbi példához hasonlóan nézhet ki.

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

A létrehozott objektumok áttekintése

A tudásbázis létrehozásakor a Azure AI Keresés automatikusan létrehoz egy adatforrást, képességkészletet, indexelőt és indexet. A létrehozási válasz az egyes objektumokat a createdResources alatt sorolja fel.

Ezek az objektumok rögzített sablon alapján jönnek létre, és a nevük a tudásforrás nevén alapul. Az objektumnevek nem módosíthatók. Kerülje az objektumok közvetlen szerkesztését, mivel a módosítások olyan hibákat vagy inkompatibilitásokat eredményezhetnek, amelyek megszakítják az indexelő folyamatot.

Az objektumlétrehozás ellenőrzéséhez használhatja a Azure portált. A munkafolyamat a következő:

1. Ellenőrizze az indexelőben a sikeres vagy sikertelen üzeneteket. Itt csatlakozási vagy kvótahibák jelennek meg.

2. Ellenőrizze az adatforrást az adattárhoz való kapcsolat ellenőrzéséhez. A kapcsolat kapcsolati karakterlánc vagy felügyelt identitást használ a tudásbázis konfigurálásának módjától függően.

3. Ellenőrizze a képességkészletet, hogy a tartalom hogyan van csoportosítva és igény szerint vektorizálva.

4. Ellenőrizze az indexben, hogy a tartalom hogyan van indexelve, és hogyan érhető el lekérés céljából, beleértve, hogy mely mezők kereshetők és szűrhetők, és mely mezők tárolják a hasonlóság kereséséhez használt vektorokat. A Search Explorerrel lekérdezéseket futtathat a létrehozott indexen.

Hozzárendelés tudásbázishoz

Ha elégedett a tudásbázissal, adja hozzá egy tudásbázishoz.

Tudásbázis lekérdezése

A tudásbázis konfigurálása után hívja meg a lekérési műveletet vagy az MCP-végpontot a tudásbázis lekérdezéséhez. Válassza ki a forgatókönyvnek megfelelő konfigurációt.

Dokumentumszintű engedélyek kényszerítése (előzetes verzió)

A dokumentumszintű engedélyek érvényesítéséhez állítsa be ingestionPermissionOptions a tudásbázis létrehozásakor, majd vegye fel a felhasználó hozzáférési jogkivonatát a lekérési kérelembe. További információ: Engedélyek kényszerítése lekérdezéskor (előzetes verzió).

Surface-dokumentumba beágyazott képek (előzetes verzió)

Ha a dokumentumba ágyazott képeket (például diagramokat vagy beolvasott képeket) meg szeretné jeleníteni a válaszszintézis válaszaiban, konfigurálja a(z) assetStore beállítást ebben a tudásforrásban, majd engedélyezze a képkiszolgálást a tudásbázison. A rendszerkép-szolgáltatás nem támogatott, ha ingestionPermissionOptions konfigurálva van. További információkért lásd: A dokumentumokba ágyazott képek megjelenítése ügynöki lekérésben (előzetes verzió).

Tudásbázis törlése

Mielőtt törölhet egy tudásbázist, törölnie kell minden olyan tudásbázist, amely hivatkozik rá, vagy frissítenie kell a tudásbázis definícióját a hivatkozás eltávolításához. Az index- és indexelőfolyamatot létrehozó tudásbázisok esetében a rendszer az összes létrehozott objektumot is törli. Ha azonban egy meglévő indexet használt egy tudásbázis létrehozásához, az index nem törlődik.

Ha egy használatban lévő tudásbázist próbál törölni, a művelet meghiúsul, és visszaadja az érintett tudásbázisok listáját.

Tudásbázis törlése:

Kapcsolódó tartalom

• Ügynöki lekérdezés az Azure AI Keresés-ben
• Mi az a tudásforrás?
• Tudásbázis létrehozása
• Tudásbázis lekérdezése
• Python minta: Azure AI Keresés blob-tudásbázis