Discover Awesome MCP Servers

ntfy-me-mcp

A streamlined MCP server that enables AI assistants to send real-time notifications to your devices through the ntfy service, allowing you to receive alerts when tasks complete or important events occur.

Remote MCP Server (Authless)

A template for deploying MCP servers on Cloudflare Workers without authentication. Enables easy deployment and connection to MCP clients like Claude Desktop and Cloudflare AI Playground through remote URLs.

Sourcerer MCP

An MCP server for semantic code search & navigation that helps AI agents work efficiently without burning through costly tokens. Instead of reading entire files, agents can search conceptually and jump directly to the specific functions, classes, and code chunks they need.

image-reader MCP Server

Server MCP berbasis TypeScript yang mengimplementasikan sistem catatan sederhana, memungkinkan pembuatan dan pengelolaan catatan teks dengan URI dan metadata.

spring-ai-mcp-server

Repositori ini memiliki demo server MCP untuk pengkodean Spring AI Vibe.

FinQ4Cn-mcp-server

Saya tidak memiliki informasi spesifik tentang server MCP (Message Communication Protocol) kuantitatif yang *paling* cocok untuk digunakan di Tiongkok. Namun, saya dapat memberikan beberapa pertimbangan dan opsi yang mungkin relevan, serta faktor-faktor yang perlu Anda pertimbangkan: **Faktor-faktor yang Perlu Dipertimbangkan:** * **Kepatuhan Regulasi:** Ini adalah yang *paling* penting. Pastikan server dan infrastruktur Anda mematuhi semua peraturan dan hukum Tiongkok yang relevan terkait data, keuangan, dan teknologi. Ini termasuk peraturan tentang transfer data lintas batas, keamanan data, dan lisensi yang diperlukan. * **Konektivitas dan Latensi:** Akses yang cepat dan andal ke data pasar dan bursa saham Tiongkok sangat penting. Pertimbangkan lokasi server, kualitas koneksi jaringan, dan latensi yang dapat ditoleransi untuk strategi perdagangan Anda. * **Keamanan:** Keamanan data dan sistem Anda sangat penting. Pilih server dengan fitur keamanan yang kuat, termasuk enkripsi, kontrol akses, dan perlindungan terhadap serangan siber. * **Skalabilitas:** Server harus dapat menangani volume data dan transaksi yang Anda harapkan, dan harus dapat ditingkatkan seiring pertumbuhan kebutuhan Anda. * **Dukungan Teknis:** Pastikan penyedia server menawarkan dukungan teknis yang responsif dan berkualitas, terutama dalam bahasa Mandarin. * **Biaya:** Pertimbangkan biaya server, bandwidth, dan layanan tambahan lainnya. * **Integrasi dengan Platform Perdagangan:** Pastikan server dapat terintegrasi dengan platform perdagangan dan sistem kuantitatif yang Anda gunakan. * **Bahasa:** Pertimbangkan apakah server dan dokumentasinya tersedia dalam bahasa Mandarin. **Opsi yang Mungkin Relevan (dengan catatan):** * **Server Cloud di Tiongkok:** * **Alibaba Cloud (Aliyun):** Penyedia cloud besar dengan infrastruktur di Tiongkok. Mereka menawarkan berbagai layanan server dan jaringan. Pastikan untuk memahami dan mematuhi semua peraturan Tiongkok saat menggunakan layanan mereka. * **Tencent Cloud:** Penyedia cloud besar lainnya di Tiongkok. Mirip dengan Aliyun, mereka menawarkan berbagai layanan server dan jaringan. * **Huawei Cloud:** Penyedia cloud yang berkembang pesat di Tiongkok. * **AWS (Amazon Web Services) China:** AWS memiliki kehadiran di Tiongkok, tetapi beroperasi melalui mitra lokal. * **Azure (Microsoft Azure) China:** Azure juga memiliki kehadiran di Tiongkok melalui mitra lokal. **Catatan:** Menggunakan server cloud di Tiongkok mungkin memerlukan lisensi dan persetujuan tambahan dari pemerintah Tiongkok. Pastikan Anda memahami dan mematuhi semua persyaratan ini. * **Server Colocation di Tiongkok:** * Menempatkan server Anda sendiri di pusat data di Tiongkok. Ini memberi Anda lebih banyak kontrol atas perangkat keras dan perangkat lunak, tetapi juga membutuhkan lebih banyak tanggung jawab untuk pemeliharaan dan keamanan. * **Server VPS (Virtual Private Server) di Tiongkok:** * Opsi yang lebih murah daripada server khusus, tetapi mungkin kurang kuat. **Rekomendasi:** 1. **Konsultasikan dengan Ahli Hukum dan Regulasi:** Ini adalah langkah *terpenting*. Dapatkan nasihat dari pengacara dan konsultan yang berpengalaman dalam peraturan keuangan dan teknologi di Tiongkok. Mereka dapat membantu Anda memahami persyaratan hukum dan memastikan bahwa Anda mematuhi semua peraturan yang relevan. 2. **Riset Penyedia Server:** Lakukan riset menyeluruh terhadap berbagai penyedia server dan bandingkan fitur, harga, dan dukungan mereka. 3. **Uji Coba:** Jika memungkinkan, uji coba server dengan data pasar dan strategi perdagangan Anda untuk memastikan bahwa server tersebut memenuhi kebutuhan Anda. 4. **Pertimbangkan Alternatif:** Jika Anda kesulitan menemukan server yang sesuai di Tiongkok, pertimbangkan untuk menggunakan server di luar Tiongkok dan menggunakan koneksi jaringan yang cepat dan andal ke bursa saham Tiongkok. Namun, ini dapat menimbulkan masalah kepatuhan regulasi yang lebih kompleks. **Penting:** Saya bukan ahli hukum atau keuangan. Informasi di atas hanya untuk tujuan informasi dan bukan merupakan nasihat hukum atau keuangan. Anda harus selalu berkonsultasi dengan profesional yang berkualifikasi sebelum membuat keputusan apa pun. Semoga informasi ini membantu!

Google OCR

Ini adalah implementasi server untuk melakukan Optical Character Recognition (OCR) menggunakan Google Cloud Vision API. Ini dibangun di atas kerangka kerja FastMCP, yang memungkinkan pembuatan alat pemrosesan perintah yang modular dan dapat diperluas.

Google Image Search MCP Server

Sebuah server MCP untuk integrasi Google Image Search.

IPLocate

Look up IP address geolocation, network information, detect proxies and VPNs, and find abuse contact details using IPLocate.io

CircleCI MCP Server

Cermin dari

Learning Ai

Belajar AI

KiMCP (Korea-integrated Model Context Protocol)

Server MCP yang memungkinkan LLM (Model Bahasa Besar) untuk menggunakan API Korea (Naver, Kakao, dll.)

Rickbot-3000 MCP Service

Enables remote management and monitoring of the Rickbot-3000 robotic system through AI assistants. Provides real-time status monitoring, command execution, system diagnostics, and deployment management capabilities.

MCP- N8N

N8N MCP

Fetch Server

Menyediakan fungsionalitas untuk mengambil konten web dalam berbagai format, termasuk HTML, JSON, teks biasa, dan Markdown dengan dukungan untuk header khusus.

Appsignal MCP

A Model Context Protocol server that allows AI assistants to fetch and analyze incident data from Appsignal, including retrieving incident details, samples, listing recent incidents, and analyzing incidents to suggest fixes.

Atrax

Proksi yang mengagregasi beberapa server MCP dan menampilkannya sebagai antarmuka terpadu, memungkinkan klien mengakses sumber daya dari beberapa server secara transparan.

Template MCP Server

A production-ready foundation template for building Model Context Protocol (MCP) servers with FastAPI, featuring modular tools, comprehensive testing, and OpenShift deployment configurations. Includes automated transformation scripts to create custom domain-specific MCP servers.

MCP Agent Server

An open-source "brain" for AI employees that enables users to create, manage, and improve persistent AI agents with their own memory and learning capabilities.

Amazon S3 MCP Server by CData

Amazon S3 MCP Server by CData

AI Collaboration MCP Server

Enables collaboration with multiple AI providers (Claude, GPT-4, Gemini, Ollama) directly from VS Code with automatic project context injection and persistent conversation history. Provides streamlined tools for getting AI advice, multi-provider research, and enhanced context sharing across sessions.

GCP MCP Server

Enables AI assistants to interact with Google Cloud Platform services for log analysis and root cause investigation. Provides tools to query Cloud Logging, detect error patterns, and perform real-time log streaming across multiple GCP projects.

mcp_repo_96c7c875

Ini adalah repositori pengujian yang dibuat oleh skrip pengujian MCP Server untuk GitHub.

FFmpeg MCP Tool

Enables image and video processing through FFmpeg, including compression, format conversion, resizing, and batch processing operations for common media formats.

MCP Server Memo

Server MCP ringan untuk manajemen memori sesi.

Notion MCP Server

An auto-generated Multi-Agent Conversation Protocol server that enables interaction with Notion's API, allowing agents to work with Notion's database, pages, and other features through standardized protocols.

Short Video Maker MCP

Short Video Maker MCP

GmailMcpServer MCP server

An MCP Server for GMail

zio-ella

There isn't a widely recognized or established "MCP framework" specifically designed for ZIO HTTP. It's possible this refers to a custom framework or a combination of libraries and patterns. However, I can explain how you might build a framework-like structure around ZIO HTTP, focusing on common concerns and best practices. This will involve concepts that *could* be considered an "MCP" (Model-Controller-Presenter/View) approach, even if not explicitly named that way. Here's a breakdown of how you might structure a ZIO HTTP application with a focus on separation of concerns: **1. Core Concepts & Libraries:** * **ZIO HTTP:** The foundation. Handles HTTP request routing, handling, and response generation. * **ZIO:** The core effect system. Provides concurrency, error handling, resource management, and dependency injection. * **ZIO Schema:** For data modeling, validation, and serialization/deserialization (e.g., JSON). This is crucial for handling request bodies and response payloads. * **ZIO Logging:** For structured logging. * **ZIO Config:** For managing application configuration. * **Database Libraries (e.g., ZIO Quill, Doobie):** If your application interacts with a database. * **Authentication/Authorization Libraries (e.g., ZIO JWT):** If your application requires authentication and authorization. **2. Conceptual "MCP" Structure (Adaptation for ZIO):** While a strict MVC/MCP might not be the best fit for ZIO's functional nature, we can adapt the principles: * **Model (Data Layer):** * **Purpose:** Represents the data structures and business logic related to your application's domain. * **Implementation:** * **ZIO Schema Definitions:** Define your data models using `ZIOSchema`. This provides type safety, validation, and serialization/deserialization capabilities. * **Data Access Objects (DAOs):** Implement DAOs using ZIO and your chosen database library (e.g., ZIO Quill). These DAOs encapsulate database interactions (queries, updates, etc.). They return `ZIO` effects representing the database operations. * **Business Logic:** Implement core business logic as pure functions that operate on your data models and return `ZIO` effects. This keeps the logic testable and composable. * **Example:** ```scala import zio._ import zio.schema._ import zio.schema.codec.JsonCodec case class User(id: Int, name: String, email: String) object User { implicit val schema: Schema[User] = DeriveSchema.gen[User] val jsonCodec = JsonCodec.jsonCodec(schema) } trait UserRepo { def getUser(id: Int): ZIO[Any, Throwable, Option[User]] def createUser(user: User): ZIO[Any, Throwable, Unit] } object UserRepo { def getUser(id: Int): ZIO[UserRepo, Throwable, Option[User]] = ZIO.serviceWithZIO[UserRepo](_.getUser(id)) def createUser(user: User): ZIO[UserRepo, Throwable, Unit] = ZIO.serviceWithZIO[UserRepo](_.createUser(user)) } // Example implementation (using a simple in-memory map for demonstration) case class UserRepoLive(ref: Ref[Map[Int, User]]) extends UserRepo { override def getUser(id: Int): ZIO[Any, Throwable, Option[User]] = ref.get.map(_.get(id)) override def createUser(user: User): ZIO[Any, Throwable, Unit] = ref.update(map => map + (user.id -> user)) } object UserRepoLive { val layer: ZLayer[Any, Nothing, UserRepo] = ZLayer.fromZIO(Ref.make(Map.empty[Int, User]).map(UserRepoLive(_))) } ``` * **Controller (Logic & Orchestration):** * **Purpose:** Receives HTTP requests, orchestrates the business logic (using the Model), and prepares the response. * **Implementation:** * **ZIO HTTP Handlers:** Define ZIO HTTP handlers that match specific routes. * **Dependency Injection:** Use ZIO's dependency injection to access the necessary services (e.g., `UserRepo`, configuration, logging). * **Request Processing:** Extract data from the request (e.g., using `ZIOHttp.request.body.asString` and then deserializing with `ZIOSchema`). * **Business Logic Invocation:** Call the appropriate business logic functions from the Model. * **Response Generation:** Construct the HTTP response (e.g., using `Response.json(serializedData)`). Handle errors gracefully. * **Example:** ```scala import zio._ import zio.http._ import zio.schema.codec.JsonCodec object UserController { val routes: Http[UserRepo, Throwable, Request, Response] = Http.collectZIO[Request] { case req @ Method.POST -> !! / "users" => for { body <- req.body.asString user <- ZIO.fromEither(User.jsonCodec.decode(body.getBytes(java.nio.charset.StandardCharsets.UTF_8))) .mapError(e => new IllegalArgumentException(s"Invalid JSON: ${new String(e)}")) _ <- UserRepo.createUser(user) resp <- ZIO.succeed(Response.status(Status.Created)) } yield resp case Method.GET -> !! / "users" / id => for { userId <- ZIO.attempt(id.toInt).refineToOrDie[Throwable] user <- UserRepo.getUser(userId) resp <- user match { case Some(u) => ZIO.succeed(Response.json(new String(User.jsonCodec.encode(u)))) case None => ZIO.succeed(Response.status(Status.NotFound)) } } yield resp } } ``` * **Presenter/View (Response Formatting):** * **Purpose:** Formats the data returned by the Controller into a suitable response format (e.g., JSON, HTML). In ZIO HTTP, this is often integrated directly into the Controller. * **Implementation:** * **ZIO Schema Serialization:** Use `ZIOSchema` to serialize data into JSON or other formats. * **Response Construction:** Use `Response.json`, `Response.html`, or other `Response` constructors to create the HTTP response. * **Error Handling:** Map errors to appropriate HTTP status codes and error messages. * **Example:** (See the `UserController` example above - the `Response.json` part is the "Presenter" aspect). You could extract this into separate functions for more complex formatting. **3. Example Application Structure:** ``` my-zio-http-app/ ├── src/main/scala/ │ ├── Main.scala (Application entry point) │ ├── model/ (Data models and business logic) │ │ ├── User.scala │ │ ├── UserRepo.scala │ │ └── ... │ ├── controller/ (HTTP handlers and orchestration) │ │ ├── UserController.scala │ │ └── ... │ ├── config/ (Configuration) │ │ └── AppConfig.scala │ └── logging/ (Logging setup) │ └── Logging.scala └── build.sbt (sbt build file) ``` **4. Key Considerations:** * **Error Handling:** Use ZIO's error handling mechanisms (`ZIO.fail`, `ZIO.catchAll`, `ZIO.orElse`) to handle errors gracefully and provide meaningful error responses to the client. * **Dependency Injection:** Leverage ZIO's dependency injection to manage dependencies between components. Use `ZLayer` to define and compose layers of dependencies. * **Testing:** Write unit tests for your business logic and integration tests for your HTTP handlers. Use ZIO Test for testing ZIO effects. * **Configuration:** Use ZIO Config to manage application configuration. This allows you to externalize configuration values and easily change them without modifying your code. * **Logging:** Use ZIO Logging to log important events and errors. This helps you monitor and debug your application. * **Asynchronous Operations:** ZIO is inherently asynchronous. Use ZIO's concurrency primitives (e.g., `ZIO.fork`, `ZIO.race`, `ZIO.merge`) to handle concurrent operations efficiently. **Example `Main.scala` (Application Entry Point):** ```scala import zio._ import zio.http._ import zio.http.Server import controller.UserController import model.UserRepoLive import zio.logging.backend.SLF4J object Main extends ZIOAppDefault { override val bootstrap: ZLayer[ZIOAppArgs, Any, Any] = SLF4J.slf4j val app: HttpApp[UserRepo, Throwable] = UserController.routes override val run: ZIO[ZIOAppArgs with Scope, Any, Any] = (Server.serve(app) *> ZIO.never) .provide( Server.default, UserRepoLive.layer ) } ``` **In summary:** While there's no pre-built "MCP framework" for ZIO HTTP, you can achieve a similar separation of concerns by structuring your application with: * **Model:** Data models, DAOs, and business logic (using ZIO Schema and database libraries). * **Controller:** ZIO HTTP handlers that orchestrate the business logic and prepare responses. * **Presenter/View:** Response formatting (often integrated into the Controller using ZIO Schema serialization). This approach leverages ZIO's strengths in concurrency, error handling, dependency injection, and testability to create a robust and maintainable ZIO HTTP application. Remember to adapt this structure to the specific needs of your application.