Membuat sumber pengetahuan blob dari Azure Blob Storage atau ADLS Gen2

Sumber pengetahuan blob menyerap konten Azure Blob Storage atau ADLS Gen2 ke dalam alur pengambilan agenik dalam Pencarian Azure AI. Sumber pengetahuan dibuat secara independen, direferensikan dalam pangkalan pengetahuan, dan digunakan sebagai data dasar ketika pangkalan pengetahuan dikueri saat runtime.

Saat membuat sumber pengetahuan blob, Anda menentukan sumber data eksternal, model, dan properti untuk menghasilkan objek Pencarian Azure AI berikut secara otomatis:

• Sumber data yang mewakili kontainer blob.
• Set keterampilan yang memotong dan secara opsional mem-vektorisasi konten multimodal dari kontainer.
• Indeks yang menyimpan konten yang diperkaya dan memenuhi kriteria untuk pengambilan agenik.
• Pengindeks yang menggunakan objek sebelumnya untuk mendorong alur pengindeksan dan pengayaan.

Pengindeks yang dihasilkan sesuai dengan pengindeks blob, yang prasyaratnya, format dokumen yang didukung, dan batasan juga berlaku untuk sumber pengetahuan blob. Untuk informasi selengkapnya, lihat dokumentasi pengindeks blob dan batas pengindeks. Jika kumpulan keterampilan yang dihasilkan memanggil layanan eksternal, batas input dan batas layanan untuk keterampilan tersebut juga berlaku.

Dukungan penggunaan

Prasyarat

• Layanan Pencarian Azure AI dalam wilayah mana pun yang menyediakan agentic retrieval.

• Akun Azure Blob Storage atau Azure Data Lake Storage (ADLS) Gen2.

• Kontainer blob dengan tipe konten yang didukung untuk konten teks. Untuk verbalisasi gambar opsional, jenis konten yang didukung bergantung pada apakah model penyelesaian obrolan Anda dapat menganalisis dan menjelaskan file gambar.

• Jika contentExtractionMode adalah standard, gunakan resource Microsoft Foundry di wilayah yang mendukung Content Understanding di Foundry Tools dengan endpoint https://<resource-name>.services.ai.azure.com. Sumber daya harus memiliki penyebaran model penyematan dan, jika Anda mengaktifkan verbalisasi gambar, penyebaran model obrolan multimodal.

• Izin untuk membuat sumber pengetahuan. Konfigurasikan autentikasi tanpa kunci dengan peran Kontributor Layanan Pencarian dan Kontributor Data Indeks Pencarian yang ditetapkan ke akun pengguna Anda (disarankan) atau gunakan kunci API admin.

• Identitas terkelola untuk layanan pencarian dengan Storage Blob Data Reader pada cakupan akun penyimpanan sumber dan Cognitive Services User pada sumber daya Microsoft Foundry. Jika Anda mengonfigurasi penyimpanan aset di akun penyimpanan yang berbeda, tetapkan juga Kontributor Data Blob Penyimpanan di cakupan akun penyimpanan tersebut. Jika kontainer sumber dan aset berada dalam akun yang sama, Storage Blob Data Contributor menyediakan baik akses baca ke sumber maupun akses baca/tulis ke penyimpanan aset.

• Jika Anda mengatur networkAccessMode ke private, selesaikan persyaratan berikut:

  • Gunakan layanan pencarian S2, S3, L1, atau L2.

  • Aktifkan identitas terkelola yang ditetapkan sistem atau ditetapkan pengguna pada layanan pencarian, berikan peran Pembaca Data Blob Penyimpanan pada akun penyimpanan, dan gunakan ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> string koneksi. Untuk identitas yang ditetapkan pengguna, atur juga ingestionParameters.identity.

  • Buat dan menyetujui tautan privat bersama ke akun penyimpanan dengan ID grup blob. Untuk ADLS Gen2, buat dan setujui kedua tautan privat bersama, blob dan dfs.

  • Buat dan setujui tautan privat bersama untuk setiap titik akhir model yang dilindungi. Gunakan ID grup openai_account untuk titik akhir Azure OpenAI dan foundry_account untuk titik akhir sumber daya Foundry.

Periksa sumber pengetahuan yang ada

Sumber pengetahuan adalah objek tingkat atas yang dapat digunakan kembali. Mengetahui tentang sumber pengetahuan yang ada sangat membantu untuk menggunakan kembali atau memberi nama objek baru.

Jalankan kode berikut untuk mencantumkan sumber pengetahuan menurut nama dan jenis.

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

Anda juga dapat mengembalikan satu sumber pengetahuan berdasarkan nama untuk meninjau definisi JSON-nya.

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

JSON berikut adalah contoh respons untuk sumber pengetahuan blob.

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

Membuat sumber pengetahuan

Jalankan kode berikut untuk membuat sumber pengetahuan blob.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Membatasi penyerapan ke jaringan privat (pratinjau)

Mulai dari versi API 2026-08-01-preview, networkAccessMode mengendalikan lingkungan jaringan tempat pengindeks yang dibuat untuk sumber pengetahuan blob dijalankan. Pengaturan ini hanya memengaruhi proses ingest dan tidak mengubah permintaan atau respons pengambilan data dari basis pengetahuan.

networkAccessMode secara default diatur ke public, yang mempertahankan perilaku jaringan publik yang ada. Ketika networkAccessMode adalah private, pengindeks yang dihasilkan berjalan di lingkungan eksekusi privat. Ini menggunakan tautan privat bersama yang disetujui untuk mengakses koneksi sumber Azure Blob Storage atau ADLS Gen2 serta dependensi Azure yang didukung, seperti model Azure OpenAI dan sumber daya Microsoft Foundry.

Untuk mengonfigurasi dan memverifikasi akses jaringan privat:

1. Selesaikan prasyarat jaringan privat.

2. Atur networkAccessMode ke private dalam permintaan pembuatan sumber pengetahuan. Anda hanya dapat mengatur properti ini selama pembuatan. Untuk mengubahnya nanti, hapus dan buat ulang sumber pengetahuan.

   Pembuatan dapat gagal jika tingkat layanan atau runtime tidak mendukung eksekusi privat atau jika tautan privat bersama yang diperlukan tidak ada.

3. Konfirmasikan bahwa pengindeks executionEnvironment yang dihasilkan adalah private.

4. Konfirmasikan bahwa setiap tautan privat bersama yang diperlukan disetujui dan menargetkan dependensi yang benar. Pembuatan yang berhasil saja tidak mengonfirmasi persetujuan tautan atau penargetan.

5. Periksa status sumber pengetahuan hingga lastSynchronizationState.endTime bernilai. Konfirmasikan bahwa itemsUpdatesFailed adalah 0, lalu verifikasi konten sumber khusus konektor. Sinkronisasi gagal jika dependensi tidak dapat dijangkau.

Gunakan analisis otomatis per bahasa (pratinjau)

Mulai dari versi API 2026-08-01-preview, penganalisis otomatis untuk tiap bahasa tersedia untuk blob, OneLake yang diindeks, dan sumber pengetahuan SharePoint yang diindeks. Saat diaktifkan, Pencarian Azure AI mendeteksi bahasa setiap bahasa dokumen sumber dan secara otomatis menerapkan penganalisis bahasa Microsoft yang cocok. Anda tidak menentukan penganalisis dalam definisi sumber pengetahuan atau dalam kueri.

Untuk mengaktifkan penganalisis per bahasa otomatis, atur contentExtractionMode ke minimal dan konfigurasikan ingestionParameters.aiServices dalam definisi sumber pengetahuan.

Untuk autentikasi tanpa kunci, hilangkan aiServices.apiKey dan tetapkan peran Pengguna Cognitive Services pada sumber daya Microsoft Foundry Anda ke identitas terkelola layanan pencarian Anda. Untuk autentikasi berbasis kunci, atur aiServices.apiKey ke kunci yang valid untuk sumber daya Foundry Anda.

Bahasa berikut didukung:

• Bahasa Inggris
• Japanese
• Bahasa Prancis
• Bahasa Spanyol
• German
• Belanda
• Italia
• Portugis Brasil
• Bahasa Portugis Eropa
• Bahasa Tionghoa Sederhana
• Tionghoa Tradisional
• Bahasa Korea

Untuk konten multibahasa, Pencarian Azure AI memilih penganalisis berdasarkan bahasa yang terdeteksi dominan. Ini menggunakan penganalisis standar ketika bahasa tidak didukung atau tidak pasti.

Saat Anda mengaktifkan penganalisis per bahasa otomatis, Pencarian Azure AI menambahkan bidang konten khusus bahasa untuk setiap bahasa yang didukung ke skema indeks yang dihasilkan, baik data Anda berisi dokumen dalam bahasa tersebut atau tidak. Selama proses ingest, dokumen diarahkan ke kolom khusus bahasa yang sesuai berdasarkan bahasa yang terdeteksi.

Bidang bahasa yang tidak digunakan tidak berisi konten terindeks dan memiliki dampak penyimpanan minimal, tetapi bidang tersebut tetap menjadi bagian dari skema indeks dan dihitung terhadap batas bidang indeks. Pertimbangkan bidang tambahan saat Anda merencanakan desain indeks, jumlah bidang, dan persyaratan penyimpanan Anda. Untuk informasi selengkapnya, lihat Batas indeks dan Memperkirakan dan mengelola kapasitas layanan pencarian.

Deteksi bahasa akan dikenakan biaya setelah alokasi gratis untuk pengayaan AI habis. Untuk informasi selengkapnya, lihat Pengayaan gratis.

Periksa status penyerapan

Jalankan kode berikut untuk memantau kemajuan dan kesehatan penyerapan, termasuk jenis sumber pengetahuan dan kesalahan pengindeksan terperinci untuk sumber pengetahuan yang menghasilkan alur pengindeks dan mengisi indeks pencarian.

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 

Respons untuk permintaan yang menyertakan parameter penyerapan dan secara aktif menyerap konten mungkin terlihat seperti contoh berikut.

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

Meninjau objek yang dihasilkan

Saat Anda membuat sumber pengetahuan ini, Pencarian Azure AI secara otomatis menghasilkan sumber data, set keterampilan, pengindeks, dan indeks. Respons pembuatan mencantumkan setiap objek di bawah createdResources.

Objek-objek ini dihasilkan sesuai dengan templat tetap, dan namanya didasarkan pada nama sumber pengetahuan. Anda tidak dapat mengubah nama objek. Hindari mengedit objek ini secara langsung, karena perubahan dapat menimbulkan kesalahan atau ketidaksesuaian yang merusak alur pengindeks.

Anda dapat menggunakan portal Azure untuk memvalidasi pembuatan objek. Alur kerjanya adalah:

1. Periksa pengindeks untuk pesan keberhasilan atau kegagalan. Kesalahan koneksi atau kuota muncul di sini.

2. Periksa sumber data untuk memverifikasi koneksi ke penyimpanan data Anda. Koneksi menggunakan string koneksi atau identitas terkelola, tergantung pada cara Anda mengonfigurasi sumber pengetahuan.

3. Periksa kumpulan keterampilan untuk melihat bagaimana konten Anda dibagi menjadi beberapa bagian dan, secara opsional, diubah menjadi vektor.

4. Periksa indeks untuk melihat bagaimana konten Anda diindeks dan diekspos untuk pengambilan, termasuk bidang mana yang dapat dicari dan dapat difilter dan bidang mana yang menyimpan vektor untuk pencarian kesamaan. Gunakan Search Explorer untuk menjalankan kueri terhadap indeks yang dihasilkan.

Tetapkan ke basis pengetahuan

Jika Anda puas dengan sumber pengetahuan, tambahkan ke pangkalan pengetahuan.

Meminta pangkalan pengetahuan

Setelah Anda mengonfigurasi pangkalan pengetahuan, panggil tindakan ambil atau titik akhir MCP untuk mengkueri sumber pengetahuan. Pilih konfigurasi yang cocok dengan skenario Anda.

Terapkan izin tingkat dokumen (pratinjau)

Untuk menerapkan izin tingkat dokumen, atur ingestionPermissionOptions saat Anda membuat sumber pengetahuan ini, lalu sertakan token akses pengguna dalam permintaan pengambilan. Untuk informasi selengkapnya, lihat Menerapkan izin pada waktu kueri (pratinjau).

Tampilkan gambar yang disematkan dalam dokumen (pratinjau)

Untuk menampilkan gambar yang disematkan dokumen (seperti diagram atau pemindaian) dalam respons sintesis jawaban, konfigurasikan assetStore pada sumber pengetahuan ini, lalu aktifkan penyajian gambar di pangkalan pengetahuan. Penyajian gambar tidak didukung saat ingestionPermissionOptions dikonfigurasi. Untuk informasi selengkapnya, lihat Menampilkan gambar yang disematkan dalam dokumen dalam pengambilan agentik (pratinjau).

Menghapus sumber pengetahuan

Sebelum dapat menghapus sumber pengetahuan, Anda harus menghapus pangkalan pengetahuan apa pun yang mereferensikannya atau memperbarui definisi pangkalan pengetahuan untuk menghapus referensi. Untuk sumber pengetahuan yang menghasilkan indeks dan alur pengindeks, semua objek yang dihasilkan juga dihapus. Namun, jika Anda menggunakan indeks yang ada untuk membuat sumber pengetahuan, indeks Anda tidak dihapus.

Jika Anda mencoba menghapus sumber pengetahuan yang sedang digunakan, tindakan gagal dan mengembalikan daftar pangkalan pengetahuan yang terpengaruh.

Untuk menghapus sumber pengetahuan:

Konten terkait

• Pengambilan informasi berbasis Agentic dalam Pencarian Azure AI
• Apa itu sumber pengetahuan?
• Membuat pangkalan pengetahuan
• Mengkueri pangkalan pengetahuan
• Contoh Python: sumber pengetahuan Blob Pencarian Azure AI