@@ -1,12 +1,15 @@
-from typing import TYPE_CHECKING, Any
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, AsyncIterator
 
 from dspy.adapters.types.tool import Tool, convert_input_schema_to_tool_args
 
 if TYPE_CHECKING:
     import mcp
 
 
-def _convert_mcp_tool_result(call_tool_result: "mcp.types.CallToolResult") -> str | list[Any]:
+def _convert_mcp_tool_result(call_tool_result: mcp.types.CallToolResult) -> str | list[Any]:
     from mcp.types import TextContent
 
     text_contents: list[TextContent] = []
@@ -27,7 +30,7 @@ def _convert_mcp_tool_result(call_tool_result: "mcp.types.CallToolResult") -> st
     return tool_content or non_text_contents
 
 
-def convert_mcp_tool(session: "mcp.ClientSession", tool: "mcp.types.Tool") -> Tool:
+def convert_mcp_tool(session: mcp.ClientSession, tool: mcp.types.Tool) -> Tool:
     """Build a DSPy tool from an MCP tool.
 
     Args:
@@ -45,3 +48,122 @@ async def func(*args, **kwargs):
         return _convert_mcp_tool_result(result)
 
     return Tool(func=func, name=tool.name, desc=tool.description, args=args, arg_types=arg_types, arg_desc=arg_desc)
+
+
+def _validate_tool_filters(include_tools: list[str] | None, exclude_tools: list[str] | None) -> None:
+    if include_tools and exclude_tools:
+        raise ValueError("Cannot specify both include_tools and exclude_tools.")
+
+
+def _validate_tool_names(requested: list[str] | None, available: list[str]) -> None:
+    if not requested:
+        return
+    unknown = set(requested) - set(available)
+    if unknown:
+        raise ValueError(f"Tool names not found on MCP server: {unknown}. Available tools: {set(available)}")
+
+
+def _filter_mcp_tools(
+    tools: list[mcp.types.Tool],
+    include_tools: list[str] | None,
+    exclude_tools: list[str] | None,
+) -> list[mcp.types.Tool]:
+    if include_tools is not None:
+        tools = [t for t in tools if t.name in set(include_tools)]
+    elif exclude_tools is not None:
+        excluded = set(exclude_tools)
+        tools = [t for t in tools if t.name not in excluded]
+    return tools
+
+
+@asynccontextmanager
+async def stdio_mcp_tools(
+    server_params: mcp.StdioServerParameters,
+    *,
+    include_tools: list[str] | None = None,
+    exclude_tools: list[str] | None = None,
+    timeout: float | None = None,
+) -> AsyncIterator[list[Tool]]:
+    """Yield DSPy tools backed by a live MCP stdio session.
+
+    Usage::
+
+        params = StdioServerParameters(command="docker", args=[...])
+        async with stdio_mcp_tools(params, exclude_tools=["dangerous"], timeout=30) as tools:
+            react = dspy.ReAct(MySignature, tools=tools)
+            result = await react.acall(...)
+
+    Args:
+        server_params: MCP stdio server parameters.
+        include_tools: If set, only include tools whose names are in this list.
+        exclude_tools: If set, exclude tools whose names are in this list.
+        timeout: Read timeout in seconds for the MCP session. None means no timeout.
+
+    Yields:
+        A list of DSPy Tool objects.
+
+    Raises:
+        ValueError: If both include_tools and exclude_tools are specified, or if any
+            requested tool names are not found on the MCP server.
+    """
+    _validate_tool_filters(include_tools, exclude_tools)
+
+    from datetime import timedelta
+
+    from mcp import ClientSession
+    from mcp.client.stdio import stdio_client
+
+    read_timeout = timedelta(seconds=timeout) if timeout is not None else None
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write, read_timeout_seconds=read_timeout) as session:
+            await session.initialize()
+            listed = await session.list_tools()
+            _validate_tool_names(include_tools or exclude_tools, [t.name for t in listed.tools])
+            filtered = _filter_mcp_tools(listed.tools, include_tools, exclude_tools)
+            yield [convert_mcp_tool(session, t) for t in filtered]
+
+
+@asynccontextmanager
+async def http_mcp_tools(
+    url: str,
+    *,
+    include_tools: list[str] | None = None,
+    exclude_tools: list[str] | None = None,
+    timeout: float | None = None,
+) -> AsyncIterator[list[Tool]]:
+    """Yield DSPy tools backed by a live MCP streamable-HTTP session.
+
+    Usage::
+
+        async with http_mcp_tools("http://127.0.0.1:8003/mcp", include_tools=["search"], timeout=30) as tools:
+            react = dspy.ReAct(MySignature, tools=tools)
+            result = await react.acall(...)
+
+    Args:
+        url: The URL of the MCP streamable-HTTP server.
+        include_tools: If set, only include tools whose names are in this list.
+        exclude_tools: If set, exclude tools whose names are in this list.
+        timeout: Read timeout in seconds for the MCP session. None means no timeout.
+
+    Yields:
+        A list of DSPy Tool objects.
+
+    Raises:
+        ValueError: If both include_tools and exclude_tools are specified, or if any
+            requested tool names are not found on the MCP server.
+    """
+    _validate_tool_filters(include_tools, exclude_tools)
+
+    from datetime import timedelta
+
+    from mcp import ClientSession
+    from mcp.client.streamable_http import streamable_http_client
+
+    read_timeout = timedelta(seconds=timeout) if timeout is not None else None
+    async with streamable_http_client(url) as (read, write, _):
+        async with ClientSession(read, write, read_timeout_seconds=read_timeout) as session:
+            await session.initialize()
+            listed = await session.list_tools()
+            _validate_tool_names(include_tools or exclude_tools, [t.name for t in listed.tools])
+            filtered = _filter_mcp_tools(listed.tools, include_tools, exclude_tools)
+            yield [convert_mcp_tool(session, t) for t in filtered]
@@ -3,7 +3,7 @@
 
 import pytest
 
-from dspy.utils.mcp import convert_mcp_tool
+from dspy.utils.mcp import convert_mcp_tool, http_mcp_tools, stdio_mcp_tools
 
 if importlib.util.find_spec("mcp") is None:
     pytest.skip(reason="mcp is not installed", allow_module_level=True)
@@ -14,6 +14,7 @@
 async def test_convert_mcp_tool():
     from mcp import ClientSession, StdioServerParameters
     from mcp.client.stdio import stdio_client
+
     server_params = StdioServerParameters(
         command="python",
         args=["tests/utils/resources/mcp_server.py"],
@@ -96,3 +97,148 @@ async def test_convert_mcp_tool():
             assert current_datetime_tool.arg_types == {}
             assert current_datetime_tool.arg_desc == {}
             assert await current_datetime_tool.acall() == "2025-07-23T09:10:10.0+00:00"
+
+
+def _find_nested_exception(eg, exc_type):
+    """Walk a (possibly nested) ExceptionGroup to find an exception of the given type."""
+    if isinstance(eg, exc_type):
+        return eg
+    if isinstance(eg, BaseException) and hasattr(eg, "exceptions"):
+        for exc in eg.exceptions:
+            found = _find_nested_exception(exc, exc_type)
+            if found:
+                return found
+    return None
+
+
+@pytest.fixture()
+def server_params():
+    from mcp import StdioServerParameters
+
+    return StdioServerParameters(
+        command="python",
+        args=["tests/utils/resources/mcp_server.py"],
+        env=None,
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.extra
+async def test_stdio_mcp_tools(server_params):
+    # Basic usage: all tools available and callable
+    async with stdio_mcp_tools(server_params) as tools:
+        names = [t.name for t in tools]
+        assert "add" in names
+        assert "hello" in names
+        assert await tools[0].acall(a=1, b=2) == "3"
+
+    # include_tools: only the specified tool is returned
+    async with stdio_mcp_tools(server_params, include_tools=["add"]) as tools:
+        assert len(tools) == 1
+        assert tools[0].name == "add"
+
+    # exclude_tools: the specified tool is filtered out
+    async with stdio_mcp_tools(server_params, exclude_tools=["wrong_tool"]) as tools:
+        names = [t.name for t in tools]
+        assert "wrong_tool" not in names
+        assert "add" in names
+
+    # include_tools and exclude_tools together raises ValueError
+    with pytest.raises(ValueError, match="Cannot specify both include_tools and exclude_tools"):
+        async with stdio_mcp_tools(server_params, include_tools=["add"], exclude_tools=["hello"]) as _:
+            pass
+
+    # timeout: session works with a timeout set
+    async with stdio_mcp_tools(server_params, timeout=10) as tools:
+        assert len(tools) > 0
+
+    # include_tools with unknown name raises ValueError
+    try:
+        async with stdio_mcp_tools(server_params, include_tools=["nonexistent"]) as _:
+            pass
+        pytest.fail("Expected ValueError")
+    except BaseException as eg:
+        err = _find_nested_exception(eg, ValueError)
+        assert err and "Tool names not found on MCP server" in str(err)
+
+    # exclude_tools with unknown name raises ValueError
+    try:
+        async with stdio_mcp_tools(server_params, exclude_tools=["nonexistent"]) as _:
+            pass
+        pytest.fail("Expected ValueError")
+    except BaseException as eg:
+        err = _find_nested_exception(eg, ValueError)
+        assert err and "Tool names not found on MCP server" in str(err)
+
+
+@pytest.fixture()
+def mcp_proxy_url():
+    """Start mcp-proxy as a subprocess, yield the URL, and tear down on exit."""
+    import socket
+    import subprocess
+    import sys
+    import time
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        port = s.getsockname()[1]
+
+    url = f"http://127.0.0.1:{port}/mcp"
+    proc = subprocess.Popen(
+        ["mcp-proxy", "--port", str(port), "--", sys.executable, "tests/utils/resources/mcp_server.py"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    try:
+        for _ in range(50):
+            try:
+                with socket.create_connection(("127.0.0.1", port), timeout=0.1):
+                    break
+            except OSError:
+                time.sleep(0.1)
+        else:
+            raise TimeoutError(f"mcp-proxy did not start on port {port}")
+        yield url
+    finally:
+        proc.terminate()
+        proc.wait(timeout=5)
+
+
+@pytest.mark.asyncio
+@pytest.mark.extra
+async def test_http_mcp_tools(mcp_proxy_url):
+    # Basic usage: all tools available and callable
+    async with http_mcp_tools(mcp_proxy_url) as tools:
+        names = [t.name for t in tools]
+        assert "add" in names
+        assert "hello" in names
+        assert await tools[0].acall(a=1, b=2) == "3"
+
+    # include_tools: only the specified tool is returned
+    async with http_mcp_tools(mcp_proxy_url, include_tools=["add"]) as tools:
+        assert len(tools) == 1
+        assert tools[0].name == "add"
+
+    # exclude_tools: the specified tool is filtered out
+    async with http_mcp_tools(mcp_proxy_url, exclude_tools=["wrong_tool"]) as tools:
+        names = [t.name for t in tools]
+        assert "wrong_tool" not in names
+        assert "add" in names
+
+    # include_tools with unknown name raises ValueError
+    try:
+        async with http_mcp_tools(mcp_proxy_url, include_tools=["nonexistent"]) as _:
+            pass
+        pytest.fail("Expected ValueError")
+    except BaseException as eg:
+        err = _find_nested_exception(eg, ValueError)
+        assert err and "Tool names not found on MCP server" in str(err)
+
+    # exclude_tools with unknown name raises ValueError
+    try:
+        async with http_mcp_tools(mcp_proxy_url, exclude_tools=["nonexistent"]) as _:
+            pass
+        pytest.fail("Expected ValueError")
+    except BaseException as eg:
+        err = _find_nested_exception(eg, ValueError)
+        assert err and "Tool names not found on MCP server" in str(err)