Google AI Edge Gallery is an Android application that serves as a showcase and playground for on-device AI models, primarily Gemma 4 and other LiteRT-compatible LLMs. It provides a rich set of interactive tasks including AI Chat, Prompt Lab, Ask Image, Audio Scribe, Tiny Garden (a mini-game powered by a 270M model), Mobile Actions (device control via function calling), and an Agent Skills system with MCP (Model Context Protocol) integration. The app manages the full lifecycle of on-device models: discovery (via HuggingFace), download, initialization, inference, and benchmarking. It features a plugin architecture via the CustomTask interface, allowing new tasks to be registered through Hilt dependency injection. Skills are defined as markdown instruction files paired with JavaScript functions executed in a WebView, enabling extensible tool use. The codebase is well-structured with Jetpack Compose UI, Proto DataStore persistence, Firebase Analytics, and a clean separation of concerns. It is a professional-grade demo application that demonstrates advanced on-device AI capabilities, though some areas (e.g., skill duplication, large ViewModels) show signs of rapid development.
This is a full-stack cultivation world simulator game (xianxia RPG) with a Python backend (FastAPI + asyncio) and a Vue 3 + TypeScript + PixiJS frontend, supported by an optional Electron desktop shell for Epic Games Store distribution. The simulation engine runs a month-by-month tick system orchestrating ~29 phases (lifecycle, actions, social, war, world events, etc.) producing emergent narratives driven by LLM calls (OpenAI/Anthropic compatible) for character decisions, story generation, world lore rewriting, and roleplay interactions. The codebase is heavily data-driven with static game configurations (sects, techniques, items, regions) loaded from CSV files and multi-language localization via gettext PO files. It exposes a public REST API (query/command) and WebSocket for real-time state updates, supports save/load with JSON snapshots and SQLite event storage, and includes comprehensive test coverage (pytest, vitest, Playwright) and CI/CD workflows. While the architecture shows strong engineering patterns (effect system, action registry, single-choice decision framework, phased simulation pipeline), it carries risks from tight coupling of global singleton registries, LLM dependency, and use of `eval` in effect conditions.
NanoFlow is a high-throughput LLM serving framework designed to optimize inference through intra-device parallelism and efficient resource utilization. It employs nano-batching (splitting requests at operation granularity) and asynchronous CPU scheduling to overlap compute, memory, and network operations within a single device. The framework supports tensor parallelism for multi-GPU deployment and includes advanced KV-cache management strategies, including offloading to SSDs to avoid recomputation. It is evaluated on models such as Llama2, Llama3, and Qwen2, demonstrating significant throughput improvements over baselines like TensorRT-LLM. The architecture is modular, comprising core components for execution and worker management, model-specific implementations, operation kernels with multiple backends (Torch, CUDA, etc.), KV-cache mechanisms, and utility functions for profiling and resource management. Key entry points include `run_llama3.py` for launching the service and various test scripts for multi-GPU scenarios. Data flows involve request processing through transformer layers, with overlapping of computation and communication via streams and asynchronous execution, managed by a topological executor. The framework relies on a complex dependency stack including NVIDIA CUDA, NCCL, CUTLASS, FlashInfer, MSCCL++, and Gurobi, which introduces maintenance challenges. However, it demonstrates strong engineering practices through reusable components such as the IOWrapper for tensor dependency management, a cross-platform profiler, and a linear programming-based buffer allocator. While active development continues, the repository faces challenges in dependency management and platform fragmentation, indicating a need for careful version control to maintain stability.
DeepZero is an automated vulnerability research pipeline engine, primarily targeting Windows kernel driver (BYOVD) analysis. It provides a highly concurrent, resumable orchestration framework where pipelines are defined declaratively in YAML. The engine supports stages: ingest, map (parallel analysis), reduce (aggregation), and bulk_map, with built-in fault tolerance, atomic state persistence, and live progress dashboards. It integrates external tools like Ghidra (headless decompilation), Semgrep (static analysis), LIEF (PE parsing), and LLM backends (LiteLLM, Claude Code) for exploitability assessment. The repository includes a full reference pipeline (loldrivers) and multiple language documentation sites. While primarily an application framework, it has strong data research characteristics due to its focus on binary corpus analysis and heuristic/AI assessment.
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.
This is the official Deno documentation repository powering docs.deno.com. It is a static documentation site built with Lume (Deno-native static site generator), with a custom server middleware stack (redirects, Google Analytics, API content-type routing, LLM file serving, markdown source access) deployed on Deno Deploy. The content corpus spans the Deno runtime CLI, Deno Deploy, Subhosting, Sandbox, Deno KV, lint rules, 100+ runnable code examples with structured JSDoc metadata, tutorials, and generated API references for Deno, Web, and Node.js APIs. The build pipeline includes multiple code-generation stages: API reference pages generated from TypeScript type definitions via deno doc with a content-hashed incremental cache, Orama search index generation with a clean FileSelector → MarkdownIndexer → Output pipeline, and LLM-friendly file generation (llms.txt, llms-full.txt, llms.json) with relevance scoring. CI enforces link validity, frontmatter freshness (last_modified), and sidebar constraints via Deno test suites.
This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.
TurboQuant Model is a Python library and CLI tool for near-lossless LLM weight quantization, implementing the TurboQuant algorithm from Zandieh et al. (2025). It provides a drop-in replacement for nn.Linear (TurboQuantLinear) that stores weights in packed 4-bit indices and dequantizes on-the-fly during matrix multiplication using fused GPU kernels (CuTile, Triton, Metal). The library supports single-pass 4-bit, multi-pass residual (e.g., 4+4), polar decomposition, and hash-based compression, achieving 4x compression vs bf16 with KLD as low as 0.002 nats. It includes a CLI for quantizing, evaluating, generating, and benchmarking HuggingFace models, with CPU offload for residual passes and advanced techniques like norm compression and entropy coding. The codebase is well-structured with comprehensive tests and benchmarks, though it targets cutting-edge CUDA 13.1+ and may have limited hardware compatibility.
GEO Optimizer is a Go library for Generative Engine Optimization that improves content visibility in AI search engines. It features a layered architecture with LLM abstraction, rule-based content scoring, and pluggable optimization strategies. The system optimizes content through a pipeline that applies strategies like structure enhancement, schema generation, and FAQ creation, using LLMs to generate optimized content while tracking improvements through scoring mechanisms. Key design patterns include the strategy interface for interchangeable optimizations and modular separation of concerns in the scoring system.
This repository is a comprehensive tutorial on building AI agent harnesses, structured as 17 progressive lessons. Each lesson introduces a single mechanism (tool use, permissions, hooks, planning, subagents, skill loading, context compaction, memory, task system, background tasks, cron scheduler, agent teams, MCP integration, workflow runtime, and goal loop) that extends a core agent loop without modifying it. The harness enables a language model (Claude) to perceive, reason, and act through tool interactions while managing context, permissions, and collaboration. The repository includes runnable Python implementations for each lesson and an interactive Next.js web application with visualizations for learning and experimentation.
PageIndex is a production-ready RAG framework that replaces vector databases with a reasoning-based, hierarchical tree index over documents. Its core innovation is the 'flash' pipeline: a sophisticated, LLM-free PDF structure extractor that uses character-level layout analysis, trie-based keyword matching, and heuristic classification to build a table of contents tree from PDFs in seconds. The system then enables agentic retrieval by feeding this tree to an LLM, which reasons over the hierarchy to find relevant pages without embedding or chunking. The repository provides a full Python SDK (PageIndexClient) with local and cloud modes, CLI tool, integrations with OpenAI Agents SDK, Anthropic SDK, and Claude Agent SDK, plus an MCP bridge for remote tool execution. While primarily an application, it contains a deep research-grade data processing pipeline (flash) with extensive multilingual dictionaries and layout analysis heuristics, giving it a hybrid character. The codebase is well-structured with clear module boundaries, extensive test coverage, and reusable patterns like the tool contract system and trie-based matching. However, it carries medium technical drift risk due to hardcoded thresholds, dependency on private APIs of LLM frameworks, and pdfium version sensitivity.
CopilotKit is a comprehensive SDK and framework designed to integrate AI agents into user interfaces across web, mobile, and chat platforms. It functions as a middleware layer connecting frontend UI components (React, Vue, Angular) with backend agent frameworks (LangGraph, CrewAI, PydanticAI, etc.). The core value proposition lies in its ability to synchronize state between the agent and the UI, support generative UI (A2UI) for dynamic component rendering, and facilitate human-in-the-loop workflows. The repository is structured as a monorepo containing core runtime packages, framework-specific adapters, and an extensive suite of integration showcases. The architecture relies on a centralized runtime (`@copilotkit/runtime`) that handles agent connections via SSE and manages tool execution. Frontend interactions are managed through hooks (`useCopilotKit`, `useAgent`) that subscribe to the runtime. The codebase demonstrates a polyglot approach, supporting Python, TypeScript, Java, and C# backends alongside multiple frontend frameworks. While the core SDK is well-structured, the repository exhibits significant code duplication across its 20+ integration showcases, which serve as both documentation and regression tests.
Onyx is a comprehensive enterprise AI platform that provides knowledge retrieval, chat, and document indexing across 50+ third-party sources. The codebase reveals a FastAPI backend with Celery workers, PostgreSQL with Alembic migrations, OpenSearch vector search, Redis caching, and a separate model server. The frontend is a Next.js application with a custom design system (opal), alongside React Native mobile app, Go CLI, Chrome extension, and an embeddable widget. The platform supports deep research, custom agents, MCP servers, sandboxed code execution (Craft), and enterprise features like SSO, SCIM, billing, and multi-tenancy. Architecture is well-structured with clean separation of concerns, but the large codebase shows some drift: platform duplication across web/mobile/CLI, extensive Alembic migration history, and lint debt. The connector framework and design system are high-quality reusable components.
mcp-agent is a Python framework for building, deploying, and serving AI agents that interact with the Model Context Protocol (MCP). In production, it provides a library and CLI toolkit that allows developers to compose agents using configurable LLM providers (OpenAI, Anthropic, Azure, Bedrock, Ollama, Google), connect to any MCP server (stdio, SSE, Websocket, Streamable HTTP), and orchestrate multi-step workflows with patterns like parallel fan-out/fan-in, router, orchestrator-worker, evaluator-optimizer, and swarm. The framework is architecture-agnostic, supporting both asyncio in-process execution and durable execution via Temporal for long-running, fault-tolerant agent loops. The system ships with a feature-rich CLI (mcp-agent) for local scaffolding, configuration, and cloud deployment to MCP Agent Cloud, including secret management, log tailing, and OAuth integration. Key entry points include the main application bootstrap (MCPApp), the Agent class (managing MCP server connections and LLM), workflow implementations in src/mcp_agent/workflows/, and the server module that exposes agents as MCP servers via FastMCP. The codebase is well-structured with clean abstractioons (ContextDependent, AugmentedLLM base), extensive testing (over 100 test files), and comprehensive observability through OpenTelemetry tracing, token counting, and structured logging. Use cases range from simple chat agents to complex research assistants, real estate analyts, and customer service desks with swarm routing. The framework is actively maintained with frequent commits, a large community, and is built to production standards.
This repository is a research codebase for training and evaluating draft models for speculative decoding, supporting three algorithms: DSpark, DFlash, and Eagle3. It provides a full pipeline from data preparation (downloading prompts, regenerating answers with a target model via SGLang, and precomputing a large binary cache of target hidden states) to distributed training with FSDP and BF16, and evaluation on standard LLM benchmarks (GSM8K, MATH500, AIME, HumanEval, etc.). The code is well-structured with reusable components for configuration, distributed utilities, checkpointing, metrics, and custom attention masks. While primarily a research artifact, it exhibits strong engineering practices and several modules that could be extracted for other large-scale ML projects. The repository is hybrid in nature: it contains both application-like training/evaluation scripts and data_research elements such as data pipelines and evaluation datasets.
MCP-UI is a monorepo SDK implementing the MCP Apps standard for rendering interactive UIs over the Model Context Protocol. It provides server-side tools (in TypeScript, Python, and Ruby) to create UI resources, and a client-side React SDK to render them in sandboxed iframes. The architecture centers on a secure double-iframe proxy pattern that isolates third-party HTML and external URLs, with JSON-RPC communication via AppBridge. The codebase is well-structured with comprehensive tests, semantic release automation, and cloudflare workers example, demonstrating strong engineering practices across multiple languages.
Text Embeddings Inference (TEI) is a production-grade inference server for open-source text embedding models, built in Rust with multiple backend implementations (Candle, Python, ONNX). The system exposes both HTTP (REST) and gRPC APIs supporting dense and sparse embeddings, reranking, sequence classification, and OpenAI-compatible endpoints. It features dynamic batching with cumulative sequence length management, flash attention optimization across CUDA compute capabilities, and comprehensive observability with Prometheus metrics and OpenTelemetry tracing. The architecture cleanly separates the router layer (HTTP/gRPC handling) from the core inference pipeline (tokenization, batching, backend dispatch) via the `Backend` trait, allowing seamless integration of different model backends and hardware targets including CPU, CUDA, ROCm, Intel, and ARM64. The codebase demonstrates strong engineering practices: modular neural network layer implementations (Linear, LayerNorm, RMSNorm, Rotary) reused across model architectures, snapshot-based regression testing for all supported models, and feature-gated builds for precise dependency control. The router provides production features such as CORS, API key authentication, request size limits, health checks, and graceful shutdown. The batching system (`Queue` struct) efficiently accumulates requests and dispatches them to the backend in configurable token-bucket sizes. While the engineering quality is high, the repository exhibits some maintenance risks: significant model duplication across `flash_` and non-flash variants for each architecture, patched upstream dependencies (candle, cudarc) that may diverge from official releases, and commented-out integration tests. The Python backend, wrapping a subprocess, introduces platform-dependent fragility, and the large number of hardware-specific Dockerfiles increases build complexity. Overall, TEI is a well-architected, actively maintained inference server suitable for production deployments, with reusable patterns in its backend abstraction, batch processing, and layer implementations.
This repository provides client-side integrations, tooling, and examples for Zep, a long-term memory platform for AI agents built on temporal knowledge graphs. It is not the Zep service itself but the ecosystem to use it. The codebase includes SDK packages for over a dozen AI agent frameworks (Google ADK, AutoGen, CrewAI, LangGraph, Pydantic AI, LiveKit, Mastra, Vercel AI SDK, Microsoft Agent Framework, Strands, AG2) in Python, TypeScript, and Go. Each integration follows a consistent pattern: out-of-band provisioning of users and threads (server-generated UUIDs), automatic context injection before each LLM call, and on-demand graph search tools. The repository also contains a standalone ingestion pipeline (zep-ingest) for bulk-loading historical data (Slack exports, emails, documents, transcripts) into Zep graphs, a Model Context Protocol (MCP) server exposing Zep graph tools, benchmarks (LoCoMo, LongMemEval) for evaluating long-term memory retrieval, and an evaluation harness for testing retrieval and question-answering accuracy. While primarily an application-focused repository, it includes data pipeline components and evaluation frameworks that give it a hybrid character.
Coz is a causal profiler for native code (C/C++, Rust, Go, Swift, Java) that uses virtual speedup experiments to identify which lines of code, if optimized, would most improve program throughput or latency. It operates by injecting a shared library (libcoz) via LD_PRELOAD or DYLD_INSERT_LIBRARIES, interposing synchronization primitives to track blocking and apply controlled delays on non-selected threads. The profiler outputs a JSON Lines profile that can be visualized with a built-in web viewer (D3.js scatter plots with loess smoothing) or analyzed via CLI. It includes an AI-assisted feature for suggesting progress point placement and optimization advice. The architecture is a hybrid: a core runtime library in C++ with language bindings for Rust, Go, Swift, and Java (JVMTI agent), plus a Python CLI that orchestrates profiling, visualization, and LLM integration. The project is a research artifact from UMass Amherst, published at SOSP 2015, and remains actively developed with modern features like streaming AI support.
An Obsidian plugin (Gemini Scribe) that integrates multiple AI providers (Gemini, Anthropic, OpenAI, Ollama) for chat, agent-based automation, and knowledge management within the Obsidian vault. The system provides a modular architecture with an agent loop that executes tools (vault operations, web search, RAG semantic search, image generation, deep research) with confirmation flows and diff previews. It features a declarative settings UI with per-feature provider routing, a skill system following the agentskills.io spec, MCP server integration, scheduled tasks, lifecycle hooks, and an evaluation harness for benchmarking agent behavior. The codebase demonstrates strong engineering practices: thorough unit testing (73%+ line coverage), clean module boundaries with leaf modules to prevent circular imports, and reusable patterns like typed event buses, retry decorators, and cancellation-safe streaming.