Crie uma fonte de conhecimento de blob a partir do Armazenamento de Blobs do Azure ou ADLS Gen2

Uma fonte de conhecimento de blobs ingere conteúdo do Armazenamento de Blobs do Azure ou do ADLS Gen2 num pipeline de recuperação por agentes no Pesquisa de IA do Azure. As fontes de conhecimento são criadas de forma independente, referenciadas numa base de conhecimento e usadas como dados de base quando a base é consultada em tempo de execução.

Quando cria uma fonte de conhecimento de blob, especifica uma fonte de dados externa, modelos e propriedades para gerar automaticamente os seguintes objetos Pesquisa de IA do Azure:

• Uma fonte de dados que representa um contentor de blobs.
• Um conjunto de habilidades que segmenta e opcionalmente vetoriza conteúdo multimodal do contêiner.
• Um índice que armazena conteúdo enriquecido e cumpre os critérios para a recuperação agêntica.
• Um indexador que utiliza os objetos anteriores para gerir o pipeline de indexação e enriquecimento.

O indexador gerado conforma-se ao indexador blob, cujos pré-requisitos, formatos de documentos suportados e limitações também se aplicam às fontes de conhecimento blob. Para mais informações, consulte a documentação do indexador de blobs e os limites do indexador. Se o conjunto de competências gerado invocar um serviço externo, também se aplicam os limites de entrada e do serviço dessa competência.

Suporte de utilização

Pré-requisitos

• Um serviço Pesquisa de IA do Azure em qualquer região que forneça recuperação proativa.

• Uma conta Armazenamento de Blobs do Azure ou Azure Data Lake Storage (ADLS) Gen2.

• Um contentor de blob com tipos de conteúdo suportados para texto. Para a verbalização opcional da imagem, o tipo de conteúdo suportado depende do facto de o seu modelo de processamento de chat ser capaz de analisar e descrever o ficheiro de imagem.

• Se contentExtractionMode for , use um recurso do Microsoft Foundry numa https://<resource-name>.services.ai.azure.com com um ponto final standard. O recurso deve ter uma implementação de modelo de embedding e, se ativar a verbalização de imagens, uma implementação de modelo de chat multimodal.

• Permissão para criar fontes de conhecimento. Configure autenticação sem chave com os papéis de Contribuidor de Serviços de Pesquisa e Contribuidor de Dados do Índice de Pesquisa atribuídos à sua conta de utilizador (recomendado) ou utilize uma chave API de administrador.

• Uma identidade gerida para o serviço de pesquisa com o Storage Blob Data Reader no âmbito da conta de armazenamento de origem e o Cognitive Services User no recurso Microsoft Foundry. Se configurares um asset store numa conta de armazenamento diferente, atribui também o Storage Blob Data Contributor nesse âmbito de conta de armazenamento. Se os contentores de origem e de ativos partilharem a mesma conta, Storage Blob Data Contributor fornece acesso de leitura à origem e acesso de leitura/escrita ao armazenamento de ativos.

• Se definir networkAccessMode como private, cumpra os seguintes requisitos:

  • Use um serviço de pesquisa S2, S3, L1 ou L2.

  • Ative uma identidade gerida atribuída pelo sistema ou atribuída pelo utilizador no serviço de pesquisa, conceda-lhe a função Leitor de Dados de Blobs de Armazenamento na conta de armazenamento e utilize uma ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> cadeia de ligação. Para uma identidade atribuída pelo utilizador, também defina ingestionParameters.identity.

  • Crie e aprove um link privado partilhado para a conta de armazenamento com o blob ID do grupo. Para ADLS Gen2, crie e aprove as ligações privadas partilhadas blob e dfs.

  • Crie e aprove um link privado partilhado para cada endpoint de modelo protegido. Utilize o ID de grupo openai_account para os endpoints do Azure OpenAI e foundry_account para os endpoints de recursos do Foundry.

Verifique fontes de conhecimento existentes

Uma fonte de conhecimento é um objeto de topo e reutilizável. Conhecer as fontes de conhecimento existentes é útil tanto para reutilizar como para nomear novos objetos.

Execute o seguinte código para listar as fontes de conhecimento por nome e tipo.

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

Também pode devolver uma única fonte de conhecimento pelo nome para rever a sua definição em 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}}

O JSON seguinte é uma resposta de exemplo para uma fonte de conhecimento de 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"
    }
  }
}

Criar uma fonte de conhecimento

Corra o código seguinte para criar uma origem de conhecimento de blobs.

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

Restringir a ingestão a uma rede privada (pré-visualização)

A partir da versão 2026-08-01-preview da API, networkAccessMode controla o ambiente de rede em que o indexador gerado para uma origem de conhecimento de blobs é executado. Esta configuração afeta apenas a ingestão e não altera os pedidos ou respostas de recuperação da base de conhecimento.

networkAccessMode tem por defeito o valor public, o que preserva o comportamento existente da rede pública. Quando networkAccessMode é private, o indexador gerado executa-se no ambiente de execução privada. Utiliza ligações privadas partilhadas aprovadas para aceder ao Armazenamento de Blobs do Azure ou à ligação de origem ADLS Gen2 e dependências suportadas do Azure, como modelos OpenAI do Azure e recursos do Microsoft Foundry.

Para configurar e verificar o acesso à rede privada:

1. Cumpra os pré-requisitos da rede privada.

2. Definir networkAccessMode para private no pedido de criação de fonte de conhecimento. Só podes definir esta propriedade durante a criação. Para alterar mais tarde, apaga e recria a fonte do conhecimento.

   A criação pode falhar se o escalão de serviço ou o ambiente de execução não suportarem a execução privada, ou se não existir uma ligação privada partilhada obrigatória.

3. Confirme que o indexador executionEnvironment gerado é private.

4. Confirme que cada ligação privada partilhada necessária está aprovada e tem como alvo a dependência correta. A criação bem-sucedida por si só não confirma a aprovação ou o direcionamento dos links.

5. Verifique periodicamente o estado da fonte de conhecimento até que lastSynchronizationState.endTime tenha um valor. Confirme que itemsUpdatesFailed é 0, e depois verifique o conteúdo da fonte específica do conector. A sincronização falha se uma dependência não for acessível.

Verificar o estado da ingestão

Execute o seguinte código para monitorizar o progresso da ingestão e a saúde, incluindo o tipo de fonte de conhecimento e erros detalhados de indexação para fontes de conhecimento que geram um pipeline de indexadores e preenchem um índice de pesquisa.

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 

Uma resposta a um pedido que inclui parâmetros de ingestão e que está a ingerir conteúdo ativamente pode assemelhar-se ao seguinte exemplo.

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

Rever os objetos gerados

Ao criar esta fonte de conhecimento, o Pesquisa de IA do Azure gera automaticamente uma origem de dados, um conjunto de competências, um indexador e um índice. A resposta de criação lista cada objeto sob createdResources.

Estes objetos são gerados de acordo com um modelo fixo, e os seus nomes baseiam-se no nome da fonte de conhecimento. Não podes mudar os nomes dos objetos. Evite editar estes objetos diretamente, pois alterações podem introduzir erros ou incompatibilidades que quebram o pipeline do indexador.

Podes usar o portal do Azure para validar a criação de objetos. O fluxo de trabalho é:

1. Verifique o indexador para mensagens de sucesso ou fracasso. Erros de conexão ou de cota aparecem aqui.

2. Verifique a fonte dos dados para verificar a ligação ao seu armazenamento de dados. A ligação utiliza uma cadeia de ligação ou uma identidade gerida, dependendo de como configuraste a fonte de conhecimento.

3. Verifica o conjunto de competências para ver como o teu conteúdo é segmentado em blocos e, opcionalmente, vetorizado.

4. Verifique o índice para ver como o seu conteúdo é indexado e exposto para recuperação, incluindo quais os campos pesquisáveis e filtráveis e quais armazenam vetores para pesquisa por similaridade. Use o Explorador de Pesquisa para realizar consultas no índice gerado.

Atribuir a uma base de conhecimento

Se estiver satisfeito com a fonte de conhecimento, adicione-a a uma base de conhecimento.

Consultar uma base de conhecimento

Depois de configurar a base de conhecimento, chama a ação de recuperação ou o endpoint MCP para consultar a fonte de conhecimento. Escolhe a configuração que corresponde ao teu cenário.

Aplicar permissões ao nível do documento (pré-visualização)

Para impor permissões ao nível do documento, defina ingestionPermissionOptions ao criar esta fonte de informações e depois inclua o token de acesso do utilizador na solicitação de recuperação. Para mais informações, consulte Impor permissões no momento da consulta (pré-visualização).

Imagens incorporadas em documentos Surface (pré-visualização)

Para apresentar imagens incorporadas nos documentos (como diagramas ou digitalizações) nas respostas de síntese, configure assetStore nesta fonte de conhecimento e, em seguida, ative a disponibilização de imagens na base de conhecimento. A disponibilização de imagens não é suportada quando ingestionPermissionOptions está configurado. Para mais informações, veja Mostrar imagens incorporadas em documentos na recuperação agêntica (pré-visualização).

Eliminar uma fonte de conhecimento

Antes de poder eliminar uma fonte de conhecimento, deve eliminar qualquer base de conhecimento que a faça referência ou atualizar a definição da base de conhecimento para remover a referência. Para fontes de conhecimento que geram um pipeline de índice e indexador, todos os objetos gerados também são eliminados. No entanto, se usou um índice existente para criar uma fonte de conhecimento, o seu índice não é eliminado.

Se tentar eliminar uma fonte de conhecimento que está em uso, a ação falha e devolve uma lista das bases de conhecimento afetadas.

Para eliminar uma fonte de conhecimento:

Conteúdo relacionado

• Busca de agência no Pesquisa de IA do Azure
• O que é uma fonte de conhecimento?
• Crie uma base de conhecimento
• Consultar uma base de conhecimento
• Exemplo em Python: origem de conhecimento de blobs do Pesquisa de IA do Azure