Guide d'installation OpenHuman (2026) : jumeau numérique IA en 5 minutes

Si vous avez repéré OpenHuman sur GitHub sans l'avoir encore installé, voici le chemin le plus court en 2026 : du téléchargement au moment où l'agent dit « vous avez une réunion cet après-midi » — étape par étape, environ 5 minutes pour un utilisateur à l'aise (OAuth et première sync inclus). OpenHuman n'est pas une page de chat de plus : c'est un agent de bureau, jumeau numérique IA personnel avec Memory Tree local, 118+ intégrations OAuth et sync en arrière-plan toutes les ~20 minutes. Une fois installé, consultez nos articles sur l'architecture et le Memory Tree et sur les Agent Skills ; ici, nous traitons uniquement comment installer, configurer et valider le succès.

L'intérêt d'OpenHuman tient à l'ensemble : les données restent sur votre machine, mais l'agent peut lire Gmail, le calendrier et GitHub — à condition de terminer correctement la configuration initiale. Lancer l'app sans OAuth ni modèle donne une interface vide et la frustration habituelle. Ce guide évite ce piège : chaque étape se conclut par un contrôle clair pour savoir si l'installation a réussi.

Préparer l'installation

OpenHuman est une application de bureau Tauri (noyau Rust + interface web), officiellement supportée sur macOS, Windows et Linux. En 2026, l'expérience optimale reste sur Mac Apple Silicon — surtout si Ollama ou MLX tourne sur la même machine. Avant de commencer, vérifiez :

• Permissions système — Sur macOS, autoriser l'app téléchargée dans « Confidentialité et sécurité » (ou clic droit → Ouvrir si hors App Store).
• Au moins un accès LLM — Clé API Anthropic / OpenAI, ou Ollama local (optionnel). Sans clé, l'interface s'ouvre mais l'agent ne peut pas inférer.
• 2–3 comptes à connecter — Pour le premier passage : Gmail + Google Calendar + GitHub (développeurs) ou Notion + Slack (travail intellectuel). Sans source, le Memory Tree reste vide et la validation en 5 minutes échoue.
• Disque et réseau — Le Memory Tree écrit en SQLite et Markdown local ; prévoyez quelques centaines de Mo. OAuth et premier fetch nécessitent un réseau stable.

Dépendances complètes et build source : dossier docs/ du dépôt officiel ; usage courant sans clone Git. Lancez d'abord une auto-vérification en terminal pour éviter de découvrir en cours de route que Homebrew ou l'architecture ne convient pas :

# 1. Système et puce (Apple Silicon = arm64)
sw_vers
uname -m

# 2. Homebrew disponible ? (pour installation brew)
brew --version
brew doctor

# 3. Si Ollama local : port 11434 libre ?
lsof -i :11434 || echo "Port 11434 libre, Ollama peut démarrer"

# 4. Espace disque (Memory Tree + cache modèles, ≥5 Go recommandés)
df -h ~

Si uname -m affiche arm64, téléchargez le binaire Apple Silicon. Sur Mac Intel, vérifiez explicitement la variante x64 dans les Releases GitHub — toutes les distributions ne publient pas simultanément les deux architectures.

Trois méthodes : paquet officiel, Homebrew, script

Le README officiel recommande : installateurs natifs signés ou gestionnaire système en priorité. Le script convient à l'essai rapide mais augmente le risque supply chain. Tableau par ordre de préférence.

# Ouvrir la dernière Release (arm64 / x64 selon la puce)
open "https://github.com/tinyhumansai/openhuman/releases/latest"
# ou la page de téléchargement
open "https://tinyhumans.ai/openhuman"

# Après téléchargement : monter le DMG et copier dans Applications
hdiutil attach ~/Downloads/OpenHuman*.dmg
cp -R "/Volumes/OpenHuman/OpenHuman.app" /Applications/
hdiutil detach "/Volumes/OpenHuman"

# Si « développeur non vérifié » : retirer la quarantaine
xattr -dr com.apple.quarantine /Applications/OpenHuman.app
open -a OpenHuman

# 1. Ajouter le tap officiel (une fois)
brew tap tinyhumansai/core

# 2. Installer (binaire stable actuel)
brew install openhuman

# 3. Vérifier le PATH
which openhuman
openhuman --version

# 4. Lancer le bureau (CLI ou Launchpad)
openhuman

# 5. Mettre à jour plus tard
brew update
brew upgrade openhuman

# Alternative sans core tap (certaines docs)
# brew install tinyhumansai/openhuman/openhuman

# Vérifier la version Node
node -v

# Installer le paquet npm (binaire natif + vérif SHA-256)
npm install -g openhuman

openhuman --version
openhuman

# 1. Importer GPG et ajouter la source apt
sudo apt-get install -y gnupg2 curl ca-certificates
curl -fsSL https://tinyhumansai.github.io/openhuman/apt/KEY.gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/openhuman.gpg
echo "deb [signed-by=/etc/apt/keyrings/openhuman.gpg arch=amd64] \
  https://tinyhumansai.github.io/openhuman/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/openhuman.list

# 2. Installer et lancer
sudo apt-get update
sudo apt-get install -y openhuman
openhuman --version

# 1. Télécharger le script sans l'exécuter
curl -fsSL \
  https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh \
  -o /tmp/openhuman-install.sh
less /tmp/openhuman-install.sh

# 2. dry-run pour prévisualiser (si supporté)
bash /tmp/openhuman-install.sh --dry-run --verbose

# 3. Installer après vérification
bash /tmp/openhuman-install.sh

# One-liner macOS / Linux (équivalent étape 3)
curl -fsSL \
  https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh \
  | bash

# Windows PowerShell :
irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iex

macOS pas à pas : de l'installation à la validation

Voici un parcours copiable mélange terminal et GUI : Homebrew + API Anthropic par défaut ; avec DMG, commencez à l'étape 3. Chaque étape indique comment confirmer le succès.

brew tap tinyhumansai/core
brew install openhuman
openhuman --version
open -a OpenHuman

# L'app tourne ? (processus OpenHuman visible)
pgrep -lf -i openhuman || ps aux | grep -i openhuman | grep -v grep

# Installer et lancer Ollama en arrière-plan
brew install ollama
brew services start ollama

# Petit modèle pour test de connectivité
ollama pull llama3.2

# Test API : JSON avec liste models
curl -s http://127.0.0.1:11434/api/tags | head -c 400
echo

# GUI : Settings → Models / Providers
#   - Cloud : clé Anthropic (sk-ant-...) ou OpenAI
#   - Local : Base URL http://127.0.0.1:11434, modèle ex. llama3.2

# Ne pas mettre la clé dans l'historique shell ; export temporaire :
read -s ANTHROPIC_API_KEY && export ANTHROPIC_API_KEY
# (saisie sans echo ; puis unset ANTHROPIC_API_KEY)

# Tester la clé Anthropic indépendamment d'OpenHuman
curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-4-20250514","max_tokens":32,"messages":[{"role":"user","content":"ping"}]}' \
  | head -c 300
echo

# GUI : Connections / Integrations → Connect
#   Ordre suggéré : Gmail → Google Calendar → GitHub
# Après OAuth navigateur : Connected / Active dans l'app

# Si proxy bloque, tester HTTPS sortant :
curl -sI https://github.com | head -5
curl -sI https://accounts.google.com | head -5

# Laisser OpenHuman 5–20 min ; statut sync dans la barre de menu
# Chemin dans Settings → Data / Memory
# Souvent sous Application Support ; recherche grossière :
find ~/Library/Application\ Support -maxdepth 3 -iname '*openhuman*' 2>/dev/null

# Racine Memory Tree connue $MEMORY_DIR — derniers Markdown :
# MEMORY_DIR="…/memory"   # chemin des réglages
# ls -lt "$MEMORY_DIR" | head
# find "$MEMORY_DIR" -name '*.md' -mtime -1 | head

# Échantillon : vrais sujets (mail/réunion/PR) ?
# head -40 "$(find "$MEMORY_DIR" -name '*.md' | head -1)"

# Test 1 — calendrier (Google Calendar connecté)
« Liste mes réunions d'aujourd'hui avec titre et heure de début, en citant la source Memory Tree. »

# Test 2 — GitHub (GitHub connecté)
« Sur quel dépôt ai-je eu des PR fusionnées récemment ? Nom du repo et titre de la PR. »

# Réponses vagues : revenir à l'étape 6 — fichiers .md générés ?

Checklist de première config en 5 minutes

Si vous préférez cocher des cases : cette liste correspond exactement à la section précédente. Le chrono démarre quand l'app est ouverte.

1. Minute 1 : fournisseur modèle — Clé Anthropic / OpenAI dans Settings, ou Base URL Ollama http://127.0.0.1:11434 ; valider avec curl …/api/tags ou sonde Anthropic.
2. Minutes 2–3 : OAuth — Connecter Gmail, Calendar, GitHub ; statut Connected après auth navigateur.
3. Minute 4 : première sync — App active ; find ~/Library/Application Support -iname '*openhuman*' pour le dossier et des .md du jour.
4. Minute 5 : test dialogue — Tests 1 et 2 ; faits concrets = succès.

En pratique, OAuth prend souvent plus d'une minute — comptez cinq minutes de travail actif plus l'attente en arrière-plan. Pour le premier jour, prévoyez plutôt une demi-heure afin que le Memory Tree se remplisse correctement.

Connecter les services et valider le Memory Tree

La sensation de « jumeau numérique » vient du Memory Tree : données tierces normalisées en blocs Markdown ≤3k tokens, SQLite local, export .md ouvrable dans Obsidian. Ne vous fiez pas qu'aux voyants verts — vérifiez que les fichiers existent sur disque :

• Dans l'app, Memory Tree / dossier mémoire : nouveaux fichiers datés d'aujourd'hui.
• Ouvrir un .md : objet d'e-mail, titre de réunion, nom de PR — faits vérifiables, pas des modèles vides.
• Option : backend partagé avec agentmemory pour qu'OpenHuman et Claude Code partagent la mémoire (avancé).

# Nombre de Markdown créés aujourd'hui
find "$MEMORY_DIR" -name '*.md' -mtime -1 2>/dev/null | wc -l

# 3 fragments les plus récents par date de modification
find "$MEMORY_DIR" -name '*.md' -print0 2>/dev/null \
  | xargs -0 ls -lt 2>/dev/null | head -3

# Fichier SQLite à proximité (nom selon version)
find "$MEMORY_DIR/.." -maxdepth 2 -name '*.sqlite' -o -name '*.db' 2>/dev/null
# DB="/path/to/openhuman.db"
# sqlite3 "$DB" ".tables"

Différence avec ChatGPT : le contexte y vit dans la conversation ; chez OpenHuman il est dans des fichiers auditables sur votre disque — une raison du buzz sur GitHub. Contexte produit dans notre retour d'expérience sur cinq jours.

Mac avancé : local vs Mac cloud en continu

OpenHuman est pensé pour un fonctionnement bureau permanent : fermer le capot ralentit la sync. Si le jumeau doit continuer à récupérer des résumés e-mail le soir, un Mac mini toujours en ligne convient — par exemple un Mac cloud ZavCloud en nœud dédié : macOS réel, IP statique, callbacks OAuth stables. Jetons OAuth et fichiers Memory Tree sont sensibles : chiffrement, contrôle d'accès et sauvegardes à part ; évitez Gmail personnel en multi-tenant partagé sans réflexion.

Sur Apple Silicon local, Ollama / MLX permettent l'inférence hors ligne — cohérent avec le local-first : modèles et mémoires sur la machine, seule la sync des intégrations passe par Internet. Pour le dev iOS, Cursor / Claude Code restent les outils de code ; avant le sprint, OpenHuman répond à « le calendrier est-il chargé aujourd'hui ? » — workflows similaires dans Anthropic et Claude Code.

# Après connexion à l'hôte macOS cloud
brew tap tinyhumansai/core && brew install openhuman
openhuman --version

# Sans GUI : certaines versions n'exécutent que le moteur de sync — voir docs officielles
# Conseil : premier OAuth via VNC/partage d'écran, session maintenue connectée

# Éviter veille (selon politique datacenter)
sudo pmset -c sleep 0 displaysleep 0

Dépannage

• App ne s'ouvre pas (macOS) — Réglages → Confidentialité → ouvrir quand même ; ou clic droit → Ouvrir. MDM peut bloquer les paquets non notarisés — DMG signé des Releases.
• Échec callback OAuth — Proxy/VPN, heure système, bloqueur de popups ; réseaux d'entreprise bloquent parfois Composio — whitelist IT.
• Memory Tree vide — Intégrations Connected ; attendre un cycle complet (~20 min) ; Issues pour limites API régionales.
• Agent invente — Mémoires non écrites ou modèle n'utilise pas les outils mémoire ; tester plus étroit, @ sur fichier mémoire si supporté.
• brew install introuvable — D'abord brew tap tinyhumansai/core ; sur Mac Intel vérifier l'architecture dans Releases.

# Échec Homebrew : vider cache et réinstaller
brew update
brew cleanup
brew reinstall openhuman

# Journal crash après plantage
log show --predicate 'process == "OpenHuman"' --last 1h | tail -50

# Ollama actif mais OpenHuman ne se connecte pas
curl -s http://127.0.0.1:11434/api/tags
lsof -i :11434

# Désinstallation complète puis réinstall (brew)
brew uninstall openhuman
rm -rf ~/Library/Application\ Support/*openhuman* 2>/dev/null
brew install openhuman

# Derniers Issues (gh CLI)
gh issue list -R tinyhumansai/openhuman -L 5

git clone https://github.com/tinyhumansai/openhuman.git
cd openhuman
git submodule update --init --recursive
pnpm install
# UI web seule
pnpm dev
# Développement bureau Tauri complet
pnpm dev:app
# Vérification côté Rust
cargo check -p openhuman --lib

FAQ

Faut-il être en ligne ? Installation, OAuth et modèles cloud oui ; fichiers mémoire locaux. Avec Ollama local, dialogue en réseau faible ; sync mail/calendrier toujours en ligne.

C'est gratuit ? Client open source (GPL-3.0) ; APIs modèles et certains connecteurs peuvent facturer — selon votre fournisseur.

Conflit avec Cursor Rules / Claude Code ? Non. OpenHuman n'édite pas le dépôt ; les agents de code ne lisent pas Gmail. Couches séparées.

• Produit — Qu'est-ce que le jumeau OpenHuman
• Skills — Agent Skills et tendance GitHub
• Comparatif — OpenHuman vs OpenClaw