Comment les compétences anthropiques modifient l'outillage des agents - et comment créer une compétence personnalisée pour Milvus afin de lancer rapidement RAG

L'utilisation des outils joue un rôle important dans le fonctionnement d'un agent. L'agent doit choisir le bon outil, décider quand l'appeler et formater les entrées correctement. Sur le papier, cela semble simple, mais une fois que l'on commence à construire des systèmes réels, on trouve beaucoup de cas limites et de modes de défaillance.

De nombreuses équipes utilisent des définitions d'outils de type MCP pour organiser tout cela, mais le MCP a quelques défauts. Le modèle doit raisonner sur tous les outils à la fois, et il n'y a pas beaucoup de structure pour guider ses décisions. De plus, chaque définition d'outil doit se trouver dans la fenêtre de contexte. Certaines d'entre elles sont volumineuses - le MCP de GitHub représente environ 26k tokens - ce qui mange le contexte avant même que l'agent ne commence à faire du vrai travail.

Anthropic a introduit les compétences pour améliorer cette situation. Les compétences sont plus petites, plus ciblées et plus faciles à charger à la demande. Au lieu de tout déverser dans le contexte, vous empaquetez la logique du domaine, les workflows ou les scripts dans des unités compactes que l'agent peut extraire seulement quand il en a besoin.

Dans ce billet, j'expliquerai comment fonctionnent les compétences anthropiques et je décrirai ensuite la construction d'une compétence simple dans Claude Code qui transforme le langage naturel en une base de connaissances soutenue par Milvus- une configuration rapide pour RAG sans câblage supplémentaire.

Que sont les compétences anthropiques ?

Lescompétences anthropiques (ou compétences d'agent) sont des dossiers qui regroupent les instructions, les scripts et les fichiers de référence dont un agent a besoin pour effectuer une tâche spécifique. Il s'agit de petits ensembles de capacités autonomes. Une compétence peut définir la manière de générer un rapport, d'effectuer une analyse ou de suivre un flux de travail particulier ou un ensemble de règles.

L'idée clé est que les compétences sont modulaires et peuvent être chargées à la demande. Au lieu d'insérer d'énormes définitions d'outils dans la fenêtre contextuelle, l'agent n'y fait entrer que les compétences dont il a besoin. Cela permet de limiter l'utilisation du contexte tout en donnant au modèle des indications claires sur les outils existants, le moment où il faut les appeler et la manière d'exécuter chaque étape.

Le format est intentionnellement simple, et pour cette raison, il est déjà supporté ou facilement adapté à travers un grand nombre d'outils de développement - Claude Code, Cursor, VS Code extensions, intégrations GitHub, configurations de style Codex, et ainsi de suite.

Une compétence suit une structure de dossiers cohérente :

skill-name/
├── SKILL.md       # Required: Skill instructions and metadata
├── scripts/         # Optional: helper scripts
├── templates/       # Optional: document templates
└── resources/       # Optional: reference materials

1. SKILL.md (Core File)

Il s'agit du guide d'exécution pour l'agent - le document qui indique à l'agent exactement comment la tâche doit être exécutée. Il définit les métadonnées de la compétence (telles que le nom, la description et les mots clés du déclencheur), le flux d'exécution et les paramètres par défaut. Dans ce fichier, vous devez décrire clairement

• le moment où la compétence doit être exécutée : Par exemple, déclencher la compétence lorsque l'entrée de l'utilisateur comprend une phrase comme "traiter des fichiers CSV avec Python".

• Comment la tâche doit être exécutée : Présentez les étapes d'exécution dans l'ordre, par exemple : interpréter la demande de l'utilisateur → appeler les scripts de prétraitement du répertoire scripts/ → générer le code requis → formater la sortie à l'aide des modèles de templates/.

• Règles et contraintes : Spécifier des détails tels que les conventions de codage, les formats de sortie et la manière dont les erreurs doivent être gérées.

2. scripts/ (Scripts d'exécution)

Ce répertoire contient des scripts pré-écrits dans des langages tels que Python, Shell ou Node.js. L'agent peut appeler ces scripts directement, au lieu de générer le même code à plusieurs reprises au moment de l'exécution. Les exemples typiques sont create_collection.py et check_env.py.

3. templates/ (modèles de documents)

Fichiers modèles réutilisables que l'agent peut utiliser pour générer un contenu personnalisé. Les exemples les plus courants sont les modèles de rapport ou les modèles de configuration.

4. resources/ (Documents de référence)

Documents de référence que l'agent peut consulter pendant l'exécution, tels que la documentation de l'API, les spécifications techniques ou les guides de bonnes pratiques.

Dans l'ensemble, cette structure reflète la manière dont le travail est transmis à un nouveau membre de l'équipe : SKILL.md explique le travail, scripts/ fournit des outils prêts à l'emploi, templates/ définit les formats standard et resources/ fournit des informations générales. Avec tout cela en place, l'agent peut exécuter la tâche de manière fiable et avec un minimum d'approximation.

Tutoriel pratique : Création d'une compétence personnalisée pour un système RAG alimenté par Milvus

Dans cette section, nous allons construire une compétence personnalisée capable de mettre en place une collection Milvus et d'assembler un pipeline RAG complet à partir d'instructions simples en langage naturel. L'objectif est d'éviter tout le travail de configuration habituel - pas de conception manuelle de schéma, pas de configuration d'index, pas de code passe-partout. Vous dites à l'agent ce que vous voulez, et Skill s'occupe des éléments Milvus pour vous.

Présentation de la conception

Conditions préalables

Composant	Exigences
CLI	claude-code
Modèles	GLM 4.7, OpenAI
Conteneur	Docker
Milvus	2.6.8
Plate-forme de configuration de modèles	CC-Switch
Gestionnaire de paquets	npm
Langage de développement	Python

Étape 1 : Configuration de l'environnement

Installer CC-Switch claude-code

npm install -g @anthropic-ai/claude-code

Installer CC-Switch

Note : CC-Switch est un outil de changement de modèle qui permet de passer facilement d'une API de modèle à l'autre lors de l'exécution locale de modèles d'IA.

Référentiel du projet : https://github.com/farion1231/cc-switch

Sélectionnez Claude et ajoutez une clé API

Vérifier l'état actuel

Déployer et démarrer Milvus-Standalone

# Download docker-compose.yml
wget https://github.com/milvus-io/milvus/releases/download/v2.6.8/milvus-standalone-docker-compose.yml -O docker-compose.yml
# Start Milvus (check port mapping: 19530:19530)
docker-compose up -d
# Verify that the services are running
docker ps | grep milvus
# You should see three containers: milvus-standalone, milvus-etcd, milvus-minio

Configurer la clé API OpenAI

# Add this to ~/.bashrc or ~/.zshrc
OPENAI_API_KEY=your_openai_api_key_here

Étape 2 : Créer la compétence personnalisée pour Milvus

Créer la structure du répertoire

cd ~/.claude/skills/
mkdir -p milvus-skills/example milvus-skills/scripts

Initialiser SKILL.md

Note : SKILL.md sert de guide d'exécution de l'agent. Il définit ce que la compétence fait et comment elle doit être déclenchée.

name: milvus-collection-builder
description: Create Milvus collections using natural language, supporting both RAG and text search scenarios

Écrire les scripts de base

Type de script	Nom du fichier	Objectif
Vérification de l'environnement	check_env.py	Vérifie la version de Python, les dépendances nécessaires et la connexion à Milvus.
Analyse de l'intention	intent_parser.py	Convertit des requêtes telles que "construire une base de données RAG" en une intention structurée telle que scene=rag
Création d'une collection	milvus_builder.py	Le constructeur de base qui génère le schéma de la collection et la configuration de l'index.
Ingestion de données	insert_milvus_data.py	Charge les documents, les regroupe, génère des embeddings et écrit les données dans Milvus.
Exemple 1	basic_text_search.py	Démontre comment créer un système de recherche de documents.
Exemple 2	rag_knowledge_base.py	Démontre comment construire une base de connaissances RAG complète.

Ces scripts montrent comment transformer une compétence centrée sur Milvus en quelque chose de pratique : un système de recherche de documents fonctionnel et une configuration de questions-réponses intelligentes (RAG).

Étape 3 : Activer la compétence et effectuer un test

Décrire la demande en langage naturel

"I want to build an RAG system."

Création d'un système RAG

Insérer un échantillon de données

Exécuter une requête

Conclusion

Dans ce tutoriel, nous avons construit un système RAG alimenté par Milvus à l'aide d'une compétence personnalisée. L'objectif n'était pas seulement de montrer une autre façon d'appeler Milvus, mais aussi de montrer comment les compétences peuvent transformer ce qui est normalement une configuration lourde en plusieurs étapes en quelque chose que vous pouvez réutiliser et sur lequel vous pouvez itérer. Au lieu de définir manuellement des schémas, d'ajuster des index ou d'assembler du code de flux de travail, la compétence prend en charge la plupart des tâches administratives afin que vous puissiez vous concentrer sur les parties de RAG qui comptent réellement.

Ce n'est qu'un début. Un pipeline RAG complet comporte de nombreux éléments mobiles : prétraitement, regroupement, paramètres de recherche hybride, reclassement, évaluation, etc. Tous ces éléments peuvent être regroupés dans des compétences distinctes et composés en fonction de votre cas d'utilisation. Si votre équipe dispose de normes internes pour les dimensions des vecteurs, les paramètres d'index, les modèles d'invite ou la logique de recherche, les compétences sont un moyen propre d'encoder ces connaissances et de les rendre reproductibles.

Pour les nouveaux développeurs, cela abaisse la barrière d'entrée - il n'est pas nécessaire d'apprendre tous les détails de Milvus avant de faire fonctionner quelque chose. Pour les équipes expérimentées, cela permet de réduire les configurations répétées et de maintenir la cohérence des projets entre les environnements. Les compétences ne remplaceront pas une conception réfléchie du système, mais elles éliminent de nombreuses frictions inutiles.

L'implémentation complète est disponible dans le dépôt open-source, et vous pouvez explorer d'autres exemples construits par la communauté sur la place de marché des compétences.

Restez à l'écoute !

Nous travaillons également à l'introduction de compétences officielles Milvus et Zilliz Cloud qui couvrent les modèles RAG courants et les meilleures pratiques de production. Si vous avez des idées ou des flux de travail spécifiques que vous souhaitez voir pris en charge, rejoignez notre canal Slack et discutez avec nos ingénieurs. Et si vous souhaitez obtenir des conseils pour votre propre installation, vous pouvez toujours réserver une session Milvus Office Hours.