chatbox

Chatbox implements a provider abstraction layer that normalizes API calls across 10+ LLM providers (OpenAI, Anthropic, Google Gemini, DeepSeek, Ollama, etc.) through a unified interface. The system uses a provider implementation pattern where each provider has its own adapter class that handles authentication, request formatting, streaming response parsing, and error handling specific to that provider's API contract. All providers are accessed through a single message-sending interface regardless of backend, enabling users to switch models without changing application logic.

Chatbox implements real-time streaming of LLM responses at the token level, parsing provider-specific streaming formats (Server-Sent Events for OpenAI, different chunking for Anthropic, etc.) and emitting individual tokens to the UI as they arrive. The system handles backpressure, error recovery mid-stream, and graceful degradation if a stream is interrupted. Streaming is abstracted through the provider layer so the UI receives a consistent token stream regardless of backend provider.

Chatbox integrates with image generation providers (DALL-E, Midjourney, Stable Diffusion, etc.) allowing users to generate images directly within conversations. Users can describe an image in text, and the system invokes the appropriate image generation provider, retrieves the generated image, and displays it in the conversation. Image generation can be triggered manually or as part of an LLM-driven workflow where the LLM decides to generate images.

Chatbox uses a unified TypeScript codebase compiled to multiple platforms: Electron for desktop (Windows, macOS, Linux), Capacitor for mobile (iOS, Android), and web browsers. The build system uses a shared renderer codebase with platform-specific main process implementations. This enables feature parity across platforms while allowing platform-specific optimizations (e.g., native file dialogs on desktop, native camera access on mobile). The build pipeline handles code signing, app store distribution, and auto-updates.

Chatbox implements comprehensive internationalization supporting 10+ languages (English, Chinese, Spanish, French, etc.). The system uses a translation file structure where UI strings are defined in a base language and translated to other languages. Language selection is persisted in user settings and applied globally. The i18n system handles pluralization, date/time formatting, and right-to-left language support. Developers can add new languages by providing translation files.

Chatbox includes a theming system that supports light and dark modes with customizable colors, fonts, and layout options. The theme is persisted in user settings and applied globally across the application. The system uses CSS variables for theme values, enabling runtime theme switching without page reload. Users can select from preset themes or customize individual theme properties. The theme system respects system preferences (OS dark mode) and allows manual override.

Chatbox implements a comprehensive keyboard shortcut system for common actions (send message, new conversation, search, etc.) with customizable keybindings. The system displays available shortcuts in the UI and allows users to rebind shortcuts to their preferences. Keyboard navigation is fully supported for accessibility, enabling users to navigate the entire application without a mouse. The shortcut system is platform-aware, using platform conventions (Cmd on macOS, Ctrl on Windows/Linux).

Chatbox renders messages with full markdown support, including code blocks with syntax highlighting, tables, lists, and formatted text. The system uses a markdown parser to convert markdown to HTML, then renders the HTML with sanitization to prevent XSS attacks. Code blocks are highlighted using a syntax highlighter (e.g., Prism.js or Highlight.js) with support for 100+ programming languages. Messages can include embedded media (images, videos) and interactive elements (buttons, links).

Chatbox stores all conversation history, user settings, and session data locally using libsql (a fork of SQLite) accessed via IPC from the Electron main process. This ensures user data never leaves the device and provides offline-first functionality. The system implements data migrations for schema changes and provides a structured query interface for accessing conversations, messages, and metadata. All data is persisted to disk immediately, enabling recovery from crashes.

Chatbox uses Jotai, a primitive atoms-based state management library, to manage application state (current conversation, message list, UI settings, provider configuration, etc.). Each piece of state is represented as an atom, and components subscribe to atoms they need, enabling fine-grained reactivity and minimal re-renders. Atoms can be composed and derived, allowing complex state logic to be built from simple primitives. This approach avoids the boilerplate of Redux while maintaining predictable state updates.

Chatbox integrates with Model Context Protocol (MCP) servers, allowing users to extend the application with custom tools and data sources. The system can connect to MCP servers (local or remote), discover available tools/resources, and invoke them within conversations. Tool results are passed back to the LLM for further processing. This enables integration with external systems (databases, APIs, file systems) without modifying Chatbox core code.

Chatbox includes a knowledge base feature that allows users to upload documents, which are indexed and made available for semantic search within conversations. Documents are processed, chunked, and embedded (using provider-specific embeddings), then stored in a vector index. When users reference the knowledge base in conversations, relevant document chunks are retrieved and injected into the LLM context. This enables RAG-style augmented generation without requiring external vector databases.

Chatbox can perform web searches and retrieve web content to augment LLM responses. When enabled, the system can search the web for current information, fetch and parse web pages, and inject the retrieved content into the LLM context. This enables the AI to provide up-to-date information beyond its training data cutoff. Web search is integrated as an optional capability that can be toggled per conversation.

Chatbox supports uploading and processing various file types (images, PDFs, documents, code files, etc.) within conversations. Files are processed according to their type — images are analyzed by vision-capable models, PDFs are extracted and chunked, code files are syntax-highlighted and analyzed. The system handles file encoding, format conversion, and context injection so the LLM can reason about file contents. File handling is abstracted to support different file types without duplicating logic.

Chatbox includes an AI copilots system that allows users to create custom assistants with predefined system prompts, knowledge bases, and tool configurations. Copilots are templates that encapsulate a specific use case (e.g., 'Code Reviewer', 'Content Writer', 'Research Assistant') with customized instructions and capabilities. Users can create, save, and share copilots, and switch between them within the application. Each copilot maintains its own conversation history and configuration.

Chatbox provides team collaboration features that allow users to share conversations, copilots, and knowledge bases with team members. Shared conversations can be viewed, commented on, or used as templates for new conversations. The system manages access control and tracks who has access to shared resources. Sharing can be done via direct links or team-based access control. This enables teams to collaborate on AI-assisted tasks and share insights.