semvec/pypi-packages huggingface dataset:
easymcp 0.4.0
Add your description here
Requires Python: >=3.13

# EasyMCP

EasyMCP is a complete rewrite of the model context protocol (MCP) in Python.

## Installation

```bash
uv add easymcp
```

## Usage

The high level API exposes a ClientManager class that can be used to manage multiple MCP servers.

```python
import asyncio
from easymcp.client.ClientManager import ClientManager
from easymcp.client.transports.stdio import StdioServerParameters

mgr = ClientManager()

searxng = StdioServerParameters(
    command="uvx",
    args=["mcp-searxng"],
)

timeserver = StdioServerParameters(
    command="uvx",
    args=["mcp-timeserver"],
)

servers = {
    "searxng": searxng,
    "timeserver": timeserver,
}

async def main():
    # initialize the client manager
    await mgr.init(servers=servers)

    # list servers
    print(mgr.list_servers())

    # remove a server
    await mgr.remove_server("searxng")

    # add a server
    await mgr.add_server("searxng", searxng)

    # list tools - these are namespaced by server name automatically
    # {server name}.{tool name}
    print(await mgr.list_tools())

    # call tool
    print(await mgr.call_tool("timeserver.get-current-time", {}))

    # list resources - these are namespaced by server name automatically
    # mcp-{server name}+{resource uri}
    print(await mgr.list_resources())

    # read resource
    print(await mgr.read_resource("mcp-timeserver+datetime://Africa/Algiers/now"))

    await asyncio.Future()

asyncio.run(main())
```

## Core Features

- list tools/resources/prompts caching out of the box
- automatic cache invalidation on tool/resource/prompt change notifications
- out of the box support for parallel requests to servers
- full lifecycle management of servers
- dynamic server addition/removal
- namespaced tools/resources/prompts
- lightweight asyncio native implementation

## Why namespace tools?

Namespaced tools remove need to perform a lookup to find the correct tool. This means:

- faster tool calls
- tool calls can be routed across many MCP hosts at scale
- mcp servers do not need globally unique tool names

## Why namespace resources?

Resources are namespaced in a way that makes it easy to make a resource URI to a specific server. You can:

- check if a URL needs to be resolved via mcp by checking if it starts with `mcp`
- check what server to resolve the URI with
- ingest resources into a search system like elastic search without having to store metadata about the server
- completely eliminate the need to map URIs to servers via a database or lookup table

## Comparison of classes to other MCP libraries

| **easyMCP**    | **modelcontextprotocol/python-sdk** |                              |
| -------------- | ----------------------------------- | ---------------------------- |
| ClientManager  |                                     | manages multiple MCP servers |
| ClientSession  | ClientSession                       | manages a single MCP server  |
| StdioTransport | stdio_client                        | raw subprocess transport     |

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
mkdocs-markupsafe-markdown-filter 0.1.1
A MkDocs plugin to add a markdown filter to jinja templates.
Requires Python: >=3.8
Keywords: jinja, mkdocs

# mkdocs-markupsafe-markdown-filter

This plugin adds [pallets' MarkupSafe] template filter to mkdocs.

[pallets' MarkupSafe]: https://github.com/pallets/markupsafe/

## Setup

Install the plugin using pip:

`pip install mkdocs-markupsafe-markdown-filter`

Activate the plugin in `mkdocs.yml`:
```yaml
plugins:
  - search
  - markupsafe-markdown-filter
```

> **Note:** If you have no `plugins` entry in your config file yet, you'll likely also want to add the `search` plugin. This is because MkDocs enables the `search` plugin by default if there is no `plugins` entry set.  When you add a external plugin like `markupsafe-markdown-filter` you have to enable the `search` plugin explicitly.  

More information about plugins in the [MkDocs documentation][mkdocs-plugins].

## Usage

Enabling this plugin will filter jinja template code through a markdown filter:

    {% set code_content %}
    ```php linenums="1"
    <?php
    foo = 1;
    bar = 3;
    if (foo == bar ) {
      // do something 
    }
    ?>
    ```
    {% endset %}
    {{ code_content|markdown }}

## See Also

More information about templates [here][mkdocs-template].

More information about blocks [here][mkdocs-block].

[mkdocs-plugins]: http://www.mkdocs.org/user-guide/plugins/
[mkdocs-template]: https://www.mkdocs.org/user-guide/custom-themes/#template-variables
[mkdocs-block]: https://www.mkdocs.org/user-guide/styling-your-docs/#overriding-template-blocks
vyxm 0.0.1
A modular AI framework with agent protocols, memory, cv and llm based machine learning algorithims.
Requires Python: >=3.8
Keywords: vyxm agents ai protocol transformers multi-agent ml learning memory computer-vision llm neural networks

# Vyxm Protocol

**Modular multi-agent protocol system with planner, distributor, and executor support.**

```python
from vyxm.protocol import Protocall

engine = Protocall()
engine.register_model("code_bot", "gpt2", "transformers", tag="Code")

response = engine.run("Write a Python class for a linked list")
print(response.output_text)
```