This repository implements a production-grade Model Context Protocol (MCP) server that exposes GitHub's REST and GraphQL APIs as a collection of tools, resources, and prompts for AI agents. The server runs in either stdio (local CLI) or HTTP (remote) mode, supporting multiple authentication methods: personal access tokens, OAuth 2.1 (PKCE browser flow, device flow, manual fallback), and GitHub App installation tokens. It provides over 90 fine-grained tools organized into toolsets (issues, pull requests, actions, projects, code scanning, etc.), each with metadata including required OAuth scopes, feature flags, read-only hints, and information flow control (IFC) labels. The architecture is modular: a central inventory builder registers all tools, resources, and prompts; per-request filtering narrows availability based on authentication, feature flags, toolsets, and read-only mode. The HTTP server uses a chi router with middleware for CORS, body limits, token extraction, scope challenge, and MCP method parsing. A React-based UI (Primer components) provides sandboxed forms for creating and editing issues and pull requests, served as embedded HTML resources. The server also includes lockdown mode for prompt injection mitigation, sanitization of user-authored content, field filtering to reduce response size, and telemetry for metrics collection. External dependencies include the MCP Go SDK, go-github (REST), shurcooL/githubv4 (GraphQL), and various utility libraries for OAuth, HTML sanitization, and configuration.
Vendure is a mature, open-source headless commerce platform built on NestJS, GraphQL, and TypeORM. It provides a complete backend for e-commerce operations including product catalog management, order lifecycle, payment/shipping/tax processing, promotions, and multi-channel support. The monorepo contains a core backend package, two parallel admin UIs (an older Angular-based admin-ui and a newer React-based dashboard), a CLI tool for scaffolding and migrations, and a plugin ecosystem with official plugins for email, asset server, job queues (BullMQ), caching (Redis), telemetry (OpenTelemetry), and AI integration via the MCP (Model Context Protocol) plugin. The architecture is modular with a strategy pattern for extensibility, an event bus for domain events, a job queue system, and a custom fields system. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, and active maintenance. Notable reusable components include a generic finite state machine framework, a runtime-resolved custom fields system, an OAuth 2.1 authorization server, a dynamic form engine, and a tag-based cache invalidation service.
Engram is a persistent memory system for AI coding agents, written in Go. It provides a local-first knowledge store using SQLite with FTS5, exposed via CLI, HTTP API, MCP server, and terminal UI. Agents can save observations (notes), search memories, manage sessions, and consolidate related knowledge. The system supports multiple AI agents (Claude Code, Codex, Pi, OpenCode) through plugin hooks and MCP tools. Optional cloud sync enables multi-device persistence via a self-hosted Postgres backend with authentication, project controls, and a dashboard. The codebase demonstrates strong engineering practices with extensive test coverage, platform-specific handling, and reusable patterns like generation fencing and migration locking.
The drawio-mcp repository provides a comprehensive ecosystem for AI-assisted diagram creation using the Model Context Protocol (MCP). It consists of four integrated approaches: an MCP App Server for inline diagram rendering in AI chat interfaces (deployable as Node.js or Cloudflare Worker), an MCP Tool Server for opening diagrams in the draw.io browser editor, assistant-specific plugins for Claude Code, Codex, and GitHub Copilot, and project instructions for Python-based diagram generation. The system enables AI assistants to create diagrams from Mermaid or XML input, apply layouts (ELK/libavoid), and export to various formats while emphasizing data residency controls—self-hosted options keep all diagram data local, with cloud export requiring explicit user action via draw.io Desktop CLI.
This repository is a Visual Studio Code extension that provides comprehensive language support for Terraform, including syntax highlighting, completions, diagnostics, and integration with the Terraform Language Server. It also offers deep integration with HCP Terraform for managing workspaces, runs, and state, along with features like module and provider exploration, telemetry collection, and bug report generation. The extension follows a modular architecture with separate modules for features, commands, and providers, and uses patterns such as dependency injection and static feature classes to maintain separation of concerns. Key entry points include the main activation function in src/extension.ts and various commands in src/commands/. The extension relies on external dependencies such as vscode-languageclient, axios, and the terraform-ls binary.
The Dext Framework is a comprehensive, modular full-stack framework for Delphi (v11+) designed to bring modern web development patterns to the native Delphi ecosystem. It is Apache 2.0 licensed and provides a coherent set of libraries covering web API construction (minimal APIs, MVC controllers, middleware pipeline, SignalR-compatible real-time hubs), an ORM with code-first migrations, dependency injection, background jobs, event bus, resilience pipeline, testing/mocking utilities, desktop UI patterns (MVU/MVVM with VCL binding), AI integration (MCP server, agent graph), CLI tooling, and telemetry/dashboard. The architecture is heavily inspired by ASP.NET Core/EF Core, with fluent builders (`TDextServices`, `TApplicationBuilder`), specification pattern, attribute-based configuration, and a focus on zero-allocation performance (custom SIMD-optimized collections, ring-buffer logging, direct codecs). It includes extensive documentation (The Dext Book in English and Portuguese), benchmark harnesses, and 40+ example applications covering real-world use cases from simple CRUD to multi-tenant e-commerce. The codebase is actively maintained, with multi-version Delphi support (XE2 through 13), community database drivers (UniDAC), and a growing ecosystem of IDE integration and design-time tooling.
SETools is a comprehensive SELinux policy analysis toolkit providing both command-line and GUI utilities for querying, comparing, and analyzing SELinux policies. The system consists of a core library (setools) for policy representation and analysis, GUI components (setoolsgui) for interactive analysis via apol, and specialized tools like seinfo (policy querying), sesearch (rule search), sediff (policy comparison), and setools-mcp (MCP server for LLM integration). The architecture features a modular design with clear separation between policy representation, querying mechanisms, difference analysis, and validation frameworks. Key strengths include a reusable query framework using descriptor patterns and mixins, a robust difference engine with wrapper-based caching, and a well-structured GUI following model-view patterns. The project demonstrates active maintenance with recent updates, strict dependency management, and extensive test coverage.
Ruflo is a large, modular AI agent orchestration platform that extends Claude Code with a plugin ecosystem, swarm coordination, memory systems, neural learning, security enforcement, and federation. The core is a CLI tool (`npx ruflo`) that provides 26+ commands and 215+ MCP tools for managing agents, memory, security, hooks, and deployments. It includes a console UI inside Claude Code, a Svelte-based chat UI (ruvocal), and a React-based goal UI. The architecture is ADR-driven with clean separation into domain, application, and infrastructure layers across 35+ plugins and 20+ core packages. The system implements advanced patterns: CQRS for memory and swarm, circuit breakers for resilience, capability envelopes for security, Ed25519 signing for release integrity, and a harness loop for automated champion selection. It supports multi-model routing, hybrid vector search (HNSW + SQLite), watermarking (WASM-based Gumbel scheme), and neural learning (PPO, DQN, Decision Transformer). Federation enables cross-installation agent collaboration with zero-trust, HMAC-signed envelopes, and PII-gated data flow. While the codebase is well-structured and actively maintained, it has some maintenance risks: duplicate helper scripts across multiple directories, hardcoded version numbers in smoke tests, experimental alpha plugins, and a large regression test suite that requires ongoing upkeep. The plugin ecosystem is extensive but some plugins may be aspirational rather than production-ready.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
OpenDataLoader-PDF is a production-grade, multi-language PDF-to-structured-content extraction tool designed for AI/LLM pipelines, RAG systems, and accessibility workflows. It converts PDFs into JSON, Markdown, HTML, plain text, and tagged PDF (PDF/UA) with high accuracy (0.907 overall benchmark). The core engine is written in Java (veraPDF-based) and provides a rich CLI, while Python and Node.js SDKs bundle the Java JAR and expose idiomatic APIs. A hybrid mode routes pages to an external AI backend (Docling) for OCR, formula extraction, and picture descriptions, with a triage processor deciding per-page routing based on content signals. The project also includes an MCP server for AI agent integration, a LangChain loader, and an agent skill bundle for correct usage.
Higress is a cloud-native, AI-native API gateway built on Istio and Envoy. In production, it operates as a Kubernetes ingress controller, an AI/LLM proxy gateway, and a Wasm plugin host. The system ingests Kubernetes resource definitions (Ingress, Gateway API, custom CRDs like WasmPlugin, Http2Rpc, McpBridge) and translates them into Envoy xDS configurations, managing the full lifecycle of gateway routes, policies, and plugins. It provides a rich set of Wasm plugins (Go, Rust, C++, AssemblyScript) for authentication, rate limiting, request/response transformation, AI proxy (with 15+ LLM providers), semantic caching, RAG, MCP server hosting, and security (WAF, bot detection, IP restriction). The architecture is microservices-oriented: a control plane (Go-based ingress controller) manages Kubernetes resources and pushes config to Envoy data planes; a CLI tool (hgctl) handles installation, plugin development, and debugging; and a plugin release pipeline manages OCI image distribution with provenance verification. External dependencies include Kubernetes (client-go, controller-runtime), Istio (pilot, networking APIs), Envoy (Go filter API), and various AI/vector DB providers (OpenAI, Milvus, Pinecone, etc.).
Lemonade is a local AI inference server and desktop application that provides OpenAI/Anthropic/Ollama-compatible APIs with support for multiple backends (llama.cpp, vLLM, whisper.cpp, Kokoro, etc.). The C++ server core handles model lifecycle, routing policies, multi-modal inference, and telemetry, while the React/TypeScript frontend (Tauri desktop app and web build) offers a full GUI for chat, image/audio generation, transcription, and model management. The repository also includes a CLI client, tray application, extensive integration tests, and automated documentation generation. Architecture follows a clean backend-descriptor registry pattern with generated boilerplate, platform abstraction for process/archive/path operations, and a sophisticated routing policy engine for model selection.
Memlab is a comprehensive JavaScript memory leak detection and heap analysis framework developed by Meta. It provides a CLI, a programmatic API, and an MCP (Model Context Protocol) server for AI-assisted debugging. The system captures heap snapshots from Chromium (via Puppeteer), Node.js, Electron.js, and Hermes, then parses and analyzes them to identify memory leaks, optimization opportunities, and retention patterns. It includes specialized detectors for detached DOM elements, React component leaks, event listener accumulation, duplicate strings, and global variable bloat. The architecture is a monorepo with packages for core parsing and algorithms, E2E browser automation, heap analysis plugins, a public API, a CLI, an in-browser visualizer (MemLens), and an MCP server that exposes over 100 analysis tools. Key data flows involve warmup, browser interaction, snapshot capture, parsing, leak filtering, trace clustering (heuristic and ML-based), and report generation. External dependencies include Puppeteer, Chromium, and the MCP SDK.
mcp-logseq is a Model Context Protocol (MCP) server that bridges AI agents (like Claude) to Logseq knowledge bases. It exposes Logseq's local HTTP API through 15+ tools for reading, creating, updating, and deleting pages and blocks, along with search, DSL queries, and optional semantic vector search via LanceDB. The server supports both stdio and HTTP/SSE transports with security features including namespace/tag-based access control, read-only mode, TLS, and bearer token authentication. The vector database is managed by a separate sync process (logseq-sync) to enforce a single-writer pattern. The codebase is well-architected with clean separation of concerns: a declarative access control system, a pure namespace matching utility, a stateful markdown parser, and an embedder abstraction with Ollama/OpenAI adapters. Configuration is lazy-cached from environment variables and a JSON config file, with no import-time side effects. The test suite is comprehensive with over 50 unit tests and integration tests for HTTP serving. While the project is still in beta, it demonstrates strong engineering practices and provides several reusable components for other MCP server implementations or Logseq integration tools.
This is the official Gemini CLI by Google, a terminal-based AI assistant that brings Gemini models to the command line. It is a large TypeScript monorepo with packages for the CLI (interactive UI built on Ink/React), core agent logic (context management, tool execution, routing, policy enforcement), SDK for programmatic agent sessions, A2A server for agent-to-agent communication, and supporting tooling (devtools, test utilities, caretaker agent for automated issue triage). The CLI supports slash commands, extensions (hooks, MCP servers, themes), skills, sandboxed execution, multiple authentication methods (OAuth, API key, Vertex AI), and rich terminal features like themes, keybindings, and mouse support. It includes an extensive evaluation framework for behavioral testing of agent capabilities. The architecture is modular with clear separation between UI, core agent loop, and extensibility layers, though the monorepo size introduces some coupling and test fragility.
Voicebox is a local-first, open-source desktop application for AI voice cloning, text-to-speech (TTS), speech-to-text (STT), and dictation. It provides a full voice I/O stack that runs entirely on the user's machine, supporting multiple TTS engines (Qwen3-TTS, Chatterbox, Kokoro, TADA, LuxTTS, etc.) with zero-shot voice cloning from short audio samples. The application is built as a Tauri v2 desktop shell (Rust) wrapping a React/TypeScript frontend and a Python FastAPI backend with SQLite storage. Key features include global dictation with auto-paste, voice profile management with effects chains, a multi-track story editor, MCP server integration for AI agents, and GPU acceleration (CUDA, ROCm, MLX, DirectML). The architecture follows a service-oriented pattern with a backend factory for pluggable TTS/STT engines, SSE-based progress streaming, and a platform abstraction layer for cross-platform compatibility. The codebase is well-structured with extensive documentation, CI/CD pipelines, and a large community.
Exa MCP Server is a Model Context Protocol server that connects AI agents to Exa's web search and research capabilities. It provides a standardized interface for agents to perform web searches, fetch webpage content, run multi-step research agents, and access other Exa functionalities. The architecture features clear separation of concerns with API handlers for Vercel deployment, core MCP server logic, tool implementations for each Exa capability, and utility functions for authentication, logging, and error handling. Key entry points include stdio CLI for local usage and Vercel HTTP functions for cloud deployment. The system handles authentication via API keys or OAuth, implements rate limiting for free tier users, and includes mechanisms to prevent API key leakage between requests.
dembrandt is a production-grade design token extraction tool that analyzes live websites via headless Chromium (Playwright) and produces structured outputs including colors, typography, spacing, components, shadows, motion, and gradients. It supports multiple export formats: W3C DTCG tokens, Tailwind CSS v4 themes, DESIGN.md, self-contained HTML reports, PDF brand guides, and terminal display. Beyond extraction, it offers drift detection (comparing extractions over time with a 0–100 score), a GitHub Action for CI gates, and an MCP server for AI agent integration (Claude, Cursor). The architecture is modular with fault-isolated extractors, a pure-function drift engine, and a generic async job queue. While primarily an application, it includes an optional ONNX ML model for brand primary color prediction and advanced color science (OKLab, CIEDE2000, gamut mapping), giving it a hybrid character. The codebase demonstrates strong engineering practices: extensive test coverage, CI/CD pipelines, lazy browser loading, and graceful degradation across all output formatters.
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.
dotnet-claude-kit is an opinionated Claude Code plugin that transforms the AI assistant into an expert .NET 10 developer. It provides 47 skills (knowledge + workflow orchestrators), 10 specialist agents (e.g., dotnet-architect, ef-core-specialist), 10 always-loaded rules, 5 project templates, automation hooks, and a Roslyn-based MCP server (CWM.RoslynNavigator) offering 22 read-only code analysis tools. The MCP server delivers token-efficient semantic queries (symbol resolution, anti-pattern detection, dead code analysis, dependency graphs) via stdio, replacing expensive file reads. The architecture is modular: skills are markdown files loaded on demand, agents route requests to specialists, and the MCP server provides a robust program analysis backend. The system supports multiple AI coding tools (Claude Code, Cursor, Codex CLI, OpenCode) with cross-tool rule parity validation. Its core philosophy emphasizes guided over prescriptive development, modern .NET only (.NET 10/C# 14), and token-conscious interactions. The codebase demonstrates strong engineering with clean abstractions, extensive unit tests (200+ tests), CI/CD for NuGet publishing, and well-documented ADRs. The MCP server components (WorkspaceManager, SymbolResolver, anti-pattern detectors, pagination) are highly reusable and exhibit non-obvious craftsmanship. While the large skill surface requires synchronization, the overall quality is excellent for a developer tooling project.