deepset-mcp 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

deepset_mcp/mcp/tool_models.py

@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: 2025-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class MemoryType(StrEnum):
+    """Configuration for how memory is provided to tools."""
+
+    EXPLORABLE = "explorable"
+    """The tool's output is stored in the object store and nested properties can be explored through using the object
+    store tools.
+    """
+
+    REFERENCEABLE = "referenceable"
+    """The tool can be called by referencing an object or object-property that was stored in the object store."""
+
+    EXPLORABLE_AND_REFERENCEABLE = "explorable_and_referenceable"
+    """The tool's output is stored in the object store and it can be called by reference."""
+
+    NO_MEMORY = "no_memory"
+    """The tool returns all outputs as is. It does not interact with the object store."""
+
+
+@dataclass
+class ToolConfig:
+    """Configuration for tool registration.
+
+    It allows users to define what arguments should be passed to the tool at registration time. These arguments will not
+    be provided by the LLM as the tool will receive them programmatically through partial application.
+
+    The configuration also determines if a tool should store outputs in the object store.
+    """
+
+    needs_client: bool = False
+    """If the tool should receive a configured instance of the 'AsyncDeepsetClient' at tool-registration time."""
+
+    needs_workspace: bool = False
+    """If the tool should receive a static deepset workspace at tool-registration time."""
+
+    memory_type: MemoryType = MemoryType.NO_MEMORY
+    """The type of memory this tool should use."""
+
+    custom_args: dict[str, Any] = field(default_factory=dict)
+    """Any other arguments that should be passed to the tool at registration time instead of being passed by the LLM."""
+
+
+@dataclass
+class DeepsetDocsConfig:
+    """Configuration for deepset documentation search tool."""
+
+    pipeline_name: str
+    api_key: str
+    workspace_name: str

deepset_mcp/{tool_registry.py → mcp/tool_registry.py}

@@ -8,7 +8,7 @@ from typing import Any
 from deepset_mcp.api.client import AsyncDeepsetClient
 from deepset_mcp.config import DEFAULT_CLIENT_HEADER, DOCS_SEARCH_TOOL_NAME
 from deepset_mcp.initialize_embedding_model import get_initialized_model
-from deepset_mcp.tool_models import DeepsetDocsConfig, MemoryType, ToolConfig
+from deepset_mcp.mcp.tool_models import DeepsetDocsConfig, MemoryType, ToolConfig
 from deepset_mcp.tools.custom_components import (
     get_latest_custom_component_installation_logs as get_latest_custom_component_installation_logs_tool,
     list_custom_component_installations as list_custom_component_installations_tool,
@@ -18,6 +18,7 @@ from deepset_mcp.tools.haystack_service import (
     get_component_definition as get_component_definition_tool,
     get_custom_components as get_custom_components_tool,
     list_component_families as list_component_families_tool,
+    run_component as run_component_tool,
     search_component_definition as search_component_definition_tool,
 )
 from deepset_mcp.tools.indexes import (
@@ -26,6 +27,7 @@ from deepset_mcp.tools.indexes import (
     get_index as get_index_tool,
     list_indexes as list_indexes_tool,
     update_index as update_index_tool,
+    validate_index as validate_index_tool,
 )
 from deepset_mcp.tools.object_store import create_get_from_object_store, create_get_slice_from_object_store
 from deepset_mcp.tools.pipeline import (
@@ -88,7 +90,7 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
         ToolConfig(
             needs_client=True,
             needs_workspace=True,
-            memory_type=MemoryType.BOTH,
+            memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE,
             custom_args={"skip_validation_errors": True},
         ),
     ),
@@ -97,7 +99,7 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
         ToolConfig(
             needs_client=True,
             needs_workspace=True,
-            memory_type=MemoryType.BOTH,
+            memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE,
             custom_args={"skip_validation_errors": True},
         ),
     ),
@@ -116,7 +118,7 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
     ),
     "validate_pipeline": (
         validate_pipeline_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.BOTH),
+        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE),
     ),
     "get_pipeline_logs": (
         get_pipeline_logs_tool,
@@ -136,16 +138,20 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
     ),
     "create_index": (
         create_index_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.BOTH),
+        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE),
     ),
     "update_index": (
         update_index_tool,
-        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.BOTH),
+        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE),
     ),
     "deploy_index": (
         deploy_index_tool,
         ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE),
     ),
+    "validate_index": (
+        validate_index_tool,
+        ToolConfig(needs_client=True, needs_workspace=True, memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE),
+    ),
     "list_templates": (
         list_pipeline_templates_tool,
         ToolConfig(
@@ -195,6 +201,10 @@ TOOL_REGISTRY: dict[str, tuple[Callable[..., Any], ToolConfig]] = {
         get_custom_components_tool,
         ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE),
     ),
+    "run_component": (
+        run_component_tool,
+        ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE_AND_REFERENCEABLE),
+    ),
     "list_secrets": (list_secrets_tool, ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE)),
     "get_secret": (get_secret_tool, ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE)),
     "list_workspaces": (list_workspaces_tool, ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE)),

deepset_mcp/{tools/tokonomics → tokonomics}/__init__.py

@@ -4,12 +4,14 @@
 
 from .decorators import explorable, explorable_and_referenceable, referenceable
 from .explorer import RichExplorer
-from .object_store import InMemoryBackend, ObjectStore
+from .object_store import InMemoryBackend, ObjectStore, ObjectStoreBackend, RedisBackend
 
 __all__ = [
     # Core classes
     "InMemoryBackend",
+    "RedisBackend",
     "ObjectStore",
+    "ObjectStoreBackend",
     "RichExplorer",
     # Decorators
     "explorable",

deepset_mcp/{tools/tokonomics → tokonomics}/decorators.py

@@ -19,8 +19,8 @@ from typing import Any, TypeVar, Union, get_args, get_origin
 
 from glom import GlomError, glom
 
-from deepset_mcp.tools.tokonomics.explorer import RichExplorer
-from deepset_mcp.tools.tokonomics.object_store import ObjectStore
+from deepset_mcp.tokonomics.explorer import RichExplorer
+from deepset_mcp.tokonomics.object_store import ObjectStore
 
 F = TypeVar("F", bound=Callable[..., Any])
 

deepset_mcp/{tools/tokonomics → tokonomics}/explorer.py

@@ -18,7 +18,7 @@ from glom import GlomError, Path, T, glom
 from rich.console import Console
 from rich.pretty import Pretty
 
-from deepset_mcp.tools.tokonomics.object_store import ObjectStore
+from deepset_mcp.tokonomics.object_store import ObjectStore
 
 
 class RichExplorer:

deepset_mcp/tools/__init__.py

@@ -2,3 +2,61 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .custom_components import get_latest_custom_component_installation_logs, list_custom_component_installations
+from .doc_search import search_docs
+from .haystack_service import (
+    get_component_definition,
+    get_custom_components,
+    list_component_families,
+    run_component,
+    search_component_definition,
+)
+from .indexes import create_index, deploy_index, get_index, list_indexes, update_index, validate_index
+from .object_store import create_get_from_object_store, create_get_slice_from_object_store
+from .pipeline import (
+    create_pipeline,
+    deploy_pipeline,
+    get_pipeline,
+    get_pipeline_logs,
+    list_pipelines,
+    search_pipeline,
+    update_pipeline,
+    validate_pipeline,
+)
+from .pipeline_template import get_template, list_templates, search_templates
+from .secrets import get_secret, list_secrets
+from .workspace import get_workspace, list_workspaces
+
+__all__ = [
+    "list_custom_component_installations",
+    "get_latest_custom_component_installation_logs",
+    "search_docs",
+    "run_component",
+    "get_custom_components",
+    "get_component_definition",
+    "search_component_definition",
+    "list_component_families",
+    "list_indexes",
+    "deploy_index",
+    "update_index",
+    "create_index",
+    "get_index",
+    "validate_index",
+    "create_get_from_object_store",
+    "create_get_slice_from_object_store",
+    "list_pipelines",
+    "get_pipeline",
+    "get_pipeline_logs",
+    "deploy_pipeline",
+    "search_pipeline",
+    "create_pipeline",
+    "update_pipeline",
+    "validate_pipeline",
+    "list_templates",
+    "get_template",
+    "search_templates",
+    "get_secret",
+    "list_secrets",
+    "list_workspaces",
+    "get_workspace",
+]

deepset_mcp/tools/custom_components.py

@@ -2,17 +2,20 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from deepset_mcp.api.custom_components.models import CustomComponentInstallationList
+from deepset_mcp.api.custom_components.models import CustomComponentInstallation
 from deepset_mcp.api.protocols import AsyncClientProtocol
+from deepset_mcp.api.shared_models import PaginatedResponse
 
 
 async def list_custom_component_installations(
-    *, client: AsyncClientProtocol, workspace: str
-) -> CustomComponentInstallationList | str:
+    *, client: AsyncClientProtocol, workspace: str, limit: int = 20, after: str | None = None
+) -> PaginatedResponse[CustomComponentInstallation] | str:
     """List custom component installations.
 
     :param client: The API client to use.
     :param workspace: The workspace to operate in.
+    :param limit: Maximum number of installations to return per page.
+    :param after: The cursor to fetch the next page of results.
 
     :returns: Custom component installations or error message.
     """
@@ -20,7 +23,7 @@ async def list_custom_component_installations(
     users = client.users()
 
     try:
-        installations = await custom_components.list_installations()
+        installations = await custom_components.list_installations(limit=limit, after=after)
     except Exception as e:
         return f"Failed to retrieve custom component installations: {e}"
 

deepset_mcp/tools/haystack_service.py

@@ -27,11 +27,9 @@ from deepset_mcp.tools.model_protocol import ModelProtocol
 def extract_component_texts(*, component_def: dict[str, Any]) -> tuple[str, str]:
     """Extracts the component name and description for embedding.
 
-    Args:
-        component_def: The component definition
+    :param component_def: The component definition
 
-    Returns:
-        A tuple containing the component name and description
+    :returns: A tuple containing the component name and description
     """
     component_type = component_def["properties"]["type"]["const"]
     name = component_def.get("title", "")
@@ -39,6 +37,18 @@ def extract_component_texts(*, component_def: dict[str, Any]) -> tuple[str, str]
     return component_type, f"{name} {description}"
 
 
+def _format_type(type_: str | list[str]) -> str:
+    """Formats the component type as a single string.
+
+    :param type_: The component type
+    :return: The component type formatted as a single string
+    """
+    if isinstance(type_, str):
+        return type_
+
+    return " | ".join(type_)
+
+
 async def _build_component_definition(
     *, component_def: dict[str, Any], component_type: str, haystack_service: Any, schema: dict[str, Any] | None = None
 ) -> ComponentDefinition | str:
@@ -79,7 +89,7 @@ async def _build_component_definition(
                         name=prop_name,
                         annotation=prop_info.get("_annotation", prop_info.get("type", "Unknown")),
                         description=prop_info.get("description", "No description available."),
-                        type=prop_info.get("type", "Unknown"),
+                        type=_format_type(prop_info.get("type", "Unknown")),
                         required=prop_name in input_required,
                     )
                     for prop_name, prop_info in input_props.items()
@@ -158,13 +168,11 @@ async def _build_component_definition(
 async def get_component_definition(*, client: AsyncClientProtocol, component_type: str) -> ComponentDefinition | str:
     """Returns the definition of a specific Haystack component.
 
-    Args:
-        client: The API client to use
-        component_type: Fully qualified component type
-            (e.g. haystack.components.routers.conditional_router.ConditionalRouter)
+    :param client: The API client to use
+    :param component_type: Fully qualified component type
+        (e.g. haystack.components.routers.conditional_router.ConditionalRouter)
 
-    Returns:
-        ComponentDefinition model or error message string
+    :returns: ComponentDefinition model or error message string
     """
     haystack_service = client.haystack_service()
 
@@ -195,14 +203,12 @@ async def search_component_definition(
 ) -> ComponentSearchResults | str:
     """Searches for components based on name or description using semantic similarity.
 
-    Args:
-        client: The API client to use
-        query: The search query
-        model: The model to use for computing embeddings
-        top_k: Maximum number of results to return (default: 5)
+    :param client: The API client to use
+    :param query: The search query
+    :param model: The model to use for computing embeddings
+    :param top_k: Maximum number of results to return (default: 5)
 
-    Returns:
-        ComponentSearchResults model or error message string
+    :returns: ComponentSearchResults model or error message string
     """
     haystack_service = client.haystack_service()
 
@@ -261,11 +267,9 @@ async def search_component_definition(
 async def list_component_families(*, client: AsyncClientProtocol) -> ComponentFamilyList | str:
     """Lists all Haystack component families that are available on deepset.
 
-    Args:
-        client: The API client to use
+    :param client: The API client to use
 
-    Returns:
-        ComponentFamilyList model or error message string
+    :returns: ComponentFamilyList model or error message string
     """
     haystack_service = client.haystack_service()
 
@@ -360,3 +364,41 @@ async def get_custom_components(*, client: AsyncClientProtocol) -> ComponentDefi
     component_definitions = [comp for comp in results if comp is not None]
 
     return ComponentDefinitionList(components=component_definitions, total_count=len(component_definitions))
+
+
+async def run_component(
+    *,
+    client: AsyncClientProtocol,
+    component_type: str,
+    init_params: dict[str, Any] | None = None,
+    input_data: dict[str, Any] | None = None,
+    input_types: dict[str, str] | None = None,
+) -> dict[str, Any] | str:
+    """Run a Haystack component with the given parameters.
+
+    This tool allows you to execute a Haystack component by providing its type
+    and initialization parameters, then passing input data to get results.
+    Use this to test components and see how they would work in your pipeline.
+
+    :param client: The API client to use
+    :param component_type: The type of component to run
+        (e.g., "haystack.components.builders.prompt_builder.PromptBuilder")
+    :param init_params: Initialization parameters for the component
+    :param input_data: Input data for the component
+    :param input_types: Optional type information for inputs (inferred if not provided). For custom types use the full
+        import path (e.g. haystack.dataclasses.document.Document for Document)
+
+    :returns: Dictionary containing the component's outputs or error message string
+    """
+    haystack_service = client.haystack_service()
+
+    try:
+        result = await haystack_service.run_component(
+            component_type=component_type,
+            init_params=init_params,
+            input_data=input_data,
+            input_types=input_types,
+        )
+        return result
+    except Exception as e:
+        return f"Failed to run component: {str(e)}"

deepset_mcp/tools/haystack_service_models.py

@@ -15,87 +15,127 @@ class ComponentInitParameter(BaseModel):
     """Represents an initialization parameter for a Haystack component."""
 
     name: str
+    "Name of the initialization parameter"
     annotation: str
+    "Type annotation string for the parameter"
     description: str
+    "Human-readable description of the parameter"
     default: Any | None = None
+    "Default value for the parameter, if any"
     required: bool = False
+    "Whether this parameter is required for component initialization"
 
 
 class ComponentIOProperty(BaseModel):
     """Represents an input/output property schema."""
 
     name: str
+    "Name of the input/output property"
     annotation: str
+    "Type annotation string for the property"
     description: str
+    "Human-readable description of the property"
     type: str
+    "Type classification of the property"
     required: bool = False
+    "Whether this property is required"
 
 
 class ComponentIODefinition(BaseModel):
     """Represents a definition referenced in I/O schema."""
 
     name: str
+    "Name of the I/O definition"
     type: str
+    "Type classification of the definition"
     properties: dict[str, ComponentIOProperty]
+    "Dictionary of properties within this definition"
     required: list[str]
+    "List of required property names"
 
 
 class ComponentIOSchema(BaseModel):
     """Represents the input/output schema for a component."""
 
     properties: dict[str, ComponentIOProperty]
+    "Dictionary of input/output properties"
     required: list[str]
+    "List of required property names"
     definitions: dict[str, ComponentIODefinition] = Field(default_factory=dict)
+    "Dictionary of type definitions referenced by properties"
 
 
 class ComponentDefinition(BaseModel):
     """Represents a complete Haystack component definition."""
 
     component_type: str
+    "Fully qualified class name of the component"
     title: str
+    "Human-readable title of the component"
     description: str
+    "Detailed description of the component's functionality"
     family: str
+    "Component family name (e.g., 'retrievers', 'generators')"
     family_description: str
+    "Description of the component family"
     init_parameters: list[ComponentInitParameter] = Field(default_factory=list)
+    "List of parameters required for component initialization"
     input_schema: ComponentIOSchema | None = None
+    "Schema defining the component's input requirements"
     output_schema: ComponentIOSchema | None = None
+    "Schema defining the component's output format"
     error_message: str | None = None
+    "Error message if component definition failed to load"
     is_custom: bool = False
+    "Whether this is a custom user-defined component"
     package_version: str | None = None
+    "Version of the package containing this component"
     dynamic_params: bool = False
+    "Whether the component accepts dynamic parameters"
 
 
 class ComponentSearchResult(BaseModel):
     """Represents a search result for a component."""
 
     component: ComponentDefinition
+    "Component definition that matched the search criteria"
     similarity_score: float
+    "Relevance score indicating how well the component matches the search"
 
 
 class ComponentSearchResults(BaseModel):
     """Response model for component search results."""
 
     results: list[ComponentSearchResult]
+    "List of components matching the search criteria"
     query: str
+    "Original search query string"
     total_found: int
+    "Total number of components found matching the search criteria"
 
 
 class ComponentFamily(BaseModel):
     """Represents a Haystack component family."""
 
     name: str
+    "Name of the component family"
     description: str
+    "Description of the component family and its purpose"
 
 
 class ComponentFamilyList(BaseModel):
     """Response model for listing component families."""
 
     families: list[ComponentFamily]
+    "List of available component families"
     total_count: int
+    "Total number of component families available"
 
 
 class ComponentDefinitionList(BaseModel):
     """Response model for listing component definitions."""
 
     components: list[ComponentDefinition]
+    "List of component definitions"
     total_count: int
+    "Total number of components available"