MCPTool is not working on python notebook

[bilgeyucel]

Describe the bug
MCPTool is not running on python notebook. It works fine in a python script.

To Reproduce
Run the code on the integration page on a colab notebook or locally with a Python notebook
MCP integration page

Error Message

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:473, in MCPTool.__init__(self, name, server_info, description, connection_timeout, invocation_timeout)
    [472](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:472) # Connect and get available tools with timeout
--> [473](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:473) tools = self._run_sync(client.connect(), timeout=connection_timeout)
    [475](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:475) # Handle no tools case

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:656, in MCPTool._run_sync(self, coro, timeout)
    [654](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:654)     # Run the coroutine in the loop but don't close it
    [655](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:655)     # AsyncExitStack depends on this loop staying open
--> [656](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:656)     return loop.run_until_complete(coro)
    [658](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:658) except asyncio.TimeoutError:

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:629, in BaseEventLoop.run_until_complete(self, future)
    [628](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:628) self._check_closed()
--> [629](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:629) self._check_running()
    [631](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:631) new_task = not futures.isfuture(future)

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:588, in BaseEventLoop._check_running(self)
    [587](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:587) if self.is_running():
--> [588](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:588)     raise RuntimeError('This event loop is already running')
    [589](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/asyncio/base_events.py:589) if events._get_running_loop() is not None:

RuntimeError: This event loop is already running

The above exception was the direct cause of the following exception:

MCPConnectionError                        Traceback (most recent call last)
Cell In[4], [line 9](vscode-notebook-cell:?execution_count=4&line=9)
      [5](vscode-notebook-cell:?execution_count=4&line=5) from haystack.dataclasses import ChatMessage
      [7](vscode-notebook-cell:?execution_count=4&line=7) from haystack_integrations.tools.mcp import MCPTool, StdioServerInfo
----> [9](vscode-notebook-cell:?execution_count=4&line=9) time_tool = MCPTool(
     [10](vscode-notebook-cell:?execution_count=4&line=10)     name="create_issue",
     [11](vscode-notebook-cell:?execution_count=4&line=11)     server_info=StdioServerInfo(command="npx", args=["-y", "@modelcontextprotocol/server-github"], env={
     [12](vscode-notebook-cell:?execution_count=4&line=12)         "GITHUB_PERSONAL_ACCESS_TOKEN": "*********"
     [13](vscode-notebook-cell:?execution_count=4&line=13)       }),
     [14](vscode-notebook-cell:?execution_count=4&line=14)     description="Use this tool to create issues on the given github repository"
     [15](vscode-notebook-cell:?execution_count=4&line=15) )
     [16](vscode-notebook-cell:?execution_count=4&line=16) print("MCP connected")
     [17](vscode-notebook-cell:?execution_count=4&line=17) pipeline = Pipeline()

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:511, in MCPTool.__init__(self, name, server_info, description, connection_timeout, invocation_timeout)
    [508](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:508)         logger.warning(f"Error during cleanup after initialization failure: {cleanup_error}")
    [510](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:510) message = f"Failed to initialize MCPTool '{name}': {e}"
--> [511](https://file+.vscode-resource.vscode-cdn.net/Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/haystack_integrations/tools/mcp/mcp_tool.py:511) raise MCPConnectionError(message=message, server_info=server_info, operation="initialize") from e

MCPConnectionError: Failed to initialize MCPTool 'create_issue': This event loop is already running

Describe your environment (please complete the following information):

• OS: macOS 14.7.4 & Google Colab
• Haystack version: 2.11
• Integration version: mcp-haystack 0.0.1

[julian-risch]

Let's discuss if this is still a prio or not

[anakin87]

The previous error seems to be solved.

I'm now getting a different error

UnsupportedOperation                      Traceback (most recent call last)
[/tmp/ipykernel_17066/3674572999.py](https://localhost:8080/#) in <cell line: 0>()
     31 user_input_msg = ChatMessage.from_user(text=user_input)
     32 
---> 33 result = pipeline.run({"llm": {"messages": [user_input_msg]}, "adapter": {"initial_msg": [user_input_msg]}})
     34 
     35 print(result["response_llm"]["replies"][0].text)

29 frames
[/usr/local/lib/python3.12/dist-packages/haystack/core/pipeline/pipeline.py](https://localhost:8080/#) in run(self, data, include_outputs_from, break_point, pipeline_snapshot, snapshot_callback)
    242         # TODO: Remove this warmup once we can check reliably whether a component has been warmed up or not
    243         # As of now it's here to make sure we don't have failing tests that assume warm_up() is called in run()
--> 244         self.warm_up()
    245 
    246         if include_outputs_from is None:

[/usr/local/lib/python3.12/dist-packages/haystack/core/pipeline/base.py](https://localhost:8080/#) in warm_up(self)
    872             if hasattr(self.graph.nodes[node]["instance"], "warm_up"):
    873                 logger.info("Warming up component {node}...", node=node)
--> 874                 self.graph.nodes[node]["instance"].warm_up()
    875 
    876     @staticmethod

[/usr/local/lib/python3.12/dist-packages/haystack/components/generators/chat/openai.py](https://localhost:8080/#) in warm_up(self)
    234         """
    235         if not self._is_warmed_up:
--> 236             warm_up_tools(self.tools)
    237             self._is_warmed_up = True
    238 

[/usr/local/lib/python3.12/dist-packages/haystack/tools/utils.py](https://localhost:8080/#) in warm_up_tools(tools)
     35         for item in tools:
     36             if hasattr(item, "warm_up"):
---> 37                 item.warm_up()
     38 
     39 

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in warm_up(self)
   1177             if self._client is not None:
   1178                 return
-> 1179             tool = self._connect_and_initialize(self.name)
   1180             self.parameters = tool.inputSchema
   1181 

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in _connect_and_initialize(self, tool_name)
   1029         """
   1030         client = self._server_info.create_client()
-> 1031         worker = _MCPClientSessionManager(client, timeout=self._connection_timeout)
   1032         tools = worker.tools()
   1033 

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in stop(self)
   1350         # released before returning. Swallow any errors during shutdown.
   1351         try:
-> 1352             self._worker_future.result(timeout=self.WORKER_SHUTDOWN_TIMEOUT)
   1353         except Exception as e:
   1354             logger.debug(f"Error during worker future result: {e}")

[/usr/lib/python3.12/concurrent/futures/_base.py](https://localhost:8080/#) in result(self, timeout)
    447                     raise CancelledError()
    448                 elif self._state == FINISHED:
--> 449                     return self.__get_result()
    450 
    451                 self._condition.wait(timeout)

[/usr/lib/python3.12/concurrent/futures/_base.py](https://localhost:8080/#) in __get_result(self)
    399         if self._exception:
    400             try:
--> 401                 raise self._exception
    402             finally:
    403                 # Break a reference cycle with the exception in self._exception

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in __init__(self, client, timeout)
   1322         # Wait (in the caller thread) until connect() finishes or raises.
   1323         try:
-> 1324             self._tools_promise.result(timeout)
   1325         except BaseException:
   1326             # If connect failed we should cancel the worker so it doesn't hang.

[/usr/lib/python3.12/concurrent/futures/_base.py](https://localhost:8080/#) in result(self, timeout)
    454                     raise CancelledError()
    455                 elif self._state == FINISHED:
--> 456                     return self.__get_result()
    457                 else:
    458                     raise TimeoutError()

[/usr/lib/python3.12/concurrent/futures/_base.py](https://localhost:8080/#) in __get_result(self)
    399         if self._exception:
    400             try:
--> 401                 raise self._exception
    402             finally:
    403                 # Break a reference cycle with the exception in self._exception

[/usr/lib/python3.12/asyncio/tasks.py](https://localhost:8080/#) in __step_run_and_handle_result(***failed resolving arguments***)
    312                 # We use the `send` method directly, because coroutines
    313                 # don't have `__iter__` and `__next__` methods.
--> 314                 result = coro.send(None)
    315             else:
    316                 result = coro.throw(exc)

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in _coroutine_with_stop_event()
    139             stop_event = asyncio.Event()
    140             stop_event_promise.set_result(stop_event)
--> 141             await coro_factory(stop_event)
    142 
    143         # Schedule the coroutine

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in _run(self, stop_event)
   1360         try:
   1361             # logger.debug(f"TOOL: _run current task: {asyncio.current_task()}")
-> 1362             tools = await self._client.connect()
   1363             # Deliver the tool list to the waiting synchronous code.
   1364             if not self._tools_promise.done():

[/usr/local/lib/python3.12/dist-packages/haystack_integrations/tools/mcp/mcp_tool.py](https://localhost:8080/#) in connect(self)
    437 
    438         server_params = StdioServerParameters(command=self.command, args=self.args, env=self.env)
--> 439         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
    440         return await self._initialize_session_with_transport(stdio_transport, f"stdio server (command: {self.command})")
    441 

[/usr/lib/python3.12/contextlib.py](https://localhost:8080/#) in enter_async_context(self, cm)
    657                             f"not support the asynchronous context manager protocol"
    658                            ) from None
--> 659         result = await _enter(cm)
    660         self._push_async_cm_exit(cm, _exit)
    661         return result

[/usr/lib/python3.12/contextlib.py](https://localhost:8080/#) in __aenter__(self)
    208         del self.args, self.kwds, self.func
    209         try:
--> 210             return await anext(self.gen)
    211         except StopAsyncIteration:
    212             raise RuntimeError("generator didn't yield") from None

[/usr/local/lib/python3.12/dist-packages/mcp/client/stdio/__init__.py](https://localhost:8080/#) in stdio_client(server, errlog)
    122 
    123         # Open process with stderr piped for capture
--> 124         process = await _create_platform_compatible_process(
    125             command=command,
    126             args=server.args,

[/usr/local/lib/python3.12/dist-packages/mcp/client/stdio/__init__.py](https://localhost:8080/#) in _create_platform_compatible_process(command, args, env, errlog, cwd)
    249         process = await create_windows_process(command, args, env, errlog, cwd)
    250     else:
--> 251         process = await anyio.open_process(
    252             [command, *args],
    253             env=env,

[/usr/local/lib/python3.12/dist-packages/anyio/_core/_subprocesses.py](https://localhost:8080/#) in open_process(command, stdin, stdout, stderr, cwd, env, startupinfo, creationflags, start_new_session, pass_fds, user, group, extra_groups, umask)
    188         kwargs["umask"] = umask
    189 
--> 190     return await get_async_backend().open_process(
    191         command,
    192         stdin=stdin,

[/usr/local/lib/python3.12/dist-packages/anyio/_backends/_asyncio.py](https://localhost:8080/#) in open_process(cls, command, stdin, stdout, stderr, **kwargs)
   2599             )
   2600         else:
-> 2601             process = await asyncio.create_subprocess_exec(
   2602                 *command,
   2603                 stdin=stdin,

[/usr/lib/python3.12/asyncio/subprocess.py](https://localhost:8080/#) in create_subprocess_exec(program, stdin, stdout, stderr, limit, *args, **kwds)
    222     protocol_factory = lambda: SubprocessStreamProtocol(limit=limit,
    223                                                         loop=loop)
--> 224     transport, protocol = await loop.subprocess_exec(
    225         protocol_factory,
    226         program, *args,

[/usr/lib/python3.12/asyncio/base_events.py](https://localhost:8080/#) in subprocess_exec(self, protocol_factory, program, stdin, stdout, stderr, universal_newlines, shell, bufsize, encoding, errors, text, *args, **kwargs)
   1754             debug_log = f'execute program {program!r}'
   1755             self._log_subprocess(debug_log, stdin, stdout, stderr)
-> 1756         transport = await self._make_subprocess_transport(
   1757             protocol, popen_args, False, stdin, stdout, stderr,
   1758             bufsize, **kwargs)

[/usr/lib/python3.12/asyncio/unix_events.py](https://localhost:8080/#) in _make_subprocess_transport(self, protocol, args, shell, stdin, stdout, stderr, bufsize, extra, **kwargs)
    209                                 "subprocess support is not installed.")
    210             waiter = self.create_future()
--> 211             transp = _UnixSubprocessTransport(self, protocol, args, shell,
    212                                             stdin, stdout, stderr, bufsize,
    213                                             waiter=waiter, extra=extra,

[/usr/lib/python3.12/asyncio/base_subprocess.py](https://localhost:8080/#) in __init__(self, loop, protocol, args, shell, stdin, stdout, stderr, bufsize, waiter, extra, **kwargs)
     34         # Create the child process: set the _proc attribute
     35         try:
---> 36             self._start(args=args, shell=shell, stdin=stdin, stdout=stdout,
     37                         stderr=stderr, bufsize=bufsize, **kwargs)
     38         except:

[/usr/lib/python3.12/asyncio/unix_events.py](https://localhost:8080/#) in _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs)
    818             stdin, stdin_w = socket.socketpair()
    819         try:
--> 820             self._proc = subprocess.Popen(
    821                 args, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr,
    822                 universal_newlines=False, bufsize=bufsize, **kwargs)

[/usr/lib/python3.12/subprocess.py](https://localhost:8080/#) in __init__(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags, restore_signals, start_new_session, pass_fds, user, group, extra_groups, encoding, errors, text, umask, pipesize, process_group)
    990         (p2cread, p2cwrite,
    991          c2pread, c2pwrite,
--> 992          errread, errwrite) = self._get_handles(stdin, stdout, stderr)
    993 
    994         # From here on, raising exceptions may cause file descriptor leakage

[/usr/lib/python3.12/subprocess.py](https://localhost:8080/#) in _get_handles(self, stdin, stdout, stderr)
   1743                 else:
   1744                     # Assuming file-like object
-> 1745                     errwrite = stderr.fileno()
   1746 
   1747             return (p2cread, p2cwrite,

[/usr/local/lib/python3.12/dist-packages/ipykernel/iostream.py](https://localhost:8080/#) in fileno(self)
    309             return self._original_stdstream_copy
    310         else:
--> 311             raise io.UnsupportedOperation("fileno")
    312 
    313     def _watch_pipe_fd(self):

UnsupportedOperation: fileno

The issue is that StdioServerInfo runs a subprocess via the MCP stdio_client, which tries to pass sys.stderr to the child process. In Colab/Jupyter, sys.stderr doesn't have a real file descriptor.

How to fix it?

• Make users aware of the issue and provide a workaround
• Implement the workaround in the integration