Discover Awesome MCP Servers

Arre Ankit_notion Mcp Server

Mirror of

gemini-mcp-server

Server TypeScript yang mengintegrasikan model Gemini Pro Google dengan Claude Desktop melalui Model Context Protocol, memungkinkan pengguna Claude untuk mengakses kemampuan pembuatan teks Gemini.

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.

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.

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.

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."

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!

ctools

Here are a few possible translations, depending on the context: * **Server MCP untuk alat:** (This is a direct translation and generally understandable.) * **Server MCP untuk peralatan:** (This is also a direct translation, using "peralatan" which can sometimes be more appropriate than "alat" for tools.) * **Server MCP untuk perkakas:** (This uses "perkakas," which is another word for tools, often implying more complex or specialized tools.) * **Server MCP untuk utilitas:** (This uses "utilitas," which can be used if the tools are software or utilities.) Without more context, it's hard to say which is the *best* translation. However, **Server MCP untuk alat** is a safe and generally accurate choice.

MLflow Prompt Registry MCP Server

Mengaktifkan akses ke templat prompt yang dikelola di MLflow melalui Claude Desktop, memungkinkan pengguna untuk menginstruksikan Claude dengan templat yang disimpan untuk tugas-tugas berulang atau alur kerja umum.

Time Server

Cermin dari

Unity MCP Server

A protocol server that bridges AI assistants with Unity projects, allowing them to analyze code, parse scenes, generate scripts, and perform other Unity operations through specialized tools.

Azure Mcp Servers

Direktori ini menampilkan berbagai server Model Context Protocol (MCP). Server-server ini memungkinkan Large Language Models (LLM) untuk mengakses alat dan sumber data dari Microsoft Azure secara aman.

MCP-RB

A lightweight Ruby framework for building MCP servers with a Sinatra-like DSL

MCP Server for Bun and Elysia

Model Context Protocol (MCP) Server for Bun and Elysia

boot-mcp

A starter template for building Model Context Protocol (MCP) applications with TypeScript

ToolChat

PydanticAI LLM chat dengan alat server MCP

ESXi MCP Server

Server manajemen VMware ESXi/vCenter berbasis MCP (Machine Control Protocol), menyediakan antarmuka REST API sederhana untuk manajemen mesin virtual.

MCP Server Template for Cursor IDE

Berikut adalah templat sederhana untuk membuat alat khusus untuk Cursor IDE menggunakan Model Context Protocol, yang dapat di-deploy melalui Heroku, Docker, atau langsung di dalam Cursor IDE: ```python # app.py (Contoh aplikasi Flask) from flask import Flask, request, jsonify import os app = Flask(__name__) @app.route('/process', methods=['POST']) def process_request(): """ Menerima permintaan dari Cursor IDE dan memprosesnya. """ data = request.get_json() # TODO: Implementasikan logika pemrosesan Anda di sini # Contoh: # context = data.get('context', '') # query = data.get('query', '') # result = f"Anda meminta: {query} dengan konteks: {context}" result = "Halo dari alat khusus Anda!" return jsonify({'result': result}) if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) app.run(debug=True, host='0.0.0.0', port=port) ``` **Penjelasan:** * **`app.py`:** Ini adalah file utama aplikasi Flask Anda. * **`Flask`:** Kerangka kerja web Python ringan yang digunakan untuk membuat API. * **`@app.route('/process', methods=['POST'])`:** Mendefinisikan endpoint `/process` yang menerima permintaan POST. Cursor IDE akan mengirimkan permintaan ke endpoint ini. * **`request.get_json()`:** Mengambil data JSON yang dikirimkan oleh Cursor IDE. Data ini biasanya berisi konteks kode dan kueri pengguna. * **`data.get('context', '')`:** Mengakses data konteks dari permintaan. Anda dapat menggunakan ini untuk mendapatkan informasi tentang kode yang sedang diedit. * **`data.get('query', '')`:** Mengakses kueri pengguna dari permintaan. Ini adalah pertanyaan atau perintah yang diberikan pengguna. * **`jsonify({'result': result})`:** Mengembalikan respons JSON ke Cursor IDE. Respons ini harus berisi hasil pemrosesan Anda. * **`os.environ.get('PORT', 5000)`:** Mendapatkan nomor port dari variabel lingkungan `PORT`. Ini penting untuk deployment ke platform seperti Heroku. Jika variabel lingkungan tidak diatur, defaultnya adalah port 5000. * **`app.run(debug=True, host='0.0.0.0', port=port)`:** Menjalankan aplikasi Flask. `debug=True` mengaktifkan mode debug, yang berguna untuk pengembangan. `host='0.0.0.0'` membuat aplikasi dapat diakses dari luar. **Cara Menggunakan:** 1. **Instal Flask:** `pip install Flask` 2. **Implementasikan Logika Pemrosesan Anda:** Ganti komentar `# TODO: Implementasikan logika pemrosesan Anda di sini` dengan kode yang melakukan apa yang Anda inginkan. Anda dapat menggunakan data `context` dan `query` untuk memproses permintaan. 3. **Jalankan Aplikasi:** `python app.py` 4. **Konfigurasikan Cursor IDE:** Di Cursor IDE, konfigurasikan alat khusus Anda untuk mengirimkan permintaan POST ke URL aplikasi Anda (misalnya, `http://localhost:5000/process`). Anda perlu menentukan URL, metode (POST), dan format data (JSON). **Opsi Deployment:** * **Heroku:** Buat aplikasi Heroku dan deploy kode Anda menggunakan Git. Pastikan untuk mengatur variabel lingkungan `PORT`. * **Docker:** Buat Dockerfile untuk aplikasi Anda dan bangun image Docker. Kemudian, jalankan container Docker. * **Langsung di dalam Cursor IDE:** Jika alat Anda sederhana, Anda dapat menjalankan aplikasi Flask langsung di dalam Cursor IDE. Namun, ini mungkin tidak ideal untuk alat yang lebih kompleks. **Contoh Dockerfile:** ```dockerfile FROM python:3.9-slim-buster WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . CMD ["python", "app.py"] ``` **requirements.txt:** ``` Flask ``` **Langkah-langkah Deployment Docker:** 1. **Buat Dockerfile dan requirements.txt:** Simpan file-file ini di direktori yang sama dengan `app.py`. 2. **Bangun Image Docker:** `docker build -t my-custom-tool .` 3. **Jalankan Container Docker:** `docker run -p 5000:5000 my-custom-tool` **Penting:** * **Keamanan:** Jika Anda meng-deploy alat Anda ke internet, pastikan untuk menerapkan langkah-langkah keamanan yang tepat, seperti otentikasi dan otorisasi. * **Penanganan Kesalahan:** Tambahkan penanganan kesalahan ke kode Anda untuk menangani kasus-kasus di mana permintaan gagal atau terjadi kesalahan. * **Dokumentasi:** Dokumentasikan API Anda sehingga pengguna dapat memahami cara menggunakannya. Templat ini memberikan titik awal yang sederhana untuk membuat alat khusus untuk Cursor IDE. Anda dapat menyesuaikannya untuk memenuhi kebutuhan spesifik Anda. Ingatlah untuk mengganti logika placeholder dengan kode Anda sendiri dan untuk menerapkan langkah-langkah keamanan yang tepat.

Model Context Protocol (MCP) Testing Servers

This is a web-based application for testing MCP servers. It was designed to demonstrate a MCP client capable of running in a typical web hosting environment.

SingleStore MCP Server

Server MCP untuk berinteraksi dengan SingleStore Management API dan layanan.

GitLab MCP Server

Server GitLab MCP (dengan fitur pelacakan aktivitas dan daftar proyek grup) Server ini didasarkan pada server GitLab MCP asli dengan peningkatan Daftar Proyek Grup dan Pelacakan Aktivitas.

req-refine MCP server

ReqRefine adalah server MCP yang meningkatkan pengumpulan kebutuhan melalui penanyaan strategis. Ia memandu pengguna untuk mengungkapkan kebutuhan yang komprehensif, mengungkap persyaratan implisit, dan mengubah dialog menjadi spesifikasi terstruktur.

open-browser-mcp-server

Buka peramban dan kunjungi alamat situs web yang ditentukan.

Kubernetes MCP Server

Server MCP untuk Kubernetes

🧠 Vibe Check MCP

Sistem interupsi pola metakognitif yang membantu mencegah asisten AI dari jalur penalaran yang terlalu rumit dengan menyediakan validasi eksternal, panduan penyederhanaan, dan mekanisme pembelajaran.

Pinecone Assistant MCP Server

Peladen MCP Asisten Pinecone