moltis

<div align="center">

<a href="https://moltis.org"><img src="https://raw.githubusercontent.com/moltis-org/moltis/main/website/favicon.svg" alt="Moltis" width="64"></a>

# Moltis — Un serveur d'agent personnel persistant et sécurisé en Rust

Un seul binaire — sandboxé, sécurisé, à vous.

[![CI](https://github.com/moltis-org/moltis/actions/workflows/ci.yml/badge.svg)](https://github.com/moltis-org/moltis/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/moltis-org/moltis/graph/badge.svg)](https://codecov.io/gh/moltis-org/moltis)
[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json&style=flat&label=CodSpeed)](https://codspeed.io/moltis-org/moltis)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Rust](https://img.shields.io/badge/Rust-1.91+-orange.svg)](https://www.rust-lang.org)
[![Discord](https://img.shields.io/discord/1469505370169933837?color=5865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/XnmrepsXp5)

[Installation](#installation) • [Comparaison](#comparison) • [Architecture](#architecture--crate-map) • [Sécurité](#security) • [Fonctionnalités](#features) • [Fonctionnement](#how-it-works) • [Contribuer](https://github.com/moltis-org/moltis/blob/main/CONTRIBUTING.md)

</div>

---

Moltis a récemment atteint [la page d'accueil de Hacker News](https://news.ycombinator.com/item?id=46993587). Veuillez [ouvrir une issue](https://github.com/moltis-org/moltis/issues) pour la moindre friction. Je m'efforce de rendre Moltis excellent.

**Sécurisé par conception** — Vos clés ne quittent jamais votre machine. Chaque commande s'exécute dans un conteneur sandboxé, jamais sur votre hôte.

**Votre matériel** — Fonctionne sur un Mac Mini, un Raspberry Pi ou tout serveur que vous possédez. Un seul binaire Rust, pas de Node.js, pas de npm, pas de runtime.

**Complet** — Voix, mémoire, rappel inter-sessions, points de contrôle d'édition automatiques, planification, Telegram, Signal, Discord, automatisation du navigateur, serveurs MCP, exécution distante via SSH ou nœud, clés de déploiement gérées avec épinglage d'hôte dans l'interface web, un inventaire en direct Paramètres → Outils, un contexte de projet compatible Cursor, et l'analyse des menaces dans les fichiers de contexte — tout est intégré. Pas de place de marché de plugins par laquelle subir une attaque de chaîne d'approvisionnement.

**Auditable** — Le runner d'agent et l'interface de modèle tiennent en ~7,5K lignes, avec les fournisseurs dans ~19K lignes supplémentaires. L'espace de travail Rust compte ~270K lignes réparties sur 59 crates modulaires que vous pouvez auditer indépendamment, avec plus de 470 fichiers Rust contenant des tests. Le code unsafe est isolé aux frontières FFI et du runtime précompilé, pas dans la boucle d'agent principale.

## Installation

```bash
# One-liner install script (macOS / Linux)
curl -fsSL https://www.moltis.org/install.sh | sh

# macOS / Linux via Homebrew
brew install moltis-org/tap/moltis

# Docker (multi-arch: amd64/arm64)
docker pull ghcr.io/moltis-org/moltis:latest

# Or build from source
cargo install moltis --git https://github.com/moltis-org/moltis
```

## Comparaison

| | OpenClaw | Hermes Agent | **Moltis** |
|---|---|---|---|
| Stack principal | TypeScript + applications compagnon Swift/Kotlin | Python + interfaces TUI/web TypeScript | **Rust** |
| Runtime | Node.js + npm/pnpm/bun | Python + uv/pip, composants UI Node optionnels | **Binaire Rust unique** |
| Taille du checkout local\* | ~1,1M LoC d'application | ~152K LoC d'application | **~270K LoC Rust** |
| Architecture | Passerelle étendue, canaux, nœuds et écosystème d'applications | Agent CLI/passerelle avec boucle d'apprentissage et outillage de recherche | **Serveur d'agent personnel persistant avec crates modulaires** |
| Crates/modules | Paquets npm, extensions, applications | Paquets Python, plugins, outils, TUI | **59 crates du workspace Rust** |
| Sandbox/backends | Permissions au niveau de l'application, outils navigateur/nœud | Local, Docker, SSH, Daytona, Singularity, Modal | **Docker/Podman + Apple Container + WASM** |
| Auth/accès | Appairage et contrôles de la passerelle locale | Configuration CLI et passerelle de messagerie | **Mot de passe + Passkey + clés API + Vault** |
| E/S vocales | Modes réveil vocal et conversation | Transcription de mémos vocaux | **Fournisseurs STT + TTS intégrés** |
| MCP | Support des plugins/intégrations | Intégration MCP | **stdio + HTTP/SSE** |
| Compétences | Compétences groupées, gérées et de workspace | Compétences auto-améliorantes et support Skills Hub | **Compétences groupées/workspace + amélioration autonome + import OpenClaw** |
| Mémoire/RAG | Mémoire et moteur de contexte basés sur des plugins | Mémoire organisée par l'agent, recherche de sessions, modélisation utilisateur | **SQLite + FTS + mémoire vectorielle** |

\* LoC mesurées avec `tokei`, en excluant `node_modules`, la sortie de build générée, `dist` et `target`.

> [Comparaison complète dans la documentation →](https://docs.moltis.org/comparison.html)

## Architecture — Carte des crates

Workspace Rust actuel : ~270K LoC réparties sur 59 crates. Le tableau ci-dessous regroupe les principales crates par rôle afin que l'architecture reste lisible.

**Runtime principal** :

| Crate | LoC | Rôle |
|-------|-----|------|
| `moltis-gateway` | 37,4K | Serveur HTTP/WS, RPC, auth, câblage au démarrage |
| `moltis-tools` | 37,0K | Exécution d'outils, sandboxing, outils WASM |
| `moltis-providers` | 18,9K | Implémentations des fournisseurs LLM |
| `moltis-agents` | 14,5K | Boucle d'agent, streaming, assemblage des prompts |
| `moltis-chat` | 14,2K | Moteur de chat, orchestration des agents |
| `moltis-config` | 10,3K | Configuration, validation |
| `moltis-httpd` | 9,9K | Primitives et middleware du serveur HTTP |
| `moltis` (CLI) | 4,7K | Point d'entrée, commandes CLI |
| `moltis-sessions` | 3,5K | Persistance des sessions |
| `moltis-common` | 1,5K | Utilitaires partagés |
| `moltis-service-traits` | 1,2K | Interfaces de services partagées |
| `moltis-protocol` | 0,7K | Types du protocole de communication |

**Crates de fonctionnalités et d'intégration** :

| Catégorie | Crates | LoC combinées |
|----------|--------|-------------|
| Canaux | `moltis-telegram`, `moltis-whatsapp`, `moltis-signal`, `moltis-discord`, `moltis-msteams`, `moltis-matrix`, `moltis-slack`, `moltis-nostr`, `moltis-channels` | 34,0K |
| Web et API | `moltis-web`, `moltis-graphql`, `moltis-webhooks` | 10,8K |
| Extensibilité | `moltis-mcp`, `moltis-mcp-agent-bridge`, `moltis-skills`, `moltis-plugins` | 11,5K |
| Mémoire et contexte | `moltis-memory`, `moltis-qmd`, `moltis-code-index`, `moltis-projects` | 11,7K |
| Voix et navigateur | `moltis-voice`, `moltis-browser` | 9,2K |
| Auth et sécurité | `moltis-auth`, `moltis-oauth`, `moltis-vault`, `moltis-secret-store`, `moltis-network-filter`, `moltis-tls` | 8,5K |
| Planification et automatisation | `moltis-cron`, `moltis-caldav`, `moltis-auto-reply` | 4,7K |
| Configuration et import | `moltis-provider-setup`, `moltis-openclaw-import`, `moltis-onboarding` | 11,7K |
| Hôtes natifs et nœuds | `moltis-swift-bridge`, `moltis-node-host`, `moltis-courier` | 5,7K |
| Outils WASM | `moltis-wasm-precompile`, `moltis-wasm-calc`, `moltis-wasm-web-fetch`, `moltis-wasm-web-search` | 1,4K |
| Crates de support | `moltis-media`, `moltis-metrics`, `moltis-tailscale`, `moltis-routing`, `moltis-canvas`, `moltis-schema-export`, `benchmarks` | 2,1K |

Utilisez `--no-default-features --features lightweight` pour les appareils aux ressources limitées (Raspberry Pi, etc.).

## Sécurité

- **Surface d'attaque réduite** — le code cœur de l'agent/de la passerelle reste en Rust sûr ; l'unsafe est isolé aux frontières FFI Swift, aux wrappers de modèles locaux et aux limites WASM précompilées
- **Exécution en bac à sable** — Docker + Apple Container, isolation par session
- **Gestion des secrets** — `secrecy::Secret`, zéroïsé à la destruction, masqué dans la sortie des outils
- **Authentification** — mot de passe + passkey (WebAuthn), limitée en débit, limitation par IP
- **Protection SSRF** — résolution DNS, blocage de loopback/privé/link-local
- **Validation d'origine** — rejette les mises à niveau WebSocket cross-origin
- **Filtrage par hooks** — les hooks `BeforeToolCall` peuvent inspecter/bloquer toute invocation d'outil
- **Intégrité de la chaîne d'approvisionnement** — [attestations d'artefacts](https://github.com/moltis-org/moltis/attestations), signature sans clé Sigstore, signature GPG (YubiKey), sommes de contrôle SHA-256/SHA-512

Voir [Architecture de sécurité](https://docs.moltis.org/security.html) pour les détails.
Vérifiez les versions avec `gh attestation verify <artifact> -R moltis-org/moltis` ou consultez [Vérification des versions](https://docs.moltis.org/release-verification.html).

## Fonctionnalités

- **Valeurs par défaut de raisonnement** - Effort de réflexion par défaut configurable pour les sessions sans modèle et les nouvelles sessions principales, avec des surcharges explicites par session (Désactivé ou niveau)
- **Passerelle IA** — Prise en charge multi-fournisseurs de LLM (OpenAI Codex, GitHub Copilot, Local), réponses en streaming, boucle d'agent avec délégation à des sous-agents, modes de session, exécution parallèle des outils
- **Communication** — Interface web avec invites d'agent via palette de commandes et copie/export Markdown, Telegram, Signal, Microsoft Teams, Discord, Slack avec cartes d'outils natives en direct, DM Nostr + chat de groupe NIP-29 (y compris les canaux Buzz de Block), accès API, E/S vocales (8 fournisseurs TTS + 7 STT), PWA mobile avec notifications push
- **Application de bureau** — Client natif Rust/gpui qui se connecte à un démon en cours d'exécution en local, via HTTPS ou via un tunnel SSH ; clés API à portée limitée stockées dans le trousseau, épinglage de certificat, rendu markdown natif en streaming, approbations avec notifications système
- **Mémoire et rappel** — Espaces de travail mémoire par agent, mémoire à long terme alimentée par embeddings, recherche hybride vecteur + texte intégral, persistance de session avec auto-compaction, rappel inter-sessions, contexte de projet compatible Cursor, analyse de sécurité des fichiers de contexte
- **Fichiers gérés** - Gestion de fichiers imbriqués authentifiée dans les Paramètres, avec un chemin hôte annoncé par l'agent et des montages indépendants en lecture seule par défaut pour les bacs à sable Docker, Podman et Apple Container
- **Édition d'agent plus sûre** — Points de contrôle automatiques avant les mutations des compétences et de la mémoire intégrées, outils de restauration, branchement de session
- **Extensibilité** — Serveurs MCP (stdio + HTTP/SSE), système de compétences, 15 événements de hook de cycle de vie avec disjoncteur, garde contre les commandes destructrices
- **Agent Client Protocol** — pilote des agents ACP externes (`codex-acp`, `claude-agent-acp`, Cursor), et sert Moltis aux clients ACP via stdio avec `moltis acp`
- **Premier lancement** — Ouvre l'onboarding dans votre navigateur avec le code de configuration pré-rempli, sert `http://localhost` sans certificat, propose une fois de faire confiance à une AC locale à nom contraint pour HTTPS sur le LAN, et épingle l'URL de l'interface web sous les journaux du terminal (avec une indication `ssh -L` en SSH)
- **Sécurité** — Coffre chiffré au repos (XChaCha20-Poly1305 + Argon2id), authentification par mot de passe + passkey + clé API, isolation par bac à sable, protection SSRF/CSWSH
- **Opérations** — Planification cron, CalDAV local durable, Gmail, e-mail Himalaya, et jeux de données de messages réutilisables Slack/Discord/Matrix/Teams, outils d'agent en lecture seule spécifiques au fournisseur, recherche plein texte rapide, projections JSONL/Markdown, instrumentation d'agent (Langfuse pour les traces LLM, OTLP pour Grafana/Datadog), métriques Prometheus, déploiement cloud (Fly.io, DigitalOcean), intégration Tailscale, clés de déploiement SSH gérées, cibles distantes épinglées à l'hôte, inventaire d'outils en direct dans les Paramètres, et flux de diagnostic d'exécution distante en CLI/web

## Fonctionnement

Moltis est un **serveur d'agent persistant local-first** — un binaire Rust unique qui
se place entre vous et plusieurs fournisseurs de LLM, conserve un état de session durable, et
peut vous rejoindre sur différents canaux sans confier vos données à un relais cloud.

```
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Web UI    │  │  Telegram   │  │  Discord    │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────┬───────┴────────┬───────┘
                │   WebSocket    │
                ▼                ▼
        ┌─────────────────────────────────┐
        │          Gateway Server         │
        │   (Axum · HTTP · WS · Auth)     │
        ├─────────────────────────────────┤
        │        Chat Service             │
        │  ┌───────────┐ ┌─────────────┐  │
        │  │   Agent   │ │    Tool     │  │
        │  │   Runner  │◄┤   Registry  │  │
        │  └─────┬─────┘ └─────────────┘  │
        │        │                        │
        │  ┌─────▼─────────────────────┐  │
        │  │    Provider Registry      │  │
        │  │  Multiple providers       │  │
        │  │  (Codex · Copilot · Local)│  │
        │  └───────────────────────────┘  │
        ├─────────────────────────────────┤
        │  Sessions  │ Memory  │  Hooks   │
        │  (JSONL)   │ (SQLite)│ (events) │
        └─────────────────────────────────┘
                       │
               ┌───────▼───────┐
               │    Sandbox    │
               │ Docker/Apple  │
               │  Container    │
               └───────────────┘
```

Voir [Quickstart](https://docs.moltis.org/quickstart.html) pour le démarrage de la passerelle, le flux de messages, les sessions et les détails de la mémoire.

## Premiers pas

### Compiler et exécuter

Nécessite [just](https://github.com/casey/just) (exécuteur de commandes) et Node.js (pour Tailwind CSS).

```bash
git clone https://github.com/moltis-org/moltis.git
cd moltis
just build-css                  # Build Tailwind CSS for the web UI
just build-release              # Build in release mode
cargo run --release --bin moltis
```

Pour une compilation de version complète incluant les outils de sandbox WASM :

```bash
just build-release-with-wasm    # Builds WASM artifacts + release binary
cargo run --release --bin moltis
```

Ouvrez `https://moltis.localhost:3000`. Au premier lancement, un code de configuration est affiché dans
le terminal — saisissez-le dans l'interface web pour définir votre mot de passe ou enregistrer une clé d'accès.

Options facultatives : `--config-dir /path/to/config --data-dir /path/to/data`

### Docker

```bash
# Docker / OrbStack
docker run -d \
  --name moltis \
  -p 13131:13131 \
  -p 13132:13132 \
  -p 1455:1455 \
  -v moltis-config:/home/moltis/.config/moltis \
  -v moltis-data:/home/moltis/.moltis \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/moltis-org/moltis:latest
```

Ouvrez `https://localhost:13131` et terminez la configuration. Pour les déploiements Docker non surveillés, définissez `MOLTIS_PASSWORD`, `MOLTIS_PROVIDER` et `MOLTIS_API_KEY` avant le premier démarrage afin de contourner l'assistant de configuration. Consultez la [documentation Docker](https://docs.moltis.org/docker.html) pour Podman, OrbStack, la confiance TLS et les détails de persistance.

### Déploiement cloud

| Fournisseur | Déployer |
|----------|--------|
| DigitalOcean | [![Deploy to DO](https://www.deploytodo.com/do-btn-blue.svg)](https://cloud.digitalocean.com/apps/new?repo=https://github.com/moltis-org/moltis/tree/main) |

**Fly.io** (CLI) :

```bash
fly launch --image ghcr.io/moltis-org/moltis:latest
fly secrets set MOLTIS_PASSWORD="your-password"
```

Toutes les configurations cloud utilisent `--no-tls` car le fournisseur gère la terminaison TLS.
Voir [Cloud Deploy docs](https://docs.moltis.org/cloud-deploy.html) pour plus de détails.

## Licence

MIT