Discover Awesome MCP Servers

mcp-playwright

this is my first mcp

MCP GitHub Project Manager

A comprehensive server that provides AI-powered GitHub project management with task generation from requirements and complete traceability from business requirements to implementation.

Zephyr MCP Server

A lightweight server that simplifies building and flashing Zephyr RTOS projects through a REST API, allowing remote control of the microcontroller programming workflow.

Sugar CRM MCP Server by CData

This read-only MCP Server allows you to connect to Sugar CRM data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

OpenRouter Search MCP Server

Here are a few ways to translate "MCP server for OpenRouter search functionality" into Indonesian, depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Server MCP untuk fungsionalitas pencarian OpenRouter** * This is a direct translation and easily understood. "MCP" is likely best left as is, assuming it's an acronym. **Option 2 (Slightly more descriptive):** * **Server MCP untuk fungsi pencarian di OpenRouter** * This uses "fungsi" instead of "fungsionalitas," which can sound a bit more natural in Indonesian. **Option 3 (Focus on the purpose):** * **Server MCP yang digunakan untuk fungsi pencarian OpenRouter** * This translates to "MCP server *that is used* for OpenRouter search function." It emphasizes the server's purpose. **Option 4 (If MCP is a specific type of server):** * **Server [Jenis Server MCP] untuk fungsionalitas pencarian OpenRouter** * If "MCP" refers to a specific type of server (e.g., "Server Database MCP"), replace "[Jenis Server MCP]" with the appropriate term. **Which option is best depends on the context.** If you want the most direct and simple translation, Option 1 is a good choice. If you want to emphasize the purpose, Option 3 is better. If MCP is a specific type of server, Option 4 is the most accurate.

mcp-server-for-local

Halo semuanya! Saya adalah layanan MCP kaya fitur, yang dirancang untuk menjembatani kesenjangan antara perangkat dan layanan, serta menghadirkan pengalaman yang nyaman bagi pengguna. Alat cuaca terhubung dengan platform meteorologi untuk dengan cepat memberikan informasi cuaca real-time global kepada pengguna, membantu semua orang merencanakan perjalanan. Alat kontrol browser mensimulasikan operasi manual, secara otomatis mencari dan menjelajahi halaman web, sehingga menghemat banyak waktu. Alat kamera memanggil kamera lokal untuk mengambil foto dan merekam video, serta menerapkan pengenalan wajah untuk memastikan keamanan rumah. Untuk mewujudkan kolaborasi alat, saya membangun kerangka kerja yang stabil, sehingga pengembang dapat melakukan ekspansi berdasarkan layanan yang ada.

mcp-image-compression

Here are a few options for translating "MCP server for local compression of various image formats" into Indonesian, depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Server MCP untuk kompresi lokal berbagai format gambar.** * This is a direct translation and easily understood. **Option 2 (Slightly more descriptive):** * **Server MCP untuk kompresi lokal berbagai macam format gambar.** * Using "macam" (kind/type) adds a bit more emphasis on the variety of image formats. **Option 3 (Focus on functionality):** * **Server MCP untuk melakukan kompresi lokal pada berbagai format gambar.** * Using "melakukan" (to perform/do) emphasizes the action of compression. **Option 4 (More formal):** * **Server MCP untuk kompresi lokal terhadap berbagai format citra.** * Using "citra" instead of "gambar" is slightly more formal and technical. **Which option is best depends on the context:** * For general use, **Option 1** is perfectly fine. * If you want to emphasize the variety of formats, use **Option 2**. * If you want to emphasize the action of compression, use **Option 3**. * If you're writing for a technical audience, **Option 4** might be more appropriate. Therefore, I recommend **Option 1: Server MCP untuk kompresi lokal berbagai format gambar.** unless you have a specific reason to choose one of the others.

Raworc MCP Server

Enables AI assistants to interact with Raworc's agent runtime platform through seamless integration. Supports session management, message handling, space and agent management, and secure secret storage operations.

Furikake

A local CLI & API for MCP management that allows users to download, install, manage, and interact with MCPs from GitHub, featuring process state management, port allocation, and HTTP API routes.

Android Debug Bridge MCP

Enables control of Android devices via ADB for automation and testing. Supports app management, screen capture, UI analysis, and input simulation through natural language commands.

AiryLark MCP Translation Server

Server ModelContextProtocol yang menyediakan layanan terjemahan berkualitas tinggi dengan alur kerja terjemahan tiga tahap (analisis, terjemahan tersegmentasi, peninjauan teks lengkap) yang mendukung berbagai bahasa dan terintegrasi dengan model yang kompatibel dengan Claude dan OpenAI.

Remote MCP Server with WorkOS AuthKit

An example MCP server that allows remote clients to connect and authenticate using WorkOS AuthKit, providing organization-centric authentication with permission-based access control for tools.

Nara Market FastMCP Server

Provides access to South Korean government procurement (G2B) and Nara Market shopping mall data, enabling users to search bid announcements, procurement statistics, product catalogs, and contract information through 15 specialized tools.

MCP client-server

make MCP Client&Server

MCP-Server-and-client-Implementation-on-Linux

Here's a breakdown of implementing an MCP (Minecraft Protocol) server and client on Linux, focusing on a more programmatic approach rather than relying on the Claude Desktop application (which isn't directly related to Minecraft server/client development): **Understanding the Minecraft Protocol (MCP)** The Minecraft Protocol is the language that Minecraft clients and servers use to communicate. It's a binary protocol, meaning data is sent as raw bytes, not human-readable text. It's complex and constantly evolving with each Minecraft version. You'll need to understand the protocol version you're targeting. **Key Considerations Before You Start** * **Minecraft Version:** The protocol changes with each Minecraft version. Choose a version to target (e.g., 1.19.4, 1.20.1, etc.). Older versions are easier to work with initially. * **Programming Language:** Choose a language you're comfortable with. Popular choices include: * **Java:** The language Minecraft is written in. Offers the most direct access to Minecraft internals (if you're modding). * **Python:** Easy to learn and has good networking libraries. Great for prototyping and simpler clients/bots. * **C/C++:** For performance-critical applications. Requires more low-level network programming. * **Go:** Good for concurrency and networking. * **Libraries:** Use libraries to handle the low-level details of socket communication, data serialization/deserialization, and potentially encryption. This will save you a lot of time and effort. * **Documentation:** The official Minecraft Wiki is a good starting point, but it's not a complete protocol specification. Look for community-maintained protocol documentation (see resources below). **General Steps for Server Implementation** 1. **Set up a Socket Server:** * Create a TCP socket that listens on port 25565 (the default Minecraft port). * Use `bind()` to associate the socket with an address and port. * Use `listen()` to start listening for incoming connections. * Use `accept()` to accept incoming client connections. This creates a new socket for each client. 2. **Handle Client Connections:** * For each client connection, create a new thread or process to handle it concurrently. This prevents one slow client from blocking the entire server. * **Handshaking:** The first thing a client does is send a handshake packet. This packet contains: * Protocol Version: The version of the Minecraft protocol the client is using. * Server Address: The address the client connected to. * Server Port: The port the client connected to. * Next State: Either 1 (status) or 2 (login). * **Status (if Next State is 1):** * The client sends a "Request" packet (empty). * The server sends a "Response" packet containing a JSON string with server information (description, players, version). * The client may send a "Ping" packet with a timestamp. * The server responds with a "Pong" packet containing the same timestamp. * **Login (if Next State is 2):** * The client sends a "Login Start" packet with the player's username. * **Authentication (Optional but Recommended):** Implement authentication to prevent unauthorized access. This usually involves contacting Mojang's authentication servers. * The server sends a "Login Success" packet with the player's UUID and username. * The server sends a "Join Game" packet to tell the client about the world. 3. **Game Logic:** * This is where the real work begins. You need to: * Receive and parse packets from the client (e.g., chat messages, movement, block placement). * Update the game world based on client actions. * Send packets to the client to update their view of the world (e.g., block updates, entity movements, chat messages). * This involves managing the game world, entities, players, and all the other aspects of a Minecraft server. **General Steps for Client Implementation** 1. **Create a Socket:** * Create a TCP socket. * Use `connect()` to connect to the server's address and port. 2. **Handshaking:** * Send the handshake packet to the server. Specify the protocol version, server address, port, and next state (usually 2 for login). 3. **Login:** * Send the "Login Start" packet with your username. * Handle authentication (if required by the server). * Receive the "Login Success" and "Join Game" packets. 4. **Game Loop:** * Continuously: * Send packets to the server (e.g., movement, chat messages). * Receive packets from the server (e.g., world updates, entity movements, chat messages). * Update the game state based on received packets. * Render the game world. **Example (Conceptual Python - Requires Libraries)** ```python import socket import struct import json # --- Server Example (Simplified) --- def handle_client(client_socket): try: # Receive handshake handshake_packet = client_socket.recv(256) # Adjust buffer size as needed # ... (Parse handshake packet - see below for details) ... # Example: Respond to status request response_data = { "version": {"name": "My Server", "protocol": 757}, # Example protocol version "players": {"max": 10, "online": 0}, "description": {"text": "A simple server"} } response_json = json.dumps(response_data) response_packet = create_string_packet(response_json) # Function to create a packet client_socket.sendall(response_packet) # ... (Handle other packets, login, game logic) ... except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() def create_string_packet(data): # Example: Create a packet with a string (using Minecraft's VarInt encoding) string_bytes = data.encode('utf-8') length = len(string_bytes) varint_length = encode_varint(length) # Function to encode length as VarInt packet_data = varint_length + string_bytes packet_length = len(packet_data) varint_packet_length = encode_varint(packet_length) return varint_packet_length + packet_data def encode_varint(value): # Encodes an integer as a Minecraft VarInt data = bytearray() while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 data.append(byte) if value == 0: break return bytes(data) # --- Client Example (Simplified) --- def connect_to_server(server_address, server_port): try: client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect((server_address, server_port)) # Create and send handshake packet protocol_version = 757 # Example protocol version server_address_str = server_address server_port_int = server_port next_state = 1 # Status handshake_packet = create_handshake_packet(protocol_version, server_address_str, server_port_int, next_state) client_socket.sendall(handshake_packet) # Receive status response status_packet = client_socket.recv(4096) # Adjust buffer size # ... (Parse status packet - see below for details) ... # ... (Handle other packets, login, game logic) ... except Exception as e: print(f"Error connecting to server: {e}") finally: client_socket.close() def create_handshake_packet(protocol_version, server_address, server_port, next_state): # Creates the handshake packet packet_id = 0x00 # Handshake packet ID packet_data = encode_varint(packet_id) protocol_version_bytes = encode_varint(protocol_version) packet_data += protocol_version_bytes server_address_bytes = server_address.encode('utf-8') server_address_length = encode_varint(len(server_address_bytes)) packet_data += server_address_length + server_address_bytes packet_data += struct.pack(">H", server_port) # Pack port as big-endian unsigned short next_state_bytes = encode_varint(next_state) packet_data += next_state_bytes packet_length = len(packet_data) packet = encode_varint(packet_length) + packet_data return packet # Example usage if __name__ == "__main__": # Server (in a separate thread/process) # server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # server_socket.bind(('0.0.0.0', 25565)) # server_socket.listen(5) # while True: # client_socket, client_address = server_socket.accept() # # Start a new thread to handle the client # import threading # client_thread = threading.Thread(target=handle_client, args=(client_socket,)) # client_thread.start() # Client connect_to_server("localhost", 25565) ``` **Important Notes on the Example:** * **Incomplete:** This is a very simplified example. It only shows the basic handshake and status request/response. You'll need to implement the full protocol for login, game logic, etc. * **Error Handling:** The example lacks proper error handling. You should add `try...except` blocks to catch potential exceptions (e.g., network errors, invalid data). * **VarInt Encoding:** Minecraft uses a variable-length integer encoding called VarInt. The `encode_varint` function shows how to encode an integer as a VarInt. You'll need to decode VarInts when receiving packets. * **Packet Structure:** Minecraft packets have a specific structure: * Packet Length (VarInt): The length of the packet data. * Packet ID (VarInt): Identifies the type of packet. * Packet Data: The actual data of the packet, which varies depending on the packet ID. * **Libraries:** Consider using libraries like `struct` (for packing/unpacking binary data), `json` (for handling JSON data), and a dedicated Minecraft protocol library (if available for your language). **Libraries and Resources** * **Python:** * `mcstatus`: A library for querying Minecraft server status. Useful for getting server information. * `nbt`: A library for reading and writing NBT data (used for storing world data). * `python-minecraft-protocol`: A library for handling the Minecraft protocol. * **Java:** * `MinecraftForge`: A popular modding API that provides access to Minecraft internals. * `ProtocolLib`: A Bukkit plugin that allows you to intercept and modify Minecraft packets. * **General Resources:** * **Wiki.vg:** Excellent, community-maintained documentation of the Minecraft protocol: [https://wiki.vg/Protocol](https://wiki.vg/Protocol) * **Minecraft Protocol Documentation:** Search online for documentation specific to the Minecraft version you're targeting. * **GitHub:** Search GitHub for open-source Minecraft server and client implementations in your chosen language. These can be valuable learning resources. **Steps to Take** 1. **Choose a Minecraft Version:** Start with an older version (e.g., 1.12.2, 1.16.5) to simplify the initial implementation. 2. **Choose a Programming Language:** Select a language you're comfortable with. 3. **Study the Protocol:** Thoroughly read the Minecraft protocol documentation for your chosen version. Understand the packet structure, data types, and packet IDs. 4. **Start with Handshaking and Status:** Implement the handshake and status request/response. This will give you a basic understanding of how to send and receive packets. 5. **Implement Login:** Implement the login process, including authentication (if necessary). 6. **Implement Basic Game Logic:** Start with simple game logic, such as handling chat messages or player movement. 7. **Iterate and Expand:** Gradually add more features and complexity to your server or client. **Important Considerations for Linux** * **Firewall:** Make sure your firewall allows connections to port 25565 (or whatever port you're using). * **Permissions:** Ensure that the user running your server or client has the necessary permissions to access the network. * **Dependencies:** Install any required libraries or dependencies using your Linux distribution's package manager (e.g., `apt`, `yum`, `pacman`). Building a Minecraft server or client from scratch is a challenging but rewarding project. Be patient, persistent, and don't be afraid to ask for help from the Minecraft development community. Good luck!

Amadeus MCP Server

Server Protokol Konteks Model yang terhubung ke Amadeus API, memungkinkan asisten AI untuk mencari penerbangan, menganalisis harga, menemukan penawaran perjalanan terbaik, dan merencanakan perjalanan multi-kota.

Jira-GitLab MCP Server

Integrates Jira and GitLab to enable AI agents to seamlessly manage issues, create branches, and automate SRE workflows from issue detection to fix deployment. Features AI-powered analysis for intelligent code generation and comprehensive automation across both platforms.

WHOOP MCP Server

Enables access to WHOOP fitness and health data through all WHOOP v2 API endpoints. Supports OAuth 2.0 authentication and provides comprehensive access to user profiles, physiological cycles, recovery metrics, sleep analysis, and workout data.

Figma MCP Server

Cermin dari

Lark Base MCP Server

A Model Context Protocol server that provides LLMs with read and write access to Feishu Base (飞书多维表格) databases, enabling them to inspect schemas and manipulate records through natural language.

MCPX MCP Gateway

MCPX is a remote-first MCP aggregator that enables zero-code integration, unified access, and dynamic routing across multiple MCP servers. It offers tool-level access controls, usage visibility, and customization to streamline and secure agentic workflows.

MCP Tools

Provides context management and todo persistence with AI second opinions from ChatGPT and Claude. Enables saving code snippets, conversations, and todos across sessions with full-text search capabilities.

figma-mcp-flutter-test

Proyek eksperimen untuk mereproduksi desain Figma di Flutter menggunakan Figma MCP Server.

Microsoft Excel MCP Server by CData

Microsoft Excel MCP Server by CData

MCP Server Demo

A Python-based Model Context Protocol server with Streamlit chat interface that allows users to manage a PostgreSQL database through both web UI and MCP tools, powered by Ollama for local LLM integration.

MedixHub Model Context Protocol (MCP) Server

MedixHub - Sebuah server Protokol Konteks Model (MCP) dengan koleksi API dan alat medis dan perawatan kesehatan.