Discover Awesome MCP Servers

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.

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.

TextToolkit

A text transformation and formatting MCP server that provides common text manipulation functions such as case conversion, encoding/decoding, formatting, analysis, and regex operations directly within your AI assistant workflow.

Gemini MCP Server for Claude Code

Integrates Google's Gemini AI models into Claude Code and other MCP clients to provide second opinions, code comparisons, and token counting. It supports streaming responses and multi-turn conversations directly within your existing AI development workflow.

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.

swagger-json-mcp

A powerful MCP server for querying and processing large Swagger/OpenAPI JSON documents, enabling LLMs to efficiently access API documentation without loading entire files.

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.

ghostkit MCP Server

MCP server that provides AI clients with 26 security and developer tools, enabling tasks like JWT decoding, HTTP header analysis, and phishing URL inspection.

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.

SentinelOps

SentinelOps is an MCP server that enables AI-powered security operations with human-in-the-loop safety. It allows agents to investigate threats, propose actions, and execute security responses only after explicit human approval.

glowfic-rag

Provides semantic search capabilities over glowfic.com content using a pre-built vector database and GTE-Large embeddings. It allows users to query specific continuities and authors through MCP-compatible tools in applications like Claude Code and Cursor.

crypto-mcp

A read-only MCP server for managing multichain crypto wallet accounts and deriving public addresses across Bitcoin, Ethereum, Solana, TRON, and more. It provides secure local storage with encrypted mnemonics and only exposes account listing and address lookup tools.

Docker Swarm MCP Server

A production-ready MCP server for Docker Swarm that provides full control over services, stacks, configs, and secrets with smart context preservation to reduce tool clutter.

loopeng

Watches your terminal sessions, identifies repetitive workflows, and converts them into callable MCP tools so AI agents can automate them.

Context MCP Server

A Model Context Protocol server that provides web content fetching capabilities with robots.txt checking removed, allowing LLMs to retrieve and convert web content to markdown.

Unity MCP Search

Enables AI assistants to search and analyze Unity project assets, including references and dependencies, via the Model Context Protocol.

FLASK-tools

Provides a collection of MCP servers for computational chemistry tasks including molecular generation and retrosynthesis. Also offers property prediction and molecule pricing capabilities.

mcp-inspire-hep

Enables searching and retrieving high-energy physics literature, authors, institutions, and conferences from INSPIRE-HEP.

Learning Ai

Belajar AI

FedRAMP Docs MCP Server

Enables querying and analysis of FedRAMP documentation, compliance requirements, and security controls through structured tools that search markdown guidance, analyze FRMR datasets, and track regulatory changes.

mcp-outlook-calendar

Enables interaction with Microsoft Outlook Calendar and To Do lists via the Microsoft Graph API, allowing users to manage events and tasks through natural language.

carbonstop-mcp

MCP server enabling AI assistants to automatically perform carbon footprint modeling, product queries, and emission analysis via the Carbonstop Cloud API.

KudaGo + Nominatim MCP Server

MCP server combining KudaGo and Nominatim APIs with configurable stdio or streamable HTTP transport.