Discover Awesome MCP Servers

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.

Parquet MCP Server by CData

Parquet MCP Server by CData

makechartswithai

MCP server that enables AI agents to recommend and generate charts from datasets using natural language, supporting 46 chart types and multiple output formats.

Cybersecurity-MCP-Server

CyberSecurity MCP Server extends Claude with real-time cybersecurity reconnaissance capabilities that Claude doesn't have by default. Instead of manually running 5 different tools across different terminals, just tell Claude "analyze google.com" and get a complete security breakdown instantly. Tools included: * WHOIS Lookup — registrar, ownership, creation/expiry dates * DNS Enumeration — A,

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.

kinqimen-mcp

A deterministic MCP facts engine for Qimen Dunjia (奇門遁甲), providing 時家, 刻家, and 金函玉鏡 chart computation tools for AI agents.

Basic MCP Server

A minimal demonstration server showcasing MCP protocol capabilities including tools, resources, and prompts with basic examples like hello world functionality.

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.

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.

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.

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.

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.

p6ai

Provides MCP tools to validate structured construction plan JSON and create projects in Primavera P6 Professional standalone SQLite databases, with automatic backup and rollback.

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.

@brightbeamai/chap-coordinator-mcp

Auditable records of human decisions over AI agent work. Approvals, edits, overrides, escalations.

ClawDaemon MCP

Connects Claude Code to a persistent OpenClaw daemon for 24/7 automation of cron jobs, webhooks, and messaging across over 23 platforms. It enables background browser automation and event tracking that persists even when the Claude session is closed.

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.

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