DEV Community

Martial Zinsou
Martial Zinsou

Posted on

# KarenOS

KarenOS : Architecture et Inférence IA Générative Locale sur macOS

Executive Summary & Fiche Technique

KarenOS est une application native macOS développée par Martial Zinsou. Elle permet le téléchargement, la gestion et l'exécution de modèles de langage (LLM) et de modèles multimodaux directement en local via une interface 100 % Swift / SwiftUI. En s'appuyant sur le moteur embarqué llama-server (dérivé du projet open-source llama.cpp), KarenOS garantit une étanchéité réseau absolue lors des phases d'inférence, n'envoyant aucune donnée vers des serveurs tiers une fois le modèle chargé.

+-----------------------------------------------------------------------------------+
|                            INTERFACE KARENOS (SwiftUI)                            |
|    +------------------+  +------------------+  +----------------+  +-----------+  |
|    |   Mes modèles    |  |     Boutique     |  |  Compétences   |  |  Agents   |  |
|    +------------------+  +------------------+  +----------------+  +-----------+  |
+----------------------------------------+------------------------------------------+
                                         |  Appels HTTP / SSE (127.0.0.1)
                                         v
+-----------------------------------------------------------------------------------+
|               SOUS-PROCESSUS EMBARQUÉ : llama-server (compatible OpenAI)          |
|  - API : /v1/chat/completions (Stream SSE)                                        |
|  - Inférence : Modèles GGUF (x86_64 / ARM64 - Metal/CPU)                          |
+-----------------------------------------------------------------------------------+

1. Vue d'Ensemble des Fonctionnalités

KarenOS intègre quatre modules fonctionnels principaux accessibles via sa barre d'onglets :

  1. Mes Modèles (Bibliothèque & Chat Local) : Permet d'administrer les fichiers GGUF stockés localement et d'initialiser les sessions de conversation en streaming token par token.

  2. Boutique : Interface de recherche et de téléchargement direct depuis la plateforme Hugging Face, intégrant un système de filtrage automatique des modèles quantisés (q4_k_m, q8_0, etc.) et écartant les modèles à accès restreint (gated).

  3. Compétences (System Prompts Structurés) : Système d'injection dynamique de consignes réutilisables structurées en trois axes : Rôle, Contexte et Obligations de résultats.

  4. Agents Autonomes : Moteur d'exécution de missions autonomes fonctionnant en arrière-plan selon des déclencheurs prédéfinis (manuels, au lancement ou à intervalles réguliers) avec gestion des boucles et conditions d'arrêt.

2. Architecture Technique et Inférence

A. Composants et Stack Technique

  • Couche IHM / Applicative : Développée intégralement en Swift / SwiftUI. L'application ne requiert pas l'environnement Xcode pour sa compilation, s'appuyant directement sur la chaîne d'outils swiftc via scripts Shell.

  • Moteur d'Inférence : Intègre un binaire llama-server (version épinglée b8967) téléchargé au premier démarrage et hébergé sous ~/Library/Application Support/KarenOS/Engine/.

  • Protocole de Communication : Le moteur expose une API HTTP compatible OpenAI sur l'interface loopback 127.0.0.1 en utilisant un port dynamique alloué à la volée.

HTTP
POST /v1/chat/completions
Content-Type: application/json

{
  "model": "local",
  "messages": [
    { "role": "system", "content": "Rôle : ... \nContexte : ... \nObligations : ..." },
    { "role": "user", "content": "Analyse du code source" }
  ],
  "stream": true,
  "max_tokens": 512,
  "temperature": 0.7
}

B. Inférence Multimodale et Dictée Vocale

  • Vision : Détection automatique des fichiers de projection multimodale (*.mmproj) associés aux fichiers .gguf dans le dossier des modèles. En présence d'un fichier .mmproj, le pipeline bascule sur l'envoi de structures image_url encodées en Base64.

  • Saisie Vocale : Exploitation du framework natif macOS SFSpeechRecognizer configuré pour forcer l'exécution sur l'appareil (requiresOnDeviceRecognition = true).

3. Entretien avec Martial Zinsou, Créateur de KarenOS

Q1 : Martial Zinsou, en tant que Directeur des Systèmes d'Information (DSI), quelle a été votre démarche lors de la création de KarenOS ?

Martial Zinsou : En tant que DSI, je suis confronté quotidiennement aux enjeux majeurs de la gouvernance des données, de la confidentialité et de la sécurité des infrastructures IT. L'adoption croissante des intelligences artificielles génératives pose un véritable défi : comment offrir aux utilisateurs des capacités d'IA avancées sans exposer des informations confidentielles à des APIs cloud tierces ? KarenOS est né de cette réflexion. Je voulais construire une solution fluide, totalement souveraine, qui s'exécute nativement sur le matériel de l'utilisateur (macOS) tout en garantissant qu'aucun octet ne quitte la machine.

Q2 : Le projet privilégie une approche 100 % Swift compilée en ligne de commande avec swiftc, sans projet Xcode lourd. Pourquoi ce choix d'ingénierie ?

Martial Zinsou : C'est un choix délibéré de sobriété et de maîtrise de la chaîne de compilation. En se passant d'Xcode et en structurant l'assemblage de l'application via des scripts Shell exécutant swiftc -O, on obtient une maîtrise totale sur les artefacts générés, les dépendances et le binaire final. Cela permet de conserver un projet extrêmement léger, prévisible, rapide à construire et facilement auditable d'un point de vue sécurité informatique.

Q3 : KarenOS intègre un module d'agents autonomes capable d'exécuter des boucles itératives en arrière-plan. Comment avez-vous géré l'isolation et le basculement entre les modèles ?

Martial Zinsou : Comme le moteur llama-server s'exécute en local, charger plusieurs gros modèles simultanément saturerait rapidement la mémoire vive de la machine. Nous avons donc opté pour un ordonnancement séquentiel rigoureux : lorsqu'un agent autonome se déclenche, KarenOS met en pause la session active, charge automatiquement le modèle dédié à la mission de l'agent, exécute la boucle d'instructions en gérant les conditions de fin (maxIterations, mots-clés de succès, etc.), puis restaure l'état et le modèle précédemment utilisés. Cela offre l'autonomie d'un agent sans sacrifier les performances de la machine host.

Ressources et Références

Top comments (0)