<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
  <channel>
    <title><![CDATA[Laurent Saint-Félix - Elasticsearch Labs]]></title>
    <description><![CDATA[Articles and tutorials from the Search team at Elastic]]></description>
    <copyright><![CDATA[© 2026. Elasticsearch B.V. All Rights Reserved]]></copyright>
    <image>
      <title><![CDATA[Laurent Saint-Félix - Elasticsearch Labs]]></title>
      <url>https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt1121c0bf0e8a6e65/6a88da6340a1841030ef456f/search-labs-thumbnail.png</url>
      <link>https://www.elastic.co/fr/search-labs/author/laurent-saint-felix</link>
    </image>
    <link>https://www.elastic.co/fr/search-labs/author/laurent-saint-felix</link>
    <atom:link href="https://www.elastic.co/fr/search-labs/rss/author/laurent-saint-felix.xml" rel="self" type="application/rss+xml"/>
    <language><![CDATA[fr]]></language>
    <lastBuildDate>Mon, 21 Sep 2026 19:50:27 GMT</lastBuildDate>
  <item>
    <title><![CDATA[Présentation de la prise en charge d'Elasticsearch dans Google MCP Toolbox for Databases]]></title>
    <description><![CDATA[Découvrez les caractéristiques de la prise en charge d'Elasticsearch maintenant disponible dans Google MCP Toolbox for Databases et utilisez les outils ES|QL pour intégrer en toute sécurité votre index à n'importe quel client MCP.]]></description>
    <content:encoded><![CDATA[<p>Dans cet article, nous allons expliquer comment utiliser Google MCP Toolbox avec <a href="https://github.com/elastic/elasticsearch">Elasticsearch</a> pour créer un outil simple permettant d'extraire des informations d'un index Elasticsearch.</p><p>Nous avons récemment contribué au projet open source <a href="https://github.com/googleapis/genai-toolbox">Google MCP Toolbox for Databases</a> en ajoutant la prise en charge d'Elasticsearch en tant que base de données.</p><p>Grâce à cette nouvelle fonctionnalité, vous pouvez désormais utiliser Google MCP Toolbox pour vous connecter à Elasticsearch et "dialoguer" directement avec vos données.</p><h2>Elasticsearch</h2><p>Nous avons besoin d'une instance Elasticsearch en cours d'exécution. Vous pouvez activer un essai gratuit sur <a href="https://www.elastic.co/cloud">Elastic Cloud</a> ou l'installer localement via le script <a href="https://github.com/elastic/start-local">start-local</a> :</p>curl -fsSL https://elastic.co/start-local | sh<p>Cela installera Elasticsearch et Kibana sur votre ordinateur et générera une clé API à utiliser pour configurer Google MCP Toolbox.</p><p>La clé API sera affichée comme sortie de la commande précédente et stockée dans un fichier .env dans le dossier elastic-start-local.</p><h2>Installer l'ensemble de données d'exemple</h2><p>Après l'installation, connectez-vous à Kibana en utilisant le nom d'utilisateur <em>elastic</em> et le mot de passe généré par le script "start-local" (stocké dans un fichier .env).</p><p>Vous pouvez installer l'ensemble de données <strong>eCommerce orders </strong>disponible dans Kibana. Il comprend un seul index nommé <strong>kibana_sample_data_ecommerce</strong> contenant des informations sur 4 675 commandes provenant d'un site web. Pour chaque commande, nous disposons des informations suivantes :</p><ul><li><p>Informations client (nom, identifiant, date de naissance, e-mail, etc.)</p></li><li><p>Date de la commande</p></li><li><p>ID de la commande</p></li><li><p>Produits (liste de tous les produits avec prix, quantité, ID, catégorie, réduction, etc.)</p></li><li><p>SKU</p></li><li><p>Prix total (hors taxes, taxes incluses)</p></li><li><p>Quantité totale</p></li><li><p>Informations géographiques (ville, pays, continent, localisation, région)</p></li></ul><p>Pour installer les données d'exemple, ouvrez la page <strong>Intégrations</strong> dans Kibana (recherchez "Integration" dans la barre de recherche supérieure), puis installez l'ensemble de données "Sample Data". Pour plus de détails, consultez la documentation ici : <a href="https://www.elastic.co/docs/explore-analyze/#gs-get-data-into-kibana">https://www.elastic.co/docs/explore-analyze/#gs-get-data-into-kibana</a>.</p><p>Cet article a pour but de montrer combien il est facile de configurer Google MCP Toolbox pour se connecter à Elasticsearch et interagir avec l'index <strong>kibana_sample_data_ecommerce</strong> en utilisant le langage naturel.</p><h2>Google MCP Toolbox</h2><p>Google MCP Toolbox est un serveur MCP open source conçu pour faciliter l'interaction sécurisée et efficace des applications et des agents IA avec les bases de données. Auparavant appelé "GenAI Toolbox for Databases", le projet a été renommé après l'adoption d'une compatibilité totale avec le protocole <a href="https://www.anthropic.com/news/model-context-protocol">MCP</a> (Model Context Protocol). Son objectif est de supprimer les tâches complexes traditionnellement requises lors de la connexion d'agents à des bases de données en gérant en arrière-plan les pools de connexion, l'authentification, l'observabilité et d'autres aspects opérationnels.</p><p>Essentiellement, la boîte à outils permet aux développeurs de définir des outils réutilisables de haut niveau qui encapsulent les interactions avec la base de données. Ces outils peuvent ensuite être invoqués par n'importe quel client compatible MCP, tel qu'un agent IA, sans que le client n'ait à implémenter des requêtes SQL de bas niveau ni à gérer des connexions de base de données. Cette approche réduit considérablement la quantité de code répétitif nécessaire à la création d'agents compatibles avec les bases de données, permettant ainsi d'intégrer des opérations de données avancées en seulement quelques lignes de logique applicative. Une fois qu'un outil est défini, il peut être partagé entre plusieurs agents, frameworks, ou langages (Figure 1).</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blte90070297ee83546/6a16fa29964cea694b08b972/137cea290bb70ad5da21853f9a6358cef4cf7451-1248x1056.png" alt="" /><p>L'un des principaux avantages de la boîte à outils est le modèle de sécurité intégré. Les flux d'authentification tels que OAuth2 et OIDC sont pris en charge de manière native, ce qui permet aux développeurs d'éviter de manipuler ou de stocker des informations sensibles d'identification de base de données dans les agents. La plateforme fournit également des fonctionnalités d'observabilité via OpenTelemetry, y compris les métriques et le traçage, ce qui est essentiel pour le débogage, la surveillance et les déploiements en production. De manière générale, MCP Toolbox sert d'interface unifiée, sécurisée et extensible pour interagir avec vos données depuis n'importe quel système compatible MCP.</p><h2>Comment installer MCP Toolbox</h2><p>Vous pouvez installer le serveur MCP Toolbox sur Linux en utilisant la commande suivante :</p>export VERSION=0.21.0
curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox<p>Si vous souhaitez l'installer sur macOS ou Windows, vous pouvez suivre les instructions <a href="https://googleapis.github.io/genai-toolbox/getting-started/introduction/#installing-the-server">détaillées ici</a>.</p><h2>Configurer Toolbox pour Elasticsearch</h2><p>Pour configurer MCP Toolbox pour Elasticsearch, nous devons créer un fichier <strong>tools.yaml</strong> comme suit :</p>sources:
  my-cluster:
    kind: elasticsearch
    addresses:
      - http://localhost:9200
    apikey: &lt;insert-here-api-key&gt;

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<p>Vous devez remplacer la valeur <strong>&lt;insert-here-api-key&gt;</strong> par une clé API Elasticsearch valide. Si vous exécutez Elasticsearch localement avec la commande "start-local", vous trouverez la clé API dans le fichier .env généré par start-local, sous la variable <strong>ES_LOCAL_API_KEY</strong>. Si vous utilisez Elastic Cloud, vous pouvez générer une clé API en suivant la procédure <a href="https://www.elastic.co/docs/deploy-manage/api-keys/elastic-cloud-api-keys">décrite ici</a>.</p><p>Les outils précédents contiennent la requête ES|QL suivante pour Elasticsearch :</p><p>Si vous ne connaissez pas ES|QL, il s'agit d'un langage de requête développé par Elastic, similaire à SQL, qui peut être utilisé pour effectuer des recherches sur un ou plusieurs indices. Pour en savoir plus sur ES|QL, consultez la documentation officielle <a href="https://www.elastic.co/docs/reference/query-languages/esql">ici</a>.</p><p>La requête ci-dessus recherche toutes les commandes stockées dans l'index <strong>kibana_sample_data_ecommerce</strong> qui contiennent le nom du client spécifié, en utilisant le paramètre <strong>?name</strong> (le point d'interrogation indique un paramètre).</p><p>Le nom du client est défini dans la configuration YAML précédente en utilisant le type chaîne et la description "The customer name" (nom du client).</p><p>Cet outil peut être utilisé pour répondre à des questions sur les commandes d'un client, par exemple : <em>Combien de commandes le client Foo a-t-il passées en octobre 2025 ?</em></p><p>Les descriptions des outils et de leurs paramètres sont essentielles pour extraire les informations pertinentes de la requête en langage naturel de l'utilisateur. Cette extraction est réalisée à l'aide de la capacité d'<strong>appel de fonctions</strong> d'un grand modèle de langage (LLM). En pratique, un LLM peut déterminer quelle fonction (outil) doit être exécutée pour obtenir les informations nécessaires, ainsi que les paramètres appropriés pour cette fonction.</p><p>Pour plus d'informations sur les appels de fonctions, nous vous invitons à lire l'article <a href="https://www.elastic.co/search-labs/blog/function-calling-with-elastic">OpenAI function calling with Elasticsearch</a> (en anglais) par Ashish Tiwari.</p><h2>Exécuter le serveur Toolbox</h2><p>Vous pouvez exécuter le serveur MCP Toolbox à l'aide du fichier "tools.yaml" précédent avec la commande suivante :</p>./toolbox --tools-file tools.yaml --ui<p>Le paramètre<strong> –ui</strong> exécute une application web à l'adresse <a href="http://127.0.0.1:5000/ui">http://127.0.0.1:5000/ui</a> (Figure 2).</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt0fb3953fae603572/6a16fa2aa6c2b92763e794fb/3caf2339b632bafd5847af1ed8b33b518a25b8a2-1600x314.png" alt="" /><p>Sélectionnez <strong>Tools</strong> (Outils) &gt; <strong>customer-orders</strong> et insérez un nom de client dans le paramètre <strong>name</strong> (par ex. Gwen Sanders), puis cliquez sur le bouton <strong>Run Tool</strong> (Exécuter l'outil). Une réponse JSON devrait s'afficher comme illustré dans la figure 3.</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltca02df8c78cb39ff/6a16fa2c961e6909b5c4cd22/b167e0142afb8919d9cedf6d0fa431d33d0e55f8-1600x933.png" alt="" /><p>La configuration est terminée et MCP Toolbox peut exécuter l'outil <strong>customer-orders</strong> pour communiquer avec Elasticsearch, en lançant la requête ES|QL.</p><h2>Utiliser MCP Toolbox avec Gemini CLI</h2><p>Nous pouvons utiliser n'importe quel client MCP pour communiquer avec MCP Toolbox for Databases. Par exemple, nous pouvons choisir <a href="https://github.com/google-gemini/gemini-cli">Gemini CLI</a>, un outil en ligne de commande permettant d'utiliser Gemini. Si vous souhaitez installer Gemini CLI, suivez les instructions <a href="https://geminicli.com/docs/get-started/installation/">indiquées ici</a>.</p><p>Gemini CLI propose une extension préconfigurée pour MCP Toolbox, disponible sur <a href="https://github.com/gemini-cli-extensions/mcp-toolbox">gemini-cli-extensions/mcp-toolbox</a>. Vous pouvez installer cette extension en exécutant la commande suivante :</p>gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox<p>Après l'installation, vous devez accéder au répertoire dans lequel vous avez stocké le fichier de configuration "tools.yaml" pour MCP Toolbox et exécuter Gemini CLI comme suit (cette étape est nécessaire pour que Gemini CLI soit automatiquement configuré avec MCP Toolbox) :</p>gemini<p>Un message de sortie devrait s'afficher comme illustré dans la figure 4.</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltf7245c10b9e32cd6/6a16fa2d964cea073208b976/0f22df6d3da13c1dc50dcb560414fa7c630eb9a7-1434x341.png" alt="" /><p>Vous pouvez vérifier si la boîte à outils MCP est connectée en utilisant la commande suivante :</p>/mcp list<p>Vous devriez voir s'afficher <strong>mcp_toolbox</strong> avec les outils<strong> customer-orders</strong> répertoriés (Figure 5).</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blte857b42dbe604203/6a16fa2f8b73cb531b189e33/97edbc40de9e44f469f6f3a09427532be167de0e-493x155.png" alt="" /><p>Si MCP Toolbox est connecté à Gemini CLI, nous pouvons maintenant poser quelques questions, telles que : "<em>Indiquez-moi les commandes pour la cliente Gwen Sanders</em>". Gemini CLI demande alors l'autorisation d'exécuter l'outil "customer-orders" depuis le serveur mcp_toolbox (voir Figure 6).</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltfb7ea752c1a39da7/6a16fa30cdacbfdf937d27ff/c052f3b5e49436903b804280c0065f67ee02444b-1432x284.png" alt="" /><p>Après confirmation, Gemini CLI exécute la requête dans MCP Toolbox, reçoit une réponse JSON et l'utilise pour mettre en forme la réponse (Figure 7).</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltb9f6e04987137a9f/6a16fa320811ae2297e9fef7/7ea5128f1705951c2757af6da4b456d394d4a080-1432x734.png" alt="" /><p>La réponse de Gemini CLI indique que Gwen Sanders a passé une seule commande de 2 produits, pour un prix total de 132 EUR.</p><h2>SDK MCP Toolbox</h2><p>Google MCP Toolbox propose également un SDK pour accéder à toutes les fonctionnalités depuis un programme écrit en Go, Python et Javascript.</p><p>Par exemple, le SDK Python est disponible sur Github à la page suivante : <a href="https://github.com/googleapis/mcp-toolbox-sdk-python">https://github.com/googleapis/mcp-toolbox-sdk-python</a>.</p><p>Nous devons créer un agent simple pour nous connecter à MCP Toolbox. Nous devons installer les packages suivants :</p>pip install toolbox-core
pip install google-adk<p>Et créer un nouveau projet d'agent à l'aide la commande suivante :</p>adk create my_agent<p>Cela créera un nouveau répertoire nommé <strong>my_agent</strong> contenant un fichier <strong>agent.py</strong>.</p><p>Mettez à jour le fichier <strong>my_agent/agent.py</strong> avec le contenu suivant pour vous connecter à Toolbox :</p>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")<p>Créez un fichier <strong>.env</strong> avec votre clé API Google :</p>echo 'GOOGLE_API_KEY="YOUR_API_KEY"' &gt; my_agent/.env<p>Enfin, nous pouvons lancer l'exécution de l'agent et observer les résultats. Pour ce faire, exécutez la commande suivante :</p>adk run my_agent<p>Ou, vous pouvez le servir via une interface web :</p>adk web --port 8000<p>Dans les deux cas, vous pouvez interagir avec MCP Toolbox à l'aide d'une interface de questions-réponses. Par exemple, vous pouvez poser la question précédente : <em>Indiquez-moi les commandes de la cliente Gwen Sanders</em>.</p><p>Pour plus d'informations sur les différents SDK, consultez cette <a href="https://googleapis.github.io/genai-toolbox/sdks/">page de documentation</a>.</p><h2>Conclusion</h2><p>Dans cet article, nous avons démontré l'intégration d'Elasticsearch pour Google MCP Toolbox for Databases. À l'aide d'un simple fichier de configuration YAML, nous pouvons définir un ensemble d'outils qui traduisent les questions en langage naturel en requêtes Elasticsearch en utilisant le langage ES|QL.</p><p>Nous avons montré comment interagir avec l'ensemble de données "kibana_sample_data_ecommerce", qui contient des commandes provenant d'un site web. Avec ce fichier de configuration, nous pouvons simplement lancer l'exécution du serveur MCP Toolbox et nous y connecter depuis n'importe quel client MCP.</p><p>Enfin, nous avons démontré comment utiliser Gemini CLI en tant que client pour nous connecter à MCP Toolbox for Databases et interroger les données e-commerce stockées dans Elasticsearch. Nous avons exécuté une requête en langage naturel pour récupérer des informations sur les commandes d'un client spécifique identifié par son nom.</p><p>À mesure que l'écosystème MCP se développe, ce modèle – des définitions d'outils légères soutenues par une infrastructure sécurisée et prête pour la production – crée de nouvelles possibilités pour construire des agents de plus en plus performants et sensibles aux données avec un minimum d'efforts. Qu'il s'agisse d'expérimenter localement les ensembles de données Elastic ou d'intégrer des fonctionnalités de recherche dans une application plus vaste, MCP Toolbox fournit une base fiable et extensible pour interagir avec vos données Elasticsearch en langage naturel.</p><p>Pour en savoir plus sur le développement d'applications d'IA agentique, consultez l'article <a href="https://search-labs-redesign.vercel.app/search-labs/blog/ai-agentic-workflows-elastic-ai-agent-builder">Construire des workflows d'IA agentique avec Elasticsearch</a> par Anish Mathur et Dana Juratoni.</p><p>Pour plus d'informations sur Google MCP Toolbox, consultez la page <a href="https://googleapis.github.io/genai-toolbox/getting-started/introduction/">vhttps://googleapis.github.io/genai-toolbox/getting-started/introduction/</a>.</p>]]></content:encoded>
    <link>https://www.elastic.co/search-labs/blog/google-mcp-toolbox-elasticsearch-support</link>
    <guid isPermaLink="true">https://www.elastic.co/search-labs/blog/google-mcp-toolbox-elasticsearch-support</guid>
    <category><![CDATA[ES|QL]]></category>
    <category><![CDATA[IA agentique]]></category>
    <dc:creator><![CDATA[Enrico Zimuel,Laurent Saint-Félix]]></dc:creator>
    <enclosure url="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt72d49893c51407cf/6a16fa33cf4f2502bab2cf7e/425a48691f436ed47c9bdfaf5d561ac122b2c472-1062x668.png" length="0" type="image/png"/>
    <pubDate>Fri, 12 Dec 2025 00:00:00 GMT</pubDate>
  </item>
  <item>
    <title><![CDATA[Utiliser la recherche hybride pour la chasse aux gophers avec Elasticsearch et Go]]></title>
    <description><![CDATA[Apprenez à réaliser une recherche hybride en combinant la recherche par mot-clé et la recherche vectorielle à l'aide d'Elasticsearch et du client Elasticsearch Go.]]></description>
    <content:encoded><![CDATA[<p>Dans les parties précédentes de cette série, il a été démontré comment utiliser le client Elasticsearch Go pour la <a href="https://www.elastic.co/search-labs/blog/perform-text-queries-with-the-elasticsearch-go-client">recherche traditionnelle par mot-clé</a> et la <a href="https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client">recherche vectorielle</a>. Cette troisième partie traite de la recherche hybride. Nous partagerons des <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch">exemples de</a> la façon dont vous pouvez combiner la recherche vectorielle et la recherche par mot-clé en utilisant <a href="https://www.elastic.co/elasticsearch/">Elasticsearch</a> et le <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a></p><h2>Produits requis</h2><p>Tout comme dans la première partie de cette série, les conditions suivantes sont requises pour cet exemple :</p><ol><li><p>Installation de Go version 1.21 ou ultérieure</p></li><li><p>Créez votre propre répertoire Go en utilisant la structure recommandée et la gestion des paquets décrite dans la <a href="https://go.dev/doc/code">documentation Go.</a></p></li><li><p>Création de votre propre cluster Elasticsearch, alimenté par un ensemble de <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch#sources">pages sur les rongeurs</a>, y compris notre sympathique <a href="https://en.wikipedia.org/wiki/Gopher">Gopher</a>, tiré de Wikipédia :</p></li></ol><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt6a436c42996e5172/6a1704cf0c48573d1c01a957/34fa81a9b4c292634c719b8303a9b6b7506d7920-1440x662.png" alt="Page Gopher de Wikipedia" /><h2>Connexion à Elasticsearch</h2><p>Pour rappel, dans nos exemples, nous utiliserons l'<a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/typedapi.html">API typée</a> proposée par le client Go. Pour établir une connexion sécurisée pour n'importe quelle requête, il faut configurer le client en utilisant l'une ou l'autre des méthodes suivantes :</p><ol><li><p>ID du nuage et clé API si vous utilisez Elastic Cloud</p></li><li><p>URL du cluster, nom d'utilisateur, mot de passe et certificat</p></li></ol><p>La connexion à notre cluster situé sur Elastic Cloud ressemblerait à ceci :</p>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:  &amp;elastictransport.ColorLogger{os.Stdout, true, true},
	})

	if err != nil {
		return nil, fmt.Errorf("unable to connect: %w", err)
	}

	return es, nil
}
<p>La connexion <code>client</code> peut alors être utilisée pour la recherche, comme le montrent les sections suivantes.</p><h2>Renforcement manuel pour la recherche hybride</h2><p>Lors de la combinaison d'un ensemble d'algorithmes de recherche, l'approche traditionnelle consiste à configurer manuellement des constantes pour stimuler chaque type de requête. Plus précisément, un facteur est spécifié pour chaque requête, et l'ensemble des résultats combinés est comparé à l'ensemble prévu pour déterminer le rappel de la requête. Nous répétons ensuite l'opération pour plusieurs ensembles de facteurs et choisissons celui qui se rapproche le plus de l'état souhaité.</p><p>Par exemple, la combinaison d'une requête de recherche textuelle unique augmentée d'un facteur de <code>0.8</code> avec une requête knn avec un facteur inférieur de <code>0.2</code> peut être réalisée en spécifiant le champ <code>Boost</code> dans les deux types de requêtes, comme le montre l'exemple ci-dessous :</p>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:         &amp;knnBoost,
			K:             &amp;k,
			NumCandidates: &amp;numCandidates,
			QueryVectorBuilder: &amp;types.QueryVectorBuilder{
				TextEmbedding: &amp;types.TextEmbedding{
					ModelId:   "sentence-transformers__msmarco-minilm-l-12-v3",
					ModelText: term,
				},
			}}).
		Query(&amp;types.Query{
			Match: map[string]types.MatchQuery{
				"title": {
					Query: term,
					Boost: &amp;queryBoost,
				},
			},
		}).
		Do(context.Background())

	if err != nil {
		return nil, err
	}

	return getRodents(res.Hits.Hits)
}
<p>Le facteur spécifié dans l'option <code>Boost</code> pour chaque requête est ajouté au score du document. En augmentant le score de notre requête par un facteur plus important que celui de la requête knn, les résultats de la requête par mot-clé sont plus fortement pondérés.</p><p>La difficulté du renforcement manuel, en particulier si vous n'êtes pas un expert en recherche, réside dans le fait qu'il nécessite une mise au point pour déterminer les facteurs qui conduiront à l'ensemble de résultats souhaité. Il s'agit simplement d'essayer des valeurs aléatoires pour voir ce qui vous rapproche de l'ensemble des résultats souhaités.</p><h2>Fusion de rangs réciproques dans la recherche hybride &amp; Go client</h2><p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html">Reciprocal Rank Fusion</a>, ou RRF, a été publié en avant-première technique pour la recherche hybride dans Elasticsearch 8.9. Il vise à réduire la courbe d'apprentissage associée à la mise au point et à réduire le temps passé à expérimenter des facteurs pour optimiser l'ensemble des résultats.</p><p>Avec la méthode RRF, le score du document est recalculé en combinant les scores par l'algorithme ci-dessous :</p>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
<p>L'avantage de l'utilisation de RRF est que nous pouvons utiliser les valeurs par défaut d'Elasticsearch. La constante de classement <code>k</code> est remplacée par défaut par <code>60</code>. Afin de trouver un compromis entre la pertinence des documents renvoyés et les performances de la requête lors de la recherche sur de grands ensembles de données, la taille de l'ensemble de résultats pour chaque requête considérée est limitée à la valeur de <code>window_size</code>, qui est fixée par défaut à <code>100</code> comme indiqué dans la <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html#rrf-api">documentation</a>.</p><p><code>k</code> et <code>windows_size</code> peuvent également être configurés dans la configuration <code>Rrf</code> dans la méthode <code>Rank</code> dans le client Go, comme dans l'exemple ci-dessous :</p>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:             &amp;k,
			NumCandidates: &amp;numCandidates,
			QueryVectorBuilder: &amp;types.QueryVectorBuilder{
				TextEmbedding: &amp;types.TextEmbedding{
					ModelId:   "sentence-transformers__msmarco-minilm-l-12-v3",
					ModelText: term,
				},
			}}).
		Query(&amp;types.Query{
			Match: map[string]types.MatchQuery{
				"title": {Query: term},
			},
		}).
		Rank(&amp;types.RankContainer{
			Rrf: &amp;types.RrfRank{
				WindowSize:   &amp;windowSize,
				RankConstant: &amp;rankConstant,
			},
		}).
		Do(context.Background())

	if err != nil {
		return nil, err
	}

	return getRodents(res.Hits.Hits)
}
<h2>Conclusion</h2><p>Nous avons vu ici comment combiner la recherche vectorielle et la recherche par mot-clé dans Elasticsearch à l'aide du <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a></p><p>Consultez le <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch">repo GitHub</a> pour tout le code de cette série. Si vous ne l'avez pas encore fait, consultez les <a href="https://www.elastic.co/search-labs/blog/perform-text-queries-with-the-elasticsearch-go-client">parties 1</a> et <a href="https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client">2</a> pour connaître tous les codes de cette série.</p><p><em>Bonne chasse aux marmottes !</em></p><h2>Ressources</h2><ol><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html">Guide Elasticsearch</a></p></li><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">Client Elasticsearch Go</a></p></li><li><p><a href="https://www.elastic.co/what-is/vector-search">Qu'est-ce que la recherche vectorielle ? | Elastique</a></p></li><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html">Fusion de rangs réciproques</a></p></li></ol>]]></content:encoded>
    <link>https://www.elastic.co/search-labs/blog/hybrid-search-with-the-elasticsearch-go-client</link>
    <guid isPermaLink="true">https://www.elastic.co/search-labs/blog/hybrid-search-with-the-elasticsearch-go-client</guid>
    <category><![CDATA[Base vectorielle]]></category>
    <category><![CDATA[Go]]></category>
    <dc:creator><![CDATA[Carly Richmond,Laurent Saint-Félix]]></dc:creator>
    <enclosure url="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltdcae959696d55a9b/6a1704d5ab7f085a56db9d7c/491ef9efbb30b253e1d9e3b7f816a9a23c8f5264-721x420.jpg" length="0" type="image/jpeg"/>
    <pubDate>Thu, 02 Nov 2023 00:00:00 GMT</pubDate>
  </item>
  <item>
    <title><![CDATA[Effectuer une recherche vectorielle dans Elasticsearch avec le client Elasticsearch Go]]></title>
    <description><![CDATA[Apprenez à effectuer une recherche vectorielle dans Elasticsearch en utilisant le client Elasticsearch Go à travers un exemple pratique.]]></description>
    <content:encoded><![CDATA[<p>Construire un logiciel dans n'importe quel langage de programmation, y compris Go, c'est s'engager dans une vie d'apprentissage. Tout au long de sa carrière universitaire et professionnelle, Carly a touché à de nombreux langages et technologies de programmation, y compris les dernières et meilleures implémentations de la recherche vectorielle. Mais ce n'était pas suffisant ! Récemment, Carly a commencé à jouer avec Go.</p><p>Tout comme les animaux, les langages de programmation et votre sympathique auteur, la recherche a connu une évolution des différentes pratiques qu'il peut être difficile de choisir pour votre propre cas d'utilisation de la recherche. Dans ce blog, nous présenterons une vue d'ensemble de la recherche vectorielle ainsi que des <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch">exemples</a> de chaque approche en utilisant <a href="https://www.elastic.co/elasticsearch/">Elasticsearch</a> et le <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a> Ces exemples vous montreront comment trouver des spermophiles et déterminer ce qu'ils mangent en utilisant la recherche vectorielle dans Elasticsearch et Go.</p><h2>Produits requis</h2><p>Pour suivre cet exemple, assurez-vous que les conditions préalables suivantes sont remplies :</p><ol><li><p>Installation de Go version 1.21 ou ultérieure</p></li><li><p>Création de votre propre repo Go avec l'outil</p></li><li><p>Création de votre propre cluster Elasticsearch, peuplé d'un ensemble de pages sur les rongeurs, y compris pour notre sympathique <a href="https://en.wikipedia.org/wiki/Gopher">Gopher</a>, à partir de Wikipedia :</p></li></ol><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt6a436c42996e5172/6a1704cf0c48573d1c01a957/34fa81a9b4c292634c719b8303a9b6b7506d7920-1440x662.png" alt="Page Gopher de Wikipedia" /><h2>Connexion à Elasticsearch</h2><p>Dans nos exemples, nous utiliserons l'<a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/typedapi.html">API typée</a> proposée par le client Go. Pour établir une connexion sécurisée pour n'importe quelle requête, il faut configurer le client en utilisant l'une ou l'autre des méthodes suivantes :</p><ol><li><p>ID du nuage et clé API si vous utilisez Elastic Cloud.</p></li><li><p>URL du cluster, nom d'utilisateur, mot de passe et certificat.</p></li></ol><p>La connexion à notre cluster situé sur Elastic Cloud ressemblerait à ceci :</p>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:  &amp;elastictransport.ColorLogger{os.Stdout, true, true},
	})

	if err != nil {
		return nil, fmt.Errorf("unable to connect: %w", err)
	}

	return es, nil
}
<p>La connexion <code>client</code> peut ensuite être utilisée pour la recherche vectorielle, comme nous le verrons dans les sections suivantes.</p><h2>Recherche vectorielle</h2><p>La recherche vectorielle tente de résoudre ce problème en convertissant le problème de recherche en une comparaison mathématique utilisant des vecteurs. Le processus d'intégration de documents comporte une étape supplémentaire consistant à convertir le document à l'aide d'un modèle en une représentation vectorielle dense, ou simplement en un flux de nombres. L'avantage de cette approche est qu'elle permet de rechercher des documents non textuels, tels que des images et des fichiers audio, en les traduisant en un vecteur accompagné d'une requête.</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltc4b3b9b2ad1e8f46/6a1704d06234e0800fdb1927/b113358093e367358d684f7aaf0a6684ebb2d0dd-1440x653.png" alt="Diagramme de recherche vectorielle" /><p>En termes simples, la recherche vectorielle est un ensemble de calculs de distances vectorielles. Dans l'illustration ci-dessous, la représentation vectorielle de notre requête <code>Go Gopher</code>est comparée aux documents de l'espace vectoriel et les résultats les plus proches (désignés par la constante <code>k</code>) sont renvoyés :</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt5c736ecfc49bb038/6a1704d2cf4f25bcb6b2d075/54a17a4b41029644e7c66f33d428e8d01a6f4ce3-1184x743.png" alt="Exemple d'espace vectoriel Gopher" /><p>En fonction de l'approche utilisée pour générer les enchâssements de vos documents, il y a deux façons différentes de savoir ce que mangent les spermophiles.</p><h3>Approche 1 : Apportez votre propre modèle</h3><p>Avec une licence Platinum, il est possible de générer les embeddings dans Elasticsearch en téléchargeant le modèle et en utilisant l'API d'inférence. La mise en place du modèle se fait en six étapes :</p><ol><li><p>Sélectionnez un modèle PyTorch à télécharger à partir d'un référentiel de modèles. Pour cet exemple, nous utilisons les <a href="https://huggingface.co/sentence-transformers/msmarco-MiniLM-L-12-v3">phrase-transformers/msmarco-MiniLM-L-12-v3</a> de Hugging Face pour générer les embeddings.</p></li><li><p>Charger le modèle dans Elastic à l'aide du <a href="https://www.elastic.co/guide/en/elasticsearch/client/eland/current/overview.html">client Eland Machine Learning pour Python</a> en utilisant les informations d'identification de notre cluster Elasticsearch et le type de tâche <code>text_embeddings</code>. Si Eland n'est pas installé, vous pouvez <a href="https://www.elastic.co/guide/en/machine-learning/current/ml-nlp-import-model.html#ml-nlp-import-docker">exécuter l'étape d'importation à l'aide de Docker</a>, comme indiqué ci-dessous :</p></li></ol>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
<ol><li><p>Une fois téléchargé, testez rapidement le modèle <code>sentence-transformers__msmarco-minilm-l-12-v3</code> avec un exemple de document pour vous assurer que les enchâssements sont générés comme prévu :</p></li></ol><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt8a399e1f50ecfdaf/6a1704d4ab7f08935edb9d78/fbbdde621361a487eb07304bed029c228d0f7aa6-1440x789.png" alt="Exemple de modèle entraîné Elastic Test" /><ol><li><p>Créer un pipeline d'ingestion contenant un processeur d'inférence. Cela permettra de générer la représentation vectorielle à l'aide du modèle téléchargé :</p></li></ol>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"
        }
      }
    }
  ]
}
<ol><li><p>Créer un nouvel index contenant le champ <code>text_embedding.predicted_value</code> de type <code>dense_vector</code> pour stocker les encastrements vectoriels générés pour chaque document :</p></li></ol>PUT vector-search-rodents
{
  "mappings": {
    "properties": {
      "text_embedding.predicted_value": {
        "type": "dense_vector",
        "dims": 384,
        "index": true,
        "similarity": "cosine"
      },
      "text": {
        "type": "text"
      }
    }
  }
}
<ol><li><p>Réindexer les documents à l'aide du pipeline d'acquisition nouvellement créé pour générer les enchâssements de texte en tant que champ supplémentaire <code>text_embedding.predicted_value</code> sur chaque document :</p></li></ol>POST _reindex
{
  "source": {
    "index": "search-rodents"
  },
  "dest": {
    "index": "vector-search-rodents",
    "pipeline": "search-rodents-vector-embedding-pipeline"
  }
}
<p>Nous pouvons maintenant utiliser l'option <code>Knn</code> sur la même API de recherche en utilisant le nouvel index <code>vector-search-rodents</code>, comme le montre l'exemple ci-dessous :</p>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:             &amp;k,
      # Number of candidates to evaluate in comparison
			NumCandidates: &amp;numCandidates,
      # Generate query vector using the same model used in the inference processor
			QueryVectorBuilder: &amp;types.QueryVectorBuilder{
				TextEmbedding: &amp;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)
}
<p>La conversion de l'objet de résultat JSON par unmarshalling se fait exactement de la même manière que dans l'exemple de la recherche par mot-clé. Les constantes <code>K</code> et <code>NumCandidates</code> nous permettent de configurer le nombre de documents voisins à renvoyer et le nombre de candidats à prendre en compte par tesson. Il est à noter que l'augmentation du nombre de candidats accroît la précision des résultats, mais entraîne une requête plus longue, car davantage de comparaisons sont effectuées.</p><p>Lorsque le code est exécuté à l'aide de la requête <code>What do Gophers eat?</code>, les résultats renvoyés sont similaires à ceux présentés ci-dessous, ce qui montre que l'article Gopher contient les informations demandées, contrairement à la recherche par mot-clé précédente :</p>[
  {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
]
<h3>Approche 2 : Inférence du visage étreint API</h3><p>Une autre option consiste à générer ces mêmes embeddings en dehors d'Elasticsearch et à les intégrer dans votre document. Comme cette option n'utilise pas de nœud d'apprentissage automatique Elasticsearch, elle peut être réalisée sur le niveau gratuit.</p><p>Hugging Face expose une <a href="https://huggingface.co/docs/api-inference/index">API d'inférence</a> gratuite et limitée dans le temps qui, avec un compte et un jeton API, peut être utilisée pour générer manuellement les mêmes enchâssements à des fins d'expérimentation et de prototypage pour vous aider à démarrer. Il n'est pas recommandé pour une utilisation en production. Une approche similaire permet d'invoquer localement vos propres modèles pour générer des embeddings ou d'utiliser l'API payante.</p><p>Dans la fonction <code>GetTextEmbeddingForQuery</code> ci-dessous, nous utilisons l'API d'inférence avec notre chaîne de requête pour générer le vecteur renvoyé par une requête <code>POST</code> au point final :</p>// 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 := &amp;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(&amp;post)

    if derr != nil {
        log.Fatal(derr)
        return nil
    }

    return post
}
<p>Le vecteur résultant, de type <code>[]float32</code>, est alors transmis en tant que <code>QueryVector</code> au lieu d'utiliser l'option <code>QueryVectorBuilder</code> pour exploiter le modèle précédemment téléchargé dans Elastic.</p>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:             &amp;k,
      # Number of candidates to evaluate in comparison
			NumCandidates: &amp;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)
}
<p>Notez que les options <code>K</code> et <code>NumCandidates</code> restent les mêmes quelles que soient les deux options et que les mêmes résultats sont générés car nous utilisons le même modèle pour générer les encastrements.</p><h2>Conclusion</h2><p>Nous avons vu ici comment effectuer une recherche vectorielle dans Elasticsearch en utilisant le <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a> Consultez le <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch">repo GitHub</a> pour tout le code de cette série. Suivez la <a href="https://www.elastic.co/search-labs/blog/hybrid-search-with-the-elasticsearch-go-client">partie 3</a> pour avoir une vue d'ensemble de la combinaison de la recherche vectorielle avec les capacités de recherche par mot-clé abordées dans la <a href="https://www.elastic.co/search-labs/blog/perform-text-queries-with-the-elasticsearch-go-client">partie 1</a> de Go.</p><p>D'ici là, bonne chasse aux marmottes !</p><h2>Ressources</h2><ol><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html">Guide Elasticsearch</a></p></li><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">Client Elasticsearch Go</a></p></li><li><p><a href="https://www.elastic.co/what-is/vector-search">Qu'est-ce que la recherche vectorielle ? | Elastique</a></p></li></ol>]]></content:encoded>
    <link>https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client</link>
    <guid isPermaLink="true">https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client</guid>
    <category><![CDATA[Base vectorielle]]></category>
    <category><![CDATA[Go]]></category>
    <dc:creator><![CDATA[Carly Richmond,Laurent Saint-Félix]]></dc:creator>
    <enclosure url="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltdcae959696d55a9b/6a1704d5ab7f085a56db9d7c/491ef9efbb30b253e1d9e3b7f816a9a23c8f5264-721x420.jpg" length="0" type="image/jpeg"/>
    <pubDate>Wed, 01 Nov 2023 00:00:00 GMT</pubDate>
  </item>
  <item>
    <title><![CDATA[Effectuer des requêtes textuelles avec le client Elasticsearch Go]]></title>
    <description><![CDATA[Apprenez à effectuer des requêtes textuelles traditionnelles dans Elasticsearch en utilisant le client Elasticsearch Go à travers un exemple pratique.]]></description>
    <content:encoded><![CDATA[<p>Construire un logiciel dans n'importe quel langage de programmation, y compris Go, c'est s'engager dans une vie d'apprentissage. Tout au long de sa carrière universitaire et professionnelle, Carly a dû s'adapter au fait d'être polyglotte et de toucher à de nombreux langages de programmation, notamment Python, C, JavaScript, TypeScript et Java. Mais ce n'était pas suffisant ! Récemment, elle a commencé à jouer avec Go !</p><p>Tout comme les animaux, les langages de programmation et l'un de vos sympathiques auteurs, la recherche a connu une évolution des différentes pratiques qu'il peut être difficile de choisir pour votre propre cas d'utilisation de la recherche. Dans ce blog, nous présenterons une vue d'ensemble de la recherche traditionnelle par mot-clé ainsi qu'<a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch">un exemple</a> utilisant <a href="https://www.elastic.co/elasticsearch/">Elasticsearch</a> et le <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a></p><h2>Produits requis</h2><p>Pour suivre cet exemple, assurez-vous que les conditions préalables suivantes sont remplies :</p><ol><li><p>Installation de Go version 1.21 ou ultérieure</p></li><li><p>Créez votre propre répertoire Go en utilisant la structure recommandée et la gestion des paquets décrite dans la <a href="https://go.dev/doc/code">documentation Go.</a></p></li><li><p>Création de votre propre cluster Elasticsearch, peuplé d'un ensemble de <a href="https://github.com/carlyrichmond/gopher-hunting-elasticsearch#sources">pages sur les rongeurs</a>, y compris notre sympathique <a href="https://en.wikipedia.org/wiki/Gopher">Gopher</a>, tiré de Wikipedia :</p></li></ol><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt6a436c42996e5172/6a1704cf0c48573d1c01a957/34fa81a9b4c292634c719b8303a9b6b7506d7920-1440x662.png" alt="Page Gopher de Wikipedia" /><h2>Connexion à Elasticsearch</h2><p>Dans nos exemples, nous utiliserons l'<a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/typedapi.html">API typée</a> offerte par le client Go. Pour établir une connexion sécurisée pour n'importe quelle requête, il faut configurer le client en utilisant l'une ou l'autre des méthodes suivantes :</p><ol><li><p>ID du nuage et clé API si vous utilisez Elastic Cloud.</p></li><li><p>URL du cluster, nom d'utilisateur, mot de passe et certificat.</p></li></ol><p>La connexion à notre cluster situé sur Elastic Cloud ressemblerait à ceci :</p>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:  &amp;elastictransport.ColorLogger{os.Stdout, true, true},
	})

	if err != nil {
		return nil, fmt.Errorf("unable to connect: %w", err)
	}

	return es, nil
}
<p>La connexion <code>client</code> peut alors être utilisée pour la recherche, comme indiqué plus loin.</p><h2>Recherche par mot-clé</h2><p>La recherche par mot-clé est le type de recherche fondamental que nous connaissons depuis la création d'<a href="https://en.wikipedia.org/wiki/Archie_(search_engine)">Archie</a>, le premier moteur de recherche Internet documenté écrit en 1990.</p><p>La traduction des documents en un index inversé est un élément central de la recherche par mots-clés. Exactement comme l'index que l'on trouve à la fin d'un manuel, un index inversé contient une correspondance entre une liste de mots clés et leur emplacement dans chaque document. Le diagramme ci-dessous montre les étapes clés de la création de l'indice :</p><img src="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt366681a12027f14b/6a17e7aa1d1b831c2093e452/9cd7b2a60d9aa54facb37738b821bba6ca925830-1440x581.png" alt="Génération d'un index inversé" /><p>Comme indiqué ci-dessus, la génération de jetons dans Elasticsearch comprend trois étapes clés :</p><ol><li><p>Suppression des caractères inutiles via zéro ou plusieurs <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-charfilters.html"><code>char_filters</code></a>. Dans notre exemple, nous supprimons les éléments HTML dans le champ <code>body_content</code> via le filtre <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-htmlstrip-charfilter.html"><code>html_strip</code></a>.</p></li><li><p>Séparation des tokens du contenu avec le <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-tokenizers.html"><code>standard</code></a><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-tokenizers.html"> tokenizer,</a> qui séparera les tokens en fonction de l'espacement et de la ponctuation clé.</p></li><li><p>Suppression des tokens indésirables ou transformation des tokens du flux de sortie du tokenizer à l'aide de zéro ou plusieurs <code>filter</code> options, telles que le <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-lowercase-tokenfilter.html"><code>lowercase</code></a><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-lowercase-tokenfilter.html"> filtre de</a> tokens ou des stemmers tels que le <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-snowball-tokenfilter.html"><code>snowball</code></a><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-snowball-tokenfilter.html"> stemmer</a> pour transformer les tokens en leur racine linguistique.</p></li></ol><h2>Rechercher dans Elasticsearch avec Go</h2><p>Lors d'une requête avec le client Go, nous spécifions l'index que nous voulons rechercher et nous transmettons la requête et d'autres options, comme dans l'exemple ci-dessous :</p>func KeywordSearch(client *elasticsearch.TypedClient, term string) ([]Rodent, error) {
	res, err := client.Search().
		Index("search-rodents").
		Query(&amp;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)
}
<p>Dans l'exemple ci-dessus, nous effectuons une <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html"><code>match</code></a><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html"> requête</a> standard pour trouver tout document dans notre index qui contient la chaîne de caractères spécifiée dans notre fonction. Notez que nous transmettons un <a href="https://pkg.go.dev/context#Background">nouveau contexte vide</a> à l'exécution de la recherche via <code>Do(context.Background())</code>. En outre, toutes les erreurs renvoyées par Elasticsearch sont transmises à l'attribut <code>err</code> à des fins de journalisation et de gestion des erreurs.</p><p>Les résultats sont renvoyés sous la forme <code>res.Hits.Hits</code>, l'attribut <code>_Source</code> contenant le document lui-même au format JSON. Pour convertir cette source en une structure compatible avec Go, nous devons <a href="https://pkg.go.dev/encoding/json#Unmarshal">décompresser</a> la réponse JSON à l'aide du <a href="https://pkg.go.dev/encoding/json">paquetage Go</a> encoding/json, comme le montre l'exemple ci-dessous :</p>func getRodents(hits []types.Hit) ([]Rodent, error) {
	var rodents []Rodent

	for _, hit := range hits {
		var currentRodent Rodent
		err := json.Unmarshal(hit.Source_, &amp;currentRodent)

		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
}
<p>La recherche et l'annulation de la requête <code>gopher</code> renverront la page Wikipédia de Gopher comme prévu :</p>[
  {ID:64f74ecd4acb3df024d91112 Title:Gopher - Wikipedia Url:https://en.wikipedia.org/wiki/Gopher}
]
<p>Cependant, si nous demandons à <code>What do Gophers eat?</code>, nous n'obtenons pas tout à fait les résultats escomptés :</p>[]
<p>Une simple recherche par mot-clé permet de renvoyer les résultats à votre application Go d'une manière performante qui fonctionne d'une manière qui nous est familière dans les applications que nous utilisons. Elle fonctionne également très bien pour les correspondances de termes exacts qui sont pertinentes dans des scénarios tels que la recherche d'une entreprise ou d'un terme particulier.</p><p>Cependant, comme nous l'avons vu plus haut, il peine à identifier le contexte et la sémantique en raison du problème d'inadéquation du vocabulaire. En outre, la prise en charge des formats de fichiers non textuels, tels que les images et les fichiers audio, constitue un défi.</p><h2>Conclusion</h2><p>Nous avons vu ici comment effectuer des requêtes textuelles traditionnelles dans Elasticsearch en utilisant le <a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">client Elasticsearch Go.</a> Go étant largement utilisé pour les scripts d'infrastructure et la construction de serveurs web, il est utile de savoir comment effectuer des recherches en Go.</p><p>Consultez le <a href="https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client">repo GitHub</a> pour tout le code de cette série. Suivez la <a href="https://www.elastic.co/search-labs/blog/perform-vector-search-with-the-elasticsearch-go-client">partie 2</a> pour avoir une vue d'ensemble de la recherche vectorielle et savoir comment effectuer une recherche vectorielle dans Go. D'ici là, bonne chasse aux marmottes !</p><h2>Ressources</h2><ol><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html">Guide Elasticsearch</a></p></li><li><p><a href="https://www.elastic.co/guide/en/elasticsearch/client/go-api/current/index.html">Client Elasticsearch Go</a></p></li><li><p><a href="https://codingexplained.com/coding/elasticsearch/understanding-analysis-in-elasticsearch-analyzers">Comprendre l'analyse dans Elasticsearch (Analyzers) par Bo Andersen | #CodingExplained</a></p></li></ol>]]></content:encoded>
    <link>https://www.elastic.co/search-labs/blog/perform-text-queries-with-the-elasticsearch-go-client</link>
    <guid isPermaLink="true">https://www.elastic.co/search-labs/blog/perform-text-queries-with-the-elasticsearch-go-client</guid>
    <category><![CDATA[Go]]></category>
    <dc:creator><![CDATA[Carly Richmond,Laurent Saint-Félix]]></dc:creator>
    <enclosure url="https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/bltdcae959696d55a9b/6a1704d5ab7f085a56db9d7c/491ef9efbb30b253e1d9e3b7f816a9a23c8f5264-721x420.jpg" length="0" type="image/jpeg"/>
    <pubDate>Tue, 31 Oct 2023 00:00:00 GMT</pubDate>
  </item>
  </channel>
</rss>