Skip to content

Building AI agents, atomically

refactoring from bool to enum type in mcp tool factory, updating tests, and docs, using http_stream for consistency, defaulting to http_stream for mcp

jon foxdc2437e1de6c
diff --git a/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py b/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py
index 2d4194c..8e3a6ed 100644
--- a/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py
+++ b/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py
@@ -14,7 +14,7 @@ from mcp.client.stdio import stdio_client
from atomic_agents.lib.base.base_io_schema import BaseIOSchema
from atomic_agents.lib.base.base_tool import BaseTool
from atomic_agents.lib.factories.schema_transformer import SchemaTransformer
-from atomic_agents.lib.factories.tool_definition_service import ToolDefinitionService, MCPToolDefinition
+from atomic_agents.lib.factories.tool_definition_service import ToolDefinitionService, MCPToolDefinition, MCPTransportType
logger = logging.getLogger(__name__)
@@ -31,8 +31,7 @@ class MCPToolFactory:
def __init__(
self,
mcp_endpoint: Optional[str] = None,
- use_stdio: bool = False,
- use_http_stream: bool = False,
+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,
client_session: Optional[ClientSession] = None,
event_loop: Optional[asyncio.AbstractEventLoop] = None,
working_directory: Optional[str] = None,
@@ -41,24 +40,20 @@ class MCPToolFactory:
Initialize the factory.
Args:
- mcp_endpoint: URL of the MCP server (for SSE) or the full command to run the server (for STDIO)
- use_stdio: If True, use STDIO transport instead of SSE
- use_http_stream: If True, use HTTP streaming transport (preferred) instead of SSE (deprecated)
+ mcp_endpoint: URL of the MCP server (for SSE/HTTP stream) or the full command to run the server (for STDIO)
+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO)
client_session: Optional pre-initialized ClientSession for reuse
event_loop: Optional event loop for running asynchronous operations
working_directory: Optional working directory to use when running STDIO commands
"""
self.mcp_endpoint = mcp_endpoint
- self.use_stdio = use_stdio
- self.use_http_stream = use_http_stream
+ self.transport_type = transport_type
self.client_session = client_session
self.event_loop = event_loop
self.schema_transformer = SchemaTransformer()
self.working_directory = working_directory
# Validate configuration
- if self.use_stdio and self.use_http_stream:
- raise ValueError("Cannot use both STDIO and HTTP stream transports at once.")
if client_session is not None and event_loop is None:
raise ValueError("When `client_session` is provided an `event_loop` must also be supplied.")
if not mcp_endpoint and client_session is None:
@@ -94,8 +89,7 @@ class MCPToolFactory:
# Create new connection
service = ToolDefinitionService(
self.mcp_endpoint,
- self.use_stdio,
- self.use_http_stream,
+ self.transport_type,
self.working_directory,
)
return asyncio.run(service.fetch_definitions())
@@ -135,8 +129,7 @@ class MCPToolFactory:
def run_tool_sync(self, params: InputSchema) -> OutputSchema: # type: ignore
bound_tool_name = self.mcp_tool_name
bound_mcp_endpoint = self.mcp_endpoint # May be None when using external session
- bound_use_stdio = self.use_stdio
- bound_use_http_stream = self.use_http_stream
+ bound_transport_type = self.transport_type
persistent_session: Optional[ClientSession] = getattr(self, "_client_session", None)
loop: Optional[asyncio.AbstractEventLoop] = getattr(self, "_event_loop", None)
bound_working_directory = getattr(self, "working_directory", None)
@@ -147,7 +140,7 @@ class MCPToolFactory:
async def _connect_and_call():
stack = AsyncExitStack()
try:
- if bound_use_stdio:
+ if bound_transport_type == MCPTransportType.STDIO:
# Split the command string into the command and its arguments
command_parts = shlex.split(bound_mcp_endpoint)
if not command_parts:
@@ -160,17 +153,23 @@ class MCPToolFactory:
)
stdio_transport = await stack.enter_async_context(stdio_client(server_params))
read_stream, write_stream = stdio_transport
- elif bound_use_http_stream:
+ elif bound_transport_type == MCPTransportType.HTTP_STREAM:
# HTTP streaming transport (preferred)
http_endpoint = f"{bound_mcp_endpoint}/mcp"
logger.debug(f"Executing tool '{bound_tool_name}' via HTTP stream: endpoint={http_endpoint}")
stream_transport = await stack.enter_async_context(sse_client(http_endpoint))
read_stream, write_stream = stream_transport
- else:
+ elif bound_transport_type == MCPTransportType.SSE:
+ # SSE transport (deprecated)
sse_endpoint = f"{bound_mcp_endpoint}/sse"
logger.debug(f"Executing tool '{bound_tool_name}' via SSE: endpoint={sse_endpoint}")
sse_transport = await stack.enter_async_context(sse_client(sse_endpoint))
read_stream, write_stream = sse_transport
+ else:
+ available_types = [t.value for t in MCPTransportType]
+ raise ValueError(
+ f"Unknown transport type: {bound_transport_type}. Available transport types: {available_types}"
+ )
session = await stack.enter_async_context(ClientSession(read_stream, write_stream))
await session.initialize()
@@ -217,8 +216,7 @@ class MCPToolFactory:
"__doc__": tool_description,
"mcp_tool_name": tool_name,
"mcp_endpoint": self.mcp_endpoint,
- "use_stdio": self.use_stdio,
- "use_http_stream": self.use_http_stream,
+ "transport_type": self.transport_type,
"_client_session": self.client_session,
"_event_loop": self.event_loop,
"working_directory": self.working_directory,
@@ -281,27 +279,25 @@ class MCPToolFactory:
# Public API functions
def fetch_mcp_tools(
mcp_endpoint: Optional[str] = None,
- use_stdio: bool = False,
- use_http_stream: bool = False,
+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,
*,
client_session: Optional[ClientSession] = None,
event_loop: Optional[asyncio.AbstractEventLoop] = None,
working_directory: Optional[str] = None,
) -> List[Type[BaseTool]]:
"""
- Connects to an MCP server via SSE, Http Stream or STDIO, discovers tool definitions, and dynamically generates
+ Connects to an MCP server via SSE, HTTP Stream or STDIO, discovers tool definitions, and dynamically generates
synchronous Atomic Agents compatible BaseTool subclasses for each tool.
Each generated tool will establish its own connection when its `run` method is called.
Args:
mcp_endpoint: URL of the MCP server or command for STDIO.
- use_stdio: If True, use STDIO transport.
- use_http_stream: If True, use HTTP streaming transport.
+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO).
client_session: Optional pre-initialized ClientSession for reuse.
event_loop: Optional event loop for running asynchronous operations.
working_directory: Optional working directory for STDIO.
"""
- factory = MCPToolFactory(mcp_endpoint, use_stdio, use_http_stream, client_session, event_loop, working_directory)
+ factory = MCPToolFactory(mcp_endpoint, transport_type, client_session, event_loop, working_directory)
return factory.create_tools()
@@ -322,8 +318,7 @@ def create_mcp_orchestrator_schema(tools: List[Type[BaseTool]]) -> Optional[Type
def fetch_mcp_tools_with_schema(
mcp_endpoint: Optional[str] = None,
- use_stdio: bool = False,
- use_http_stream: bool = False,
+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,
*,
client_session: Optional[ClientSession] = None,
event_loop: Optional[asyncio.AbstractEventLoop] = None,
@@ -334,8 +329,7 @@ def fetch_mcp_tools_with_schema(
Args:
mcp_endpoint: URL of the MCP server or command for STDIO.
- use_stdio: If True, use STDIO transport.
- use_http_stream: If True, use HTTP streaming transport.
+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO).
client_session: Optional pre-initialized ClientSession for reuse.
event_loop: Optional event loop for running asynchronous operations.
working_directory: Optional working directory for STDIO.
@@ -345,7 +339,7 @@ def fetch_mcp_tools_with_schema(
- List of dynamically generated tool classes
- Orchestrator output schema with Union of tool input schemas, or None if no tools found.
"""
- factory = MCPToolFactory(mcp_endpoint, use_stdio, use_http_stream, client_session, event_loop, working_directory)
+ factory = MCPToolFactory(mcp_endpoint, transport_type, client_session, event_loop, working_directory)
tools = factory.create_tools()
if not tools:
return [], None
diff --git a/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py b/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py
index f722b8a..8784580 100644
--- a/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py
+++ b/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py
@@ -4,6 +4,7 @@ import logging
import shlex
from contextlib import AsyncExitStack
from typing import List, NamedTuple, Optional, Dict, Any
+from enum import Enum
from mcp import ClientSession, StdioServerParameters
from mcp.client.sse import sse_client
@@ -12,6 +13,14 @@ from mcp.client.stdio import stdio_client
logger = logging.getLogger(__name__)
+class MCPTransportType(Enum):
+ """Enum for MCP transport types."""
+
+ SSE = "sse"
+ HTTP_STREAM = "http_stream"
+ STDIO = "stdio"
+
+
class MCPToolDefinition(NamedTuple):
"""Definition of an MCP tool."""
@@ -26,8 +35,7 @@ class ToolDefinitionService:
def __init__(
self,
endpoint: Optional[str] = None,
- use_stdio: bool = False,
- use_http_stream: bool = False,
+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,
working_directory: Optional[str] = None,
):
"""
@@ -35,13 +43,11 @@ class ToolDefinitionService:
Args:
endpoint: URL of the MCP server (for SSE/HTTP stream) or command string (for STDIO)
- use_stdio: Whether to use STDIO transport
- use_http_stream: Whether to use HTTP stream transport (no '/sse')
+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO)
working_directory: Optional working directory to use when running STDIO commands
"""
self.endpoint = endpoint
- self.use_stdio = use_stdio
- self.use_http_stream = use_http_stream
+ self.transport_type = transport_type
self.working_directory = working_directory
async def fetch_definitions(self) -> List[MCPToolDefinition]:
@@ -62,7 +68,7 @@ class ToolDefinitionService:
definitions = []
stack = AsyncExitStack()
try:
- if self.use_stdio:
+ if self.transport_type == MCPTransportType.STDIO:
# STDIO transport
command_parts = shlex.split(self.endpoint)
if not command_parts:
@@ -73,18 +79,21 @@ class ToolDefinitionService:
server_params = StdioServerParameters(command=command, args=args, env=None, cwd=self.working_directory)
stdio_transport = await stack.enter_async_context(stdio_client(server_params))
read_stream, write_stream = stdio_transport
- elif self.use_http_stream:
+ elif self.transport_type == MCPTransportType.HTTP_STREAM:
# HTTP Stream transport
transport_endpoint = f"{self.endpoint}/mcp"
logger.info(f"Attempting HTTP Stream connection to {transport_endpoint}")
transport = await stack.enter_async_context(sse_client(transport_endpoint))
read_stream, write_stream = transport
- else:
- # Default to SSE transport (deprecated)
+ elif self.transport_type == MCPTransportType.SSE:
+ # SSE transport (deprecated)
transport_endpoint = f"{self.endpoint}/sse"
logger.info(f"Attempting SSE connection to {transport_endpoint}")
transport = await stack.enter_async_context(sse_client(transport_endpoint))
read_stream, write_stream = transport
+ else:
+ available_types = [t.value for t in MCPTransportType]
+ raise ValueError(f"Unknown transport type: {self.transport_type}. Available types: {available_types}")
session = await stack.enter_async_context(ClientSession(read_stream, write_stream))
definitions = await self.fetch_definitions_from_session(session)
diff --git a/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py b/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py
index bf074d7..33d8991 100644
--- a/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py
+++ b/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py
@@ -7,7 +7,7 @@ from atomic_agents.lib.factories.mcp_tool_factory import (
fetch_mcp_tools_with_schema,
MCPToolFactory,
)
-from atomic_agents.lib.factories.tool_definition_service import MCPToolDefinition, ToolDefinitionService
+from atomic_agents.lib.factories.tool_definition_service import MCPToolDefinition, ToolDefinitionService, MCPTransportType
class DummySession:
@@ -21,12 +21,12 @@ def test_fetch_mcp_tools_no_endpoint_raises():
def test_fetch_mcp_tools_event_loop_without_client_session_raises():
with pytest.raises(ValueError):
- fetch_mcp_tools(None, False, client_session=DummySession(), event_loop=None)
+ fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=DummySession(), event_loop=None)
def test_fetch_mcp_tools_empty_definitions(monkeypatch):
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: [])
- tools = fetch_mcp_tools("http://example.com", use_stdio=False)
+ tools = fetch_mcp_tools("http://example.com", MCPTransportType.HTTP_STREAM)
assert tools == []
@@ -34,12 +34,12 @@ def test_fetch_mcp_tools_with_definitions_http(monkeypatch):
input_schema = {"type": "object", "properties": {}, "required": []}
definitions = [MCPToolDefinition(name="ToolX", description="Dummy tool", input_schema=input_schema)]
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)
- tools = fetch_mcp_tools("http://example.com", use_stdio=False)
+ tools = fetch_mcp_tools("http://example.com", MCPTransportType.HTTP_STREAM)
assert len(tools) == 1
tool_cls = tools[0]
# verify class attributes
assert tool_cls.mcp_endpoint == "http://example.com"
- assert tool_cls.use_stdio is False
+ assert tool_cls.transport_type == MCPTransportType.HTTP_STREAM
# input_schema has only tool_name field
Model = tool_cls.input_schema
assert "tool_name" in Model.model_fields
@@ -76,7 +76,7 @@ def test_fetch_mcp_tools_with_schema_no_endpoint_raises():
def test_fetch_mcp_tools_with_schema_empty(monkeypatch):
monkeypatch.setattr(MCPToolFactory, "create_tools", lambda self: [])
- tools, schema = fetch_mcp_tools_with_schema("endpoint", False)
+ tools, schema = fetch_mcp_tools_with_schema("endpoint", MCPTransportType.HTTP_STREAM)
assert tools == []
assert schema is None
@@ -86,7 +86,7 @@ def test_fetch_mcp_tools_with_schema_nonempty(monkeypatch):
dummy_schema = object()
monkeypatch.setattr(MCPToolFactory, "create_tools", lambda self: dummy_tools)
monkeypatch.setattr(MCPToolFactory, "create_orchestrator_schema", lambda self, t: dummy_schema)
- tools, schema = fetch_mcp_tools_with_schema("endpoint", True)
+ tools, schema = fetch_mcp_tools_with_schema("endpoint", MCPTransportType.STDIO)
assert tools == dummy_tools
assert schema is dummy_schema
@@ -95,16 +95,16 @@ def test_fetch_mcp_tools_with_stdio_and_working_directory(monkeypatch):
input_schema = {"type": "object", "properties": {}, "required": []}
definitions = [MCPToolDefinition(name="ToolZ", description=None, input_schema=input_schema)]
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)
- tools = fetch_mcp_tools("run me", True, working_directory="/tmp")
+ tools = fetch_mcp_tools("run me", MCPTransportType.STDIO, working_directory="/tmp")
assert len(tools) == 1
tool_cls = tools[0]
- assert tool_cls.use_stdio is True
+ assert tool_cls.transport_type == MCPTransportType.STDIO
assert tool_cls.mcp_endpoint == "run me"
assert tool_cls.working_directory == "/tmp"
[email protected]("use_stdio", [False, True])
-def test_run_tool(monkeypatch, use_stdio):
[email protected]("transport_type", [MCPTransportType.HTTP_STREAM, MCPTransportType.STDIO])
+def test_run_tool(monkeypatch, transport_type):
# Setup dummy transports and session
import atomic_agents.lib.factories.mcp_tool_factory as mtf
@@ -148,8 +148,10 @@ def test_run_tool(monkeypatch, use_stdio):
definitions = [MCPToolDefinition(name="ToolA", description="desc", input_schema=input_schema)]
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)
# Run fetch and execute tool
- endpoint = "cmd run" if use_stdio else "http://e"
- tools = fetch_mcp_tools(endpoint, use_stdio, working_directory="wd" if use_stdio else None)
+ endpoint = "cmd run" if transport_type == MCPTransportType.STDIO else "http://e"
+ tools = fetch_mcp_tools(
+ endpoint, transport_type, working_directory="wd" if transport_type == MCPTransportType.STDIO else None
+ )
tool_cls = tools[0]
inst = tool_cls()
result = inst.run(tool_cls.input_schema(tool_name="ToolA"))
@@ -177,7 +179,7 @@ def test_run_tool_with_persistent_session(monkeypatch):
# Create and pass an event loop
loop = asyncio.new_event_loop()
try:
- tools = fetch_mcp_tools(None, False, client_session=client, event_loop=loop)
+ tools = fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=client, event_loop=loop)
tool_cls = tools[0]
inst = tool_cls()
result = inst.run(tool_cls.input_schema(tool_name="ToolB"))
@@ -196,9 +198,9 @@ def test_fetch_tool_definitions_via_service(monkeypatch):
return defs
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", fake_fetch)
- factory_http = MCPToolFactory("http://e", False)
+ factory_http = MCPToolFactory("http://e", MCPTransportType.HTTP_STREAM)
assert factory_http._fetch_tool_definitions() == defs
- factory_stdio = MCPToolFactory("http://e", True, working_directory="/tmp")
+ factory_stdio = MCPToolFactory("http://e", MCPTransportType.STDIO, working_directory="/tmp")
assert factory_stdio._fetch_tool_definitions() == defs
@@ -209,7 +211,7 @@ def test_fetch_tool_definitions_propagates_error(monkeypatch):
raise RuntimeError("nope")
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", fake_fetch)
- factory = MCPToolFactory("http://e", False)
+ factory = MCPToolFactory("http://e", MCPTransportType.HTTP_STREAM)
with pytest.raises(RuntimeError):
factory._fetch_tool_definitions()
@@ -259,7 +261,7 @@ def test_run_tool_handles_special_result_types(monkeypatch):
MCPToolDefinition(name="T", description=None, input_schema={"type": "object", "properties": {}, "required": []})
]
monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)
- tool_cls = fetch_mcp_tools("e", False)[0]
+ tool_cls = fetch_mcp_tools("e", MCPTransportType.HTTP_STREAM)[0]
result = tool_cls().run(tool_cls.input_schema(tool_name="T"))
assert result.result == "hello"
@@ -269,7 +271,7 @@ def test_run_tool_handles_special_result_types(monkeypatch):
return 123
monkeypatch.setattr(mtf, "ClientSession", PlainSession)
- result2 = fetch_mcp_tools("e", False)[0]().run(tool_cls.input_schema(tool_name="T"))
+ result2 = fetch_mcp_tools("e", MCPTransportType.HTTP_STREAM)[0]().run(tool_cls.input_schema(tool_name="T"))
assert result2.result == 123
@@ -302,14 +304,14 @@ def test_run_invalid_stdio_command_raises(monkeypatch):
],
)
# Use a blank-space endpoint to bypass init validation but trigger empty command in STDIO
- tool_cls = fetch_mcp_tools(" ", True, working_directory="/wd")[0]
+ tool_cls = fetch_mcp_tools(" ", MCPTransportType.STDIO, working_directory="/wd")[0]
with pytest.raises(RuntimeError) as exc:
tool_cls().run(tool_cls.input_schema(tool_name="Bad"))
assert "STDIO command string cannot be empty" in str(exc.value)
def test_create_tool_classes_skips_invalid(monkeypatch):
- factory = MCPToolFactory("endpoint", False)
+ factory = MCPToolFactory("endpoint", MCPTransportType.HTTP_STREAM)
defs = [
MCPToolDefinition(name="Bad", description=None, input_schema={"type": "object", "properties": {}, "required": []}),
MCPToolDefinition(name="Good", description=None, input_schema={"type": "object", "properties": {}, "required": []}),
@@ -345,7 +347,7 @@ def test_force_mark_unreachable_lines_for_coverage():
def test__fetch_tool_definitions_service_branch(monkeypatch):
"""Covers lines 112-113: ToolDefinitionService branch in _fetch_tool_definitions."""
- factory = MCPToolFactory("dummy_endpoint", False)
+ factory = MCPToolFactory("dummy_endpoint", MCPTransportType.HTTP_STREAM)
# Patch fetch_definitions to avoid real async work
async def dummy_fetch_definitions(self):
@@ -396,7 +398,7 @@ def test_run_tool_with_persistent_session_no_event_loop(monkeypatch):
# Create tool with persistent session and a valid event loop
loop = asyncio.new_event_loop()
try:
- tools = fetch_mcp_tools(None, False, client_session=client, event_loop=loop)
+ tools = fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=client, event_loop=loop)
tool_cls = tools[0]
inst = tool_cls()
# Remove the event loop to simulate the error path
diff --git a/atomic-agents/tests/lib/factories/test_tool_definition_service.py b/atomic-agents/tests/lib/factories/test_tool_definition_service.py
index 8cc81aa..8541201 100644
--- a/atomic-agents/tests/lib/factories/test_tool_definition_service.py
+++ b/atomic-agents/tests/lib/factories/test_tool_definition_service.py
@@ -4,6 +4,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
from atomic_agents.lib.factories.tool_definition_service import (
ToolDefinitionService,
MCPToolDefinition,
+ MCPTransportType,
)
@@ -91,7 +92,7 @@ class TestToolDefinitionService:
@pytest.mark.asyncio
async def test_fetch_via_stdio(self):
# Create service
- service = ToolDefinitionService("command arg1 arg2", use_stdio=True)
+ service = ToolDefinitionService("command arg1 arg2", MCPTransportType.STDIO)
# Mock the fetch_definitions_from_session method
service.fetch_definitions_from_session = AsyncMock(
@@ -123,7 +124,7 @@ class TestToolDefinitionService:
@pytest.mark.asyncio
async def test_stdio_empty_command(self):
# Create service with empty command
- service = ToolDefinitionService("", use_stdio=True)
+ service = ToolDefinitionService("", MCPTransportType.STDIO)
# Test that ValueError is raised for empty command
with pytest.raises(ValueError, match="Endpoint is required"):
@@ -173,7 +174,7 @@ class TestToolDefinitionService:
@pytest.mark.asyncio
async def test_stdio_command_parts_empty(self):
- svc = ToolDefinitionService(" ", use_stdio=True)
+ svc = ToolDefinitionService(" ", MCPTransportType.STDIO)
with pytest.raises(
RuntimeError, match="Unexpected error during tool definition fetching: STDIO command string cannot be empty"
):
diff --git a/atomic-examples/mcp-agent/README.md b/atomic-examples/mcp-agent/README.md
index bbd862f..8d2a427 100644
--- a/atomic-examples/mcp-agent/README.md
+++ b/atomic-examples/mcp-agent/README.md
@@ -107,7 +107,7 @@ This example shows the flexibility of the MCP architecture with two distinct tra
# Second terminal: Run the client with HTTP Stream transport
cd example-client
- poetry run python -m example_client.main --transport http
+ poetry run python -m example_client.main --transport http_stream
```
## Example Queries
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main.py b/atomic-examples/mcp-agent/example-client/example_client/main.py
index 1a88af2..42b41a5 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main.py
@@ -6,48 +6,43 @@ This file serves as a launcher that can run either the STDIO or SSE transport ve
import argparse
import sys
+from atomic_agents.lib.factories.tool_definition_service import MCPTransportType
def main():
"""Parse command line arguments and launch the appropriate implementation."""
parser = argparse.ArgumentParser(description="MCP Agent example client")
+
+ # Get available transport choices from the enum
+ transport_choices = [transport.value for transport in MCPTransportType]
+
parser.add_argument(
"--transport",
- choices=["stdio", "sse", "http"],
- default="stdio",
- help="Transport method to use for MCP communication (stdio, sse, or http)",
+ choices=transport_choices,
+ default=MCPTransportType.STDIO.value,
+ help=f"Transport method to use for MCP communication. Available: {', '.join(transport_choices)}",
)
args = parser.parse_args()
- if args.transport == "stdio":
- # Import and run STDIO implementation
- try:
- from example_client.main_stdio import main as stdio_main
-
- stdio_main()
- except ImportError as e:
- print(f"Failed to import STDIO implementation: {e}")
- sys.exit(1)
- elif args.transport == "sse":
- # Import and run SSE implementation
- try:
- from example_client.main_sse import main as sse_main
+ # Map transport values to their corresponding main functions
+ transport_mapping = {
+ MCPTransportType.STDIO.value: ("example_client.main_stdio", "stdio_main"),
+ MCPTransportType.SSE.value: ("example_client.main_sse", "sse_main"),
+ MCPTransportType.HTTP_STREAM.value: ("example_client.main_http", "http_main"),
+ }
- sse_main()
- except ImportError as e:
- print(f"Failed to import SSE implementation: {e}")
- sys.exit(1)
- elif args.transport == "http":
- # Import and run HTTP implementation
+ if args.transport in transport_mapping:
+ module_name, function_name = transport_mapping[args.transport]
try:
- from example_client.main_http import main as http_main
-
- http_main()
+ module = __import__(module_name, fromlist=[function_name])
+ main_func = getattr(module, function_name)
+ main_func()
except ImportError as e:
- print(f"Failed to import HTTP implementation: {e}")
+ print(f"Failed to import {args.transport} implementation: {e}")
sys.exit(1)
else:
print(f"Unknown transport: {args.transport}")
+ print(f"Available transports: {', '.join(transport_choices)}")
sys.exit(1)
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_http.py b/atomic-examples/mcp-agent/example-client/example_client/main_http.py
index a58a61e..bab428e 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main_http.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main_http.py
@@ -5,6 +5,7 @@ Communicates with the server_http.py `/mcp` endpoint using HTTP GET/POST/DELETE
import sys
from atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools
+from atomic_agents.lib.factories.tool_definition_service import MCPTransportType
from rich.console import Console
from rich.table import Table
from pydantic import Field
@@ -38,7 +39,7 @@ def main():
client = instructor.from_openai(openai.OpenAI(api_key=config.openai_api_key))
console.print("[bold green]Initializing MCP Agent System (HTTP Stream mode)...[/bold green]")
- tools = fetch_mcp_tools(mcp_endpoint=config.mcp_server_url, use_stdio=False, use_http_stream=True)
+ tools = fetch_mcp_tools(mcp_endpoint=config.mcp_server_url, transport_type=MCPTransportType.HTTP_STREAM)
if not tools:
console.print(f"[bold red]No MCP tools found at {config.mcp_server_url}[/bold red]")
sys.exit(1)
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py b/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
index 8b343dc..47fd444 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main_sse.py
@@ -1,5 +1,6 @@
# pyright: reportInvalidTypeForm=false
from atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools
+from atomic_agents.lib.factories.tool_definition_service import MCPTransportType
from rich.console import Console
from rich.table import Table
from rich.markdown import Markdown
@@ -48,7 +49,7 @@ class FinalResponseSchema(BaseIOSchema):
# Fetch tools and build ActionUnion statically
tools = fetch_mcp_tools(
mcp_endpoint=config.mcp_server_url,
- use_stdio=False,
+ transport_type=MCPTransportType.SSE,
)
if not tools:
raise RuntimeError("No MCP tools found. Please ensure the MCP server is running and accessible.")
diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py b/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py
index d063549..9b18761 100644
--- a/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py
+++ b/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py
@@ -1,5 +1,6 @@
# pyright: reportInvalidTypeForm=false
from atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools
+from atomic_agents.lib.factories.tool_definition_service import MCPTransportType
from rich.console import Console
from rich.table import Table
import openai
@@ -77,7 +78,7 @@ stdio_session = stdio_loop.run_until_complete(_bootstrap_stdio())
# Fetch tools and build ActionUnion statically
tools = fetch_mcp_tools(
mcp_endpoint=None,
- use_stdio=True,
+ transport_type=MCPTransportType.STDIO,
client_session=stdio_session, # Pass persistent session
event_loop=stdio_loop, # Pass corresponding loop
)