Discover Awesome MCP Servers

Favicon MCP Server

A MCP server for converting input images into favicon

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!

Enhanced Gmail MCP Server

Sebuah server Protokol Konteks Model yang memungkinkan asisten AI seperti Claude untuk berinteraksi dengan Gmail melalui bahasa alami, menyediakan kemampuan manajemen email yang komprehensif termasuk mengirim, membaca, mengatur, mencari, dan mengelola draf dan label.

SFMC_MCP_SERVER

MCP server for connecting Claude to Salesforce Marketing Cloud REST API

AI Meta MCP Server

Memungkinkan model AI untuk secara dinamis membuat dan menjalankan alat kustom mereka sendiri melalui arsitektur meta-fungsi, mendukung runtime JavaScript, Python, dan Shell dengan keamanan sandbox dan alur persetujuan manusia.

Huntress API MCP Server

Mirror of

IDA Pro MCP Server

Plugin IDA Pro untuk menjalankan server MCP SSE untuk kursor / claude.

Office-PowerPoint-MCP-Server

A server that enables creating and editing PowerPoint presentations programmatically through the Model Context Protocol, supporting features like adding slides, images, textboxes, charts, and tables.

Wait MCP Server

Test MCP Server for Waiting

Gmail Plugin MCP Server

Sebuah server MCP yang memungkinkan integrasi Gmail, memungkinkan pengguna untuk mengelola email (mengirim, menerima, membaca, membuang, menandai sebagai sudah dibaca) secara langsung melalui klien MCP seperti Claude Desktop.

yfinance MCP Server

Here are a few ways to translate "MCP Server for fething yfinance financial data into Claude Desktop" into Indonesian, depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Server MCP untuk mengambil data keuangan yfinance ke Claude Desktop** * This is a direct translation and easily understood. **Option 2 (More descriptive, using "mengumpulkan" - to gather):** * **Server MCP untuk mengumpulkan data keuangan dari yfinance ke Claude Desktop** * This uses "mengumpulkan" which means "to gather" or "to collect," making it slightly more descriptive. **Option 3 (More formal, using "memasukkan" - to input/insert):** * **Server MCP untuk memasukkan data keuangan dari yfinance ke Claude Desktop** * This uses "memasukkan" which means "to input" or "to insert," suggesting a more structured process. **Option 4 (Using "mendapatkan" - to obtain/get):** * **Server MCP untuk mendapatkan data keuangan dari yfinance ke Claude Desktop** * This uses "mendapatkan" which means "to obtain" or "to get," emphasizing the acquisition of the data. **Which one is best depends on the context:** * If you want a simple and direct translation, **Option 1** is fine. * If you want to emphasize the gathering of data, **Option 2** is good. * If you want to emphasize the inputting of data, **Option 3** is good. * If you want to emphasize the obtaining of data, **Option 4** is good. In most cases, **Option 1** or **Option 2** would be the most natural and easily understood.

AWorld

Bangun, evaluasi, dan jalankan Bantuan Multi-Agen Umum dengan mudah.

Figma MCP Server

Server Protokol Konteks Model yang terintegrasi dengan API Figma, memungkinkan interaksi dengan file Figma, komentar, komponen, proyek, dan manajemen webhook.

cosense-mcp-server MCP Server

Mirror of

MCP Server for Agent8

Sebuah server yang mengimplementasikan Model Context Protocol (MCP) untuk mendukung pengembangan Agent8 SDK dengan menyediakan prompt sistem dan kemampuan pencarian contoh kode melalui transport stdio dan SSE.

MCP Google Spreadsheet

MCP Server for Google Spreadsheet

Simple MCP MySQL Server

A lightweight MCP server for MySQL, built with python

Comfy MCP Pipeline

This is a pipeline wrapper for comfy-mcp-server for Open WebUI.

Model Context Protocol Server For Cyber Security

Model Context Protocol Server For Cyber Security

Spotify MCP Server

Cermin dari

Agora MCP

Sebuah server MCP yang menghubungkan asisten AI ke SearchAgora, memungkinkan pengguna untuk mencari, menemukan, dan membeli produk di seluruh web melalui percakapan bahasa alami.

Bitable MCP Server

Menyediakan akses ke Lark Bitable melalui Model Context Protocol, memungkinkan pengguna untuk berinteraksi dengan tabel Bitable menggunakan alat yang telah ditentukan sebelumnya.

Bio-OS MCP Server

The MCP Servers for Bio-OS instance platforms.

Shodan MCP Server

Menyediakan akses ke fungsionalitas Shodan API, memungkinkan asisten AI untuk menanyakan informasi tentang perangkat yang terhubung ke internet untuk penelitian keamanan siber dan intelijen ancaman.

AniList

Server MCP AniList untuk mengakses data API AniList

Mcp Server

Playing with Model Context Protocol server(s)

mcp-server-gohilvl

A set of tools to connect gohighlevel data to your LLMs