Add support for MCP tools to CrewAI adapter

Author: ljupche98

pyagentspec/requirements-dev.txt

@@ -38,3 +38,4 @@ sphinx_toolbox<=3.8.0
 
 # For remote tool tests
 fastapi[standard-no-fastapi-cloud-cli]
+cryptography

pyagentspec/src/pyagentspec/adapters/crewai/_agentspecconverter.py

@@ -25,7 +25,12 @@
 from pyagentspec.adapters.crewai._types import (
     CrewAIAgent,
     CrewAIBaseTool,
+    CrewAIHTTPTransport,
     CrewAILlm,
+    CrewAIMCPClient,
+    CrewAIMCPNativeTool,
+    CrewAISSETransport,
+    CrewAIStdioTransport,
     CrewAIStructuredTool,
     CrewAITool,
 )
@@ -39,6 +44,13 @@
 )
 from pyagentspec.llms.openaiconfig import OpenAiConfig as AgentSpecOpenAiConfig
 from pyagentspec.llms.vllmconfig import VllmConfig as AgentSpecVllmModel
+from pyagentspec.mcp.clienttransport import ClientTransport as AgentSpecClientTransport
+from pyagentspec.mcp.clienttransport import SSETransport as AgentSpecSSETransport
+from pyagentspec.mcp.clienttransport import StdioTransport as AgentSpecStdioTransport
+from pyagentspec.mcp.clienttransport import (
+    StreamableHTTPTransport as AgentSpecStreamableHTTPTransport,
+)
+from pyagentspec.mcp.tools import MCPTool as AgentSpecMCPTool
 from pyagentspec.property import Property as AgentSpecProperty
 from pyagentspec.tools import ServerTool as AgentSpecServerTool
 from pyagentspec.tools import Tool as AgentSpecTool
@@ -119,6 +131,10 @@ def convert(
             agentspec_component = self._agent_convert_to_agentspec(
                 crewai_component, referenced_objects
             )
+        elif isinstance(crewai_component, CrewAIMCPClient):
+            agentspec_component = self._mcp_client_convert_to_agentspec(
+                crewai_component, referenced_objects
+            )
         elif isinstance(crewai_component, CrewAIBaseTool):
             agentspec_component = self._tool_convert_to_agentspec(
                 crewai_component, referenced_objects
@@ -175,6 +191,35 @@ def _llm_convert_to_agentspec(
 
         raise ValueError(f"Unsupported type of LLM in Agent Spec: {model_provider}")
 
+    def _mcp_client_convert_to_agentspec(
+        self, crewai_mcp_client: CrewAIMCPClient, referenced_objects: Dict[str, Any]
+    ) -> AgentSpecClientTransport:
+        crewai_transport = crewai_mcp_client.transport
+        server_name, server_url, _ = crewai_mcp_client._get_server_info()
+        if isinstance(crewai_transport, CrewAIStdioTransport):
+            return AgentSpecStdioTransport(
+                name=server_name,
+                command=crewai_transport.command,
+                args=crewai_transport.args,
+                env=crewai_transport.env,
+            )
+        elif isinstance(crewai_transport, CrewAIHTTPTransport):
+            return AgentSpecStreamableHTTPTransport(
+                name=server_name,
+                url=server_url or "",
+                headers=crewai_transport.headers,
+            )
+        elif isinstance(crewai_transport, CrewAISSETransport):
+            return AgentSpecSSETransport(
+                name=server_name,
+                url=server_url or "",
+                headers=crewai_transport.headers,
+            )
+
+        raise ValueError(
+            f"Transports of type {type(crewai_transport)} are not yet supported for translation to AgentSpec"
+        )
+
     def _tool_convert_to_agentspec(
         self, crewai_tool: CrewAIBaseTool, referenced_objects: Dict[str, Any]
     ) -> AgentSpecTool:
@@ -189,17 +234,35 @@ def _tool_convert_to_agentspec(
             output_json_schema = _get_return_type_json_schema_from_function_reference(
                 crewai_tool._run
             )
-        # There seem to be no counterparts for client tools and remote tools in CrewAI at the moment
-        return AgentSpecServerTool(
-            name=crewai_tool.name,
-            description=crewai_tool.description,
-            inputs=_pydantic_model_to_properties_list(crewai_tool.args_schema),
-            outputs=[AgentSpecProperty(title="result", json_schema=output_json_schema)],
-        )
+        if isinstance(crewai_tool, CrewAIMCPNativeTool):
+            return AgentSpecMCPTool(
+                name=crewai_tool.original_tool_name,
+                description=crewai_tool.description.split("Tool Description: ")[1],
+                inputs=_pydantic_model_to_properties_list(crewai_tool.args_schema),
+                outputs=[AgentSpecProperty(title="result", json_schema=output_json_schema)],
+                client_transport=cast(
+                    AgentSpecClientTransport,
+                    self.convert(
+                        crewai_tool.mcp_client,
+                        referenced_objects=referenced_objects,
+                    ),
+                ),
+            )
+        else:
+            # There seem to be no counterparts for client tools and remote tools in CrewAI at the moment
+            return AgentSpecServerTool(
+                name=crewai_tool.name,
+                description=crewai_tool.description,
+                inputs=_pydantic_model_to_properties_list(crewai_tool.args_schema),
+                outputs=[AgentSpecProperty(title="result", json_schema=output_json_schema)],
+            )
 
     def _agent_convert_to_agentspec(
         self, crewai_agent: CrewAIAgent, referenced_objects: Dict[str, Any]
     ) -> AgentSpecAgent:
+        tools = crewai_agent.tools or []
+        if crewai_agent.mcps:
+            tools += crewai_agent.get_mcp_tools(crewai_agent.mcps)
         return AgentSpecAgent(
             id=str(crewai_agent.id),
             name=crewai_agent.role,
@@ -214,6 +277,6 @@ def _agent_convert_to_agentspec(
             ),
             tools=[
                 cast(AgentSpecTool, self.convert(tool, referenced_objects=referenced_objects))
-                for tool in (crewai_agent.tools or [])
+                for tool in tools
             ],
         )

pyagentspec/src/pyagentspec/adapters/crewai/_crewaiconverter.py

@@ -13,9 +13,15 @@
 from pyagentspec.adapters.crewai._types import (
     CrewAIAgent,
     CrewAIBaseTool,
+    CrewAIHTTPTransport,
     CrewAILlm,
+    CrewAIMCPClient,
+    CrewAIMCPNativeTool,
     CrewAIServerToolType,
+    CrewAISSETransport,
+    CrewAIStdioTransport,
     CrewAITool,
+    CrewAITransport,
 )
 from pyagentspec.agent import Agent as AgentSpecAgent
 from pyagentspec.component import Component as AgentSpecComponent
@@ -26,6 +32,14 @@
 )
 from pyagentspec.llms.openaiconfig import OpenAiConfig as AgentSpecOpenAiConfig
 from pyagentspec.llms.vllmconfig import VllmConfig as AgentSpecVllmModel
+from pyagentspec.mcp.clienttransport import ClientTransport as AgentSpecClientTransport
+from pyagentspec.mcp.clienttransport import SSETransport as AgentSpecSSETransport
+from pyagentspec.mcp.clienttransport import StdioTransport as AgentSpecStdioTransport
+from pyagentspec.mcp.clienttransport import (
+    StreamableHTTPTransport as AgentSpecStreamableHTTPTransport,
+)
+from pyagentspec.mcp.tools import MCPTool as AgentSpecMCPTool
+from pyagentspec.mcp.tools import MCPToolBox as AgentSpecMCPToolBox
 from pyagentspec.property import Property as AgentSpecProperty
 from pyagentspec.property import _empty_default as _agentspec_empty_default
 from pyagentspec.tools import Tool as AgentSpecTool
@@ -108,6 +122,10 @@ def convert(
             crewai_component = self._tool_convert_to_crewai(
                 agentspec_component, tool_registry, converted_components
             )
+        elif isinstance(agentspec_component, AgentSpecClientTransport):
+            crewai_component = self._client_transport_convert_to_crewai(
+                agentspec_component, tool_registry, converted_components
+            )
         elif isinstance(agentspec_component, AgentSpecComponent):
             raise NotImplementedError(
                 f"The AgentSpec Component type '{agentspec_component.__class__.__name__}' is not yet supported "
@@ -212,6 +230,14 @@ def client_tool(**kwargs: Any) -> Any:
             )
         elif isinstance(agentspec_tool, AgentSpecRemoteTool):
             return self._remote_tool_convert_to_crewai(agentspec_tool)
+        elif isinstance(agentspec_tool, AgentSpecMCPTool):
+            return self._mcp_tool_convert_to_crewai(
+                agentspec_tool, tool_registry, converted_components
+            )
+        elif isinstance(agentspec_tool, AgentSpecMCPToolBox):
+            raise NotImplementedError(
+                "Conversion of AgentSpec MCPToolBox objects is not yet implemented"
+            )
         raise ValueError(
             f"Tools of type {type(agentspec_tool)} are not yet supported for translation to CrewAI"
         )
@@ -246,6 +272,57 @@ def _remote_tool(**kwargs: Any) -> Any:
             func=_remote_tool,
         )
 
+    def _mcp_tool_convert_to_crewai(
+        self,
+        mcp_tool: AgentSpecMCPTool,
+        tool_registry: Dict[str, CrewAIServerToolType],
+        converted_components: Optional[Dict[str, Any]] = None,
+    ) -> CrewAIMCPNativeTool:
+        return CrewAIMCPNativeTool(
+            mcp_client=self.convert(mcp_tool.client_transport, tool_registry, converted_components),
+            tool_name=mcp_tool.name,
+            tool_schema={
+                "description": mcp_tool.description or "",
+                "args_schema": _create_pydantic_model_from_properties(
+                    mcp_tool.name.title() + "InputSchema", mcp_tool.inputs or []
+                ),
+            },
+            server_name=mcp_tool.client_transport.name,
+        )
+
+    def _client_transport_convert_to_crewai(
+        self,
+        agentspec_transport: AgentSpecClientTransport,
+        tool_registry: Dict[str, CrewAIServerToolType],
+        converted_components: Optional[Dict[str, Any]] = None,
+    ) -> CrewAIMCPClient:
+        transport: Optional[CrewAITransport] = None
+        if isinstance(agentspec_transport, AgentSpecStdioTransport):
+            transport = CrewAIStdioTransport(
+                command=agentspec_transport.command,
+                args=agentspec_transport.args,
+                env=agentspec_transport.env,
+            )
+        elif isinstance(agentspec_transport, AgentSpecSSETransport):
+            transport = CrewAISSETransport(
+                url=agentspec_transport.url,
+                headers=agentspec_transport.headers,
+            )
+        elif isinstance(agentspec_transport, AgentSpecStreamableHTTPTransport):
+            transport = CrewAIHTTPTransport(
+                url=agentspec_transport.url,
+                headers=agentspec_transport.headers,
+                streamable=True,
+            )
+        else:
+            raise ValueError(
+                f"Transports of type {type(agentspec_transport)} are not yet supported for translation to CrewAI"
+            )
+        return CrewAIMCPClient(
+            transport=transport,
+            cache_tools_list=True,
+        )
+
     def _agent_convert_to_crewai(
         self,
         agentspec_agent: AgentSpecAgent,

pyagentspec/src/pyagentspec/adapters/crewai/_types.py

@@ -16,17 +16,29 @@
     from crewai import LLM as CrewAILlm
     from crewai import Agent as CrewAIAgent
     from crewai import Flow as CrewAIFlow
+    from crewai.mcp.client import MCPClient as CrewAIMCPClient
+    from crewai.mcp.transports import BaseTransport as CrewAITransport
+    from crewai.mcp.transports import HTTPTransport as CrewAIHTTPTransport
+    from crewai.mcp.transports import SSETransport as CrewAISSETransport
+    from crewai.mcp.transports import StdioTransport as CrewAIStdioTransport
     from crewai.tools import BaseTool as CrewAIBaseTool
     from crewai.tools.base_tool import Tool as CrewAITool
+    from crewai.tools.mcp_native_tool import MCPNativeTool as CrewAIMCPNativeTool
     from crewai.tools.structured_tool import CrewStructuredTool as CrewAIStructuredTool
 else:
     crewai = LazyLoader("crewai")
     # We need to import the classes this way because it's the only one accepted by the lazy loader
     CrewAILlm = crewai.LLM
     CrewAIAgent = crewai.Agent
     CrewAIFlow = crewai.Flow
+    CrewAIMCPClient = crewai.mcp.client.MCPClient
+    CrewAITransport = crewai.mcp.transports.BaseTransport
+    CrewAIHTTPTransport = crewai.mcp.transports.HTTPTransport
+    CrewAISSETransport = crewai.mcp.transports.SSETransport
+    CrewAIStdioTransport = crewai.mcp.transports.StdioTransport
     CrewAIBaseTool = LazyLoader("crewai.tools").BaseTool
     CrewAITool = LazyLoader("crewai.tools.base_tool").Tool
+    CrewAIMCPNativeTool = LazyLoader("crewai.tools.mcp_native_tool").MCPNativeTool
     CrewAIStructuredTool = LazyLoader("crewai.tools.structured_tool").CrewStructuredTool
 
 CrewAIComponent = Union[CrewAIAgent, CrewAIFlow[Any]]
@@ -36,9 +48,15 @@
     "CrewAILlm",
     "CrewAIAgent",
     "CrewAIFlow",
+    "CrewAIMCPClient",
+    "CrewAITransport",
+    "CrewAIHTTPTransport",
+    "CrewAISSETransport",
+    "CrewAIStdioTransport",
     "CrewAIBaseTool",
     "CrewAITool",
     "CrewAIStructuredTool",
     "CrewAIComponent",
+    "CrewAIMCPNativeTool",
     "CrewAIServerToolType",
 ]