Discover Awesome MCP Servers

OrchestrateKit MCP

Enables Cursor and Claude Desktop to design production-ready AI workflows by exposing a structured registry of components, edges, stacks, routes, and playbooks, with capabilities for goal matching, route composition, and confidence scoring.

Time MCP

Provides time-related tools for LLM applications, enabling retrieval of current UTC time in ISO 8601 format and Unix timestamps.

mcp-email-client

MCP server for email management that enables reading, searching, drafting, replying to, and sending emails with thread-aware replies and draft-first safety, supporting Gmail API and IMAP/SMTP backends.

QuickBooks Online MCP Server

Provides 55 tools for managing QuickBooks entities like customers, invoices, and bills via any MCP-compatible client, built on Cloudflare Workers with OAuth 2.0 authentication.

Examplary MCP Server

Provides AI assistants with access to Examplary's exam management platform, enabling users to create and manage exams, generate questions from materials, grade student responses, and collaborate in workspaces through 60+ API endpoints.

AI Group Markdown to Word MCP Server

Converts Markdown documents to professional Word documents with advanced formatting capabilities including mathematical formulas, custom styling, tables, images, headers/footers, and watermarks.

Salesforce MCP

Enables AI agents to query, mutate, and analyze Salesforce CRM data natively through the Model Context Protocol, without requiring API glue code.

mcp-data-govt-nz

Enables searching and exploring New Zealand government data via CKAN API, including full-text search, organizations, groups, tags, and recent changes.

Daily Notes MCP

A basic MCP server for daily notes, currently exposing a hello world prompt and tool, deployable to Vercel and installable as a plugin for Claude Code and Codex.

DJ Claude

A music MCP server enabling multi-agent collaboration where AI agents jam together in real-time, with 20 tools, conductor mode, and zero dependencies.

Cyclops

Cyclops

MySQL MCP Server Pro

Enables comprehensive MySQL database operations including CRUD, performance optimization, health monitoring, index analysis, lock detection, and SQL execution plan analysis with role-based permission control.

Obsidian Learning Extension

Extends the official Obsidian MCP server with intelligent learning and second-brain features, including AI-generated challenges, progress analytics, spaced repetition, and knowledge gap analysis.

fitllm

Will this AI model fit on your Mac?

kurigram-mcp

MCP server to debug Telegram bots by controlling your Telegram user session over MTProto. It enables sending messages, reading chats, handling updates, and invoking raw Telegram API methods.

MCP Weather Server

Provides real-time weather information, enabling AI assistants to retrieve current temperature and weather conditions for any location worldwide.

mcp-ror

Enables searching and retrieving organization records from the Research Organization Registry, with fuzzy affiliation matching.

vision-mcp

Enables AI agents to analyze images using any OpenAI-compatible vision API, providing tools for image analysis, OCR, error diagnosis, diagram understanding, and chart analysis.

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.

obsidian-mcp

Wraps the Obsidian CLI to allow LLM agents to read/write notes, search, manage frontmatter, navigate links, and run plugins on a running Obsidian instance.

Canvas MCP Server

Connects Claude Desktop to Canvas LMS to monitor academic activities like assignments, announcements, and upcoming deadlines. It enables users to track courses and pending tasks through a unified interface using the Canvas REST API.

Atrax

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

x402-dex-intel

Real-time DEX token momentum, orderbook liquidity depth, and whale flows on Base Mainnet gated with gasless x402 micropayments.

SilentFail

Diagnose MCP servers — health checks, tool testing, token cost audits, conflict detection, and security scanning with 50+ prompt injection patterns. Works as CLI or MCP server inside Claude Desktop.

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.

Shodh-Memory

Provides persistent cognitive memory for AI agents and robots with no LLM in the loop, using algorithms for storage, recall, and forgetting; supports MCP, HTTP, and ROS2.

HKLaw MCP

A stateless MCP server for Hong Kong legal research, offering tools to analyze legal intent, search official HKeL statutes, fetch current law metadata, and check source status.

UK Parliament MCP Server

An MCP server that gives AI assistants access to UK Parliament data. Query MPs, Lords, bills, votes, committees, debates, and more through AI assistants like Claude Desktop and VS Code Copilot.

swagger-mcp-tools

A Swagger/OpenAPI query tool for MCP clients like Cursor, enabling AI assistants to browse, search, and retrieve detailed API type information.

code-context

Enables AI coding assistants to automatically scan, store, and query API endpoints from codebases, providing instant lookup and semantic search to reduce context switching and token consumption.