FastMCP is a production-oriented Python framework for the Model Context Protocol (MCP). Rather than being a single application, it is a multi-package library stack: `fastmcp_slim` provides the core server/client framework, `fastmcp_remote` bridges remote MCP servers to local stdio, and `fastmcp_tasks` implements SEP-2663 background task execution. The core architecture centers on the `FastMCP` server class, a `Client` class with transport abstraction (stdio, SSE, Streamable HTTP, in-memory), provider-based component registration (local, filesystem, OpenAPI, proxy, skills), composable middleware, transforms, OAuth/OIDC authentication, OpenTelemetry instrumentation, and a CLI for running, installing, deploying, and inspecting servers. Entry points include the `fastmcp` CLI and the Python APIs `FastMCP`, `Client`, `ClientGroup`, `FastMCPApp`, and `TasksExtension`. This is an application framework, not a data/research repository, though it contains information-retrieval components (BM25 and regex tool search), OpenAPI schema conversion machinery, and telemetry utilities that approach data-engineering utility. The codebase demonstrates strong engineering discipline: extensive unit and integration tests, conformance testing against the MCP spec, lazy imports to preserve startup performance, upgrade-guide tests that verify documentation claims, and a transform/middleware system that keeps extensions decoupled from core server logic. External dependencies include the MCP Python SDK, Pydantic, Starlette/ASGI, OpenTelemetry, optional authlib, optional prefab-ui for interactive apps, and an internal `httpx2` fork, which is the most notable maintenance risk in an otherwise current codebase.
ToolHive is a production-grade MCP (Model Context Protocol) server management platform developed by Stacklok. It provides a comprehensive CLI (`thv`), a Kubernetes operator (`thv-operator`), a proxy runner, and a virtual MCP server (vMCP) for aggregating multiple backend MCP servers. The system manages the full lifecycle of MCP workloads—running, stopping, building, exporting, and monitoring—while enforcing authentication (OAuth, OIDC, SPIFFE, AWS STS), authorization (Cedar, HTTP PDP, annotation-based), rate limiting, telemetry (OpenTelemetry/Prometheus), and secrets management (1Password, keychain, environment). It supports multiple transport protocols (SSE, streamable HTTP, stdio) and container runtimes (Docker, Podman, Kubernetes). The architecture is modular: a CLI layer built with Cobra, an API layer (RESTful registry and health endpoints), a Kubernetes operator layer with CRD reconcilers, a transport proxy layer with session management, and a plugin/skill system for installing and verifying OCI artifacts with Sigstore signing. The vMCP subsystem provides tool aggregation, conflict resolution, capability caching, and health monitoring with circuit breakers. External dependencies include Kubernetes client-go, Docker engine, Redis/Valkey, OpenTelemetry SDK, Sigstore, Ory/Fosite (OAuth), and various Go libraries for YAML, JSON Schema, and HTTP networking. Key data flows: CLI commands trigger workload creation via the runner, which builds a RunConfig from user flags and environment, then deploys the MCP server in a container (Docker/Kubernetes). The proxy layer intercepts MCP JSON-RPC messages, applies middleware (auth, rate limiting, telemetry, body limits), and forwards to the backend server. The vMCP server aggregates tools from multiple backends, resolves naming conflicts, and presents a unified MCP interface to clients. Telemetry spans are created at each layer and exported via OTLP. Skills and plugins are installed from OCI registries, verified with Sigstore, and managed via lock files with content digest validation.
This repository implements an MCP (Model Context Protocol) server that bridges AI assistants with SearXNG, a privacy-respecting metasearch engine. It exposes four primary tools: `searxng_web_search` for web queries, `searxng_search_suggestions` for autocomplete, `searxng_instance_info` for capability discovery, and `web_url_read` for fetching and converting web pages to markdown. The server runs in two transport modes: STDIO (default) for simple MCP integration, and HTTP for stateful/stateless remote access with optional OAuth and static bearer authentication. The architecture is modular and security-focused. Core modules include a proxy layer with per-type agent selection, SSRF protection via private IP blocking and DNS rebinding detection, a browser solver chain (FlareSolverr/Byparr) for challenge solving, worker-threaded PDF extraction, and multi-instance failover/fanout for SearXNG replicas. All credential-bearing output (logs, errors, MCP resources) is redacted by a centralized sanitizer. Extensive environment-variable configuration (~40+ knobs) controls caching, timeouts, rate limiting, TLS, and result formatting. Highlights include a strict integer parser that rejects unsafe or malformed values, an LFU cache with age tie-breakers and configurable TTL, and a comprehensive URL security module covering both IPv4 and IPv6 private ranges. The test suite achieves over 90% line coverage and includes integration, unit, fuzz, and e2e tests, with documentation tests that verify README and configuration docs match source contracts. The project is actively maintained with frequent releases, pinned dependencies, and a verification gate that enforces zero-vulnerability audits before publishing.
AgentSkillsHub is a production-grade web application that indexes, grades, and surfaces open-source AI agent skills, MCP servers, and Claude/Codex skills. It operates as a full-stack directory with a trust-layer differentiator: each skill receives a deterministic security grade (SAFE/CAUTION/UNSAFE/REJECT) from a rule-based scanner (35 patterns across 11 categories) and a composite quality score (10 signals). The system is architected as a FastAPI monolith (backend) with a React SPA frontend pre-rendered for SEO via 13+ build-time generators, backed by Supabase (PostgreSQL) and triggered by GitHub Actions every 8 hours. It ingests data from the GitHUB Search API through a 6-phase pipeline (search → metadata → README fetch → scoring → classification → composability), then serves the catalog via static HTML pages, REST API endpoints, an MCP server, and a CLI tool. Monetization includes a Pro tier with paid deep search, a $49 deep-audit per skill, and enterprise subscriptions. The codebase also produces original research: a published dataset of 130k+ graded skills, an arXiv paper on security distributions, a 12-chapter Blue Book, and extensive SEO/GEO strategy documents. Despite its hybrid nature (both a software application and a data research project), the dominant character is application because the running web service is primary; the research outputs are byproducts of the operational pipeline.
This is a monorepo containing over 40 independent MCP (Model Context Protocol) servers for AWS services, hosted under awslabs/mcp. Each server exposes tools, resources, and prompts that allow AI agents (coding assistants, chatbots) to interact with AWS APIs, databases, documentation, and best practices. The architecture is a collection of standalone Python packages, each with its own entry point (server.py/main.py), tests, Dockerfile, and PyPI distribution. Servers are built using either FastMCP or the lower-level MCP Python SDK, with consistent patterns for read-only enforcement, error handling, AWS client creation, and user-agent tracking. The codebase demonstrates solid engineering with extensive test coverage, but suffers from significant copy-paste boilerplate across servers (healthcheck scripts, Context singletons, test_init.py) and inconsistent use of MCP frameworks. Notable high-craftsmanship components include the AWS API MCP server's custom CLI-to-IR parser and execution engine, the OpenAPI MCP server's pluggable authentication provider framework, and the DynamoDB MCP server's schema-driven code generation tool. The repository is actively maintained with frequent commits and issue triage, though some servers are marked as deprecated or in initial setup, and the announcement of a successor ('Agent Toolkit for AWS') suggests potential future migration.
AssetOpsBench is a unified open framework for building, orchestrating, and evaluating domain-specific AI agents in industrial asset operations and maintenance (Industry 4.0). It provides a suite of MCP (Model Context Protocol) servers that expose domain tools for IoT telemetry, work order lifecycle, failure mode analysis, time-series forecasting/anomaly detection, vibration diagnostics, and utility functions. The framework includes multiple agent runners (plan-execute, Claude, OpenAI, Deep, Stirrup, OpenCode, direct LLM) that consume these tools, and a comprehensive evaluation pipeline with LLM-as-judge and deterministic structured-answer scorers. The system is designed to run reproducible benchmark scenarios with ground truth, producing leaderboard reports for agent comparison. It is accepted at KDD 2026 and powers multiple competitions. Architecturally, the system is a collection of Python packages with 14 CLI entry points defined in pyproject.toml. Each MCP server is a standalone FastMCP application using stdio transport, backed by CouchDB for persistence. Agent runners share a common trajectory model and observability layer (OpenTelemetry with file-based export). The evaluation pipeline is pluggable with a scorer registry. The codebase also includes a significant data/research component: a time-series feature extraction library (130+ extractors), a model catalog with foundation models (TinyTimeMixer, sktime wrappers), synthetic data generation for vibration signals, and showcase notebooks demonstrating end-to-end model lifecycle. The hybrid nature makes it both a software benchmark framework and a research platform for industrial AI.
This repository is a community-curated awesome list for the Model Context Protocol (MCP) ecosystem, cataloguing hundreds of MCP server implementations, clients, frameworks, utilities, and tutorials. It is primarily a structured markdown documentation site with a consistent badge taxonomy (language, scope, OS), a deep category hierarchy, and multi-language translations. The repo contains no application source code or data pipeline; the only executable logic is a GitHub Actions workflow that validates pull requests adding new entries. The validation enforces formatting standards, allowed emoji tags, Glama badge requirements, duplicate link checks, and non-GitHub URL rejection, which keeps the list high-quality at scale despite its size. The repository serves as a discovery hub for engineers building with LLMs and agentic systems, making it a valuable reference asset rather than a runnable service. It is actively maintained, with recent commits, broad community participation, and a strong automation framework, though its value derives from curation quality rather than software craftsmanship.
This is a Claude Code plugin and resource library, not a deployable application or data pipeline: 27 slash commands, 9+ autonomous skills, 3 auditor subagents, and extensive prompt-engineering documentation that extend the Claude Code CLI. In production, the system functions as configuration-as-code content consumed by the Claude Code runtime — teaching the assistant how to create executable plans (PLAN.md is the prompt itself), chain meta-prompts, build MCP servers, manage subagent orchestration, run autonomous coding loops (the 'Ralph' technique), and apply iOS/macOS development expertise. The only real executable code is a handful of self-contained scripts: a TypeScript CLI for The Pirate Bay API, Python/TypeScript MCP server templates, project scaffolding shell scripts, and autonomous loop iteration scripts. The dominant architectural pattern is the 'router skill': a SKILL.md entry point with essential principles, an intake gate, a routing table, and progressive disclosure into workflows, references, templates, and scripts — implemented consistently across all skills with pure XML prompt structure and checkpoint-based plan execution. Despite being classified as an application (there is no data-research character — no notebooks, datasets, or pipelines), its substance is largely authored content rather than software. The craft is strong: consistent XML schemas across files, a genuine QA layer (skill-auditor agents), secret hygiene practices, and a well-developed checkpoint/auth-gate protocol for safe automation. However, the repo carries real drift risks: duplicated reference files (research-pitfalls.md, cli-observability.md are copied across skills), dangling references to not-yet-created files, tight coupling to Claude Code's evolving plugin API, version-specific Apple platform guidance that will age, and the included The Pirate Bay skill which depends on a fragile third-party API and presents a content-policy concern. An engineer seeking to reuse this should extract the self-contained templates and scripts (MCP server scaffolding, loop automation) and treat the reference material as opinionated prompt guidance rather than canonical documentation.