---
title: Client
description: Learn how to use the Mirascope MCP Client to interact with Model Context Protocol servers, accessing standardized resources, tools, and prompts through either stdio or SSE connections.
---

# MCP Client

<Callout type="info">
  If you haven't already, we recommend first reading and learning about [Model Context Protocol](https://github.com/modelcontextprotocol)
</Callout>

MCP Client in Mirascope enables you to interact with MCP servers through a standardized protocol. The client provides methods to access resources, tools, and prompts exposed by MCP servers.

## Basic Usage and Syntax

Let's connect to our book recommendation server using the MCP client:

```python
import asyncio
from pathlib import Path

from mcp.client.stdio import StdioServerParameters
from mirascope.mcp import stdio_client

server_file = Path(__file__).parent / "server.py"

server_params = StdioServerParameters( # [!code highlight]
    command="uv", # [!code highlight]
    args=["run", "python", str(server_file)], # [!code highlight]
    env=None, # [!code highlight]
) # [!code highlight]


async def main() -> None:
    async with stdio_client(server_params) as client: # [!code highlight]
        prompts = await client.list_prompts()
        print(prompts[0])



asyncio.run(main())

```

This example demonstrates:

1. Creating server parameters with `StdioServerParameters`
2. Using the `stdio_client` context manager to connect to the server
3. Accessing the list of available prompts

## Client Components

### Standard In/Out (stdio) Server Connection

To connect to an MCP server, use the `stdio_client` context manager with appropriate server parameters:

```python-snippet-skip
server_file = Path(__file__).parent / "server.py" # [!code highlight]

server_params = StdioServerParameters( # [!code highlight]
    command="uv", # [!code highlight]
    args=["run", "python", str(server_file)], # [!code highlight]
    env=None, # [!code highlight]
) # [!code highlight]


async def main() -> None:
    async with stdio_client(server_params) as client: # [!code highlight]
        prompts = await client.list_prompts()
        print(prompts[0])

```

The `StdioServerParameters` specify how to launch and connect to the server process.

### Server Side Events (sse) Server Connection

You can also use the `sse_client` instead to connect to an MCP server side event endpoint:

```python-snippet-skip
from mirascope.mcp import sse_client


async with sse_client("http://localhost:8000") as client: # [!code highlight]
    prompts = await client.list_prompts()
    print(prompts[0])
```

### Prompts

You can list available prompts and get prompt templates from the server:

```python-snippet-skip
        prompts = await client.list_prompts()
        print(prompts[0])
        # name='recommend_book' description='Get book recommendations by genre.' arguments=[PromptArgument(name='genre', description='Genre of book to recommend (fantasy, mystery, sci-fi, etc.)', required=True)]
        prompt_template = await client.get_prompt_template(prompts[0].name)
        prompt = await prompt_template(genre="fantasy")
        print(prompt)
        # [BaseMessageParam(role='user', content='Recommend a fantasy book')]
```

The client automatically converts server prompts into Mirascope-compatible prompt templates that return `BaseMessageParam` instances. This makes it easy to consume these prompts downstream in your Mirascope code.

### Resources

Resources can be listed and read from the server:

```python-snippet-skip
        resources = await client.list_resources()
        resource = await client.read_resource(resources[0].uri)
        print(resources[0])
        # uri=AnyUrl('file://books.txt/') name='Books Database' description='Read the books database file.' mimeType='text/plain'
        print(resource)
        # ['The Name of the Wind by Patrick Rothfuss\nThe Silent Patient by Alex Michaelides']
```

The client provides methods to:

- `list_resources()`: Get available resources
- `read_resource(uri)`: Read resource content by URI

If the resource is text, it will be converted into a `TextPart` instance. Otherwise it will be the MCP `BlobResourceContents` type where the data contained is the original bytes encoded as a base64 string.

### Tools

Tools from the server can be used with Mirascope's standard call decorators:

```python-snippet-skip
        tools = await client.list_tools() # [!code highlight]

        @llm.call(
            provider="$PROVIDER",
            model="$MODEL",
            tools=tools, # [!code highlight]
        )
        def recommend_book(genre: str) -> str:
            return f"Recommend a {genre} book"

        if tool := recommend_book("fantasy").tool: # [!code highlight]
            call_result = await tool.call() # [!code highlight]
            print(call_result) # [!code highlight]
            # ['The Name of the Wind by Patrick Rothfuss'] # [!code highlight]
```

The client automatically converts server tools into Mirascope-compatible tool types that can be used with any provider's call decorator.

## Type Safety

The MCP client preserves type information from the server:

1. **Prompts**: Arguments and return types from server prompt definitions
2. **Resources**: MIME types and content types for resources
3. **Tools**: Input schemas and return types for tools

This enables full editor support and type checking when using server components.

## Next Steps

By using the MCP client with Mirascope's standard features like [Calls](/docs/v1/learn/calls), [Tools](/docs/v1/learn/tools), and [Prompts](/docs/v1/learn/prompts), you can build powerful applications that leverage local services through MCP servers.