Userful Mcps

🚀 Useful Model Library

This is a library for building and using useful models. It offers a variety of tools and services to assist users in completing various tasks.

🚀 Quick Start

This library provides a range of tools and services to help users accomplish diverse tasks.

✨ Features

• Offers a variety of tools and services for different tasks.
• Allows users to build and use useful models easily.

📦 Installation

You can install the library using the following command:

pip install useful-models

💻 Usage Examples

Basic Usage

Create a Simple Server

from mcp import Server, Tool, TextContent, stdio_server
import logging

class MyService:
    def __init__(self):
        # Resource preparation during service initialization
        pass

    def my_function(self, param1: str, param2: int) -> dict:
        # Implement specific business logic
        logging.info(f"Execute my_function with parameters {param1=}, {param2=}")
        result_content = f"Result: Successfully processed {param1} and {param2}"
        return {"content": result_content}

async def serve() -> None:
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
    server = Server("mcp-my-service")
    service = MyService()

    @server.list_tools()
    async def list_tools() -> list[Tool]:
        logging.info("list_tools is called")
        return [
            Tool(
                name="my.tool",
                description="My tool description",
                inputSchema={"type": "object", "properties": {"param1": {"type": "string"}, "param2": {"type": "integer"}}, "required": ["param1", "param2"]}
            ),
        ]

    @server.call_tool()
    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
        logging.info(f"call_tool is called with tool name {name=} and arguments {arguments=}")
        try:
            if name == "my.tool":
                param1 = arguments.get("param1")
                param2 = arguments.get("param2")
                if not (param1 and param2):
                    raise ValueError("Missing required parameters")

                result = service.my_function(param1, int(param2))
                logging.info(f"Tool executed successfully with result {result=}")
                return [TextContent(type="text", text=json.dumps(result))]
            else:
                logging.warning(f"An unknown tool is requested: {name}")
                raise ValueError(f"Unknown tool: {name}")
        except Exception as e:
            logging.error(f"Error occurred while executing tool {name}: {e}", exc_info=True)
            error_payload = json.dumps({"error": str(e)})
            return [TextContent(type="text", text=error_payload)]

    options = server.create_initialization_options()
    logging.info("Starting the MCP server...")
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, options)
    logging.info("The MCP server has stopped.")

def main():
    try:
        asyncio.run(serve())
    except KeyboardInterrupt:
        logging.info("The server has been interrupted by the user.")

if __name__ == "__main__":
    # Allow debugging by directly running the script
    main()

Project Structure

• useful-models/: Contains the implementation of all models and tools.
• tests/: Stores test files to ensure code quality.

Testing

You can run the tests from the root directory using the following command:

pytest tests/

⚠️ Important Note

Please make sure pytest is installed.

📄 License

This project is licensed under the MIT License. The specific terms are as follows:

• Anyone is allowed to use, copy, modify, and distribute this software freely.
• Modified versions must be clearly marked in the documentation.
• No fees are required.

🤝 Contribution Guidelines

We welcome everyone to contribute code! Please follow these steps:

1. Fork the project repository.
2. Develop on your own branch.
3. Submit your code and create a Pull Request.

Let's work together to make this model library even more useful!