Context+ is an MCP (Model Context Protocol) server that provides AI agents with structural and semantic awareness of large codebases. It operates over stdio and exposes 17 tools for code discovery, analysis, version control, and memory management. The architecture is layered: a core layer handles multi-language AST parsing via tree-sitter (36 languages with WASM grammars and regex fallback), gitignore-aware recursive directory walking with nested .gitignore support, vector embedding generation (Ollama or OpenAI-compatible APIs) with disk caching and adaptive batching, and an in-memory property graph for long-term memory with decay scoring and auto-similarity edges. A tools layer wraps these capabilities into MCP tools for context tree generation, file skeleton extraction, semantic search (file-level and identifier-level with call-site ranking), blast radius analysis, static analysis runner, commit validation with shadow restore points, spectral clustering-based semantic navigation, and Obsidian-style feature hub navigation. A git layer provides a shadow restore point system for undo without touching git history. The server includes process lifecycle management (idle timeout, parent process monitoring, broken pipe detection) and a realtime embedding tracker that incrementally refreshes embeddings on file changes. The landing page is a separate Next.js application deployed on Cloudflare Workers that serves the documentation and instructions API.
This repository implements an MCP (Model Context Protocol) server that serves as a bridge between MCP clients (like Claude Code) and OpenAI's Codex CLI. It exposes Codex CLI functionality as MCP tools, enabling AI-powered code analysis, generation, and review within editor environments. The server handles stdio communication, manages conversational sessions, spawns Codex CLI processes with appropriate arguments, and processes their output to provide structured responses to clients. The architecture follows a modular design with clear separation between server setup, tool definitions, handlers, session management, and command execution utilities.
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.
n8n is a production-grade workflow automation and AI agent platform. In production, it runs as a Node.js Express server with a Vue 3 frontend, executing user-defined workflows composed of nodes (triggers, actions, LLM calls). Workflows can be triggered manually, via webhooks, schedules, or events, and the execution engine handles concurrency, retries, errors, and data passing between nodes. The platform supports AI agents through an SDK that manages LLM calls, tool execution, memory, conversation loops, and MCP (Model Context Protocol) integration, enabling autonomous multi-step agents. Architecturally, the monorepo is organized into backend (packages/cli, packages/core, @n8n/engine), frontend (packages/frontend/editor-ui), database layer (@n8n/db with TypeORM), AI/agent packages (@n8n/agents, @n8n/ai-utilities, @n8n/instance-ai), and a vast node/credential library (packages/nodes-base, @n8n/nodes-langchain). Dependency injection is handled by @n8n/di, controllers are decorated with @RestController, and database models use a forked TypeORM. The system supports multiple database backends (PostgreSQL, SQLite) and can scale with Redis and worker processes. Key data flows: Workflow definitions are persisted in the database with version history. Execution data (inputs, outputs, binary data) is stored for monitoring and replay. The AI agent runtime uses a persistent message store for conversation memory, supports checkpoint/restore for long-running agents, and integrates with external LLMs (OpenAI, Anthropic, etc.) via a unified model factory. The platform exposes REST APIs for CRUD operations on workflows, credentials, users, and executions, as well as WebSocket push for real-time UI updates. External dependencies include a database, optional Redis for scaling, and numerous third-party services via nodes and credentials.
WorldMonitor is a full-stack, open-source global intelligence platform providing real-time monitoring of geopolitical, economic, military, supply chain, and natural events. The codebase is overwhelmingly an application (single-page web dashboard, Vercel Edge API, Convex backend, Tauri desktop app, CLI, and SDKs) with a secondary data pipeline character (consumer price scraping, external API seeding). It powers a commercial SaaS with free and Pro tiers, featuring a map-based dashboard with 100+ configurable panels, an MCP (Model Context Protocol) server for AI agents, and extensive multi-language support (28 locales). The architecture follows a seed-cache pattern where Railway cron jobs fetch external data into Redis, and serverless Edge functions read cached JSON for low-latency responses. The frontend uses vanilla TypeScript with Vite, deck.gl/MapLibre for mapping, and a panel system for modular UI composition. The system is actively maintained, with daily commits, comprehensive test coverage (unit, integration, E2E with Playwright), and a well-documented API surface with 298 protobuf definitions across 36 domain services. While the codebase is large and occasionally duplicates shared constants across modules, it demonstrates strong software engineering practices including circuit breakers, idempotency keys, rate limiting, and a consistent handler pattern.
AList is a self-hosted file listing and sharing gateway written in Go. In production it aggregates over 100 distinct storage backends — local disk, Aliyun Drive, OneDrive, Google Drive, S3, Baidu, PikPak, Thunder, WebDAV mounts, FTP/SFTP servers, and more — behind a unified virtual file tree, then exposes that tree simultaneously through a web UI + REST API, WebDAV, an S3-compatible object storage endpoint, FTP, SFTP, and an MCP (Model Context Protocol) tool server. It is a monolithic Go application (Gin + GORM) deployed as a single binary or Docker container, with a rich feature surface: role/permission-based multi-user access with path-scoped grants, password-protected time-limited shares with burn-after-read and download tracking, pluggable search backends (Meilisearch, Bleve, database full-text, no-index), offline downloads via aria2/qBittorrent/Transmission plus cloud-native tools, archive extraction (zip/7z/rar/iso9660), device session limits, rate limiting, SSO/LDAP/WebAuthn auth, and an FRP reverse-proxy client for NAT traversal.
This repository implements an AI-powered diagram generation and editing application that integrates draw.io with large language models. Users describe diagrams in natural language, and the system generates, edits, and validates draw.io XML diagrams through a chat interface. The architecture is a Next.js 16 web application with App Router, supporting multiple AI providers (OpenAI, Anthropic, Google, AWS Bedrock, DeepSeek, Ollama, etc.) via the Vercel AI SDK. It includes a desktop Electron app with offline draw.io support, an MCP server for external AI agent integration (Claude, Cursor, VS Code), and an admin panel for runtime configuration of models, access controls, and observability (Langfuse). The application is self-hostable via Docker and deployable to Vercel or Cloudflare Workers. The core workflow involves a chat interface where users send prompts, optionally upload files (images, PDF, text) or URLs, and the AI responds with tool calls to display, edit, or append diagrams. The system handles streaming XML generation, debounced diagram updates, and automatic XML validation/fixing to correct common LLM output issues. It supports multi-page diagrams, shape libraries (AWS, Azure, GCP, etc.), and experimental VLM-based diagram validation. Session history, templates, and diagram versions are persisted in IndexedDB, with optional server-side quota management via DynamoDB. The codebase demonstrates strong engineering practices with comprehensive unit and E2E tests, CI/CD pipelines, multi-platform builds (web, desktop, MCP server), and i18n support for English, Chinese, and Japanese. It features reusable patterns such as a registry-driven admin settings system, DNS-based SSRF protection, and a standalone XML validation library. While the project is actively maintained and uses modern frameworks, its large dependency surface and complex configuration precedence (env vars, admin panel, file-based) introduce some maintenance overhead.
drawio-skill is a comprehensive toolkit for generating, manipulating, validating, and publishing draw.io architecture diagrams from natural language, codebases, infrastructure-as-code, API specifications, and other structured sources. It provides a unified CLI (`diagramctl.py`) and an optional MCP server (`diagramctl_mcp.py`) that expose workflows for building, syncing, viewing, testing, reviewing, querying, what-if analysis, story generation, and publishing diagrams. The system uses a formal Diagram Intermediate Representation (IR) to separate semantic meaning from geometry, enabling incremental reconciliation, multi-view projection, architecture contract enforcement, and accessible HTML story output. It includes 15+ importers for languages (Python, JS, Go, Rust), IaC (Terraform, Kubernetes, Docker Compose), schemas (SQL, OpenAPI, AsyncAPI, Protobuf, GraphQL), and live infrastructure (Docker, Terraform state). The project is packaged as an AI agent skill compatible with Claude Code, Cursor, Copilot, and other Agent Skills hosts, and ships with GitHub Actions for CI integration. While primarily an application, it also bundles curated icon indices and style presets that could be considered data assets.
This repository implements a persistent memory server for AI agents, designed to solve the problem of agent amnesia across sessions, devices, and team members. The production system is a Rust-based HTTP server (Axum) that exposes a RESTful API with 48+ endpoints, backed by LanceDB for vector storage and supporting both hosted and self-hosted deployments. It ingests conversational or document data via an LLM-powered pipeline that extracts atomic facts, filters noise, scores admission, and reconciles with existing memories using seven operations (CREATE, MERGE, SUPERSEDE, etc.). The system manages a full memory lifecycle with Weibull decay, tier-based promotion/demotion, and auto-forgetting, and provides a multi-stage retrieval pipeline that combines vector search, BM25, cross-encoder reranking, decay boosting, and MMR diversity. Plugins for Claude Code, OpenCode, OpenClaw, and MCP allow client-side integration, and a GitHub connector ingests commits, issues, and PRs as memories. The architecture is multi-tenant with personal, team, and organization spaces, each isolated in separate LanceDB directories, and supports versioned, provenance-tracked sharing with staleness detection.
claude-mem is a persistent memory system for AI coding assistants, primarily targeting Claude Code but also supporting Codex, Cursor, Windsurf, OpenClaw, and other platforms. It captures observations, summaries, and user prompts from coding sessions via lifecycle hooks (SessionStart, PostToolUse, etc.), stores them in SQLite (local) or Postgres (server), and injects relevant context into future sessions to maintain continuity across agent interactions. The system operates as a background worker daemon (Bun) or a multi-user server (Express + BullMQ + Valkey) with API key authentication, team/project scoping, and rate limiting. Architecturally, claude-mem is a hybrid of a CLI plugin and a standalone server. The CLI component integrates into IDEs via hook scripts and MCP servers, while the server component provides REST APIs for memory management, search, and cloud sync. It features a dual-storage backend (SQLite for local, Postgres for server) with vector search via ChromaDB and full-text search via SQLite FTS5. The system includes a React-based viewer for browsing memory feeds, telemetry (opt-out PostHog), and a Cloudflare Workers-based sync hub for cross-device synchronization. The codebase demonstrates strong engineering practices with well-abstracted components (search strategies, provider abstraction, atomic file operations, telemetry scrubbing) but carries some technical debt from its dual-runtime evolution (legacy worker vs. server-beta) and extensive Windows-specific workarounds. It is actively maintained with frequent releases and comprehensive test coverage.
This repository is the official Model Context Protocol (MCP) reference implementation, containing seven standalone servers (everything, filesystem, memory, sequentialthinking, fetch, git, time) written in TypeScript or Python. These servers demonstrate the full MCP protocol—tools, prompts, resources, transports (stdio, SSE, Streamable HTTP), subscriptions, sampling, elicitation, tasks, and structured content. They are designed as educational examples for developers building their own MCP servers, not as production-ready solutions. The codebase is well-structured with consistent patterns (server factory, transport abstraction, security-focused path validation, atomic file operations, knowledge graph management) and includes extensive test suites. While actively maintained, some Python servers show drift from the latest MCP SDK (v2 API renames in progress), and the Everything server's demo code is tightly coupled to experimental protocol features. The repository also serves as a central hub for the MCP ecosystem via a curated community resource directory (ADDITIONAL.md).
Coolify is a self-hosted Platform-as-a-Service (PaaS) that enables users to deploy and manage applications, databases, and services on their own infrastructure. It serves as an open-source alternative to Heroku, Netlify, or Vercel, supporting Docker-based deployments with Git integration (GitHub, GitLab, Gitea, Bitbucket), multiple build packs (Railpack, Nixpacks), and one-click service templates. The system manages servers, reverse proxies (Traefik/Caddy), SSL certificates, scheduled backups, and multi-channel notifications (email, Discord, Slack, Telegram, Pushover, webhook). The architecture is a Laravel monolith with a Livewire + Alpine.js frontend for the v4 UI and a React + TypeScript canvas-based interface for the v5 UI. Background jobs are handled by Laravel Horizon with dedicated queues for deployments, cron tasks, and reconciliation. Real-time updates use Soketi (a Pusher-compatible WebSocket server) and Laravel Echo. The system integrates with cloud providers (Hetzner, Vultr, DigitalOcean) for server provisioning and Stripe for subscription billing. A Model Context Protocol (MCP) server exposes resources and tools for AI assistant integration. Key data flows include: webhook ingestion from Git providers triggering deployment jobs, SSH-based remote command execution on managed servers, Docker Compose parsing and environment variable injection, database backup scheduling with S3 storage, and proxy configuration generation. The v5 architecture introduces a control-plane/agent split with Flux (HTTP socket) and coold (gRPC) components for improved scalability and isolation. External dependencies include Docker, PostgreSQL, Redis, Soketi, Stripe API, cloud provider APIs, and various notification service endpoints. The codebase is actively developed with frequent schema migrations and a dual v4/v5 code path, indicating ongoing architectural evolution.
Nacos is a production-grade dynamic service discovery, configuration management, and service management platform, originally built by Alibaba. The codebase is a large Java/Spring Boot monolith with a React frontend, organized into modules for core infrastructure (cluster, gRPC, Raft consensus, Distro sync), configuration management (CRUD, long-polling, gray rules, history), naming/service discovery (instance registration, health checks, push v2), and an extensive plugin system (auth, datasource, encryption, control, visibility). In recent versions, Nacos has expanded into AI resource management, adding modules for MCP server registry, agent specs, skills, prompts, A2A agent discovery, vector search indexing, and pipeline execution. The repository includes two frontend codebases (legacy console-ui and modern console-ui-next with Radix UI/Tailwind), a Java client SDK, and comprehensive unit/integration tests. The architecture is modular with SPI-based plugin loading, event-driven internal communication, and support for multiple databases (Derby, MySQL, PostgreSQL, Oracle). Despite its size and rapid AI feature growth, the codebase maintains solid engineering practices with clear separation of concerns, extensive test coverage, and a well-defined plugin contract.
Task Master is a monorepo providing an AI-driven task management system designed for integration with AI coding assistants (Claude Code, Cursor, Windsurf, etc.). It consists of a CLI tool (`task-master`), an MCP server, a VS Code extension, and core library packages. The system manages tasks with statuses, priorities, dependencies, tags, and subtasks, and offers AI-assisted operations like PRD parsing, task expansion, complexity analysis, and TDD workflow automation (autopilot). It supports multiple storage backends (local JSON files, remote Hamster API via Supabase) and 15+ AI providers. The architecture follows a clean layered pattern with domain modules in `@tm/core` consumed by CLI and MCP interfaces, though a legacy `scripts/` directory still contains overlapping logic being gradually migrated. The codebase demonstrates strong engineering practices including factory patterns, abstract base classes, dependency injection, atomic file operations, and extensive test coverage. Some technical drift is present due to the ongoing migration from JavaScript to TypeScript and duplicated MCP server implementations.
This monorepo (Nx) implements a complete ecosystem for managing and distributing 'skills'—curated, structured instructions for AI coding agents. The codebase reveals a production CLI (`agent-skills`) built with Ink/React for interactive terminal UI, an MCP server (`agent-skills-mcp`) for agent-in-context skill lookup via FastMCP, a Next.js marketplace website for browsing, and a skills catalog with over 150 skill definitions across architecture, cloud, development, quality, security, and other domains. The core library (`@tech-leads-club/core`) uses a clean hexagonal architecture with port/adapter separation for file system, HTTP, environment, logging, and shell operations, enabling testability and future portability. The CLI supports interactive and non-interactive install/remove/update workflows with atomic lockfile writes, append-only audit logging, and content-hash integrity verification. The MCP server implements a progressive disclosure pattern (search → read → fetch/prepare) to minimize token usage, with registry caching and ETag revalidation. The marketplace is highly SEO-optimized with JSON-LD structured data, breadcrumbs, and static generation. Property-based tests (fast-check) for UI components and cache boundaries demonstrate strong engineering discipline. The skills catalog itself is the core product—each skill is a markdown file with YAML frontmatter, optional scripts/references, and trigger phrases, all validated by a custom validation tool and security-scanned in CI. While the architecture is solid and the codebase is actively maintained with frequent releases, some areas show drift risk: duplicate validation scripts across skills, hardcoded benchmark data in the marketplace, and tight coupling to external CDN availability for registry downloads. The cloud-deploy skill references an enormous set of Cloudflare product docs that will inevitably become outdated. Overall, this is a well-crafted, modern TypeScript monorepo that effectively solves the problem of giving AI agents reusable, safe, and discoverable instructions.
This is an MCP (Model Context Protocol) server that auto-generates AI-agent-friendly tools from the Notion REST API OpenAPI specification. It runs as a CLI tool (stdio transport) or an HTTP server (Streamable HTTP transport), exposing 24 tools covering users, search, blocks, pages, comments, data sources, and databases — including dedicated markdown read/write endpoints. The architecture follows a clean three-layer design: an OpenAPI-to-MCP converter (`parser.ts`) that transforms each operation into a tool with JSON Schema input/output; an MCP proxy (`proxy.ts`) that handles tool listing/calling and deserializes double-encoded JSON parameters (a known MCP client issue); and an HTTP client (`http-client.ts`) that executes the actual API calls using axios and openapi-client-axios. Notable engineering highlights include per-operation `Notion-Version` header sourcing from the spec (so each endpoint can pin its required API version), a per-request token passthrough mechanism for multi-tenant deployments, and comprehensive test coverage with snapshot tests locking the tool surface. The repo is well-structured TypeScript with clear separation of concerns, though the README signals that this local MCP server may be sunset in favor of a newer remote MCP offering.
pREST is a production-grade Go HTTP server that automatically exposes PostgreSQL databases as RESTful and MCP (Model Context Protocol) APIs without requiring hand-written backend code. It provides instant CRUD endpoints for any table, custom SQL template execution with parameterized queries, and a built-in Studio web UI for exploring and managing APIs. The system is architected around a hexagonal pattern with a clean adapter interface supporting multiple databases (PostgreSQL, TimescaleDB), dependency injection for controllers, and a layered middleware stack for authentication (JWT), authorization (table/field-level ACL), caching, and CORS. Security is a primary concern: SQL injection is mitigated through strict identifier validation, template parameter screening, and bound parameter binding, while credential leakage in logs is prevented by a dedicated redaction package. The codebase is well-tested with both unit tests (using sqlmock) and integration tests (against real PostgreSQL in Docker), and includes OpenTelemetry integration for observability. It is not a data research or analytics project; it is a pure application for building low-code database APIs.
Vibe Check MCP is a production-ready MCP (Model Context Protocol) server that provides metacognitive oversight for AI agents. It implements the research-backed Chain-Pattern Interrupt (CPI) methodology to prevent reasoning lock-in by injecting reflective pauses during agent workflows. The server exposes six tools: `vibe_check` for generating clarifying questions via a secondary LLM, `vibe_learn` for logging patterns of mistakes and successes, and three constitution management tools (`update_constitution`, `reset_constitution`, `check_constitution`) for per-session behavioral rules. It supports multiple LLM providers (Gemini, OpenAI, Anthropic, OpenRouter) with automatic fallback to static questions when the LLM is unavailable, and maintains session history for context-aware feedback. The architecture is a monolithic MCP server with dual transport modes: stdio for local agent clients (Claude Desktop, Cursor, Windsurf, VS Code) and streamable HTTP for remote access. A CLI tool (`vibe-check-mcp`) automates installation into all major MCP client configurations with atomic writes and backup creation, handles secret management via interactive prompts or env files, and provides diagnostic commands. The server includes robust HTTP security hardening: DNS-rebinding protection via Host header validation, loopback-only CORS by default with a configurable allowlist, explicit JSON body size limits, and proper JSON-RPC error responses instead of HTML pages. The codebase is well-organized with separation of concerns, extensive unit and integration tests (over 30 test files), CI/CD with security scanning, and clean abstraction layers such as a central model registry and request-scoped transport wrappers.
EDT-MCP is an Eclipse/OSGi plugin that implements a Model Context Protocol (MCP) server for 1C:Enterprise Development Tools (EDT). It exposes over 95 MCP tools enabling AI agents (Claude, Copilot, Cursor) to inspect and manipulate EDT workspaces – reading metadata, editing BSL code, running tests, managing debug sessions, performing git operations, and configuring infobases. The server runs as a plugin inside EDT, uses JSON-RPC 2.0 over HTTP/SSE transport, and supports progressive tool disclosure via toolsets. A separate proxy component allows routing MCP calls across multiple EDT backends with hot-plug failover. The architecture is layered: a protocol layer (session management, origin validation, JSON schema building), a tool registry with atomic catalog replacement, utility services for EDT model access (BmTransactions, ProjectContext, DebugSessionRegistry), and UI extensions (metadata tagging, virtual groups, call history view). The build uses Maven/Tycho and produces a p2 update site for EDT 2026.1 and 2026.2. Test coverage includes headless unit tests (JUnit/Mockito), Python e2e tests against a live server, conformance tests against the official MCP conformance suite, and ratchet tests that enforce coding standards, error quality, schema parity, and mutation safety. Key engineering patterns include: idempotent tool execution with destructive consent gates, PII redaction via HMAC pseudonymization, optimistic locking via ContentHash for read-modify-write cycles, bilingual Russian/English FQN normalization, and strict separation of read/write transactions (reads use IBmModel.executeReadonlyTask, writes use execute). The codebase is well-maintained with active issue triage and CI/CD pipelines.
Chiasmus is a neurosymbolic verification engine packaged as a TypeScript library and Model Context Protocol (MCP) server. It bridges LLMs with formal solvers — Z3 (SMT) and SWI-Prolog (WASM) — by translating natural-language problems into template-based formal specifications that are verified with mathematical certainty. It also performs static code analysis: tree-sitter-based extraction of call graphs for TypeScript/JavaScript, Python, Go, Rust, Clojure, Scheme, Racket, and Common Lisp, followed by 16 analyses (reachability, dead code, impact, cycles, layer violations, community detection, hubs, bridges, diffs). Architecturally, the repo is a modular ESM library with an MCP server entry point (src/mcp-server.ts) exposing 11 tools over stdio (chiasmus_graph, chiasmus_map, chiasmus_formalize, chiasmus_verify, chiasmus_search, chiasmus_review, chiasmus_learn, etc.). Core subsystems: graph extraction with per-file content-hash caching and snapshot diffing; a formalization engine that selects from 8 built-in skill templates via BM25/embedding retrieval and runs an LLM-driven correction loop against the solvers; a SQLite-backed skill library that learns new templates from verified solutions; and pluggable LLM adapters (Anthropic, OpenAI-compatible, Azure, local via node-llama-cpp). Data flows: source files are parsed by tree-sitter into a CodeGraph, which can be emitted as Prolog facts for symbolic queries or analyzed natively with O(V+E) algorithms (Tarjan SCC, BFS). For verification, a problem statement is embedded, matched to a template, slot-filled by an LLM, linted, and iteratively corrected until the Z3/Prolog solver confirms the property or finds a counterexample. The benchmark suite compares Chiasmus against traditional implementations across RBAC, dependency resolution, taint analysis, workflow validation, and validation consistency. Maintenance is active (v0.1.28, CI on Node 22/24, 70+ test files covering graph extraction, solvers, MCP tools, search, and skills). The codebase is well-engineered with several genuinely reusable components — native graph algorithms, an LRU extraction cache, a BM25 index, and a tsconfig alias resolver — though some coupling exists between the extractor and the TypeScript type environment, and the vendored WASM grammars require periodic upstream syncs.