Crea una fonte di conoscenza BLOB da Archiviazione BLOB di Azure o ADLS Gen2

Una fonte di conoscenza BLOB acquisisce contenuti provenienti da Archiviazione BLOB di Azure o ADLS Gen2 in una pipeline di recupero basata su agenti in Azure AI Search. Le origini delle informazioni vengono create in modo indipendente, a cui viene fatto riferimento in una Knowledge Base e usate come dati di base quando viene eseguita una query sulla Knowledge Base in fase di esecuzione.

Quando si crea un'origine BLOB della fonte di conoscenza, si specifica un'origine dati esterna, i modelli e le proprietà per generare automaticamente i seguenti oggetti di Azure AI Search:

• Origine dati che rappresenta un contenitore BLOB.
• Set di competenze che suddivide e, facoltativamente, vettorizza il contenuto multimodale dal contenitore.
• Indice che archivia il contenuto arricchito e soddisfa i criteri per il recupero agentico.
• Indicizzatore che usa gli oggetti precedenti per guidare la pipeline di indicizzazione e arricchimento.

L'indicizzatore generato è conforme all'indicizzatore BLOB, i cui prerequisiti, i formati di documento supportati e le limitazioni si applicano anche alle origini delle informazioni BLOB. Per altre informazioni, vedere la documentazione dell'indicizzatore BLOB e i limiti dell'indicizzatore. Se il set di competenze generato chiama un servizio esterno, si applicano anche i limiti di input e servizio della competenza.

Supporto per l'utilizzo

Prerequisiti

• Servizio di Ricerca con intelligenza artificiale di Azure disponibile in qualsiasi area che supporta il recupero tramite agenti autonomi.

• Un account Archiviazione BLOB di Azure o Azure Data Lake Storage (ADLS) Gen2.

• Contenitore BLOB con tipi di contenuto supportati per il contenuto di testo. Per la verbalizzazione facoltativa delle immagini, il tipo di contenuto supportato dipende dal fatto che il modello di completamento della chat possa analizzare e descrivere il file di immagine.

• Se contentExtractionMode è standard, usa una risorsa Microsoft Foundry in una area geografica supportata da Content Understanding in Foundry Tools con un endpoint https://<resource-name>.services.ai.azure.com. La risorsa deve avere una distribuzione di un modello di incorporamento e, se si abilita la verbalizzazione delle immagini, una distribuzione di un modello di chat multimodale.

• Autorizzazione per la creazione di origini delle informazioni. Configurare l'autenticazione senza chiave con i ruoli Collaboratore servizio di ricerca e Collaboratore ai dati dell'indice di ricerca assegnati all'account utente (scelta consigliata) o usare una chiave API di amministrazione.

• Un'identità gestita per il servizio di ricerca con Storage Blob Data Reader nell'ambito dell'account di archiviazione di origine e Cognitive Services User sulla risorsa Microsoft Foundry. Se si configura un archivio asset in un account di archiviazione diverso, assegnare anche il collaboratore dati BLOB di archiviazione all'ambito di tale account di archiviazione. Se il contenitore di origine e quello dell'asset appartengono allo stesso account, Storage Blob Data Contributor fornisce sia l'accesso in lettura all'origine sia l'accesso in lettura/scrittura all'archivio delle risorse.

• Se imposti networkAccessMode su private, completa i requisiti seguenti:

  • Usare un servizio di ricerca S2, S3, L1 o L2.

  • Abilitare un'identità gestita assegnata dal sistema o dall'utente sul servizio di ricerca, concederle il ruolo Storage Blob Data Reader nell'account di archiviazione e usare una stringa di connessione ResourceId=/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>. Per un'identità assegnata dall'utente, impostare anche ingestionParameters.identity.

  • Crea e approva un link privato condiviso all'account di archiviazione con l'ID gruppo blob. Per ADLS Gen2, crea e approva sia blob che dfs collegamenti privati condivisi.

  • Creare e approvare un collegamento privato condiviso per ogni endpoint del modello protetto. Usare l'ID di gruppo openai_account per gli endpoint Azure OpenAI e foundry_account per gli endpoint delle risorse Foundry.

Verificare la presenza di fonti di conoscenza esistenti

Un'origine delle conoscenze è un oggetto riutilizzabile di primo livello. Conoscere le origini conoscenze esistenti è utile per riutilizzare o denominare nuovi oggetti.

Eseguire il codice seguente per elencare le origini delle informazioni in base al nome e al 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}}

Puoi anche restituire una singola fonte di conoscenza per nome per esaminarne la definizione 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}}

Il codice JSON seguente è una risposta di esempio per un'origine delle informazioni 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"
    }
  }
}

Creare una fonte di conoscenza

Esegui il codice seguente per creare un'origine di conoscenza 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
    }
  }
}

Limitare l'inserimento a una rete privata (anteprima)

A partire dalla versione API 2026-08-01-preview, networkAccessMode controlla l'ambiente di rete in cui viene eseguito l'indicizzatore generato per una fonte delle informazioni blob. Questa impostazione influisce solo sull'acquisizione e non modifica le richieste o le risposte di recupero della base di conoscenza.

networkAccessMode l'impostazione predefinita è public, che mantiene il comportamento di rete pubblica esistente. Quando networkAccessMode è private, l'indicizzatore generato viene eseguito nell'ambiente di esecuzione privata. Usa collegamenti privati condivisi approvati per accedere alla connessione di origine di Archiviazione BLOB di Azure o ADLS Gen2 e alle dipendenze supportate Azure, ad esempio Azure modelli OpenAI e risorse Microsoft Foundry.

Per configurare e verificare l'accesso alla rete privata:

1. Completare i prerequisiti della rete privata.

2. Impostare networkAccessMode su private nella richiesta di creazione dell'origine dati della knowledge base. È possibile impostare questa proprietà solo durante la creazione. Per modificarla successivamente, eliminare e ricreare l'origine della conoscenza.

   La creazione può avere esito negativo se il livello di servizio o il runtime non supporta l'esecuzione privata o se non esiste un collegamento privato condiviso richiesto.

3. Verificare che l'indicizzatore executionEnvironment generato sia private.

4. Verificare che ogni collegamento privato condiviso richiesto sia approvato e che sia destinato alla dipendenza corretta. La creazione con esito positivo non conferma l'approvazione o la destinazione del collegamento.

5. Monitorare lo stato della fonte delle informazioni finché lastSynchronizationState.endTime non assume un valore. Verificare che itemsUpdatesFailed sia 0e quindi verificare il contenuto di origine specifico del connettore. La sincronizzazione non riesce se una dipendenza non è raggiungibile.

Usare analizzatori automatici per linguaggio (anteprima)

A partire dalla versione API 2026-08-01-preview, sono disponibili analizzatori automatici specifici per lingua per le fonti delle informazioni blob, OneLake indicizzate e SharePoint indicizzate. Se abilitata, Azure AI Search rileva la lingua di ogni documento di origine e applica automaticamente un analizzatore del linguaggio Microsoft corrispondente. Non si specifica un analizzatore nella definizione di un'origine dati o in una query.

Per abilitare gli analizzatori automatici specifici per lingua, impostare contentExtractionMode su minimal e configurare ingestionParameters.aiServices nella definizione dell'origine della conoscenza.

Per l'autenticazione senza chiave, omettere aiServices.apiKey e assegnare il ruolo utente di Servizi cognitivi nella risorsa Microsoft Foundry all'identità gestita del servizio di ricerca. Per l'autenticazione basata su chiave, impostare su aiServices.apiKey una chiave valida per la risorsa Foundry.

Sono supportate le lingue seguenti:

• Italiano
• Japanese
• Francese
• Spagnolo
• Tedesco
• Olandese
• Italian
• Portoghese brasiliano
• Portoghese europeo
• Cinese semplificato
• Cinese tradizionale
• Coreano

Per il contenuto multilingue, Azure AI Search seleziona un analizzatore in base alla lingua rilevata predominante. Usa l'analizzatore standard quando la lingua non è supportata o incerta.

Quando si abilitano gli analizzatori automatici per linguaggio, Azure AI Search aggiunge campi di contenuto specifici della lingua per ogni lingua supportata allo schema dell'indice generato, indipendentemente dal fatto che i dati contengano documenti in tali lingue. Durante l'inserimento, i documenti vengono indirizzati al campo specifico della lingua appropriato in base alla lingua rilevata.

I campi del linguaggio inutilizzati non contengono contenuto indicizzato e hanno un impatto minimo sull'archiviazione, ma rimangono parte dello schema dell'indice e contano per il limite dei campi dell'indice. Prendere in considerazione i campi aggiuntivi quando si pianificano i requisiti di progettazione, conteggio dei campi e archiviazione dell'indice. Per altre informazioni, vedere Limiti degli indici e Stimare e gestire la capacità di un servizio di ricerca.

Il rilevamento della lingua è a pagamento dopo la quota gratuita per l'arricchimento tramite IA. Per altre informazioni, vedere Arricchimenti gratuiti.

Controllare lo stato di inserimento

Eseguire il codice seguente per monitorare lo stato e l'integrità dell'inserimento, inclusi il tipo di origine delle informazioni e gli errori dettagliati di indicizzazione per le origini delle informazioni che generano una pipeline dell'indicizzatore e popolano un indice di ricerca.

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 risposta per una richiesta che include parametri di inserimento e inserisce attivamente contenuto potrebbe essere simile all'esempio seguente.

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

Esaminare gli oggetti generati

Quando si crea questa origine conoscenze, Azure AI Search genera automaticamente un'origine dati, un set di competenze, un indicizzatore e un indice. La risposta di creazione elenca ogni oggetto in createdResources.

Questi oggetti vengono generati in base a un modello fisso e i relativi nomi si basano sul nome dell'origine conoscenze. Non è possibile modificare i nomi degli oggetti. Evitare di modificare direttamente questi oggetti, perché le modifiche possono introdurre errori o incompatibilità che interrompono la pipeline dell'indicizzatore.

È possibile usare il portale di Azure per convalidare la creazione di oggetti. Il flusso di lavoro è:

1. Controllare l'indicizzatore per i messaggi di esito positivo o negativo. Gli errori di connessione o quota vengono visualizzati qui.

2. Controllare l'origine dati per verificare la connessione all'archivio dati. La connessione utilizza una stringa di connessione o un'identità gestita, a seconda di come è stata configurata l'origine dati.

3. Controlla il set di competenze per vedere come i contenuti sono suddivisi in blocchi ed eventualmente vettorializzati.

4. Controllare l'indice per vedere in che modo il contenuto viene indicizzato ed esposto per il recupero, inclusi i campi ricercabili e filtrabili e quali campi archiviano vettori per la ricerca di somiglianza. Usa Search Explorer per eseguire query sull'indice generato.

Assegnare a una knowledge base

Se sei soddisfatto della fonte di conoscenza, aggiungila a una base di conoscenza.

Eseguire una query su una base di conoscenza

Dopo aver configurato la Knowledge Base, chiamare l'azione di recupero o l'endpoint MCP per eseguire una query sull'origine della knowledge base. Scegliere la configurazione corrispondente allo scenario.

Applicare le autorizzazioni a livello di documento (anteprima)

Per applicare le autorizzazioni a livello di documento, impostare ingestionPermissionOptions creando questa fonte di conoscenza, e quindi includere il token di accesso dell'utente nella richiesta di recupero. Per altre informazioni, vedere Applicare le autorizzazioni in fase di query (anteprima).

Mostra immagini incorporate nei documenti (anteprima)

Per visualizzare nelle risposte di sintesi delle risposte le immagini incorporate nei documenti (ad esempio diagrammi o scansioni), configurare assetStore in questa origine di conoscenza e quindi abilitare la distribuzione delle immagini nella knowledge base. La gestione delle immagini non è supportata quando ingestionPermissionOptions è configurata. Per ulteriori informazioni, consultare Immagini incorporate nei documenti Surface nel recupero agentico (anteprima).

Eliminare una fonte di conoscenza

Prima di poter eliminare una fonte di conoscenza, è necessario eliminare qualsiasi base di conoscenza che vi faccia riferimento o aggiornare la definizione della base di conoscenza per rimuovere il riferimento. Per le fonti di conoscenza che generano una pipeline dell'indice e dell'indicizzatore, vengono eliminati anche tutti gli oggetti generati. Tuttavia, se è stato usato un indice esistente per creare un'origine conoscenze, l'indice non viene eliminato.

Se si tenta di eliminare una fonte di conoscenza attualmente in uso, l'azione fallisce e restituisce un elenco delle basi di conoscenza interessate.

Per eliminare una fonte di conoscenza:

Contenuto correlato

• Recupero agentico in Azure AI Search
• Che cos'è un'origine delle conoscenze?
• Creare una knowledge base
• Interrogare una base di conoscenza
• Esempio Python: origine conoscenza Blob di Azure AI Search