Pyjo-MCP 0.1.0__py3-none-any.whl

Pyjo/MCP/Tool.py

@@ -0,0 +1,399 @@
+"""
+Pyjo.MCP.Tool - Tool of a server of MCP
+=======================================
+::
+
+    from Pyjo.MCP.Tool import Tool
+
+    def add(a: int, b: int) -> int:
+        \"\"\"Add two numbers.
+
+        :param a: The first number.
+        :param b: The second number.
+        \"\"\"
+        return a + b
+
+    tool = Tool(add)
+    print(tool.name, tool.description, tool.input_schema)
+
+    # Or import the module, as in Google Python Style Guide
+
+    import Pyjo.MCP.Tool
+
+    tool = Pyjo.MCP.Tool.new(add, name='math.add', title='Addition')
+    tool.call_p({'a': 1, 'b': 2}).then(print).wait()
+
+:mod:`Pyjo.MCP.Tool` is a tool of :mod:`Pyjo.MCP.Server`, a function that a
+language model calls with the arguments of its ``inputSchema``. The name, the
+description and the schemas of the tool are those of the function by default:
+its name, the first paragraph of its docstring, the schema of its parameters,
+with the descriptions of its docstring, and the one of what it returns, of
+:mod:`Pyjo.JSON.Schema`.
+
+The function returns the result of the tool, as a value, a :mod:`Pyjo.Promise`
+of it or a coroutine, of an ``async def``:
+
+* a value of the ``outputSchema`` of the tool, as of the annotation of what the
+  function returns, is the ``structuredContent`` of the result, and its JSON
+  the text of its ``content``;
+* a string, without an ``outputSchema``, is the text of the ``content``;
+* a :class:`dict` with ``content``, without an ``outputSchema``, is the result
+  as it is, for the content of another type, as an image;
+* ``None`` is a result without content, and another value is its JSON.
+
+Arguments that the ``inputSchema`` does not validate, and a function that
+raises :class:`Error`, give a result with ``isError``, whose text the language
+model reads to call the tool again, as a tool reports the errors of its
+execution. Another exception is an error of the server, which the result does
+not tell.
+
+See also
+--------
+
+:mod:`Pyjo.MCP.Server`, :mod:`Pyjo.JSON.Schema`, :mod:`Pyjo.MCP`.
+
+Classes
+-------
+"""
+
+import Pyjo.Base
+import Pyjo.Exception
+import Pyjo.JSON
+import Pyjo.JSON.Schema
+import Pyjo.Promise
+
+import builtins
+import dataclasses
+import datetime
+import enum
+import inspect
+import re
+import uuid
+
+from collections.abc import Callable, Mapping
+from typing import Any, cast
+
+
+type Anything = builtins.object
+
+# The characters of a token of a name of a field of HTTP (RFC 9110)
+_TOKEN = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
+
+
+class Error(Pyjo.Exception.object):
+    """
+    An error of the execution of a tool, which the result of the call tells
+    with ``isError``, so that the language model can correct the arguments. ::
+
+        raise Pyjo.MCP.Tool.Error.new('Invalid departure date: must be in the future')
+    """
+
+
+class Pyjo_MCP_Tool(Pyjo.Base.object):
+    """
+    :mod:`Pyjo.MCP.Tool` inherits all methods from :mod:`Pyjo.Base` and
+    implements the following new ones.
+    """
+
+    def __init__(
+        self,
+        cb: Callable[..., Any],
+        *,
+        name: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        input_schema: Mapping[str, Any] | Pyjo.JSON.Schema.object | None = None,
+        output_schema: Mapping[str, Any] | Pyjo.JSON.Schema.object | bool | None = None,
+        annotations: Mapping[str, Any] | None = None,
+        context: bool = False,
+    ) -> None:
+        """::
+
+            tool = Pyjo.MCP.Tool.new(add)
+            tool = Pyjo.MCP.Tool.new(add, name='math.add', title='Addition')
+            tool = Pyjo.MCP.Tool.new(lambda c, **args: ..., input_schema={'type': 'object'}, context=True)
+            tool = Pyjo.MCP.Tool.new(report, output_schema=False)
+
+        Construct a new :mod:`Pyjo.MCP.Tool` object of a function. With
+        ``context``, the function gets the :class:`~Pyjo.MCP.Server.Context` of
+        the request before its arguments. ``output_schema`` of ``False`` gives
+        the tool no ``outputSchema``, also when the function has the annotation
+        of what it returns.
+        """
+        signature = inspect.signature(cb)
+        skip = 1 if context else 0
+
+        if input_schema is None:
+            schema = Pyjo.JSON.Schema.parameters(cb, skip=skip)
+            data = cast(dict[str, Any], schema.data)
+            if description is None:
+                description = data.pop('description', None)
+            else:
+                data.pop('description', None)
+        elif isinstance(input_schema, Pyjo.JSON.Schema.object):
+            schema = input_schema
+        else:
+            schema = Pyjo.JSON.Schema.new(dict(input_schema))
+
+        output: Pyjo.JSON.Schema.object | None = None
+        if output_schema is None or output_schema is True:
+            returns = Pyjo.JSON.Schema.returns(cb)
+            # A string is the text of the content, and None no content
+            if returns is not None and cast(dict[str, Any], returns.data).get('type') not in ('string', 'null'):
+                output = returns
+        elif isinstance(output_schema, Pyjo.JSON.Schema.object):
+            output = output_schema
+        elif output_schema is not False:
+            output = Pyjo.JSON.Schema.new(dict(output_schema))
+
+        self.annotations: dict[str, Any] = dict(annotations or {})
+        """::
+
+            annotations = tool.annotations
+
+        The properties of the behaviour of the tool, as ``readOnlyHint``, which
+        a client takes as hints, for the ``annotations`` of the tool.
+        """
+
+        self.cb = cb
+        """::
+
+            cb = tool.cb
+
+        The function of the tool.
+        """
+
+        self.context = context
+        """::
+
+            boolean = tool.context
+
+        Whether the function gets the context of the request before its
+        arguments.
+        """
+
+        self.description = description or ''
+        """::
+
+            description = tool.description
+
+        What the tool does, for the language model, the first paragraph of the
+        docstring of the function by default.
+        """
+
+        self.input_schema: Pyjo.JSON.Schema.object = schema
+        """::
+
+            schema = tool.input_schema
+
+        The :mod:`Pyjo.JSON.Schema` of the arguments, the ``inputSchema`` of
+        the tool, the one of the parameters of the function by default.
+        """
+
+        self.name = name or cb.__name__
+        """::
+
+            name = tool.name
+
+        The name of the tool, the one of the function by default.
+        """
+
+        self.output_schema = output
+        """::
+
+            schema = tool.output_schema
+
+        The :mod:`Pyjo.JSON.Schema` of the ``structuredContent`` of the result,
+        the ``outputSchema`` of the tool, the one of what the function returns
+        by default, or ``None``.
+        """
+
+        self.title = title
+        """::
+
+            title = tool.title
+
+        The name of the tool for people, or ``None``.
+        """
+
+        self._header_params = _header_params_of(schema.data, self.name)
+        self._signature = signature
+
+    def __json__(self) -> dict[str, Any]:
+        """::
+
+            definition = tool.__json__()
+
+        The definition of the tool, as ``tools/list`` gives it, with its
+        ``name``, ``title``, ``description``, ``inputSchema``,
+        ``outputSchema`` and ``annotations``, where it has them.
+        """
+        definition: dict[str, Any] = {'name': self.name}
+        if self.title is not None:
+            definition['title'] = self.title
+        definition['description'] = self.description
+        definition['inputSchema'] = self.input_schema.data
+        if self.output_schema is not None:
+            definition['outputSchema'] = self.output_schema.data
+        if self.annotations:
+            definition['annotations'] = self.annotations
+        return definition
+
+    def call_p(self, arguments: Mapping[str, Any], context: Any = None) -> Pyjo.Promise.object:
+        """::
+
+            promise = tool.call_p({'a': 1, 'b': 2})
+            promise = tool.call_p({'a': 1, 'b': 2}, context)
+
+        Call the function with the arguments, and return a :mod:`Pyjo.Promise`
+        of the result of the tool, as ``tools/call`` gives it, without its
+        ``resultType``, or rejected with an exception of the function that is not an
+        :class:`Error`, an error of the server. ::
+
+            # {'content': [{'type': 'text', 'text': '3'}], 'structuredContent': 3, 'isError': False}
+            tool.call_p({'a': 1, 'b': 2}).then(print).wait()
+        """
+        if not (result := self.input_schema.validate(dict(arguments))):
+            return Pyjo.Promise.resolve(error_result(f'Invalid arguments:\n{result}'))
+        try:
+            bound = self._signature.bind(*([context] if self.context else []), **arguments)
+        except TypeError as e:
+            return Pyjo.Promise.resolve(error_result(f'Invalid arguments: {e}'))
+
+        try:
+            value = self.cb(*bound.args, **bound.kwargs)
+        except Error as e:
+            return Pyjo.Promise.resolve(error_result(e.message))
+        except Exception as e:
+            return Pyjo.Promise.reject(e)
+        if inspect.iscoroutine(value):
+            value = Pyjo.Promise.new(value)
+        if isinstance(value, Pyjo.Promise.object):
+
+            def failed(e: Any = None) -> Any:
+                if isinstance(e, Error):
+                    return error_result(e.message)
+                return Pyjo.Promise.reject(e)
+
+            return value.then(self.result, failed)
+        try:
+            return Pyjo.Promise.resolve(self.result(value))
+        except Exception as e:
+            return Pyjo.Promise.reject(e)
+
+    @property
+    def header_params(self) -> list[tuple[str, list[str], str]]:
+        """::
+
+            params = tool.header_params
+
+        The arguments of the ``x-mcp-header`` of the ``inputSchema``, which a
+        client of HTTP sends as the headers ``Mcp-Param-{name}`` too, each with
+        the name, the path of the properties and the type. A header that the
+        specification does not allow, as of a property of an array or of a
+        ``number``, fails with a :mod:`Pyjo.Exception` when the tool is made.
+        """
+        return self._header_params
+
+    def result(self, value: Any = None) -> dict[str, Any]:
+        """::
+
+            result = tool.result(3)
+            result = tool.result('Three')
+
+        The result of the tool of what the function returns. A value that the
+        ``outputSchema`` does not validate fails with a :mod:`Pyjo.Exception`,
+        as an error of the server.
+        """
+        if self.output_schema is not None:
+            data = _plain(value)
+            if not (result := self.output_schema.validate(data)):
+                raise Pyjo.Exception.new(f'The result of the tool {self.name} is not valid:\n{result}')
+            text = Pyjo.JSON.to_json(data)
+            return {'content': [{'type': 'text', 'text': text}], 'structuredContent': data, 'isError': False}
+        if value is None:
+            return {'content': [], 'isError': False}
+        if isinstance(value, dict) and 'content' in value:
+            return cast(dict[str, Any], value)
+        data = _plain(value)
+        return text_result(data if isinstance(data, str) else Pyjo.JSON.to_json(data))
+
+
+def error_result(text: str) -> dict[str, Any]:
+    """::
+
+        result = Pyjo.MCP.Tool.error_result('Invalid departure date')
+
+    A result of a tool with the text of an error of its execution and
+    ``isError``.
+    """
+    return {'content': [{'type': 'text', 'text': text}], 'isError': True}
+
+
+def text_result(text: str) -> dict[str, Any]:
+    """::
+
+        result = Pyjo.MCP.Tool.text_result('Sunny')
+
+    A result of a tool with a text.
+    """
+    return {'content': [{'type': 'text', 'text': text}], 'isError': False}
+
+
+def _header_params_of(schema: Anything, tool: str) -> list[tuple[str, list[str], str]]:
+    params: list[tuple[str, list[str], str]] = []
+    _header_params(schema, [], params, False)
+    names = [name.lower() for name, _, _ in params]
+    if len(set(names)) != len(names):
+        raise Pyjo.Exception.new(f'The x-mcp-header of the tool {tool} are not unique')
+    return params
+
+
+def _header_params(schema: Anything, path: list[str], params: list[tuple[str, list[str], str]], hidden: bool) -> None:
+    # The properties that have an x-mcp-header, through the chain of properties from the root only
+    if not isinstance(schema, dict):
+        return
+    schema_ = cast(dict[str, Any], schema)
+    for keyword, value in schema_.items():
+        if keyword == 'properties' and isinstance(value, dict):
+            for key, property in cast(dict[str, Any], value).items():
+                _header_params(property, [*path, key], params, hidden)
+        elif keyword in ('items', 'prefixItems', 'additionalProperties', 'patternProperties', 'contains', '$defs'):
+            _header_params(value, path, params, True)
+        elif keyword in ('allOf', 'anyOf', 'oneOf', 'not', 'if', 'then', 'else', 'dependentSchemas'):
+            for each in cast(list[Any], value) if isinstance(value, list) else [value]:
+                _header_params(each, path, params, True)
+    if (name := schema_.get('x-mcp-header')) is None:
+        return
+    type = schema_.get('type')
+    if hidden or not path:
+        raise Pyjo.Exception.new(f'The x-mcp-header {name} is not of a property of the root')
+    if not isinstance(name, str) or not _TOKEN.fullmatch(name):
+        raise Pyjo.Exception.new(f'The x-mcp-header {name!r} is not a name of a header')
+    if type not in ('integer', 'string', 'boolean'):
+        raise Pyjo.Exception.new(f'The x-mcp-header {name} is not of an integer, a string or a boolean')
+    params.append((name, path, type))
+
+
+def _plain(value: Any) -> Any:
+    # The value as JSON has it, of the types that Pyjo.JSON.Schema gives a schema
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        return {field.name: _plain(getattr(value, field.name)) for field in dataclasses.fields(value)}
+    if isinstance(value, enum.Enum):
+        return _plain(value.value)
+    if isinstance(value, datetime.datetime | datetime.date | datetime.time):
+        return value.isoformat()
+    if isinstance(value, uuid.UUID):
+        return str(value)
+    if isinstance(value, dict):
+        return {str(key): _plain(item) for key, item in cast(dict[Any, Any], value).items()}
+    if isinstance(value, list | tuple | set | frozenset):
+        return [_plain(item) for item in cast(list[Any], value)]
+    if value is None or isinstance(value, bool | int | float | str):
+        return value
+    return Pyjo.JSON.decode_json(Pyjo.JSON.encode_json(value))
+
+
+new = Pyjo_MCP_Tool.new
+object = Pyjo_MCP_Tool
+Tool = Pyjo_MCP_Tool

Pyjo/MCP/__init__.py

@@ -0,0 +1,80 @@
+"""
+Pyjo.MCP - Model Context Protocol for Pyjoyment
+===============================================
+::
+
+    import Pyjo.MCP
+
+    print(Pyjo.MCP.PROTOCOL_VERSION)
+
+    # Pyjoyment.Lite
+    from Pyjo.MCP.Server import Server
+    from Pyjoyment.Lite import *
+
+    server = Server(name='calculator', version='1.0.0')
+
+    @server.tool
+    def add(a: int, b: int) -> int:
+        \"\"\"Add two numbers.\"\"\"
+        return a + b
+
+    plugin('AllowedHosts')
+    any('/mcp', server.to_action())
+
+    app.start()
+
+:mod:`Pyjo.MCP` is the namespace of the `Model Context Protocol
+<https://modelcontextprotocol.io>`_ for :mod:`Pyjoyment`, a server and a client
+made with Pyjoyment, of the revision :data:`PROTOCOL_VERSION` of the
+specification, whose core is stateless: every request carries its version and
+the capabilities of its client in its ``_meta``, without a session.
+
+:mod:`Pyjo.MCP.Server` is the server, whose tools, prompts, resources and
+resource templates are :mod:`Pyjo.MCP.Tool`, :mod:`Pyjo.MCP.Prompt`,
+:mod:`Pyjo.MCP.Resource` and :mod:`Pyjo.MCP.ResourceTemplate` objects,
+:mod:`Pyjo.MCP.Client` is the client, :mod:`Pyjo.MCP.Test` tests a server
+with its requests, and the messages are those of :mod:`Pyjo.JSON.RPC`.
+
+See also
+--------
+
+:mod:`Pyjo.MCP.Server`, :mod:`Pyjo.MCP.Tool`, :mod:`Pyjo.MCP.Prompt`,
+:mod:`Pyjo.MCP.Resource`, :mod:`Pyjo.MCP.ResourceTemplate`,
+:mod:`Pyjo.MCP.Client`, :mod:`Pyjo.MCP.Test`, :mod:`Pyjoyment`,
+https://github.com/dex4er/Pyjoyment.
+
+It is inspired by the distribution `MCP <https://metacpan.org/pod/MCP>`_ of
+CPAN, built on Mojolicious.
+"""
+
+import importlib.metadata
+
+
+__version__ = importlib.metadata.version('Pyjo-MCP')
+"""The version of the distribution, of its metadata, which the workflow Automated version sets in pyproject.toml."""
+
+PROTOCOL_VERSION = '2026-07-28'
+"""The revision of the specification of the Model Context Protocol, as ``MCP-Protocol-Version`` names it."""
+
+SUPPORTED_VERSIONS = (PROTOCOL_VERSION,)
+"""The revisions that the server supports, as ``server/discover`` gives them."""
+
+HEADER_MISMATCH = -32020
+"""The code of the error of a header of HTTP that does not match the body of the request, or that is missing."""
+MISSING_REQUIRED_CLIENT_CAPABILITY = -32021
+"""The code of the error of a request that needs a capability that its client does not declare."""
+UNSUPPORTED_PROTOCOL_VERSION = -32022
+"""The code of the error of a request of a revision that the server does not support."""
+
+META_CLIENT_CAPABILITIES = 'io.modelcontextprotocol/clientCapabilities'
+"""The key of ``_meta`` of a request with the capabilities of its client."""
+META_CLIENT_INFO = 'io.modelcontextprotocol/clientInfo'
+"""The key of ``_meta`` of a request with the name and the version of its client."""
+META_LOG_LEVEL = 'io.modelcontextprotocol/logLevel'
+"""The key of ``_meta`` of a request with the level of the log messages that its client wants."""
+META_PROTOCOL_VERSION = 'io.modelcontextprotocol/protocolVersion'
+"""The key of ``_meta`` of a request with its revision of the specification."""
+META_SERVER_INFO = 'io.modelcontextprotocol/serverInfo'
+"""The key of ``_meta`` of a result with the name and the version of its server."""
+META_SUBSCRIPTION_ID = 'io.modelcontextprotocol/subscriptionId'
+"""The key of ``_meta`` of a message of a subscription with the ``id`` of its request ``subscriptions/listen``."""

pyjo_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.5
+Name: Pyjo-MCP
+Version: 0.1.0
+Summary: Model Context Protocol server and client for Pyjoyment.
+Project-URL: Homepage, https://github.com/dex4er/Pyjo-MCP
+Project-URL: Documentation, https://pyjoyment.readthedocs.io/projects/pyjo-mcp/en/latest/
+Author-email: Piotr Roszatycki <piotr.roszatycki@gmail.com>
+License-Expression: Artistic-2.0
+License-File: LICENSE
+Keywords: mcp,model-context-protocol,pyjoyment
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Requires-Dist: pyjoyment>=0.1.0
+Description-Content-Type: text/markdown
+
+[![Home](https://img.shields.io/badge/%F0%9F%8F%A0-Pyjoyment-02a7a0)](https://github.com/dex4er/Pyjoyment)
+[![GitHub](https://img.shields.io/github/stars/dex4er/Pyjo-MCP?style=flat&label=GitHub%20%E2%AD%90&logo=github)](https://github.com/dex4er/Pyjo-MCP)
+[![Documentation](https://img.shields.io/badge/docs-Read_the_Docs-blue?logo=readthedocs&logoColor=white)](https://pyjoyment.readthedocs.io/projects/pyjo-mcp/en/latest/)
+[![License](https://img.shields.io/github/license/dex4er/Pyjo-MCP.svg)](https://github.com/dex4er/Pyjo-MCP/blob/main/LICENSE)
+[![Tests](https://github.com/dex4er/Pyjo-MCP/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/dex4er/Pyjo-MCP/actions/workflows/tests.yaml)
+
+# Pyjo-MCP
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/dex4er/Pyjoyment/main/Pyjoyment/resources/public/pyjo/logo-white-4x.png">
+    <img src="https://raw.githubusercontent.com/dex4er/Pyjoyment/main/Pyjoyment/resources/public/pyjo/logo-black-4x.png" alt="Pyjoyment" width="322">
+  </picture>
+</p>
+
+[Model Context Protocol](https://modelcontextprotocol.io) server and client
+for [Pyjoyment](https://github.com/dex4er/Pyjoyment), of the revision
+2026-07-28 of the specification.
+
+## Installation
+
+From [PyPI](https://pypi.org/project/Pyjo-MCP/), with
+[Pyjoyment](https://pypi.org/project/Pyjoyment/), which it depends on:
+
+```sh
+pip install Pyjo-MCP
+```
+
+or, in a project managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv add Pyjo-MCP
+```
+
+The development version is installed from the Git repository:
+
+```sh
+pip install git+https://github.com/dex4er/Pyjo-MCP
+```
+
+## Usage
+
+A server of MCP is a route of an application of Pyjoyment, whose tools are
+functions, with the schemas of their type hints and the descriptions of their
+docstrings:
+
+```python
+from Pyjo.MCP.Server import Server
+from Pyjo.MCP.Tool import Error
+from Pyjoyment.Lite import *
+
+server = Server(name='calculator', version='1.0.0')
+
+
+@server.tool
+def divide(a: float, b: float) -> float:
+    """Divide the first number by the second one."""
+    if b == 0:
+        raise Error.new('Division by zero')
+    return a / b
+
+
+# Host and Origin of localhost only, against DNS rebinding
+plugin('AllowedHosts')
+
+any('/mcp', server.to_action())
+
+app.start()
+```
+
+```sh
+uv run python calculator.py daemon -l http://127.0.0.1:3000
+```
+
+Its endpoint is `http://127.0.0.1:3000/mcp`, of the transport Streamable HTTP.
+The whole calculator is [`examples/calculator.py`](examples/calculator.py).
+
+Prompts, the templates of messages that a user picks, and resources, the data
+that a client reads by its URI, are functions too:
+
+```python
+@server.prompt
+def explain(expression: str) -> str:
+    """Explain an arithmetic expression step by step."""
+    return f'Explain step by step how to compute {expression}.'
+
+
+@server.resource('calculator://precision', mime_type='application/json')
+def precision() -> dict:
+    """The precision of the numbers of the calculator."""
+    return {'digits': 15}
+```
+
+The same application serves the transport stdio too, with a hook:
+
+```python
+hook('before_server_start', server.to_stdio())
+```
+
+A client of MCP, as Claude Code, then starts it with the command `stdio`:
+
+```sh
+claude mcp add calculator -- uv run python examples/calculator.py stdio
+```
+
+[`examples/weather.py`](examples/weather.py) is a gateway to the weather of
+[Open-Meteo](https://open-meteo.com), which needs no key, with the tools
+`find_places`, `current_weather`, `forecast` and `hourly_forecast`, which
+request the API with the non-blocking user agent of the application. A client of MCP, as Claude Code,
+connects to it over HTTP:
+
+```sh
+uv run python examples/weather.py daemon -l http://127.0.0.1:3000
+claude mcp add --transport http weather http://127.0.0.1:3000/mcp
+```
+
+[`examples/mcp_cli.py`](examples/mcp_cli.py) is a client of the command line
+for the tools of any server of MCP: a tool is a command, in kebab-case, and its
+arguments are options, with the descriptions and the constraints of its
+`inputSchema` in the help of the command. The result is text, with tables of
+the lists of objects, or JSON:
+
+```sh
+uv run python examples/mcp_cli.py --help
+uv run python examples/mcp_cli.py forecast --place Kraków --language pl --days 2
+uv run python examples/mcp_cli.py hourly-forecast -p Warsaw -H 6 -f json
+```
+
+It is made with `Pyjo.MCP.Client`, a client of MCP over Streamable HTTP, which
+sends the `_meta` and the headers that every request carries:
+
+```python
+from Pyjo.MCP.Client import Client
+
+client = Client('http://127.0.0.1:3000/mcp')
+print(client.call_tool('divide', {'a': 7, 'b': 2})['structuredContent'])
+```
+
+`Pyjo.MCP.Test` tests a server with the requests of the client, without
+starting it:
+
+```python
+import Pyjo.MCP.Test
+
+from Pyjo.File import curfile
+from Pyjo.Test import *
+
+t = Pyjo.MCP.Test.new(curfile().sibling('calculator.py'))
+t.call_ok('divide', a=7, b=2).status_is(200).structured_content_is(3.5)
+t.call_ok('divide', a=1, b=0).is_error_is(True).text_content_is('Division by zero')
+
+done_testing()
+```
+
+## Documentation
+
+The tutorial, which makes servers of MCP step by step, and the API of the package
+are on [Read the Docs](https://pyjoyment.readthedocs.io/projects/pyjo-mcp/en/latest/).
+
+## Status
+
+A server of the tools, the prompts and the resources of MCP over Streamable
+HTTP and stdio, with `server/discover`, `tools/list`, `tools/call`,
+`prompts/list`, `prompts/get`, `resources/list`, `resources/templates/list`,
+`resources/read`, `subscriptions/listen` and `completion/complete`, a client
+of them over Streamable HTTP, and assertions of tests with its requests. A tool
+sends its progress and its log messages before its result, and a subscription
+gets the changes of the lists and of the resources. A resource template is a
+URI Template of RFC 6570, whose URIs a client reads. A tool, a prompt and a
+resource ask the user, the language model or the roots of the client for
+input, in the rounds of a multi round-trip request, and the arguments of the
+prompts and the variables of the templates complete their values.
+
+## License
+
+The Artistic License 2.0, as Pyjoyment.

pyjo_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+Pyjo/MCP/Client.py,sha256=KJd-rQLzS7RBZymxsXnUd_YaE_oi80-sYAVBP9bdiFU,33292
+Pyjo/MCP/Prompt.py,sha256=KsP46nlimkBYvYa5miniyvtC5EGee5lbPziwwVCtuwg,9338
+Pyjo/MCP/Resource.py,sha256=RgA7t2qBemMqlfR4j4-Ok7NmfZfRQKPlCsmsdu2Q8Jc,6202
+Pyjo/MCP/ResourceTemplate.py,sha256=DtoMGx7HwTOMVjFZtWtye2hc_mfXLgjQLBvRcQkkWbA,9247
+Pyjo/MCP/Server.py,sha256=9f_GeEA8Q6T8NsOhXU-Qhyxm3IDsWhYXiuhFAeCnGpM,63892
+Pyjo/MCP/Test.py,sha256=n9jcYICIVdoV2mPVcbaOf6Vpgdzbqw6hBVAQBdePFq0,31612
+Pyjo/MCP/Tool.py,sha256=WlzTWm7iOBMMODzFJcnhZORoIkAVjSJbVDfpZEHsdE0,14689
+Pyjo/MCP/__init__.py,sha256=zXw7rQlO8uYhgDxeZ-rVCIlnlFNG7G-jA9EX8FxuPaE,3365
+pyjo_mcp-0.1.0.dist-info/METADATA,sha256=wsTqnrngC77eL7Hkd_v6rlw2s27k0x4_pEPOZ2DCAbQ,6843
+pyjo_mcp-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyjo_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=wqf_RI5i8Of0e_6xwFe7wBhw72jXAkF_9N8Ny9ScaP4,8894
+pyjo_mcp-0.1.0.dist-info/RECORD,,

pyjo_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any