Combiner Computer Use avec d'autres tools

L’IA ne se limite pas à l’écran

Computer Use est puissant seul, mais il devient redoutable quand vous le combinez avec d’autres outils (tools) de l’API Claude. Tant que l’agent ne dispose que de la souris et du clavier, tout ce qu’il extrait reste prisonnier de sa conversation : pour l’écrire en base, il faudrait qu’il ouvre un client SQL à l’écran. En lui donnant des fonctions, vous lui offrez une seconde main. Le modèle peut alors utiliser Computer Use pour naviguer sur le web ET appeler des fonctions personnalisées pour traiter les données, interroger des bases de données ou interagir avec des API tierces.

L’architecture multi-tools

L’API Claude permet de déclarer plusieurs outils dans un même appel, et le modèle choisit l’outil le plus adapté à chaque étape. La déclaration ci-dessous en réunit trois : l’outil Computer Use, identifié par son type versionné et ses dimensions d’écran, puis deux outils maison décrits par un schéma JSON. Remarquez que les outils personnalisés se définissent uniquement par leur nom, leur description et la forme de leurs paramètres — c’est la description en langage naturel qui détermine si le modèle saura les invoquer au bon moment, elle mérite donc autant de soin que le code qu’elle expose.

import anthropic

client = anthropic.Anthropic()

tools = [
    # Outil 1 : Computer Use (navigation visuelle)
    {
        "type": "computer_20241022",
        "name": "computer",
        "display_width_px": 1280,
        "display_height_px": 720,
    },
    # Outil 2 : Sauvegarder dans une base de données
    {
        "name": "save_to_database",
        "description": "Sauvegarde des données extraites dans PostgreSQL.",
        "input_schema": {
            "type": "object",
            "properties": {
                "table": {"type": "string", "description": "Nom de la table"},
                "data": {"type": "object", "description": "Données à insérer"},
            },
            "required": ["table", "data"],
        },
    },
    # Outil 3 : Envoyer un email de notification
    {
        "name": "send_email",
        "description": "Envoie un email de notification.",
        "input_schema": {
            "type": "object",
            "properties": {
                "to": {"type": "string"},
                "subject": {"type": "string"},
                "body": {"type": "string"},
            },
            "required": ["to", "subject", "body"],
        },
    },
]

Dispatch des outils

Déclarer les outils ne les implémente pas : le modèle demande, votre code exécute. Votre boucle principale doit donc maintenant router les appels vers le bon outil en fonction du nom reçu. La seule subtilité concerne la valeur de retour. Un appel Computer Use doit répondre par un nouveau screenshot, puisque c’est le seul moyen pour le modèle de constater l’effet de son clic ; un appel à save_to_database ou send_email renvoie simplement un accusé de traitement. Prévoyez systématiquement une branche par défaut pour les noms inconnus, sans quoi un outil mal orthographié fait planter la boucle au lieu de remonter une erreur exploitable par le modèle.

def dispatch_tool(tool_name: str, tool_input: dict, page=None):
    """Route l'appel vers le bon outil."""

    if tool_name == "computer":
        # Action Computer Use sur le navigateur
        execute_action(page, tool_input)
        return capture_screenshot(page)

    elif tool_name == "save_to_database":
        # Insertion en base de données
        return save_to_db(tool_input["table"], tool_input["data"])

    elif tool_name == "send_email":
        # Envoi d'email via SMTP
        return send_notification(
            to=tool_input["to"],
            subject=tool_input["subject"],
            body=tool_input["body"],
        )

    else:
        return {"error": f"Outil inconnu : {tool_name}"}

Cas concret : veille concurrentielle

Voici un workflow complet qui combine navigation web et traitement de données. La mission décrit les trois phases en nommant explicitement l’outil attendu à chaque fois, ce qui aide le modèle à ne pas tenter d’envoyer un email en cliquant dans une interface web alors qu’une fonction dédiée existe.

task = """
Tu es un agent de veille concurrentielle. Voici ta mission :

1. NAVIGATION (Computer Use) :
   - Va sur https://competitor.example.com/pricing
   - Extrais tous les plans tarifaires (nom, prix, fonctionnalités)

2. SAUVEGARDE (save_to_database) :
   - Sauvegarde chaque plan dans la table 'competitor_pricing'
   - Inclus la date d'extraction

3. NOTIFICATION (send_email) :
   - Envoie un résumé à [email protected]
   - Sujet : "Mise à jour tarifs [concurrent] - [date]"
   - Corps : tableau récapitulatif des prix
"""

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    tools=tools,
    system="Tu es un agent de veille. Utilise les outils disponibles.",
    messages=[{"role": "user", "content": task}],
)

Le modèle va automatiquement alterner entre Computer Use (pour naviguer) et les autres outils (pour sauvegarder et notifier). Concrètement, vous verrez passer une dizaine d’actions de navigation, puis un appel save_to_database par plan tarifaire, puis un unique send_email : l’agent regroupe de lui-même les résultats parce que la mission le lui demande.

Boucle multi-tools complète

La boucle d’exécution reprend la structure que vous connaissez, avec une nuance importante : chaque tour peut contenir plusieurs blocs tool_use, et vous devez tous les traiter avant de rendre la main au modèle. Les résultats sont accumulés dans une liste puis renvoyés en un seul message de rôle user, chaque entrée reliée à sa demande par le tool_use_id. Une réponse dont le stop_reason vaut end_turn signale que le modèle considère la mission terminée et livre sa synthèse en texte.

def multi_tool_loop(task: str, page, max_iterations: int = 20):
    """Boucle principale avec plusieurs outils."""
    messages = [{"role": "user", "content": task}]

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-5",
            max_tokens=4096,
            tools=tools,
            messages=messages,
        )

        # Ajouter la réponse du modèle
        messages.append({"role": "assistant", "content": response.content})

        # Fin de la tâche
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    print(f"Résultat final : {block.text}")
            break

        # Exécuter les outils demandés
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                print(f"  Outil : {block.name} — {block.input}")
                result = dispatch_tool(block.name, block.input, page)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": str(result),
                })

        messages.append({"role": "user", "content": tool_results})

    return messages

Outils complémentaires courants

Les outils que vous adjoindrez à Computer Use se rangent dans un petit nombre de familles, chacune répondant à un besoin récurrent des agents de navigation.

Points clés à retenir

• Déclarez tous vos outils (Computer Use + custom) dans le même appel API
• Le modèle choisit automatiquement l’outil le plus adapté à chaque étape
• Le dispatch des outils se fait dans votre boucle principale côté client
• Combiner navigation visuelle et traitement de données crée des agents très puissants
• Gardez les outils simples et bien documentés pour que le modèle les utilise correctement