Biblioteka kliencka Wyszukiwanie AI platformy Azure dla JavaScript - wersja 13.1.0

Wyszukiwanie AI platformy Azure (wcześniej znany jako "Azure Cognitive Search") to platforma wyszukiwania informacji oparta na sztucznej inteligencji, która pomaga deweloperom tworzyć bogate doświadczenia wyszukiwania oraz generatywne aplikacje AI łączące duże modele językowe z danymi korporacyjnymi.

Usługa Wyszukiwanie AI platformy Azure jest odpowiednia dla następujących scenariuszy aplikacji:

  • Konsolidowanie różnych typów zawartości w jeden indeks z możliwością wyszukiwania. Aby wypełnić indeks, możesz wypchnąć dokumenty JSON zawierające zawartość lub jeśli dane znajdują się już na platformie Azure, utwórz indeksator, aby automatycznie ściągać dane.
  • Dołącz zestawy umiejętności do indeksatora, aby utworzyć zawartość z możliwością wyszukiwania na podstawie obrazów i dokumentów bez struktury. Zestaw umiejętności korzysta z interfejsów API z usług Azure AI Services na potrzeby wbudowanego rozpoznawania OCR, rozpoznawania jednostek, wyodrębniania kluczowych fraz, wykrywania języka, tłumaczenia tekstu i analizy tonacji. Możesz również dodać niestandardowe umiejętności, aby zintegrować zewnętrzne przetwarzanie zawartości podczas pozyskiwania danych.
  • W aplikacji klienckiej wyszukiwania zaimplementuj logikę zapytań i środowiska użytkownika podobne do komercyjnych wyszukiwarek internetowych i aplikacji w stylu czatu.

Biblioteka @azure/search-documents klienta umożliwia wykonywanie następujących czynności:

  • Przesyłanie zapytań przy użyciu formularzy wektorów, słów kluczowych i hybrydowych zapytań.
  • Zaimplementuj zapytania filtrowane pod kątem metadanych, wyszukiwania geoprzestrzennego, nawigacji aspektowej lub zawężaj wyniki na podstawie kryteriów filtrowania.
  • Tworzenie indeksów wyszukiwania i zarządzanie nimi.
  • Przekazywanie i aktualizowanie dokumentów w indeksie wyszukiwania.
  • Tworzenie indeksatorów ściągających dane z platformy Azure do indeksu i zarządzanie nimi.
  • Twórz zestawy umiejętności, które dodają wzbogacanie sztucznej inteligencji do pozyskiwania danych i zarządzaj nimi.
  • Tworzenie analizatorów i zarządzanie nimi na potrzeby zaawansowanej analizy tekstu lub zawartości wielojęzycznej.
  • Optymalizowanie wyników dzięki profilom klasyfikacji semantycznej i oceniania, aby uwzględnić logikę biznesową lub świeżość.

Kluczowe linki:

Wprowadzenie

Instalowanie pakietu @azure/search-documents

npm install @azure/search-documents

Wersja 13.1.0 domyślnie celuje w 2026-10-01 API usługi GA. Podczas aktualizacji z wersji 13.0.0 przejrzyj zmianyto-GA łamania GA-. Zaktualizowane przykłady TypeScript i JavaScript są dostępne w samples/v13.

Obecnie obsługiwane środowiska

  • Wersje LTS Node.js
  • Najnowsze wersje przeglądarek Safari, Chrome, Microsoft Edge i Firefox.

Aby uzyskać więcej informacji, zobacz nasze zasady pomocy technicznej.

Warunki wstępne

Aby utworzyć nową usługę wyszukiwania, możesz użyć Azure Portal, Azure PowerShell lub interfejsu wiersza polecenia platformy Azure. Oto przykład użycia interfejsu wiersza polecenia platformy Azure do utworzenia bezpłatnego wystąpienia na potrzeby rozpoczynania pracy:

az search service create --name <mysearch> --resource-group <mysearch-rg> --sku free --location westus

Zobacz Wybieranie warstwy cenowej , aby uzyskać więcej informacji na temat dostępnych opcji.

Uwierzytelnianie klienta

Aby wchodzić w interakcję z usługą wyszukiwania, należy utworzyć odpowiedniego klienta: SearchClient do dokumentów, SearchIndexClient indeksów i zasobów wiedzy, SearchIndexerClient do źródeł/indeksatorów/zestawów umiejętności lub KnowledgeRetrievalClient do wyszukiwania bazy wiedzy. Aby utworzyć wystąpienie obiektu klienta, potrzebny jest punkt końcowy i role platformy Azure lub klucz interfejsu API. Możesz zapoznać się z dokumentacją, aby uzyskać więcej informacji na temat obsługiwanych podejść uwierzytelniania za pomocą usługi wyszukiwania.

Uzyskiwanie klucza interfejsu API

Klucz interfejsu API może być łatwiejszym podejściem do rozpoczęcia od, ponieważ nie wymaga wstępnie istniejących przypisań ról.

Punkt końcowy i klucz interfejsu API można uzyskać z usługi wyszukiwania w Azure Portal. Zapoznaj się z dokumentacją , aby dowiedzieć się, jak uzyskać klucz API.

Alternatywnie możesz użyć następującego polecenia interfejsu wiersza polecenia platformy Azure , aby pobrać klucz interfejsu API z usługi wyszukiwania:

az search admin-key show --resource-group <your-resource-group-name> --service-name <your-resource-name>

Istnieją dwa typy kluczy używanych do uzyskiwania dostępu do usługi wyszukiwania: klucze admin(odczyt i zapis) i klucze zapytania(tylko do odczytu). Ograniczenie dostępu i operacji w aplikacjach klienckich jest niezbędne do ochrony zasobów wyszukiwania w usłudze. Zawsze używaj klucza zapytania, a nie klucza administratora dla dowolnego zapytania pochodzącego z aplikacji klienckiej.

Uwaga: Powyższy przykładowy fragment Azure CLI pobiera klucz administratora, dzięki czemu łatwiej jest zacząć eksplorować API, ale należy nim zarządzać ostrożnie.

Po utworzeniu klucza api-key możesz go użyć w następujący sposób:

import {
  SearchClient,
  AzureKeyCredential,
  SearchIndexClient,
  SearchIndexerClient,
  KnowledgeRetrievalClient,
} from "@azure/search-documents";

// To query and manipulate documents
const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

// To manage indexes and synonymmaps
const indexClient = new SearchIndexClient("<endpoint>", new AzureKeyCredential("<apiKey>"));

// To manage indexers, datasources and skillsets
const indexerClient = new SearchIndexerClient("<endpoint>", new AzureKeyCredential("<apiKey>"));

// To retrieve from a knowledge base
const knowledgeRetrievalClient = new KnowledgeRetrievalClient(
  "<endpoint>",
  "<knowledgeBaseName>",
  new AzureKeyCredential("<apiKey>"),
);

Uwierzytelnianie w chmurze krajowej

Aby uwierzytelnić się w chmurze krajowej, należy wprowadzić następujące dodatki do konfiguracji klienta:

  • Ustaw w Audience polu SearchClientOptions
import { DefaultAzureCredential } from "@azure/identity";
import {
  SearchClient,
  KnownSearchAudience,
  SearchIndexClient,
  SearchIndexerClient,
  KnowledgeRetrievalClient,
} from "@azure/search-documents";

const credential = new DefaultAzureCredential({
  authorityHost: "https://login.chinacloudapi.cn",
});

// To query and manipulate documents
const searchClient = new SearchClient("<endpoint>", "<indexName>", credential, {
  audience: KnownSearchAudience.AzureChina,
});

// To manage indexes and synonymmaps
const indexClient = new SearchIndexClient("<endpoint>", credential, {
  audience: KnownSearchAudience.AzureChina,
});

// To manage indexers, datasources and skillsets
const indexerClient = new SearchIndexerClient("<endpoint>", credential, {
  audience: KnownSearchAudience.AzureChina,
});

// To retrieve from a knowledge base
const knowledgeRetrievalClient = new KnowledgeRetrievalClient(
  "<endpoint>",
  "<knowledgeBaseName>",
  credential,
  { audience: KnownSearchAudience.AzureChina },
);

Kluczowe pojęcia

Usługa Wyszukiwanie AI platformy Azure zawiera co najmniej jeden indeks, który zapewnia trwały magazyn danych z możliwością wyszukiwania w postaci dokumentów JSON. (Jeśli dopiero zaczynasz przygodę z wyszukiwaniem, możesz bardzo przybliżoną analogię między indeksami a tabelami bazy danych.) Biblioteka @azure/search-documents klienta udostępnia operacje na tych zasobach poprzez cztery główne typy klientów.

Uwaga: Korzystanie z przeglądarki zależy od tego, czy wybrana operacja wyszukiwania i zasób mają skonfigurowany CORS. Źródła wiedzy i bazy wiedzy plików ujawniają ustawienia CORS, ale wiele operacji zarządzania jest przeznaczonych dla zaufanych aplikacji po stronie serwera.

Pojęcia specyficzne dla języka TypeScript/JavaScript

Dokumentów

Element przechowywany wewnątrz indeksu wyszukiwania. Kształt tego dokumentu jest opisany w indeksie za pomocą fields właściwości. Każdy z nich SearchField ma nazwę, typ danych i dodatkowe metadane, takie jak to, czy można je przeszukiwać lub filtrować.

Paginacja

Zazwyczaj chcesz pokazać użytkownikowi tylko podzbiór wyników wyszukiwania w tym samym czasie. Aby to obsłużyć, możesz użyć topparametrów i , skipincludeTotalCount aby zapewnić środowisko stronicowania na podstawie wyników wyszukiwania.

Kodowanie pól dokumentu

Obsługiwane typy danych w indeksie są mapowane na typy JSON w żądaniach/odpowiedziach API. Biblioteka klienta JS przechowuje te same elementy, z pewnymi wyjątkami:

  • Edm.DateTimeOffset jest konwertowany na JS Date.
  • Edm.GeographyPoint jest konwertowany na GeographyPoint typ eksportowany przez bibliotekę klienta.
  • Specjalne wartości number typu (NaN, Infinity -Infinity) są serializowane jako ciągi w interfejsie API REST, ale są konwertowane z powrotem przez number bibliotekę klienta.

Uwaga: Typy danych są konwertowane na podstawie wartości, a nie typu pola w schemacie indeksu. Oznacza to, że jeśli masz ciąg daty ISO8601 (np. "2020-03-06T18:48:27.896Z") jako wartość pola, zostanie on przekonwertowany na datę niezależnie od sposobu jego przechowywania w schemacie.

Przykłady

Poniższe przykłady pokazują podstawy - zapoznaj się z naszymi przykładami , aby uzyskać więcej informacji.

Poniższe przykłady używają stabilnego 2026-10-01 API usługi, które jest domyślnym dla klienta. Rozszerzają istniejące przepływy indeksów, indeksatorów, źródeł wiedzy i wyszukiwania, zamiast wymagać osobnego zestawu klientów.

Dla pełnych, możliwych do uruchomienia przepływów pracy, przykładowe źródła obejmują również indeksowane kolumny zawartości SQL, prywatne analizatory importu i analizatory wybranych przez usługi, modele opisu obrazów i semantyczne podziały na fragmenty, budżety serwisowe/indeksujące w czasie działania oraz adresy URL cytowań należące do wyszukiwania. Opcjonalne ustawienia zasobów i wymagania wstępne są wymienione w pliku sample.env.

Znajdź podobne dokumenty

Używaj moreLikeThis z istniejącym kluczem dokumentu i pomiń tekst wyszukiwania. Wybierz wyraźnie pola tekstowe najwyższego poziomu: złożone pola nie są obsługiwane przez tę operację. Indeks musi zawierać inne dokumenty, aby zwrócić przydatne dopasowania.

import { SearchClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchClient("<endpoint>", "<indexName>", new DefaultAzureCredential());

const response = await client.search(undefined, {
  moreLikeThis: "1",
  searchFields: ["hotelName", "description"],
  select: ["hotelId", "hotelName"],
  top: 5,
});
for await (const result of response.results) {
  console.log(result.document);
}

Skonfiguruj bazę wiedzy

Użyj wypełnionego źródła wiedzy z skonfigurowanym wyszukiwaniem semantycznym. Wdrój skonfigurowany model czatu i nadaj zarządzanej tożsamości usługi Search Cognitive Services OpenAI User na zasobie Azure OpenAI. Nazwa wdrożenia i nazwa modelu to oddzielne ustawienia; wdrożenie może mieć niestandardową nazwę. Dzwoniący potrzebuje Search Service Contributor do zarządzania bazami wiedzy.

Przechowywane instrukcje, tryb wyjściowy oraz wysiłek rozumowania mogą być aktualizowane bez konieczności wymiany źródeł wiedzy. answerSynthesis używa skonfigurowanego modelu; extractiveData zwraca wyodrębnioną zawartość bez syntezy odpowiedzi. Tryby rozumowania GA to minimal, low, oraz medium. Jawne zamiary żądań omijają planowanie zapytań modelu.

import { SearchIndexClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexClient("<endpoint>", new DefaultAzureCredential());

const knowledgeBase = await client.createKnowledgeBase({
  name: "hotel-knowledge-base",
  knowledgeSources: [{ name: "<existingKnowledgeSourceName>" }],
  models: [
    {
      kind: "azureOpenAI",
      azureOpenAIParameters: {
        resourceUrl: "<azureOpenAIEndpoint>",
        deploymentId: "<chatDeploymentName>",
        modelName: "gpt-5.4-mini",
      },
    },
  ],
  retrievalReasoningEffort: { kind: "low" },
  outputMode: "answerSynthesis",
  retrievalInstructions: "Prioritize hotel amenities and pricing information.",
  answerInstructions: "Answer concisely and cite the supporting sources.",
});

knowledgeBase.outputMode = "extractiveData";
await client.createOrUpdateKnowledgeBase(knowledgeBase);

Lista zasobów z kontrolkami stronicowania

Przefiltruj początkową listę według prefiksu nazwy i pozwól SDK podążać za nieprzejrzystymi linkami kontynuacyjnymi. Pagery SearchIndexClient ujawniają byPage(). Istniejące metody listowania z mapą synonimów, indeksatorem, źródłem danych i wygodą skillset nadal zwracają tablice po zebraniu wszystkich stron; klienci protokołu udostępniają odpowiadające operacje stronicowane.

import { SearchIndexClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexClient("<endpoint>", new DefaultAzureCredential());

for await (const page of client
  .listIndexes({
    search: "hotel",
    searchType: "prefix",
    pageSize: 10,
  })
  .byPage()) {
  console.log(page.map((index) => index.name));
}

Konfiguracja uprawnień dokumentów SharePoint

Zarejestruj aplikację łącznika SharePoint oraz jej federacyjne poświadczenia przed utworzeniem indeksu. applicationId federatedCredentialId i są wymagane razem; mogą być dostarczone, tenantId gdy różnią się od dzierżawy usługi wyszukiwania. Dzwoniący potrzebuje Współtwórcy Search Service.

Grant na udostępnianie o ograniczonym zakresie organizacji używa orgLink:<tenantId> pola uprawnień userIds . organizationAccessExpiration Identyfikuje jego znacznik czasu wygaśnięcia. Najwyżej jedno najwyższe Edm.DateTimeOffset pole może to umożliwić. Usługa weryfikuje tenant i znacznik czasu użytkownika podczas zapytań filtrowanych przez uprawnienia; samo deklarowanie tych pól nie przyznaje dostępu.

import { SearchIndexClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexClient("<endpoint>", new DefaultAzureCredential());

await client.createIndex({
  name: "sharepoint-permissions",
  permissionFilterOption: "enabled",
  sharePointConnectorAppRegistration: {
    applicationId: "<applicationId>",
    federatedCredentialId: "<federatedCredentialId>",
  },
  fields: [
    { name: "id", type: "Edm.String", key: true },
    { name: "content", type: "Edm.String", searchable: true },
    {
      name: "userIds",
      type: "Collection(Edm.String)",
      filterable: true,
      permissionFilter: "userIds",
    },
    {
      name: "organizationLinkExpiresAt",
      type: "Edm.DateTimeOffset",
      organizationAccessExpiration: true,
    },
  ],
});

Indeksuj zawartość witryny SharePoint

Zakresy GA SharePoint obejmują AllSiteLists, AllSitePages, oraz AllSiteContent, oprócz istniejących zakresów bibliotek. Podaj parametry połączenia łącznika przez środowisko, zamiast osadzać sekret aplikacji w kodzie źródłowym.

import { SearchIndexClient, KnownIndexedSharePointContainerName } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexClient("<endpoint>", new DefaultAzureCredential());
const connectionString = process.env.SHAREPOINT_CONNECTION_STRING;
if (!connectionString) {
  throw new Error("Set SHAREPOINT_CONNECTION_STRING before creating the knowledge source.");
}

await client.createKnowledgeSource({
  name: "sharepoint-site",
  kind: "indexedSharePoint",
  indexedSharePointParameters: {
    connectionString,
    containerName: KnownIndexedSharePointContainerName.AllSiteContent,
  },
});

Odśwież niezmienione uprawnienia ADLS Gen2

Dla istniejącego indeksatora ADLS Gen2, który pobiera uprawnienia, odświeża metadane uprawnień nawet wtedy, refreshAllAcls gdy zawartość dokumentu nie uległa zmianie. Domyślnie trueuruchamia się maksymalnie raz na 24 godziny i nie przetwarza ponownie zawartości ani wzbogacania. Ustaw na, false aby wyłączyć odświeżanie.

import { SearchIndexerClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexerClient("<endpoint>", new DefaultAzureCredential());
const indexer = await client.getIndexer("<existingAdlsGen2Indexer>");

indexer.parameters = {
  ...indexer.parameters,
  configuration: {
    ...indexer.parameters?.configuration,
    refreshAllAcls: true,
  },
};
await client.createOrUpdateIndexer(indexer);

Pobierz z bazy wiedzy

import {
  KnowledgeRetrievalClient,
  AzureKeyCredential,
  KnownKnowledgeRetrievalReasoningEffortKind,
} from "@azure/search-documents";

const client = new KnowledgeRetrievalClient(
  "<endpoint>",
  "<knowledgeBaseName>",
  new AzureKeyCredential("<apiKey>"),
);

const response = await client.retrieve({
  intents: [{ type: "semantic", search: "What information is available?" }],
  retrievalReasoningEffort: { kind: KnownKnowledgeRetrievalReasoningEffortKind.Low },
  includeActivity: true,
});

console.log(response.response);

Wyszukiwanie wiedzy o strumieniu

Typowany iterator używa jednego połączenia SSE, obsługuje ramki i heartbeat, a zatrzymuje się po response.completed lub error. Zakończenie może raportować pełne (200) lub częściowe206 () wyniki. Zadzwoń, controller.abort() aby anulować prośbę. Nieznane nazwy zdarzeń są ignorowane; zdarzenia token-delta nie są częścią tego API. Zobacz przykład strumieniowania, aby poznać korelację aktywności i obsługę anulowania.

import { KnowledgeRetrievalClient, AzureKeyCredential } from "@azure/search-documents";

const client = new KnowledgeRetrievalClient(
  "<endpoint>",
  "<knowledgeBaseName>",
  new AzureKeyCredential("<apiKey>"),
);

const controller = new AbortController();
for await (const event of await client.retrieveStream(
  {
    intents: [{ type: "semantic", search: "Summarize the indexed information." }],
    includeActivity: true,
  },
  { abortSignal: controller.signal },
)) {
  if (event.event === "activity.completed") {
    console.log(`Activity ${event.data.id} took ${event.data.elapsedInMs}ms`);
  } else if (event.event === "response.completed") {
    console.log(event.data.statusCode === 206 ? "Partial results" : "Complete results");
    console.log(event.data.response.response);
  } else if (event.event === "error") {
    throw new Error(event.data.error.message);
  }
}

Przesyłanie i aktualizacja pliku źródła wiedzy

import { SearchIndexClient, AzureKeyCredential } from "@azure/search-documents";

const client = new SearchIndexClient("<endpoint>", new AzureKeyCredential("<apiKey>"));
const body = {
  metadata: { fileName: "manuals/example.txt", metadata: { category: "manual" } },
  content: {
    contents: new TextEncoder().encode("Azure AI Search retrieves relevant information."),
    contentType: "text/plain",
    filename: "example.txt",
  },
};

const uploaded = await client.uploadKnowledgeSourceFileMultipart("<knowledgeSourceName>", body);
if (!uploaded.fileId) {
  throw new Error("The service did not return an uploaded file ID.");
}

await client.updateKnowledgeSourceFile("<knowledgeSourceName>", uploaded.fileId, {
  ...body,
  metadata: { ...body.metadata, metadata: { category: "updated-manual" } },
});
for await (const file of client.listKnowledgeSourceFiles("<knowledgeSourceName>", {
  prefix: "manuals/",
  pageSize: 10,
})) {
  console.log(file.fileName, file.parsingMode, file.extractionMode);
}

Sprawdź pojemność źródła wiedzy pliku

Status źródła wiedzy Plik udostępnia fileCapacity (KnowledgeSourceFileCapacity) wraz z pozostałą liczbą plików oraz limitem bajtów na plik. Sprawdź je przed przesłaniem; inne rodzaje źródeł wiedzy nie raportują tego pola. Bezpośrednie przesyłanie wymaga Search Service Contributor, a zarządzana tożsamość usługi Search potrzebuje Cognitive Services OpenAI User na zasobie osadzającym.

import { SearchIndexClient } from "@azure/search-documents";
import { DefaultAzureCredential } from "@azure/identity";

const client = new SearchIndexClient("<endpoint>", new DefaultAzureCredential());
const status = await client.getKnowledgeSourceStatus("<fileKnowledgeSourceName>");

if (!status.fileCapacity) {
  throw new Error("The knowledge source did not report File upload capacity.");
}
console.log(`Remaining files: ${status.fileCapacity.remainingFileCount}`);
console.log(`Maximum file size: ${status.fileCapacity.maxFileSizeBytes} bytes`);

Tworzenie indeksu

import { SearchIndexClient, AzureKeyCredential } from "@azure/search-documents";

const indexClient = new SearchIndexClient("<endpoint>", new AzureKeyCredential("<apiKey>"));

const result = await indexClient.createIndex({
  name: "example-index",
  fields: [
    {
      type: "Edm.String",
      name: "id",
      key: true,
    },
    {
      type: "Edm.Double",
      name: "awesomenessLevel",
      sortable: true,
      filterable: true,
      facetable: true,
    },
    {
      type: "Edm.String",
      name: "description",
      searchable: true,
    },
    {
      type: "Edm.ComplexType",
      name: "details",
      fields: [
        {
          type: "Collection(Edm.String)",
          name: "tags",
          searchable: true,
        },
      ],
    },
    {
      type: "Edm.Int32",
      name: "hiddenWeight",
      hidden: true,
    },
  ],
});

console.log(`Index created with name ${result.name}`);

Pobieranie określonego dokumentu z indeksu

Określony dokument może zostać pobrany przez jego wartość klucza podstawowego:

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const result = await searchClient.getDocument("1234");

Dodawanie dokumentów do indeksu

Możesz przekazać wiele dokumentów do indeksu wewnątrz partii:

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const uploadResult = await searchClient.uploadDocuments([
  // JSON objects matching the shape of the client's index
  {},
  {},
  {},
]);
for (const result of uploadResult.results) {
  console.log(`Uploaded ${result.key}; succeeded? ${result.succeeded}`);
}

Wyszukiwanie dokumentów

Aby wyświetlić listę wszystkich wyników określonego zapytania, możesz użyć search go z ciągiem wyszukiwania, który używa prostej składni zapytania:

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const searchResults = await searchClient.search("wifi -luxury");
for await (const result of searchResults.results) {
  console.log(result);
}

Aby uzyskać bardziej zaawansowane wyszukiwanie, które używa składni Lucene, określ queryType wartość full:

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const searchResults = await searchClient.search('Category:budget AND "recently renovated"^3', {
  queryType: "full",
  searchMode: "all",
});
for await (const result of searchResults.results) {
  console.log(result);
}

Wykonywanie zapytań za pomocą języka TypeScript

W języku TypeScript przyjmuje parametr ogólny, SearchClient który jest kształtem modelu dokumentów indeksu. Dzięki temu można wykonywać silnie typizowane wyszukiwanie pól zwracanych w wynikach. TypeScript jest również w stanie sprawdzić pola zwrócone podczas określania parametru select .

import { SearchClient, AzureKeyCredential, SelectFields } from "@azure/search-documents";

// An example schema for documents in the index
interface Hotel {
  hotelId?: string;
  hotelName?: string | null;
  description?: string | null;
  descriptionVector?: Array<number>;
  parkingIncluded?: boolean | null;
  lastRenovationDate?: Date | null;
  rating?: number | null;
  rooms?: Array<{
    beds?: number | null;
    description?: string | null;
  }>;
}

const searchClient = new SearchClient<Hotel>(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const searchResults = await searchClient.search("wifi -luxury", {
  // Only fields in Hotel can be added to this array.
  // TS will complain if one is misspelled.
  select: ["hotelId", "hotelName", "rooms/beds"],
});

// These are other ways to declare the correct type for `select`.
const select = ["hotelId", "hotelName", "rooms/beds"] as const;
// This declaration lets you opt out of narrowing the TypeScript type of your documents,
// though the AI Search service will still only return these fields.
const selectWide: SelectFields<Hotel>[] = ["hotelId", "hotelName", "rooms/beds"];
// This is an invalid declaration. Passing this to `select` will result in a compiler error
// unless you opt out of including the model in the client constructor.
const selectInvalid = ["hotelId", "hotelName", "rooms/beds"];

for await (const result of searchResults.results) {
  // result.document has hotelId, hotelName, and rooms with only the beds property.
  // Trying to access result.document.description would emit a TS error.
  console.log(result.document.hotelName);
}

Wykonywanie zapytań za pomocą filtrów OData

Użycie parametru filter zapytania umożliwia wykonywanie zapytań dotyczących indeksu przy użyciu składni wyrażenia $filter OData.

import { SearchClient, AzureKeyCredential, odata } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const baseRateMax = 200;
const ratingMin = 4;
const searchResults = await searchClient.search("WiFi", {
  filter: odata`Rooms/any(room: room/BaseRate lt ${baseRateMax}) and Rating ge ${ratingMin}`,
  orderBy: ["Rating desc"],
  select: ["hotelId", "hotelName", "Rating"],
});
for await (const result of searchResults.results) {
  // Each result will have "HotelId", "HotelName", and "Rating"
  // in addition to the standard search result property "score"
  console.log(result);
}

Wykonywanie zapytań za pomocą wektorów

Osadzanie tekstu może być odpytywane za pomocą parametru vector wyszukiwania. Aby uzyskać więcej informacji, zobacz Wektory zapytań i Filtrowanie zapytań wektorowych .

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const queryVector: number[] = [
  // Embedding of the query "What are the most luxurious hotels?"
];
const searchResults = await searchClient.search("*", {
  vectorSearchOptions: {
    queries: [
      {
        kind: "vector",
        vector: queryVector,
        fields: ["descriptionVector"],
        kNearestNeighborsCount: 3,
      },
    ],
  },
});
for await (const result of searchResults.results) {
  // These results are the nearest neighbors to the query vector
  console.log(result);
}

Wykonywanie zapytań za pomocą aspektów

Facety służą do pomocy użytkownikowi Twojej aplikacji w zawężeniu wyszukiwania według wstępnie skonfigurowanych wymiarów. Składnia fasetów umożliwia sortowanie i grupowanie wartości faset.

import { SearchClient, AzureKeyCredential } from "@azure/search-documents";

const searchClient = new SearchClient(
  "<endpoint>",
  "<indexName>",
  new AzureKeyCredential("<apiKey>"),
);

const searchResults = await searchClient.search("WiFi", {
  facets: ["category,count:3,sort:count", "rooms/baseRate,interval:100"],
});
console.log(searchResults.facets);

Podczas pobierania wyników będzie dostępna właściwość, facets która będzie wskazywać liczbę wyników, które mieszczą się w każdym zasobniku aspektu. Można to wykorzystać do doprecyzowania (np. przeprowadzenia wyszukiwania uzupełniającego, które filtruje Rating wartość większą lub równą 3 i mniejszą niż 4).

Rozwiązywanie problemów

Wyrąb

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań i odpowiedzi HTTP, ustaw zmienną środowiskową AZURE_LOG_LEVEL na info. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel w @azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietów @azure/rejestratora.

Następne kroki

Przyczyniając się

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik dotyczący współtworzenia , aby dowiedzieć się więcej na temat tworzenia i testowania kodu.

Ten projekt z zadowoleniem przyjmuje wkład i sugestie. Większość kontrybucja wymaga zgody na umowę licencyjną współautora (CLA), deklarując, że masz prawo, a w rzeczywistości przyznaj nam prawa do korzystania z twojego wkładu. Szczegółowe informacje można znaleźć na stronie cla.microsoft.com.

W tym projekcie jest używany Kodeks postępowania firmy Microsoft dla oprogramowania typu open source. Aby uzyskać więcej informacji, zobacz Kodeks postępowania — często zadawane pytania lub skontaktuj się z [email protected] z dodatkowymi pytaniami lub komentarzami.