OpenHands/OpenHands is the frontend application for the OpenHands AI agent platform, known as Agent Canvas. It is a React single-page application (SPA) built with Vite, TypeScript, Tailwind CSS, and React Router. The application provides a comprehensive user interface for interacting with AI coding agents (OpenHands, Claude Code, Codex, Gemini, or any ACP-compatible agent) via an agent server. It supports multiple backends (local self-hosted, cloud at app.all-hands.dev) with a backend registry that routes API calls accordingly. The UI includes a chat interface with real-time WebSocket event streaming, a conversation panel for managing multiple sessions, a file explorer with Monaco editor, terminal emulator, browser snapshot view, git integration (commits, diff viewer, push/pull), settings for LLM profiles, MCP servers, secrets, skills/plugins, and an automation dashboard for scheduled or event-driven agent runs. The application is also published as an npm package (@openhands/agent-canvas) for embedding in other applications, and supports Electron desktop builds. The architecture follows a modern React pattern with Zustand for client-side state management (conversations, events, UI preferences), TanStack React Query for server-state caching and synchronization, and react-i18next for internationalization. The backend abstraction layer is a key architectural feature: every service (settings, profiles, git, secrets, automations, etc.) branches on the active backend kind (local vs cloud) and delegates to either a direct SDK client (@openhands/typescript-client) or a cloud proxy (callCloudProxy). This dual-transport pattern is enforced by guard tests that prevent ad-hoc HTTP calls outside vetted files. The application also includes a manifest system for declarative automation setup, a tool visualizer registry for rendering agent tool calls (bash, file editor, search, task), and extensive mock infrastructure (MSW) for development and testing. Key entry points include the root layout (src/routes/root-layout.tsx) which provides the main shell with sidebar, command menu, and onboarding; the conversation main view (src/components/features/conversation/conversation-main/conversation-main.tsx) with resizable panels for chat and tabs; the settings pages (src/routes/settings.tsx) with schema-driven forms; and the automation dashboard (src/routes/automations-list.tsx). External dependencies include the agent server REST API, cloud proxy endpoints, @openhands/typescript-client SDK, @openhands/extensions for automation catalogs, and various UI libraries (HeroUI, framer-motion, xterm.js, Monaco editor). The codebase is actively maintained with over 84k stars, frequent commits, and a large test suite (Vitest unit tests, Playwright E2E tests, Stryker mutation testing).
gpt4free (g4f) is a large-scale, community-driven Python library that aggregates dozens of free AI providers (LLMs, image, audio, video) into a unified, OpenAI-compatible interface. It provides multiple access modes: a Python client library (sync/async), a FastAPI-based API server, a Flask web GUI, a CLI tool, a Model Context Protocol (MCP) server for tool calling, a browser extension, a Discord bot, an Android app, and a Go launcher. The architecture is provider-based: each AI service (e.g., ChatGPT, Gemini, DeepSeek, Copilot, Grok, Perplexity) is wrapped in an adapter class implementing a common `AsyncGeneratorProvider` interface. The system handles authentication via cookies, OAuth flows, HAR files, and browser automation (CDP/nodriver), and supports streaming, tool/function calling, image generation, audio synthesis, and web search. It is primarily an application for consuming free AI models, not a research or data pipeline project, though it includes some data-oriented utilities like token optimization and usage tracking.
One API is a production-ready OpenAI API gateway that aggregates 30+ LLM providers (OpenAI, Anthropic, Google Gemini, Azure, Baidu, Alibaba, Zhipu, Moonshot, DeepSeek, Ollama, etc.) behind a single OpenAI-compatible endpoint. The Go backend implements a sophisticated relay system with provider-specific adaptors that translate OpenAI-format requests to each provider's native API. It features token-based quota management with group/channel multipliers, load balancing across channels, automatic failover, channel health monitoring with metric-based auto-disable, and multi-node deployment with Redis synchronization. The React frontend (three themes: default, berry, air) provides admin dashboards for channel/token/user management, billing visualization, and system configuration. The codebase demonstrates strong engineering practices: clean adaptor pattern for provider extensibility, comprehensive middleware chain, batched database updates for performance, and well-structured configuration management.
FastGPT is a production-grade AI Agent building platform that enables users to create, deploy, and manage AI applications through a visual workflow editor. The system provides a full-stack solution including a Next.js frontend with Chakra UI, a comprehensive REST API layer, and a modular backend architecture. Core capabilities include a workflow engine with agent loops, tool calling, dataset (knowledge base) management with vector search, sandboxed code execution (JS/Python), multi-tenant team management with fine-grained permissions, billing and usage tracking, and integration with external platforms (WeChat, Feishu, Dingtalk, MCP). The platform is designed for both open-source community and commercial deployments, with feature gating via license activation. The codebase is organized as a monorepo with clear separation of concerns: shared types and constants in `packages/global`, business logic in `packages/service`, UI components in `packages/web`, data access layer in `packages/dal`, and separate services for sandbox execution and volume management. It relies on MongoDB, Redis, BullMQ, S3-compatible storage, and multiple vector database backends (PG, Milvus, OceanBase, SeekDB, OpenGauss). The architecture is predominantly monolithic with the main application as a Next.js app, but sandbox and volume manager run as independent services, indicating a hybrid monolith/microservices pattern.
The Vercel AI SDK is a comprehensive TypeScript monorepo providing a unified, provider-agnostic interface for building AI-powered applications. It abstracts interactions with dozens of LLM providers (OpenAI, Anthropic, Google, Mistral, Cohere, xAI, etc.) behind a consistent API for text generation, streaming, structured output, image/video generation, speech, transcription, embeddings, and tool calling. The architecture is modular: a core `ai` package exposes high-level functions (`generateText`, `streamText`, `generateImage`, `embed`, `transcribe`, `ToolLoopAgent`, `HarnessAgent`) and a middleware system, while separate `@ai-sdk/provider` packages define versioned model interfaces (v2–v4) and `@ai-sdk/provider-utils` provides shared utilities for schema validation, error handling, and HTTP. Each provider lives in its own package (e.g., `@ai-sdk/openai`, `@ai-sdk/anthropic`) with model-specific options and error handlers. The SDK also includes a harness/agent framework (`@ai-sdk/harness`) for integrating external coding agents (Claude Code, Codex, Cursor, GitHub Copilot, etc.) with sandboxed execution and workflow orchestration, plus UI integrations for React, Vue, Svelte, and Angular. Key data flows involve constructing prompts, calling provider APIs via fetch, streaming responses as Server-Sent Events or ReadableStreams, and transforming messages between model and UI formats. External dependencies include provider API endpoints, Zod for schema validation, and OpenTelemetry for telemetry.
This is the canonical implementation of OpenAI's Harmony response format, the structured prompt format used by the gpt-oss open-weight model series. The repository provides a high-performance Rust core for rendering conversations into token sequences and parsing model outputs back into structured messages. It supports multi-channel reasoning (analysis, commentary, final), tool/function calling with JSON Schema-defined parameters, structured outputs, and streaming incremental parsing. The library is packaged with first-class Python bindings via PyO3 and a JavaScript/WASM build for browser use. A Next.js demo visualizes the token-level rendering. The codebase demonstrates strong engineering: a custom BPE tokenizer (tiktoken) implementation in Rust, a streaming parser that gracefully handles partial UTF-8 sequences, and a JSON Schema-to-TypeScript converter for tool definitions. Tests are comprehensive with parity between Rust and Python test suites.
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.
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.
This repository implements a deep research assistant web application that combines large language models (LLMs) with web search capabilities to generate comprehensive research reports. Built with Next.js 15, React, and Tailwind CSS, it features a client-side interface for topic input and research workflow management, backed by API routes that proxy requests to external AI and search services to protect API keys. The system orchestrates an iterative research process: planning sub-queries, executing parallel searches across multiple providers (Tavily, Firecrawl, Exa, etc.), analyzing results with auto-review cycles, and generating cited final reports. Key architectural elements include Zustand-based state management with localForage persistence, a Model Context Protocol (MCP) server for standardized tool/resource exposure, PWA support for offline installation, and modular components for knowledge base management, file parsing, and real-time progress streaming via Server-Sent Events (SSE).
AutoGPT is a full-stack SaaS platform for building, deploying, and running AI agents. It provides a visual agent builder (blocks), a copilot chat interface that can generate and orchestrate agents from natural language, a marketplace for sharing agents and skills, team/experts management with scheduling and credential stacks, and a subscription billing system with Stripe. The architecture is a multi-service backend (FastAPI, PostgreSQL, Redis) with a Next.js frontend, supporting real-time WebSocket execution events, OAuth integrations with 45+ providers, and feature flags via LaunchDarkly and PostHog. The platform is dual-licensed (Polyform Shield for platform code, MIT for classic code) and supports both hosted SaaS and self-hosted deployment. The codebase is organized into two major areas: `autogpt_platform/` (the current platform) and `classic/` (legacy AutoGPT and Forge). The platform backend uses a block-based execution system where each integration (Google, Slack, GitHub, etc.) is a self-contained block with typed I/O schemas, cost tracking, and credential management. The frontend features a rich component library with dynamic form rendering (RJSF), responsive dialog/drawer patterns, and extensive state management via TanStack Query and Zustand. Key entry points include the copilot chat UI, the agent library, marketplace, team management, and admin panels. Primary data flows involve user input through the copilot or builder, which triggers graph execution via the execution manager, with events streamed over WebSocket. Credits are deducted per block execution, and billing is handled through Stripe subscriptions with trial management. Analytics events are sent to PostHog and DataFast for product metrics. The system relies on external dependencies including PostgreSQL (with pgvector), Redis, Stripe, LaunchDarkly, PostHog, Sentry, and numerous third-party APIs for integrations.
Open WebUI is a full-stack, self-hosted AI chat platform that provides a feature-rich interface for interacting with local and cloud-based large language models (Ollama, OpenAI-compatible APIs, Anthropic). The system is built as a monolith with a Python FastAPI backend and a Svelte (SvelteKit) frontend, deployed via Docker. It supports retrieval-augmented generation (RAG) with multiple vector database backends (Chroma, Qdrant, Milvus, pgvector, Elasticsearch, etc.), web search integration (20+ providers), document loading (PDF, DOCX, YouTube, web pages), and a plugin system for custom filters, actions, tools, and pipelines. Additional features include user/group management with granular access control, real-time collaboration via WebSockets, automations with RRULE scheduling, calendar, notes, channels, code execution (Pyodide/Jupyter), image generation (ComfyUI), voice/video calls, and comprehensive analytics. The architecture emphasizes extensibility through abstract base classes (vector DB, reranker, storage provider) and a valve-based configuration system for plugins.
OpenMontage is an open-source, agentic video production platform where an AI coding assistant (Claude Code, Cursor) orchestrates the entire pipeline. It provides a library of 100+ tools (video generation, audio, graphics, enhancement, analysis, avatar, subtitles) behind a scored provider selection layer, and 10+ production pipeline manifests (animated explainer, cinematic, documentary montage, talking head, etc.) that define stage order, approval gates, and tool assignments. The core architecture is a Python framework with a BaseTool class, ToolRegistry for auto-discovery, pipeline loader, checkpoint system, and a Remotion-based video composer. It also includes a Backlot living storyboard server for live production monitoring and an Ink Theater procedural puppetry engine. While primarily an application, it contains data/research elements such as ManimGL/ManimCE educational animation examples covering transformer internals, quantum mechanics, and ML concepts, as well as a CLIP-based corpus builder for documentary montage pipelines.
VoltAgent is a large TypeScript monorepo for building, deploying, observing, and evaluating AI agents. The core package provides an agent runtime with tool calling, memory, subagents, guardrails, workflow orchestration, MCP client integration, A2A protocol support, voice, and OpenTelemetry-based observability. Framework adapters expose this runtime as HTTP/SSE/WebSocket servers via Hono, Elysia, and serverless function providers, while a CLI scaffolds projects and manages VoltOps deployment/auth flows. The repo is fundamentally an application framework, though it contains hybrid data-oriented subsystems: a RAG package with many document chunking strategies, vector adapters, and BM25 search, plus evaluation/scoring packages used for LLM benchmark experiments.
Read Frog is a browser extension for AI-assisted language learning. It provides in-page translation, video subtitle translation, text-to-speech, and a selection toolbar with custom AI actions. The extension supports over 30 language model and translation providers, configurable via a unified provider interface, with features like automatic page translation, hover translation, and AI-powered note suggestions. The architecture is built on the WXT framework (MV3) for cross-browser compatibility, with a background service worker orchestrating translation queues, caching, and state management. The frontend uses React 19, Jotai for state, TanStack Query for data fetching, and a custom Base UI component library. The codebase is highly modular with extensive test coverage, a versioned configuration migration system (100+ schema versions), and sophisticated DOM manipulation for in-place translation.
This repository is a full-stack Next.js application that serves as the world's largest open-source prompt library for AI. It provides a platform for users to create, share, discover, and manage prompts for various AI models (ChatGPT, Claude, Gemini, etc.). The core functionality includes CRUD operations for prompts with types (text, image, video, audio, skill, taste), voting, commenting, versioning, change requests, collections, and moderation tools. It features AI-powered capabilities such as semantic search via OpenAI embeddings, prompt improvement, translation, quality checking, and media generation through plugin-based providers (Fal.ai, Wiro.ai). The application supports multi-tenancy for self-hosting with configurable branding, authentication plugins (OAuth, OIDC, GitHub, Apple, Google), and storage backends (S3, DO Spaces). Beyond the web app, it includes a CLI tool (packages/prompts.chat) for browsing and running prompts locally, a Raycast extension for quick access, and an MCP server for integration with AI coding assistants. Additionally, it bundles an interactive educational book on prompt engineering (28+ chapters) and a gamified kids learning section, both fully localized into 17 languages. The codebase is well-structured with a plugin registry pattern, configuration-driven design, and extensive use of modern Next.js patterns (App Router, server components, streaming).
This is a comprehensive educational course repository ('Generative AI for Beginners') containing 21 structured lessons covering the full spectrum of generative AI application development. While classified as an application repository due to its extensive runnable code examples across Python, JavaScript, TypeScript, and .NET, its primary purpose is pedagogical. The repository teaches practical patterns for building GenAI applications including: prompt engineering, chat applications, RAG/vector search, image generation, function calling, AI agents, fine-tuning, LLMOps, and responsible AI practices. Each lesson provides assignments and solutions for multiple LLM providers (Azure OpenAI, OpenAI, GitHub Models). The codebase demonstrates modern GenAI application patterns with a strong emphasis on multi-language implementation parity and accessibility through 40+ language translations. The shared/python utilities provide reusable helpers for API interactions, environment management, and input validation that could be extracted for production use.
CowAgent is a production-grade multi-agent AI assistant platform that routes messages from 12+ IM channels (WeChat, Feishu, Telegram, DingTalk, Slack, Discord, QQ, WeCom, web console, desktop Electron app) through a modular agent core. The core implements planning, tool use (bash, file editing, browser, web search, MCP, sub-agent delegation, scheduler, memory, vision), three-tier memory with vector embeddings and markdown-aware chunking, knowledge base management, skill system with SKILL.md manifests and a skill hub, self-evolution (idle-conversation review loop), and multi-agent team orchestration with peer transport. The architecture is a modular monolith: channel adapters normalize messages into a unified ChatMessage, the Bridge dispatches to per-agent/session model resolution, the Agent protocol (Task/AgentResult/AgentAction) drives the execution loop with streaming, cancellation, and steering, and all state persists to SQLite with incremental migration. Key entry points are app.py (startup orchestration), cli/cli.py (daemon lifecycle), channel/web/web_channel.py (HTTP API and SSE streaming), and the desktop Electron client (React/TypeScript with Zustand stores). External dependencies include LLM APIs (OpenAI, Claude, Gemini, DeepSeek, etc.), IM platform webhooks/SDKs, optional voice TTS/ASR providers, and MCP servers. The codebase demonstrates strong engineering practices with extensive regression tests (200+ test files), atomic file writes, thread-safe context propagation via ContextVar, and security guards for credential paths and SSRF.
AstrBot is a production-grade, multi-platform LLM chatbot framework and development platform. It connects to 10+ instant messaging platforms (QQ, Telegram, Discord, Slack, WeChat, Lark, etc.) via adapter pattern, integrates with 20+ LLM providers (OpenAI, Anthropic, Gemini, DashScope, etc.), and provides a plugin system (Stars) with command/regex/filter decorators. The architecture is a modular monolith: a FastAPI backend serves a Vue 3 dashboard for management, while a pipeline of stages processes incoming messages through waking checks, rate limiting, content safety, LLM interaction, and response delivery. It includes a knowledge base with RAG (FAISS vector store, chunking, hybrid retrieval), agent runners (Dify, Coze, DeerFlow), sandboxed code execution (computer use), TTS/STT, cron jobs, and a CLI. The codebase is well-structured with extensive test coverage, but its broad scope introduces some duplication and deprecated modules.
This repository is a comprehensive Node-RED package for building multi-platform chatbots with minimal coding. It provides a visual flow editor (Node-RED) with over 100 custom nodes for message handling, conversation management, AI integration (OpenAI, Dialogflow), and platform adapters for Telegram, Facebook Messenger, WhatsApp, Slack, Viber, Sinch, DeepChat, and more. The package also includes Mission Control, a React-based admin dashboard for managing users, content, messages, plugins, and device tracking, with a GraphQL API and WebSocket real-time updates. The architecture follows a middleware pattern (ChatExpress) for message normalization and platform abstraction, with a plugin system (code-plug) for extending the admin UI. While primarily an application, it includes some data persistence (SQLite via Sequelize) for chat logs, user records, and content management, but no data science or analytics pipelines.
This repository provides a production-ready, full-stack Retrieval-Augmented Generation (RAG) chat application built with Python FastAPI and React TypeScript. It demonstrates how to use Azure OpenAI (or OpenAI.com, or Ollama) to answer questions about data stored in Azure Database for PostgreSQL with the pgvector extension. The system supports both a simple RAG flow (embedding + direct search) and an advanced flow that uses OpenAI function calling to rewrite queries and apply column filters (brand, price). It features hybrid search combining full-text search and vector similarity via Reciprocal Rank Fusion. The backend is a monolith serving API endpoints and a React frontend, designed for deployment to Azure Container Apps using the Azure Developer CLI. The codebase includes comprehensive unit tests, end-to-end tests with Playwright, evaluation scripts, load testing with locust, and safety evaluation using Azure AI Red Teaming. The architecture is cleanly separated into reusable modules, making it a solid reference architecture for building RAG applications on Azure.