couchbase-mcp-server 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

certs/capella_root_ca.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw
+JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy
+MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG
+A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi
+enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85
+Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU
+WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6
+rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn
+mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j
+KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE
+FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B
+AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8
+m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY
+xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P
+Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA
+fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi
+DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==
+-----END CERTIFICATE-----

{couchbase_mcp_server-0.5.0.dist-info → couchbase_mcp_server-0.5.2.dist-info}/METADATA

@@ -1,26 +1,26 @@
 Metadata-Version: 2.4
 Name: couchbase-mcp-server
-Version: 0.5.0
+Version: 0.5.2
 Summary: Couchbase MCP Server - The Developer Data Platform for Critical Applications in Our AI World
-Author-email: Nithish Raghunandanan <devadvocates@couchbase.com>
-License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Couchbase-Ecosystem/mcp-server-couchbase
 Project-URL: Documentation, https://github.com/Couchbase-Ecosystem/mcp-server-couchbase#readme
 Project-URL: Issues, https://github.com/Couchbase-Ecosystem/mcp-server-couchbase/issues
+Author-email: Nithish Raghunandanan <devadvocates@couchbase.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Database
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: click==8.2.1
-Requires-Dist: couchbase==4.4.0
-Requires-Dist: lark-sqlpp==0.0.1
-Requires-Dist: mcp[cli]==1.12.0
+Requires-Python: <3.14,>=3.10
+Requires-Dist: click<9.0.0,>=8.2.1
+Requires-Dist: couchbase<5.0.0,>=4.4.0
+Requires-Dist: lark-sqlpp>=0.0.1
+Requires-Dist: mcp[cli]<2.0.0,>=1.20.0
+Requires-Dist: urllib3>=2.0.0
 Provides-Extra: dev
-Requires-Dist: ruff==0.12.5; extra == "dev"
-Requires-Dist: pre-commit==4.2.0; extra == "dev"
-Dynamic: license-file
+Requires-Dist: pre-commit==4.2.0; extra == 'dev'
+Requires-Dist: ruff==0.12.5; extra == 'dev'
+Description-Content-Type: text/markdown
 
 # Couchbase MCP Server
 
@@ -32,6 +32,8 @@ An [MCP](https://modelcontextprotocol.io/) server implementation of Couchbase th
   <img width="380" height="200" src="https://glama.ai/mcp/servers/@Couchbase-Ecosystem/mcp-server-couchbase/badge" alt="Couchbase Server MCP server" />
 </a>
 
+<!-- mcp-name: io.github.Couchbase-Ecosystem/mcp-server-couchbase -->
+
 ## Features
 
 - Get a list of all the buckets in the cluster
@@ -43,9 +45,13 @@ An [MCP](https://modelcontextprotocol.io/) server implementation of Couchbase th
 - Upsert a document by ID to a specified scope and collection
 - Delete a document by ID from a specified scope and collection
 - Run a [SQL++ query](https://www.couchbase.com/sqlplusplus/) on a specified scope
+  - Queries are automatically scoped to the specified bucket and scope, so use collection names directly (e.g., use `SELECT * FROM users` instead of `SELECT * FROM bucket.scope.users`)
   - There is an option in the MCP server, `CB_MCP_READ_ONLY_QUERY_MODE` that is set to true by default to disable running SQL++ queries that change the data or the underlying collection structure. Note that the documents can still be updated by ID.
 - Get the status of the MCP server
 - Check the cluster credentials by connecting to the cluster
+- List all indexes in the cluster with their definitions, with optional filtering by bucket, scope, collection and index name.
+- Get index recommendations from Couchbase Index Advisor for a given SQL++ query to optimize query performance
+- Get cluster health status and list of all running services
 
 ## Prerequisites
 

couchbase_mcp_server-0.5.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+certs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+certs/capella_root_ca.pem,sha256=SuSjgKclcQQg0kheTRd3dg6B0FUsUy717T5n3xcAU_E,1131
+mcp_server.py,sha256=dvHQR-55JhuXX_bj2hLU0ek411qPp0qHEKqAmPdwjKU,4991
+tools/__init__.py,sha256=otQd8IiEILtl1jgorEO1E9KqL_2xBBlqwnVHejoCPE0,1668
+tools/index.py,sha256=cCBr0ptFBVc-HN5SoCauQAh2DsAP_Is8NPUSa6QcLM0,6682
+tools/kv.py,sha256=NGUs43iuXElj9rYe4RCyCStqoh5y1fUgbg1oWuU4WeQ,2493
+tools/query.py,sha256=tg_MBrk8Pe8G3SCWV7m3RpA562pCuowUzCS7gGO95TI,3941
+tools/server.py,sha256=4krPjBoQmUHUmOE03T0CcCGFJtoaeHVS91oOrYj8JsA,6670
+utils/__init__.py,sha256=Fcbp-VIK0Gwwy7hl1AjV9NBKZsscmOV2vYdTBam5M3A,1361
+utils/config.py,sha256=B6H_JYDn6uxtu9juM924zdvNQgSaHh_u6rYME3_0_xQ,268
+utils/connection.py,sha256=NtAU4pmHMZubSJcs_X_lai9o8dih5mW0RyrRdmyp1Po,2892
+utils/constants.py,sha256=w0zvQ1zMzJBg44Yl3aQW8KfaaRPn0BgPOLEe8xLeLSE,487
+utils/context.py,sha256=XZL4M70BMdFBptJ9sT0zxhEey-EvvoSKZJrP_sb7q-A,2286
+utils/index_utils.py,sha256=W0rvoBXU_2aB9m-HDlLChZoMzvlIX6FUWF6RTsYGfYM,10910
+couchbase_mcp_server-0.5.2.dist-info/METADATA,sha256=N07YqDMLBXra3Qh4gu5hlxCvG_nnLbm0E3sMN2KAQqM,21220
+couchbase_mcp_server-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+couchbase_mcp_server-0.5.2.dist-info/entry_points.txt,sha256=iU5pF4kIMTnNhoMPHhdH-k8o1Fmxb_iM9qJHCZcL6Ak,57
+couchbase_mcp_server-0.5.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+couchbase_mcp_server-0.5.2.dist-info/RECORD,,

{couchbase_mcp_server-0.5.0.dist-info → couchbase_mcp_server-0.5.2.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

mcp_server.py

@@ -165,7 +165,6 @@ def main(
         {
             "host": host,
             "port": port,
-            "transport": sdk_transport,
         }
         if transport in NETWORK_TRANSPORTS
         else {}

tools/__init__.py

@@ -4,6 +4,9 @@ Couchbase MCP Tools
 This module contains all the MCP tools for Couchbase operations.
 """
 
+# Index tools
+from .index import get_index_advisor_recommendations, list_indexes
+
 # Key-Value tools
 from .kv import (
     delete_document_by_id,
@@ -20,6 +23,7 @@ from .query import (
 # Server tools
 from .server import (
     get_buckets_in_cluster,
+    get_cluster_health_and_services,
     get_collections_in_scope,
     get_scopes_and_collections_in_bucket,
     get_scopes_in_bucket,
@@ -40,6 +44,9 @@ ALL_TOOLS = [
     delete_document_by_id,
     get_schema_for_collection,
     run_sql_plus_plus_query,
+    get_index_advisor_recommendations,
+    list_indexes,
+    get_cluster_health_and_services,
 ]
 
 __all__ = [
@@ -55,6 +62,9 @@ __all__ = [
     "delete_document_by_id",
     "get_schema_for_collection",
     "run_sql_plus_plus_query",
+    "get_index_advisor_recommendations",
+    "list_indexes",
+    "get_cluster_health_and_services",
     # Convenience
     "ALL_TOOLS",
 ]

tools/index.py

@@ -0,0 +1,172 @@
+"""
+Tools for index operations.
+
+This module contains tools for listing and managing indexes in the Couchbase cluster and getting index recommendations using the Couchbase Index Advisor.
+"""
+
+import logging
+from typing import Any
+
+from mcp.server.fastmcp import Context
+
+from tools.query import run_sql_plus_plus_query
+from utils.config import get_settings
+from utils.constants import MCP_SERVER_NAME
+from utils.index_utils import (
+    fetch_indexes_from_rest_api,
+    process_index_data,
+    validate_connection_settings,
+    validate_filter_params,
+)
+
+logger = logging.getLogger(f"{MCP_SERVER_NAME}.tools.index")
+
+
+def get_index_advisor_recommendations(
+    ctx: Context, bucket_name: str, scope_name: str, query: str
+) -> dict[str, Any]:
+    """Get index recommendations from Couchbase Index Advisor for a given SQL++ query.
+
+    The Index Advisor analyzes the query and provides recommendations for optimal indexes.
+    This tool works with SELECT, UPDATE, DELETE, or MERGE queries.
+    The queries will be run on the specified scope in the specified bucket.
+
+    Returns a dictionary with:
+    - current_used_indexes: Array of currently used indexes (if any)
+    - recommended_indexes: Array of recommended secondary indexes (if any)
+    - recommended_covering_indexes: Array of recommended covering indexes (if any)
+
+    Each index object contains:
+    - index: The CREATE INDEX SQL++ command
+    - statements: Array of statement objects with the query and run count
+    """
+    try:
+        # Build the ADVISOR query
+        advisor_query = f"SELECT ADVISOR('{query}') AS advisor_result"
+
+        logger.info("Running Index Advisor for the provided query")
+
+        # Execute the ADVISOR function at cluster level using run_sql_plus_plus_query
+        advisor_results = run_sql_plus_plus_query(
+            ctx, bucket_name, scope_name, advisor_query
+        )
+
+        if not advisor_results:
+            return {
+                "message": "No recommendations available",
+                "current_used_indexes": [],
+                "recommended_indexes": [],
+                "recommended_covering_indexes": [],
+            }
+
+        # The result is wrapped in advisor_result key
+        advisor_data = advisor_results[0].get("advisor_result", {})
+
+        # Extract the relevant fields with defaults
+        response = {
+            "current_used_indexes": advisor_data.get("current_used_indexes", []),
+            "recommended_indexes": advisor_data.get("recommended_indexes", []),
+            "recommended_covering_indexes": advisor_data.get(
+                "recommended_covering_indexes", []
+            ),
+        }
+
+        # Add summary information for better user experience
+        response["summary"] = {
+            "current_indexes_count": len(response["current_used_indexes"]),
+            "recommended_indexes_count": len(response["recommended_indexes"]),
+            "recommended_covering_indexes_count": len(
+                response["recommended_covering_indexes"]
+            ),
+            "has_recommendations": bool(
+                response["recommended_indexes"]
+                or response["recommended_covering_indexes"]
+            ),
+        }
+
+        logger.info(
+            f"Index Advisor completed. Found {response['summary']['recommended_indexes_count']} recommended indexes"
+        )
+
+        return response
+
+    except Exception as e:
+        logger.error(f"Error running Index Advisor: {e!s}", exc_info=True)
+        raise
+
+
+def list_indexes(
+    ctx: Context,
+    bucket_name: str | None = None,
+    scope_name: str | None = None,
+    collection_name: str | None = None,
+    index_name: str | None = None,
+    include_raw_index_stats: bool = False,
+) -> list[dict[str, Any]]:
+    """List all indexes in the cluster with optional filtering by bucket, scope, collection, and index name.
+    Returns a list of indexes with their names and CREATE INDEX definitions.
+    Uses the Index Service REST API (/getIndexStatus) to retrieve index information directly.
+
+    Args:
+        ctx: MCP context for cluster connection
+        bucket_name: Optional bucket name to filter indexes
+        scope_name: Optional scope name to filter indexes (requires bucket_name)
+        collection_name: Optional collection name to filter indexes (requires bucket_name and scope_name)
+        index_name: Optional index name to filter indexes (requires bucket_name, scope_name, and collection_name)
+        include_raw_index_stats: If True, include raw index stats (as-is from API) in addition
+                              to cleaned-up version. Default is False.
+
+    Returns:
+        List of dictionaries with keys:
+        - name (str): Index name
+        - definition (str): Cleaned-up CREATE INDEX statement
+        - status (str): Current status of the index (e.g., "Ready", "Building", "Deferred")
+        - isPrimary (bool): Whether this is a primary index
+        - bucket (str): Bucket name where the index exists
+        - scope (str): Scope name where the index exists
+        - collection (str): Collection name where the index exists
+        - raw_index_stats (dict, optional): Complete raw index status object from API including metadata,
+                                           state, keyspace info, etc. (only if include_raw_index_stats=True)
+    """
+    try:
+        # Validate parameters
+        validate_filter_params(bucket_name, scope_name, collection_name, index_name)
+
+        # Get and validate connection settings
+        settings = get_settings()
+        validate_connection_settings(settings)
+
+        # Fetch indexes from REST API
+        logger.info(
+            f"Fetching indexes from REST API for bucket={bucket_name}, "
+            f"scope={scope_name}, collection={collection_name}, index={index_name}"
+        )
+
+        raw_indexes = fetch_indexes_from_rest_api(
+            settings["connection_string"],
+            settings["username"],
+            settings["password"],
+            bucket_name=bucket_name,
+            scope_name=scope_name,
+            collection_name=collection_name,
+            index_name=index_name,
+            ca_cert_path=settings.get("ca_cert_path"),
+        )
+
+        # Process and format the results
+        indexes = [
+            processed
+            for idx in raw_indexes
+            if (processed := process_index_data(idx, include_raw_index_stats))
+            is not None
+        ]
+
+        logger.info(
+            f"Found {len(indexes)} indexes from REST API "
+            f"(include_raw_index_stats={include_raw_index_stats})"
+        )
+        return indexes
+
+    except Exception as e:
+        logger.error(f"Error listing indexes: {e}", exc_info=True)
+        raise

tools/query.py

@@ -39,7 +39,15 @@ def get_schema_for_collection(
 def run_sql_plus_plus_query(
     ctx: Context, bucket_name: str, scope_name: str, query: str
 ) -> list[dict[str, Any]]:
-    """Run a SQL++ query on a scope and return the results as a list of JSON objects."""
+    """Run a SQL++ query on a scope and return the results as a list of JSON objects.
+
+    The query will be run on the specified scope in the specified bucket.
+    The query should use collection names directly without bucket/scope prefixes, as the scope context is automatically set.
+
+    Example:
+        query = "SELECT * FROM users WHERE age > 18"
+        # Incorrect: "SELECT * FROM bucket.scope.users WHERE age > 18"
+    """
     cluster = get_cluster_connection(ctx)
 
     bucket = connect_to_bucket(cluster, bucket_name)

tools/server.py

@@ -4,6 +4,7 @@ Tools for server operations.
 This module contains tools for getting the server status, testing the connection, and getting the buckets in the cluster, the scopes and collections in the bucket.
 """
 
+import json
 import logging
 from typing import Any
 
@@ -137,3 +138,43 @@ def get_collections_in_scope(
         ctx, query, bucket_name=bucket_name, scope_name=scope_name
     )
     return [result["collection_name"] for result in results]
+
+
+def get_cluster_health_and_services(
+    ctx: Context, bucket_name: str | None = None
+) -> dict[str, Any]:
+    """Get cluster health status and list of all running services.
+
+    This tool provides health monitoring by:
+    - Getting health status of all running services with latency information (via ping)
+    - Listing all services running on the cluster with their endpoints
+    - Showing connection status and node information for each service
+
+    If bucket_name is provided, it actively pings services from the perspective of the bucket.
+    Otherwise, it uses cluster-level ping to get the health status of the cluster.
+
+    Returns:
+    - Cluster health status with service-level connection details and latency measurements
+    """
+    try:
+        cluster = get_cluster_connection(ctx)
+
+        if bucket_name:
+            # Ping services from the perspective of the bucket
+            bucket = connect_to_bucket(cluster, bucket_name)
+            result = bucket.ping().as_json()
+        else:
+            # Ping services from the perspective of the cluster
+            result = cluster.ping().as_json()
+
+        return {
+            "status": "success",
+            "data": json.loads(result),
+        }
+    except Exception as e:
+        logger.error(f"Error getting cluster health: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "message": "Failed to get cluster health and services information",
+        }

utils/__init__.py

@@ -34,6 +34,11 @@ from .context import (
     get_cluster_connection,
 )
 
+# Index utilities
+from .index_utils import (
+    fetch_indexes_from_rest_api,
+)
+
 # Note: Individual modules create their own hierarchical loggers using:
 # logger = logging.getLogger(f"{MCP_SERVER_NAME}.module.name")
 
@@ -46,6 +51,8 @@ __all__ = [
     # Context
     "AppContext",
     "get_cluster_connection",
+    # Index utilities
+    "fetch_indexes_from_rest_api",
     # Constants
     "MCP_SERVER_NAME",
     "DEFAULT_READ_ONLY_MODE",

utils/index_utils.py

@@ -0,0 +1,308 @@
+"""
+Utility functions for index operations.
+
+This module contains helper functions for working with Couchbase indexes.
+"""
+
+import logging
+import os
+from importlib.resources import files
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .constants import MCP_SERVER_NAME
+
+logger = logging.getLogger(f"{MCP_SERVER_NAME}.utils.index_utils")
+
+
+def validate_filter_params(
+    bucket_name: str | None,
+    scope_name: str | None,
+    collection_name: str | None,
+    index_name: str | None = None,
+) -> None:
+    """Validate that filter parameters are provided in the correct hierarchy."""
+    if scope_name and not bucket_name:
+        raise ValueError("bucket_name is required when filtering by scope_name")
+    if collection_name and (not bucket_name or not scope_name):
+        raise ValueError(
+            "bucket_name and scope_name are required when filtering by collection_name"
+        )
+    if index_name and (not bucket_name or not scope_name or not collection_name):
+        raise ValueError(
+            "bucket_name, scope_name, and collection_name are required when filtering by index_name"
+        )
+
+
+def validate_connection_settings(settings: dict[str, Any]) -> None:
+    """Validate that required connection settings are present."""
+    required = ["connection_string", "username", "password"]
+    missing = [key for key in required if not settings.get(key)]
+    if missing:
+        raise ValueError(f"Missing required connection settings: {', '.join(missing)}")
+
+
+def clean_index_definition(definition: Any) -> str:
+    """Clean up index definition string by removing quotes and escape characters."""
+    if isinstance(definition, str) and definition:
+        return definition.strip('"').replace('\\"', '"')
+    return ""
+
+
+def process_index_data(
+    idx: dict[str, Any], include_raw_index_stats: bool
+) -> dict[str, Any] | None:
+    """Process raw index data into formatted index info.
+
+    Args:
+        idx: Raw index data from the API
+        include_raw_index_stats: Whether to include complete raw stats in the output
+
+    Returns:
+        Formatted index info dictionary, or None if the index should be skipped (e.g., no name).
+    """
+    name = idx.get("name", "")
+    if not name:
+        return None
+
+    # Start with name and optional definition
+    index_info: dict[str, Any] = {"name": name}
+
+    clean_def = clean_index_definition(idx.get("definition", ""))
+    if clean_def:
+        index_info["definition"] = clean_def
+
+    # Copy standard fields from raw index data
+    standard_fields = ["status", "bucket", "scope", "collection"]
+    for field in standard_fields:
+        if field in idx:
+            index_info[field] = idx[field]
+
+    # Always include isPrimary as a boolean
+    index_info["isPrimary"] = idx.get("isPrimary", False)
+
+    # Optionally include complete raw stats
+    if include_raw_index_stats:
+        index_info["raw_index_stats"] = idx
+
+    return index_info
+
+
+def _get_capella_root_ca_path() -> str:
+    """Get the path to the Capella root CA certificate.
+
+    Uses importlib.resources to locate the certificate file, which works when the package is installed with fallback for development.
+
+    Returns:
+        Path to the Capella root CA certificate file.
+    """
+    try:
+        # Use importlib.resources to get the certificate path (works for installed packages)
+        cert_file = files("certs").joinpath("capella_root_ca.pem")
+        # Convert to string path - this works for both installed packages and dev mode
+        return str(cert_file)
+    except (ImportError, FileNotFoundError, TypeError):
+        # Fallback for development: use src/certs/ directory
+        utils_dir = os.path.dirname(os.path.abspath(__file__))
+        src_dir = os.path.dirname(utils_dir)
+        fallback_path = os.path.join(src_dir, "certs", "capella_root_ca.pem")
+
+        if os.path.exists(fallback_path):
+            logger.info(f"Using fallback certificate path: {fallback_path}")
+            return fallback_path
+
+        # If we still can't find it, log a warning and return the fallback path anyway
+        logger.warning(
+            f"Could not locate Capella root CA certificate at {fallback_path}. "
+            "SSL verification may fail for Capella connections."
+        )
+        return fallback_path
+
+
+def _extract_hosts_from_connection_string(connection_string: str) -> list[str]:
+    """Extract all hosts from a Couchbase connection string.
+
+    Args:
+        connection_string: Connection string like 'couchbase://host' or 'couchbases://host1,host2,host3'
+
+    Returns:
+        List of hosts extracted from the connection string
+    """
+    # Parse the connection string
+    parsed = urlparse(connection_string)
+
+    # If there's a netloc (host), extract all hosts
+    if parsed.netloc:
+        # Split by comma to handle multiple hosts
+        # Remove port if present from each host
+        hosts = [host.split(":")[0].strip() for host in parsed.netloc.split(",")]
+        return hosts
+
+    # Fallback: try to extract manually
+    # Handle cases like 'couchbase://host:8091' or just 'host'
+    host_part = connection_string.replace("couchbase://", "").replace(
+        "couchbases://", ""
+    )
+    host_part = host_part.split("/")[0]
+    hosts = [host.split(":")[0].strip() for host in host_part.split(",")]
+    return hosts
+
+
+def _determine_ssl_verification(
+    connection_string: str, ca_cert_path: str | None
+) -> bool | str:
+    """Determine SSL verification setting based on connection string and cert path.
+
+    Args:
+        connection_string: Couchbase connection string
+        ca_cert_path: Optional path to CA certificate
+
+    Returns:
+        SSL verification setting (bool or path to cert file)
+    """
+    is_tls_enabled = connection_string.lower().startswith("couchbases://")
+    is_capella_connection = connection_string.lower().endswith(".cloud.couchbase.com")
+
+    # Priority 1: Capella connections always use Capella root CA
+    if is_capella_connection:
+        capella_ca = _get_capella_root_ca_path()
+        if os.path.exists(capella_ca):
+            logger.info(
+                f"Capella connection detected, using Capella root CA: {capella_ca}"
+            )
+            return capella_ca
+        logger.warning(
+            f"Capella CA certificate not found at {capella_ca}, "
+            "falling back to system CA bundle"
+        )
+        return True
+
+    # Priority 2: Non-Capella TLS connections use provided cert or system CA bundle
+    if is_tls_enabled:
+        if ca_cert_path:
+            logger.info(f"Using provided CA certificate: {ca_cert_path}")
+            return ca_cert_path
+        logger.info("Using system CA bundle for SSL verification")
+        return True
+
+    # Priority 3: Non-TLS connections (HTTP), disable SSL verification
+    logger.info("Non-TLS connection, SSL verification disabled")
+    return False
+
+
+def _build_query_params(
+    bucket_name: str | None,
+    scope_name: str | None,
+    collection_name: str | None,
+    index_name: str | None = None,
+) -> dict[str, str]:
+    """Build query parameters for the index REST API.
+
+    Args:
+        bucket_name: Optional bucket name
+        scope_name: Optional scope name
+        collection_name: Optional collection name
+        index_name: Optional index name
+
+    Returns:
+        Dictionary of query parameters
+    """
+    params = {}
+    if bucket_name:
+        params["bucket"] = bucket_name
+    if scope_name:
+        params["scope"] = scope_name
+    if collection_name:
+        params["collection"] = collection_name
+    if index_name:
+        params["index"] = index_name
+    return params
+
+
+def fetch_indexes_from_rest_api(
+    connection_string: str,
+    username: str,
+    password: str,
+    bucket_name: str | None = None,
+    scope_name: str | None = None,
+    collection_name: str | None = None,
+    index_name: str | None = None,
+    ca_cert_path: str | None = None,
+    timeout: int = 30,
+) -> list[dict[str, Any]]:
+    """Fetch indexes from Couchbase Index Service REST API.
+
+    Uses the /getIndexStatus endpoint to retrieve index information.
+    This endpoint returns indexes with their definitions directly from the Index Service.
+
+    Args:
+        connection_string: Couchbase connection string (may contain multiple hosts)
+        username: Username for authentication
+        password: Password for authentication
+        bucket_name: Optional bucket name to filter indexes
+        scope_name: Optional scope name to filter indexes
+        collection_name: Optional collection name to filter indexes
+        index_name: Optional index name to filter indexes
+        ca_cert_path: Optional path to CA certificate for SSL verification.
+                     If not provided and using Capella, will use Capella root CA.
+        timeout: Request timeout in seconds (default: 30)
+
+    Returns:
+        List of index status dictionaries containing name, definition, and other metadata
+    """
+    # Extract all hosts from connection string
+    hosts = _extract_hosts_from_connection_string(connection_string)
+
+    # Determine protocol and port based on whether TLS is enabled
+    is_tls_enabled = connection_string.lower().startswith("couchbases://")
+    protocol = "https" if is_tls_enabled else "http"
+    port = 19102 if is_tls_enabled else 9102
+
+    logger.info(
+        f"TLS {'enabled' if is_tls_enabled else 'disabled'}, "
+        f"using {protocol.upper()} with port {port}"
+    )
+
+    # Build query parameters and determine SSL verification
+    params = _build_query_params(bucket_name, scope_name, collection_name, index_name)
+    verify_ssl = _determine_ssl_verification(connection_string, ca_cert_path)
+
+    # Try each host one by one until we get a successful response
+    last_error = None
+    for host in hosts:
+        try:
+            url = f"{protocol}://{host}:{port}/getIndexStatus"
+            logger.info(
+                f"Attempting to fetch indexes from: {url} with params: {params}"
+            )
+
+            response = httpx.get(
+                url,
+                params=params,
+                auth=(username, password),
+                verify=verify_ssl,
+                timeout=timeout,
+            )
+
+            response.raise_for_status()
+            data = response.json()
+            indexes = data.get("status", [])
+
+            logger.info(f"Successfully fetched {len(indexes)} indexes from {host}")
+            return indexes
+
+        except httpx.HTTPError as e:
+            logger.warning(f"Failed to fetch indexes from {host}: {e}")
+            last_error = e
+        except Exception as e:
+            logger.warning(f"Unexpected error when fetching from {host}: {e}")
+            last_error = e
+
+    # If we get here, all hosts failed
+    error_msg = f"Failed to fetch indexes from all hosts: {hosts}"
+    if last_error:
+        error_msg += f". Last error: {last_error}"
+    logger.error(error_msg)
+    raise RuntimeError(error_msg)

couchbase_mcp_server-0.5.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-mcp_server.py,sha256=QGKbHL5fnQQnFkZZvK89eEWR6HcmF_0JqV_E6lke3M8,5031
-couchbase_mcp_server-0.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tools/__init__.py,sha256=1FRntOrRYPiITHteCiEu0DrIBEesNgpeeLkvzFpRNv4,1355
-tools/kv.py,sha256=NGUs43iuXElj9rYe4RCyCStqoh5y1fUgbg1oWuU4WeQ,2493
-tools/query.py,sha256=fSSG7XuxnND1lHwI-r8y_M3h6f82vCXxCwB_A2wHN-M,3598
-tools/server.py,sha256=iv_UH4OiBnlPYSSEt1rs3LFeYmIZb_c5mEEYBToS8gU,5188
-utils/__init__.py,sha256=eVRW08PAfJXrB3cYbmHIj3v6kfa1-a9dlNXsEOB0igU,1223
-utils/config.py,sha256=B6H_JYDn6uxtu9juM924zdvNQgSaHh_u6rYME3_0_xQ,268
-utils/connection.py,sha256=NtAU4pmHMZubSJcs_X_lai9o8dih5mW0RyrRdmyp1Po,2892
-utils/constants.py,sha256=w0zvQ1zMzJBg44Yl3aQW8KfaaRPn0BgPOLEe8xLeLSE,487
-utils/context.py,sha256=XZL4M70BMdFBptJ9sT0zxhEey-EvvoSKZJrP_sb7q-A,2286
-couchbase_mcp_server-0.5.0.dist-info/METADATA,sha256=G_R6LVJ0LqtBhF4v58z1-qRms3YgHjDpLLDfGwlEI3Q,20630
-couchbase_mcp_server-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-couchbase_mcp_server-0.5.0.dist-info/entry_points.txt,sha256=iU5pF4kIMTnNhoMPHhdH-k8o1Fmxb_iM9qJHCZcL6Ak,57
-couchbase_mcp_server-0.5.0.dist-info/top_level.txt,sha256=cQeSKgjLtHXStynG6fJkj8o4tBep9OkDai_4h5bf_4I,23
-couchbase_mcp_server-0.5.0.dist-info/RECORD,,

couchbase_mcp_server-0.5.0.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-mcp_server
-tools
-utils