<![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/es/search-labs/author/tomas-murua https://www.elastic.co/es/search-labs/author/tomas-murua Tue, 22 Sep 2026 11:53:55 GMT <![CDATA[Crear un conector de ChatGPT con Elasticsearch para buscar incidencias de GitHub.]]> Recientemente, OpenAI anunció la característica de conectores personalizados para ChatGPT en los planes Pro/Business/Enterprise y Edu. Además de los conectores listos para usar que permiten acceder a datos en Gmail, GitHub, Dropbox, etc. Es posible crear conectores personalizados utilizando servidores MCP.

Los conectores personalizados te permiten combinar tus conectores de ChatGPT existentes con otras fuentes de datos como Elasticsearch para obtener respuestas integrales.

En este artículo, crearemos un servidor MCP que conecta ChatGPT a un índice de Elasticsearch que contiene información sobre incidencias internas de GitHub y solicitudes de extracción. Esto permite responder a búsquedas en lenguaje natural mediante los datos de Elasticsearch.

Desplegaremos el servidor MCP utilizando FastMCP en Google Colab con ngrok para obtener una URL pública a la que ChatGPT pueda conectarse, lo que eliminará la necesidad de una infraestructura compleja.

Para una visión general del MCP y su ecosistema, consulta El estado actual de MCP.

Prerrequisitos

Antes de comenzar, necesitarás:

  • Clúster de Elasticsearch (8.X o superior).

  • Clave API de Elasticsearch con acceso de lectura a tu índice.

  • Cuenta de Google (para Google Colab)

  • Cuenta de Ngrok (el nivel gratuito funciona)

  • Cuenta de ChatGPT con plan Pro/Enterprise/Business o Edu.

Comprensión de los requisitos del conector MCP de ChatGPT.

Los conectores MCP de ChatGPT requieren la implementación de dos herramientas: search y fetch. Para más detalles, consulta OpenAI Docs.

Herramienta de búsqueda

Devuelve una lista de resultados relevantes de tu índice de Elasticsearch según la búsqueda del usuario.

Lo que recibe:

  • Un solo texto con la búsqueda de lenguaje natural del usuario.

  • Ejemplo: “Encuentra incidencias relacionadas con la migración de Elasticsearch”.

Lo que devuelve: 

  • Un objeto con una clave result que contiene un arreglo de objetos de resultado. Cada resultado incluye:

    • id - Identificador único de documentos.

    • title - Título de la incidencia o PR.

    • url - Enlace a la incidencia o PR.

En nuestra implementación:

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

Herramienta de extracción

Recupera el contenido completo de un documento específico.

Lo que recibe:

  • Una sola cadena de texto con el ID del documento de Elasticsearch del resultado de la búsqueda.

  • Ejemplo: “Consígueme los detalles de PR-578”.

Lo que devuelve:

  • Un objeto de documento completo con:

    • id - Identificador único de documentos.

    • title - Título de la incidencia o PR.

    • text - Descripción completa del problema/PR y sus detalles

    • url - Enlace a la incidencia o PR.

    • type - Tipo de documento (incidencia, pull_request).

    • status - Estado actual (abierto, en progreso, resuelto)

    • priority - Nivel de prioridad (bajo, medio, alto, crítico)

    • assignee - Persona asignada al problema/PR

    • created_date - Fecha de creación.

    • resolved_date - Cuando se resolvió (si procede)

    • labels - Etiquetas asociadas al documento

    • related_pr - ID de solicitud de extracción relacionado

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 }

Nota: Este ejemplo usa una estructura plana donde todos los campos están en el nivel raíz. Los requisitos de OpenAI son flexibles y también admiten objetos de metadatos anidados.

Sets de datos de incidencias y PR de GitHub

Para este tutorial, vamos a usar un set de datos interno de GitHub que contenga incidencias y solicitudes de extracción. Esto representa un escenario en el que deseas buscar datos internos privados a través de ChatGPT.

Los sets de datos se pueden encontrar aquí. Y actualizaremos el índice de los datos mediante la API de bulk.

Este sets de datos incluye:

  • Problemas con descripciones, estado, prioridad y responsables.

  • Solicitudes de extracción con cambios de código, revisiones e información de despliegue.

  • Relaciones entre incidencias y PR (p. ej., PR-578 soluciona ISSUE-1889).

  • Etiquetas, fechas y otros metadatos

Mappings de índices

El índice utiliza los siguientes mappings para brindar soporte a la búsqueda híbrida con ELSER. El campo text_semantic se utiliza para la búsqueda semántica, mientras que los demás campos permiten la búsqueda por palabras clave.

{ "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" } } } }

Construye el servidor MCP

Nuestro servidor MCP implementa dos herramientas que siguen las especificaciones de OpenAI, y utilizan búsquedas híbridas para combinar coincidencia semántica y textual para obtener mejores resultados.

Herramienta de búsqueda

Usa la búsqueda híbrida con RRF (Fusión de Rango Recíproco), combinando la búsqueda semántica con la coincidencia de texto:

@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)}")

Puntos clave:

  • Búsqueda híbrida con RRF: Combina búsqueda semántica (ELSER) y búsqueda por texto (BM25) para mejores resultados.

  • Búsqueda de múltiples coincidencias: Busca en múltiples campos con mejores ponderaciones (título^3, texto^2, responsable^2). El símbolo de intercalación (^) multiplica las puntuaciones de relevancia, y prioriza las coincidencias en los títulos sobre el contenido.

  • Correspondencia aproximada: fuzziness: AUTO maneja los errores tipográficos y ortográficos al permitir coincidencias aproximadas.

  • Ajuste de parámetros de RRF:

    • rank_window_size: 50 - Especifica cuántos resultados principales de cada recuperador (semántico y textual) se consideran antes de combinarlos.

    • rank_constant: 60 - Este valor determina cuánta influencia tienen los documentos en los conjuntos de resultados individuales sobre el resultado final clasificado.

  • Solo devuelve los campos obligatorios: id, title, url según la especificación de OpenAI, y evita exponer otros campos innecesariamente.

Herramienta de extracción

Recupera los detalles del documento por ID de documento, si 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)}")

Puntos clave:

  • Búsqueda por campo de ID de documento: usa la búsqueda de término en el campo personalizado id.

  • Devuelve el documento completo: incluye el campo completo text con todo el contenido.

  • Estructura plana: todos los campos en el nivel raíz, coincidiendo con la estructura de documentos de Elasticsearch.

Desplegar en Google Colab

Usaremos Google Colab para ejecutar nuestro servidor MCP y ngrok para exponerlo públicamente de forma tal que ChatGPT pueda conectarse.

Paso 1: Abre el cuaderno de Google Colab.

Accede a nuestro cuaderno preconfigurado Elasticsearch MCP para ChatGPT.

Paso 2: Configura tus credenciales

Necesitarás tres datos:

  • URL de Elasticsearch: Tu URL del cluster de Elasticsearch.

  • Clave API de Elasticsearch: Clave API con acceso de lectura a tu índice.

  • Token de autenticación ngrok: Token gratis de ngrok. Usaremos ngrok para exponer la URL de MCP a internet y así ChatGPT pueda conectarse.

Obtener tu token ngrok

  1. Regístrate para una cuenta gratis en ngrok

  2. Ve a tu dashboard de ngrok

  3. Copia tu token de autenticación

Agregar secretos a Google Colab

En el cuaderno de Google Colab:

  1. Haz clic en el icono de llave en la barra lateral izquierda para abrir Secretos.

  2. Añade estos tres secretos:

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

3. Habilitar el acceso al cuaderno para cada secreto

Agregar secretos a Google Collab

Paso 3: Ejecutar el cuaderno

  1. Haz clic en Tiempo de ejecución y, a continuación, en Ejecutar todo para ejecutar todas las celdas.

  2. Espera que el servidor se inicie (aproximadamente 30 segundos).

  3. Busque la salida que muestre su URL pública de ngrok

4. La salida mostrará algo como:

La salida de ejecutar un cuaderno en Google Collab

Conéctate a ChatGPT.

Ahora conectaremos el servidor MCP a tu cuenta de ChatGPT.

  1. Abre ChatGPT y ve a Configuración.

  2. Navega a Conectores.Si estás usando una cuenta Pro, debes activar el modo de desarrollador en los conectores.

Conectando el servidor MPC a una cuenta de ChatGPT

Si estás usando la versión Enterprise o Business de ChatGPT, debes publicar el conector en tu lugar de trabajo.

3. Haz clic en Crear.

Agregar un conector a ChatGPT

Nota: En los espacios de trabajo Business, Enterprise y Edu, solo los propietarios, administradores y usuarios que tengan habilitada la correspondiente configuración (para Enterprise/Edu) pueden agregar conectores personalizados. Los usuarios con un rol de miembro común no tienen la capacidad de agregar conectores personalizados por su cuenta.

Una vez que un propietario o usuario administrador agrega un conector y lo habilita, estará disponible para que lo usen todos los miembros del espacio de trabajo.

4. Introduce la información requerida y la URL de tu ngrok que termina en /sse/. Recuerda la “/” después de “sse”. No funcionará si no la agregas:

  • Nombre: Elasticsearch MCP

  • Descripción: MCP personalizado para buscar y extraer información interna de GitHub.

Crear un conector MCP de Elastic

5. Presione Crear para guardar el MCP personalizado.

Guardar el conector MCP personalizado haciendo clic en crear

La conexión es instantánea si tu servidor está en funcionamiento. No se necesita ninguna otra autenticación, ya que la clave API de Elasticsearch está configurada en tu servidor.

Prueba el servidor MCP

Antes de hacer preguntas, necesitas seleccionar qué conector ChatGPT debe usar.

Seleccionar qué conector debe usar ChatGPT

Indicación 1: Buscar incidencias

Pregunta: “Encuentre incidencias relacionadas con la migración de Elasticsearch” y confirma la llamada a la herramienta de acciones.

Pide a ChatGPT “Encuentra incidencias relacionadas con la migración de Elasticsearch” y confirma la llamada a la herramienta de acciones.

ChatGPT llamará a la herramienta search con tu búsqueda. Puedes ver que está buscando herramientas disponibles y preparándose para llamar a la herramienta Elasticsearch y confirma con el usuario antes de tomar cualquier acción en relación con la herramienta.

Solicitud de llamada a la herramienta:

{ "query": "Elasticsearch migration issues" }

Respuesta de la herramienta:

{ "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 procesa los resultados y los presenta en un formato natural y conocido.

Cómo procesa ChatGPT los resultados de la solicitud de llamada a la herramienta y la respuesta de la herramienta

Entre bastidores

Indicación: “Busca incidencias relacionadas con la migración de Elasticsearch”

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

2. Elasticsearch realiza una búsqueda híbrida

  • La búsqueda semántica entiende conceptos como “actualización” y “compatibilidad de versiones”.

  • La búsqueda de texto encuentra coincidencias exactas de "Elasticsearch" y "migración".

  • RRF combina y clasifica los resultados de ambos enfoques

3. Devuelve los 10 mejores eventos que coinciden con id, title, url

4. ChatGPT identifica “ISSUE-1712: migrar de Elasticsearch 7.x a 8.x” como el resultado más relevante.

Indicación 2: Obtén los detalles completos

Pregunta: “Obtén detalles de ISSUE-1889”

ChatGPT reconoce que quieres información detallada sobre un problema específico y llama a la herramienta de búsqueda y confirma con el usuario antes de hacer cualquier acción con la herramienta.

ChatGPT reconoce que deseas información detallada sobre una incidencia específica, llama a la herramienta fetch y confirma con el usuario antes de tomar cualquier acción con la herramienta.

Solicitud de llamada a la herramienta:

{ "id": "ISSUE-1889" }

Respuesta de la herramienta:

{ "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 sintetiza la información y la presenta de manera clara.

Cómo ChatGPT sintetiza la información y la presenta Cómo ChatGPT presenta la información

Entre bastidores

Indicación: «Obtén los detalles de ISSUE-1889»

  1. Llamadas de ChatGPT fetch(“ISSUE-1889”)

  2. Elasticsearch recupera el documento completo

  3. Devuelve un documento completo con todos los campos a nivel raíz.

  4. ChatGPT sintetiza la información y responde con citas adecuadas.

Conclusión

En este artículo, creamos un servidor MCP personalizado que conecta ChatGPT a Elasticsearch con herramientas MCP dedicadas de búsqueda y extracción, lo cual permite realizar búsquedas en lenguaje natural sobre datos privados.

Este patrón MCP funciona para cualquier índice, documentación, productos, logs o cualquier otro dato de Elasticsearch que quieras buscar mediante lenguaje natural.

]]> 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[Construir un agente de IA para RRHH con Elastic Agent Builder y GPT-OSS]]> Introducción

Este artículo te mostrará cómo construir un agente de IA para RRHH usando GPT-OSS y Elastic Agent Builder. El agente puede responder a tus preguntas sin enviar datos a OpenAI, Anthropic ni ningún servicio externo.

Usaremos LM Studio para servir GPT-OSS localmente y lo conectaremos a Elastic Agent Builder.

Al final de este artículo, tendrás un agente de IA personalizado que podrá responder preguntas en lenguaje natural sobre los datos de tus empleados manteniendo el control total sobre tu información y modelo.

Prerrequisitos

Para este artículo, necesitas:

¿Por qué usar GPT-OSS?

Con un LLM local tienes el control para desplegarlo en tu propia infraestructura y ajustarlo para adaptarlo a tus propias necesidades. Todo esto manteniendo el control sobre los datos que compartes con el modelo y, por supuesto, no tienes que pagar una tasa de licencia a un proveedor externo.

OpenAI lanzó GPT-OSS el 5 de agosto de 2025, como parte de su compromiso con el ecosistema del modelo abierto.

El modelo de parámetros 20B ofrece:

  • Capacidades de uso de herramientas

  • Inferencia eficiente

  • Compatible con SDK OpenAI

  • Compatible con flujos de trabajo agentes

Comparación de referencias:

Arquitectura de soluciones

La arquitectura funciona completamente en tu máquina local. Elastic (que funciona en Docker) se comunica directamente con tu LLM local a través de LM Studio, y Elastic Agent Builder emplea esta conexión para crear agentes de IA personalizados que pueden consultar los datos de tus empleados.

Para más detalles, consulte esta documentación.

Construir un agente de IA para RRHH: Pasos

Dividiremos la implementación en 5 pasos:

  1. Configurar LM Studio con un modelo local

  2. Despliega Elastic Local con Docker

  3. Crea el conector OpenAI en Elastic

  4. Sube los datos de los empleados a Elasticsearch

  5. Construye y prueba tu agente de IA

Paso 1: Configurar LM Studio con GPT-OSS 20B

LM Studio es una aplicación fácil de usar que te permite ejecutar grandes modelos de lenguaje localmente en tu computadora. Proporciona un servidor API compatible con OpenAI, lo que facilita su integración con herramientas como Elastic sin un proceso de configuración complejo. Para más detalles, consulta la documentación de LM Studio.

Primero, descarga e instala LM Studio desde el sitio web oficial. Una vez instalado, abre la aplicación.

En la interfaz de LM Studio:

  1. Ve a la pestaña de búsqueda y busca "GPT-OSS"

  2. Selecciona el openai/gpt-oss-20b de OpenAI

  3. Haz clic en descargar

El tamaño de este modelo debería ser aproximadamente 12,10GB. La descarga puede tardar unos minutos, dependiendo de tu conexión a Internet.

Una vez descargado el modelo:

  1. Ve a la pestaña del servidor local

  2. Selecciona el openai/gpt-oss-20b

  3. Usa el puerto predeterminado 1234

  4. En el panel derecho, ve a Cargar y establece la longitud de contexto en 40K o más

5. Haz clic en iniciar servidor

Deberías ver esto si el servidor está funcionando.

[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.

Paso 2: Desplegar Elastic Local con Docker

Ahora configuraremos Elasticsearch y Kibana localmente usando Docker. Elastic proporciona un script conveniente que gestiona todo el proceso de configuración. Para más detalles, consulte la documentación oficial.

Ejecuta el script de inicio local

Ejecuta el siguiente comando en tu terminal:

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

Este guion será:

  • Descargar y configurar Elasticsearch y Kibana

  • Inicia ambos servicios usando Docker Compose

  • Activa automáticamente una licencia de prueba Platinum de 30 días

Producción esperada

Solo espera el siguiente mensaje y almacena la contraseña y la clave API que se muestra; los necesitarás para acceder a 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

Acceso a Kibana

Abre tu navegador y navega a:

http://localhost:5601

Inicia sesión usando las credenciales obtenidas en la salida del terminal.

Habilitar Agent Builder

Una vez iniciado sesión en Kibana, navega a Management > AI > Agent Builder y activa el Agent Builder.

Paso 3: Crea el conector OpenAI en Elastic

Ahora configuraremos Elastic para que use tu LLM local.

Conectores de acceso

  1. En Kibana

  2. Ve a Configuración > Gestión del Proyecto

  3. En Alertas e Información, selecciona Conectores

  4. Haz clic en Crear conector

Configurar el conector

Selecciona OpenAI de la lista de conectores. LM Studio emplea el SDK OpenAI, lo que lo hace compatible.

Diligencia el espacio con estos valores:

  • Nombre del conector: LM Studio - GPT-OSS 20B

  • Selecciona un proveedor de OpenAI: Otros (Servicio compatible con OpenAI)

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

  • Modelo por defecto: openai/gpt-oss-20b

  • API Key: testkey-123 (cualquier texto funciona, porque LM Studio Server no requiere autenticación.)

Para terminar la configuración, haz clic en Almacenar y probar.

Importante: Activa la opción "Habilitar la llamada a funciones nativas"; esto es necesario para que el Constructor de Agentes funcione correctamente. Si no activas esto, te aparecerá un error de No tool calls found in the response .

Prueba la conexión

El elástico debería probar automáticamente la conexión. Si todo está configurado correctamente, verás un mensaje de éxito como este:

Respuesta:

{ "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" }

Paso 4: Subir los datos de los empleados a Elasticsearch

Ahora subiremos el conjunto de datos de empleados de RRHH para demostrar cómo el agente trabaja con datos sensibles. Generé un conjunto de datos ficticio con esta estructura.

Estructura del conjunto de datos

{ "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" }

Crea el índice con mapeos

Primero, crea el índice con mapeos adecuados. Ten en cuenta que estamos usando semantic_text campos para algunos campos clave; Esto permite capacidades de búsqueda semántica para nuestro índice.

​​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" } } } }

Índice con API Bulk

Copia y pega el conjunto de datos en tus Dev Tools en Kibana y ejecutalo:

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": "...", ...}

Verifica los datos

Realiza una consulta para verificar:

GET hr-employees/_search

Paso 5: Construye y prueba tu agente de IA

Con todo configurado, es hora de crear un agente de IA personalizado usando Elastic Agent Builder. Para más detalles, consulte la documentación de Elastic.

Agregar el conector

Antes de poder crear nuestro nuevo agente, tenemos que configurar nuestro constructor de agentes para usar nuestro conector personalizado llamado LM Studio - GPT-OSS 20B porque el predeterminado es el Elastic Managed LLM. Para eso, necesitamos ir a Configuración > Gestión de Proyectos > Configuración de GenAI; ahora seleccionamos la que creamos y hacemos clic en Almacenar.

Constructor de Agentes de Acceso

  1. Ir a Agentes

  2. Haz clic en Crear un nuevo agente

Configurar el agente

Para crear un nuevo agente, los campos requeridos son el ID del agente, el nombre de visualización y las instrucciones de visualización.

Pero hay más opciones de personalización, como las Instrucciones Personalizadas que guían cómo se comportará tu agente e interactuará con tus herramientas, similar a una indicación del sistema, pero para nuestro agente personalizado. Las etiquetas ayudan a organizar tus agentes, el color del avatar y el símbolo del avatar.

Los que elegí para nuestro agente basándome en el conjunto de datos son: ID del agente: hr_assistant

Instrucciones personalizadas:

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

Etiquetas: Human Resources y GPT-OSS

Nombre de visualización: HR Analytics Assistant

Descripción de la exposición:

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.

Con todos los datos ahí, podemos hacer clic en Almacenar a nuestro nuevo agente.

Prueba al agente

Ahora puedes hacer preguntas en lenguaje natural sobre los datos de tus empleados, y GPT-OSS 20B entenderá la intención y generará una respuesta adecuada.

Pronto:

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

Respuesta:

El proceso de Agente fue:

1. Entiende tu pregunta usando el conector GPT-OSS

2. Generar la consulta Elasticsearch adecuada (usando las herramientas integradas o ES| personalizadoQL)

3. Recuperar los registros de empleados coincidentes

4. Presentar resultados en lenguaje natural con un formato adecuado

A diferencia de la búsqueda léxica tradicional, el agente impulsado por GPT-OSS entiende la intención y el contexto, facilitando encontrar información sin conocer los nombres exactos de los campos o la sintaxis de la consulta. Para más detalles sobre el proceso de pensamiento del agente, consulta este artículo.

Conclusión

En este artículo, creamos un agente de IA personalizado usando el Agent Builder de Elastic para conectarse al modelo OpenAI GPT-OSS que se ejecuta localmente. Al desplegar tanto Elastic como el LLM en tu máquina local, esta arquitectura te permite aprovechar las capacidades de IA generativa manteniendo el control total sobre tus datos, todo ello sin enviar información a servicios externos.

Usamos GPT-OSS 20B como experimento, pero aquí se hacen referencia a los modelos oficialmente recomendados para Elastic Agent Builder. Si necesitas capacidades de razonamiento más avanzadas, también está la variante de parámetros 120B que rinde mejor para escenarios complejos, aunque requiere una máquina de especificaciones más altas para ejecutar localmente. Para más detalles, consulte la documentación oficial de 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[Paneles impulsados por IA: de una visión a Kibana]]> Kibana Lens hace que los paneles de control sean muy sencillos, pero cuando necesitas decenas de paneles, los clics se acumulan. ¿Y si pudieras hacer un boceto de un panel de control, hacer capturas de pantalla y dejar que un LLM termine todo el proceso por ti?

En este artículo, haremos que eso suceda. Crearemos una aplicación que tome una imagen de un panel de control, analice nuestros mapeos y luego genere un panel sin que tengamos que tocar Kibana en absoluto.

Pasos:

  1. Antecedentes y flujo de trabajo de la aplicación

  2. Preparar datos

  3. Configuración de LLM

  4. Funciones de aplicación

Antecedentes y flujo de trabajo de la aplicación

La primera idea que se me ocurrió fue dejar que el LLM generara todo el formato NDJSON de los objetos almacenados de Kibana y luego los importara a Kibana.

Probamos algunos modelos:

  • Gemini 2.5 pro

  • GPT o3 / o4-mini-alto / 4,1

  • Claude 4 soneto

  • Grok 3

  • Deepseek (Deepthink R1)

Y para los prompts, empezamos tan sencillos como:

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

A pesar de repasar algunos ejemplos de planos y explicaciones detalladas sobre cómo construir cada visualización, no tuvimos suerte. Si te interesa esta experimentación, puedes encontrar detalles aquí.

El resultado de este enfoque fue ver estos mensajes al intentar subir a Kibana los archivos producidos por el LLM:

Esto significa que el JSON generado es inválido o está mal formateado. Los problemas más comunes eran que el LLM producía NDJSON incompleto, alucinaban parámetros o devolvían JSON normal en lugar de NDJSON, por mucho que intentáramos hacer cumplir lo contrario.

Inspirados por este artículo —donde las plantillas de búsqueda funcionaban mejor que el estilo libre de un LLM— decidimos dar plantillas al LLM en lugar de pedir generar el archivo NDJSON completo y luego, en código, usar los parámetros dados por el LLM para crear las visualizaciones adecuadas. Este enfoque no decepcionó, y es previsible y ampliable, ya que ahora el código hace el trabajo duro y no el LLM.

El flujo de trabajo de la aplicación será el siguiente:

Omitiremos algo de código para simplificar, pero puedes encontrar el código funcional de la aplicación completa en este cuaderno.

Prerrequisitos

Antes de empezar a desarrollar, necesitarás lo siguiente:

  1. Python 3.8 o superior

  2. Un entorno Venv Python

  3. Una instancia de Elasticsearch en ejecución, junto con su endpoint y clave API

  4. Una clave de API de OpenAI almacenada bajo el nombre de la variable de entorno OPENAI_API_KEY:

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

Preparar datos

Para los datos, lo mantendremos sencillo y usaremos registros sitio web de muestra de Elastic. Puedes aprender cómo importar esos datos a tu clúster aquí.

Cada documento incluye detalles sobre el anfitrión que emitió las solicitudes a la aplicación, junto con información sobre la propia solicitud y su estado de respuesta. A continuación se muestra un documento de ejemplo:

{ "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 }

Ahora, vamos a tomar los mapeos del índice que acabamos de cargar, 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"]

Vamos a pasar los mapeos junto con la imagen que cargaremos más adelante.

Configuración de LLM

Configuremos el LLM para que use una salida estructurada para introducir una imagen y recibir un JSON con la información que necesitamos pasar a nuestra función para producir los objetos JSON.

Instalamos las dependencias:

pip install elasticsearch pydantic langchain langchain-openai -q

Elasticsearch nos ayudará a recuperar los mapeos de índice. Pydantic nos permite definir esquemas en Python para luego pedir al LLM que lo siga, y LangChain es el framework que facilita la llamada a LLMs y herramientas de IA.

Crearemos un esquema Pydantic para definir la salida que queremos del LLM. Lo que necesitamos saber de la imagen es el tipo de gráfico, campo, título de visualización y título del panel de control:

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]

Para la entrada de imagen enviaremos un panel de control que acabo de dibujar:

Ahora declaramos la llamada al modelo LLM y la carga de imagen. Esta función recibirá los mapeos del índice de Elasticsearch y una imagen del panel de control que queremos generar.

Con with_structured_output podemos usar nuestro esquema de Dashboard Pydantic como objeto de respuesta que producirá el LLM. Con Pydantic, podemos definir modelos de datos con validación, lo que garantiza que la salida del LLM coincida con la estructura esperada.

Para convertir la imagen a base64 y enviarla como entrada, puedes usar un convertidor online o hacerlo en código.

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)}")

El LLM ya tiene contexto sobre los paneles Kibana, así que no necesitamos explicar todo en el prompt, solo algunos detalles para cerciorarnos de que no olvide que está funcionando con Elasticsearch y Kibana.

Vamos a desglosar el prompt:

Sección

Razón

Eres un experto en analizar paneles de Kibana a partir de imágenes para la versión 9.0.0 de Kibana.

Al reforzar esto es Elasticsearch, y la versión de Elasticsearch reducimos la probabilidad de que el LLM alucine parámetros antiguos o inválidos.

Se te dará una imagen del panel de control y un mapeo de índice de Elasticsearch.

Explicamos que la imagen trata sobre paneles para evitar interpretaciones erróneas por parte del LLM.

A continuación se muestran los mapeos de índices del índice en el que se basa el panel de control. Emplea esto para ayudarte a entender los datos y los campos disponibles. Mapeos de índice: {index_mappings}

Es crucial proporcionar los mapeos para que el LLM pueda seleccionar campos válidos dinámicamente. De lo contrario, podríamos codificar los mapeos aquí, lo cual es demasiado rígido, o confiar en la imagen que contiene los nombres de campo correctos, lo cual no es fiable.

Incluye solo los campos relevantes para cada visualización, basándote en lo que sea visible en la imagen.

Tuvimos que agregar este refuerzo porque a veces intenta agregar campos que no son relevantes para la imagen.

Esto devolverá un objeto con un serial de visualizaciones para mostrar:

"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"")" ]

Procesamiento de la respuesta de los LLM

Creamosun panel de panel de muestra 2x2 y luego lo exportamos en JSON usando la API Get a dashboard, y después almacenamos los paneles como plantillas de visualización (pastel, barra, métrica) donde podemos reemplazar algunos parámetros para crear nuevas visualizaciones con diferentes campos según la pregunta.

Puedes ver los archivos JSON de plantilla aquí. Fíjate en cómo cambiamos los valores de los objetos que queremos reemplazar más adelante por {variable_name}

Con la información que nos proporcionó el LLM, podemos decidir qué plantilla usar y qué valores reemplazar.

fill_template_with_analysis recibirá los parámetros de un único panel, incluyendo la plantilla JSON de la visualización, un título, un campo y las coordenadas de la visualización en la cuadrícula.

Luego, reemplazará los valores de la plantilla y devolverá la visualización JSON final.

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)

Para simplificar, tendremos coordenadas estáticas que asignaremos a los paneles que el LLM decida crear y produciremos un panel de cuadrícula 2x2 como en la imagen anterior.

# 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

Dependiendo del tipo de visualización decidido por el LLM, elegiremos una plantilla de archivo JSON y reemplazaremos la información relevante usando fill_template_with_analysis , luego agregaremos el nuevo panel a un array que usaremos más adelante para crear el panel de control.

Cuando el panel esté listo, usaremos la API Crear un panel para enviar el nuevo archivo JSON a Kibana y generar el panel:

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)}")

Para ejecutar el script y generar el panel de control, ejecuta el siguiente comando en la consola:

python <file_name>.py

El resultado final será el siguiente:

Conclusión

Los LLMs muestran sus fuertes capacidades visuales al hacer texto a código o convertir imágenes en código. La API de los paneles también permite convertir archivos JSON en paneles, y con un LLM y algo de código, podemos convertir imágenes en un panel Kibana.

El siguiente paso es mejorar la flexibilidad de los gráficos del salpicadero empleando diferentes configuraciones de cuadra, tamaños y posiciones de tablero. Además, ofrecer soporte para visualizaciones y tipos de visualización más complejos sería una adición útil a esta aplicación.

]]> 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