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.
This repository implements a Model Context Protocol (MCP) server that exposes DuckDB and MotherDuck databases to AI assistants and IDEs. The server provides five MCP tools: execute_query for running SQL queries, list_databases/list_tables/list_columns for catalog exploration, and switch_database_connection for changing the active database at runtime. It supports multiple database sources including in-memory DuckDB, local .duckdb files, S3-hosted databases, and MotherDuck cloud databases. The server can run in read-only or read-write mode, with additional security features like SaaS mode for MotherDuck that restricts local filesystem access. The codebase is well-architected with clear separation of concerns: a DatabaseClient class handles all connection management and query execution, tool implementations are pure functions living in a dedicated subpackage, and server configuration is centralized in configs.py. The use of FastMCP for the MCP protocol provides a solid foundation. The repository includes a comprehensive test suite of over 30 E2E tests covering local files, in-memory databases, MotherDuck, S3, read-only mode, concurrent access, timeouts, result limits, type serialization, catalog tools, and HTTP transport modes. CI/CD pipelines automatically run tests, publish to PyPI and the MCP registry, and create GitHub releases with MCPB bundles. The server is production-ready with features like lazy connection initialization, query timeout via threading, automatic result truncation based on row and character limits, and support for ephemeral connections that avoid file locks. The code handles edge cases such as MotherDuck read-scaling token validation, S3 credential chain support, and proper redaction of sensitive tokens in switch database responses. While the architecture is solid, most components are tightly coupled to the DatabaseClient interface, limiting direct reusability outside this project. The instructions.py module is the most easily extractable component, providing a template for generating dynamic MCP server instructions based on configuration.
This repository provides a stealth browser automation MCP (Model Context Protocol) server that offers undetectable control over real browser instances (Chrome, Chromium, Edge) via the Chrome DevTools Protocol (CDP) and the `nodriver` library. It exposes 97 tools across 11 sections including navigation, DOM interaction, element extraction (styles, structure, events, animations), network interception and modification (including dynamic Python-powered hooks), CDP command execution, cookie management, tab control, and proxy forwarding with authentication. The architecture is a FastMCP-based server with singleton managers for browser instances, network interception, element cloning, and process cleanup. It supports stdio and HTTP transports, Docker deployment, and optional bearer auth. The system is designed to bypass anti-bot detection (Cloudflare, CreepJS, login walls) and is used for scraping, testing, and AI agent automation. While the codebase is well-structured and the functionality is comprehensive, there is some code duplication across multiple element cloner implementations and technical drift risk due to tight coupling with CDP APIs and the `py2js` transpiler dependency.