Discover Awesome MCP Servers

Conduit

Enables AI agents to interact with Figma in real-time through a WebSocket connection. Supports comprehensive design operations including text manipulation, layouts, components, variables, and export functionality.

Weather MCP Server

Provides weather forecast and alert information for US locations using the National Weather Service API. Enables users to get detailed weather forecasts by coordinates and retrieve active weather alerts by state.

Vibe Coder MCP

Sebuah server MCP yang memperkuat asisten AI dengan alat canggih untuk pengembangan perangkat lunak, memungkinkan penelitian, perencanaan, pembuatan kode, dan perancangan proyek melalui interaksi bahasa alami.

MCP Dockerized Server

A minimal, containerized MCP server that exposes a Streamable HTTP transport with API key authentication, allowing secure access to MCP endpoints.

MUXI Framework

Kerangka kerja agen AI yang dapat diperluas.

World Bank Data360 MCP Server

Enables access to World Bank Data360 API with 1000+ economic and social indicators across 200+ countries and 60+ years of historical data, allowing searches, temporal coverage checks, and filtered data retrieval through natural language queries.

Generalized MCP Server

Dynamically exposes Python SDKs (Kubernetes, GitHub, Azure) through an agent-friendly gRPC interface. Enables interaction with cloud services and platforms using natural language by automatically converting SDK functionality into callable functions.

New Relic MCP Server

Run NRQL, NerdGraph, and REST v2 operations to query data, manage incidents, create synthetics, and annotate deployments — all from your MCP client.

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!

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

Figma MCP Server

Cermin dari

SimpleWeatherForecastServer

SimpleWeatherForecastServer

MCP Server (Mortgage Comparison Platform)

Server MCP kanonik untuk mengurai PDF Perkiraan Pinjaman (Loan Estimate/LE) dan Pengungkapan Penutupan (Closing Disclosure/CD) menjadi JSON yang sesuai dengan MISMO dengan konteks yang diperkaya LLM. Dibangun untuk otomatisasi, kepatuhan, dan pengambilan keputusan hipotek berbasis AI.

AXYS MCP Lite

Enables AI assistants to search through structured databases and unstructured content (documents, videos, files) using natural language queries with semantic understanding.

example-mcp-server-sse

example-mcp-server-sse

MCP Server Example

A simple example MCP server that demonstrates basic server functionality and can be easily run using uv package manager. Provides a minimal implementation for learning and development purposes.

MCP-Ambari-API

Manage and monitor Hadoop clusters via Apache Ambari API, enabling service operations, configuration changes, status checks, and request tracking through a unified MCP interface for simplified administration. * Guide: https://call518.medium.com/llm-based-ambari-control-via-mcp-8668a2b5ffb9

RFC MCP Server

An MCP server that enables programmatic access to IETF RFC documents, allowing users to fetch, search, and extract specific sections from RFCs.

Personal MCP Server

A personal MCP server for Claude Desktop that enables task management, note-taking, file system operations, and optional Google Calendar integration. Includes comprehensive testing tools and visual monitoring for easy setup and debugging.

MCP Dungeon Game

An idle dungeon crawler game playable through conversation, featuring equipment collection, time-based dungeon exploration, auto-battles, random events, and encrypted local save data.

LangChain MCP

A Multi-Server Control Plane system that enables natural language querying of job listings and employee feedback data through two specialized servers built with LangChain.

AI

Here are some things related to artificial intelligence: * **Machine Learning (Pembelajaran Mesin):** Algorithms that allow computers to learn from data without being explicitly programmed. (Algoritma yang memungkinkan komputer untuk belajar dari data tanpa diprogram secara eksplisit.) * **Deep Learning (Pembelajaran Mendalam):** A subfield of machine learning that uses artificial neural networks with multiple layers to analyze data. (Subbidang pembelajaran mesin yang menggunakan jaringan saraf tiruan dengan banyak lapisan untuk menganalisis data.) * **Natural Language Processing (NLP) (Pemrosesan Bahasa Alami):** The ability of computers to understand, interpret, and generate human language. (Kemampuan komputer untuk memahami, menafsirkan, dan menghasilkan bahasa manusia.) * **Computer Vision (Visi Komputer):** The ability of computers to "see" and interpret images and videos. (Kemampuan komputer untuk "melihat" dan menafsirkan gambar dan video.) * **Robotics (Robotika):** The design, construction, operation, and application of robots. (Desain, konstruksi, operasi, dan aplikasi robot.) * **Expert Systems (Sistem Pakar):** Computer systems that emulate the decision-making ability of a human expert. (Sistem komputer yang meniru kemampuan pengambilan keputusan seorang ahli manusia.) * **AI Ethics (Etika AI):** The moral principles and values that should guide the development and use of AI. (Prinsip dan nilai moral yang harus memandu pengembangan dan penggunaan AI.) * **AI Safety (Keamanan AI):** Research and practices aimed at ensuring that AI systems are safe and beneficial to humanity. (Penelitian dan praktik yang bertujuan untuk memastikan bahwa sistem AI aman dan bermanfaat bagi umat manusia.) * **AI Applications (Aplikasi AI):** The use of AI in various industries, such as healthcare, finance, transportation, and education. (Penggunaan AI di berbagai industri, seperti perawatan kesehatan, keuangan, transportasi, dan pendidikan.) * **AI Research (Penelitian AI):** Ongoing efforts to advance the field of AI through theoretical and experimental investigations. (Upaya berkelanjutan untuk memajukan bidang AI melalui investigasi teoretis dan eksperimental.) * **Neural Networks (Jaringan Saraf Tiruan):** Computational models inspired by the structure and function of the human brain. (Model komputasi yang terinspirasi oleh struktur dan fungsi otak manusia.) * **Generative AI (AI Generatif):** AI models that can generate new content, such as text, images, and music. (Model AI yang dapat menghasilkan konten baru, seperti teks, gambar, dan musik.) * **Reinforcement Learning (Pembelajaran Penguatan):** A type of machine learning where an agent learns to make decisions by interacting with an environment. (Jenis pembelajaran mesin di mana agen belajar membuat keputusan dengan berinteraksi dengan lingkungan.) * **AI Hardware (Perangkat Keras AI):** Specialized hardware designed to accelerate AI computations. (Perangkat keras khusus yang dirancang untuk mempercepat komputasi AI.) * **AI Governance (Tata Kelola AI):** The frameworks and policies used to manage the development and deployment of AI systems. (Kerangka kerja dan kebijakan yang digunakan untuk mengelola pengembangan dan penerapan sistem AI.)

Quranic Etymology Explorer

AI-powered educational platform for analyzing Quranic words through etymology, frequency patterns, and cross-linguistic research, providing complete project context for AI-assisted development.

Odoo MCP Unified Server

Enables interaction with Odoo ERP systems through 17+ business tools covering sales, purchasing, inventory, and accounting operations. Supports both Claude Desktop integration and web deployment with dual transport modes.

EuConquisto Composer MCP

Enables direct creation and management of educational content on the EuConquisto Composer platform through a 7-step workflow. Supports lesson creation, content validation, and Brazilian education standards compliance

mcp-web-audit

A Node.js-based frontend security audit tool that performs comprehensive dependency security audits for both local projects and remote repositories. Generates detailed Markdown reports with vulnerability detection, risk assessment, and fix recommendations.

MCSManager MCP Server

Enables AI agents to manage Minecraft servers through MCSManager, including instance control (start/stop/restart), file management, scheduled tasks, user management, and backup operations.

Strava MCP Server

Enables AI assistants to retrieve and display Strava activity data including workout details, distance, time, and dates. Currently uses sample data but can be extended for real Strava API integration.

MCP Router

MCP Router memungkinkan Anda mengelola server MCP (Model Context Protocol) Anda dengan mudah.