Utwórz źródło wiedzy typu blob z Azure Blob Storage lub ADLS Gen2

Źródło wiedzy obiektów blob pozyskuje zawartość z usługi Azure Blob Storage lub ADLS Gen2 do agentowego potoku wyszukiwania w usłudze Wyszukiwanie AI platformy Azure. Źródła wiedzy są tworzone niezależnie, przywoływane w bazie wiedzy i używane jako dane uziemienia, gdy baza wiedzy jest odpytywane w czasie wykonywania zapytań.

Podczas tworzenia źródła wiedzy obiektu blob należy określić zewnętrzne źródło danych, modele i właściwości, aby automatycznie wygenerować następujące obiekty Wyszukiwanie AI platformy Azure:

• Źródło danych reprezentujące kontener blobów.
• Zestaw umiejętności, który fragmentuje i opcjonalnie wektoryzuje zawartość wielomodalną z kontenera.
• Indeks, który przechowuje wzbogaconą treść i spełnia kryteria odbioru przez system agenta.
• Indeksator, który używa poprzednich obiektów do napędzania potoku indeksowania i wzbogacania.

Wygenerowany indeksator jest zgodny z indeksatorem obiektów blob, którego wymagania wstępne, obsługiwane formaty dokumentów i ograniczenia dotyczą również źródeł wiedzy obiektów blob. Więcej informacji znajduje się w dokumentacji indeksatora obiektów blob i limitach indeksatora. Jeśli wygenerowany zestaw umiejętności wywołuje usługę zewnętrzną, zastosowanie mają również limity danych wejściowych tej umiejętności i limity usługi.

Wsparcie użytkowania

Wymagania wstępne

• Usługa Wyszukiwanie AI platformy Azure w dowolnym regionie, która zapewnia autonomiczne wyszukiwanie.

• Konto Azure Blob Storage lub Azure Data Lake Storage (ADLS) Gen2.

• Kontener obiektów blob z obsługiwanymi typami zawartości dla zawartości tekstowej. W przypadku opcjonalnej werbalizacji obrazów obsługiwany typ zawartości zależy od tego, czy model uzupełniania czatu może analizować i opisywać plik obrazu.

• Jeśli contentExtractionMode to standard, użyj zasobu Microsoft Foundry w regionie obsługiwanym przez funkcję Content Understanding w narzędziach Foundry z https://<resource-name>.services.ai.azure.com punktem końcowym. Zasób musi mieć wdrożenie modelu osadzeń oraz — jeśli włączysz funkcję werbalizacji obrazów — wdrożenie wielomodalnego modelu czatu.

• Uprawnienie do tworzenia źródeł wiedzy. Skonfiguruj uwierzytelnianie bez klucza przy użyciu ról Współautor usługi wyszukiwania i Współautor danych indeksu wyszukiwania przypisanych do konta użytkownika (zalecane) lub użyj klucza interfejsu API administratora.

• Tożsamość zarządzana dla usługi wyszukiwania z rolą Czytelnik danych obiektów blob usługi Storage w zakresie źródłowego konta magazynu oraz z rolą Użytkownik usług Cognitive Services w zasobie Microsoft Foundry. Jeśli skonfigurujesz magazyn zasobów dla innego konta magazynu, przypisz również rolę Współautor danych obiektu blob usługi Storage na poziomie tego konta magazynu. Jeśli kontenery źródłowy i zasobów należą do tego samego konta, Storage Blob Data Contributor zapewnia zarówno dostęp do odczytu ze źródła, jak i dostęp do odczytu i zapisu w magazynie zasobów.

• Jeśli ustawisz networkAccessMode na private, upewnij się, że spełniono następujące wymagania:

  • Użyj usługi wyszukiwania S2, S3, L1 lub L2.

  • Włącz tożsamość zarządzaną przypisaną przez system lub przez użytkownika dla usługi wyszukiwania, przyznaj jej rolę Czytelnik danych obiektu blob usługi Storage na koncie magazynu i użyj parametrów połączenia ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>. W przypadku tożsamości przypisanej przez użytkownika ustaw również wartość ingestionParameters.identity.

  • Utwórz i zatwierdź udostępniony prywatny link do konta magazynu przy użyciu identyfikatora blob grupy. W przypadku usługi ADLS Gen2 utwórz i zatwierdź oba udostępnione linki prywatne: blob i dfs.

  • Utwórz i zatwierdź udostępniony link prywatny dla każdego chronionego punktu końcowego modelu. Użyj openai_account jako identyfikatora grupy dla punktów końcowych Azure OpenAI oraz foundry_account dla punktów końcowych zasobów Foundry.

Sprawdzanie istniejących źródeł wiedzy

Źródłem wiedzy jest obiekt najwyższego poziomu wielokrotnego użytku. Znajomość istniejących źródeł wiedzy jest przydatna w przypadku ponownego użycia lub nazewnictwa nowych obiektów.

Uruchom następujący kod, aby wyświetlić listę źródeł wiedzy według nazwy i typu.

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

Możesz również zwrócić pojedyncze źródło wiedzy według nazwy, aby przejrzeć jego definicję JSON.

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

Następujący plik JSON to przykładowa odpowiedź z obiektu wiedzy typu 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"
    }
  }
}

Tworzenie źródła wiedzy

Uruchom następujący kod, aby utworzyć źródło wiedzy typu 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
    }
  }
}

Ogranicz pozyskiwanie danych do sieci prywatnej (wersja zapoznawcza)

Począwszy od wersji interfejsu API 2026-08-01-preview, element networkAccessMode steruje środowiskiem sieciowym, w którym jest uruchamiany wygenerowany indeksator dla źródła wiedzy obiektu blob. To ustawienie wpływa tylko na indeksowanie i nie zmienia żądań ani odpowiedzi pobierania z bazy wiedzy.

networkAccessMode wartość domyślna to public, która zachowuje istniejące zachowanie sieci publicznej. Gdy parametr networkAccessMode ma wartość private, wygenerowany indeksator działa w prywatnym środowisku wykonywania. Używa zatwierdzonych współużytkowanych łączy prywatnych do uzyskiwania dostępu do źródłowego połączenia z usługą Azure Blob Storage lub ADLS Gen2 oraz do obsługiwanych zależności platformy Azure, takich jak modele usługi Azure OpenAI i zasoby Microsoft Foundry.

Aby skonfigurować i zweryfikować dostęp do sieci prywatnej:

1. Wypełnij wymagania wstępne dotyczące sieci prywatnej.

2. Ustaw networkAccessMode na private w żądaniu utworzenia źródła wiedzy. Tę właściwość można ustawić tylko podczas tworzenia. Aby zmienić je później, usuń i ponownie utwórz źródło wiedzy.

   Tworzenie może zakończyć się niepowodzeniem, jeśli warstwa usługi lub środowisko uruchomieniowe nie obsługuje wykonywania prywatnego lub jeśli wymagany udostępniony link prywatny nie istnieje.

3. Upewnij się, że wygenerowany indeksator executionEnvironment ma wartość private.

4. Upewnij się, że każde wymagane współdzielone łącze prywatne zostało zatwierdzone i wskazuje właściwą zależność. Samo pomyślne utworzenie nie potwierdza zatwierdzenia linku ani kierowania.

5. Sonduj stan źródła wiedzy, dopóki lastSynchronizationState.endTime nie ma wartości. Potwierdź, że itemsUpdatesFailed to 0, a następnie zweryfikuj zawartość źródłową związaną z danym łącznikiem. Synchronizacja kończy się niepowodzeniem, jeśli zależność nie jest osiągalna.

Korzystanie z automatycznych analizatorów dla poszczególnych języków (wersja zapoznawcza)

Od wersji interfejsu API 2026-08-01-preview automatyczne analizatory specyficzne dla języka są dostępne dla obiektów blob, indeksowanych źródeł wiedzy usługi OneLake oraz indeksowanych źródeł wiedzy programu SharePoint. Po włączeniu Wyszukiwanie AI platformy Azure wykrywa język każdego dokumentu źródłowego i automatycznie stosuje zgodny analizator języka Microsoft. Nie określasz analizatora w definicji źródła wiedzy ani w zapytaniu.

Aby włączyć automatyczne analizatory dla każdego języka, ustaw element contentExtractionMode na minimal i skonfiguruj ingestionParameters.aiServices w definicji źródła wiedzy.

W przypadku uwierzytelniania bez klucza pomiń aiServices.apiKey i przypisz rolę użytkownika usług Cognitive Services w zasobie usługi Microsoft Foundry do tożsamości zarządzanej usługi wyszukiwania. W przypadku uwierzytelniania opartego na kluczach ustaw wartość aiServices.apiKey na prawidłowy klucz dla zasobu Foundry.

Obsługiwane są następujące języki:

• angielski
• Japoński
• Francuski
• Hiszpański
• Niemiecki
• Niderlandzki
• Włoski
• Portugalski (Brazylia)
• portugalski (europejski)
• Chiński (uproszczony)
• Chiński tradycyjny
• Koreański

W przypadku zawartości wielojęzycznej Wyszukiwanie AI platformy Azure wybiera analizator na podstawie głównie wykrytego języka. Używa standardowego analizatora, gdy język nie jest obsługiwany lub nie można go jednoznacznie określić.

Po włączeniu automatycznych analizatorów dla poszczególnych języków Wyszukiwanie AI platformy Azure dodaje pola zawartości specyficzne dla języka dla każdego obsługiwanego języka do wygenerowanego schematu indeksu, niezależnie od tego, czy dane zawierają dokumenty w tych językach. Podczas przetwarzania dokumenty są kierowane do odpowiedniego pola właściwego dla danego języka na podstawie wykrytego języka.

Nieużywane pola języka nie zawierają indeksowanej zawartości i mają minimalny wpływ na magazyn, ale pozostają częścią schematu indeksu i są liczone do limitu pól indeksu. Podczas planowania projektu indeksu, liczby pól i wymagań dotyczących magazynu należy wziąć pod uwagę dodatkowe pola. Aby uzyskać więcej informacji, zobacz Limity indeksów i Szacowanie pojemności usługi wyszukiwania i zarządzanie nią.

Wykrywanie języka jest płatne po wykorzystaniu bezpłatnego limitu wzbogacania AI. Aby uzyskać więcej informacji, zobacz Bezpłatne wzbogacania.

Sprawdź stan importowania danych

Uruchom następujący kod, aby monitorować postęp przetwarzania danych i kondycję, w tym rodzaj źródła wiedzy i szczegółowe błędy indeksowania dla źródeł wiedzy, które generują potok indeksatora i tworzą indeks wyszukiwania.

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 

Odpowiedź na żądanie, która zawiera parametry pozyskiwania i aktywnie pozyskuje zawartość, może wyglądać jak poniższy przykład.

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

Przeglądanie wygenerowanych obiektów

Podczas tworzenia tego źródła wiedzy Wyszukiwanie AI platformy Azure automatycznie generuje źródło danych, zestaw umiejętności, indeksator i indeks. Odpowiedź na żądanie utworzenia wymienia każdy obiekt pod elementem createdResources.

Te obiekty są generowane zgodnie z ustalonym szablonem, a ich nazwy są oparte na nazwie źródła wiedzy. Nie można zmienić nazw obiektów. Unikaj bezpośredniego edytowania tych obiektów, ponieważ zmiany mogą powodować błędy lub niezgodności, które przerywają potok indeksatora.

Aby zweryfikować tworzenie obiektów, możesz użyć portalu Azure. Przepływ pracy to:

1. Sprawdź indeksator pod kątem komunikatów o powodzeniu lub niepowodzeniu. Błędy połączenia lub limitu przydziału są wyświetlane tutaj.

2. Sprawdź źródło danych, aby zweryfikować połączenie z magazynem danych. Połączenie używa albo parametru połączenia, albo tożsamości zarządzanej, w zależności od tego, jak skonfigurowano źródło wiedzy.

3. Sprawdź zestaw umiejętności, aby zobaczyć, jak treść jest dzielona na fragmenty i opcjonalnie wektoryzowana.

4. Sprawdź indeks, aby zobaczyć, jak zawartość jest indeksowana i uwidoczniona na potrzeby pobierania, w tym pola, które można przeszukiwać i filtrować oraz które pola przechowują wektory na potrzeby wyszukiwania podobieństwa. Użyj Eksploratora wyszukiwania, aby uruchamiać zapytania względem wygenerowanego indeksu.

Przypisywanie do bazy wiedzy

Jeśli źródło wiedzy jest zadowalające, dodaj je do bazy wiedzy.

Wykonywanie zapytań w bazie wiedzy

Po skonfigurowaniu bazy wiedzy wywołaj akcję pobierania lub punkt końcowy MCP , aby wykonać zapytanie względem źródła wiedzy. Wybierz konfigurację zgodną ze scenariuszem.

Wymuszanie uprawnień na poziomie dokumentu (wersja zapoznawcza)

Aby wymusić uprawnienia na poziomie dokumentu, ustaw ingestionPermissionOptions podczas tworzenia tego źródła wiedzy, a następnie dołącz token dostępu użytkownika do żądania pobierania. Aby uzyskać więcej informacji, zobacz Wymuszanie uprawnień w czasie zapytania (wersja zapoznawcza).

Wyświetlanie obrazów osadzonych w dokumentach (wersja zapoznawcza)

Aby uwzględniać obrazy osadzone w dokumentach (takie jak diagramy lub skany) w odpowiedziach generowanych przez syntezę odpowiedzi, skonfiguruj assetStore w tym źródle wiedzy, a następnie włącz udostępnianie obrazów w bazie wiedzy. Dostarczanie obrazów nie jest obsługiwane, gdy skonfigurowano ingestionPermissionOptions. Aby uzyskać więcej informacji, zobacz Wyświetlanie obrazów osadzonych w dokumentach w wyszukiwaniu agentowym (wersja zapoznawcza).

Usuwanie źródła wiedzy

Aby można było usunąć źródło wiedzy, należy usunąć dowolną bazę wiedzy, która odwołuje się do źródła wiedzy, lub zaktualizować definicję bazy wiedzy, aby usunąć odwołanie. W przypadku źródeł wiedzy, które generują potok indeksu i indeksatora, wszystkie wygenerowane obiekty również są usuwane. Jeśli jednak użyto istniejącego indeksu do utworzenia źródła wiedzy, indeks nie zostanie usunięty.

Jeśli spróbujesz usunąć używane źródło wiedzy, akcja zakończy się niepowodzeniem i zwróci listę baz wiedzy, których dotyczy problem.

Aby usunąć źródło wiedzy:

Powiązana zawartość

• Pobieranie przy użyciu agentów w Wyszukiwanie AI platformy Azure
• Co to jest źródło wiedzy?
• Tworzenie bazy wiedzy
• Wykonywanie zapytań względem bazy wiedzy
• Przykład w Pythonie: źródło wiedzy Wyszukiwanie AI platformy Azure dla obiektów blob