Definir un outil avec son schema JSON

Tu demarres un projet ambitieux : construire un agent web intelligent, dans le style de Perplexity. Un programme capable de chercher sur le web, lire des pages, et repondre a tes questions avec des sources. A la fin de cette serie, tu auras un agent complet que tu pourras montrer en portfolio.

Premiere etape : comprendre comment un LLM peut utiliser des outils. Quand tu parles a ChatGPT et qu'il cherche sur le web ou execute du code, il ne fait pas ca par magie. Il utilise un mecanisme appele function calling. Tu lui donnes une liste d'outils disponibles avec leur description, et il choisit lequel appeler en fonction de la question.

Chaque outil est decrit par un schema JSON. C'est une fiche d'identite qui dit au LLM : voici le nom de l'outil, ce qu'il fait, et quels parametres il attend. Le format suit la specification OpenAI :

{
"type": "function",
"function": {
"name": "calculer",
"description": "Evalue une expression mathematique",
"parameters": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "L'expression a calculer, par exemple 2 + 3 * 4"
}
},
"required": ["expression"]
}
}
}

Ecris une fonction creer_schema_outil(nom, description, parametres) qui prend le nom de l'outil (string), sa description (string), et un dictionnaire de parametres. Chaque cle du dictionnaire parametres est le nom du parametre, et la valeur est un dictionnaire avec "type" et "description". La fonction renvoie le schema JSON complet au format OpenAI.

Ecris aussi une fonction creer_boite_a_outils(outils) qui prend une liste de tuples (fonction, schema) et renvoie un dictionnaire ou chaque cle est le nom de l'outil et la valeur est la fonction correspondante. Ca servira plus tard pour dispatcher les appels.

Exemple :

schema = creer_schema_outil(
"rechercher_web",
"Cherche des informations sur le web",
{"query": {"type": "string", "description": "La requete de recherche"}}
)
schema["function"]["name"] renvoie "rechercher_web"
schema["type"] renvoie "function"

def ma_fonction(query): return "resultat"
boite = creer_boite_a_outils([(ma_fonction, schema)])
"rechercher_web" in boite renvoie True

Tests (4/5)

Schema avec un parametre

import json
s = creer_schema_outil("rechercher", "Cherche sur le web", {"query": {"type": "string", "description": "Requete"}})
assert s["type"] == "function", "Le type doit etre 'function'"
assert s["function"]["name"] == "rechercher"
assert s["function"]["description"] == "Cherche sur le web"
props = s["function"]["parameters"]["properties"]
assert "query" in props, "Le parametre 'query' doit etre dans properties"
assert props["query"]["type"] == "string"

Schema avec plusieurs parametres

s = creer_schema_outil("lire_page", "Lit une page web", {
    "url": {"type": "string", "description": "URL de la page"},
    "max_chars": {"type": "integer", "description": "Nombre max de caracteres"}
})
props = s["function"]["parameters"]["properties"]
assert len(props) == 2, f"Attendu 2 parametres, obtenu {len(props)}"
assert "url" in props and "max_chars" in props
required = s["function"]["parameters"]["required"]
assert "url" in required and "max_chars" in required

Boite a outils basique

def chercher(query): return "resultats"
def calculer(expr): return "42"
s1 = creer_schema_outil("chercher", "Recherche", {"query": {"type": "string", "description": "q"}})
s2 = creer_schema_outil("calculer", "Calcul", {"expr": {"type": "string", "description": "e"}})
boite = creer_boite_a_outils([(chercher, s1), (calculer, s2)])
assert len(boite) == 2, f"Attendu 2 outils, obtenu {len(boite)}"
assert boite["chercher"]("test") == "resultats"
assert boite["calculer"]("1+1") == "42"

Boite a outils vide

boite = creer_boite_a_outils([])
assert isinstance(boite, dict), "La boite doit etre un dictionnaire"
assert len(boite) == 0, "La boite vide ne doit contenir aucun outil"

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def creer_schema_outil(nom, description, parametres):
    properties = {}
    required = []
    for nom_param, info in parametres.items():
        properties[nom_param] = {
            "type": info["type"],
            "description": info["description"]
        }
        required.append(nom_param)
    return {
        "type": "function",
        "function": {
            "name": nom,
            "description": description,
            "parameters": {
                "type": "object",
                "properties": properties,
                "required": required
            }
        }
    }

def creer_boite_a_outils(outils):
    boite = {}
    for fonction, schema in outils:
        nom = schema["function"]["name"]
        boite[nom] = fonction
    return boite

← Deployer sur Streamlit Cloud Function calling : le LLM … →

solution.py

Bravo!

Definir un outil avec son schema JSON

Tests (4/5)

Indices (3 disponibles)

Solution officielle