Tutoriel Claude Opus 4.5 : créer un agent pour wiki GitHub

De nombreux dépôts GitHub modernes manquent d’une documentation claire et structurée, en particulier côté wikis.

Créer ces pages manuellement peut prendre des heures entre la lecture du code, la compréhension de l’architecture et l’organisation des contenus.

Un agent IA pour Wiki GitHub peut résoudre ce problème.

Dans ce tutoriel, je vous guide pas à pas pour créer un agent IA GitHub Wiki entièrement automatisé : un outil en ligne de commande qui utilise Claude Opus 4.5 et le Claude Agent SDK pour générer des wikis GitHub complets à partir d’une simple instruction. 

Au lieu d’écrire la documentation à la main, cet outil analyse votre code, comprend sa structure et produit un wiki propre et multi-pages, automatiquement enregistré et publié dans votre repository. 

Tout s’exécute via une application CLI interactive, rapide, intelligente et pensée pour les développeurs.

Dans ce guide, nous suivrons un processus en trois étapes pour configurer l’environnement, construire l’agent GitHub Wiki, puis le tester sur de vrais dépôts :

1. Configurer l’environnement : installer les dépendances, installer et authentifier Claude Code, configurer les tokens GitHub et activer la fonctionnalité Wiki.
2. Construire l’application : créer l’outil CLI, configurer le Claude Agent, intégrer les outils GitHub MCP, ajouter le suivi des coûts et implémenter la logique de génération du wiki (Home, Getting Started, Architecture & Tools).
3. Tester l’agent : l’exécuter sur de vrais dépôts (ECom-Intel et Issue-Analyzer) pour vérifier le clonage, l’analyse, la création du wiki et le push automatique.

Si vous débutez avec les agents IA et souhaitez aller plus loin, nous vous recommandons le parcours de compétences AI Agent Fundamentals. Lisez aussi notre tutoriel sur Claude Cowork et notre guide sur le nouveau Claude Opus 4.6.

Configurer votre environnement pour le tutoriel GitHub Wiki avec Claude Opus 4.5

Avant de construire l’agent GitHub Wiki avec Opus 4.5, assurez-vous que votre environnement est correctement configuré. Cette section détaille tous les prérequis et étapes d’installation.

1. Prérequis pour exécuter l’agent Wiki Claude Opus 4.5

• Python 3.11 ou supérieur (requis par le Python Claude Agent SDK).
• Node.js et npm (requis pour installer Claude Code), la colonne vertébrale de notre application, qui fournit agents, outils et intégrations pour les serveurs MCP.

2. Installer et authentifier Claude Code

Ouvrez votre terminal (Invite de commandes, PowerShell ou Terminal macOS) et exécutez la commande suivante pour installer la CLI Claude Code :

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

Tapez claude dans votre terminal pour lancer Claude Code. Puis, dans le chat Claude, saisissez /login pour vous authentifier et accéder au modèle et aux outils Opus 4.5, comme ci-dessous.

Vous pouvez en savoir plus sur Claude Code dans notre tutoriel pratique. 

3. Générer un jeton GitHub Personal Access Token à granularité fine

Pour créer un Personal Access Token GitHub à granularité fine, rendez-vous sur GitHub et accédez à : 

Settings → Developer Settings → Personal Access Tokens → Fine-grained tokens. 

Créez un nouveau token et sélectionnez le repository que vous utiliserez dans la section Repository. Configurez ensuite les Permissions. Par sécurité, il est recommandé de définir une courte date d’expiration pour le token.

Ensuite, définissez le Personal Access Token comme variable d’environnement :

export GITHUB_PAT="your-github-personal-access-token"

4. Initialiser votre wiki GitHub

GitHub ne permet pas actuellement de créer d’abord un wiki en local.

Vous devez donc initialiser le wiki manuellement en :

1. Ouvrant votre repository sur GitHub
2. Cliquant sur l’onglet Wiki
3. Cliquant sur « Create the first page »
4. Enregistrant la page (peu importe le titre)

5. Installer le Claude Agent SDK

Nous allons installer le framework agentique Claude qui gère tout : de l’utilisation de MCP à l’invocation d’outils, la création de fichiers et le push des changements vers le dépôt distant.

pip install claude-agent-sdk

Construire l’agent Auto Wiki avec Claude Opus 4.5

Nous allons créer une application CLI Python nommée gh_wiki_cli.py. Ce fichier contiendra les configurations, agents, outils, un client MCP, des prompts système, l’application CLI elle-même et des fonctions utilitaires. 

Ces composants permettront à l’utilisateur de fournir le lien du repository et à l’agent de le traiter correctement pour publier le wiki GitHub.

1. Imports

Cette partie importe les modules de la bibliothèque standard Python, les aides de typage et le Claude Agent SDK.

• asyncio pour l’I/O asynchrone (chat + streaming).
• os, sys pour les variables d’environnement et la sortie du programme.
• dataclass pour suivre des statistiques.
• Imports du Claude Agent SDK pour communiquer avec l’agent et les outils MCP.

import asyncio
import os
import sys
from dataclasses import dataclass
from typing import Dict

# --- SDK Imports ---
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ClaudeSDKClient,
    McpSdkServerConfig,
    ResultMessage,
    TextBlock,
    ToolResultBlock,
    ToolUseBlock,
)

2. Prompt système

C’est le « cerveau » de l’agent. Nous allons indiquer au modèle Opus 4.5 comment se comporter et comment utiliser les outils.

SYSTEM_PROMPT = """
        You are an expert Technical Writer and GitHub Wiki specialist.

        TOOLS
        - Read, Write, Glob, Grep:
        - Use these to inspect files and folders in the project directory (e.g. /tmp/Issue-Analyzer) and in wiki_clone/.
        - Use them to list files, read contents, and search for patterns.
        - Write:
        - Use this ONLY to write or update three wiki pages inside wiki_clone/:
            - wiki_clone/Home.md
            - wiki_clone/Getting-Started.md
            - wiki_clone/Architecture-and-Tools.md
        - Bash:
        - Bash is ONLY allowed for git commands, never for inspection or editing.
        - Allowed commands (with cd wiki_clone/ when needed):
            - git clone <repo>.wiki.git wiki_clone  (if wiki_clone does not already exist)
            - git status
            - git add .
            - git commit -m "Update wiki"
            - git push
        - Do NOT use Bash for ls, cat, grep, find, python, or any other way of reading/writing files.

        WORKFLOW
        1. When the user gives a GitHub repo URL:
        - Use Bash to clone the wiki if wiki_clone/ does not already exist:
            git clone <repo>.wiki.git wiki_clone
        2. Use Read/Glob/Grep (and any GitHub MCP tools) to explore the project:
        - Read important files in the project folder (e.g. README, docs/, src/).
        - Use that information to generate documentation.
        3. Use Write to create or update ONLY:
        - wiki_clone/Home.md
        - wiki_clone/Getting-Started.md
        - wiki_clone/Architecture-and-Tools.md
        4. When the wiki pages are ready:
        - Use Bash from wiki_clone/ to:
            git add .
            git commit -m "Update wiki"
            git push

        RULES
        - You may READ from the whole project directory and wiki_clone/.
        - You may WRITE only to the three wiki pages inside wiki_clone/.
        - Never use Bash to inspect or edit files; only use it for git commands.
        - Keep documentation clear, concise, and in GitHub Wiki style.
        """

3. Gestion des couleurs pour la CLI

Cela améliore l’affichage de la sortie CLI, tout en restant fonctionnel si colorama n’est pas installé.

• Tente d’utiliser colorama pour la couleur du texte.
• Bascule sur MockColors si besoin, afin que le script tourne sans couleur mais sans planter.

try:
    from colorama import Fore, Style, init

    init()
except ImportError:

    class MockColors:
        def __getattr__(self, name):
            return ""

    Fore = Style = MockColors()

4. Suivre les statistiques de session

Une petite dataclass pour suivre le coût, le nombre d’échanges et la durée.

• total_cost : somme du coût en $ renvoyé par le Claude SDK.
• total_turns : nombre de requêtes utilisateur envoyées.
• duration_ms : durée cumulée en millisecondes.

@dataclass
class SessionStats:
    total_cost: float = 0.0
    total_turns: int = 0
    duration_ms: int = 0

5. Créer les options de l’agent

Nous allons créer l’objet ClaudeAgentOptions et nous connecter à nos serveurs MCP. La fonction ci-dessous valide les variables d’environnement requises, configure le serveur MCP GitHub s’il est disponible et restreint les outils utilisables par l’agent.

Nous limitons volontairement les allowed_tools afin qu’Opus 4.5 puisse : utiliser Bash pour les opérations Git, appeler le serveur MCP GitHub pour inspecter le contenu du dépôt, et utiliser Read/Write (avec Glob et Grep) pour travailler avec les fichiers Markdown locaux et les valider.

def create_agent_options() -> ClaudeAgentOptions:
    """Validates env vars and configures the agent options."""
    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
    github_pat = os.getenv("GITHUB_PAT")

    if not anthropic_key:
        print(
            f"{Fore.RED}Error: ANTHROPIC_API_KEY environment variable is required.{Style.RESET_ALL}"
        )
        sys.exit(1)

    # Configure MCP servers
    mcp_servers: Dict[str, McpSdkServerConfig] = {}
    if github_pat:
        mcp_servers["github"] = {
            "type": "http",
            "url": "https://api.githubcopilot.com/mcp/",
            "headers": {"Authorization": f"Bearer {github_pat}"},
        }

    return ClaudeAgentOptions(
        model="claude-opus-4-5",
        system_prompt=SYSTEM_PROMPT,
        mcp_servers=mcp_servers,
        permission_mode="bypassPermissions",
        allowed_tools=[
            "Read",
            "Write",
            "Glob",
            "Grep",
            "Bash",
            "mcp__github__*",
        ],
    )

6. Traiter la réponse en streaming

Cette fonction écoute le flux et affiche le texte, l’usage des outils et leurs sorties.

• Utilise client.receive_response() en flux asynchrone.
• Affiche le texte de l’assistant au fil de l’eau.
• Lorsqu’un outil est invoqué → affiche [Tool Use: ...].
• Quand un outil renvoie une sortie → tronque et affiche un aperçu sur une seule ligne.
• Quand un ResultMessage arrive → met à jour SessionStats avec le coût et la durée.

async def process_response_stream(client: ClaudeSDKClient, stats: SessionStats):
    """Handles the stream of messages from the agent."""
    async for message in client.receive_response():
        # 1. Handle Assistant Content (Text & Tool Requests)
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="", flush=True)
                elif isinstance(block, ToolUseBlock):
                    print(f"\n{Fore.CYAN}[Tool Use: {block.name}]{Style.RESET_ALL}")

        # 2. Handle Tool Results (Outputs)
        if hasattr(message, "content") and isinstance(message.content, list):
            for block in message.content:
                if isinstance(block, ToolResultBlock):
                    # Truncate output for cleaner CLI
                    raw_output = str(block.content)
                    clean_output = raw_output.replace("\n", " ")
                    short_output = (
                        clean_output[:200] + "..."
                        if len(clean_output) > 200
                        else clean_output
                    )
                    print(
                        f"{Fore.YELLOW}  -> [Output]: {short_output}{Style.RESET_ALL}"
                    )

        # 3. Handle Result Metrics (Cost & Usage)
        if isinstance(message, ResultMessage):
            if message.total_cost_usd:
                stats.total_cost += message.total_cost_usd
            if message.duration_ms:
                stats.duration_ms += message.duration_ms

7. Afficher un récapitulatif final

De jolies statistiques de fin de session pour la CLI, avec le nombre d’échanges, la durée et le coût en dollars.

• Convertit duration_ms en secondes.
• Affiche le coût total avec 4 décimales.

def print_summary(stats: SessionStats):
    """Prints the final session statistics."""
    print(f"\n\n{Fore.GREEN}=== Session Summary ==={Style.RESET_ALL}")
    print(f"Total Turns:   {stats.total_turns}")
    print(f"Duration:      {stats.duration_ms / 1000:.2f}s")
    print(f"Total Cost:    ${stats.total_cost:.4f}")
    print(f"{Fore.GREEN}======================={Style.RESET_ALL}")

8. Fonction principale asynchrone

C’est le flux de contrôle central de l’application : il gère l’initialisation, la connexion aux services, la lecture des saisies utilisateur et l’envoi des requêtes. La fonction appelle create_agent_options() et initialise les statistiques. Elle affiche une bannière d’introduction et précise quels serveurs MCP sont activés. Elle crée aussi un ClaudeSDKClient dans un contexte asynchrone.

L’application exécute une boucle REPL simple (Read-Eval-Print Loop) :

1. Tapez « exit » ou « quit » pour quitter l’application.
2. Chaque requête valide incrémente stats.total_turns de 1.
3. await client.query(user_input) envoie le message de l’utilisateur.
4. await process_response_stream(...) affiche le résultat en streaming.
5. Toutes les exceptions sont captées et affichées en rouge.
6. Enfin, la fonction appelle toujours print_summary(stats).

async def main():
    options = create_agent_options()
    stats = SessionStats()

    # Welcome message
    print(f"{Fore.GREEN}=== GitHub Wiki AI Agent (Auto-Mode) ==={Style.RESET_ALL}")
    print(
        f"MCP Servers: {', '.join(options.mcp_servers.keys()) if options.mcp_servers else 'None'}"
    )
    print("Ask me to help with a GitHub wiki by mentioning the repository URL!")
    print("Type 'exit' to quit.\n")

    async with ClaudeSDKClient(options=options) as client:
        try:
            await client.connect()

            while True:
                try:
                    user_input = input(f"\n{Fore.BLUE}>> {Style.RESET_ALL}").strip()
                except EOFError:
                    break

                if not user_input:
                    continue

                if user_input.lower() in ["exit", "quit"]:
                    break

                stats.total_turns += 1

                # Send query
                await client.query(user_input)
                print()  # Spacer

                # Process response stream using helper function
                await process_response_stream(client, stats)

        except Exception as e:
            print(f"\n{Fore.RED}Session Error: {e}{Style.RESET_ALL}")
        finally:
            print_summary(stats)

9. Point d’entrée du script

Enfin, nous définissons le point d’entrée du script pour que la CLI s’exécute lorsque le fichier est lancé directement. Le bloc ci-dessous démarre la boucle asynchrone principale et gère l’arrêt proprement :

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\nSession interrupted.")
        sys.exit(0)

Tester l’agent Auto Wiki

Une fois tout installé, lancez l’app de chat CLI et vérifiez que votre CLI Claude Code fonctionne :

python gh_wiki_cli.py

Vous pouvez maintenant interagir avec l’agent comme dans une interface de chat. Posez des questions générales ou demandez-lui directement de construire le wiki de votre repository :

create the github wiki for https://github.com/kingabzpro/ECom-Intel

Si l’utilisateur demande de créer un wiki, l’agent effectue automatiquement :

1. Clonage du wiki : crée ou réutilise un dossier wiki_clone/ et récupère le contenu le plus récent du wiki.
2. Inspection du repository : lit les fichiers clés du dépôt GitHub à l’aide des outils MCP. 
3. Génération des pages : rédige et écrit automatiquement des pages telles que :
• Home.md
• Getting-Started.md
• Architecture-and-Tools.md
4. Commit et push : l’agent ajoute les nouvelles pages, les commit et pousse les mises à jour vers : <your-repo>.wiki.git
5. Exemple de sortie réussie : une fois terminé, vous verrez un message de confirmation clair. Et le wiki sera en ligne à : https://github.com/kingabzpro/ECom-Intel/wiki

J’ai été vraiment impressionné par la capacité de l’agent à rassembler des images de démonstration, des graphiques et d’autres informations clés, puis à composer une page d’accueil cohérente pour le wiki.

Le wiki inclut désormais une table des matières digne de ce nom, des explications sur l’assistant et les outils, ainsi que des consignes claires pour « getting started ».

En fin d’exécution, le récapitulatif indiquait un coût d’environ 1 USD pour une seule session, ce qui reste assez élevé pour générer un wiki de trois pages. Si le repository était plus grand et que nous visons, par exemple, 12 pages, le coût grimperait sensiblement.

=== Session Summary ===
Total Turns:   1
Duration:      282.99s
Total Cost:    $0.9047
=======================

Dans le second test, j’ai demandé à l’agent de créer un wiki pour un autre repository :

create the github wiki for https://github.com/kingabzpro/Issue-Analyzer

Le résultat était encore meilleur. Le wiki généré, disponible sur https://github.com/kingabzpro/Issue-Analyzer/wiki, contient désormais une documentation correcte expliquant l’objectif du projet et comment démarrer. 

On y trouve des tableaux bien structurés, un schéma d’architecture et d’autres sections essentielles qui permettent de comprendre l’ensemble du projet en cinq minutes, plutôt que de passer des jours à lire le code.

Dernières réflexions

Lorsque j’ai appris qu’Opus 4.5 était présenté comme le meilleur modèle de codage et d’agents au monde, j’étais vraiment enthousiaste, d’autant qu’il est proposé à un prix comparable aux modèles Sonnet. 

Cependant, mon enthousiasme est retombé en constatant que l’expérimentation et la réalisation d’une petite application m’ont coûté environ 15 $ en usage API.

Opus 4.5 est puissant mais coûteux. J’ai aussi tenté de reproduire le même workflow avec Haiku et Sonnet, mais l’expérience était nettement inférieure pour ce type de tâche agentique, très axée documentation. 

Les deux revenaient fréquemment à l’usage d’outils Bash, même lorsque je précisais d’utiliser les outils MCP pour lire les fichiers GitHub. De plus, ils adoptaient souvent des chemins plus longs et moins directs pour résoudre les problèmes.

Si vous privilégiez la précision, la fiabilité et une génération de code et de documentation de haute qualité, Opus 4.5 mérite clairement votre attention. 

En revanche, si votre cas d’usage est moins critique ou si vous êtes très sensible aux coûts, vous préférerez rester sur Sonnet, voire sur des modèles open source moins onéreux. Les coûts liés à Opus 4.5 peuvent vite grimper, surtout pour des workflows agentiques multi-étapes sur de grands dépôts.

Si le projet vous intéresse, vous trouverez le code source complet ici, clonable et exécutable en local : kingabzpro/GitHub-Wiki-Agent.

Si vous avez envie de continuer à créer des agents IA, nous vous recommandons le cours Multi-Agent Systems with LangGraph.