The Kibana MCP Server enables MCP-compatible clients to interact with Kibana instances through natural language or programmatic requests, dynamically managing API endpoints based on official Elastic Stack 8.x OpenAPI specifications.
• Connect Securely: Connect to local or remote Kibana instances using username/password authentication with SSL/TLS and custom CA certificate support • Multi-Space Operations: Access and manage APIs across multiple Kibana spaces in enterprise environments • Dynamic API Management: List, search, and get detailed information about Kibana API endpoints using keyword searches or comprehensive listings • Execute Custom Requests: Perform API operations (GET, POST, PUT, DELETE) with custom parameters, bodies, and target spaces • Monitor Server Status: Check Kibana server status globally or for specific spaces • Manage Spaces: Retrieve and manage available Kibana spaces with detailed information • Flexible Integration: Seamlessly integrate with MCP clients like Claude Desktop, supporting both conversational (tool-based) and raw data access (resource-based) interaction modes
Connects to Elastic Stack services through Kibana, using the OpenAPI YAML specification from Elastic Stack 8.x (ES8) to dynamically retrieve and manage all Kibana API endpoints.
Provides access to Kibana instances through API endpoints, allowing users to search, view, and execute Kibana APIs. Supports operations like checking server status, managing saved objects, creating dashboards, handling cases, and accessing endpoint events through Kibana's API.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Kibana MCP Servershow me the top 5 error logs from the last hour"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Kibana MCP Server
API Specification
This project is based on the official Elastic Kibana API documentation and uses the OpenAPI YAML specification from Elastic Stack 8.x (ES8) to dynamically retrieve and manage all Kibana API endpoints. For the latest details, see the Kibana API documentation.
A Kibana MCP server implementation that allows any MCP-compatible client (such as Claude Desktop) to access your Kibana instance via natural language or programmatic requests.
This project is community-maintained and is not an official product of Elastic or MCP.
💡 Companion Project
For complete Elastic Stack integration, pair this with Elasticsearch MCP Server for direct Elasticsearch data operations. Together, they provide comprehensive observability and data management capabilities for your Elastic Stack environment.
🚀 Installation
Quick Install
Alternative: From Source
Related MCP server: MISP-MCP-SERVER
🎯 Quick Start
Method 1: Direct CLI Usage
Using Basic Authentication
Using Cookie Authentication
Using API Key Authentication
Method 2: Claude Desktop Integration (Recommended)
Add to your Claude Desktop configuration file:
Config file locations:
MacOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Using Basic Authentication
Using Cookie Authentication
Using API Key Authentication
Method 3: Using Environment File
Method 4: Streamable HTTP Mode (NEW in v0.4.0)
Run the server as a standalone HTTP service for remote access and API integration:
HTTP Mode Features:
Exposes MCP server at
http://host:port/mcpendpointHealth check available at
http://host:port/healthSession-based connection management
Supports both POST (JSON-RPC requests) and GET (SSE streams)
Compatible with any HTTP client or MCP SDK
Example HTTP client usage:
Features
Core Features
Connect to local or remote Kibana instances
Dual transport modes:
Stdio transport (default) - For Claude Desktop and local MCP clients
Streamable HTTP transport (NEW in v0.4.0) - For remote access, API integration, and web applications
Dual authentication support:
Cookie-based authentication (recommended for browser sessions)
Basic authentication (username/password)
SSL/TLS and custom CA certificate support
Multi-space support for enterprise Kibana environments
Exposes Kibana API endpoints as both tools and resources
Search, view, and execute Kibana APIs from MCP clients
Type-safe, extensible, and easy to integrate
Session management with automatic UUID generation for HTTP mode
Health check endpoint for monitoring and load balancing
Visualization Layer (VL) Features
Complete CRUD operations for Kibana saved objects
Universal saved object management - works with all object types
Intelligent parameter handling - supports multiple input formats (arrays, JSON strings, comma-separated)
Optimized search with pagination support and performance tips
Bulk operations for efficient mass updates and deletions
Version control with optimistic concurrency for safe updates
Reference management for object relationships
Multi-format type support - flexible input parsing for better UX
Directory Structure
Resources
Resource URI | Description |
| Returns all available Kibana API endpoints (can filter with |
| Returns details for a specific API endpoint |
Examples:
kibana-api://paths?search=saved_objectskibana-api://path/GET/%2Fapi%2Fstatus
Tools
Base Tools
Tool Name | Description | Input Parameters |
| Get the current status of the Kibana server |
|
| Execute a custom Kibana API request |
|
| Get available Kibana spaces and current context |
|
| Search Kibana API endpoints by keyword |
|
| List all Kibana API endpoints | None |
| Get details for a specific Kibana API endpoint |
|
Visualization Layer (VL) Tools - Saved Objects Management
Tool Name | Description | Input Parameters |
| Search for Kibana saved objects (universal) |
|
| Get a single saved object by type and ID |
|
| Create a new saved object (universal) |
|
| Update a single saved object |
|
| Update multiple saved objects in bulk |
|
| Delete multiple saved objects in bulk |
|
Supported Saved Object Types: dashboard, visualization, index-pattern, search, config, lens, map, tag, canvas-workpad, canvas-element
Prompts
Prompt Name | Description |
| Tool expert mode (highly recommended in Claude Desktop), supports intelligent analysis, search, execution, and explanation of Kibana APIs via tools. Recommended for most users. |
| Resource helper mode, guides how to access and use Kibana API info via resource URIs. Suitable for clients that only support resource access or need raw API metadata. |
Configuration
Configure the server via environment variables:
Kibana Connection Settings
Variable Name | Description | Required |
| Kibana server address (e.g. http://localhost:5601) | Yes |
| Kibana API Key (base64 encoded, for API key auth) | No* |
| Kibana username (for basic auth) | No* |
| Kibana password (for basic auth) | No* |
| Kibana session cookies (for cookie auth) | No* |
| Default Kibana space (default: 'default') | No |
| CA certificate path (optional, for SSL verification) | No |
| Request timeout in ms (default 30000) | No |
| Max request retries (default 3) | No |
| Set to | No |
*One of the following authentication methods must be provided: KIBANA_API_KEY, KIBANA_COOKIES, or both KIBANA_USERNAME and KIBANA_PASSWORD. Priority order: API Key > Basic Auth > Cookies.
Transport Mode Settings (NEW in v0.4.0)
Variable Name | Description | Default | Values |
| Transport mode selection |
|
|
| HTTP server port (when using HTTP transport) |
| 1-65535 |
| HTTP server host (when using HTTP transport) |
| Any valid host |
Transport Mode Details:
Stdio mode (default): For Claude Desktop and local MCP clients
HTTP mode: Runs as a standalone HTTP server for remote access, API integration, and web applications
📦 Package Information
NPM Package: @tocharian/mcp-server-kibana
GitHub Repository: TocharianOU/mcp-server-kibana
Node.js: >= 18.0.0
Package Size: ~685KB (6.4MB unpacked)
🔧 Troubleshooting
Common Issues
"import: command not found" error
Connection issues
Verify Kibana URL is accessible
Check authentication credentials
For SSL issues, try setting
NODE_TLS_REJECT_UNAUTHORIZED=0
Claude Desktop not detecting the server
Restart Claude Desktop after config changes
Check config file syntax with a JSON validator
Verify environment variables are set correctly
Example Queries
Basic Queries
"What is the status of my Kibana server?"
"What is the status of my Kibana server in the 'marketing' space?"
"List all available Kibana spaces I can access."
"List all available Kibana API endpoints."
"Show details for the POST /api/saved_objects/_find endpoint."
"Execute a custom API request for /api/status."
Saved Objects Management
"Search for all dashboards in Kibana"
"Find visualizations containing 'nginx' in the title"
"Get dashboard with ID 'my-dashboard-123'"
"Create a new dashboard with title 'Sales Overview'"
"Update the description of visualization 'viz-456'"
"Delete multiple old dashboards by their IDs"
"Search for lens visualizations in the 'analytics' space"
"Find all canvas workpads created this month"
"Get the first 10 index patterns with only title and description fields"
"Bulk update multiple dashboard titles"
"Search across multiple object types: dashboards and visualizations"
"Create a new index pattern for 'logs-*' with timestamp field"
Two Prompt Modes in Claude Desktop
When using this server with Claude Desktop, two different prompt interaction modes are supported:
1. Tool-based Prompt Mode
How it works: Claude Desktop can directly call server tools (including base tools like
get_status,execute_api, and VL tools likevl_search_saved_objects,vl_create_saved_object) to answer your questions or perform actions.Best for: Users who want a conversational, guided experience. The server will automatically search, execute, and explain Kibana APIs and manage saved objects.
Example: "Show all dashboards containing 'sales'" or "Create a new visualization for web analytics"
Testing tip: Select the
kibana-tool-expertprompt in Claude Desktop for integration testing, then start using it.
2. Resource-based Prompt Mode
How it works: Claude Desktop interacts with the server via resource URIs (such as
kibana-api://pathsorkibana-api://path/GET/%2Fapi%2Fstatus), and the server returns structured data for Claude to parse.Best for: Advanced users, MCP clients that only support resource access, or programming scenarios needing raw API metadata.
Example: "Get resource kibana-api://paths?search=dashboard"
Note: The two endpoints in resources (kibana-api://paths and kibana-api://path/{method}/{encoded_path}) have corresponding base tools (list_all_kibana_api_paths, get_kibana_api_detail). This design ensures compatibility with MCP clients that cannot intelligently select multiple resources, making it easier for tools like Claude Desktop to interact with Kibana.
Tip: Most users are recommended to use tool mode for a more natural and powerful experience; resource mode offers maximum flexibility for advanced and compatibility use cases.
Development
Install dependencies:
Build the server:
Auto-rebuild in development mode:
Run in different modes:
Debugging
Since the MCP server communicates via stdio, debugging can be inconvenient. It is recommended to use MCP Inspector:
After starting, Inspector will provide a browser-accessible debugging tool URL.
Community
This project is community-maintained. Contributions and feedback are welcome! Please be respectful and inclusive in all communications, and follow the Elastic Community Code of Conduct.
License
This project is licensed under the Apache License 2.0. See the LICENSE file for details.
Troubleshooting
Check if MCP configuration is correct
Ensure the Kibana address is accessible
Verify authentication credentials have sufficient permissions
If using a custom CA, ensure the certificate path is correct and readable
If using
NODE_TLS_REJECT_UNAUTHORIZED=0, be aware of security risksCheck error messages output in the terminal