La fonction auto_toolkit
Cette fonction génère dynamiquement une liste de `FunctionTool` LlamaIndex à partir des fonctions publiques d’un module Python.
Elle inspecte les fonctions du module fourni, applique des filtres d’inclusion/exclusion, et transforme chaque fonction retenue en outil agentifiable (`FunctionTool`) via l’examen de sa signature et de sa documentation.
Paramètres :
module (ModuleType) :
Le module Python à analyser (ex. : `statistics`, `math`, ou un module métier).
include (List[str], optionnel) :
Liste blanche : noms de fonctions à inclure explicitement. Si None, inclut toutes les fonctions publiques.
exclude (List[str], optionnel) :
Liste noire : noms de fonctions à ignorer. Prioritaire sur `include`.
verbose (bool, optionnel) :
Si True, affiche dans la console les outils ajoutés et les erreurs éventuelles.
Retour :
List[FunctionTool] :
Liste des objets `FunctionTool` générés à partir des fonctions sélectionnées.
Usage :
from modules.tools.tool_factory import auto_toolkit
tools = auto_toolkit(
statistics,
include=["mean", "stdev", "median"],
tags=["statistique"],
verbose=True
Voici l’essentiel du code :
- ## Usinage ##
- def auto_toolkit(
- module: ModuleType,
- *,
- include: List[str] = None,
- exclude: List[str] = None,
- verbose: bool = False,
- **kwargs
- ) -> List[FunctionTool]:
- """
- Génère une liste de FunctionTool LlamaIndex à partir des fonctions publiques d’un module.
- Applique automatiquement les décorateurs d’entrée/sortie pour compatibilité agentique.
- Test : test_auto_toolkit.py
- Paramètres
- ----------
- module : ModuleType
- Module Python à inspecter (ex. statistics, math, ou module maison)
- include : list of str, optional
- Liste blanche : noms de fonctions à inclure (si spécifié)
- exclude : list of str, optional
- Liste noire : noms de fonctions à ignorer
- verbose : bool
- Si True, affiche les outils ajoutés
- **kwargs : dict
- Métadonnées supplémentaires à passer à `as_llama_tool` (ex. tags, metadata, etc.)
- Returns
- -------
- List[FunctionTool]
- Liste d’outils LlamaIndex prêts à être enregistrés dans un agent
- """
- tools = []
- total = 0
- success = 0
- for name, fn in inspect.getmembers(module, inspect.isfunction):
- if name.startswith("_"):
- continue
- if include and name not in include:
- continue
- if exclude and name in exclude:
- continue
- total += 1
- try:
- # Application des décorateurs d’entrée et de sortie
- decorated_fn = react_tool_output(react_tool_input(fn))
- decorated_fn = react_tool_output(name)(decorated_fn )
- # Création du FunctionTool avec métadonnées
- tool = as_llama_tool(
- name=name,
- **kwargs
- )(decorated_fn)
- tools.append(tool)
- success += 1
- if verbose:
- trace(f"Outil ajouté : {get_tool_name(tool)}", logger)
- except Exception as e:
- trace(f"Erreur lors de l'ajout de l'outil '{name}': {e}", logger)
- trace(f"{success} outils ajoutés avec succès sur {total} fonctions inspectées.", logger)
- return tools
Voici le code pour générer automatiquement des outils de fonction à partir du module ’statistiques. Noter que l’on peut choisir les fonctions à importer.
- from modules.tools.tool_factory import auto_toolkit
- tools += auto_toolkit(
- statistics,
- include=["mean", "stdev", "median", "variance"],
- verbose=True
- )
Modules Python et fonctions utilisables
Tous les modules Python ne sont pas pertinents pour produire des FunctionTool exploitables dans un agent. Voici une sélection affinée, classée selon leur **pertinence, c’est-à-dire leur capacité à fournir des fonctions :
- publiques
- pures ou quasi-pures
- typées
- documentées
- auto-validables via fn_schema
| Module | Pertinence |
|---|---|
| statistics | Fonctions bien typées, docstring claires, signatures simples |
| math | Fonctions scalaires pures, typées, robustes |
| cmath | Idem, mais pour les complexes |
| decimal | Fonctions précises pour calculs financiers |
| fractions | Manipulation exacte de rationnels |
| datetime | Fonctions de manipulation de dates (attention à la mutabilité) |
| calendar | Fonctions pures sur les jours, semaines, années |
| itertools | Générateurs utiles, mais nécessite des wrappers pour être agentifiables |
| functools (partiellement) | Quelques fonctions décorables (ex. reduce) si bien encapsulées |
Voici un tableau synthétique des fonctions principales pour chaque module Python standard qui peuvent être transformés en FunctionTool par tool_factory, avec leur description.* Ces fonctions sont typées, documentées, et généralement compatibles avec FunctionTool*.
statistics — Statistiques descriptives
| Fonction | Description |
|---|---|
| mean(data) | Moyenne arithmétique |
| fmean(data) | Moyenne arithmétique rapide (float uniquement) |
| geometric_mean(data) | Moyenne géométrique |
| harmonic_mean(data) | Moyenne harmonique |
| median(data) | Médiane |
| median_low(data) | Plus grande valeur ≤ médiane |
| median_high(data) | Plus petite valeur ≥ médiane |
| median_grouped(data, interval=1) | Médiane pour données groupées |
| mode(data) | Valeur la plus fréquente |
| multimode(data) | Liste des valeurs les plus fréquentes |
| pstdev(data, mu=None) | Écart-type de la population |
| stdev(data, xbar=None) | Écart-type de l’échantillon |
| pvariance(data, mu=None) | Variance de la population |
| variance(data, xbar=None) | Variance de l’échantillon |
| quantiles(data, , n=4, method=’exclusive’)* | Découpe en quantiles |
| covariance(x, y) | Covariance entre deux séries |
| correlation(x, y) | Corrélation de Pearson |
| linear_regression(x, y) | Régression linéaire (renvoie pente et intercept) |
math — Mathématiques de base
| Fonction | Description |
|---|---|
| sqrt(x) | Racine carrée |
| exp(x) | Exponentielle |
| log(x, base=math.e) | Logarithme (base e par défaut) |
| log10(x) | Logarithme décimal |
| log2(x) | Logarithme base 2 |
| pow(x, y) | Puissance ( x^y ) |
| fabs(x) | Valeur absolue |
| factorial(x) | Factorielle |
| gcd(a, b) | Plus grand commun diviseur |
| lcm(a, b) | Plus petit commun multiple |
| ceil(x) | Arrondi supérieur |
| floor(x) | Arrondi inférieur |
| trunc(x) | Troncature (partie entière) |
| sin(x), cos(x), tan(x) | Fonctions trigonométriques |
| degrees(x), radians(x) | Conversion angle ↔ radians |
| isclose(a, b) | Comparaison flottante |
| isnan(x), isinf(x), isfinite(x) | Tests numériques |
cmath — Mathématiques complexes
| Fonction | Description |
|---|---|
| sqrt(x) | Racine carrée complexe |
| exp(x) | Exponentielle complexe |
| log(x, base=math.e) | Log complexe |
| phase(x) | Argument (angle) d’un nombre complexe |
| polar(x) | Coordonnées polaires |
| rect(r, phi) | Conversion polaire → cartésien |
| sin(x), cos(x), tan(x) | Trigonométrie complexe |
decimal — Calculs décimaux précis
| Fonction | Description |
|---|---|
| Decimal(x) | Crée un nombre décimal précis |
| getcontext() | Accès au contexte (précision, arrondi) |
| setcontext(ctx) | Définit un contexte personnalisé |
| localcontext() | Contexte temporaire |
| Méthodes : sqrt(), ln(), exp(), quantize(), etc. | Opérations précises sur Decimal |
fractions — Calculs exacts avec fractions
| Fonction | Description |
|---|---|
| Fraction(x) | Crée une fraction exacte |
| limit_denominator(max_denominator) | Approximation avec dénominateur borné |
| Opérations : +, -, *, /, ** | Calculs exacts entre fractions ou entiers |
datetime — Dates et heures
| Fonction | Description |
|---|---|
| datetime(year, month, day, ...) | Objet date-heure |
| date(year, month, day) | Objet date |
| time(hour, minute, ...) | Objet heure |
| timedelta(...) | Durée |
| now(), today(), utcnow() | Horodatages actuels |
| Méthodes : isoformat(), weekday(), strftime() | Formatage et manipulation |
calendar — Calendriers
| Fonction | Description |
|---|---|
| isleap(year) | Année bissextile ? |
| monthrange(year, month) | Premier jour et nombre de jours |
| monthcalendar(year, month) | Matrice des semaines |
| weekday(year, month, day) | Jour de la semaine |
| month_name, day_name | Noms localisés |
RSS 2.0