Qu’est-ce que Gemini 3.1 Pro Customtools ? Comprenez l’utilisation du modèle privilégiant les outils personnalisés en 5 minutes

Beaucoup de développeurs sont perplexes lorsqu'ils voient le nom de modèle gemini-3.1-pro-preview-customtools : que signifie "customtools" ? En quoi est-il différent du gemini-3.1-pro-preview standard ? Cet article vous aide à y voir clair en 5 minutes.

Valeur ajoutée : À la fin de cette lecture, vous saurez quand utiliser la version standard, quand préférer la version customtools, et comment faire le bon choix pour le développement de vos Agents.

Qu'est-ce que Gemini 3.1 Pro Customtools ?

L'explication en une phrase

gemini-3.1-pro-preview-customtools est une variante dédiée publiée par Google le 19 février 2026, en même temps que la version standard de Gemini 3.1 Pro. Sa seule différence majeure avec la version standard est qu'elle donne la priorité aux outils personnalisés que vous avez enregistrés, plutôt que d'exécuter des commandes bash par défaut.

Voici ce que dit textuellement le Changelog officiel de Google :

Lancement d'un point de terminaison séparé gemini-3.1-pro-preview-customtools, qui priorise mieux les outils personnalisés, pour les utilisateurs travaillant avec un mélange de bash et d'outils.

Pourquoi cette variante est-elle nécessaire ?

Dans le développement d'Agents, les développeurs enregistrent généralement deux types de capacités pour le modèle :

1. Exécution Bash/Code : Permet au modèle d'exécuter directement des commandes shell.
2. Outils personnalisés (Custom Tools) : Des fonctions structurées définies par le développeur, comme view_file, search_code, create_pr, etc.

Où est le problème ? La version standard de Gemini 3.1 Pro a parfois tendance à être "paresseuse" : elle ignore vos outils personnalisés soigneusement conçus pour utiliser directement des commandes bash afin d'accomplir la tâche. Par exemple, même si vous avez enregistré un outil view_file, le modèle pourrait décider d'exécuter cat filename.py, court-circuitant ainsi votre outil.

Cela pose problème dans certains scénarios :

• Les outils personnalisés peuvent inclure un contrôle des permissions et une journalisation (logs).
• Le format de retour des outils personnalisés est structuré, ce qui facilite le traitement ultérieur.
• Les outils personnalisés peuvent être connectés à des systèmes externes (bases de données, API, etc.).

La variante customtools a été créée pour résoudre ce problème : forcer le modèle à privilégier les outils que vous avez enregistrés.

Différences clés entre Gemini 3.1 Pro Standard et la version Customtools

🎯 Compréhension clé : Le « niveau d'intelligence » des deux modèles est strictement identique. La seule différence réside dans le choix que fait le modèle face au dilemme : « Dois-je utiliser bash ou l'outil que vous avez enregistré ? ». La version customtools aura davantage tendance à choisir vos outils personnalisés.

Dans quels cas utiliser Gemini 3.1 Pro Customtools ?

Scénarios nécessitant la version customtools

Scénarios où la version standard suffit

Le conseil officiel de Google

Google précise explicitement dans la FAQ du guide du développeur Gemini 3 :

If you are using gemini-3.1-pro-preview and the model ignores your custom tools in favor of bash commands, try the gemini-3.1-pro-preview-customtools model instead.

Traduction : Si vous constatez que la version standard ignore vos outils personnalisés au profit de commandes bash, essayez plutôt le modèle gemini-3.1-pro-preview-customtools.

Méthodes d'appel de l'API Gemini 3.1 Pro Customtools

Appel de base : exactement comme la version standard

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface unifiée APIYI
)

# Il suffit de changer le nom du modèle, le reste du code demeure inchangé
response = client.chat.completions.create(
    model="gemini-3.1-pro-preview-customtools",
    messages=[
        {"role": "user", "content": "Aide-moi à consulter le contenu du fichier main.py dans le projet"}
    ]
)
print(response.choices[0].message.content)

Appel d'Agent avec outils personnalisés

La véritable puissance de la version customtools réside dans son utilisation avec le function calling :

import openai
import json

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interface unifiée APIYI
)

# Définition des outils personnalisés
tools = [
    {
        "type": "function",
        "function": {
            "name": "view_file",
            "description": "Afficher le contenu d'un fichier spécifié",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "Chemin du fichier"
                    }
                },
                "required": ["file_path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_code",
            "description": "Rechercher des mots-clés dans la base de code",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Mot-clé de recherche"
                    },
                    "file_pattern": {
                        "type": "string",
                        "description": "Modèle de correspondance de fichier, ex: *.py"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# La version customtools utilisera en priorité les outils définis ci-dessus
response = client.chat.completions.create(
    model="gemini-3.1-pro-preview-customtools",
    messages=[
        {"role": "user", "content": "Aide-moi à trouver tous les fichiers Python contenant TODO dans le projet"}
    ],
    tools=tools
)

# Le modèle appellera l'outil search_code au lieu d'utiliser directement grep
tool_call = response.choices[0].message.tool_calls[0]
print(f"Outil : {tool_call.function.name}")
print(f"Paramètres : {tool_call.function.arguments}")

import openai
import json

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "view_file",
            "description": "Afficher le contenu d'un fichier spécifié",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {"type": "string", "description": "Chemin du fichier"}
                },
                "required": ["file_path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_code",
            "description": "Rechercher des mots-clés dans la base de code",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Mot-clé de recherche"},
                    "file_pattern": {"type": "string", "description": "Modèle de correspondance de fichier"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "edit_file",
            "description": "Modifier un contenu spécifique dans un fichier",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {"type": "string", "description": "Chemin du fichier"},
                    "old_content": {"type": "string", "description": "Ancien contenu à remplacer"},
                    "new_content": {"type": "string", "description": "Nouveau contenu"}
                },
                "required": ["file_path", "old_content", "new_content"]
            }
        }
    }
]

# Simulation de l'exécution des outils
def execute_tool(name, args):
    """À remplacer par une implémentation réelle dans un projet concret"""
    if name == "view_file":
        return f"Contenu du fichier : {args['file_path']} (simulé)"
    elif name == "search_code":
        return f"Résultats pour '{args['query']}' : 3 correspondances trouvées (simulé)"
    elif name == "edit_file":
        return f"Le contenu de {args['file_path']} a été remplacé (simulé)"
    return "Outil inconnu"

# Boucle principale de l'Agent
messages = [{"role": "user", "content": "Trouve tous les commentaires TODO dans le projet et répare-les"}]
max_turns = 5

for turn in range(max_turns):
    response = client.chat.completions.create(
        model="gemini-3.1-pro-preview-customtools",
        messages=messages,
        tools=tools
    )

    msg = response.choices[0].message
    messages.append(msg)

    if msg.tool_calls:
        for tc in msg.tool_calls:
            args = json.loads(tc.function.arguments)
            result = execute_tool(tc.function.name, args)
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": result
            })
            print(f"[Tour {turn+1}] Appel : {tc.function.name}({args})")
    else:
        print(f"[Terminé] {msg.content[:200]}")
        break

🚀 Démarrage rapide : Via la plateforme APIYI (apiyi.com), la version standard et la version customtools utilisent la même clé API. Il suffit de modifier le paramètre model pour basculer, ce qui est idéal pour tester en A/B quelle version convient le mieux à votre Agent.

Relation entre Gemini 3.1 Pro Customtools et les frameworks d'Agent

Compatibilité avec les principaux frameworks d'Agent

La version customtools est particulièrement précieuse pour les scénarios de développement d'Agent suivants :

Comparaison du comportement entre Gemini 3.1 Pro Customtools et la version standard

Pour mieux comprendre la différence, jetons un œil à un exemple concret :

Une même requête, deux réactions différentes selon le modèle

Requête utilisateur : « Aide-moi à voir le contenu du fichier src/main.py »

Outil enregistré : view_file(file_path: string)

Les deux approches permettent d'obtenir le contenu du fichier, mais l'appel via un outil personnalisé présente les avantages suivants :

1. Contrôle des permissions : Votre outil view_file peut vérifier si le chemin est dans une liste blanche.
2. Sortie formatée : L'outil peut renvoyer du JSON structuré plutôt que du texte brut.
3. Audit des logs : Les appels d'outils sont automatiquement enregistrés par le framework.
4. Gestion des erreurs : L'outil peut fournir des messages d'erreur conviviaux au lieu d'erreurs bash.

Évolution des modèles d'appel d'outils Google Gemini

Customtools est la première variante de modèle dédiée à l'appel d'outils proposée par Google. Voici la cartographie complète des modèles Gemini liés aux outils :

Cela montre que Google segmente ses modèles par scénario d'utilisation, plutôt que d'essayer de couvrir tous les besoins avec un seul modèle généraliste. D'autres variantes spécialisées apparaîtront probablement à l'avenir.

Foire aux questions

Résumé : Aide-mémoire Gemini 3.1 Pro Customtools

En une phrase : gemini-3.1-pro-preview-customtools est en quelque sorte le « mode spécial Agent » de Gemini 3.1 Pro — il rend le modèle plus docile pour utiliser vos outils enregistrés plutôt que de lancer directement du bash. Le prix ne change pas, l'intelligence non plus, c'est juste la stratégie de sélection d'outils qui est mieux adaptée au développement d'Agents.

Nous vous recommandons d'accéder aux deux versions via la plateforme APIYI (apiyi.com) pour effectuer des tests A/B sur vos projets réels et choisir la plus adaptée. Pour les développeurs d'Agents, la version customtools est presque toujours le meilleur choix.

Ressources complémentaires

1. Documentation Google AI : Page du modèle Gemini 3.1 Pro Preview

   • Lien : ai.google.dev/gemini-api/docs/models/gemini-3.1-pro-preview
   • Note : Contient une comparaison entre la version standard et la version customtools.

2. Changelog de l'API Gemini : Mise à jour du 19 février 2026

   • Lien : ai.google.dev/gemini-api/docs/changelog
   • Note : Première annonce de la variante customtools.

3. Guide du développeur Gemini 3 : Conseils sur le choix des outils dans la FAQ

   • Lien : ai.google.dev/gemini-api/docs/gemini-3
   • Note : Quand passer de la version standard à la version customtools.

4. Documentation Google AI : Guide sur l'appel de fonctions (Function Calling)

   • Lien : ai.google.dev/gemini-api/docs/function-calling
   • Note : Détails sur l'API d'appel de fonctions des modèles Gemini.

📝 Auteur : Équipe APIYI | Pour toute discussion technique, visitez APIYI sur apiyi.com
📅 Dernière mise à jour : 20 février 2026
🏷️ Mots-clés : gemini-3.1-pro-preview-customtools, outils personnalisés, développement d'agents, function calling, appel d'outils, appel d'API