Discover Awesome MCP Servers

ClickHouse MCP Agent

Enables querying ClickHouse databases using natural language with AI models, supporting multiple providers and access restrictions via per-call allow-lists.

GitHub Triage Agent MCP Server

Enables autonomous triage of GitHub issues and pull requests through MCP, with classification, deduplication, prioritization, and safe human-in-the-loop actions.

tokencost-mcp-server

An MCP (Model Context Protocol) server that provides real-time LLM token pricing data for 60+ AI models across 15 providers.

WP Database MCP Server

Read-only MCP server for exploring WordPress MySQL/MariaDB databases. Provides schema inspection, relationship mapping, and safe SQL querying.

mailmate-mcp

Enables searching, reading, moving, tagging, and linking emails in MailMate via MCP tools, allowing Claude to manage email without leaving the conversation.

Index Network MCP Server

Enables ChatGPT integration with Index Network's discovery protocol through MCP tools. Provides quick setup with ngrok tunneling for public access and includes health check, echo, and search functionality.

lanhu-context-mcp

Converts Lanhu design URLs into AI-ready implementation context including HTML+CSS (Tailwind), image downloads, design tokens, and guidance.

finance-agent

Personal finance MCP server that integrates Plaid bank data with local SQLite memory for conversational budgeting, goal tracking, and transaction management.

Israel Grocery MCP

Enables cross-store price comparison and recipe-driven cart automation for Israeli grocery stores Shufersal and Tiv Taam, with an extensible architecture for additional stores.

MCP Workspace Server

Provides secure, sandboxed file system access for AI assistants to read, write, and manage project files with controlled command execution capabilities, all confined to a designated workspace directory.

Research Oyster

MCP server for local, source-agnostic research, turning briefs into platform-specific searches and cited evidence dossiers with PostgreSQL storage and optional browser capture.

discord-mcp

Enables AI clients to manage Discord servers, including channels, messages, roles, members, permissions, threads, invites, events, webhooks, and emoji, through natural language commands.

mcp-takeout-googlefit

Enables AI assistants to read and analyze Google Fit exported data (activities, daily metrics, workouts, sleep) from Google Takeout, providing tools for queries, resources, and coaching prompts.

appium-mcp-server

Enables AI assistants to perform mobile device automation testing via Appium through the Model Context Protocol, supporting Android and iOS devices with 40+ tools.

crom-mcp

MCP server for querying the Crom API v2, providing access to SCP Foundation Wikidot site data including page search, author stats, and forum content.

salesforce-verified-mcp

A read-only MCP server for Salesforce that returns verified answers or says it cannot, with an evaluation suite that measures its correctness.

dida-mcp-server

Enables AI assistants to manage TickTick/Dida365 tasks, projects, and tags through the MCP protocol, with features for GTD-based task organization and OAuth authentication.

shipcheck-mcp

Enables AI agents to run Shipcheck on local JavaScript/TypeScript repositories, scanning for launch risks like exposed env vars, unsigned webhooks, and missing security guardrails.

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.

micropub-mcp

Enables AI agents to create, update, delete, and query posts on any Micropub-compatible blog with IndieAuth authentication.

Google News MCP Agent

Fetches news articles from Google News, vectorizes them locally using ChromaDB, and enables semantic search through natural language queries.

GeoRanker MCP Server

An agent-friendly MCP server for the GeoRanker High-Volume API, enabling SEO rank tracking and keyword management through natural language.

ATLAS MCP

Safe, reliable, and verifiable execution for the Model Context Protocol, enabling governed tasks with planning, capability approval, side-effect verification, and evidence receipts.

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.

우리어디가? MCP

Converts package tour schedules and travel information into card-style guides for easy sharing on KakaoTalk. Helps travelers reorganize scattered details from PDFs, chat messages, and websites into structured daily guides, packing lists, cost summaries, and emergency cards.

instantKOM MCP Server

Enables AI assistants to manage instantKOM messenger platform resources (channels, contacts, messages, newsletters, bots, flows, analytics) via structured type-safe tool calls.

veris

Provenance-first web access for AI agents, delivering clean content with verifiable source metadata and SEC EDGAR financial data.

MCP GitLab Server

Enables comprehensive GitLab integration allowing LLMs to manage projects, issues, merge requests, repository files, CI/CD pipelines, and perform batch operations. Supports advanced features like AI-optimized summaries, smart diffs, and atomic operations with rollback support.