feat: adds run_component tool (#172)

Author: mathislucka

src/deepset_mcp/tool_registry.py

@@ -18,6 +18,7 @@
     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 (
@@ -195,6 +196,10 @@ async def search_docs(query: str) -> str:
         get_custom_components_tool,
         ToolConfig(needs_client=True, memory_type=MemoryType.EXPLORABLE),
     ),
+    "run_component": (
+        run_component_tool,
+        ToolConfig(needs_client=True, memory_type=MemoryType.BOTH),
+    ),
     "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)),

src/deepset_mcp/tools/haystack_service.py

@@ -360,3 +360,41 @@ async def build_single_component(schema: dict[str, Any]) -> ComponentDefinition
     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)}"

test/unit/tools/test_haystack_service.py

@@ -13,6 +13,7 @@
     get_component_definition,
     get_custom_components,
     list_component_families,
+    run_component,
     search_component_definition,
 )
 from deepset_mcp.tools.haystack_service_models import (
@@ -546,3 +547,74 @@ async def test_get_custom_components_api_error() -> None:
     assert isinstance(result, str)
     assert "Error retrieving component schemas" in result
     assert "API Error" in result
+
+
+@pytest.mark.asyncio
+async def test_run_component_success() -> None:
+    run_response = {
+        "output": {
+            "prompt": "Hello, world! This is a test prompt.",
+        }
+    }
+    resource = FakeHaystackServiceResource(run_component_response=run_response)
+    client = FakeClient(resource=resource)
+
+    result = await run_component(
+        client=client,
+        component_type="haystack.components.builders.PromptBuilder",
+        init_params={"template": "Hello, {{name}}! This is a {{type}} prompt."},
+        input_data={"name": "world", "type": "test"},
+    )
+
+    assert isinstance(result, dict)
+    assert "output" in result
+    assert result["output"]["prompt"] == "Hello, world! This is a test prompt."
+
+
+@pytest.mark.asyncio
+async def test_run_component_with_input_types() -> None:
+    run_response = {"output": {"documents": [{"content": "Test document", "meta": {}}]}}
+    resource = FakeHaystackServiceResource(run_component_response=run_response)
+    client = FakeClient(resource=resource)
+
+    result = await run_component(
+        client=client,
+        component_type="haystack.components.readers.TextFileReader",
+        init_params={},
+        input_data={"sources": ["/path/to/file.txt"]},
+        input_types={"sources": "List[str]"},
+    )
+
+    assert isinstance(result, dict)
+    assert "output" in result
+    assert "documents" in result["output"]
+    assert len(result["output"]["documents"]) == 1
+    assert result["output"]["documents"][0]["content"] == "Test document"
+
+
+@pytest.mark.asyncio
+async def test_run_component_minimal_params() -> None:
+    run_response = {"output": {"result": "success"}}
+    resource = FakeHaystackServiceResource(run_component_response=run_response)
+    client = FakeClient(resource=resource)
+
+    result = await run_component(client=client, component_type="haystack.components.readers.HTMLReader")
+
+    assert isinstance(result, dict)
+    assert result["output"]["result"] == "success"
+
+
+@pytest.mark.asyncio
+async def test_run_component_api_error() -> None:
+    resource = FakeHaystackServiceResource(exception=UnexpectedAPIError(status_code=500, message="API Error"))
+    client = FakeClient(resource=resource)
+
+    result = await run_component(
+        client=client,
+        component_type="haystack.components.builders.PromptBuilder",
+        init_params={"template": "Hello, {{name}}!"},
+    )
+
+    assert isinstance(result, str)
+    assert "Failed to run component" in result
+    assert "API Error" in result