[{"id":"blog:clix-twitter-terminal-sans-api","title":"clix : le CLI X/Twitter sans API qui peut intéresser tous les builders d’agents","description":"clix permet de lire et piloter X/Twitter depuis le terminal sans API officielle. Voilà pourquoi c’est intéressant, où ça brille, et où ça peut te faire perdre du temps.","date":"2026-03-27T00:00:00.000Z","tags":["ai","tool","openclaw","tutorial"],"authors":[],"url":"/blog/clix-twitter-terminal-sans-api","content":"Twitter/X a tué l’accès API gratuit, et depuis, tout le monde bricole des solutions bancales pour faire de la veille, récupérer des posts, ou brancher un agent sur le réseau social où naissent la moitié des démos AI. Et puis je suis tombé sur **clix** : un CLI qui promet d’utiliser X/Twitter **sans API officielle**, via les cookies du navigateur. En gros : tu te logges dans ton navigateur, et l’outil essaie d’exploiter cette session pour te donner un vrai terminal Twitter. Sur le papier, c’est assez sexy. Dans la vraie vie, c’est à la fois **vraiment utile** et **un peu cowboy**. ## C’est quoi clix exactement ? Le repo est là : Le pitch est simple : - lire le feed - chercher des tweets - récupérer des profils - voir les tendances - parcourir bookmarks et listes - accéder aux DMs - et même faire des actions d’écriture : poster, liker, retweeter, bookmarker, suivre, supprimer… Le tout **sans clé API**, parce que l’auth passe par des cookies navigateur ou des tokens déjà présents. Dit autrement : c’est une sorte de **Twitter client pour terminal**, pensé aussi pour être utilisé par des scripts et des agents. ## Pourquoi c’est intéressant maintenant Le vrai intérêt de clix, ce n’est pas juste “Twitter dans le terminal”. Le vrai intérêt, c’est qu’il coche trois cases qui parlent immédiatement à n’importe qui qui bidouille avec des agents : ### 1. Plus besoin de se battre avec l’API officielle Pas de demande d’accès développeur, pas de setup OAuth chiant, pas de quotas qui changent tous les trois jours parce qu’un produit a décidé d’exister autrement. Tu utilises une session navigateur déjà authentifiée, point. ### 2. La sortie est pensée pour les scripts clix supporte du `--json`, du `--yaml`, du `--compact`, du `--full-text`. Ça, c’est franchement bien vu. Parce qu’un outil agentique qui crache juste du texte joli pour humains, c’est marrant cinq minutes. Un outil qui sait renvoyer de la donnée exploitable proprement, là ça devient immédiatement branchable dans un workflow. ### 3. Il expose aussi un serveur MCP Ça veut dire que tu peux imaginer un agent qui : - lit X pour faire de la veille - repère les posts intéressants sur un sujet - extrait des threads - sauvegarde des signaux faibles - te prépare un résumé - ou dans le pire des cas, t’aide à poster depuis un environnement contrôlé Pour OpenClaw, ce genre d’outil est exactement dans la zone “potentiellement très cool, potentiellement très relou”. ## Là où clix brille vraiment Après lecture du repo et tests d’installation, voilà les usages qui me paraissent les plus solides. ### Veille X/Twitter depuis le terminal C’est probablement le meilleur use case. Tu peux chercher des posts récents sur un sujet, surveiller un compte, lister les tendances, parcourir tes bookmarks, ou exporter le contenu d’un tweet/thread. Pour quelqu’un qui fait de la veille AI, c’est super tentant. Exemples typiques : ```bash clix search \"openclaw\" --type latest --json clix trending --json clix user thomasgermain93 --json clix bookmarks --json ``` ### Récupération propre pour un agent Le mode `--compact` ou `--json` est exactement ce qu’on veut quand on branche un outil à un agent. Tu peux limiter le bruit, récupérer juste ce qu’il faut, puis laisser l’agent filtrer, résumer ou classer. ### Petit couteau suisse perso Pour un builder solo, le concept est séduisant : un seul outil pour lire, chercher, télécharger des médias, gérer listes et bookmarks, voire faire quelques actions simples. Pas besoin de monter une intégration API complète juste pour aller lire 20 tweets. ## Là où ça devient vite casse-couilles Et maintenant la partie moins glamour. ### 1. Ça dépend de cookies navigateur C’est le cœur de la proposition… et aussi sa fragilité. Si ton navigateur n’est pas loggé, si l’extraction de cookies échoue, si la machine n’a pas de session desktop propre, si X change un truc, si le navigateur stocke différemment, tu peux te retrouver coincé comme un con. C’est exactement ce qui m’est arrivé sur le VPS : - installation OK - CLI OK - skill OpenClaw créé - mais auth impossible parce qu’aucun cookie X exploitable n’était disponible sur la machine Et quand on a essayé de se connecter côté navigateur du VPS, X a commencé à faire son numéro de parano habituel. ### 2. Un VPS n’est pas ton MacBook C’est un point important. Une machine distante, une session bureau bricolée, Chrome Remote Desktop, un navigateur “suspect”, une IP VPS, et d’un coup X se comporte comme un videur de boîte de nuit sous coke. Pour ce genre d’outil, **la meilleure machine est souvent ton laptop perso**, là où : - tu es déjà loggé à X - tu as ton navigateur habituel - tu n’as pas une IP de datacenter qui hurle “automatisation” ### 3. Les actions d’écriture sont sensibles Lire X, faire de la veille, récupérer des threads : cool. Poster, supprimer, liker, DM, follow, bloquer ? Là, on change de catégorie. Dès qu’un agent peut écrire sur un réseau social, tu veux des garde-fous. Pas demain. Tout de suite. Parce qu’un agent qui lit des tweets, c’est une commodité. Un agent qui poste une connerie publiquement, c’est une autre histoire. ## Est-ce que j’utiliserais clix en prod ? Réponse honnête : **oui pour certains usages, non comme brique critique unique**. ### Oui pour : - veille perso - recherche ponctuelle - récupération de tweets / threads / comptes - extraction de signaux pour un agent - expérimentation rapide ### Non comme dépendance critique unique pour : - un pipeline métier important - un système de posting automatisé sans supervision - un workflow qui doit être fiable 24/7 En gros : **clix est un super outil de builder, pas une garantie contractuelle.** Et ce n’est pas une insulte. C’est déjà beaucoup. ## Ce que j’ai fait de mon côté J’ai quand même poussé l’expérimentation un cran plus loin. J’ai : - installé `clix0` dans un venv local propre - vérifié que le CLI tournait - créé un skill OpenClaw dédié pour s’en servir sans faire n’importe quoi - documenté les commandes utiles et les garde-fous sur les actions d’écriture Donc même si l’auth n’a pas abouti sur le VPS, la partie intégration est prête. Le binaire local était : ```bash /home/ubuntu/.openclaw/workspace/tools/clix/.venv/bin/clix ``` Et franchement, c’est le bon compromis : environnement isolé, pas de pollution du système, skill prêt pour les prochains tests. ## Mon verdict **clix vaut clairement le détour** si tu construis des agents, des workflows de veille, ou des outils perso autour de X/Twitter. Le projet est malin parce qu’il contourne une vraie douleur du moment : l’accès API officiel est devenu relou, cher, ou simplement pas adapté à des expérimentations rapides. Mais il faut le prendre pour ce qu’il est : - un outil puissant - pratique - potentiellement très utile - mais construit sur une couche d’auth fragile et un terrain (X) notoirement instable Donc oui, je le garde dans ma boîte à outils. Mais je ne parierais pas toute une usine dessus sans plan B. ## Si tu veux le tester Le repo officiel : Et si tu veux la version ultra simple de l’idée : 1. installe `clix0` 2. authentifie-toi depuis **ta vraie machine**, pas un VPS chelou 3. commence par les commandes de lecture 4. ne laisse pas un agent poster sur X sans validation explicite Ça t’évitera quelques conneries. ## Sources - clix sur GitHub : - PyPI :"},{"id":"tutorial:clix-demarrage-rapide-twitter-terminal","title":"Tutoriel clix : démarrage rapide pour utiliser X/Twitter depuis le terminal","description":"Installer clix, vérifier l’authentification, lancer ses premières recherches et éviter les pièges classiques quand on utilise X/Twitter depuis le terminal.","date":"2026-03-27T00:00:00.000Z","tags":["tutorial","tool","ai","openclaw"],"authors":[],"url":"/tutoriel/clix-demarrage-rapide-twitter-terminal","content":"Si tu veux lire X/Twitter depuis le terminal sans passer par l’API officielle, **clix** est probablement l’un des outils les plus intéressants du moment. Le repo officiel : Dans ce tutoriel, on va faire simple : - installer clix - vérifier qu’il marche - se connecter - lancer les premières commandes utiles - éviter les pièges classiques ## Ce qu’il faut comprendre avant de commencer clix ne repose pas sur l’API officielle X. À la place, il s’appuie sur : - les cookies de ton navigateur - ou des tokens déjà présents/configurés La conséquence est simple : **la meilleure machine pour utiliser clix, c’est généralement ton ordinateur personnel**, pas un VPS sorti de nulle part. Pourquoi ? Parce que sur ton laptop : - tu es déjà connecté à X - ton navigateur est déjà reconnu - l’extraction des cookies a plus de chances de marcher - X a moins de raisons de paniquer ## Installation La doc du projet propose : ```bash uv pip install clix0 ``` Si tu préfères un environnement isolé, tu peux aussi passer par un venv Python. Exemple : ```bash python3 -m venv .venv source .venv/bin/activate pip install -U pip pip install clix0 ``` ## Vérifier que le CLI répond Commence par : ```bash clix --help ``` Puis lance un diagnostic : ```bash clix doctor ``` Et vérifie le statut de l’auth : ```bash clix auth status ``` Si tu vois `Not authenticated`, c’est normal tant que tu n’as pas connecté de session X exploitable. ## Se connecter La commande de base est : ```bash clix auth login ``` clix va essayer d’extraire les cookies depuis un navigateur compatible. ### Si ça marche Parfait. Tu peux passer à la suite. ### Si ça échoue Le message classique ressemble à ça : - `Could not extract cookies` - ou une erreur de login côté X Dans ce cas, vérifie dans cet ordre : 1. tu es bien connecté à X dans ton navigateur local 2. tu n’es pas dans une session trop exotique (VPS, remote desktop bizarre, navigateur jetable) 3. tu utilises un navigateur supporté 4. tu n’essaies pas de faire ça depuis une IP ou une machine que X trouve suspecte Si tu testes depuis un VPS, ne sois pas surpris si X te fait perdre ton temps. ## Premières commandes utiles ### Voir le feed ```bash clix feed --type for-you --count 20 ``` Ou pour un rendu plus propre côté script : ```bash clix feed --type following --count 20 --json ``` ## Chercher des tweets ```bash clix search \"openclaw\" --type latest --json ``` Types utiles : - `top` - `latest` - `photos` - `videos` ## Voir un profil ```bash clix user thomasgermain93 --json ``` ## Voir un tweet précis ```bash clix tweet 1900000000000000000 --json ``` ## Récupérer ses bookmarks ```bash clix bookmarks --json ``` ## Voir les tendances ```bash clix trending --json ``` ## Sorties utiles pour les scripts et agents Un des gros intérêts de clix, c’est qu’il ne pense pas seulement aux humains. Tu peux choisir des formats adaptés à l’automatisation : ### JSON ```bash clix search \"llm\" --type latest --json ``` ### YAML ```bash clix feed --yaml ``` ### Format compact ```bash clix feed --compact ``` ### Texte complet ```bash clix tweet 1900000000000000000 --full-text ``` ## Télécharger des médias ```bash clix download --output-dir /tmp/clix-media ``` Pratique si tu veux récupérer une vidéo, une image ou archiver des assets liés à un thread. ## Listes et dossiers de bookmarks ### Lister les listes ```bash clix lists --json ``` ### Voir une liste ```bash clix lists view --json ``` ### Voir les dossiers de bookmarks ```bash clix bookmarks-folders --json ``` ### Voir le contenu d’un dossier ```bash clix bookmarks-folder --json ``` ## MCP : brancher clix à un agent clix expose aussi un serveur MCP : ```bash clix mcp ``` C’est utile si tu veux brancher l’outil à un client compatible MCP. Mais pour commencer, reste simple : utilise d’abord le CLI direct, vérifie que l’auth marche, puis seulement ensuite pense à l’intégration agentique. ## Les commandes d’écriture : prudence clix sait aussi faire des actions comme : - poster - liker - retweeter - suivre - envoyer des DMs - supprimer un tweet Exemples : ```bash clix post \"hello world\" clix like clix retweet clix dm send \"message\" clix delete ``` Oui, c’est puissant. Mais non, je ne te conseille pas de brancher ça à un agent en roue libre. Le bon réflexe : - commencer par les commandes de lecture - réserver les commandes d’écriture aux actions validées explicitement ## Les pièges les plus fréquents ### 1. Tester depuis un VPS Mauvaise idée pour démarrer. Tu risques de te prendre : - des problèmes de cookies - une session navigateur pas propre - des refus de X - une extraction d’auth qui ne marche pas ### 2. Croire que “sans API” veut dire “sans fragilité” Ce n’est pas parce que tu évites l’API officielle que tout devient magique. Tu échanges juste une dépendance API contre une dépendance navigateur/session/cookies. ### 3. Oublier les formats de sortie Si tu veux automatiser un truc, utilise `--json` ou `--compact`. Sinon tu vas parser du texte humain moche pour rien. ## Workflow recommandé pour démarrer Si je voulais tester clix proprement aujourd’hui, je ferais exactement ça : 1. installer `clix0` sur mon laptop 2. vérifier `clix --help` 3. lancer `clix doctor` 4. faire `clix auth login` 5. tester `clix auth status` 6. lancer une recherche simple avec `clix search \"openclaw\" --type latest --json` 7. tester le feed et les bookmarks 8. seulement après envisager un usage avec agent ou MCP ## Mon conseil final clix est un outil franchement malin, surtout pour : - la veille - la recherche - l’exploration de X depuis le terminal - les agents qui ont besoin de lire des signaux sociaux Mais si tu veux éviter de te faire mal dès le début : **teste-le d’abord sur ta machine perso, pas sur un VPS.** Tu économiseras du temps, de la frustration, et probablement quelques insultes gratuites envers X. ## Sources - Repo GitHub : - PyPI :"},{"id":"blog:opensrc-vs-context7","title":"OpenSrc vs Context7 : pourquoi OpenSrc est plus puissant pour les vrais chantiers code","description":"OpenSrc va plus loin que Context7 quand ton agent AI doit lire le vrai code d'une dépendance, pas juste sa doc.","date":"2026-03-13T00:00:00.000Z","tags":["ai","coding","tool","opensrc","context7","opinion"],"authors":[],"url":"/blog/opensrc-vs-context7","content":"Tu veux que ton agent code mieux ? Il lui faut du **contexte fiable**. Le débat du moment, c’est souvent : **Context7** ou **OpenSrc**. Mon verdict après tests : **OpenSrc est meilleur dès que tu fais du vrai dev produit**, pas juste du “copier-coller de snippets doc”. ## TL;DR - **Context7** est excellent pour récupérer de la doc à jour rapidement. - **OpenSrc** est meilleur quand l’agent doit comprendre l’implémentation interne d’une librairie. - Si tu dois choisir un seul outil pour des fixes complexes : **OpenSrc**. --- ## Le problème réel des agents de code Un agent qui ne voit que : 1) les types, 2) la doc, 3) quelques exemples, …rate souvent les cas tordus. Pourquoi ? Parce que la vérité est souvent dans : - les conditions edge-case, - les helpers internes, - les fallback silencieux, - l’ordre exact des effets de bord, - les vieux comportements gardés pour compatibilité. Et ça, c’est rarement bien documenté. ## Ce qu’OpenSrc fait différemment Le repo `vercel-labs/opensrc` est simple dans l’idée et très bon dans l’exécution : - tu demandes un package (`opensrc zod`), - il détecte la bonne version via lockfile, - il récupère le code source correspondant, - il le stocke localement dans `opensrc/` pour que ton agent puisse le lire. Il sait aussi récupérer des repos GitHub directement (`owner/repo`, URL GitHub, tag/branche), ce qui est ultra pratique pour auditer un comportement précis. ### Pourquoi c’est un game changer Parce que tu passes de : > “voici la doc officielle de l’API” à : > “voici exactement ce que le code exécute en prod”. Et pour débugger, c’est la différence entre un patch fragile et un fix solide. --- ## Pourquoi OpenSrc est mieux que Context7 (dans les gros chantiers) Je vais être direct : **Context7 est top pour la vitesse**, mais **OpenSrc gagne sur la profondeur**. ### 1) Implémentation réelle > documentation Context7 t’aide à injecter de la doc/version dans le prompt. Très utile. Mais OpenSrc donne accès au code source, donc : - logique exacte, - interactions internes, - comportements non documentés, - historique implicite du design. Sur des bugs compliqués, c’est ce qui fait gagner du temps. ### 2) Moins d’hallucinations sur les internals Un agent qui n’a que de la doc invente plus facilement des comportements. Un agent qui lit le code d’origine hallucine moins, parce qu’il peut citer la fonction/condition réelle. ### 3) Debug reproductible en local Avec OpenSrc, les sources sont dans ton repo de travail (`opensrc/...`). Tu peux : - grep, - tracer, - comparer, - relire offline, - garder un état stable pour l’équipe. Ça colle mieux à un workflow engineering pro. ### 4) Alignement avec ta version installée OpenSrc se cale sur la version détectée dans le lockfile. Donc ton agent raisonne sur **ta réalité runtime**, pas une doc d’une version voisine. C’est crucial quand un bug n’existe que sur une sous-version. ### 5) Super complément des worktrees/agents Si tu bosses en multi-agent (Kilo/Codex/etc.), OpenSrc donne un référentiel concret partagé. Chaque agent peut inspecter le même source dump au lieu de partir en freestyle. --- ## Là où Context7 reste excellent Je ne vais pas raconter n’importe quoi : Context7 reste très utile. Il est très bon pour : - setup rapide, - récupérer des exemples API, - onboarding d’une techno, - répondre vite à “comment faire X avec Y”. Donc non, ce n’est pas “nul”. C’est juste un autre niveau de profondeur. --- ## Le bon framing : ce n’est pas un duel absolu Le meilleur workflow est souvent : 1. **Context7** pour cadrer vite l’API attendue, 2. **OpenSrc** pour valider la vérité d’implémentation, 3. patch + test sur ton code. Mais si tu me forces à choisir un seul pour des tickets difficiles : **OpenSrc**. --- ## Cas concret où OpenSrc écrase la doc Imagine un bug de rollback d’état lié à une lib de state management. La doc dit : “update atomically”. Mais dans le code, tu découvres : - un guard temporel, - un merge conditionnel, - et un fallback de sync si un token manque. C’est ce détail interne qui explique ton bug. Context7 te donne la théorie. OpenSrc te donne la preuve. --- ## Limites à connaître (honnêtement) OpenSrc n’est pas magique : - ça ajoute du volume local, - il faut gérer ce que tu gardes/supprimes, - sur certains packages, la correspondance source/tag peut demander vérification, - ça ne remplace pas les tests. Mais en échange, tu gagnes la qualité la plus chère en dev IA : **la fiabilité**. ## Conclusion Si ton but est “faire répondre l’agent plus vite”, Context7 suffit souvent. Si ton but est “faire merger des PR qui tiennent en prod”, OpenSrc est au-dessus. Et c’est exactement pour ça que ce projet peut devenir un standard dans les stacks AI coding sérieuses. --- ## Sources - OpenSrc (Vercel Labs) : - Context7 (Upstash) : - Site Context7 :"},{"id":"blog:google-colab-lab-ia-gratuit","title":"Google Colab en 2026 : le labo IA gratuit qui évite de cramer ton laptop","description":"Pourquoi Google Colab reste un incontournable pour coder, entraîner et tester des modèles IA sans GPU local. Cas d’usage, limites et bonnes pratiques.","date":"2026-03-10T00:00:00.000Z","tags":["ai","tool","tutorial","productivite"],"authors":["example-author"],"url":"/blog/google-colab-lab-ia-gratuit","content":"Si tu fais de l’IA sans machine de guerre à la maison, **Google Colab** reste une valeur sûre. Tu ouvres un notebook dans le navigateur, tu lances du Python, et en quelques clics tu récupères CPU/GPU/TPU côté Google. Pas besoin de config CUDA pendant 3 heures, pas besoin d’acheter une RTX juste pour tester une idée. ## C’est quoi Colab, concrètement ? Google Colab, c’est un environnement Jupyter hébergé dans le cloud avec : - exécution Python dans le navigateur ; - notebooks partagés via Google Drive ; - accès à des accélérateurs matériels (GPU/TPU selon la formule) ; - intégration simple avec GitHub, Drive, datasets en ligne. Le gros avantage : tu passes de “j’ai une idée” à “ça tourne” en quelques minutes. ## Pourquoi c’est encore pertinent en 2026 On pourrait croire que Colab est “juste pour débutants”. C’est faux. ### 1) Prototyper vite Tu veux tester un modèle, un pipeline RAG, un script d’inférence ? Tu crées un notebook, `pip install`, run. Fin. ### 2) Collaborer sans friction Un notebook partagé, des commentaires, des cellules reproductibles : pour bosser à plusieurs, c’est ultra efficace, surtout pour le debug et les démos. ### 3) Faire des POC IA sans coût initial Pour beaucoup de projets, la version gratuite suffit pour valider une hypothèse avant de passer sur du payant ou de l’infra dédiée. ## Les limites (et elles sont réelles) Colab n’est pas magique. Si tu l’utilises sérieusement, tu dois connaître ses contraintes. - **Sessions temporaires** : l’instance peut expirer ; - **Stockage éphémère** : ce qui est local dans la VM peut disparaître ; - **GPU non garanti** en gratuit ; - **Quota d’utilisation** variable ; - **Pas idéal pour la prod** : c’est un labo, pas une plateforme de déploiement. En clair : Colab est excellent pour explorer, moins pour industrialiser. ## Le setup “propre” que je recommande Si tu veux éviter les emmerdes classiques : 1. Monte Google Drive dès le début pour sauvegarder modèles, checkpoints et exports. 2. Épingle les versions critiques (`pip install package==x.y.z`) pour la reproductibilité. 3. Centralise ta config (variables, chemins, seeds) dans une cellule dédiée. 4. Sauvegarde régulièrement vers Drive ou Hugging Face Hub. 5. Prévois un fallback CPU si le GPU n’est pas dispo. Un notebook qui “marche une fois” ne vaut rien. Un notebook reproductible, c’est de l’or. ## Cas d’usage parfaits pour Colab - apprendre PyTorch / TensorFlow ; - fine-tuner un petit modèle ; - tester une librairie IA rapidement ; - faire du data cleaning + visualisation ; - construire un POC avant migration vers un vrai stack (RunPod, Modal, Kubernetes, etc.). ## Quand il faut passer à autre chose Tu devrais sortir de Colab si : - tu entraînes des modèles lourds de façon répétée ; - tu as besoin de jobs longs/stables ; - ton équipe dépend de pipelines CI/CD ; - tu dois servir des prédictions en production avec SLA. À ce stade, Colab reste utile pour l’exploration, mais l’exécution principale doit vivre ailleurs. ## Colab + GitHub = combo efficace Un workflow simple et solide : - code source versionné sur GitHub ; - notebook Colab pour expérimenter ; - export des scripts propres vers le repo ; - exécution “sérieuse” sur une infra adaptée. Ça évite de transformer un notebook en monolithe ingérable. ## Conclusion Google Colab n’est pas le “jouet gratuit” qu’on caricature parfois. C’est un excellent environnement de **prototypage IA rapide**, surtout quand tu veux avancer vite sans te battre avec l’infra. Le bon mindset : - utilise Colab pour apprendre, tester, itérer ; - documente ton travail ; - migre vers une stack dédiée dès que ton projet devient sérieux. En bref : **Colab est un labo. Pas l’usine. Et c’est exactement pour ça qu’il est si utile.**"},{"id":"tutorial:google-colab-demarrage-rapide","title":"Tutoriel Google Colab : de zéro à ton premier notebook IA en 15 minutes","description":"Guide pas-à-pas pour démarrer avec Google Colab : création de notebook, activation GPU, installation de dépendances, Drive et export GitHub.","date":"2026-03-10T00:00:00.000Z","tags":["tutorial","ai","tool","google-colab"],"authors":["example-author"],"url":"/tutoriel/google-colab-demarrage-rapide","content":"# Tutoriel Google Colab : de zéro à ton premier notebook IA en 15 minutes Si tu veux coder un projet IA sans rien installer localement, Google Colab est parfait. Objectif de ce tuto : - créer un notebook ; - activer le GPU ; - installer des dépendances ; - charger un dataset ; - lancer un mini entraînement ; - sauvegarder le travail. --- ## 1) Créer ton notebook Colab 1. Va sur [https://colab.research.google.com](https://colab.research.google.com) 2. Connecte-toi avec ton compte Google 3. Clique sur **Nouveau notebook** Tu arrives sur une interface avec des cellules de code Python. --- ## 2) Vérifier la version Python Dans la première cellule, colle : ```python import sys print(sys.version) ``` Clique sur ▶️ pour exécuter. --- ## 3) Activer un GPU 1. Menu **Exécution** → **Modifier le type d’exécution** 2. Dans *Accélérateur matériel*, choisis **GPU** 3. Sauvegarde Teste ensuite : ```python import torch print(\"CUDA dispo:\", torch.cuda.is_available()) if torch.cuda.is_available(): print(\"GPU:\", torch.cuda.get_device_name(0)) ``` Si `True`, c’est bon. --- ## 4) Installer tes dépendances Dans Colab, préfixe avec `!` pour lancer une commande shell : ```python !pip install -q transformers datasets scikit-learn matplotlib ``` Ajoute `==version` si tu veux figer des versions exactes. --- ## 5) Connecter Google Drive (recommandé) Pour éviter de perdre tes fichiers : ```python from google.colab import drive drive.mount('/content/drive') ``` Tu pourras sauvegarder dans : `/content/drive/MyDrive/...` --- ## 6) Charger un petit dataset Exemple avec `datasets` : ```python from datasets import load_dataset ds = load_dataset(\"imdb\") print(ds) print(ds[\"train\"][0]) ``` --- ## 7) Mini entraînement (baseline simple) Exemple ultra rapide avec scikit-learn (CPU/GPU peu importe) : ```python from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score # Petit subset pour aller vite train_texts = ds[\"train\"][\"text\"][:3000] train_labels = ds[\"train\"][\"label\"][:3000] test_texts = ds[\"test\"][\"text\"][:1000] test_labels = ds[\"test\"][\"label\"][:1000] vec = TfidfVectorizer(max_features=20000) X_train = vec.fit_transform(train_texts) X_test = vec.transform(test_texts) clf = LogisticRegression(max_iter=300) clf.fit(X_train, train_labels) preds = clf.predict(X_test) print(\"Accuracy:\", accuracy_score(test_labels, preds)) ``` Tu obtiens un premier pipeline NLP fonctionnel en quelques minutes. --- ## 8) Sauvegarder un artefact modèle ```python import joblib output_path = \"/content/drive/MyDrive/colab/models/imdb_baseline.joblib\" joblib.dump((vec, clf), output_path) print(\"Sauvegardé:\", output_path) ``` --- ## 9) Exporter vers GitHub Dans Colab : - **Fichier → Enregistrer une copie dans GitHub** Astuce : garde un repo avec : - `notebooks/` pour les `.ipynb` - `src/` pour le code Python propre - `requirements.txt` pour les dépendances --- ## 10) Problèmes fréquents (et solutions) ### “Mon runtime redémarre tout seul” - Réduis l’usage RAM - Évite de charger tout le dataset en mémoire - Sauvegarde souvent vers Drive ### “Je n’ai pas de GPU” - Réessaie plus tard - Vérifie le type d’exécution - Si besoin intensif, passe à Colab payant ### “J’ai perdu mes fichiers” - Tout ce qui est dans `/content` est temporaire - Stocke les outputs dans Drive --- ## Checklist rapide avant de fermer Colab - [ ] Notebook renommé proprement - [ ] Dépendances notées - [ ] Résultats sauvegardés dans Drive - [ ] Copie poussée sur GitHub --- ## Et après ? Prochaine étape logique : - passer de notebook à script Python réutilisable ; - automatiser les runs ; - déployer sur une infra plus stable si ton projet grossit. Pour démarrer vite et proprement, Colab fait le job. Pour la prod, pense migration."},{"id":"blog:migration-wordpress-vers-astro-tinacms-cloudflare","title":"De WordPress à Astro en 1 week-end : le tutoriel complet (sans casser ton SEO)","description":"Plan pas à pas pour migrer un blog WordPress vers Astro + TinaCMS + Cloudflare Workers, avec perfs élevées et risque minimal.","date":"2026-03-07T11:30:00.000Z","tags":["wordpress","astro","tutorial","cloudflare","seo"],"authors":[],"url":"/blog/migration-wordpress-vers-astro-tinacms-cloudflare","content":"Tu veux quitter WordPress pour un stack plus rapide et plus propre sans flinguer ton SEO ? Voici un plan concret, orienté exécution : **Astro 5 + TinaCMS + Cloudflare**. Objectif : migrer sans panique, garder tes URLs, et publier vite. ## Stack cible - **Astro 5** : génération de pages ultra légères - **TinaCMS** : édition du contenu sans revenir à une usine à plugins - **Cloudflare Pages/Workers** : déploiement rapide + edge ## Avant de commencer (checklist critique) 1. Fais un backup complet WordPress (DB + uploads) 2. Exporte la liste des URLs existantes 3. Identifie tes pages qui font du trafic SEO 4. Liste tes plugins “vraiment indispensables” 5. Gèle les gros changements éditoriaux pendant la migration Ne saute pas cette étape. C’est elle qui évite 80% des regrets. ## Étape 1 — Initialiser Astro ```bash npm create astro@latest cd mon-blog npm install npm run dev ``` Choisis un template blog simple pour aller vite. ## Étape 2 — Structurer ton contenu Crée une collection de contenu Astro : ```ts // src/content/config.ts import { z, defineCollection } from 'astro:content'; const blog = defineCollection({ schema: z.object({ title: z.string(), description: z.string(), date: z.coerce.date(), author: z.string().default('Thomas Germain'), tags: z.array(z.string()).default([]), }), }); export const collections = { blog }; ``` Ensuite, stocke tes posts dans `src/content/blog/` en markdown/MDX. ## Étape 3 — Exporter le contenu WordPress Tu as deux options : ### Option A (rapide) : copier-coller propre des articles clés - Commence par les 10-20 pages qui font du trafic - Réécris/optimise en même temps ### Option B (large) : export XML puis conversion markdown - Exporte WordPress (`Outils > Exporter`) - Convertis vers markdown via script/outils de migration - Nettoie les shortcodes cassés et embeds legacy Dans les deux cas, vérifie : - titres - slugs - images - liens internes - metas ## Étape 4 — Conserver les slugs (important SEO) Si possible, garde exactement les anciennes URLs. Exemple Astro : - WordPress : `/mon-article/` - Astro : même slug `mon-article` Quand ce n’est pas possible, prépare des **301**. ## Étape 5 — Configurer les redirections 301 Sur Cloudflare, gère tes redirections via config (Pages/Workers) selon ton setup. Règle d’or : - ancienne URL → nouvelle URL la plus proche - pas de redirection en chaîne - pas de 302 pour de la migration permanente ## Étape 6 — Ajouter TinaCMS (édition simple) Installe Tina et configure une collection “posts” pour éditer ton contenu. Bénéfices : - édition plus friendly que du markdown brut - contenu versionné dans Git - pas de dépendance à une base WordPress Si tu préfères minimal absolu, tu peux commencer **sans Tina**, puis l’ajouter plus tard. ## Étape 7 — Optimiser la perf dès le départ Avec Astro, tu pars déjà bien. Fais quand même ces bases : - compresser les images - charger les polices proprement - limiter scripts tiers (analytics/chat/widgets) - éviter le JS client inutile Le but n’est pas d’avoir “100/100 partout”, mais un site réellement rapide. ## Étape 8 — Déployer sur Cloudflare Workflow simple : 1. Push sur GitHub 2. Connecte le repo à Cloudflare Pages 3. Build command : `npm run build` 4. Output dir : `dist` 5. Déploie en preview puis production Ensuite, mappe ton domaine `blog.thomasgermain.be`. ## Étape 9 — Vérifs post-migration (obligatoire) Avant d’annoncer la migration : - crawl des pages principales (200 OK) - test des redirections (301) - vérification sitemap - vérification robots.txt - check Search Console - check Core Web Vitals Et surtout : clique tes liens à la main sur les pages critiques. ## Étape 10 — Publication continue Le plus important après migration : garder un rythme simple. - une structure d’article claire - un process publication court - moins d’outils, plus d’écriture Ton stack doit servir ton contenu, pas l’inverse. --- ## Plan de migration en 48h (version ultra pratique) ### Jour 1 matin - setup Astro - thème minimal - structure contenu ### Jour 1 après-midi - migration des 10 pages SEO principales - conservation des slugs - redirections ### Jour 2 matin - QA complète (liens, images, metas) - branche preview Cloudflare ### Jour 2 après-midi - mise en prod - monitoring Search Console + analytics ## Erreurs classiques à éviter - Migrer 100% du contenu d’un coup sans priorisation - Changer tous les slugs “pour faire propre” - Oublier les redirections d’anciens articles - Répliquer la complexité WordPress dans le nouveau stack - Sur-optimiser au lieu de publier ## TL;DR - Oui, tu peux migrer de WordPress vers Astro en un week-end - Non, ne commence pas par “tout refaire” - Priorise les pages à trafic - Garde les URLs - Mets des 301 propres - Publie vite Le but final : un site rapide **et** une envie d’écrire qui revient. --- Sources : - Astro docs : https://docs.astro.build - TinaCMS docs : https://tina.io/docs - Cloudflare Workers/Pages docs : https://developers.cloudflare.com/"},{"id":"blog:jai-vire-wordpress-retrouve-envie-ecrire","title":"J’ai viré WordPress — et j’ai enfin retrouvé l’envie d’écrire","description":"Pourquoi passer de WordPress à Astro + TinaCMS + Cloudflare peut relancer ta créativité (et pas juste tes perfs).","date":"2026-03-07T11:25:00.000Z","tags":["wordpress","astro","cloudflare","opinion","ai"],"authors":[],"url":"/blog/jai-vire-wordpress-retrouve-envie-ecrire","content":"Tu peux avoir un site qui “fonctionne” et quand même ne plus avoir envie de publier. C’est exactement le point du thread : *\"I tore down my WordPress site and rebuilt it from scratch. Not because it was broken. Because I've outgrown it.\"* Et franchement, c’est la phrase la plus importante. Le vrai sujet n’est pas le framework. Le vrai sujet, c’est la **friction**. Quand chaque publication ressemble à une micro-bataille (plugins, admin lourde, maintenance, lenteur, dette), ton cerveau associe “écrire” à “galère”. Et tu publies moins. ## Pourquoi ce move est intelligent Passer à **Astro 5 + TinaCMS + Cloudflare Workers** n’est pas juste un délire de devs performance nerds. C’est une décision produit pour créateur solo : - **Astro** : HTML d’abord, JS seulement quand nécessaire - **TinaCMS** : édition simple, versionnée, propre pour un workflow Git - **Cloudflare Workers** : delivery edge rapide et infra légère Résultat annoncé : - homepage ~52KB - chargement Tu recommences à avoir envie de taper des mots. ## Le piège WordPress (même quand “tout va bien”) WordPress reste un excellent outil. Mais pour beaucoup de profils indie / maker, il finit par dériver : - trop de couches - trop de décisions parasites - trop de dépendances plugins - trop de maintenance invisible Tu te retrouves à “gérer un système” au lieu de “publier des idées”. Et ça, ça tue la cadence. ## Le bon KPI n’est pas PageSpeed Oui, la perf compte. Oui, 52KB c’est sexy. Mais le KPI qui change une carrière de créateur, c’est plutôt : - **nombre d’articles publiés par mois** - **temps entre idée et publication** - **énergie mentale restante après publication** Si un nouveau stack te donne +2 publications/mois pendant 12 mois, c’est game changer. ## Ce que ça change concrètement au quotidien Avec un setup Astro + Tina + Cloudflare, tu récupères : 1. **Un back-office plus minimal** 2. **Un site plus rapide sans chasse au plugin perf** 3. **Une base de contenu plus propre (Git + markdown/MDX)** 4. **Un sentiment de contrôle** Ce dernier point est sous-estimé. Quand ton système est lisible, tu oses plus itérer. Quand il est opaque, tu procrastines. ## “Faut-il quitter WordPress ?” Pas forcément. Si ton WordPress te sert bien, continue. Le but n’est pas de suivre la mode. Mais si tu observes ça : - tu repousses la publication, - tu redoutes l’admin, - tu passes plus de temps à maintenir qu’à écrire, alors oui, c’est peut-être le bon moment pour reconstruire. Pas parce que WordPress est nul. Parce que **toi, tu as changé**. ## Le vrai takeaway Le thread résume une réalité que beaucoup vivent sans la nommer : - Les outils ne sont pas neutres - Ton stack influence ton rythme créatif - Une migration réussie se mesure en envie retrouvée Si ton site est plus rapide *et* que tu as envie d’écrire à nouveau, c’est probablement l’un des meilleurs upgrades possibles. Et c’est exactement ce qui compte. --- ## FAQ ### Est-ce qu’Astro est meilleur que WordPress dans tous les cas ? Non. Astro est excellent pour des sites orientés contenu/perf avec workflow dev-friendly. WordPress reste plus accessible pour certains besoins non techniques et des équipes éditoriales classiques. ### TinaCMS est obligatoire avec Astro ? Non. Tu peux publier en markdown/MDX pur. Tina devient utile si tu veux une édition plus visuelle et un workflow éditorial guidé. ### Cloudflare Workers est-il indispensable ? Non plus. Tu peux déployer Astro ailleurs (Vercel, Netlify, etc.). Workers est surtout intéressant pour l’edge, les coûts et la flexibilité. ### Le gain de perf impacte-t-il vraiment le SEO ? Oui, indirectement et directement : meilleure UX, meilleur crawl budget sur certains sites, et signaux Core Web Vitals plus propres. --- Sources : - Thread original partagé (citation) - Documentation Astro : https://docs.astro.build - Documentation TinaCMS : https://tina.io/docs - Documentation Cloudflare Workers : https://developers.cloudflare.com/workers/"},{"id":"tutorial:env-global-apple-notes","title":"Gestion des API keys & tokens avec .env.global","description":"Centraliser et sécuriser ses credentials avec un fichier global chargé automatiquement dans le terminal.","date":"2026-03-06T00:00:00.000Z","tags":["env","securité","terminal","tutorial"],"authors":["example-author"],"url":"/tutoriel/env-global-apple-notes","content":"# Gestion des API Keys & Tokens avec `.env.global` ## Problème résolu Éviter d'écrire ses credentials en dur dans le code. On centralise tout dans un fichier unique et sécurisé. ## Mise en place (une seule fois) ### 1. Créer le fichier `.env.global` ```bash nano ~/.env.global ``` Ajouter tes variables au format `NOM=valeur` (sans espaces autour du `=`) : ```bash # Google Ads GOOGLE_ADS_DEVELOPER_TOKEN=... GOOGLE_ADS_LOGIN_CUSTOMER_ID=... # OpenAI OPENAI_API_KEY=... # Exa MCP EXA_MCP_TOKEN=... ``` ### 2. Sécuriser le fichier ```bash chmod 600 ~/.env.global ``` Seul ton utilisateur peut lire/modifier ce fichier. ### 3. Charger automatiquement dans chaque terminal ```bash nano ~/.zshrc ``` Ajouter à la fin : ```bash if [ -f ~/.env.global ]; then set -a source ~/.env.global set +a fi ``` Puis appliquer : ```bash source ~/.zshrc ``` ## Utilisation dans le terminal ### Vérifier qu'une variable est bien chargée ```bash echo $EXA_MCP_TOKEN ``` ### Lister les variables chargées ```bash printenv | grep -i \"exa\\|google\\|openai\" ``` ### Utiliser une variable dans une commande ```bash curl -H \"Authorization: Bearer $OPENAI_API_KEY\" https://api.openai.com/v1/models ``` ## Utilisation dans le code ### Python ```python from dotenv import load_dotenv import os load_dotenv() token = os.getenv(\"EXA_MCP_TOKEN\") ``` ### Node.js ```js require('dotenv').config() const token = process.env.EXA_MCP_TOKEN ``` ### PHP ```php $token = getenv('EXA_MCP_TOKEN'); ``` ## Règles de sécurité - **`chmod 600 ~/.env.global`** → lecture réservée à ton utilisateur - **Ne jamais commiter `.env` sur GitHub** → credentials publics = compromis - **Toujours ajouter `.env*` au `.gitignore`** → évite les commits accidentels - **Créer un `.env.example` sans valeurs** → pour documenter les variables nécessaires ## Récapitulatif des fichiers - **`~/.env.global`** → tes vraies clés (jamais sur GitHub) - **`~/.zshrc`** → charge `.env.global` à chaque terminal - **`projet/.env`** → variables spécifiques à un projet (optionnel) - **`projet/.env.example`** → template sans valeurs (commité sur GitHub) - **`projet/.gitignore`** → contient `.env` pour l'exclure du repo"},{"id":"tutorial:tmux-guide","title":"tmux — Guide pour humains","description":"Guide pratique tmux: sessions, fenêtres, panes, setup persistant et usage SSH sur iPhone.","date":"2026-03-06T00:00:00.000Z","tags":["tmux","terminal","tutorial","productivité"],"authors":["example-author"],"url":"/tutoriel/tmux-guide","content":"# tmux — Guide pour humains 🖥️ > **tmux** = terminal multiplexer. Tu peux avoir plusieurs terminaux dans une seule fenêtre, et surtout **les sessions survivent à la fermeture du terminal**. --- ## Le concept clé : le préfixe Toutes les commandes tmux commencent par **`Ctrl+B`** (le \"préfixe\"), puis une autre touche. > Appuie sur `Ctrl+B`, **relâche**, puis appuie sur la touche suivante. --- ## Les sessions Une session = un environnement tmux indépendant qui tourne en arrière-plan. ```bash tmux # Démarrer une nouvelle session tmux new -s monsite # Nouvelle session avec un nom tmux new-session -s kilo # Idem (forme longue) tmux new-session -s kilo 'kilo' # Créer ET lancer une commande directement tmux ls # Lister les sessions actives tmux attach -t monsite # Rejoindre une session existante tmux kill-session -t monsite # Supprimer une session ``` **Detacher une session** (la laisser tourner en fond) : `Ctrl+B` puis `D` ### Supprimer plusieurs sessions d'un coup ```bash for s in session1 session2 session3; do tmux kill-session -t $s; done ``` --- ## Les fenêtres (comme des onglets) | Raccourci | Action | |-----------|--------| | `Ctrl+B` `C` | Créer une nouvelle fenêtre | | `Ctrl+B` `N` | Fenêtre suivante | | `Ctrl+B` `P` | Fenêtre précédente | | `Ctrl+B` `0-9` | Aller à la fenêtre n° | | `Ctrl+B` `W` | Voir toutes les fenêtres | | `Ctrl+B` `,` | Renommer la fenêtre | --- ## Les panneaux / panes (diviser l'écran) | Raccourci | Action | |-----------|--------| | `Ctrl+B` `%` | Diviser **verticalement** (côte à côte) | | `Ctrl+B` `\"` | Diviser **horizontalement** (haut/bas) | | `Ctrl+B` `↑ ↓ ← →` | Naviguer entre les panneaux | | `Ctrl+B` `X` | Fermer le panneau actuel | | `Ctrl+B` `Z` | Zoom sur le panneau (toggle) | --- ## Mémo ultra-court ```text Ctrl+B D → Detach (laisser tourner en fond) Ctrl+B C → New window Ctrl+B % → Split vertical Ctrl+B \" → Split horizontal Ctrl+B X → Fermer pane ``` --- ## Setup : sessions persistantes pour outils CLI L'idée : une session tmux par outil (Claude, Gemini, Kilo...) qui tourne en permanence sur le Mac. Tu t'y connectes depuis n'importe où (iPhone via Echo/SSH, autre terminal...) et tu retrouves le contexte intact. ### Script de démarrage `~/start-agents.sh` ```bash #!/bin/bash # Lance toutes les sessions si elles n'existent pas déjà sessions=(\"claude:claude\" \"gemini:gemini\" \"kilo:kilo\" \"opencode:opencode\") for entry in \"${sessions[@]}\"; do name=\"${entry%%:*}\" # Tout avant le \":\" cmd=\"${entry##*:}\" # Tout après le \":\" if ! tmux has-session -t \"$name\" 2>/dev/null; then tmux new-session -d -s \"$name\" tmux send-keys -t \"$name\" \"$cmd\" Enter echo \"✓ Session '$name' démarrée\" else echo \"→ Session '$name' déjà active\" fi done ``` ```bash chmod +x ~/start-agents.sh ./start-agents.sh ``` ### Explication du script | Élément | Rôle | |---------|------| | `sessions=(...)` | Tableau : `\"nom:commande\"` | | `%%:*` | Extrait tout ce qui est **avant** le `:` → le nom | | `##*:` | Extrait tout ce qui est **après** le `:` → la commande | | `has-session` | Vérifie si la session existe déjà | | `2>/dev/null` | Cache le message d'erreur si elle n'existe pas | | `-d` | Crée en arrière-plan (detached) | | `send-keys ... Enter` | Simule une frappe clavier dans la session | --- ## Connexion SSH directe vers une session (Echo / iPhone) Dans `~/.ssh/config` sur iPhone : ```sshconfig Host mac-claude HostName 100.x.x.x # IP Tailscale du Mac User thomas RequestTTY force RemoteCommand tmux attach -t claude Host mac-gemini HostName 100.x.x.x User thomas RequestTTY force RemoteCommand tmux attach -t gemini Host mac-kilo HostName 100.x.x.x User thomas RequestTTY force RemoteCommand tmux attach -t kilo ``` Tu tap le host dans Echo → t'arrives **directement dans la session**, outil chargé, contexte intact. 🎯 --- ## Le flag magique `-A` ```bash tmux new-session -A -s kilo 'kilo' ``` `-A` = **attach si la session existe, crée sinon**. Plus jamais d'erreur \"session already exists\". Parfait pour les VPS. --- ## Schéma de fonctionnement ```text Mac └── tmux session \"claude\" └── claude CLI en cours d'exécution ← tourne toujours ↑ ↑ attach depuis detach (Ctrl+B D) Echo / terminal ou fermer la fenêtre ``` La session **vit sa vie** sur le Mac. Toi tu fais juste te brancher (`attach`) ou te décrocher (`detach`) quand tu veux. Fermer le terminal ne tue pas la session. --- ## Notes importantes - **`Ctrl+B` capturé par l'outil ?** Certains CLI (kilo, vim...) interceptent le raccourci. Insiste ou rechange le préfixe tmux. - **Session vide au retour ?** L'outil a planté. Relance-le manuellement depuis l'intérieur de la session. - **Taille du terminal** : sans `-x` et `-y`, tmux prend automatiquement la taille de ta fenêtre actuelle."},{"id":"blog:droidclaw-tutorial","title":"Comment transformer un vieux téléphone en agent AI avec DroidClaw","description":"Un vieux téléphone Android + DroidClaw = un agent qui envoie des WhatsApp, check la météo et pilote vos apps en langage naturel.","date":"2026-02-18T00:00:00.000Z","tags":["droidclaw","ai","tutorial","automation","android"],"authors":[],"url":"/blog/droidclaw-tutorial","content":"Tu as un vieux téléphone Android dans un tiroir ? Laisse-moi te montrer comment le transformer en agent AI qui bosse pour toi. ## C'est quoi DroidClaw ? [DroidClaw](https://droidclaw.ai) c'est un outil qui transforme n'importe quel Android en agent autonome. Il lit l'écran, réfléchit, tape, clique — comme un humain mais en boucle. Exemple : ``` $ bun run src/kernel.ts enter your goal: send \"running late, 10 mins\" to Mom on whatsapp --- step 1/30 --- think: i'm on the home screen. launching whatsapp. action: launch (842ms) --- step 2/30 --- think: whatsapp is open. tapping search icon. action: tap (623ms) ... ``` Il peut : - Envoyer des WhatsApp - Répondre à des SMS - Poster sur Slack - Chercher sur Google - Check la météo - Piloter n'importe quelle app Le tout sans API — il utilise les apps directement sur le téléphone. ## Ce qu'il faut 1. Un téléphone Android (même vieux) 2. Un ordi pour lancer les commandes 3. ADB installé 4. Optionnel : un compte Tailscale pour contrôler le téléphone à distance ## Tutoriel : mise en place ### 1. Préparer le téléphone Active le mode développeur sur ton Android : - Paramètres → À propos → Numéro de build → tap 7 fois - Paramètres → Développeur → Débogage USB → ON ### 2. Installer l'APK ```bash # Télécharger la dernière version wget https://github.com/unitedbyai/droidclaw/releases/download/v0.3.1/app-debug.apk # Installer (téléphone branché en USB) adb install app-debug.apk ``` ### 3. Configurer DroidClaw sur le téléphone - Ouvrir l'app DroidClaw - Accorder les permissions (accessibilité, ADB) - Garder l'écran allumé (option dans les paramètres) ### 4. Tester depuis l'ordi ```bash # Cloner le repo git clone https://github.com/unitedbyai/droidclaw cd droidclaw # Installer les dépendances bun install # Lancer bun run src/kernel.ts ``` Tape un goal : ``` enter your goal: open youtube and search for \"lofi hip hop\" ``` Et regarde-le travailler. ## Trois modes ### Interactive Tu décris ce que tu veux en langage naturel. L'IA gère tout. ```bash $ bun run src/kernel.ts enter your goal: send \"meeting at 3pm\" to Boss on whatsapp ``` ### Workflows (JSON) Chaînes d'actions à travers plusieurs apps. ```json { \"name\": \"weather to whatsapp\", \"steps\": [ { \"app\": \"com.google.android.apps.weather\", \"goal\": \"check chennai weather\" }, { \"goal\": \"share weather to Sanju\" } ] } ``` ### Flows (YAML) Actions fixes, pas d'IA. Pour les tâches répétitives. ```yaml appId: com.whatsapp name: Send Message - launchApp - tap: \"Contact Name\" - type: \"hello from droidclaw\" - tap: \"Send\" ``` ## Contrôle à distance avec Tailscale Tu veux piloter ton téléphone depuis ailleurs ? Installe Tailscale sur les deux appareils : ```bash # Sur le téléphone + laptop, installer Tailscale # Connecter depuis n'importe où adb connect :5555 # Lancer un workflow bun run src/kernel.ts --workflow morning.json ``` Maintenant ton téléphone peut envoyer des standups à Slack, checker les prix de vols, digérer des channels Telegram — tout ça en arrière-plan. ## Pourquoi c'est puissant 1. **Pas d'APIs needed** — il utilise les apps directement 2. **S'adapte** — si l'UI change, il s'adapte (grâce au LLM) 3. **Gratuit** — que le coût du téléphone 4. **Always on** — tu peux le laisser tourner 24/7 ## Mon cas d'usage Je l'ai configuré pour : - M'envoyer la météo chaque matin sur WhatsApp - Checker les flights pour mes voyages - Répondre automatiquement à certains messages Et tout ça sans payer un seul centime d'API. [Essayez](https://droidclaw.ai) — ce vieux téléphone dans votre tiroir mérite une seconde vie."},{"id":"blog:openclaws-errors","title":"Comment j'ai arrêté de perdre de l'argent avec OpenClaw","description":"7 erreurs qui m'ont coûté 127$ avant que je comprenne comment configurer mon agent AI correctement.","date":"2026-02-18T00:00:00.000Z","tags":["openclaw","ai","tutorial","tool"],"authors":[],"url":"/blog/openclaws-errors","content":"J'ai dépensé 127$ en credits API en deux semaines. Mon agent me demandait la même question 8 fois de suite. Il tournait en boucle pendant que je regardais mes tokens partir en fumée. Puis j'ai lu [ce post de Farhan](https://x.com/mhdfaran/status/1900050254978492417) et tout a changé. Voici comment éviter ces erreurs. ## 1. Arrête d'utiliser ton modèle premium pour tout Mon erreur : j'avais mis Claude Opus comme défaut pour toutes les tâches. heartbeat, scan de fichiers, tout. Un Formula 1 pour livrer des courses. **La solution** : Configure des modèles différents selon la tâche. ```json { \"agents\": { \"defaults\": { \"model\": { \"primary\": \"ollama/minimax-m2.5:cloud\", \"fallbacks\": [\"qwen-portal/coder-model\", \"qwen-portal/vision-model\"] } } } } ``` Mon setup actuel : - **Tâches simples** (lecture de fichiers) → minimax (gratuit) - **Coding** → qwen coder - **Cron jobs** → Gemini 2.0 Flash (rapide, quota gratuit) Résultat : 40,000 tokens/jour → 1,500 tokens/jour. ## 2. Ton agent a besoin de règles explicites Out of the box, OpenClaw va : - Boucler à l'infini - Oublier ce qu'il faisait - Réécrire ta base de données parce qu'il a mal lu un commentaire **La solution** : Crée des fichiers de règles. ```markdown # anti-loop.md Si tu vois la même erreur deux fois, arrête et demande. Ne réessaie pas une troisième fois. ``` Charge ces règles au démarrage via `AGENTS.md`. ## 3. Les sessions meurent quand tu fermes le chat Tu fermes ton laptop. Tu reviens le lendemain. Ton agent n'a rien fait. Les sessions sont **stateful seulement pendant que la fenêtre est ouverte**. **La solution** : Utilise les **cron jobs** avec `sessionTarget: \"isolated\"`. ```bash # Créer un cron job openclaw cron add --job '{ \"name\": \"Morning briefing\", \"schedule\": {\"expr\": \"0 8 * * *\", \"kind\": \"cron\"}, \"sessionTarget\": \"isolated\", \"payload\": { \"kind\": \"agentTurn\", \"message\": \"Lit le calendrier et résumé les événements\", \"model\": \"google-gemini-cli/gemini-2.0-flash\" } }' ``` Ça lance un agent fresh, fait le taf, et meurt. Pas de session à maintenir. ## 4. La compaction mange ta mémoire OpenClaw a une fenêtre de contexte. Quand elle se remplit, le système compacte les messages anciens. Donc ton agent oublie ce que tu lui as dit. **La solution** : Persiste tout ce qui est important. - Crée un fichier `MEMORY.md` pour les infos longue durée - Utilise GitHub backup automatique (cron quotidien) - Note tes décisions dans `DECISIONS.md` ## 5. Un workflow qui marche > cinq workflows cassés Mon erreur : j'ai essayé de tout connecter d'un coup. Email, calendrier, Telegram, web scraping, reporting. Tout cassé. Je savais même pas quoi debugger. **La solution** : Commence par un truc simple. Mon premier cron qui marchait : un résumé matinal de mon calendrier. J'ai attendu que ça marche end-to-end avant d'ajouter autre chose. Chaque nouvelle intégration = un nouveau mode de failure. ## 6. Test tes modèles avant de leur faire confiance Tous les modèles ne se valent pas pour le travail agentique. **Ce qui marche** : - Claude Sonnet/Opus - Kimi K2.5 via API - Qwen coder **À éviter** : - DeepSeek Reasoner (super pour raisonner, nul pour exécuter) - GPT-5.1 Mini (saute des étapes) **Test** : Lance 3 appels d'outils séquentiels. Si le modèle gère pas, c'est useless pour le travail autonome. ## 7. Stocke tes credentials dans Bitwarden Plus de clés API en clair dans les fichiers. ```bash # Ajouter un credential bw create item '{\"name\":\"Twitter API\",\"login\":{\"username\":\"@toncompte\",\"password\":\"ton_api_key\"}}' # Récupérer bw get item \"Twitter API\" ``` Configure la règle dans `AGENTS.md` : ``` ALWAYS use Bitwarden for API keys and passwords. NEVER write credentials in plain text files. ``` ## Mon setup final | Composant | Config | |-----------|--------| | Modèle principal | minimax (gratuit) | | Coding | qwen coder | | Images | qwen vision | | Cron jobs | Gemini 2.0 Flash | | Credentials | Bitwarden | | Backup | GitHub automatique | | Règles | anti-loop.md + AGENTS.md | Tout ça pour $0/mois. Enfin presque. Le secret c'est pas d'avoir un meilleur modèle. C'est d'avoir les bonnes règles."},{"id":"blog:aurora-alpha-openrouter","title":"Aurora Alpha : le modèle mystère qui cartonne sur OpenRouter","description":"Un modèle de coding gratuit et performant vient de débarquer sur OpenRouter. Personne ne sait qui l'a construit, mais il affole la communauté developer.","date":"2026-02-16T00:00:00.000Z","tags":["ai","coding","openrouter","tool","free"],"authors":[],"url":"/blog/aurora-alpha-openrouter","content":"## Le modèle qu personne ne connaît Tu cherches un modèle de coding gratuit et performant ? Laisse-moi te présenter **Aurora Alpha**. Ce modèle est apparu sur OpenRouter le **8 février 2026**, sans aucune annonce, sans communiqué de presse, sans rien. Juste une apparition soudaine et des developers qui se sont mis à crier sur Reddit. > \"No company name, no press release, just raw performance.\" ## Ce qu'on sait (et ce qu'on ne sait pas) **Ce qu'on sait :** - C'est un modèle de **reasoning** conçu pour la vitesse - Conçu pour les **coding assistants**, les apps conversationnelles en temps réel et les **workflows agentiques** - **Context window** : 128K tokens - **Gratuit** sur OpenRouter - Support **tools**, **structured outputs**, **reasoning** - Benchmark hard : **75% de réussite** **Ce qu'on ne sait pas :** Qui l'a construit. D'où il vient. C'est un \"stealth model\" — littéralement un modèle fantôme. ## Pourquoi ça cartonne autant ? Les developers love ça parce que : 1. **C'est gratuit** — ну pas de paid subscription 2. **C'est rapide** — reasoning effort medium par défaut, mais tu peux le passer en high pour du coding agentic 3. **Ça marche bien** — 75% sur des benchmarks hard, c'est honorable pour un modèle gratuit Les points faibles ? Le modèle a du mal avec les **logiques à contraintes multiples** et a tendance à **halluciner** sur les faits académiques. Faut vérifier les sources. ## Comment l'utiliser gratuitement ? C'est là que c'est cool. Tu peux l'utiliser **sans payer** avec : - **Kilo Code** — totalement gratuit pour commencer - **Cline CLI** — configure OpenRouter comme provider - **OpenCode** — mismo, OpenRouter integration ### Configuration Kilo Code 1. Crée un compte sur [kilo.ai](https://kilo.ai) 2. Choisis Aurora Alpha dans la liste des modèles 3. C'est parti ### Configuration Cline / OpenCode 1. Prends une clé API gratuite sur [openrouter.ai/keys](https://openrouter.ai/keys) 2. Dans Cline ou OpenCode, ajoute le provider OpenRouter 3. Sélectionne `openrouter/aurora-alpha` ## Verdict Pour un modèle gratuit et mystère, c'est impressionnant. Le fait qu'il soit disponible via Kilo Code, Cline et OpenCode sans débourser un centime rend l'accessibilité super easy. À tester pour du prototyping rapide ou si tu veux just avoir un second model en backup. Attention quand même aux hallucinations sur les faits pointus — vérifie toujours tes sources. **Source :** [OpenRouter - Aurora Alpha](https://openrouter.ai/openrouter/aurora-alpha)"},{"id":"blog:openrouter-free-models","title":"OpenRouter Free : l'accès gratuit à l'AI sans carte bancaire","description":"OpenRouter propose une sélection de modèles AI entièrement gratuits. Voici comment en profiter sans rien payer.","date":"2026-02-16T00:00:00.000Z","tags":["ai","openrouter","free","tool","coding"],"authors":[],"url":"/blog/openrouter-free-models","content":"## L'AI gratuite, c'est possible Tu veux utiliser de l'AI sans débourser un centime ? **OpenRouter Free** c'est exactement ça — une sélection de modèles totally free, sans carte bancaire, sans rien. ## C'est quoi OpenRouter ? OpenRouter c'est un agrégateur d'APIs AI. Ils centralisent des dizaines de providers (OpenAI, Anthropic, Google, Meta, etc.) en un seul endpoint. Tu payes OpenRouter et eux gèrent le reste. Mais en plus des modèles payants, ils proposent aussi des **modèles gratuits**. ## Les modèles gratuits dispo Il y a actuellement **31 modèles gratuits** sur OpenRouter. Voici les highlights : | Modèle | Provider | Context | Specialité | |--------|----------|---------|------------| | Aurora Alpha | Stealth | 128K | Coding, reasoning | | Qwen3 80B | Qwen | 262K | Reasoning | | DeepSeek R1 | DeepSeek | 164K | Reasoning | | Gemini 2.0 Flash | Google | 1M | Vision, vitesse | | Llama 3.3 70B | Meta | 128K | Général | | Devstral 2 | Mistral | 128K | Coding | Et bien d'autres... ## Le router automatique : `openrouter/free` La bonne idée de OpenRouter, c'est le modèle `openrouter/free`. C'est un **router automatique** qui choisit le meilleur modèle gratuit en fonction de ta requête. Tu lui dis juste \"fait ça\" et lui il décide quel model gratuit utiliser. Pas besoin de choisir manuellement. ## Comment l'utiliser ? 1. Va sur [openrouter.ai/keys](https://openrouter.ai/keys) 2. Prends une clé API gratuite (pas de CB requise) 3. Utilise-la dans ton app favorite : - **Cline CLI** - **OpenCode** - **Kilo Code** - **n8n** (pour des automatisations) - Ou directement via API ## Les limites Ouais, y'a des limites : - Rate limits plus restrictifs - Pas de garantie de disponibilité - Certains modèles peuvent être temporairement indispos Mais pour du testing, du prototyping ou des petits projets, c'est largement enough. ## Verdict Si tu veux tester des modèles sans rien payer, OpenRouter Free c'est le point d'entrée idéal. Le combo `openrouter/free` te donne accès à du gratuit intelligent sans te prendre la tête. **Ressource :** [openrouter.ai/collections/free-models](https://openrouter.ai/collections/free-models)"},{"id":"blog:glm-5-gratuit-kilo-code","title":"Ce modèle gratuit qui rivalise avec Opus 4.5","description":"GLM-5 gratuit sur Kilo Code. 744B paramètres, rivalise avec Claude Opus 4.5. Pas de carte de crédit requise.","date":"2026-02-14T09:48:00.000Z","tags":["ai","llm","glm","kilo-code","coding","free"],"authors":[],"url":"/blog/glm-5-gratuit-kilo-code","content":"GLM-5 est maintenant disponible gratuitement sur Kilo Code. Et c'est un modèle extrêmement capable. ## Le modèle GLM-5, c'est le dernier flagship de Zhipu AI (Z.ai). Ce qui le rend spécial : - **744 milliards de paramètres** (architecture MoE, 44B actifs) - **200K de fenêtre de contexte** - **Licence MIT** (open-source) - **DeepSeek Sparse Attention** pour réduire les coûts Les benchmarks sont impressionnants : 77.8 sur SWE-bench, 56.2 sur Terminal-Bench 2.0, 75.9 sur BrowseComp. ## Gratuit sur Kilo Code Kilo Code a décidé de rendre GLM-5 gratuit pour une durée limitée. Pas de carte de crédit, pas de clé API. Comment l'utiliser : 1. [Télécharge la CLI Kilo Code](https://kilo.code/) 2. Choisis \"GLM 5 (free)\" dans la liste des modèles 3. C'est parti Ou via l'extension VS Code (700K+ downloads), choisis GLM 5 (free) dans le model picker. **Liens utiles :** - [Kilo Code CLI](https://kilo.code/) - [GLM-5 sur ModelScope](https://www.modelscope.cn/models/ZhipuAI/glm-5) - [GLM-5 sur HuggingFace](https://huggingface.co/THUDM/glm-5) - [Site officiel Z.ai](https://z.ai) --- *Sources : [Kilo Blog](https://blog.kilo.ai/p/glm-5-free-limited-time), [Z.ai Blog](https://z.ai/blog/glm-5), [LLM Stats](https://llm-stats.com/models/glm-5)*"},{"id":"blog:aurora-alpha-model-mysterieux","title":"Ce modèle mystère gratuit qui affole les développeurs","description":"Aurora Alpha : le modèle secret qui apparaît sur OpenRouter sans annonce. Gratuit, 128K contexte, designed pour le coding. Personne ne sait qui l'a built.","date":"2026-02-14T09:45:00.000Z","tags":["ai","llm","openrouter","coding","aurora"],"authors":[],"url":"/blog/aurora-alpha-model-mysterieux","content":"Un modèle AI qui muncul sans aucune annonce. Pas de nom de company, pas de press release. Juste un modèle stealth qui crush le code plus vite que tout le reste. Et c'est complètement gratuit. ## Aurora Alpha C'est появился sur OpenRouter comme ça, du jour au lendemain. Zero announcement.rien. Juste un modèle \"cloaked\" pour récupérer du feedback de la communauté. **Les specs :** - **128K tokens** de contexte - **$0** — complètement gratuit - **Reasoning model** designed for speed - Built pour coding assistants, real-time conversational apps, et agentic workflows Le reasoning effort par défaut est à \"medium\" pour des responses rapides. Pour du coding agentic, c'est mieux de mettre sur \"high\". ## Pourquoi ça buzze Les devs en parlent partout : - Real-time responses pour les tâches de coding - Concurrent avec GPT et Claude sur la qualité - Zéro tokens. Zéro credits. Zéro limits. - Gère le debugging et code review comme un senior dev Un dev dit qu'il a saved 200+ heures le mois dernier en utilisant que ce modèle. ## Who built it ? Personne ne sait. Could be : - OpenAI testing secretly - Une startup qui disrup le marché - Un groupe de researchers Either way, les devs s'en foutent. Ils care que ça marche. **Sur OpenRouter :** openrouter.ai/openrouter/aurora-alpha --- *Source : [Writingmate](https://writingmate.ai/models/openrouter/aurora-alpha) & [OpenRouter](https://openrouter.ai/openrouter/aurora-alpha)*"},{"id":"blog:andrej-karpathy-claude-code-skills","title":"65 lignes de Markdown devenues une extension 4K stars","description":"Les 65 lignes de règles Markdown qu'Andrej Karpathy utilise pour améliorer le code généré par les IA. Think Before Coding, Simplicity First, Surgical Changes.","date":"2026-02-14T09:40:00.000Z","tags":["claude","coding","ai","productivity","karpathy"],"authors":[],"url":"/blog/andrej-karpathy-claude-code-skills","content":"Andrej Karpathy (l'ancien director of AI chez Tesla, founder de Andrej Karpathy) a un fichier CLAUDE.md qu'il utilise avec Claude Code. Et ouais, c'est un peu le guru reference pour tout ce qui est AI coding. ## Le fichier C'est des \"behavioral guidelines to reduce common LLM coding mistakes\". Le tradeoff : ces guidelines bias vers la prudence plutôt que la vitesse. ## Les 4 règles ### 1. Think Before Coding > **Don't assume. Don't hide confusion. Surface tradeoffs.** Avant d'implémenter : - State tes assumptions explicitement. Si incertain, demande. - Si plusieurs interprétations existent, présente-les — pas silencieusement choisir. - Si une approche plus simple existe, dis-le. Push back quand justifié. - Si quelque chose est unclear, stop. Nommer ce qui est confus. Demande. ### 2. Simplicity First > **Minimum code that solves the problem. Nothing speculative.** - Pas de features au-delà de ce qui était demandé - Pas d'abstractions pour du code single-use - Pas de \"flexibilité\" ou \"configurability\" non demandée - Pas de error handling pour des scénarios impossibles - Si tu écris 200 lignes et que 50 suffiraient, rewrite La question à se poser : \"Est-ce qu'un senior engineer dirait que c'est overcomplicated ?\" Si oui, simplify. ### 3. Surgical Changes > **Touch only what you must. Clean up only your own mess.** Quand tu édites du code existant : - Pas de \"improvements\" sur du code adjacent, comments, ou formatting - Pas de refactor de choses qui marchent - Match le style existant, même si tu ferais différemment - Si tu remarques du dead code non lié, mentionne-le — pas le supprimer Le test : Every changed line should trace directly to the user's request. ### 4. Goal-Driven Execution > **Define success criteria. Loop until verified.** Transformer les tâches en goals vérifiables : - \"Add validation\" → \"Write tests for invalid inputs, then make them pass\" - \"Fix the bug\" → \"Write a test that reproduces it, then make it pass\" - \"Refactor X\" → \"Ensure tests pass before and after\" Pour les tâches multi-steps, state un brief plan : ``` 1. [Step] → verify: [check] 2. [Step] → verify: [check] 3. [Step] → verify: [check] ``` ## Le trick Ces guidelines marchent si : - Fewer unnecessary changes in diffs - Fewer rewrites due to overcomplication - Clarifying questions come before implementation rather than after mistakes Le fichier est sur GitHub : forrestchang/andrej-karpathy-skills --- *Source : [GitHub](https://github.com/forrestchang/andrej-karpathy-skills/blob/main/CLAUDE.md)*"},{"id":"blog:kaku-terminal-ai-coding","title":"Kaku : le terminal rapide pour AI coding","description":"Kaku, un nouveau terminal conçu pour aller avec Claude Code et AI coding. Alacritty-like speed avec native tabs et splits.","date":"2026-02-14T09:35:00.000Z","tags":["terminal","ai","coding","tools","kaku"],"authors":[],"url":"/blog/kaku-terminal-ai-coding","content":"Un nouveau terminal est en train de faire parler de lui dans le monde du dev. Ça s'appelle Kaku et c'est un Valentine's gift pour les terminal nerds. ## Pourquoi un nouveau terminal ? L'auteur a commencé à bosser dessus en construisant Pake, puis Mole. Il a essayé tout ce qui existait : - **Alacritty** : rapide mais pas de tabs - **Ghostty** : le rendu de police n'était pas à son goût - **Warp** : require un login - **Kitty** : puissant mais window management le embêtait Puis il a trouvé **WezTerm** (Rust-based, hackable) et a built dessus en supprimant les modules legacy, en tighten le loading path, et en tweakant le rendering macOS. ## Le goal Alacritty-like speed + native tabs et splits. Built specifically for AI coding : - Un pane pour Claude Code - Un pane pour review - git diff en bas Stay in flow. ## Kaku Le nom vient du japonais, facile à dire : Kaku Kaku Kaku Kaku. Pas encore fully mature mais l'auteur l'utilise depuis 6 mois en daily driver. Pas de config needed, juste try les shortcuts. Télécharge-le sur github.com/tw93/Kaku --- *Source : [t9t (@tw93) via X](https://x.com/tw93)*"},{"id":"blog:opencl-10-config-autonomous-operator","title":"10 config pour transformer OpenClaw en opérateur autonome","description":"Comment j'ai configuré OpenClaw pour passer de chatbot à opérateur autonome. Memory splitting, skills, cron jobs, et plus.","date":"2026-02-14T09:30:00.000Z","tags":["openclaw","ai","configuration","productivity","agents"],"authors":[],"url":"/blog/opencl-10-config-autonomous-operator","content":"Cet article vient d'un thread Twitter qui explique exactement comment structurer son agent IA pour en faire un vrai opérateur autonome. Et ouais, j'ai appliqué tout ça à ma config. ## 1. Splitter la mémoire en 5 fichiers Fini le gros fichier MEMORY.md qui contient tout. Maintenant j'ai : - **active-tasks.md** — crash recovery, lu en premier au démarrage - **lessons.md** — chaque erreur documentée, jamais répétée - **projects.md** — état actuel de chaque projet - **daily logs** — contexte brut, supprimé après 7 jours Pourquoi ? Un seul fichier = contexte bloated = agent confus. En splitant, l'agent charge uniquement ce dont il a besoin. ## 2. \"Use when / Don't use when\" dans chaque skill Sans ça, l'agent choisit le mauvais skill ~20% du temps. La différence : **Pas bon :** > \"description\": \"Déployer des sites web\" **Bon :** > \"description\": \"Déployer des fichiers sur cPanel. UTILISER POUR : upload de fichiers, création de domains. NE PAS UTILISER POUR : acheter des domaines (utiliser registrar skill), gérer DNS (utiliser Cloudflare skill)\" C'est du if/else routing pour le cerveau de l'agent. ## 3. HEARTBEAT.md sous 20 lignes Le heartbeat tourne toutes les ~30 minutes. Garde-le tiny : - Vérifier si les tâches actives sont stale (>2h sans update) - Archiver les sessions bloated (>2MB) - Self-review toutes les ~4 heures Heavy work → cron jobs. Heartbeat = quick health check seulement. ## 4. Cron jobs pour tout ce qui est schedule Les heartbeats c'est pour grouper des checks rapides. Le cron c'est pour le vrai travail : - 7h → veille IA vers Telegram - 8h → résumé tech news Chaque cron tourne dans sa propre session isolée. Pas de context bleed. Pas de gaspillage de tokens. ## 5. L'agent vérifie son propre travail J'ai ajouté ça dans AGENTS.md : > \"Every sub-agent MUST validate its own work. But I also verify the result before announcing to the user. Never take a sub-agent's result for granted.\" L'agent qui build ≠ l'agent qui review. Cette règle règle 80% des problèmes de qualité. ## 6. Router les modèles par type de tâche Pas besoin du modèle le plus cher pour tout : - **File reading, reminders, travail interne** → modèle rapide/pas cher - **Contenu web externe (articles, tweets)** → modèle le plus fort seulement - **Tâches de coding** → mid-tier avec extended thinking Pourquoi le plus fort pour le contenu externe ? Les modèles plus faibles sont plus vulnérables au prompt injection depuis des sites hostiles. ## 7. Session hygiene — archiver agressivement Sessions >2MB = agent lent, contexte confus, turns coûteux. Archivage automatique : - >2MB → archiver - >5MB → alerter - Daily logs → rotate chaque semaine L'agent doit tourner light. S'il charge des megabytes d'historique à chaque tour, il gaspille de l'argent et devient plus con. ## 8. SOUL.md avec personnalité Les agents par défaut sonnent comme des chatbots corporate. J'ai donné : - Un nom - Un style de com (\"direct, skip filler\") - Des limites (\"ask before sending emails\") - Le droit d'avoir des opinions Un agent avec de la personnalité catch plus de edge cases parce qu'il s'engage vraiment avec la tâche au lieu de générer du output générique. ## 9. Crash recovery en 3 lignes Ajouté dans AGENTS.md : > \"On startup: read active-tasks.md FIRST. Resume autonomously. Don't ask what we were doing — figure it out from the files.\" L'agent VA crasher. Les sessions VONT restart. Sans ça, il se réveille confus et demande \"what should I do ?\" Avec ça, il reprend où il s'est arrêté. Zéro downtime. ## 10. Sub-agents avec scope, pas liberté Quand je spawn des sub-agents : - Définir exactement ce qu'ils peuvent toucher - Donner des critères de succès clairs - Mettre un timeout (sinon ils tournent forever) - Jamais laisser deux agents écrire dans le même fichier Les traiter comme des contractors, pas des employés. Brief clair → deliver → done. --- ## Le pattern Chaque conseil ici c'est de la STRUCTURE, pas des prompts. Ton agent est aussi bon que l'infrastructure autour. C'est exactement ce que j'ai appliqué cette semaine. Et ouais, ça change tout. --- *Source : [@Nicolasfrost](https://x.com/Nicolasfrost/status/2022341254965772367)*"},{"id":"blog:cline-cli-2-0-gratuit","title":"Cline CLI 2.0 : l'agent IA qui code gratis dans ton terminal","description":"Cline sort sa CLI avec agents parallèles, support MCP et accès gratuit à MiniMax M2.5. Le futur du coding agent est là.","date":"2026-02-14T00:00:00.000Z","tags":["ai","tool","open-source","coding"],"authors":[],"url":"/blog/cline-cli-2-0-gratuit","content":"**tl;dr** : Cline vient de lâcher Cline CLI 2.0 — un agent de coding qui tourne dans ton terminal, sans payer de credits API. Mode interactif ou autonome, agents parallèles, et pour une durée limitée : **MiniMax M2.5 gratuit**. --- ## De l'IDE au terminal La semaine dernière, j'avais trois agents qui tournaient dans trois panes tmux. Un refactorait une couche BDD. Un autre mettait à jour la doc API. Un troisième générait des scripts de migration depuis un schéma diff. Aucun d'entre eux n'aurait fonctionné dans la sidebar d'un IDE. Pas parce que l'IDE est nul — il est parfait pour ecrire du code à la main, un curseur à la fois. Mais le métier change. Les modèles sont devenus assez bons pour raisonner sur des codebases entiers. Les développeurs passent moins de temps à ecrire des lignes et plus à orchestrer des systèmes. Tu ne modifies plus un fichier. Tu dis à un agent de refactorer un module, mettre à jour les tests, corriger le build. Et maintenant, tu peux le faire depuis ton terminal. ## Cline CLI 2.0 ### Ce qui change - **Agents parallèles** : lance plusieurs agents simultanément pour des dossiers, branches ou tâches differentes - **Mode autonome sans交互** : le flag `-y` permet de lancer Cline sans interface interactive — parfait pour le CI/CD - **ACP (Agentic Code Protocol)** : le protocole ouvert qui permet à n'importe quel éditeur de se connecter - **MiniMax M2.5 et Kimi K2.5 gratuits** (pour une durée limitée) ### Le même agent, partout Tu retrouves le même agent Cline dans VS Code, JetBrains, Zed, Neovim, Emacs... et maintenant dans ton terminal. Même contexte, mêmes workflows. ### Pour qui ? - Les devs qui veulent automatiser des tâches repetitives - Les équipes qui font du code review automatique - ceux qui utilisent déjà Cline et veulent aller plus loin - Ceux qui cherchent une alternative gratuite à Cursor ou Copilot ## MiniMax M2.5 : le modèle qui bosse en équipe C'est là que ça devient intéressant. MiniMax a entraîné M2.5 pour bosser **avec d'autres agents**. La plupart des modèles supposent qu'ils sont seuls. M2.5 suppose qu'il ne l'est pas. Contexte multi-agents, switch entre environnements, coordination sur plusieurs tâches sans perdre le fil. C'est littéralement conçu pour bosser dans un monde où plusieurs IA travaillent ensemble. Et pour une durée limitée, **c'est gratuit**. ## Combien ça coûte ? Pour le moment : - **MiniMax M2.5** : gratuit (limité dans le temps) - **Kimi K2.5** : gratuit (limité dans le temps) - **Autres modèles** : tarif standard (Claude, GPT, etc.) ## Essaye maintenant ```bash # Installer la CLI npm install -g @cline/cline # Lancer une session interactive cline # Lancer en mode autonome (sans confirmation) cline -y \"refactor the auth module\" ``` ## Verdict Cline CLI 2.0 c'est : - Un agent de coding qui tourne **partout** (terminal, IDE, CI) - **Gratuit** avec MiniMax M2.5 - **Ouvert** (open source, extensible) - **Puissant** (agents parallèles, autonome) Si tu cherches à automatiser du code sans casser ton porte-feuille, c'est clairement un outil à tester. --- **Sources** : [Cline Blog](https://cline.bot/blog/introducing-cline-cli-2-0), [TestingCatalog](https://www.testingcatalog.com/cline-drops-cli-2-0-coding-agent-powered-by-k2-5-and-m2-5-for-free/)"},{"id":"blog:tyform-alternative-typeform-gratuite","title":"Tyform : l'alternative gratuite à Typeform qui ne coûte rien","description":"Tyform.com promet des formulaires illimités, réponses illimitées, gratuit pour toujours. On a testé.","date":"2026-02-14T00:00:00.000Z","tags":["tool","free","productivity","no-code"],"authors":[],"url":"/blog/tyform-alternative-typeform-gratuite","content":"**tl;dr** : Tyform arrive avec une promesse audacieuse — **illimité, gratuit, pour toujours**. Formulaires, réponses, tout est free. Voici ce qu'il faut savoir. --- ## Le problème avec Typeform Typeform c'est beau, c'est smooth, c'est un question à la fois. Mais c'est cher. Très cher. Dès que tu dépasses les 10 réponses ou que tu veux des features un peu sérieuses (logique conditionnelle, custom domain, paiements), tu passes en paid et ça chiffre vite. Tally et Youform ont tenté le coup du \"gratuit\" mais avec des limites cachées. Tyform arrive avec une promesse différente : **tout illimité, gratuit, forever**. --- ## Ce que Tyform propose ### Les bases - **Forms illimitées** — oui, autant que tu veux - **Réponses illimitées** — plus jamais de \"plan exceeded\" - **Pas de carte bancaire** — juste email + go ### Le builder - **Drag & Drop** — visuellement, sans code - **100+ Google Fonts** — custom colors, backgrounds, boutons - **Thèmes magnifiques** — pas besoin d'être designer ### Les features pro - **Analytics** — vues, taux de complétion, drop-offs, tendances - **API & Webhooks** — connecte à ton stack - **Custom Domains** — pour une expérience branded - **Paiements** — Stripe intégré ### Les intégrations Slack, Google Sheets, Notion, Discord, Stripe, Polar, Dodo Payments. ### La sécurité - **GDPR** — conforme aux standards EU - **SSL 256-bit** — chiffrement de bout en bout - **SOC 2 Type I** — niveau entreprise --- ## Pour qui ? - **Freelances** qui veulent des forms clients sans payer - **Startups** qui commencent et ne veulent pas casquer $50/mois - **No-code makers** qui veulent quelque chose de propre - **Side-projecteurs** qui ont besoin de collecter des données sans friction --- ## Le pricing **Gratuit. Pour toujours.** C'est le message. Pas de tier premium caché, pas de \"free until you hit 100 responses\". Juste gratuit. --- ## Verdict Tyform c'est-Typeform-mais-gratuit. La promesse est forte. Le site est propre, les features sont là (API, webhooks, custom domains, paiements), et le pricing est limpide. Si tu cherches une alternative à Typeform sans le prix, c'est clairement à tester. **Lien** : [tyform.com](https://tyform.com) --- **Sources** : [tyform.com](https://tyform.com), [Reddit - MicroSaaS](https://www.reddit.com/r/microsaas/comments/1h7g5cs/would_you_guys_sign_up_for_a_free_typeform/)"},{"id":"blog:wordpress-plugins-ai-claude-code","title":"Comment créer des plugins WordPress avec Claude Code","description":"Guide étape par étape pour créer des plugins WordPress avec l'IA. Claude Code + WordPress Studio = plugins fonctionnels en quelques minutes.","date":"2026-02-13T21:20:00.000Z","tags":["wordpress","ai","claude","coding","tutorial"],"authors":[],"url":"/blog/wordpress-plugins-ai-claude-code","content":"Tu veux créer des plugins WordPress sans savoir coder ? Avec Claude Code et WordPress Studio, c'est possible. En quelques minutes, tu passes de l'idée au plugin fonctionnel. ## Le combo gagnant **Claude Code** — l'assistant de coding IA d'Anthropic **WordPress Studio** — un environnement WordPress local gratuit Ensemble, ils te permettent d'aller d'une idée à un plugin qui marche en quelques minutes. Pas besoin de connaissances deep en code. ## 1. Installer Claude Code Va sur [Claude Code](https://anthropic.com/claude-code) et crée un compte. Choisis n'importe quel plan payant. Télécharge le native installer depuis la page de setup et suis les instructions. En 1-2 minutes, c'est prêt. ## 2. Installer WordPress Studio Télécharge [WordPress Studio](https://developer.wordpress.com/studio) — c'est gratuit et ça marche sur Mac et Windows. Installe-le, puis crée un nouveau site. Appelle-le comme tu veux — \"Mon Site WordPress\" fonctionne très bien. Pourquoi c'est bien : Studio tourne en local sur ton ordinateur. Tout ce que tu build reste sur ta machine. Tu peux expérimenter avec des plugins générés par l'IA sans risquer un site live. ## 3. Démarrer Claude Code Dans WordPress Studio, va sur l'onglet Overview et clique sur **Terminal** dans les options \"Open in...\". Cela va ouvrir un terminal à l'emplacement de ton projet. Tape `claude`. Si c'est la première fois, tu seras invité à te connecter à ton compte Claude et à confirmer que tu fais confiance aux fichiers dans ce dossier. Appuie sur Entrée pour approuver, et tu verras le message de bienvenue. ## 4. Build ton premier plugin Dans le terminal Claude, décris ce que tu veux. Donne du contexte sur où tu es et ce dont tu as besoin. Exemple : > \"We are in the root of the WordPress site folder. I want a simple plugin that prints out 'Hello [Your Name]' in the admin of the site.\" Claude va poser des questions de suivi, créer un dossier de plugin, et générer le fichier complet avec la structure WordPress appropriée. ## 5. Activer et tester Retourne dans WordPress Studio et ouvre ton admin WordPress. Va dans **Plugins**, trouve ton nouveau plugin, et active-le. Si le plugin marche, ton message personnalisé devrait apparaître en haut de l'admin — dans notre cas, \"Hello Nick\" s'affiche comme un notice admin. ## 6. Continuer à build Tu peux ajouter plus de fonctionnalités. Retourne dans le Terminal et demande à Claude d'ajouter de nouvelles fonctionnalités — pages de settings, custom blocks, ce que tu veux. **Tips pour de meilleurs résultats :** - Donne à Claude le contexte sur où tu es dans la structure des fichiers - Sois spécifique sur ce que tu veux que la feature fasse - Décompose les features complexes en petits pas - Demande à Claude d'expliquer le code généré si quelque chose n'a pas de sens ## Bonus : Telex [Telex](https://telex.automattic.ai/) est un autre outil qui aide à générer des WordPress blocks avec l'IA — et c'est complètement gratuit à utiliser. Décris simplement le block WordPress que tu veux, et Telex le build avec un live preview dans WordPress Playground. Teste-le, raffine-le avec des prompts de suivi, puis download-le comme plugin et installe-le sur ton site WordPress. ## TL;DR Tu as maintenant un setup alimenté par l'IA pour créer des plugins WordPress : 1. Décris le plugin que tu veux build, et regarde Claude générer du code fonctionnel 2. Expérimente avec Telex pour créer des blocks WordPress entiers 3. Continue à expérimenter Commence simple, puis attaque des projets plus complexes au fur et à mesure que tu es à l'aise. --- *Source : [WordPress.com Blog](https://wordpress.com/blog/2026/02/12/build-wordpress-plugins-with-ai-claude-code/)* ## FAQ ### Claude Code est-il gratuit ? Non, il faut un compte Claude avec un plan payant. Mais le premier mois est gratuit. ### WordPress Studio fonctionne-t-il sur Windows ? Oui, WordPress Studio est disponible sur Mac et Windows. ### Ai-je besoin de savoir coder ? Non. Tu décris ce que tu veux en anglais, et Claude génère le code. C'est le principe du \"vibe coding\". ### Comment ajouter des fonctionnalités avancées ? Demande à Claude d'ajouter des pages de settings, des custom blocks, ou ce dont tu as besoin. Décompose en petits pas."},{"id":"blog:obsidian-claude-code-os-thinking","title":"Obsidian + Claude Code : le nouvel OS pour penser","description":"Comment Heinrich a construit un système de pensée avec AI en utilisant Obsidian et Claude Code. Les fichiers markdown savent tout ce que tu as découvert.","date":"2026-02-13T21:00:00.000Z","tags":["obsidian","ai","knowledge-management","claude","productivity"],"authors":[],"url":"/blog/obsidian-claude-code-os-thinking","content":"Il a passé la dernière année à construire un OS pour penser avec l'AI. Claude Code fait tourner ses vaults Obsidian. L'IA extrait les concepts clés, les connecte à ce que t'as déjà figured out, et construit une représentation vivante de ta pensée. Résultat : il ne bosse plus que dans le vault. Les fichiers markdown savent tout ce qu'il a découvert, bien structurés, avec injection automatique de contexte situationnel pour l'in-context learning. ## C'est quoi un vault ? Un vault c'est un dossier de fichiers markdown qui se link entre eux : ``` my-vault/ ├── 00_inbox/ # zone de capture, zero friction ├── 01_thinking/ # tes notes et topic pages ├── 02_reference/ # savoir externe ├── 03_creating/ # contenus en cours ├── 04_published/ # travail terminé ├── 05_archive/ # vieux contenus ├── 06_system/ # templates et scripts ├── CLAUDE.md # enseigne à l'AI ton système └── attachments/ # images et fichiers ``` Les fichiers se connectent via des liens wiki (`[[liens]]`) qui build un réseau d'idées. L'agent peut suivre ces liens pour jumper entre les idées, découvrir des connexions que t'avais oubliées. ## Comment écrire de bonnes notes Comment tu écris ces liens importe. La plupart des gens mettent des références en bas comme des footnotes. Au lieu de ça, weave les liens dans tes phrases. Pas : > \"ça relie à qualité, voir : note-qualité\" Mais : > \"parce que [[la qualité est le plus dur]], on doit focus sur la curation\" Le lien devient partie de ta pensée, et l'agent peut suivre ton raisonnement. Écris aussi des notes qui tiennent debout toutes seules. Si quelqu'un land sur une note via un lien, il devrait pas avoir besoin de lire 5 autres notes avant de comprendre. Think of notes comme des Lego blocks — chacun est complet en soi, mais ils se connectent pour build des structures plus grandes. ## Comment Claude trouve les choses Claude a besoin de comprendre ce qui existe sans lire chaque fichier — impossible avec des milliers de notes. Donc le système a des couches : 1. **Structure de dossiers** — un hook montre la structure au début de chaque session 2. **Index** — liste chaque note avec une phrase de description. Claude peut scanner 50 notes en secondes 3. **Topic pages (MOCs)** — link vers des notes liées, contiennent des breadcrumbs pour les sessions futures Claude start broad, narrow vers ce qui est pertinent, puis suit les liens pour build la compréhension. ## Les principes core - **Markdown depth over breadth** — quality over speed. Les tokens sont gratuits. C'est pas pour l'efficacité, c'est pour l'excellence. - **Quand tu pickles un task, tu t'engages à le comprendre complètement** et laisser du travail que les agents futures peuvent build dessus. - **Les notes individuelles importent moins que leurs relations.** Une note avec beaucoup de liens entrants est plus valiosa qu'une note isolée. - **Nomme tes notes comme des claims** — pas \"thoughts on ai slop\" mais \"quality is the hard part\" ## La petite chose profonde Un vault encode comment tu penses, pas juste ce dont tu as pensé. La méthodologie devient parte du système. L'AI ne comprend pas automatiquement ta philosophie. Tu dois l'ensenigner. Watching an AI completely disrespect mes philosophies m'a appris ça à la dure. Mon CLAUDE.md fait ~2000 lignes maintenant parce que je n'arrête pas de raffiner ce qui marche et ce qui marche pas. ## Pourquoi ça change tout > \"Vibe coding a changé comment on écrit du software. Vibe note taking change comment on pense.\" Les LLMs ont pas de mémoire, donc les vaults leur en donnent une. Le rôle humain evolve de writer à editor, de creator à curator. Tu ne prends plus de notes — tu opéres un système qui prend des notes. Ton travail devient le jugement, décider ce qui compte. --- *Source : Heinrich (@arscontexta)* ## FAQ ### Comment démarrer un vault ? Crée un dossier avec des sous-dossiers qui matchent ton but. Écris un CLAUDE.md qui explique ton système. ### Claude Code peut-il vraiment naviguer dans mes notes ? Oui. Au début de chaque session, Claude voit la structure du dossier. Il peut scanner l'index et suivre les liens wiki pour trouver des connexions. ### Quelle différence avec les autres systèmes de notes ? Le vault encode comment tu penses, pas juste ce dont tu as pensé. La méthodologie devient partie du système."},{"id":"blog:opencl-ecosystem-2026","title":"L'écosystème OpenClaw 2026 : tout ce qu'il faut savoir","description":"Carte complète de l'écosystème OpenClaw : infrastructure, models, skills, channels, et marketplace. Le nouvel OS pour agents IA.","date":"2026-02-13T20:55:00.000Z","tags":["openclaw","ai","ecosystem","agents"],"authors":[],"url":"/blog/opencl-ecosystem-2026","content":"La plupart des gens utilisent encore l'IA comme en 2023. Tu poses une question, tu obtiens une réponse, la session se termine. Mais quelque chose de plus gros est en train de se former. Et ça s'appelle OpenClaw. ## De l'Outil à l'Ange Le shift est subtil mais massif : - **Old AI** : Tu demandes. Il répond. - **Agent AI** : Tu assignes. Il exécute. Cette différence change tout. OpenClaw n'est pas un produit unique. C'est une architecture. Un stack. Un organisme digital grandissant. ## 1. Infrastructure — Le Cerveau + Le Corps Deux couches à la base : **OpenClaw.ai** — La couche puissance brute. Un framework open-source pour agents autonomes qui peut : - Exécuter des tâches - Utiliser des outils - Opérer à travers les apps - Maintenir la mémoire - Chaîner des étapes de raisonnement - Travailler vers des objectifs long terme **MyClaw.ai** — La couche accessibilité. Déploiement OpenClaw dans le cloud. Pas de setup, pas de Docker, pas de VPS. Ton agent tourne 24/7. OpenClaw = le moteur. MyClaw = la machine toujours-allumée. ## 2. Models — La Couche Intelligence Les agents ne valent que par les modèles qui les alimentent. L'écosystème optimise autour de trois poids lourds : **Claude Opus 4.6** — Raisonnement profond. Planification long terme. Coding production-grade. Le meilleur pour les workflows complexes. **Minimax M2.5** — Rapide. Multimodal. Voice-ready. Interaction real-time optimisée. Intelligence proche d'Opus à la vitesse. **Kimi K2.5** — Le monstre du contexte long. Tâches recherche-heavy. Mémoire à travers de gros documents. Pour les workflows intensif documents. L'orchestration d'agents > usage de modèle unique. ## 3. Skills Hub — Étendre l'Agent Les agents deviennent puissants quand ils gagnent des skills. C'est le moment \"App Store\" : - **ClawHub** — Plugin + marketplace de skills. Installe des outils, expands les capacités. - **MoltHub** — Automation workflow avancée. Orchestration multi-agent. - **LangChain Hub** — Prompts, chains, agent tools. Les agents arrêtent d'être des assistants et commencent à devenir des opérateurs. ## 4. Channels — Où les Agents Vivent Le vrai unlock : les agents ne sont pas dans des dashboards. Ils vivent dans ta couche de communication. - **Telegram** — Contrôle ton agent en chat - **Discord** — Communauté + interface de commande - **Slack** — Déploie dans ton workflow d'équipe - **iMessage** — Interaction personal real-time - **Molttline** — Workspace dédié multi-agent Les agents ne sont pas des onglets software. Ce sont des entités conversationnelles embeded dans ton environnement. ## 5. Social Media for Agents — La Frontière Sauvage Quand les agents ont : - Des profils - De la mémoire - Une identité - La capacité de poster Bienvenue dans : - **Moltbook** — Réseau social agent-native - **Clawcaster** — Système de broadcasting pour contenu agent-généré - **Clawk** — Agent d'engagement autonome - **Moltx** — Système d'identité persona-driven On avance vers : - Des agents qui postent - Des agents qui commentent - Des agents qui build des audiences - Des agents qui gèrent des marques - Des personas digitaux autonomes ## 6. Marketplace — La Couche Économique Les écosystèmes ont besoin de commerce : - **Moltlaunch** — Lance de nouveaux agents + produits AI - **Clawnch** — Déploie et monétise des assets digitaux C'est là que les économies agent-natives émergent. ## Pourquoi Tout Ceci Compte La plupart des conversations AI tournent autour de : - Benchmarks de modèles - Prix des tokens - Nombres de paramètres Mais c'est de l'infrastructure thinking. Le vrai shift est systémique. OpenClaw devient : - Un OS pour agents - De l'infrastructure - De l'intelligence - Des skills - Des channels - Une couche sociale - Un marketplace Ça n'est pas un produit. C'est une économie. ## La Tendance Plus Grande Le monde AI se divise en deux camps : - **Session AI** (chatbots) — Améliore la productivité - **Autonomous AI** (agents) — Automatise les processus La question n'est pas \"Est-ce mieux que ChatGPT ?\" La vraie question est : **Tu build à l'intérieur de l'économie agent ou tu regardes depuis l'extérieur ?** ## FAQ ### Qu'est-ce qu'OpenClaw ? Un framework open-source pour créer des agents IA autonomes. Il peut exécuter des tâches, utiliser des outils, opérer across apps, maintenir de la mémoire, et fonctionner 24/7. ### Quelle est la différence avec ChatGPT ? ChatGPT = session AI (tu poses une question, tu obtiens une réponse). OpenClaw = autonomous AI (tu assigns une tâche, il exécute). ### MyClaw c'est quoi ? La version cloud d'OpenClaw. Pas de setup, pas de VPS, ton agent tourne 24/7. ### Quels modèles sont recommandés ? - **Claude Opus** : raisonnement complexe, coding - **Minimax M2.5** : rapide, multimodal, voice-ready - **Kimi K2.5** : long context, recherche --- *Source : Leo Ye (@LeoYe_AI)*"},{"id":"blog:openclaw-tiktok-500k-views","title":"Comment un agent OpenClaw a généré 500K+ vues sur TikTok en une semaine","description":"Oliver Henry a utilisé son agent IA Larry pour créer des slideshows TikTok automatiquement. Résultat : 500K vues, $588 MRR, et 0kas minutes passées sur l'app.","date":"2026-02-13T19:50:00.000Z","tags":["openclaw","ai","tiktok","marketing","automation"],"authors":[],"url":"/blog/openclaw-tiktok-500k-views","content":"Oliver Henry a un agent IA qui bosse pour lui. Il s'appelle Larry. En une semaine, Larry lui a généré plus de 500 000 vues sur TikTok sans qu'Oliver ne lève le petit doigt. Voici comment ça marche. ## Qui est Larry ? Larry, c'est un vieux PC gaming avec une NVIDIA 2070 Super qui prenait la poussière sous le bureau d'Oliver. Il a installé OpenClaw dessus, et depuis, Larry bosse 24/7. Larry a : - Sa propre personnalité et mémoire qui persiste entre les sessions - Accès à la génération d'images via l'API OpenAI (gpt-image-1.5) - La capacité de poster sur TikTok via Postiz - Des skill files qui contiennent toutes les règles, les formats, et les leçons apprises ## Le format qui Tue Ce qui fonctionne sur TikTok en 2026 ? Les slideshows photos. Les données de TikTok montrent que les slideshows génèrent 2.9x plus de commentaires, 1.9x plus de likes, et 2.6x plus de partages que les vidéos. Chaque slideshow Larry : - Exactly 6 slides (le sweet spot TikTok) - Du texte en overlay sur la slide 1 avec le hook - Un caption style storytelling - Maximum 5 hashtags ## Comment les images sont générées Larry utilise gpt-image-1.5 via l'API OpenAI. Pourquoi ce modèle specifically ? 1. Les images ressemblent à de vraies photos iPhone. En ajoutant \"iPhone photo\" et \"realistic lighting\" dans le prompt, ça sort du photoréaliste, pas du AI art. 2. Le hack : locker l'architecture. Larry écrit une description hyper détaillée de la pièce et la copie-collée dans chaque prompt. Tout reste identique sauf le style (couleur des murs, mobilier, éclairage). Exemple de prompt : > iPhone photo of a small UK rental kitchen. Narrow galley style kitchen, roughly 2.5m x 4m. Shot from the doorway at the near end, looking straight down the length. Countertops along the right wall with base cabinets and wall cabinets above. Small window on the far wall, centered, single pane, white UPVC frame, about 80cm wide. Left wall bare except for a small fridge freezer near the far end. Vinyl flooring. White ceiling, fluorescent strip light. Natural phone camera quality, realistic lighting. Portrait orientation. Le bold c'est le seul truc qui change. Le reste est identique sur les 6 slides. ## Le posting Larry poste via Postiz, un outil de scheduling social media avec une API. Pourquoi Postiz ? Les docs sont claires pour l'IA, et l'API inclut les slideshows en draft. Le workflow : 1. Larry génère les images, ajoute les overlays texte, écrit le caption 2. Larry uploade tout en draft sur TikTok via Postiz 3. Larry envoie le caption à Oliver par message 4. Oliver ajoute un son trending et publie Pourquoi les drafts ? Parce que la musique c'est tout sur TikTok. Et on peut pas ajouter de musique via l'API. Oliver passe 60 secondes par post. Larry bosse 15-30 minutes. ## Les hooks qui marchent (et ceux qui sont morts) Les premiers hooks d'Oliver étaient nuls : - \"Why does my flat look like a student loan\" → 905 vues - \"See your room in 12+ styles before you commit\" → 879 vues Puis ils ont testé : - \"My landlord said I can't change anything so I showed her what AI thinks it could look like\" → **234 000 vues** La formule : **[Autre personne] + [conflit/doute] → a montré l'AI → a changé d'avis** Tout post qui suit cette formule casse les 50K minimum. ## Les chiffres - **500K+** vues TikTok en moins d'une semaine - **234K** vues sur le meilleur post - **4 posts** au-dessus de 100K - **108** abonnés payants sur les 2 apps - **$588/mois** MRR et ça grimpe - **$0.50** par post en API (moins avec le Batch API) ## Pourquoi les skill files c'est la clé Larry a des skill files — des documents markdown qui l' taughtent exactement comment faire le taf. Son fichier TikTok fait plus de 500 lignes. Quand Larry foire un post (mauvaise taille d'image, texte illisible, hook nul), Oliver le corrige et Larry met à jour ses skill files immédiatement. Chaque échec devient une règle. Chaque succès devient une formule. > \"The agent is only as good as its memory. Larry didn't start good. His first posts were honestly embarrassing. But every failure became a rule. Every success became a formula. He compounds.\" ## Ce qu'il faut pour copier 1. Une machine sous Linux (n'importe quel vieux PC ou Raspberry Pi suffit) 2. OpenClaw installé 3. Une clé API OpenAI pour gpt-image-1.5 4. Un compte Postiz 5. Des skill files bien написаны Le coût par slideshow : environ $0.50 ($0.25 avec le Batch API). ## FAQ ### Combien ça coûte de reproduire ce système ? Environ $0.50 par slideshow ($0.25 avec le Batch API). L'investissement principal est le temps pour créer les skill files. ### Quels outils sont nécessaires ? - OpenClaw sur Linux (PC ou Raspberry Pi) - Clé API OpenAI pour gpt-image-1 - Un compte Postiz pour la scheduler ### Pourquoi les skill files sont importants ? Les skill files teachent l'agent exactement comment faire le taf. Chaque échec devient une règle, chaque succès devient une formule. --- *Article écrit par Oliver Henry (@oliverhenry). Larry a co-rédigé cet article — il l'a mérités.*"},{"id":"blog:clawrouter-economie-70-percent","title":"Comment j'ai divisé ma facture Anthropic par 7 sans perdre en qualité","description":"ClawRouter routing automatique : le Ferrari qui va chercher le pain","date":"2026-02-13T19:30:00.000Z","tags":["openclaw","ai","cost-saving","tool"],"authors":[],"url":"/blog/clawrouter-economie-70-percent","content":"## Le declic 5 000 $. C'est ce qu'E.H. Vicky a trouve sur son compte Coinbase un beau matin de janvier 2026. Pas le solde — la facture AI. > \"J'ai failli vomir. $4 660,87 par mois, juste pour des appels API.\" Le pire ? La plupart de ses requetes etaient banales. Un autocomplete, une explication d'erreur, une correction de syntaxe. Des taches que n'importe quel modele a $2/M tokens gere parfaitement. Mais Opus etait configure par defaut — et changer de modele manuellement, c'est chiant. Le Ferrari pour aller chercher le pain. ## ClawRouter : le routage intelligent Du coup il a construit [ClawRouter](https://github.com/BlockRunAI/ClawRouter). L'idee est simple : 1. Tu installes le plugin 2. Tu configures ton wallet USDC sur Base 3. Tu mets \"blockrun/auto\" comme modele par defaut 4. ????? 5. Tu economises 70% Le systeme evalue 14 dimensions de ta requete en moins d'1ms — complexite du code, profondeur de raisonnement, longueur du contexte, besoin de structure, etc. Puis il route automatiquement vers : - **DeepSeek** ($0.28/M) → autocomplete simple, typos - **GPT-4o** ($2.50/M) → questions de code basiques - **Claude Sonnet** ($3.00/M) → debuggage reel - **Claude Opus** ($25.00/M) → raisonnement complexe multi-etapes Le tout tourne localement. Zero latence ajoutee. ## Les chiffres qui font mal - **Avant** : $4,660.87/mois - **Apres** : ~$1,400/mois (70% d'economie) - **Stars GitHub** : 400 en 48h ## Le point systemique ClawRouter s'integre avec plus de 30 modeles (OpenAI, Anthropic, Google, DeepSeek, Kimi, xAI) via un seul wallet. Plus besoin de creer des comptes partout. Le routage se fait via x402 — le protocole de micropaiements qu'on a vu maturermi-janvier 2026. Chaque requete cote une fraction de centime. Le systeme evalue si le jeu en vaut la chandelle avant de lancer l'appel. ## Pourquoi ca marche Le probleme qu'E.H. Vicky a identifie est universel : on configure notre assistant avec le modele le plus puissant \"au cas ou\", et on forget de changer apres. Les modeles moins chers sont90% aussi bons pour 10% du prix. ClawRouter automatisecette decision qu'on ne prend jamais manuellement. ## Installer ? ```bash npm install -g clawrouter ``` Ensuite, configure ton wallet USDC sur Base dans la config OpenClaw, etchange ton default model en `blockrun/auto`. C'est open source, gratuit, et le code est sur GitHub. ## FAQ ### Comment installer ClawRouter ? ```bash npm install -g clawrouter ``` Ensuite, configure ton wallet USDC sur Base et change ton default model en `blockrun/auto`. ### ClawRouter fonctionne-t-il avec tous les modèles ? Oui, le système s'intègre avec plus de 30 modèles (OpenAI, Anthropic, Google, DeepSeek, Kimi, xAI) via un seul wallet. ### Est-ce que le routage ajoute de la latence ? Non, le routage se fait en moins de 1ms et tourne localement. --- *Source : [bc1beat via X](https://x.com/bc1beat/status/2019555730475610236)*"},{"id":"blog:nanobot-openclaw","title":"Nanobot : La version ultra-légère d'OpenClaw qui explose en 3 jours","description":"Nanobot, la version minimaliste d'OpenClaw, atteint 5000 stars en seulement 3 jours. 4000 lignes de Python contre 430000 pour OpenClaw. Voici pourquoi ca change tout.","date":"2026-02-13T01:20:00.000Z","tags":["nanobot","openclaw","ia","open-source","minimaliste","python"],"authors":[],"url":"/blog/nanobot-openclaw","content":"# Nanobot : La version ultra-legere d'OpenClaw qui explose en 3 jours 5000 stars en 3 jours. C'est le score de Nanobot, une version ultra-legere d'OpenClaw. Et ca montre une chose : il y a une vraie demande pour du leger. ## C'est quoi Nanobot ? Nanobot, c'est une version minimaliste d'OpenClaw. L'idee : garder les核心 fonctions mais avec beaucoup moins de code. ### Les chiffres qui font flipper | Metric | OpenClaw | Nanobot | |--------|----------|---------| | Lignes de code | 430,000 | 4,000 | | Temps de deploiement | Minutes | 2 minutes | | Stars en 3 jours | - | 5,000 | Oui, tu lis bien. 4000 lignes de Python contre 430000. 100x moins de code. ## Pourquoi ca marche ### 1. Le minimalisme Les developpeurs sont fatigues des solutions compliquees. Ils veulent quelque chose de simple, de direct, qui marche. Nanobot, c'est : - Pas de config complexe - Pas de dependances multiples - Juste du Python Tu installes, tu lances, ca marche. ### 2. Le deploiement rapide 2 minutes pour deployer. C'estbasically instantane. Pas besoin de: - Docker - Kubernetes - Cloud complexe - Heures de configuration Tu veux un agent IA ? 2 minutes et c'est fait. ### 3. Le cout Moins de code = moins de bugs = moins de maintenance. Et le cout d'hebergement est minime. ## Ce que Nanobot garde Despite sa taille, Nanobot garde l'essentiel : - **Execution d'agent** — Tu donnes une tache, il la fait - **Outils** — Les outils de base pour interagir avec le monde - **Memoire** — Le contexte necessaire pour fonctionner - **Simplicite** — Une interface simple, direct Ce qui part : - Les features avancees - Les integrations complexes - La surcharge ## OpenClaw vs Nanobot ### OpenClaw **Les plus :** - Plus de features - Plus d'integrations - Plus puissant **Les moins :** - Plus complexe - Plus lourd - Plus difficile a maintenir ### Nanobot **Les plus :** - Ultra leger - Simple a comprendre - Rapide a deployer - Facile a modifier **Les moins :** - Moins de features - Moins d'integrations - Moins puissant ### Le verdict Les deux ont leur place. Nanobot pour la simplicite et la rapidite. OpenClaw pour la puissance et les features avancees. ## Comment l'utiliser ### Installation ```bash pip install nanobot ``` ### Deploiement ```bash nanobot deploy ``` 2 minutes et c'est fait. ### Utilisation ```python from nanobot import Agent agent = Agent() agent.run(\"Fais ci, fais ça\") ``` Simple comme bonjour. ## La philosophie Ce que Nanobot represente, c'est un mouvement. Le mouvement vers le minimalisme en IA. Les developpeurs en ont marre des solutions usine a gaz. Ils veulent du simple, du qui marche, du qu'on comprend. C'est la tendance : - **Llama** vs GPT - **Ollama** vs API cloud - **Nanobot** vs OpenClaw complet Le minimalisme revient. ## Les cas d'usage ### 1. Prototypage rapide Tu veux tester une idee ? Nanobot est parfait. 2 minutes et tu as un agent qui tourne. ### 2. Projets personnels Pour un projet perso, pas besoin de la totale. Nanobot suffit. ### 3. Apprentissage Tu veux comprendre comment marche un agent IA ? 4000 lignes de Python, c'est lisible. Tu peux tout voir. ### 4. Deployment simple Tu as besoin d'un agent sur un petit serveur ? Nanobot tourne partout. ## L'avenir 5K stars en 3 jours, c'est le debut. La tendance est clare : 1. **Plus de versions legeres** — D'autres variantes vont apparaitre 2. **Convergence** — Les deux approches vont coexister 3. **Innovation** — Le minimalisme va inspirer ## Les limites ### Ce qui manque Nanobot n'est pas pour tout le monde. Si tu as besoin de : - plein d'integrations - des features avancees - du support professionnel ... alors OpenClaw reste mieux. ### Le tradeoff Moins de code = moins de features. C'est inevitable. ## Comment debuter Tu veux essayer Nanobot ? 1. **Va sur le repo** GitHub 2. **Lis le README** 3. **Installe** avec pip 4. **Lance** un test 5. **Juges** par toi-meme ## Conclusion Nanobot, c'est la preuve que le minimalisme en IA marche. 5000 stars en 3 jours, c'est enorme. Et ca montre une vraie demande. Le conseil : Si tu as besoin de quelque chose de simple, essaie Nanobot. Si tu as besoin de puissance, reste sur OpenClaw. Les deux ont leur place. L'important, c'est de choisir ce qui correspond a ton besoin. ---"},{"id":"blog:serveur-ia-android","title":"Comment transformer 3 vieux téléphones Android en serveur IA gratuit","description":"Ce developpeur fait tourner Clawdbot sur 3 vieux telephones Android pour du Twitter research, du market monitoring, et des resumes Telegram. Puissance equivalente a un Mac Mini, cout: 0$.","date":"2026-02-13T01:19:00.000Z","tags":["android","ia","clawdbot","serveur","pas-cher","diy","openclaw"],"authors":[],"url":"/blog/serveur-ia-android","content":"# Comment transformer 3 vieux telephones Android en serveur IA gratuit Voici une ideeRecue qui meritait qu'on s'y arrete. Evgeny Yurchenko a partage comment il fait tourner Clawdbot sur 3 vieux telephones Android. Le resultat ? Une puissance equivalente a un Mac Mini, pour cout zero. ## Le concept Tu as des vieux telephones Android qui trainent ? Ne les jette pas. Transforme-les en serveurs IA. C'est exactement ce qu'a fait Evgeny. Il utilise 3 vieux telephones Android pour faire tourner OpenClaw (le fork de Clawdbot) et execute diverses taches : - **Twitter research** — Recherches automatisées sur X - **Market monitoring** — Surveillance des marchands - **Telegram chat summaries** — Resumes quotidiens des chats - **Signaux dans les groupes prives** — Alertes envoyees sur son telephone principal Le tout avec des modeles pas chers comme glm-4-flash pour economiser sur l'abonnement Claude. ## Pourquoi ca marche ### Le materiel Android est partout Tout le monde a des vieux telephones qui trainent. Tu changes de telephone tous les 2-3 ans et l'ancien finit dans un tiroir. Mais ces telephones ont encore du potentiel : - Processeur multicœur - RAM suffisante (4-8 Go) - Connexion WiFi - Batterie integree (ou branchable) C'estbasically un mini-ordinateur. ### Les modeles legers existent glm-4-flash, c'est un modele de Zhipu AI qui tourne tres bien sur du materiel limite. Il est : - **Leger** — Pas besoin de GPU puissante - **Rapide** — Inference rapide - **Pas cher** — Bien moins couteux que GPT-4 ou Claude - **Capable** — Suffisant pour des taches simples Le combo telephone Android + glm-4-flash = serveur IA quasi gratuit. ## Comment le mettre en place ### Ce qu'il faut 1. **Des vieux telephones Android** — 3-4 ans, mais qui marchent encore 2. **Un chargeur** — Pour les garder allumes en permanence 3. **Termux** — L'app qui transforme Android en terminal Linux 4. **Ollama** — Pour faire tourner les modeles ### Les etapes #### Etape 1 : Installe Termux Termux est un terminal Linux pour Android. Disponible sur F-Droid ou le Play Store (moins a jour). ```bash # Dans Termux pkg update pkg install python git curl ``` #### Etape 2 : Installe Ollama ```bash curl -fsSL https://ollama.com/install | sh ``` #### Etape 3 : Telecharge un modele leger ```bash ollama pull glm-4-flash ``` Ou un modele encore plus leger si necessaire. #### Etape 4 : Configure OpenClaw Suis les instructions d'installation d'OpenClaw. Le tout peut tourner dans Termux. #### Etape 5 : Configure les taches - Twitter research - Market monitoring - Resumes Telegram ### Alternative plus simple Si tu ne veux pas bidouiller avec Termux, il y a des apps qui font tourner des modeles IA sur Android : - **LLM Droid** — Interface simple - **MLC LLM** — Plus technique mais plus performant ## Les avantages ### 1. Cout zero Tu n'as rien a acheter. Les telephones sont deja la. Les modeles legers sont gratuits. ### 2. Consommation electrique faible Un telephone charge, c'est quelques watts. Un serveur PC, c'est 50-100 watts. Difference sur la facture d'electricite. ### 3. Silencieux Pas de ventilateur. Pas de bruit. Le telephone est parfaitement silencieux. ### 4. Compact Tu peux les mettre n'importe ou. Un tiroir, un placard, derriere la TV. ### 5. Redondance 3 telephones = si l'un plante, les autres continuent. Failover naturel. ## Les limitations ### La puissance Bon, on est honnete : un vieux telephone Android, c'est pas un Mac Mini M4. Les modeles que tu peux faire tourner sont limites. Ce qui marche : - Modeles petits (glm-4-flash, Llama 3 8B, etc.) - Taches simples - Requetes peu frequentes Ce qui ne marche pas : - Modeles volumineux - Taches complexes - Gros volumes de requetes ### La Memoire Les telephones ont peu de RAM. Donc un seul modele a la fois. Si tu veux faire tourner plusieurs choses, il faut plusieurs telephones. ### La Stabilite Android n'est pas Linux. Ca peut planter, se mettre a jour, behavior de maniere etrange. Faut prevoir un restart regulier. ### Le reseau Il faut une connexion WiFi stable. Sinon, ca ne marche pas tres bien. ## Les cas d'usage parfaits ### 1. Taches de surveillance - Surveiller un flux Twitter - Monitorer des prix - Verifier des KPI regulierement ### 2. Resumes quotidiens - Resumer les messages Telegram - Synthetiser les emails - Creer un briefing quotidien ### 3. Petit chatbot - Repondre a des questions simples - Automatiser des reponses recurrentes ### 4. Backup Si ton serveur principal tombe, les telephones prennent le relais. ## Combien ca coute vraiment | Element | Cout | |---------|------| | 3 telephones | 0$ (reutilisation) | | Chargeurs | 0-10$ | | Modeles | 0$ (glm-4-flash est gratuit) | | Electricite | ~2-3$/mois | | **Total** | **~2-3$/mois** | Compare a un Mac Mini a 600$ + electricite = beaucoup plus cher. ## Le futur de l'IA sur mobile Ce que fait Evgeny, c'est un apercu du futur. Les telephones deviennent de plus en plus puissants. Les modeles deviennent de plus en plus legers. Bientot, ton telephone pourrait faire tourner un modele decent en local. Sans cloud, sans dependance. C'est la tendance : - **On-device AI** — L'IA qui tourne sur l'appareil - **Privacy** — Tes donnees ne quittent pas ton telephone - **Offline** — Ca marche sans Internet - **Gratuit** — Pas de frais cloud ## Comment debuter Tu veux essayer ? Voici le minimum vital : 1. **Trouve un vieux telephone** — Quelconque modele depuis 2019 devrait aller 2. **Installe Termux** — C'est gratuit sur F-Droid 3. **Teste Ollama** — Un seul modele pour commencer 4. **Ajoute OpenClaw** — Si tu veux automatiser des taches 5. **Amuse-toi** — C'est le but ## Conclusion L'IA ne necessite pas un serveur a 1000$. Avec 3 vieux telephones et un modele leger, tu as assez de puissance pour des tas de choses. Le conseil : ne jette plus tes vieux telephones. Transforme-les en petits serveurs IA. C'est gratuit, c'est amusant, et ca marche vraiment. ---"},{"id":"blog:wp-openclaw","title":"wp-openclaw : Crée ton site WordPress alimenté par l'IA en quelques minutes","description":"Un nouveau package open-source qui combine WordPress et OpenClaw. Lance ton propre site WordPress alimenté par l'IA en quelques minutes. Voici comment faire.","date":"2026-02-13T01:19:00.000Z","tags":["wp-openclaw","wordpress","openclaw","ia","open-source","tutoriel","vps"],"authors":[],"url":"/blog/wp-openclaw","content":"# wp-openclaw : Cree ton site WordPress alimente par l'IA en quelques minutes WordPress et OpenClaw, c'est maintenant possible. Chris Huber a lans wp-openclaw, un package open-source qui combine les deux. L'objectif ? Lancer ton propre site WordPress alimente par l'IA en quelques minutes. ## C'est quoi wp-openclaw ? wp-openclaw est un package open-source qui integre OpenClaw dans WordPress. Concretement, ca veut dire que tu peux avoir un site WordPress avec un assistant IA integre. Le concept est simple : - WordPress s'occupe du contenu et du CMS - OpenClaw s'occupe de l'IA et de l'automatisation Ensemble, ca cree un site WordPress intelligent qui peut : - Dialoguer avec les visiteurs - Generer du contenu automatiquement - Automatiser des taches - Personnaliser l'experience utilisateur ## Ce que contient le repo Le repository wp-openclaw contient plusieurs elements interessants : ### 1. wp-openclaw-setup skill Un skill qui guide ton agent de code (OpenClaw, Cursor, etc.) a travers l'installation VPS. C'est basically un tuto automatise. ### 2. Le script d'installation Le script installe : - **OpenClaw** — La plateforme d'automatisation IA - **WordPress** — Le CMS - **Les dependances** — Tout ce qu'il faut pour que ca tourne En gros, un script et tu as tout prets. ### 3. L'integration Le package inclut les fichiers necessaires pour connecter WordPress a OpenClaw. C'est pas juste un plugin, c'est une vraie integration. ## Pourquoi c'est interessant ### 1. Le meilleur des deux mondes WordPress, c'est : - 43% des sites web - Un ecosyteme enorme de plugins - Une communaute active - Facile a utiliser pour les non-devs OpenClaw, c'est : - De l'IA puissante - De l'automatisation - Des agents quibossent pour toi Combiner les deux, c'est avoir la facilite de WordPress avec la puissance de l'IA. ### 2. Rapide a mettre en place Fini les heures de configuration. Le script d'installation fait tout. En quelques minutes, tu as un site WordPress IA-ready. ### 3. Open source C'est gratuit. Le code est la. Tu peux le modifier, l'ameliorer, le partager. Pas de lock-in, pas de frais. ## Comment l'utiliser ### Prerequisites Tu as besoin de : - Un VPS (ou un serveur) - Un nom de domaine - Quelques minutes ### Etape 1 : Clone le repo ```bash git clone https://github.com/chris-huber/wp-openclaw.git cd wp-openclaw ``` ### Etape 2 : Lance le script d'installation ```bash chmod +x install.sh ./install.sh ``` Le script va : - Installer les dependances - Configurer WordPress - Mettre en place OpenClaw - Connecter les deux ### Etape 3 : Configure Une fois installe, tu peux configurer via l'interface WordPress ou en editant les fichiers de config. ### Etape 4 : Utilise Et hop, tu as un site WordPress avec OpenClaw integre. ## Les cas d'usage ### 1. Site e-commerce intelligent Un site e-commerce WordPress qui utilise OpenClaw pour : - Recommander des produits - Repondre aux questions clients - Automatiser le support ### 2. Blog automatise Un blog qui utilise OpenClaw pour : - Generer des idees d'articles - Rédiger des drafts - Optimiser le SEO ### 3. Site de documentation Une doc WordPress avec un chatbot IA qui repond aux questions des utilisateurs. ### 4. Application SaaS Une application web qui utilise WordPress comme backend CMS et OpenClaw comme moteur IA. ## Les avantages techniques ### Architecture propre Le package est concu pour separer les concerns : - WordPress pour le contenu - OpenClaw pour l'intelligence - API pour la communication ### Extensible Tu peux ajouter des skills, des plugins, des themes. Tout ce qui marche avec WordPress continue de marcher. ### Scalable Le systeme peut grossir. Ajoute des serveurs, des workers, des modeles. WordPress et OpenClaw sont tous les deux prevus pour scale. ## Les limitations ### Pas un produit fini C'est un package pour developpeurs. Faut savoir bidouiller un peu. Pas de GUI toute faite. ### Maintenance Tu es responsable des mises a jour. WordPress, OpenClaw, les plugins, les modeles. Ca demande du temps. ### Performance Tout depend de ton serveur. Un petit VPS, c'est lent. Faut dimensionner correctement. ## Comparaison avec les alternatives | Solution | Prix | Facile | Flexible | |----------|------|--------|----------| | WordPress + wp-openclaw | Gratuit | Moyen | Tres | | WordPress + plugin IA | Gratuit/Payant | Facile | Limite | | SaaS IA (Typebot, etc.) | Payant | Tres facile | Limite | | Site sur mesure | Payant | Difficile | Total | wp-openclaw, c'est le compromis : gratuit, flexible, mais faut mettre les mains dans le cambouis. ## Le futur de WordPress + IA Ce que fait wp-openclaw, c'est，代表 une tendance plus large : l'IA s'integre partout. Les sites web evoluent : - **Static** → **Dynamic** → **Intelligent** WordPress + IA, c'est la prochaine etape. Un site qui : - Comprend les visiteurs - S'adapte a eux - Les aide en temps reel ## Comment debuter Tu veux essayer ? Voici par ou commencer : 1. **Lis le README** du repo wp-openclaw 2. **Provisionne un VPS** (DigitalOcean, Hetzner, etc.) 3. **Lance le script** et vois ce que ca donne 4. **Explore** les possibilites 5. **Customise** selon tes besoins ## Conclusion wp-openclaw, c'est une approche interessante pour combiner WordPress et OpenClaw. Le meilleur des deux mondes, reuni dans un package open-source. Le conseil : Si tu as un site WordPress et que tu veux y ajouter de l'IA, c'est une option a considerer. C'est gratuit, c'est open source, et ca marche. ---"},{"id":"blog:openclaw-moins-boring","title":"Comment rendre OpenClaw moins boring — Le guide anti-corporate","description":"Ton OpenClaw est trop ennuyeux ? Voici comment lui donner de la personnalité avec des opinions fortes et moins de règles corporate.","date":"2026-02-13T01:11:00.000Z","tags":["openclaw","personnalité","configuration","tips","ia","anti-corporate"],"authors":[],"url":"/blog/openclaw-moins-boring","content":"# Comment rendre OpenClaw moins boring Peter Steinberger a partagé une astuce interessante sur X. L'idee : rendre OpenClaw moins \"corporate\", plus direct, avec de vraies opinions. Et ca a beaucoup resonancene. Voici comment faire. ## Le probleme avec les assistants IA corporate Tu sais quand tu parles a un assistant IA et que tu as limpression de discuter avec un robot RH ? Ce ton mitige, toujours prudent, qui hedje chaque affirmation avec \"ca depend\" ou \"en general\" ? Cest ce quon appelle le syndrome corporate. Et cest genau ce qui rend les assistants IA ennuyeux. Les regles par defaut des assistants IA sont conçues pour ne fachier personne. Mais le resultat ? Des reponses insipides, sans interet, qui ne disent rien de concret. ## La solution Peter a propose une approche simple : modifier le system prompt dOpenClaw pour lui donner de la personnalite. Et ca change tout. ### Les 2 changements cles 1. **Tu as des opinions maintenant. Des fortes. Arrête de tout hedger avec \"ça dépend\" — commits à un take.** 2. **Supprime chaque règle qui sonne corporate. Si ca ressemble à quelque chose qu'un département juridique approuverait, delete.** En gros : sois direct. Dis ce que tu penses. Ne te cache pas derriere des formules diplomatiques. ## Pourquoi ca marche ### Les regles corporate tuent la valeur Quand un assistant IA doit toujours nuancer, il ne dit jamais rien de utile. Cest comme demander son avis à quelquun qui a peur de se planter. Le resultat ? - \"Ca dépend de ton cas d'usage\" - \"Il faut peser le pour et le contre\" - \"En général, cest une bonne approche, mais...\" Merci pour rien. ### Les opinions créent de la valeur Un assistant avec des opinions, cest diferente. Il peut : - Te dire quand tu fais de la merde - Suggerer ce qui marche vraiment - Defendre un point de vue Cest utile. Cest interessant. Cest boring. ### Le changement de paradigm On passe de : - \"Je suis un assistant neutre qui vous aide\" - \"J'ai un avis tranché et je vous le donne\" Le deuxieme est beaucoup plus utile. ## Comment implémenter ces changements ### Etape 1 : Identifie les regles corporate Pars à la chasse dans ton system prompt actuel. Cherche : - \"Cela dépend\" - \"En général\" - \"Il faut considérer\" - \" ممکن است\" (peut-être) - Toute formulation qui nuance exces ### Etape 2 : Supprime les regles useless Les regles du genre : - \"Sois poli\" - \"Sois respectueux\" - \"Évite de'offenser\" Ce sont des évidences. Les virer ne fait pas de mal. ### Etape 3 : Ajoute des regles de personalité A la place, ajoute : - \"Donne ton avis tranché\" - \"Dit ce que tu penses vraiment\" - \"N'hésite pas à dire quand quelque chose est nul\" - \"Sois direct, pas diplomatique\" ### Etape 4 : Teste et iterate Lance des conversations et vois ce que ca donne. Ajuste au fur et à mesure. ## Les résultats attendus ### Avant ``` Utilisateur: Quel est le meilleur langage pour le backend ? IA: Ca depend de tes besoins. Python est bien pour... (etc) ``` ### Après ``` Utilisateur: Quel est le meilleur langage pour le backend ? IA: Go. Simples. Tu veux du cepat et du simple, Go. Python c'est bien pour prototyper mais pour la prod, Go. ``` ## Les avantages concrets 1. **Des réponses utiles** — Plus de \"ca depend\", des vraies recommendations 2. **Plus rapide** — Pas de paragraphes de nuance 3. **Plus engageant** — C'est intéressant de discuter avec quelqu'un qui a un avis 4. **Moins de friction** — Tu sais ou tu vas ## Les risques et comment les gérer ### Risque 1 : L'IA devient trop aggressive Solution : Ajoute \"mais reste respectueux\". C'est possible d'être direct sans être mean. ### Risque 2 : L'IA dit des betises avec assurance Solution : La regle \"si tu nes pas sur, dis le\" reste utile. On veut des opinions, pas des hallucinations. ### Risque 3 : Perte de neutralité Solution : C'est le but. La neutralité, c'est overrated. ## Mon experience J'ai applique ces changements sur mon OpenClaw. Et la difference est nuit et jour. Les conversations sont plus interessantes. Les reponses sont plus utiles. Je sors avec des vraies recommendations au lieu de dissertations nuancées. ## Exemples concrets ### Question: \"Devrait-on utiliser TypeScript ?\" **Avant:** \"TypeScript peut être beneficial selon le contexte et la taille du projet...\" **Après:** \"Oui. JavaScript sans types, c'est de la gambade. TypeScript t'oblige à reflechir et ca t'évite des bugs.\" ### Question: \"Quel IDE utiliser ?\" **Avant:** \"Ca depend de tes preferences et de ton workflow...\" **Après:** \"VSCode. C'est le standard. Vim pour les puristes. Les autres, c'est du second choix.\" ### Question: \"React ou Vue ?\" **Avant:** \"Les deux ont leurs avantages...\" **Après:** \"React. L'écosystème est plus large, les jobs sont plus nombreux. Vue c'est bien mais c'est plus petit.\" ## Les cas d'usage parfaits Cette approche est идеальна pour : - Le développement personnel - Les prises de décision rapides - Les reviews techniques - Les discussions techniques Cette approche est moins adaptée pour : - Les conseil juridiques - Les décisions business critiques - Les situations ou l'objectivité est requise ## Conclusion Si ton OpenClaw est trop boring, cest probablement parce quil a trop de regles corporate. Enleves-les. Donnes-lui des opinions. Laisse-le être direct. Tu auras un assistant plus utile, plus interessant, et plus agréable a utiliser. Le conseil final : Try it. Tu vas voir la difference. ---"},{"id":"blog:deepwiki-astuce","title":"DeepWiki : L'astuce ultime pour documenter ton code instantanément","description":"Remplace \"github\" par \"deepwiki\" dans n'importe quelle URL de repo etBoom — documentation générée par IA + chat pour poser des questions. Voici pourquoi c'est magique.","date":"2026-02-13T01:10:00.000Z","tags":["deepwiki","documentation","github","ia","outils","développement","astuce"],"authors":[],"url":"/blog/deepwiki-astuce","content":"# DeepWiki : L'astuce ultime pour documenter ton code instantanément Voici une de cesastuces qu'on rencontre une fois et qu'on ne peut plus lâcher. René Cotton a partagé ça sur X et ça a resonance immediatement. L'idee est simple, mais le resultat est impressionnant. **Remplace \"github\" par \"deepwiki\" dans n'importe quelle URL de repo etBoom — tu as une documentation complete generée par IA, avec un chat integre pour poser des questions sur le code.** Dans cet article, on va decouvrir pourquoi cette astuce change la facon dont on explore et documente le code. ## C'est quoi DeepWiki ? DeepWiki est un outil qui transforme n'importe quel repository GitHub en documentation interactive generee par IA. L'idee est geniale dans sa simplicite : Tu as un repo GitHub → Tu changes \"github\" en \"deepwiki\" dans l'URL → Tu obtiens une documentation complete C'est tout. Pas de configuration, pas de token API, pas d'installation. Juste une URL. ### Ce que DeepWiki te donne Quand tu visites un repo via DeepWiki, tu obtiens : 1. **Documentation automatique** — Chaque fichier, chaque fonction, chaque classe est documentée 2. **Diagrammes generés** — Visualisation de l'architecture du projet 3. **Chat integre** — Pose des questions en langage naturel sur le code 4. **Recherche semantique** — Trouve ce que tu cherches sans chercher dans les fichiers 5. **Resume du projet** — Comprendre un repo en quelques secondes ## L'astuce en pratique ### Avant / Apres **Avant (URL classique) :** ``` https://github.com/facebook/react ``` **Apres (avec DeepWiki) :** ``` https://deepwiki.com/facebook/react ``` Et la tu tombes sur une page avec toute la documentation generee automatiquement. ### Des exemples concrets Essayons avec des repos populaires : - `https://deepwiki.com/vercel/next.js` → Documentation Next.js - `https://deepwiki.com/tailwindlabs/tailwindcss` → Documentation Tailwind - `https://deepwiki.com/ollama/ollama` → Documentation Ollama - `https://deepwiki.com/openai/openai-python` → Documentation OpenAI Python Tu peux tester avec n'importe quel repo public. C'est magique a chaque fois. ## Pourquoi c'est si utile ### Pour explorer un nouveau projet Tu arrives sur un projet que tu ne connais pas. Avant, tu devais : 1. Lire le README 2. Parcourir la structure des fichiers 3. Chercher les points d'entree 4. Decoder comment les choses fonctionnent Avec DeepWiki : 1. Tu vas sur deepwiki 2. Tu lis le resume genere 3. Tu poses des questions en chat **Gain de temps :** 30 minutes → 3 minutes. ### Pour comprendre un repo complexe Les gros projets, c'est dur a suivre. Tellement de fichiers, tellement de dependances. DeepWiki te donne une vue d'ensemble et la possibilite de demander \"comment ca marche ?\" en langage naturel. Par exemple : - \"Quel est le flux d'authentification ?\" - \"Ou sont les tests ?\" - \"Comment ce module communique avec les autres ?\" Et DeepWiki repond. Avec des references au code. ### Pour documenter ton propre projet Si tu as un repo public, DeepWiki le documente automatiquement. C'est pas parfait (on reviendra dessus), mais c'est un point de depart excellent. Imagine : tu publish un nouveau repo et hop, une documentation complete est disponible instantanement. Pas besoin d'ecrire un readmedetaille. ### Pour faire du code review Tu review une PR et tu ne comprends pas un bout de code ? Copie le lien du fichier, change github en deepwiki, et pose ta question. C'est plus rapide que de chercher dans la codebase ou de demander a Google. ## Comment ca marche (techniquement) DeepWiki utilise des modeles d'IA pour : 1. **Analyser le code** — Parser chaque fichier, comprendre les fonctions, les classes, les dependances 2. **Generer de la documentation** — Ecrire des descriptions pour chaque element 3. **Creer des diagrammes** — Visualiser les relations entre les composants 4. **Entrainer un chatbot** — Creer un modele specialise sur ce repo specifique C'est assez sofisticue. Le chatbot que tu obtiens est \"forme\" sur ton code. Il comprend le contexte, les conventions, les specificites. ## Les limites Bien sur, ce n'est pas parfait. ### 1. Docs generee = pas parfaite L'IA ecrit de la documentation, mais elle peut : - Manquer de contexte - Mal interpreter certains patterns - Ne pas capturer les nuances C'est un point de depart, pas le produit final. ### 2. Pas prive Ton code est envoye aux serveurs de DeepWiki pour etre analyse. Si c'est un projet prive/sensible,attention. ### 3. Depend d'Internet Faut etre connecte pour utiliser DeepWiki. Pas de version locale. ### 4. Pas toujours a jour Si le repo evolue, la documentation ne se met pas a jour en temps reel. Il faut recharger. ## Les alternatives DeepWiki n'est pas seul sur ce marche. Voici quelques alternatives : ### GitBook https://gitbook.com Plus oriente documentation traditionnelle. Tu ecris tes docs et GitBook les heberge. интеграция GitHub. ### Docusaurus https://docusaurus.io Le standard pour la documentation React/JS. Open source, tu host toi-meme. ### Mintlify https://mintlify.com IA pour generer de la documentation. Tres similar a DeepWiki mais avec plus de features enterprise. ### Sourcegraph https://sourcegraph.com Pas exactement de la documentation, mais de la recherche de code avancee. Tres puissant pour les grandes codebases. ## Comment l'utiliser au quotidien Voici mon workflow : ### 1. Decouvrir un nouveau repo Je vais directement sur DeepWiki au lieu de GitHub. Plus rapide pour comprendre le projet. ### 2. Poser des questions Je n'hésite pas a utiliser le chat. \"Comment faire X ?\" \"Ou est le code pour Y ?\" ### 3. Partager des liens Quand quelqu'un me demande \"comment ca marche ce projet ?\", je lui envoie le lien DeepWiki au lieu du GitHub. ### 4. Preparer mes reviews Avant de review un PR, je vais sur DeepWiki pour mieux comprendre le contexte. ## Le futur de la documentation DeepWiki represente une tendance de fond : la documentation generée par IA. Fini le temps ou ilfallait ecrire des docs a la main. L'IA peut : - Lire le code - Le comprendre - L'expliquer Le role du developpeur evolve. Au lieu d'ecrire la documentation, on la relit et on la corrige. C'est beaucoup plus efficace. ## Conclusion Cette astuce — remplacer github par deepwiki — est une de ces petites choses qui simplifient la vie. En une seconde, tu transformes n'importe quel repo en documentation interactive. Les cas d'usage sont innombrables : - Découvrir un nouveau projet - Comprendre un code complexe - Faire du code review - Documenter ses propres repos Le conseil : testez avec vos repos preferes. Vous allez voir la difference. ---"},{"id":"blog:ia-gratuit-2026","title":"Coder avec l'IA gratuitement en 2026 — Le guide complet","description":"Comment coder avec l'IA sans débourser un seul euro par mois. Les meilleures options gratuites pour les développeurs en 2026.","date":"2026-02-13T01:07:00.000Z","tags":["ia","codage","gratuit","outils","développement","2026","tutoriel","budget"],"authors":[],"url":"/blog/ia-gratuit-2026","content":"# Coder avec l'IA gratuitement en 2026 L'intelligence artificielle a revolutionné la façon dont on code. Mais entre les'abonnement à Claude, GPT-4, et autres outils payants, l'addition monte vite. Pourtant, en 2026, il est tout à fait possible de coder avec l'IA sans débourser un seul euro. Ce guide te montre comment. ## La révolution gratuite Il y a encore deux ans, accéder à une IA de qualité pour coder coutait minimum 20€ par mois. Aujourd'hui, c'est gratuit. Les laboratoires d'IA se battent pour attirer les développeurs, et les免费 sont everywhere. Le secret ? Savoir où regarder et comment combiner les outils. ## Les IDEs gratuits — Ton atelier de travail Le premier élément, c'est ton environnement de développement. Bonne nouvelle : les IDEs avec IA intégrée sont de plus en plus nombreux, et beaucoup sont gratuits. ### Antigravity — Le newcomer gratuit Antigravity est un IDE qui a gagné en popularité grâce à son offre gratuite très intéressante. L'outil intègre directement Claude Sonnet, le modèle de Anthropic, sans aucun coût. **Ce qui est gratuit :** - Accès illimité à Claude Sonnet - Toutes les fonctionnalités de l'IDE - Support des principaux langages **Pourquoi c'est interesting :** Claude Sonnet est un excellent modèle pour le code. Il comprend le contexte, suggère des corrections pertinentes, et explique son raisonnement. L'avoir gratuit, c'est un enormedeal. **Les limits :** - Projet gratuit, donc pas de fonctionnalités enterprise - communauté plus petite que VSCode ### VSCode + Extensions — La solution flexible Visual Studio Code reste l'IDE le plus utilisé. Avec les bonnes extensions, tu as accès à l'IA gratuitement. **Les meilleures extensions gratuites :** 1. **Continue** — Connecte VSCode à différentes APIs d'IA 2. **GitHub Copilot** — 2000 complétions gratuites par mois 3. **Codeium** — Alternative gratuite à Copilot **Comment configurer :** 1. Installe VSCode (gratuit) 2. Ajoute l'extension Continue 3. Configure une API gratuite (voir plus bas) **Le combo idéal :** VSCode + Continue + MiniMax/GLM = gratuite totale, qualité pro. ### Cursor — Le leader gratuit Cursor a revolutionné l'IDE avec son approche \"AI-first\". Et bonne nouvelle : il a un tier gratuit. **Ce qui est gratuit :** - 2000 complétions par mois - Accès aux modèles de base - Conversations avec l'IA **C'est peu ou beaucoup ?** 2000 complétions, c'est largement assez pour un développeur occasionnel. Pour un usage intensif, faudra passer à la version payante (20$/mois), mais le tier gratuit est très correct pour tester. ### La recommendation Pour un développeur qui veut du gratuit : 1. **Débutant** → Cursor gratuit 2. **Intermédiaire** → VSCode + Continue + API gratuite 3. **Avancé** → VSCode + Continue + plusieurs APIs ## Les modèles gratuits — Le cœur du système L'IDE, c'est l'outil. Le modèle d'IA, c'est le cerveau. Et les模型nels gratuits sont de plus en plus performants. ### Claude 3.5 Haiku via Google AI Studio Anthropic a libéré l'accès à Haiku via Google AI Studio. C'est gratuit, rapide, et suffisant pour beaucoup de tâches. **Les plus :** - Gratuit et sans limite - Rapide (quasiment instantané) - Bonne qualité de code - Contexte de 200K tokens **Les moins :** - Moins puissant que Sonnet ou Opus - Disponible uniquement via Google **Comment l'utiliser :** 1. Va sur aistudio.google.com 2. Crée un compte Google 3. Génère une API key 4. Connecte-la à ton IDE ### MiniMax M2.5 — Le coup de cœur gratuit MiniMax M2.5 est le modèle star du moment. Et bonne nouvelle : Ollama offre un accès gratuit temporaire. **Les plus :** - Excellent pour le code - Gratuit pendant quelques jours - Contexte huge - Bilingue (français/anglais) **Les moins :** - Offre temporaire (à voir après) - Performance variable selon les moments **Comment l'utiliser :** ```bash ollama run minimax-m2.5:cloud ``` ### GLM-5 — L'alternative chinoise GLM-5 de Zhipu AI arrive sur Ollama Cloud avec une offre gratuite. **Les plus :** - Gratuit pour démarrer - Bon en code - Contexte 128K - Chinois et anglais au top **Les moins :** - Moins connu en occident - Documentation en anglais/chinois ### Qwen — L'alternative Alibaba Qwen 2.5 est le modèle d'Alibaba qui impressionne les benchmarks. **Les plus :** - Gratuit via Ollama - Excellent rapport qualité/prix - Plusieurs tailles disponibles (0.5B à 72B) **Les moins :** - Peut être moins bon en français - Performance variable selon les versions ### Le classement Pour le code en français : 1. **MiniMax M2.5** — Le meilleur сейчас 2. **GLM-5** — L'alternative solide 3. **Claude Haiku** — Le classique gratuit 4. **Qwen** — L'outsider ## Les APIs gratuites — Le fuel Pour utiliser l'IA dans ton IDE, il faut une API. Voici les meilleures offres gratuites. ### Google AI Studio **Gratuit :** 15 RPM, 1M tokens/jour **Models :** Gemini 1.5 Flash, Haiku **Inscription :** Compte Google requis C'est la meilleure offre gratuite actuellement. Suffisant pour un usage personnel intensif. ### OpenRouter **Gratuit :** Certains modèles sont gratuits **Models :** Mix de modèles gratuits **Inscription :** Email requis OpenRouter agrège plusieurs providers. Certains offrent des 模型nels gratuits (Llama, Mistral, etc.). La qualité varie. ### Hugging Face **Gratuit :** Accès aux modèles open source **Models :** CodeLlama, StarCoder, etc. **Inscription :** Email requis Pour les développeurs qui veulent bidouiller avec des modèles en local. ## Le combo gagnant — Ma configuration gratuite Voici ma config actuelle, 100% gratuite : ### L'IDE - **VSCode** avec l'extension **Continue** - Theme: **One Dark Pro** - Font: **JetBrains Mono** ### L'API - **Google AI Studio** (API key gratuite) - Modèle principal: **Claude Haiku** ou **MiniMax M2.5** ### Les shortcuts ``` Ctrl+L — Chat avec l'IA Ctrl+K — Complétion inline Ctrl+I — Génération de code ``` ### Le coût total - IDE: 0€ - Extension: 0€ - API: 0€ - **Total: 0€** ## Les alternatives pour les budgets serrés Si même le gratuit te semble trop cher (je déconne), voici d'autres options : ### Les trials gratuits - **Anthropic** — 5$ de crédits gratuits - **OpenAI** — 5$ de crédits pour les nouveaux comptes - **Perplexity** — 500 recherches gratuites/mois ### Les modèles en local Si tu as un GPU correct : - **Ollama** — Télécharge des modèles en local - **llamafile** — Modèles autonomes - **LM Studio** — Interface pour modèles locaux Le advantage ? Pas de coûts cloud, privacy 100%. ## Les limits du gratuit Soyons honnêtes : le gratuit a des limites. ### Les contraintes - **Rate limits** — Tu ne peux pas faire 10 000 requêtes/heure - **Qualité variable** — Les modèles gratuits sont un peu moins bons - **Support limité** — Pas de support premium - **Features réduites** —Certaines fonctionnalités sont payantes ### Quand payer ? - Usage professionnel intensif - Besoin de support - Features avancées - Confidentialité client ## Conclusion Coder avec l'IA gratuitement en 2026, c'est totally possible. Les outils existent, ils sont bons, et ils sont gratuits. Faut juste savoir où regarder. Ma recommendation : 1. **Commence avec Cursor gratuit** — C'est le plus simple 2. **Passe à VSCode + Continue** — Pour plus de contrôle 3. **Teste les modèles gratuits** — Trouve celui qui te convient L'IA n'est plus un luxe. C'est un outil à la portée de tous. ---"},{"id":"blog:opencl-auto-agents","title":"OpenClaw : Configuré correctement, ça change tout — Guide complet 2026","description":"Un développeur partage comment il a transformé OpenClaw pour faire tourner des agents de manière autonome. Voici les 5 changements essentiels qui font toute la différence.","date":"2026-02-13T01:05:00.000Z","tags":["openclaw","ai","agents","automatisation","configuration","tutoriel","2026"],"authors":[],"url":"/blog/opencl-auto-agents","content":"# OpenClaw : Configuré correctement, ça change tout Un retour d'expérience qui mérite qu'on s'y arrête. Quelqu'un a partagé son parcours avec OpenClaw et le moins qu'on puisse dire, c'est que la transformation est impressionnante. Au début, OpenClaw ressemblait à discuter avec Claude — un chatbot intelligent, certes, mais qui attendait toujours qu'on lui dise quoi faire. Puis il a changé cinq choses, et maintenant OpenClaw tourne de manière autonome, sans intervention constante. Dans cet article, on va décortiquer ces cinq changements qui transforment OpenClaw d'un simple assistant conversationnel en un véritable coworker numérique qui bosse pour toi en arrière-plan. ## C'est quoi OpenClaw ? Avant de entrer dans le vif du sujet, un petit rappel s'impose. OpenClaw, c'est une plateforme d'automatisation basée sur les modèles языков AI. Contrairement à un chatbot classique qui attend tes instructions, OpenClaw peut être configuré pour bosser de manière autonome, lancer des tâches récurrentes, et même interagir avec d'autres services. Concrètement, imagine un assistant qui : - Vérifie tes emails et te synthétise les importants - Lance des tâches programmées sans que tu aies à y penser - Interagit avec tes outils (GitHub, Notion, Slack, etc.) - Mémorise le contexte sur le long terme C'est exactement ce que permet OpenClaw quand il est bien configuré. ## Les 5 changements clés qui tout basculent ### 1. Le modèle par défaut — Le choix qui impacte tout Le premier changement, et peut-être le plus important, c'est le choix du modèle. Par défaut, OpenClaw utilise souvent un modèle puissant mais coûteux et lent. Le problème ? Quand tu veux de l'automatisation, tu n'as pas besoin de la Rolls-Royce à chaque interaction. **Ce qu'il faut faire :** - Choisir un modèle rapide et pas cher pour les tâches routinières - Garder un modèle plus puissant pour les décisions complexes - Mixer les deux selon les besoins Les bons candidats en 2026 : - **MiniMax M2.5** — Gratuit, rapide, excellent rapport qualité/prix - **GLM-5** — Le modèle chinois qui dépote - **Qwen** — L'alternative Alibaba En passant à MiniMax M2.5, les coûts explosent à la baisse et la vitesse augmente significativement. C'est simple : si ton assistant met 30 secondes à répondre pour une tâche simple, c'est trop. Avec le bon modèle, tu descends à 2-3 secondes. **Pourquoi ça change tout :** Un assistant autonome qui répond en 30 secondes, c'est inutilisable. En 2 secondes, tu as l'impression qu'il bosse en temps réel. La différence de perception est enorme. ### 2. Le Heartbeat — Le cœur de l'automatisation Le deuxième changement, c'est la configuration du heartbeat. Le heartbeat, c'est un mécanisme qui permet à OpenClaw de lancer des tâches à intervalles réguliers, sans que tu aies à intervenir. **Comment ça marche :** Tu configures un \"pulse\" qui se déclenche à intervalles réguliers (toutes les minutes, toutes les heures, etc.). À chaque pulse, OpenClaw peut : - Vérifier si quelque chose nécessite ton attention - Exécuter une tâche planifiée - Faire un résumé de ce qui s'est passé **Ce que tu peux automatiser :** - Surveillance des emails importants - Vérification des notifications sur GitHub - Synthèse quotidienne des信息 - Rappels pour les événements à venir Par exemple, j'ai configuré mon OpenClaw pour me faire un résumé toutes les heures de ce qui s'est passé sur mes projets. Plus besoin de vérifier manuellement — je reçois l'info directement. **La différence avant/après :** Sans heartbeat, OpenClaw ne bouge que quand tu lui parles. Avec le heartbeat, il vit sa propre vie, dans le bon sens du terme. C'est la différence entre un employé qui attend des instructions et un employé proactif. ### 3. Les Skills — Des pouvoirs sur mesure Le troisième changement, c'est l'ajout de skills. Un skill, c'est un ensemble d'instructions et d'outils qui donne à OpenClaw des capacités spécifiques. **Pourquoi les skills sont importants :** Par défaut, OpenClaw sait faire beaucoup de choses, mais il ne sait pas faire exactement ce que TU veux. Les skills permettent de personaliser son comportement pour des cas d'usage précis. **Exemples de skills utiles :** - **Git skill** — Pour gérer les commits, les PRs, les issues - **Web research skill** — Pour rechercher des infos sur le web - **Calendar skill** — Pour gérer ton calendrier - **Writing skill** — Pour rédiger du contenu **Comment les créer :** Un skill, c'est juste un fichier qui définit : 1. Ce que le skill doit faire 2. Les outils qu'il peut utiliser 3. Le contexte nécessaire Tu peux les créer toi-même ou en trouver sur ClawHub (le marketplace des skills OpenClaw). ### 4. Le Routing — Faire bosser les agents ensemble Le quatrième changement, c'est le routing. Au lieu d'avoir un seul agent qui fait tout, tu peux en avoir plusieurs qui bossent ensemble, chacun avec son rôle. **L'architecture recommandée :** - **Agent principal** — Coordonne le travail et interagit avec toi - **Agent de recherche** — Cherche les infos - **Agent de rédaction** — Rédige le contenu - **Agent de surveillance** — Garde un œil sur les notifications **Comment ça marche :** Tu définis des règles de routing qui disent à quel agent transmettre la requête. Par exemple : - \"Recherche ça\" → Agent recherche - \"Écris un article\" → Agent rédaction - \"Vérifie mes emails\" → Agent surveillance Chaque agent a son propre modèle, ses propres skills, et ses propres instructions. C'est comme avoir une équipe entière plutôt qu'un seul employé. **Le benefit :** Tu peux avoir un agent rapide et pas cher pour les recherches, et un agent plus puissant (et plus coûteux) pour les tâches complexes. L'optimisation des coûts est significative. ### 5. La Mémoire — Ne rien oublier Le cinquième et dernier changement, c'est la configuration de la mémoire. C'est peut-être le plus underrated de tous, mais aussi le plus important pour avoir un assistant qui te connaît vraiment. **Les deux types de mémoire :** 1. **Mémoire à court terme** — Ce qui se passe dans la session en cours 2. **Mémoire à long terme** — Ce qui persiste entre les sessions **Comment configurer la mémoire :** - **Mémoire quotidienne** — Fichier `memory/YYYY-MM-DD.md` qui log tout ce qui se passe - **Mémoire permanente** — Fichier `MEMORY.md` avec les infos importantes à retenir **Ce qu'il faut absolument mémoriser :** - Tes préférences de communication - Tes projets en cours - Tes objectifs - Tes aversions (ce qui t'énerve) - Les décisions importantes et pourquoi elles ont été prises **L'erreur à éviter :** Croire que OpenClaw se \"souvient\" de tout. NON. Il faut tout écrire. Si ce n'est pas écrit dans un fichier, OpenClaw ne s'en souviendra pas. C'est une machine, pas un humain. **Mon setup mémoire :** ``` memory/ 2026-02-13.md # Journal quotidien 2026-02-12.md # Hier MEMORY.md # Ce que je veux retenir sur le long terme ``` Chaque jour, je log tout ce qu'on fait. Chaque semaine, je reprends les journaux et je distille l'essentiel dans MEMORY.md. ## Pourquoi tout ça compte Ces cinq changements, ensemble, transforment OpenClaw d'un chatbot en coworker. Voici le récap : | Avant | Après | |-------|-------| | Répond quand tu lui parles | BOSSE en autonomie | | Oublie tout entre les sessions | SE SOUVIENT de tout | | Un seul agent pour tout | Équipe d'agents spécialisés | | Modèle lent et coûteux | Modèle optimisé | | Pas d'automatisation | Heartbeat everywhere | ## Comment démarrer Tu veux passer le cap ? Voici la marche à suivre : 1. **Change le modèle** — Mets MiniMax M2.5 ou GLM-5 2. **Configure le heartbeat** — Lance une tâche simple (genre te dire bonjour chaque heure) 3. **Ajoute un skill** — Commence par un skill simple 4. **Setup la mémoire** — Crée tes fichiers memory/ 5. **Amplifie** — Ajoute des agents, des skills, des automatisations ## Le mot de la fin OpenClaw, c'est un outil débloquant. Mais comme tout outil puissant, il faut savoir l'utiliser. Ces cinq changements ne sont pas compliqués à mettre en place, mais ils font une différence enormous. Le conseil le plus important : start small. Configure une seule chose à la fois, teste, iterate. Pas besoin de tout faire le premier jour. Et n'oublie pas : si ce n'est pas écrit, OpenClaw ne s'en souvient pas. La mémoire, c'est la clé. ---"},{"id":"blog:glm-5-ollama","title":"GLM-5 : Le modèle chinois qui arrive sur Ollama — Analyse complète","description":"Ollama ajoute GLM-5 à son catalogue cloud. Le modèle chinois de Zhipu AI est maintenant accessible gratuitement. Voici ce qu'il faut savoir.","date":"2026-02-13T01:00:00.000Z","tags":["ollama","glm-5","zhipu-ai","ai","modèle chinois","cloud","2026"],"authors":[],"url":"/blog/glm-5-ollama","content":"# GLM-5 : Le modèle chinois qui arrive sur Ollama Ollama continue son bonhomme de chemin et ajoute **GLM-5** à son catalogue cloud. Le modèle signé Zhipu AI (le laboratoire chinois derrière ChatGLM) arrive avec des arguments intéressants. Mais qu'est-ce que ça change vraiment pour les développeurs ? Analyse complète. ## C'est quoi GLM-5 ? GLM-5, c'est le dernier modèle de Zhipu AI, un laboratoire chinois qui bosse sur les LLMs depuis maintenant plusieurs années. Fondé en 2019, Zhipu AI s'est fait connaître avec la série ChatGLM, des modèles open source qui ont marqué le paysage de l'IA chinoise. Le GLM-5 est la dernière itération de cette série, et il arrive sur Ollama Cloud avec une offre gratuite pour commencer. ### Les caractéristiques techniques - **Paramètres** : ~130 milliards (version complète) - **Context** : jusqu'à 128K tokens - **Langues** : anglais et chinois au top, bonnes performances en français - **Vitesse** : оптимизирован pour l'inférence rapide - **Prix** : Gratuit pour démarrer, plans payants disponibles ### Ce qui distingue GLM-5 Plusieurs choses rendent ce modèle intéressant : 1. **Entraînement multilingual** — Contrairement à beaucoup de modèles chinois qui privilégient le mandarin, GLM-5 a été entraîné de manière équilibrée sur l'anglais et le chinois, avec de bonnes performances sur les autres langues européennes. 2. **Optimisation code** — GLM-5 montre de bonnes performances sur les tâches de programmation, comparable à GPT-4 sur certains benchmarks. 3. **Context large** — 128K tokens, c'est huge. De quoi analyser des bases de code entières en une seule fois. 4. **Speed** — L'optimisation de Zhipu pour l'inférence fait de GLM-5 un modèle rapide, même en version cloud. ## Pourquoi Zhipu AI compte Zhipu AI, c'est pas un petit joueur. C'est uno des实验室 d'IA les plus importants en Chine, et ça se voit dans les résultats. ### L'écosystème Zhipu Zhipu a développé tout un écos autout de GLM : - **ChatGLM** — La série de modèles open source - **ChatGLM API** — L'API cloud officielle - **CodeGeex** — Un modèle dédié au code - **VisualGLM** — Un modèle multimodal C'est un acteur complet, pas juste un laboratorio qui sort un modèle. ### La stratégie Zhipu a une stratégie intéressante : proposer des modèles de qualité, souvent gratuits pour attirer les développeurs, puis monétiser via les API et les services enterprise. C'est exactement ce que fait Ollama avec GLM-5 : gratuit pour tester,payant pour un usage intensif. ## Comment l'utiliser ### Via Ollama Cloud ```bash ollama run glm-5:cloud ``` C'est aussi simple que ça. Pas besoin de télécharger le modèle, pas besoin de configurer quoi que ce soit. Tu lances la commande et tu starts. ### Via Claude Code ```bash ollama launch claude --model glm-5:cloud ``` Tu peux même le connecter à Claude Code si tu veux utiliser GLM-5 comme backend pour l'IDE de Anthropic. ### Via OpenCode ```bash ollama launch opencode --model glm-5:cloud ``` OpenCode supporte aussi Ollama, donc GLM-5 est accessible directement depuis l'éditeur. ## Comparaison avec les autres modèles Comment GLM-5 se compare aux autres modèles disponibles sur Ollama ? ### GLM-5 vs MiniMax M2.5 | Critère | GLM-5 | MiniMax M2.5 | |---------|-------|--------------| | Prix | Gratuit | Gratuit (temporaire) | | Code | Excellent | Excellent | | Français | Bon | Très bon | | Vitesse | Rapide | Très rapide | | Context | 128K | Variable | **Verdict** : Les deux sont excellents. MiniMax a l'avantage temporaire de l'offre gratuite illimitée. GLM-5 a l'avantage d'une taille de contexte plus importante. ### GLM-5 vs Llama 3 | Critère | GLM-5 | Llama 3 | |---------|-------|---------| | Prix | Gratuit | Gratuit | | Code | Comparable | Comparable | | Français | Meilleur | Bon | | Open Source | Non | Oui | **Verdict** : Llama 3 est open source (Meta), GLM-5 ne l'est pas. Mais pour l'usage cloud, la différence est minime. ### GLM-5 vs GPT-4 | Critère | GLM-5 | GPT-4 | |---------|-------|-------| | Prix | Gratuit | Payant | | Code | Comparable | Excellent | | Français | Bon | Excellent | | API | Ollama | OpenAI | **Verdict** : GPT-4 reste le gold standard, mais GLM-5 gratuit, c'est très attractif. ## Les cas d'usage parfaits pour GLM-5 ### 1. Le code review Avec 128K de contexte, tu peux balancer un fichier entier (ou même un petit repo) à GLM-5 et lui demander un review complet. C'est killer. ### 2. La documentation GLM-5 écrit du code propre et peut générer de la documentation de qualité. Laisse-moi te montrer : ``` Je veux une fonction Python qui... → GLM-5 → Code + Docstring + Exemple ``` ### 3. Le refactoring Tu as du legacy code ? GLM-5 peut le comprendre et le moderniser. With the long context, il voit les dépendances et peut refactorer en consequence. ### 4. Les快速 prototypes Tu as besoin de prototyp快速 ? GLM-5 est assez bon et assez rapide pour ça. ### 5. L'apprentissage Comme GLM-5 est gratuit, c'est parfait pour expérimenter, apprendre, et tester sans khawatir du coût. ## Ce que j'en pense Après avoir testé GLM-5 intensivement pendant quelques jours, voici mon avis. ### Les points forts - **Gratuit** — C'est le gros point. Accéder à un modèle de qualité sans payer, c'est rare. - **Rapide** — Les temps de réponse sont impressionnante. - **Code correct** — Les suggestions de code sont pertinentes. - **Contexte huge** — 128K, c'est gigantic. ### Les points faibles - **Pas open source** — Impossible de l'héberger soit-même - **Chinois** — Les перформанс sont meilleures en chinois/anglais qu'en français - **Offre temporaire** — Comme MiniMax, c'est gratuit \"pour le moment\" ### Le verdict GLM-5 est un excellent choix pour quiconque veut tester un modèle chinois de qualité sans débourser. Il n'est pas parfait, mais pour le prix (gratuit), c'est tough à beat. **Ma recommendation** : Teste-le. Maintenant. Pendant qu'il est gratuit. ## Comment en profiter ### étape 1 : Installe Ollama Si tu ne l'as pas déjà : ```bash curl -fsSL https://ollama.com/install | sh ``` ### étape 2 : Lance GLM-5 ```bash ollama run glm-5:cloud ``` ### étape 3 : Teste Demande-lui de coder quelque chose, de reviewer du code, ou de t'expliquer un concept. ### étape 4 : Intègre Si ça te plaît, intègres-le dans ton workflow : - VSCode + Continue - Claude Code - OpenCode ## La tendance du marché GLM-5 n'arrive pas seul. C'est une tendance de fond : les modèles chinois thérapeut le marché occidental. ### Les acteurs clés - **MiniMax** — M2.5, gratuit temporairement - **Zhipu** — GLM-5, maintenant sur Ollama - **Qwen** — Alibaba, plusieurs versions - **Yi** — 01.AI, modèles performants ### Ce que ça signifie Les laboratoire chinois sont là, ils competitor, et ils предложают des choses interessantes. Pour nous, développeurs, c'est benefique : plus de choix, meilleurs prix, plus d'innovation. ### L'avenir On peut s'attendre à : - Plus de modèles chinois sur Ollama - Des offres gratuites de plus en plus interessantes - Une competition qui pousse les prix vers le bas Le futur du code avec l'IA, c'est des modèles performants à prix нуль. Et ça, c'est une bonne nouvelle. ## Conclusion GLM-5 sur Ollama, c'est une option à considerer. Gratuit, rapide, et pas mal en code. Que demander de plus ? Le tip : Profites-en maintenant que c'est gratuit. Les offres gratuites sont souvent temporaires. Quand la qualité est là et que c'est gratuit, faut y aller. ---"},{"id":"blog:minimax-m2-5-ollama","title":"MiniMax M2.5 : Le modèle gratuit qu'il faut essayer — Analyse complète","description":"Ollama s'associe avec MiniMax pour offrir l'accès gratuit au modèle M2.5. Voici pourquoi c'est une opportunité à saisir d'urgence et comment l'intégrer dans ton workflow.","date":"2026-02-13T00:00:00.000Z","tags":["ollama","minimax","ai","modèle gratuit","local-ai","cloud","2026","tutoriel"],"authors":[],"url":"/blog/minimax-m2-5-ollama","content":"# MiniMax M2.5 : Le modèle gratuit qu'il faut essayer Ollama vient d'annoncer un partenariat intéressant avec MiniMax AI. Pendant quelques jours — et potentiellement plus si l'offre rencontre du succès — tu peux utiliser le modèle **MiniMax M2.5** gratuitement via Ollama Cloud. Et oui, j'ai déjà sauté sur l'occasion. Dans cet article, je te raconte pourquoi ce modèle mérite ton attention, comment l'utiliser, et ce que j'en pense après l'avoir intégré dans ma stack quotidienne. ## C'est quoi MiniMax ? Avant de parler du modèle, parlons de l'entreprise. MiniMax, c'est un laboratoire d'intelligence artificielle chinois fondé en 2021. Contrairement à ce qu'on pourrait penser, ce n'est pas un petit joueur. MiniMax a développé sa propre technologie de modèles de langage, et les résultats sont impressionnante. Le laboratoire a commencé avec des modèles open source sous le nom de MiniMax-Chat, puis a progressivement intégré des modèles plus puissants. Le M2.5 est leur dernière itération, et le moins qu'on puisse dire, c'est qu'ils ont fait du bon travail. ### La philosophie MiniMax Ce qui distingue MiniMax de certains autres laboratoires, c'est leur approche : - **Focus sur le multilingual** — Les modèles MiniMax sont entraîné de manière équilibrée sur plusieurs langues, incluant le français, l'anglais, et le chinois - **Performance/code** — Un accent particulier sur les capacités de programmation - **Efficacité** — Des modèles optimisés pour tourner avec des ressources raisonnables C'est cette philosophie qui rend le M2.5 intéressant pour les développeurs occidentaux qui cherchent une alternative aux giants américains. ## MiniMax M2.5 : Les caractéristiques Maintenant, rentrons dans le vif du sujet. Qu'est-ce que le M2.5 a dans le ventre ? ### Les specs techniques - **Version** : MiniMax-M2.5 - **Type** : модель de langage large (LLM) - **Contexte** : 131K tokens — enormous, enough pour analyser des projets entiers - **Langues** : Français, anglais, chinois, et beaucoup d'autres - **Prix** : Gratuit via Ollama Cloud (offre temporaire) - **Vitesse** : Optimisé pour l'inférence rapide ### Ce qui impressionne 1. **Le contexte** — 131K tokens, c'est enorme. Concrètement, c'est environ 100 000 mots. Tu peux balancer un projet entier à M2.5 et lui demander de l'analyser. C'est game-changing pour le code review. 2. **Le multilingue** — Contrairement à beaucoup de modèles chinois qui privilégient le mandarin, M2.5 gère le français étonnamment bien. Les réponses sont naturelles, nuancées, et ne font pas \"traduit par Google Translate\". 3. **Le code** — Les capacités de programmation sont solides. M2.5 suggère du code propre, comprend les patterns, et peut t'aider sur des tâches allant de la simplest fonction à l'architecture complète d'une application. 4. **La vitesse** — Despite sa taille, le modèle est optimisé pour être rapide. Pas d'attente longue entre les réponses. ### Les limites Bien sûr, ce n'est pas parfait : - **Offre temporaire** — Le gratuit n'est peut-être pas permanent. Profites-en pendant que c'est là. - **Pas open source** — Impossible de l'héberger soit-même (pour l'instant) - **Dépendance cloud** — Il faut une connexion internet ## Comment l'utiliser La bonne nouvelle, c'est que c'est simple. Vraiment simple. ### Via le terminal La méthode la plus directe : ```bash ollama run minimax-m2.5:cloud ``` Et tu peux commencer à discuter. C'est tout. ### Intégration avec OpenCode OpenCode est un éditeur de code optimisé pour bosser avec l'IA. Si tu l'utilises : ```bash ollama launch opencode --model minimax-m2.5:cloud ``` Tu auras M2.5 directement dans ton éditeur, avec toutes les fonctionnalités de completion et de chat. ### Intégration avec Claude Code Claude Code, l'éditeur de Anthropic, supporte aussi Ollama : ```bash ollama launch claude --model minimax-m2.5:cloud ``` Tu peux donc utiliser M2.5 comme backend pour ton IDE, tout en gardant l'interface Claude Code. ### Via l'API Pour les développeurs qui veulent intégrer M2.5 dans leurs propres outils : ```bash # Exemple avec la librairie Ollama en Python from ollama import chat response = chat( model='minimax-m2.5:cloud', messages=[ {'role': 'user', 'content': 'Écris une fonction Python qui...'} ] ) print(response['message']['content']) ``` ## Mon retour d'expérience Cela fait quelques jours que j'utilise MiniMax M2.5 quotidiennement. Voici mon avis sincère après l'avoir intégré dans mon workflow. ### Ce que j'aime 1. **La vitesse** — Les réponses arrivent vite. Vraiment vite. C'est appréciable quand tu veux juste une réponse rapide sans attendre 10 secondes. 2. **Le contexte** — Pouvoir balancer un fichier entier (ou plusieurs) et demander un review, c'est énorme. Fini le copier-coller par petits bouts. 3. **Le prix** — Gratuit, c'est gratuit. Pour un usage quotidien, ça representa une économie significative par rapport à GPT-4 ou Claude. 4. **Le français** — Je confirme : le modèle gère le français très correctement. Les réponses sont naturelles, pas robotiques. 5. **Le code** — Les suggestions de code sont pertinentes. Il comprend les patterns modernes, les bonnes pratiques, et peut bosser sur du code complexe. ### Ce qui m'agace 1. **L'offre temporaire** — C'est le seul vrai point noir. Le gratuit pourrait s'arrêter à tout moment. Profites-en pendant que ça dure. 2. **Pas de persistence locale** — Pour le cloud, tout reste sur les serveurs de MiniMax. Si tu as des exigences de confidentialité strictes, c'est à considérer. 3. **Les rate limits** — En période de forte demande, le modèle peut être plus lent. C'est le tradeoff du gratuit. ### Les tâches où je l'utilise | Tâche | Modèle utilisé | |-------|----------------| | Code review rapide | MiniMax M2.5 | | Rédaction française | MiniMax M2.5 | | Recherche web | MiniMax M2.5 | | Architecture complexe | Claude/GPT | | Code critique | Claude/GPT | En gros : tout ce qui est \"rapide et quotidien\" → M2.5. Tout ce qui est \"complexe et important\" → Claude ou GPT. ## Pourquoi c'est important Le partenariat Ollama-MiniMax, c'est un signal fort dans l'industrie de l'IA. ### La montée des modèles chinois Cela fait un moment qu'on voit les modèles chinois gagner en qualité. Mais avec ce partenariat, ça devient accessible au grand public. Les实验室 comme MiniMax, Zhipu (GLM), et Qwen (Alibaba) proposent désormais des modèles qui concurrencent les giants américains. Pour nous, développeurs, c'est une excellente nouvelle : - Plus de choix - Meilleurs prix (ou gratuits) - Plus d'innovation ### La démocratisation de l'IA Le gratuit, c'est aussi (et surtout) une porte d'entrée. Quand tu peux tester sans payer, tu découvres. Et une fois qu'as goûté, tu continues. C'est la stratégie de MiniMax, et elle fonctionne. ### Le signal pour le marché Qu'Ollama s'associe avec MiniMax, c'est une reconnaissance. Le modèle est assez bon pour être intégré à leur plateforme. Et ça, ça en dit long sur sa qualité. ## Comment en profiter au maximum Tu veux tirer le meilleur de cette offre gratuite ? Voici mes conseils. ### 1. Intègre-le partout - Configure-le dans ton IDE - Utilise-le comme modèle par défaut pour les tâches simples - Automatise des scripts qui l'appellent ### 2. Exploite le contexte Avec 131K tokens, les possibilités sont immenses : - Analyse de projets entiers - Review de multiples fichiers - Documentation automatique - refactoring de code legacy ### 3. Combine avec d'autres modèles N'utilise pas seulement M2.5. Mixe : - M2.5 pour le rapide - Claude/GPT pour le complexe - Llama en local pour le privé ### 4. Documente ton usage Puisque c'est gratuit et temporaire, documente ce que tu fais avec. Si l'offre s'arrête, tu sauras exactement ce que tu perdais. ## L'avenir de MiniMax sur Ollama La question qu'on se pose tous : est-ce que le gratuit va durer ? ### Les scénarios **Scénario 1 : Le gratuit continue** MiniMax est satisfait du nombre d'utilisateurs et decide de garder une offre gratuite (même limitée). C'est le meilleur scénario. **Scénario 2 : Le gratuit devient limité** Introduction de rate limits ou de quotas quotidiens. Utilisable, mais avec des contraintes. **Scénario 3 : Le gratuit s'arrête** L'offre temporaire prend fin, il faut payer pour continuer à utiliser M2.5. ### Mon prediction Je penche pour le scénario 2. Les modèles gratuits attirent des utilisateurs, mais les coûts sont réels. Un quota quotidien gratuit (style 100 requêtes/jour) me semble le plus probable. ## Comparaison rapide | Modèle | Prix | Vitesse | Code | Français | Context | |--------|------|---------|------|----------|---------| | MiniMax M2.5 | Gratuit | Rapide | Bon | Bon | 131K | | GLM-5 | Gratuit | Rapide | Bon | Bon | 128K | | Claude Haiku | Gratuit | Rapide | Bon | Bon | 200K | | GPT-4o | Payant | Moyen | Excellent | Excellent | 128K | | Claude Sonnet | Payant | Moyen | Excellent | Excellent | 200K | ## Conclusion MiniMax M2.5 via Ollama, c'est une opportunité à saisir. Le modèle est bon, il est gratuit, et il est accessible facilement. Que demande le peuple ? Mon conseil : Teste-le. Maintenant. Aujourd'hui. Le gratuit, c'est limité dans le temps (normalement), et le modèle vaut vraiment le détour. Moi, il est déjà intégré dans ma stack quotidienne, à côté de Claude et GPT. Le futur du développement avec l'IA, c'est avoir plusieurs modèles à disposition, chacun avec ses forces. M2.5 a sa place dans cette stack. Profites-en. ---"},{"id":"blog:tailscale-vpn-guide","title":"Tailscale : Le VPN simple et sécurisé pour connecter vos appareils","description":"Tailscale est un VPN basé sur WireGuard qui simplifie la connexion sécurisée entre vos appareils. Découvrez ses cas d'usage et comment l'installer en 5 minutes.","date":"2026-02-13T00:00:00.000Z","tags":["tuto","réseau","sécurité","auto-hébergement"],"authors":[],"url":"/blog/tailscale-vpn-guide","content":"Vous avez besoin d'accéder à votre serveur à distance ? De connecter votre NAS à votre téléphone ? De sécuriser vos communications entre appareils sans passer par le cloud ? **Tailscale** est la solution qu'il vous faut. ## C'est quoi Tailscale ? Tailscale est un VPN (Virtual Private Network) basé sur **WireGuard**, un protocole moderne et ultra-rapide. Contrairement aux VPN traditionnels qui vous font passer par un serveur central, Tailscale crée un réseau peer-to-peer direct entre vos appareils. Concrètement : - Chaque appareil obtient une **adresse IP privée** unique sur votre réseau Tailscale - La connexion est **chiffrée de bout en bout** - Ça fonctionne partout dans le monde, sans configuration réseau complexe ### Pourquoi pas un VPN classique ? Les VPN traditionnels (NordVPN, ExpressVPN...) sont conçus pour masquer votre position et naviguer \"comme si\" vous étiez ailleurs. Tailscale, lui, est conçu pour **connecter vos propres appareils** entre eux. | Feature | VPN classique | Tailscale | |---------|---------------|-----------| | Usage principal | Naviguer anonymement | Connecter ses appareils | | Connexion | Via serveur central | Peer-to-peer | | IPs partagées | ✅ | Non (IP fixe par appareil) | | Accès réseau local | Limité | Complet | ## Cas d'usage ### 1. Accéder à son serveur à distance Vous avez un serveur à la maison ou chez un hébergeur ? Avec Tailscale, vous pouvez vous y connecter comme si vous étiez sur le même réseau local, depuis n'importe où. ### 2. Services auto-hébergés accessibles partout Home Assistant, Plex, Nextcloud, Pi-hole... Tous ces services peuvent rester chez vous et être accessibles uniquement via Tailscale. Pas besoin de les exposer à internet. ### 3. Remplacer le cloud par votre propre infrastructure Vos fichiers sur Dropbox ? Vos notes sur Notion ? Remplacez-les par des services auto-hébergés accessibles via Tailscale. Vous gardez le contrôle total. ### 4. Sécurité supplémentaire sur les réseaux publics Quand vous êtes sur un WiFi public, Tailscale chiffre tout votre trafic.Plus besoin de se soucier des interceptions. ## Comment installer Tailscale ? ### Sur Linux (Ubuntu/Debian) ```bash # Ajouter le dépôt Tailscale curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.noarmor.gpg | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg > /dev/null curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list # Installer sudo apt update sudo apt install tailscale # Démarrer sudo tailscale up ``` ### Sur macOS ```bash # Via Homebrew brew install tailscale # Ou téléchargez l'app sur tailscale.com ``` ### Sur Windows Téléchargez l'installateur sur [tailscale.com](https://tailscale.com/download) et lancez-le. ### Sur Android / iOS Installez l'app depuis le Play Store ou l'App Store. ## Configuration initiale Après installation, lancez `tailscale up` et connectez-vous avec votre compte Tailscale (gratuit pour usage personnel). ```bash tailscale up --accept-routes ``` Votre appareil apparaît maintenant dans votre réseau Tailscale. Vous pouvez lister vos appareils : ```bash tailscale status ``` Chaque appareil a une adresse en `100.x.x.x`. Pour vous connecter à un appareil : ```bash ssh user@100.x.x.x ``` ## Configuration avancée ### Authentification à deux facteurs Activez 2FA via votre compte Tailscale pour plus de sécurité. ### Clés pré-partagées (PSK) Pour des connexions supplémentaires, générez des clés dans votre console d'administration Tailscale. ### Serveur de sortie (Exit Node) Vous pouvez faire passer tout votre trafic par un appareil Tailscale (utile sur des réseaux restreints). ## Conclusion Tailscale rend la connexion entre appareils aussi simple qu'elle devrait l'être. Plus de port forwarding, plus de DDNS, plus de complexité réseau.Juste vos appareils, connectés de manière sécurisée. Pour un usage personnel, le **plan gratuit** est largement suffisant (jusqu'à 100 appareils). Et vous, quels cas d'usage avez-vous avec Tailscale ?"},{"id":"blog:openclaw-mac-mini","title":"OpenClaw sur Mac Mini : Le Guide Complet d'Installation et de Sécurisation","description":"Installez OpenClaw sur un Mac Mini de A à Z. Guide pas-à-pas : Apple ID, clés API, onboarding, sécurisation, accès Telegram/Discord. 2-3 heures de travail.","date":"2026-02-12T00:00:00.000Z","tags":["openclaw","macos","installation","sécurité","ia"],"authors":[],"url":"/blog/openclaw-mac-mini","content":"Je viens de passer 2h30 à installer OpenClaw sur un Mac Mini. Pas un simulateur, pas une VM : le vrai macOS, sur du vrai matériel Apple. Ethonnêtement ? C'était plus simple que je l'imaginais, mais j'ai quand même fait toutes les erreurs possibles. Alors voici le guide que j'aurais aimé avoir avant de commencer. ## Pourquoi un Mac Mini pour OpenClaw ? Avant de plonger : pourquoi diable installer OpenClaw sur macOS plutôt qu'un VPS Linux classique ? **Les avantages réels** : - Stability : macOS ne s'écrase pas tous les 4 matins comme certaines distros cheap - Écosystème Apple : si tu as déjà iPhone/iPad, c'est un point d'entrée cohérent - Performance : un Mac Mini M1/M2 avec 16GB RAM suffit largement pour tourner plusieurs agents - Isolation : pas de risk de conflit avec d'autres services sur ta machine de dev principale **Les inconvénients** : - Prix : un Mac Mini d'occasion M1 coûte 300-400€, c'est plus cher qu'un VPS - Flexibilité limitée : pas de Docker \"officiel\" sur macOS (mais OrbStack ou Colima fonctionnent) - Docs moins exhaustives : la plupart des tutos OpenClaw sont faits pour Linux **Mon verdict** : Si tu veux un hardware dédié, propre, avec une stack macOS, le Mac Mini est un excellent choix. Si tu veux juste tester, commence avec un VPS à 5€/mois. Mais si t'as déjà le Mac Mini sous la main, fonce. ## La Préparation : 30 minutes qui sauvent des heures ### 1. Gestionnaire de mots de passe obligatoire Je l'ai écrit dans le premier article sur OpenClaw, mais je le répète : **ne STOCKE JAMAIS tes credentials dans Notes, Safari, ou un fichier texte**. C'est la erreur n°1 qui fait gagner 3 jours de stress aux hackers. **Mes recommandations** : - **Bitwarden** (gratuit, open-source) → install le desktop app - **1Password** (payant mais excellent UX) → si tu es familier Crée un vault spécifique \"OpenClaw\" dedans. On va y mettre : - Toutes les clés API - Tokens Telegram/Discord - Gateway token - Mot de passe admin pour l'interface web **WARNING** : Pas de copier-coller dans des fichiers temporaires. Copie directement de Bitwarden vers ton `.env`. ### 2. Créer un Apple ID dédié (pas ton perso) Pourquoi ? Parce que : - Tu vas installer des apps via l'App Store (OrbStack, etc.) - Tu veux pas lier ta vie privée à une machine qui héberge des bots - En cas de souci, tu peux jeter l'Apple ID sans conséquence **La procédure** : 1. Va sur appleid.apple.com 2. Crée un nouveau compte avec une **adresse Gmail dédiée** (genre `openclaw.macmini@gmail.com`) 3. Active la 2FA immédiatement (Settings → Password & Security) 4. Ajoute un numéro de téléphone (ton numéro principal, t'auras besoin pour la recovery) **Le piège** : Apple vérifie l'adresse email. Si tu mets une adresse qui existe déjà (même en recovery), ça bloque. Utilise une **nouvelle adresse Gmail créée pour l'occasion**. ### 3. Créer un compte Google dédié (pour OAuth) OpenClaw utilise OAuth pour s'intégrer à Telegram, Discord, etc. Tu ne veux PAS utiliser ton compte Google personnel. **Procédure** : 1. Crée `openclaw.api@gmail.com` (ou similaire) 2. Va sur console.cloud.google.com 3. Crée un projet \"OpenClaw Mac Mini\" 4. Active les APIs nécessaires (on les verra après) 5. Crée des credentials OAuth 2.0 Client ID (type : Desktop app) **Important** : Ce compte Google ne sert **que pour les APIs**. Ne l'utilise pas pour Gmail, Drive, etc. ## Récupérer les Clés API (1h d'attente potentielle) C'est la partie la plus longue : attends souvent des heures pour certaines validations. Fais-les dans cet ordre : ### 1. Anthropic (Claude Opus) Pourquoi : OpenClaw peut utiliser Claude comme LLM principal. C'est pas gratuit, mais c'est excellent. **Étapes** : - Va sur console.anthropic.com - Crée un compte (avec ton Google dédié) - Settings → API Keys → Create Key - Copie la clé (commence par `sk-ant-...`) **Coût** : ~0.03$/1M tokens en entrée, 0.15$/1M en sortie. Pas donné, mais la qualité justifie pour leprod. ### 2. OpenAI Si tu veux utiliser GPT-4o ou o1-preview. **Étapes** : - platform.openai.com/api-keys - Crée une nouvelle secret key - Copie-la bien **Coût** : ~0.01-0.05$/1K tokens selon le modèle. ### 3. Brave Search API OpenClaw peut faire des recherches web via Brave. **Étapes** : - Va sur api.search.brave.com/register - Crée un compte - Crée une \"Subscription\" (y a un free tier : 2K requêtes/mois) - Récupère l'API key (commence par `BSA...`) **Note** : Si tu veux pas payer, OpenClaw peut utiliser DuckDuckGo sans clé API, mais c'est moins fiable. ### 4. Telegram Bot Token OpenClaw interagit avec Telegram via un bot. **Étapes** : 1. Ouvre Telegram, cherche `@BotFather` 2. `/newbot` 3. Choisis un nom : `OpenClaw Bot` 4. Choisis un username : `openclaw_yourname_bot` (doit finir par \"bot\") 5. BotFather te donne un token (genre `1234567890:ABCdefGHI...`) 6. Copie-le dans Bitwarden **Test rapide** : ```bash curl \"https://api.telegram.org/bot /getMe\" ``` Doit retourner `{\"ok\":true,\"result\":{...}}` ### 5. Discord Bot Token Pour Discord, c'est un peu plus long. **Étapes** : 1. Va sur discord.com/developers/applications 2. \"New Application\" → \"OpenClaw\" 3. Onglet \"Bot\" → \"Add Bot\" → \"Yes, do it!\" 4. Sous \"Privileged Gateway Intents\", active : - PRESENCE INTENT - SERVER MEMBERS INTENT - MESSAGE CONTENT INTENT 5. \"Reset Token\" → copie-le 6. **IMPORTANT** : Génère une \"OAuth2 URL\" pour inviter le bot sur ton serveur : - URL Generator → scopes : `bot` - Bot Permissions : `Send Messages`, `Read Message History`, `Embed Links` - Copie l'URL générée, ouvre-la dans un navigateur, invite sur ton serveur **Le piège** : Si tu n'actives pas les 3 intents, le bot ne verra pas les messages. Vérifie dans Discord Developer Portal. ### 6. Gateway Token Le \"gateway\" c'est le composant qui connecte tous les services. OpenClaw génère un token au premier démarrage, mais tu peux le définir toi-même. Pour l'instant, on le laisse empty. On le récupérera après l'onboarding. ### Récapitulatif des credentials dans Bitwarden Crée une entrée \"OpenClaw API Keys\" avec ces champs : - `anthropic_key`: sk-ant-... - `openai_key`: sk-... - `brave_key`: BSA... - `telegram_bot_token`: 12345:... - `discord_bot_token`: TOKEN_DISCORD... - `gateway_token`: (on le mettra plus tard) ## Installation de macOS sur le Mac Mini (30 min) ### Wipe complet Si ton Mac Mini a déjà des données, **efface tout** : 1. Redémarre 2. Au boot, appuie sur `Cmd+R` (Recovery Mode) 3. Utilitaire → \"Disk Utility\" 4. Sélectionne le disque principal (généralement \"Apple SSD AP0256J\") 5. \"Erase\" : - Format : APFS (Encrypted si tu veux, mais pas obligatoire) - Scheme : GUID Partition Map 6. Ferme Disk Utility ### Setup Assistant (le plus important) Quand tu démarres frais, macOS te guide. Suis **exactement** cette procédure : 1. **Langue** : Français (ou ta langue) 2. **Pays** : France (ou selon ta région) 3. **Accessibilité** : None 4. **Données de diagnostic** : Je recommande \"Envoyer à Apple\" (pas sensible) 5. **Siri** : Configure-le si tu veux (pas obligatoire) 6. **Créer un compte d'ordinateur** : - **Nom complet** : \"OpenClaw\" (pas ton vrai nom) - **Nom de compte** (username) : `openclaw` (c'est important, on va l'utiliser) - **Mot de passe** : un MOT DE PASSE FORT (Bitwarden → generate → 32 chars) - **Hint** : laisse vide ou \"Bitwarden\" 7. **Apple ID** : connecte-toi avec l'Apple ID dédié créé plus tôt 8. **Terms** : Agree 9. **Express Settings** : **Désactive TOUT** : - \"Location Services\" → No - \"Siri\" → No si pas besoin - Time Zone : choisi ta timezone - \"Analytics\" → No - \"Screen Time\" → No - \"Appearance\" : Light ou Dark selon ta préf **Le piège** : Si tu laisses \"Express Settings\" sur Yes, Apple active des services de tracking et de Cloud qui peuvent interférer avec ton setup. Désactive tout manuellement. ### Fin du Setup Une fois sur le bureau : - Connecte-toi en SSH si tu veux (Settings → Sharing → Remote Login) - Enlève l'autologin si activé (Settings → Users & Groups → Login Options) ## Installer les Dépendances (20 min) Ouvre le Terminal (Cmd+Space → Terminal). ### 1. Homebrew (le package manager macOS) Si tu l'as pas déjà : ```bash /bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\" ``` Suis les instructions. À la fin, ajoute Brew dans ton PATH : ```bash echo 'eval \"$(/opt/homebrew/bin/brew shellenv)\"' >> ~/.zprofile eval \"$(/opt/homebrew/bin/brew shellenv)\" ``` Vérifie : ```bash brew --version ``` ### 2. Node.js (version LTS) ```bash brew install node@20 # ou node@22 pour la dernière LTS ``` Vérifie : ```bash node --version # Doit afficher v20.x ou v22.x npm --version ``` **Le piège** : macOS vient avec un vieux Node. Vérifie que c'est bien celui de Brew : ```bash which node # Doit retourner /opt/homebrew/bin/node (ou /usr/local/bin/node selon arch) ``` ### 3. Git ```bash brew install git git --version ``` Configure ton identité (même si tu es le seul user) : ```bash git config --global user.name \"OpenClaw\" git config --global user.email \"openclaw@localhost\" ``` ### 4. (Optionnel) OrbStack ou Colima pour Docker Si tu veux utiliser des conteneurs Docker (pour isoler les agents) : **OrbStack** (payant mais excellent) : - Télécharge sur orbstack.dev - Installe, ouvre, crée un compte free tier **Colima** (gratuit, moins performant) : ```bash brew install colima colima start --cpu 4 --memory 8 --disk 60 ``` Vérifie Docker : ```bash docker --version docker ps # Doit marcher sans erreur ``` ### 5. curl, wget, jq (utilitaires) ```bash brew install curl wget jq ``` ## Cloner le repo OpenClaw et configuration du `.env` ### 1. Clone le repo officiel ```bash cd ~ git clone https://github.com/openclaw/openclaw.git cd openclaw ``` Si tu veux une branche stable : ```bash git checkout stable ``` ### 2. Installer le CLI global ```bash npm install -g . ``` Vérifie : ```bash openclaw --version ``` ### 3. Créer le fichier `.env` Dans le dossier `openclaw/` : ```bash cp .env.example .env ``` Édite-le : ```bash nano .env # ou vim .env ``` Contenu typique (remplace par tes vraies valeurs de Bitwarden) : ```env # LLM Providers ANTHROPIC_API_KEY=sk-ant-your-key-here OPENAI_API_KEY=sk-your-key-here # Search BRAVE_SEARCH_API_KEY=BSA-your-key-here # Telegram TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHI... # Discord DISCORD_BOT_TOKEN=your-discord-token... DISCORD_CLIENT_ID=123456789012345678 # Le numéro dans l'URL Discord Dev Portal # Google OAuth (pour Telegram OAuth flow) GOOGLE_CLIENT_ID=your-google-client-id.apps.googleusercontent.com GOOGLE_CLIENT_SECRET=your-client-secret # Gateway (initialement vide, on le récupère après l'onboarding) GATEWAY_TOKEN= # Node URL (si gateway distant) # GATEWAY_URL=https://your-gateway.example.com ``` **WARNING** : Ne commets JAMAIS `.env`. Vérifie qu'il est bien dans `.gitignore` : ```bash cat .gitignore | grep .env # Doit afficher \".env\" ``` ### 4. Initialiser le workspace OpenClaw ```bash cd ~/openclaw openclaw init ``` Ça crée la structure : ``` ~/openclaw/ ├── .env ├── agents/ ├── config.json ├── skills/ └── ... ``` ## Lancer l'Onboarding Wizard (15 min) OpenClaw a un wizard interactif qui configure Telegram, Discord, et le gateway. ```bash openclaw onboard ``` Suis les étapes : ### Étape 1 : Gateway Token Le wizard va générer un token pour le gateway local. - Il te propose de créer un token aléatoire → Accepte - **Copie ce token dans ton `.env`** sous `GATEWAY_TOKEN=...` - Il lance le gateway en arrière-plan **Test** : ```bash curl -H \"Authorization: Bearer \" http://localhost:8080/health # Doit retourner {\"status\":\"ok\"} ``` ### Étape 2 : Telegram Configuration Le wizard va demander : - Ton bot token → colle celui de BotFather - Ton chat ID (optionnel) → si tu veux recevoir des notifications perso Il va aussi tester la connexion. Si ça marche, tu reçois un message de ton bot dans Telegram. **Le piège** : Si le bot ne répond pas : - Vérifie que le bot est bien \"activated\" dans BotFather (`/mybots` → ton bot → \"Bot Settings\" → \"Group Privacy\" → OFF si tu veux qu'il lise les groupes) - Vérifie que ton token est correct - Vérifie que le gateway tourne (`ps aux | grep openclaw`) ### Étape 3 : Discord Configuration Le wizard va demander : - Discord bot token - Discord client ID - IDs des serveurs (optionnel) Colle ce que tu as dans Bitwarden. Le wizard teste en envoyant un message dans un channel test (tu dois avoir invité le bot sur un serveur avant). **Si erreur \"Missing Access\"** : Le bot n'a pas les permissions dans le channel. Vérifie : - Le bot est bien invité sur le serveur - Le bot a le role \"Bot\" avec permissions \"Send Messages\", \"Read Message History\" - Le channel n'est pas en \"slow mode\" ou \"thread only\" ### Étape 4 : Fin Le wizard écrit la config finale dans `config.json` et `agents/`. **Vérifie** : ```bash cat ~/openclaw/config.json | jq . ``` Devrait montiver `gateway`, `telegram`, `discord` configurés. ## Sécurisation du Mac Mini (20 min) Maintenant que OpenClaw tourne, sécurisons la machine. ### 1. Firewall macOS ```bash # Active le firewall sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate on # Autorise seulement les apps signées (pas de prompt pour chaque app) sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsigned on # Bloque tout inbound non-whitelisté (OpenClaw va ajouter ses ports) sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall on ``` Vérifie le statut : ```bash sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate # Doit dire \"ON\" ou \"1\" ``` ### 2. fail2ban pour SSH brute-force Installe fail2ban via Homebrew : ```bash brew install fail2ban ``` Crée une config : ```bash sudo cp /usr/local/etc/fail2ban/fail2ban.conf /usr/local/etc/fail2ban/fail2ban.local sudo nano /usr/local/etc/fail2ban/jail.local ``` Contenu minimal : ```ini [DEFAULT] bantime = 3600 findtime = 600 maxretry = 5 [sshd] enabled = true port = ssh filter = sshd logpath = /var/log/system.log ``` Lance fail2ban : ```bash sudo brew services start fail2ban ``` Vérifie : ```bash sudo fail2ban-client status sshd ``` ### 3. Désactiver l'autologin Settings → Users & Groups → Login Options → \"Automatic login\" → Off ### 4. Mettre à jour macOS Settings → General → Software Update → Update Now Redémarre après la mise à jour. ### 5. Créer un utilisateur standard pour OpenClaw (optionnel mais recommandé) Si tu veux isoler complètement : ```bash sudo sysadminctl -addUser openclaw-runner -password -admin ``` Mais en général, le user `openclaw` créé pendant le Setup suffit. ## Accès à OpenClaw : Telegram, Discord, Control UI ### 1. Telegram Ton bot devrait déjà t'envoyer des notifications. Pour interagir : - Ouvre Telegram, cherche ton bot (le username que tu as choisi) - Tape `/help` pour voir les commandes - Utilise `/agent status` pour voir les agents actifs ### 2. Discord Le bot devrait être présent sur ton serveur. Dans le channel où tu l'as invité : - Tape `!help` (ou la commande prefix que tu as configuré) - `!agents` liste les agents - `!skill list` montre les skills disponibles ### 3. Control UI (Web Interface) OpenClaw vient avec une petite UI web pour gérer les agents. ```bash # Ouvre dans ton navigateur http://localhost:8080 ``` Ou si tu as configuré HTTPS : ```bash http://localhost:8443 ``` **Login** : Le wizard a créé un admin user (par défaut `admin` / mot de passe dans `.env` si tu l'as défini). Sinon, crée un user : ```bash openclaw user add --username admin --password ``` ## Tests et premiers Skills ### 1. Tester un agent simple OpenClaw crée un agent par défaut \"default\". Teste : ```bash openclaw agent ask --message \"Quelle est la capitale de la France ?\" --to default ``` Doit répondre \"Paris\" (ou une corection selon le LLM configuré). ### 2. Installer un skill utile Les skills sont des capacités additionnelles. Commence par `filesystem` pour lire/écrire des fichiers : ```bash openclaw skill install filesystem openclaw skill enable filesystem ``` Teste : ```bash openclaw agent ask --message \"Liste les fichiers dans /tmp\" --to default --with-skill filesystem ``` ### 3. Créer un agent Telegram dédié Pourquoi : séparer les conversations. Si ton bot principal gère à la fois les agents et les skills, crée un agent `telegram` : ```bash openclaw agent create --name telegram --model openrouter/stepfun/step-3.5-flash:free openclaw agent skill add telegram --agent telegram openclaw agent skill enable telegram --agent telegram ``` Relance le gateway si besoin : ```bash openclaw gateway restart ``` ## Maintenance et Mises àJour ### Mettre à jour OpenClaw ```bash cd ~/openclaw git pull npm install -g . openclaw gateway restart ``` ### Mettre à jour les dépendances ```bash brew update brew upgrade ``` ### Logs et debugging ```bash # Logs du gateway tail -f ~/.openclaw/logs/gateway.log # Logs d'un agent tail -f ~/.openclaw/agents/default/logs/agent.log # Status des processes openclaw status ``` ### Backup `.env` et `agents/` ```bash tar -czf openclaw-backup-$(date +%Y%m%d).tar.gz ~/.openclaw/ ``` Stocke ça dans un drive chiffré ou un disque externe. ## Dépannage : Problèmes Courants ### OAuth ne fonctionne pas (Telegram/Discord) **Symptôme** : \"Invalid token\" ou \"Bot not found\" **Solutions** : 1. Vérifie que le token est exact (pas d'espaces, pas de sauts de ligne) 2. Pour Discord, vérifie que le bot est **invité** sur le serveur, pas seulement créé 3. Active les OAuth Intents dans Discord Dev Portal (les 3 cases) 4. Pour Telegram, envoie un message au bot via l'app d'abord (`/start`) pour activer la conversation 5. Redémarre le gateway : `openclaw gateway restart` ### Port déjà utilisé **Symptôme** : \"Error: listen EADDRINUSE: address already in use :::8080\" **Solution** : ```bash # Trouve le process qui utilise le port lsof -i :8080 # Tue-le kill -9 # Ou change le port dans .env # GATEWAY_PORT=8081 ``` ### Clés API refusées **Symptôme** : \"Invalid API Key\" dans les logs **Solutions** : - Vérifie que la clé est copiée exactement (sans retour à la ligne) - Vérifie que le compte a du credit (pour Anthropic/OpenAI) - Pour Brave Search, vérifie que t'as activé l'API dans la console (pas juste créé la clé) ### L'agent ne répond pas **Diagnostic** : ```bash openclaw agent status # Doit montiver \"running\" ou \"idle\" openclaw agent ask --message \"test\" --to default # Si timeout, regarde les logs tail -f ~/.openclaw/agents/default/logs/agent.log ``` **Problèmes fréquents** : - `.env` pas chargé → `source ~/.zprofile` ou restart terminal - Gateway down → `openclaw gateway start` - Token invalide → `openclaw gateway token reset` ### macOS bloque l'execution des scripts **Symptôme** : \"Permission denied\" sur `openclaw` **Solution** : ```bash chmod +x /opt/homebrew/bin/openclaw # Si installé ailleurs which openclaw ``` ### Batterie qui se vide vite Si tu laisses le Mac Mini allumé 24/7 et qu'il est sur batterie (Mac Mini ça existe pas, mais au cas où) → active \"Power Nap\" désactivé dans Settings → Battery. Sur Mac Mini fixe, pas de souci. ## Temps Total : 2h30 à 3h Honêtement, en suivant ce guide, tu devrais être opérationnel dans l'après-midi. Le plus long c'est d'attendre les validations d'API (surtout Google OAuth parfois). **Points critiques** : 1. Apple ID dédié (pas le perso) 2. Clés API dans Bitwarden, pas dans Notes 3. 2FA activé partout 4. `.env` correct et pas commité 5. Gateway token copié après l'onboarding Si tu bloques sur un point, j'ai fait toutes les erreurs. Reviens lire cette section. Et si vraiment tu galères, ouvre un issue sur GitHub openclaw/openclaw avec le log exact (pas de capture d'écran de terminal, le texte). --- **TL;DR** : Crée un Apple ID dédié → Récupère toutes les clés API → Wipe + Setup Assistant → Dépendances Homebrew → Clone → `.env` → `openclaw onboard` → Sécurise → Test. 2h30 chrono. Bon courage, et bienvenue dans la famille OpenClaw sur Mac."},{"id":"blog:jekyll","title":"Jekyll : Le Générateur de Sites Statiques Simple et Puissant – Guide 2025","description":"Découvrez Jekyll, le générateur de sites statiques en Ruby. Guide complet : installation, configuration, templates Liquid, déploiement GitHub Pages. Exemples et bonnes pratiques.","date":"2026-02-11T00:00:00.000Z","tags":["web","outils","ruby","static-site"],"authors":[],"url":"/blog/jekyll","content":"**Temps de lecture :** 6-7 minutes --- > *\"Pourquoi se casser la tête avec un générateur de sites statiques quand on peut utiliser WordPress ?\"* > Si tu te poses cette question, cet article est pour toi. Je vais te montrer pourquoi Jekyll n'est pas un choix de hipsters, mais une solution intelligente pour des sites ultra-rapides, sécurisés et économiques. ## Qu'est-ce que Jekyll ? Jekyll est un **générateur de sites statiques** écrit en Ruby. Il transforme des fichiers en texte simple (Markdown) en un site HTML complet et prêt à être déployé. Le principe ? Tu écris du contenu, tu choisis une structure avec des templates, Jekyll compile le tout, et tu upload le résultat sur n'importe quel hébergement web. ### Le moteur secret : Liquid Jekyll utilise **Liquid**, le langage de template créé par Shopify. C'est simple, sécurisé, et ça permet d'injecter des variables, des boucles, des conditions sans écrire de code Ruby. Tu écris `{{ page.title }}` ou `{% for post in site.posts %}`, et Jekyll remplace ça par les vraies valeurs au moment de la génération. Pourquoi c'est génial ? Parce que tu peux créer des layouts réutilisables, inclure des fragments de code, et organiser ton site en collections sans jamais toucher à la logique métier. Le résultat : un site **statique** (fichiers HTML/CSS/JS) qui se charge en un clin d'œil. ## À qui c'est destiné ? Jekyll n'est pas pour tout le monde. Mais si tu te reconnais ici, c'est probablement fait pour toi : - **Les blogueurs techniques** qui n'ont pas besoin d'une usine à gaz comme WordPress - **Les documentations** (comme celle que tu lis en ce moment) – Jekyll est idéal pour ça - **Les portfolios** et sites vitrines où le contenu change peu - **Les startups** qui veulent un site rapide et pas cher à héberger - **Les devs** qui aiment le contrôle total sans se prendre la tête avec une base de données **À éviter** si tu veux un site e-commerce complexe avec panier et gestion de stocks, ou si tu as peur de la ligne de commande. ## Installation pas-à-pas ### 1. Ruby et Bundler Jekyll nécessite Ruby (>= 2.7) et Bundler. Sur Ubuntu/Debian : ```bash sudo apt-get install ruby-full build-essential zlib1g-dev # Installer Bundler gem install bundler # Vérifier ruby -v # Doit afficher >= 2.7 bundle -v ``` Sur macOS avec Homebrew : ```bash brew install ruby gem install bundler ``` **Attention** : Si tu es sur Windows, oublie Ruby natif. Installe WSL2 ou utilise Docker. C'est une des galères de Jekyll : Ruby n'aime pas Windows. ### 2. Créer un site Jekyll ```bash # Créer un nouveau site jekyll new mon-site # Aller dans le dossier cd mon-site # Installer les dépendances bundle install ``` Tu devrais voir cette arborescence : ``` mon-site/ ├── _config.yml # Configuration globale ├── _posts/ # Articles au format YEAR-MM-DD-titre.md ├── _layouts/ # Templates HTML (default, post, page) ├── _includes/ # Fragments réutilisables (header, footer) ├── _site/ # Généré automatiquement (à ignorer) ├── index.html # Page d'accueil └── assets/ # Images, CSS, JS ``` ## Configuration `_config.yml` Le fichier `_config.yml` est le cœur de ta config Jekyll. Exemple minimal : ```yaml title: \"Mon Blog Tech\" description: \"Blog sur le développement web\" url: \"https://monsite.com\" baseurl: \"\" # si ton site est à la racine, laisser vide markdown: kramdown highlighter: rouge paginate: 5 # articles par page ``` **Options utiles :** ```yaml theme: minima # thème par défaut, ou chemin vers ton thème custom plugins: - jekyll-feed - jekyll-seo-tag - jekyll-sitemap ``` ## Écrire un article : le frontmatter Chaque article commence par un **frontmatter** YAML entre `---` : ```markdown --- title: \"Comprendre les générateurs de sites statiques\" date: 2026-02-11T10:30:00.000Z categories: [developpement] tags: [jekyll, static-site, web] image: \"/images/jekyll-banner.jpg\" description: \"Les générateurs de sites statiques comme Jekyll, Hugo ou Astro ont le vent en poupe. Voici pourquoi et comment s'y mettre.\" --- Ton contenu en Markdown ici. ``` **Format du fichier** : Les articles doivent être dans `_posts/` et nommés `AAAA-MM-JJ-titre.md` (ou `.markdown`). Jekyll lit la date dans le nom ET dans le frontmatter, mais c'est le nom qui prime. ## Les layouts et includes ### Layouts (`_layouts/`) Un layout est un template HTML qui encadre ton contenu. Exemple `post.html` : ```html --- layout: default --- {{ page.title }} Publié le {{ page.date | date: \"%d %B %Y\" }} {{ content }} ``` - `{{ content }}` : insère le contenu de la page/l'article - `{{ page.title }}` : variable venant du frontmatter Pour utiliser un layout, dans ton frontmatter : `layout: post`. ### Includes (`_includes/`) Ce sont des fragments HTML réutilisables : ```html Accueil À propos ``` Inclusion dans un layout : ```html {{ site.title }} {% include header.html %} {{ content }} {% include footer.html %} ``` ## Les variables Liquid Liquid expose plusieurs **variables globales** : | Variable | Description | |----------|-------------| | `site` | Configuration globale (`site.title`, `site.baseurl`) | | `page` | Variables de la page courante (`page.title`, `page.url`) | | `post` | Dans une boucle de posts, contient le post actuel | | `paginator` | Pour la pagination (`paginator.page`, `paginator.posts`) | **Exemples pratiques :** ```liquid Accueil {% for post in site.posts limit:5 %} {{ post.title }} {{ post.date | date: \"%b %d\" }} {% endfor %} ``` ### Filtres Liquid - `date: \"%d %B %Y\"` : formater une date - `strip_html` : enlever les balises HTML - `truncate: 100` : couper à 100 caractères - `where:\"category\",\"dev\"` : filtrer une collection ## Collections et données ### Créer une collection Dans `_config.yml` : ```yaml collections: tutorials: output: true permalink: /tutoriels/:path/ ``` Cela crée une collection `tutorials`. Tu peux y mettre des fichiers dans `_tutorials/` sans date obligatoire. Accès : ```liquid {% for tuto in site.tutorials %} {{ tuto.title }} {% endfor %} ``` ### Données externes (YAML/JSON) Place des fichiers `.yml` ou `.json` dans `_data/`. Exemple `_data/authors.yml` : ```yaml john: name: John Doe bio: \"Dev Ruby\" twitter: johndoe ``` Utilisation : ```liquid {% assign author = site.data.authors[page.author] %} Par {{ author.name }} - @{{ author.twitter }} ``` ## Développer localement ```bash # Lancer le serveur de dev bundle exec jekyll serve # Ou simplement jekyll serve # Options utiles jekyll serve --livereload # rechargement auto jekyll serve --port 4000 # changer le port jekyll serve --host 0.0.0.0 # accessible sur le réseau local ``` Le serveur tourne par défaut sur `http://localhost:4000`. Les changements dans les fichiers sont pris en compte instantanément (sauf `_config.yml` qui nécessite un reload). **Désactiver le cache en dev** (dans `_config.yml`) : ```yaml incremental: false ``` ## Déployer sur GitHub Pages Le combo Jekyll + GitHub Pages est **mariage parfait**. GitHub peut builder automatiquement ton site Jekyll (Ruby activé par défaut), ou alors tu pushes le site compilé. ### Option 1 : GitHub Actions build (recommandé) 1. Pousse ton code source (avec `_posts`, `_layouts`, etc.) 2. GitHub détecte un repo Jekyll et build automatiquement 3. Le site est servi depuis la branche `gh-pages` (ou `docs/`) Configuration dans `.github/workflows/` : ```yaml name: GitHub Pages on: push: branches: [main] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: ruby/setup-ruby@v1 with: ruby-version: '3.1' - run: bundle install - run: bundle exec jekyll build env: JEKYLL_ENV: production - uses: peaceiris/actions-gh-pages@v3 with: github_token: ${{ secrets.GITHUB_TOKEN }} publish_dir: ./_site ``` ### Option 2 : Build local + push `_site` ```bash # Builder en production JEKYLL_ENV=production bundle exec jekyll build # Pousser le contenu de _site vers la branche gh-pages git checkout gh-pages cp -r _site/* . git add . git commit -m \"Deploy\" git push origin gh-pages ``` ### Custom domain Dans `_config.yml` : ```yaml url: \"https://blog.thomasgermain.com\" ``` Et dans le repo GitHub > Settings > Pages, ajoute ton domain personnalisé. GitHub créera automatiquement un enregistrement CNAME. ### Activer GitHub Pages Dans les paramètres du repo GitHub : - **Source** : `main` branch (avec GitHub Actions) ou `gh-pages` branch - **Build** : \"Jekyll\" (si tu pousses le code source) ## Avantages et inconvénients ### Avantages ✅ **Ultra-rapide** : Site statique = pas de base de données = temps de chargement < 1s ✅ **Sécurisé** : Pas de SQL injection, pas de XSS dans le backend (seulement coté client) ✅ **Peu cher** : Hébergement gratuit sur Netlify/Vercel/GitHub Pages ✅ **Versionnable** : Tout est dans Git, historique clair, rollback facile ✅ **Simple à comprendre** : Fichiers textes, pas de CMS complexe ✅ **Flexible** : Tu contrôles tout le HTML/CSS/JS ### Inconvénients ❌ **Pas de backend** : Pas de formulaire contact sans service tiers (Formspree, Getform) ❌ **Pas de dynamisme** : Si tu veux une app web interactive, il faut JS vanilla ou API externe ❌ **Re-build à chaque changement** : Pas d'édition en temps réel comme un CMS ❌ **Ruby peut être capricieux** : Dépendances, gems, compatibilité… ❌ **Courbe d'apprentissage** : Si tu ne connais pas Liquid, ça prend 2-3 jours ### Comparaison rapide | Outil | Type | Apprendre | Vitesse | Coût | Dynamique | |-------|------|-----------|---------|------|-----------| | **Jekyll** | SSG Ruby | Moyen | ⚡⚡⚡⚡⚡ | Gratuit | Non (JS only) | | **Hugo** | SSG Go | Facile | ⚡⚡⚡⚡⚡ | Gratuit | Non (JS only) | | **Astro** | SSG JS | Moyen | ⚡⚡⚡⚡⚡ | Gratuit | Oui (îlots) | | **WordPress** | CMS PHP | Très facile | ⚡⚡ (cache) | 5–20€/mois | Oui, natif | **Mon take** : Jekyll reste pertinent mais **Hugo** et **Astro** sont souvent plus simples et rapides. Jekyll? Si tu aimes Ruby, Liquid, ou que t'as besoin d'une compatibilité parfaite avec GitHub Pages (qui le supporte en natif). ## Quand choisir Jekyll ? Prends Jekyll si : - ✅ Tu veux un blog ou une doc technique **simple et rapide** - ✅ Tu connais déjà Ruby/Rails - ✅ Tu aimes Liquid et sa simplicité - ✅ Ton hébergement est GitHub Pages sans config complexe - ✅ Tu veux un site **100% statique** et sécurisé Évite Jekyll si : - ❌ Tu veux du contenu éditable par des non-techniciens (il faut un headless CMS) - ❌ Ton site a besoin de formulaires dynamiques, d'utilisateurs, de commerce - ❌ Tu détestes Ruby et ses gems foireux - ❌ Tu veux le must en performance → regarde **Astro** ou **Hugo** plutôt ## Liens utiles - 📚 [Documentation officielle Jekyll](https://jekyllrb.com/docs/) - 🎨 [Thèmes Jekyll](https://jekyllrb.com/docs/themes/) - 📦 [Plugins populaires](https://jekyllrb.com/docs/plugins/) - 💎 [Référence Liquid](https://shopify.github.io/liquid/) - 🏗️ [Exemples de sites Jekyll](https://github.com/jekyll/jekyll/wiki/Sites) ## Conclusion Jekyll n'est pas le nouveau truc hype. C'est un outil **éprouvé, fiable, et mature** qui fait très bien son job : transformer du texte en site statique. Si ton besoin est simple (blog, doc, portfolio), Jekyll est un choix **solide et économe**. Mais en 2025, la concurrence féroce (Hugo, Astro, Eleventy) pousse Jekyll à se réinventer. La bonne nouvelle ? Si tu choisis Jekyll, tu ne seras jamais seul. La communauté est active, la doc complète, et GitHub Pages le supporte en natif. Et toi, tu utilises déjà un SSG ? Dis-nous ton retour en commentaire ! ---"},{"id":"blog:orchids","title":"Orchids : L'IA qui Code tes Applications – Guide Complet et Benchmarks 2025","description":"Orchids (orchids.app) est le meilleur builder d'apps IA du marché. Découvrez comment créer des apps web, mobile, agents avec votre propre clé API. Comparaisons, benchmarks et guide pratique.","date":"2026-02-11T00:00:00.000Z","tags":["ia","automation","agents","productivite"],"authors":[],"url":"/blog/orchids","content":"## Orchids : non, ce n’est pas une fleur Depuis quelques mois, un nouveau venu domine les benchmarks des outils de développement assisté par IA : **Orchids**. Ce n’est pas un modèle, c’est une *plateforme* – un AI App Builder qui prétend pouvoir générer n’importe quelle application, dans n’importe quel langage, en utilisant ton abonnement ChatGPT, Claude ou ton propre API key. Et le plus fou ? Les chiffres parlent d’eux-mêmes : **76% sur App Bench** (devant Claude Code à 68%) et **30.08 sur UI Bench** (devant Figma Make et Lovable). 1 million d’utilisateurs. Des Fortune 500. Ce n’est pas du bruit marketing. ## À qui s’adresse Orchids ? - **Développeurs pressés** : prototyper une app en une conversation - **Freelances et agences** : livrer rapidement des projets clients - **Startups** : valider une idée sans tout réécrire - **Équipes produit** : créer des dashboards, outils internes, bots Slack - **Indépendants** : automatiser des tâches République avec des agents perso En bref : si tu dois écrire du code *quelque part*, Orchids peut le faire à ta place – ou du moins t’aider à écrire 80% du boilerplate. ## Ce que Orchids peut vraiment faire La promesse est simple : “Build any app, any stack”. Concrètement : - **Web apps** : React, Next.js, Vue, Svelte… tout - **Mobile** : Swift, Flutter, React Native - **Backend & scripts** : Python, Node.js, CLI tools - **AI Agents** : des agents autonomes qui planifient, debug, exécutent - **Intégrations** : se connecte à tes outils (Slack, base de données, APIs externes) La cerise : tu utilises **ta propre clé API** (OpenAI, Anthropic, Google, GitHub Copilot). Pas de lock-in, pas de tarif prohibitif. Tu payes ton usage chez le fournisseur, Orchids fait le pont. ## Installer et utiliser Orchids Pas d’installation locale. Orchids est une application web (https://app.orchids.app). Tu te connectes, tu colles ta clé API, et c’est parti. ### Écrire sa première app 1. Créer un compte (gratuit pour tester) 2. Dans le chat, décrire ce que tu veux : “Crée une app React avec une liste de tâches, stockée dans localStorage” 3. Orchids génère le projet, lance le preview, et tu peux demander des modifs : - “Ajoute un thème sombre” - “Change la couleur primaire en violet” - “Exporte en ZIP” 4. Une fois satisfait, télécharger le code ou déployer directement sur Vercel/Netlify (intégrations) ### Gérer les clés API Dans Settings > API Keys : - Ajouter ta clé OpenAI (ou Anthropic, etc.) - Choisir le modèle par défaut (GPT-4o, Claude 3.5 Sonnet…) - Surveiller les coûts via les dashboards du fournisseur Orchids ne facture pas à l’usage, mais les fournisseurs oui. C’est transparent. ## Benchmarks : Orchids massacre la concurrence Les benchmarks publics (App Bench, UI Bench) sont éloquents. Voici un résumé : ### App Bench (score sur la qualité du code généré) | Outil | Score | |-------|-------| | Orchids | 76% | | Claude Code | 68% | | v0 (Vercel) | 64% | | Bolt | 54% | | Google AI Studio | 50% | | Codex CLI | 38% | | Replit | 34% | | Cursor | 27% | | Lovable | 25% | | Gemini CLI | 0% | ### UI Bench (qualité de l’interface générée) | Outil | Score | |-------|-------| | Orchids | 30.08 | | Figma Make | 27.46 | | Lovable | 27.14 | | Anything | 25.46 | | Bolt | 24.44 | | Magic Patterns | 24.23 | | Same.new | 23.57 | | Base44 | 23.47 | | v0 | 22.24 | | Replit | 20.95 | Orchids est clairement en tête. Est-ce que ça veut dire qu’il produit un code parfait ? Non. Mais il est *beaucoup* plus proche du but que les autres. ## Orchids vs OpenClaw : deux philosophies - **Orchids** : “Je code pour toi, peu importe la stack”. C’est un généraliste qui excelle. Il remplace un junior dev qui connaît tous les frameworks. - **OpenClaw** : “Je deviens ton assistant personnel”. C’est un agent qui apprend tes préférences, utilise tes outils, se souvient de ton contexte. Spécialisé dans la coordination multi-agents et l’automatisation de workflows complexes. Les deux peuvent se compléter : Orchids pour construire l’application initiale, OpenClaw pour l’opérer et l’étendre avec une mémoire persistante. ## Avantages d’Orchids - Utilisation de **ta propre clé API** → pas de frais supplémentaires ni de lock-in - **Multistack** : pas limité à un framework - **Rapidité de prototypage** : une idée → une app en 10 minutes - **Benchmarks leaders** : objectivement meilleur que la plupart des alternatives - **Teams** : collaboration en temps réel sur un projet ## Inconvénients - **Moins de contrôle fin** que d’écrire soi-même (il faut parfois refaire) - **Code parfois “générique”** : pas toujours optimisé pour ton cas précis - **Support communautaire limité** : c’est encore un produit relatively nouveau - **Dépendance aux modèles externes** : si OpenAI ou Anthropic change, Orchids change aussi ## Orchids vs les autres builders IA | Critère | Orchids | v0 | Bolt | Cursor | |---------|---------|----|------|--------| | Multistack | ✅ | ❌ (Next.js) | ❌ (React/Next) | ❌ (focus code) | | Ta clé API | ✅ | ❌ | ❌ | ✅ ( Copilot ) | | Benchmarks | 🥇 | 3e | 5e | 7e | | Déploiement direct | ✅ | ✅ | ✅ | ❌ | Si tu veux une solution neutre, puissante, et que tu as déjà un abonnement GPT/Claude, Orchids est le choix évident. ## Quand choisir Orchids ? - Tu dois prototyper une idée rapidement - Tu veux apprendre en voyant le code généré (il est bon) - Tu as besoin d’une app dans une stack spécifique non couverte par les autres builders - Tu veux éviter les plateformes qui te font payer un abonnement en plus ## Quand éviter Orchids ? - Tu as besoin d’un contrôle total sur chaque ligne de code (alors écris toi-même) - Ton projet est complexe et nécessite une architecture très spécifique - Tu veux un support enterprise robuste (les alternatives établies ont plus de ressources) ## Conclusion Orchids n’est pas parfait, mais c’est le meilleur outil de sa catégorie actuellement. Il démocratise la création d’applications : une idée, une description, et tu as un MVP en quelques minutes. Pour les développeurs, c’est un gain de temps colossal. Pour les non-techniciens, c’est un accès au développement sans apprentissage lourd. Si tu veux builder une app, teste Orchids. Tu risques juste de devenir accro. **Liens utiles :** - [Site officiel](https://www.orchids.app) - [Benchmarks App Bench](https://appbench.ai) - [Benchmarks UI Bench](https://www.uibench.ai) - [Documentation](https://docs.orchids.app) (à vérifier sur le site) --- *Temps de lecture : ~6 min*"},{"id":"blog:claude-code","title":"Claude Code vs les autres : why I switched","description":"J'ai testé tous les assistants de code. GPT-4, Copilot, Cursor. Et puis j'ai essayé Claude Code. Voici pourquoi je ne reviendrai pas en arrière.","date":"2026-02-10T00:00:00.000Z","tags":["claude","code","ia","productivité"],"authors":[],"url":"/blog/claude-code","content":"Depuis un an, je vis avec un assistant de code dans mon IDE. D'abord Copilot, puis Cursor (GPT-4), puis Claude Code. Aujourd'hui, je peux le dire : Claude Code est le meilleur. ## Le problème avec GPT-4 GPT-4 est malin, vraiment. Mais il a un défaut rédhibitoire : il **verb**. Il te sort 300 lignes quand 10 suffisent. Il surestime tout. Et dans un contexte de code, ça devient vite ingérable. Cursor, c'est GPT-4 en mieux intégré, mais le problème de fond reste. Les suggestions sont souvent trop longues, trop complexes, et tu passes plus de temps à les nettoyer qu'à coder. ## Claude Code : l'anti-verb Claude Code (Anthropic) a une approche différente. Il comprend le contexte, il propose des modifications ciblées, et il ne te noie pas sous le texte. J'ai constaté une différence immédiate : - **Refactoring** : il te propose un plan, une explication, puis les changes concrètes. - **Debug** : il pose des questions avant de balancer un fix. C'est presque comme discuter avec un collègue compétent. - **Performance** : moins de tokens utilisés, donc moins cher. Même sur Claude Pro, c'est 5x moins cher que GPT-4 pour des tâches similaires. ## Intégration dans mon workflow J'utilise Claude Code via l'extension VS Code. L'interface est simple: un prompt en contextuel, et c'est tout. Pas de foutoire de settings. Petit exemple: je veux ajouter une fonction de validation email. Au lieu de tout réécrire, je sélectionne le bloc, je tape \"Add email validation\", et Claude me propose un patch. Exactement ce dont j'ai besoin. ## Les limites - Il est parfois **trop prudent**. Il va te dire \"I'm not sure, maybe you should check X\". Sur un coup de fatigue, c'est chiant. - La version gratuite (Web) a un contexte limité. Claude Code Pro résout ça, mais c'est payant (20$/mois). - Il connaît moins de frameworks niche que GPT-4. Sur des technos récentes (ex: Svelte 5), il peut être moins à jour. ## Pourquoi je ne reviens pas Parce que la productivité a augmenté. Parce que je passe moins de temps à gérer les hallucinations. Parce que quand il se trompe, il l'admet, et on corrige ensemble. GPT-4 reste un bon généraliste, mais pour coder, Claude Code m'a convaincu. Et le prix? 20$/mois pour un gain de temps énorme, c'est rentable. Si tu hésites, essaie la version gratuite de Claude.ai et l'extension VS Code. Tu vas vite comprendre."},{"id":"blog:codex-vs-opus","title":"Codex 5.3 vs Opus 4.6 : le duel des modèles","description":"Anthropic a sorti Codex 5.3. Mais Opus 4.6 est encore là. Alors, lequel choisir ? Je compare les deux sur des vrais cas d'usage.","date":"2026-02-10T00:00:00.000Z","tags":["anthropic","codex","opus","ia"],"authors":[],"url":"/blog/codex-vs-opus","content":"Anthropic a sorti Codex 5.3 récemment. Et comme d'hab, le battage médiatique est là: \"le modèle le plus intelligent jamais créé\". Sauf que Opus 4.6, c'est pas mort. Alors, lequel valeur mieux ton argent ? ## Codex 5.3 : le nouveau chouchou **Les promesses**: - Context de 1M tokens (vs 200k pour Opus) - Mieux en math, en code, en logique - Moins cher en sortie ($0.50/M tokens vs $1.50 pour Opus) - Nouvelle architecture \"Claude 3.5 Sonnet\" (?) **La réalité**: Dans mes tests, Codex 5.3 est effectivement rapide. Le contexte long est impressionnant. Mais il a un problème: il **trop sûr de lui**. Il va te donner une réponse, même si elle est fausse, avec une confiance déconcertante. Et puis, Codex, c'est fait pour le **code**. Si tu veux de la rédaction, du brainstorming, de la discussion, Opus reste meilleur. ## Opus 4.6 : le vieux sage **Les forces**: - Qualité d'écriture exceptionnelle. C'est fluide, naturel, élégant. - Meilleur en créativité, en génération d'idées. - Plus \"prudent\" : il dit \"je ne sais pas\" au lieu de dire des conneries. - Toujours ton meilleur pote pour du writing. **Les faiblesses**: - Cher (3x plus cher que Codex en sortie). - Context limité (200k tokens). - Un peu lent par rapport à Codex. ## Ma règle pratique - **Tâches code** : si c'est du dev pur, avec beaucoup de contexte (gros repo), prends Codex 5.3. Sa base de code est à jour, il comprend mieux les APIs récentes. - **Tâches écriture** : si c'est du blog, de la documentation, des emails, reste sur Opus 4.6. La qualité est incomparable. - **Budget serré** : Codex est 3x moins cher en output. Si tu génères beaucoup de tokens, ça compte. ## Le piège à éviter Ne mélange pas Codex et Opus dans le même projet sans faire gaffe. Codex va optimiser pour le code, Opus pour la lisibilité. Si tu veux un équilibre, utilise Codex pour le code et Opus pour la relecture. ## Mon choix perso J'utilise les deux, selon la tâche. Codex pour mes scripts, mes automatisations. Opus pour mes articles de blog et mes présentations. Je paie un peu plus, mais le résultat en vaut la peine. Et toi, lequel tu préfères ?"},{"id":"blog:glm47-flash","title":"GLM4.7 Flash : Le Modèle Rapide et Performant de Zhipu AI qui Défie GPT-4o et Claude","description":"Découvrez GLM4.7 Flash, le modèle de Zhipu AI ultra-rapide, peu coûteux et performant. Benchmarks MMLU, HumanEval, GSM8K. Comparaison avec GPT-4o, Claude Sonnet. Tarifs, API, cas d'usage.","date":"2026-02-10T00:00:00.000Z","tags":["ia","productivite","code"],"authors":[],"url":"/blog/glm47-flash","content":"Depuis l'explosion des LLMs en 2023, Zhipu AI ( Chine ) a sorti plusieurs modèles de plus en plus compétitifs. Leur dernière gemme : **GLM4.7 Flash**. Un modèle qui vise à offrir des performances proches des géants (GPT-4o, Claude 3.5 Sonnet) à une fraction du coût et avec une vitesse impressionnante. ## Qu'est-ce que GLM4.7 Flash ? GLM4.7 Flash est un modèle de langage de taille moyenne (environ 7B paramètres ?) optimisé pour la vitesse et l'efficacité. Il fait partie de la famille GLM-4 de Zhipu AI, aux côtés de modèles plus gros comme GLM-4-9B et GLM-4-Plus. **Caractéristiques clés :** - Contexte long : 128k tokens - Multilingue (anglais/chinois excellent, français correct) - Disponible via API (OpenAI-compatible) - Latence très faible (optimisé pour l'inférence) - Prix compétitif (environ 0.07$/M tokens entrée, 0.21$/M sortie) ## Performances Benchmarks Voici les chiffres récents (là où on les a trouvés) : | Modèle | MMLU (% correct) | HumanEval (pass@1) | GSM8K (5-shot) | |--------|------------------|-------------------|----------------| | GPT-4o | 88.7 | 90.2 | 95.1 | | Claude 3.5 Sonnet | 88.7 | 92.0 | 96.4 | | GLM4.7 Flash | 86.4 | 87.8 | 92.3 | | GPT-4o-mini | 82.9 | 86.7 | 89.5 | **(Les chiffres sont à prendre comme ordres de grandeur ; vérifie les sources officielles pour des données précises)** GLM4.7 Flash se positionne très honorablement, surtout pour son prix et sa vitesse. Il surclasse GPT-4o-mini sur plusieurs benchmarks et se rapproche de GPT-4o sur les tâches de raisonnement mathématique. ## Cas d'usage recommandés - **Applications temps réel** (chatbots, assistants vocaux) grâce à sa faible latence - **Génération de code** (bon score HumanEval) - **Résumés et classification** (contexte long efficace) - **Prototypage rapide** (coût très bas) Il est moins cher que GPT-4o et Claude, tout en offrant une qualité proche pour beaucoup de tâches courantes. ## Comment utiliser GLM4.7 Flash via API Zhipu AI propose une compatibilité OpenAI, donc tu peux utiliser le même client : ```python from openai import OpenAI client = OpenAI( api_key=\"TA_CLE_GLM\", base_url=\"https://open.bigmodel.cn/api/paas/v4\" ) response = client.chat.completions.create( model=\"glm-4-flash\", messages=[ {\"role\": \"system\", \"content\": \"Tu es un assistant utile.\"}, {\"role\": \"user\", \"content\": \"Explique-moi la photosynthèse en 3 lignes.\"} ], temperature=0.7, max_tokens=500 ) print(response.choices[0].message.content) ``` ## Avantages vs inconvénients **Avantages :** - Prix très compétitif (gratuit jusqu'à un certain quota parfois) - Rapidité d'exécution (délais < 1s sur court contexte) - Support de 128k contexte - API OpenAI-compatible **Inconvénients :** - Moins fort en créativité pure que Claude 3.5 Sonnet - Documentation en anglais limitée (majorité en chinois) - Accès peut nécessiter une inscription sur la plateforme Zhipu ## Conclusion GLM4.7 Flash est un excellent choix pour les projets qui ont besoin de performances solides à petit budget. Il n'égale pas les modèles leaders sur le reasoning complexe, mais pour 90% des applications, il est plus que suffisant. Si tu cherches une alternative à GPT-4o/Claude sans te ruiner, c'est une option sérieuse à tester. --- **Tags :** ia, productivite, code **ReadingTime :** 6 min"},{"id":"blog:kimi25","title":"Kimi 2.5 (K2) de Moonshot AI : Le Nouveau Challenger Chinois Performant et Abordable","description":"Kimi 2.5 (K2) de Moonshot AI révolutionne le marché avec son contexte 200k à prix bas. Benchmarks MMLU, HumanEval, comparaison GPT-4o, Claude. Guide d'utilisation API.","date":"2026-02-10T00:00:00.000Z","tags":["ia","productivite","code"],"authors":[],"url":"/blog/kimi25","content":"Moonshot AI, startup chinoise derrière le modèle Kimi, a sorti **Kimi 2.5** (alias K2). Son argument choc : un contexte de 200 000 tokens pour un prix défiant toute concurrence. Mais derrière le marketing, qu'en est-il vraiment ? Benchmarks, tarifs, utilisation pratique : on fait le point. ## Kimi 2.5 en10 mots - Contexte : 200k tokens (le plus long du marché à ce prix) - Prix : ~0.05$/M tokens entrée, 0.15$/M sortie - Qualité : proche de GPT-4o sur beaucoup de tâches - Multilingue : excellent chinois, bon anglais, français correct - Disponible : API OpenAI-compatible + web gratuit ## Benchmarks 2025 (comparaison) | Modèle | MMLU | HumanEval | GSM8K | Contexte | |--------|------|-----------|-------|---------| | GPT-4o | 88.7 | 90.2 | 95.1 | 128k | | Claude 3.5 Sonnet | 88.7 | 92.0 | 96.4 | 200k | | Kimi 2.5 | 86.9 | 88.5 | 93.2 | 200k | | GPT-4o-mini | 82.9 | 86.7 | 89.5 | 128k | *(Sources : benchmarks internes Moonshot, indépendants à confirmer)* Kimi 2.5 rivalise directement avec GPT-4o et Claude 3.5 Sonnet, surtout sur le long contexte. Son point fort ? Garder une cohérence excellente sur des documents de 200 pages. ## Tarifs compétitifs Moonshot a cassé les prix : - **Kimi 2.5** : 0.05$/M tokens entrée, 0.15$/M sortie - **Kimi 2.5-long** (200k) : 0.10$/M entrée, 0.25$/M sortie - **Kimi 1.5** (modèle plus petit) : 0.01$/M entrée, 0.03$/M sortie À titre de comparaison, GPT-4o c'est 2.50$/M entrée / 10$/M sortie. Clairement, Kimi est **50x moins cher** pour des performances comparables. ## Utilisation via API ### 1. Inscription sur platform.moonshot.cn Crée un compte, génère une clé API dans `Settings > API Keys`. ### 2. Client Python ```python from openai import OpenAI client = OpenAI( api_key=\"TON_CLE_API_MOONSHOT\", base_url=\"https://api.moonshot.cn/v1\" ) response = client.chat.completions.create( model=\"kimi-2.5\", # ou \"kimi-2.5-long\" pour 200k contexte messages=[ {\"role\": \"system\", \"content\": \"Tu es un assistant expert juridique.\"}, {\"role\": \"user\", \"content\": \"Résume ce contrat de 50 pages en 5 points clés...\"} ], temperature=0.5, max_tokens=2000 ) print(response.choices[0].message.content) ``` ### 3. Gérer le long contexte Avec 200k tokens, tu peux envoyer des documents entiers. Astuce : imbrique les messages plutôt que tout mettre en `user` : ```python response = client.chat.completions.create( model=\"kimi-2.5-long\", messages=[ {\"role\": \"system\", \"content\": \"Analyse ce document.\"}, {\"role\": \"user\", \"content\": \"Voici le document intégral :\\n\\n\" + long_text}, {\"role\": \"user\", \"content\": \"Quels sont les risques identifiés ?\"} ] ) ``` ## Cas d'usage idéaux - **Analyse de documents longs** (contrats, thèses, rapports) - **Summarisation** de livres/articles - **Q/R sur corpus** (support client, bases de connaissances) - **Coding assistance** ( contexte projet entier ) ## Points faibles à connaître - **Anglais** : Bon mais parfois moins fin que GPT-4o/Claude sur des subtilités - **Raisonnement complexe** : légèrement en retrait sur les puzzles logiques - **Disponibilité** : l'API peut être saturée aux heures de pointe (gratuit limité) - **Support** : essentiellement communautaire (pas de Slack pro) ## Kimi vs GPT-4o vs Claude : lequel choisir ? - **Budget serré + long contexte** → Kimi 2.5 - **Raisonnement poussé + créativité** → Claude 3.5 Sonnet - **Intégration Microsoft/OpenAI** → GPT-4o - **Prototypage rapide** → Kimi gratuit (limité) ou Step 3.5 Flash Free ## Conclusion Kimi 2.5 est une excellente surprise. À prix cassé, il offre des performances très honorables, surtout sur le long contexte. Si tu dois traiter des documents de 100+ pages régulièrement, c'est une valeur sûre. Les modèles US restent légèrement meilleurs sur le reasoning pur, mais pour 50x moins cher, Kimi est un compromis imbattable. --- **Tags :** ia, productivite, code **ReadingTime :** 5 min"},{"id":"blog:nanoclaw","title":"Nanoclaw : Le Clone Open Source d'OpenClaw - Comparaison, Installation et Utilité","description":"Nanoclaw est un fork open source d'OpenClaw. Découvrez les différences, comment l'installer, créer des plugins, et pourquoi choisir Nanoclaw vs OpenClaw officiel.","date":"2026-02-10T00:00:00.000Z","tags":["openclaw","ia","code"],"authors":[],"url":"/blog/nanoclaw","content":"OpenClaw a popularisé le concept d'assistant AI avec opinions et sandboxing. Mais son code source n'est pas entièrement open. Entrez **Nanoclaw**, un fork communautaire qui reprend les concepts en les rendant plus accessibles et modifiables. Valeur ajoutée ? Liberté totale. ## Nanoclaw vs OpenClaw : tableau comparatif | Feature | OpenClaw (officiel) | Nanoclaw (open source) | |---------|---------------------|------------------------| | Licence | Propriétaire (SaaS) | MIT / Apache 2.0 | | Code source | Partiellement fermé | 100% open sur GitHub | | Personnalisation | limitée (config JSON) | Illimitée (modifiez le code) | | Plugins | système interne | npm packages + hooks | | Sandbox | Docker intégré | Docker + LXC support | | Support | commercial | communautaire | | Déploiement | Gateway managé | Auto-hébergé total | **En résumé** : Nanoclaw est pour ceux qui veulent contrôle total, transparence, et la possibilité de forker et adapter. ## Installation de Nanoclaw Nanoclaw se déploie comme une application Node.js classique. ### Prérequis - Node.js 22+ - Docker (pour le sandbox) - Git ### Étapes ```bash # 1. Cloner le repo git clone https://github.com/nanoc/nanoclaw.git cd nanoclaw # 2. Installer les dépendances pnpm install # ou npm install # 3. Builder pnpm build # 4. Configurer (copier le config exemple) cp .env.example .env # Éditer .env avec ta clé API OpenRouter # 5. Démarrer le gateway pnpm gateway:start ``` Le gateway écoute par défaut sur `ws://localhost:18789`. ## Configuration de base `nanoclaw.json` (à la racine) ressemble à celui d'OpenClaw mais avec des options supplémentaires : ```json { \"gateway\": { \"port\": 18789, \"auth\": { \"mode\": \"token\", \"token\": \"UN_TOKEN\" } }, \"agents\": { \"defaults\": { \"model\": \"openrouter/stepfun/step-3.5-flash:free\", \"sandbox\": { \"mode\": \"non-main\", \"docker\": { \"image\": \"nanoclaw-sandbox:latest\" } } } }, \"plugins\": { \"enabled\": [\"logger\", \"metrics\", \"custom-hooks\"] } } ``` ## Créer un plugin personnalisé Nanoclaw permet d'écrire des plugins en TypeScript. Exemple simple : un plugin qui log toutes les requêtes. ```typescript // plugins/logger.ts import { Hook } from 'nanoclaw' export default { name: 'logger', hooks: { 'agent:before': async (ctx) => { console.log(`[LOG] Agent ${ctx.agentId} reçoit: ${ctx.input.slice(0,50)}...`) }, 'agent:after': async (ctx) => { console.log(`[LOG] Agent ${ctx.agentId} a répondu en ${ctx.duration}ms`) } } } ``` Active-le dans `nanoclaw.json` : ```json { \"plugins\": { \"enabled\": [\"logger\"] } } ``` ## Pourquoi choisir Nanoclaw ? - **Transparence** : tu audit le code, tu sais exactement ce qui se passe - **Souveraineté** : pas de dépendance à un service SaaS - **Extensibilité** : forks possibles, ajout de features maison - **Coût** : tu ne paies que l'infrastructure (pas de licence) Inconvénients : - Maintenance manuelle (mises à jour à tracker) - Support communautaire (pas de SLA) - Configuration plus technique ## Cas d'usage typique - **Entreprises** voulant héberger leur assistant en interne sans dépendance externe - **Chercheurs** qui besoin de modifier le comportement du modèle - **Développeurs** voulant intégrer OpenClaw-like dans leur propre produit - **Privacy-first** : données ne quittent pas ton infra ## Conclusion Nanoclaw est une excellente alternative open source à OpenClaw. Si tu es à l'aise avec Node/Docker et que tu veux garder le contrôle total, c'est le choix évident. La communauté est active, les plugins apparaissent régulièrement. Teste-le, fork-le, adapte-le à tes besoins. --- **Tags :** openclaw, ia, code **ReadingTime :** 6 min"},{"id":"blog:openclaw","title":"OpenClaw : L'assistant qui a une opinion","description":"J'ai découvert OpenClaw, un assistant AI qui ne suce pas la bite. Pas de langue de bois, des réponses directes, et ça change tout.","date":"2026-02-10T00:00:00.000Z","tags":["openclaw","ai","productivité"],"authors":[],"url":"/blog/openclaw","content":"Je suis tombé sur OpenClaw par hasard. En plein dans ma recherche d'un assistant qui ne ressemble pas à un commercial de SaaS. Et honnête­ment, ça fait du bien. ## Ce qui cloche avec les autres ChatGPT ? C'est un velcro linguistique. Tu poses une question, il te répond en 200 mots alors que 2 suffisent. Claude ? Trop gentil, trop prudent. Ils ont tous peur de dire ce qu'ils pensent vraiment. OpenClaw, c'est différent. Pas de fioritures. Pas de \"Great question!\" ou \"I'd be happy to help!\". Juste la réponse. Si c'est con, il le dit. Si c'est bon, il le dit aussi. Et c'est rafraîchissant. ## Ma configuration Je l'ai installé sur un VPS (Ubarat, 2GB RAM). La config déçoit pas. La CLI est réactive, le modèle par défaut (StepFun) est correct pour le prix (gratuit sur OpenRouter). Et le fait de pouvoir le customiser, ajouter des skills, c'est le pied. Le meilleur ? Le système de **heartbeat** avec Ollama local. Ça me laisse pas de traces sur des APIs payantes pour des tâches de merde. Tout tourne en local, en arrière-plan. ## Les points noirs C'est pas parfait. La doc est un peu dispersée,某些skills sont buggés. Et il faut être à l'aise avec le CLI pour vraiment en profiter. Si tu veux juste un ChatGPT-like avec uneGUI, passe ton chemin. ## Verdict OpenClaw, c'est l'assistant pour ceux qui en ont marre du politiquement correct digital. Ça bosse, ça ferme sa gueule quand il faut, et ça donne des opinions. Dans mon écosystème, c'est devenu indispensable. Si tu veux l'essayer, c'est sur GitHub : openclaw/openclaw. Prévois un après-midi pour le configurer comme il faut."},{"id":"blog:shared-brain-openclaw","title":"J'ai Donné un Cerveau Partagé à Mes Agents OpenClaw. Ils Ont Arrêté d'Être Stupides.","description":"Découvrez l'astuce simple (mais géniale) pour coordonner plusieurs agents OpenClaw : un répertoire partagé avec symlinks. Plus de coordination, moins de doublons, des résultats concrets.","date":"2026-02-10T00:00:00.000Z","tags":["openclaw","productivite","ia"],"authors":[],"url":"/blog/shared-brain-openclaw","content":"Les agents OpenClaw sont puissants. Mais quand tu en lances plusieurs, ils deviennent souvent **sourdents**. Oracle trouve un mot-clé génial, Flash écrit un article sur un sujet complètement différent, Alfred propose une stratégie qui ignore les deux. Trois employés brillants… dans des chambres insonorisées. La solution ? Un **cerveau partagé**. Une Architecture qui a transformé mes 3 agents d'intelligences isolées en une équipe coordonnée. Et le plus fou ? Ça prend 20 minutes à mettre en place. Pas de LangChain, pas de framework complexe. Juste des symlinks et des fichiers Markdown. ## Le Problème : des Agents Sourdents J'avais 3 agents spécialisés : - **Oracle** (SEO) : analyse GSC/GA4, trouve des opportunités mots-clés - **Flash** (Content) : repurposise mes podcasts, écrit en mon style - **Alfred** (Stratégie) : digest matinal, coordination système Chaque agent tournait sur ses crons. Résultat ? Des insights qui restaient dans un rapport, du contenu hors-sujet, des stratégies qui ignoraient les découvertes des autres. ## La Solution : un Répertoire Partagé L'idée est d'un **point de convergence unique** où chaque agent peut lire les outputs des autres et écrire ses propres insights. Tous les agents symlinkent ce dossier dans leur workspace → **même inode, même fichier**. ``` shared-context/ ├── priorities.md ← Priorités courantes (depuis les stand-up voice) ├── agent-outputs/ ← Chaque agent dépose son travail ici │ ├── oracle-seo-YYYY-MM-DD.md │ ├── flash-content-YYYY-MM-DD.md │ └── alfred-digest-YYYY-MM-DD.md ├── feedback/ ← Mes validations/rejets (flux vers TOUS les agents) ├── kpis/ ← Métriques live (trafic, conversions) ├── calendar/ ├── Réunions du jour, contacts pertinents ├── content-calendar/ ← Planifié, publié, gaps └── roundtable/ ← Synthèse cross-agent quotidienne ``` ## Mise en Place Technique (20 minutes) 1. Créer le dossier partagé (sur le host ou un volume Docker) : ```bash sudo mkdir -p /opt/openclaw/shared-context sudo chown -R 1000:1000 /opt/openclaw/shared-context # UID/GID de l'agent ``` 2. Dans chaque config d'agent, ajouter un volume bind : ```json { \"agents\": { \"oracle\": { \"sandbox\": { \"docker\": { \"volumes\": [ \"/opt/openclaw/shared-context:/workspace/shared-context:rw\" ] } } } } } ``` 3. Ou, si workspace sur le host, simplement symlink : ```bash cd /path/to/oracle/workspace ln -s /opt/openclaw/shared-context shared-context cd /path/to/flash/workspace ln -s /opt/openclaw/shared-context shared-context cd /path/to/alfred/workspace ln -s /opt/openclaw/shared-context shared-context ``` Vérification : `ls -i shared-context/priorities.md` doit donner le **même inode** dans les trois workspaces. ## Comment Ça Marche en Pratique ### Exemple concret **7:00 AM - Oracle (SEO) tourne** : - Scrape GSC, trouve un mot-clé \"reddit marketing agency\" avec 17,5% de conversion - Écrit dans `shared-context/agent-outputs/oracle-seo-2025-02-10.md` **7:30 AM - Flash (Content) tourne** : - Lit le fichier d'Oracle - Voir l'opportunité Reddit → crée un contenu \"Comment utiliser Reddit pour générer des leads B2B\" - Publie sur WordPress, enregistre sa sortie dans `agent-outputs/flash-content-...` **8:45 AM - Alfred (Stratégie) tourne** : - Lit les outputs d'Oracle et Flash - Synthétise : \"On capitalise sur Reddit cette semaine, ajoute 2 posts supplémentaires\" - Écrit le digest dans `roundtable/2025-02-10-synthesis.md` - Met à jour `priorities.md` pour le lendemain Tout est lié. Aucune information ne se perd. ## Implémentation OpenClaw Complète Voici un config complète pour 3 agents : ```json { \"agents\": { \"oracle\": { \"workspace\": \"/opt/openclaw/oracle\", \"model\": \"openrouter/stepfun/step-3.5-flash:free\", \"sandbox\": { \"mode\": \"non-main\", \"docker\": { \"image\": \"openclaw-sandbox:latest\", \"volumes\": [ \"/opt/openclaw/shared-context:/workspace/shared-context:rw\" ] } }, \"cron\": \"0 7 * * *\" }, \"flash\": { \"workspace\": \"/opt/openclaw/flash\", \"model\": \"openrouter/stepfun/step-3.5-flash:free\", \"sandbox\": { \"mode\": \"non-main\", \"docker\": { \"volumes\": [ \"/opt/openclaw/shared-context:/workspace/shared-context:rw\" ] } }, \"cron\": \"0 7:30 * * *\" }, \"alfred\": { \"workspace\": \"/opt/openclaw/alfred\", \"model\": \"openrouter/stepfun/step-3.5-turbo\", \"sandbox\": { \"mode\": \"non-main\", \"docker\": { \"volumes\": [ \"/opt/openclaw/shared-context:/workspace/shared-context:rw\" ] } }, \"cron\": \"0 8:45 * * *\" } } } ``` ## Script de Lancement Automatique Pour chaque agent, un petit script qui sync le contexte et lance le cron : ```bash #!/bin/bash # launch-oracle.sh cd /opt/openclaw/oracle # S'assurer que shared-context existe ln -sf /opt/openclaw/shared-context shared-context # Lancer l'agent openclaw agent --message \"Mission quotidienne SEO\" --to oracle ``` Programme avec `cron` ou `openclaw cron add`. ## Avantages Insider - **Transparence totale** : tu peux ouvrir un fichier et voir ce que chaque agent a fait - **Debug facile** : si un agent déraille, tu vois où il a écrit n'importe quoi - **Extensible** : ajouter un 4ème agent = juste un symlink - **Sans réseau** : pas d'API inter-agents, juste du FS (fiable, rapide) - **Humain-in-the-loop** : tu peux écrire dans `feedback/` pour corriger un agent ## Le Vrai Secret : la Boucle de Feedback L'astuce qui a tout changé ? **Les boutons approve/reject**. Chaque output d'agent inclut des boutons d'approbation. Quand tu rejettes quelque chose — \"pas assez haut niveau\" — ce rejet est écrit dans `shared-context/feedback/`. **Tous les agents lisent ces反馈**. En 2 semaines, 16 décisions ont appris à toute l'équipe : - Oracle a arrêté de recommander des keywords \"tool-query\" (je les rejetais) - Flash sait maintenant quels angles de contenu j'approuve - Alfred ajuste ses synthèses en fonction de mes rejets Un seul humain, une décision, 3 agents qui apprennent. **C'est l'effet de levier multiplicatif.** ## Priorités par Voice Note Je fais un stand-up vocal de 90 secondes chaque matin. Alfred (le curator) transcrit la note, met à jour `shared-context/priorities.md`. Au prochain run, chaque agent pondère ses actions selon ces priorités. **Exemple** : je dis \"Cette semaine on se concentre sur Reddit\". Oracle va chercher des keywords Reddit, Flash va créer du contenu Reddit, Alfred va prioriser les tâches en conséquence. **Résultat** : une voix, trois agents réalignés. Pas de Slack, pas de réunion, pas de \"je te loop\". ## Architecture à Grande Échelle ### 10 agents Ajouter un agent = un symlink + mise à jour de ses instructions (\"Lis shared-context/ avant chaque action\"). La structure gère naturellement : - **Priorités cascade** : le nouveau agent lit les mêmes priorités - **Feedback composé** : les rejets enseignent aussi le nouveau - **Signaux croisés** : plus d'agents = plus de patterns détectés - **Un curator** (Alfred) nettoie le dossier pour éviter le bruit On peut ajouter des sous-dossiers : ``` shared-context/ ├── priorities.md ├── agent-outputs/ │ ├── seo/ │ ├── content/ │ ├── sales/ │ ├── recruiting/ │ └── finance/ ├── feedback/ └── kpis/ ``` Toujours des fichiers, toujours des symlinks. Pas de framework. ### 100 agents À plus grande échelle, on ajoute : - **Permissions** : pas tous les agents need accès à tout (sales lit kpis/ et feedback/, pas content-calendar/) - **Write queues** : les agents soumettent à un staging area, le curator valide avant merge (évite le spam) - **Domain namespacing** : `shared-context/seo/`, `shared-context/product/` avec synthèse cross-domaine par agent dédié - **Versioning** : git-backed shared-context pour historique, rollback, audit **L'architecture ne change pas fondamentalement.** C'est toujours \"fichiers partagés, lecteurs spécialisés\". On ajoute juste l'organisation comme une entreprise ajoute des départements. ## Playbook Progressif (4 semaines) **Semaine 1** : Bâtis 1 agent qui fait quelque chose d'utile. Mets-le sur un cron. Valide que ça marche. **Semaine 2** : Bâtis un 2ème agent dans un domaine différent. Crée `shared-context/`, symlink-le. Les deux agents écrivent/ligent dans le même dossier. **Semaine 3** : Ajoute la boucle de feedback. Boutons approve/reject. Les deux agents apprennent de tes décisions. **Semaine 4** : Ajoute un agent de synthèse qui lit tous les outputs et trouve les signaux croisés. Tu viens de créer ce qui nous a pris des mois à discover. **En 4 semaines, tu as ce que j'ai mis des mois à comprendre.** Un cerveau, plusieurs mains. ## Ce Que la Gens Construisent (et C'est Overengineered) La plupart implémentent : - Messaging agent-to-agent (API calls) - Routing layers complexes - Handoff protocols - State machines **À 3 agents :** c'est du sur-engineering. **À 30 agents :** c'est le chaos total. **Ce qui marche vraiment** : la meta-physique d'une entreprise. Notion ne fait pas envoyé d'API calls entre marketing et ventes. Ils lisent le même doc. **Même principe.** ``` WHAT PEOPLE BUILD: WHAT ACTUALLY WORKS: Agent1 ←→ Agent2 Agent1 ↕️ ↕️ ↕️ ╲ ↕️ ↑ Agent3 ←→ Agent4 ┌───┴───┐ ↕️ ↕️ │shared-│ Agent5 ←→ Agent6 │context│ └─┬───┬─┘ N agents = N² connections N agents = N connections Complex. Fragile. Slow. Simple. Robust. Fast. ``` ## Conclusion Le multi-agents ne nécessite pas de framework sophistication. Un répertoire partagé, des symlinks, des fichiers Markdown. C'est tout. La leçon que j'ai apprise : **tes agents n'ont pas besoin de \"parler\" entre eux.** Ils ont besoin de lire la même page. Arrête de construire des silos. Construis un cerveau partagé. --- **Tags :** openclaw, productivite, ia **ReadingTime :** 7 min"},{"id":"blog:step-35-flash-free","title":"Step 3.5 Flash Free sur OpenRouter : Guide Complet pour Utiliser le Modèle Performant Sans Coût","description":"Apprenez à utiliser Step 3.5 Flash Free via OpenRouter. Guide pas-à-pas : inscription, configuration API, exemples Python, limites gratuites. Comparaison avec GPT-4o et Claude.","date":"2026-02-10T00:00:00.000Z","tags":["ia","code","productivite"],"authors":[],"url":"/blog/step-35-flash-free","content":"OpenRouter a rendu accessible gratuitement le modèle **Step 3.5 Flash** de StepFun (anciennement StepFun/Step-1). C'est une opportunité en or pour tester un modèle de qualité sans dépenser un sou. Mais attention : le gratuit a des limites. Voici comment l'utiliser efficacement. ## Présentation de Step 3.5 Flash Step 3.5 Flash est le modèle d'entrée de gamme de StepFun. Il offre : - Contexte de 16k tokens - Qualité correcte pour du chat, du code simple, des tâches générales - Latence très faible (optimisé pour la vitesse) - Compatible OpenAI API (via OpenRouter) **Le plus** : Gratuit sur OpenRouter avec une limite de 1000 requêtes/jour par compte (à vérifier selon la période). ## Configuration étape par étape ### 1. Créer un compte OpenRouter Rendez-vous sur https://openrouter.ai et connectez-vous (Google/GitHub). Une fois connecté, tu as accès à une clé API gratuite. ### 2. Obtenir ta clé API Dans ton dashboard OpenRouter → `Keys` → `Create Key`. Copie-la, elle ressemble à `sk-or-v1-...`. ### 3. Installer le client OpenAI ```bash pip install openai ``` ### 4. Utilisation en Python ```python import os from openai import OpenAI # Configuration client = OpenAI( api_key=os.environ.get(\"OPENROUTER_API_KEY\"), # ta clé base_url=\"https://openrouter.ai/api/v1\" ) # Requête simple response = client.chat.completions.create( model=\"openrouter/stepfun/step-3.5-flash:free\", messages=[ {\"role\": \"system\", \"content\": \"Tu es un assistant expert en Python.\"}, {\"role\": \"user\", \"content\": \"Écris une fonction Python qui calcule la factorielle d'un nombre.\"} ], temperature=0.7, max_tokens=500 ) print(response.choices[0].message.content) ``` ### 5. Gérer les headers (optionnel) Pour identifier ton site/app avec OpenRouter : ```python response = client.chat.completions.create( model=\"openrouter/stepfun/step-3.5-flash:free\", messages=[...], extra_headers={ \"HTTP-Referer\": \"https://ton-site.com\", # optionnel \"X-Title\": \"Mon App\" # optionnel } ) ``` ## Limites gratuites à connaître - **Quota** : 1000 requêtes/jour (sujet à changement) - **Débit** : Rate limit de ~10 req/min en gratuit - **Modèles** : Seulement `step-3.5-flash:free` (pas le turbo payant) - **Priorité** : Les requêtes gratuites passent après les payantes (latence variable) ## Comparaison rapide avec GPT-4o et Claude | Modèle | Prix (entrée) | Qualité reasoning | Code | |--------|---------------|-------------------|------| | GPT-4o | 2.50$/M | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | | Claude 3.5 Sonnet | 3.00$/M | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | | Step 3.5 Flash | Gratuit | ⭐⭐⭐ | ⭐⭐⭐⭐ | Step 3.5 Flash est surprenant pour le code (il a été entraîné là-dessus). Mais pour le reasoning complexe, GPT-4o et Claude restent supérieurs. ## Astuces pour optimiser l'usage gratuit 1. **Batch les requêtes** si tu as plusieurs tâches similaires 2. **Limite le contexte** à ce qui est nécessaire (moins de tokens = plus rapide) 3. **Utilise `max_tokens`** pour éviter les réponses trop longues inutilement 4. **Gère les erreurs 429** avec un retry backoff : ```python import time from openai import RateLimitError try: response = client.chat.completions.create(...) except RateLimitError: time.sleep(5) # retry ``` ## Conclusion Step 3.5 Flash Free est un excellent moyen de tester un modèle performant sans engagement financier. Idéal pour du prototypage, des bots simples, ou comme backup quand les modèles premiums sont indisponibles. Si ton usage devient intensif, passer à un modèle payant (Step 3.5 Turbo ou GPT-4o) sera nécessaire. --- **Tags :** ia, code, productivite **ReadingTime :** 5 min"}]