The Entire CLI (`entire`) is a production-grade command-line tool that integrates AI coding agents (Claude Code, Codex, Gemini CLI, Cursor, Copilot, OpenCode, Factory AI Droid, Pi) with Git workflows. It captures session transcripts, token usage, file changes, and agent prompts as git-backed checkpoints, enabling traceability, review, and collaboration on AI-assisted development. The CLI provides commands for session management (`session`, `resume`, `clean`), checkpoint inspection (`checkpoint list`, `checkpoint policy`), multi-agent code review (`review`, `investigate`), authentication (`auth`, `login`), and project management (`project`, `grant`). It operates as a git remote helper (`git-remote-entire`) for pushing/pulling checkpoint data via the Entire data plane. Architecturally, the system is a modular Go CLI built on Cobra, with pluggable backends for checkpoint storage (git-refs and git-branch) and agent integration. Each agent has a dedicated package under `cmd/entire/cli/agent/` that implements hooks, transcript parsing, and lifecycle management. Security is a first-class concern: file operations use `os.Root` to prevent symlink escapes (`osroot`), session IDs are validated against path traversal (`validation`), and a configurable redaction pipeline strips secrets from transcripts (`redact`). The system uses OpenAPI-generated client code (`internal/coreapi`) for control plane communication and supports multi-region deployment via cross-jurisdictional HTTP clients. The codebase demonstrates high craftsmanship with clean package boundaries, extensive test coverage (unit, integration, e2e, and benchmarks), and well-documented interfaces for extensibility. Reusable components include atomic JSON file writing, cross-platform process management (`execx`), advisory file locking (`flock`), and process liveness detection (`proclive`). The review subsystem provides a framework for multi-agent code review with structured findings, which could be adapted for other automated review workflows. While the codebase is well-maintained and actively developed, the tight coupling to many agent-specific formats and the dual checkpoint backend add maintenance surface area and complexity.
Notte is a full-stack web AI agent framework and browser automation SDK. The implementation is a multi-package Python monorepo: notte-core provides shared domain models, actions, error hierarchies, telemetry, and configuration; notte-browser implements Playwright/Patchright browser control, DOM snapshotting, scraping pipelines, and form-filling heuristics; notte-agent contains the LLM-driven agent loop, deterministic fallback, and workflow execution; notte-llm wraps LiteLLM with structured completions, retries, and a file-based prompt library; notte-sdk is the client for the hosted Notte cloud API with remote sessions, agents, vaults, personas, and serverless functions; notte-integrations adds notifiers and third-party CDP session providers. Primary entry points are `NotteClient` for cloud usage, `NotteSession` for local browser automation, and `Agent`/`AgentFallback` for autonomous and hybrid scripted-agent workflows.
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.
This is a production-grade Kubernetes operator written in Go that manages the full lifecycle of MariaDB databases (including Galera clusters, asynchronous replication, and MaxScale proxies) on Kubernetes. It implements a custom resource definition (CRD) pattern with controllers, validating webhooks, and sidecar agents to handle deployment, scaling, TLS, backups (logical and physical), point-in-time recovery, and SQL resource management (users, grants, databases). The operator is built with controller-runtime and kubebuilder, and includes extensive integration tests using Ginkgo/Gomega and envtest. Its architecture is modular, with separate controllers for each CRD, reusable builder packages for Kubernetes objects, and well-factored utility packages for data structures, PKI, condition management, and statefulset helpers. The codebase is actively maintained, with a rich set of examples, Helm charts, and multi-cluster support. It does not include any data research or analytics components.
PocketRisu is a self-hosted AI roleplay chat platform, forked from RisuAI. It runs as a Node.js server with a Svelte 5 frontend, accessed via browser. The system supports multiple AI providers (OpenAI, Anthropic, Google Gemini, etc.) through a pluggable adapter pattern, and includes character management, lorebooks, plugins, MCP (Model Context Protocol) tools, translation, TTS, image generation, and a comprehensive data-driven settings system. Data is stored in SQLite with content-defined chunking for large values, and the architecture is a monolith with a client-server split: the server handles persistence, backup, asset manifests, and model job processing; the client handles UI, state management, and direct AI API calls (with optional server-side proxy). Key entry points include src/main.ts (client bootstrap), server/node/server.cjs (server), src/ts/storage/database.svelte.ts (central store), and src/ts/process/request/ (AI request handling). External dependencies include Node.js, SQLite, various AI provider APIs, MCP servers, and browser APIs (File System Access, IndexedDB). The codebase is well-tested with unit and integration tests, and features a sophisticated plugin system with sandboxed execution, a model preset registry with remote sync, and a chat delta sync mechanism for efficient data transfer.
This is a Next.js 16 starter template that combines Nextra 4 for documentation, Tailwind CSS 4 for styling, and comprehensive internationalization support. It provides a foundation for building documentation sites, blogs, and marketing landing pages with features like dark/light theme switching, responsive design, SEO optimizations, and pre-built UI components. The architecture centers around Next.js App Router with language-specific routing ([lang] segment), MDX-driven content in src/content/{lang}/, and a modular component system. Key strengths include a type-safe i18n system with compile-time checking, high-performance UI components like ScrollProgressBar (which uses requestAnimationFrame and lerp for smooth animation) and LinkPreview (which combines Radix UI hover cards with Framer Motion physics-based animations), and thoughtful separation of concerns between content, presentation, and logic. The template is actively maintained and stays current with modern web technologies.
Ask Molty is a Cloudflare Worker that serves as a documentation agent for OpenClaw. It accepts user questions via a chat API, builds a read-only workspace from pre-indexed documentation, source code, and GitHub issues/PRs, then uses OpenAI's chat models with tool calls (search_workspace, read_workspace, list_workspace, run_shell) to answer grounded in the workspace. The worker handles authentication via OpenClaw ID or GitHub session cookies, serves artifact files (e.g., github-search.jsonl) via a proxy, and includes robust error handling for timeouts, malformed data, and streaming. The codebase is well-structured with separate modules for auth, prompt, retrieval, and types, and includes a comprehensive smoke test suite that mocks network interactions to verify behavior.
Taste-skill is not a software application in the traditional sense; it is a portable library of AI-agent 'skills' - extremely detailed Markdown instruction files (SKILL.md) distributed via the `npx skills add` CLI (Vercel agent-skills spec) and a .claude-plugin marketplace. The repo's product is the prompt content itself: 13 frontend design-direction skills that agents like Claude Code, Codex, and ChatGPT load to avoid generic 'AI slop' output. The flagship is `taste-skill` v2 (`design-taste-frontend`), a ~5000-line instruction document that codifies anti-pattern bans (zero em-dashes, no section-number eyebrows, no three-equal-card rows), a brief-inference protocol, design-system mapping to official packages (Fluent, Carbon, Polaris, GOV.UK), canonical GSAP/scroll-reactive code skeletons, and a hard pre-flight checklist with mechanical pass/fail criteria. It is complemented by image-generation-only skills (brandkit, imagegen-frontend-web/mobile) that produce reference comps for downstream coding agents, plus variant skills (brutalist, minimalist, soft, stitch, output-enforcement). The repository also contains a `research/laziness/` folder documenting LLM output-truncation causes and remediation, and a small set of Node/Sharp image-processing scripts used to build the README assets. Those scripts contain one genuinely valuable, extractable algorithm: a flood-fill outer-background removal with auto-cropping to content bounds. The scripts are one-off (hardcoded `C:/Users/User/Downloads` source paths, tightly coupled to specific sponsor assets), so they are not drop-in reusable without adaptation, but the background-removal technique itself is portable. This is a content/instruction repository rather than a codebase; software-engineering quality bars (tests, CI) do not apply. Its craftsmanship lives in the rigor, specificity, and mechanical enforcement of the prompt files, which is exceptional for the prompt-engineering domain. The active development cadence, current dependency references (Tailwind v4, Motion/react, React Server Components), and 92k-star traction confirm it is the leading project in its niche.
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.
MemPalace is a local-first, persistent memory system for AI agents. It stores and retrieves structured 'drawers' (memory chunks) organized into wings, rooms, and closets, with hybrid vector+BM25 search, a temporal knowledge graph, and agent coordination via a logstream. The system provides a CLI, an MCP server (both full and lightweight), and shell hooks for integration with Claude Code, Cursor, Codex, Antigravity, and DeepSeek Harness. It supports multiple storage backends (ChromaDB, SQLite exact, pgvector, Qdrant, Milvus, and a Rust native backend) and offers privacy-first operation with no mandatory API keys or internet connectivity. Architecturally, MemPalace is a modular Python package with optional Rust acceleration (PyO3). The core is split into several packages: `mempalace.cli` (fragment-exec-based CLI), `mempalace.mcp_server` (MCP tool server), `mempalace.palace` (palace operations and locks), `mempalace.searcher` (hybrid ranking and filters), and `mempalace.backends` (pluggable storage). The knowledge graph is SQLite-backed with temporal validity windows. A write-ahead log provides an audit trail. The system uses a hybrid logical clock (HLC) for causal ordering and a source adapter system for pluggable ingest. Although primarily an application, the project includes extensive benchmarking and model evaluation suites, giving it a mild hybrid character.
CrewAI is a large, actively maintained Python framework for orchestrating autonomous AI agents and event-driven multi-agent workflows. The codebase is organized as a monorepo with six libraries under `lib/`: `crewai` (core framework), `crewai-cli` (CLI), `crewai-tools` (tool integrations), `crewai-files` (multimodal file handling), `crewai-core` (shared utilities), and `devtools` (release tooling). The core provides two complementary abstractions — Crews for autonomous role-based agent collaboration and Flows for precise, state-machine-driven orchestration — that can be combined in production applications. The framework supports numerous LLM providers (OpenAI, Anthropic, Gemini, Azure, Bedrock, and many more), a wide array of built-in and third-party tools, MCP/A2A protocol integrations, human-in-the-loop flows, and enterprise deployment via the AMP Suite. The repository has extensive test coverage (pytest with VCR cassettes), strong static analysis (ruff, mypy, bandit), and a well-defined release process. While the framework code is solid and well-structured, the repository is dominated by auto-generated documentation files (thousands of `.mdx` files across multiple versions and languages) and repetitive tool README templates, which inflate the file count but contribute little reusable engineering value.
GPT Researcher is an autonomous research agent that produces comprehensive, cited reports from web and local sources. In production, it operates as a full-stack web application: a FastAPI backend (main.py, backend/server/app.py) exposes REST and WebSocket endpoints for initiating research, streaming progress, and retrieving reports. A Next.js frontend (frontend/nextjs/) provides the user interface, and a lightweight vanilla JS frontend (frontend/scripts.js) is also available. The core Python package (gpt_researcher/) can be used programmatically via the GPTResearcher class or as a CLI tool (cli.py). Architecture follows a planner-executor pattern: given a research task, the system generates sub-queries, executes them in parallel across 20+ search engine wrappers (Tavily, Google, Bing, Brave, DuckDuckGo, ArXiv, PubMed, etc.), scrapes the resulting URLs using multiple backends (BeautifulSoup, browser automation, PyMuPDF, FireCrawl), filters and compresses the context using embedding or keyword-based methods, and finally generates a structured report with citations. The system supports multiple report types (summary, detailed, deep research) and multi-agent orchestrations (LangGraph, AG2) for more complex workflows. Key data flows: user query to sub-query generation (LLM) to parallel search across configured retrievers to URL scraping to context compression to source curation to report generation (LLM) to output as markdown/PDF/DOCX. Real-time progress is streamed via WebSocket. External dependencies include LLM providers (OpenAI, Anthropic, Google, Ollama, etc.), search APIs (Tavily, SerpAPI, etc.), and optional services (MCP servers, vector stores, image generation APIs). The codebase demonstrates strong engineering practices: extensive test suite (200+ tests), plugin architecture for retrievers, configurable context filters, cost tracking, and evaluation frameworks for quality and hallucination. However, it carries maintenance risks from its large dependency surface, multiple parallel agent implementations, and reliance on rapidly-changing external APIs.
PaperQA2 is an agentic retrieval-augmented generation (RAG) system for scientific literature. It answers questions by searching, indexing, and analyzing PDFs, text documents, and clinical trials using a multi-step agent workflow. The system integrates with multiple scholarly metadata providers (Crossref, Semantic Scholar, OpenAlex, Unpaywall) for DOI resolution, citation counts, retraction detection, and journal quality scoring. It supports multiple LLM backends via LiteLLM, pluggable PDF readers (pypdf, PyMuPDF, Docling, Nemotron), and vector stores (Numpy, Qdrant). The architecture is a Python library with a CLI (`pqa`), featuring a hierarchical Pydantic settings system, an agent framework with tool selection and memory, and a plugin-based document parsing pipeline. While primarily an application, it is research-backed with published benchmarks (LitQA2, LFRQA) and includes config presets for different quality/performance trade-offs.
This is a production-grade, AI-powered code review automation tool that integrates with multiple version control systems (GitHub, GitLab, Bitbucket Cloud/Server, Azure DevOps, Gitea) and multiple LLM providers (OpenAI, Claude, Gemini, Ollama, Bedrock, OpenRouter, Azure OpenAI). The system is implemented as a Python async CLI application, packaged as a Docker image, and includes CI/CD integration templates for GitHub Actions, GitLab CI, Jenkins, Bitbucket Pipelines, and Azure Pipelines. Architecturally, it follows a clean layered design: a CLI layer (Typer) drives commands; a configuration layer (Pydantic Settings with multiple file/env sources) manages nested settings for LLM, VCS, agent, review, artifacts, and logging; a service layer orchestrates the review process through runners, gateways, and internal services (prompt building, diff analysis, policy enforcement, cost tracking, artifact persistence); and a client layer provides unified abstractions for VCS and LLM providers with provider-specific implementations. The tool supports multiple review modes: inline comments on specific code lines, summary comments on the entire PR, context review (full repository exploration via an optional agent loop), and reply to existing comments. The agent loop uses a ReAct pattern with tool execution (shell commands like `rg`, `cat`, `git`) to gather deeper context, with duplicate detection and context limits. A dry-run mode allows testing without posting to VCS. The system also includes a hook service for lifecycle events, cost tracking per request, and optional artifact saving of LLM interactions. Key strengths include extensive test coverage (unit tests with fake clients and fixtures), generic reusable components (HTTP client with retry, pagination helpers, diff parser, LLM output JSON parser, cost service), and a well-structured configuration system that supports discriminated unions for provider-specific settings. The codebase is actively maintained, uses modern Python async patterns, and demonstrates high craftsmanship in its abstraction layers and separation of concerns.
Swarm is a production-grade Swift-native agent runtime framework for building multi-agent conversational systems with type-safe tools, on-device Apple Foundation Models, composable workflows, memory, guardrails, and observability. The architecture is modular: core agent execution (Agent, Workflow, Job) with pluggable inference providers (Foundation Models, OpenAI-compatible, mock), memory backends (conversation, sliding window, summary, vector, persistent via SwiftData or Wax SQLite), and tool integration (built-in tools, MCP protocol, web search). Key entry points include Agent.run()/stream(), Workflow.execute(), and the SwarmMCPServerService for exposing tools via MCP. Data flows involve agent turns with tool calls, memory retrieval/consolidation, and durable workflow checkpointing via the HiveCore deterministic runtime. External dependencies include Apple FoundationModels (macOS 26+), swift-log, swift-syntax (for macros), and optional Wax (SQLite vector store) and OpenTelemetry SDK. The framework emphasizes compile-time safety via @Tool and @Agent macros, and provides resilience patterns (retry, fallback, circuit breaker, rate limiting) and observability (tracing, metrics, OpenTelemetry).
This repository is a Home Assistant custom component that adds OpenAI-compatible text-to-speech to a HA instance. It is distributed as an integration for HACS and registered as a config-flow service integration. In production it exposes TTS entities, an `openai_tts.say` service that announces text to media players with automatic volume save/restore and optional chimes, and an `openai_tts.set_api_key` service for credential rotation. The architecture is a HA integration split into focused modules: config flow and profile subentries, a streaming TTS engine, a sentence-level audio pipelining layer, an ffmpeg-based loudness pipeline, push-driven API health tracking, cache and validation logic, repairs, diagnostics, and a large announcement orchestration module. Provider support is driven by declarative presets for OpenAI, Mistral, Groq, Lemonfox, Kokoro, Chatterbox, and custom OpenAI-compatible endpoints, and the code intentionally modern-targets HA's streaming TTS contract rather than retaining legacy fallback paths.
The UTCP-MCP Bridge is a multi-language implementation that exposes Universal Tool Calling Protocol (UTCP) tools as Model Context Protocol (MCP) tools, enabling MCP clients like Claude Desktop to discover and call any UTCP-registered tool. The system consists of MCP servers (in Node.js/TypeScript, Python, Rust, and a web-based implementation) that initialize a UTCP client, register providers from configuration, and expose standard MCP tools for tool management (register/deregister manuals, call tools, search tools, list tools, get tool info, and get required variables). The architecture cleanly separates MCP server concerns from UTCP client operations, with each language implementation following similar patterns but idiomatic to its ecosystem. The bridge handles MCP specification nuances like proper content block preservation for binary data and provides dynamic provider management through REST APIs in the web UI.
This repository is not a traditional application but a distribution and runtime for 'Superpowers' – a collection of structured skill definitions (markdown files with YAML frontmatter) that shape the behavior of AI coding agents (Claude Code, Codex, Gemini CLI, etc.). The core product is a set of carefully crafted instructions (e.g., subagent-driven development, brainstorming, systematic debugging, test-driven development) plus per-harness bootstrap injection scripts, plugin manifests, and a small zero-dependency visual companion server. The project's architecture is a multi-harness plugin system: each agent platform gets a plugin manifest and a session-start hook that injects the bootstrap skill, enabling the agent to invoke Superpowers skills via a 'Skill' tool or native equivalents. The repository demonstrates high engineering craftsmanship in its skill design (rationalization tables, Red Flags, evidence-driven iteration) and in the accompanying scripts (polyglot hook runner, secure WebSocket server, worktree isolation). It is actively maintained with frequent releases and a formal design/plan/specification process. However, the primary value is in the skill content rather than reusable software components; reuse outside the Superpowers ecosystem requires adapting the bootstrap injection and tool mappings for a new harness.
This repository is the official companion code for the book *Build a Large Language Model (From Scratch)* by Sebastian Raschka (105k+ stars). It provides a step-by-step, educational implementation of GPT-2 and its modern variants (Llama 3, Qwen3, Gemma 3/4, Olmo3) entirely in PyTorch, organized by book chapters (2–7 plus appendices). The codebase is a mix of Jupyter notebooks for interactive learning and Python modules that form a reusable pip package (`llms-from-scratch`), accompanied by extensive CI/CD pipelines, unit tests, and performance analysis scripts. Architecturally, the core is a modular transformer library that includes tokenization (BPE, tiktoken, custom), multi-head attention with multiple variants (GQA, MLA, SWA, DSA, cross-layer KV sharing), feedforward blocks, normalization (LayerNorm, RMSNorm), and LoRA. The code supports pretraining from scratch, classification finetuning (spam, IMDB), instruction finetuning (with/without LoRA), and preference tuning (DPO). It can load pretrained weights from OpenAI, Hugging Face, and local checkpoints. The package exposes clean interfaces (`GPTModel`, `generate`, `train_model_simple`) and includes bonus materials for KV cache implementations, mixture-of-experts, memory estimators, and user interfaces (Chainlit). While primarily educational, the code exhibits production-quality patterns: isolated attention modules, configurable model architecture, well-structured training loops, and robust weight loading with shape validation. The repository is actively maintained with recent commits, cross-platform support (Linux, macOS, Windows), and a strong emphasis on reproducibility (fixed seeds, deterministic settings, environment definitions via pixi/uv/conda). Duplication exists across bonus notebooks and a few hardcoded paths, but the core package and test suite are well-coordinated.
Deep-Live-Cam is a real-time face swapping desktop application that uses ONNX Runtime with insightface models to swap faces in live webcam feeds or pre-recorded images/videos. The core pipeline involves face detection (RetinaFace), face recognition (ArcFace), and a face swap model (inswapper_128), with optional face enhancement via GFPGAN or GPEN-BFR ONNX models. The application provides a PySide6 GUI for selecting source/target faces, toggling options (mouth mask, many faces, Poisson blending, sharpening, temporal interpolation), and managing camera selection. It supports multiple execution providers: CUDA (NVIDIA), CoreML (Apple Silicon), DirectML (AMD/Intel), OpenVINO (Intel), and CPU fallback. Video processing can run in-memory via FFmpeg pipes (avoiding disk I/O) or via traditional frame extraction to PNG files. The architecture is modular: frame processors (face swapper, enhancers) follow a common interface, and the codebase includes optimizations for Apple Silicon (CoreML subgraph optimization, Pad decomposition, Shape/Gather folding) and CUDA (IO binding, CUDA graphs). The project also includes a benchmark pipeline and unit tests for core components.