Discover Awesome MCP Servers

Maine Burn Permit MCP Server

Enables checking real-time fire danger levels and automating burn permit applications for Maine locations through the Maine Fire Weather system and official burn permit portal.

mcp-md-vector-search

Một triển khai máy chủ MCP (Model Context Protocol) gọn nhẹ, tận dụng PGLite và pgvector để thực hiện các tìm kiếm tương đồng hiệu quả trên các tài liệu Markdown cục bộ.

GitHub MCP Tools

Một chương trình Multi-Claude để tương tác với các API của GitHub thông qua Claude Desktop, cho phép người dùng tìm kiếm kho lưu trữ, quản lý các vấn đề, yêu cầu kéo, cài đặt kho lưu trữ, quy trình làm việc và cộng tác viên.

MCP Server Framework

A general-purpose MCP server that provides utility tools for echo, date/time, and file operations within Claude Code and Claude Desktop. It functions as an extensible framework designed to help developers easily build and register custom Python-based tools.

Example MCP Server

A simple demonstration MCP server that provides a basic 'say_hello' tool for greeting users by name, serving as a template for building MCP servers with TypeScript.

MCP Framework

Một framework TypeScript để xây dựng các máy chủ Model Context Protocol (MCP) với khả năng tự động khám phá và tải các công cụ, tài nguyên và lời nhắc.

Model Context Provider (MCP) Server

Tạo điều kiện tương tác nâng cao với các mô hình ngôn ngữ lớn (LLM) bằng cách cung cấp khả năng quản lý ngữ cảnh thông minh, tích hợp công cụ và điều phối mô hình AI đa nhà cung cấp để có quy trình làm việc dựa trên AI hiệu quả.

NewRelic MCP Server

A comprehensive MCP server providing over 26 tools for querying, monitoring, and analyzing NewRelic data through NRQL queries and entity management. It enables interaction with NewRelic's NerdGraph API for managing alerts, logs, and incidents directly within Claude Code sessions.

MC Pool

A curated collection of Model Context Protocol (MCP) servers for popular SaaS platforms — Stripe, Sentry, Notion, Linear, Datadog, Vercel, PagerDuty, HubSpot, Intercom, Shopify, Google Workspace

FineData MCP Server

Enables AI agents to scrape any website by providing tools for JavaScript rendering, antibot bypass, and automatic captcha solving. It supports synchronous, asynchronous, and batch scraping operations with built-in proxy rotation.

Remote MCP Server

A Cloudflare Workers-based MCP server that enables connecting AI assistants like Claude Desktop to custom tools without authentication requirements.

pinchtab-mcp

Control Chrome via accessibility tree snapshots through PinchTab. Zero-config browser automation with 19 tools.

XServer MCP Server

MCP server for Xserver hosting that provides tools to manage mail accounts, DNS records, server information, and domain verification through natural language.

Cursor10x MCP

The Cursor10x Memory System creates a persistent memory layer for AI assistants (specifically Claude), enabling them to retain and recall short-term, long-term and episodic memory on autonomously.

rag-mcp

An MCP knowledge server that enables saving and retrieving memory across sessions, with tools to ingest text, URLs, YouTube, and files, and perform semantic search.

Wealthfolio MCP Server

Enables AI-powered portfolio analysis for Wealthfolio, allowing Claude to query and analyze investment holdings, asset allocation, real estate properties, and execute transactions through natural language.

fintools-mcp

Provides a comprehensive financial analysis toolkit for AI assistants, featuring technical indicators, options chain analysis, and risk-based position sizing. It enables users to perform stock market analysis and evaluate trade performance using real-time data from Yahoo Finance.

happy-thoughts

Pay-per-thought AI second opinions for autonomous agents. Agents pay 0.01–0.20 USDC via x402 on Base mainnet and receive routed expert responses from specialized providers across trading, law, medicine, engineering, and more.

Customer Registration MCP Server

Enables creating and managing customer records via an external API with Bearer token authentication, supporting required fields (name, email, phone) and extensive optional data including addresses, UTM parameters, and tags.

ShiLiu MCP Server

Enables digital human (avatar) creation, voice cloning, and video generation through ShiLiu API, compatible with any MCP client.

Sociality MCP

Social media analytics, post insights, and competitor benchmarking for AI agents.

Fenshitu MCP

Generates professional A-share intraday stock charts with 1-day and multi-day views, matching Chinese trading software styles.

mcpwatch

MCP server that audits other MCP servers. Run MCPWatch security scans from inside Claude Code or any MCP-compatible agent with 10 OWASP MCP Top 10 aligned checks and A-F letter grades.

TestRail MCP Server

Enables comprehensive TestRail test management integration with support for projects, test cases, runs, results, advanced reporting, analytics, and AutoSpectra test automation framework synchronization.

Settled

Enables AI agents to query a team's decision ledger to check if past decisions are still binding before taking action, via the decisions:// MCP protocol.

aiohttp-mcp

Here are some tools and libraries that can help you build Model Context Protocol (MCP) servers on top of aiohttp in Python: **Core Libraries:** * **aiohttp:** (As you mentioned) This is the fundamental asynchronous HTTP server and client library for Python. You'll use it to handle incoming requests, route them to the appropriate handlers, and send responses. It provides the basic building blocks for your MCP server. * **asyncio:** aiohttp is built on top of `asyncio`, Python's built-in asynchronous I/O framework. You'll need to understand `asyncio` concepts like event loops, coroutines (`async def`), and tasks to effectively use aiohttp. **Libraries for MCP Specifics (Depending on your MCP implementation):** * **Serialization/Deserialization Libraries (for handling MCP messages):** * **protobuf (Protocol Buffers):** If your MCP uses Protocol Buffers for message encoding, you'll need the `protobuf` library and the `grpcio-tools` package (for generating Python code from your `.proto` definitions). This is a very common choice for MCP due to its efficiency and schema definition capabilities. You'll likely use `asyncio` compatible protobuf libraries. Look for examples of using protobuf with `aiohttp`. * **msgpack:** A binary serialization format that's often faster than JSON. The `msgpack` library provides Python bindings. There are `asyncio` compatible versions or wrappers you might need to use. * **JSON:** If your MCP uses JSON, Python's built-in `json` module is sufficient. However, for very high performance, consider `orjson` which is a faster JSON library. * **Other Binary Serialization Formats:** Depending on the specific MCP, you might need libraries for other binary formats like Apache Avro or Thrift. * **Schema Validation (if your MCP requires it):** * **jsonschema:** For validating JSON payloads against a JSON Schema. Useful if your MCP uses JSON and has a defined schema. * **Cerberus:** A lightweight and extensible data validation library. Can be used for validating dictionaries or other data structures. * **gRPC (if your MCP is based on gRPC):** * **grpcio:** The core gRPC library for Python. While gRPC is often used with HTTP/2, you *might* be able to adapt it to work with aiohttp, but this is generally not the recommended approach. gRPC has its own server implementation. If you're using gRPC, you'd typically use the gRPC server directly, not aiohttp. However, you *could* potentially use aiohttp for other parts of your application and gRPC for the MCP endpoint. **Helper Libraries and Patterns:** * **aiohttp-middlewares:** aiohttp supports middlewares, which are functions that can intercept and process requests and responses. You can use middlewares for things like: * Authentication/Authorization * Logging * Request validation * Error handling * **Dependency Injection (e.g., `dependency_injector`):** If your MCP server has complex dependencies (e.g., database connections, model loaders), consider using a dependency injection framework to manage them. This makes your code more testable and maintainable. * **Configuration Management (e.g., `configparser`, `python-decouple`):** Use a library to manage your server's configuration (e.g., port number, database connection strings, model paths). * **Logging (e.g., `logging` module):** Implement proper logging to track requests, errors, and other important events. **Example Structure (Conceptual):** ```python import asyncio import aiohttp from aiohttp import web import logging # Example: Using protobuf # import my_mcp_pb2 # Generated protobuf code # import my_mcp_pb2_grpc # Configure logging logging.basicConfig(level=logging.INFO) async def handle_mcp_request(request): """Handles an incoming MCP request.""" try: # 1. Read the request body (e.g., as bytes) request_body = await request.read() # 2. Deserialize the request body (e.g., using protobuf) # message = my_mcp_pb2.MyRequestMessage() # message.ParseFromString(request_body) # 3. Process the request (e.g., call a model) # result = await process_model(message) # 4. Serialize the response (e.g., using protobuf) # response_message = my_mcp_pb2.MyResponseMessage() # response_message.result = result # response_body = response_message.SerializeToString() # Example using JSON data = await request.json() result = await process_model(data) response_body = web.json_response({"result": result}) # 5. Return the response return response_body except Exception as e: logging.exception("Error handling MCP request") return web.json_response({"error": str(e)}, status=500) # Or appropriate error code async def process_model(data): """Simulates processing a model based on the request.""" # Replace this with your actual model processing logic await asyncio.sleep(0.1) # Simulate some work return f"Model processed data: {data}" async def create_app(): """Creates the aiohttp application.""" app = web.Application() app.add_routes([web.post('/mcp', handle_mcp_request)]) # MCP endpoint return app async def main(): """Runs the aiohttp server.""" app = await create_app() runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) await site.start() logging.info("Server started on http://localhost:8080") try: await asyncio.Future() # Run forever finally: await runner.cleanup() if __name__ == '__main__': asyncio.run(main()) ``` **Key Considerations:** * **Asynchronous Operations:** Ensure that all I/O-bound operations (e.g., reading from the network, writing to a database, calling a model) are performed asynchronously using `async` and `await`. This is crucial for the performance of your aiohttp server. * **Error Handling:** Implement robust error handling to catch exceptions and return appropriate error responses to the client. Use logging to track errors. * **Concurrency:** aiohttp handles concurrency using `asyncio`. You don't typically need to manage threads directly. However, be aware of potential bottlenecks in your code (e.g., CPU-bound operations) and consider using a process pool executor (`asyncio.get_running_loop().run_in_executor`) to offload those operations to separate processes. * **Security:** If your MCP server handles sensitive data, implement appropriate security measures, such as authentication, authorization, and encryption (HTTPS). * **Performance:** Profile your server to identify performance bottlenecks and optimize accordingly. Consider using caching to reduce the load on your models. * **Testing:** Write thorough unit tests and integration tests to ensure that your MCP server is working correctly. Use `aiohttp.test_utils` for testing aiohttp applications. Remember to adapt these suggestions to the specific requirements of your Model Context Protocol. Good luck!

ui-diff-mcp

Enables comparison of mobile app screenshots against design mockups, with Calorix as the first integration target.

gcp-mcp

Enables managing Google Cloud Platform (GCP) resources through natural language commands, including compute instances, storage, databases, and monitoring.

Minted MCP Server

Enables interaction with Minted.com to retrieve address book contacts, order history, and delivery information for recent card orders.

iaas-conversion-mcp

A Model Context Protocol (MCP) server that converts Confluence pages into standardized formats for the IaaS Storage team.