Discover Awesome MCP Servers

actual-mcp

Enables agents to read and edit budgets in Actual Budget via natural language, with a safety layer that requires confirmation for destructive actions.

Kiwix Wiki MCP Server

Provides access to offline Wikipedia and other content through Kiwix, enabling search and retrieval of articles from local ZIM files.

Filesystem MCP Server (@shtse8/filesystem-mcp)

Server Node.js Model Context Protocol (MCP) yang menyediakan akses sistem berkas yang aman dan relatif untuk agen AI seperti Cline/Claude.

dynamodb-mcp-server

An MCP server that gives LLM agents full access to Amazon DynamoDB, supporting table management, querying, scanning, and item CRUD operations.

screenshot-mcp

Enables AI agents to capture screenshots of windows (e.g., WeChat developer tools) and save them locally, allowing the agent to read the image directly and close the code-change-to-review loop without OSS or network.

MCP English Tutor

A professional 1-on-1 English tutoring server that enables AI assistants to provide oral practice, grammar correction, and vocabulary recommendations. It features specialized tools for generating conversation topics, tracking progress, and creating immersive role-play scenarios.

Zillow MCP Server

Integrates Zillow real estate data with AI assistants, enabling property search, neighborhood insights, and affordability calculations through natural language.

dispatch-mcp

MCP server for tier-based dispatch delegation via OmniRoute, enabling message dispatching to various AI model tiers and health monitoring.

WalletTriage MCP

Real-time exploit-exposure check for EVM wallets with x402 USDC payments, no signup needed.

Fastify MCP Server Plugin

A Fastify plugin that enables multi-tenant MCP servers with isolated tools per bearer token, allowing AI assistants to interact with custom services via the Model Context Protocol.

MCP Java Backend Suite

A comprehensive MCP toolkit for Java backend developers, providing 35 tools across 5 servers for database analysis, JVM diagnostics, migration assistance, Spring Boot monitoring, and Redis diagnostics.

mcptut1

Tutorial server dan klien MCP

MCP Installer

Here are a few ways to interpret "MCP server that searches MCP Servers" and their Indonesian translations: **Interpretation 1: A server for the Minecraft Coder Pack (MCP) that helps you find other MCP servers.** * **Indonesian Translation:** Server MCP yang mencari Server MCP lain. * **Alternative Indonesian Translation:** Server untuk Minecraft Coder Pack (MCP) yang membantu Anda menemukan server MCP lainnya. (More explicit) **Interpretation 2: A server that lists and provides information about other Minecraft servers using the Minecraft Coder Pack (MCP).** * **Indonesian Translation:** Server yang mendaftar dan memberikan informasi tentang server Minecraft lain yang menggunakan Minecraft Coder Pack (MCP). **Interpretation 3: A server that is itself an MCP server and also has a search function to find other MCP servers.** * **Indonesian Translation:** Server yang merupakan server MCP dan juga memiliki fungsi pencarian untuk menemukan server MCP lainnya. **Which translation is best depends on the specific context.** If you can provide more information about what the server *does*, I can give you a more accurate and helpful translation.

My MCP

TO DO microsoft

Highrise MCP Server by CData

This read-only MCP Server allows you to connect to Highrise data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

TMS Development Wizard

Enables rapid exploration and integration of Omelet's Routing Engine and iNavi's Maps API for building Transport Management Systems, providing endpoint discovery, schema exploration, integration patterns, and troubleshooting guides.

ClickUp MCP Server

Provides integration with ClickUp's API, allowing you to retrieve task information and manage ClickUp data through MCP-compatible clients.

suno-mcp

A RunAPI MCP server for the Suno music generation models, enabling task creation (text-to-music, covers, mashups, etc.), polling, and pricing lookup through a single API key.

git-log-mcp

Enables querying git commit history to analyze when and why code changes happened, providing authorship context and diffs for specific modules.

ProductLane MCP Server

Provides AI assistants with access to ProductLane support threads, contacts, changelogs, and documentation through a set of MCP tools.

mcpManager

A desktop app and local MCP gateway that centralizes management of Claude/Codex configurations and provides unified access to Daytona sandbox and Tailscale networking operations through a single proxy entry point.

Corpus MCP Server

Enables AI assistants to securely interact with the Corpus Tracker application to manage financial portfolios and analyze net worth. It provides tools for tracking stock and gold holdings, logging transactions, and generating cash flow trends.

MCP RAG System

A Retrieval-Augmented Generation system that enables uploading, processing, and semantic search of PDF documents using vector embeddings and FAISS indexing for context-aware question answering.

Data.gov.il MCP Server

Enables AI assistants to search, discover, and analyze thousands of datasets from Israel's national open data portal. It provides tools for querying government ministries, municipalities, and public bodies using the CKAN API.

YouTube MCP Server

Enables AI agents to extract YouTube video metadata and generate high-quality multilingual transcriptions with voice activity detection, supporting 99 languages with translation capabilities and intelligent caching.

MCP TS Quickstart

Okay, here's a guide to creating a build-less TypeScript quickstart for an MCP (presumably Minecraft Protocol) server implementation. This approach prioritizes speed of setup and iteration, sacrificing some performance and type-checking rigor for the sake of simplicity. **Important Considerations:** * **Performance:** Running TypeScript directly without compilation is generally slower than running compiled JavaScript. This is fine for prototyping and small-scale testing, but you'll want to compile to JavaScript for production. * **Type Checking:** While you'll get some type checking from your IDE, you won't have the full, strict type checking that a proper build process provides. This means you might miss errors until runtime. * **Dependencies:** This approach assumes you're using a module system that Node.js understands (CommonJS or ES Modules). We'll use ES Modules for this example. **Steps:** 1. **Project Setup:** * Create a new directory for your project: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Initialize a `package.json` file: ```bash npm init -y ``` * Install TypeScript as a development dependency: ```bash npm install --save-dev typescript @types/node ``` 2. **TypeScript Configuration (tsconfig.json - Optional but Recommended):** While we're aiming for "build-less," a basic `tsconfig.json` can still be helpful for IDE support and some level of type checking. Create a `tsconfig.json` file in your project root: ```json { "compilerOptions": { "target": "es2020", // Or a more recent version "module": "esnext", // Use ES Modules "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Optional: If you *do* want to compile later }, "include": ["src/**/*"], // Where your TypeScript files are "exclude": ["node_modules"] } ``` * **`target`:** Specifies the ECMAScript target version. `es2020` or later is generally a good choice. * **`module`:** Crucially, set this to `esnext` to use ES Modules. This allows you to use `import` and `export` statements directly. * **`moduleResolution`:** Set to `node` for Node.js-style module resolution. * **`esModuleInterop`:** Important for compatibility between CommonJS and ES Modules. * **`strict`:** Enables strict type checking (recommended for catching errors). * **`skipLibCheck`:** Can speed up type checking by skipping type checking of declaration files. Disable if you encounter type errors in your dependencies. * **`outDir`:** Optional. If you decide to compile later, this specifies the output directory for the compiled JavaScript files. 3. **Create a Source Directory:** ```bash mkdir src ``` 4. **Create Your Server File (e.g., `src/index.ts`):** ```typescript // src/index.ts import net from 'net'; const PORT = 25565; // Default Minecraft port const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); socket.on('data', (data) => { console.log('Received data:', data); // TODO: Implement Minecraft protocol handling here socket.write('Hello from the server!\n'); // Example response }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); ``` 5. **Run Your Server (Without Compilation):** You can run the TypeScript file directly using `ts-node` (if you install it) or using Node.js with the `--loader` flag. Since we're aiming for build-less, let's use the `--loader` flag. Add this to your `package.json` scripts: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "node --loader ts-node/esm src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@types/node": "^20.11.19", "typescript": "^5.4.0-dev.20240320" } } ``` Then, run: ```bash npm start ``` **Explanation of `node --loader ts-node/esm src/index.ts`:** * `node`: Executes the Node.js runtime. * `--loader ts-node/esm`: This is the key part. It tells Node.js to use `ts-node/esm` as a module loader. `ts-node/esm` is a special version of `ts-node` that supports ES Modules. It will dynamically compile your TypeScript code in memory and execute it. * `src/index.ts`: The entry point to your application. 6. **Install `ts-node` (Alternative):** If you prefer, you can install `ts-node` globally or locally: ```bash npm install -g ts-node # Globally (not recommended for project-specific dependencies) npm install --save-dev ts-node # Locally ``` If you install it locally, you'll need to adjust your `package.json` script: ```json { "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" } } ``` Then run `npm start`. **Explanation and Next Steps:** * **Basic Server:** The code creates a simple TCP server that listens on port 25565 (the default Minecraft port). It logs client connections, receives data, and sends a basic response. * **Minecraft Protocol:** The `// TODO: Implement Minecraft protocol handling here` comment is where you'll need to add the logic to parse and handle the Minecraft protocol. This is the most complex part of building an MCP server. You'll need to understand the protocol specification. Libraries exist to help with this (see below). * **Error Handling:** The code includes basic error handling for socket errors. You'll want to expand this to handle other potential errors. * **Asynchronous Operations:** Minecraft protocol handling often involves asynchronous operations (e.g., reading data from the socket). Use `async/await` to make your code more readable. **Libraries to Consider:** * **`prismarine-protocol`:** A popular library for parsing and handling the Minecraft protocol. It's part of the PrismarineJS project. This is *highly* recommended. * **`node-raknet`:** If you're dealing with Bedrock Edition, you'll need to handle the RakNet protocol. **Example using `prismarine-protocol` (Illustrative - Requires Installation):** First, install the library: ```bash npm install prismarine-protocol ``` Then, modify your `src/index.ts` (this is a simplified example): ```typescript import net from 'net'; import { createSerializer, createDeserializer } from 'prismarine-protocol'; const PORT = 25565; const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); const serializer = createSerializer({ version: '1.19.4' }); // Replace with the correct version const deserializer = createDeserializer({ version: '1.19.4' }); socket.on('data', (data) => { deserializer.write(data); let packet; while ((packet = deserializer.read())) { console.log('Received packet:', packet); // Example: Respond to a handshake packet if (packet.name === 'handshake') { const response = { version_name: 'My Server', protocol_version: packet.data.protocol_version, max_players: 100, online_players: 0, sample: [], description: { text: 'A TypeScript MCP Server' }, favicon: null, }; serializer.write('status', response); const statusPacket = serializer.read(); if (statusPacket) { socket.write(statusPacket); } } } }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); ``` **Important Notes about the `prismarine-protocol` Example:** * **Version:** You *must* specify the correct Minecraft protocol version when creating the serializer and deserializer. The example uses `'1.19.4'`. Use the version that your server is intended to support. Incorrect versions will lead to parsing errors. * **Packet Handling:** The example shows how to read packets using `deserializer.read()`. You'll need to implement logic to handle different packet types based on the Minecraft protocol specification. * **Status Response:** The example shows how to respond to a handshake packet with a status response. This is a basic example; you'll need to implement the full status response according to the protocol. * **Error Handling:** `prismarine-protocol` can throw errors if it encounters invalid data. Wrap your `deserializer.read()` calls in a `try...catch` block to handle these errors gracefully. * **Buffering:** The `deserializer` might not have enough data to parse a complete packet. It buffers the data internally. The `while ((packet = deserializer.read()))` loop ensures that you process all available packets. **Moving to Production:** When you're ready to deploy your server to production, you *must* compile your TypeScript code to JavaScript. Use the `tsc` command: ```bash tsc ``` This will create JavaScript files in the `outDir` specified in your `tsconfig.json` (or the current directory if you don't have an `outDir`). Then, you can run the JavaScript files using Node.js: ```bash node dist/index.js // Assuming your output directory is "dist" ``` **Summary:** This guide provides a quick way to get started with a TypeScript MCP server implementation without a full build process. Remember that this approach is best for prototyping and small-scale testing. For production deployments, you should always compile your TypeScript code to JavaScript. Use libraries like `prismarine-protocol` to simplify the process of handling the Minecraft protocol. Good luck! **Indonesian Translation:** Oke, berikut adalah panduan untuk membuat *quickstart* TypeScript tanpa proses *build* untuk implementasi server MCP (kemungkinan besar Minecraft Protocol). Pendekatan ini memprioritaskan kecepatan pengaturan dan iterasi, mengorbankan beberapa kinerja dan ketelitian pemeriksaan tipe demi kesederhanaan. **Pertimbangan Penting:** * **Kinerja:** Menjalankan TypeScript secara langsung tanpa kompilasi umumnya lebih lambat daripada menjalankan JavaScript yang telah dikompilasi. Ini tidak masalah untuk pembuatan prototipe dan pengujian skala kecil, tetapi Anda perlu mengkompilasi ke JavaScript untuk produksi. * **Pemeriksaan Tipe:** Meskipun Anda akan mendapatkan beberapa pemeriksaan tipe dari IDE Anda, Anda tidak akan memiliki pemeriksaan tipe yang lengkap dan ketat seperti yang disediakan oleh proses *build* yang tepat. Ini berarti Anda mungkin melewatkan kesalahan hingga *runtime*. * **Dependensi:** Pendekatan ini mengasumsikan Anda menggunakan sistem modul yang dipahami oleh Node.js (CommonJS atau ES Modules). Kita akan menggunakan ES Modules untuk contoh ini. **Langkah-langkah:** 1. **Pengaturan Proyek:** * Buat direktori baru untuk proyek Anda: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Inisialisasi file `package.json`: ```bash npm init -y ``` * Instal TypeScript sebagai dependensi pengembangan: ```bash npm install --save-dev typescript @types/node ``` 2. **Konfigurasi TypeScript (tsconfig.json - Opsional tetapi Disarankan):** Meskipun kita bertujuan untuk "tanpa *build*," `tsconfig.json` dasar masih dapat membantu untuk dukungan IDE dan beberapa tingkat pemeriksaan tipe. Buat file `tsconfig.json` di *root* proyek Anda: ```json { "compilerOptions": { "target": "es2020", // Atau versi yang lebih baru "module": "esnext", // Gunakan ES Modules "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Opsional: Jika Anda *ingin* mengkompilasi nanti }, "include": ["src/**/*"], // Di mana file TypeScript Anda berada "exclude": ["node_modules"] } ``` * **`target`:** Menentukan versi ECMAScript target. `es2020` atau yang lebih baru umumnya merupakan pilihan yang baik. * **`module`:** Sangat penting, atur ini ke `esnext` untuk menggunakan ES Modules. Ini memungkinkan Anda menggunakan pernyataan `import` dan `export` secara langsung. * **`moduleResolution`:** Atur ke `node` untuk resolusi modul gaya Node.js. * **`esModuleInterop`:** Penting untuk kompatibilitas antara CommonJS dan ES Modules. * **`strict`:** Mengaktifkan pemeriksaan tipe yang ketat (disarankan untuk menangkap kesalahan). * **`skipLibCheck`:** Dapat mempercepat pemeriksaan tipe dengan melewati pemeriksaan tipe file deklarasi. Nonaktifkan jika Anda menemukan kesalahan tipe dalam dependensi Anda. * **`outDir`:** Opsional. Jika Anda memutuskan untuk mengkompilasi nanti, ini menentukan direktori keluaran untuk file JavaScript yang dikompilasi. 3. **Buat Direktori Sumber:** ```bash mkdir src ``` 4. **Buat File Server Anda (misalnya, `src/index.ts`):** ```typescript // src/index.ts import net from 'net'; const PORT = 25565; // Port Minecraft default const server = net.createServer((socket) => { console.log('Klien terhubung:', socket.remoteAddress, socket.remotePort); socket.on('data', (data) => { console.log('Data diterima:', data); // TODO: Implementasikan penanganan protokol Minecraft di sini socket.write('Halo dari server!\n'); // Contoh respons }); socket.on('close', () => { console.log('Klien terputus:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Kesalahan socket:', err); }); }); server.listen(PORT, () => { console.log(`Server mendengarkan di port ${PORT}`); }); ``` 5. **Jalankan Server Anda (Tanpa Kompilasi):** Anda dapat menjalankan file TypeScript secara langsung menggunakan `ts-node` (jika Anda menginstalnya) atau menggunakan Node.js dengan *flag* `--loader`. Karena kita bertujuan untuk tanpa *build*, mari gunakan *flag* `--loader`. Tambahkan ini ke skrip `package.json` Anda: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "node --loader ts-node/esm src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@types/node": "^20.11.19", "typescript": "^5.4.0-dev.20240320" } } ``` Kemudian, jalankan: ```bash npm start ``` **Penjelasan `node --loader ts-node/esm src/index.ts`:** * `node`: Mengeksekusi *runtime* Node.js. * `--loader ts-node/esm`: Ini adalah bagian penting. Ini memberi tahu Node.js untuk menggunakan `ts-node/esm` sebagai *module loader*. `ts-node/esm` adalah versi khusus dari `ts-node` yang mendukung ES Modules. Ini akan secara dinamis mengkompilasi kode TypeScript Anda dalam memori dan mengeksekusinya. * `src/index.ts`: Titik masuk ke aplikasi Anda. 6. **Instal `ts-node` (Alternatif):** Jika Anda lebih suka, Anda dapat menginstal `ts-node` secara global atau lokal: ```bash npm install -g ts-node # Secara global (tidak disarankan untuk dependensi khusus proyek) npm install --save-dev ts-node # Secara lokal ``` Jika Anda menginstalnya secara lokal, Anda perlu menyesuaikan skrip `package.json` Anda: ```json { "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" } } ``` Kemudian jalankan `npm start`. **Penjelasan dan Langkah Selanjutnya:** * **Server Dasar:** Kode membuat server TCP sederhana yang mendengarkan di port 25565 (port Minecraft default). Ini mencatat koneksi klien, menerima data, dan mengirim respons dasar. * **Protokol Minecraft:** Komentar `// TODO: Implementasikan penanganan protokol Minecraft di sini` adalah tempat Anda perlu menambahkan logika untuk mengurai dan menangani protokol Minecraft. Ini adalah bagian paling kompleks dari membangun server MCP. Anda perlu memahami spesifikasi protokol. Pustaka ada untuk membantu dengan ini (lihat di bawah). * **Penanganan Kesalahan:** Kode menyertakan penanganan kesalahan dasar untuk kesalahan *socket*. Anda perlu memperluas ini untuk menangani potensi kesalahan lainnya. * **Operasi Asinkron:** Penanganan protokol Minecraft sering melibatkan operasi asinkron (misalnya, membaca data dari *socket*). Gunakan `async/await` untuk membuat kode Anda lebih mudah dibaca. **Pustaka yang Perlu Dipertimbangkan:** * **`prismarine-protocol`:** Pustaka populer untuk mengurai dan menangani protokol Minecraft. Ini adalah bagian dari proyek PrismarineJS. Ini *sangat* direkomendasikan. * **`node-raknet`:** Jika Anda berurusan dengan Bedrock Edition, Anda perlu menangani protokol RakNet. **Contoh menggunakan `prismarine-protocol` (Ilustratif - Membutuhkan Instalasi):** Pertama, instal pustaka: ```bash npm install prismarine-protocol ``` Kemudian, modifikasi `src/index.ts` Anda (ini adalah contoh yang disederhanakan): ```typescript import net from 'net'; import { createSerializer, createDeserializer } from 'prismarine-protocol'; const PORT = 25565; const server = net.createServer((socket) => { console.log('Klien terhubung:', socket.remoteAddress, socket.remotePort); const serializer = createSerializer({ version: '1.19.4' }); // Ganti dengan versi yang benar const deserializer = createDeserializer({ version: '1.19.4' }); socket.on('data', (data) => { deserializer.write(data); let packet; while ((packet = deserializer.read())) { console.log('Paket diterima:', packet); // Contoh: Menanggapi paket handshake if (packet.name === 'handshake') { const response = { version_name: 'My Server', protocol_version: packet.data.protocol_version, max_players: 100, online_players: 0, sample: [], description: { text: 'A TypeScript MCP Server' }, favicon: null, }; serializer.write('status', response); const statusPacket = serializer.read(); if (statusPacket) { socket.write(statusPacket); } } } }); socket.on('close', () => { console.log('Klien terputus:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Kesalahan socket:', err); }); }); server.listen(PORT, () => { console.log(`Server mendengarkan di port ${PORT}`); }); ``` **Catatan Penting tentang Contoh `prismarine-protocol`:** * **Versi:** Anda *harus* menentukan versi protokol Minecraft yang benar saat membuat *serializer* dan *deserializer*. Contohnya menggunakan `'1.19.4'`. Gunakan versi yang ingin didukung oleh server Anda. Versi yang salah akan menyebabkan kesalahan penguraian. * **Penanganan Paket:** Contoh menunjukkan cara membaca paket menggunakan `deserializer.read()`. Anda perlu mengimplementasikan logika untuk menangani berbagai jenis paket berdasarkan spesifikasi protokol Minecraft. * **Respons Status:** Contoh menunjukkan cara menanggapi paket *handshake* dengan respons status. Ini adalah contoh dasar; Anda perlu mengimplementasikan respons status lengkap sesuai dengan protokol. * **Penanganan Kesalahan:** `prismarine-protocol` dapat memunculkan kesalahan jika menemukan data yang tidak valid. Bungkus panggilan `deserializer.read()` Anda dalam blok `try...catch` untuk menangani kesalahan ini dengan baik. * **Buffering:** `deserializer` mungkin tidak memiliki cukup data untuk mengurai paket lengkap. Ini *buffer* data secara internal. Loop `while ((packet = deserializer.read()))` memastikan bahwa Anda memproses semua paket yang tersedia. **Pindah ke Produksi:** Saat Anda siap untuk menyebarkan server Anda ke produksi, Anda *harus* mengkompilasi kode TypeScript Anda ke JavaScript. Gunakan perintah `tsc`: ```bash tsc ``` Ini akan membuat file JavaScript di `outDir` yang ditentukan dalam `tsconfig.json` Anda (atau direktori saat ini jika Anda tidak memiliki `outDir`). Kemudian, Anda dapat menjalankan file JavaScript menggunakan Node.js: ```bash node dist/index.js // Asumsikan direktori keluaran Anda adalah "dist" ``` **Ringkasan:** Panduan ini menyediakan cara cepat untuk memulai implementasi server MCP TypeScript tanpa proses *build* lengkap. Ingatlah bahwa pendekatan ini paling baik untuk pembuatan prototipe dan pengujian skala kecil. Untuk penyebaran produksi, Anda harus selalu mengkompilasi kode TypeScript Anda ke JavaScript. Gunakan pustaka seperti `prismarine-protocol` untuk menyederhanakan proses penanganan protokol Minecraft. Semoga berhasil!

서울시 교통 데이터 MCP 서버

서울시 교통 데이터 MCP 서버 - 실시간 교통 정보, 대중교통, 따릉이 등의 데이터를 제공하는 MCP 서버

CloakBrowser MCP Server

A stealth browser automation MCP server that wraps CloakBrowser's patched Chromium to bypass bot detection, providing 22 tools for web navigation, interaction, and session management.

Nuclino MCP Server

Provides access to Nuclino content through structured search and retrieval tools.

safe-solana-mcp

An MCP server providing policy-gated Solana access for AI agents, with read-only operations and guarded transfers that require policy checks and simulation, returning unsigned transactions.