5ire

Abstracts 12+ AI providers (OpenAI, Anthropic, Google, Mistral, Grok, DeepSeek, Ollama, Perplexity, Doubao, etc.) behind a single chat interface using a provider-agnostic ChatService base architecture with provider-specific implementations. Streams responses in real-time via Electron IPC bridge, manages per-conversation model selection and parameters, and handles token counting/cost estimation across heterogeneous provider APIs.

Implements Model Context Protocol (MCP) client that connects to local and remote tool servers via three transport mechanisms: StdioTransport (local processes), SSETransport (HTTP Server-Sent Events), and StreamableHTTPTransport (streaming HTTP). Manages tool discovery, schema validation, and execution with user approval policies. Tools are executed in the main Electron process and results are injected into chat context for model reasoning.

Implements a modal approval UI that intercepts tool calls before execution. Users can review the tool name, parameters, and expected side effects before approving or denying. Approved tools are executed in the main Electron process with results injected back into the chat context. Supports approval policies (e.g., 'always approve file reads, always deny file writes') to reduce approval fatigue.

Uses Zustand for in-memory state management in the React renderer process (conversations, messages, UI state) and Electron Store for persistent state in the main process (provider configs, API keys, user preferences). State is synced between processes via IPC: renderer dispatches actions, main process updates persistent store, and updates are broadcast back to renderer. This separation ensures sensitive data (API keys) stays in the main process.

Ingests documents (PDF, DOCX, XLSX, TXT) into a local SQLite + LanceDB vector store using bge-m3 embeddings generated locally via @xenova/transformers. Implements semantic search with citation tracking, allowing models to retrieve relevant document chunks and cite sources in responses. Knowledge base is persisted locally; optional Supabase sync enables cross-device access.

Manages 12+ AI provider configurations with encrypted API key storage using Electron Store. Supports dynamic model discovery (fetching available models from provider APIs), custom provider registration with user-defined endpoints, and per-provider parameter validation. API keys are encrypted at rest and never exposed to the renderer process; all provider communication happens in the main Electron process.

Tracks API consumption per conversation and provider using provider-specific token counting logic. Estimates costs based on provider pricing models (input/output token rates). Aggregates usage metrics in SQLite for historical analysis. Supports both exact token counting (for OpenAI via tiktoken) and estimation (for providers without public token counting).

Organizes conversations in a hierarchical structure (folders, tags) with SQLite persistence. Supports per-conversation model and provider selection, allowing users to compare responses from different models on the same prompt. Implements conversation forking (branching from a specific message) and message editing with automatic re-generation. Conversation state is managed via Zustand in the renderer process and synced to SQLite in the main process.

Built on Electron 31.7.1 with a three-process architecture: Main Process (Node.js, handles API calls and file I/O), Renderer Process (React 18.3.1, UI), and Preload Script (sandboxed context bridge). Uses contextBridge to expose only whitelisted IPC methods to the renderer, preventing direct access to Node.js APIs. Supports Windows, macOS, and Linux with native OS integrations.

Implements i18n (internationalization) using JSON translation files stored in `public/locales/{language}/translation.json`. Supports English and Chinese (Simplified) with extensible architecture for additional languages. Translations are loaded at startup and injected into React components via context or hooks. UI components from Fluent UI automatically adapt to language selection.

Renders chat messages as markdown with syntax-highlighted code blocks. Uses a markdown parser to convert message text to React components, with custom renderers for code blocks (using Prism.js or similar), links, and images. Supports inline LaTeX math rendering. Messages are streamed character-by-character for real-time display, with a streaming indicator showing when the model is still generating.

Provides a rich text editor for composing messages with support for multi-line input, markdown preview, and message history (up/down arrow navigation). Exposes model-specific parameters (temperature, top_p, max_tokens, etc.) as UI controls that vary by provider. Parameters are validated against provider constraints before sending requests. System message editing is supported per-conversation.