elasticsearch-mcp-server 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

{elasticsearch_mcp_server-1.0.0.dist-info → elasticsearch_mcp_server-2.0.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: elasticsearch-mcp-server
-Version: 1.0.0
-Summary: MCP Server for interacting with Elasticsearch
+Version: 2.0.0
+Summary: MCP Server for interacting with Elasticsearch and OpenSearch
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -205,17 +205,23 @@ License:                                  Apache License
            limitations under the License.
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.49.0
 Requires-Dist: elasticsearch>=8.0.0
 Requires-Dist: fastmcp>=0.4.0
 Requires-Dist: mcp>=1.0.0
+Requires-Dist: opensearch-py>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: tomli>=2.2.1
 Description-Content-Type: text/markdown
 
-# Elasticsearch MCP Server
+# Elasticsearch/OpenSearch MCP Server
+
+[![smithery badge](https://smithery.ai/badge/elasticsearch-mcp-server)](https://smithery.ai/server/elasticsearch-mcp-server)
 
 ## Overview
 
-A Model Context Protocol (MCP) server implementation that provides Elasticsearch interaction. This server enables searching documents, analyzing indices, and managing cluster through a set of tools.
+A Model Context Protocol (MCP) server implementation that provides Elasticsearch and OpenSearch interaction. This server enables searching documents, analyzing indices, and managing cluster through a set of tools.
 
 <a href="https://glama.ai/mcp/servers/b3po3delex"><img width="380" height="200" src="https://glama.ai/mcp/servers/b3po3delex/badge" alt="Elasticsearch MCP Server" /></a>
 
@@ -227,41 +233,67 @@ https://github.com/user-attachments/assets/f7409e31-fac4-4321-9c94-b0ff2ea7ff15
 
 ### Index Operations
 
-- `list_indices`: List all indices in the Elasticsearch cluster.
-- `get_mapping`: Retrieve the mapping configuration for a specific index.
-- `get_settings`: Get the settings configuration for a specific index.
+- `list_indices`: List all indices.
+- `get_index`: Returns information (mappings, settings, aliases) about one or more indices.
+- `create_index`: Create a new index.
+- `delete_index`: Delete an index.
 
 ### Document Operations
 
-- `search_documents`: Search documents in an index using Elasticsearch Query DSL.
+- `search_documents`: Search for documents.
+- `index_document`: Creates or updates a document in the index.
+- `get_document`: Get a document by ID.
+- `delete_document`: Delete a document by ID.
+- `delete_by_query`: Deletes documents matching the provided query.
 
 ### Cluster Operations
 
-- `get_cluster_health`: Get health status of the cluster.
-- `get_cluster_stats`: Get statistical information about the cluster.
+- `get_cluster_health`: Returns basic information about the health of the cluster.
+- `get_cluster_stats`: Returns high-level overview of cluster statistics.
+
+### Alias Operations
+
+- `list_aliases`: List all aliases.
+- `get_alias`: Get alias information for a specific index.
+- `put_alias`: Create or update an alias for a specific index.
+- `delete_alias`: Delete an alias for a specific index.
 
+## Configure Environment Variables
 
-## Start Elasticsearch Cluster
+Copy the `.env.example` file to `.env` and update the values accordingly.
 
-Start the Elasticsearch cluster using Docker Compose:
+## Start Elasticsearch/OpenSearch Cluster
+
+Start the Elasticsearch/OpenSearch cluster using Docker Compose:
 
 ```bash
-docker-compose up -d
+# For Elasticsearch
+docker-compose -f docker-compose-elasticsearch.yml up -d
+
+# For OpenSearch
+docker-compose -f docker-compose-opensearch.yml up -d
 ```
 
-This will start a 3-node Elasticsearch cluster and Kibana. Default Elasticsearch username `elastic`, password `test123`.
+The default Elasticsearch username is `elastic` and password is `test123`. The default OpenSearch username is `admin` and password is `admin`.
 
-You can access Kibana from http://localhost:5601.
+You can access Kibana/OpenSearch Dashboards from http://localhost:5601.
 
 ## Usage with Claude Desktop
 
-Add the following configuration to Claude Desktop's config file `claude_desktop_config.json`.
+### Option 1: Installing via Smithery
 
-### Option 1: Using uvx (Recommended)
+To install Elasticsearch Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/elasticsearch-mcp-server):
 
-Using `uvx` will automatically install the package from PyPI, no need to clone the repository locally
+```bash
+npx -y @smithery/cli install elasticsearch-mcp-server --client claude
+```
+
+### Option 2: Using uvx
+
+Using `uvx` will automatically install the package from PyPI, no need to clone the repository locally. Add the following configuration to Claude Desktop's config file `claude_desktop_config.json`.
 
 ```json
+// For Elasticsearch
 {
   "mcpServers": {
     "elasticsearch-mcp-server": {
@@ -270,23 +302,41 @@ Using `uvx` will automatically install the package from PyPI, no need to clone t
         "elasticsearch-mcp-server"
       ],
       "env": {
-        "ELASTIC_HOST": "https://localhost:9200",
-        "ELASTIC_USERNAME": "elastic",
-        "ELASTIC_PASSWORD": "test123"
+        "ELASTICSEARCH_HOST": "https://localhost:9200",
+        "ELASTICSEARCH_USERNAME": "elastic",
+        "ELASTICSEARCH_PASSWORD": "test123"
+      }
+    }
+  }
+}
+
+// For OpenSearch
+{
+  "mcpServers": {
+    "opensearch-mcp-server": {
+      "command": "uvx",
+      "args": [
+        "opensearch-mcp-server"
+      ],
+      "env": {
+        "OPENSEARCH_HOST": "https://localhost:9200",
+        "OPENSEARCH_USERNAME": "admin",
+        "OPENSEARCH_PASSWORD": "admin"
       }
     }
   }
 }
 ```
 
-### Option 2: Using uv with local development
+### Option 3: Using uv with local development
 
-Using `uv` requires cloning the repository locally and specifying the path to the source code.
+Using `uv` requires cloning the repository locally and specifying the path to the source code. Add the following configuration to Claude Desktop's config file `claude_desktop_config.json`.
 
 ```json
+// For Elasticsearch
 {
   "mcpServers": {
-    "elasticsearch": {
+    "elasticsearch-mcp-server": {
       "command": "uv",
       "args": [
         "--directory",
@@ -295,9 +345,29 @@ Using `uv` requires cloning the repository locally and specifying the path to th
         "elasticsearch-mcp-server"
       ],
       "env": {
-        "ELASTIC_HOST": "https://localhost:9200",
-        "ELASTIC_USERNAME": "elastic",
-        "ELASTIC_PASSWORD": "test123"
+        "ELASTICSEARCH_HOST": "https://localhost:9200",
+        "ELASTICSEARCH_USERNAME": "elastic",
+        "ELASTICSEARCH_PASSWORD": "test123"
+      }
+    }
+  }
+}
+
+// For OpenSearch
+{
+  "mcpServers": {
+    "opensearch-mcp-server": {
+      "command": "uv",
+      "args": [
+        "--directory",
+        "path/to/src/elasticsearch_mcp_server",
+        "run",
+        "opensearch-mcp-server"
+      ],
+      "env": {
+        "OPENSEARCH_HOST": "https://localhost:9200",
+        "OPENSEARCH_USERNAME": "admin",
+        "OPENSEARCH_PASSWORD": "admin"
       }
     }
   }
@@ -309,11 +379,17 @@ Using `uv` requires cloning the repository locally and specifying the path to th
 
 Restart Claude Desktop to load the new MCP server.
 
-Now you can interact with your Elasticsearch cluster through Claude using natural language commands like:
+Now you can interact with your Elasticsearch/OpenSearch cluster through Claude using natural language commands like:
 - "List all indices in the cluster"
 - "How old is the student Bob?"
 - "Show me the cluster health status"
 
+## Usage with Anthropic MCP Client
+
+```python
+uv run mcp_client/client.py src/server.py
+```
+
 ## License
 
-This project is licensed under the Apache License Version 2.0 - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache License Version 2.0 - see the [LICENSE](LICENSE) file for details.

elasticsearch_mcp_server-2.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+src/__init__.py,sha256=aNKcThftSLh9IjOTA-UUpoRzIm4R0WwXKGAzykwecmU,211
+src/server.py,sha256=BtNr3oKiRK1rbnocFIKzwpukY87_AylzKh_ffwP6Zr8,2153
+src/clients/__init__.py,sha256=3UezAt9422S-7BvMiCo2Y9pmATVutorwsIQXP_g_CkA,1221
+src/clients/base.py,sha256=vTe4I62ruO2bEeSAag-2B5fJOWJDXllKbo8qA0h4VkM,2160
+src/clients/exceptions.py,sha256=NYF3KVw-9aAgCViin5OuBI6miMEPS5QsdHx6bcis1wc,2493
+src/clients/common/__init__.py,sha256=VgvgxFpESn2wAuJmH0XM_Ej2izI7dxK7QJe9wG4fmW0,211
+src/clients/common/alias.py,sha256=rB53TSld5x2vZyDNAwyEdnh1KWUXMSD7h5fSv_ubR2Q,759
+src/clients/common/client.py,sha256=GD-V97Dj8c2XGUYt58vqCggkk-k8WJePPgngBDWO5aM,973
+src/clients/common/cluster.py,sha256=pd5BVpqqDU6Lck3K704eEdhgFgzt9NstotWQLyG9zFM,401
+src/clients/common/document.py,sha256=ZzZiXDf_UhlN2FCmqW3drVjIZ07kGYP9yth_sgsJGPc,1623
+src/clients/common/index.py,sha256=vyH5iXlJe5JLcDK6fhCCEPN-tgGm6zP5ilwGPdWCXbY,776
+src/tools/__init__.py,sha256=qiMRNUKlpNGnqbrkgBHGa7El1Pw_0a2qUJnuk_Q8LtY,324
+src/tools/alias.py,sha256=p9TD4gXkGRGWHTYfvCg7G2hj-Uch9jwDXJNUY1hSD0Y,1376
+src/tools/cluster.py,sha256=XRAG-uxdfrieYX1ov_cBb66IYXaa8OoSWCUfXvNauy0,587
+src/tools/document.py,sha256=XZTVuk4di9VEwWMZN7jyDVnzoOiXkb4FBrXF44sVXTs,2052
+src/tools/index.py,sha256=7KNPtElTFelkjRSvdMqPBx9nx_9Uk01OnTMeVo7YeCs,1345
+src/tools/register.py,sha256=wrG2P6-YPW77bTg1j_ELp8omWRYsJjFeOHUy_unHe6Y,1344
+elasticsearch_mcp_server-2.0.0.dist-info/METADATA,sha256=ro27Cz5Px51wVUv8lz-ASLObuMlWXQlbcw-RWT6SonI,18512
+elasticsearch_mcp_server-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+elasticsearch_mcp_server-2.0.0.dist-info/entry_points.txt,sha256=ImfJnUwMpQUBmu-1MeBG_P0dwamfXKQh82mBKW7tWNY,138
+elasticsearch_mcp_server-2.0.0.dist-info/licenses/LICENSE,sha256=DBsjuP5FR51d9kaUdXlVBuBv3cQ_I_adq9gefYQ9FcY,11339
+elasticsearch_mcp_server-2.0.0.dist-info/RECORD,,

elasticsearch_mcp_server-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+elasticsearch-mcp-server = src.server:elasticsearch_mcp_server
+opensearch-mcp-server = src.server:opensearch_mcp_server

src/__init__.py

@@ -0,0 +1,6 @@
+"""
+Search MCP Server package.
+"""
+from src.server import elasticsearch_mcp_server, opensearch_mcp_server, run_search_server
+
+__all__ = ['elasticsearch_mcp_server', 'opensearch_mcp_server', 'run_search_server']

src/clients/__init__.py

@@ -0,0 +1,42 @@
+import os
+
+from dotenv import load_dotenv
+
+from src.clients.common.client import SearchClient
+from src.clients.exceptions import handle_search_exceptions
+
+def create_search_client(engine_type: str) -> SearchClient:
+    """
+    Create a search client for the specified engine type.
+    
+    Args:
+        engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
+        
+    Returns:
+        A search client instance
+    """
+    # Load configuration from environment variables
+    load_dotenv()
+    
+    # Get configuration from environment variables
+    prefix = engine_type.upper()
+    hosts_str = os.environ.get(f"{prefix}_HOSTS", "https://localhost:9200")
+    hosts = [host.strip() for host in hosts_str.split(",")]
+    username = os.environ.get(f"{prefix}_USERNAME")
+    password = os.environ.get(f"{prefix}_PASSWORD")
+    verify_certs = os.environ.get(f"{prefix}_VERIFY_CERTS", "false").lower() == "true"
+    
+    config = {
+        "hosts": hosts,
+        "username": username,
+        "password": password,
+        "verify_certs": verify_certs
+    }
+    
+    return SearchClient(config, engine_type)
+
+__all__ = [
+    'create_search_client',
+    'handle_search_exceptions',
+    'SearchClient',
+]

src/clients/base.py

@@ -0,0 +1,54 @@
+from abc import ABC
+import logging
+import warnings
+from typing import Dict
+
+class SearchClientBase(ABC):
+    def __init__(self, config: Dict, engine_type: str):
+        """
+        Initialize the search client.
+        
+        Args:
+            config: Configuration dictionary with connection parameters
+            engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
+        """
+        self.logger = logging.getLogger()
+        self.config = config
+        self.engine_type = engine_type
+        
+        # Extract common configuration
+        hosts = config.get("hosts")
+        username = config.get("username")
+        password = config.get("password")
+        verify_certs = config.get("verify_certs", False)
+        
+        # Disable insecure request warnings if verify_certs is False
+        if not verify_certs:
+            warnings.filterwarnings("ignore", message=".*verify_certs=False is insecure.*")
+            warnings.filterwarnings("ignore", message=".*Unverified HTTPS request is being made to host.*")
+            
+            try:
+                import urllib3
+                urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+            except ImportError:
+                pass
+        
+        # Initialize client based on engine type
+        if engine_type == "elasticsearch":
+            from elasticsearch import Elasticsearch
+            self.client = Elasticsearch(
+                hosts=hosts,
+                basic_auth=(username, password) if username and password else None,
+                verify_certs=verify_certs
+            )
+            self.logger.info(f"Elasticsearch client initialized with hosts: {hosts}")
+        elif engine_type == "opensearch":
+            from opensearchpy import OpenSearch
+            self.client = OpenSearch(
+                hosts=hosts,
+                http_auth=(username, password) if username and password else None,
+                verify_certs=verify_certs
+            )
+            self.logger.info(f"OpenSearch client initialized with hosts: {hosts}")
+        else:
+            raise ValueError(f"Unsupported engine type: {engine_type}")

src/clients/common/__init__.py

@@ -0,0 +1,6 @@
+from .index import IndexClient
+from .document import DocumentClient
+from .cluster import ClusterClient
+from .alias import AliasClient
+
+__all__ = ['IndexClient', 'DocumentClient', 'ClusterClient', 'AliasClient']

src/clients/common/alias.py

@@ -0,0 +1,20 @@
+from typing import Dict
+
+from src.clients.base import SearchClientBase
+
+class AliasClient(SearchClientBase):
+    def list_aliases(self) -> Dict:
+        """Get all aliases."""
+        return self.client.cat.aliases()
+    
+    def get_alias(self, index: str) -> Dict:
+        """Get aliases for the specified index."""
+        return self.client.indices.get_alias(index=index)
+
+    def put_alias(self, index: str, name: str, body: Dict) -> Dict:
+        """Creates or updates an alias."""
+        return self.client.indices.put_alias(index=index, name=name, body=body)
+    
+    def delete_alias(self, index: str, name: str) -> Dict:
+        """Delete an alias for the specified index."""
+        return self.client.indices.delete_alias(index=index, name=name)

src/clients/common/client.py

@@ -0,0 +1,25 @@
+from typing import Dict
+
+from src.clients.common.alias import AliasClient
+from src.clients.common.cluster import ClusterClient
+from src.clients.common.document import DocumentClient
+from src.clients.common.index import IndexClient
+
+class SearchClient(IndexClient, DocumentClient, ClusterClient, AliasClient):
+    """
+    Unified search client that combines all search functionality.
+    
+    This class uses multiple inheritance to combine all specialized client implementations
+    (index, document, cluster, alias) into a single unified client.
+    """
+    
+    def __init__(self, config: Dict, engine_type: str):
+        """
+        Initialize the search client.
+        
+        Args:
+            config: Configuration dictionary with connection parameters
+            engine_type: Type of search engine to use ("elasticsearch" or "opensearch")
+        """
+        super().__init__(config, engine_type)
+        self.logger.info(f"Initialized the {engine_type} client")

src/clients/common/cluster.py

@@ -0,0 +1,12 @@
+from typing import Dict
+
+from src.clients.base import SearchClientBase
+
+class ClusterClient(SearchClientBase):
+    def get_cluster_health(self) -> Dict:
+        """Get cluster health information from OpenSearch."""
+        return self.client.cluster.health()
+    
+    def get_cluster_stats(self) -> Dict:
+        """Get cluster statistics from OpenSearch."""
+        return self.client.cluster.stats()

src/clients/common/document.py

@@ -0,0 +1,37 @@
+from typing import Dict, Optional
+
+from src.clients.base import SearchClientBase
+
+class DocumentClient(SearchClientBase):
+    def search_documents(self, index: str, body: Dict) -> Dict:
+        """Search for documents in the index."""
+        return self.client.search(index=index, body=body)
+    
+    def index_document(self, index: str, document: Dict, id: Optional[str] = None) -> Dict:
+        """Creates a new document in the index."""
+        # Handle parameter name differences between Elasticsearch and OpenSearch
+        if self.engine_type == "elasticsearch":
+            # For Elasticsearch: index(index, document, id=None, ...)
+            if id is not None:
+                return self.client.index(index=index, document=document, id=id)
+            else:
+                return self.client.index(index=index, document=document)
+        else:
+            # For OpenSearch: index(index, body, id=None, ...)
+            if id is not None:
+                return self.client.index(index=index, body=document, id=id)
+            else:
+                return self.client.index(index=index, body=document)
+    
+    def get_document(self, index: str, id: str) -> Dict:
+        """Get a document by ID."""
+        return self.client.get(index=index, id=id)
+    
+    def delete_document(self, index: str, id: str) -> Dict:
+        """Removes a document from the index."""
+        return self.client.delete(index=index, id=id)
+
+    def delete_by_query(self, index: str, body: Dict) -> Dict:
+        """Deletes documents matching the provided query."""
+        return self.client.delete_by_query(index=index, body=body)
+

src/clients/common/index.py

@@ -0,0 +1,20 @@
+from typing import Dict, Optional
+
+from src.clients.base import SearchClientBase
+
+class IndexClient(SearchClientBase):
+    def list_indices(self) -> Dict:
+        """List all indices."""
+        return self.client.cat.indices()
+    
+    def get_index(self, index: str) -> Dict:
+        """Returns information (mappings, settings, aliases) about one or more indices."""
+        return self.client.indices.get(index=index)
+    
+    def create_index(self, index: str, body: Optional[Dict] = None) -> Dict:
+        """Creates an index with optional settings and mappings."""
+        return self.client.indices.create(index=index, body=body)
+    
+    def delete_index(self, index: str) -> Dict:
+        """Delete an index."""
+        return self.client.indices.delete(index=index)

src/clients/exceptions.py

@@ -0,0 +1,69 @@
+import functools
+import logging
+from typing import TypeVar, Callable
+
+from fastmcp import FastMCP
+from mcp.types import TextContent
+
+T = TypeVar('T')
+
+def handle_search_exceptions(func: Callable[..., T]) -> Callable[..., list[TextContent]]:
+    """
+    Decorator to handle exceptions in search client operations.
+    
+    Args:
+        func: The function to decorate
+        
+    Returns:
+        Decorated function that handles exceptions
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        logger = logging.getLogger()   
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Unexpected error in {func.__name__}: {e}")
+            return [TextContent(type="text", text=f"Unexpected error in {func.__name__}: {str(e)}")]
+    
+    return wrapper
+
+def with_exception_handling(tool_instance: object, mcp: FastMCP) -> None:
+    """
+    Register tools from a tool instance with automatic exception handling applied to all tools.
+    
+    This function temporarily replaces mcp.tool with a wrapped version that automatically
+    applies the handle_search_exceptions decorator to all registered tool methods.
+    
+    Args:
+        tool_instance: The tool instance that has a register_tools method
+        mcp: The FastMCP instance used for tool registration
+    """
+    # Save the original tool method
+    original_tool = mcp.tool
+
+    @functools.wraps(original_tool)
+    def wrapped_tool(*args, **kwargs):
+        # Get the original decorator
+        decorator = original_tool(*args, **kwargs)
+
+        # Return a new decorator that applies both the exception handler and original decorator
+        def combined_decorator(func):
+            # First apply the exception handling decorator
+            wrapped_func = handle_search_exceptions(func)
+            # Then apply the original mcp.tool decorator
+            return decorator(wrapped_func)
+
+        return combined_decorator
+
+    try:
+        # Temporarily replace mcp.tool with our wrapped version
+        mcp.tool = wrapped_tool
+
+        # Call the registration method on the tool instance
+        tool_instance.register_tools(mcp)
+    finally:
+        # Restore the original mcp.tool to avoid affecting other code that might use mcp.tool
+        # This ensures that our modification is isolated to just this tool registration
+        # and prevents multiple nested decorators if register_all_tools is called multiple times
+        mcp.tool = original_tool

src/server.py

@@ -0,0 +1,71 @@
+import logging
+import sys
+
+from fastmcp import FastMCP
+
+from src.clients import create_search_client
+from src.tools.alias import AliasTools
+from src.tools.cluster import ClusterTools
+from src.tools.document import DocumentTools
+from src.tools.index import IndexTools
+from src.tools.register import ToolsRegister
+
+class SearchMCPServer:
+    def __init__(self, engine_type):
+        # Set engine type
+        self.engine_type = engine_type
+        self.name = f"{self.engine_type}_mcp_server"
+        self.mcp = FastMCP(self.name)
+        self.logger = logging.getLogger()
+        self.logger.info(f"Initializing {self.name}...")
+        
+        # Create the corresponding search client
+        self.search_client = create_search_client(self.engine_type)
+        
+        # Initialize tools
+        self._register_tools()
+
+    def _register_tools(self):
+        """Register all MCP tools."""
+        # Create a tools register
+        register = ToolsRegister(self.logger, self.search_client, self.mcp)
+        
+        # Define all tool classes to register
+        tool_classes = [
+            IndexTools,
+            DocumentTools,
+            ClusterTools,
+            AliasTools
+        ]        
+        # Register all tools
+        register.register_all_tools(tool_classes)
+
+    def run(self):
+        """Run the MCP server."""
+        self.mcp.run()
+
+def run_search_server(engine_type):
+    """Run search server with specified engine type."""
+    server = SearchMCPServer(engine_type=engine_type)
+    server.run()
+
+def elasticsearch_mcp_server():
+    """Entry point for Elasticsearch MCP server."""
+    run_search_server(engine_type="elasticsearch")
+
+def opensearch_mcp_server():
+    """Entry point for OpenSearch MCP server."""
+    run_search_server(engine_type="opensearch")
+
+if __name__ == "__main__":
+    # Default to Elasticsearch
+    engine_type = "elasticsearch"
+    
+    # If command line arguments are provided, use the first argument as the engine type
+    if len(sys.argv) > 1:
+        engine_type = sys.argv[1].lower()
+    
+    if engine_type == "opensearch":
+        opensearch_mcp_server()
+    else:
+        elasticsearch_mcp_server()

src/tools/__init__.py

@@ -0,0 +1,13 @@
+from src.tools.index import IndexTools
+from src.tools.document import DocumentTools
+from src.tools.cluster import ClusterTools
+from src.tools.alias import AliasTools
+from src.tools.register import ToolsRegister
+
+__all__ = [
+    'IndexTools',
+    'DocumentTools',
+    'ClusterTools',
+    'AliasTools',
+    'ToolsRegister',
+]

src/tools/alias.py

@@ -0,0 +1,46 @@
+from typing import Dict, List
+
+from fastmcp import FastMCP
+
+class AliasTools:
+    def __init__(self, search_client):
+        self.search_client = search_client
+    def register_tools(self, mcp: FastMCP):
+        @mcp.tool()
+        def list_aliases() -> List[Dict]:
+            """List all aliases."""
+            return self.search_client.list_aliases()
+
+        @mcp.tool()
+        def get_alias(index: str) -> Dict:
+            """
+            Get alias information for a specific index.
+
+            Args:
+                index: Name of the index
+            """
+            return self.search_client.get_alias(index=index)
+
+        @mcp.tool()
+        def put_alias(index: str, name: str, body: Dict) -> Dict:
+            """
+            Create or update an alias for a specific index.
+
+            Args:
+                index: Name of the index
+                name: Name of the alias
+                body: Alias configuration
+            """
+            return self.search_client.put_alias(index=index, name=name, body=body)
+
+        @mcp.tool()
+        def delete_alias(index: str, name: str) -> Dict:
+            """
+            Delete an alias for a specific index.
+
+            Args:
+                index: Name of the index
+                name: Name of the alias
+            """
+            return self.search_client.delete_alias(index=index, name=name)
+        

src/tools/cluster.py

@@ -0,0 +1,17 @@
+from typing import Dict
+
+from fastmcp import FastMCP
+
+class ClusterTools:
+    def __init__(self, search_client):
+        self.search_client = search_client
+    def register_tools(self, mcp: FastMCP):
+        @mcp.tool()
+        def get_cluster_health() -> Dict:
+            """Returns basic information about the health of the cluster."""
+            return self.search_client.get_cluster_health()
+
+        @mcp.tool()
+        def get_cluster_stats() -> Dict:
+            """Returns high-level overview of cluster statistics."""
+            return self.search_client.get_cluster_stats()

src/tools/document.py

@@ -0,0 +1,64 @@
+from typing import Dict, Optional
+
+from fastmcp import FastMCP
+
+class DocumentTools:
+    def __init__(self, search_client):
+        self.search_client = search_client
+    
+    def register_tools(self, mcp: FastMCP):
+        @mcp.tool()
+        def search_documents(index: str, body: Dict) -> Dict:
+            """
+            Search for documents.
+            
+            Args:
+                index: Name of the index
+                body: Search query
+            """
+            return self.search_client.search_documents(index=index, body=body)
+        
+        @mcp.tool()
+        def index_document(index: str, document: Dict, id: Optional[str] = None) -> Dict:
+            """
+            Creates or updates a document in the index.
+            
+            Args:
+                index: Name of the index
+                document: Document data
+                id: Optional document ID
+            """
+            return self.search_client.index_document(index=index, id=id, document=document)
+        
+        @mcp.tool()
+        def get_document(index: str, id: str) -> Dict:
+            """
+            Get a document by ID.
+            
+            Args:
+                index: Name of the index
+                id: Document ID
+            """
+            return self.search_client.get_document(index=index, id=id)
+        
+        @mcp.tool()
+        def delete_document(index: str, id: str) -> Dict:
+            """
+            Delete a document by ID.
+            
+            Args:
+                index: Name of the index
+                id: Document ID
+            """
+            return self.search_client.delete_document(index=index, id=id)
+        
+        @mcp.tool()
+        def delete_by_query(index: str, body: Dict) -> Dict:
+            """
+            Deletes documents matching the provided query.
+            
+            Args:
+                index: Name of the index
+                body: Query to match documents for deletion
+            """
+            return self.search_client.delete_by_query(index=index, body=body)

src/tools/index.py

@@ -0,0 +1,44 @@
+from typing import Dict, Optional, List
+
+from fastmcp import FastMCP
+
+class IndexTools:
+    def __init__(self, search_client):
+        self.search_client = search_client
+        
+    def register_tools(self, mcp: FastMCP):
+        @mcp.tool()
+        def list_indices() -> List[Dict]:
+            """List all indices."""
+            return self.search_client.list_indices()
+
+        @mcp.tool()
+        def get_index(index: str) -> Dict:
+            """
+            Returns information (mappings, settings, aliases) about one or more indices.
+            
+            Args:
+                index: Name of the index
+            """
+            return self.search_client.get_index(index=index)
+
+        @mcp.tool()
+        def create_index(index: str, body: Optional[Dict] = None) -> Dict:
+            """
+            Create a new index.
+            
+            Args:
+                index: Name of the index
+                body: Optional index configuration including mappings and settings
+            """
+            return self.search_client.create_index(index=index, body=body)
+
+        @mcp.tool()
+        def delete_index(index: str) -> Dict:
+            """
+            Delete an index.
+            
+            Args:
+                index: Name of the index
+            """
+            return self.search_client.delete_index(index=index)

src/tools/register.py

@@ -0,0 +1,41 @@
+import logging
+from typing import List, Type
+
+from fastmcp import FastMCP
+
+from src.clients import SearchClient
+from src.clients.exceptions import with_exception_handling
+
+class ToolsRegister:
+    """Class to handle registration of MCP tools."""
+    
+    def __init__(self, logger: logging.Logger, search_client: SearchClient, mcp: FastMCP):
+        """
+        Initialize the tools register.
+        
+        Args:
+            logger: Logger instance
+            search_client: Search client instance
+            mcp: FastMCP instance
+        """
+        self.logger = logger
+        self.search_client = search_client
+        self.mcp = mcp
+    
+    def register_all_tools(self, tool_classes: List[Type]):
+        """
+        Register all tools with the MCP server.
+        
+        Args:
+            tool_classes: List of tool classes to register
+        """
+        for tool_class in tool_classes:
+            self.logger.info(f"Registering tools from {tool_class.__name__}")
+            tool_instance = tool_class(self.search_client)
+            
+            # Set logger and client attributes
+            tool_instance.logger = self.logger
+            tool_instance.search_client = self.search_client
+            
+            # Register tools with automatic exception handling
+            with_exception_handling(tool_instance, self.mcp)

elasticsearch_mcp_server/__init__.py

@@ -1,10 +0,0 @@
-from . import server
-
-
-def main():
-    """Main entry point for the package."""
-    server.main()
-
-
-# Optionally expose other important items at package level
-__all__ = ["main", "server"]

elasticsearch_mcp_server/es_client.py

@@ -1,40 +0,0 @@
-import logging
-import os
-from dotenv import load_dotenv
-from elasticsearch import Elasticsearch
-import warnings
-
-class ElasticsearchClient:
-    def __init__(self, logger: logging.Logger):
-        self.logger = logger
-        self.es_client = self._create_elasticsearch_client()
-
-    def _get_es_config(self):
-        """Get Elasticsearch configuration from environment variables."""
-        # Load environment variables from .env file
-        load_dotenv()
-        config = {
-            "host": os.getenv("ELASTIC_HOST"),
-            "username": os.getenv("ELASTIC_USERNAME"),
-            "password": os.getenv("ELASTIC_PASSWORD")
-        }
-        
-        if not all([config["username"], config["password"]]):
-            self.logger.error("Missing required Elasticsearch configuration. Please check environment variables:")
-            self.logger.error("ELASTIC_USERNAME and ELASTIC_PASSWORD are required")
-            raise ValueError("Missing required Elasticsearch configuration")
-        
-        return config
-
-    def _create_elasticsearch_client(self) -> Elasticsearch:
-        """Create and return an Elasticsearch client using configuration from environment."""
-        config = self._get_es_config()
-
-        # Disable SSL warnings
-        warnings.filterwarnings("ignore", message=".*TLS with verify_certs=False is insecure.*",)
-
-        return Elasticsearch(
-            config["host"],
-            basic_auth=(config["username"], config["password"]),
-            verify_certs=False
-        )

elasticsearch_mcp_server/server.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-import logging
-from fastmcp import FastMCP
-from .tools.index import IndexTools
-from .tools.document import DocumentTools
-from .tools.cluster import ClusterTools
-
-class ElasticsearchMCPServer:
-    def __init__(self):
-        self.name = "elasticsearch_mcp_server"
-        self.mcp = FastMCP(self.name)
-        
-        # Configure logging
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-        self.logger = logging.getLogger(self.name)
-        
-        # Initialize tools
-        self._register_tools()
-
-    def _register_tools(self):
-        """Register all MCP tools."""
-        # Initialize tool classes
-        index_tools = IndexTools(self.logger)
-        document_tools = DocumentTools(self.logger)
-        cluster_tools = ClusterTools(self.logger)
-        
-        # Register tools from each module
-        index_tools.register_tools(self.mcp)
-        document_tools.register_tools(self.mcp)
-        cluster_tools.register_tools(self.mcp)
-
-    def run(self):
-        """Run the MCP server."""
-        self.mcp.run()
-
-def main():
-    server = ElasticsearchMCPServer()
-    server.run()

elasticsearch_mcp_server/tools/cluster.py

@@ -1,38 +0,0 @@
-import logging
-from typing import Dict, Any
-from ..es_client import ElasticsearchClient
-from mcp.types import TextContent
-
-class ClusterTools(ElasticsearchClient):
-    def register_tools(self, mcp: Any):
-        """Register cluster-related tools."""
-        
-        @mcp.tool(description="Get cluster health status")
-        async def get_cluster_health() -> list[TextContent]:
-            """
-            Get health status of the Elasticsearch cluster.
-            Returns information about the number of nodes, shards, etc.
-            """
-            self.logger.info("Getting cluster health")
-            try:
-                response = self.es_client.cluster.health()
-                return [TextContent(type="text", text=str(response))]
-            except Exception as e:
-                self.logger.error(f"Error getting cluster health: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]
-
-        @mcp.tool(description="Get cluster statistics")
-        async def get_cluster_stats() -> list[TextContent]:
-            """
-            Get statistics from a cluster wide perspective. 
-            The API returns basic index metrics (shard numbers, store size, memory usage) and information 
-            about the current nodes that form the cluster (number, roles, os, jvm versions, memory usage, cpu and installed plugins).
-            https://www.elastic.co/guide/en/elasticsearch/reference/8.17/cluster-stats.html
-            """
-            self.logger.info("Getting cluster stats")
-            try:
-                response = self.es_client.cluster.stats()
-                return [TextContent(type="text", text=str(response))]
-            except Exception as e:
-                self.logger.error(f"Error getting cluster stats: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]

elasticsearch_mcp_server/tools/document.py

@@ -1,25 +0,0 @@
-import logging
-from typing import Dict, Any
-from ..es_client import ElasticsearchClient
-from mcp.types import TextContent
-
-class DocumentTools(ElasticsearchClient):
-    def register_tools(self, mcp: Any):
-        """Register document-related tools."""
-        
-        @mcp.tool(description="Search documents in an index with a custom query")
-        async def search_documents(index: str, body: dict) -> list[TextContent]:
-            """
-            Search documents in a specified index using a custom query.
-            
-            Args:
-                index: Name of the index to search
-                body: Elasticsearch query DSL
-            """
-            self.logger.info(f"Searching in index: {index} with query: {body}")
-            try:
-                response = self.es_client.search(index=index, body=body)
-                return [TextContent(type="text", text=str(response))]
-            except Exception as e:
-                self.logger.error(f"Error searching documents: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]

elasticsearch_mcp_server/tools/index.py

@@ -1,51 +0,0 @@
-import logging
-from typing import Dict, Any
-from ..es_client import ElasticsearchClient
-from mcp.types import TextContent
-
-class IndexTools(ElasticsearchClient):
-    def register_tools(self, mcp: Any):
-        """Register index-related tools."""
-        
-        @mcp.tool(description="List all indices in the Elasticsearch cluster")
-        async def list_indices() -> list[TextContent]:
-            """List all indices in the Elasticsearch cluster."""
-            self.logger.info("Listing indices...")
-            try:
-                indices = self.es_client.cat.indices(format="json")
-                return [TextContent(type="text", text=str(indices))]
-            except Exception as e:
-                self.logger.error(f"Error listing indices: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]
-
-        @mcp.tool(description="Get index mapping")
-        async def get_mapping(index: str) -> list[TextContent]:
-            """
-            Get the mapping for an index.
-            
-            Args:
-                index: Name of the index
-            """
-            self.logger.info(f"Getting mapping for index: {index}")
-            try:
-                response = self.es_client.indices.get_mapping(index=index)
-                return [TextContent(type="text", text=str(response))]
-            except Exception as e:
-                self.logger.error(f"Error getting mapping: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]
-
-        @mcp.tool(description="Get index settings")
-        async def get_settings(index: str) -> list[TextContent]:
-            """
-            Get the settings for an index.
-            
-            Args:
-                index: Name of the index
-            """
-            self.logger.info(f"Getting settings for index: {index}")
-            try:
-                response = self.es_client.indices.get_settings(index=index)
-                return [TextContent(type="text", text=str(response))]
-            except Exception as e:
-                self.logger.error(f"Error getting settings: {e}")
-                return [TextContent(type="text", text=f"Error: {str(e)}")]

elasticsearch_mcp_server-1.0.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-elasticsearch_mcp_server/__init__.py,sha256=wGsW3VlozSA6CWKQSuUTaLZb31m4dNN8ACNG6xRwOyU,186
-elasticsearch_mcp_server/es_client.py,sha256=n7RYcB97DgCIkrY1ryP4Ubq3IJxfnKqzvXMXRCbOXr8,1510
-elasticsearch_mcp_server/server.py,sha256=RGKJKk6EpnM1etM8CYXoR_A4OjHqlXcIyRqgJfNJksg,1212
-elasticsearch_mcp_server/tools/cluster.py,sha256=bGShKKDCgHW0GZoPd8ty__yX1Yn_dTwOH4hGGQsO5l8,1849
-elasticsearch_mcp_server/tools/document.py,sha256=PDD63Etp1MS0G8N3IDg1j-hG41r5OFe4adlotnyuZHU,1075
-elasticsearch_mcp_server/tools/index.py,sha256=Zgc90bVNH18LaHs4CXIRDAdcAdJyxx_RN788xZjLA-A,2174
-elasticsearch_mcp_server-1.0.0.dist-info/METADATA,sha256=2aJ3yVM0e-zCowyEEOQYmZw78ii3qwLLdJ5RRzAv7qQ,16225
-elasticsearch_mcp_server-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-elasticsearch_mcp_server-1.0.0.dist-info/entry_points.txt,sha256=sAW_y-4MkO9T00GbIb_tLQikrTPF94uHU1YkbWMj65g,75
-elasticsearch_mcp_server-1.0.0.dist-info/licenses/LICENSE,sha256=DBsjuP5FR51d9kaUdXlVBuBv3cQ_I_adq9gefYQ9FcY,11339
-elasticsearch_mcp_server-1.0.0.dist-info/RECORD,,

elasticsearch_mcp_server-1.0.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-elasticsearch-mcp-server = elasticsearch_mcp_server:main