Discover Awesome MCP Servers

Sleeper API MCP

This Model Context Protocol server provides access to the Sleeper Fantasy Football API, enabling agents to fetch data about users, leagues, drafts, rosters, matchups, and player information without requiring an API key.

vulcan-file-ops

MCP server that gives Claude Desktop and other desktop MCP clients filesystem powers—read, write, edit, and manage files like AI coding assistants.

Playwright MCP Server

Enables web browser automation and inspection using structured data instead of screenshots, allowing AI agents to interact with web pages programmatically through the Playwright framework.

MCP Containers

数百ものMCPサーバーのコンテナ化バージョン 📡 🧠

sqlite-kg-vec-mcp

SQLiteをベースにした、ナレッジグラフとベクトルデータベースを統合したMCPサーバー

MinIO MCP Server

Enables interaction with MinIO object storage through a standardized Model-Context Protocol interface. Supports listing buckets and objects, retrieving files, and uploading data to MinIO storage.

Act-On MCP Server by CData

This read-only MCP Server allows you to connect to Act-On data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

GitHub Repository Manager MCP Server

Enables AI assistants to create and delete GitHub repositories with customizable settings through the Model Context Protocol, supporting both public and private repositories with secure token-based authentication.

ns-bridge

An MCP server that enables AI assistants to interact with the Netherlands Railways (NS) API for route planning, pricing, and real-time departure information. It provides tools for searching stations, planning trips with connections, and viewing real-time departure boards.

Dynamics 365 MCP Server 🚀

Microsoft Dynamics 365 用 MCP サーバー

MCP-Server de Mapas Mentais

A Python application that automatically generates different types of mind maps (presentation, comparison, beginner/intermediate content, problem analysis, and review) to help organize ideas visually through Claude Desktop integration.

Website to Markdown MCP Server

Fetches website content and converts it to Markdown format with AI-powered content cleanup, ad removal, and full OpenAPI/Swagger specification support for easy processing by AI assistants.

Tripo3D MCP

A tool integration that wraps Tripo3D API capabilities for 3D model generation, texturing, animation, and format conversion, supporting text/image-to-3D workflows via natural language commands.

Controtto

Okay, I understand. I can translate English text to Japanese. I can also analyze Go code and provide feedback based on Domain-Driven Design (DDD) and Clean Architecture principles. I will strive to be strict in my evaluation, looking for potential violations and suggesting improvements. To get the best results, please provide me with: * **The English text you want translated to Japanese.** * **The Go code you want me to analyze.** The more context you provide (e.g., a description of the code's purpose, the domain it operates in), the better I can assess it. * **Any specific areas you're concerned about.** For example, "I'm worried about the coupling between the domain and infrastructure layers" or "I'm not sure if this aggregate is correctly defined." **Here's what I'll look for when analyzing Go code under DDD and Clean Architecture:** **Domain-Driven Design (DDD):** * **Ubiquitous Language:** Is the code using terminology that aligns with the domain experts' language? * **Domain Model:** Is there a clear and well-defined domain model that captures the essential concepts and rules of the business? * **Entities:** Are entities correctly identified and modeled with appropriate identity and behavior? * **Value Objects:** Are value objects used to represent immutable concepts and ensure consistency? * **Aggregates:** Are aggregates properly defined with a clear root entity and well-defined boundaries? Are invariants maintained within aggregates? * **Repositories:** Are repositories used to abstract data access and persistence concerns from the domain? * **Domain Events:** Are domain events used to decouple different parts of the system and react to significant changes in the domain? * **Services:** Are domain services used to encapsulate complex business logic that doesn't naturally belong to an entity or value object? **Clean Architecture:** * **Dependency Inversion Principle (DIP):** Are high-level modules (e.g., domain) independent of low-level modules (e.g., infrastructure)? Are abstractions (interfaces) used to decouple layers? * **Separation of Concerns:** Is the code organized into distinct layers with clear responsibilities? * **Testability:** Is the code easily testable, with minimal dependencies on external systems? * **Framework Independence:** Is the core business logic independent of specific frameworks and technologies? * **UI Independence:** Is the core business logic independent of the user interface? * **Database Independence:** Is the core business logic independent of the database? * **Use Cases (Interactors):** Are use cases clearly defined and implemented as interactors that orchestrate the domain logic? * **Entities (Domain Layer):** The innermost layer containing the core business entities and rules. * **Application Layer:** Contains use cases and application services that orchestrate the domain logic. * **Interface Adapters Layer:** Adapts data between the application layer and external systems (e.g., UI, database). * **Infrastructure Layer:** Provides concrete implementations of interfaces defined in the inner layers (e.g., database access, external API calls). **My Analysis will include:** * **Identification of potential violations of DDD and Clean Architecture principles.** * **Suggestions for improvements, including code examples where appropriate.** * **Explanation of the reasoning behind my recommendations.** **Example:** You might provide me with this Go code: ```go package main import ( "database/sql" "fmt" _ "github.com/lib/pq" ) type User struct { ID int Name string Email string } func GetUser(db *sql.DB, id int) (User, error) { query := "SELECT id, name, email FROM users WHERE id = $1" row := db.QueryRow(query, id) var user User err := row.Scan(&user.ID, &user.Name, &user.Email) if err != nil { return User{}, err } return user, nil } func main() { db, err := sql.Open("postgres", "user=postgres password=password dbname=mydb sslmode=disable") if err != nil { panic(err) } defer db.Close() user, err := GetUser(db, 1) if err != nil { panic(err) } fmt.Println(user) } ``` And I might respond with: "This code has several issues from a DDD and Clean Architecture perspective: 1. **Tight Coupling to Infrastructure:** The `GetUser` function directly depends on the `sql.DB` object. This tightly couples the code to the database implementation, making it difficult to test and change. 2. **Lack of Abstraction:** There's no abstraction layer (e.g., a repository) between the domain and the database. 3. **Domain Model Anemia:** The `User` struct is a simple data structure with no behavior. It's likely just a data transfer object (DTO) and not a rich domain entity. 4. **No Use Case:** The `main` function directly calls `GetUser`. There's no clear use case defined. Here's a possible refactoring to address these issues: ```go package main import ( "context" "database/sql" "fmt" _ "github.com/lib/pq" ) // Domain Layer type User struct { ID int Name string Email string } // Repository Interface type UserRepository interface { Get(ctx context.Context, id int) (User, error) } // Infrastructure Layer type PostgresUserRepository struct { db *sql.DB } func NewPostgresUserRepository(db *sql.DB) UserRepository { return &PostgresUserRepository{db: db} } func (r *PostgresUserRepository) Get(ctx context.Context, id int) (User, error) { query := "SELECT id, name, email FROM users WHERE id = $1" row := r.db.QueryRowContext(ctx, query, id) var user User err := row.Scan(&user.ID, &user.Name, &user.Email) if err != nil { return User{}, err } return user, nil } // Application Layer (Use Case) type GetUserUseCase struct { repo UserRepository } func NewGetUserUseCase(repo UserRepository) *GetUserUseCase { return &GetUserUseCase{repo: repo} } func (uc *GetUserUseCase) Execute(ctx context.Context, id int) (User, error) { return uc.repo.Get(ctx, id) } func main() { db, err := sql.Open("postgres", "user=postgres password=password dbname=mydb sslmode=disable") if err != nil { panic(err) } defer db.Close() repo := NewPostgresUserRepository(db) useCase := NewGetUserUseCase(repo) user, err := useCase.Execute(context.Background(), 1) if err != nil { panic(err) } fmt.Println(user) } ``` This refactored code introduces a `UserRepository` interface to abstract data access, a `PostgresUserRepository` implementation in the infrastructure layer, and a `GetUserUseCase` to represent a specific use case. This makes the code more testable, maintainable, and aligned with DDD and Clean Architecture principles. Further improvements could include adding domain logic to the `User` entity and using domain events." Now, please provide me with the text or code you want me to work with!

Aseprite MCP Tools

A Python MCP server enabling programmatic interaction with Aseprite for pixel art creation and manipulation with features like drawing operations, palette management, and batch processing.

JEFit MCP Server

Enables analysis and retrieval of JEFit workout data through natural language. Provides access to workout dates, detailed exercise information, and batch workout analysis for fitness tracking and progress monitoring.

Asana MCP Server

An MCP (Multi-Agent Conversation Protocol) server that enables interacting with the Asana API through natural language commands for task management, project organization, and team collaboration.

DIE MCP Server

An MCP server that enables AI agents to analyze executable files using Detect It Easy (DIE), providing capabilities to examine file structures, detect packers, compilers, and gather other forensic information.

Steam MCP Server

Provides tools for interacting with the Steam Web API to access player profiles, game libraries, achievements, statistics, inventories, and game information through natural language.

MCP API Server

A Model Context Protocol server that enables AI assistants to make HTTP requests (GET, POST, PUT, DELETE) to external APIs through standardized MCP tools.

MCP Server with External Tools

Enables AI models to access external services including weather data, file system operations, and SQLite database interactions through a standardized JSON-RPC interface. Features production-ready architecture with security, rate limiting, and comprehensive error handling.

Alibaba Cloud DMS MCP Server

A Model Context Protocol server that enables large language models to access database metadata and perform cross-engine data querying across diverse database ecosystems.

Cyber Sentinel MCP Server

A threat intelligence aggregation server that provides unified access to multiple security sources for analyzing indicators (IPs, domains, hashes, URLs) with confidence scoring.

Weather Alerts MCP Server

Enables users to fetch real-time weather alerts from the National Weather Service API for any US state. Provides formatted weather warnings, watches, and advisories with severity levels and safety instructions.

Confluence MCP Server

鏡 (Kagami)

PM Counter Monitoring MCP Server

Enables monitoring and querying of telecom performance management (PM) counters from remote SFTP locations, providing access to interface statistics, CPU/memory utilization, BGP peer data, and system metrics through a conversational interface.