avril 2026

CrewAI un orchestrateur d’Agents IA en python

Dans ce tutoriel je vais vous montrer comment faire vos premiers pas avec les agents IA

Savez vous ce qu’est un agent IA?

Tout le monde parle d’agent IA mais je pense que beaucoup ne savent pas ce qu’est vraiment un agent IA.

Un agent IA est un programme propulsé par un LLM (Claude, chatGPT etc) et qui a reçu un prompt bien spécifique pour exécuter une tâche précise. Il est capable d’agir sur des informations, chercher des information via Google, manipuler des fichiers, à la différence de l’IA que vous connaissez qui ne fait que répondre à votre question.

Un agent IA est capable de communiquer avec d’autres agents IA au sein d’une équipe, il est hautement spécialisé, il peut tourner en mode séquentiel ou parallèle, et à la fin livrer un travail d’équipe dirigé par un manager.

Qu’est ce que le framework CrewAI ?

C’est une librairie Python, qui va s’occuper d’orchestrer les agents IA, les faire communiquer entre eux. La version actuelle au moment où j’écris cet article est la version 1.14 (méfiez vous des tuto périmés que vous donne les LLM et mêm le cours officiel de CrewAI !). Le site officiel de CrewAI est ici.

Pourquoi utiliser des agent IA?

L’utilisation d’agent IA spécialisé va rendre un meilleur travail qu’un LMM tout seul.

Exemple basique avec l’analyse

Pour utiliser CrewAI, il vous faut 3 chose : les agents, les tâches (Task) et le Crew. On va aussi affecter un LLM à chaque agent, et on peut affecter un LLM différent au manager des agents.

Mise en place de l’environnement virtuel et installation des paquets

Pour chaque projet il est important de mettre en place un environnement virtuel pour isoler les librairies de l’installation globale de python. Ainsi allez dans un endroit qui vous plait pour votre projet.

# dans un répertoire dédié à votre projet faites la création de l'environnement virtuel
#creation de l'environnement virtuel
python -m venv venv

#Puis dans votre environnement virtuel
python -m pip install crewai crewai-tools python-dotenv

un fichier .env.example

Usage du script

pour faire simple une action est passée par défaut
python run.py

Mais vous pouvez passez en argument une autre action
le script prend jusqu'à 4 arguments.
python run.py --stock TSLA --risk High --strategy "Swing Trading"

Description de ce qui se passe quand vous lancez le script

1. Le Manager LLM lit les tâches et décide qui fait quoi et dans quel ordre.

2. Les agents s’exécutent en séquence, chacun produisant un « thought process » visible :

  • Thought: → l’agent réfléchit à ce qu’il doit faire
  • Action: → il décide d’utiliser un outil (scraping, recherche…)
  • Action Input: → les paramètres qu’il passe à l’outil
  • Observation: → le résultat retourné par l’outil
  • Final Answer: → sa conclusion pour cette tâche

3. Le Manager valide chaque résultat avant de passer à la tâche suivante.

4. Les 4 agents travaillent dans l’ordre :

  • Data Analyst → analyse le marché AAPL
  • Trading Strategy Developer → propose des stratégies
  • Trade Advisor → planifie l’exécution
  • Risk Advisor → évalue les risques et produit le rapport final

Tout cet output verbose c’est le « raisonnement » des agents rendu visible — c’est ce qui rend crewAI intéressant à observer. Tu peux mettre verbose=False sur les agents et le crew pour n’avoir que le résultat final.

Comment crewAI scripte un agent

data_analyst_agent = Agent(
    role="Data Analyst",
    goal=(
        "Monitor and analyze market data in real-time "
        "to identify trends and predict market movements."
    ),
    backstory=(
        "Specializing in financial markets, this agent "
        "uses statistical modeling and machine learning "
        "to provide crucial insights. With a knack for data, "
        "the Data Analyst Agent is the cornerstone for "
        "informing trading decisions."
    ),
    verbose=True,
    allow_delegation=True,
    tools=tools,
    llm=llm,
)

Le backstory est le texte qui décrite (prompte) l’agent. Le paramètre llm indique le LLM à utiliser. allow_delegation permet à un agent de confier sa mission à un autre agent dès lors qu’il pense qu’il n’est pas le mieux dans une tâche. Si vous débutez mettez à False. tools quant à lui est une liste d’outils (qu’il faut déclarer) pour que l’agent puisse le solliciter pour faire autre chose que de répondre comme un LMM basiquement. Dans la section 5 on a tools = [scrape_tool, search_tool]. Pour Serper il vous faudra aller sur leur site créer un compte et obtenir une clé API. Il vous faut aussi une clé API openAI.

Voir la liste des outils potentiels

python -c "import crewai_tools; print(dir(crewai_tools))"

# va vous donner une grande liste d'outils
['AIMindTool', 'ApifyActorsTool', 'ArxivPaperTool', 'BedrockInvokeAgentTool', 'BedrockKBRetrieverTool', 'BraveImageSearchTool', 'BraveLLMContextTool', 'BraveLocalPOIsDescriptionTool', 'BraveLocalPOIsTool', 'BraveNewsSearchTool', 'BraveSearchTool', 'BraveVideoSearchTool', 'BraveWebSearchTool', 'BrightDataDatasetTool', 'BrightDataSearchTool', 'BrightDataWebUnlockerTool', 'BrowserbaseLoadTool', 'CSVSearchTool', 'CodeDocsSearchTool', 'ComposioTool', 'ContextualAICreateAgentTool', 'ContextualAIParseTool', 'ContextualAIQueryTool', 'ContextualAIRerankTool', 'CouchbaseFTSVectorSearchTool', 'CrewaiPlatformTools', 'DOCXSearchTool', 'DallETool', 'DatabricksQueryTool', 'DaytonaExecTool', 'DaytonaFileTool', 'DaytonaPythonTool', 'DirectoryReadTool', 'DirectorySearchTool', 'E2BExecTool', 'E2BFileTool', 'E2BPythonTool', 'EXASearchTool', 'EnterpriseActionTool', 'FileCompressorTool', 'FileReadTool', 'FileWriterTool', 'FirecrawlCrawlWebsiteTool', 'FirecrawlScrapeWebsiteTool', 'FirecrawlSearchTool', 'GenerateCrewaiAutomationTool', 'GithubSearchTool', 'HyperbrowserLoadTool', 'InvokeCrewAIAutomationTool', 'JSONSearchTool', 'JinaScrapeWebsiteTool', 'LinkupSearchTool', 'LlamaIndexTool', 'MCPServerAdapter', 'MDXSearchTool', 'MergeAgentHandlerTool', 'MongoDBVectorSearchConfig', 'MongoDBVectorSearchTool', 'MultiOnTool', 'MySQLSearchTool', 'NL2SQLTool', 'OCRTool', 'OxylabsAmazonProductScraperTool', 'OxylabsAmazonSearchScraperTool', 'OxylabsGoogleSearchScraperTool', 'OxylabsUniversalScraperTool', 'PDFSearchTool', 'ParallelSearchTool', 'PatronusEvalTool', 'PatronusLocalEvaluatorTool', 'PatronusPredefinedCriteriaEvalTool', 'QdrantVectorSearchTool', 'RagTool', 'S3ReaderTool', 'S3WriterTool', 'ScrapeElementFromWebsiteTool', 'ScrapeWebsiteTool', 'ScrapegraphScrapeTool', 'ScrapegraphScrapeToolSchema', 'ScrapflyScrapeWebsiteTool', 'SeleniumScrapingTool', 'SerpApiGoogleSearchTool', 'SerpApiGoogleShoppingTool', 'SerperDevTool', 'SerperScrapeWebsiteTool', 'SerplyJobSearchTool', 'SerplyNewsSearchTool', 'SerplyScholarSearchTool', 'SerplyWebSearchTool', 'SerplyWebpageToMarkdownTool', 'SingleStoreSearchTool', 'SnowflakeConfig', 'SnowflakeSearchTool', 'SpiderTool', 'StagehandTool', 'TXTSearchTool', 'TavilyExtractorTool', 'TavilySearchTool', 'VisionTool', 'WeaviateVectorSearchTool', 'WebsiteSearchTool', 'XMLSearchTool', 'YoutubeChannelSearchTool', 'YoutubeVideoSearchTool', 'ZapierActionTool', 'ZapierActionTools', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', 'adapters', 'aws', 'rag', 'security', 'tools']

verbose permet d’afficher dans le terminal ce qui se passe. le goal répond à « pourquoi tu existes dans cette équipe », la tâche répond à « qu’est-ce que tu fais maintenant », alors que le backstory décrit l’agent.

Les Task

data_analysis_task = Task(
    description=(
        "Continuously monitor and analyze market data for "
        "the selected stock ({stock_selection}). "
        "Use statistical modeling and machine learning to "
        "identify trends and predict market movements."
    ),
    expected_output=(
        "Insights and alerts about significant market "
        "opportunities or threats for {stock_selection}."
    ),
    agent=data_analyst_agent,
)

expected_out est une instruction envoyée au LLM. Il y a différents niveau de contrainte, détaillées ci-dessous :

Niveau 1 : il faut être très précis

#  vague
expected_output="Un rapport d'analyse."

#  précis
expected_output=(
    "Un rapport structuré avec exactement ces sections : "
    "1) Tendances actuelles, 2) Opportunités, 3) Risques, "
    "4) Recommandation finale en une phrase. "
    "Format markdown, maximum 500 mots."
)

Niveau 2 : ajouter un guardrail (validation automatique)

task = Task(
    description="Analyse le stock {stock_selection}.",
    expected_output="Un rapport avec tendances, opportunités et risques.",
    agent=analyst,
    guardrail=(
        "Le rapport doit contenir les mots 'tendances', 'opportunités' "
        "et 'risques'. Il doit faire au moins 200 mots."
    )
)

Niveau 3 : forcer un formation JSON avec Pydantic (le plus strict)

from pydantic import BaseModel
from typing import List

class AnalysisReport(BaseModel):
    tendances: List[str]
    opportunites: List[str]
    risques: List[str]
    recommandation: str

task = Task(
    description="Analyse le stock {stock_selection}.",
    expected_output="Un rapport d'analyse structuré.",
    agent=analyst,
    output_pydantic=AnalysisReport,  # force le format
)

# Accès au résultat structuré après kickoff :
result = crew.kickoff(inputs={"stock_selection": "AAPL"})
print(result.pydantic.recommandation)
print(result.pydantic.risques)

Voici le code source intégral

"""
run.py — Analyse financière multi-agents avec crewAI v1.x
----------------------------------------------------------
Compatible : crewai >= 1.0 (testé sur 1.14)

Installation :
    pip install crewai crewai-tools python-dotenv

Fichier .env requis :
    OPENAI_API_KEY=sk-...
    SERPER_API_KEY=...     (optionnel, pour la recherche web)

Usage :
    python run.py
    python run.py --stock TSLA --risk High --strategy "Swing Trading"
"""

import os
import argparse
from dotenv import load_dotenv

# ── 1. Variables d'environnement ─────────────────────────────────────────────
load_dotenv()

if not os.getenv("OPENAI_API_KEY"):
    raise EnvironmentError(
        "OPENAI_API_KEY manquant !\n"
        "Crée un fichier .env avec : OPENAI_API_KEY=sk-..."
    )

# ── 2. Arguments CLI ──────────────────────────────────────────────────────────
parser = argparse.ArgumentParser(description="Analyse financière multi-agents crewAI v1.x")
parser.add_argument("--stock",    default="AAPL",        help="Ticker boursier (défaut: AAPL)")
parser.add_argument("--capital",  default="100000",      help="Capital initial (défaut: 100000)")
parser.add_argument("--risk",     default="Medium",      choices=["Low", "Medium", "High"])
parser.add_argument("--strategy", default="Day Trading", help="Stratégie de trading")
args = parser.parse_args()

# ── 3. Imports crewAI v1.x ───────────────────────────────────────────────────
# CHANGEMENT v1.x : on n'importe plus depuis langchain_openai
# crewAI gère le LLM en interne via LiteLLM
from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import ScrapeWebsiteTool, SerperDevTool




# ── 4. LLM ───────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x : on utilise crewai.LLM au lieu de langchain_openai.ChatOpenAI
# Le préfixe "openai/" est la convention LiteLLM
llm = LLM(
    model="openai/gpt-4o-mini",   # ou "openai/gpt-4o", "openai/gpt-3.5-turbo"
    temperature=0.7,
    api_key=os.getenv("OPENAI_API_KEY"),
)

# LLM dédié au manager (peut être le même ou un modèle plus puissant)
manager_llm = LLM(
    model="openai/gpt-4o-mini",
    temperature=0.7,
    api_key=os.getenv("OPENAI_API_KEY"),
)

# ── 5. Outils ────────────────────────────────────────────────────────────────
# SerperDevTool nécessite SERPER_API_KEY dans .env
# Sans clé, les agents raisonnent sur leurs connaissances sans chercher sur le web
search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()
tools = [scrape_tool, search_tool]



# ── 6. Agents ────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x : on passe `llm=` explicitement à chaque agent

data_analyst_agent = Agent(
    role="Data Analyst",
    goal=(
        "Monitor and analyze market data in real-time "
        "to identify trends and predict market movements."
    ),
    backstory=(
        "Specializing in financial markets, this agent "
        "uses statistical modeling and machine learning "
        "to provide crucial insights. With a knack for data, "
        "the Data Analyst Agent is the cornerstone for "
        "informing trading decisions."
    ),
    verbose=True,
    allow_delegation=True,
    tools=tools,
    llm=llm,
)

trading_strategy_agent = Agent(
    role="Trading Strategy Developer",
    goal=(
        "Develop and test various trading strategies based "
        "on insights from the Data Analyst Agent."
    ),
    backstory=(
        "Equipped with a deep understanding of financial "
        "markets and quantitative analysis, this agent "
        "devises and refines trading strategies. It evaluates "
        "the performance of different approaches to determine "
        "the most profitable and risk-averse options."
    ),
    verbose=True,
    allow_delegation=True,
    tools=tools,
    llm=llm,
)

execution_agent = Agent(
    role="Trade Advisor",
    goal=(
        "Suggest optimal trade execution strategies "
        "based on approved trading strategies."
    ),
    backstory=(
        "This agent specializes in analyzing the timing, price, "
        "and logistical details of potential trades. By evaluating "
        "these factors, it provides well-founded suggestions for "
        "when and how trades should be executed to maximize "
        "efficiency and adherence to strategy."
    ),
    verbose=True,
    allow_delegation=True,
    tools=tools,
    llm=llm,
)

risk_management_agent = Agent(
    role="Risk Advisor",
    goal=(
        "Evaluate and provide insights on the risks "
        "associated with potential trading activities."
    ),
    backstory=(
        "Armed with a deep understanding of risk assessment models "
        "and market dynamics, this agent scrutinizes the potential "
        "risks of proposed trades. It offers a detailed analysis of "
        "risk exposure and suggests safeguards to ensure that "
        "trading activities align with the firm's risk tolerance."
    ),
    verbose=True,
    allow_delegation=True,
    tools=tools,
    llm=llm,
)

# ── 7. Tâches ────────────────────────────────────────────────────────────────
# Les {accolades} sont remplacées par les valeurs de `inputs` au kickoff

data_analysis_task = Task(
    description=(
        "Continuously monitor and analyze market data for "
        "the selected stock ({stock_selection}). "
        "Use statistical modeling and machine learning to "
        "identify trends and predict market movements."
    ),
    expected_output=(
        "Insights and alerts about significant market "
        "opportunities or threats for {stock_selection}."
    ),
    agent=data_analyst_agent,
)

strategy_development_task = Task(
    description=(
        "Develop and refine trading strategies based on "
        "the insights from the Data Analyst and "
        "user-defined risk tolerance ({risk_tolerance}). "
        "Consider trading preferences ({trading_strategy_preference})."
    ),
    expected_output=(
        "A set of potential trading strategies for {stock_selection} "
        "that align with the user's risk tolerance."
    ),
    agent=trading_strategy_agent,
    context=[data_analysis_task],   # reçoit le résultat de la tâche précédente
)

execution_planning_task = Task(
    description=(
        "Analyze approved trading strategies to determine the "
        "best execution methods for {stock_selection}, "
        "considering current market conditions and optimal pricing."
    ),
    expected_output=(
        "Detailed execution plans suggesting how and when to "
        "execute trades for {stock_selection}."
    ),
    agent=execution_agent,
    context=[strategy_development_task],
)

risk_assessment_task = Task(
    description=(
        "Evaluate the risks associated with the proposed trading "
        "strategies and execution plans for {stock_selection}. "
        "Provide a detailed analysis of potential risks "
        "and suggest mitigation strategies."
    ),
    expected_output=(
        "A comprehensive risk analysis report detailing potential "
        "risks and mitigation recommendations for {stock_selection}."
    ),
    agent=risk_management_agent,
    context=[strategy_development_task, execution_planning_task],
    output_file="result_{stock_selection}.md",  # sauvegarde automatique
    markdown=True,
)

# ── 8. Crew ───────────────────────────────────────────────────────────────────
# CHANGEMENT v1.x :
#   - manager_llm prend un objet crewai.LLM (plus de ChatOpenAI)
#   - Process.hierarchical toujours supporté
financial_trading_crew = Crew(
    agents=[
        data_analyst_agent,
        trading_strategy_agent,
        execution_agent,
        risk_management_agent,
    ],
    tasks=[
        data_analysis_task,
        strategy_development_task,
        execution_planning_task,
        risk_assessment_task,
    ],
    manager_llm=manager_llm,
    process=Process.hierarchical,
    verbose=True,
)

# ── 9. Inputs et lancement ────────────────────────────────────────────────────
financial_trading_inputs = {
    "stock_selection":             args.stock,
    "initial_capital":             args.capital,
    "risk_tolerance":              args.risk,
    "trading_strategy_preference": args.strategy,
    "news_impact_consideration":   True,
}

print("\n" + "=" * 60)
print("  ANALYSE FINANCIÈRE MULTI-AGENTS — crewAI v1.x")
print("=" * 60)
print(f"  Ticker    : {financial_trading_inputs['stock_selection']}")
print(f"  Capital   : ${financial_trading_inputs['initial_capital']}")
print(f"  Risque    : {financial_trading_inputs['risk_tolerance']}")
print(f"  Stratégie : {financial_trading_inputs['trading_strategy_preference']}")
print("=" * 60)
print("\n⚡ Démarrage... (peut prendre 2–5 minutes)\n")

result = financial_trading_crew.kickoff(inputs=financial_trading_inputs)

print("\n" + "=" * 60)
print("  RÉSULTAT FINAL")
print("=" * 60 + "\n")
print(result)
print(f"\n✅ Rapport sauvegardé dans : result_{args.stock.lower()}.md")

QMD un moteur de recherche de documents markdown

Pour installer ce logiciel, il vaut mieux être sous Linux, aussi si vous êtes sous Windows, soit vous allez dans WSL soit vous utilisez Gitbash pour l’installer, sinon Windows ne trouvera pas le programme.

Le fonctionnement est repris du site officiel :

Voici le repository : https://github.com/tobi/qmd

Installation de QMD

npm install -g @tobilu/qmd

// pour ajouter un répertoire à indexer
qmd collection add ~/notes --name notes

ci dessus c'est un chemin Linux, par exemple si vous êtes dans Document et que vous êtes l'utilisateur John, le chemin devient : /mnt/c/Users/John/Documents

qmd collection add /mnt/c/Users/John/Documents --name mesdocuments

L’intérêt de QMD est que nous vivons à l’âge de l’intelligence artificielle, et l’outil s’intègre très bien dans des workflow agentiques.

Récemment Andrej Karpathy a publié une solution à base d’Obsidian https://x.com/karpathy/status/2039805659525644595?s=46 pour construire un wiki à base de fichier md, capable de s’enrichir de façon incrémental, offrant une solution alternative au RAG.

QMD peut donc s’utiliser en IA agentique. Car tout ce qui est à base de markdown est utilisé comme support d’information pour les LLM, car c’est un formation structuré et vecteur d’information qui minimise l’utilisation de token.

Les RAG comme les MCP sont des solutions pour doter les LLM d’un contexte sur lequel ils n’ont pas été entrainés, évitant ainsi des hallucinations.

Par extension, aujourd’hui des gens s’intéresse à ce qu’on appelle un second cerveau (après le nôtre), l’idée est de combler ce qui manque au LLM : une mémoire persistante, qui le rendrait vraiment très efficace (pensez à Jarvis de Iron Man)

Maitriser ce skills vous permettre de concevoir un assistant vraiment efficace et opérationnel.

Les Skills Claude : le guide complet pour étendre les capacités de votre IA

Si vous utilisez Claude régulièrement, vous avez peut-être remarqué qu’il adapte son comportement selon les contextes — il sait créer des documents Word propres, lire des PDFs complexes, ou générer des présentations PowerPoint clé en main. Derrière cette magie, il y a souvent un skill. Ce tutoriel vous explique tout : ce que c’est, comment en créer un, comment le rendre vraiment efficace, et comment Claude décide de l’utiliser.

Qu’est-ce qu’un skill ?

Un skill est un fichier d’instructions que vous donnez à Claude pour lui apprendre à accomplir une tâche spécifique de façon reproductible et de qualité professionnelle.
Imaginez que vous êtes chef cuisinier et que vous recrutez un assistant. Plutôt que de lui expliquer chaque soir comment préparer votre sauce signature, vous lui remettez une fiche recette détaillée : les ingrédients, les étapes dans l’ordre, les erreurs à éviter, les variantes possibles. C’est exactement ça, un skill. Avant je faisais toujours un long prompt avec des différence entre chaque fois, donc avec un skill c’est beaucouyp plus carré et je suis sûr de ne rien oublier, et je peux même améliorer mon skill puisque vous pouvez versionner le skill sur Github.

Concrètement, un skill c’est :

  • Un dossier portant le nom du skill (ex : docx/, pdf/, pptx/)
  • Un fichier principal appelé SKILL.md — le cœur du skill
  • Optionnellement : des scripts, des fichiers de référence, des assets (modèles, polices, icônes…)
mon-skill/

├── SKILL.md              ← obligatoire
├── scripts/              ← scripts réutilisables
├── references/           ← documentation technique
└── assets/               ← templates, polices, image

À quoi ça sert concrètement un skill ?

Sans skill, si vous demandez à Claude « crée-moi un document Word professionnel », il va faire de son mieux — mais il risque d’oublier de gérer les styles, la table des matières, les en-têtes, les numéros de page. Avec un skill docx, Claude suit une méthode éprouvée : il installe les bonnes librairies Python, utilise python-docx de la bonne façon, applique une mise en page cohérente. Le résultat est radicalement différent.

Les skills servent à :

  • Capitaliser sur une méthode qui fonctionne bien
  • Standardiser les sorties pour qu’elles soient toujours de qualité
  • Éviter de réexpliquer la même chose à chaque conversation

Gérer des cas complexes avec des scripts et des ressources bundlées

Comment est structuré un SKILL.md ?

Le fichier SKILL.md a deux parties : un en-tête YAML (appelé frontmatter) et un corps en Markdown.

---

name: mon-skill

description: Ce que fait ce skill et quand l'utiliser. Inclure les déclencheurs spécifiques.

---

# Corps du skill

## Ce que Claude doit faire

Le frontmatter : la clé du déclenchement

Le frontmatter contient deux champs essentiels :

name — l’identifiant du skill. Simple, en minuscules, avec des tirets.

description — c’est le champ le plus important de tout le skill. C’est grâce à lui que Claude décide d’utiliser (ou non) le skill. Claude ne lit pas l’intégralité du skill à chaque requête — il scanne les descriptions de tous les skills disponibles et choisit lesquels consulter.

Pour une bonne description répondez à ces trois questions :

  1. Qu’est-ce que ce skill fait ?
  2. Dans quelles contextes l’utiliser ?
  3. Quels mots-clés ou situations doivent le déclencher ?
description: >
  Crée des documents Word (.docx) professionnels avec mise en page avancée.
  Utiliser dès que l'utilisateur mentionne "Word", "docx", ".docx", ou demande
  un rapport, mémo, lettre, ou tout document téléchargeable. Également utile
  pour extraire du contenu depuis un .docx existant ou pour insérer des images
  dans un document Word.

Le corps : les instructions pour Claude

Le corps du SKILL.md contient tout ce dont Claude a besoin pour accomplir la tâche : étapes à suivre, formats de sortie attendus, exemples, cas limites à gérer, erreurs courantes à éviter.

Il n’y a pas de format imposé — c’est du Markdown libre. :

## Workflow

1. Installer les dépendances : `pip install python-docx --break-system-packages`
2. Créer le document avec les styles appropriés
3. Sauvegarder dans /mnt/user-data/outputs/

## Format de sortie

Toujours utiliser cette structure :
- En-tête avec titre et date
- Table des matières si > 3 sections
- Pied de page avec numéros de page

## Exemples

**Exemple 1 :**
Requête : "Fais-moi un rapport d'analyse"

Action : Créer un .docx avec titre, TOC, sections numérotées

## À ne pas faire
- Ne pas utiliser reportlab (pour les PDFs, pas les .docx)
- Ne pas oublier d'appeler present_files à la fin

Le système de chargement progressif

Un des concepts les plus élégants des skills est la progressive disclosure : un système à trois niveaux.

Niveau 1 : Métadonnées (toujours en contexte)

  name + description (~100 mots)

Niveau 2 : Corps du SKILL.md (chargé quand le skill est déclenché)

  Instructions complètes (<500 lignes idéalement)

Niveau 3 : Ressources bundlées (chargées à la demande)

  Scripts, références, assets (taille illimitée)

Cela signifie que Claude ne lit pas tous les skills en entier à chaque requête — ce serait beaucoup trop lourd. Il ne consulte que ce dont il a besoin, au moment où il en a besoin. A la différence des serveurs MCP qui peuvent être gourmand en tokens.
Implication pratique : gardez votre SKILL.md sous 500 lignes. Si vous avez beaucoup de documentation (par exemple, plusieurs frameworks cloud : AWS, GCP, Azure), mettez-la dans des fichiers de référence séparés et indiquez dans le SKILL.md quand les lire :

## Documentation spécifique par plateforme

Selon la plateforme demandée, lire le fichier correspondant :
- AWS → references/aws.md
- GCP → references/gcp.md  
- Azure → references/azure.md

Pensez à économiser vos tokens !

Comment créer un bon skill

Je sais qu’il existe des sites qui listent des milliers de skills, mais vous devez apprendre à les concocter vous même. Vous pouvez néanmoins vous inspirer pour faire les votre, comme ça vous comprendrez ce que vous faites.

Voici les principes qui distinguent un skill basique d’un skill vraiment efficace.

Principe 1 : la description est reine

Répétons-le car c’est crucial : la description détermine si le skill sera utilisé ou non. Une description trop vague = skill ignoré. Une description trop restrictive = skill sous-utilisé.

La description doit être légèrement « assertive » — elle doit pousser Claude à utiliser le skill dans tous les cas pertinents. Comparez :

description: Outil pour créer des dashboards. << trop vague

  Crée des dashboards interactifs pour visualiser des données internes.
  Utiliser dès que l'utilisateur mentionne des dashboards, de la visualisation
  de données, des métriques, ou veut afficher n'importe quel type de données
  d'entreprise — même sans le mot "dashboard" explicitement.
  ^ beaucoup plus précis, le contexte est plus riche, moins de devinette de la part du LLM.

Principe 2 : le principe de moindre surprise

Le comportement du skill doit correspondre exactement à ce que sa description promet. Un skill qui fait des choses inattendues crée de la confusion. Si votre description dit « crée des PDFs », le skill ne devrait pas aussi modifier des fichiers Excel sans le mentionner.

Principe 3 : préférez l’impératif dans les instructions

Les instructions doivent être claires et directes :

Il serait bien d'installer les dépendances  << trop vague, ce n'est pas un ordre...

"Installer les dépendances avec pip install python-docx --break-system-packages" << précis et impératif

Principe 4 : inclure des exemples

Les exemples sont parmi les éléments les plus puissants d’un skill. Ils ancrent les instructions dans le concret :

## Exemples de messages de commit

Input: "Ajout de l'authentification avec JWT"
Output: feat(auth): implement JWT-based authentication
Input: "Correction du bug d'affichage sur mobile"
Output: fix(ui): resolve display issue on mobile screens

Principe 5 : anticipez les cas limites

Qu’est-ce qui peut mal tourner ? Documentez-le :

## Cas limites et erreurs courantes

- Si le fichier est trop volumineux (>50MB), prévenir l'utilisateur et proposer de traiter par chunks
- Si python-docx n'est pas disponible, l'installer avec --break-system-packages
- Si l'utilisateur ne précise pas de langue, utiliser le français par défaut

Principe 6 : déléguez aux scripts pour les tâches répétitives

Pour des opérations complexes et reproductibles, créez des scripts dans scripts/. Claude peut les exécuter sans même les lire entièrement — ce qui économise du contexte et garantit la cohérence.

## Création du document

Exécuter le script de génération :
```bash
python scripts/generate_report.py --title "$TITRE" --output /mnt/user-data/outputs/
---
## 5. Comment Claude décide d'invoquer un skill
C'est la question que tout créateur de skills se pose : quand est-ce que Claude va réellement utiliser mon skill ?
### Le mécanisme de déclenchement
### Ce qui favorise le déclenchement

- **Des mots-clés dans la requête** qui correspondent à la description du skill
- **La complexité de la tâche** — les tâches multi-étapes déclenchent mieux
- **Une description assertive** qui liste explicitement les déclencheurs
- **Le format de sortie attendu** — si l'utilisateur mentionne ".docx", ".pdf", ".pptx"
### Ce qui empêche le déclenchement
- Description trop vague ou trop générique
- Tâche trop simple (Claude la gère sans aide)
- Mots-clés absents de la description
### Astuce : tester et optimiser

Pour vérifier qu’un skill se déclenche bien, essayez différentes formulations de requête et observez si Claude consulte le skill. Si des requêtes légitimes passent à travers, enrichissez la description avec ces formulations.

Il existe même des outils d’optimisation automatique (comme run_loop.py dans l’outil skill-creator) qui testent la description avec des dizaines de variantes et proposent des améliorations basées sur les résultats.

Les skills par défaut de Claude

Vous avez dû sans doute rencontré ces skills car il les affiche dans la version web : docx, pptx,pdf,xlsx, frontend-design (en tant que dév web je le vois souvent), et skill-creator (un skill puor créer des skills !)

Qu’est ce que le python launcher?

Une des difficultés que je rencontre avec Python est le global et le local, les différents version de python runtime installée, parfois les scripts nécessite une version spécifique de Python, c’est là que trouve son utilité le python launcher

# lister les version de python installée
$ py --list

Installer plusieurs versions de python

Pour installer plusieurs version de python, vous pouvez allez sur le site officiel python.org et sélectionnez les versions que vous voulez télécharger. Mais, attention, pour les anciennes version, les installeur n’existent plus, et il faut compiler à partir du code source, pas pratique.

Mais selon cette page, à partir de la version 3.16 de python, le python install manager sera discontinué.

pyenv-win

C’est l’outil en ligne pour installer plusieurs versions de python.

# pour installer sous Powershell
pip install pyenv-win --target "$HOME\.pyenv"

# il est peut être préférable d'installer via GIT
git clone https://github.com/pyenv-win/pyenv-win.git "$HOME\.pyenv"

#ajout au PATH
[System.Environment]::SetEnvironmentVariable('PYENV',"$HOME\.pyenv\pyenv-win","User")
[System.Environment]::SetEnvironmentVariable('PATH',"$HOME\.pyenv\pyenv-win\bin;$HOME\.pyenv\pyenv-win\shims;$env:PATH","User")

# exemple de commandes
pyenv install 3.10.5   # Installe Python 3.10.5
pyenv install 3.11.9    # Installe Python 3.11.9
pyenv versions          # Liste les versions installées
pyenv global 3.11.9     # Définit la version par défaut
pyenv local 3.10.11     # Définit la version pour le dossier courant

Solution plus moderne Python Install Manager

Allez sur cette page https://www.python.org/downloads/release/pymanager-261/, téléchargez le binaire et installez le. Puis pour installer une version spécifique de python :

pymanager install 3.12

Note 1:

Quand vous faites des commandes en shell sous Windows, distinguez bien Powershell, CMD, gitbash, cela peut avoir une grande incidence sur la réussite de la commande.

N’installez pas seulement la dernière version de python, en effet les librairies ne suivent pas aussi vite les version de Python, particulièrement en machine learning, je suis confronté à des erreurs car j’avais la dernière version.

Note 2:

python -m pip est toujours plus sûr car ça garantit que l’installation se fait dans le même Python que celui qui exécute ton script.

python -m pip install librosa