mirascope 1.21.6__py3-none-any.whl → 1.22.0__py3-none-any.whl

mirascope/llm/__init__.py

@@ -4,6 +4,7 @@ from ._context import context
 from ._override import override
 from .call_response import CallResponse
 from .stream import Stream
+from .tool import Tool
 
 __all__ = [
     "CallResponse",
@@ -11,6 +12,7 @@ __all__ = [
     "LocalProvider",
     "Provider",
     "Stream",
+    "Tool",
     "calculate_cost",
     "call",
     "context",

mirascope/mcp/__init__.py

@@ -1,6 +1,7 @@
 """Mirascope Model Context Protocol (MCP) implementation."""
 
-from .server import MCPServer
-from .tools import MCPTool
+from .client import MCPClient, sse_client, stdio_client
+from .server import MCPServer  # DEPRECATED
+from .tools import MCPTool  # DEPRECATED
 
-__all__ = ["MCPServer", "MCPTool"]
+__all__ = ["MCPClient", "MCPServer", "MCPTool", "sse_client", "stdio_client"]

mirascope/mcp/_utils.py

@@ -0,0 +1,277 @@
+"""MCP client utility functions."""
+
+import base64
+import string
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from contextlib import asynccontextmanager
+from typing import Any
+
+from anyio import create_memory_object_stream, create_task_group
+from anyio.streams.memory import MemoryObjectReceiveStream
+from mcp.types import (
+    EmbeddedResource,
+    ImageContent,
+    JSONRPCMessage,
+    PromptMessage,
+    TextContent,
+    TextResourceContents,
+)
+from mcp.types import Tool as MCPTool
+from pydantic import BaseModel, ConfigDict, Field, create_model
+
+from ..core import BaseMessageParam, BaseTool
+from ..core.base import AudioPart, DocumentPart, ImagePart
+
+
+def create_tool_call(
+    name: str,
+    call_tool: Callable[[str, dict | None], Awaitable[Any]],
+) -> Callable[..., Awaitable[list[str | ImageContent | EmbeddedResource]]]:
+    """Create a tool call function for a Mirascope Tool.
+
+    Args:
+        name: The name of the tool
+        call_tool: The function to call the tool
+
+    Returns:
+        A function that can be used as the call method for a Tool
+    """
+
+    async def call(self: BaseTool) -> list[str | ImageContent | EmbeddedResource]:
+        result = await call_tool(name, self.args)  # pyright: ignore [reportOptionalCall]
+        if result.isError:
+            raise RuntimeError(f"MCP Server returned error: {self._name()}")
+        return [
+            content.text if isinstance(content, TextContent) else content
+            for content in result.content
+        ]
+
+    return call
+
+
+def convert_prompt_message_to_base_message_params(
+    prompt_message: PromptMessage,
+) -> BaseMessageParam:
+    """
+    Convert a single PromptMessage back into a BaseMessageParam.
+
+    Args:
+        prompt_message: A PromptMessage instance.
+
+    Returns:
+        A BaseMessageParam instance representing the given prompt_message.
+
+    Raises:
+        ValueError: If the role is invalid or if the content type is unsupported.
+    """
+
+    # Validate role
+    if prompt_message.role not in ["user", "assistant"]:
+        raise ValueError(f"invalid role: {prompt_message.role}")
+
+    content = prompt_message.content
+
+    # Handle TextContent
+    if isinstance(content, TextContent):
+        # If it's text, we can just return a single string
+        return BaseMessageParam(role=prompt_message.role, content=content.text)
+
+    # Handle ImageContent
+    elif isinstance(content, ImageContent):
+        decoded_image = base64.b64decode(content.data)
+
+        image_part = ImagePart(
+            type="image",
+            image=decoded_image,
+            media_type=content.mimeType,
+            detail=None,  # detail not provided by PromptMessage
+        )
+        return BaseMessageParam(role=prompt_message.role, content=[image_part])
+
+    elif isinstance(content, EmbeddedResource):
+        resource = content.resource
+        if isinstance(resource, TextResourceContents):
+            # For text content embedded resources, just return the text
+            return BaseMessageParam(role=prompt_message.role, content=resource.text)
+        else:
+            mime_type = resource.mimeType
+            if not mime_type:
+                raise ValueError(
+                    "BlobResourceContents has no mimeType, cannot determine content type."
+                )
+
+            decoded_data = base64.b64decode(resource.blob)
+
+            if mime_type.startswith("image/"):
+                # Treat as ImagePart
+                image_part = ImagePart(
+                    type="image",
+                    image=decoded_data,
+                    media_type=mime_type,
+                    detail=None,
+                )
+                return BaseMessageParam(role=prompt_message.role, content=[image_part])
+            elif mime_type == "application/pdf":
+                doc_part = DocumentPart(
+                    type="document", media_type=mime_type, document=decoded_data
+                )
+                return BaseMessageParam(role=prompt_message.role, content=[doc_part])
+            elif mime_type.startswith("audio/"):
+                # Treat as AudioPart
+                audio_part = AudioPart(
+                    type="audio", media_type=mime_type, audio=decoded_data
+                )
+                return BaseMessageParam(role=prompt_message.role, content=[audio_part])
+            else:
+                raise ValueError(f"Unsupported mime type: {mime_type}")
+
+    else:
+        raise ValueError(f"Unsupported content type: {type(content)}")
+
+
+def snake_to_pascal(snake: str) -> str:
+    """Convert a snake_case string to PascalCase.
+
+    Args:
+        snake: A snake_case string
+
+    Returns:
+        The string converted to PascalCase
+    """
+    return string.capwords(snake.replace("_", " ")).replace(" ", "")
+
+
+def build_object_type(
+    properties: dict[str, Any], required: list[str], name: str
+) -> type[BaseModel]:
+    """Build a Pydantic model from JSON Schema properties.
+
+    Args:
+        properties: JSON Schema properties dictionary
+        required: List of required property names
+        name: Name for the generated model
+
+    Returns:
+        A dynamically created Pydantic model class
+    """
+    fields = {}
+    for prop_name, prop_schema in properties.items():
+        class_name = snake_to_pascal(prop_name)
+        type_ = json_schema_to_python_type(prop_schema, class_name)
+        if prop_name in required:
+            fields[prop_name] = (
+                type_,
+                Field(..., description=prop_schema.get("description")),
+            )
+        else:
+            fields[prop_name] = (
+                type_ | None,
+                Field(None, description=prop_schema.get("description")),
+            )
+
+    return create_model(name, __config__=ConfigDict(extra="allow"), **fields)
+
+
+def json_schema_to_python_type(schema: dict[str, Any], name: str = "Model") -> Any:  # noqa: ANN401
+    """
+    Recursively convert a JSON Schema snippet into a Python type annotation or a dynamically generated pydantic model.
+
+    Args:
+        schema: JSON Schema to convert
+        name: Name for any generated models
+
+    Returns:
+        Corresponding Python type or Pydantic model
+    """
+    json_type = schema.get("type", "any")
+
+    if json_type == "string":
+        return str
+    elif json_type == "number":
+        return float
+    elif json_type == "integer":
+        return int
+    elif json_type == "boolean":
+        return bool
+    elif json_type == "array":
+        # Recursively determine the items type for arrays
+        items_schema = schema.get("items", {})
+        items_type = json_schema_to_python_type(items_schema)
+        return list[items_type]
+    elif json_type == "object":
+        # Recursively build a dynamic model for objects
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+        return build_object_type(properties, required, name)
+    else:
+        # Default fallback
+        return Any
+
+
+def create_tool_from_mcp_tool(tool: MCPTool) -> type[BaseTool]:
+    """
+    Create a `BaseTool` type definition from the given MCP Tool instance.
+
+    Args:
+        tool: MCP tool instance.
+
+    Returns:
+        A dynamically created `Tool` schema.
+    """
+    schema = tool.inputSchema
+    properties = schema.get("properties", {})
+    required_fields = schema.get("required", [])
+
+    fields = {}
+    for field_name, field_schema in properties.items():
+        field_type = json_schema_to_python_type(field_schema)
+
+        if field_name in required_fields:
+            default = Field(..., description=field_schema.get("description"))
+            annotation = field_type
+        else:
+            default = Field(None, description=field_schema.get("description"))
+            annotation = field_type | None
+
+        fields[field_name] = (annotation, default)
+
+    return create_model(snake_to_pascal(tool.name), __base__=BaseTool, **fields)
+
+
+@asynccontextmanager
+async def read_stream_exception_filer(
+    original_read: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+    exception_handler: Callable[[Exception], None] | None = None,
+) -> AsyncGenerator[MemoryObjectReceiveStream[JSONRPCMessage], None]:
+    """
+    Handle exceptions in the original stream.
+    Default handler is to ignore read stream exception for invalid JSON lines and log them.
+
+    Args:
+        original_read: The original stream to read from.
+        exception_handler: An optional handler for exception.
+
+    Yields:
+        A filtered stream with exceptions removed
+    """
+    read_stream_writer, filtered_read = create_memory_object_stream(0)
+
+    async def task() -> None:
+        try:
+            async with original_read:
+                async for msg in original_read:
+                    if isinstance(msg, Exception):
+                        if exception_handler:
+                            exception_handler(msg)
+                        continue
+                    await read_stream_writer.send(msg)
+        finally:
+            await read_stream_writer.aclose()
+
+    async with create_task_group() as tg:
+        tg.start_soon(task)
+        try:
+            yield filtered_read
+        finally:
+            await filtered_read.aclose()
+            tg.cancel_scope.cancel()

mirascope/mcp/client.py

@@ -1,305 +1,151 @@
-import base64
-import string
-from collections.abc import AsyncGenerator, Awaitable, Callable
-from contextlib import asynccontextmanager
-from typing import Any, TypeVar
-
-from anyio import create_memory_object_stream, create_task_group
-from anyio.streams.memory import MemoryObjectReceiveStream
+"""The `MCPServer` Class and context managers."""
+
+import contextlib
+from collections.abc import AsyncIterator, Awaitable, Callable
+from datetime import timedelta
+from typing import Any
+
 from mcp import ClientSession
-from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.client.session import ListRootsFnT, SamplingFnT
+from mcp.client.sse import sse_client as mcp_sse_client
+from mcp.client.stdio import StdioServerParameters
+from mcp.client.stdio import stdio_client as mcp_stdio_client
 from mcp.types import (
     BlobResourceContents,
-    CallToolResult,
-    EmbeddedResource,
-    ImageContent,
-    JSONRPCMessage,
-    Prompt,
-    PromptMessage,
     Resource,
-    TextContent,
-    TextResourceContents,
-    Tool,
 )
-from pydantic import AnyUrl, BaseModel, ConfigDict, Field, create_model
-
-from mirascope.core import BaseMessageParam, BaseTool
-from mirascope.core.base import AudioPart, DocumentPart, ImagePart
-
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-
-
-def _create_tool_call(
-    name: str,
-    call_tool: Callable[[str, dict | None], Awaitable[CallToolResult]],
-) -> Callable[..., Awaitable[list[str | ImageContent | EmbeddedResource]]]:
-    async def call(self: BaseTool) -> list[str | ImageContent | EmbeddedResource]:
-        result = await call_tool(name, self.args)  # pyright: ignore [reportOptionalCall]
-        if result.isError:
-            raise RuntimeError(f"MCP Server returned error: {self._name()}")
-        parsed_results = []
-        for content in result.content:
-            if isinstance(content, TextContent):
-                parsed_results.append(content.text)
-            else:
-                parsed_results.append(content)
-        return [
-            content.text if isinstance(content, TextContent) else content
-            for content in result.content
-        ]
+from pydantic import AnyUrl
 
-    return call
-
-
-def _convert_prompt_message_to_base_message_params(
-    prompt_message: PromptMessage,
-) -> BaseMessageParam:
-    """
-    Convert a single PromptMessage back into a BaseMessageParam.
+from mirascope.core import BaseMessageParam, BaseTool, TextPart
+from mirascope.mcp import _utils
 
-    Args:
-        prompt_message: A PromptMessage instance.
 
-    Returns:
-        A BaseMessageParam instance representing the given prompt_message.
+class MCPClient(ClientSession):
+    """The SSE client session that connects to the MCP server.
 
-    Raises:
-        ValueError: If the role is invalid or if the content type is unsupported.
+    All of the results from the server are converted into Mirascope-friendly types.
     """
 
-    # Validate role
-    if prompt_message.role not in ["user", "assistant"]:
-        raise ValueError(f"invalid role: {prompt_message.role}")
-
-    content = prompt_message.content
-
-    # Handle TextContent
-    if isinstance(content, TextContent):
-        # If it's text, we can just return a single string
-        return BaseMessageParam(role=prompt_message.role, content=content.text)
+    _session: ClientSession
 
-    # Handle ImageContent
-    elif isinstance(content, ImageContent):
-        decoded_image = base64.b64decode(content.data)
-
-        image_part = ImagePart(
-            type="image",
-            image=decoded_image,
-            media_type=content.mimeType,
-            detail=None,  # detail not provided by PromptMessage
-        )
-        return BaseMessageParam(role=prompt_message.role, content=[image_part])
-
-    elif isinstance(content, EmbeddedResource):
-        resource = content.resource
-        if isinstance(resource, TextResourceContents):
-            return BaseMessageParam(role=prompt_message.role, content=resource.text)
-        else:
-            mime_type = resource.mimeType
-            if not mime_type:
-                raise ValueError(
-                    "BlobResourceContents has no mimeType, cannot determine content type."
-                )
-
-            decoded_data = base64.b64decode(resource.blob)
-
-            if mime_type.startswith("image/"):
-                # Treat as ImagePart
-                image_part = ImagePart(
-                    type="image",
-                    image=decoded_data,
-                    media_type=mime_type,
-                    detail=None,
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[image_part])
-            elif mime_type == "application/pdf":
-                doc_part = DocumentPart(
-                    type="document", media_type=mime_type, document=decoded_data
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[doc_part])
-            elif mime_type.startswith("audio/"):
-                # Treat as AudioPart
-                audio_part = AudioPart(
-                    type="audio", media_type=mime_type, audio=decoded_data
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[audio_part])
-            else:
-                raise ValueError(f"Unsupported mime type: {mime_type}")
-
-    else:
-        raise ValueError(f"Unsupported content type: {type(content)}")
-
-
-def snake_to_pascal(snake: str) -> str:
-    return string.capwords(snake.replace("_", " ")).replace(" ", "")
-
-
-def build_object_type(
-    properties: dict[str, Any], required: list[str], name: str
-) -> type[BaseModel]:
-    fields = {}
-    for prop_name, prop_schema in properties.items():
-        class_name = snake_to_pascal(prop_name)
-        type_ = json_schema_to_python_type(prop_schema, class_name)
-        if prop_name in required:
-            fields[prop_name] = (
-                type_,
-                Field(..., description=prop_schema.get("description")),
-            )
-        else:
-            fields[prop_name] = (
-                type_ | None,
-                Field(None, description=prop_schema.get("description")),
-            )
-
-    return create_model(name, __config__=ConfigDict(extra="allow"), **fields)
-
-
-def json_schema_to_python_type(schema: dict[str, Any], name: str = "Model") -> Any:  # noqa: ANN401
-    """
-    Recursively convert a JSON Schema snippet into a Python type annotation or a dynamically generated pydantic model.
-    """
-    json_type = schema.get("type", "any")
-
-    if json_type == "string":
-        return str
-    elif json_type == "number":
-        return float
-    elif json_type == "integer":
-        return int
-    elif json_type == "boolean":
-        return bool
-    elif json_type == "array":
-        # Recursively determine the items type for arrays
-        items_schema = schema.get("items", {})
-        items_type = json_schema_to_python_type(items_schema)
-        return list[items_type]
-    elif json_type == "object":
-        # Recursively build a dynamic model for objects
-        properties = schema.get("properties", {})
-        required = schema.get("required", [])
-        return build_object_type(properties, required, name)
-    else:
-        # Default fallback
-        return Any
-
-
-def create_model_from_tool(tool: Tool) -> type[BaseModel]:
-    """
-    Create a dynamic pydantic model from the given Tool instance based on its inputSchema.
-    """
-    schema = tool.inputSchema
-    properties = schema.get("properties", {})
-    required_fields = schema.get("required", [])
-
-    fields = {}
-    for field_name, field_schema in properties.items():
-        field_type = json_schema_to_python_type(field_schema)
-
-        if field_name in required_fields:
-            default = Field(..., description=field_schema.get("description"))
-            annotation = field_type
-        else:
-            default = Field(None, description=field_schema.get("description"))
-            annotation = field_type | None
-
-        fields[field_name] = (annotation, default)
-
-    return create_model(
-        snake_to_pascal(tool.name), __config__=ConfigDict(extra="allow"), **fields
-    )
+    def __init__(self, session: ClientSession) -> None:
+        """Initializes an instance of `MCPClient`.
 
+        Args:
+            session: The original MCP `ClientSession`.
+        """
+        self._session = session
 
-class MCPClient:
-    def __init__(self, session: ClientSession) -> None:
-        self.session: ClientSession = session
+    async def list_resources(self) -> list[Resource]:  # pyright: ignore [reportIncompatibleMethodOverride]
+        """List all resources available on the MCP server.
 
-    async def list_resources(self) -> list[Resource]:
-        result = await self.session.list_resources()
+        Returns:
+            A list of Resource objects
+        """
+        result = await self._session.list_resources()
         return result.resources
 
-    async def read_resource(
+    async def read_resource(  # pyright: ignore [reportIncompatibleMethodOverride]
         self, uri: str | AnyUrl
-    ) -> list[str | BlobResourceContents]:
-        result = await self.session.read_resource(
+    ) -> list[TextPart | BlobResourceContents]:
+        """Read a resource from the MCP server.
+
+        Args:
+            uri: URI of the resource to read
+
+        Returns:
+            Contents of the resource, either as string or BlobResourceContents
+        """
+        result = await self._session.read_resource(
             uri if isinstance(uri, AnyUrl) else AnyUrl(uri)
         )
-        parsed_results = []
+        parsed_results: list[TextPart | BlobResourceContents] = []
         for content in result.contents:
-            if isinstance(content, TextResourceContents):
-                parsed_results.append(content.text)
-            else:
+            if isinstance(content, BlobResourceContents):
                 parsed_results.append(content)
+            else:
+                parsed_results.append(TextPart(type="text", text=content.text))
         return parsed_results
 
-    async def list_prompts(self) -> list[Prompt]:
-        result = await self.session.list_prompts()
+    async def list_prompts(self) -> list[Any]:  # pyright: ignore [reportIncompatibleMethodOverride]
+        """List all prompts available on the MCP server.
+
+        Returns:
+            A list of Prompt objects
+        """
+        result = await self._session.list_prompts()
         return result.prompts
 
     async def get_prompt_template(
         self, name: str
     ) -> Callable[..., Awaitable[list[BaseMessageParam]]]:
+        """Get a prompt template from the MCP server.
+
+        Args:
+            name: Name of the prompt template
+
+        Returns:
+            A callable that accepts keyword arguments and returns a list of BaseMessageParam
+        """
+
+        # TODO: wrap this with `llm.prompt` once it's implemented so that they prompts
+        # can be run super easily inside of an `llm.context` block.
         async def async_prompt(**kwargs: str) -> list[BaseMessageParam]:
-            result = await self.session.get_prompt(name, kwargs)
+            result = await self._session.get_prompt(name, kwargs)  # type: ignore
 
             return [
-                _convert_prompt_message_to_base_message_params(prompt_message)
+                _utils.convert_prompt_message_to_base_message_params(prompt_message)
                 for prompt_message in result.messages
             ]
 
         return async_prompt
 
-    async def list_tools(self) -> list[type[BaseModel]]:
-        list_tool_result = await self.session.list_tools()
+    async def list_tools(self) -> list[type[BaseTool]]:  # pyright: ignore [reportIncompatibleMethodOverride]
+        """List all tools available on the MCP server.
+
+        Returns:
+            A list of dynamically created `BaseTool` types.
+        """
+        list_tool_result = await self._session.list_tools()
 
         converted_tools = []
         for tool in list_tool_result.tools:
-            model = create_model_from_tool(tool)
-            model.call = _create_tool_call(tool.name, self.session.call_tool)  # pyright: ignore [reportAttributeAccessIssue]
+            model = _utils.create_tool_from_mcp_tool(tool)
+            tool_call_method = _utils.create_tool_call(
+                tool.name, self._session.call_tool
+            )
+            model.call = tool_call_method  # pyright: ignore [reportAttributeAccessIssue]
             converted_tools.append(model)
         return converted_tools
 
 
-@asynccontextmanager
-async def read_stream_exception_filer(
-    original_read: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-    exception_handler: Callable[[Exception], None] | None = None,
-) -> AsyncGenerator[MemoryObjectReceiveStream[JSONRPCMessage], None]:
-    """
-    Handle exceptions in the original stream.
-    default handler is to ignore read stream exception for invalid JSON lines and log them.
-    Args:
-        original_read: The original stream to read from.
-        exception_handler: An optional handler for exception.
-    """
-    read_stream_writer, filtered_read = create_memory_object_stream(0)
-
-    async def task() -> None:
-        try:
-            async with original_read:
-                async for msg in original_read:
-                    if isinstance(msg, Exception):
-                        if exception_handler:
-                            exception_handler(msg)
-                        continue
-                    await read_stream_writer.send(msg)
-        finally:
-            await read_stream_writer.aclose()
-
-    async with create_task_group() as tg:
-        tg.start_soon(task)
-        try:
-            yield filtered_read
-        finally:
-            await filtered_read.aclose()
-            tg.cancel_scope.cancel()
-
-
-@asynccontextmanager
-async def create_mcp_client(
+@contextlib.asynccontextmanager
+async def sse_client(
+    url: str,
+    list_roots_callback: ListRootsFnT | None = None,
+    read_timeout_seconds: timedelta | None = None,
+    sampling_callback: SamplingFnT | None = None,
+    session: ClientSession | None = None,
+) -> AsyncIterator[MCPClient]:
+    async with (
+        mcp_sse_client(url) as (read, write),
+        ClientSession(
+            read,
+            write,
+            read_timeout_seconds=read_timeout_seconds,
+            sampling_callback=sampling_callback,
+            list_roots_callback=list_roots_callback,
+        ) as session,
+    ):
+        await session.initialize()
+        yield MCPClient(session)
+
+
+@contextlib.asynccontextmanager
+async def stdio_client(
     server_parameters: StdioServerParameters,
     read_stream_exception_handler: Callable[[Exception], None] | None = None,
-) -> AsyncGenerator[MCPClient, None]:
+) -> AsyncIterator[MCPClient]:
     """
     Create a MCPClient instance with the given server parameters and exception handler.
 
@@ -311,11 +157,11 @@ async def create_mcp_client(
 
     """
     async with (
-        stdio_client(server_parameters) as (read, write),
-        read_stream_exception_filer(
+        mcp_stdio_client(server_parameters) as (read, write),
+        _utils.read_stream_exception_filer(
             read, read_stream_exception_handler
         ) as filtered_read,
-        ClientSession(filtered_read, write) as session,
+        ClientSession(filtered_read, write) as session,  # pyright: ignore [reportArgumentType]
     ):
         await session.initialize()
         yield MCPClient(session)

mirascope/mcp/server.py

@@ -1,6 +1,7 @@
-"""MCP server implementation."""
+"""The `MCPServer` Class and context managers."""
 
 import inspect
+import warnings
 from collections.abc import Awaitable, Callable, Iterable
 from typing import Literal, ParamSpec, cast, overload
 
@@ -117,7 +118,12 @@ def _generate_prompt_from_function(fn: Callable) -> Prompt:
 
 
 class MCPServer:
-    """MCP server implementation."""
+    """MCP server implementation.
+
+    DEPRECATED: The MCPServer implementation is deprecated and will be removed in a future version.
+    Mirascope will only implement the client-side of MCP in the future, allowing it to connect to any
+    MCP server implementation, even if not built with Mirascope.
+    """
 
     def __init__(
         self,
@@ -134,6 +140,13 @@ class MCPServer:
         ]
         | None = None,
     ) -> None:
+        warnings.warn(
+            "MCPServer is deprecated and will be removed in a future version. "
+            "Mirascope will only implement the client-side of MCP in the future. "
+            "We recommend using the official MCP SDK (e.g. `FastMCP`) for server-side implementations.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self.name: str = name
         self.version: str = version
         self.server: Server = Server(name)

mirascope/mcp/tools.py

@@ -1,10 +1,15 @@
 """The `MCPTool` class for easy tool usage with MCPTool LLM calls.
 
 usage docs: learn/tools.md
+
+DEPRECATED: The MCPTool class is deprecated and will be removed in a future version.
+Mirascope will only implement the client-side of MCP in the future, allowing it to connect to any
+MCP server implementation, even if not built with Mirascope.
 """
 
 from __future__ import annotations
 
+import warnings
 from typing import Any
 
 from pydantic import BaseModel
@@ -34,6 +39,9 @@ class MCPToolToolConfig(ToolConfig, total=False):
 class MCPTool(BaseTool):
     """A class for defining tools for MCP LLM calls.
 
+    DEPRECATED: The MCPTool class is deprecated and will be removed in a future version.
+    Mirascope will only implement the client-side of MCP in the future.
+
     Example:
 
     ```python
@@ -74,6 +82,14 @@ class MCPTool(BaseTool):
         print(tool_type.tool_schema())  # prints the MCP-specific tool schema
         ```
         """
+        # Show deprecation warning
+        warnings.warn(
+            "The MCPTool class is deprecated and will be removed in a future version. "
+            "Mirascope will only implement the client-side of MCP in the future. "
+            "We recommend using the official MCP SDK (e.g. `FastMCP`) for server-side implementations.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         kwargs = {
             "input_schema": cls.model_json_schema(),
             "name": cls._name(),

{mirascope-1.21.6.dist-info → mirascope-1.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 1.21.6
+Version: 1.22.0
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/WELCOME
@@ -79,7 +79,7 @@ Requires-Dist: litellm<2,>=1.42.12; extra == 'litellm'
 Provides-Extra: logfire
 Requires-Dist: logfire<4,>=1.0.0; extra == 'logfire'
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.0.0; extra == 'mcp'
+Requires-Dist: mcp>=1.3.0; extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai<2,>=1.0.0; extra == 'mistral'
 Provides-Extra: openai

{mirascope-1.21.6.dist-info → mirascope-1.22.0.dist-info}/RECORD

@@ -333,7 +333,7 @@ mirascope/integrations/otel/__init__.py,sha256=OzboYfm3fUNwKTuu08KX83hQHYI4oZYN2
 mirascope/integrations/otel/_utils.py,sha256=SCVb3MpcpqLpCpumJEbEdINceNdusnyT6iuKPz66sBc,8778
 mirascope/integrations/otel/_with_hyperdx.py,sha256=f17uxXQk5zZPtyj6zwPwJz5i7atsnUPOoq1LqT8JO0E,1637
 mirascope/integrations/otel/_with_otel.py,sha256=tbjd6BEbcSfnsm5CWHBoHwbRNrHt6-t4or-SYGQSD-w,1659
-mirascope/llm/__init__.py,sha256=zo7QD39zQ6HIU_N2yHrzd6bbcT9YmlikZ84JN_r5k4E,397
+mirascope/llm/__init__.py,sha256=rCukXJUqSGiDGNMMM9g3NS8clnrCxgCpaFIXIG1M660,432
 mirascope/llm/_call.py,sha256=zPULSy5GLlJszphRvc3WUSFEsmP83Abp0FzbZefTa8Y,13848
 mirascope/llm/_context.py,sha256=vtHJkLlFfUwyR_hYEHXAw3xunpHhLn67k4kuFw50GR8,12481
 mirascope/llm/_override.py,sha256=m4MdOhM-aJRIGP7NBJhscq3ISNct6FBPn3jjmryFo_Q,112292
@@ -343,10 +343,11 @@ mirascope/llm/call_response.py,sha256=4w_2Dgt325lEjMaFlg7Iq2AGp8cI0uSaqCa8MR_S5G
 mirascope/llm/call_response_chunk.py,sha256=bZwO43ipc6PO1VLgGSaAPRqCIUyZD_Ty5oxdJX62yno,1966
 mirascope/llm/stream.py,sha256=GtUKyLBlKqqZTOKjdL9FLInCXJ0ZOEAe6nymbjKwyTQ,5293
 mirascope/llm/tool.py,sha256=MQRJBPhP1d-OyOz3PE_VsKmSXca0chySyYO1U9OW8ck,1824
-mirascope/mcp/__init__.py,sha256=mGboroTrBbzuZ_8uBssOhkqiJOJ4mNCvaJvS7mhumhg,155
-mirascope/mcp/client.py,sha256=ZsjaT6E5i4Cdm3iVp2-JTuDniUlzynWeeJvnBAtuffQ,11123
-mirascope/mcp/server.py,sha256=7BjZO3DkaiokEOgJOY9fbEX3M6YwAExN6Kw9s-Dp7Sc,11737
-mirascope/mcp/tools.py,sha256=IKQZCiQHh_YxJM-V90U9Z6xPQTYIfWFDBj8khhHDiw4,2254
+mirascope/mcp/__init__.py,sha256=1tvG-fRD-_mr2vF3M49OgTLR7Vw8zdT6LucxnY4prF8,282
+mirascope/mcp/_utils.py,sha256=jyuE28W9Gy6sF17dRNZnqXRBhD_dmJBxIXq99UWmpHk,9221
+mirascope/mcp/client.py,sha256=ZK88o4UelR9htFWAWDbw084ZTrRL8tONdxlIX62adnM,5608
+mirascope/mcp/server.py,sha256=weXBk9ZmUcfZ5SZcR-dGRxvVXRMpn5UsE6ancnK1HZk,12402
+mirascope/mcp/tools.py,sha256=IT7CEqbBBiFc7mkaRpWIepUpuy_oSdcEa4cwGopEYWc,3079
 mirascope/retries/__init__.py,sha256=xw3jJm-vL4kR10VaKN6A8KGoP2CsAg5_Gy1eWVMgYhQ,249
 mirascope/retries/fallback.py,sha256=LPSyIfPAHajt3-M_Z1M4ZSbgHjbXghMBbb9fjNQ27UU,4876
 mirascope/retries/tenacity.py,sha256=stBJPjEpUzP53IBVBFtqY2fUSgmOV1-sIIXZZJ9pvLY,1387
@@ -370,7 +371,7 @@ mirascope/v0/base/ops_utils.py,sha256=1Qq-VIwgHBaYutiZsS2MUQ4OgPC3APyywI5bTiTAmA
 mirascope/v0/base/prompts.py,sha256=FM2Yz98cSnDceYogiwPrp4BALf3_F3d4fIOCGAkd-SE,1298
 mirascope/v0/base/types.py,sha256=ZfatJoX0Yl0e3jhv0D_MhiSVHLYUeJsdN3um3iE10zY,352
 mirascope/v0/base/utils.py,sha256=XREPENRQTu8gpMhHU8RC8qH_am3FfGUvY-dJ6x8i-mw,681
-mirascope-1.21.6.dist-info/METADATA,sha256=G019BNHoF6aiD4C12Dqv77qn3vJhI2Zi-KWJTfwc0L4,8730
-mirascope-1.21.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mirascope-1.21.6.dist-info/licenses/LICENSE,sha256=LAs5Q8mdawTsVdONpDGukwsoc4KEUBmmonDEL39b23Y,1072
-mirascope-1.21.6.dist-info/RECORD,,
+mirascope-1.22.0.dist-info/METADATA,sha256=2Tod_tF9thr1KIVCfKCVTGfgtBvd9NLgOIdIo5YMvlQ,8730
+mirascope-1.22.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mirascope-1.22.0.dist-info/licenses/LICENSE,sha256=LAs5Q8mdawTsVdONpDGukwsoc4KEUBmmonDEL39b23Y,1072
+mirascope-1.22.0.dist-info/RECORD,,