deepset-mcp 0.0.5rc1__py3-none-any.whl → 0.0.7__py3-none-any.whl

deepset_mcp/api/shared_models.py

@@ -2,20 +2,130 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import BaseModel, Field
+from collections.abc import AsyncIterator, Awaitable, Callable, Coroutine
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 
 class NoContentResponse(BaseModel):
     """Response model for an empty response."""
 
     success: bool = True
+    "Indicates whether the operation was successful"
     message: str = "No content"
+    "Human-readable message describing the response"
 
 
 class DeepsetUser(BaseModel):
     """Model representing a user on the deepset platform."""
 
     id: str = Field(alias="user_id")
+    "Unique identifier for the user"
     given_name: str | None = None
+    "User's given (first) name"
     family_name: str | None = None
+    "User's family (last) name"
     email: str | None = None
+    "User's email address"
+
+
+T = TypeVar("T")
+
+
+class PaginatedResponse(BaseModel, Generic[T]):
+    """
+    A response model for a single page of cursor-paginated results.
+
+    This model also acts as an async iterator to fetch subsequent pages.
+    """
+
+    # --- Public Data Fields ---
+    data: list[T]
+    "List of items for the current page"
+    has_more: bool
+    "Whether there are more items available beyond this page"
+    total: int | None = None
+    "Total number of items across all pages, if known"
+    next_cursor: str | None = None
+    "Cursor for fetching the next page of results"
+
+    # --- Internal Paginator State (Defaults to None) ---
+    _fetch_func: Callable[..., Coroutine[Any, Any, "PaginatedResponse[T]"]] | None = PrivateAttr(default=None)
+    _base_args: dict[str, Any] | None = PrivateAttr(default=None)
+    _cursor_param: str = PrivateAttr(default="before")
+
+    @model_validator(mode="before")
+    @classmethod
+    def populate_cursors_from_data(cls, data: dict[str, Any]) -> dict[str, Any]:
+        """Populate next_cursor from the last element of data."""
+        if isinstance(data, dict) and isinstance(data.get("data"), list):
+            data_list = data["data"]
+
+            if data_list and data.get("has_more"):
+                last_item = data_list[-1]
+                if isinstance(last_item, dict):
+                    # Use the cursor field if specified, raise if not provided
+                    cursor_field = data.get("_cursor_field")
+                    if not cursor_field:
+                        raise ValueError("Cursor field must be specified when creating PaginatedResponse")
+                    cursor = last_item.get(cursor_field)
+                    data["next_cursor"] = cursor
+
+        return data
+
+    @classmethod
+    def create_with_cursor_field(cls, data: dict[str, Any], cursor_field: str) -> "PaginatedResponse[T]":
+        """Factory method that allows specifying the cursor field."""
+        # Inject the cursor field into the data before validation
+        data_copy = data.copy()
+        data_copy["_cursor_field"] = cursor_field
+        return cls.model_validate(data_copy)
+
+    def _inject_paginator(
+        self,
+        fetch_func: Callable[..., Awaitable["PaginatedResponse[T]"]],
+        base_args: dict[str, Any],
+        cursor_param: str = "before",
+    ) -> None:
+        """Injects the necessary components to make this object iterable."""
+        # Convert Awaitable to Coroutine for typing compatibility
+        if callable(fetch_func):
+            # This is a runtime check - mypy doesn't understand the callable compatibility
+            self._fetch_func = fetch_func  # type: ignore
+        self._base_args = {k: v for k, v in base_args.items() if v is not None}
+        self._cursor_param = cursor_param
+
+    async def _get_next_page(self) -> "PaginatedResponse[T] | None":
+        """Fetches the next page of results using the stored fetch function."""
+        if self._fetch_func is None or self._base_args is None:
+            raise TypeError(
+                "Paginator has not been initialized. Please use the resource's list() method to create this object."
+            )
+
+        if not self.has_more or not self.next_cursor:
+            return None
+
+        args = self._base_args.copy()
+        # TODO: Pagination in the deepset API is currently implemented in an unintuitive way.
+        # TODO: The cursor is always time based (created_at) and after signifies pipelines older than the current cursor
+        # TODO: while 'before' signals pipelines younger than the current cursor.
+        # TODO: This is applied irrespective of any sort (e.g. name) that would conflict with this approach.
+        # TODO: Change this to 'after' once the behaviour is fixed on the deepset API
+        args[self._cursor_param] = self.next_cursor
+
+        next_page = await self._fetch_func(**args)
+        next_page._inject_paginator(self._fetch_func, self._base_args, self._cursor_param)
+        return next_page
+
+    async def items(self) -> AsyncIterator[T]:
+        """Asynchronously iterates over each item across all pages, starting from this page."""
+        current_page: PaginatedResponse[T] | None = self
+        while current_page:
+            for item in current_page.data:
+                yield item
+            current_page = await current_page._get_next_page()
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        """Make the object itself iterable for the most pythonic experience."""
+        return self.items()

deepset_mcp/api/transport.py

@@ -187,17 +187,11 @@ class AsyncTransport:
         api_key: str,
         config: dict[str, Any] | None = None,
     ):
-        """
-        Initialize an instance of AsyncTransport.
-
-        Parameters
-        ----------
-        base_url : str
-            Base URL for the API
-        api_key : str
-            Bearer token for authentication
-        config : dict, optional
-            Configuration for httpx.AsyncClient, e.g., {'timeout': 10.0}
+        """Initialize an instance of AsyncTransport.
+
+        :param base_url: Base URL for the API
+        :param api_key: Bearer token for authentication
+        :param config: Configuration for httpx.AsyncClient, e.g., {'timeout': 10.0}
         """
         # We deepcopy the config so that we don't mutate it when used for subsequent initializations
         config = deepcopy(config) or {}
@@ -244,27 +238,15 @@ class AsyncTransport:
         timeout: float | None | Literal["config"] = "config",
         **kwargs: Any,
     ) -> TransportResponse[Any]:
-        """
-        Send a regular HTTP request and return the response.
-
-        Parameters
-        ----------
-        method : str
-            HTTP method
-        url : str
-            URL endpoint
-        response_type : type[T], optional
-            Expected response type for type checking
-        timeout : float | None | Literal["config"], optional
-            Request timeout in seconds. If "config", uses transport config timeout.
-            If None, disables timeout. If float, uses specific timeout.
-        **kwargs : Any
-            Additional arguments to pass to httpx
-
-        Returns
-        -------
-        TransportResponse[T]
-            The response with parsed JSON if available
+        """Send a regular HTTP request and return the response.
+
+        :param method: HTTP method
+        :param url: URL endpoint
+        :param response_type: Expected response type for type checking
+        :param timeout: Request timeout in seconds. If "config", uses transport config timeout.
+                       If None, disables timeout. If float, uses specific timeout.
+        :param kwargs: Additional arguments to pass to httpx
+        :returns: The response with parsed JSON if available
         """
         if timeout != "config":
             kwargs["timeout"] = timeout
@@ -300,32 +282,22 @@ class AsyncTransport:
         return TransportResponse(text=response.text, status_code=response.status_code, json=untyped_response)
 
     def stream(self, method: str, url: str, **kwargs: Any) -> AbstractAsyncContextManager[StreamingResponse]:
-        """
-        Open a streaming HTTP connection.
-
-        Parameters
-        ----------
-        method : str
-            HTTP method
-        url : str
-            URL endpoint
-        **kwargs : Any
-            Additional arguments to pass to httpx.stream()
-
-        Yields
-        ------
-        StreamingResponse
-            Response object with streaming capabilities
-
-        Examples
-        --------
-        async with transport.stream("POST", "/api/stream", json=data) as response:
-            if response.success:
-                async for line in response.iter_lines():
-                    process_line(line)
-            else:
-                error = await response.read_body()
-                handle_error(error)
+        """Open a streaming HTTP connection.
+
+        :param method: HTTP method
+        :param url: URL endpoint
+        :param kwargs: Additional arguments to pass to httpx.stream()
+        :yields: Response object with streaming capabilities
+
+        .. code-block:: python
+
+            async with transport.stream("POST", "/api/stream", json=data) as response:
+                if response.success:
+                    async for line in response.iter_lines():
+                        process_line(line)
+                else:
+                    error = await response.read_body()
+                    handle_error(error)
         """
 
         @asynccontextmanager

deepset_mcp/api/user/__init__.py

@@ -2,3 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .resource import UserResource
+
+__all__ = ["UserResource"]

deepset_mcp/api/workspace/__init__.py

@@ -4,8 +4,6 @@
 
 """Workspace API module."""
 
-from .models import Workspace, WorkspaceList
-from .protocols import WorkspaceResourceProtocol
 from .resource import WorkspaceResource
 
-__all__ = ["Workspace", "WorkspaceList", "WorkspaceResourceProtocol", "WorkspaceResource"]
+__all__ = ["WorkspaceResource"]

deepset_mcp/api/workspace/models.py

@@ -14,14 +14,10 @@ class Workspace(BaseModel):
     """Model representing a workspace on the deepset platform."""
 
     name: str
+    "Human-readable name of the workspace"
     workspace_id: UUID
+    "Unique identifier for the workspace"
     languages: dict[str, Any]
+    "Supported languages and their configuration settings"
     default_idle_timeout_in_seconds: int
-
-
-class WorkspaceList(BaseModel):
-    """Model representing a list of workspaces."""
-
-    data: list[Workspace]
-    has_more: bool = False
-    total: int
+    "Default timeout in seconds before workspace becomes idle"

deepset_mcp/api/workspace/protocols.py

@@ -7,16 +7,16 @@
 from typing import Protocol
 
 from deepset_mcp.api.shared_models import NoContentResponse
-from deepset_mcp.api.workspace.models import Workspace, WorkspaceList
+from deepset_mcp.api.workspace.models import Workspace
 
 
 class WorkspaceResourceProtocol(Protocol):
     """Protocol defining the interface for workspace resources."""
 
-    async def list(self) -> WorkspaceList:
+    async def list(self) -> list[Workspace]:
         """List all workspaces.
 
-        :returns: A WorkspaceList containing all workspaces.
+        :returns: A list containing all workspaces.
         """
         ...
 

deepset_mcp/api/workspace/resource.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING
 
 from deepset_mcp.api.shared_models import NoContentResponse
 from deepset_mcp.api.transport import raise_for_status
-from deepset_mcp.api.workspace.models import Workspace, WorkspaceList
+from deepset_mcp.api.workspace.models import Workspace
 from deepset_mcp.api.workspace.protocols import WorkspaceResourceProtocol
 
 logger = logging.getLogger(__name__)
@@ -28,10 +28,10 @@ class WorkspaceResource(WorkspaceResourceProtocol):
         """
         self._client = client
 
-    async def list(self) -> WorkspaceList:
+    async def list(self) -> list[Workspace]:
         """List all workspaces.
 
-        :returns: A WorkspaceList containing all workspaces.
+        :returns: A list containing all workspaces.
         """
         resp = await self._client.request(
             endpoint="v1/workspaces",
@@ -42,13 +42,9 @@ class WorkspaceResource(WorkspaceResourceProtocol):
 
         if resp.json is not None and isinstance(resp.json, list):
             workspaces = [Workspace.model_validate(item) for item in resp.json]
-            return WorkspaceList(
-                data=workspaces,
-                has_more=False,
-                total=len(workspaces),
-            )
+            return workspaces
         else:
-            return WorkspaceList(data=[], has_more=False, total=0)
+            return []
 
     async def get(self, workspace_name: str) -> Workspace:
         """Get a specific workspace by name.

deepset_mcp/main.py

@@ -11,9 +11,8 @@ import typer
 from mcp.server.fastmcp import FastMCP
 
 from deepset_mcp.config import DEEPSET_DOCS_DEFAULT_SHARE_URL, DOCS_SEARCH_TOOL_NAME
-from deepset_mcp.server import configure_mcp_server
-from deepset_mcp.tool_models import WorkspaceMode
-from deepset_mcp.tool_registry import TOOL_REGISTRY
+from deepset_mcp.mcp.server import configure_mcp_server
+from deepset_mcp.mcp.tool_registry import TOOL_REGISTRY
 
 
 class TransportEnum(StrEnum):
@@ -60,13 +59,6 @@ def main(
             help="Deepset docs search share URL. Can also be set via DEEPSET_DOCS_SHARE_URL environment variable.",
         ),
     ] = None,
-    workspace_mode: Annotated[
-        WorkspaceMode,
-        typer.Option(
-            "--workspace-mode",
-            help="Whether workspace should be set statically or dynamically provided during a tool call.",
-        ),
-    ] = WorkspaceMode.STATIC,
     tools: Annotated[
         list[str] | None,
         typer.Option(
@@ -126,11 +118,10 @@ def main(
     The Deepset MCP server provides tools to interact with the deepset AI platform,
     allowing you to create, debug, and learn about pipelines on the platform.
 
-    :param workspace: Deepset workspace name
+    :param workspace: Deepset workspace name. Pass if you only want to run the tools on a specific workspace.
     :param api_key: Deepset API key for authentication
     :param api_url: Deepset API base URL
     :param docs_share_url: Deepset docs search share URL
-    :param workspace_mode: Whether workspace should be set statically or dynamically
     :param tools: List of tools to register
     :param list_tools: List all available tools and exit
     :param api_key_from_auth_header: Get API key from authorization header
@@ -171,13 +162,8 @@ def main(
         )
         raise typer.Exit(1)
 
-    if workspace_mode == WorkspaceMode.STATIC and not workspace:
-        typer.echo(
-            "Error: Workspace is required when using static workspace mode. "
-            "Set --workspace or DEEPSET_WORKSPACE environment variable.",
-            err=True,
-        )
-        raise typer.Exit(1)
+    if not workspace:
+        logging.info("No workspace specified. Workspace needs to be provided during tool calling.")
 
     if DOCS_SEARCH_TOOL_NAME in tool_names and docs_share_url is None:
         typer.echo(
@@ -190,7 +176,6 @@ def main(
     mcp = FastMCP("deepset AI platform MCP server")
     configure_mcp_server(
         mcp_server_instance=mcp,
-        workspace_mode=workspace_mode,
         deepset_api_key=api_key,
         deepset_api_url=api_url,
         deepset_workspace=workspace,

deepset_mcp/mcp/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2025-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .server import configure_mcp_server
+from .store import initialize_or_get_initialized_store
+from .tool_factory import build_tool
+from .tool_models import ToolConfig
+
+__all__ = ["configure_mcp_server", "build_tool", "ToolConfig", "initialize_or_get_initialized_store"]

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

@@ -10,15 +10,14 @@ 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.store import initialize_store
-from deepset_mcp.tool_factory import register_tools
-from deepset_mcp.tool_models import DeepsetDocsConfig, WorkspaceMode
-from deepset_mcp.tool_registry import TOOL_REGISTRY
+from deepset_mcp.mcp.store import initialize_or_get_initialized_store
+from deepset_mcp.mcp.tool_factory import register_tools
+from deepset_mcp.mcp.tool_models import DeepsetDocsConfig
+from deepset_mcp.mcp.tool_registry import TOOL_REGISTRY
 
 
 def configure_mcp_server(
     mcp_server_instance: FastMCP,
-    workspace_mode: WorkspaceMode | str,
     tools_to_register: set[str] | None = None,
     deepset_api_key: str | None = None,
     deepset_api_url: str | None = None,
@@ -32,12 +31,11 @@ def configure_mcp_server(
     """Configure the MCP server with the specified tools and settings.
 
     :param mcp_server_instance: The FastMCP server instance to configure
-    :param workspace_mode: The workspace mode ("static" or "dynamic")
     :param tools_to_register: Set of tool names to register with the server.
         Will register all tools if set to None.
     :param deepset_api_key: Optional Deepset API key for authentication
     :param deepset_api_url: Optional Deepset API base URL
-    :param deepset_workspace: Optional workspace name for static mode
+    :param deepset_workspace: Pass a deepset workspace name if you only want to run the tools on a specific workspace.
     :param deepset_docs_shareable_prototype_url: Shareable prototype URL that allows access to a docs search pipeline.
         Will fall back to the default shareable prototype URL if set to None.
     :param get_api_key_from_authorization_header: Whether to extract API key from authorization header
@@ -52,15 +50,6 @@ def configure_mcp_server(
     if deepset_docs_shareable_prototype_url is None:
         deepset_docs_shareable_prototype_url = DEEPSET_DOCS_DEFAULT_SHARE_URL
 
-    if isinstance(workspace_mode, str):
-        workspace_mode = WorkspaceMode(workspace_mode)
-
-    if workspace_mode == WorkspaceMode.STATIC and deepset_workspace is None:
-        raise ValueError(
-            "Static workspace mode requires a workspace name. "
-            "Please provide 'deepset_workspace' when using WorkspaceMode.STATIC."
-        )
-
     if deepset_api_key is None and not get_api_key_from_authorization_header:
         raise ValueError(
             "API key is required for authentication. "
@@ -73,11 +62,12 @@ def configure_mcp_server(
     docs_config = DeepsetDocsConfig(api_key=api_key_docs, workspace_name=workspace_name, pipeline_name=pipeline_name)
 
     # Initialize the store before registering tools
-    store = initialize_store(backend=object_store_backend, redis_url=object_store_redis_url, ttl=object_store_ttl)
+    store = initialize_or_get_initialized_store(
+        backend=object_store_backend, redis_url=object_store_redis_url, ttl=object_store_ttl
+    )
 
     register_tools(
         mcp_server_instance=mcp_server_instance,
-        workspace_mode=workspace_mode,
         workspace=deepset_workspace,
         tool_names=tools_to_register,
         docs_config=docs_config,

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

@@ -7,7 +7,7 @@
 import functools
 import logging
 
-from deepset_mcp.tools.tokonomics.object_store import InMemoryBackend, ObjectStore, ObjectStoreBackend, RedisBackend
+from deepset_mcp.tokonomics import InMemoryBackend, ObjectStore, ObjectStoreBackend, RedisBackend
 
 logger = logging.getLogger(__name__)
 
@@ -30,12 +30,12 @@ def create_redis_backend(url: str) -> ObjectStoreBackend:
 
 
 @functools.lru_cache(maxsize=1)
-def initialize_store(
+def initialize_or_get_initialized_store(
     backend: str = "memory",
     redis_url: str | None = None,
     ttl: int = 600,
 ) -> ObjectStore:
-    """Initialize the object store.
+    """Initializes the object store or gets an existing object store instance if it was initialized before.
 
     :param backend: Backend type ('memory' or 'redis')
     :param redis_url: Redis connection URL (required if backend='redis')

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

@@ -14,9 +14,9 @@ from mcp.server.fastmcp import Context, FastMCP
 
 from deepset_mcp.api.client import AsyncDeepsetClient
 from deepset_mcp.config import DEFAULT_CLIENT_HEADER, DOCS_SEARCH_TOOL_NAME
-from deepset_mcp.tool_models import DeepsetDocsConfig, MemoryType, ToolConfig, WorkspaceMode
-from deepset_mcp.tool_registry import TOOL_REGISTRY
-from deepset_mcp.tools.tokonomics import (
+from deepset_mcp.mcp.tool_models import DeepsetDocsConfig, MemoryType, ToolConfig
+from deepset_mcp.mcp.tool_registry import TOOL_REGISTRY
+from deepset_mcp.tokonomics import (
     ObjectStore,
     RichExplorer,
     explorable,
@@ -78,41 +78,35 @@ def remove_params_from_docstring(docstring: str | None, params_to_remove: set[st
 
 
 def apply_workspace(
-    base_func: Callable[..., Any], config: ToolConfig, workspace_mode: WorkspaceMode, workspace: str | None = None
+    base_func: Callable[..., Any], config: ToolConfig, workspace: str | None = None
 ) -> Callable[..., Any]:
     """
-    Applies a deepset workspace to the function depending on the workspace mode and the ToolConfig.
+    Applies a deepset workspace to the function depending on the ToolConfig.
 
     Removes the workspace argument from the function's signature and docstring if applied.
 
     :param base_func: The function to apply workspace to.
     :param config: The ToolConfig for the function.
-    :param workspace_mode: The WorkspaceMode for the function.
-    :param workspace: The workspace to use for static mode.
+    :param workspace: The workspace to use.
     :returns: Function with workspace handling applied and updated signature/docstring.
     :raises ValueError: If workspace is required but not available.
     """
-    if not config.needs_workspace:
+    if not config.needs_workspace or not workspace:
         return base_func
 
-    if workspace_mode == WorkspaceMode.STATIC:
-
-        @functools.wraps(base_func)
-        async def workspace_wrapper(*args: Any, **kwargs: Any) -> Any:
-            return await base_func(*args, workspace=workspace, **kwargs)
+    @functools.wraps(base_func)
+    async def workspace_wrapper(*args: Any, **kwargs: Any) -> Any:
+        return await base_func(*args, workspace=workspace, **kwargs)
 
-        # Remove workspace from signature
-        original_sig = inspect.signature(base_func)
-        new_params = [p for name, p in original_sig.parameters.items() if name != "workspace"]
-        workspace_wrapper.__signature__ = original_sig.replace(parameters=new_params)  # type: ignore
+    # Remove workspace from signature
+    original_sig = inspect.signature(base_func)
+    new_params = [p for name, p in original_sig.parameters.items() if name != "workspace"]
+    workspace_wrapper.__signature__ = original_sig.replace(parameters=new_params)  # type: ignore
 
-        # Remove workspace from docstring
-        workspace_wrapper.__doc__ = remove_params_from_docstring(base_func.__doc__, {"workspace"})
+    # Remove workspace from docstring
+    workspace_wrapper.__doc__ = remove_params_from_docstring(base_func.__doc__, {"workspace"})
 
-        return workspace_wrapper
-    else:
-        # For dynamic mode, workspace is passed as parameter
-        return base_func
+    return workspace_wrapper
 
 
 def apply_memory(
@@ -139,7 +133,7 @@ def apply_memory(
         return explorable(object_store=store, explorer=explorer)(base_func)
     elif config.memory_type == MemoryType.REFERENCEABLE:
         return referenceable(object_store=store, explorer=explorer)(base_func)
-    elif config.memory_type == MemoryType.BOTH:
+    elif config.memory_type == MemoryType.EXPLORABLE_AND_REFERENCEABLE:
         return explorable_and_referenceable(object_store=store, explorer=explorer)(base_func)
     else:
         raise ValueError(f"Invalid memory type: {config.memory_type}")
@@ -226,7 +220,6 @@ def apply_client(
 def build_tool(
     base_func: Callable[..., Any],
     config: ToolConfig,
-    workspace_mode: WorkspaceMode,
     api_key: str | None = None,
     workspace: str | None = None,
     use_request_context: bool = True,
@@ -240,7 +233,6 @@ def build_tool(
 
     :param base_func: The base tool function.
     :param config: Tool configuration specifying dependencies and custom arguments.
-    :param workspace_mode: How the workspace should be handled.
     :param api_key: The deepset API key to use.
     :param workspace: The workspace to use when using a static workspace.
     :param use_request_context: Whether to collect the API key from the request context.
@@ -257,7 +249,7 @@ def build_tool(
     enhanced_func = apply_memory(enhanced_func, config, object_store)
 
     # Apply workspace handling
-    enhanced_func = apply_workspace(enhanced_func, config, workspace_mode, workspace)
+    enhanced_func = apply_workspace(base_func=enhanced_func, config=config, workspace=workspace)
 
     # Apply client injection (adds ctx parameter if needed)
     enhanced_func = apply_client(
@@ -282,7 +274,6 @@ def build_tool(
 
 def register_tools(
     mcp_server_instance: FastMCP,
-    workspace_mode: WorkspaceMode,
     api_key: str | None = None,
     workspace: str | None = None,
     tool_names: set[str] | None = None,
@@ -295,9 +286,8 @@ def register_tools(
 
     Args:
         mcp_server_instance: FastMCP server instance
-        workspace_mode: How workspace should be handled
         api_key: An api key for the deepset AI platform; only needs to be provided when not read from request context.
-        workspace: Workspace to use; only needs to be provided if using a static workspace.
+        workspace: Pass a deepset workspace name if you only want to run the tools on a specific workspace.
         tool_names: Set of tool names to register (if None, registers all tools)
         get_api_key_from_authorization_header: Whether to use request context to retrieve an API key for tool execution.
         docs_config: Configuration for the deepset documentation search tool.
@@ -310,12 +300,6 @@ def register_tools(
             "Either pass 'api_key' or 'use_request_context'."
         )
 
-    if workspace_mode == WorkspaceMode.STATIC and workspace is None:
-        raise ValueError(
-            "'workspace_mode' set to 'static' but no workspace provided. "
-            "You need to set a deepset workspace name as 'workspace'."
-        )
-
     if docs_config is None and tool_names is None:
         raise ValueError(
             f"'docs_config' cannot be None when requesting to register all tools. "
@@ -360,7 +344,6 @@ def register_tools(
             enhanced_tool = build_tool(
                 base_func=base_func,
                 config=config,
-                workspace_mode=workspace_mode,
                 workspace=workspace,
                 use_request_context=get_api_key_from_authorization_header,
                 base_url=base_url,
@@ -368,4 +351,4 @@ def register_tools(
                 api_key=api_key,
             )
 
-        mcp_server_instance.add_tool(enhanced_tool, name=tool_name)
+        mcp_server_instance.add_tool(enhanced_tool, name=tool_name, structured_output=False)