Khoj is an open-source personal AI assistant functioning as a 'second brain' for interacting with personal knowledge bases. It provides a chat interface allowing users to converse with various AI models about documents, notes, and connected data sources (local files, GitHub, Notion). The system supports multimodal capabilities including image generation, code execution, voice input/output, and computer operation through a modular agent architecture. Khoj features a Python/Django backend with FastAPI for API endpoints, a PostgreSQL database with pgvector for vector storage and search, and multiple frontends including a web application (React/Next.js), desktop client (Electron), mobile app (Android), and plugins for Obsidian and Emacs. The architecture emphasizes separation of concerns with distinct modules for file processing, embedding generation, conversation handling, tool integration, and user management.
Rocket.Chat is a production-grade, self-hosted team communication platform that provides real-time messaging, voice/video conferencing, omnichannel customer support (livechat), federation (Matrix), and an extensible app marketplace. The system is architected as a monorepo with a Meteor-based main application (apps/meteor) serving both the client (React with Fuselage UI) and server (Meteor methods, REST APIs via Hono, and microservices for enterprise features). Enterprise services (e.g., account, presence, authorization, DDP streamer) are implemented as separate polka-based microservices and gated by a license module. The client leverages React, TanStack Query, Zustand, and a rich component library (packages/ui-client). Data flows primarily through MongoDB (via typed model layers) with real-time updates pushed over DDP/WebSockets. File uploads use S3 or GridFS. Federation is achieved via Matrix protocol integration. The apps engine (packages/apps-engine) allows third-party apps to hook into message, room, and user events through a bridge pattern. The codebase includes extensive unit tests (Jest, Mocha), integration tests, Playwright e2e tests, and Storybook with a11y checks. External dependencies include MongoDB, Meteor, React, i18next, and a large set of npm packages managed by Yarn workspaces. The repository is actively maintained with frequent commits, changesets for versioning, and CI/CD pipelines.
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.
ClickClack is a production-grade, self-hostable team chat platform built for people, bots, and agents. The backend is a single Go binary serving a REST API with WebSocket real-time events, supporting both SQLite and PostgreSQL as interchangeable storage backends. The frontend is a Svelte 5 single-page application embedded into the Go binary, with an optional Electron desktop client and a TypeScript SDK for bot development. The system provides workspaces, channels, threads, direct messages, file uploads, full-text search, reactions, pinned messages, slash commands, event subscriptions, and push notifications (Web Push and Pushover). Authentication supports magic links, passwords (Argon2id), GitHub OAuth, and Cloudflare Access JWT. The architecture emphasizes security with SSRF-safe callback dialers, strict cookie namespacing, rate limiting, and bot scope enforcement. The codebase is notable for its dual-database store pattern with shared contract tests, a real-time event hub with cursor-based recovery, and a comprehensive test suite including unit, integration, and Playwright end-to-end tests. It is not a data research project; it is a fully featured application designed for self-hosting or cloud deployment.
This repository is a mature, well-architected IRC framework for Node.js, providing a high-level event-driven API for building IRC clients and bots. The codebase is structured around a core `Client` class that manages connection lifecycle, handles IRC protocol (including IRCv3 extensions like SASL, message tags, batch, etc.), and exposes a flexible middleware system for processing raw and parsed events. The architecture separates concerns into distinct modules: connection transport (TCP/TLS, WebSocket, SOCKS), IRC line parsing, command routing, network information tracking, and user/channel state management. The library demonstrates deep understanding of the IRC protocol and delivers a robust, test-covered implementation suitable for production use. Notable design patterns include an event emitter architecture, middleware pipeline, and stream-based channel message relay.
Zulip Desktop is an Electron-based desktop client for the Zulip team chat platform. It wraps the Zulip web application in a native window, providing multi-organization support via tabbed webviews, desktop notifications, tray/dock integration, spellcheck, and automatic updates. The architecture follows a standard Electron pattern with a main process (app/main/index.ts) managing windows, IPC, and system integrations, and a renderer process (app/renderer/js/main.ts) handling the UI, tab management, and settings pages. Communication between processes is facilitated by a strongly typed IPC system (typed-ipc.ts) that defines all channels and ensures type safety. The application persists user preferences and server configurations via JSON files (settings.json, domain.json) with Zod schema validation, and supports enterprise deployment through a global configuration file. External dependencies include Electron, electron-builder for packaging, electron-updater for auto-updates, Sentry for error reporting, and i18next for internationalization. The codebase is well-structured with clear separation of concerns, reusable component patterns, and comprehensive build pipelines for Windows, macOS, and Linux.
Stream Chat Swift is an iOS/macOS SDK for building real-time chat and messaging applications. It provides a modular architecture separating core networking (StreamChat), UI components (StreamChatUI), and shared utilities (StreamChatCommonUI). The SDK supports features like channels, messages, reactions, threads, polls, attachments, typing indicators, and presence. It uses Combine for reactive programming, Core Data for persistence, and WebSocket for real-time communication. The repository includes demo applications, example implementations (SlackClone, MessengerClone, etc.), and extensive testing infrastructure. The SDK follows protocol-oriented programming with dependency injection via Appearance and Components providers, enabling high customization.
Odysseus is a self-hosted, full-stack AI assistant platform built with FastAPI (Python) and vanilla JavaScript. It provides a unified workspace for chat with multiple LLM providers (OpenAI, Anthropic, Ollama, local models), deep research with multi-step web analysis, RAG-based memory and document indexing, email/calendar/contacts management via IMAP/CalDAV/CardDAV, an image editor with layers and AI tools, task scheduling, web search, and MCP (Model Context Protocol) server integration. The architecture follows a modular route-per-domain pattern with backward-compatibility shims, a shared SQLite database via SQLAlchemy, and ChromaDB for vector storage. The frontend is a single-page application with streaming markdown rendering, live thinking display, and extensive keyboard shortcuts. The system is designed for multi-user operation with owner-scoped data isolation, atomic file writes for state persistence, and comprehensive security measures including SSRF protection, prompt injection hardening, and secret encryption. It includes a hardware-fit recommendation engine (cookbook) for selecting optimal LLM inference backends (llama.cpp, vLLM, diffusers) based on local GPU capabilities. While primarily an application, it incorporates significant data engineering patterns: embedding lanes with fallback, search result ranking, memory consolidation with near-duplicate removal, and deep research synthesis pipelines. The codebase demonstrates strong engineering practices with extensive regression testing (over 400 test files), CI/CD pipelines, and security scanning. However, it shows signs of technical drift with duplicate code paths (e.g., search ranking in both `src/search` and `services/search`), heavy monkeypatching in tests, and some legacy migration complexity. The project is actively maintained with frequent commits and issue triage.
FreakWAN is a LoRa-based wide-area network (WAN) messaging system designed for ESP32 and T-ECHO devices. It implements a fully distributed, open chat network independent of internet or cellular infrastructure. The system supports plaintext and encrypted messaging, group chats, media sharing (small images), sensor data collection, and includes features like duty cycle tracking, automatic retransmission with ACK suppression, and neighborhood discovery via HELLO messages. The codebase is written in MicroPython (with a C port for T-ECHO) and is entirely self-contained, relying only on standard libraries. Architecturally, the application runs as a single asyncio event loop with multiple tasks for periodic message sending, HELLO advertising, serial input handling, and optional IRC/Telegram bot integration. The radio layer is abstracted behind SX1276 and SX1262 drivers, and the display uses a terminal-like Scroller view with splash screen and status icons. The protocol layer defines message types (Data, Ack, Hello, Ping, Pong) and supports encryption via AES-CBC with HMAC integrity. The repository is well-structured, with clear separation of concerns and reusable components that can be extracted for other projects.
SillyTavern is a full-stack web application (Node.js/Express backend, jQuery/Webpack frontend) that serves as a highly customizable frontend for interacting with large language models (LLMs) for roleplaying and chat. It supports dozens of AI backends (OpenAI, Anthropic, Kobold, Ollama, vLLM, etc.) via streaming text and chat completions, and provides an extensive plugin/extension system for TTS, translation, image generation, vector search, and more. The application features a sophisticated macro engine (Chevrotain-based CST parser) for dynamic prompt templating, a slash command framework with typed arguments and autocomplete, and a rich UI with themes, backgrounds, character management, and branching chat history. It is designed for power users who want fine-grained control over prompts, model parameters, and UI behavior, and includes multi-user support with authentication, secrets management, and per-user data isolation.
Tokimeki is a full-featured, open-source Bluesky client built with SvelteKit and TypeScript. It provides a multi-column deck layout (similar to TweetDeck) with support for multiple accounts, real-time timeline updates, chat (direct and group), rich media embeds, custom moderation (keyword mutes, labelers), and extensive customization (themes, keyboard shortcuts, layout options). The application uses the AT Protocol (XRPC) for all Bluesky interactions, implements OAuth and password-based authentication, and includes a service worker for push notifications and offline caching. Architecturally, Tokimeki is a single-page application (SPA) with server-side routes for OAuth flows, AI features (alt text generation, column icon suggestions), and proxy endpoints. State management is handled via Svelte 5 runes ($state, $derived) and custom reactive classes (ColumnState, AppState, PostState). Data persistence uses IndexedDB (via Dexie) for accounts, bookmarks, and drafts, and localStorage for settings. The codebase is modular with clear separation of concerns: UI components in src/lib/components/, state classes in src/lib/classes/, utilities in src/lib/, and routes in src/routes/. It includes a comprehensive test suite using Vitest and Playwright. Key features include a custom feed merge engine for combining multiple timelines, a virtual scrolling system with Fenwick tree for efficient rendering, an image compression pipeline with WebAssembly and fallback, a full chat system with group management, and an atmosphere service registry for third-party integrations. The application is internationalized with 10+ locales and supports on-device translation via the browser's Translator API.
ChatTTS is a generative speech model application designed specifically for dialogue scenarios, functioning as a Text-to-Speech (TTS) library with integrated serving infrastructure. The core logic resides in the ChatTTS package, where `ChatTTS/core.py` defines the main inference interface. The architecture combines a GPT-based language model (`ChatTTS/model/gpt.py`) for token generation, a DVAE (`ChatTTS/model/dvae.py`) for audio compression, and Vocos as a vocoder. The system supports multiple speakers, prosodic control (laughter, pauses), and text normalization for Chinese and English. Deployment is handled through multiple entry points: a FastAPI-based API server (`examples/api/main.py`), a Gradio WebUI (`examples/web/webui.py`), and CLI tools (`examples/cmd/run.py`). A significant engineering highlight is the integration of vLLM (`ChatTTS/model/velocity/`) to optimize inference throughput for the GPT component. The repository includes robust asset management (`ChatTTS/utils/dl.py`) for model weights with SHA256 verification and ONNX export capabilities (`examples/onnx/exporter.py`) for cross-platform deployment. While the underlying model is research-grade (trained on 100k+ hours of audio), the repository structure prioritizes application delivery over experimental research. It provides a stable library interface with clear separation between model logic, audio processing (`tools/audio/`), and serving layers. The codebase demonstrates high craftsmanship in handling stochastic generation reproducibility (`tools/seeder/ctx.py`) and speaker embedding management (`ChatTTS/model/speaker.py`), making it a production-ready TTS solution rather than a raw research notebook collection.
Zulip is a production-grade, open-source team chat application built as a Django monolith with a real-time Tornado event server. The backend uses Django ORM with PostgreSQL, RabbitMQ for async queue processing (email, push notifications, URL previews), Memcached/Redis for caching and rate limiting, and a custom typed-endpoint decorator pattern for API validation. The frontend is a mix of legacy jQuery/Handlebars and modern TypeScript with Zod schemas, Webpack bundling, and extensive UI components for chat composition, streams, topics, user groups, and settings. The system exposes a REST API (used by mobile and desktop clients), webhook ingestion for 50+ third-party services, and a full billing/support subsystem via Stripe. The architecture is a single monolithic Django application with separate Tornado process for real-time push, alongside queue workers and cron-like management commands. Key entry points include the Django WSGI server, Tornado event server, management commands (e.g., manage.py), and webhook view functions. External dependencies include PostgreSQL, RabbitMQ, Redis, Memcached, Stripe, pgroonga (full-text search), pyvips (image processing), and numerous npm packages.
Wildfire Chat IM Server is a production-grade instant messaging backend built on a heavily customized Moquette MQTT broker. It provides MQTT-based client connectivity, HTTP REST APIs for admin/robot/channel management, and supports features like private/group/chatroom/channel messaging, file/media storage (local or Qiniu), push notifications, sensitive word filtering, conference/voice-video events, social moments, and multi-domain mesh federation. The architecture is a multi-module Maven project (broker, common, sdk, distribution) using Netty for networking, Hazelcast for distributed caching, and MySQL/H2 with Flyway migrations for persistence. The codebase demonstrates solid engineering with annotation-driven routing, protobuf message serialization, and a clean SDK for server-side integration. However, it suffers from a god-class in MemoryMessagesStore, duplicated configurations, vendored Netty MQTT codec, and some security concerns (hardcoded keys, weak XOR encryption). It is actively maintained with frequent schema migrations and feature additions, but the licensing is ambiguous (multiple license files) and documentation is primarily in Chinese.
This is a monorepo housing two terminal-based Instagram clients: a modern TypeScript client using React Ink for a rich Terminal User Interface (TUI) and a legacy Python client using curses. The system provides a full-featured Instagram experience entirely within the terminal, including real-time messaging via MQTT, feed and story browsing, profile viewing, multi-account management, authentication (with 2FA/challenge support), and one-turn CLI commands for AI agent integration. It also incorporates LLM-based chat summarization (OpenAI compatible) and basic analytics in the Python client. Architecture is straightforward: a CLI entry point (Pastel for TS, Typer for Python) dispatches commands, with the TUI built from reusable Ink components (ScrollView, MessageList, InputBox, etc.) that manage state via React hooks and contexts. A mock system enables offline UI development. External dependencies include reverse-engineered Instagram APIs (instagram-private-api, instagram_mqtt) and multiple utility libraries. The dual-client structure and reliance on patched, unofficial APIs introduce maintenance risks, but the TypeScript client is well-crafted with clear separation of concerns, thorough component reuse, and thoughtful UX design for keyboard-driven terminal use.
CoAI (formerly ChatNio) is a full-stack AI chat platform and LLM gateway that provides a unified chat interface and OpenAI-compatible API proxy for 16+ AI model providers (OpenAI, Anthropic Claude, Google Gemini, Midjourney, DeepSeek, etc.). The system is built with a Go backend (Gin framework) and a React/TypeScript frontend (Redux, Tailwind CSS, Radix UI), with MySQL and Redis for persistence and caching. It supports real-time WebSocket chat, streaming responses, conversation management, file upload, web search, image generation, and a plugin system (MCP). The platform includes a comprehensive billing and subscription system with elastic per-token pricing and tiered plans (Basic/Standard/Pro), along with an admin dashboard for user management, channel configuration, analytics (model usage, request volume, revenue, errors), and system settings. It also features invitation codes, redeem codes, affiliate marketing, and multiple payment gateway integrations (Stripe, WeChat Pay, etc.). Architecturally, the backend employs an adapter pattern for AI providers, a channel manager for load balancing and retries, and a WebSocket connection manager with rate limiting. The frontend is heavily componentized with shadcn/ui and includes i18n support (English, Chinese, Japanese, Russian). Deployment is supported via Docker Compose, Zeabur, and a Tauri desktop app. While the codebase is well-structured and feature-rich, it shows signs of technical drift such as copy-pasted processor files across adapters, hardcoded model constants, and a large dependency surface. The open-source version is Apache 2.0 licensed, with a commercial 'CoAI Pro' tier offering additional features.
Copilot for Xcode is a macOS application that integrates multiple AI code completion and chat services (GitHub Copilot, Codeium, OpenAI, Claude, Google Gemini, Ollama) directly into Xcode as a source editor extension. It provides inline code suggestions, a chat panel with context-aware memory, a prompt-to-code feature, and custom command execution. The architecture is a multi-process system: a host app manages settings and lifecycle, an XPC extension service handles AI requests and workspace state, and an Accessibility-powered widget overlays suggestion and chat panels on Xcode windows. The codebase is heavily modularized into Swift packages (Core, Tool, OverlayWindow) and uses the Composable Architecture (TCA) for state management. While primarily an application, it includes data-centric components like embedding services, vector stores (USearch), and a LangChain-inspired chain abstraction for retrieval-augmented generation, giving it a hybrid character.
Turms is a production-grade, open-source instant messaging engine designed for 100K to 10M concurrent users. The system follows a microservices architecture with two core Java/Spring Boot servers: turms-gateway (handles client connections, authentication, session management, and push) and turms-service (implements business logic for messaging, groups, users, conversations, storage, and admin API). Both servers are built on a reactive stack (Project Reactor, Netty) for non-blocking I/O and high throughput. The platform includes a Vue.js admin UI (turms-admin), multiple client SDKs (JavaScript, Kotlin, Swift, Dart, C++), a Flutter chat demo, and a plugin system for extensibility (anti-spam, push notifications, MinIO storage, Rasa chatbot, LiveKit conferencing). Data is stored in MongoDB (sharded), Redis (session, blocklist, sequence IDs), and optionally Elasticsearch for full-text search. The codebase demonstrates strong engineering practices: custom RPC codecs for cluster communication, a property metadata framework for configuration validation, thread-safe rate limiting, and a well-defined plugin extension point system. While primarily an application, it includes an AI serving module (PaddleOCR) for content moderation, but this is a minor component. The repository is actively maintained with frequent commits, comprehensive CI/CD pipelines, and Terraform deployment scripts.
Ganymede is a media management system focused on archiving and managing Twitch content (VODs, live streams, clips) with a Go backend using Ent ORM, Echo framework, and River job queue, and a Next.js frontend with Mantine UI. It provides video archiving, playlist management, user authentication, API keys, and administrative interfaces. The system processes media through a pipeline involving yt-dlp, FFmpeg, and TwitchDownloaderCLI, storing metadata in PostgreSQL and files on disk. It includes features like chat archiving, chapter detection, muted segment detection, and rule-based playlist automation.
whatscli is a terminal-based (TUI) WhatsApp client written in Go. It connects via the WhatsApp Web API using the whatsmeow library, providing message sending/receiving, media attachment handling, group management, and desktop notifications. The architecture is a monolith with two goroutines: a tview-based UI main loop and a session manager that handles the WhatsApp connection and command dispatch through channels. The UI is highly configurable via an INI config file, supporting custom keybindings and color schemes. The codebase demonstrates good concurrency patterns with channel-based IPC and includes unit tests for the message storage layer. While the UI logic in main.go is tightly coupled to tview, the message database and event handling show clean separation and moderate reusability.