Lobe Chat

Abstracts 100+ LLM providers (OpenAI, Anthropic, Google, Azure, local Ollama, etc.) behind a unified request/response interface. Uses a provider configuration system with model definitions, localization metadata, and dynamic model list customization syntax. Handles provider-specific authentication, rate limiting, and streaming response normalization across heterogeneous APIs without client-side provider switching logic.

Enables chat interactions combining text, images (vision), audio input (STT), and audio output (TTS) in a single conversation thread. Integrates vision models for image analysis, TTS providers for spoken responses, and STT for voice input transcription. Message rendering system handles mixed-media content with proper UI component selection based on message type and content MIME types.

Provides comprehensive internationalization with translations for 50+ languages using a structured JSON-based localization system. Translations are organized by feature and component, with fallback to English for missing translations. Model descriptions are localized separately to support provider-specific terminology. Language detection uses browser locale with manual override. Localization workflow includes automated translation updates and contributor guidelines for community translations.

Uses Zustand for lightweight client-side state management with automatic persistence to localStorage. State includes user preferences, UI state (sidebar open/closed, theme), agent configurations, and conversation history. Zustand stores are organized by feature (chat store, agent store, settings store, etc.) with clear separation of concerns. Middleware handles localStorage synchronization and state hydration on app startup. Server state is fetched via React Query with automatic caching and invalidation.

Uses a relational database schema (PostgreSQL/MySQL) with tables for users, sessions, messages, agents, knowledge bases, files, and audit logs. Schema includes foreign key constraints, indexes for performance, and timestamp columns for auditing. Database migrations are version-controlled using Drizzle ORM with automatic schema generation. Migrations are applied on deployment with rollback support. Schema includes specialized tables for RAG (documents, chunks, embeddings) and agent execution (cron jobs, execution traces).

Handles file uploads (documents, images, audio) with S3-compatible storage backend. Supports multipart uploads for large files (>100MB) with resumable upload capability. Files are stored with metadata (MIME type, size, upload timestamp) in database. Implements presigned URLs for secure file access without exposing credentials. Supports local file storage fallback for development. File deletion cascades to related records (messages, knowledge base documents).

Uses Redis for distributed caching of frequently accessed data (user sessions, agent configurations, model lists) and rate limiting. Session data is stored in Redis with TTL-based expiration, enabling stateless server instances. Rate limiting uses token bucket algorithm with per-user quotas (e.g., 100 requests/hour). Cache invalidation is event-driven: when agents or knowledge bases are updated, related cache entries are purged. Fallback to database if Redis is unavailable.

Provides a plugin marketplace and execution runtime for extending agent capabilities via function calling. Plugins are defined with JSON schemas describing inputs/outputs, which are passed to LLMs for tool selection. Supports both native plugins and Model Context Protocol (MCP) servers for standardized tool integration. Plugin execution is sandboxed and routed through a tool execution layer that handles provider-specific function calling APIs (OpenAI, Anthropic, etc.).

Implements a complete retrieval-augmented generation (RAG) system: documents are chunked using configurable strategies, embedded via provider APIs (OpenAI, local models), stored in vector database, and retrieved via semantic search. Supports multiple file formats (PDF, TXT, Markdown, DOCX) with automatic format detection. Retrieved documents are injected into LLM context as augmented prompts. Vector search uses cosine similarity with configurable chunk size and overlap parameters.

Provides an agent execution runtime that decomposes user intents into multi-step tasks using chain-of-thought reasoning. Agents are configured with system prompts, tool access, knowledge base grounding, and memory context. The runtime orchestrates LLM calls with tool invocation loops: LLM generates thoughts and tool calls, tools execute, results are fed back to LLM for next step. Supports both synchronous and streaming execution with proper error handling and fallback strategies.

Organizes conversations into sessions (separate chat threads) and topics (conversation branches within a session). Each message is stored with parent/child relationships, enabling conversation tree navigation and branching. Topics allow users to explore alternative conversation paths from a single point. Session metadata includes creation time, model used, and custom tags. Supports session export, sharing, and archival. Database schema uses relational integrity constraints to maintain conversation tree structure.

Maintains persistent user memory across conversations: facts about the user, preferences, conversation history summaries, and learned behaviors. Memory is stored in a dedicated database table and automatically injected into agent system prompts as context. Uses configurable memory update strategies (explicit user edits, automatic summarization, or hybrid). Memory is scoped per user and can be selectively enabled/disabled per agent. Supports memory export and import for user data portability.

Implements multi-user support with role-based access control (RBAC) for managing permissions across agents, knowledge bases, and sessions. Roles include admin, user, and custom roles with granular permissions (create agent, edit knowledge base, share session, etc.). User management includes invitation, deactivation, and permission auditing. Access control is enforced at the API layer with middleware that checks user role and resource ownership before allowing operations.

Renders chat messages with support for rich content types: text, code blocks, images, audio, tables, and custom components. Uses a message rendering system that maps MIME types and content metadata to React components. Markdown is parsed and rendered with syntax highlighting for code blocks. LaTeX math expressions are supported via KaTeX. Message content is sanitized to prevent XSS attacks. Supports custom message renderers for extensibility.

Supports multiple deployment targets: Docker containers (with multi-stage builds for optimization), Vercel serverless (one-click deployment), and Electron desktop application. Docker setup includes environment variable configuration, database migrations, and Redis caching. Vercel deployment uses Next.js serverless functions with automatic scaling. Electron app bundles the same codebase with native OS integration (file system access, system tray, auto-updates). CI/CD pipeline automates builds, tests, and releases across all platforms.