deepset-mcp 0.0.2rc2__py3-none-any.whl → 0.0.3__py3-none-any.whl

deepset_mcp/api/pipeline_template/models.py

@@ -1,7 +1,8 @@
 from enum import StrEnum
+from typing import Any
 from uuid import UUID
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class PipelineType(StrEnum):
@@ -28,10 +29,36 @@ class PipelineTemplate(BaseModel):
     display_name: str = Field(alias="name")
     pipeline_template_id: UUID = Field(alias="pipeline_template_id")
     potential_applications: list[str] = Field(alias="potential_applications")
-    yaml_config: str | None = Field(None, alias="query_yaml")
+    yaml_config: str | None = None
     tags: list[PipelineTemplateTag]
     pipeline_type: PipelineType
 
+    @model_validator(mode="before")
+    @classmethod
+    def populate_yaml_config(cls, values: Any) -> Any:
+        """Populate yaml_config from query_yaml or indexing_yaml based on pipeline_type."""
+        if not isinstance(values, dict):
+            return values
+
+        # Skip if yaml_config is already set
+        if values.get("yaml_config") is not None:
+            return values
+
+        # Get pipeline_type from the model data
+        pipeline_type = values.get("pipeline_type")
+
+        if pipeline_type == PipelineType.INDEXING or pipeline_type == "indexing":
+            yaml_config = values.get("indexing_yaml")
+        elif pipeline_type == PipelineType.QUERY or pipeline_type == "query":
+            yaml_config = values.get("query_yaml")
+        else:
+            yaml_config = None
+
+        if yaml_config is not None:
+            values["yaml_config"] = yaml_config
+
+        return values
+
 
 class PipelineTemplateList(BaseModel):
     """Response model for listing pipeline templates."""

deepset_mcp/config.py

@@ -0,0 +1,25 @@
+"""This module contains static configuration for the deepset MCP server."""
+
+# We need this mapping to which environment variables integrations are mapped to
+# The mapping is maintained in the pipeline operator:
+# https://github.com/deepset-ai/dc-pipeline-operator/blob/main/dc_operators/config.py#L279
+TOKEN_DOMAIN_MAPPING = {
+    "huggingface.co": ["HF_API_TOKEN", "HF_TOKEN"],
+    "api.openai.com": ["OPENAI_API_KEY"],
+    "bedrock.amazonaws.com": ["BEDROCK"],
+    "api.cohere.ai": ["COHERE_API_KEY"],
+    "openai.azure.com": ["AZURE_OPENAI_API_KEY"],
+    "cognitive-services.azure.com": ["AZURE_AI_API_KEY"],
+    "unstructured.io": ["UNSTRUCTURED_API_KEY"],
+    "api.deepl.com": ["DEEPL_API_KEY"],
+    "generativelanguage.googleapis.com": ["GOOGLE_API_KEY"],
+    "api.nvidia.com": ["NVIDIA_API_KEY"],
+    "api.voyageai.com": ["VOYAGE_API_KEY"],
+    "searchapi.io": ["SEARCHAPI_API_KEY"],
+    "snowflakecomputing.com": ["SNOWFLAKE_API_KEY"],
+    "wandb.ai": ["WANDB_API_KEY"],
+    "mongodb.com": ["MONGO_CONNECTION_STRING"],
+    "together.ai": ["TOGETHERAI_API_KEY"],
+}
+
+DEEPSET_DOCS_DEFAULT_SHARE_URL = "https://cloud.deepset.ai/shared_prototypes?share_token=prototype_eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3ODM0MjE0OTguNTk5LCJhdWQiOiJleHRlcm5hbCB1c2VyIiwiaXNzIjoiZEMiLCJ3b3Jrc3BhY2VfaWQiOiI4YzI0ZjExMi1iMjljLTQ5MWMtOTkzOS1hZTkxMDRhNTQyMWMiLCJ3b3Jrc3BhY2VfbmFtZSI6ImRjLWRvY3MtY29udGVudCIsIm9yZ2FuaXphdGlvbl9pZCI6ImNhOWYxNGQ0LWMyYzktNDYwZC04ZDI2LWY4Y2IwYWNhMDI0ZiIsInNoYXJlX2lkIjoiY2Y3MTA3ODAtOThmNi00MzlmLThiNzYtMmMwNDkyODNiMDZhIiwibG9naW5fcmVxdWlyZWQiOmZhbHNlfQ.5j6DCNRQ1_KB8lhIJqHyw2hBIleEW1_Y_UBuH6MTYY0"

deepset_mcp/main.py

@@ -1,10 +1,15 @@
 import argparse
+import asyncio
 import logging
 import os
 from pathlib import Path
+from urllib.parse import parse_qs, urlparse
 
+import jwt
 from mcp.server.fastmcp import FastMCP
 
+from deepset_mcp.api.client import AsyncDeepsetClient
+from deepset_mcp.config import DEEPSET_DOCS_DEFAULT_SHARE_URL
 from deepset_mcp.tool_factory import WorkspaceMode, register_tools
 
 # Initialize MCP Server
@@ -34,6 +39,58 @@ async def deepset_recommended_prompt() -> str:
     return prompt_path.read_text()
 
 
+async def fetch_shared_prototype_details(share_url: str) -> tuple[str, str, str]:
+    """Gets the pipeline name, workspace name and an API token for a shared prototype url.
+
+    :param share_url: The URL of a shared prototype on the deepset platform.
+
+    :returns: A tuple containing the pipeline name, workspace name and an API token.
+    """
+    parsed_url = urlparse(share_url)
+    query_params = parse_qs(parsed_url.query)
+    share_token = query_params.get("share_token", [None])[0]
+    if not share_token:
+        raise ValueError("Invalid share URL: missing share_token parameter.")
+
+    jwt_token = share_token.replace("prototype_", "")
+
+    decoded_token = jwt.decode(jwt_token, options={"verify_signature": False})
+    workspace_name = decoded_token.get("workspace_name")
+    if not workspace_name:
+        raise ValueError("Invalid JWT in share_token: missing 'workspace_name'.")
+
+    share_id = decoded_token.get("share_id")
+    if not share_id:
+        raise ValueError("Invalid JWT in share_token: missing 'share_id'.")
+
+    # For shared prototypes, we need to:
+    # 1. Fetch prototype details (pipeline name) using the information encoded in the JWT
+    # 2. Create a shared prototype user
+    async with AsyncDeepsetClient(api_key=share_token) as client:
+        response = await client.request(f"/v1/workspaces/{workspace_name}/shared_prototypes/{share_id}")
+        if not response.success:
+            raise ValueError(f"Failed to fetch shared prototype details: {response.status_code} {response.json}")
+
+        data = response.json or {}
+        pipeline_names: list[str] = data.get("pipeline_names", [])
+        if not pipeline_names:
+            raise ValueError("No pipeline names found in shared prototype response.")
+
+        user_info = await client.request("/v1/workspaces/dc-docs-content/shared_prototype_users", method="POST")
+
+        if not user_info.success:
+            raise ValueError("Failed to fetch user information from shared prototype response.")
+
+        user_data = user_info.json or {}
+
+        try:
+            api_key = user_data["user_token"]
+        except KeyError:
+            raise ValueError("No user token in shared prototype response.") from None
+
+    return workspace_name, pipeline_names[0], api_key
+
+
 def main() -> None:
     """Entrypoint for the deepset MCP server."""
     parser = argparse.ArgumentParser(description="Run the Deepset MCP server.")
@@ -48,22 +105,18 @@ def main() -> None:
         help="Deepset API key (env DEEPSET_API_KEY)",
     )
     parser.add_argument(
-        "--docs-workspace",
-        help="Deepset docs search workspace (env DEEPSET_DOCS_WORKSPACE)",
-    )
-    parser.add_argument(
-        "--docs-pipeline-name",
-        help="Deepset docs pipeline name (env DEEPSET_DOCS_PIPELINE_NAME)",
-    )
-    parser.add_argument(
-        "--docs-api-key",
-        help="Deepset docs pipeline API key (env DEEPSET_DOCS_API_KEY)",
+        "--docs-share-url",
+        default=DEEPSET_DOCS_DEFAULT_SHARE_URL,
+        help="Deepset docs search share URL (env DEEPSET_DOCS_SHARE_URL)",
     )
     parser.add_argument(
         "--workspace-mode",
-        choices=["implicit", "explicit"],
-        default="implicit",
-        help="Whether workspace is implicit (from env) or explicit (as parameter). Default: implicit",
+        choices=[WorkspaceMode.STATIC, WorkspaceMode.DYNAMIC],
+        default=WorkspaceMode.STATIC,
+        help=(
+            "Whether workspace should be set statically or dynamically provided during a tool call. "
+            f"Default: '{WorkspaceMode.STATIC}'"
+        ),
     )
     parser.add_argument(
         "--tools",
@@ -89,17 +142,23 @@ def main() -> None:
     # prefer flags, fallback to env
     workspace = args.workspace or os.getenv("DEEPSET_WORKSPACE")
     api_key = args.api_key or os.getenv("DEEPSET_API_KEY")
-    docs_workspace = args.docs_workspace or os.getenv("DEEPSET_DOCS_WORKSPACE")
-    docs_pipeline_name = args.docs_pipeline_name or os.getenv("DEEPSET_DOCS_PIPELINE_NAME")
-    docs_api_key = args.docs_api_key or os.getenv("DEEPSET_DOCS_API_KEY")
+    docs_share_url = args.docs_share_url or os.getenv("DEEPSET_DOCS_SHARE_URL")
+
+    if docs_share_url:
+        try:
+            workspace_name, pipeline_name, api_key_docs = asyncio.run(fetch_shared_prototype_details(docs_share_url))
+            os.environ["DEEPSET_DOCS_WORKSPACE"] = workspace_name
+            os.environ["DEEPSET_DOCS_PIPELINE_NAME"] = pipeline_name
+            os.environ["DEEPSET_DOCS_API_KEY"] = api_key_docs
+        except (ValueError, jwt.DecodeError) as e:
+            parser.error(f"Error processing --docs-share-url: {e}")
 
     # Create server configuration
     workspace_mode = WorkspaceMode(args.workspace_mode)
 
-    # Only require workspace for implicit mode
-    if workspace_mode == WorkspaceMode.IMPLICIT:
+    if workspace_mode == WorkspaceMode.STATIC:
         if not workspace:
-            parser.error("Missing workspace: set --workspace or DEEPSET_WORKSPACE (required for implicit mode)")
+            parser.error("Missing workspace: set --workspace or DEEPSET_WORKSPACE")
 
     if not api_key:
         parser.error("Missing API key: set --api-key or DEEPSET_API_KEY")
@@ -109,14 +168,6 @@ def main() -> None:
         os.environ["DEEPSET_WORKSPACE"] = workspace
     os.environ["DEEPSET_API_KEY"] = api_key
 
-    # Set docs environment variables if provided
-    if docs_workspace:
-        os.environ["DEEPSET_DOCS_WORKSPACE"] = docs_workspace
-    if docs_pipeline_name:
-        os.environ["DEEPSET_DOCS_PIPELINE_NAME"] = docs_pipeline_name
-    if docs_api_key:
-        os.environ["DEEPSET_DOCS_API_KEY"] = docs_api_key
-
     # Parse tool names if provided
     tool_names = None
     if args.tools:

deepset_mcp/tool_factory.py

@@ -19,7 +19,6 @@ from deepset_mcp.tools.custom_components import (
     list_custom_component_installations as list_custom_component_installations_tool,
 )
 from deepset_mcp.tools.doc_search import (
-    get_docs_config,
     search_docs as search_docs_tool,
 )
 from deepset_mcp.tools.haystack_service import (
@@ -48,9 +47,9 @@ from deepset_mcp.tools.pipeline import (
     validate_pipeline as validate_pipeline_tool,
 )
 from deepset_mcp.tools.pipeline_template import (
-    get_pipeline_template as get_pipeline_template_tool,
-    list_pipeline_templates as list_pipeline_templates_tool,
-    search_pipeline_templates as search_pipeline_templates_tool,
+    get_template as get_pipeline_template_tool,
+    list_templates as list_pipeline_templates_tool,
+    search_templates as search_pipeline_templates_tool,
 )
 from deepset_mcp.tools.secrets import (
     get_secret as get_secret_tool,
@@ -63,6 +62,16 @@ from deepset_mcp.tools.workspace import (
     list_workspaces as list_workspaces_tool,
 )
 
+
+def are_docs_available() -> bool:
+    """Checks if documentation search is available."""
+    return bool(
+        os.environ.get("DEEPSET_DOCS_WORKSPACE", False)
+        and os.environ.get("DEEPSET_DOCS_PIPELINE_NAME", False)
+        and os.environ.get("DEEPSET_DOCS_API_KEY", False)
+    )
+
+
 EXPLORER = RichExplorer(store=STORE)
 
 
@@ -108,16 +117,11 @@ async def search_docs(query: str) -> str:
     :param query: The search query to execute against the documentation.
     :returns: The formatted search results from the documentation.
     """
-    docs_config = get_docs_config()
-    if not docs_config:
-        raise RuntimeError("Documentation search configuration not available")
-
-    docs_workspace, docs_pipeline_name, docs_api_key = docs_config
-    async with AsyncDeepsetClient(api_key=docs_api_key) as client:
+    async with AsyncDeepsetClient(api_key=os.environ["DEEPSET_DOCS_API_KEY"]) as client:
         response = await search_docs_tool(
             client=client,
-            workspace=docs_workspace,
-            pipeline_name=docs_pipeline_name,
+            workspace=os.environ["DEEPSET_DOCS_WORKSPACE"],
+            pipeline_name=os.environ["DEEPSET_DOCS_PIPELINE_NAME"],
             query=query,
         )
     return response
@@ -126,8 +130,8 @@ async def search_docs(query: str) -> str:
 class WorkspaceMode(StrEnum):
     """Configuration for how workspace is provided to tools."""
 
-    IMPLICIT = "implicit"  # workspace from env, no parameter in tool signature
-    EXPLICIT = "explicit"  # workspace as required parameter in tool signature
+    STATIC = "static"  # workspace from env, no parameter in tool signature
+    DYNAMIC = "dynamic"  # workspace as required parameter in tool signature
 
 
 class MemoryType(StrEnum):
@@ -165,11 +169,21 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
     ),
     "create_pipeline": (
         create_pipeline_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.BOTH),
+        ToolConfig(
+            needs_client=True,
+            needs_workspace=True,
+            memory_type=MemoryType.BOTH,
+            custom_args={"skip_validation_errors": True},
+        ),
     ),
     "update_pipeline": (
         update_pipeline_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.BOTH),
+        ToolConfig(
+            needs_client=True,
+            needs_workspace=True,
+            memory_type=MemoryType.BOTH,
+            custom_args={"skip_validation_errors": True},
+        ),
     ),
     "get_pipeline": (
         get_pipeline_tool,
@@ -216,15 +230,20 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
         deploy_index_tool,
         ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE),
     ),
-    "list_pipeline_templates": (
+    "list_templates": (
         list_pipeline_templates_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE),
+        ToolConfig(
+            needs_client=True,
+            needs_workspace=True,
+            memory_type=MemoryType.EXPLORABLE,
+            custom_args={"field": "created_at", "order": "DESC", "limit": 100},
+        ),
     ),
-    "get_pipeline_template": (
+    "get_template": (
         get_pipeline_template_tool,
         ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE),
     ),
-    "search_pipeline_templates": (
+    "search_templates": (
         search_pipeline_templates_tool,
         ToolConfig(
             needs_client=True,
@@ -290,8 +309,8 @@ def create_enhanced_tool(
     Args:
         base_func: The base tool function.
         config: Tool configuration specifying dependencies and custom arguments.
-        workspace_mode: How the workspace should be handled (implicit or explicit).
-        workspace: The workspace to use for implicit mode.
+        workspace_mode: How the workspace should be handled.
+        workspace: The workspace to use when using a static workspace.
 
     Returns:
         An enhanced, awaitable tool function with an updated signature and docstring.
@@ -333,7 +352,7 @@ def create_enhanced_tool(
         params_to_remove.update(config.custom_args.keys())
     if config.needs_client:
         params_to_remove.add("client")
-    if config.needs_workspace and workspace_mode == WorkspaceMode.IMPLICIT:
+    if config.needs_workspace and workspace_mode == WorkspaceMode.STATIC:
         params_to_remove.add("workspace")
 
     # Create the new signature from the original function
@@ -350,15 +369,15 @@ def create_enhanced_tool(
     # Create the final wrapper function that handles client/workspace injection
     if config.needs_client:
         if config.needs_workspace:
-            if workspace_mode == WorkspaceMode.IMPLICIT:
+            if workspace_mode == WorkspaceMode.STATIC:
 
-                async def workspace_implicit_wrapper(**kwargs: Any) -> Any:
+                async def workspace_environment_wrapper(**kwargs: Any) -> Any:
                     ws = workspace or get_workspace_from_env()
                     async with AsyncDeepsetClient() as client:
                         return await decorated_func(client=client, workspace=ws, **kwargs)
 
-                wrapper = workspace_implicit_wrapper
-            else:  # EXPLICIT mode
+                wrapper = workspace_environment_wrapper
+            else:  # DYNAMIC mode
 
                 async def workspace_explicit_wrapper(**kwargs: Any) -> Any:
                     async with AsyncDeepsetClient() as client:
@@ -400,7 +419,7 @@ def create_enhanced_tool(
         params_to_remove_from_doc = set()
         if config.needs_client:
             params_to_remove_from_doc.add("client")
-        if config.needs_workspace and workspace_mode == WorkspaceMode.IMPLICIT:
+        if config.needs_workspace and workspace_mode == WorkspaceMode.STATIC:
             params_to_remove_from_doc.add("workspace")
         if config.custom_args:
             params_to_remove_from_doc.update(config.custom_args.keys())
@@ -428,11 +447,11 @@ def register_tools(
     Args:
         mcp: FastMCP server instance
         workspace_mode: How workspace should be handled
-        workspace: Workspace to use for implicit mode (if None, reads from env)
+        workspace: Workspace to use for environment mode (if None, reads from env)
         tool_names: Set of tool names to register (if None, registers all tools)
     """
     # Check if docs search is available
-    docs_available = get_docs_config() is not None
+    docs_available = are_docs_available()
 
     # Validate tool names if provided
     if tool_names is not None:
@@ -446,8 +465,8 @@ def register_tools(
         # Warn if search_docs was requested but config is missing
         if "search_docs" in tool_names and not docs_available:
             logging.warning(
-                "Documentation search tool requested but not available. To enable, set the following environment "
-                "variables: DEEPSET_DOCS_WORKSPACE, DEEPSET_DOCS_PIPELINE_NAME, DEEPSET_DOCS_API_KEY"
+                "Documentation search tool requested but not available. To enable, set the DEEPSET_DOCS_SHARE_URL "
+                "environment variable."
             )
 
         tools_to_register = tool_names.copy()
@@ -457,8 +476,7 @@ def register_tools(
         # Warn if search_docs would be skipped in "all tools" mode
         if not docs_available:
             logging.warning(
-                "Documentation search tool not enabled. To enable, set the following environment "
-                "variables: DEEPSET_DOCS_WORKSPACE, DEEPSET_DOCS_PIPELINE_NAME, DEEPSET_DOCS_API_KEY"
+                "Documentation search tool not enabled. To enable, set the DEEPSET_DOCS_SHARE_URL environment variable."
             )
 
     # Remove search_docs if config is not available

deepset_mcp/tools/doc_search.py

@@ -1,5 +1,3 @@
-import os
-
 from deepset_mcp.api.exceptions import BadRequestError, ResourceNotFoundError, UnexpectedAPIError
 from deepset_mcp.api.pipeline.models import DeepsetSearchResponse
 from deepset_mcp.api.protocols import AsyncClientProtocol
@@ -46,14 +44,6 @@ async def search_docs(*, client: AsyncClientProtocol, workspace: str, pipeline_n
     :returns: A string containing the formatted search results or error message.
     """
     try:
-        # First, check if the pipeline exists and get its status
-        pipeline = await client.pipelines(workspace=workspace).get(pipeline_name=pipeline_name)
-
-        # Check if pipeline is deployed
-        if pipeline.status != "DEPLOYED":
-            return f"Documentation pipeline '{pipeline_name}' is not deployed (current status: {pipeline.status})."
-
-        # Execute the search
         search_response = await client.pipelines(workspace=workspace).search(pipeline_name=pipeline_name, query=query)
 
         return doc_search_results_to_llm_readable_string(results=search_response)
@@ -66,18 +56,3 @@ async def search_docs(*, client: AsyncClientProtocol, workspace: str, pipeline_n
         return f"Failed to search documentation using pipeline '{pipeline_name}': {e}"
     except Exception as e:
         return f"An unexpected error occurred while searching documentation with pipeline '{pipeline_name}': {str(e)}"
-
-
-def get_docs_config() -> tuple[str, str, str] | None:
-    """Get docs search configuration from environment variables.
-
-    :returns: Tuple of (workspace, pipeline_name, api_key) if all are available, None otherwise.
-    """
-    workspace = os.environ.get("DEEPSET_DOCS_WORKSPACE")
-    pipeline_name = os.environ.get("DEEPSET_DOCS_PIPELINE_NAME")
-    api_key = os.environ.get("DEEPSET_DOCS_API_KEY")
-
-    if workspace and pipeline_name and api_key:
-        return workspace, pipeline_name, api_key
-
-    return None

deepset_mcp/tools/pipeline_template.py

@@ -6,34 +6,38 @@ from deepset_mcp.api.pipeline_template.models import (
     PipelineTemplateList,
     PipelineTemplateSearchResult,
     PipelineTemplateSearchResults,
+    PipelineType,
 )
 from deepset_mcp.api.protocols import AsyncClientProtocol
 from deepset_mcp.tools.model_protocol import ModelProtocol
 
 
-async def list_pipeline_templates(
+async def list_templates(
     *,
     client: AsyncClientProtocol,
     workspace: str,
     limit: int = 100,
     field: str = "created_at",
     order: str = "DESC",
-    filter: str | None = None,
+    pipeline_type: PipelineType | str | None = None,
 ) -> PipelineTemplateList | str:
-    """Retrieves a list of all available pipeline templates.
+    """Retrieves a list of all available pipeline and indexing templates.
 
     :param client: The async client for API requests.
     :param workspace: The workspace to list templates from.
     :param limit: Maximum number of templates to return (default: 100).
     :param field: Field to sort by (default: "created_at").
     :param order: Sort order, either "ASC" or "DESC" (default: "DESC").
-    :param filter: OData filter expression to filter templates by criteria.
+    :param pipeline_type: The type of pipeline to return.
 
     :returns: List of pipeline templates or error message.
     """
     try:
         return await client.pipeline_templates(workspace=workspace).list_templates(
-            limit=limit, field=field, order=order, filter=filter
+            limit=limit,
+            field=field,
+            order=order,
+            filter=f"pipeline_type eq '{pipeline_type}'" if pipeline_type else None,
         )
     except ResourceNotFoundError:
         return f"There is no workspace named '{workspace}'. Did you mean to configure it?"
@@ -41,16 +45,14 @@ async def list_pipeline_templates(
         return f"Failed to list pipeline templates: {e}"
 
 
-async def get_pipeline_template(
-    *, client: AsyncClientProtocol, workspace: str, template_name: str
-) -> PipelineTemplate | str:
-    """Fetches detailed information for a specific pipeline template, identified by its `template_name`.
+async def get_template(*, client: AsyncClientProtocol, workspace: str, template_name: str) -> PipelineTemplate | str:
+    """Fetches detailed information for a specific pipeline or indexing template, identified by its `template_name`.
 
     :param client: The async client for API requests.
     :param workspace: The workspace to fetch template from.
     :param template_name: The name of the template to fetch.
 
-    :returns: Pipeline template details or error message.
+    :returns: Pipeline or indexing template details or error message.
     """
     try:
         return await client.pipeline_templates(workspace=workspace).get_template(template_name=template_name)
@@ -60,22 +62,29 @@ async def get_pipeline_template(
         return f"Failed to fetch pipeline template '{template_name}': {e}"
 
 
-async def search_pipeline_templates(
-    *, client: AsyncClientProtocol, query: str, model: ModelProtocol, workspace: str, top_k: int = 10
+async def search_templates(
+    *,
+    client: AsyncClientProtocol,
+    query: str,
+    model: ModelProtocol,
+    workspace: str,
+    top_k: int = 10,
+    pipeline_type: PipelineType | str = PipelineType.QUERY,
 ) -> PipelineTemplateSearchResults | str:
-    """Searches for pipeline templates based on name or description using semantic similarity.
+    """Searches for pipeline or indexing templates based on name or description using semantic similarity.
 
     :param client: The API client to use.
     :param query: The search query.
     :param model: The model to use for computing embeddings.
     :param workspace: The workspace to search templates from.
     :param top_k: Maximum number of results to return (default: 10).
+    :param pipeline_type: The type of pipeline to return ('indexing' or 'query'; default: 'query').
 
     :returns: Search results with similarity scores or error message.
     """
     try:
         response = await client.pipeline_templates(workspace=workspace).list_templates(
-            filter="pipeline_type eq 'QUERY'"
+            filter=f"pipeline_type eq '{pipeline_type}'"
         )
     except UnexpectedAPIError as e:
         return f"Failed to retrieve pipeline templates: {e}"

deepset_mcp/tools/secrets.py

@@ -1,9 +1,27 @@
+from pydantic import BaseModel
+
 from deepset_mcp.api.exceptions import ResourceNotFoundError, UnexpectedAPIError
 from deepset_mcp.api.protocols import AsyncClientProtocol
-from deepset_mcp.api.secrets.models import Secret, SecretList
+from deepset_mcp.config import TOKEN_DOMAIN_MAPPING
+
+
+class EnvironmentSecret(BaseModel):
+    """Model representing a secret or an integration."""
+
+    name: str
+    id: str
+    invalid: bool | None = None
+
+
+class EnvironmentSecretList(BaseModel):
+    """Model representing a list of secrets and integrations."""
 
+    data: list[EnvironmentSecret]
+    has_more: bool
+    total: int
 
-async def list_secrets(*, client: AsyncClientProtocol, limit: int = 10) -> SecretList | str:
+
+async def list_secrets(*, client: AsyncClientProtocol, limit: int = 10) -> EnvironmentSecretList | str:
     """Lists all secrets available in the user's deepset organization.
 
     Use this tool to retrieve a list of secrets with their names and IDs.
@@ -15,7 +33,26 @@ async def list_secrets(*, client: AsyncClientProtocol, limit: int = 10) -> Secre
     :returns: List of secrets or error message
     """
     try:
-        return await client.secrets().list(limit=limit)
+        secrets_list = await client.secrets().list(limit=limit)
+        integrations_list = await client.integrations().list()
+
+        env_secrets = [EnvironmentSecret(name=secret.name, id=secret.secret_id) for secret in secrets_list.data]
+        for integration in integrations_list.integrations:
+            env_vars = TOKEN_DOMAIN_MAPPING.get(integration.provider_domain, [])
+            for env_var in env_vars:
+                env_secrets.append(
+                    EnvironmentSecret(
+                        name=env_var,
+                        id=str(integration.model_registry_token_id),
+                        invalid=integration.invalid,
+                    )
+                )
+
+        return EnvironmentSecretList(
+            data=env_secrets,
+            has_more=secrets_list.has_more,
+            total=len(env_secrets),
+        )
     except ResourceNotFoundError as e:
         return f"Error: {str(e)}"
     except UnexpectedAPIError as e:
@@ -24,7 +61,7 @@ async def list_secrets(*, client: AsyncClientProtocol, limit: int = 10) -> Secre
         return f"Unexpected error: {str(e)}"
 
 
-async def get_secret(*, client: AsyncClientProtocol, secret_id: str) -> Secret | str:
+async def get_secret(*, client: AsyncClientProtocol, secret_id: str) -> EnvironmentSecret | str:
     """Retrieves detailed information about a specific secret by its ID.
 
     Use this tool to get information about a specific secret when you know its ID.
@@ -36,9 +73,25 @@ async def get_secret(*, client: AsyncClientProtocol, secret_id: str) -> Secret |
     :returns: Secret information or error message
     """
     try:
-        return await client.secrets().get(secret_id=secret_id)
-    except ResourceNotFoundError as e:
-        return f"Error: {str(e)}"
+        secret = await client.secrets().get(secret_id=secret_id)
+        return EnvironmentSecret(name=secret.name, id=secret.secret_id)
+    except ResourceNotFoundError:
+        try:
+            integrations_list = await client.integrations().list()
+            for integration in integrations_list.integrations:
+                if str(integration.model_registry_token_id) == secret_id:
+                    env_vars = TOKEN_DOMAIN_MAPPING.get(integration.provider_domain, [])
+                    if env_vars:
+                        return EnvironmentSecret(
+                            name=env_vars[0],
+                            id=str(integration.model_registry_token_id),
+                            invalid=integration.invalid,
+                        )
+            return f"Error: Secret with ID '{secret_id}' not found."
+        except UnexpectedAPIError as e:
+            return f"API Error: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"
     except UnexpectedAPIError as e:
         return f"API Error: {str(e)}"
     except Exception as e:

{deepset_mcp-0.0.2rc2.dist-info → deepset_mcp-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepset-mcp
-Version: 0.0.2rc2
+Version: 0.0.3
 Summary: Collection of MCP tools and Agents to work with the deepset AI platform. Create, debug or learn about pipelines on the platform. Useable from the CLI, Cursor, Claude Code, or other MCP clients.
 Project-URL: Homepage, https://deepset.ai
 Author-email: Mathis Lucka <mathis.lucka@deepset.ai>, Tanay Soni <tanay.soni@deepset.ai>
@@ -22,6 +22,7 @@ Requires-Dist: mcp>=1.10.1
 Requires-Dist: model2vec
 Requires-Dist: numpy
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyjwt[crypto]
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Provides-Extra: analysis

{deepset_mcp-0.0.2rc2.dist-info → deepset_mcp-0.0.3.dist-info}/RECORD

@@ -1,8 +1,9 @@
 deepset_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepset_mcp/config.py,sha256=OkWTP04u57_t15ohiGcYbkx0DwKxYrpCDZjB-CcSDIY,1622
 deepset_mcp/initialize_embedding_model.py,sha256=dgItYfml2LvEk_uxZJSga0aEstFUxTdqAvWWSpEZQEA,300
-deepset_mcp/main.py,sha256=CLUSiUouY2NXvTo8rVyqvqiMsX4Fd2qhl8xF99Tge9Y,4321
+deepset_mcp/main.py,sha256=tmQnjUkgjgFB-vlSo_ZFG9Aj-ZIESjpOFIQH3lNu_lI,6568
 deepset_mcp/store.py,sha256=rhjAZgisgdmc7cr61qdTmp0ZEXCYBKZL5faPmQgDFT4,116
-deepset_mcp/tool_factory.py,sha256=euxZ2jXxe0SzzCUvG3aRIEr-n20irdUVZccU3yxDrEA,19312
+deepset_mcp/tool_factory.py,sha256=ybwYu95_MAVsJU3uADSQAykb7YQjAZsAkTtWnZUdpRw,19561
 deepset_mcp/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepset_mcp/agents/debugging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepset_mcp/agents/debugging/debugging_agent.py,sha256=MRr88Af8AMrof1WLlxanppusaahp41WFCHkfaxrX_iI,1646
@@ -38,7 +39,7 @@ deepset_mcp/api/pipeline/models.py,sha256=JO5pvglyVNsXIIY1IFUnei2grarNoiPSEnAI3c
 deepset_mcp/api/pipeline/protocols.py,sha256=6n9AiQkMAzHyr0Fs0JrhtYXcb5Adz1fI5DTOLCtym58,2469
 deepset_mcp/api/pipeline/resource.py,sha256=Mov91pEDxeXoBtzQAsfvn8YVevnwjC2aJhey86we9bM,13989
 deepset_mcp/api/pipeline_template/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepset_mcp/api/pipeline_template/models.py,sha256=OtbU3DIQZdMx65N0-yhFk8S26aPt8wUz2ZnKqIGI_sY,1422
+deepset_mcp/api/pipeline_template/models.py,sha256=TFuKQYv05BZs3eYOff4KOzqY4U2BOcE6P_p_hi4XCcg,2345
 deepset_mcp/api/pipeline_template/protocols.py,sha256=nyOAxgd1ZMrKfCYsOgjlo16xLvbUUWadWFhSuMa0S7k,644
 deepset_mcp/api/pipeline_template/resource.py,sha256=h7Umn70zJ3Klt-GPqPkrBwXZ-R8hgHsQKkhZ4DAsm7w,3113
 deepset_mcp/api/secrets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -95,20 +96,20 @@ deepset_mcp/prompts/deepset_copilot_prompt.md,sha256=QctQQ4yQ9zl-uWv48dfr1DGhEKP
 deepset_mcp/prompts/deepset_debugging_agent.md,sha256=m5Y-n9cXQGm9BZ3wZ3N_hQmMjrXVfc1cqV8i8Kle5uU,9488
 deepset_mcp/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepset_mcp/tools/custom_components.py,sha256=fl0HYEoX9a_yaDOJ8zrAeetnm43P9zkprlYaa_j16FI,1844
-deepset_mcp/tools/doc_search.py,sha256=E3_-T-WCzvBXEDGjC3Y_qyG3dHUhWUPWgt_34aTn5xM,3654
+deepset_mcp/tools/doc_search.py,sha256=WnfnY9-y_MYsUCMYSyi3suy0WvjLzP4RWEMgkvfcRnA,2736
 deepset_mcp/tools/haystack_service.py,sha256=bR8lL4cWMjJjM6gxpwdUt5xCJ01YMUrRKiG7s2lO7Ts,15050
 deepset_mcp/tools/haystack_service_models.py,sha256=eizThOPKfiUo9ayRAk-sbuSCoY_6gL0vEnv2MwVEGZY,2336
 deepset_mcp/tools/indexes.py,sha256=PSC0SLzo97x86LRwQuivz22_fPGUrBA8t6a8rE1b8V4,5306
 deepset_mcp/tools/model_protocol.py,sha256=NiEo8YG2RCFJdU8GApsmGCq3ZzrbAylP_BD6C_-UaNI,418
 deepset_mcp/tools/pipeline.py,sha256=mcbNoQw2l6QMkmfRvMF4PUoQq4KXxIEwHjiGpj46aGw,14732
-deepset_mcp/tools/pipeline_template.py,sha256=zqn2OeDaLz3ePS_dWDLDWCc3rZ2904CkOq8J3_b0zdw,4822
-deepset_mcp/tools/secrets.py,sha256=yDZc4WHFvByG8jxBpyT5iuXx5W-88xabdrk-Fv7O2og,1773
+deepset_mcp/tools/pipeline_template.py,sha256=gvrrUN-_hQ_DRbbwvN4Wtna5QWo8qKadPwqdRQXmBlU,5147
+deepset_mcp/tools/secrets.py,sha256=2YdfGKAg9IJwW390WfnQutq8oyRQ9XlWnIJlc53Eovk,3800
 deepset_mcp/tools/workspace.py,sha256=JAyUKI_BMGn9FnmoAqmnnRKsTXnSnPuZmuAB3JgzuMY,2729
 deepset_mcp/tools/tokonomics/__init__.py,sha256=QFDYoHPEpfaJ9fr5kfNJ1QXykDFzfy91i-wuqJLqrN0,1958
 deepset_mcp/tools/tokonomics/decorators.py,sha256=msJNho6p6ZnZ5CNjPLbt0RM0CLz8gUzzQCWYT30M10Q,14833
 deepset_mcp/tools/tokonomics/explorer.py,sha256=sSmvXesfl5GdJGiWgCj5ktTOub097pBhhF26BqqT_ig,12880
 deepset_mcp/tools/tokonomics/object_store.py,sha256=OtmVal_6hJPb5R-3mAGLmgAblgM05jdw3f1R7PvvdP0,6415
-deepset_mcp-0.0.2rc2.dist-info/METADATA,sha256=riwN3sF-XtZYBEXNDUFkesrznHF9k1XCUd9i4pPWSOQ,9661
-deepset_mcp-0.0.2rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-deepset_mcp-0.0.2rc2.dist-info/entry_points.txt,sha256=gm-y9dhJVhzslA3nh8W3tofranX76WAw_ATxWbzAhoQ,101
-deepset_mcp-0.0.2rc2.dist-info/RECORD,,
+deepset_mcp-0.0.3.dist-info/METADATA,sha256=v6eb9GT2SuVU7-KBkuRP_Dd8U_UPcrazQXoVKdBLIjQ,9687
+deepset_mcp-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+deepset_mcp-0.0.3.dist-info/entry_points.txt,sha256=gm-y9dhJVhzslA3nh8W3tofranX76WAw_ATxWbzAhoQ,101
+deepset_mcp-0.0.3.dist-info/RECORD,,