mcp-haystack 0.0.2__tar.gz → 0.2.0__tar.gz

mcp_haystack-0.2.0/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## [integrations/mcp-v0.1.0] - 2025-04-22
+
+### 🚀 Features
+
+- Add MCPToolset (#1626)
+
+
+## [integrations/mcp-v0.0.2] - 2025-04-11
+
+### 📚 Documentation
+
+- Fix MCPTool import in code example (#1578)
+
+### 🌀 Miscellaneous
+
+- Feat: Add AsyncExecutor in MCPTool, ensure MCPTool works in hayhooks (#1643)
+
+## [integrations/mcp-v0.0.1] - 2025-03-12
+
+### 🚀 Features
+
+- Add MCP tooling integration (#1487)
+
+<!-- generated by git-cliff -->

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-haystack
-Version: 0.0.2
+Version: 0.2.0
 Summary: Haystack integration for Model Context Protocol (MCP)
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/mcp#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -18,7 +18,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.10
-Requires-Dist: haystack-ai>=2.9.0
+Requires-Dist: exceptiongroup
+Requires-Dist: haystack-ai>=2.13.0
+Requires-Dist: httpx
 Requires-Dist: mcp
 Description-Content-Type: text/markdown
 

mcp_haystack-0.2.0/examples/google_maps_agent.py

@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+### Overview
+# This script shows how to use the **Google Maps MCP Server** in combination with the **Haystack Agent** and **OpenAI's Chat Generator** to search for places via the Google Places API.
+
+# ---
+
+# ### 🔧 Step 1: Start the Google Maps MCP Server
+
+# Make sure you have a valid **Google Maps API key**.
+# See [Google Maps API Key](https://developers.google.com/maps/documentation/places/web-service/get-api-key) for more information.
+
+# Run the following Docker command to start the MCP Server locally on port 8000:
+
+# ```bash
+# docker run -it --rm -p 8000:8000 \
+#   -e GOOGLE_MAPS_API_KEY=$GOOGLE_MAPS_API_KEY \
+#   supercorp/supergateway \
+#   --stdio "npx -y @modelcontextprotocol/server-google-maps" \
+#   --port 8000
+# ```
+
+# ---
+
+# ### 🕵️ Step 2: Inspect Available Tools (Optional but useful)
+
+# You can verify that the MCP server is running and see the available tools using:
+
+# ```bash
+# npx -y @modelcontextprotocol/inspector
+# ```
+
+# Connect MCP Inspector to the server at `http://localhost:8000/sse` and click on "List Tools" to display tools such as:
+
+# - `maps_geocode`: Convert address → coordinates
+# - `maps_reverse_geocode`: Convert coordinates → address
+# - `maps_search_places`: Search places (e.g., restaurants)
+# - `maps_place_details`: Get details of a specific place
+# - `maps_distance_matrix`: Calculate travel distance/time
+# - `maps_elevation`: Get elevation info
+# - `maps_directions`: Get route directions
+
+# ---
+
+# ### ▶️ Step 3: Run the Python Script
+
+# This script sets up:
+# - A **Langfuse trace**
+# - A **MCPToolset** with selected tools (`maps_geocode`, `maps_search_places`)
+# - An **Agent** using `gpt-4.1` to process a natural language request
+
+# To run the script:
+
+# ```bash
+# python examples/google_maps_agent.py
+# ```
+
+# The agent will respond to this example query:
+
+# > "Find the five best Persian restaurants close to Zinnowitzer Str. 1, 10115 Berlin, Germany"
+
+from haystack.components.agents import Agent
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+
+# from haystack_integrations.components.connectors.langfuse.langfuse_connector import LangfuseConnector
+from haystack_integrations.tools.mcp.mcp_tool import SSEServerInfo
+from haystack_integrations.tools.mcp.mcp_toolset import MCPToolset
+
+
+def main():
+    # tracer = LangfuseConnector("Agent google maps search")
+    # Optionally, you can use Langfuse to trace the agent's activity but it needs
+    # additional configuration.
+    # See [Langfuse integration](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse) for more information.
+    toolset = MCPToolset(
+        SSEServerInfo(base_url="http://localhost:8000"), tool_names=["maps_geocode", "maps_search_places"]
+    )
+    agent = Agent(chat_generator=OpenAIChatGenerator(model="gpt-4.1"), tools=toolset)
+    result = agent.run(
+        messages=[
+            ChatMessage.from_user(
+                text="Find the five best persian restaurants close to Zinnowitzer Str. 1, 10115 Berlin, Germany"
+            )
+        ]
+    )
+    print(result["messages"][-1].text)
+
+
+if __name__ == "__main__":
+    main()

mcp_haystack-0.2.0/examples/mcp_filtered_tools.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack_integrations.tools.mcp import MCPToolset, SSEServerInfo
+
+# This example demonstrates using MCPToolset with SSE transport
+# and filtering tools by name
+# Run this client after running the server mcp_sse_server.py
+# It shows how MCPToolset can selectively include only specific tools
+
+
+def main():
+    """Example of using MCPToolset with filtered tools."""
+
+    try:
+        print("Creating toolset with all available tools:")
+        # Create a toolset with all available tools
+        full_toolset = MCPToolset(
+            server_info=SSEServerInfo(base_url="http://localhost:8000"),
+        )
+
+        # Print all discovered tools
+        print(f"Discovered {len(full_toolset)} tools:")
+        for tool in full_toolset:
+            print(f"  - {tool.name}: {tool.description}")
+
+        print("\nCreating toolset with filtered tools:")
+        # Create a toolset with only specific tools
+        # In this example, we're only including the 'add' tool
+        filtered_toolset = MCPToolset(
+            server_info=SSEServerInfo(base_url="http://localhost:8000"),
+            tool_names=["add"],  # Only include the 'add' tool
+        )
+
+        # Print filtered tools
+        print(f"Filtered toolset has {len(filtered_toolset)} tools:")
+        for tool in filtered_toolset:
+            print(f"  - {tool.name}: {tool.description}")
+
+        # Use the filtered toolset
+        if len(filtered_toolset) > 0:
+            add_tool = filtered_toolset.tools[0]  # The only tool should be 'add'
+            result = add_tool.invoke(a=10, b=5)
+            print(f"\nInvoking {add_tool.name}: 10 + 5 = {result.content[0].text}")
+        else:
+            print("No tools available in the filtered toolset")
+
+    except Exception as e:
+        print(f"Error in filtered toolset example: {e}")
+
+
+if __name__ == "__main__":
+    main()

mcp_haystack-0.2.0/examples/mcp_sse_toolset.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack_integrations.tools.mcp import MCPToolset, SSEServerInfo
+
+# This example demonstrates using MCPToolset with SSE transport
+# Run this client after running the server mcp_sse_server.py
+# It shows how MCPToolset automatically discovers and creates tools from the MCP server
+
+
+def find_tool(toolset, tool_name):
+    """
+    Find a tool by name in the toolset.
+
+    :param toolset: The toolset to search in
+    :param tool_name: The name of the tool to find
+    :returns: The tool if found, None otherwise
+    """
+    for tool in toolset:
+        if tool.name == tool_name:
+            return tool
+    return None
+
+
+def main():
+    """Example of using MCPToolset with SSE transport."""
+
+    try:
+        # Create the toolset - this automatically discovers all available tools
+        # from the MCP server and creates Tool instances for each one
+        sse_toolset = MCPToolset(
+            server_info=SSEServerInfo(base_url="http://localhost:8000"),
+        )
+
+        # Print discovered tools
+        print(f"Discovered {len(sse_toolset)} tools:")
+        for tool in sse_toolset:
+            print(f"  - {tool.name}: {tool.description}")
+
+        # Get tools by name from the toolset
+        add_tool = find_tool(sse_toolset, "add")
+        if not add_tool:
+            print("Add tool not found!")
+            return
+
+        subtract_tool = find_tool(sse_toolset, "subtract")
+        if not subtract_tool:
+            print("Subtract tool not found!")
+            return
+
+        # Use the tools
+        result = add_tool.invoke(a=7, b=3)
+        print(f"7 + 3 = {result.content[0].text}")
+
+        result = subtract_tool.invoke(a=5, b=3)
+        print(f"5 - 3 = {result.content[0].text}")
+
+        result = add_tool.invoke(a=10, b=20)
+        print(f"10 + 20 = {result.content[0].text}")
+
+    except Exception as e:
+        print(f"Error in SSE toolset example: {e}")
+
+
+if __name__ == "__main__":
+    main()

mcp_haystack-0.2.0/examples/mcp_stdio_toolset.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack_integrations.tools.mcp import MCPToolset, StdioServerInfo
+
+# This example shows how to use MCPToolset with stdio transport
+# MCPToolset automatically discovers all available tools from the MCP server
+# Here we use the mcp-server-time server
+# See https://github.com/modelcontextprotocol/servers/tree/main/src/time for more details
+# prior to running this script, pip install mcp-server-time
+
+
+def find_tool(toolset, tool_name):
+    """
+    Find a tool by name in the toolset.
+
+    :param toolset: The toolset to search in
+    :param tool_name: The name of the tool to find
+    :returns: The tool if found, None otherwise
+    """
+    for tool in toolset:
+        if tool.name == tool_name:
+            return tool
+    return None
+
+
+def main():
+    """Example of using the MCPToolset implementation with stdio transport."""
+
+    try:
+        # Create server info for the time service
+        server_info = StdioServerInfo(command="uvx", args=["mcp-server-time", "--local-timezone=Europe/Berlin"])
+
+        # Create the toolset - this will automatically discover all available tools
+        stdio_toolset = MCPToolset(server_info=server_info)
+
+        # Print discovered tools
+        print(f"Discovered {len(stdio_toolset)} tools:")
+        for tool in stdio_toolset:
+            print(f"  - {tool.name}: {tool.description}")
+
+        # Find tools by name using the helper function
+        time_tool = find_tool(stdio_toolset, "get_current_time")
+        if not time_tool:
+            print("Time tool not found!")
+            return
+
+        # Use the get_current_time tool
+        result = time_tool.invoke(timezone="America/New_York")
+        print(f"Current time in New York: {result.content[0].text}")
+
+        result = time_tool.invoke(timezone="America/Los_Angeles")
+        print(f"Current time in Los Angeles: {result.content[0].text}")
+    except Exception as e:
+        print(f"Error in stdio toolset example: {e}")
+
+
+if __name__ == "__main__":
+    main()

mcp_haystack-0.2.0/examples/time_pipeline_toolset.py

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# Full example of a pipeline that uses MCPToolset to get the current time
+# and then uses the time to answer a user question.
+# Here we use the mcp-server-time mcp package
+# See https://github.com/modelcontextprotocol/servers/tree/main/src/time for more details
+# prior to running this script, pip install mcp-server-time
+
+import os
+
+from haystack import Pipeline
+from haystack.components.converters import OutputAdapter
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.components.tools import ToolInvoker
+from haystack.dataclasses import ChatMessage
+
+from haystack_integrations.tools.mcp import MCPToolset, StdioServerInfo
+
+
+def main():
+    # Create server info for the time service
+    server_info = StdioServerInfo(command="uvx", args=["mcp-server-time", "--local-timezone=Europe/Berlin"])
+
+    # Create the toolset - this will automatically discover all available tools
+    mcp_toolset = MCPToolset(server_info)
+    # Check if OpenAI API key is set
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        print("OPENAI_API_KEY environment variable is not set.")
+        print("You need to set it to run the pipeline example.")
+        print("For now, demonstrating direct tool usage:")
+
+    pipeline = Pipeline()
+    pipeline.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini", tools=mcp_toolset))
+    pipeline.add_component("tool_invoker", ToolInvoker(tools=mcp_toolset))
+    pipeline.add_component(
+        "adapter",
+        OutputAdapter(
+            template="{{ initial_msg + initial_tool_messages + tool_messages }}",
+            output_type=list[ChatMessage],
+            unsafe=True,
+        ),
+    )
+    pipeline.add_component("response_llm", OpenAIChatGenerator(model="gpt-4o-mini"))
+    pipeline.connect("llm.replies", "tool_invoker.messages")
+    pipeline.connect("llm.replies", "adapter.initial_tool_messages")
+    pipeline.connect("tool_invoker.tool_messages", "adapter.tool_messages")
+    pipeline.connect("adapter.output", "response_llm.messages")
+
+    user_input = "What is the time in New York? Be brief."  # can be any city
+    user_input_msg = ChatMessage.from_user(text=user_input)
+
+    result = pipeline.run({"llm": {"messages": [user_input_msg]}, "adapter": {"initial_msg": [user_input_msg]}})
+
+    print(result["response_llm"]["replies"][0].text)
+
+
+if __name__ == "__main__":
+    main()

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/pydoc/config.yml

@@ -3,6 +3,7 @@ loaders:
     search_path: [../src]
     modules: [
       "haystack_integrations.tools.mcp.mcp_tool",
+      "haystack_integrations.tools.mcp.mcp_toolset",
     ]
     ignore_when_discovered: ["__init__"]
 processors:
@@ -17,7 +18,7 @@ renderer:
   type: haystack_pydoc_tools.renderers.ReadmeIntegrationRenderer
   excerpt: MCP integration for Haystack
   category_slug: integrations-api
-  title: mcp
+  title: MCP
   slug: integrations-mcp
   order: 145
   markdown:

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/pyproject.toml

@@ -27,7 +27,12 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
 ]
-dependencies = ["mcp", "haystack-ai>=2.9.0"]
+dependencies = [
+    "mcp",
+    "haystack-ai>=2.13.0",
+    "exceptiongroup",  # Backport of ExceptionGroup for Python < 3.11
+    "httpx"  # HTTP client library used for SSE connections
+]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/mcp#readme"
@@ -75,7 +80,7 @@ dependencies = [
     "pip",
     "black>=23.1.0",
     "mypy>=1.0.0",
-    "ruff>=0.0.243",
+    "ruff>=0.0.243"
 ]
 
 [tool.hatch.envs.lint.scripts]
@@ -133,6 +138,10 @@ ignore = [
     "PLR0912",
     "PLR0913",
     "PLR0915",
+    # Ignore the errors for process open we're seeing in tests
+    "RUF005",
+    "S603",
+    "S607",
 ]
 unfixable = [
     # Don't touch unused imports
@@ -165,9 +174,12 @@ module = [
     "haystack.*",
     "haystack_integrations.*",
     "pytest.*",
+    "pytest_asyncio",
     "anyio.*",
     "mcp.*",
     "mcp",
+    "httpx",
+    "exceptiongroup"
 ]
 ignore_missing_imports = true
 
@@ -181,4 +193,4 @@ log_cli = true
 asyncio_default_fixture_loop_scope = "function"
 
 [tool.hatch.metadata]
-allow-direct-references = true 
+allow-direct-references = true 

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/src/haystack_integrations/tools/mcp/__init__.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from .mcp_tool import (
     MCPClient,
     MCPConnectionError,
@@ -11,6 +15,7 @@ from .mcp_tool import (
     StdioClient,
     StdioServerInfo,
 )
+from .mcp_toolset import MCPToolset
 
 __all__ = [
     "MCPClient",
@@ -20,6 +25,7 @@ __all__ = [
     "MCPServerInfo",
     "MCPTool",
     "MCPToolNotFoundError",
+    "MCPToolset",
     "SSEClient",
     "SSEServerInfo",
     "StdioClient",

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/src/haystack_integrations/tools/mcp/mcp_tool.py

@@ -5,6 +5,7 @@
 import asyncio
 import concurrent.futures
 import threading
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Coroutine
 from contextlib import AsyncExitStack
@@ -16,6 +17,7 @@ from haystack import logging
 from haystack.core.serialization import generate_qualified_class_name, import_class_by_name
 from haystack.tools import Tool
 from haystack.tools.errors import ToolInvocationError
+from haystack.utils.url_validation import is_valid_http_url
 
 from mcp import ClientSession, StdioServerParameters, types
 from mcp.client.sse import sse_client
@@ -351,18 +353,19 @@ class SSEClient(MCPClient):
     MCP client that connects to servers using SSE transport.
     """
 
-    def __init__(self, base_url: str, token: str | None = None, timeout: int = 5) -> None:
+    def __init__(self, server_info: "SSEServerInfo") -> None:
         """
-        Initialize an SSE MCP client.
+        Initialize an SSE MCP client using server configuration.
 
-        :param base_url: Base URL of the server
-        :param token: Authentication token for the server (optional)
-        :param timeout: Connection timeout in seconds
+        :param server_info: Configuration object containing URL, token, timeout, etc.
         """
         super().__init__()
-        self.base_url: str = base_url.rstrip("/")  # Remove any trailing slashes
-        self.token: str | None = token
-        self.timeout: int = timeout
+
+        # in post_init we validate the url and set the url field so it is guaranteed to be valid
+        # safely ignore the mypy warning here
+        self.url: str = server_info.url  # type: ignore[assignment]
+        self.token: str | None = server_info.token
+        self.timeout: int = server_info.timeout
 
     async def connect(self) -> list[Tool]:
         """
@@ -371,12 +374,11 @@ class SSEClient(MCPClient):
         :returns: List of available tools on the server
         :raises MCPConnectionError: If connection to the server fails
         """
-        sse_url = f"{self.base_url}/sse"
         headers = {"Authorization": f"Bearer {self.token}"} if self.token else None
         sse_transport = await self.exit_stack.enter_async_context(
-            sse_client(sse_url, headers=headers, timeout=self.timeout)
+            sse_client(self.url, headers=headers, timeout=self.timeout)
         )
-        return await self._initialize_session_with_transport(sse_transport, f"HTTP server at {self.base_url}")
+        return await self._initialize_session_with_transport(sse_transport, f"HTTP server at {self.url}")
 
 
 @dataclass
@@ -432,22 +434,51 @@ class SSEServerInfo(MCPServerInfo):
     """
     Data class that encapsulates SSE MCP server connection parameters.
 
-    :param base_url: Base URL of the MCP server
+    :param url: Full URL of the MCP server (including /sse endpoint)
+    :param base_url: Base URL of the MCP server (deprecated, use url instead)
     :param token: Authentication token for the server (optional)
     :param timeout: Connection timeout in seconds
     """
 
-    base_url: str
+    url: str | None = None
+    base_url: str | None = None  # deprecated
     token: str | None = None
     timeout: int = 30
 
+    def __post_init__(self):
+        """Validate that either url or base_url is provided."""
+        if not self.url and not self.base_url:
+            message = "Either url or base_url must be provided"
+            raise ValueError(message)
+        if self.url and self.base_url:
+            message = "Only one of url or base_url should be provided, if both are provided, base_url will be ignored"
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+        if self.base_url:
+            if not is_valid_http_url(self.base_url):
+                message = f"Invalid base_url: {self.base_url}"
+                raise ValueError(message)
+
+            warnings.warn(
+                "base_url is deprecated and will be removed in a future version. Use url instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            # from now on only use url for the lifetime of the SSEServerInfo instance, never base_url
+            self.url = f"{self.base_url.rstrip('/')}/sse"
+
+        elif not is_valid_http_url(self.url):
+            message = f"Invalid url: {self.url}"
+            raise ValueError(message)
+
     def create_client(self) -> MCPClient:
         """
         Create an SSE MCP client.
 
-        :returns: Configured HttpMCPClient instance
+        :returns: Configured MCPClient instance
         """
-        return SSEClient(self.base_url, self.token, self.timeout)
+        # Pass the validated SSEServerInfo instance directly
+        return SSEClient(server_info=self)
 
 
 @dataclass
@@ -491,7 +522,7 @@ class MCPTool(Tool):
     # Create tool instance
     tool = MCPTool(
         name="add",
-        server_info=SSEServerInfo(base_url="http://localhost:8000")
+        server_info=SSEServerInfo(url="http://localhost:8000/sse")
     )
 
     # Use the tool

mcp_haystack-0.2.0/src/haystack_integrations/tools/mcp/mcp_toolset.py

@@ -0,0 +1,257 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+from exceptiongroup import ExceptionGroup
+from haystack import logging
+from haystack.core.serialization import generate_qualified_class_name, import_class_by_name
+from haystack.tools import Tool, Toolset
+
+from .mcp_tool import (
+    AsyncExecutor,
+    MCPConnectionError,
+    MCPServerInfo,
+    MCPToolNotFoundError,
+    SSEServerInfo,
+    StdioServerInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MCPToolset(Toolset):
+    """
+    A Toolset that connects to an MCP (Model Context Protocol) server and provides
+    access to its tools.
+
+    MCPToolset dynamically discovers and loads all tools from any MCP-compliant server,
+    supporting both network-based SSE connections and local process-based stdio connections.
+    This dual connectivity allows for integrating with both remote and local MCP servers.
+
+    Example using MCPToolset in a Haystack Pipeline:
+    ```python
+    # Prerequisites:
+    # 1. pip install uvx mcp-server-time  # Install required MCP server and tools
+    # 2. export OPENAI_API_KEY="your-api-key"  # Set up your OpenAI API key
+
+    import os
+    from haystack import Pipeline
+    from haystack.components.converters import OutputAdapter
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.tools import ToolInvoker
+    from haystack.dataclasses import ChatMessage
+    from haystack_integrations.tools.mcp import MCPToolset, StdioServerInfo
+
+    # Create server info for the time service (can also use SSEServerInfo for remote servers)
+    server_info = StdioServerInfo(command="uvx", args=["mcp-server-time", "--local-timezone=Europe/Berlin"])
+
+    # Create the toolset - this will automatically discover all available tools
+    # You can optionally specify which tools to include
+    mcp_toolset = MCPToolset(
+        server_info=server_info,
+        tool_names=["get_current_time"]  # Only include the get_current_time tool
+    )
+
+    # Create a pipeline with the toolset
+    pipeline = Pipeline()
+    pipeline.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini", tools=mcp_toolset))
+    pipeline.add_component("tool_invoker", ToolInvoker(tools=mcp_toolset))
+    pipeline.add_component(
+        "adapter",
+        OutputAdapter(
+            template="{{ initial_msg + initial_tool_messages + tool_messages }}",
+            output_type=list[ChatMessage],
+            unsafe=True,
+        ),
+    )
+    pipeline.add_component("response_llm", OpenAIChatGenerator(model="gpt-4o-mini"))
+    pipeline.connect("llm.replies", "tool_invoker.messages")
+    pipeline.connect("llm.replies", "adapter.initial_tool_messages")
+    pipeline.connect("tool_invoker.tool_messages", "adapter.tool_messages")
+    pipeline.connect("adapter.output", "response_llm.messages")
+
+    # Run the pipeline with a user question
+    user_input = "What is the time in New York? Be brief."
+    user_input_msg = ChatMessage.from_user(text=user_input)
+
+    result = pipeline.run({"llm": {"messages": [user_input_msg]}, "adapter": {"initial_msg": [user_input_msg]}})
+    print(result["response_llm"]["replies"][0].text)
+    ```
+
+    You can also use the toolset via MCP SSE to talk to remote servers:
+    ```python
+    from haystack_integrations.tools.mcp import MCPToolset, SSEServerInfo
+    from haystack.components.tools import ToolInvoker
+
+    # Create the toolset with an SSE connection
+    sse_toolset = MCPToolset(
+        server_info=SSEServerInfo(url="http://some-remote-server.com:8000/sse"),
+        tool_names=["add", "subtract"]  # Only include specific tools
+    )
+
+    # Use the toolset as shown in the pipeline example above
+    ```
+    """
+
+    def __init__(
+        self,
+        server_info: MCPServerInfo,
+        tool_names: list[str] | None = None,
+        connection_timeout: float = 30.0,
+        invocation_timeout: float = 30.0,
+    ):
+        """
+        Initialize the MCP toolset.
+
+        :param server_info: Connection information for the MCP server
+        :param tool_names: Optional list of tool names to include. If provided, only tools with
+                          matching names will be added to the toolset.
+        :param connection_timeout: Timeout in seconds for server connection
+        :param invocation_timeout: Default timeout in seconds for tool invocations
+        :raises MCPToolNotFoundError: If any of the specified tool names are not found on the server
+        """
+        # Store configuration
+        self.server_info = server_info
+        self.tool_names = tool_names
+        self.connection_timeout = connection_timeout
+        self.invocation_timeout = invocation_timeout
+
+        # Connect and load tools
+        try:
+            # Create the appropriate client using the factory method
+            client = self.server_info.create_client()
+
+            # Connect and get available tools using AsyncExecutor
+            tools = AsyncExecutor.get_instance().run(client.connect(), timeout=self.connection_timeout)
+
+            # If tool_names is provided, validate that all requested tools exist
+            if self.tool_names:
+                available_tools = {tool.name for tool in tools}
+                missing_tools = set(self.tool_names) - available_tools
+                if missing_tools:
+                    message = (
+                        f"The following tools were not found: {', '.join(missing_tools)}. "
+                        f"Available tools: {', '.join(available_tools)}"
+                    )
+                    raise MCPToolNotFoundError(
+                        message=message, tool_name=next(iter(missing_tools)), available_tools=list(available_tools)
+                    )
+
+            # This is a factory that creates the invocation function for the Tool
+            def create_invoke_tool(mcp_client, tool_name, tool_timeout):
+                def invoke_tool(**kwargs) -> Any:
+                    """Invoke a tool using the existing client and AsyncExecutor."""
+                    result = AsyncExecutor.get_instance().run(
+                        mcp_client.call_tool(tool_name, kwargs), timeout=tool_timeout
+                    )
+                    return result
+
+                return invoke_tool
+
+            # Create Tool instances not MCPTool for each available tool
+            haystack_tools = []
+            for tool_info in tools:
+                # Skip tools not in the tool_names list if tool_names is provided
+                if self.tool_names is not None and tool_info.name not in self.tool_names:
+                    logger.debug(
+                        "Skipping tool '{name}' as it's not in the requested tool_names list", name=tool_info.name
+                    )
+                    continue
+
+                # Use the helper function to create the invoke_tool function
+                tool = Tool(
+                    name=tool_info.name,
+                    description=tool_info.description,
+                    parameters=tool_info.inputSchema,
+                    function=create_invoke_tool(client, tool_info.name, self.invocation_timeout),
+                )
+                haystack_tools.append(tool)
+
+            # Initialize parent class with complete tools list
+            super().__init__(tools=haystack_tools)
+
+        except Exception as e:
+            if isinstance(self.server_info, SSEServerInfo):
+                base_message = f"Failed to connect to SSE server at {self.server_info.url}"
+                checks = ["1. The server is running"]
+
+                # Check for ConnectError in exception group or direct exception
+                has_connect_error = isinstance(e, httpx.ConnectError) or (
+                    isinstance(e, ExceptionGroup) and any(isinstance(exc, httpx.ConnectError) for exc in e.exceptions)
+                )
+
+                if has_connect_error:
+                    # Use urlparse to reliably get scheme, hostname, and port
+                    parsed_url = urlparse(self.server_info.url)
+                    port_str = ""
+                    if parsed_url.port:
+                        port_str = str(parsed_url.port)
+                    elif parsed_url.scheme == "http":
+                        port_str = "80 (default)"
+                    elif parsed_url.scheme == "https":
+                        port_str = "443 (default)"
+                    else:
+                        port_str = "unknown (scheme not http/https or missing)"  # Or handle more schemes if needed
+
+                    # Ensure hostname is handled correctly (it might be None)
+                    hostname_str = str(parsed_url.hostname) if parsed_url.hostname else "<unknown>"
+                    message = f"2. The address '{hostname_str}' and port '{port_str}' are correct"
+                    checks.append(message)
+                    checks.append("3. There are no firewall or network connectivity issues")
+                    message = f"{base_message}. Please check if:\n" + "\\n".join(checks)
+                else:
+                    message = f"{base_message}: {e}"
+            elif isinstance(self.server_info, StdioServerInfo):  # stdio connection
+                base_message = "Failed to start MCP server process"
+                stdio_info = self.server_info
+                args_str = " ".join(stdio_info.args) if stdio_info.args else ""
+                cmd = f"{stdio_info.command}{' ' + args_str if args_str else ''}"
+                checks = [f"1. The command and arguments are correct (attempted: {cmd})"]
+                message = f"{base_message}. Please check if:\n" + "\n".join(checks)
+            else:
+                message = f"Unsupported server info type: {type(self.server_info)}"
+
+            raise MCPConnectionError(message=message, server_info=self.server_info, operation="initialize") from e
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serialize the MCPToolset to a dictionary.
+
+        :returns: A dictionary representation of the MCPToolset
+        """
+        return {
+            "type": generate_qualified_class_name(type(self)),
+            "data": {
+                "server_info": self.server_info.to_dict(),
+                "tool_names": self.tool_names,
+                "connection_timeout": self.connection_timeout,
+                "invocation_timeout": self.invocation_timeout,
+            },
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "MCPToolset":
+        """
+        Deserialize an MCPToolset from a dictionary.
+
+        :param data: Dictionary representation of the MCPToolset
+        :returns: A new MCPToolset instance
+        """
+        inner_data = data["data"]
+
+        # Reconstruct the server_info object
+        server_info_dict = inner_data.get("server_info", {})
+        server_info_class = import_class_by_name(server_info_dict["type"])
+        server_info = server_info_class.from_dict(server_info_dict)
+
+        # Create a new MCPToolset instance
+        return cls(
+            server_info=server_info,
+            tool_names=inner_data.get("tool_names"),
+            connection_timeout=inner_data.get("connection_timeout", 30.0),
+            invocation_timeout=inner_data.get("invocation_timeout", 30.0),
+        )

{mcp_haystack-0.0.2 → mcp_haystack-0.2.0}/tests/test_mcp_tool.py

@@ -132,6 +132,26 @@ class TestMCPServerInfo:
         assert new_info.token == "test-token"
         assert new_info.timeout == 45
 
+    def test_url_base_url_validation(self):
+        """Test validation of url and base_url parameters."""
+        # Test with neither url nor base_url
+        with pytest.raises(ValueError, match="Either url or base_url must be provided"):
+            SSEServerInfo()
+
+        # Test with both url and base_url
+        with pytest.warns(DeprecationWarning, match="base_url is deprecated"):
+            SSEServerInfo(url="http://example.com/sse", base_url="http://example.com")
+
+        # Test with only url
+        server_info = SSEServerInfo(url="http://example.com/sse")
+        assert server_info.url == "http://example.com/sse"
+        assert server_info.base_url is None
+
+        # Test with only base_url (deprecated but supported)
+        with pytest.warns(DeprecationWarning, match="base_url is deprecated"):
+            server_info = SSEServerInfo(base_url="http://example.com")
+            assert server_info.base_url == "http://example.com"  # Should preserve original base_url
+
     def test_stdio_server_info_serde(self):
         """Test serialization/deserialization of StdioServerInfo."""
         server_info = StdioServerInfo(command="python", args=["-m", "mcp_server_time"], env={"TEST_ENV": "value"})
@@ -157,7 +177,7 @@ class TestMCPServerInfo:
         http_client = http_info.create_client()
         stdio_client = stdio_info.create_client()
 
-        assert http_client.base_url == "http://example.com"
+        assert http_client.url == "http://example.com/sse"
         assert stdio_client.command == "python"
 
 
@@ -345,8 +365,8 @@ if __name__ == "__main__":
         server_process = None
         try:
             # Start the server in a separate process
-            server_process = subprocess.Popen(  # noqa: S603
-                ["python", server_script_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True  # noqa: S607
+            server_process = subprocess.Popen(
+                ["python", server_script_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
             )
 
             # Give the server a moment to start

mcp_haystack-0.2.0/tests/test_mcp_toolset.py

@@ -0,0 +1,296 @@
+import os
+import sys
+import time
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+import pytest_asyncio
+from haystack.tools import Tool
+
+from haystack_integrations.tools.mcp import MCPToolset, SSEServerInfo
+from haystack_integrations.tools.mcp.mcp_tool import MCPConnectionError
+
+
+@pytest_asyncio.fixture
+async def mock_mcp_toolset():
+    """Fixture to create a pre-configured MCPToolset for testing without server connection."""
+    mock_tool1 = MagicMock(spec=Tool)
+    mock_tool1.name = "tool1"
+    mock_tool1.description = "Test tool 1"
+    mock_tool1.inputSchema = {"type": "object", "properties": {}}
+
+    mock_tool2 = MagicMock(spec=Tool)
+    mock_tool2.name = "tool2"
+    mock_tool2.description = "Test tool 2"
+    mock_tool2.inputSchema = {"type": "object", "properties": {}}
+
+    mock_client = AsyncMock()
+    mock_client.connect.return_value = [mock_tool1, mock_tool2]
+    mock_client.close = AsyncMock()
+
+    with (
+        patch("haystack_integrations.tools.mcp.mcp_toolset.AsyncExecutor.get_instance") as mock_executor,
+        patch("haystack_integrations.tools.mcp.mcp_tool.MCPServerInfo.create_client") as mock_create_client,
+    ):
+        mock_create_client.return_value = mock_client
+        mock_executor.return_value.run.return_value = [mock_tool1, mock_tool2]
+
+        toolset = MCPToolset(
+            server_info=SSEServerInfo(base_url="http://example.com", token="test-token"),
+            connection_timeout=45,
+            invocation_timeout=60,
+        )
+
+        yield toolset
+
+        # Cleanup
+        await mock_client.close()
+
+
+@pytest_asyncio.fixture
+async def mock_mcp_toolset_with_tool_names():
+    """Fixture to create an MCPToolset with specific tool_names filtering."""
+    mock_tool2 = MagicMock(spec=Tool)
+    mock_tool2.name = "tool2"
+    mock_tool2.description = "Test tool 2"
+    mock_tool2.inputSchema = {"type": "object", "properties": {}}
+
+    mock_client = AsyncMock()
+    mock_client.connect.return_value = [mock_tool2]
+    mock_client.close = AsyncMock()
+
+    with (
+        patch("haystack_integrations.tools.mcp.mcp_toolset.AsyncExecutor.get_instance") as mock_executor,
+        patch("haystack_integrations.tools.mcp.mcp_tool.MCPServerInfo.create_client") as mock_create_client,
+    ):
+        mock_create_client.return_value = mock_client
+        mock_executor.return_value.run.return_value = [mock_tool2]
+
+        toolset = MCPToolset(
+            server_info=SSEServerInfo(base_url="http://example.com", token="test-token"),
+            tool_names=["tool2"],  # Only include tool2
+            connection_timeout=45,
+            invocation_timeout=60,
+        )
+
+        yield toolset
+
+        # Cleanup
+        await mock_client.close()
+
+
+@pytest.mark.asyncio
+class TestMCPToolset:
+    """Tests for the MCPToolset class."""
+
+    async def test_toolset_initialization(self, mock_mcp_toolset):
+        """Test if the MCPToolset initializes correctly and loads tools."""
+        toolset = mock_mcp_toolset
+
+        assert isinstance(toolset.server_info, SSEServerInfo)
+        assert toolset.connection_timeout == 45
+        assert toolset.invocation_timeout == 60
+        assert len(toolset) == 2
+
+        tool_names = [tool.name for tool in toolset.tools]
+        assert "tool1" in tool_names
+        assert "tool2" in tool_names
+
+        tool1 = next(tool for tool in toolset.tools if tool.name == "tool1")
+        tool2 = next(tool for tool in toolset.tools if tool.name == "tool2")
+
+        assert tool1.name == "tool1"
+        assert tool2.name == "tool2"
+        assert tool1.description == "Test tool 1"
+        assert tool2.description == "Test tool 2"
+
+    async def test_toolset_with_filtered_tools(self, mock_mcp_toolset_with_tool_names):
+        """Test if the MCPToolset correctly filters tools based on tool_names parameter."""
+        toolset = mock_mcp_toolset_with_tool_names
+
+        # Verify tool_names parameter was stored
+        assert toolset.tool_names == ["tool2"]
+
+        # Verify only the specified tool was added
+        assert len(toolset) == 1
+
+        tool_names = [tool.name for tool in toolset.tools]
+        assert "tool1" not in tool_names
+        assert "tool2" in tool_names
+
+        # Check the tool that was included
+        tool = toolset.tools[0]
+        assert tool.name == "tool2"
+        assert tool.description == "Test tool 2"
+
+    async def test_toolset_serde(self, mock_mcp_toolset):
+        """Test serialization and deserialization of MCPToolset."""
+        toolset = mock_mcp_toolset
+
+        toolset_dict = toolset.to_dict()
+        assert toolset_dict["type"] == "haystack_integrations.tools.mcp.mcp_toolset.MCPToolset"
+        assert toolset_dict["data"]["connection_timeout"] == 45
+        assert toolset_dict["data"]["invocation_timeout"] == 60
+        assert toolset_dict["data"]["server_info"]["base_url"] == "http://example.com"
+        assert toolset_dict["data"]["tool_names"] is None
+
+        with patch("haystack_integrations.tools.mcp.mcp_toolset.MCPToolset.__init__", return_value=None) as mock_init:
+            MCPToolset.from_dict(toolset_dict)
+
+            mock_init.assert_called_once()
+            _, kwargs = mock_init.call_args
+            assert kwargs["connection_timeout"] == 45
+            assert kwargs["invocation_timeout"] == 60
+            assert kwargs["tool_names"] is None
+            assert isinstance(kwargs["server_info"], SSEServerInfo)
+            assert kwargs["server_info"].base_url == "http://example.com"
+
+    async def test_toolset_serde_with_tool_names(self, mock_mcp_toolset_with_tool_names):
+        """Test serialization and deserialization of MCPToolset with tool_names parameter."""
+        toolset = mock_mcp_toolset_with_tool_names
+
+        toolset_dict = toolset.to_dict()
+        assert toolset_dict["type"] == "haystack_integrations.tools.mcp.mcp_toolset.MCPToolset"
+        assert toolset_dict["data"]["tool_names"] == ["tool2"]
+
+        with patch("haystack_integrations.tools.mcp.mcp_toolset.MCPToolset.__init__", return_value=None) as mock_init:
+            MCPToolset.from_dict(toolset_dict)
+
+            mock_init.assert_called_once()
+            _, kwargs = mock_init.call_args
+            assert kwargs["tool_names"] == ["tool2"]
+
+    async def test_toolset_combination(self, mock_mcp_toolset):
+        """Test combining MCPToolset with other tools."""
+        toolset = mock_mcp_toolset
+
+        def add(a: int, b: int) -> int:
+            """Add two numbers"""
+            return a + b
+
+        add_tool = Tool(
+            name="add",
+            description="Add two numbers",
+            function=add,
+            parameters={
+                "type": "object",
+                "properties": {"a": {"type": "integer"}, "b": {"type": "integer"}},
+                "required": ["a", "b"],
+            },
+        )
+
+        combined_tools = toolset + [add_tool]
+
+        assert len(combined_tools) == 3
+
+        tool_names = [tool.name for tool in combined_tools.tools]
+        assert "tool1" in tool_names
+        assert "tool2" in tool_names
+        assert "add" in tool_names
+
+    async def test_toolset_error_handling(self):
+        """Test error handling during toolset initialization."""
+        with pytest.raises(MCPConnectionError):
+            MCPToolset(
+                server_info=SSEServerInfo(base_url="http://example.com"),
+                connection_timeout=30.0,
+                invocation_timeout=30.0,
+            )
+
+
+@pytest.mark.integration
+class TestMCPToolsetIntegration:
+    """Integration tests for MCPToolset."""
+
+    @pytest.mark.skipif(sys.platform == "win32", reason="Windows fails for some reason")
+    def test_toolset_with_sse_connection(self):
+        """Test MCPToolset with an SSE connection to a simple server."""
+        import socket
+        import subprocess
+        import tempfile
+
+        # Find an available port
+        def find_free_port():
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(("", 0))
+                return s.getsockname()[1]
+
+        port = find_free_port()
+
+        # Create a temporary file for the server script
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_file:
+            temp_file.write(
+                f"""
+from mcp.server.fastmcp import FastMCP
+mcp = FastMCP("MCP Calculator", host="127.0.0.1", port={port})
+
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    \"\"\"Add two numbers\"\"\"
+    return a + b
+
+@mcp.tool()
+def subtract(a: int, b: int) -> int:
+    \"\"\"Subtract b from a\"\"\"
+    return a - b
+
+if __name__ == "__main__":
+    try:
+        mcp.run(transport="sse")
+    except Exception as e:
+        sys.exit(1)
+""".encode()
+            )
+            server_script_path = temp_file.name
+
+        server_process = None
+        try:
+            # Start the server in a separate process
+            server_process = subprocess.Popen(
+                ["python", server_script_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            )
+
+            # Give the server a moment to start
+            time.sleep(2)
+
+            # Create the toolset
+            server_info = SSEServerInfo(base_url=f"http://127.0.0.1:{port}")
+            toolset = MCPToolset(server_info=server_info)
+
+            # Verify we got both tools
+            assert len(toolset) == 2
+
+            tool_names = [tool.name for tool in toolset.tools]
+            assert "add" in tool_names
+            assert "subtract" in tool_names
+
+            # Test the add tool
+            add_tool = next(tool for tool in toolset.tools if tool.name == "add")
+            result = add_tool.invoke(a=5, b=3)
+            assert result.content[0].text == "8"
+
+            # Test the subtract tool
+            subtract_tool = next(tool for tool in toolset.tools if tool.name == "subtract")
+            result = subtract_tool.invoke(a=10, b=4)
+            assert result.content[0].text == "6"
+
+        except Exception:
+            # Check server output for clues
+            if server_process and server_process.poll() is None:
+                server_process.terminate()
+            raise
+
+        finally:
+            # Clean up
+            if server_process:
+                if server_process.poll() is None:  # Process is still running
+                    server_process.terminate()
+                    try:
+                        server_process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        server_process.kill()
+                        server_process.wait(timeout=5)
+
+            # Remove the temporary file
+            if os.path.exists(server_script_path):
+                os.remove(server_script_path)

mcp_haystack-0.0.2/CHANGELOG.md

@@ -1,9 +0,0 @@
-# Changelog
-
-## [integrations/mcp-v0.0.1] - 2025-03-12
-
-### 🚀 Features
-
-- Add MCP tooling integration (#1487)
-
-<!-- generated by git-cliff -->

mcp_haystack-0.0.2/examples/hayhooks/pipeline_wrapper.py

@@ -1,82 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-Example of a Hayhooks PipelineWrapper for deploying an MCP Tool-based time pipeline as a REST API.
-
-To run this example:
-
-1. Install Hayhooks and dependencies:
-   $ pip install hayhooks haystack-ai
-
-2. Start the Hayhooks server:
-   $ hayhooks run
-
-3. Deploy this pipeline wrapper:
-   $ hayhooks pipeline deploy-files -n time_pipeline {root_dir_for_mcp_haystack_integration}/examples/hayhooks/
-
-4. Invoke via curl:
-   $ curl -X POST 'http://localhost:1416/time_pipeline/run' -H 'accept: application/json' -H 'Content-Type: application/json' -d '{"query":"What is the time in San Francisco? Be brief"}'
-
-For more information, see: https://github.com/deepset-ai/hayhooks
-"""
-
-from hayhooks import BasePipelineWrapper
-from haystack import Pipeline
-from haystack.components.converters import OutputAdapter
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.components.tools import ToolInvoker
-from haystack.dataclasses import ChatMessage
-
-from haystack_integrations.tools.mcp.mcp_tool import MCPTool, StdioServerInfo
-
-
-class PipelineWrapper(BasePipelineWrapper):
-    def setup(self) -> None:
-        """
-        Setup the pipeline with MCP time tool.
-
-        This creates a pipeline that uses an MCP time tool to get the current time
-        and then uses the time to answer a user question.
-        """
-
-        time_tool = MCPTool(
-            name="get_current_time",
-            server_info=StdioServerInfo(command="uvx", args=["mcp-server-time", "--local-timezone=Europe/Berlin"]),
-        )
-
-        self.pipeline = Pipeline()
-        self.pipeline.add_component("llm", OpenAIChatGenerator(model="gpt-4o-mini", tools=[time_tool]))
-        self.pipeline.add_component("tool_invoker", ToolInvoker(tools=[time_tool]))
-        self.pipeline.add_component(
-            "adapter",
-            OutputAdapter(
-                template="{{ initial_msg + initial_tool_messages + tool_messages }}",
-                output_type=list[ChatMessage],
-                unsafe=True,
-            ),
-        )
-        self.pipeline.add_component("response_llm", OpenAIChatGenerator(model="gpt-4o-mini"))
-        self.pipeline.connect("llm.replies", "tool_invoker.messages")
-        self.pipeline.connect("llm.replies", "adapter.initial_tool_messages")
-        self.pipeline.connect("tool_invoker.tool_messages", "adapter.tool_messages")
-        self.pipeline.connect("adapter.output", "response_llm.messages")
-
-    def run_api(self, query: str) -> str:
-        """
-        Run the pipeline with a user query.
-
-        :param query: The user query asking about time
-        :return: The response from the LLM
-        """
-        # Create a user message from the query
-        user_input_msg = ChatMessage.from_user(text=query)
-
-        # Run the pipeline
-        result = self.pipeline.run(
-            {"llm": {"messages": [user_input_msg]}, "adapter": {"initial_msg": [user_input_msg]}}
-        )
-
-        # Return the text of the first reply
-        return result["response_llm"]["replies"][0].text