Creación de un origen de conocimiento de blobs desde Azure Blob Storage o ADLS Gen2

Una fuente de conocimientos de blobs ingiere contenido de Azure Blob Storage o ADLS Gen2 en una canalización de recuperación de agentes en Búsqueda de Azure AI. Los orígenes de conocimiento se crean de forma independiente, se hace referencia en una base de conocimiento y se usan como datos de base cuando se consulta la base de conocimiento en tiempo de ejecución.

Al crear un origen de conocimiento de blobs, especifique un origen de datos externo, modelos y propiedades para generar automáticamente los siguientes objetos Búsqueda de Azure AI:

• Origen de datos que representa un contenedor de blobs.
• Conjunto de habilidades que fragmenta y, opcionalmente, vectoriza el contenido multimodal del contenedor.
• Índice que almacena contenido enriquecido y cumple los criterios para la recuperación agencial.
• Indexador que emplea los objetos anteriores para impulsar la tubería de indexación y enriquecimiento.

El indexador generado se ajusta al indexador de blobs, cuyos requisitos previos, formatos de documento admitidos y limitaciones también se aplican a los orígenes de conocimiento de blobs. Para más información, consulte la documentación del indexador de blobs y los límites del indexador. Si el conjunto de aptitudes generado llama a un servicio externo, también se aplican los límites de entrada y servicio de esa aptitud.

Soporte para el uso

Requisitos previos

• Un servicio de Búsqueda de Azure AI en cualquier región que proporcione recuperación mediante agentes.

• Una cuenta de Azure Blob Storage o Azure Data Lake Storage (ADLS) Gen2.

• Un contenedor de blobs con tipos de contenido admitidos para el contenido de texto. Para la verbalización de imágenes opcional, el tipo de contenido admitido depende de si el modelo de finalización del chat puede analizar y describir el archivo de imagen.

• Si contentExtractionMode es standard, use un recurso de Microsoft Foundry en una región admitida por Content Understanding en Foundry Tools con un punto de conexión https://<resource-name>.services.ai.azure.com. El recurso debe tener una implementación de modelo de incrustación y, si habilitas la verbalización de imágenes, una implementación de modelo de chat multimodal.

• Permiso para crear orígenes de conocimiento. Configure la autenticación sin clave con los roles Colaborador del servicio de búsqueda y Colaborador de datos del índice de búsqueda asignados a su cuenta de usuario (recomendado) o use una clave de API de administrador.

• Una identidad administrada para el servicio de búsqueda con Lector de datos de blobs de almacenamiento en el ámbito de la cuenta de almacenamiento de origen y Usuario de Cognitive Services en el recurso de Microsoft Foundry. Si configura un almacén de activos en una cuenta de almacenamiento diferente, asigne también Storage Blob Data Contributor en el ámbito de esa cuenta de almacenamiento. Si los contenedores de origen y de recursos comparten una cuenta, Colaborador de datos de Storage Blob proporciona tanto acceso de lectura al origen como acceso de lectura y escritura al almacén de recursos.

• Si establece networkAccessMode en private, complete los siguientes requisitos:

  • Use un servicio de búsqueda S2, S3, L1 o L2.

  • Habilite una identidad administrada asignada por el sistema o asignada por el usuario en el servicio de búsqueda, concédale el rol Lector de datos de Storage Blob en la cuenta de almacenamiento y use un ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account> cadena de conexión. Para una identidad asignada por el usuario, establezca también ingestionParameters.identity.

  • Cree y apruebe un enlace privado compartido para la cuenta de almacenamiento con el identificador de grupo blob. Para ADLS Gen2, cree y apruebe ambos enlaces privados compartidos, blob y dfs.

  • Cree y apruebe un vínculo privado compartido para cada punto de conexión de modelo protegido. Use el identificador del grupo openai_account para los puntos de conexión de Azure OpenAI y foundry_account para los puntos de conexión del recurso de Foundry.

Comprobación de orígenes de conocimiento existentes

Un origen de conocimiento es un objeto reutilizable de nivel superior. Conocer los orígenes de conocimiento existentes resulta útil para reutilizar o asignar nombres a nuevos objetos.

Ejecute el código siguiente para enumerar los orígenes de conocimiento por nombre y 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}}

También puede devolver un único origen de conocimiento por nombre para revisar la definición JSON de este.

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

El siguiente json es una respuesta de ejemplo para un origen de conocimiento de blobs.

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

Creación de un origen de conocimiento

Ejecute el código siguiente para crear un origen de conocimiento 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
    }
  }
}

Restricción de la ingesta a una red privada (versión preliminar)

A partir de la versión de la 2026-08-01-preview API, networkAccessMode controla el entorno de red en el que se ejecuta el indexador generado para un origen de conocimiento de blobs. Esta configuración solo afecta a la ingesta y no modifica las solicitudes ni las respuestas de recuperación de la base de conocimiento.

networkAccessMode tiene como valor predeterminado public, lo que conserva el comportamiento de red pública existente. Cuando networkAccessMode es private, el indexador generado se ejecuta en el entorno de ejecución privado. Usa vínculos privados compartidos aprobados para acceder a la conexión de origen de Azure Blob Storage o ADLS Gen2 y las dependencias de Azure compatibles, como Azure modelos openAI y recursos de Microsoft Foundry.

Para configurar y comprobar el acceso a la red privada:

1. Complete los requisitos previos de la red privada.

2. Establezca private en networkAccessMode en la solicitud de creación de la fuente de conocimiento. Esta propiedad solo se puede establecer al crearla. Para cambiarlo más adelante, elimine y vuelva a crear el origen de conocimiento.

   Se puede producir un error en la creación si el nivel de servicio o el entorno de ejecución no admiten la ejecución privada o si no existe un vínculo privado compartido necesario.

3. Confirme que el indexador executionEnvironment generado es private.

4. Confirme que se aprueba cada vínculo privado compartido necesario y tiene como destino la dependencia correcta. La creación correcta por sí sola no confirma la aprobación ni el destino de los vínculos.

5. Consulte el estado de la fuente de conocimiento hasta que lastSynchronizationState.endTime tenga un valor. Confirme que itemsUpdatesFailed es 0y compruebe el contenido de origen específico del conector. Se produce un error en la sincronización si no se puede acceder a una dependencia.

Uso de analizadores automáticos por idioma (versión preliminar)

A partir de la 2026-08-01-previewversión de la API, hay disponibles analizadores automáticos por idioma para fuentes de conocimiento de blob, OneLake indexado y SharePoint indexado. Cuando está habilitada, Búsqueda de Azure AI detecta el idioma de cada documento de origen y aplica automáticamente un analizador de idioma Microsoft coincidente. No se especifica un analizador en la definición del origen de conocimiento ni en una consulta.

Para habilitar analizadores automáticos por idioma, establezca contentExtractionMode en minimal y configure ingestionParameters.aiServices en la definición del origen de conocimiento.

Para la autenticación sin claves, omita aiServices.apiKey y asigne el rol de usuario de Cognitive Services en el recurso Microsoft Foundry a la identidad administrada del servicio de búsqueda. Para la autenticación basada en claves, establezca en aiServices.apiKey una clave válida para el recurso Foundry.

Se admiten los siguientes idiomas:

• Inglés
• Japanese
• Francés
• Español
• Alemán
• Neerlandés
• Italian
• Portugués (Brasil)
• Portugués europeo
• Chino simplificado
• Chino tradicional
• Korean

Para el contenido multilingüe, Búsqueda de Azure AI selecciona un analizador en función del idioma detectado predominante. Usa el analizador estándar cuando el idioma no es compatible o no es seguro.

Al habilitar analizadores automáticos por idioma, Búsqueda de Azure AI agrega campos de contenido específicos del idioma para cada idioma admitido al esquema de índice generado, tanto si los datos contienen documentos en esos idiomas como si no. Durante la ingesta, los documentos se dirigen al campo específico del idioma correspondiente según el idioma detectado.

Los campos de lenguaje sin usar no contienen contenido indizado y tienen un impacto mínimo en el almacenamiento, pero siguen formando parte del esquema de índice y cuentan para el límite de campos de índice. Tenga en cuenta los campos adicionales al planear el diseño del índice, el recuento de campos y los requisitos de almacenamiento. Para más información, consulte Límites de índice y Estimación y administración de la capacidad de un servicio de búsqueda.

La detección de idioma se factura después de la asignación gratuita de enriquecimiento con IA. Para obtener más información, consulte Enriquecimientos gratuitos.

Comprobación del estado de la ingesta

Ejecute el código siguiente para supervisar el progreso y el estado de la ingesta, incluidos el tipo de origen de conocimiento y los errores de indexación detallados para los orígenes de conocimiento que generan una canalización del indexador y rellenan un índice de búsqueda.

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 

Una respuesta para una solicitud que incluye parámetros de ingesta y que está ingeriendo contenido activamente podría ser similar al ejemplo siguiente.

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

Revisión de los objetos generados

Al crear este origen de conocimiento, Búsqueda de Azure AI genera automáticamente un origen de datos, un conjunto de aptitudes, un indexador y un índice. La respuesta de creación enumera cada objeto en createdResources.

Estos objetos se generan según una plantilla fija y sus nombres se basan en el nombre del origen de conocimiento. No se pueden cambiar los nombres de objeto. Evite editar estos objetos directamente, ya que los cambios pueden introducir errores o incompatibilidades que interrumpen la canalización del indexador.

Puede usar el portal de Azure para validar la creación de objetos. El flujo de trabajo es:

1. Compruebe si el indexador tiene mensajes correctos o erróneos. Los errores de conexión o cuota aparecen aquí.

2. Compruebe el origen de datos para comprobar la conexión con el almacén de datos. La conexión utiliza una cadena de conexión o una identidad administrada, según cómo hayas configurado el origen de conocimiento.

3. Compruebe el conjunto de habilidades para ver cómo se fragmenta su contenido y, opcionalmente, cómo se vectoriza.

4. Compruebe el índice para ver cómo se indexa y expone el contenido para la recuperación, incluidos los campos que se pueden buscar y filtrar y qué campos almacenan vectores para la búsqueda de similitud. Use el Explorador de búsqueda para ejecutar consultas en el índice generado.

Asignar a una base de conocimiento

Si está satisfecho con el origen de conocimiento, agréguelo a una base de conocimiento.

Consulta de una base de conocimiento

Después de configurar la base de conocimiento, llame a la acción de recuperación o al punto de conexión de MCP para consultar el origen de conocimiento. Elija la configuración que coincida con el escenario.

Aplicación de permisos de nivel de documento (versión preliminar)

Para aplicar permisos de nivel de documento, establezca ingestionPermissionOptions al crear este origen de conocimiento y, a continuación, incluya el token de acceso del usuario en la solicitud de recuperación. Para obtener más información, consulte Aplicar permisos en tiempo de consulta (versión preliminar).

Mostrar imágenes incrustadas en documentos (versión preliminar)

Para mostrar imágenes incrustadas en documentos (como diagramas o escaneos) en las respuestas de síntesis, configure assetStore en este origen de conocimiento y, a continuación, habilite la publicación de imágenes en la base de conocimiento. El servicio de imágenes no es compatible cuando se configura ingestionPermissionOptions. Para obtener más información, consulte Mostrar imágenes incrustadas en documentos en recuperación de agentes (versión preliminar).

Eliminación de un origen de conocimiento

Para poder eliminar un origen de conocimiento, debe eliminar cualquier base de conocimiento que haga referencia a ella o actualizar la definición de la base de conocimiento para quitar la referencia. En el caso de los orígenes de conocimiento que generan una canalización de índice e indexador, también se eliminan todos los objetos generados . Sin embargo, si usó un índice existente para crear un origen de conocimiento, el índice no se eliminará.

Si intenta eliminar un origen de conocimiento que está en uso, se produce un error en la acción y devuelve una lista de bases de conocimiento afectadas.

Para eliminar un origen de conocimiento:

Contenido relacionado

• Recuperación de agentes en Azure AI Search
• ¿Qué es un origen de conocimiento?
• Creación de una base de conocimiento
• Consulta de una base de conocimiento
• Ejemplo de Python: origen de conocimiento de blobs de Búsqueda de Azure AI