Noureddine RAMDI / Eclaire: a local-first AI assistant unifying your personal data with local LLMs

Created Mon, 04 May 2026 10:23:01 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
940 Words
github-stars typescript local-ai llm self-hosted docker privacy

eclaire-labs/eclaire

Eclaire tackles a problem many of us face: how to have an AI assistant that works locally, respects your privacy, and seamlessly integrates all your personal data — tasks, notes, photos, documents — without relying on cloud services. Instead of sending your data to third-party servers, Eclaire orchestrates multiple local large language models (LLMs) through a unified API, offering a personal AI environment you fully control.

What Eclaire does and its architecture

At its core, Eclaire is a local-first, self-hosted AI assistant built primarily in TypeScript. It unifies diverse personal data types — tasks, notes, documents, photos, bookmarks — under one privacy-preserving interface designed to keep everything on your machine.

The architecture is modular and modern:

  • Frontend: Built with React 19 and Vite, providing a responsive and modular user interface.
  • Backend: A Node.js server using Hono, a lightweight and performance-oriented framework.
  • Database: Supports both PostgreSQL and SQLite, allowing flexible deployment from single-user setups to multi-user environments.
  • Background workers: Handle asynchronous tasks and AI computations outside the main request flow.

A standout feature is how Eclaire integrates with local LLM backends. Instead of relying on cloud-based AI APIs, it supports llama.cpp, MLX, vLLM, and Ollama — all run locally — accessed through an OpenAI-compatible API gateway. This means existing OpenAI tools or clients can work with Eclaire by simply pointing to its local API endpoint.

The system also implements AI tool calling — enabling the assistant to search your content, resolve tasks, or create notes intelligently by invoking specialized AI-powered tools. This helps bridge user intent with actionable results over your data.

Deployment-wise, Eclaire is flexible: you can run it as a single container unifying frontend/backend/worker services or split them into separate containers. It also supports hardware acceleration on Apple MLX and NVIDIA CUDA, boosting LLM inference performance where available.

Technical strengths and tradeoffs

Eclaire’s most notable strength is its local-first design combined with AI orchestration. By supporting multiple local LLM backends, it avoids vendor lock-in and cloud privacy concerns — a big deal for users wary of sending sensitive data to external servers.

The use of TypeScript across the stack improves maintainability and developer experience. The codebase leverages modern frameworks like React 19 and Hono, which balance performance and simplicity.

Supporting both PostgreSQL and SQLite covers a broad range of use cases from lightweight personal setups to multi-user deployments. The modular architecture separating frontend, backend, and workers adds flexibility and scalability.

The OpenAI-compatible API gateway is a smart design choice. It reuses existing client tooling and workflows without reinventing the wheel, easing integration with other AI tools.

However, there are tradeoffs and limitations:

  • The project is in pre-release (v0.6.0), so expect evolving APIs and potential rough edges.
  • Running local LLMs requires significant hardware resources and setup effort compared to cloud APIs.
  • Hardware acceleration support is platform-specific, mainly Apple MLX and NVIDIA CUDA, limiting performance gains on other systems.
  • The complexity of orchestrating multiple LLMs and AI tools locally demands a deeper understanding of infrastructure and AI workflows.

Despite these, Eclaire’s code is surprisingly clean and well-structured for a project at this stage, indicating solid engineering and a focus on extensibility.

Quick start with Eclaire

Eclaire’s README provides a clear quick start path using Docker and Docker Compose along with a recommended local LLM server (llama.cpp):

mkdir eclaire && cd eclaire
curl -fsSL https://raw.githubusercontent.com/eclaire-labs/eclaire/main/setup.sh | sh

This setup script:

  1. Downloads configuration files
  2. Generates secrets automatically
  3. Initializes the PostgreSQL database

After the initial setup, the README notes additional prerequisites for development mode, including Node.js (≥ 24), pnpm, and document/image processing tools depending on your OS (macOS or Ubuntu/Debian). For example, on macOS:

brew install --cask libreoffice
brew install poppler graphicsmagick imagemagick ghostscript libheif

To run the project in development:

git clone https://github.com/eclaire-labs/eclaire.git
cd eclaire
corepack enable
pnpm setup:dev
pnpm dev

This will start the frontend at http://localhost:3000 and backend health check at http://localhost:3001/health.

For container enthusiasts, there’s also a script to build Docker images locally:

./scripts/build.sh
docker compose -f compose.yaml -f compose.dev.yaml -f compose.local.yaml up -d

This flexibility allows you to choose between quick containerized deployment or full local dev setups.

Verdict

Eclaire is a promising project if you want a self-hosted, privacy-first AI assistant that unifies personal data and integrates with local LLMs. It’s particularly relevant for developers and power users comfortable managing local AI infrastructure and who want to avoid cloud dependencies.

The modular architecture and OpenAI-compatible API gateway make it extensible and compatible with existing AI workflows. However, the pre-release status and hardware requirements mean it’s not yet a plug-and-play solution for casual users.

If you’re exploring local AI assistants and want to orchestrate multiple LLM backends under a unified interface, Eclaire is worth a serious look. It’s a solid foundation with a clear focus on privacy and flexibility, though expect to invest time mastering the setup and understanding its tradeoffs.

→ GitHub Repo: eclaire-labs/eclaire ⭐ 855 · TypeScript