Vous avez rêvé d'une intelligence artificielle capable de voir ce qui s'affiche sur votre écran et d'exécuter des actions à votre place ? Ouvrir des applications, cliquer sur des boutons, remplir des formulaires, analyser des graphiques en temps réel ? Aujourd'hui, c'est désormais accessible à tous, même sans expérience en programmation d'API.

Dans ce tutoriel complet, je vais vous guider pas à pas depuis zéro pour construire votre propre agent multimodal capable d'interpréter visuellement son environnement et d'interagir avec votre ordinateur. Nous utiliserons l'API HolySheep AI qui offre des tarifs remarquablement compétitifs : moins de 50ms de latence, un taux de change de ¥1 pour $1, et des crédits gratuits pour commencer.

Comprendre le Principe des Agents Multimodaux

Un agent multimodal est un programme qui combine plusieurs modes de perception : la vision par ordinateur (analyse d'images), le traitement du langage naturel (compréhension des instructions), et la capacité d'action (exécuter des tâches sur le système).

Concrètement, le flux de travail fonctionne ainsi :

Prérequis et Installation

Compte HolySheep AI

Avant de commencer, vous aurez besoin d'un compte sur HolySheep AI. Pourquoi ce choix plutôt qu'OpenAI ou Anthropic ? Les raisons sont simples : les prix sont jusqu'à 85% moins chers que les alternatives américaines, avec une latence moyenne inférieure à 50ms depuis la Chine. Les prix 2026 par million de tokens illustrent parfaitement cet avantage :

Avec des prix pareils, vous pouvez expérimenter sans crainte de ruiner votre budget. De plus, HolySheep accepte WeChat Pay et Alipay, ce qui simplifie énormément le paiement pour les utilisateurs chinois.

Installation des Bibliothèques Python

Ouvrez votre terminal et installez les dépendances nécessaires :

pip install openai Pillow pyautogui numpy python-dotenv requests

Ces bibliothèques nous permettront respectivement de : communiquer avec l'API HolySheep, capturer des images, simuler les actions de la souris et du clavier, manipuler des tableaux de données, et gérer les variables d'environnement.

Configuration de la Clé API

Créez un fichier nommé .env à la racine de votre projet et ajoutez votre clé API :

HOLYSHEEP_API_KEY=votre_cle_api_ici

Pour obtenir votre clé, connects-toi sur ton tableau de bord HolySheep, puis accède à la section "API Keys". Clique sur "Generate New Key" et copie la clé générée.

Maintenant, créons un fichier config.py pour charger cette configuration :

import os
from dotenv import load_dotenv

load_dotenv()


Configuration de l'API HolySheep

HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"


Vérification que la clé API est bien configurée

if not HOLYSHEEP_API_KEY:
    raise ValueError("❌ HOLYSHEEP_API_KEY non trouvée. Vérifiez votre fichier .env")

Construction du Module de Capture d'Écran

La capture d'écran est le cœur de notre agent visuel. Créons un module dédié screenshot.py :

from PIL import Image
import numpy as np
import pyautogui
import io
import base64

class ScreenCapture:
    """Module de capture d'écran optimisé pour l'analyse par IA"""
    
    def __init__(self):
        # Configuration de PyAutoGUI pour plus de sécurité
        pyautogui.FAILSAFE = True  # Déplacer la souris au coin supérieur gauche arrête le programme
        pyautogui.PAUSE = 0.1      # Pause entre chaque action pour éviter les erreurs
        
    def capture_screen(self, region=None):
        """
        Capture l'écran ou une région spécifique
        
        Args:
            region: Tuple (left, top, width, height) pour capturer une zone spécifique
            
        Returns:
            Image PIL compressée en base64 pour l'envoi à l'API
        """
        if region:
            screenshot = pyautogui.screenshot(region=region)
        else:
            screenshot = pyautogui.screenshot()
        
        # Conversion en bytes compressés (JPEG pour réduire la taille)
        buffer = io.BytesIO()
        screenshot.save(buffer, format='JPEG', quality=75)
        buffer.seek(0)
        
        # Encodage en base64 pour transmission
        image_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
        
        return image_base64, screenshot
    
    def capture_and_save(self, filename="capture.png"):
        """Capture et sauvegarde locally pour debug"""
        screenshot = pyautogui.screenshot()
        screenshot.save(filename)
        print(f"📸 Capture sauvegardée : {filename}")
        return screenshot

Implémentation de l'Agent Multimodal

Maintenant, créons le cœur de notre système : l'agent qui analyse les images et prend des décisions. Le fichier agent.py contiendra toute la logique :

from openai import OpenAI
import json
import time

class MultimodalAgent:
    """Agent capable de voir l'écran et d'exécuter des actions"""
    
    def __init__(self, api_key, base_url):
        # Initialisation du client OpenAI compatible avec HolySheep
        self.client = OpenAI(
            api_key=api_key,
            base_url=base_url
        )
        self.screen_capture = ScreenCapture()
        
        # Mémoire de conversation pour le contexte
        self.conversation_history = []
        
    def analyze_screen(self, instruction_user):
        """
        Analyse l'écran actuel et détermine l'action à effectuer
        
        Args:
            instruction_user: Instruction en langage naturel
            
        Returns:
            Dict contenant l'action recommandée et les paramètres
        """
        # Capture de l'écran
        image_base64, screenshot = self.screen_capture.capture_screen()
        
        # Construction du prompt système
        system_prompt = """Tu es un assistant qui analyse des captures d'écran d'ordinateur.
Ton rôle est de déterminer quelle ACTION effectuer ensuite pour accomplir la tâche demandée.

Réponds UNIQUEMENT au format JSON suivant (sans markdown, sans code block):
{
    "action": "click|move|type|scroll|wait|complete|error",
    "target": "description du target ou null",
    "coordinates": {"x": nombre, "y": nombre} ou null,
    "text": "texte à taper ou null",
    "reasoning": "explication courte de ton choix"
}

Types d'actions :
- click: Cliquer sur un élément
- move: Déplacer la souris vers une position
- type: Saisir du texte
- scroll: Faire défiler la page
- wait: Attendre que quelque chose se passe
- complete: La tâche est terminée
- error: Impossible d'accomplir la tâche"""
        
        # Ajout de l'instruction user au contexte
        self.conversation_history.append({
            "role": "user",
            "content": [
                {"type": "text", "text": f"Tâche à accomplir : {instruction_user}"},
                {"type": "image_url", "image_url": {
                    "url": f"data:image/jpeg;base64,{image_base64}"
                }}
            ]
        })
        
        # Appel à l'API HolySheep avec le modèle vision
        response = self.client.chat.completions.create(
            model="deepseek-chat-v3",  # Modèle avec capacités multimodales
            messages=[
                {"role": "system", "content": system_prompt},
                *self.conversation_history[-5:]  # Garder les 5 derniers échanges
            ],
            max_tokens=500,
            temperature=0.3
        )
        
        # Parse la réponse JSON
        response_text = response.choices[0].message.content
        try:
            action_data = json.loads(response_text)
        except json.JSONDecodeError:
            action_data = {"action": "error", "reasoning": f"Réponse invalide: {response_text}"}
        
        # Ajout à l'historique
        self.conversation_history.append({
            "role": "assistant",
            "content": response_text
        })
        
        return action_data
    
    def execute_action(self, action_data):
        """Exécute l'action determined par l'analyse"""
        action = action_data.get("action")
        print(f"🎬 Action : {action} - {action_data.get('reasoning', '')}")
        
        if action == "click" and action_data.get("coordinates"):
            x, y = action_data["coordinates"]["x"], action_data["coordinates"]["y"]
            pyautogui.click(x, y)
            print(f"   ✅ Clic aux coordonnées ({x}, {y})")
            
        elif action == "move" and action_data.get("coordinates"):
            x, y = action_data["coordinates"]["x"], action_data["coordinates"]["y"]
            pyautogui.moveTo(x, y, duration=0.3)
            print(f"   ✅ Souris déplacée vers ({x}, {y})")
            
        elif action == "type" and action_data.get("text"):
            pyautogui.typewrite(action_data["text"], interval=0.05)
            print(f"   ✅ Texte saisi : '{action_data['text']}'")
            
        elif action == "scroll":
            pyautogui.scroll(-300)  # Scroll vers le bas
            print("   ✅ Défilement effectué")
            
        elif action == "wait":
            time.sleep(2)
            print("   ⏳ Attente de 2 secondes...")
            
        elif action == "complete":
            print("   🎉 Tâche terminée avec succès !")
            return True
            
        elif action == "error":
            print(f"   ❌ Erreur : {action_data.get('reasoning', 'Raison inconnue')}")
            return True  # Arrêter en cas d'erreur
            
        return False
    
    def run_task(self, instruction, max_iterations=20):
        """
        Exécute une tâche complète en boucle
        
        Args:
            instruction: Instruction en langage naturel
            max_iterations: Nombre maximum d'itérations pour éviter les boucles infinies
        """
        print(f"\n🚀 Démarrage de la tâche : {instruction}")
        print("=" * 60)
        
        for iteration in range(max_iterations):
            print(f"\n📍 Itération {iteration + 1}/{max_iterations}")
            
            # 1. Analyse de l'écran
            action_data = self.analyze_screen(instruction)
            
            # 2. Affichage des détails
            print(f"💭 Décision : {action_data.get('reasoning', '')}")
            
            # 3. Exécution de l'action
            is_complete = self.execute_action(action_data)
            
            if is_complete:
                print("\n✨ Tâche accomplished !")
                return True
                
            # Pause pour laisser le temps à l'écran de se mettre à jour
            time.sleep(1)
        
        print(f"\n⚠️ Nombre maximum d'itérations atteint ({max_iterations})")
        return False

Script Principal : Votre Premier Agent Fonctionnel

Créons maintenant le fichier main.py qui regroupera tout et vous permettra de tester votre agent :

#!/usr/bin/env python3
"""
Exemple d'utilisation d'un agent multimodal HolySheep
pour automatiser des tâches sur ordinateur
"""

from config import HOLYSHEEP_API_KEY, HOLYSHEEP_BASE_URL
from agent import MultimodalAgent

def main():
    print("""
    ╔═══════════════════════════════════════════════════════════╗
    ║        AGENT MULTIMODAL HOLYSHEEP - DÉMO                  ║
    ║  L'IA qui voit votre écran et exécute vos commandes      ║
    ╚═══════════════════════════════════════════════════════════╝
    """)
    
    # Initialisation de l'agent
    agent = MultimodalAgent(
        api_key=HOLYSHEEP_API_KEY,
        base_url=HOLYSHEEP_BASE_URL
    )
    
    # Exemples de tâches possibles
    print("\n📋 Tâches possibles :")
    print("   1. Ouvrir le navigateur et chercher une information")
    print("   2. Remplir un formulaire automatiquement")
    print("   3. Naviguer dans des menus et effectuer des clics")
    print("   4. Analyser des données affichées et produire un rapport")
    
    # Demande à l'utilisateur
    print("\n" + "=" * 60)
    instruction = input("🎯 Entrez votre instruction (ou 'quitter' pour sortir) : ")
    
    if instruction.lower() in ['quitter', 'exit', 'q']:
        print("👋 Au revoir !")
        return
    
    # Exécution de la tâche
    agent.run_task(instruction)
    
    print("\n" + "=" * 60)
    print("💡 L'agent a terminé son travail. Vérifiez le résultat sur votre écran.")

if __name__ == "__main__":
    main()

Amélioration : Agent avec Auto-Correction

L'agent basique fonctionne, mais il peut commettre des erreurs. Améliorons-le avec un système d'auto-correction qui vérifie le résultat de chaque action :

class SmartMultimodalAgent(MultimodalAgent):
    """Version améliorée avec auto-correction et gestion d'erreurs"""
    
    def __init__(self, api_key, base_url):
        super().__init__(api_key, base_url)
        self.action_history = []
        
    def verify_action(self, expected_result):
        """
        Vérifie que l'action a produit le résultat attendu
        
        Args:
            expected_result: Description du résultat attendu
            
        Returns:
            Tuple (success, feedback)
        """
        # Capture d'écran post-action
        image_base64, screenshot = self.screen_capture.capture_screen()
        
        verification_prompt = f"""
Suite à une action, vérifie si le résultat attendu a été achieved.
        
Résultat attendu : {expected_result}
        
Analyse la capture d'écran et réponds au format JSON :
{{
    "success": true/false,
    "feedback": "description de ce que tu observes réellement",
    "needs_retry": true/false,
    "suggested_fix": "action corrective si nécessaire"
}}
"""
        
        response = self.client.chat.completions.create(
            model="deepseek-chat-v3",
            messages=[
                {"role": "system", "content": "Tu es un expert en vérification d'actions UI."},
                {"role": "user", "content": [
                    {"type": "text", "text": verification_prompt},
                    {"type": "image_url", "image_url": {
                        "url": f"data:image/jpeg;base64,{image_base64}"
                    }}
                ]}
            ],
            max_tokens=300
        )
        
        return json.loads(response.choices[0].message.content)
    
    def run_smart_task(self, instruction, max_iterations=15):
        """Version intelligente avec vérification automatique"""
        print(f"\n🚀 Démarrage de la tâche SMART : {instruction}")
        print("=" * 60)
        
        for iteration in range(max_iterations):
            print(f"\n📍 Itération {iteration + 1}/{max_iterations}")
            
            # Analyse et décision
            action_data = self.analyze_screen(instruction)
            action_type = action_data.get("action")
            
            print(f"💭 Action planifiée : {action_type}")
            print(f"   → {action_data.get('reasoning', '')}")
            
            # Cas spécial : terminaison
            if action_type == "complete":
                print("\n🎉 Tâche terminée avec succès !")
                return True
            
            # Exécution de l'action
            self.execute_action(action_data)
            self.action_history.append(action_data)
            
            # Vérification du résultat
            print("\n🔍 Vérification du résultat...")
            time.sleep(1.5)  # Attendre la mise à jour de l'écran
            
            verification = self.verify_action(
                action_data.get("reasoning", "action réussie")
            )
            
            if verification["success"]:
                print(f"   ✅ Vérifié : {verification['feedback']}")
            else:
                print(f"   ⚠️ Résultat inattendu : {verification['feedback']}")
                
                if verification["needs_retry"] and iteration < max_iterations - 1:
                    print(f"   🔧 Tentative de correction...")
                    # L'agent analysera automatiquement la nouvelle situation
                    continue
                    
        print(f"\n⚠️ Limite d'itérations atteinte")
        return False

Guide Visuel : Schéma de Fonctionnement

Pour mieux visualiser le processus, voici l'architecture en étapes :

Cas d'Usage Concrets

Automatisation de Saisie de Données

Imaginez un tableau avec 100 lignes à remplir. Au lieu de le faire manuellement, votre agent peut :

  1. Analyser la structure du formulaire
  2. Comprendre où inserer chaque donnée
  3. Cliquer sur le bon champ
  4. Saisir l'information
  5. Passer à la ligne suivante

Test Automatisé d'Applications

Les développeurs peuvent créer des agents qui testent automatiquement les interfaces utilisateur :

Scraping Intelligent

Au lieu d'écrire des scrapers complexes avec XPath ou CSS selectors, vous pouvez simplement dire à l'agent : "Récupère toutes les offres d'emploi de cette page et enregistre-les dans un fichier Excel".

Erreurs Courantes et Solutions

Erreur 1 : "ModuleNotFoundError: No module named 'openai'"

Symptôme : Le script ne démarre pas et affiche une erreur d'import.

Cause : La bibliothèque OpenAI n'est pas installée ou vous utilisez une version ancienne.

Solution : Réinstallez les dépendances avec cette commande :

pip install --upgrade openai Pillow pyautogui numpy python-dotenv

Ressources connexes

Articles connexes