Go - Elasticsearch Labs

Verwendung der hybriden Suche für die Gopher-Jagd mit Elasticsearch und Go

Carly Richmond,Laurent Saint-Félix — Thu, 02 Nov 2023 00:00:00 GMT

In den vorherigen Teilen dieser Serie wurde gezeigt, wie man den Elasticsearch Go-Client für die traditionelle Stichwortsuche und die Vektorsuche verwendet. Dieser dritte Teil behandelt die hybride Suche. Wir zeigen Ihnen Beispiele , wie Sie Vektorsuche und Stichwortsuche mit Elasticsearch und dem Elasticsearch Go-Client kombinieren können.

Voraussetzungen

Genau wie im ersten Teil dieser Reihe gelten auch für dieses Beispiel folgende Voraussetzungen:

Installation von Go Version 1.21 oder höher
Erstellen Sie Ihr eigenes Go-Repository gemäß der in der Go-Dokumentationbeschriebenen empfohlenen Struktur und Paketverwaltung.
Erstellen eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

Zur Erinnerung: In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud
Cluster-URL, Benutzername, Passwort und Zertifikat

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

func GetElasticsearchClient() (*elasticsearch.TypedClient, error) { var cloudID = os.Getenv("ELASTIC_CLOUD_ID") var apiKey = os.Getenv("ELASTIC_API_KEY") var es, err = elasticsearch.NewTypedClient(elasticsearch.Config{ CloudID: cloudID, APIKey: apiKey, Logger: &elastictransport.ColorLogger{os.Stdout, true, true}, }) if err != nil { return nil, fmt.Errorf("unable to connect: %w", err) } return es, nil }

Die client -Verbindung kann dann für Suchvorgänge verwendet werden, wie in den nachfolgenden Abschnitten gezeigt wird.

Manuelles Boosting für Hybridsuche

Bei der Kombination beliebiger Suchalgorithmen bestand der traditionelle Ansatz darin, Konstanten manuell zu konfigurieren, um jeden Abfragetyp zu verstärken. Genauer gesagt wird für jede Anfrage ein Faktor festgelegt, und das kombinierte Ergebnisset wird mit dem erwarteten Set verglichen, um die Trefferquote der Anfrage zu bestimmen. Dann wiederholen wir den Vorgang für mehrere Faktorensätze und wählen denjenigen aus, der unserem gewünschten Zustand am nächsten kommt.

Beispielsweise kann die Kombination einer einzelnen Textsuchanfrage mit einem Gewichtungsfaktor von 0.8 mit einer kNN-Abfrage mit einem niedrigeren Gewichtungsfaktor von 0.2 durch Angabe des Feldes Boost in beiden Abfragetypen erfolgen, wie im folgenden Beispiel gezeigt:

func HybridSearchWithBoost(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 var knnBoost float32 = 0.2 var queryBoost float32 = 0.8 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ Field: "text_embedding.predicted_value", Boost: &knnBoost, K: &k, NumCandidates: &numCandidates, QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": { Query: term, Boost: &queryBoost, }, }, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Der in der Option Boost für jede Abfrage angegebene Faktor wird zur Dokumentbewertung addiert. Indem wir den Score unserer Match-Abfrage um einen größeren Faktor erhöhen als den der KNN-Abfrage, werden die Ergebnisse der Keyword-Abfrage stärker gewichtet.

Die Herausforderung beim manuellen Boosting, insbesondere wenn man kein Suchmaschinenexperte ist, besteht darin, dass es eine Feinabstimmung erfordert, um die Faktoren herauszufinden, die zum gewünschten Ergebnis führen. Es geht einfach darum, verschiedene Werte auszuprobieren, um zu sehen, welcher Wert Sie dem gewünschten Ergebnis näherbringt.

Reciprocal Rank Fusion in hybrid search & Go client

Reciprocal Rank Fusion, oder RRF, wurde in Elasticsearch 8.9 als technische Vorschau für die hybride Suche veröffentlicht. Ziel ist es, den Lernaufwand für die Feinabstimmung zu reduzieren und den Zeitaufwand für das Experimentieren mit Faktoren zur Optimierung des Ergebnissatzes zu verringern.

Bei RRF wird die Dokumentenbewertung durch Mischen der Bewertungen mithilfe des folgenden Algorithmus neu berechnet:

score := 0.0 // q is a query in the set of queries (vector and keyword search) for _, q := range queries { // result(q) is the results if document in result(q) { // k is a ranking constant (default 60) // rank(result(q), d) is the document's rank within result(q) // range from 1 to the window_size (default 100) score += 1.0 / (k + rank(result(q), d)) } } return score

Der Vorteil der Verwendung von RRF besteht darin, dass wir die sinnvollen Standardwerte in Elasticsearch nutzen können. Die Rangkonstante k ist standardmäßig auf 60 gesetzt. Um einen Kompromiss zwischen der Relevanz der zurückgegebenen Dokumente und der Abfrageleistung bei der Suche in großen Datensätzen zu erzielen, ist die Größe des Ergebnissatzes für jede betrachtete Abfrage auf den Wert window_size begrenzt, der standardmäßig auf 100 eingestellt ist, wie in der Dokumentation beschrieben.

k und windows_size kann auch innerhalb der Rrf -Konfiguration innerhalb der Rank -Methode im Go-Client konfiguriert werden, wie im folgenden Beispiel gezeigt:

func HybridSearchWithRRF(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 // Minimum required window size for the default result size of 10 var windowSize int64 = 10 var rankConstant int64 = 42 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ Field: "text_embedding.predicted_value", K: &k, NumCandidates: &numCandidates, QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": {Query: term}, }, }). Rank(&types.RankContainer{ Rrf: &types.RrfRank{ WindowSize: &windowSize, RankConstant: &rankConstant, }, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Fazit

Hier haben wir besprochen, wie man Vektor- und Stichwortsuche in Elasticsearch mithilfe des Elasticsearch Go-Clients kombiniert.

Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Falls Sie es noch nicht getan haben, schauen Sie sich Teil 1 und Teil 2 an, um den gesamten Code dieser Serie zu finden.

Viel Spaß bei der Gopherjagd!

Ressourcen

Führen Sie eine Vektorsuche in Elasticsearch mit dem Elasticsearch Go-Client durch.

Carly Richmond,Laurent Saint-Félix — Wed, 01 Nov 2023 00:00:00 GMT

Softwareentwicklung in jeder Programmiersprache, einschließlich Go, bedeutet die Verpflichtung zu lebenslangem Lernen. Während ihrer Universitäts- und Berufslaufbahn hat Carly mit vielen Programmiersprachen und Technologien experimentiert, darunter auch mit den neuesten und besten Implementierungen der Vektorsuche. Aber das reichte nicht! Seit Kurzem spielt auch Carly Go.

Genau wie Tiere, Programmiersprachen und Ihr freundlicher Autor hat sich auch die Suche im Laufe der Zeit weiterentwickelt und verschiedene Praktiken hervorgebracht, bei denen es schwierig sein kann, die richtige für Ihren individuellen Anwendungsfall zu finden. In diesem Blog geben wir einen Überblick über die Vektorsuche und zeigen Beispiele für die einzelnen Ansätze mit Elasticsearch und dem Elasticsearch Go-Client. Anhand dieser Beispiele wird Ihnen gezeigt, wie Sie mit Hilfe der Vektorsuche in Elasticsearch und Go Taschenratten finden und deren Nahrung bestimmen können.

Voraussetzungen

Um diesem Beispiel folgen zu können, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Installation von Go Version 1.21 oder höher
Erstellung eines eigenen Go-Repositorys mit dem
Erstellung eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud.
Cluster-URL, Benutzername, Passwort und Zertifikat.

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

Die client -Verbindung kann dann für die Vektorsuche verwendet werden, wie in den nachfolgenden Abschnitten gezeigt wird.

Vektorsuche

Die Vektorsuche versucht, dieses Problem zu lösen, indem sie das Suchproblem in einen mathematischen Vergleich mithilfe von Vektoren umwandelt. Der Dokumenteneinbettungsprozess beinhaltet einen zusätzlichen Schritt, bei dem das Dokument mithilfe eines Modells in eine dichte Vektordarstellung oder einfach in einen Zahlenstrom umgewandelt wird. Der Vorteil dieses Ansatzes besteht darin, dass man auch nicht-textuelle Dokumente wie Bilder und Audiodateien durchsuchen kann, indem man sie zusammen mit einer Suchanfrage in einen Vektor übersetzt.

Vereinfacht ausgedrückt ist die Vektorsuche eine Reihe von Vektordistanzberechnungen. In der folgenden Abbildung wird die Vektordarstellung unserer Anfrage Go Gophermit den Dokumenten im Vektorraum verglichen, und die nächstliegenden Ergebnisse (gekennzeichnet durch die Konstante k) werden zurückgegeben:

Je nachdem, welcher Ansatz zur Generierung der Einbettungen für Ihre Dokumente verwendet wird, gibt es zwei verschiedene Wege, um herauszufinden, was Taschenratten fressen.

Ansatz 1: Bringen Sie Ihr eigenes Modell mit

Mit einer Platinum-Lizenz ist es möglich, die Einbettungen innerhalb von Elasticsearch zu generieren, indem das Modell hochgeladen und die Inferenz-API verwendet wird. Die Einrichtung des Modells umfasst sechs Schritte:

Wählen Sie ein PyTorch-Modell aus einem Modell-Repository zum Hochladen aus. Für dieses Beispiel verwenden wir den sentence-transformers/msmarco-MiniLM-L-12-v3 von Hugging Face, um die Einbettungen zu generieren.
Laden Sie das Modell in Elastic mit dem Eland Machine Learning Client für Python unter Verwendung der Anmeldeinformationen für unseren Elasticsearch-Cluster und dem Aufgabentyp text_embeddings. Falls Eland nicht installiert ist, können Sie den Import-Schritt mit Docker ausführen, wie unten gezeigt:

docker run -it --rm --network host \ docker.elastic.co/eland/eland \ eland_import_hub_model \ --cloud-id $ELASTIC_CLOUD_ID \ --es-api-key $ELASTIC_API_KEY \ --hub-model-id sentence-transformers/msmarco-MiniLM-L-12-v3 \ --task-type text_embedding

Nach dem Hochladen sollte das Modell sentence-transformers__msmarco-minilm-l-12-v3 schnell mit einem Beispieldokument getestet werden, um sicherzustellen, dass die Einbettungen wie erwartet generiert werden:

Erstellen Sie eine Ingest-Pipeline, die einen Inferenzprozessor enthält. Dadurch kann die Vektordarstellung mithilfe des hochgeladenen Modells generiert werden:

PUT _ingest/pipeline/search-rodents-vector-embedding-pipeline { "processors": [ { "inference": { "model_id": "sentence-transformers__msmarco-minilm-l-12-v3", "target_field": "text_embedding", "field_map": { "body_content": "text_field" } } } ] }

Erstellen Sie einen neuen Index, der das Feld text_embedding.predicted_value vom Typ dense_vector enthält, um die für jedes Dokument generierten Vektoreinbettungen zu speichern:

PUT vector-search-rodents { "mappings": { "properties": { "text_embedding.predicted_value": { "type": "dense_vector", "dims": 384, "index": true, "similarity": "cosine" }, "text": { "type": "text" } } } }

Die Dokumente werden mithilfe der neu erstellten Ingest-Pipeline neu indiziert, um die Text-Embeddings als zusätzliches Feld text_embedding.predicted_value in jedem Dokument zu generieren:

POST _reindex { "source": { "index": "search-rodents" }, "dest": { "index": "vector-search-rodents", "pipeline": "search-rodents-vector-embedding-pipeline" } }

Nun können wir die Option Knn in derselben Such-API mit dem neuen Index vector-search-rodents verwenden, wie im folgenden Beispiel gezeigt:

func VectorSearch(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ # Field in document containing vector Field: "text_embedding.predicted_value", # Number of neighbors to return K: &k, # Number of candidates to evaluate in comparison NumCandidates: &numCandidates, # Generate query vector using the same model used in the inference processor QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}).Do(context.Background()) if err != nil { return nil, fmt.Errorf("error in rodents vector search: %w", err) } return getRodents(res.Hits.Hits) }

Die Konvertierung des JSON-Ergebnisobjekts mittels Unmarshalling erfolgt auf genau die gleiche Weise wie im Beispiel der Stichwortsuche. Mithilfe der Konstanten K und NumCandidates können wir die Anzahl der zurückzugebenden Nachbardokumente und die Anzahl der pro Shard zu berücksichtigenden Kandidaten konfigurieren. Beachten Sie, dass eine Erhöhung der Anzahl der Kandidaten zwar die Genauigkeit der Ergebnisse erhöht, aber zu einer längeren Abfragedauer führt, da mehr Vergleiche durchgeführt werden.

Wird der Code mit der Abfrage What do Gophers eat? ausgeführt, sehen die zurückgegebenen Ergebnisse ähnlich wie unten dargestellt aus, was verdeutlicht, dass der Gopher-Artikel im Gegensatz zur vorherigen Stichwortsuche die angeforderten Informationen enthält:

[ {ID:64f74ecd4acb3df024d91112 Title:Gopher - Wikipedia Url:https://en.wikipedia.org/wiki/Gopher} {ID:64f74ed34acb3d71aed91fcd Title:Squirrel - Wikipedia Url:https://en.wikipedia.org/wiki/Squirrel} //Other results omitted ]

Ansatz 2: Hugging Face Inference API

Eine weitere Möglichkeit besteht darin, diese Einbettungen außerhalb von Elasticsearch zu generieren und sie als Teil Ihres Dokuments einzubinden. Da diese Option keinen Elasticsearch Machine Learning-Knoten verwendet, kann sie im kostenlosen Tarif durchgeführt werden.

Hugging Face stellt eine kostenlose, ratenbegrenzte Inferenz-API zur Verfügung, mit der Sie mithilfe eines Kontos und eines API-Tokens dieselben Einbettungen manuell für Experimente und Prototyping generieren können, um Ihnen den Einstieg zu erleichtern. Für den Einsatz in der Produktion wird es nicht empfohlen. Das lokale Aufrufen eigener Modelle zur Generierung von Einbettungen oder die Nutzung der kostenpflichtigen API kann ebenfalls mit einem ähnlichen Ansatz erfolgen.

In der folgenden Funktion GetTextEmbeddingForQuery verwenden wir die Inferenz-API anhand unserer Abfragezeichenfolge, um den Vektor zu generieren, der von einer POST Anfrage an den Endpunkt zurückgegeben wird:

// HuggingFace text embedding helper func GetTextEmbeddingForQuery(term string) []float32 { // HTTP endpoint model := "sentence-transformers/msmarco-minilm-l-12-v3" posturl := fmt.Sprintf("https://api-inference.huggingface.co/pipeline/feature-extraction/%s", model) // JSON body body := []byte(fmt.Sprintf(`{ "inputs": "%s", "options": {"wait_for_model":True} }`, term)) // Create a HTTP post request r, err := http.NewRequest("POST", posturl, bytes.NewBuffer(body)) if err != nil { log.Fatal(err) return nil } token := os.Getenv("HUGGING_FACE_TOKEN") r.Header.Add("Authorization", fmt.Sprintf("Bearer %s", token)) client := &http.Client{} res, err := client.Do(r) if err != nil { panic(err) } defer res.Body.Close() var post []float32 derr := json.NewDecoder(res.Body).Decode(&post) if derr != nil { log.Fatal(derr) return nil } return post }

Der resultierende Vektor vom Typ []float32 wird dann als QueryVector übergeben, anstatt die Option QueryVectorBuilder zu verwenden, um das zuvor in Elastic hochgeladene Modell zu nutzen.

func VectorSearchWithGeneratedQueryVector(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { vector, err := GetTextEmbeddingForQuery(term) if err != nil { return nil, err } if vector == nil { return nil, fmt.Errorf("unable to generate vector: %w", err) } var k = 10 var numCandidates = 10 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ # Field in document containing vector Field: "text_embedding.predicted_value", # Number of neighbors to return K: &k, # Number of candidates to evaluate in comparison NumCandidates: &numCandidates, # Query vector returned from Hugging Face inference API QueryVector: vector, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Beachten Sie, dass die Optionen K und NumCandidates unabhängig von den beiden Optionen gleich bleiben und dass die gleichen Ergebnisse generiert werden, da wir dasselbe Modell zur Generierung der Einbettungen verwenden.

Fazit

Hier haben wir besprochen, wie man eine Vektorsuche in Elasticsearch mit dem Elasticsearch Go-Client durchführt. Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Im Anschluss daran lesen Sie Teil 3, um einen Überblick über die Kombination der Vektorsuche mit den in Teil eins behandelten Schlüsselwortsuchfunktionen in Go zu erhalten.

Bis dahin, viel Erfolg bei der Gopherjagd!

Ressourcen

Führen Sie Textabfragen mit dem Elasticsearch Go-Client durch.

Carly Richmond,Laurent Saint-Félix — Tue, 31 Oct 2023 00:00:00 GMT

Softwareentwicklung in jeder Programmiersprache, einschließlich Go, bedeutet die Verpflichtung zu lebenslangem Lernen. Während ihrer gesamten Universitäts- und Berufslaufbahn musste sich Carly an die Polyglotte anpassen und sich mit vielen Programmiersprachen auseinandersetzen, darunter Python, C, JavaScript, TypeScript und Java. Aber das reichte nicht! Seit Kurzem spielt sie auch Go!

Genau wie Tiere, Programmiersprachen und auch einige Ihrer Lieblingsautoren hat sich die Suche im Laufe der Zeit weiterentwickelt und verschiedene Vorgehensweisen hervorgebracht, bei denen es schwierig sein kann, die richtige für Ihren individuellen Anwendungsfall zu finden. In diesem Blog geben wir einen Überblick über die traditionelle Stichwortsuche und stellen ein Beispiel mit Elasticsearch und dem Elasticsearch Go-Client vor.

Voraussetzungen

Um diesem Beispiel folgen zu können, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Installation von Go Version 1.21 oder höher
Erstellen Sie Ihr eigenes Go-Repository gemäß der in der Go-Dokumentationbeschriebenen empfohlenen Struktur und Paketverwaltung.
Erstellung eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud.
Cluster-URL, Benutzername, Passwort und Zertifikat.

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

Die client -Verbindung kann dann, wie später gezeigt wird, für die Suche verwendet werden.

Stichwortsuche

Die Stichwortsuche ist die grundlegende Suchart, mit der wir seit der Entwicklung von Archie, der ersten dokumentierten Internet-Suchmaschine aus dem Jahr 1990, vertraut sind.

Ein zentraler Bestandteil der Stichwortsuche ist die Übersetzung von Dokumenten in einen invertierten Index. Genau wie das Register am Ende eines Lehrbuchs enthält ein invertiertes Register eine Zuordnung zwischen einer Liste von Tokens und deren Position in jedem Dokument. Das folgende Diagramm zeigt die wichtigsten Schritte der Indexerstellung:

Wie oben dargestellt, umfasst die Token-Generierung in Elasticsearch drei Hauptphasen:

Entfernen unnötiger Zeichen durch Null oder mehr char_filters. In unserem Beispiel entfernen wir HTML-Elemente innerhalb des Feldes body_content mithilfe des Filters html_strip .
Die Tokens werden mithilfe des standard Tokenizers vom Inhalt getrennt, wobei die Trennung anhand von Leerzeichen und Satzzeichen erfolgt.
Unerwünschte Tokens werden aus dem Ausgabestream des Tokenizers entfernt oder Tokens mithilfe von null oder mehr filter -Optionen transformiert, z. B. durch den lowercase -Tokenfilter oder Stemmer wie den snowball -Stemmer , um Tokens wieder in ihre Sprachwurzel umzuwandeln.

Suche in Elasticsearch mit Go

Bei Abfragen mit dem Go-Client geben wir den zu durchsuchenden Index an und übergeben die Abfrage sowie weitere Optionen, wie im folgenden Beispiel:

func KeywordSearch(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { res, err := client.Search(). Index("search-rodents"). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": {Query: term}, }, }). From(0). Size(10). Do(context.Background()) if err != nil { return nil, fmt.Errorf("could not search for rodents: %w", err) } return getRodents(res.Hits.Hits) }

Im obigen Beispiel führen wir eine Standardabfrage matchdurch, um alle Dokumente in unserem Index zu finden, die die an unsere Funktion übergebene Zeichenkette enthalten. Beachten Sie, dass wir über Do(context.Background()) einen neuen leeren Kontext an die Suchausführung übergeben. Darüber hinaus werden alle von Elasticsearch zurückgegebenen Fehler zur Protokollierung und Fehlerbehandlung an das Attribut err ausgegeben.

Die Ergebnisse werden in res.Hits.Hits zurückgegeben, wobei das Attribut _Source das Dokument selbst im JSON-Format enthält. Um diese Quelle in eine Go-kompatible Struktur umzuwandeln, müssen wir die JSON-Antwort mithilfe des Go -Pakets encoding/json deserialisieren, wie im folgenden Beispiel gezeigt:

func getRodents(hits []types.Hit) ([]Rodent, error) { var rodents []Rodent for _, hit := range hits { var currentRodent Rodent err := json.Unmarshal(hit.Source_, ¤tRodent) if err != nil { return nil, fmt.Errorf("an error occurred while unmarshaling rodent %s: %w", hit.Id_, err) } currentRodent.ID = hit.Id_ rodents = append(rodents, currentRodent) } return rodents, nil }

Die Suche und das Unmarshalling der Anfrage gopher liefert wie erwartet die Wikipedia-Seite für Gopher zurück:

[ {ID:64f74ecd4acb3df024d91112 Title:Gopher - Wikipedia Url:https://en.wikipedia.org/wiki/Gopher} ]

Wenn wir jedoch What do Gophers eat? fragen, erhalten wir nicht ganz die gewünschten Ergebnisse:

[]

Eine einfache Stichwortsuche ermöglicht es, Ergebnisse performant an Ihre Go-Anwendung zurückzugeben, und zwar auf eine Weise, die wir von den Anwendungen, die wir verwenden, gewohnt sind. Es eignet sich auch hervorragend für exakte Suchbegriffübereinstimmungen, die für Szenarien wie die Suche nach einem bestimmten Unternehmen oder Begriff relevant sind.

Wie wir oben sehen, hat es jedoch aufgrund des Vokabular-Diskrepanzen Probleme, Kontext und Semantik zu identifizieren. Darüber hinaus stellt die Unterstützung von Nicht-Text-Dateiformaten wie Bildern und Audiodateien eine Herausforderung dar.

Fazit

Hier haben wir besprochen, wie man mit dem Elasticsearch Go-Client herkömmliche Textabfragen in Elasticsearch durchführt. Da Go häufig für die Skripterstellung im Infrastrukturbereich und den Aufbau von Webservern verwendet wird, ist es nützlich zu wissen, wie man in Go sucht.

Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Im Anschluss daran folgt Teil 2, um einen Überblick über die Vektorsuche und deren Durchführung in Go zu erhalten. Bis dahin, viel Erfolg bei der Gopherjagd!