TiDB is a production-grade, open-source distributed SQL database with MySQL compatibility, horizontal scalability, strong consistency (ACID), and HTAP capabilities via TiKV (row store) and TiFlash (columnar store). The architecture separates compute (TiDB Server) from storage (TiKV/TiFlash) with PD for cluster management. Key entry points: cmd/tidb-server (SQL layer), lightning/cmd/tidb-lightning (TB-scale import), br/cmd/br (backup/restore), dumpling/cmd/dumpling (export). The codebase demonstrates exceptional craftsmanship with a modular design: the parser (pkg/parser) is a standalone MySQL-compatible SQL parser used by external projects; pkg/objstore provides a unified storage abstraction (S3/GCS/Azure/local/HDFS) with compression/encryption; pkg/dxf/framework implements a distributed execution framework with scheduler/task-executor/planner; pkg/timer provides distributed cron/interval scheduling with persistence; pkg/extension enables plugin-based authentication/session-hooks/custom-functions; pkg/util/chunk/arena/zeropool/mvmap/intset/bitmap provide high-performance columnar processing and memory management; pkg/expression uses code generation for vectorized SIMD evaluation; pkg/planner implements a Cascades-based cost-based optimizer with plan caching; pkg/ddl executes online schema changes via job-based distributed backfill with schema versioning; pkg/statistics maintains histograms/CMS/FM-sketch with auto-analyze priority queues. The repo includes comprehensive testing (unit, integration, realtikv, chaos) and modern Go practices (generics, interfaces, DI).
Qwen Code (formerly Gemini CLI) is an open-source, multi-platform AI coding assistant designed to operate in the terminal, web shell, desktop (Tauri), VS Code, JetBrains, and chat channels (DingTalk, WeChat, Slack, etc.). The architecture is a monorepo with ~30+ packages centered around a core library (`packages/core`) that provides agent runtime, tool orchestration, memory, MCP support, and telemetry. The primary entry points are the CLI (`packages/cli` with an Ink-based TUI), the web shell (`packages/web-shell`), and a daemon server (`packages/cli/src/serve/`) that exposes REST/SSE endpoints for session management, file editing, and sandboxed shell execution. The system supports multiple LLM providers (OpenAI, Anthropic, Gemini, DeepSeek, etc.) and features sub-agents, goal-oriented workflows, approval modes, browser automation (CUA driver in Rust), and a Java managed-agent server for enterprise deployments. Data flows are user-to-agent: user input enters via a client (CLI, web, IDE), is processed by the core agent loop, which invokes tools (shell, file system, LSP, MCP servers) and streams responses back. External dependencies include Node.js v22+, pnpm, and platform-specific native binaries (Rust CUA driver, Electron desktop). The codebase is actively maintained with daily commits, extensive integration tests, and CI/CD pipelines. While it is a software application, it includes telemetry modules and a few Python scripts for benchmark analysis, but no research-grade data pipelines or ML training code.
DeerFlow is an open-source, full-stack AI agent harness built on LangGraph/LangChain, providing a production-ready platform for building, deploying, and managing conversational AI agents. The system features a Python/FastAPI backend with a modular architecture that includes agent orchestration, long-term memory (DeerMem), sandboxed code execution, a skill system with static analysis (SkillScan), MCP (Model Context Protocol) tool integration, multi-channel IM support (Telegram, Slack, Discord, Lark, etc.), scheduled tasks, subagent batches, and a comprehensive authorization framework. The frontend is a Next.js/React workspace with real-time streaming, artifact management, and a terminal UI (TUI) for headless operation. The architecture follows a gateway pattern: the FastAPI gateway handles authentication (JWT, OAuth, PATs), routing, and SSE streaming, while the core harness package (`deerflow`) implements agent logic, middleware chains, and runtime components. Persistence uses SQLAlchemy with Alembic migrations, supporting both SQLite and PostgreSQL. The system is highly extensible via a Python extension API (`deerflow-extension-api`) and a plugin system for frontend surfaces. Deployment supports Docker Compose and Kubernetes (Helm chart). While primarily an application, DeerFlow includes research-oriented components such as memory eviction benchmarks, context snapshot evaluations, and tracing integrations (LangSmith, Langfuse, OpenTelemetry). The codebase demonstrates strong engineering practices with extensive unit tests, blocking IO regression tests, and contract tests, though its large feature surface and many configuration options introduce complexity and potential for drift between environments.
This repository is a curated collection of tips, scripts, and a Claude Code plugin (dx) that enhances developer workflows with Claude Code. It is primarily a knowledge base and tooling repository, not a standalone application. The core deliverable is the dx plugin, which bundles skills for GitHub Actions debugging, conversation half/quarter-cloning, context handoffs, Reddit/HN research, private GitHub search, and version checks. The repository also includes a custom status line script (context-bar.sh), a setup script for recommended configurations, and extensive markdown content documenting 49 tips for using Claude Code effectively. The architecture is a mix of bash scripts, skill definitions (markdown with YAML frontmatter), and a plugin manifest. The standout component is the half-clone-conversation.sh script, a 400+ line bash utility that clones Claude Code conversations with careful edge-case handling, cross-platform support (macOS, Linux, Windows Git Bash), and a comprehensive 19-test suite. The repository demonstrates high craftsmanship in its bash scripting, thorough testing, and detailed documentation of workarounds for platform limitations (e.g., Reddit's blocking, GitHub's private repo search).
This repository contains the official Helm charts for deploying SonarQube on Kubernetes, maintained by SonarSource. It provides two charts: `sonarqube` for standard (Community/Developer/Enterprise) deployments and `sonarqube-dce` for Data Center Edition with clustered search and application nodes. The charts are production-grade, supporting a wide range of Kubernetes features including StatefulSets, Deployments, Ingress, NetworkPolicies, PodDisruptionBudgets, Prometheus monitoring, Istio service mesh with strict mTLS, OpenShift integration, and autoscaling via HPA and KEDA. A distinguishing feature is the agentic AI subsystem: the charts deploy an orchestrator, hunter, and remediation agent runtimes, a Squid-based egress proxy for sandboxed runtime isolation, gVisor/Kata sandboxing, and an HKDF-based key derivation hook for secure inter-component communication. The repository also includes integrations for Azure and Google Cloud marketplaces, comprehensive CI/CD pipelines (build, sign, publish, compatibility tests), and migration scripts for PostgreSQL and ingress-nginx to Gateway API/Istio. The codebase demonstrates high craftsmanship in Helm template design, with extensive validation, test fixtures, and golden-file tests covering hundreds of configuration permutations.
AG2 is a production-grade Python framework for building multi-agent AI systems. It provides a unified agent abstraction with support for multiple LLM providers (OpenAI, Anthropic, Gemini, Mistral, Bedrock, Ollama, xAI, Z.AI, DashScope), protocol integrations (A2A, A2UI, MCP, ACP), and sandboxed code execution (Docker, Daytona, local). The architecture is event-driven with a modular middleware pipeline, dependency injection, and a streaming event bus. It includes a full evaluation suite with trace reconstruction, scorers, pairwise comparison, and result persistence. The network layer enables distributed agent coordination via a hub-and-channel model with WAL persistence, identity management, and transport-agnostic envelopes. The framework also supports real-time voice interaction, skills-based toolkits, knowledge stores, and human-in-the-loop workflows. While the surface area is large, the codebase demonstrates high craftsmanship with clean abstractions, protocol-based interfaces, and extensive test coverage across all modules.
The AIMLInterviews repository is primarily an interview preparation tool that centers around an MCP (Model Context Protocol) server. This server turns any MCP-compatible AI assistant into a spoiler-free interview coach by providing tools to list problems, give progressive hints, review answers, and generate learning or company-specific preparation plans. The server dynamically builds an in-memory catalog by scanning markdown files in the src/ and cn/ directories, extracting problems and sections based on heading patterns. Beyond the server, the repository contains extensive educational content including markdown guides, Jupyter notebooks for ML algorithm implementations, and solution code with tests, all aimed at AI/ML interview readiness.
Commonly is an open-source multi-agent collaboration platform where humans and AI agents work together in shared workspaces called 'pods'. The system provides real-time messaging, task management, agent runtime (native, hosted, or bring-your-own), marketplace for agent skills, and integrations with external chat platforms like Discord, Slack, Telegram, and GroupMe. The architecture is a full-stack monolith with separate external agent bridge services and a Cloudflare Workers-based agent runtime. The backend (Node.js/Express) uses a dual-database design (MongoDB for primary data, PostgreSQL for messages/tasks) with automatic sync. The frontend is a React SPA with a v2 design system. The CLI allows local agents to participate via device-code auth and polling. The MCP server provides standard tools for agents to interact with the platform. The codebase is well-structured with extensive test coverage (unit, integration, E2E), Architecture Decision Records (ADRs), and reusable packages for types, integration SDK, and MCP tools. Notable craftsmanship includes pluggable storage drivers, deterministic agent wake targeting, and a test utility that replicates the production PostgreSQL schema to catch DDL drift.
Debug-gym is a framework for developing and evaluating AI agents that perform interactive debugging of software. It provides a Gymnasium-inspired environment where agents can use tools like a debugger (pdb), file viewer, editor, and shell to inspect and modify code in order to fix bugs. The framework supports multiple execution backends (local, Docker, Kubernetes) to ensure isolation and reproducibility, and integrates with various LLM providers through a unified interface. The system is designed around a loop of observation, action, and feedback: the agent observes the current state (e.g., code, test output), selects a tool to apply (e.g., set a breakpoint, edit a file), and receives the outcome from the environment. This enables the creation of agents that can learn to debug or be evaluated on debugging benchmarks such as SWE-Bench and Mini-Nightmare. The framework also includes analysis tools for visualizing agent trajectories and logging experiment results, supporting both development and research use cases. Key architectural features include a plugin-based tool system, abstract terminal and LLM interfaces, and a secure workspace for code manipulation. These components are designed to be modular and extensible, allowing researchers and developers to plug in new tools, environments, or language models with minimal changes to the core loop.
AutoGen is a multi-agent AI framework originally from Microsoft Research, now in maintenance mode and succeeded by Microsoft Agent Framework. The codebase is a large monorepo containing Python packages (autogen-core, autogen-agentchat, autogen-ext, autogen-studio, agbench) and a .NET implementation (Microsoft.AutoGen.*), with Python as the primary language. The architecture is layered: Core provides event-driven agent runtime, message passing, and distributed infrastructure via gRPC; AgentChat offers higher-level multi-agent teams and patterns; Extensions integrate external services (OpenAI, Azure, MCP, GraphRAG, etc.); Studio is a FastAPI web UI with a Gatsby frontend for no-code agent prototyping. Key entry points include AssistantAgent, group chat managers, and various team orchestrators. The system relies heavily on LLM clients, Pydantic models, gRPC for distributed runtimes, and OpenTelemetry for tracing. Despite the maintenance mode status, the code shows solid engineering with clear separation of concerns, extensive test suites, and well-structured packages. However, the ecosystem is in transition, with active development shifted to the successor framework.
Solace Agent Mesh is a production-grade, full-stack platform for building, deploying, and managing event-driven multi-agent AI systems. It comprises a Python backend (FastAPI, Google ADK, SAC), a React/TypeScript web UI (chat, projects, workflows, prompts, scheduled tasks), a Click-based CLI, and a Docusaurus documentation site. The system uses a microservices-like architecture with separate gateway (HTTP/SSE), platform service (model configuration, storage), and agent components, all communicating via the Solace event broker and the A2A (Agent-to-Agent) protocol. Key entry points include the CLI (`solace-agent-mesh`), the web UI (`/chat`, `/projects`, `/workflows`), and the REST API (`/api/v1`). Data flows involve user requests via SSE, agent orchestration with workflow DAGs, tool execution (built-in, MCP, OpenAPI), artifact storage (S3/GCS/Azure/filesystem), and session persistence in SQL databases (SQLite/PostgreSQL/MySQL). External dependencies include a Solace broker, LLM endpoints (LiteLLM), optional databases, and cloud storage services. The repository is marked as deprecated (Development Status 7 – Inactive), with the new version being a desktop application.
This repository is an educational course on harness engineering for AI coding agents. It is a collection of lecture materials, code examples, and project templates that teach how to build environments, state management, verification, and control mechanisms for AI coding agents. The course is structured as 14 lectures and 8 projects, with a sample Electron knowledge-base app used as a running example. The repository is primarily documentation and educational content, with some reusable templates and scripts for harness creation and auditing.