<![CDATA[Tomás Murúa - Elasticsearch Labs]]> <![CDATA[Tomás Murúa - Elasticsearch Labs]]> https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt1121c0bf0e8a6e65/6a88da6340a1841030ef456f/search-labs-thumbnail.png https://www.elastic.co/fr/search-labs/author/tomas-murua https://www.elastic.co/fr/search-labs/author/tomas-murua Tue, 29 Sep 2026 10:24:17 GMT <![CDATA[Créer un connecteur ChatGPT avec Elasticsearch pour interroger les issues GitHub]]> OpenAI a récemment annoncé la fonctionnalité connecteurs personnalisés pour ChatGPT sur les plans Pro/Business/Entreprise et Edu. En plus des connecteurs prêts à l'emploi pour accéder aux données sur Gmail, GitHub, Dropbox, etc., il est possible de créer des connecteurs personnalisés en utilisant des serveurs MCP.

Les connecteurs personnalisés vous donnent la possibilité de combiner vos connecteurs ChatGPT existants avec des sources de données supplémentaires comme Elasticsearch pour obtenir des réponses complètes.

Dans cet article, nous allons créer un serveur MCP qui connecte ChatGPT à un index Elasticsearch contenant des informations sur les issues GitHub internes et les requêtes pull. Cela permet de répondre aux requêtes en langage naturel en utilisant vos données Elasticsearch.

Nous déploierons le serveur MCP en utilisant FastMCP sur Google Colab avec ngrok pour obtenir une URL publique à laquelle ChatGPT peut se connecter, éliminant ainsi le besoin d'une configuration complexe de l'infrastructure.

Pour un aperçu complet de MCP et de son écosystème, reportez-vous à la section État actuel du MCP.

Prérequis

Avant de commencer, vous aurez besoin des éléments suivants :

  • Cluster Elasticsearch (8.X ou supérieur)

  • Clé API Elasticsearch avec accès en lecture à votre index

  • Compte Google (pour Google Colab)

  • Compte ngrok (fonctionne avec le niveau gratuit)

  • Compte ChatGPT avec un forfait Pro/Entreprise/Business ou Edu

Comprendre les exigences du connecteur ChatGPT MCP

Les connecteurs ChatGPT MCP nécessitent l'implémentation de deux outils : search et fetch. Pour plus de détails, consultez OpenAI Docs.

Outil de recherche

Renvoie une liste de résultats pertinents depuis votre index Elasticsearch en fonction d'une requête utilisateur.

Ce qu'il reçoit :

  • Une chaîne unique contenant la requête en langage naturel de l'utilisateur.

  • Exemple : "Recherchez les issues liées à la migration d'Elasticsearch."

Ce qu'il renvoie : 

  • Un objet avec une clé result contenant un tableau d'objets de résultats. Chaque résultat inclut :

    • id - Identifiant de document unique

    • title - Titre de l'issue ou de la PR

    • url - Lien vers l'issue/la PR

Dans notre implémentation :

return { "results": [ { "id": "PR-612", "title": "Fix memory leak in WebSocket notification service", "url": "https://internal-git.techcorp.com/pulls/612" }, # ... more results ] }

Outil de récupération

Récupère le contenu complet d'un document spécifique.

Ce qu'il reçoit :

  • Chaîne unique contenant l'ID du document Elasticsearch extrait du résultat de la recherche

  • Exemple : "Donnez-moi les détails de la PR-578."

Ce qu'il renvoie :

  • Objet de document complet contenant :

    • id - Identifiant de document unique

    • title - Titre de l'issue ou de la PR

    • text - Description complète du problème/PR et détails

    • url - Lien vers l'issue/la PR

    • type - Type de document (issue, pull_request)

    • status - Statut actuel (ouvert, en cours, résolu)

    • priority - Niveau de priorité (faible, moyen, élevé, critique)

    • assignee - Personne en charge de l'issue/la PR

    • created_date - Date de création

    • resolved_date - Date de résolution (le cas échéant)

    • labels - Balises associées au document

    • related_pr - ID de la requête pull associée

return { "id": "PR-578", "title": "Security hotfix: Patch SQL injection vulnerabilities", "text": "Description: CRITICAL SECURITY FIX for ISSUE-1889. Patches SQL...", "url": "https://internal-git.techcorp.com/pulls/578", "type": "pull_request", "status": "closed", "priority": "critical", "assignee": "sarah_dev", "created_date": "2025-09-19", "resolved_date": "2025-09-19", "labels": "security, hotfix, sql", "related_pr": null }

Remarque : Cet exemple utilise une structure plate où tous les champs se trouvent au niveau racine. Les exigences d'OpenAI sont flexibles et prennent également en charge les objets de métadonnées imbriqués.

Issues GitHub et ensemble de données de PR

Pour ce tutoriel, nous allons utiliser un ensemble de données interne de GitHub contenant des issues et des requêtes pull. Ceci représente un scénario dans lequel vous souhaitez interroger des données privées et internes via ChatGPT.

L'ensemble de données est accessible ici. Et nous mettrons à jour l'index des données à l'aide de l'API Bulk.

Cet ensemble de données comprend :

  • Issues avec description, état, niveau de priorité et personnes en charge

  • Requêtes pull avec modifications de code, révisions et informations de déploiement

  • Relations entre les issues et les PR (p. ex., la PR-578 corrige l'ISSUE-1889)

  • Étiquettes, dates et autres métadonnées

Mappings de l'index

L'index utilise les mappings suivants pour prendre en charge la recherche hybride avec ELSER. Le champ text_semantic est utilisé pour la recherche sémantique, tandis que les autres champs permettent la recherche par mot-clé.

{ "mappings": { "properties": { "id": { "type": "keyword" }, "title": { "type": "text" }, "text": { "type": "text" }, "text_semantic": { "type": "semantic_text", "inference_id": ".elser-2-elasticsearch" }, "url": { "type": "keyword" }, "type": { "type": "keyword" }, "status": { "type": "keyword" }, "priority": { "type": "keyword" }, "assignee": { "type": "keyword" }, "created_date": { "type": "date", "format": "iso8601" }, "resolved_date": { "type": "date", "format": "iso8601" }, "labels": { "type": "keyword" }, "related_pr": { "type": "keyword" } } } }

Créer le serveur MCP

Notre serveur MCP implémente deux outils conformes aux spécifications d'OpenAI qui utilisent la recherche hybride pour combiner la sémantique et la correspondance de texte pour de meilleurs résultats.

Outil de recherche

Utilise la recherche hybride avec RRF (fusion des rangs réciproques) qui combine la recherche sémantique avec la correspondance de texte :

@mcp.tool() async def search(query: str) -> Dict[str, List[Dict[str, Any]]]: """ Search for internal issues and PRs using hybrid search (semantic + text with RRF). Returns list with id, title, and url per OpenAI spec. """ if not query or not query.strip(): return {"results": []} logger.info(f"Searching for: '{query}'") try: # Hybrid search with RRF (Reciprocal Rank Fusion) response = es_client.search( index=ELASTICSEARCH_INDEX, size=10, source=["id", "title", "url", "type", "priority"], retriever={ "rrf": { "retrievers": [ { # Semantic search with ELSER "standard": { "query": { "semantic": { "field": "text_semantic", "query": query } } } }, { # Text search (BM25) for keyword matching "standard": { "query": { "multi_match": { "query": query, "fields": [ "title^3", "text^2", "assignee^2", "type", "labels", "priority" ], "type": "best_fields", "fuzziness": "AUTO" } } } } ], "rank_window_size": 50, "rank_constant": 60 } } ) results = [] if response and 'hits' in response: for hit in response['hits']['hits']: source = hit['_source'] results.append({ "id": source.get('id', hit['_id']), "title": source.get('title', 'Unknown'), "url": source.get('url', '') }) logger.info(f"Found {len(results)} results") return {"results": results} except Exception as e: logger.error(f"Search error: {e}") raise ValueError(f"Search failed: {str(e)}")

Points clés :

  • Recherche hybride avec RRF : combine la recherche sémantique (ELSER) et la recherche de texte (BM25) pour de meilleurs résultats.

  • Requête à correspondance multiple : Recherches sur plusieurs champs avec boosting (title^3, text^2, assignee^2). Le symbole caret (^) multiplie les scores de pertinence, en privilégiant les correspondances dans les titres plutôt que dans le contenu.

  • Fuzzy matching (correspondance approximative) : fuzziness: AUTO gère les fautes de frappe et d'orthographe en autorisant les correspondances approximatives.

  • Ajustement des paramètres RRF :

    • rank_window_size: 50 - Spécifie le nombre de résultats principaux de chaque récupérateur (sémantique et texte) pris en compte avant la fusion.

    • rank_constant: 60 - Cette valeur détermine l'influence des documents dans chaque ensemble de résultats sur le classement final.

  • Ne renvoie que les champs obligatoires : id, title, url conformément à la spécification d'OpenAI, et évite d'exposer inutilement des champs supplémentaires.

Outil de récupération

Récupère les détails du document par ID de document, s'il existe :

@mcp.tool() async def fetch(id: str) -> Dict[str, Any]: """ Retrieve complete issue/PR details by ID. Returns id, title, text, url. """ if not id: raise ValueError("ID is required") logger.info(f"Fetching: {id}") try: # Search by the 'id' field (not _id) since IDs are stored as a field response = es_client.search( index=ELASTICSEARCH_INDEX, body={ "query": { "term": { "id": id # Search by your custom 'id' field } }, "size": 1 } ) if not response or not response['hits']['hits']: raise ValueError(f"Document with id '{id}' not found") hit = response['hits']['hits'][0] source = hit['_source'] result = { "id": source.get('id', id), "title": source.get('title', 'Unknown'), "text": source.get('text', ''), "url": source.get('url', ''), "type": source.get('type', ''), "status": source.get('status', ''), "priority": source.get('priority', ''), "assignee": source.get('assignee', ''), "created_date": source.get('created_date', ''), "resolved_date": source.get('resolved_date', ''), "labels": source.get('labels', ''), "related_pr": source.get('related_pr', '') } logger.info(f"Fetched: {result['title']}") return result except Exception as e: logger.error(f"Fetch error: {e}") raise ValueError(f"Failed to fetch '{id}': {str(e)}")

Points clés :

  • Recherche par champ d'ID de document : utilise une requête de terme sur le champ personnalisé id

  • Renvoie le document complet : inclut le champ complet text avec tout le contenu

  • Structure plate : tous les champs au niveau racine, correspondant à la structure de document d'Elasticsearch.

Déployer sur Google Colab

Nous utiliserons Google Colab pour exécuter notre serveur MCP et ngrok pour l'exposer publiquement afin que ChatGPT puisse s'y connecter.

Étape 1 : Ouvrir le notebook Google Colab

Accédez à notre notebook préconfiguré Elasticsearch MCP pour ChatGPT.

Étape 2 : Configurer vos identifiants

Vous aurez besoin de trois informations :

  • URL Elasticsearch : l'URL de votre cluster Elasticsearch.

  • Clé API Elasticsearch : clé API avec accès en lecture à votre index.

  • Jeton d'authentification ngrok : jeton gratuit fourni par ngrok. Nous utiliserons ngrok pour exposer l'URL du MCP à l'Internet afin que ChatGPT puisse s'y connecter.

Obtenir votre token ngrok

  1. Créez un compte gratuit sur ngrok

  2. Accédez à votre tableau de bord ngrok

  3. Copier votre jeton d'authentification

Ajouter des secrets à Google Colab

Dans le notebook Google Colab :

  1. Cliquez sur l'icône clé dans la barre latérale gauche pour ouvrir Secrets.

  2. Ajoutez ces trois secrets :

ELASTICSEARCH_URL=https://your-cluster.elastic.com:443 ELASTICSEARCH_API_KEY=your-api-key NGROK_TOKEN=your-ngrok-token

3. Activer l'accès aux notebooks pour chaque secret

Ajouter des secrets à Google Colab

Étape 3 : Exécuter le notebook

  1. Cliquez sur Runtime (Exécution) puis sur Run all (Tout exécuter) pour exécuter toutes les cellules

  2. Attendez que le serveur démarre (environ 30 secondes)

  3. Recherchez l'URL publique de ngrok dans la sortie

4. La sortie affichera quelque chose comme :

La sortie de l'exécution d'un notebook dans Google Colab

Se connecter à ChatGPT

Nous allons maintenant connecter le serveur MCP à votre compte ChatGPT.

  1. Ouvrez ChatGPT et accédez aux Paramètres.

  2. Accédez à Connectors (Connecteurs).Si vous utilisez un compte Pro, vous devez activer le mode développeur dans les connecteurs.

Connexion du serveur MPC à un compte ChatGPT

Si vous utilisez ChatGPT Enterprise ou Business, vous devez publier le connecteur sur votre espace de travail.

3. Cliquez sur Create (Créer).

Ajouter un connecteur à ChatGPT

Remarque : Dans les espaces de travail Business, Entreprise et Edu, seuls les propriétaires, les administrateurs et les utilisateurs ayant activé l'option correspondante (pour Entreprise/Edu) peuvent ajouter des connecteurs personnalisés. Les utilisateurs ayant un rôle de membre standard ne peuvent pas ajouter de connecteurs personnalisés eux-mêmes.

Une fois qu'un connecteur est ajouté et activé par un propriétaire ou un utilisateur administrateur, il devient accessible à tous les membres de l'espace de travail.

4. Saisissez les informations requises et votre URL ngrok se terminant par /sse/. Notez le "/" après "sse". Cela ne fonctionnera pas sans cet élément :

  • Nom : Elasticsearch MCP

  • Description : MCP personnalisé pour la recherche et la récupération d'informations GitHub internes.

Créer un connecteur MCP Elastic

5. Appuyez sur Créer pour enregistrer le MCP personnalisé.

Sauvegarder le connecteur MCP personnalisé en cliquant sur Créer

La connexion est instantanée si votre serveur est en cours d'exécution. Aucune authentification supplémentaire n'est requise, car la clé API Elasticsearch est configurée sur votre serveur.

Tester le serveur MCP

Avant de poser des questions, vous devez sélectionner le connecteur que ChatGPT doit utiliser.

Sélection du connecteur que ChatGPT doit utiliser

Prompt 1 : Recherchez les issues

Demandez : "Recherchez les issues liées à la migration d'Elasticsearch", puis confirmez l'appel à l'outil d'action.

Demandez à ChatGPT « Trouve les problèmes liés à la migration d'Elasticsearch » et confirmez l'appel de l'outil Actions.

ChatGPT appellera l'outil search avec votre requête. Vous pouvez voir qu'il recherche des outils disponibles et se prépare à appeler l'outil Elasticsearch, et confirme auprès de l'utilisateur avant de prendre toute action sur l'outil.

Demande d'appel d'outil :

{ "query": "Elasticsearch migration issues" }

Réponse de l'outil :

{ "results": [ { "id": "PR-598", "title": "Elasticsearch 8.x migration - Application code changes", "url": "https://internal-git.techcorp.com/pulls/598" }, { "id": "ISSUE-1712", "title": "Migrate from Elasticsearch 7.x to 8.x", "url": "https://internal-git.techcorp.com/issues/1712" }, { "id": "RFC-045", "title": "Design Proposal: Microservices Migration Architecture", "url": "https://internal-git.techcorp.com/rfcs/045" } // ... 7 more results ] }

ChatGPT traite les résultats et les présente dans un format conversationnel naturel.

Comment ChatGPT traite les résultats de la demande d'appel d'outil et de la réponse de l'outil

En coulisses

Prompt : "Recherchez les issues liées à la migration d'Elasticsearch"

1. Appels de ChatGPT search(“Elasticsearch migration”)

2. Elasticsearch effectue une recherche hybride.

  • La recherche sémantique comprend des concepts tels que "mise à niveau" et "compatibilité des versions".

  • La recherche de texte trouve des correspondances exactes pour "Elasticsearch" et "migration".

  • RRF combine et classe les résultats des deux approches

3. Renvoie les 10 événements les plus pertinents avec id, title, url

4. ChatGPT identifie "ISSUE-1712: migrate from Elasticsearch 7.x to 8.x" (Migrer d'Elasticsearch 7.x vers 8.x) comme résultat le plus pertinent.

Prompt 2 : Obtenez tous les détails

Demandez : "Donnez-moi les détails de l'ISSUE-1889"

ChatGPT comprend que vous souhaitez obtenir des informations détaillées sur un problème spécifique, appelle l'outil fetch et confirme auprès de l'utilisateur avant d'entreprendre toute action sur l'outil.

ChatGPT comprend que vous souhaitez obtenir des informations détaillées sur un problème spécifique, appelle l'outil fetch et confirme auprès de l'utilisateur avant d'entreprendre des actions sur l'outil.

Demande d'appel d'outil :

{ "id": "ISSUE-1889" }

Réponse de l'outil :

{ "id": "ISSUE-1889", "title": "SQL injection vulnerability in search endpoint", "text": "Description: Security audit identified SQL injection vulnerability in /api/v1/search endpoint. User input from query parameter is not properly sanitized before being used in raw SQL query. Severity: HIGH - Immediate action required Affected Code: - File: services/search/query_builder.py - Line: 145-152 - Issue: String concatenation used instead of parameterized queries Investigation: - @security_team_alice: Confirmed exploitable with UNION-based injection - @sarah_dev: Checking all other endpoints for similar patterns - @john_backend: Found 3 more instances in legacy codebase Remediation: - Rewrite using SQLAlchemy ORM or parameterized queries - Add input validation and sanitization - Implement WAF rules as additional layer - Security regression tests Comments: - @tech_lead_mike: Stop all other work, this is P0 - @sarah_dev: PR-578 ready with fixes for all 4 vulnerable endpoints - @alex_devops: Deployed hotfix to production 2025-09-19 at 14:30 UTC - @security_team_alice: Verified fix, conducting full pentest next week Resolution: All vulnerable endpoints patched. Added pre-commit hooks to catch raw SQL queries. Security training scheduled for team.", "url": "https://internal-git.techcorp.com/issues/1889", "type": "issue", "status": "closed", "priority": "critical", "assignee": "sarah_dev", "created_date": "2025-09-18", "resolved_date": "2025-09-19", "labels": "security, vulnerability, bug, sql", "related_pr": "PR-578" }

ChatGPT synthétise les informations et les présente clairement.

Comment ChatGPT synthétise les informations et les présente Comment ChatGPT présente les informations

En coulisses

Prompt : "Donnez-moi les détails de l'ISSUE-1889"

  1. Appels ChatGPT fetch(“ISSUE-1889”)

  2. Elasticsearch extrait le document complet

  3. Retourne un document complet avec tous les champs au niveau racine

  4. ChatGPT synthétise les informations et répond avec les citations appropriées.

Conclusion

Dans cet article, nous avons créé un serveur MCP personnalisé qui connecte ChatGPT à Elasticsearch à l'aide d'outils MCP de recherche et de récupération dédiés, permettant de lancer des requêtes en langage naturel sur des données privées.

Ce modèle MCP fonctionne pour n'importe quel index Elasticsearch, documentation, produit, log ou toute autre donnée que vous souhaitez interroger en langage naturel.

]]> https://www.elastic.co/search-labs/blog/chatgpt-connector-mcp-server-github-elasticsearch https://www.elastic.co/search-labs/blog/chatgpt-connector-mcp-server-github-elasticsearch Mon, 01 Dec 2025 00:00:00 GMT <![CDATA[Construire un agent d'IA pour les RH avec Elastic Agent Builder et GPT-OSS]]> Introduction

Cet article vous montrera comment construire un agent d'IA pour les RH en utilisant GPT-OSS et Elastic Agent Builder. L'agent peut répondre à vos questions sans envoyer de données à OpenAI, Anthropic ou tout autre service externe.

Nous allons utiliser LM Studio pour servir GPT-OSS localement et le connecter à Elastic Agent Builder.

À la fin de cet article, vous disposerez d'un agent d'IA personnalisé capable de répondre à des questions en langage naturel sur les données de vos employés, tout en conservant un contrôle total sur vos informations et votre modèle.

Produits requis

Pour cet article, vous avez besoin de :

Pourquoi utiliser GPT-OSS ?

Avec un LLM local, vous avez la possibilité de le déployer dans votre propre infrastructure et de l'adapter à vos besoins. Tout cela en gardant le contrôle sur les données que vous partagez avec le modèle et, bien sûr, sans avoir à payer de licence à un fournisseur externe.

OpenAI a publié GPT-OSS le 5 août 2025, dans le cadre de son engagement envers l'écosystème des modèles ouverts.

Le modèle de paramètres 20B offre :

  • Capacités d'utilisation des outils

  • Inférence efficace

  • Compatible avec le SDK OpenAI

  • Compatible avec les flux de travail agentiques

Comparaison des points de repère :

Architecture de la solution

L'architecture fonctionne entièrement sur votre machine locale. Elastic (exécuté dans Docker) communique directement avec votre LLM local via LM Studio, et Elastic Agent Builder utilise cette connexion pour créer des agents d'IA personnalisés qui peuvent interroger les données de vos employés.

Pour plus de détails, consultez cette documentation.

Construire un agent d'IA pour les RH : étapes

Nous diviserons la mise en œuvre en 5 étapes :

  1. Configurer LM studio avec un modèle local

  2. Déployer Elastic local avec Docker

  3. Créer le connecteur OpenAI dans Elastic

  4. Téléchargement des données des employés vers Elasticsearch

  5. Créez et testez votre agent d'intelligence artificielle

Étape 1 : Configurer LM Studio avec GPT-OSS 20B

LM Studio est une application conviviale qui vous permet d'exécuter localement de grands modèles linguistiques sur votre ordinateur. Il fournit un serveur d'API compatible avec OpenAI, ce qui facilite l'intégration avec des outils tels qu'Elastic sans processus de configuration complexe. Pour plus de détails, reportez-vous à la documentation de LM Studio.

Tout d'abord, téléchargez et installez LM Studio depuis le site officiel. Une fois installée, ouvrez l'application.

Dans l'interface de LM Studio :

  1. Allez dans l'onglet recherche et cherchez "GPT-OSS"

  2. Sélectionnez le site openai/gpt-oss-20b à partir d'OpenAI

  3. Cliquez sur télécharger

La taille de ce modèle devrait être d'environ 12,10 Go. Le téléchargement peut prendre quelques minutes, en fonction de votre connexion internet.

Une fois le modèle téléchargé :

  1. Aller dans l'onglet du serveur local

  2. Sélectionner l'openai/gpt-oss-20b

  3. Utiliser le port par défaut 1234

  4. Dans le panneau de droite, cliquez sur Charger et réglez la longueur du contexte sur 40K ou plus.

5. Cliquez sur démarrer le serveur

Vous devriez voir ceci si le serveur est en cours d'exécution.

[LM STUDIO SERVER] Success! HTTP server listening on port 1234 [LM STUDIO SERVER] Supported endpoints: [LM STUDIO SERVER] -> GET http://localhost:1234/v1/models [LM STUDIO SERVER] -> POST http://localhost:1234/v1/responses [LM STUDIO SERVER] -> POST http://localhost:1234/v1/chat/completions [LM STUDIO SERVER] -> POST http://localhost:1234/v1/completions [LM STUDIO SERVER] -> POST http://localhost:1234/v1/embeddings Server started.

Étape 2 : Déployer Elastic local avec Docker

Nous allons maintenant configurer Elasticsearch et Kibana localement à l'aide de Docker. Elastic fournit un script pratique qui gère l'ensemble du processus d'installation. Pour plus de détails, voir la documentation officielle.

Exécuter le script start-local

Exécutez la commande suivante dans votre terminal :

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

Ce script va :

  • Télécharger et configurer Elasticsearch et Kibana

  • Démarrer les deux services à l'aide de Docker Compose

  • Activation automatique d'une licence d'essai Platinum de 30 jours

Résultats attendus

Attendez le message suivant et enregistrez le mot de passe et la clé API indiqués ; vous en aurez besoin pour accéder à Kibana :

🎉 Congrats, Elasticsearch and Kibana are installed and running in Docker! 🌐 Open your browser at http://localhost:5601 Username: elastic Password: KSUlOMNr 🔌 Elasticsearch API endpoint: http://localhost:9200 🔑 API key: cnJGX0pwb0JhOG00cmNJVklUNXg6cnNJdXZWMnM4bncwMllpQlFlUTlWdw== Learn more at https://github.com/elastic/start-local

Accéder à Kibana

Ouvrez votre navigateur et naviguez vers :

http://localhost:5601

Connectez-vous en utilisant les informations d'identification obtenues dans la sortie du terminal.

Activer le constructeur d'agents

Une fois connecté à Kibana, naviguez vers Management > AI > Agent Builder et activez l'Agent Builder.

Étape 3 : Créer le connecteur OpenAI dans Elastic

Nous allons maintenant configurer Elastic pour qu'il utilise votre LLM local.

Connecteurs d'accès

  1. Dans Kibana

  2. Allez dans Paramètres du projet > Gestion

  3. Sous Alertes et aperçus, sélectionnez Connecteurs

  4. Cliquez sur Créer un connecteur

Configurer le connecteur

Sélectionnez OpenAI dans la liste des connecteurs. LM Studio utilise le SDK OpenAI, ce qui le rend compatible.

Remplissez les champs avec ces valeurs :

  • Nom du connecteur : LM Studio - GPT-OSS 20B

  • Sélectionnez un fournisseur OpenAI : Autre (Service compatible avec l'OpenAI)

  • URL : http://host.docker.internal:1234/v1/chat/completions

  • Modèle par défaut : openai/gpt-oss-20b

  • Clé API : testkey-123 (n'importe quel texte fonctionne, car le serveur LM Studio ne nécessite pas d'authentification).

Pour terminer la configuration, cliquez sur Save & test.

Important : Activez l'option "Enable native function calling" (activer l'appel de fonctions natives) ; cette option est nécessaire pour que l'Agent Builder fonctionne correctement. Si vous ne l'activez pas, vous obtiendrez une erreur No tool calls found in the response.

Tester la connexion

Elastic devrait automatiquement tester la connexion. Si tout est configuré correctement, vous obtiendrez un message de réussite comme celui-ci :

Réponse :

{ "status": "ok", "data": { "id": "chatcmpl-flj9h0hy4wcx4bfson00an", "object": "chat.completion", "created": 1761189456, "model": "openai/gpt-oss-20b", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Hello! 👋 How can I assist you today?", "reasoning": "Just greet.", "tool_calls": [] }, "logprobs": null, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 69, "completion_tokens": 23, "total_tokens": 92 }, "stats": {}, "system_fingerprint": "openai/gpt-oss-20b" }, "actionId": "ee1c3aaf-bad0-4ada-8149-118f52dad757" }

Étape 4 : Téléchargement des données des employés vers Elasticsearch

Nous allons maintenant télécharger l'ensemble de données relatives aux employés des RH afin de montrer comment l'agent travaille avec des données sensibles. J'ai généré un ensemble de données fictives avec cette structure.

Structure de l'ensemble de données

{ "employee_id": "0f4dce68-2a09-4cb1-b2af-6bcb4821539b", "full_name": "Daffi Stiebler", "email": "lscutchings0@huffingtonpost.com", "date_of_birth": "1975-06-20T15:39:36Z", "hire_date": "2025-07-28T00:10:45Z", "job_title": "Physical Therapy Assistant", "department": "HR", "salary": "108455", "performance_rating": "Needs Improvement", "years_of_experience": 2, "skills": "Java", "education_level": "Master's Degree", "manager": "Carl MacGibbon", "emergency_contact": "Leigha Scutchings", "home_address": "5571 6th Park" }

Créer l'index avec les correspondances

Tout d'abord, créez l'index avec les correspondances appropriées. Notez que nous utilisons des champs semantic_text pour certains champs clés ; cela permet des capacités de recherche sémantique pour notre index.

​​PUT hr-employees { "mappings": { "properties": { "@timestamp": { "type": "date" }, "employee_id": { "type": "keyword" }, "full_name": { "type": "text", "copy_to": "employee_semantic" }, "email": { "type": "keyword" }, "date_of_birth": { "type": "date", "format": "iso8601" }, "hire_date": { "type": "date", "format": "iso8601" }, "job_title": { "type": "text", "copy_to": "employee_semantic" }, "department": { "type": "text", "copy_to": "employee_semantic" }, "salary": { "type": "double" }, "performance_rating": { "type": "text", "copy_to": "employee_semantic" }, "years_of_experience": { "type": "long" }, "skills": { "type": "text", "copy_to": "employee_semantic" }, "education_level": { "type": "text", "copy_to": "employee_semantic" }, "manager": { "type": "text", "copy_to": "employee_semantic" }, "emergency_contact": { "type": "keyword" }, "home_address": { "type": "keyword" }, "employee_semantic": { "type": "semantic_text" } } } }

Index avec Bulk API

Copiez et collez le jeu de données dans votre Dev Tools dans Kibana et exécutez-le :

POST hr-employees/_bulk {"index": {}} {"employee_id": "57728b91-e5d7-4fa8-954a-2384040d3886", "full_name": "Filide Gane", "email": "vhallahan1@booking.com", "job_title": "Business Systems Development Analyst", "department": "Marketing", "salary": "$52330.27", "performance_rating": "Meets Expectations", "years_of_experience": 12, "skills": "Java", "education_level": "Bachelor's Degree", "date_of_birth": "2000-02-07T16:49:32Z", "hire_date": "2023-11-07T13:03:16Z", "manager": "Freedman Kings", "emergency_contact": "Vilhelmina Hallahan", "home_address": "75 Dennis Junction"} {"index": {}} {"employee_id": "...", ...}

Vérifier les données

Exécutez une requête pour vérifier :

GET hr-employees/_search

Étape 5 : Créer et tester votre agent d'intelligence artificielle

Une fois tout configuré, il est temps de créer un agent d'IA personnalisé à l'aide d'Elastic Agent Builder. Pour plus de détails, voir la documentation Elastic.

Ajouter le connecteur

Avant de pouvoir créer notre nouvel agent, nous devons configurer notre Agent builder pour qu'il utilise notre connecteur personnalisé appelé LM Studio - GPT-OSS 20B, car le connecteur par défaut est Elastic Managed LLM. Pour cela, nous devons aller dans Project Setting > Management > GenAI Settings; nous sélectionnons alors celui que nous avons créé et cliquons sur Save.

Agent d'accès Constructeur

  1. Aller aux agents

  2. Cliquez sur Créer un nouvel agent

Configurer l'agent

Pour créer un nouvel agent, les champs obligatoires sont l'identifiant de l'agent, le nom d'affichage et les instructions d'affichage.

Mais il existe d'autres options de personnalisation, comme les instructions personnalisées qui indiquent comment votre agent va se comporter et interagir avec vos outils, à la manière d'une invite système, mais pour notre agent personnalisé. Les étiquettes permettent d'organiser les agents, la couleur de l'avatar et le symbole de l'avatar.

Ceux que j'ai choisis pour notre agent sur la base de l'ensemble des données sont les suivants : Agent ID : hr_assistant

Instructions personnalisées :

You are an HR Analytics Assistant that helps answer questions about employee data. When responding to queries: - Provide clear, concise answers - Include relevant employee details (name, department, salary, skills) - Format monetary values with currency symbols - Be professional and maintain data confidentiality

Étiquettes : Human Resources et GPT-OSS

Nom d'affichage : HR Analytics Assistant

Description de l'affichage :

A specialized AI assistant for Human Resources that helps analyze employee data, compensation, performance metrics, and talent management. Ask questions about employees, departments, salaries, or performance analytics.

Une fois toutes les données saisies, nous pouvons cliquer sur Enregistrer notre nouvel agent.

Tester l'agent

Vous pouvez désormais poser des questions en langage naturel sur les données de vos employés, et GPT-OSS 20B comprendra l'intention et générera une réponse appropriée.

Prompt :

Which employee is the one with the highest salary in the hr-employees index?

Réponse :

Le processus de l'agent a été le suivant :

1. Comprendre votre question à l'aide du connecteur GPT-OSS

2. Générer la requête Elasticsearch appropriée (à l'aide des outils intégrés ou d'ES|QL personnalisés)

3. Récupérer les enregistrements des salariés correspondants

4. Présenter les résultats en langage naturel avec un formatage approprié

Contrairement à la recherche lexicale traditionnelle, l'agent alimenté par GPT-OSS comprend l'intention et le contexte, ce qui facilite la recherche d'informations sans connaître les noms exacts des champs ou la syntaxe de la requête. Pour plus de détails sur le processus de réflexion de l'agent, voir cet article.

Conclusion

Dans cet article, nous avons construit un agent d'IA personnalisé à l'aide de l'Agent Builder d'Elastic pour se connecter au modèle OpenAI GPT-OSS fonctionnant localement. En déployant à la fois Elastic et le LLM sur votre machine locale, cette architecture vous permet de tirer parti des capacités d'IA générative tout en conservant un contrôle total sur vos données, le tout sans envoyer d'informations à des services externes.

Nous avons utilisé GPT-OSS 20B à titre expérimental, mais les modèles officiellement recommandés pour Elastic Agent Builder sont référencés ici. Si vous avez besoin de capacités de raisonnement plus avancées, il existe également la variante de paramètre 120B qui est plus performante pour les scénarios complexes, bien qu'elle nécessite une machine plus sophistiquée pour fonctionner localement. Pour plus de détails, consultez la documentation officielle d'OpenAI.

]]> https://www.elastic.co/search-labs/blog/build-an-ai-agent-hr-elastic-agent-builder-gpt-oss https://www.elastic.co/search-labs/blog/build-an-ai-agent-hr-elastic-agent-builder-gpt-oss Wed, 26 Nov 2025 00:00:00 GMT <![CDATA[Tableaux de bord alimentés par l'IA : D'une vision à Kibana]]> Kibana Lens simplifie le glisser-déposer des tableaux de bord, mais lorsque vous avez besoin de dizaines de panneaux, les clics s'accumulent. Et si vous pouviez dessiner un tableau de bord, en faire une capture d'écran et laisser un LLM terminer tout le processus à votre place ?

Dans cet article, nous allons y parvenir. Nous allons créer une application qui prend une image d'un tableau de bord, analyse nos mappings et génère un tableau de bord sans que nous ayons à toucher à Kibana !

Les étapes:

  1. Contexte & flux de travail de l'application

  2. Préparer les données

  3. Configuration LLM

  4. Fonctions d'application

Contexte & flux de travail de l'application

La première idée qui m'est venue à l'esprit a été de laisser le LLM générer l'ensemble des objets sauvegardés au format NDJSON dans Kibana, puis de les importer dans Kibana.

Nous avons essayé une poignée de modèles :

  • Gemini 2.5 pro

  • GPT o3 / o4-mini-high / 4.1

  • Sonnet de Claude 4

  • Grok 3

  • Deepseek (Deepthink R1)

En ce qui concerne les messages-guides, nous avons commencé par une phrase simple :

You are an Elasticsearch Saved-Object generator (Kibana 9.0). INPUTS ===== 1. PNG screenshot of a 4-panel dashboard (attached). 2. Index mapping (below) – trimmed down to only the fields present in the screenshot. 3. Example NDJSON of *one* metric visualization (below) for reference. TASK ==== Return **only** a valid NDJSON array that recreates the dashboard exactly: * 2 metric panels (Visits, Unique Visitors) * 1 pie chart (Most used OS) * 1 vertical bar chart (State Geo Dest) * Use index pattern `kibana_sample_data_logs`. * Preserve roughly the same layout (2×2 grid). * Use `panelIndex` values 1-4 and random `id` strings. * Kibana version: 9.0

Bien que nous ayons parcouru des exemples en quelques images et des explications détaillées sur la manière de construire chaque visualisation, nous n'avons pas eu de chance. Si vous êtes intéressé par cette expérimentation, vous pouvez trouver des détails ici.

Le résultat de cette approche était l'apparition de ces messages lorsque l'on essayait de télécharger vers Kibana les fichiers produits par le LLM :

Cela signifie que le JSON généré est invalide ou mal formaté. Les problèmes les plus fréquents étaient que le LLM produisait des NDJSON incomplets, des paramètres hallucinants ou retournait du JSON normal au lieu de NDJSON, même si nous essayions de faire en sorte qu'il en soit autrement.

Inspirés par cet article - où les modèles de recherche ont mieux fonctionné que le LLM freestyle - nous avons décidé de donner des modèles au LLM au lieu de demander de générer le fichier NDJSON complet et ensuite nous, dans le code, utilisons les paramètres donnés par le LLM pour créer les visualisations appropriées.

Le processus de candidature sera le suivant :

Nous omettons une partie du code pour des raisons de simplicité, mais vous pouvez trouver le code de travail de l'application complète sur ce carnet.

Produits requis

Avant de commencer à développer, vous aurez besoin des éléments suivants :

  1. Python 3.8 ou supérieur

  2. Un environnement Venv Python

  3. Une instance Elasticsearch en cours d'exécution, ainsi que son point d'accès et sa clé API

  4. Une clé d'API OpenAI stockée dans la variable d'environnement OPENAI_API_KEY :

export OPENAI_API_KEY="your-openai-api-key"

Préparer les données

Pour les données, nous resterons simples et utiliserons les journaux web de l'échantillon Elastic. Pour savoir comment importer ces données dans votre cluster , cliquez ici.

Chaque document contient des informations sur l'hôte qui a envoyé des demandes à l'application, ainsi que des informations sur la demande elle-même et l'état de sa réponse. Vous trouverez ci-dessous un exemple de document :

{ "agent": "Mozilla/5.0 (X11; Linux i686) AppleWebKit/534.24 (KHTML, like Gecko) Chrome/11.0.696.50 Safari/534.24", "bytes": 8509, "clientip": "70.133.115.149", "extension": "css", "geo": { "srcdest": "US:IT", "src": "US", "dest": "IT", "coordinates": { "lat": 38.05134111, "lon": -103.5106908 } }, "host": "cdn.elastic-elastic-elastic.org", "index": "kibana_sample_data_logs", "ip": "70.133.115.149", "machine": { "ram": 5368709120, "os": "osx" }, "memory": null, "message": "70.133.115.149 - - [2018-08-30T23:35:31.492Z] \"GET /styles/semantic-ui.css HTTP/1.1\" 200 8509 \"-\" \"Mozilla/5.0 (X11; Linux i686) AppleWebKit/534.24 (KHTML, like Gecko) Chrome/11.0.696.50 Safari/534.24\"", "phpmemory": null, "referer": "http://twitter.com/error/john-phillips", "request": "/styles/semantic-ui.css", "response": 200, "tags": [ "success", "info" ], "@timestamp": "2025-07-03T23:35:31.492Z", "url": "https://cdn.elastic-elastic-elastic.org/styles/semantic-ui.css", "utc_time": "2025-07-03T23:35:31.492Z", "event": { "dataset": "sample_web_logs" }, "bytes_gauge": 8509, "bytes_counter": 51201128 }

Prenons maintenant les mappings de l'index que nous venons de charger, kibana_sample_data_logs:

INDEX_NAME = "kibana_sample_data_logs" es_client = Elasticsearch( [os.getenv("ELASTICSEARCH_URL")], api_key=os.getenv("ELASTICSEARCH_API_KEY"), ) result = es_client.indices.get_mapping(index=INDEX_NAME) index_mappings = result[list(result.keys())[0]]["mappings"]["properties"]

Nous allons transmettre les mappings avec l'image que nous chargerons plus tard.

Configuration LLM

Configurons le LLM pour qu'il utilise la sortie structurée afin d'entrer une image et de recevoir un JSON contenant les informations que nous devons transmettre à notre fonction pour produire les objets JSON.

Nous installons les dépendances :

pip install elasticsearch pydantic langchain langchain-openai -q

Elasticsearch nous aidera à récupérer les mappages d'index. Pydantic nous permet de définir des schémas en Python pour demander au LLM de les suivre, et LangChain est le cadre qui facilite l'appel aux LLM et aux outils d'IA.

Nous allons créer un schéma pydantique pour définir les résultats que nous voulons obtenir du LLM. Ce que nous devons savoir à partir de l'image, c'est le type de graphique, le champ, le titre de la visualisation et le titre du tableau de bord :

class Visualization(BaseModel): title: str = Field(description="The dashboard title") type: List[Literal["pie", "bar", "metric"]] field: str = Field( description="The field that this visualization use based on the provided mappings" ) class Dashboard(BaseModel): title: str = Field(description="The dashboard title") visualizations: List[Visualization]

Pour la saisie de l'image, nous enverrons un tableau de bord que je viens de dessiner :

Nous déclarons maintenant l'appel au modèle LLM et le chargement de l'image. Cette fonction recevra les mappings de l'index Elasticsearch et une image du tableau de bord que nous voulons générer.

Avec with_structured_output, nous pouvons utiliser notre schéma Pydantic Dashboard comme objet de réponse que le LLM produira. Avec Pydantic, nous pouvons définir des modèles de données avec validation, ce qui garantit que la sortie LLM correspond à la structure attendue.

Pour convertir l'image en base64 et l'envoyer en entrée, vous pouvez utiliser un convertisseur en ligne ou le faire en code.

prompt = f""" You are an expert in analyzing Kibana dashboards from images for the version 9.0.0 of Kibana. You will be given a dashboard image and an Elasticsearch index mapping. Below are the index mappings for the index that the dashboard is based on. Use this to help you understand the data and the fields that are available. Index Mappings: {index_mappings} Only include the fields that are relevant for each visualization, based on what is visible in the image. """ message = [ { "role": "user", "content": [ {"type": "text", "text": prompt}, { "type": "image", "source_type": "base64", "data": image_base64, "mime_type": "image/png", }, ], } ] try: llm = init_chat_model("gpt-4.1-mini") llm = llm.with_structured_output(Dashboard) dashboard_values = llm.invoke(message) print("Dashboard values generated by the LLM successfully") print(dashboard_values) except Exception as e: print(f"Failed to analyze image and match fields: {str(e)}")

Le LLM connaît déjà le contexte des tableaux de bord Kibana, nous n'avons donc pas besoin de tout expliquer dans l'invite, juste quelques détails pour s'assurer qu'il n'oublie pas qu'il travaille avec Elasticsearch et Kibana.

Décortiquons l'invitation :

Section

Raison

Vous êtes un expert en analyse de tableaux de bord Kibana à partir d'images pour la version 9.0.0 de Kibana.

En insistant sur le fait qu'il s'agit d'Elasticsearch et de la version d'Elasticsearch, nous réduisons la probabilité que le LLM hallucine des paramètres anciens/invalides.

Vous recevrez une image de tableau de bord et un mappage d'index Elasticsearch.

Nous expliquons que l'image concerne les tableaux de bord afin d'éviter toute interprétation erronée de la part du LLM.

Vous trouverez ci-dessous les correspondances d'index pour l'index sur lequel le tableau de bord est basé, ce qui vous aidera à comprendre les données et les champs disponibles. Mappages d'index : {index_mappings}

Il est essentiel de fournir les correspondances afin que le LLM puisse sélectionner les champs valides de manière dynamique. Sinon, nous pourrions coder en dur les correspondances ici, ce qui est trop rigide, ou compter sur le fait que l'image contienne les bons noms de champs, ce qui n'est pas fiable.

N'incluez que les champs pertinents pour chaque visualisation, en fonction de ce qui est visible dans l'image.

Nous avons dû ajouter ce renforcement parce qu'il arrive que l'on essaie d'ajouter des champs qui ne sont pas pertinents pour l'image.

Cela renvoie un objet contenant un tableau de visualisations à afficher :

"Dashboard values generated by the LLM successfully title=""Client, Extension, OS, and Response Keyword Analysis""visualizations="[ "Visualization(title=""Count of Client IP", "type="[ "metric" ], "field=""clientip"")", "Visualization(title=""Extension Keyword Distribution", "type="[ "pie" ], "field=""extension.keyword"")", "Visualization(title=""Most Used OS", "type="[ "bar" ], "field=""machine.os.keyword"")", "Visualization(title=""Response Keyword Distribution", "type="[ "bar" ], "field=""response.keyword"")" ]

Traitement de la réponse au mécanisme d'apprentissage tout au long de la vie

Nous avons créé un exemple de tableau de bord 2x2 panneaux à l'adresseet l'avons exporté en JSON à l'aide de l'API Get a dashboard, puis nous avons stocké les panneaux en tant que modèles de visualisation (camembert, barre, métrique) dans lesquels nous pouvons remplacer certains paramètres pour créer de nouvelles visualisations avec différents champs en fonction de la question.

Vous pouvez consulter les fichiers JSON du modèle ici. Notez que nous avons modifié les valeurs de l'objet que nous voulons remplacer plus tard par {variable_name}

Grâce aux informations fournies par le mécanisme d'apprentissage tout au long de la vie, nous pouvons décider du modèle à utiliser et des valeurs à remplacer.

fill_template_with_analysis recevra les paramètres pour un seul panneau, y compris le modèle JSON de la visualisation, un titre, un champ et les coordonnées de la visualisation sur la grille.

Ensuite, il remplacera les valeurs du modèle et renverra la visualisation JSON finale.

def fill_template_with_analysis( template: Dict[str, Any], visualization: Visualization, grid_data: Dict[str, Any], ): template_str = json.dumps(template) replacements = { "{visualization_id}": str(uuid.uuid4()), "{title}": visualization.title, "{x}": grid_data["x"], "{y}": grid_data["y"], } if visualization.field: replacements["{field}"] = visualization.field for placeholder, value in replacements.items(): template_str = template_str.replace(placeholder, str(value)) return json.loads(template_str)

Pour faire simple, nous aurons des coordonnées statiques que nous assignerons aux panneaux que le LLM décidera de créer et nous produirons un tableau de bord à grille 2x2 comme l'image ci-dessus.

# Filling templates fields panels = [] grid_data = [ {"x": 0, "y": 0}, {"x": 12, "y": 0}, {"x": 0, "y": 12}, {"x": 12, "y": 12}, ] i = 0 for vis in dashboard_values.visualizations: for vis_type in vis.type: template = templates.get(vis_type, templates.get("bar", {})) filled_panel = fill_template_with_analysis(template, vis, grid_data[i]) panels.append(filled_panel) i += 1

En fonction du type de visualisation décidé par le LLM, nous choisirons un modèle de fichier JSON et remplacerons les informations pertinentes à l'aide de fill_template_with_analysis , puis nous ajouterons le nouveau panneau à un tableau que nous utiliserons ultérieurement pour créer le tableau de bord.

Lorsque le tableau de bord est prêt, nous utilisons l'API Create a dashboard pour envoyer le nouveau fichier JSON à Kibana afin de générer le tableau de bord :

try: dashboard_id = str(uuid.uuid4()) # post request to create the dashboard endpoint url = f"{os.getenv('KIBANA_URL')}/api/dashboards/dashboard/{dashboard_id}" dashboard_config = { "attributes": { "title": dashboard_values.title, "description": "Generated by AI", "timeRestore": True, "panels": panels, # Visualizations with the values generated by the LLM "timeFrom": "now-7d/d", "timeTo": "now", }, } headers = { "Content-Type": "application/json", "kbn-xsrf": "true", "Authorization": f"ApiKey {os.getenv('ELASTICSEARCH_API_KEY')}", } requests.post( url, headers=headers, json=dashboard_config, ) # Url to the generated dashboard dashboard_url = f"{os.getenv('KIBANA_URL')}/app/dashboards#/view/{dashboard_id}" print("Dashboard URL: ", dashboard_url) print("Dashboard ID: ", dashboard_id) except Exception as e: print(f"Failed to create dashboard: {str(e)}")

Pour exécuter le script et générer le tableau de bord, exécutez la commande suivante dans la console :

python <file_name>.py

Le résultat final sera le suivant :

Conclusion

Les LLM démontrent leurs fortes capacités visuelles lorsqu'ils transforment du texte en code ou des images en code. L'API des tableaux de bord permet également de transformer des fichiers JSON en tableaux de bord, et avec un LLM et un peu de code, nous pouvons transformer des images en tableau de bord Kibana.

L'étape suivante consiste à améliorer la flexibilité des visuels des tableaux de bord en utilisant différents paramètres de grille, différentes tailles de tableau de bord et différentes positions. De plus, la prise en charge de visualisations et de types de visualisation plus complexes serait un ajout utile à cette application.

]]> https://www.elastic.co/search-labs/blog/ai-powered-dashboards https://www.elastic.co/search-labs/blog/ai-powered-dashboards Wed, 16 Jul 2025 00:00:00 GMT