TL;DR
La puissance d'OpenClaw réside dans son extensibilité via les compétences (skills). Avec plus de 700 compétences construites par la communauté disponibles via ClawHub et la capacité de créer des compétences personnalisées en utilisant des fichiers SKILL.md ou TypeScript, vous pouvez transformer votre assistant OpenClaw en un outil spécialisé pour pratiquement n'importe quelle tâche. Ce guide couvre tout, de l'installation des compétences existantes à la création et à la publication des vôtres.
Introduction
OpenClaw offre déjà de puissantes capacités prêtes à l'emploi, mais son véritable potentiel est débloqué grâce aux compétences (skills). Que vous ayez besoin d'une assistance spécialisée en codage, d'une automatisation DevOps, d'outils de recherche ou de fonctionnalités spécifiques à un secteur, il existe probablement une compétence pour cela – et sinon, vous pouvez en créer une.
Avec plus de 700 compétences développées par la communauté disponibles via ClawHub et la possibilité de créer des compétences personnalisées, OpenClaw devient l'assistant IA dont vous avez besoin.
Dans ce guide complet, nous aborderons :
- Comment trouver et installer des compétences depuis ClawHub
- Gérer et organiser vos compétences
- Créer des compétences personnalisées à partir de zéro
- Publier vos compétences pour la communauté
- Bonnes pratiques de sécurité
Comprendre les compétences OpenClaw
Que sont les compétences (Skills) ?
Les compétences (Skills) sont des extensions modulaires qui ajoutent des capacités spécifiques à OpenClaw. Considérez-les comme des plugins qui confèrent à votre assistant IA de nouvelles aptitudes, de l'envoi de types d'e-mails spécifiques à l'interaction avec des API particulières.
Types de compétences
1. Compétences en langage naturel (SKILL.md)
La forme la plus simple – écrite en Markdown avec un frontmatter YAML. Elles définissent des runbooks opérationnels qu'OpenClaw suit lorsque certaines conditions sont remplies.
2. Compétences TypeScript
Des compétences complètes construites avec TypeScript qui peuvent accéder à des API, exécuter une logique complexe et s'intégrer profondément avec des services externes.
3. Compétences basées sur la CLI
Des compétences qui encapsulent des outils en ligne de commande, permettant à OpenClaw d'utiliser n'importe quel outil disponible sur votre système.
Comment fonctionnent les compétences
Les compétences sont chargées dynamiquement lorsque nécessaire (chargement juste-à-temps), ce qui maintient l'utilisation de la mémoire gérable. Lorsqu'une requête utilisateur correspond aux déclencheurs d'une compétence, OpenClaw exécute les actions définies par la compétence.
Catégories de compétences
ClawHub héberge des compétences dans de nombreuses catégories :
- Agents de codage et IDE (plus de 133 compétences)
- DevOps et Cloud (plus de 212 compétences)
- Recherche (plus de 253 compétences)
- IA et LLMs (plus de 287 compétences)
- Productivité (plus de 150 compétences)
- Données et analyses (plus de 100 compétences)
- Et bien d'autres encore...
Installation de compétences depuis ClawHub
Trouver des compétences
Parcourez le marché ClawHub à l'adresse clawhub.ai ou effectuez une recherche directement via OpenClaw :
# Rechercher des compétences
openclaw skills search "github"
# Lister les compétences populaires
openclaw skills popular
# Parcourir une catégorie
openclaw skills browse devops
Installer une compétence
Une fois que vous avez trouvé une compétence que vous souhaitez, son installation est simple :
# Installer une compétence spécifique
openclaw skills install github-actions
# Installer avec une version spécifique
openclaw skills install github-actions@1.2.0
# Installer depuis un éditeur spécifique
openclaw skills install @username/skill-name
Installer toutes les compétences recommandées
# Installer les compétences de démarrage populaires
openclaw skills install-recommended
Vérifier l'installation
# Lister toutes les compétences installées
openclaw skills list
# Vérifier les détails de la compétence
openclaw skills info github-actions
Gérer vos compétences installées
Activer et désactiver des compétences
# Désactiver une compétence (la maintient installée mais inutilisée)
openclaw skills disable github-actions
# Activer une compétence désactivée
openclaw skills enable github-actions
Mettre à jour des compétences
# Mettre à jour une compétence spécifique
openclaw skills update github-actions
# Mettre à jour toutes les compétences
openclaw skills update-all
Supprimer des compétences
# Désinstaller une compétence
openclaw skills uninstall github-actions
Configuration des compétences
De nombreuses compétences prennent en charge la configuration personnalisée :
# Configurer une compétence
openclaw skills config github-actions --set token=your-github-token
Ou modifiez directement le fichier de configuration de la compétence :
# ~/.openclaw/skills/github-actions/config.yaml
token: your-github-token
default-branch: main
auto-merge: false
Créer des compétences personnalisées
Quand créer des compétences personnalisées
Créez une compétence personnalisée lorsque vous avez besoin de :
- Intégrations API spécifiques non couvertes par les compétences existantes
- Flux de travail d'automatisation personnalisés
- Fonctionnalités spécifiques à un secteur
- Outils internes propriétaires
Structure d'une compétence
Une compétence de base se compose de :
my-custom-skill/
├── SKILL.md # Définition de la compétence (pour les compétences en langage naturel)
├── config.yaml # Schéma de configuration
└── icon.svg # Icône de la compétence (facultatif)
Pour les compétences TypeScript :
my-typescript-skill/
├── src/
│ └── index.ts # Code principal de la compétence
├── package.json
├── tsconfig.json
├── config.schema.json
└── skill.yaml # Manifeste de la compétence
Création de compétences SKILL.md
Structure SKILL.md de base
Voici un fichier SKILL.md minimal :
---
name: weather-alert
description: Get weather alerts for your location
triggers:
- "weather"
- "weather alert"
- "forecast"
requires:
- location
actions:
- name: get_weather
api: https://api.weather.com/v3
params:
location: "{location}"
---
# Compétence d'alerte météo
Cette compétence fournit des alertes et des prévisions météo pour votre emplacement.
## Configuration
Définissez votre emplacement dans la configuration de la compétence :
- city: Nom de votre ville
- units: métrique ou impériale
Exemple complet : Compétence de résumé d'e-mail
---
name: daily-email-summary
description: Receive a daily summary of your important emails
triggers:
- "email summary"
- "daily emails"
- "summarize my emails"
requires:
- email_access
- api_key
actions:
- name: fetch_emails
method: gmail.users.messages.list
params:
q: "is:unread"
maxResults: 10
- name: summarize
model: gpt-4
prompt: "Summarize these emails in bullet points"
---
# Compétence de résumé d'e-mail quotidien
Restez informé de votre boîte de réception grâce à des résumés quotidiens automatisés.
## Fonctionnalités
- Récupère les e-mails non lus de Gmail
- Utilise l'IA pour résumer les points clés
- Envoie le résumé à votre canal préféré
## Configuration
1. Configurez l'accès à l'API Gmail dans vos paramètres OpenClaw
2. Définissez votre heure de résumé préférée
3. Choisissez votre canal de livraison (Telegram, Discord, etc.)
## Exemple d'utilisation
Vous : Envoyez-moi mon résumé d'e-mails
OpenClaw : Voici un résumé de vos 8 e-mails non lus :
- Demande de réunion de John concernant la planification du T3
- Confirmation de commande d'Amazon
- Newsletter de TechCrunch...
### Déclencheurs avancés
Utilisez des déclencheurs plus sophistiqués :
```markdown
---
name: smart-reminder
triggers:
# Phrases exactes
- "remind me to {action}"
# Modèles
- "remind me in {duration}"
# Contextuels
context:
- channel: work
patterns: ["meeting", "deadline", "project"]
---
# Compétence de rappel intelligent
Gère toutes les demandes de rappel avec une analyse intelligente.
Création de compétences TypeScript
Pour des intégrations plus complexes, les compétences TypeScript offrent un contrôle total.
Configuration de votre environnement de développement
# Créer un nouveau projet de compétence
openclaw skills create my-awesome-skill
# Naviguer vers le répertoire de la compétence
cd my-awesome-skill
# Installer les dépendances
npm install
# Démarrer le serveur de développement
npm run dev
Structure d'une compétence TypeScript
// src/index.ts
import { Skill, SkillContext, SkillResult } from '@openclaw/skill-sdk';
export default class MyAwesomeSkill implements Skill {
name = 'my-awesome-skill';
description = 'A skill that does something awesome';
// Appelé lorsque la compétence est chargée
async onLoad(context: SkillContext): Promise<void> {
console.log('Skill loaded!');
}
// Appelé lorsque la compétence correspond à un déclencheur
async execute(context: SkillContext): Promise<SkillResult> {
const { userMessage, config } = context;
// Votre logique de compétence ici
const result = await this.doSomethingAwesome(userMessage.content);
return {
message: result,
actions: []
};
}
private async doSomethingAwesome(input: string): Promise<string> {
// Implémentez votre logique de compétence
return `You said: ${input}`;
}
}
Manifeste de compétence (skill.yaml)
name: my-awesome-skill
version: 1.0.0
description: A skill that does something awesome
author:
name: Your Name
email: you@example.com
triggers:
- pattern: "do something awesome"
type: exact
config:
apiKey:
type: string
required: true
description: Clé API pour le service
permissions:
- network
- filesystem
runtime: nodejs18
Schéma de configuration (config.schema.json)
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"properties": {
"apiKey": {
"type": "string",
"description": "Clé API pour le service"
},
"enabled": {
"type": "boolean",
"default": true
}
},
"required": ["apiKey"]
}
Construction et test
# Construire la compétence
npm run build
# Exécuter les tests
npm test
# Packager pour la distribution
npm run package
Exemple : Compétence d'intégration GitHub
Voici un exemple plus complet montrant l'intégration d'API :
import { Skill, SkillContext, SkillResult } from '@openclaw/skill-sdk';
import axios from 'axios';
export default class GitHubSkill implements Skill {
name = 'github';
description = 'Interact with GitHub repositories';
async execute(context: SkillContext): Promise<SkillResult> {
const { userMessage, config } = context;
const message = userMessage.content.toLowerCase();
if (message.includes('list repos')) {
return this.listRepositories(config);
} else if (message.includes('create issue')) {
return this.createIssue(context);
}
return {
message: 'I can help with listing repos, creating issues, and more.',
actions: []
};
}
private async listRepositories(config: any): Promise<SkillResult> {
const response = await axios.get('https://api.github.com/user/repos', {
headers: {
Authorization: `token ${config.githubToken}`
}
});
const repos = response.data.slice(0, 5).map((r: any) => r.name).join('\n');
return {
message: `Your recent repositories:\n${repos}`,
actions: []
};
}
private async createIssue(context: SkillContext): Promise<SkillResult> {
// Extraire les détails du problème du message utilisateur
return {
message: 'I need more details to create an issue. Please specify the repository, title, and description.',
actions: [
{
type: 'request_input',
fields: ['repo', 'title', 'description']
}
]
};
}
}
Publication de compétences sur ClawHub
Préparer votre compétence pour la publication
- Tester minutieusement : Assurez-vous que votre compétence fonctionne dans divers scénarios
- Ajouter de la documentation : Un fichier SKILL.md clair avec des exemples
- Définir les autorisations appropriées : Ne demander que l'accès nécessaire
- Ajouter une icône : Créer une icône SVG simple
- Gestion des versions : Utiliser le versionnement sémantique (1.0.0, 1.1.0, etc.)
Processus de publication
# Se connecter à ClawHub
openclaw skills login
# Vérifier que votre compétence est prête
openclaw skills validate
# Publier votre compétence
openclaw skills publish
Exigences de publication
- Manifeste de compétence valide (skill.yaml)
- Requis : nom, version, description, auteur
- Au moins un déclencheur défini
- Analyse virusTotal (effectuée automatiquement)
- Vérification d'identité
Gestion des versions
# Incrémenter la version
openclaw skills version patch # 1.0.0 -> 1.0.1
openclaw skills version minor # 1.0.0 -> 1.1.0
openclaw skills version major # 1.0.0 -> 2.0.0
# Publier une nouvelle version
openclaw skills publish
Bonnes pratiques de sécurité
Installation de compétences tierces
Note de sécurité importante : L'incident ClawHavoc début 2026 a révélé des compétences malveillantes sur ClawHub. Suivez toujours ces précautions :
- Vérifier les éditeurs : Installez uniquement les compétences provenant d'éditeurs de confiance et vérifiés
- Examiner les autorisations : Vérifiez quelles autorisations la compétence demande
- Auditer le code : Pour les compétences TypeScript, examinez le code source
- Commencer isolé : Testez les compétences dans un environnement séparé en premier
# Vérifier les autorisations de la compétence avant l'installation
openclaw skills inspect github-actions
Créer des compétences sécurisées
Lorsque vous construisez vos propres compétences :
# Spécifiez toujours les autorisations minimales requises
permissions:
- network # Seulement si nécessaire
- filesystem # Seulement si nécessaire
# Ne jamais coder en dur les secrets
# MAUVAIS :
const apiKey = "sk-1234567890";
# BON :
const apiKey = process.env.API_KEY;
Configuration de sécurité recommandée
# ~/.openclaw/security.yaml
skill_security:
require_virustotal: true
require_verified_publisher: false # Définir sur true pour la production
audit_permissions: true
sandbox_mode: true
Développement de compétences avancées
Dépendances de compétences
Les compétences peuvent dépendre d'autres compétences :
# skill.yaml
dependencies:
- name: github
version: ">=1.0.0"
- name: slack
version: ">=2.0.0"
Compétences basées sur les événements
Réagir aux événements OpenClaw :
export default class EventSkill implements Skill {
async onMessage(context: SkillContext): Promise<SkillResult> {
// Appelé à chaque message
}
async onTimer(context: SkillContext): Promise<SkillResult> {
// Appelé selon un calendrier
}
async onStartup(context: SkillContext): Promise<void> {
// Appelé au démarrage d'OpenClaw
}
async onShutdown(context: SkillContext): Promise<void> {
// Appelé à l'arrêt d'OpenClaw
}
}
Utilisation de MCP avec les compétences
Combinez les compétences avec les serveurs MCP :
# skill.yaml
mcpServers:
- name: filesystem
command: npx @modelcontextprotocol/server-filesystem ./data
- name: github
command: npx @modelcontextprotocol/server-github
Dépannage
La compétence ne se charge pas
# Vérifier le statut de la compétence
openclaw skills status my-skill
# Afficher les logs de la compétence
openclaw logs --skill my-skill
Causes courantes :
- Dépendances manquantes
- Configuration invalide
- Problèmes d'autorisation
Le déclencheur ne correspond pas
# Tester la correspondance du déclencheur
openclaw skills test-trigger "your trigger phrase"
Problèmes de performance
# Vérifier l'utilisation des ressources par la compétence
openclaw skills monitor
# Désactiver temporairement les compétences gourmandes en ressources
openclaw skills disable heavy-skill
Conclusion
Le système de compétences d'OpenClaw le transforme d'un simple assistant IA en une plateforme puissante et extensible. Que vous installiez des compétences créées par la communauté depuis ClawHub ou que vous développiez vos propres solutions personnalisées, les possibilités sont pratiquement illimitées.
L'écosystème OpenClaw se renforce avec chaque nouvelle compétence. Commencez à construire dès aujourd'hui !
