LibreChat

LibreChat implements a BaseClient architecture that abstracts OpenAI, Anthropic, Google, Azure, AWS Bedrock, and local models (Ollama, LM Studio) behind a single interface. Each provider has a dedicated implementation class that handles protocol differences, token counting, and streaming responses. The system uses a provider registry pattern to route requests to the correct client based on configuration, enabling seamless switching between providers without application-level changes.

LibreChat uses a declarative YAML configuration system (librechat.yaml) that defines AI providers, agents, RAG settings, and authentication methods. The system includes a schema validator that enforces type safety and required fields at startup, preventing misconfiguration. Environment variables override YAML values, enabling both local development and containerized deployment without code changes. The configuration loader parses YAML, validates against TypeScript schemas, and injects resolved config into the application context.

LibreChat supports multiple authentication methods for enterprise deployments: OAuth2 (Google, GitHub, Discord), OpenID Connect, LDAP, and SAML. The authentication service abstracts provider differences; users configure their preferred method via environment variables or YAML. OAuth flows use standard libraries (passport.js); OpenID Connect uses the openid-client library; LDAP uses ldapjs; SAML uses passport-saml. Authenticated users are associated with conversations and have isolated access to their data. The system supports role-based access control (RBAC) for feature flags and admin functions. Session management uses secure cookies with configurable expiration.

LibreChat implements a message processing pipeline that handles user input, invokes the selected LLM provider, processes tool calls, and manages multi-turn conversations. The pipeline is event-driven: user messages trigger provider calls, tool invocations are detected in LLM responses, tools are executed (either built-in or MCP), results are fed back to the LLM, and the cycle repeats until the LLM produces a final response. The system includes error recovery (retries with exponential backoff), timeout handling, and conversation context management. Tool invocation schemas are validated before execution. The pipeline is asynchronous and supports streaming responses.

LibreChat includes comprehensive internationalization support using i18next, enabling the UI to be translated into multiple languages. Language files are JSON-based and organized by locale (en, de, fr, ar, etc.). The system detects user language preference from browser settings or user profile, loads the appropriate language file, and renders the UI in that language. Translations cover all UI elements (buttons, labels, error messages, help text). The system supports right-to-left (RTL) languages like Arabic. Language switching is available in the settings menu without page reload. Developers can add new languages by creating new JSON files and registering them in the i18n configuration.

LibreChat provides Docker deployment with multi-stage builds (Dockerfile, Dockerfile.multi) that optimize image size by separating build and runtime stages. The main Dockerfile builds the Node.js backend and React frontend in separate stages, resulting in a ~500MB image. Docker Compose configurations (docker-compose.yml, deploy-compose.yml) orchestrate LibreChat, MongoDB, and optional services (Redis, Ollama). Kubernetes support includes Helm charts for declarative deployments with configurable replicas, resource limits, and persistent volumes. The system supports environment variable injection for configuration, enabling the same image to run in dev, staging, and production with different configs.

LibreChat implements an Assistants API compatible with OpenAI's Assistants API, enabling users to create persistent assistants with custom instructions, tools, and file attachments. Assistants are stored in the database with metadata (name, description, instructions, tools, model). When a user interacts with an assistant, the system maintains conversation state, manages file uploads, and executes tool calls within the assistant's context. The system supports file retrieval (code interpreter can access uploaded files) and tool use (assistants can invoke registered tools). Assistants can be shared across conversations, enabling consistent behavior across multiple interactions.

Implements a comprehensive internationalization system supporting 20+ languages for the UI. Language strings are stored in JSON files organized by language code (en, de, fr, etc.). The frontend uses a translation library (likely i18next) to load and apply translations dynamically. Users can switch languages in settings, and the preference is persisted. The system supports right-to-left (RTL) languages like Arabic and Hebrew. Translation keys are organized hierarchically for maintainability.

LibreChat provides a UI-driven agent builder that allows users to compose agents without writing code. Agents are defined as JSON schemas specifying tools, system prompts, model selection, and execution parameters. The system includes a marketplace for sharing and discovering custom agents. Agents are stored in the database and executed through the message processing pipeline, which handles tool invocation, error recovery, and multi-turn conversations. The builder validates agent configurations and provides real-time testing within the chat interface.

LibreChat integrates the @modelcontextprotocol/sdk to connect external tools and context sources. MCP servers expose tools via a standardized protocol; LibreChat's MCP client discovers available tools, validates their schemas, and registers them in a tool registry. During message processing, the agent can invoke registered MCP tools, which are executed in the MCP server's context and return results back to the LLM. The system handles MCP server lifecycle (connection, reconnection, disconnection) and includes reconnection-storm tests to prevent cascading failures.

LibreChat includes a code interpreter that executes code in isolated sandboxes supporting Python, Node.js, Go, C/C++, Java, PHP, Rust, and Fortran. The interpreter receives code from the LLM, executes it in a containerized environment with resource limits (CPU, memory, timeout), captures stdout/stderr, and returns results to the LLM for analysis. The system prevents code from accessing the host filesystem or network, ensuring security. Execution results are stored in conversation history, enabling multi-turn code refinement.

LibreChat integrates web search capabilities that query the internet, scrape content from results, and rerank results by relevance to the user's query. The system uses a search provider (e.g., SerpAPI, Bing Search) to retrieve URLs, fetches page content, extracts text, and passes relevant snippets to the LLM. Reranking uses semantic similarity to prioritize results matching the query intent. Search results are cached to reduce API calls and improve response latency. The feature is configurable and can be enabled/disabled per conversation.

LibreChat implements a Retrieval-Augmented Generation (RAG) system that indexes documents into a vector database, retrieves relevant chunks based on semantic similarity, and augments LLM prompts with retrieved context. The system supports multiple embedding models (OpenAI, local models) and vector stores (Pinecone, Weaviate, Milvus, local). Documents are chunked using configurable strategies (fixed size, semantic boundaries), embedded, and stored with metadata. During inference, user queries are embedded and matched against the vector store; top-k results are injected into the system prompt. The RAG configuration is defined in rag.yml and can be customized per conversation.

LibreChat stores conversations in MongoDB with full-text search and filtering capabilities. Each conversation is a document containing messages, metadata (created date, model used, provider), and user associations. The system indexes conversations by user, timestamp, and content, enabling fast retrieval and search. Users can search conversations by keyword, filter by date range or model, and export conversation history. Conversations are associated with users via authentication; multi-user deployments enforce access control. The database schema supports conversation branching (multiple responses to a single message) and conversation forking (creating new conversations from existing ones).

LibreChat supports multimodal inputs including image analysis, file uploads, and text-to-speech/speech-to-text. Users can upload images (PNG, JPEG, WebP) which are sent to the LLM's vision API for analysis. Files (PDF, text, code) can be uploaded and processed; PDFs are extracted to text, and code files are syntax-highlighted. The system handles file size limits, validates MIME types, and stores uploaded files temporarily. Images are encoded as base64 or URLs depending on the provider's API. Speech-to-text converts audio to text using browser APIs or server-side processing; text-to-speech converts responses to audio for accessibility.

LibreChat includes an artifacts system that enables the LLM to generate interactive UI components (React, HTML, Mermaid diagrams) that render in the chat interface. The system detects artifact markers in LLM responses, extracts code, validates syntax, and renders components in an isolated iframe. React artifacts have access to a limited API (useState, useEffect) but cannot access the host application. HTML artifacts are rendered as-is with CSP restrictions. Mermaid diagrams are rendered using the Mermaid.js library. Users can edit artifacts in-place, copy code, or download as files. The artifact system enables dynamic, interactive responses beyond static text.