Laurent Saint-Félix - Elasticsearch Labs

Einführung der Elasticsearch-Unterstützung in der Google MCP Toolbox for Databases

Enrico Zimuel,Laurent Saint-Félix — Fri, 12 Dec 2025 00:00:00 GMT

In diesem Artikel zeigen wir Ihnen, wie Sie die Google MCP Toolbox mit Elasticsearch nutzen, um ein einfaches Tool zur Extraktion von Informationen aus einem Elasticsearch-Index zu erstellen.

Wir haben vor Kurzem zum Open-Source-Projekt Google MCP Toolbox for Databases beigetragen, indem wir Unterstützung für Elasticsearch als Datenbank hinzugefügt haben.

Mit diesem neuen Feature können Sie jetzt die Google MCP Toolbox verwenden, um eine Verbindung zu Elasticsearch herzustellen und direkt mit Ihren Daten zu „kommunizieren“.

Elasticsearch

Wir benötigen eine laufende Elasticsearch-Instanz. Sie können eine kostenlose Testversion auf Elastic Cloud aktivieren oder es lokal mit dem start-local-Skript installieren:

curl -fsSL https://elastic.co/start-local | sh

Dadurch werden Elasticsearch und Kibana auf Ihrem Computer installiert und ein API-Schlüssel generiert, der zur Konfiguration der Google MCP Toolbox verwendet wird.

Der API-Schlüssel wird als Ausgabe des vorherigen Befehls angezeigt und in einer .env-Datei im Ordner elastic-start-local gespeichert.

Installieren Sie den Beispieldatensatz

Nach der Installation können Sie sich mit dem Benutzernamen elastic und dem vom start-local-Skript generierten Passwort (gespeichert in einer .env-Datei) bei Kibana anmelden.

Sie können den Datensatz für E-Commerce-Bestellungen , der von Kibana verfügbar ist, installieren. Sie enthält einen einzigen Index namens kibana_sample_data_ecommerce, der Informationen über 4.675 Bestellungen von einer E-Commerce-Website enthält. Für jede Bestellung haben wir folgende Informationen:

Kundeninformationen (Name, Ausweis, Geburtsdatum, E-Mail-Adresse usw.)
Bestelldatum
Bestell-ID
Produkte (Liste aller Produkte mit Preis, Menge, ID, Kategorie, Rabatt usw.)
SKU
Gesamtpreis (ohne Steuern, mit Steuern)
Gesamtmenge
Geoinformationen (Stadt, Land, Kontinent, Ort, Region)

Um die Beispieldaten zu installieren, öffnen Sie die Seite Integrationen in Kibana (suchen Sie in der Suchleiste oben nach „Integration“) und installieren Sie die „Beispieldaten“. Weitere Details finden Sie in der Dokumentation hier: https://www.elastic.co/docs/explore-analyze/#gs-get-data-into-kibana.

Ziel dieses Artikels ist es, zu zeigen, wie einfach es ist, die Google MCP Toolbox so zu konfigurieren, dass sie sich mit Elasticsearch verbindet und mit dem kibana_sample_data_ecommerce-Index in natürlicher Sprache interagiert.

Google MCP Toolbox

Die Google MCP Toolbox ist ein Open-Source-MCP-Server, der entwickelt wurde, um Anwendungen und KI-Agenten die sichere und effiziente Interaktion mit Datenbanken zu erleichtern. Das Projekt, das zuvor unter dem Namen „GenAI Toolbox for Databases“ bekannt war, wurde nach der vollständigen Kompatibilität mit dem Model Context Protocol (MCP) umbenannt. Ziel ist es, den üblicherweise beim Verbinden von Agenten mit Datenbanken erforderlichen hohen Aufwand zu reduzieren, indem Verbindungspooling, Authentifizierung, Beobachtbarkeit und andere betriebliche Belange im Hintergrund übernommen werden.

Im Kern ermöglicht es die Toolbox Entwicklern, wiederverwendbare, hochwertige Werkzeuge zu definieren, die Datenbankinteraktionen kapseln. Diese Tools können dann von jedem MCP-kompatiblen Client – wie beispielsweise einem KI-Agenten – aufgerufen werden, ohne dass der Client Low-Level-SQL-Abfragen implementieren oder Datenbankverbindungen verwalten muss. Dieser Ansatz reduziert die Menge an Boilerplate-Code, die für den Aufbau datenbankbewusster Agenten benötigt wird, drastisch und ermöglicht die Integration fortgeschrittener Datenoperationen in nur wenigen Anwendungszeilen. Sobald ein Werkzeug definiert ist, kann es von mehreren Agenten, Frameworks oder Sprachen gemeinsam genutzt werden (Abbildung 1).

Ein großer Vorteil der Nutzung der Toolbox ist das integrierte Sicherheitsmodell. Authentifizierungsabläufe wie OAuth2 und OIDC werden nativ unterstützt, sodass Entwickler:innen die Verarbeitung oder Speicherung sensibler Datenbankzugangsdaten in Agenten vermeiden können. Die Plattform bietet außerdem Beobachtbarkeit-Features – einschließlich Metriken und Tracing – über OpenTelemetry, was für Debugging, Monitoring und Deployments in der Produktionsumgebung unerlässlich ist. Insgesamt dient die MCP Toolbox als einheitliche, sichere und erweiterbare Schnittstelle zur Interaktion mit Ihren Daten von jedem MCP-fähigen System.

So installieren Sie die MCP Toolbox

Sie können den MCP-Toolbox-Server unter Linux mit folgendem Befehl installieren:

export VERSION=0.21.0 curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox chmod +x toolbox

Für eine Installation unter macOS oder Windows können Sie den hier beschriebenen Anweisungen folgen.

Toolbox für Elasticsearch konfigurieren

Um die MCP Toolbox für Elasticsearch zu konfigurieren, müssen wir eine tools.yaml-Datei erstellen, und zwar wie folgt:

sources: my-cluster: kind: elasticsearch addresses: - http://localhost:9200 apikey: tools: customer-orders: kind: elasticsearch-esql source: my-cluster description: Get the orders made by a customer identified by name. query: | FROM kibana_sample_data_ecommerce | WHERE MATCH(customer_full_name, ?name, {"operator": "AND"}) parameters: - name: name type: string description: The customer name. toolsets: elasticsearch-tools: - customer-orders

Sie müssen den Wert durch einen gültigen Elasticsearch-API-Schlüssel ersetzen. Wenn Sie Elasticsearch lokal mit start-local ausführen, finden Sie den API-Schlüssel in der von start-local generierten .env-Datei unter der Variable ES_LOCAL_API_KEY. Wenn Sie Elastic Cloud verwenden, können Sie einen API-Schlüssel generieren, indem Sie das hier beschriebene Verfahren befolgen.

Die vorherigen Tools enthalten die folgende ES|QL-Abfrage für Elasticsearch:

Falls Ihnen ES|QL nicht geläufig ist: Es handelt sich um eine von Elastic entwickelte Abfragesprache, die ähnlich wie SQL funktioniert und mit der man einen oder mehrere Indizes durchsuchen kann. Mehr über ES|QL finden Sie in der offiziellen Dokumentation hier.

Die obige Abfrage sucht nach allen im kibana_sample_data_ecommerce-Index gespeicherten Bestellungen, die den Namen des:der angegebenen Kund:in enthalten, und verwendet den ?name-Parameter (das Fragezeichen bezeichnet einen Parameter).

Der Name des Kunden wird in der vorherigen YAML-Konfiguration mit dem Typ „Zeichenfolge“ und der Beschreibung „Der Name des Kunden“ definiert.

Mit diesem Tool können Fragen zu den Bestellungen eines:einer Kund:in beantwortet werden – zum Beispiel: Wie viele Bestellungen hat Kund:in Foo im Oktober 2025 aufgegeben?

Die Beschreibungen der Werkzeuge und ihrer Parameter sind unerlässlich, um die relevanten Informationen aus der natürlichsprachlichen Anfrage des:der Nutzer:in zu extrahieren. Diese Extraktion erfolgt mithilfe der Funktionsaufruf-Funktion eines Large Language Models (LLM). In der Praxis kann ein LLM bestimmen, welche Funktion (welches Werkzeug) ausgeführt werden muss, um die notwendigen Informationen zu erhalten, sowie die entsprechenden Parameter für diese Funktion.

Für weitere Informationen zu Funktionsaufrufen empfehlen wir, den Artikel OpenAI Function Calling with Elasticsearch von Ashish Tiwari zu lesen.

Führen Sie den Toolbox-Server aus

Sie können die MCP Toolbox unter Verwendung der vorherigen tools.yaml-Datei mit folgendem Befehl ausführen:

./toolbox --tools-file tools.yaml --ui

Der Parameter –ui führt eine Webanwendung unter http://127.0.0.1:5000/ui aus (Abbildung 2).

Sie können die Option Tools > customer-orders auswählen und im Feld Parametername einen Kundennamen eingeben (z. B. Gwen Sanders) und anschließend auf die Schaltfläche Tool ausführen klicken. Sie sollten eine JSON-Reaktion sehen, wie in Abbildung 3 dargestellt.

Die Einrichtung ist abgeschlossen, und die MCP Toolbox kann das Tool customer-orders ausführen, um mit Elasticsearch zu kommunizieren und dabei die ES|QL-Anfrage auszuführen.

Verwendung der MCP Toolbox mit Gemini CLI

Wir können jeden beliebigen MCP-Client verwenden, um mit der MCP Toolbox für Datenbanken zu kommunizieren. Zum Beispiel können wir Gemini CLI verwenden, ein Befehlszeilen-Tool zur Nutzung von Gemini. Sie können die Gemini CLI gemäß den hier beschriebenen Anweisungen installieren.

Gemini CLI bietet eine vorkonfigurierte Erweiterung für die MCP Toolbox an, verfügbar unter gemini-cli-extensions/mcp-toolbox. Sie können diese Erweiterung installieren, indem Sie folgenden Befehl ausführen:

gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox

Nach der Installation müssen Sie in das Verzeichnis gehen, in dem Sie die Konfigurationsdatei tools.yaml für die MCP Toolbox gespeichert haben, und Gemini CLI wie folgt ausführen (dieser Schritt ist erforderlich, damit die Gemini-CLI automatisch mit der MCP-Toolbox konfiguriert wird):

gemini

In Abbildung 4 sollten Sie eine Ausgabeanzeige sehen.

Mit dem folgenden Befehl können Sie überprüfen, ob die MCP Toolbox verbunden ist:

/mcp list

Sie sollten die mcp_toolbox mit den aufgelisteten Tools customer-orders sehen (Abbildung 5).

Wenn die MCP Toolbox mit der Gemini CLI verbunden ist, können wir nun versuchen, einige Fragen zu stellen, wie zum Beispiel: „ Gib mir die Bestellungen für die Kundin Gwen Sanders.“ Anschließend fordert die Gemini CLI die Berechtigung an, das Tool customer-orders vom Server mcp_toolbox auszuführen (siehe Abbildung 6).

Nach der Bestätigung führt Gemini CLI die Anfrage an die MCP Toolbox aus und erhält als Ergebnis eine JSON-Reaktion, die zur Formatierung der Reaktion verwendet wird (Abbildung 7).

Die Reaktion von Gemini CLI wird berichten, dass Gwen Sanders lediglich eine Bestellung über zwei Produkte zum Gesamtpreis von 132 Euro aufgegeben hat.

MCP Toolbox SDKs

Die Google MCP Toolbox bietet außerdem ein SDK an, um alle Funktionen eines in Go, Python und Javascript geschriebenen Programms abzurufen.

Das Python SDK ist beispielsweise auf GitHub unter folgender Seite verfügbar: https://github.com/googleapis/mcp-toolbox-sdk-python.

Wir müssen einen einfachen Agenten erstellen, der mit der MCP Toolbox verbunden werden kann. Wir müssen die folgenden Pakete installieren:

pip install toolbox-core pip install google-adk

Und erstellen Sie ein neues Agentenprojekt mit folgendem Befehl:

adk create my_agent

Dadurch wird ein neues Verzeichnis namens my_agent mit einer Datei agent.py erstellt.

Aktualisieren Sie my_agent/agent.py mit dem folgenden Inhalt, um eine Verbindung zu Toolbox herzustellen:

from google.adk import Agent from google.adk.apps import App from toolbox_core import ToolboxSyncClient client = ToolboxSyncClient("http://127.0.0.1:5000") root_agent = Agent( name='root_agent', model='gemini-2.5-flash', instruction="You are a helpful AI assistant designed to search information about a dataset of ecommerce orders.", tools=client.load_toolset(), ) app = App(root_agent=root_agent, name="my_agent")

Erstellen Sie eine .env-Datei mit Ihrem Google API-Schlüssel:

echo 'GOOGLE_API_KEY="YOUR_API_KEY"' > my_agent/.env

Schließlich können wir den Agenten ausführen und die Ergebnisse beobachten. Um den Agenten auszuführen, können Sie folgenden Befehl ausführen:

adk run my_agent

Alternativ können Sie ihn über eine Webschnittstelle bereitstellen:

adk web --port 8000

In beiden Tickets können Sie mit der MCP Toolbox über eine Q&A-Schnittstelle interagieren. Sie können zum Beispiel die vorherige Frage stellen: Geben Sie mir die Bestellungen der Kundin Gwen Sanders.

Weitere Informationen zu den verschiedenen SDKs finden Sie auf dieser Dokumentationsseite.

Fazit

In diesem Artikel haben wir die Elasticsearch-Integration für die Google MCP Toolbox for Databases demonstriert. Mithilfe einer einfachen YAML-Konfigurationsdatei können wir eine Reihe von Tools definieren, die Fragen in natürlicher Sprache mithilfe der ES|QL-Sprache in Elasticsearch-Abfragen übersetzen.

Wir haben gezeigt, wie man mit dem Datensatz kibana_sample_data_ecommerce interagiert, der Bestellungen von einer Website enthält. Mit dieser Konfigurationsdatei können wir den MCP Toolbox-Server einfach ausführen und uns von jedem MCP-Client aus mit ihm verbinden.

Abschließend haben wir gezeigt, wie man die Gemini-CLI als Client nutzt, um sich mit der MCP Toolbox for Databases zu verbinden und die in Elasticsearch gespeicherten E-Commerce-Daten abzufragen. Wir haben eine Abfrage in natürlicher Sprache ausgeführt, um Informationen über Bestellungen für eine:n bestimmte:n, namentlich identifizierte:n Kund:in abzurufen.

Während das MCP-Ökosystem weiter wächst, schafft dieses Muster – leichte Werkzeugdefinitionen mit sicherer, produktionsreifer Infrastruktur – neue Möglichkeiten, immer leistungsfähigere, datenbewusste Agenten mit minimalem Aufwand zu entwickeln. Ob Sie nun lokal mit den Elastic-Beispieldatensätzen experimentieren oder Suchfunktionen in eine größere Anwendung integrieren, die MCP Toolbox bietet eine zuverlässige, erweiterbare Grundlage für die Interaktion mit Ihren Elasticsearch-Daten unter Verwendung natürlicher Sprache.

Weitere Informationen zur Entwicklung agentischer KI-Anwendungen finden Sie im Artikel Building AI Agentic Workflows with Elasticsearch von Anish Mathur und Dana Juratoni.

Weitere Informationen über die Google MCP Toolbox finden Sie unter https://googleapis.github.io/genai-toolbox/getting-started/introduction/.

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!