OGX (formerly Llama Stack) is a production-grade, open-source AI inference platform that provides a drop-in replacement for the OpenAI API. It is a multi-provider API gateway supporting chat completions, embeddings, the Responses API (agentic turns with tool use), vector stores, file processing, conversations, prompts, skills, and connectors. The system is built on a clean provider plugin architecture where inline (built-in) and remote providers (30+ including Anthropic, Bedrock, Gemini, Ollama, vLLM, NVIDIA) are registered via ProviderSpec and dynamically routed. The FastAPI server auto-discovers API protocols and generates routes with telemetry (OpenTelemetry), authentication, multi-tenancy, and ABAC access control. The repository includes a Next.js admin UI, a Python CLI, OpenAPI-generated client SDKs (Python, TypeScript), benchmarking tools (RAG eval, vertical scaling), and comprehensive integration tests with recording/replay. It is designed for self-hosted or cloud deployment with Kubernetes and Docker support.
MindsHub Cowork is a platform superproject that orchestrates four independent submodules into a unified AI workspace for knowledge workers. The repository itself contains no application logic — it's a pure orchestration layer using git submodules (frontend: Electron/Vite app, backend/core_api: FastAPI server, backend/core_agent: Anton autonomous agent, backend/data-vault: data engine). The superproject provides a sophisticated developer workflow via its Makefile: per-developer branch selection through a gitignored dev.env, dual run paths (local source with hot-reload vs uv-tool-installed desktop server) that follow the same refs, deliberate pin management via 'make pin'/'make baseline', and a nuclear 'make flush' for complete environment reset. Submodules are configured with 'ignore = all' so branch work never pollutes the parent git status. The Docker setup uses multi-stage builds with uv for Python and nginx for the web SPA. The REST API (documented in docs/api.html) exposes conversations, projects, artifacts, schedules, files, connectors, memories, skills, scratchpads, and search — all backed by a local SQLite database. This is hybrid in that it manages both a desktop (Electron) and web (SPA) frontend against the same API, but the dominant character is application orchestration.
Onyx is a full-stack AI enterprise search and chat platform. The backend is a Python/FastAPI service with Celery workers, PostgreSQL, Redis, and a vector search engine (Vespa/OpenSearch). It ingests documents from 50+ external connectors (Google Drive, Slack, Confluence, Jira, SharePoint, etc.), runs a chunking/embedding/indexing pipeline, and serves RAG chat and search to multiple frontends: Next.js web app, React Native/Expo mobile app, Tauri desktop wrapper, Go CLI, an embeddable web widget, and a Terraform provider. It also includes an MCP server, deep research flows, sandboxed code-execution sessions (Craft), prompt caching, SSO/OAuth/SCIM multi-tenancy, rate limiting, and an admin analytics console. The repository has a hybrid character because it contains substantial data-engineering machinery (indexing pipelines, chunkers, embedding providers, evals) but the dominant identity is a production application rather than a research project.
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.
53AIHub is an open-source enterprise AI knowledge management and agent orchestration platform. The codebase reveals a multi-tenant SaaS/self-hosted system that allows organizations to build, deploy, and operate AI agents across multiple backends (OpenAI, Coze, Dify, Gemini, etc.), manage knowledge bases with full RAG pipelines (document parsing, chunking, embedding, graph extraction, wiki generation), record and transcribe meetings with insight extraction, and provide a unified search and chat interface. The architecture is a Go monolith backend using Gin and GORM, with a monorepo frontend comprising three React apps (admin console, end-user portal, and embeddable agent plugin) sharing a common business logic and component library. Data flows center on document ingestion pipelines, real-time agent relay with tool execution, and recording/speech processing. The system integrates with vector stores (Qdrant), Elasticsearch, Redis, and various LLM providers. While primarily an application, it contains substantial data processing pipelines characteristic of a data_research project, particularly the RAG and recording insight modules.
OS1 (nokodo) is a full-stack AI-powered collaborative platform combining autonomous agents, deep research, real-time collaboration, and extensible tooling in a self-hostable workspace. The system features a modular architecture with FastAPI/Python backend, Svelte 5 frontend, and separate admin console, communicating via REST API, WebSocket, and Redis pub/sub. Core capabilities include AI agent construction with tool integration (web search, code execution, file operations), persistent memory system with vector search, real-time document editing, and comprehensive resource management (threads, notes, files, projects, calendars, reminders). The platform emphasizes extensibility through plugin systems for tools, filters, and hooks, with production-ready deployment via Docker Compose.
KAITO (Kubernetes AI Toolchain Operator) is a production-grade Kubernetes operator that automates the full lifecycle of large language model (LLM) deployments. It reconciles custom resources—Workspace, InferenceSet, RAGEngine, MultiRoleInference, and ModelMirror—to provision GPU nodes, download or stream model weights from HuggingFace or Azure Blob, run inference servers (vLLM or HuggingFace Transformers), perform fine-tuning (LoRA/QLoRA), and manage RAG pipelines with vector stores (FAISS/Qdrant) and output guardrails. The operator supports multi-cloud node provisioning (Azure GPU provisioner, Karpenter, BYO) and features like prefill-decode disaggregation, model mirroring, and benchmark metrics collection. The system architecture is a collection of Go controllers using controller-runtime, with admission webhooks for CRD validation and a set of Python services for inference, tuning, and RAG. Key entry points: cmd/workspace/main.go (workspace controller), cmd/ragengine/main.go (RAG engine controller), presets/workspace/inference/vllm/inference_api.py (vLLM inference service), and presets/ragengine/main.py (RAG FastAPI service). Data flows: user creates a Workspace CR → controller creates NodeClaims, provisions GPU nodes, downloads/streams model weights → creates StatefulSet with inference service → exposes Service. For RAG: user creates RAGEngine CR → controller deploys vector store and inference service → user indexes documents via API → chat completions with retrieval augmentation. Notable engineering patterns include a plugin-based model registry (KaitoModelRegister), a generator pattern (WorkspaceGeneratorContext with chainable manifest modifiers), an abstract NodeProvisioner interface with multiple implementations, and a hot-reloadable guardrails system with Prometheus metrics. The codebase has extensive test coverage: unit tests with mock clients, integration tests for controllers, and end-to-end tests using Ginkgo that validate real cluster behavior. The project is actively maintained with frequent commits, CI/CD workflows, and versioned documentation.
GeekAI is a full-stack, production-grade AI creation platform providing chat, image generation (MidJourney, DALL-E, Jimeng, Stable Diffusion), video generation (Sora, Veo, Keling, MiniMax, Wan, Doubao), music generation (Suno), and PPT creation. The system features a Go + Gin backend with MySQL/Redis persistence and a Vue 3 (Element Plus/Vant) frontend supporting both desktop and mobile interfaces. It includes a complete monetization framework with power credits, multiple payment gateways (Alipay, WeChat Pay, EPay), user invite/reward system, and an administrative dashboard for managing users, models, API keys, and system configurations. Architecturally, the backend follows a layered pattern with handlers, services, and stores. Key design patterns include an adapter pattern for video generation providers (allowing easy addition of new AI services), a factory pattern for OSS uploaders (local, MinIO, Qiniu, Aliyun, Tencent), and an abstraction for payment integrations. Async tasks (e.g., image generation, video creation) are handled via Redis-based queues with polling for status updates. The frontend uses Pinia stores for state management and includes reusable UI components like custom tabs, file uploaders, and parameter builders. The codebase demonstrates solid engineering with moderate code quality. It has several genuinely reusable patterns (video adapter, upload manager, payment service interface) but also exhibits duplication between desktop and mobile views, some hardcoded configuration, and reliance on many third-party SDKs that may drift over time. While not exceptionally polished, it is a fully functional commercial-grade platform suitable for deployment and customization.
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 a comprehensive AI inference and application platform built primarily on Java (Spring Boot) and Vue.js. It provides a suite of SDKs for computer vision (face recognition, OCR, segmentation), NLP (text embedding, translation), and AIGC (Stable Diffusion, ControlNet). The architecture is modular, separating inference logic (SDKs) from application logic (Web Apps, Desktop Apps, API Platform). It utilizes Deep Java Library (DJL) for model inference, integrating PyTorch and ONNX Runtime backends. The system supports multimodal search (Face, Image, Code, Text) using vector databases like Milvus. Hybridity: While it contains AI research components (models, inference), the codebase is structured as a production-ready software platform with web interfaces, APIs, and desktop wrappers, rather than a research notebook collection. It functions as a monorepo containing multiple distinct Spring Boot applications and Vue.js frontends, each serving a specific AI task (e.g., face_search, image_search, aigc_image_gen).