Discover Awesome MCP Servers

Prem MCP Server

Một triển khai máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol - MCP) cho phép tích hợp liền mạch với Claude và các ứng dụng khách tương thích MCP khác để truy cập các mô hình ngôn ngữ, khả năng RAG và các tính năng quản lý tài liệu của Prem AI.

gemini-mcp-server

Một máy chủ TypeScript tích hợp mô hình Gemini Pro của Google với Claude Desktop thông qua Giao thức Ngữ cảnh Mô hình (Model Context Protocol), cho phép người dùng Claude truy cập các khả năng tạo văn bản của Gemini.

GitHub Actions MCP Server

Một máy chủ MCP cho phép các trợ lý AI quản lý quy trình làm việc GitHub Actions bằng cách cung cấp các công cụ để liệt kê, xem, kích hoạt, hủy và chạy lại quy trình làm việc thông qua GitHub API.

StrongApps_MCPE_servers

Gương của

Sequential Thinking MCP Server

Một máy chủ MCP cho phép giải quyết vấn đề một cách linh hoạt, phản xạ bằng cách cấu trúc các quy trình tư duy và tự động ghi lại mỗi phiên vào Recall.

Sanity MCP server

Sanity MCP Server

Multichain MCP Server 🌐

A MCP Server Route Hub connecting all MCP Servers

JetBrains MCP Proxy Server

Máy chủ chuyển tiếp các yêu cầu từ máy khách đến JetBrains IDE.

claude_mcp

Different MCP servers in Python

Tinypng Mcp Server

Sử dụng TinyPNG thông qua MCP.

Notion MCP Server

Notion MCPでブロックやトグルなどしようできるようにしたサーバー

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 makes NEAR's sharding approach work. You don't directly "make MCP calls" in the same way you make function calls to a smart contract. Instead, you interact with the blockchain in a way that *triggers* MCP processes behind the scenes. **How Interactions Trigger MCP Processes** Most interactions that involve cross-shard communication will implicitly use MCP. Here's a breakdown: 1. **Cross-Contract Calls (Cross-Shard Calls):** This is the most common scenario. When a contract on one shard calls a function on a contract located on a *different* shard, MCP is used to facilitate the communication. This involves: * **Initiating the Call:** The contract on the originating shard initiates the call to the target contract on the other shard. * **Message Passing:** The NEAR protocol (including MCP) handles the secure and reliable transfer of the call data (arguments, attached deposit, gas) from the originating shard to the target shard. * **Execution on the Target Shard:** The target contract executes the function. * **Result Handling:** The result of the function execution (return value, any state changes) is then passed back to the originating shard via MCP. * **Callback (Optional):** The originating contract can define a callback function that is executed when the result from the target contract is received. 2. **State Synchronization:** MCP is also used to ensure that the state of the blockchain is consistent across all shards. This involves periodically synchronizing state information between shards. **How to Make Cross-Contract Calls (The Practical Approach)** You don't directly call MCP functions. You use the NEAR SDKs (JavaScript, Rust, etc.) to make cross-contract calls, and the SDK handles the underlying MCP communication for you. Here's a general example using JavaScript (with `near-api-js`): ```javascript import { connect, keyStores, WalletConnection } from 'near-api-js'; // Configuration (replace with your actual values) const config = { networkId: 'testnet', // or 'mainnet' keyStore: new keyStores.BrowserLocalStorageKeyStore(), // or other key store nodeUrl: 'https://rpc.testnet.near.org', // or mainnet RPC URL walletUrl: 'https://wallet.testnet.near.org', // or mainnet wallet URL contractName: 'your-contract-on-shard-A.testnet', // Contract on the originating shard }; async function callCrossContract() { const near = await connect(config); const wallet = new WalletConnection(near, config.contractName); // Check if the user is signed in if (!wallet.isSignedIn()) { wallet.requestSignIn(config.contractName, 'Your App Name'); // Request sign-in return; } const contract = await new near.Contract( wallet.account(), config.contractName, { viewMethods: [], // Methods that don't change state changeMethods: ['call_other_contract'], // Methods that change state } ); try { // Call a function on your contract that then calls another contract const result = await contract.call_other_contract({ args: { target_contract: 'your-contract-on-shard-B.testnet', // Contract on the target shard method_name: 'some_function', // Function to call on the target contract argument: { message: 'Hello from shard A!' }, // Arguments for the target function }, gas: '300000000000000', // Gas for the entire transaction (including cross-contract call) deposit: '1000000000000000000000', // Attached deposit (in yoctoNEAR) }); console.log('Cross-contract call result:', result); } catch (error) { console.error('Error during cross-contract call:', error); } } callCrossContract(); ``` **Explanation:** * **`near-api-js`:** This is the NEAR JavaScript SDK. You'll need to install it: `npm install near-api-js` * **Configuration:** Set up your NEAR configuration (network ID, key store, node URL, wallet URL, contract name). **Crucially, `contractName` should be the contract on the shard where you're *initiating* the cross-contract call.** * **Wallet Connection:** Connect to the NEAR wallet to handle user authentication and signing of transactions. * **Contract Instance:** Create an instance of your contract using `near.Contract`. Specify the `changeMethods` that your contract exposes. In this example, we assume your contract has a method called `call_other_contract`. * **`call_other_contract` (Example):** This is a *hypothetical* function in your contract on shard A. It's responsible for making the actual cross-contract call. It would look something like this in your contract code (e.g., in Rust or AssemblyScript): ```rust // Example (Rust) - in your contract on shard A #[payable] pub fn call_other_contract( &mut self, target_contract: AccountId, method_name: String, argument: String, ) -> Promise { Promise::new(target_contract) .function_call( method_name.into_bytes(), argument.into_bytes(), env::attached_deposit(), env::prepaid_gas() - GAS_FOR_SIMPLE_CALL, // Subtract gas for this function ) } ``` * **`target_contract`:** The account ID of the contract you want to call on the other shard. * **`method_name`:** The name of the function you want to call on the target contract. * **`argument`:** The arguments to pass to the target function (serialized as a string or bytes). * **`env::attached_deposit()`:** Passes the attached deposit (NEAR tokens) to the target contract. * **`env::prepaid_gas()`:** Specifies the gas limit for the entire transaction. You need to allocate enough gas for both the initial function call *and* the cross-contract call. Subtract some gas for the initial function's execution. * **`gas`:** Specify the gas limit for the entire transaction. This is *very important*. If you don't provide enough gas, the transaction will fail. Estimate the gas required carefully. You can use the NEAR CLI to simulate transactions and estimate gas costs. * **`deposit`:** The amount of NEAR tokens (in yoctoNEAR) to attach to the transaction. This is often required when calling functions that modify state or transfer tokens. * **Error Handling:** Wrap the `contract.call` in a `try...catch` block to handle potential errors. **Important Considerations:** * **Gas Limits:** Cross-contract calls consume more gas than regular calls within the same shard. You need to carefully estimate the gas required for both the initial function call and the cross-contract call. Insufficient gas is a common cause of transaction failures. * **Attached Deposit:** Make sure to attach the appropriate deposit (NEAR tokens) to the transaction if the target function requires it. * **Serialization/Deserialization:** When passing arguments between contracts, you need to serialize and deserialize the data correctly. Use a consistent serialization format (e.g., JSON, Borsh). The target contract needs to be able to deserialize the arguments you send. * **Asynchronous Nature:** Cross-contract calls are asynchronous. The result of the call is not immediately available. You'll typically use callbacks or promises to handle the result when it becomes available. * **Security:** Be very careful when making cross-contract calls. Ensure that the target contract is trustworthy and that you are passing valid arguments. Malicious contracts could potentially exploit vulnerabilities in your code. * **Error Handling:** Implement robust error handling to gracefully handle failures during cross-contract calls. Log errors and provide informative messages to the user. * **Testing:** Thoroughly test your cross-contract calls in a test environment (e.g., testnet) before deploying to mainnet. * **Callbacks:** Use callbacks to handle the results of cross-contract calls. This allows your contract to react to the outcome of the call and update its state accordingly. * **Contract Upgrades:** Be aware that contract upgrades can affect cross-contract calls. If the target contract is upgraded, it may change its API or behavior, which could break your code. * **Transaction Fees:** Cross-contract calls incur transaction fees. The fees are paid in NEAR tokens. **Example Contract Code (Rust - Simplified)** Here's a simplified example of how your contract on shard A might look (using Rust): ```rust use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use near_sdk::collections::LookupMap; use near_sdk::env; use near_sdk::json_types::U128; use near_sdk::near_bindgen; use near_sdk::AccountId; use near_sdk::Promise; const GAS_FOR_SIMPLE_CALL: u64 = 5_000_000_000_000; // Example gas amount #[near_bindgen] #[derive(BorshDeserialize, BorshSerialize)] pub struct Contract { owner_id: AccountId, data: LookupMap<String, String>, } impl Default for Contract { fn default() -> Self { Self { owner_id: env::current_account_id(), data: LookupMap::new(b"d".to_vec()), } } } #[near_bindgen] impl Contract { #[init] pub fn new(owner_id: AccountId) -> Self { Self { owner_id, data: LookupMap::new(b"d".to_vec()), } } #[payable] pub fn call_other_contract( &mut self, target_contract: AccountId, method_name: String, argument: String, ) -> Promise { Promise::new(target_contract) .function_call( method_name.into_bytes(), argument.into_bytes(), env::attached_deposit(), env::prepaid_gas() - GAS_FOR_SIMPLE_CALL, // Subtract gas for this function ) } 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) } } ``` **Vietnamese Translation (Summary)** Để tương tác với blockchain NEAR thông qua các lệnh gọi MCP (Meta-Consensus Protocol), bạn không trực tiếp gọi các hàm MCP. Thay vào đó, bạn sử dụng các SDK của NEAR (JavaScript, Rust, v.v.) để thực hiện các lệnh gọi liên hợp đồng (cross-contract calls). Các SDK này sẽ tự động xử lý giao tiếp MCP bên dưới. Các lệnh gọi liên hợp đồng xảy ra khi một hợp đồng trên một shard gọi một hàm trên một hợp đồng nằm trên một shard khác. MCP đảm bảo rằng dữ liệu được truyền một cách an toàn và đáng tin cậy giữa các shard. Bạn cần chú ý đến các giới hạn gas, tiền gửi đính kèm, tuần tự hóa/giải tuần tự hóa dữ liệu, tính chất không đồng bộ của các lệnh gọi liên hợp đồng và bảo mật. Kiểm tra kỹ lưỡng các lệnh gọi liên hợp đồng của bạn trong môi trường thử nghiệm trước khi triển khai lên mainnet. **In summary:** You don't directly interact with MCP. You use cross-contract calls, and the NEAR SDK handles the MCP details for you. Pay close attention to gas limits, deposits, serialization, and security.

Calendar MCP Server

Gương của

Favicon MCP Server

A MCP server for converting input images into favicon

TxtAI Assistant MCP

Triển khai máy chủ Giao thức Ngữ cảnh Mô hình (MCP) cho tìm kiếm ngữ nghĩa và quản lý bộ nhớ bằng TxtAI. Máy chủ này cung cấp một API mạnh mẽ để lưu trữ, truy xuất và quản lý các bộ nhớ dựa trên văn bản với khả năng tìm kiếm ngữ nghĩa. Bạn cũng có thể sử dụng Claude và Cline AI.

Enhanced Gmail MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép các trợ lý AI như Claude tương tác với Gmail thông qua ngôn ngữ tự nhiên, cung cấp các khả năng quản lý email toàn diện bao gồm gửi, đọc, sắp xếp, tìm kiếm và quản lý bản nháp và nhãn.

AI Meta MCP Server

Cho phép các mô hình AI tự động tạo và thực thi các công cụ tùy chỉnh của riêng chúng thông qua kiến trúc meta-function, hỗ trợ các môi trường runtime JavaScript, Python và Shell với bảo mật sandbox và quy trình phê duyệt của con người.

Huntress API MCP Server

Mirror of

Oss Mcp

Một máy chủ giao thức Model Context (Ngữ cảnh Mô hình) cho phép các mô hình ngôn ngữ lớn tải trực tiếp các tệp lên Dịch vụ Lưu trữ Đối tượng của Alibaba Cloud (OSS), hỗ trợ nhiều cấu hình OSS và các thư mục tải lên được chỉ định.

IDA Pro MCP Server

Plugin IDA Pro để chạy máy chủ MCP SSE cho cursor / claude

Obsidian MCP Server

Mirror of

Code Assistant

An LLM-powered, autonomous coding assistant. Also offers an MCP mode.

Office-PowerPoint-MCP-Server

Một máy chủ cho phép tạo và chỉnh sửa các bài thuyết trình PowerPoint một cách tự động thông qua Giao thức Ngữ cảnh Mô hình (Model Context Protocol), hỗ trợ các tính năng như thêm trang chiếu, hình ảnh, hộp văn bản, biểu đồ và bảng.

Wait MCP Server

Test MCP Server for Waiting

mysql-server MCP Server

Máy chủ MCP dựa trên TypeScript, tạo điều kiện thuận lợi cho việc thực thi truy vấn SQL và kết nối cơ sở dữ liệu MySQL bằng cách sử dụng các biến môi trường.

Figma MCP Server

Một máy chủ giao thức ngữ cảnh mô hình (Model Context Protocol) tích hợp với API của Figma, cho phép tương tác với các tệp, bình luận, thành phần, dự án và quản lý webhook của Figma.

Bitable MCP Server

Cung cấp quyền truy cập vào Lark Bitable thông qua Giao thức Ngữ cảnh Mô hình, cho phép người dùng tương tác với các bảng Bitable bằng các công cụ được xác định trước.