Tworzenie indeksowanego źródła wiedzy usługi OneLake

Indeksowane źródło wiedzy usługi OneLake importuje pliki Microsoft OneLake 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 indeksowanego źródła wiedzy OneLake 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 jezioro.
• Zestaw umiejętności, który fragmentuje i opcjonalnie wektoryzuje zawartość wielomodalną z jeziora.
• 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 OneLake, którego wymagania wstępne, obsługiwane zadania, obsługiwane formaty dokumentów, obsługiwane skróty i ograniczenia dotyczą również źródeł wiedzy OneLake. Aby uzyskać więcej informacji, zobacz dokumentację indeksatora OneLake i limity 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.

• Ukończenie wymagań wstępnych indeksatora OneLake.

• Ukończenie przygotowywania danych indeksatora OneLake.

• Jeśli contentExtractionMode to standard, użyj zasobu Microsoft Foundry w regionie obsługiwanym przez usługę Content Understanding w narzędziach Foundry Tools oraz punktu końcowego https://<resource-name>.services.ai.azure.com. Wdróż model embeddingów oraz multimodalny model czatu, jeśli włączysz funkcję opisywania obrazów.

• 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.

• Jeśli źródło wiedzy określa model usługi Azure OpenAI do tworzenia osadzeń lub opisywania obrazów, usługa wyszukiwania musi mieć zarządzaną tożsamość z uprawnieniami Cognitive Services User do zasobu Microsoft Foundry.

Limitations

Synchronizacja prywatna nie jest obsługiwana w przypadku indeksowanych źródeł wiedzy usługi OneLake. Pozostaw networkAccessMode ustawione na public.

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

Poniższy kod JSON to przykładowa odpowiedź dla indeksowanego źródła wiedzy OneLake.

{
  "name": "my-onelake-ks",
  "kind": "indexedOneLake",
  "description": "A sample indexed OneLake knowledge source.",
  "encryptionKey": null,
  "indexedOneLakeParameters": {
    "fabricWorkspaceId": "<REDACTED>",
    "lakehouseId": "<REDACTED>",
    "targetPath": null,
    "ingestionParameters": {
      "disableImageVerbalization": false,
      "ingestionPermissionOptions": [],
      "contentExtractionMode": "standard",
      "identity": null,
      "embeddingModel": {
        "kind": "azureOpenAI",
        "azureOpenAIParameters": {
          "resourceUri": "<REDACTED>",
          "deploymentId": "text-embedding-3-large",
          "modelName": "text-embedding-3-large"
        }
      },
      "chatCompletionModel": {
        "kind": "azureOpenAI",
        "azureOpenAIParameters": {
          "resourceUri": "<aoai-endpoint>",
          "deploymentId": "gpt-5-mini",
          "modelName": "gpt-5-mini"
        }
      },
      "ingestionSchedule": null,
      "aiServices": {
        "uri": "<aoai-endpoint>",
      }
    },
    "createdResources": {
    "datasource": "my-onelake-ks-datasource",
    "indexer": "my-onelake-ks-indexer",
    "skillset": "my-onelake-ks-skillset",
    "index": "my-onelake-ks-index"
    }
  }
}

Tworzenie źródła wiedzy

Uruchom następujący kod, aby utworzyć indeksowane źródło wiedzy usługi OneLake.

// Create an indexed OneLake 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 oneLakeParams = new IndexedOneLakeKnowledgeSourceParameters(
    fabricWorkspaceId: fabricWorkspaceId,
    lakehouseId: lakehouseId)
{
    IngestionParameters = ingestionParams
};

var knowledgeSource = new IndexedOneLakeKnowledgeSource(
    name: "my-onelake-ks",
    indexedOneLakeParameters: oneLakeParams)
{
    Description = "This knowledge source pulls content from a lakehouse."
};

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

// Create an indexed OneLake 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 oneLakeParams = new IndexedOneLakeKnowledgeSourceParameters(
    fabricWorkspaceId: fabricWorkspaceId,
    lakehouseId: lakehouseId)
{
    IngestionParameters = ingestionParams
};

var knowledgeSource = new IndexedOneLakeKnowledgeSource(
    name: "my-onelake-ks",
    indexedOneLakeParameters: oneLakeParams)
{
    Description = "This knowledge source pulls content from a lakehouse."
};

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

# Create an indexed OneLake knowledge source
from azure.identity import DefaultAzureCredential
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import IndexedOneLakeKnowledgeSource, IndexedOneLakeKnowledgeSourceParameters, KnowledgeBaseAzureOpenAIModel, AzureOpenAIVectorizerParameters, KnowledgeSourceAzureOpenAIVectorizer, KnowledgeSourceContentExtractionMode, KnowledgeSourceIngestionParameters
from azure.search.documents.knowledgebases.models import KnowledgeSourceNetworkAccessMode

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

knowledge_source = IndexedOneLakeKnowledgeSource(
    name = "my-onelake-ks",
    description= "This knowledge source pulls content from a lakehouse.",
    encryption_key = None,
    indexed_one_lake_parameters = IndexedOneLakeKnowledgeSourceParameters(
        fabric_workspace_id = "fabric_workspace_id",
        lakehouse_id = "lakehouse_id",
        target_path = None,
        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 an indexed OneLake knowledge source
from azure.identity import DefaultAzureCredential
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import IndexedOneLakeKnowledgeSource, IndexedOneLakeKnowledgeSourceParameters, KnowledgeBaseAzureOpenAIModel, AzureOpenAIVectorizerParameters, KnowledgeSourceContentExtractionMode
from azure.search.documents.knowledgebases.models import KnowledgeSourceIngestionParameters, KnowledgeSourceAzureOpenAIVectorizer

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

knowledge_source = IndexedOneLakeKnowledgeSource(
    name = "my-onelake-ks",
    description= "This knowledge source pulls content from a lakehouse.",
    encryption_key = None,
    indexed_one_lake_parameters = IndexedOneLakeKnowledgeSourceParameters(
        fabric_workspace_id = "fabric_workspace_id",
        lakehouse_id = "lakehouse_id",
        target_path = None,
        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 an indexed OneLake knowledge source
PUT {{search-endpoint}}/knowledgesources/my-onelake-ks?api-version=2026-08-01-preview
Authorization: Bearer {{search-access-token}}
Content-Type: application/json

{
    "name": "my-onelake-ks",
    "kind": "indexedOneLake",
    "description": "This knowledge source pulls content from a lakehouse.",
    "indexedOneLakeParameters": {
      "fabricWorkspaceId": "<fabric-workspace-id>",
      "lakehouseId": "<lakehouse-id>",
      "targetPath": null,
      "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 an indexed OneLake knowledge source
PUT {{search-endpoint}}/knowledgesources/my-onelake-ks?api-version=2026-04-01
Authorization: Bearer {{search-access-token}}
Content-Type: application/json

{
    "name": "my-onelake-ks",
    "kind": "indexedOneLake",
    "description": "This knowledge source pulls content from a lakehouse.",
    "indexedOneLakeParameters": {
      "fabricWorkspaceId": "<fabric-workspace-id>",
      "lakehouseId": "<lakehouse-id>",
      "targetPath": null,
      "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
    }
  }
}

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

W przypadku każdej bazy wiedzy, która określa indeksowane źródło wiedzy OneLake, upewnij się, że ustawiono wartość includeReferenceSourceDatatrue. Ten krok jest niezbędny do ściągnięcia adresu URL dokumentu źródłowego do cytatu.

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).

Surface 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