Discover Awesome MCP Servers

NEAR MCP

Okay, here's how you can interact with the NEAR blockchain through MCP (Meta-Consensus Protocol) calls, along with explanations and considerations: **Understanding MCP (Meta-Consensus Protocol)** MCP is a core component of the NEAR blockchain's architecture. It's essentially the mechanism that allows different shards (parallel blockchains within NEAR) to communicate and coordinate with each other. It's what enables cross-shard transactions and data sharing. **How MCP Calls Work (Simplified)** 1. **Initiation:** A transaction on one shard (Shard A) needs to interact with a contract or data on another shard (Shard B). This transaction initiates an MCP call. 2. **Message Passing:** The transaction on Shard A creates a message that contains the details of the desired interaction (e.g., function call, data transfer). This message is routed through the MCP layer. 3. **Cross-Shard Communication:** The MCP layer ensures that the message is reliably delivered to Shard B. 4. **Execution on Target Shard:** Shard B receives the message and executes the requested action (e.g., calls a function on a contract). 5. **Response (Optional):** If the interaction requires a response, Shard B sends a message back to Shard A through the MCP layer. 6. **Completion:** Shard A receives the response (if any) and completes the original transaction. **Key Considerations When Using MCP Calls** * **Asynchronous Nature:** MCP calls are inherently asynchronous. This means that the original transaction that initiates the call doesn't immediately receive the result. You need to design your contracts to handle this asynchronous behavior. You'll typically use callbacks or other mechanisms to process the results when they become available. * **Gas Costs:** Cross-shard calls are generally more expensive in terms of gas than intra-shard calls (calls within the same shard). This is because they involve more complex communication and coordination. * **Complexity:** Developing contracts that rely on MCP calls can be more complex than developing single-shard contracts. You need to carefully manage the state and handle potential errors that can occur during cross-shard communication. * **Security:** Cross-shard communication introduces additional security considerations. You need to ensure that the messages being passed between shards are properly authenticated and authorized to prevent malicious actors from exploiting vulnerabilities. **How to Implement MCP Calls (Example using `near-sdk-rs`)** While you don't directly "call" MCP, you use the NEAR SDK to create contracts that leverage the underlying MCP functionality for cross-shard communication. Here's a simplified example using Rust and `near-sdk-rs`: **Contract A (on Shard A):** ```rust use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use near_sdk::collections::UnorderedMap; use near_sdk::json_types::U128; use near_sdk::{env, near_bindgen, AccountId, Promise, PromiseResult}; #[near_bindgen] #[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)] pub struct ContractA { owner_id: AccountId, data: UnorderedMap<String, String>, } #[near_bindgen] impl ContractA { #[init] pub fn new(owner_id: AccountId) -> Self { Self { owner_id, data: UnorderedMap::new(b"data".to_vec()), } } pub fn set_data(&mut self, key: String, value: String) { self.data.insert(&key, &value); } pub fn get_data(&self, key: String) -> Option<String> { self.data.get(&key) } // Function to call Contract B on another shard pub fn call_contract_b(&self, contract_b_account_id: AccountId, key: String) -> Promise { // Construct the arguments for the function call on Contract B let args = near_sdk::serde_json::json!({ "key": key, "value": "some_value_from_a".to_string(), }).to_string().into_bytes(); // Call the `set_data` function on Contract B Promise::new(contract_b_account_id) .function_call( "set_data".to_string(), // Function name on Contract B args, // Arguments for the function call 0, // Attached deposit (in yoctoNEAR) 50_000_000_000_000, // Gas attached (adjust as needed) ) .then(Self::callback_after_call_b(env::current_account_id())) } // Callback function to handle the result of the call to Contract B #[private] pub fn callback_after_call_b(caller_account_id: AccountId) -> Promise { near_sdk::log!("Callback from Contract B received"); match env::promise_result(0) { PromiseResult::Successful(_result) => { near_sdk::log!("Call to Contract B was successful"); // Optionally, process the result from Contract B here Promise::new(caller_account_id).function_call( "process_result".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } PromiseResult::Failed => { near_sdk::log!("Call to Contract B failed"); // Handle the failure appropriately Promise::new(caller_account_id).function_call( "handle_failure".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } PromiseResult::NotReady => { near_sdk::log!("Call to Contract B is not ready yet"); Promise::new(caller_account_id).function_call( "retry_call".to_string(), near_sdk::serde_json::json!({}).to_string().into_bytes(), 0, 50_000_000_000_000, ) } } } #[private] pub fn process_result(&mut self) { near_sdk::log!("Processing result from Contract B"); } #[private] pub fn handle_failure(&mut self) { near_sdk::log!("Handling failure from Contract B"); } #[private] pub fn retry_call(&mut self) { near_sdk::log!("Retrying call to Contract B"); } } ``` **Contract B (on Shard B):** ```rust use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use near_sdk::collections::UnorderedMap; use near_sdk::{env, near_bindgen, AccountId}; #[near_bindgen] #[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)] pub struct ContractB { owner_id: AccountId, data: UnorderedMap<String, String>, } #[near_bindgen] impl ContractB { #[init] pub fn new(owner_id: AccountId) -> Self { Self { owner_id, data: UnorderedMap::new(b"data".to_vec()), } } pub fn set_data(&mut self, key: String, value: String) { near_sdk::log!("Contract B received key: {}, value: {}", key, value); self.data.insert(&key, &value); } pub fn get_data(&self, key: String) -> Option<String> { self.data.get(&key) } } ``` **Explanation:** 1. **`call_contract_b` (Contract A):** * This function initiates the cross-shard call. * `contract_b_account_id`: The account ID of Contract B (on the other shard). * `args`: The arguments to be passed to the `set_data` function on Contract B. We use `serde_json` to serialize the arguments into a JSON string. * `Promise::new(...)`: Creates a new promise to call the function on Contract B. * `function_call(...)`: Specifies the function to call (`set_data`), the arguments, the attached deposit (0 in this case), and the gas attached. **Important:** Allocate sufficient gas for the cross-shard call. * `.then(Self::callback_after_call_b(...))`: Attaches a callback function (`callback_after_call_b`) to handle the result of the call to Contract B. This is crucial because the call is asynchronous. 2. **`callback_after_call_b` (Contract A):** * This function is executed *after* the call to Contract B has completed (either successfully or with an error). * `env::promise_result(0)`: Retrieves the result of the promise (the call to Contract B). * `PromiseResult::Successful(_result)`: If the call was successful, you can access the result (if any) from Contract B. * `PromiseResult::Failed`: If the call failed, you need to handle the error appropriately (e.g., retry, log the error, revert the transaction). * `PromiseResult::NotReady`: If the call is not ready yet, you can retry the call. 3. **`set_data` (Contract B):** * This is the function that is called on Contract B. * It receives the `key` and `value` from Contract A. * It stores the data in its own `data` map. **Deployment and Testing:** 1. **Deploy Contract A to one shard.** 2. **Deploy Contract B to a *different* shard.** This is essential for testing cross-shard communication. 3. **Call `call_contract_b` on Contract A**, providing the account ID of Contract B. 4. **Observe the logs:** You should see logs from both Contract A and Contract B, indicating that the cross-shard call was initiated, executed, and the callback was handled. **Important Notes:** * **Gas Allocation:** Carefully estimate and allocate sufficient gas for cross-shard calls. Insufficient gas will cause the transaction to fail. You can use the NEAR CLI to simulate transactions and estimate gas costs. * **Error Handling:** Implement robust error handling in your contracts to deal with potential failures during cross-shard communication. * **Security Audits:** If you are building critical applications that rely on cross-shard communication, consider having your contracts audited by security professionals. * **NEAR Documentation:** Refer to the official NEAR documentation for the most up-to-date information on cross-shard communication and MCP: [https://docs.near.org/](https://docs.near.org/) **In summary, you don't directly "call" MCP. You use the NEAR SDK to create contracts that leverage the underlying MCP functionality for cross-shard communication. The key is to use `Promise` and `then` to handle the asynchronous nature of cross-shard calls and to implement proper error handling.** Let me know if you have any more specific questions or scenarios you'd like to explore!

MCP AI Infra Real Time Agent

Mengembangkan infrastruktur AI berbasis MCP yang memungkinkan eksekusi alat secara real-time, pengambilan pengetahuan terstruktur, dan interaksi agentik dinamis untuk klien AI seperti Claude dan Cursor.

TxtAI Assistant MCP

Implementasi server Model Context Protocol (MCP) untuk pencarian semantik dan manajemen memori menggunakan TxtAI. Server ini menyediakan API yang kuat untuk menyimpan, mengambil, dan mengelola memori berbasis teks dengan kemampuan pencarian semantik. Anda juga dapat menggunakan Claude dan Cline AI.

MCP Server useful tools

Here are a few ways to translate that, depending on the nuance you want to convey: **Option 1 (Most straightforward):** * Alat-alat berguna untuk Server MCP, Spring AI MCP, Weather MCP, Stock MCP, Alat Cuaca, Alat Saham. **Option 2 (Slightly more descriptive, using "perangkat" for "tool"):** * Perangkat berguna untuk Server MCP, Spring AI MCP, Weather MCP, Stock MCP, Perangkat Cuaca, Perangkat Saham. **Option 3 (Using "utilitas" for "tool," implying a utility program):** * Utilitas berguna untuk Server MCP, Spring AI MCP, Weather MCP, Stock MCP, Utilitas Cuaca, Utilitas Saham. **Explanation of Choices:** * **MCP Server:** This is kept as is, assuming it's a specific product or system name. * **Spring AI MCP, Weather MCP, Stock MCP:** These are also kept as is, assuming they are specific product or system names. * **Tool:** The best translation depends on the context. * "Alat" is a general word for tool. * "Perangkat" can also mean device or tool, and might be more appropriate if the tools are software-based. * "Utilitas" implies a utility program or software tool. Choose the option that best fits the context of your text. If these are software tools, "Perangkat" or "Utilitas" might be better choices than "Alat."

Arre Ankit_notion Mcp Server

Mirror of

Plane MCP Server

Sebuah server Protokol Konteks Model yang memungkinkan LLM (Model Bahasa Besar) untuk berinteraksi dengan Plane.so, memungkinkan mereka untuk mengelola proyek dan isu melalui API Plane untuk alur kerja manajemen proyek yang efisien.

DevOps MCP Servers

MCP servers for DevOps tools and integrations. Created and maintained by the a37 team.

Unity MCP Server for Smithery.ai

A Model Context Protocol server for Unity game development that enables users to manage projects, edit scenes, create prefabs, and generate scripts through natural language integration with Smithery.ai.

Ableton Live MCP Server

MCP Server implementation for Ableton Live OSC control

MCP Web UI

MCP Web UI is a web-based user interface that serves as a Host within the Model Context Protocol (MCP) architecture. It provides a powerful and user-friendly interface for interacting with Large Language Models (LLMs) while managing context aggregation and coordination between clients and servers.

PDF Search for Zed

Ekstensi server MCP untuk Zed yang mengambil bagian-bagian relevan dari sebuah berkas PDF.

Metaplex MCP Server

Mirror of

Cline Notification Server

Here are a few ways an MCP (likely referring to a Minecraft server) can send notifications via Telegram: **1. Using a Minecraft Plugin (Recommended):** * **EssentialsX (with a Telegram Extension):** EssentialsX is a very popular and versatile Minecraft server plugin. Some extensions or add-ons specifically integrate with Telegram. You'd install EssentialsX and then the Telegram extension. The extension would typically allow you to configure notifications for: * Server start/stop * Player join/leave * Player deaths * Server crashes * Custom messages triggered by commands or events * **Dedicated Telegram Plugins:** Search for plugins specifically designed for Telegram integration on platforms like SpigotMC or BukkitDev. These plugins are often more focused on Telegram functionality and might offer more advanced features. Examples might include: * `/tellraw` integration to send formatted messages to Telegram. * Telegram commands that players can use from within the game. * Advanced filtering of notifications. **How to use a plugin (General Steps):** 1. **Download the Plugin:** Get the `.jar` file for the plugin you choose. 2. **Install the Plugin:** Place the `.jar` file into the `plugins` folder of your Minecraft server directory. 3. **Restart the Server:** Restart your Minecraft server to load the plugin. 4. **Configure the Plugin:** Most plugins require configuration. This usually involves editing a configuration file (often `config.yml` or similar) within the plugin's folder in the `plugins` directory. You'll need to: * **Get a Telegram Bot Token:** Create a Telegram bot using BotFather (search for "BotFather" in Telegram). BotFather will give you a unique bot token. * **Get a Telegram Chat ID:** Find the chat ID of the Telegram chat you want to send notifications to. There are various ways to do this, often involving sending a message to the bot and then retrieving the chat ID from the bot's logs or using a specific command. * **Enter the Token and Chat ID:** Put the bot token and chat ID into the plugin's configuration file. 5. **Test the Plugin:** Use the plugin's commands or trigger events (like a player joining) to test if notifications are being sent correctly. **2. Using a Script and Server RCON (Less Common, More Technical):** * **RCON:** RCON (Remote Console) allows you to remotely execute commands on your Minecraft server. * **Script:** You would write a script (e.g., in Python, Bash, or Node.js) that: 1. Connects to your Minecraft server using RCON. 2. Monitors the server logs for specific events (e.g., "Player [username] joined the game"). 3. When an event occurs, the script sends a message to your Telegram bot using the Telegram Bot API. **Why this is less common:** * More complex to set up. * Requires programming knowledge. * Can be less reliable than a dedicated plugin. * Higher resource usage (the script is constantly running and monitoring logs). **3. Using a Webhook (Potentially, depending on the MCP):** * If your MCP (Minecraft Control Panel) has the ability to trigger webhooks on certain events, you could configure it to send a webhook to a service like IFTTT or Zapier. These services can then be configured to send a message to your Telegram bot. **Important Considerations:** * **Security:** Be very careful about storing your Telegram bot token and chat ID securely. Do not share them publicly. Consider using environment variables or encrypted configuration files. * **Rate Limiting:** The Telegram Bot API has rate limits. Avoid sending too many messages in a short period of time, or your bot may be temporarily blocked. * **Plugin Compatibility:** Make sure the plugin you choose is compatible with your Minecraft server version (e.g., Spigot, Paper, Fabric). * **Server Performance:** Some plugins can impact server performance. Choose plugins that are well-optimized. **Indonesian Translation of the above:** Berikut adalah beberapa cara agar MCP (kemungkinan mengacu pada server Minecraft) dapat mengirimkan notifikasi melalui Telegram: **1. Menggunakan Plugin Minecraft (Disarankan):** * **EssentialsX (dengan Ekstensi Telegram):** EssentialsX adalah plugin server Minecraft yang sangat populer dan serbaguna. Beberapa ekstensi atau add-on secara khusus terintegrasi dengan Telegram. Anda akan menginstal EssentialsX dan kemudian ekstensi Telegram. Ekstensi ini biasanya memungkinkan Anda untuk mengonfigurasi notifikasi untuk: * Server mulai/berhenti * Pemain bergabung/keluar * Kematian pemain * Server crash * Pesan khusus yang dipicu oleh perintah atau peristiwa * **Plugin Telegram Khusus:** Cari plugin yang dirancang khusus untuk integrasi Telegram di platform seperti SpigotMC atau BukkitDev. Plugin ini seringkali lebih fokus pada fungsionalitas Telegram dan mungkin menawarkan fitur yang lebih canggih. Contohnya mungkin termasuk: * Integrasi `/tellraw` untuk mengirim pesan yang diformat ke Telegram. * Perintah Telegram yang dapat digunakan pemain dari dalam game. * Penyaringan notifikasi tingkat lanjut. **Cara menggunakan plugin (Langkah Umum):** 1. **Unduh Plugin:** Dapatkan file `.jar` untuk plugin yang Anda pilih. 2. **Instal Plugin:** Tempatkan file `.jar` ke dalam folder `plugins` dari direktori server Minecraft Anda. 3. **Mulai Ulang Server:** Mulai ulang server Minecraft Anda untuk memuat plugin. 4. **Konfigurasi Plugin:** Sebagian besar plugin memerlukan konfigurasi. Ini biasanya melibatkan pengeditan file konfigurasi (seringkali `config.yml` atau serupa) di dalam folder plugin di direktori `plugins`. Anda perlu: * **Dapatkan Token Bot Telegram:** Buat bot Telegram menggunakan BotFather (cari "BotFather" di Telegram). BotFather akan memberi Anda token bot yang unik. * **Dapatkan ID Obrolan Telegram:** Temukan ID obrolan dari obrolan Telegram yang ingin Anda kirimi notifikasi. Ada berbagai cara untuk melakukan ini, seringkali melibatkan pengiriman pesan ke bot dan kemudian mengambil ID obrolan dari log bot atau menggunakan perintah tertentu. * **Masukkan Token dan ID Obrolan:** Masukkan token bot dan ID obrolan ke dalam file konfigurasi plugin. 5. **Uji Plugin:** Gunakan perintah plugin atau picu peristiwa (seperti pemain yang bergabung) untuk menguji apakah notifikasi dikirim dengan benar. **2. Menggunakan Skrip dan RCON Server (Kurang Umum, Lebih Teknis):** * **RCON:** RCON (Remote Console) memungkinkan Anda untuk mengeksekusi perintah dari jarak jauh di server Minecraft Anda. * **Skrip:** Anda akan menulis skrip (misalnya, dalam Python, Bash, atau Node.js) yang: 1. Terhubung ke server Minecraft Anda menggunakan RCON. 2. Memantau log server untuk peristiwa tertentu (misalnya, "Pemain [username] bergabung dengan game"). 3. Ketika suatu peristiwa terjadi, skrip mengirim pesan ke bot Telegram Anda menggunakan Telegram Bot API. **Mengapa ini kurang umum:** * Lebih rumit untuk diatur. * Membutuhkan pengetahuan pemrograman. * Bisa kurang andal daripada plugin khusus. * Penggunaan sumber daya yang lebih tinggi (skrip terus berjalan dan memantau log). **3. Menggunakan Webhook (Potensial, tergantung pada MCP):** * Jika MCP (Minecraft Control Panel) Anda memiliki kemampuan untuk memicu webhook pada peristiwa tertentu, Anda dapat mengonfigurasinya untuk mengirim webhook ke layanan seperti IFTTT atau Zapier. Layanan ini kemudian dapat dikonfigurasi untuk mengirim pesan ke bot Telegram Anda. **Pertimbangan Penting:** * **Keamanan:** Berhati-hatilah dalam menyimpan token bot Telegram dan ID obrolan Anda dengan aman. Jangan membagikannya secara publik. Pertimbangkan untuk menggunakan variabel lingkungan atau file konfigurasi terenkripsi. * **Pembatasan Tingkat:** Telegram Bot API memiliki batasan tingkat. Hindari mengirim terlalu banyak pesan dalam waktu singkat, atau bot Anda mungkin diblokir sementara. * **Kompatibilitas Plugin:** Pastikan plugin yang Anda pilih kompatibel dengan versi server Minecraft Anda (misalnya, Spigot, Paper, Fabric). * **Kinerja Server:** Beberapa plugin dapat memengaruhi kinerja server. Pilih plugin yang dioptimalkan dengan baik.

mcp-golang

Write Model Context Protocol servers in few lines of go code. Docs at

LSP MCP

An Model Context Protocol (MCP) server that provides LLMs/AI Agents with the capabilities of a language server protocol (LSP) server. This gives the AI the ability to get language aware context from the codebase.

mcp-server-sql-analyzer

MCP server for SQL static analysis.

MCP Inspector

Visual testing tool for MCP servers

Puppeteer MCP Server

Cermin dari

Ntfy MCP Server

Server Protokol Konteks Model yang memungkinkan sistem AI untuk mengirimkan notifikasi waktu nyata ke ponsel, desktop, dan perangkat lain melalui layanan publish/subscribe ntfy.

MCP Calculate Server

Layanan komputasi matematika yang memungkinkan pengguna untuk melakukan perhitungan simbolik termasuk aritmatika dasar, aljabar, kalkulus, penyelesaian persamaan, dan operasi matriks melalui protokol MCP.

Clojars MCP Server

Mirror of

Substack MCP Server

MCP server for Substack API integration with Claude

Mcp Repo2llm Server

Sebuah server MCP yang mengubah repositori kode dari GitHub, GitLab, atau direktori lokal menjadi format yang ramah LLM, menjaga konteks dan struktur untuk pemrosesan AI yang lebih baik.

MCPE Alpha Server for Pterodactyl

Mirror of

MCP-RSS-Crawler

Sebuah server MCP yang mengambil umpan RSS dan membagikannya dengan LLM, memungkinkan asisten AI untuk mengakses dan menyajikan berita dan artikel terbaru dari umpan yang dikonfigurasi.

Upbit MCP Server

Berinteraksi dengan layanan bursa mata uang kripto Upbit untuk mengambil data pasar, mengelola akun, dan mengeksekusi perdagangan. Sederhanakan pengalaman perdagangan Anda dengan alat untuk manajemen pesanan, deposit, penarikan, dan analisis teknis.

anki MCP server

Anki MCP server

FastMCP

A TypeScript framework for building MCP servers.

AWS Service Reference MCP Server

An MCP Server for accessing the AWS Programatic Service Authorisation Reference