Continue is an open-source AI coding agent that provides chat, autocomplete, edit, and agent capabilities across VS Code, JetBrains IDEs, and a standalone CLI. The architecture centers on a shared TypeScript core (`core/`) that handles LLM interactions, context providers, tool definitions, indexing, and configuration management. This core is consumed by three frontends: a VS Code extension (`extensions/vscode/`), a JetBrains plugin (`extensions/intellij/`), and a CLI (`extensions/cli/`) with a React-based TUI. A separate React GUI (`gui/`) runs as a webview in the IDE extensions. The system supports 50+ LLM providers through a plugin architecture in `core/llm/llms/` and uses a YAML-based configuration system (`packages/config-yaml/`) with a Hub for sharing assistants. Codebase indexing uses a content-addressed Merkle tree approach with a Rust sync library (`sync/`). The repository is now read-only and deprecated as of the final 2.0.0 release, with the team recommending users migrate to the CLI.
Open-AutoGLM (Phone Agent) is an AI-powered mobile automation framework that uses vision-language models to understand phone screens and execute user tasks through automated touch, swipe, and text input operations. The system works by repeatedly capturing device screenshots, sending them to a vision model (AutoGLM-Phone-9B or compatible API), parsing the model's decision into actionable commands, and executing those commands via platform-specific debugging tools (ADB for Android, HDC for HarmonyOS, WebDriverAgent for iOS). The architecture employs a device factory pattern to abstract platform differences behind a unified interface, an OpenAI-compatible model client with streaming and performance metrics, and a command-based action handler that supports tap, type, swipe, launch, back, home, long press, and takeover operations. The repository is structured as both a CLI application and a Python library, with comprehensive configuration for 50+ Android apps, 60+ HarmonyOS apps, and 100+ iOS apps, along with bilingual system prompts (Chinese/English), configurable timing parameters, and callback hooks for sensitive operation confirmation and manual intervention. Notable features include remote debugging support, verbose step-by-step execution with model thinking output, and integration with third-party model hosting services.
ChatWiki is an open-source, multi-service AI chatbot and workflow automation platform primarily targeting the WeChat ecosystem. In production, it operates as a suite of Go microservices (chatwiki, message_service, code_run, websocket, plugin, llm_runner) behind a Gin web server, with a Vue 3 admin panel, separate mobile/PC/Electron frontends, and an embeddable SDK. The core functionality includes knowledge base management (document ingestion, chunking, vector storage with pgvector), a LogicFlow-based visual workflow builder, multi-channel messaging (WeChat Official Account, Mini Program, Feishu, DingTalk, Telegram, WhatsApp, LINE), and an AI agent framework called Clawbot with skill reuse. External dependencies include PostgreSQL (with pgvector and AGE graph extension), Redis, NSQ message queue, and optional Neo4j and E2B sandbox. While the system is primarily an application, it incorporates data-intensive components such as RAG pipelines, LLM request logging, and daily statistics, giving it a hybrid character.
SmallCode is an open-source AI coding assistant CLI designed to run locally on consumer hardware with small language models (8B–35B parameters). It provides a full-screen terminal UI with streaming output, tool execution, and multi-turn agent loops. The system compensates for small-model limitations through a context budget engine, forgiving JSON parser, patch-first editing, early-stop detection, and TODO-driven planning. It supports multiple LLM providers (Ollama, LM Studio, llama.cpp, OpenAI, Anthropic, DeepSeek) with automatic escalation to stronger models on hard failure. The architecture is a monolith agent loop with modular subsystems: a plugin system for tools, commands, and hooks; a skill system for reusable prompt templates; a knowledge injection system for contextual notes; a memory store with SQLite/FTS5; a RAG index for code snippet retrieval; and an MCP client/server for tool interoperability. The codebase includes a compiled MarrowScript cognition layer with typed prompts, output validation, and budget tracking, though the dual implementation (hand-ported JS alongside MarrowScript sources) introduces drift risk. Key entry points include bin/smallcode.js (main CLI), src/tui/fullscreen.js (zero-dependency TUI), and src/compiled/cognition/ (prompts, routers, validation). The agent loop orchestrates user input, model calls, tool dispatch, and improvement loops. The repository also includes benchmark harnesses, trace recording, evaluation runners, and a provider wizard for configuration. Despite being marked as 'dead' in the README, the codebase exhibits high craftsmanship in several reusable components, though the large feature surface and experimental nature suggest maintenance challenges.
Voquill is a cross-platform voice dictation and AI transcription application that allows users to dictate into any application with real-time speech recognition, AI post-processing, and an agent mode for automated tasks. The desktop app (Tauri + Rust + React) provides a native overlay, global hotkeys, and multiple transcription backends (local Whisper, cloud providers, enterprise). The enterprise edition includes a gateway service with PostgreSQL, admin panel, OIDC SSO, and custom STT/LLM providers. Mobile apps (Flutter) with keyboard extensions provide dictation on iOS and Android. The CLI tool offers headless dictation and agent functionality. The architecture is a monorepo with shared packages for types, utilities, voice AI integrations, and agent loop, demonstrating a well-structured, multi-platform application with significant hybrid characteristics due to extensive data pipelines for transcription and model management.
This repository is a large-scale educational resource and community showcase for building LLM-powered agents using the custom 'HelloAgents' framework. It is organized as a multi-chapter tutorial (16 chapters) covering agent fundamentals, tool use, memory systems, multi-agent protocols (MCP/A2A/ANP), context engineering, reinforcement learning (SFT→GRPO), and evaluation. Each chapter contains runnable code examples, and the repository also hosts 40+ community-contributed 'Co-creation-projects' that demonstrate real-world agent applications across domains including stock analysis, health record management, academic research, code assistance, game design, and data analysis. The architecture is not a single deployable system but a polyglot collection of independent projects, most following a FastAPI backend + Vue/React frontend pattern, with a shared dependency on the HelloAgents framework core. The primary data flow in each project is: user input → LLM reasoning loop (ReAct/Plan-and-Solve/Reflection) → tool execution (search, database, code execution, APIs) → memory/context update → response generation. External dependencies include OpenAI-compatible LLM APIs, search engines (Tavily, Brave, DuckDuckGo), vector stores (Qdrant, Milvus, Neo4j), and various domain-specific APIs (financial data, academic databases, weather). The codebase serves as both a learning path for agent development and a practical reference for common agent patterns, though quality varies significantly between the polished tutorial chapters and the prototype-level community projects.
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.
This repository is an educational collection of minimal, from-scratch implementations of core LLM and generative AI systems, maintained by DataWhale. It is not a single production application; rather, it is a set of self-contained 'Tiny' sub-projects covering a small LLM trained on TinyStories, a RAG pipeline, a ReAct agent, an LLM evaluation harness, a DDPM diffusion model, a Transformer, a GraphRAG system, and an image-based RAG pipeline. Each sub-project has its own README, requirements, and runnable code or notebooks, with heavy Chinese-language comments explaining the underlying theory. The code is intentionally simple and readable rather than production-hardened, and it serves as a teaching resource for understanding how these systems work internally.
DemoGPT is an open-source Python framework that provides two core capabilities: (1) an automatic Streamlit application generator that converts natural language descriptions into complete, runnable Streamlit apps through a multi-stage LLM pipeline (planning, task decomposition, code generation, assembly), and (2) the DemoGPT AgentHub, a modular library for building AI agents with built-in tools (web search, code execution, Wikipedia, weather, etc.), two agent types (ToolCallingAgent for single-step tasks, ReactAgent for multi-step reasoning), and a RAG (Retrieval Augmented Generation) system supporting Chroma, FAISS, and Pinecone vector stores. The codebase is primarily a library/application hybrid, with the Streamlit app acting as both a user interface and a demonstration of the generation pipeline. The architecture separates concerns into chains, prompts, task definitions, and controllers, but many components are tightly coupled to the specific generation pipeline. The AgentHub portion is more modular and reusable. Technical drift is medium: the code uses deprecated LangChain APIs (LLMChain, Chain.run), hardcodes older models like gpt-3.5-turbo-16k in some generated code, and has a broad dependency range. Maintenance appears active with recent commits and responsive issue triage, but the codebase would benefit from modernizing to LangChain's new LCEL syntax and updating default models.
This repository is a personal cookbook and project showcase centered on the MiniCPM family of large language models (MiniCPM, MiniCPM-V, MiniCPM3). It contains over a dozen distinct application projects, including multi-modal OCR + visual grounding (OCR_VG), cross-modal image-text search, ReAct-style agent planning (agent_auto_plan), MBTI personality role-play, low-memory RAG (4G_memory_rag), AWQ quantization, embedding extraction, SFT/DPO fine-tuning pipelines, and Windows agent demos. Each project includes source code, shell scripts, and accompanying Chinese/English tutorials in markdown format. The codebase is primarily a collection of independent, loosely coupled modules rather than a unified application. It demonstrates practical usage of MiniCPM models for fine-tuning, deployment with vLLM/Ollama/llama.cpp, and integration with LangChain. The quality is functional but inconsistent: many modules contain hardcoded paths, duplicated logic, and lack tests, yet several components (ReAct data generation, image slicing utilities, LangChain wrapper) exhibit sufficient isolation and craftsmanship to be reusable across projects. The repo is actively maintained with a recent commit, but dependency on unmerged forks and version-specific model files poses a medium technical drift risk.
This repository is the open-source CLI client for Amazon Q Developer (formerly CodeWhisperer), now deprecated in favor of the closed-source Kiro CLI. It is a Rust workspace with approximately 2000 files, building two main binaries: `q` (terminal chat assistant) and `qchat` (legacy chat binary). The codebase is dominated by auto-generated AWS SDK client crates (amzn-codewhisperer-client, amzn-codewhisperer-streaming-client, amzn-qdeveloper-streaming-client, amzn-consolas-client, amzn-toolkit-telemetry-client), which are Smithy-generated and checked in. Hand-written code includes the chat CLI interactive loop, an agent framework with MCP (Model Context Protocol) support, a semantic search client using local ONNX models (MiniLM) and BM25 indexing, authentication (OIDC with device grant flow), telemetry, and an OS abstraction layer. The architecture is essentially a monolithic CLI application with multiple supporting libraries. About 90% of the source files are generated code, which means the hand-crafted components are relatively small. The project was previously actively maintained but is now effectively archived; the README states only critical security fixes will be accepted.
Bert-VITS2 is a multilingual text-to-speech system based on VITS2 (Variational Inference Text-to-Speech with improved Transformer backbone). It supports Chinese, Japanese, and English synthesis with optional emotion conditioning via pre-trained models (WavLM, wav2vec2-emotion, CLAP). The codebase provides a complete pipeline: data preprocessing (resampling, text normalization, BERT feature extraction), multi-speaker training with distributed support, inference through a Gradio web UI or FastAPI server (hiyoriUI.py), and ONNX export for deployment. The architecture uses separate per-language BERT models for text encoding, a flow-based decoder, stochastic duration predictor, and multi-scale discriminators (including a WavLM-based discriminator). The repository includes numerous versioned subdirectories (oldVersion/, onnx_modules/) for backward compatibility with model versions 1.0.1 through 2.4, resulting in significant code duplication and maintenance overhead. The README explicitly states the project is no longer maintained and recommends the successor project Fish-Speech.