Discover Awesome MCP Servers

Cerebra Legal MCP Server

Server MCP kelas perusahaan yang menyediakan alat khusus untuk penalaran dan analisis hukum, secara otomatis mendeteksi domain hukum dan menawarkan panduan, templat, dan pemformatan sitasi khusus domain.

Overview

An MCP server for Apache Kafka & its ecosystem.

MCP Server for MySQL based on NodeJS

Server Protokol Konteks Model yang menyediakan akses baca-saja ke database MySQL, memungkinkan LLM untuk memeriksa skema database dan menjalankan kueri baca-saja.

Getting Started

Golang MCP server example

pty-mcp

An MCP tool server that provides a stateful terminal.

Swift MCP GUI Server

There isn't a single, widely known "MCP server" specifically designed to execute keyboard input and mouse movement commands on macOS. The term "MCP server" is quite broad and could refer to various things. However, here's a breakdown of approaches and technologies you could use to achieve this, along with considerations for each: **Understanding the Challenge** Controlling keyboard and mouse input programmatically on macOS requires interacting with the operating system's accessibility features and security mechanisms. macOS is very protective of user input, so you'll need to grant the necessary permissions. **Possible Approaches and Technologies** 1. **AppleScript (with a Server Component):** * **How it works:** AppleScript is a scripting language built into macOS that can control applications and system functions, including keyboard and mouse input. You can create an AppleScript that performs the desired actions. You would then need a server component (e.g., a Python script using Flask or a Node.js server) to receive commands and execute the AppleScript. * **Example (AppleScript):** ```applescript tell application "System Events" keystroke "Hello, world!" delay 0.5 click at {100, 100} -- Click at coordinates (100, 100) end tell ``` * **Pros:** Relatively easy to learn and use for basic tasks. Built-in to macOS. * **Cons:** AppleScript can be slow. Requires enabling accessibility permissions in System Preferences (Security & Privacy > Accessibility). The server component adds complexity. Error handling can be tricky. 2. **Python with `pyautogui` (and a Server Component):** * **How it works:** `pyautogui` is a Python library that provides functions for controlling the mouse and keyboard. You'd need a server (e.g., Flask, Django, FastAPI) to receive commands and then use `pyautogui` to execute them. * **Example (Python with `pyautogui`):** ```python import pyautogui from flask import Flask, request app = Flask(__name__) @app.route('/keypress', methods=['POST']) def keypress(): data = request.get_json() key = data.get('key') if key: pyautogui.press(key) return "Key pressed", 200 else: return "No key specified", 400 @app.route('/movemouse', methods=['POST']) def movemouse(): data = request.get_json() x = data.get('x') y = data.get('y') if x is not None and y is not None: pyautogui.moveTo(x, y) return "Mouse moved", 200 else: return "Missing x or y coordinate", 400 if __name__ == '__main__': app.run(debug=True) ``` * **Pros:** Python is a versatile language. `pyautogui` is relatively easy to use. * **Cons:** Requires installing Python and `pyautogui`. Requires enabling accessibility permissions. The server component adds complexity. `pyautogui` can be unreliable if the target application's UI changes. 3. **Node.js with `robotjs` (and a Server Component):** * **How it works:** `robotjs` is a Node.js library for controlling the mouse and keyboard. Similar to the Python approach, you'd need a server (e.g., Express.js) to receive commands and then use `robotjs` to execute them. * **Example (Node.js with `robotjs`):** ```javascript const robot = require('robotjs'); const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); // for parsing application/json app.post('/keypress', (req, res) => { const key = req.body.key; if (key) { robot.keyTap(key); res.send('Key pressed'); } else { res.status(400).send('No key specified'); } }); app.post('/movemouse', (req, res) => { const x = req.body.x; const y = req.body.y; if (x !== undefined && y !== undefined) { robot.moveMouse(x, y); res.send('Mouse moved'); } else { res.status(400).send('Missing x or y coordinate'); } }); app.listen(port, () => { console.log(`Example app listening at http://localhost:${port}`); }); ``` * **Pros:** Node.js is widely used and has a large community. `robotjs` is relatively performant. * **Cons:** Requires installing Node.js and `robotjs`. Requires enabling accessibility permissions. The server component adds complexity. 4. **Objective-C/Swift (with a Server Component):** * **How it works:** You can write a native macOS application using Objective-C or Swift that uses the `CGEvent` API to control keyboard and mouse input. This would likely be the most robust and performant solution, but also the most complex to develop. You'd still need a server component to receive commands. * **Pros:** Native performance. Fine-grained control over input events. * **Cons:** Steeper learning curve. Requires Xcode and knowledge of Objective-C or Swift. Significant development effort. Requires enabling accessibility permissions. **Important Considerations (Security and Permissions)** * **Accessibility Permissions:** All of these methods (except perhaps a very low-level, kernel-mode driver, which is highly discouraged) will require you to grant accessibility permissions to the application or script in System Preferences > Security & Privacy > Accessibility. This is a *critical* security consideration. Only grant these permissions to applications you trust completely. macOS will prompt the user to grant these permissions the first time the application attempts to use the accessibility APIs. * **Security Risks:** Allowing an application to control your keyboard and mouse poses a significant security risk. A malicious application could use these permissions to steal passwords, control your computer remotely, or perform other harmful actions. Be extremely cautious about granting these permissions. * **Sandboxing:** If you're distributing your application, consider macOS's sandboxing features to limit its capabilities and reduce the potential for harm. **Choosing the Right Approach** * **For simple tasks and quick prototyping:** AppleScript or Python with `pyautogui` might be sufficient. * **For more complex or performance-critical tasks:** Node.js with `robotjs` or a native Objective-C/Swift application would be better choices. * **If security is paramount:** Carefully consider the implications of granting accessibility permissions and implement appropriate security measures. **In summary, there's no single "MCP server" for this purpose. You'll need to combine a server component (e.g., Flask, Express.js) with a library or API that can control keyboard and mouse input (e.g., AppleScript, `pyautogui`, `robotjs`, `CGEvent`). Remember to prioritize security and only grant accessibility permissions to trusted applications.** Here's the translation to Indonesian: Tidak ada "server MCP" tunggal yang dikenal luas yang dirancang khusus untuk menjalankan perintah input keyboard dan gerakan mouse di macOS. Istilah "server MCP" cukup luas dan dapat merujuk pada berbagai hal. Namun, berikut adalah rincian pendekatan dan teknologi yang dapat Anda gunakan untuk mencapai ini, beserta pertimbangan untuk masing-masing: **Memahami Tantangan** Mengontrol input keyboard dan mouse secara terprogram di macOS memerlukan interaksi dengan fitur aksesibilitas dan mekanisme keamanan sistem operasi. macOS sangat protektif terhadap input pengguna, jadi Anda perlu memberikan izin yang diperlukan. **Pendekatan dan Teknologi yang Mungkin** 1. **AppleScript (dengan Komponen Server):** * **Cara kerjanya:** AppleScript adalah bahasa skrip bawaan macOS yang dapat mengontrol aplikasi dan fungsi sistem, termasuk input keyboard dan mouse. Anda dapat membuat AppleScript yang melakukan tindakan yang diinginkan. Anda kemudian memerlukan komponen server (misalnya, skrip Python menggunakan Flask atau server Node.js) untuk menerima perintah dan menjalankan AppleScript. * **Contoh (AppleScript):** ```applescript tell application "System Events" keystroke "Hello, world!" delay 0.5 click at {100, 100} -- Klik pada koordinat (100, 100) end tell ``` * **Kelebihan:** Relatif mudah dipelajari dan digunakan untuk tugas-tugas dasar. Bawaan macOS. * **Kekurangan:** AppleScript bisa lambat. Memerlukan pengaktifan izin aksesibilitas di System Preferences (Security & Privacy > Accessibility). Komponen server menambah kompleksitas. Penanganan kesalahan bisa rumit. 2. **Python dengan `pyautogui` (dan Komponen Server):** * **Cara kerjanya:** `pyautogui` adalah pustaka Python yang menyediakan fungsi untuk mengontrol mouse dan keyboard. Anda memerlukan server (misalnya, Flask, Django, FastAPI) untuk menerima perintah dan kemudian menggunakan `pyautogui` untuk menjalankannya. * **Contoh (Python dengan `pyautogui`):** ```python import pyautogui from flask import Flask, request app = Flask(__name__) @app.route('/keypress', methods=['POST']) def keypress(): data = request.get_json() key = data.get('key') if key: pyautogui.press(key) return "Key pressed", 200 else: return "No key specified", 400 @app.route('/movemouse', methods=['POST']) def movemouse(): data = request.get_json() x = data.get('x') y = data.get('y') if x is not None and y is not None: pyautogui.moveTo(x, y) return "Mouse moved", 200 else: return "Missing x or y coordinate", 400 if __name__ == '__main__': app.run(debug=True) ``` * **Kelebihan:** Python adalah bahasa yang serbaguna. `pyautogui` relatif mudah digunakan. * **Kekurangan:** Memerlukan instalasi Python dan `pyautogui`. Memerlukan pengaktifan izin aksesibilitas. Komponen server menambah kompleksitas. `pyautogui` bisa tidak dapat diandalkan jika UI aplikasi target berubah. 3. **Node.js dengan `robotjs` (dan Komponen Server):** * **Cara kerjanya:** `robotjs` adalah pustaka Node.js untuk mengontrol mouse dan keyboard. Mirip dengan pendekatan Python, Anda memerlukan server (misalnya, Express.js) untuk menerima perintah dan kemudian menggunakan `robotjs` untuk menjalankannya. * **Contoh (Node.js dengan `robotjs`):** ```javascript const robot = require('robotjs'); const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); // for parsing application/json app.post('/keypress', (req, res) => { const key = req.body.key; if (key) { robot.keyTap(key); res.send('Key pressed'); } else { res.status(400).send('No key specified'); } }); app.post('/movemouse', (req, res) => { const x = req.body.x; const y = req.body.y; if (x !== undefined && y !== undefined) { robot.moveMouse(x, y); res.send('Mouse moved'); } else { res.status(400).send('Missing x or y coordinate'); } }); app.listen(port, () => { console.log(`Example app listening at http://localhost:${port}`); }); ``` * **Kelebihan:** Node.js banyak digunakan dan memiliki komunitas yang besar. `robotjs` relatif berkinerja tinggi. * **Kekurangan:** Memerlukan instalasi Node.js dan `robotjs`. Memerlukan pengaktifan izin aksesibilitas. Komponen server menambah kompleksitas. 4. **Objective-C/Swift (dengan Komponen Server):** * **Cara kerjanya:** Anda dapat menulis aplikasi macOS asli menggunakan Objective-C atau Swift yang menggunakan API `CGEvent` untuk mengontrol input keyboard dan mouse. Ini mungkin solusi yang paling kuat dan berkinerja tinggi, tetapi juga yang paling kompleks untuk dikembangkan. Anda tetap memerlukan komponen server untuk menerima perintah. * **Kelebihan:** Kinerja asli. Kontrol terperinci atas peristiwa input. * **Kekurangan:** Kurva pembelajaran yang lebih curam. Memerlukan Xcode dan pengetahuan tentang Objective-C atau Swift. Upaya pengembangan yang signifikan. Memerlukan pengaktifan izin aksesibilitas. **Pertimbangan Penting (Keamanan dan Izin)** * **Izin Aksesibilitas:** Semua metode ini (kecuali mungkin driver mode kernel tingkat rendah, yang sangat tidak disarankan) akan mengharuskan Anda memberikan izin aksesibilitas ke aplikasi atau skrip di System Preferences > Security & Privacy > Accessibility. Ini adalah pertimbangan keamanan *kritis*. Hanya berikan izin ini ke aplikasi yang Anda percayai sepenuhnya. macOS akan meminta pengguna untuk memberikan izin ini saat pertama kali aplikasi mencoba menggunakan API aksesibilitas. * **Risiko Keamanan:** Mengizinkan aplikasi untuk mengontrol keyboard dan mouse Anda menimbulkan risiko keamanan yang signifikan. Aplikasi jahat dapat menggunakan izin ini untuk mencuri kata sandi, mengontrol komputer Anda dari jarak jauh, atau melakukan tindakan berbahaya lainnya. Berhati-hatilah saat memberikan izin ini. * **Sandboxing:** Jika Anda mendistribusikan aplikasi Anda, pertimbangkan fitur sandboxing macOS untuk membatasi kemampuannya dan mengurangi potensi bahaya. **Memilih Pendekatan yang Tepat** * **Untuk tugas sederhana dan pembuatan prototipe cepat:** AppleScript atau Python dengan `pyautogui` mungkin cukup. * **Untuk tugas yang lebih kompleks atau kritis terhadap kinerja:** Node.js dengan `robotjs` atau aplikasi Objective-C/Swift asli akan menjadi pilihan yang lebih baik. * **Jika keamanan adalah yang terpenting:** Pertimbangkan dengan cermat implikasi dari pemberian izin aksesibilitas dan terapkan langkah-langkah keamanan yang sesuai. **Singkatnya, tidak ada "server MCP" tunggal untuk tujuan ini. Anda perlu menggabungkan komponen server (misalnya, Flask, Express.js) dengan pustaka atau API yang dapat mengontrol input keyboard dan mouse (misalnya, AppleScript, `pyautogui`, `robotjs`, `CGEvent`). Ingatlah untuk memprioritaskan keamanan dan hanya memberikan izin aksesibilitas ke aplikasi yang tepercaya.**

browser-use MCP Server

Server MCP berbasis TypeScript yang mengimplementasikan sistem catatan sederhana, memungkinkan pengguna untuk membuat, mengakses, dan menghasilkan ringkasan catatan teks melalui Claude Desktop.

Linear MCP Server

linear MCP server based on mcp-go

MCP-LLM Bridge

Jembatan antara server Ollama dan MCP, memungkinkan LLM lokal untuk menggunakan alat Protokol Konteks Model.

UseGrant MCP Server

Server Protokol Konteks Model yang menyediakan alat untuk mengelola penyedia, klien, penyewa, dan token akses melalui platform UseGrant.

GitHub MCP Server Plus

Mirror of

Patent_mcp_server

Server FastMCP untuk data USPTO

Solana Model Context Protocol (MCP) Demo

Implementasi server MCP sederhana yang menyediakan model AI dengan metode Solana RPC dasar dan perintah pengembangan yang bermanfaat.

LMStudio-MCP

Jembatan yang memungkinkan Claude berkomunikasi dengan model LLM yang berjalan secara lokal melalui LM Studio, sehingga pengguna dapat memanfaatkan model pribadi mereka melalui antarmuka Claude.

PancakeSwap PoolSpy MCP Server

Sebuah server MCP yang melacak liquidity pool yang baru dibuat di Pancake Swap.

Mcp Allure Server

Sebuah server yang mengonversi laporan pengujian Allure ke dalam format yang mudah dipahami oleh LLM (Large Language Model), memungkinkan model AI untuk menganalisis hasil pengujian dengan lebih baik dan memberikan wawasan tentang kegagalan pengujian serta potensi perbaikan.

MCP GitHub Repository Server

Mirror of

MCP Server Whisper

Sebuah Server MCP untuk transkripsi audio menggunakan OpenAI.

Pica Mcp Server

A Model Context Protocol Server for Pica, built in TypeScript

🪐 ✨ Earthdata MCP Server

Server Protokol Konteks Model yang memungkinkan penemuan dan pengambilan Data Bumi NASA secara efisien untuk analisis geospasial.

Steel Puppeteer

Cermin dari

Snak

Bangun agen AI yang kuat dan aman dengan dukungan Starknet.