This is a comprehensive academic paper downloader application that retrieves PDFs from over 20 sources, including open access repositories (Unpaywall, OpenAlex, arXiv, EuropePMC), publisher APIs (Elsevier, Springer Nature TDM, Wiley), and institutional access channels (WebVPN, CARSI, EZProxy). It is distributed as a Python CLI tool (Typer), an MCP server (FastMCP) for AI agent integration, and a web UI, with support for batch processing, browser automation (Playwright/CloakBrowser), Tor, and FlareSolverr for anti-bot bypass. The architecture is centered on a multi-lane scheduling pipeline (publisher-specific, OA, grey sources, institutional) with tiered parallel racing, adaptive scoring, and negative caching. It includes publisher-specific PDF routing strategies for 19+ publishers, a registry pattern for extensibility, and a CookieStore for persistent session management. The application also provides citation export (BibTeX/RIS/Endnote), Zotero integration, and markdown conversion. While the primary character is a software application, it exhibits hybrid data-research traits through its extensive data source integration, metadata enrichment (Crossref, Semantic Scholar), and caching layer. The codebase is well-structured with clear modules but suffers from some code duplication (notably an institutional subpackage that mirrors core modules) and hardcoded paths, reducing maintainability. Overall, it is a sophisticated, production-ready tool that demonstrates advanced patterns in browser automation and anti-crawl techniques.
Agentic Awesome Skills is a curated marketplace infrastructure for AI coding agent skills—instructional playbooks (SKILL.md files) with accompanying scripts and assets. The repository provides a multi-platform distribution system supporting Claude Code, Cursor, Gemini CLI, Codex CLI, Kiro, and others. It includes a React+Vite web application for browsing, searching, and installing skills; a CLI and MCP server for local agent integration; and a comprehensive validation, security scanning, and release pipeline. The codebase implements a transaction engine with deterministic content addressing (canonical JSON + SHA-256), durable state management, and schema-validated skill installation, forming a robust foundation for agent-owned tool selection and workflow planning. While the core infrastructure (AAS v1 library, MCP server, catalog search) demonstrates high craftsmanship and reusability, the repository is hampered by massive file duplication: identical skill scripts and governance modules appear under `skills/`, `plugins/agentic-awesome-skills/`, and `plugins/agentic-awesome-skills-claude/`, creating synchronization risk. Some skills contain hardcoded paths or incomplete boilerplate. The repository is actively maintained with CI/CD, automated audits, and security scrutiny, though the sheer volume of 2,474+ skills imposes ongoing maintenance burden. Overall, it is a well-engineered, production-quality skill distribution platform with notable reusable design patterns.
Vibe Kanban is a full-stack, dual-deployment application (local Tauri desktop app + remote cloud service) that combines Kanban-style issue tracking with AI coding agent workspaces. The local backend is a Rust Axum server backed by SQLite, while the remote backend uses PostgreSQL with ElectricSQL for real-time sync. The system allows users to create projects, manage issues, and launch coding workspaces where AI agents (Claude, Codex, Gemini, Copilot, etc.) execute tasks on isolated branches with preview servers, git operations, and automated code review. It includes a relay tunnel system for remote host pairing, a WebRTC transport for low-latency streaming, and an MCP server for external tool integration. The frontend is built with React, Tailwind CSS, and a shared component library, supporting localization in 7 languages. The project is officially sunsetting, as stated in the README, but the codebase remains a substantial example of a modern Rust/TypeScript monorepo with real-time collaboration, AI executor abstraction, and multi-platform delivery.
This repository is a TypeScript monorepo for an AI-powered autonomous web browsing agent called 'open-browser'. It consists of three packages: core library (open-browser), CLI (@open-browser/cli), and sandbox (@open-browser/sandbox). The core library orchestrates an agent loop that uses Playwright to control a Chromium browser, extracts DOM state via CDP, sends it to an LLM (OpenAI, Anthropic, Google) which decides actions in structured JSON, and executes those actions via a CommandExecutor. The system supports vision screenshots, extended thinking, compact mode, planning, evaluation, replay recording, and MCP server integration. The CLI provides commands for running agents, interactive sessions, and direct browser manipulation. The sandbox provides resource-limited execution. Key entry points include the Agent class, Viewport browser session, CommandExecutor, and BridgeServer. External dependencies include Playwright, Vercel AI SDK, Zod, Turndown, and various LLM provider SDKs. The architecture follows a modular monorepo with clear separation of concerns, event-driven communication via EventHub, and a guard/watchdog pattern for browser lifecycle management. The codebase demonstrates strong engineering practices with extensive use of Zod schemas for structured outputs, a command catalog pattern, and comprehensive telemetry and cost tracking.
callx is a Node.js CLI tool that serves as a unified runtime switcher and configuration manager for AI coding assistants like Claude Code and OpenCode. It allows users to define multiple AI 'sprites' (agent configurations) with different providers, models, skills, and MCP servers, all managed through a single `~/.config/callx` directory. The system provides two entry points: the `call` command for quick invocation of sprites, and `callcli`, a full-featured TUI built with Ink and React for managing providers, sprites, skills, MCP servers, and git worktrees. The architecture is a monolith CLI application with a clear separation between runtime utilities (`lib/runtime.js`), git worktree helpers (`lib/worktree.js`), and the TUI frontend (`lib/callcli/app.mjs`). The runtime module handles all configuration file I/O, provider normalization, skill syncing via symlinks, and MCP server configuration generation for both Claude Code and OpenCode formats. The TUI provides a Monokai-themed interface with list-based navigation, field-level editing, and multi-select for skills and MCP servers. Key data flows include: reading `providers.json` for API keys and endpoints, reading sprite `config.json` for CLI type and model selection, syncing skill packs from `skillpacks/` to sprite-specific `skills/` directories via symlinks, and generating MCP configuration files from `mcpservers/` definitions. The tool also integrates with git worktrees, providing an interactive flow to create new branches and worktrees with suggested naming conventions. External dependencies are minimal: Node.js 18+, Ink and React for the TUI, and the target AI CLI tools (opencode-ai, @anthropic-ai/claude-code).
This is a comprehensive test automation framework for 1C:Enterprise 8.3 managed applications, named 'Tester'. It provides a full suite of tools for creating, managing, executing, and reporting on UI and business logic test scenarios. The repository contains three main integrated components: (1) a native C++ add-in (addon/) that exposes low-level capabilities like screenshot capture, regex, file watching, metadata parsing, and a Model Context Protocol (MCP) server for AI agent integration; (2) a 1C:Enterprise configuration (tester/) with catalogs, documents, common modules, and forms implementing scenario lifecycle management, execution engine with debugging, job scheduling, error logging, and report generation; and (3) a VS Code extension (addon.vscode/) for editing scenarios with syntax highlighting, code completion, and direct test execution. The system supports distributed execution via agent computers, file system synchronization with external editors (EDT, VS Code), version control through git integration, and role-based access control. Notable patterns include a bilingual API (English/Russian method aliases), a fluent assertion library, a custom JSON diff engine for UI state comparison, and an XML log transpiler that converts recorded user actions into executable scripts. Documentation is extensive, including a separate wiki site built with MkDocs. The repository is actively maintained with frequent releases, though it shows medium technical drift due to some outdated dependencies in the VS Code extension and use of platform-specific workarounds.
GitMCP is a remote Model Context Protocol (MCP) server running on Cloudflare Workers that turns any public GitHub repository (or GitHub Pages site) into live, searchable documentation for AI tools. AI clients like Claude Desktop, Cursor, and MCP Inspector connect to gitmcp.io/{owner}/{repo} over SSE with OAuth and receive repo-specific MCP tools: fetch_<repo>_documentation, search_<repo>_documentation, search_<repo>_code, and fetch_url_content. The ingestion pipeline fetches llms.txt first (falling back to README.md, then landing-page HTML converted via html-to-md), chunks it with markdown-aware chunkers (heading-context-preserving, code-block and list aware), and indexes it into Cloudflare Vectorize using a dependency-free deterministic embedder built from hashing plus term-frequency/keyword extraction, with a hybrid ranking that blends normalized vector similarity (60%) with keyword/proximity/heading heuristics (40%). Robots.txt is parsed, cached, and respected before external fetches - an uncommon discipline for doc scrapers. The codebase also ships a full web chat application (React Router v7, Tailwind, shadcn/ui, AI SDK) with model selection across OpenAI/Anthropic/Groq/XAI, MCP server management, and a streaming chat API endpoint. Architecturally, the MCP server itself is implemented as a Cloudflare Durable Object (MyMCP), with KV caching (TTL with jitter to prevent cache stampedes), R2 storage for pre-generated docs, a queue for background ingestion, Vectorize for semantic search, Analytics Engine for usage metrics, and GitHub API integration with rate-limit tracking and retry/backoff. A notable design pattern is the RepoHandler strategy interface: per-repo families (three.js, react-router) provide customized tool sets, doc-fetch strategies, and search behavior while the generic handler covers all other repos, including a static mapping of library names to their canonical doc repos. Testing is solid: Vitest unit tests cover tool registration, repo handlers, URL parsing, caching, and three.js utilities (with snapshots), and Playwright e2e tests run against a locally-provisioned R2 environment; CI runs both on push/PR. Weaknesses and drift: the embedding layer is explicitly a prototype-grade stand-in ('In a production environment, you would use a proper embedding service like OpenAI') and will produce weak semantic results; badge.ts contains ~96k tokens of hardcoded escaped SVG logo paths (extreme maintenance fragility); several hardcoded host URLs (git-mcp.idosalomon.workers.dev, CHAT_API_URL) baked into source; a generated-type mismatch where Vectorize metadata filters use $gt at runtime but generated types only declare $eq/$ne; vector re-ingestion only deletes the first 100 stale chunks (repos with more chunks accumulate orphans); and the frontend uses React Router v7's unstable_viteEnvironmentApi. These are prototype-velocity marks rather than architectural rot - the core strategy/caching/testing structure is genuinely well-built.
mdui is a comprehensive Web Component library implementing Material Design 3 (Material You). It provides over 30 reusable UI components (buttons, dialogs, navigation, forms, etc.) built with Lit, supporting dynamic color theming, dark/light modes, and localization across 60+ languages. The library is framework-agnostic and can be used directly in HTML or with any frontend framework. It includes a bundled jQuery-like utility (@mdui/jq) for DOM manipulation, a Model Context Protocol (MCP) server for AI-assisted development tooling, and IDE plugins for VS Code and JetBrains. The codebase is well-structured with a monorepo managed by pnpm, featuring shared mixins, controllers, and decorators that promote consistency across components. The project is actively maintained with recent commits, comprehensive documentation, and a large demo site.
This is the server platform for the XiaoZhi (小智) ESP32 voice-assistant ecosystem: a large multi-component monorepo that turns low-cost ESP32 hardware into an AI voice assistant. The core is a Python asyncio service (main/xiaozhi-server) that maintains WebSocket connections with devices and runs a real-time audio pipeline — VAD, ASR, intent/LLM orchestration, tool calling, and TTS — streaming audio back to the device. Device onboarding, OTA firmware updates, and the WebSocket handshake are partly in the Python server and partly in a Java Spring Boot management API (main/manager-api) backed by MySQL + Redis, which exposes a broad admin surface: users, devices, agents, model-provider configuration (LLM/ASR/TTS/VAD/memory/intent), RAGFlow-backed knowledge bases, voice clone, voiceprint, chat history, and MCP tool management. Two management frontends exist (a Vue 2 web console and a uni-app/Vue 3 mobile app), plus a Live2D digital-human web client and an offline theme generator for firmware assets. It is an application, not a research repository — no notebooks, data pipelines, or analytical datasets; the 'data' features (RAG ingestion, voice cloning, chat-history reporting, performance testers) are all operational application features.
This is a Model Context Protocol (MCP) server that enables AI agents to interact with the Godot game engine. It provides tools to launch the Godot editor, run projects in debug mode, capture console output, manage scenes, add nodes, load sprites, export mesh libraries, and handle UID references for Godot 4.4+. The server is a single TypeScript process that communicates via stdio, spawning Godot processes for complex operations and using a bundled GDScript for scene manipulation. It includes path traversal protection, class name validation to prevent arbitrary script instantiation, and flexible parameter naming (supports both camelCase and snake_case). The project is well-structured, with clear error handling and debug logging, making it suitable for integration with AI coding assistants like Claude, Cline, and Cursor.
The repository is an MCP (Model Context Protocol) server designed to interact with Xiaohongshu (Little Red Book) social media platform. It exposes a set of tools via the MCP standard that enable AI assistants to perform actions like checking cookie validity, retrieving home feed, searching notes, fetching note content and comments, and posting comments. The server requires a valid Xiaohongshu cookie obtained from web login for authentication. Architecturally, the application follows a modular design separating the MCP transport layer (implemented using FastMCP in `xhs_mcp/__main__.py`) from the business logic handled by API clients. Two API implementations exist: the original (`xhs_mcp/api/xhs_api.py`) uses curl_cffi and execjs to reverse-engineer and execute JavaScript for generating required anti-bot signatures (X-S, X-T headers), while the v2 version (`xhs_mcp/api/xhs_api_v2.py`) employs Playwright for JavaScript execution in a browser context. The MCP server dynamically registers tools from these API modules, manages server lifecycle with proper resource cleanup, and handles authentication errors by prompting cookie validation. The project demonstrates solid engineering practices with clear separation of concerns, async/await patterns for non-blocking I/O, and environment-based configuration for sensitive data. However, it faces inherent technical drift due to reliance on Xiaohongshu's private undocumented APIs, which are subject to frequent changes that break signature generation mechanisms. The dual API implementations indicate ongoing efforts to adapt to such changes, though they introduce maintenance overhead. Dependency management is modern using uv and Python 3.12, but version constraints (e.g., curl-cffi<0.14.0) may pose future compatibility risks.
This repository is the full-stack personal website of Max Stoiber (mxstbr.com), built with Next.js 16, TailwindCSS, and TypeScript. It serves a dual role: a public-facing blog and digital garden, and a private family productivity suite called 'MaxOS' that simulates a Windows 98 desktop environment. The public side includes MDX blog posts, Hashnode-synced notes, an RSS feed, and an investing page. The private side is a full-featured operating system shell with iframe-based apps: a calendar (with events stored in Redis), a finance portfolio tracker (pulling from Tiingo), a reminder system, a todo list, and a sophisticated chore management system (Chores2) for tracking kids' chores, rewards, and completions. The Chores2 subsystem is the most architecturally rich part of the codebase. It uses a layered domain-driven design with types, domain logic, commands, a service layer, a repository (with both in-memory and Redis implementations using compare-and-set transactions), MCP tool definitions for AI integration, and a notification outbox pattern for reliable Telegram delivery. The system supports time-window-based chore scheduling, period bonuses, approval workflows, and undo. It was recently rebuilt from a legacy version, with all features documented and verified in design docs. The codebase also integrates AI heavily: a Clippy chat assistant (powered by OpenAI) accessible via web and Telegram, and an MCP server that exposes tools for calendar, chores, and finance, enabling ChatGPT and other AI agents to read and mutate family data. The architecture is modern, with server actions, streaming, and Redis-backed state. However, the repo shows signs of being a single-developer project with some duplication (two active chore board UIs) and hardcoded secrets (parental PIN).
This repository is a comprehensive .NET SDK for integrating with the WeChat (Weixin) ecosystem, covering Official Accounts (MP), Enterprise WeChat (Work), Mini Programs (WxOpen), Open Platform, and WeChat Pay (TenPay V2/V3). It provides strongly-typed API wrappers for hundreds of WeChat endpoints, message/event handling with a rich class hierarchy, caching abstractions, and utilities for signature verification, encryption, and OAuth. The architecture is a modular monolith with separate packages per platform, sample MVC applications for .NET 4.5/8/10, and dependency injection support via registration modules. Key entry points include static API classes (e.g., `CommonJsonSend.Send<T>()`), message handler base classes, and container-based token management. The SDK also includes experimental components such as an MCP server for AI tool integration and a browser plugin for development assistance. The codebase demonstrates consistent patterns: base result classes with error code handling, container caching with capability flags, extension methods for payment notification decryption, and automatic access token refresh via `ApiHandlerWapper.TryCommonApi`. While the SDK is actively maintained and supports modern .NET versions, it carries some technical debt from legacy .NET 4.x support, duplicated DTOs across platforms, and incomplete test coverage that relies on live credentials. Overall, it is a functional and widely-used SDK (8900+ stars) with solid engineering practices but room for improvement in code consolidation and test automation.
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.
CoexistAI is a research assistant framework implemented as a FastAPI application that provides a suite of API endpoints for web search, YouTube and Reddit retrieval, geospatial mapping, git repository analysis, text-to-speech/podcast generation, and knowledge base creation from local files or crawled websites. It integrates with an MCP server for agentic workflows and supports pluggable LLMs (Google, OpenAI, Ollama, local) and embedders (Google, HuggingFace, Infinity). The architecture is monolithic with modular utility functions, containerized via Docker with a companion SearxNG instance for privacy-respecting search. The codebase demonstrates a hybrid nature: while primarily an application with explicit API entry points, its core purpose is to support research and data-gathering tasks, making it equally relevant for data research scenarios. Configuration is centralized, and the system includes a web-based admin UI for runtime parameter changes. Active development is evident from recent commits and numerous utility modules, though some global mutable state and fallback-heavy code indicate where the system has evolved rapidly.
CodexMCP is a lightweight MCP (Model Context Protocol) server that acts as a bridge between Claude Code and OpenAI's Codex CLI. It exposes a single `codex` tool that allows MCP clients to invoke Codex CLI sessions programmatically over stdio. The server handles session persistence via UUIDs, supports multi-turn conversations, parallel execution, and sandboxed workspace modes. The core implementation consists of a subprocess wrapper that streams JSON lines from Codex's `exec` command, parses agent messages and thread IDs, and returns structured results. It also includes Windows-specific command-line escaping to handle prompt injection safely. The codebase is minimal (two source modules plus a CLI entry point) but demonstrates solid patterns for wrapping external CLI tools in the MCP protocol, with graceful shutdown handling and error reporting. It does not include tests or CI/CD configuration, but the architecture is clean and focused.
The JetBrains MCP Proxy Server is a Node.js application that acts as a middleware between MCP-compatible clients (such as Claude Desktop or VS Code) and JetBrains IDEs equipped with the MCP Server plugin. It discovers the IDE's MCP endpoint by scanning a predefined port range (63342-63352) or using a specified IDE_PORT environment variable, caches the endpoint, and periodically verifies its availability. The proxy then exposes an MCP server over stdio, forwarding tool listing and tool invocation requests to the IDE's HTTP-based MCP endpoint. The implementation uses the Model Context Protocol SDK for stdio communication and node-fetch for HTTP requests, featuring error handling, logging, and endpoint caching with periodic refresh.
This repository is primarily an extensive educational compendium covering mathematics, computer science, and artificial intelligence from first principles to state-of-the-art topics. It contains over 100 markdown files organized into 20 chapters, each with detailed explanations, diagrams, and interactive coding tasks (primarily in Python/JAX). The repo also includes auxiliary tooling: a MkDocs-based documentation site with MathJax and a Pyodide in-browser Python runner that includes a JAX compatibility shim, and a TypeScript MCP (Model Context Protocol) server that provides programmatic access to the compendium content for AI assistants. While the vast majority of the repository is educational content rather than runnable software, the MCP server and interactive runner are functional application components. The compendium is well-structured and current, but the code examples are pedagogical (simplified, not production-ready) and the JAX shim is a fragile polyfill. The project is not a data research pipeline—it contains no datasets, experiment logs, or trained models.