Discover Awesome MCP Servers

kagi-kan-mcp

Unofficial MCP server for working with Kagi without API access (you'll need to be a customer, tho). Searches and summarizes. Uses Kagi session token for easy authentication.

Foundry VTT MCP Bridge

Connects Claude Desktop to Foundry VTT for AI-powered campaign management, enabling natural language interaction with game data including quest creation, character management, compendium searches, and dice rolling. Provides 20 MCP tools for seamless integration between Claude and your tabletop RPG sessions.

Automated-Webflow

Connecting MCP (likely referring to a Minecraft Protocol) servers directly to a Webflow project is **not directly possible** without some form of intermediary. Webflow is a website builder primarily designed for static content and dynamic content sourced from its CMS or external APIs. Minecraft servers, on the other hand, operate on a different protocol and don't directly integrate with Webflow's capabilities. Here's a breakdown of why and how you can achieve something similar: **Why Direct Connection Isn't Possible:** * **Different Protocols:** Minecraft servers use the Minecraft Protocol (MCP) for communication, while Webflow uses HTTP/HTTPS for web requests. They are fundamentally incompatible. * **Webflow's Limitations:** Webflow is not designed to handle real-time, persistent connections like those required for a Minecraft server. * **Security Concerns:** Directly exposing a Minecraft server to the internet without proper security measures is a significant risk. **How to Achieve a Similar Result (Displaying Server Status on Webflow):** The most common approach involves using an intermediary server or service to fetch the Minecraft server status and then display that information on your Webflow site. Here's a general outline: 1. **Choose an Intermediary:** You'll need something to bridge the gap between your Webflow site and your Minecraft server. Here are a few options: * **Custom API (Node.js, Python, etc.):** This is the most flexible but requires coding. You'd write a script that: * Queries the Minecraft server for its status (player count, MOTD, etc.). Libraries like `minecraft-server-util` (Node.js) or `mcstatus` (Python) can help. * Exposes this data through a simple API endpoint (e.g., `/api/minecraft-status`). * **Third-Party Minecraft Server Status API:** There are services specifically designed to provide Minecraft server status information via API. Examples include: * [https://api.mcsrvstat.us/](https://api.mcsrvstat.us/) * [https://minecraftapi.com/](https://minecraftapi.com/) * (Search for "Minecraft Server Status API" for more options) * **Serverless Functions (Netlify Functions, AWS Lambda, etc.):** Similar to a custom API, but hosted on a serverless platform. This can be a cost-effective option for low-traffic sites. 2. **Implement the Intermediary:** * **Custom API:** Write the code to query the Minecraft server and expose the data via an API endpoint. Deploy this API to a hosting platform (e.g., Heroku, DigitalOcean, AWS). * **Third-Party API:** Sign up for an account (if required) and obtain an API key. Familiarize yourself with the API documentation. * **Serverless Function:** Write the code to query the Minecraft server and return the data. Deploy the function to your chosen serverless platform. 3. **Fetch Data from Webflow:** * **Webflow CMS (Recommended):** If you want to update the server status periodically, you can use the Webflow CMS. * Create a CMS collection (e.g., "Minecraft Servers"). * Add fields for server name, IP address, player count, MOTD, etc. * Use a tool like Zapier or Make (Integromat) to schedule updates to the CMS collection. Zapier/Make will call your API (or the third-party API) and update the CMS fields. * Bind the CMS fields to elements on your Webflow page. * **Custom Code (Less Recommended):** You can use custom code in Webflow to fetch the data directly from your API using JavaScript's `fetch` API. However, this is generally less maintainable and can be more complex. You'll need to handle CORS issues and potentially use a proxy server. 4. **Display the Data on Webflow:** * Once the data is in your Webflow CMS or available via custom code, you can use Webflow's designer to display the server status information on your page. **Example (Using a Third-Party API and Webflow CMS with Zapier):** 1. **Choose a Third-Party API:** Let's say you choose `api.mcsrvstat.us`. 2. **Webflow CMS Setup:** * Create a CMS collection called "Minecraft Servers". * Add fields: * `Server Name` (Text) * `IP Address` (Text) * `Players Online` (Number) * `Max Players` (Number) * `MOTD` (Text) * `Online` (Boolean) 3. **Zapier Setup:** * **Trigger:** "Schedule by Zapier" (e.g., every 5 minutes). * **Action:** "Get Minecraft Server Status" (Custom Webhook). * **Method:** `GET` * **URL:** `https://api.mcsrvstat.us/2/<YOUR_SERVER_IP>` (Replace `<YOUR_SERVER_IP>` with your server's IP address) * **Headers:** (Usually none required) * **Action:** "Update Webflow CMS Item". * Connect your Webflow account. * Select your "Minecraft Servers" collection. * Map the data from the API response to the CMS fields: * `Server Name`: (You might hardcode this or get it from the API if available) * `IP Address`: (You might hardcode this) * `Players Online`: `data.players.online` * `Max Players`: `data.players.max` * `MOTD`: `data.motd.clean[0]` (This might need adjustment depending on the API's MOTD format) * `Online`: `data.online` 4. **Webflow Design:** * Create a page or section on your Webflow site. * Add a Collection List element and connect it to your "Minecraft Servers" collection. * Add text elements inside the Collection Item and bind them to the CMS fields (Server Name, Players Online, etc.). * Style the elements as desired. **Important Considerations:** * **API Rate Limits:** Be mindful of the rate limits of any third-party API you use. Don't make requests too frequently. * **Error Handling:** Implement error handling in your API or Zapier/Make setup to gracefully handle cases where the Minecraft server is offline or the API is unavailable. * **Security:** If you're using a custom API, secure it properly to prevent unauthorized access. * **Caching:** Consider caching the server status data to reduce the load on your Minecraft server and API. * **CORS:** If you're using custom code in Webflow to fetch data from your API, you'll need to configure CORS on your API server to allow requests from your Webflow domain. In summary, directly connecting a Minecraft server to Webflow isn't possible. You need an intermediary (API or service) to fetch the server status and then display that information on your Webflow site, typically using the Webflow CMS and a tool like Zapier or Make for scheduled updates.

HubDB MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for HubDB (beta): https://www.cdata.com/download/download.aspx?sku=KTZK-V&type=beta

Shopping MCP Server (Amazon + Target)

Enables AI assistants to search products, manage shopping carts, place orders, and retrieve order history from Amazon and Target accounts.

Tableau MCP Server

Enables discovery, querying, and exporting of Tableau Cloud dashboards and data sources. Supports searching workbooks, filtering data, and exporting views as PDF, PNG, PowerPoint, CSV, or JSON.

Netbox MCP Server

A powerful integration server that combines Netbox's network infrastructure management capabilities with MCP (Multi-Cloud Platform) functionality.

MCP Book Search Server

An intelligent book search server that leverages Aladin Book API and OpenAI GPT to transform natural language search requests into structured search parameters for finding relevant books.

Aha! MCP Server

Enables interaction with Aha! product management platform through GraphQL API. Supports retrieving features, requirements, and pages by reference number, as well as searching documents across Aha! workspaces.

FinanceMCP

A TypeScript-based MCP server that enables users to query financial news, stock data, and index information while managing text notes with creation and summarization capabilities.

MCP Server Demo

A demonstration MCP server that provides calculator tools for arithmetic operations, personalized greeting resources, and code review prompt templates. Enables users to perform basic math calculations, generate dynamic greetings, and access reusable code review templates through the Model Context Protocol.

Google Drive MCP Server

Enables AI agents to efficiently access and process Google Drive documents by converting them to markdown and offering selective content extraction. Features intelligent caching, advanced search capabilities, and respect for Drive permissions to optimize context window usage.

mcp-test

Okay, here are some general concepts and a basic outline for integrating an MCP (presumably referring to a Minecraft Protocol) server with Large Language Model (LLM) applications. This is a complex topic, and the specifics will depend heavily on your goals and the specific LLM and Minecraft server you're using. **Understanding the Core Concepts** * **Minecraft Protocol (MCP):** This is the communication protocol used between Minecraft clients and servers. It's a binary protocol, meaning it's not human-readable. You'll need libraries to encode and decode these packets. * **LLMs (Large Language Models):** These are AI models trained on massive datasets of text and code. They can generate text, translate languages, answer questions, and more. Examples include GPT-3/GPT-4, LaMDA, and open-source models like Llama 2. * **Integration Goal:** The goal is to allow the LLM to interact with the Minecraft server in some way. This could involve: * **Reading Server State:** Getting information about the world, players, entities, etc. * **Sending Commands:** Having the LLM issue commands to the server (e.g., `/say`, `/tp`, `/give`). * **Responding to Events:** Having the LLM react to events happening in the game (e.g., a player joining, a block being broken, a chat message being sent). * **Generating Content:** Using the LLM to create stories, quests, or even build structures within the game. **High-Level Architecture** The typical architecture involves these components: 1. **Minecraft Server:** The standard Minecraft server (e.g., Vanilla, Spigot, Paper). 2. **MCP Library/Wrapper:** A library that handles the Minecraft Protocol. This is crucial for encoding and decoding packets. Examples: * **Python:** `mcstatus`, `nbt`, `minecraft-protocol` * **Java:** `minecraft-server-util`, `netty` (for low-level protocol handling) * **Node.js:** `minecraft-protocol` 3. **Bridge/Middleware:** This is the code that connects the Minecraft server and the LLM. It typically does the following: * **Listens for Events:** Monitors the Minecraft server for relevant events (e.g., chat messages, player actions). * **Translates Data:** Converts data from the Minecraft Protocol into a format suitable for the LLM (e.g., text strings, JSON). * **Sends Data to LLM:** Sends the data to the LLM API. * **Receives LLM Response:** Gets the response from the LLM. * **Translates LLM Response:** Converts the LLM's response into Minecraft commands or actions. * **Sends Commands to Server:** Sends the commands to the Minecraft server using the MCP library. 4. **LLM API:** The API for the Large Language Model you're using (e.g., OpenAI API, Cohere API, a locally hosted LLM). **Basic Steps for Integration** 1. **Choose a Programming Language and Libraries:** Select a language (Python, Java, Node.js are common) and the appropriate MCP library. Consider the ease of use, performance, and available documentation. 2. **Set Up Minecraft Server:** Install and configure your Minecraft server. Make sure you can connect to it. 3. **Implement MCP Connection:** Write code to connect to the Minecraft server using your chosen MCP library. You'll need the server's IP address and port. 4. **Event Handling:** Implement code to listen for events on the Minecraft server. Start with a simple event like chat messages. Parse the MCP packets to extract the relevant information (e.g., the player's name and the message). 5. **LLM API Integration:** * **Get API Key:** Obtain an API key from your chosen LLM provider (e.g., OpenAI). * **Install LLM Library:** Install the appropriate library for interacting with the LLM API (e.g., `openai` for Python). * **Send Data to LLM:** Send the relevant data (e.g., the chat message) to the LLM API. You'll need to format the data as a prompt. 6. **Process LLM Response:** Receive the response from the LLM. This will typically be a text string. Parse the response to extract the desired information or command. 7. **Send Commands to Minecraft Server:** Use the MCP library to send commands to the Minecraft server based on the LLM's response. For example, if the LLM responds with "`/say Hello, world!`", you would send the appropriate MCP packet to execute that command. 8. **Error Handling:** Implement robust error handling to catch exceptions and prevent your application from crashing. **Example Scenario: LLM Responding to Chat Messages** Let's say you want the LLM to respond to chat messages in the game. 1. **Player types:** "What is the meaning of life?" 2. **Bridge:** * Receives the chat message event. * Extracts the player's name and the message. * Formats the message as a prompt for the LLM: `"A player named [player_name] asked: What is the meaning of life?"` * Sends the prompt to the LLM API. 3. **LLM:** Processes the prompt and generates a response (e.g., "The meaning of life is 42."). 4. **Bridge:** * Receives the LLM's response. * Formats the response as a Minecraft command: `"/say [LLM] The meaning of life is 42."` * Sends the command to the Minecraft server. 5. **Minecraft Server:** Executes the command, and the message "\[LLM] The meaning of life is 42." is displayed in the chat. **Code Snippet (Python - Conceptual)** ```python # This is a simplified example and requires proper MCP library setup import mcstatus import openai # Minecraft server details server_address = "your_server_ip:25565" # OpenAI API key openai.api_key = "YOUR_OPENAI_API_KEY" def handle_chat_message(player_name, message): """Handles a chat message by sending it to the LLM and executing the response.""" prompt = f"A player named {player_name} said: {message}" response = openai.Completion.create( engine="text-davinci-003", # Choose an appropriate LLM engine prompt=prompt, max_tokens=50, ) llm_response = response.choices[0].text.strip() # Format the LLM response as a Minecraft command minecraft_command = f"/say [LLM] {llm_response}" # Send the command to the Minecraft server (using your MCP library) send_minecraft_command(minecraft_command) # Replace with actual MCP code def send_minecraft_command(command): """Sends a command to the Minecraft server using the MCP library.""" # Replace this with your actual MCP code to send the command print(f"Sending command to Minecraft: {command}") # Example using mcstatus (not for sending commands, just for demonstration) try: server = mcstatus.MinecraftServer.lookup(server_address) status = server.status() print(f"Server latency: {status.latency}") except Exception as e: print(f"Error connecting to server: {e}") # Example usage (replace with your actual event loop) # This is just a placeholder - you need to integrate with your MCP library's event handling # to receive actual chat messages. if __name__ == "__main__": print("Starting Minecraft LLM integration...") # Simulate a chat message handle_chat_message("Player123", "Hello, world!") handle_chat_message("Player456", "What is the capital of France?") print("Integration complete.") ``` **Important Considerations** * **Security:** Be extremely careful about allowing the LLM to execute arbitrary commands on your Minecraft server. Implement strict input validation and sanitization to prevent malicious commands. Consider using a whitelist of allowed commands. * **Rate Limiting:** LLM APIs often have rate limits. Implement rate limiting in your code to avoid exceeding these limits. * **Cost:** Using LLM APIs can be expensive. Monitor your API usage and set spending limits. * **Latency:** There will be latency involved in sending data to the LLM and receiving a response. This can make the interaction feel less responsive. * **Context:** LLMs typically have a limited context window. You may need to implement a mechanism to provide the LLM with relevant context about the game world. * **Ethical Considerations:** Be mindful of the ethical implications of using LLMs in a game environment. Avoid generating content that is offensive, harmful, or misleading. * **Minecraft Server Version:** The Minecraft protocol changes with each version. Make sure your MCP library is compatible with the version of your Minecraft server. **Next Steps** 1. **Choose your MCP library:** Research and select the best library for your chosen language and Minecraft server version. 2. **Study the MCP:** Learn the basics of the Minecraft Protocol. Understand how chat messages, commands, and other events are encoded. 3. **Start Small:** Begin with a simple integration, such as having the LLM respond to chat messages. 4. **Iterate and Improve:** Gradually add more features and complexity to your integration. This is a complex project, but with careful planning and execution, you can create some very interesting and innovative applications. Good luck!

Flight Planner MCP Server

Membuat rencana penerbangan tingkat agen perjalanan menggunakan API fast-flights, memungkinkan pengguna untuk mencari penerbangan dan menghasilkan rencana perjalanan yang komprehensif.

Bazi MCP

An AI-powered metaphysical Bazi calculator that provides accurate Chinese astrological chart calculations for personality analysis and destiny forecasting, addressing inaccuracies in existing AI fortune-telling tools.

X API AI Agent – Personal Learning Project

Oke, berikut adalah terjemahan dari teks tersebut ke dalam bahasa Indonesia: Agen AI yang dapat memposting di X (Twitter) dengan bantuan Server MCP (Protokol Teks Model).

MCP Devcontainers

An MCP server that enables interaction with development containers through the devcontainers CLI, allowing users to start, run commands in, and execute arbitrary shell commands inside devcontainers.

Meeting Room MCP Server

A simple MCP server that enables meeting room booking through an AI assistant, supporting room availability checks and booking operations with React Agent pattern for tool calling.

DWZ Short URL MCP Server

Enables AI assistants to create, manage, and analyze short URLs through complete URL shortening functionality. Supports batch operations, custom domains, click statistics, and comprehensive link management.

Xiaohongshu API MCP Server

A microservice that wraps Xiaohongshu (Little Red Book) API into a RESTful API server, enabling users to perform various operations on the platform such as retrieving notes, searching users and content, and accessing user information.

MISP MCP Server

Server Protokol Konteks Model (MCP) yang terintegrasi dengan MISP (Platform Berbagi Informasi Malware) untuk menyediakan kemampuan intelijen ancaman ke Model Bahasa Besar.

Tavily Web Search MCP Server

Enables web search capabilities through the Tavily API, allowing users to search the web for information using natural language queries. Demonstrates MCP (Model Context Protocol) server implementation with stdio transport mode.

Lithic MCP Server

A TypeScript implementation of a Model Context Protocol server providing read-only access to Lithic banking and card services API.

Elysia MCP Plugin

A comprehensive ElysiaJS plugin for building Model Context Protocol (MCP) servers with HTTP transport, session management, and support for tools, resources, and prompts.

Apple Mail MCP Server

Enables AI assistants to interact with Apple Mail through natural language, providing comprehensive email management including reading, searching, composing, organizing, and analyzing emails across all configured accounts. Includes an expert skill system that teaches intelligent email workflows and productivity strategies.

File Patch MCP Server

Enables applying unified diff patches to files with comprehensive security validation, automatic backup/rollback, and atomic multi-file operations. Provides 7 tools and 4 error recovery patterns for safe patch management workflows.

Wanyi Watermark Remover

Extracts watermark-free videos and images from Douyin (TikTok) and Xiaohongshu (RedNote) share links, with optional AI-powered video transcription support.

Chrome Extension Bridge MCP

Jembatan ekstensi Chrome yang memungkinkan Anda terhubung ke server MCP untuk menggunakan objek window global.

CodeAnalysis MCP Server

Server Protokol Konteks Model komprehensif untuk analisis kode tingkat lanjut yang menyediakan alat untuk analisis sintaksis, visualisasi dependensi, dan dukungan alur kerja pengembangan yang dibantu AI.