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.
Tachikoma is a production-grade Swift SDK/library that provides a unified typed interface to a broad spectrum of LLM providers: OpenAI (Chat Completions, the newer Responses API for GPT-5+ generations, and a ChatGPT Codex OAuth backend), Anthropic (Claude with streaming signed thinking blocks), Google Gemini, Mistral, Groq, Grok/xAI, Kimi, MiniMax, OpenRouter, Together, Replicate, Ollama, LM Studio, Azure OpenAI, and arbitrary OpenAI/Anthropic-compatible endpoints. Its public surface is deliberately modeled on the Vercel AI SDK: generateText/streamText, generateObject/streamObject with partial-JSON repair, embeddings, vision analysis, and multi-step agent tool-calling loops. Beyond generation, it ships composable stop conditions, response caching, retry policies, usage/cost accounting, reasoning-effort controls, and a provider feature-parity adapter that normalizes differences in system roles, vision, and tool limits across backends. The repo is strictly an application SDK in character: no datasets, notebooks, or data pipelines. The one data-like facet is its manually curated model capability catalog (context lengths, pricing, per-generation reasoning support), which is embedded as Swift enums rather than external registries. Architecturally it is a SwiftPM monorepo of five products: Tachikoma (core generation/provider layer), TachikomaAgent (conversations, dynamic tool registry, MCP tool binding), TachikomaAudio (transcription, TTS, and an OpenAI Realtime WebSocket voice client), TachikomaMCP (a client for Model Context Protocol servers over stdio/SSE/HTTP with full JSON Schema bridging), and TachikomaConfigCLI (auth/credential helper), plus two example CLIs (ai-cli, gpt5cli). All providers implement a common ModelProvider protocol with ProviderRequest/ProviderResponse and AsyncThrowingStream-based streaming, with shared SSE/NDJSON parsing funneled through OpenAICompatibleHelper and provider-specific adapters for Anthropic, Google, and Ollama. The code is Swift 6.2, heavily async/await, and covered by a substantial test suite (Swift Testing, mock URLProtocol fixtures, snapshot tests, serialized mutex-guarded tests for shared state), with CI across macOS and Linux. The codebase exhibits strong engineering practice: clean provider abstraction, genuinely reusable utilities (stream transforms, retry policies, TTL caches, typed JSON Schema views), modular product boundaries, and disciplined error modeling. Its principal weaknesses are the enormous provider surface that must be manually maintained (hardcoded capability matrices, context-length string heuristics like isOpus48/isSonnet5, static pricing tables in ModelCostCalculator), a handful of @unchecked Sendable singletons and NSLock-guarded global state, Linux/Apple streaming divergence (Linux buffers the full response instead of streaming bytes), some dead placeholder APIs (the legacy generate() returning a mock string), and a rapid feature-churn cadence visible in the changelog (GPT-5.6/6, Claude 5, reasoning replay). These are maintainability risks more than correctness defects; the tested behavior is consistently thorough. Overall this is a high-craft SDK that an engineer building AI application features in Swift would benefit from studying, particularly its OpenAI-compatible adapter pattern, cache-key determinism, and MCP schema translation.
Perfetto MCP is a Model Context Protocol server that provides tools for analyzing Perfetto trace files. It maintains persistent connections to trace files and exposes various analysis tools through the MCP protocol, including ANR detection, CPU profiling, jank frame detection, memory leak analysis, and more. The architecture features a modular design with separate components for connection management, tool implementations, and resource registration. Key entry points include the main server module, development entrypoint, and package initialization. The system handles connection lifecycle management with automatic reconnection and provides structured JSON responses for all tool invocations.
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 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.
Roo Code is an AI coding assistant extension for Visual Studio Code that provides AI-powered code generation, explanation, refactoring, and debugging capabilities. It integrates with multiple LLM providers (OpenAI, Anthropic, Google Gemini, etc.) through a well-designed abstraction layer. The application features different modes (Code, Architect, Ask, Debug, Custom) for various tasks, file operations through AI, terminal integration, MCP (Model Context Protocol) support for extensible tooling, task persistence, and a chat interface for interacting with AI models. Built as a monorepo with pnpm workspaces, it consists of a core extension, webview-based UI, CLI application, and documentation site. While the original team has moved on to another project (Roomote), the README indicates a community team has stepped up to maintain and improve Roo Code.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
This repository implements a Model Context Protocol (MCP) server that exposes the QuickBooks Online API as tools for AI agents such as Claude Code. It provides 143 tools covering full CRUD and search operations across 29 entity types (Customer, Invoice, Bill, Vendor, Employee, Account, Item, JournalEntry, Deposit, Transfer, TimeActivity, etc.) and 11 financial reports (Balance Sheet, Profit & Loss, Cash Flow, Trial Balance, General Ledger, etc.). The architecture follows a clean separation between handler modules (wrapping the node-quickbooks library with OAuth authentication) and tool definitions (Zod schemas registered with the MCP server). A singleton QuickbooksClient manages OAuth 2.0 token refresh and persistence, while environment feature flags (QUICKBOOKS_DISABLE_WRITE/UPDATE/DELETE) suppress tool categories. The codebase is heavily tested with Jest (100% coverage enforced in CI) and uses modern TypeScript (ESM). It handles QBO-specific quirks such as automated sales tax (AST), sparse vs full updates, and fallback patterns (e.g., delete via void/inactive). Despite its broad coverage, the implementation is highly repetitive (87 handlers, 90 tools) with liberal use of `any` types and hand-rolled ambient declarations for missing upstream typings. The project is actively maintained with recent commits and detailed design documentation, though version numbers and test counts show minor drift between README and CHANGELOG. Overall, this is a comprehensive, production-grade integration that prioritizes completeness and correctness over elegance.