mcp-use 1.3.13__py3-none-any.whl → 1.4.0__py3-none-any.whl

mcp_use/agents/adapters/__init__.py

@@ -4,7 +4,14 @@ Adapters for converting MCP tools to different frameworks.
 This package provides adapters for converting MCP tools to different frameworks.
 """
 
+from .anthropic import AnthropicMCPAdapter
 from .base import BaseAdapter
 from .langchain_adapter import LangChainAdapter
+from .openai import OpenAIMCPAdapter
 
-__all__ = ["BaseAdapter", "LangChainAdapter"]
+try:
+    from .google import GoogleMCPAdapter
+
+    __all__ = ["BaseAdapter", "LangChainAdapter", "OpenAIMCPAdapter", "AnthropicMCPAdapter", "GoogleMCPAdapter"]
+except ImportError:
+    __all__ = ["BaseAdapter", "LangChainAdapter", "OpenAIMCPAdapter", "AnthropicMCPAdapter"]

mcp_use/agents/adapters/anthropic.py

@@ -0,0 +1,93 @@
+import re
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from mcp.types import Prompt, Resource, Tool
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.client.connectors.base import BaseConnector
+
+
+def _sanitize_for_tool_name(name: str) -> str:
+    """Sanitizes a string to be a valid tool name for Anthropic."""
+    # Anthropic tool names can only contain a-z, A-Z, 0-9, and underscores,
+    # and must be 64 characters or less.
+    return re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_")[:64]
+
+
+class AnthropicMCPAdapter(BaseAdapter):
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new Anthropic adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        super().__init__(disallowed_tools)
+        # This map stores the actual async function to call for each tool.
+        self.tool_executors: dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
+
+        self._connector_tool_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+
+        self.tools: list[dict[str, Any]] = []
+        self.resources: list[dict[str, Any]] = []
+        self.prompts: list[dict[str, Any]] = []
+
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP tool to the Anthropic tool format."""
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_tool.name] = (
+            lambda connector=connector, name=mcp_tool.name, **kwargs: connector.call_tool(name, kwargs)
+        )
+
+        fixed_schema = self.fix_schema(mcp_tool.inputSchema)
+        return {"name": mcp_tool.name, "description": mcp_tool.description, "input_schema": fixed_schema}
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP resource to a readable tool in Anthropic format."""
+        tool_name = _sanitize_for_tool_name(f"resource_{mcp_resource.name}")
+
+        if tool_name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[tool_name] = (
+            lambda connector=connector, uri=mcp_resource.uri, **kwargs: connector.read_resource(uri)
+        )
+
+        return {
+            "name": tool_name,
+            "description": mcp_resource.description,
+            "input_schema": {"type": "object", "properties": {}},
+        }
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP prompt to a usable tool in Anthropic format."""
+        if mcp_prompt.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_prompt.name] = (
+            lambda connector=connector, name=mcp_prompt.name, **kwargs: connector.get_prompt(name, kwargs)
+        )
+
+        properties = {}
+        required_args = []
+        if mcp_prompt.arguments:
+            for arg in mcp_prompt.arguments:
+                prop = {"type": "string"}
+                if arg.description:
+                    prop["description"] = arg.description
+                properties[arg.name] = prop
+                if arg.required:
+                    required_args.append(arg.name)
+        parameters_schema = {"type": "object", "properties": properties}
+        if required_args:
+            parameters_schema["required"] = required_args
+
+        return {
+            "name": mcp_prompt.name,
+            "description": mcp_prompt.description,
+            "input_schema": parameters_schema,
+        }

mcp_use/agents/adapters/base.py

@@ -5,7 +5,7 @@ This module provides the abstract base class that all MCP tool adapters should i
 """
 
 from abc import ABC, abstractmethod
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from mcp.types import Prompt, Resource, Tool
 
@@ -32,43 +32,118 @@ class BaseAdapter(ABC):
             disallowed_tools: list of tool names that should not be available.
         """
         self.disallowed_tools = disallowed_tools or []
+
+        # Three maps to optimize and cache only what is needed
         self._connector_tool_map: dict[BaseConnector, list[T]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[T]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[T]] = {}
 
-    @telemetry("adapter_create_tools")
-    async def create_tools(self, client: "MCPClient") -> list[T]:
-        """Create tools from an MCPClient instance.
+        self.tools: list[T] = []
+        self.resources: list[T] = []
+        self.prompts: list[T] = []
 
-        This is the recommended way to create tools from an MCPClient, as it handles
-        session creation and connector extraction automatically.
+    def parse_result(self, tool_result: Any) -> str:
+        """Parse the result from any MCP operation (tool, resource, or prompt) into a string.
 
         Args:
-            client: The MCPClient to extract tools from.
+            tool_result: The result object from an MCP operation.
 
         Returns:
-            A list of tools in the target framework's format.
+            A string representation of the result content.
+        """
+        if getattr(tool_result, "isError", False):
+            # Handle errors first
+            error_content = tool_result.content or "Unknown error"
+            return f"Error: {error_content}"
+        elif hasattr(tool_result, "contents"):  # For Resources (ReadResourceResult)
+            return "\n".join(c.decode() if isinstance(c, bytes) else str(c) for c in tool_result.contents)
+        elif hasattr(tool_result, "messages"):  # For Prompts (GetPromptResult)
+            return "\n".join(str(s) for s in tool_result.messages)
+        elif hasattr(tool_result, "content"):  # For Tools (CallToolResult)
+            return str(tool_result.content)
+        else:
+            # Fallback for unexpected types
+            return str(tool_result)
+
+    @telemetry("adapter_fix_schema")
+    def fix_schema(self, schema: dict) -> dict:
+        """Convert JSON Schema 'type': ['string', 'null'] to 'anyOf' format and fix enum handling.
 
-        Example:
-            ```python
-            from mcp_use.client import MCPClient
-            from mcp_use.adapters import YourAdapter
+        Args:
+            schema: The JSON schema to fix.
 
-            client = MCPClient.from_config_file("config.json")
-            tools = await YourAdapter.create_tools(client)
-            ```
+        Returns:
+            The fixed JSON schema.
         """
-        # Ensure we have active sessions
+        if isinstance(schema, dict):
+            if "type" in schema and isinstance(schema["type"], list):
+                schema["anyOf"] = [{"type": t} for t in schema["type"]]
+                del schema["type"]  # Remove 'type' and standardize to 'anyOf'
+
+            # Fix enum handling - ensure enum fields are properly typed as strings
+            if "enum" in schema and "type" not in schema:
+                schema["type"] = "string"
+
+            for key, value in schema.items():
+                schema[key] = self.fix_schema(value)  # Apply recursively
+        return schema
+
+    async def _get_connectors(self, client: MCPClient) -> list[BaseConnector]:
+        """Get all connectors from the client, creating sessions if needed."""
         if not client.active_sessions:
             logger.info("No active sessions found, creating new ones...")
             await client.create_all_sessions()
 
-        # Get all active sessions
         sessions = client.get_all_active_sessions()
+        return [session.connector for session in sessions.values()]
+
+    async def create_all(self, client: MCPClient) -> None:
+        """Create tools, resources, and prompts from an MCPClient instance."""
+        await self.create_tools(client)
+        await self.create_resources(client)
+        await self.create_prompts(client)
 
-        # Extract connectors from sessions
-        connectors = [session.connector for session in sessions.values()]
+    async def create_tools(self, client: MCPClient) -> list[T]:
+        """Create tools from the MCPClient instance.
 
-        # Create tools from connectors
-        return await self._create_tools_from_connectors(connectors)
+        This handles session creation and connector extraction automatically.
+        The created tools are stored in `self.tools`.
+
+        Returns:
+            A list of tools in the target framework's format.
+        """
+        connectors = await self._get_connectors(client)
+        self.tools = await self._create_tools_from_connectors(connectors)
+
+        return self.tools
+
+    async def create_resources(self, client: MCPClient) -> list[T]:
+        """Create resources from the MCPClient instance.
+
+        This handles session creation and connector extraction automatically.
+        The created resources are stored in `self.resources`.
+
+        Returns:
+            A list of resources in the target framework's format.
+        """
+        connectors = await self._get_connectors(client)
+        self.resources = await self._create_resources_from_connectors(connectors)
+
+        return self.resources
+
+    async def create_prompts(self, client: MCPClient) -> list[T]:
+        """Create prompts from the MCPClient instance.
+
+        This handles session creation and connector extraction automatically.
+        The created prompts are stored in `self.prompts`.
+
+        Returns:
+            A list of prompts in the target framework's format.
+        """
+        connectors = await self._get_connectors(client)
+        self.prompts = await self._create_prompts_from_connectors(connectors)
+
+        return self.prompts
 
     @telemetry("adapter_load_tools")
     async def load_tools_for_connector(self, connector: BaseConnector) -> list[T]:
@@ -85,38 +160,15 @@ class BaseAdapter(ABC):
             logger.debug(f"Returning {len(self._connector_tool_map[connector])} existing tools for connector")
             return self._connector_tool_map[connector]
 
-        # Create tools for this connector
-
-        # Make sure the connector is initialized and has tools
-        success = await self._ensure_connector_initialized(connector)
-        if not success:
+        if not await self._ensure_connector_initialized(connector):
             return []
 
         connector_tools = []
-        # Now create tools for each MCP tool
         for tool in await connector.list_tools():
-            # Convert the tool and add it to the list if conversion was successful
             converted_tool = self._convert_tool(tool, connector)
             if converted_tool:
                 connector_tools.append(converted_tool)
 
-        # Convert resources to tools so that agents can access resource content directly
-        resources_list = await connector.list_resources() or []
-        if resources_list:
-            for resource in resources_list:
-                converted_resource = self._convert_resource(resource, connector)
-                if converted_resource:
-                    connector_tools.append(converted_resource)
-
-        # Convert prompts to tools so that agents can retrieve prompt content
-        prompts_list = await connector.list_prompts() or []
-        if prompts_list:
-            for prompt in prompts_list:
-                converted_prompt = self._convert_prompt(prompt, connector)
-                if converted_prompt:
-                    connector_tools.append(converted_prompt)
-        # ------------------------------
-
         # Store the tools for this connector
         self._connector_tool_map[connector] = connector_tools
 
@@ -128,6 +180,66 @@ class BaseAdapter(ABC):
 
         return connector_tools
 
+    @telemetry("adapter_load_resources")
+    async def load_resources_for_connector(self, connector: BaseConnector):
+        """Dynamically load resources for a specific connector.
+
+        Args:
+            connector: The connector to load resources for.
+
+        Returns:
+            The list of resources that were loaded in the target framework's format.
+        """
+        if connector in self._connector_resource_map:
+            logger.debug(f"Returning {len(self._connector_resource_map[connector])} existing resources for connector")
+            return self._connector_resource_map[connector]
+
+        if not await self._ensure_connector_initialized(connector):
+            return []
+
+        connector_resources = []
+        for resource in await connector.list_resources() or []:
+            converted_resource = self._convert_resource(resource, connector)
+            if converted_resource:
+                connector_resources.append(converted_resource)
+
+        self._connector_resource_map[connector] = connector_resources
+        logger.debug(
+            f"Loaded {len(connector_resources)} new resources for connector: "
+            f"{[getattr(r, 'name', str(r)) for r in connector_resources]}"
+        )
+        return connector_resources
+
+    @telemetry("adapter_load_prompts")
+    async def load_prompts_for_connector(self, connector: BaseConnector) -> list[T]:
+        """Dynamically load prompts for a specific connector.
+
+        Args:
+            connector: The connector to load prompts for.
+
+        Returns:
+            The list of prompts that were loaded in the target framework's format.
+        """
+        if connector in self._connector_prompt_map:
+            logger.debug(f"Returning {len(self._connector_prompt_map[connector])} existing prompts for connector")
+            return self._connector_prompt_map[connector]
+
+        if not await self._ensure_connector_initialized(connector):
+            return []
+
+        connector_prompts = []
+        for prompt in await connector.list_prompts() or []:
+            converted_prompt = self._convert_prompt(prompt, connector)
+            if converted_prompt:
+                connector_prompts.append(converted_prompt)
+
+        self._connector_prompt_map[connector] = connector_prompts
+        logger.debug(
+            f"Loaded {len(connector_prompts)} new prompts for connector: "
+            f"{[getattr(p, 'name', str(p)) for p in connector_prompts]}"
+        )
+        return connector_prompts
+
     @abstractmethod
     def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> T:
         """Convert an MCP tool to the target framework's tool format."""
@@ -144,24 +256,35 @@ class BaseAdapter(ABC):
         pass
 
     async def _create_tools_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:
-        """Create tools from MCP tools in all provided connectors.
-
-        Args:
-            connectors: list of MCP connectors to create tools from.
-
-        Returns:
-            A list of tools in the target framework's format.
-        """
+        """Create tools from MCP tools in all provided connectors."""
         tools = []
         for connector in connectors:
-            # Create tools for this connector
             connector_tools = await self.load_tools_for_connector(connector)
             tools.extend(connector_tools)
 
-        # Log available tools for debugging
         logger.debug(f"Available tools: {len(tools)}")
         return tools
 
+    async def _create_resources_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:
+        """Create resources from MCP resources in all provided connectors."""
+        resources = []
+        for connector in connectors:
+            connector_resources = await self.load_resources_for_connector(connector)
+            resources.extend(connector_resources)
+
+        logger.debug(f"Available resources: {len(resources)}")
+        return resources
+
+    async def _create_prompts_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:
+        """Create prompts from MCP prompts in all provided connectors."""
+        prompts = []
+        for connector in connectors:
+            connector_prompts = await self.load_prompts_for_connector(connector)
+            prompts.extend(connector_prompts)
+
+        logger.debug(f"Available prompts: {len(prompts)}")
+        return prompts
+
     def _check_connector_initialized(self, connector: BaseConnector) -> bool:
         """Check if a connector is initialized and has tools.
 

mcp_use/agents/adapters/google.py

@@ -0,0 +1,103 @@
+import re
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from mcp.types import Prompt, Resource, Tool
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.client.connectors.base import BaseConnector
+
+try:
+    from google.genai import types
+except ImportError as e:
+    raise ImportError(
+        "google-genai is required for GoogleMCPAdapter. Install it with: uv pip install google-genai"
+    ) from e
+
+
+def _sanitize_for_tool_name(name: str) -> str:
+    """Sanitizes a string to be a valid tool name for Google."""
+    # Google tool names can only contain a-z, A-Z, 0-9, and underscores,
+    # and must be 64 characters or less.
+    return re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_")[:64]
+
+
+class GoogleMCPAdapter(BaseAdapter):
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new Google adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        super().__init__(disallowed_tools)
+        # This map stores the actual async function to call for each tool.
+        self.tool_executors: dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
+
+        self._connector_tool_map: dict[BaseConnector, list[types.FunctionDeclaration]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[types.FunctionDeclaration]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[types.FunctionDeclaration]] = {}
+
+        self.tools: list[types.FunctionDeclaration] = []
+        self.resources: list[types.FunctionDeclaration] = []
+        self.prompts: list[types.FunctionDeclaration] = []
+
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> types.FunctionDeclaration:
+        """Convert an MCP tool to the Google tool format."""
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_tool.name] = (
+            lambda connector=connector, name=mcp_tool.name, **kwargs: connector.call_tool(name, kwargs)
+        )
+
+        fixed_schema = self.fix_schema(mcp_tool.inputSchema)
+        function_declaration = types.FunctionDeclaration(
+            name=mcp_tool.name, description=mcp_tool.description, parameters_json_schema=fixed_schema
+        )
+        return function_declaration
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> types.FunctionDeclaration:
+        """Convert an MCP resource to a readable tool in Google format."""
+        tool_name = _sanitize_for_tool_name(f"resource_{mcp_resource.name}")
+
+        if tool_name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[tool_name] = (
+            lambda connector=connector, uri=mcp_resource.uri, **kwargs: connector.read_resource(uri)
+        )
+
+        function_declaration = types.FunctionDeclaration(
+            name=tool_name,
+            description=mcp_resource.description,
+            parameters_json_schema={"input_schema": {"type": "object", "properties": {}}},
+        )
+        return function_declaration
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> types.FunctionDeclaration:
+        """Convert an MCP prompt to a usable tool in Google format."""
+        if mcp_prompt.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_prompt.name] = (
+            lambda connector=connector, name=mcp_prompt.name, **kwargs: connector.get_prompt(name, kwargs)
+        )
+
+        properties = {}
+        required_args = []
+        if mcp_prompt.arguments:
+            for arg in mcp_prompt.arguments:
+                prop = {"type": "string"}
+                if arg.description:
+                    prop["description"] = arg.description
+                properties[arg.name] = prop
+                if arg.required:
+                    required_args.append(arg.name)
+        parameters_schema = {"type": "object", "properties": properties}
+        if required_args:
+            parameters_schema["required"] = required_args
+
+        function_declaration = types.FunctionDeclaration(
+            name=mcp_prompt.name, description=mcp_prompt.description, parameters_json_schema=parameters_schema
+        )
+        return function_declaration

mcp_use/agents/adapters/langchain_adapter.py

@@ -35,29 +35,12 @@ class LangChainAdapter(BaseAdapter):
         """
         super().__init__(disallowed_tools)
         self._connector_tool_map: dict[BaseConnector, list[BaseTool]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[BaseTool]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[BaseTool]] = {}
 
-    @telemetry("adapter_fix_schema")
-    def fix_schema(self, schema: dict) -> dict:
-        """Convert JSON Schema 'type': ['string', 'null'] to 'anyOf' format and fix enum handling.
-
-        Args:
-            schema: The JSON schema to fix.
-
-        Returns:
-            The fixed JSON schema.
-        """
-        if isinstance(schema, dict):
-            if "type" in schema and isinstance(schema["type"], list):
-                schema["anyOf"] = [{"type": t} for t in schema["type"]]
-                del schema["type"]  # Remove 'type' and standardize to 'anyOf'
-
-            # Fix enum handling - ensure enum fields are properly typed as strings
-            if "enum" in schema and "type" not in schema:
-                schema["type"] = "string"
-
-            for key, value in schema.items():
-                schema[key] = self.fix_schema(value)  # Apply recursively
-        return schema
+        self.tools: list[BaseTool] = []
+        self.resources: list[BaseTool] = []
+        self.prompts: list[BaseTool] = []
 
     @telemetry("adapter_convert_tool")
     def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> BaseTool:
@@ -116,6 +99,7 @@ class LangChainAdapter(BaseAdapter):
                 try:
                     tool_result: CallToolResult = await self.tool_connector.call_tool(self.name, kwargs)
                     try:
+                        # Use the helper function to parse the result
                         return str(tool_result.content)
                     except Exception as e:
                         # Log the exception for debugging

mcp_use/agents/adapters/openai.py

@@ -0,0 +1,111 @@
+import re
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from mcp.types import Prompt, Resource, Tool
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.client.connectors.base import BaseConnector
+
+
+def _sanitize_for_tool_name(name: str) -> str:
+    """Sanitizes a string to be a valid tool name for OpenAI."""
+    # OpenAI tool names can only contain a-z, A-Z, 0-9, and underscores,
+    # and must be 64 characters or less.
+    return re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_")[:64]
+
+
+class OpenAIMCPAdapter(BaseAdapter):
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new OpenAI adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        super().__init__(disallowed_tools)
+        # This map stores the actual async function to call for each tool.
+        self.tool_executors: dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
+
+        self._connector_tool_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+
+        self.tools: list[dict[str, Any]] = []
+        self.resources: list[dict[str, Any]] = []
+        self.prompts: list[dict[str, Any]] = []
+
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP tool to the OpenAI tool format."""
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_tool.name] = (
+            lambda connector=connector, name=mcp_tool.name, **kwargs: connector.call_tool(name, kwargs)
+        )
+
+        fixed_schema = self.fix_schema(mcp_tool.inputSchema)
+        return {
+            "type": "function",
+            "function": {
+                "name": mcp_tool.name,
+                "description": mcp_tool.description,
+                "parameters": fixed_schema,
+            },
+        }
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP resource to a readable tool in OpenAI format."""
+        # Sanitize the name to be a valid function name for OpenAI
+        tool_name = _sanitize_for_tool_name(f"resource_{mcp_resource.name}")
+
+        if tool_name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[tool_name] = (
+            lambda connector=connector, uri=mcp_resource.uri, **kwargs: connector.read_resource(uri)
+        )
+
+        mcp_resource_desc = mcp_resource.description
+        return {
+            "type": "function",
+            "function": {
+                "name": tool_name,
+                "description": mcp_resource_desc,
+                # They take no arguments
+                "parameters": {"type": "object", "properties": {}},
+            },
+        }
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP prompt to a usable tool in OpenAI format."""
+        if mcp_prompt.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_prompt.name] = (
+            lambda connector=connector, name=mcp_prompt.name, **kwargs: connector.get_prompt(name, kwargs)
+        )
+
+        # Preparing JSON schema for prompt arguments
+        properties = {}
+        required_args = []
+        if mcp_prompt.arguments:
+            for arg in mcp_prompt.arguments:
+                prop = {"type": "string"}
+                if arg.description:
+                    prop["description"] = arg.description
+                properties[arg.name] = prop
+                if arg.required:
+                    required_args.append(arg.name)
+
+        parameters_schema = {"type": "object", "properties": properties}
+        if required_args:
+            parameters_schema["required"] = required_args
+
+        return {
+            "type": "function",
+            "function": {
+                "name": mcp_prompt.name,
+                "description": mcp_prompt.description,
+                "parameters": parameters_schema,
+            },
+        }