AJEAN

Vos modèles d'IA tournent chez vous, dans un seul binaire : chat, mémoire persistante, accès web, outils et accès à distance chiffré.

AJEAN fournit tout ce qui entoure le modèle : l'interface de chat, les outils de l'assistant, la gestion du service et celle du matériel. Le moteur d'inférence est llama.cpp, qu'AJEAN compile lui-même pour la machine sur laquelle il tourne.

télécharger le binaire  →  ajean llamacpp install  →  ajean edit  →  ajean start  →  c'est parti

Aucune dépendance à l'exécution, aucun flag CMake à retenir, aucun conteneur. Vous obtenez une interface de chat complète et un endpoint compatible OpenAI pour vos outils tiers.

---

Ce que fait AJEAN

Un assistant, pas seulement un modèle. L'interface web offre un chat avec raisonnement affiché, mémoire persistante, compactage automatique du contexte quand la conversation s'allonge, prompt système éditable, et des réglages d'apparence synchronisés entre appareils.

Des outils réels. ajean agent on active d'un seul coup toutes les capacités du modèle sur la machine :

Outil	Rôle
terminal	exécute une commande (bash sous Unix, cmd.exe sous Windows)
write / edit	écrit un fichier, ou le modifie par remplacement exact
mem_*	mémoire Markdown persistante entre les sessions
web_*	recherche et lecture de pages, via Crawl4AI
mcp__*	les outils des serveurs MCP configurés

Le matériel et le moteur, gérés pour vous. ajean llamacpp install clone et compile llama.cpp avec les bons flags pour cette machine : CUDA (capacité de calcul détectée par GPU, donc le multi-GPU fonctionne), ROCm, Metal, Vulkan, ou repli CPU. ajean llamacpp update récupère le dernier commit, arrête le service le temps de recompiler, puis le redémarre.

Un service, pas un script. ajean install écrit l'unité systemd, la règle sudoers et les dossiers. Ensuite start / stop / status / logs. Windows et macOS ont leurs équivalents natifs (voir plus bas).

Plusieurs modèles, un clic. Les presets gardent chacun leur configuration complète ; basculer de l'un à l'autre recharge le modèle sans toucher à un fichier. Les .gguf peuvent vivre sur n'importe quel disque.

Accessible de partout. ajean link ouvre une connexion sortante vers ajean.link, donc aucun port à ouvrir, et cela fonctionne même en CGNAT. Le chat est chiffré de bout en bout : le relais ne voit jamais les conversations.

Démarrage

1. Le binaire

curl -L -o jean https://github.com/nathaninline/ajean/releases/latest/download/jean-linux-amd64
chmod +x ajean
sudo mv ajean /usr/local/bin/ajean

(Autres cibles sur la page Releases : Linux, macOS et Windows, en amd64 et arm64.)

2. Installation et compilation du moteur

sudo ajean install        # unité systemd, sudoers, dossiers
ajean llamacpp install    # compile llama.cpp pour le GPU présent

Nécessite git et cmake, plus le toolkit de l'accélérateur (CUDA, ROCm…) pour l'accélération GPU.

3. Démarrage

ajean edit      # régler MODEL=/chemin/vers/le-modele.gguf
ajean start
ajean test      # vérifier que le modèle répond
ajean web       # http://<hôte>:8090

Commandes

Application :
  app                           lance l'UI web + ouvre le navigateur (auto au double-clic)
  web [PORT]                    UI web seule (défaut :8090)
  chat [prompt-système]         chat dans le terminal

Service :
  start | stop | restart        gérer le service
  status | logs                 état / logs en direct
  enable | disable              démarrage au boot
  edit                          éditer $AJEAN_HOME/config.env
  test | bench [N]              vérifier que le modèle répond / mesurer les tok/s
  vram | gpu [index…]           VRAM / choix des GPU (gpu all = tous)
  set-api-key [clé]             protéger le moteur d'inférence (Bearer)
  set-web-key [clé]             protéger l'API de pilotage

Capacités de l'IA :
  agent [on|off|status]         active TOUS les outils (terminal, fichiers, mémoire)
  memory [off|ondemand|always]  mode mémoire
  internet [on|off|url <url>|key <clé>]   accès web via Crawl4AI

Presets et moteur :
  switch [N]                    changer de preset (configs/)
  llamacpp install|update|status

Accès distant (ajean.link) :
  link <token>                  enregistre le token et démarre le lien
  link start|restart|stop       gérer le service de lien
  link code                     code d'appairage (10 min, usage unique)
  link status|logout

Installation :
  install | uninstall
  update [--check]              mise à jour depuis les releases GitHub
  version

Configuration

Tout vit sous $AJEAN_HOME (/etc/ajean sous Linux/macOS, %ProgramData%\ajean sous Windows). Le service lit config.env :

Clé	Signification	Défaut
BIN	chemin vers llama-server (réglé par llamacpp install)	—
MODEL	nom de fichier ou chemin complet du .gguf	—
HOST / PORT	adresse / port d'écoute	0.0.0.0 / 8080
CTX	taille du contexte	32768
NGL	couches déportées sur le GPU	999
BATCH / UBATCH	batch / micro-batch	2048 / 512
THREADS / THREADS_BATCH	threads CPU	0 (auto)
KV_TYPE (_K / _V)	quantization du cache KV	—
CUDA_VISIBLE_DEVICES	GPU utilisés (réglé par ajean gpu)	tous
REASONING	passthrough du mode raisonnement	—
REASONING_BUDGET	plafond de tokens de réflexion ; -1 = illimité	-1
COMPACT	compactage automatique du contexte (off pour couper)	activé
MEM_MODE	mémoire : off / ondemand / always	always
CRAWL4AI_URL / CRAWL4AI_KEY	serveur d'accès internet	—
EXTRA_ARGS	ajouté tel quel à la ligne de commande du moteur	—

La clé API (ajean set-api-key) vit dans $AJEAN_HOME/.api_key, à part, afin de survivre aux changements de preset.

Modèles sur un autre disque. Les .gguf n'ont pas à résider dans $AJEAN_HOME : dans l'éditeur de preset de l'interface, section Modèle → Dossiers de modèles, ajoutez le dossier voulu. Ses modèles apparaissent dans la liste, groupés par dossier. La liste est enregistrée dans model_dirs.json, donc conservée d'un preset à l'autre.

Variables d'environnement

Variable	Rôle	Défaut
AJEAN_HOME	racine des données	/etc/ajean, %ProgramData%\ajean
AJEAN_MODEL_DIRS	dossiers de modèles (séparés par :, ; sous Windows)	—
JEAN_SERVICE	nom de l'unité systemd	ajean
HF_TOKEN	token Hugging Face pour les modèles privés	—
AJEAN_DL_CONNS	connexions parallèles au téléchargement	—
EDITOR	éditeur pour ajean edit	nano / notepad

Les capacités de l'IA

Mémoire

L'IA tient des pages Markdown sous $AJEAN_HOME/MEMORY/, relues et mises à jour entre les sessions. Trois modes, indépendants du mode agent :

ajean memory always     # (défaut) elle cherche avant de répondre et enregistre d'elle-même
ajean memory ondemand   # outils disponibles, mais utilisés seulement sur demande
ajean memory off        # mémoire coupée

Accès internet

Par défaut, l'IA n'a pas accès au web. En branchant un serveur Crawl4AI, elle gagne web_search (DuckDuckGo), web_open, web_read et web_grep. AJEAN ne fournit pas ce serveur, il s'y branche :

docker run -d -p 11235:11235 --shm-size=1g unclecode/crawl4ai:latest
ajean internet url http://localhost:11235
ajean internet on
ajean internet status

Les outils web ne sont proposés au modèle que si le mode agent est actif, l'accès internet activé et le serveur joignable. Sinon ils n'existent pas, et le modèle ne peut donc pas les inventer.

Serveurs MCP

AJEAN parle le Model Context Protocol : on y branche des serveurs tiers (fichiers, bases de données, API…) et leurs outils s'ajoutent à ceux de l'IA, nommés mcp__<serveur>__<outil>.

La configuration se fait depuis l'interface web (section Serveurs MCP) ou en éditant $AJEAN_HOME/mcp.json, au même format que Claude Desktop, si bien qu'un fichier existant se réutilise tel quel :

{
  "mcpServers": {
    "fs": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"] },
    "api": { "url": "https://exemple.com/mcp" }
  }
}

Les transports stdio et HTTP sont pris en charge. Comme le terminal, un serveur MCP exécute du code sur la machine hôte : ses outils ne sont donnés au modèle que si le mode agent est actif.

Windows

• Pas de systemd : ajean start lance le service en arrière-plan (suivi par fichier PID) ; stop, restart, status et logs agissent dessus, sans droits administrateur. enable / disable ne sont pas gérés, il faut passer par une tâche planifiée.
• AJEAN_HOME vaut %ProgramData%\ajean (repli %LOCALAPPDATA%\ajean).
• ajean install crée seulement le dossier de données et un config.env de départ.
• Le terminal de l'IA passe par cmd.exe. Elle le sait, et écrit ses fichiers par l'outil dédié plutôt que par le shell, ce qui lui permet de produire des scripts contenant des guillemets.

ajean install
ajean edit          # BIN=...\llama-server.exe et MODEL=...\modele.gguf
ajean start
ajean status

ajean llamacpp install compile également sous Windows si git et cmake sont présents ; sinon, récupérer un llama-server.exe pré-compilé et pointer BIN dessus.

macOS

La page Releases publie AJEAN-macos-arm64.zip / AJEAN-macos-amd64.zip, un bundle AJEAN.app. Dézipper, glisser dans Applications, ouvrir : l'interface démarre sur http://localhost:8090, s'ouvre dans le navigateur, et l'icône se pose dans la barre de menus. Pas de fenêtre de Terminal, pas d'icône dans le Dock.

L'application n'est signée qu'en ad-hoc : au premier lancement, faire clic droit → Ouvrir.

Pour un usage en ligne de commande, prendre le binaire nu ajean-darwin-arm64 : hors bundle, il conserve son comportement CLI. Les services passent par launchd.

Accès distant via ajean.link

ajean link ouvre une connexion sortante vers le relais : le serveur reste injoignable depuis l'extérieur, mais reste accessible de partout.

ajean link <token>        # token fourni sur ajean.link
ajean link code           # code d'appairage à saisir dans le portail

Le lien tourne comme un service : la commande rend la main, la connexion continue en tâche de fond. Inutile de lancer ajean web, l'interface est servie dans le tunnel. Le portail donne accès à l'interface du serveur avec un chat chiffré, à la gestion de plusieurs machines, et en option à un endpoint compatible OpenAI.

Il s'agit d'un service optionnel et payant ; tout le reste d'AJEAN est et restera open source et gratuit.

Sécurité : la boîte noire

Le relais est conçu comme un tube aveugle : il transporte les données sans pouvoir les lire.

• Chat chiffré de bout en bout (X25519 + AES-GCM). La clé est dérivée du mot de passe via OPAQUE et ne quitte jamais le navigateur.
• Empreinte vérifiée. ajean link affiche l'empreinte de la clé de la machine, à confirmer une fois dans le portail, ce qui défait toute tentative d'interception par le relais.
• Appairage authentifié. Un code à usage unique (ajean link code) garantit qu'un seul navigateur autorisé pilote le serveur ; même compromis, le relais ne peut pas forger de commande.
• Code servi hors du relais. Le portail provient d'une origine indépendante (GitHub Pages) : le relais ne peut pas injecter de code pour dérober la clé.

Reste visible du relais : des métadonnées techniques (machine en ligne, modèle chargé, VRAM), jamais le contenu des conversations.

Endpoint OpenAI (opt-in)

Pour brancher des outils tiers, AJEAN peut exposer https://<machine>.oai.ajean.link/v1, authentifié par la clé API du serveur. Désactivé par défaut, activable par machine depuis l'interface (panneau Accès OpenAI), sans redémarrage.

Le VPS effectue un simple passthrough SNI : le TLS est terminé sur la machine hôte (Let's Encrypt via TLS-ALPN-01, à travers le tunnel), le relais ne voit que du chiffré.

API de pilotage

ajean web expose une API HTTP pour piloter AJEAN à distance. À protéger avant toute exposition :

ajean set-web-key      # génère une clé

Chaque appel /api/* présente alors Authorization: Bearer <clé> :

Méthode	Endpoint	Rôle
GET	/api/ping	connectivité + validité de la clé
GET	/api/status · /api/vram	état du service · GPU
GET	/api/presets	liste des presets (avec l'actif)
POST	/api/switch {"n":<index>}	changer de modèle
POST	/api/start · /api/stop · /api/restart	piloter le service
POST	/api/chat {"messages":[…]}	chat (flux SSE)

⚠️ La clé voyage en clair en HTTP. Pour une exposition publique, placer un reverse-proxy HTTPS devant, ou utiliser ajean link.

Compiler depuis les sources

Go 1.25+. AJEAN est écrit à 100 % en Go, l'interface est embarquée via go:embed :

git clone https://github.com/nathaninline/ajean.git
cd ajean
CGO_ENABLED=0 go build -o ajean ./cmd/ajean

Compiler AJEAN ne demande que Go. Compiler le moteur llama.cpp demande git, cmake et le toolkit de l'accélérateur.

Arborescence

• cmd/ajean/ : point d'entrée + ressources Windows (icône, versioninfo).
• internal/ajean/ : tout le code, fichiers préfixés par domaine (web_*, chat_*, llm_*, backend_*, relay_*, sys_*, mcp_*) ; carte dans doc.go.
• internal/ajean/ui/ : interface web embarquée. index.html est généré : les sources vivent dans ui/src/. Pour modifier l'interface, éditer ui/src/ puis lancer go generate ./internal/ajean.

Licence

MIT. Le marked.min.js embarqué est Marked, également MIT.