Discover Awesome MCP Servers

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.

Subscriptions API MCP Server

An MCP server for the VTEX Subscriptions API (v3) that enables managing subscription services through natural language interactions, auto-generated using AG2's MCP builder.

Medical GraphRAG Assistant

Enables AI-powered medical information retrieval through FHIR clinical document search and GraphRAG-based exploration of medical entities and relationships. Combines vector search with knowledge graph queries for comprehensive healthcare data analysis.

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

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol servers using TypeScript SDK, with example calculator and greeting tools, and server information resources.

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.

docxtpl MCP Server

Enables Word document generation from templates using Jinja2 syntax and parsing of DOCX, PDF, and Excel files to extract structured content, metadata, and text.

Spec Workflow MCP

Provides structured spec-driven development workflow tools for AI-assisted software development with sequential spec creation (Requirements → Design → Tasks). Features a real-time web dashboard for monitoring project progress and managing development workflows.

MCP Server Boilerplate (TypeScript)

Boilerplate TypeScript untuk server MCP menggunakan SDK resmi, dengan dukungan untuk stdio/http, logging, Docker, dan pengujian.

Parquet MCP Server by CData

Parquet MCP Server by CData

Hermes Search MCP Server

Enables AI systems to perform full-text and semantic search operations over structured/unstructured data in Azure Cognitive Search, with capabilities for document indexing and management through natural language.

Said MCP

A MCP server that provides real-time weather information for any city through a simple tool that resolves geographic coordinates and fetches current weather data.

AutoDev Codebase MCP Server

HTTP-based server that provides semantic code search capabilities to IDEs through the Model Context Protocol, allowing efficient codebase exploration without repeated indexing.

Velero MCP Server

Provides read-only access to Velero backup and schedule resources in Kubernetes clusters, enabling AI agents to inspect backups, schedules, and generate Velero YAML manifests safely without write permissions.

Remote MCP Server on Cloudflare

A Model Context Protocol server implementation that runs on Cloudflare Workers, providing tool integration for AI assistants like Claude with OAuth login capability.

MCP - Model Context Protocol

Server MCP menggunakan TypeScript dan JavaScript yang dibuat dengan dokumentasi MCP resmi, menangani data Cuaca AS dengan konteks untuk dua alat - menampilkan perkiraan cuaca dan peringatan cuaca untuk lokasi berbasis di AS. Menggunakan Zod untuk validasi data dan diarsitekturkan menjadi dua folder - src dan build, pengembangan (ts) dan produksi (js) masing-masing.

Jira MCP Server

Enables AI assistants to interact with Jira Cloud instances for comprehensive issue management including creating, updating, searching issues, managing comments, workflow transitions, and project metadata discovery. Supports JQL queries, user search, and custom field operations with secure API token authentication.

Awesome-MCP-Scaffold

A production-ready development scaffold for MCP servers, optimized for Cursor IDE with built-in tools, resources, and prompts that enables quick development of Model Context Protocol servers with 5-minute startup and 10-minute development capabilities.

Figma MCP Server Overview

UI otomatis dibuat dari Figma oleh Cursor AI di Server MCP.

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 Interactsh Bridge

Enables out-of-band interaction testing by integrating ProjectDiscovery's interactsh service as an MCP server. Allows AI agents to create callback domains, send probes, and capture DNS/HTTP interactions for security testing and verification workflows.