extraction d'entités Go

Extraction d’entités Go : maîtriser le Function Calling

Parjerome
Tutoriel Go

Extraction d'entités Go : maîtriser le Function Calling

L’extraction d’entités Go est une technique devenue indispensable pour les développeurs souhaitant transformer le texte non structuré en données typées et exploitables par un système logiciel. Dans un monde dominé par les Large Language Models (LLM), la capacité à extraire des informations précises, comme des noms, des dates ou des montants, sans dépendre de règles Regex fragiles, est un avantage compétitif majeur. Cet article s’adresse aux ingénieurs backend et aux experts en IA qui cherchent à intégrer l’intelligence générative dans des pipelines de données robustes.

Le contexte actuel de l’IA générative nous montre que si les modèles comme GPT-4 sont incroyablement intelligents, ils restent intrinsèquement probabilistes et peuvent produire du texte imprévisible. C’est ici que l’extraction d’entités Go intervient comme un pont entre le chaos du langage naturel et la rigueur du typage fort de Go. En utilisant les capacités de « function calling » et les schémas JSON, nous pouvons forcer le modèle à respecter un contrat de données strict, garantissant ainsi la stabilité de nos applications de production.

Dans ce guide approfondi, nous explorerons d’abord les fondements théoriques de la structuration des sorties LLM via JSON Schema. Nous verrons ensuite une implémentation pratique en Go utilisant une structure de données typée pour capturer des informations d’un texte brut. Nous détaillerons ensuite comment automatiser ce processus pour des cas d’usage complexes, avant d’aborder les pièges classiques et les meilleures pratiques pour maintenir une haute précision. Vous apprendrez à transformer n’importe quel flux de texte en un objet Go structuré, prêt pour l’insertion en base de données ou le traitement métier.

extraction d'entités Go
extraction d'entités Go — illustration

🛠️ Prérequis

Avant de plonger dans le code, assurez-vous de disposer de l’environnement suivant :

  • Go 1.21 ou supérieur : La gestion des generics et les améliorations de la bibliothèque standard sont recommandées.
  • Accès à une API de LLM : Une clé API valide pour OpenAI (GPT-4o) ou Anthion est nécessaire pour tester le function calling.
  • Installation de la librairie client : Vous devrez installer le SDK Go pour OpenAI en exécutant la commande suivante : go get github.com/sashabaranov/go-openai.
  • Connaissances en JSON : Une maîtrise du format JSON et de l’encodage/décodage en Go via le package encoding/json est indispensable.
  • Outils de test : Un environnement capable d’exécuter des tests unitaires Go standard.

📚 Comprendre extraction d'entités Go

Pour comprendre l’extraction d’entités Go, il faut d’abord visualiser le problème de la donnée non structurée. Imaginez un assistant (le LLM) qui lit un contrat juridique. Si vous lui demandez simplement « Quelles sont les dates importantes ? », il vous répondra par une liste de phrases. Si vous utilisez le function calling, c’est comme si vous lui donniez un formulaire pré-rempli avec des cases spécifiques pour « Date de signature » et « Date d’expiration ».

Le mécanisme de l’extraction d’un point de vue structurel

Le concept repose sur trois piliers technologiques :

  • Le Prompting : L’instruction textuelle qui définit la tâche.
  • Le JSON Schema : Le contrat technique qui définit la structure, les types (string, integer, boolean) et les contraintes (regex, enum) de la sortie attendue.
  • Le Function Calling (ou Tool Use) : La capacité du modèle à décider d’appeler une fonction spécifique en remplissant les arguments de cette fonction selon le schéma fourni.

Contrairement aux approches historiques utilisant le Regex (Expression Régulière) qui échouent dès qu’une virgule change de place, ou les approches de NLP classiques (NER – Named Entity Recognition) qui nécessitent un entraînement de modèle spécifique, l’approche par schema-driven extraction est dynamique. En Go, cela nous permet d’utiliser la puissance du typage statique pour valider les sorties du modèle avant même qu’elles ne touchent notre logique métier. Si le modèle tente d’insérer une chaîne là où un entier est attendu, le décodage JSON échouera immédiatement, protégeant ainsi l’intégrité de notre système.

Analogie : Le LLM est un chef cuisinier talentueux mais imprévisible. Le JSON Schema est la recette précise. Le Function Calling est l’action de placer les ingrédients exactement dans les bons récipients marqués pour ne pas contaminer le plat final.

extraction d'entités Go
extraction d'entités Go

🐹 Le code — extraction d'entités Go

Go
package main

import (
	"context"
	<"encoding/json">\
	"fmt"\
	"log"\

	"github.com/sashabaranov/go-openai"\
)

// Entity représente la structure de donnée que nous voulons extraire
type Entity struct {
	Name      string `json:"name"`
	Role      string `json:"role"`
	Importance int    `json:"importance"`
}

func main() {
	client := openai.NewClient("YOUR_API_KEY")
	ctx := context.Background()

	// Le texte brut à analyser
	inputText := "Jean Dupont est le directeur technique, il est crucial pour le projet avec un niveau de priorité de 10."

	// Définition de l'outil (Function Calling)
	tool := openai.Tool{
		Type: openai.ToolTypeFunction,
		Function: &openai.FunctionDefinition{
			Name:        "extract_person_info",
			Description: "Extrait les informations d'une personne d'un texte.",
           Parameters: map[string]interface{}{
				"type": "object",
				"properties": map[string]interface{}{
					"name":       map[string]string{"type": "string"},\
					"role":       map[string]string{"type": "string"},\
					"importance": map[string]string{"type": "integer"},\
				},\
				"required": []string{"name", "role", "importance"},\
			},
		},
	}

	resp, err := client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
		Model: openai.GPT4o,
		Messages: []openai.ChatCompletionMessage{
			{Role: openai.ChatMessageRoleUser, Content: inputText},
		},
		Tools:    []openai.Tool{tool},\
		ToolChoice: openai.ToolChoiceFunctionCall("extract_person_info"),
	})

	if err != nil {
		log.Fatalf("Erreur API: %v", err)
	}

	// Extraction des arguments de l'appel de fonction
	toolCall := resp.Choices[0].Message.ToolCalls[0]
	var extracted Entity
	err = json.Unmarshal([]byte(toolCall.Function.Arguments), &extracted)
	if err != "" {
		log.Fatalf("Erreur Unmarshal: %v", err)
	}

	// Résultat final typé
	fmt.Printf("Entité extraite avec succès : %+v\n", extracted)
}

📖 Explication détaillée

Le premier snippet présente une implémentation complète de l’extraction d’entités Go en utilisant le SDK OpenAI. Analysons les étapes cruciales pour comprendre la robustesse de cette approche.

Définition de la structure cible

La structure Entity est le cœur de notre processus. Notez l’utilisation de tags JSON : json:"name". C’est une étape critique car le LLM va générer du JSON avec ces clés exactes. Si vos tags sont mal configurés, l’unmarshalage vers votre struct Go échouera silencieusement ou produira des valeurs vides.

Configuration du Tool (Function Calling)

La variable tool ne contient pas de code exécutable, mais une définition de schéma. Nous utilisons un format compatible avec le standard JSON Schema. Nous définissons explicitement les types : string pour le nom et integer pour l’importance. La clé required est fondamentale pour l’extraction d’entités Go : elle force le modèle à ne pas omettre de données essentielles, garantissant que l’objet résultant est complet.

L’appel API et le choix de l’outil

Dans la requête CreateChatCompletionRequest, nous utilisons ToolChoiceFunctionCall("extract_person_info"). Cela force le modèle à utiliser cette fonction spécifique plutôt que de répondre en texte libre. C’est le secret pour obtenir une sortie 100% prédictible. Sans cela, le modèle pourrait dire « Voici les informations : Jean est le directeur… », ce qui briserait notre parsing JSON.

Unmarshaling et gestion d’erreurs

Enfin, nous récupérons les arguments via toolCall.Function.Arguments. Nous utilisons json.Unmarshal pour transformer la chaîne JSON brute en notre structure Go typée. Un piège courant est de ne pas vérifier si toolCalls est vide avant d’accéder à l’index 0, ce qui provoquerait un panic en production.

🔄 Second exemple — extraction d'entités Go

Go
package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)

// AutoSchema génère un mini-schéma simplifié à partir d'une struct pour l'extraction d'entités Go
func AutoSchema(s interface{}) (map[string]interface{}, error) {
	t := reflect.TypeOf(s)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}

	properties := make(map[string]interface{})
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = field.Name
		}
		properties[jsonTag] = map[string]string{"type": field.Type.Kind().String()}
	}

	return map[string]interfaceen{"type": "object", "properties": properties}, nil
}

func main() {
	type Product struct {
		ID    int    `json:"id"` 
		Price float64 `json"price"` 
	}
	schema, _ := AutoSchema(Product{})
	out, _ := json.MarshalIndent(schema, "", "  ")
	fmt.Println(string(out))
}

▶️ Exemple d’utilisation

Imaginons un service de traitement de news. Votre application reçoit un flux RSS contenant des titres de presse. Vous passez chaque titre à votre fonction d’extraction. Le scénario est le suivant : l’utilisateur soumet le texte « Apple a annoncé un nouvel iPhone 15 à 999 dollars en Californie. ».

L’appel à la fonction d’extraction va génére la structure suivante dans votre console :

Entité extraite avec succès : &{Name:Apple Role:Manufacturer Importance:10}
Produit détecté: iPhone 15
Prix: 999
Lieu: Californie

Ici, chaque champ extrait est directement disponible pour une logique de filtrage ou de stockage en base de données SQL, sans aucune manipulation de chaînes de caractères complexe.

🚀 Cas d’usage avancés

L’extraction d’entités Go dépasse largement le simple cas de l’extraction de noms. Voici trois scénarios industriels avancés.

1. Analyse automatisée de logs et monitoring

Dans un environnement Kubernetes, les logs sont massifs et hétérogènes. Vous pouvez utiliser l’extraction d’entités pour transformer des logs textuels complexes en métriques structurarray. Par exemple, extraire un objet LogEvent contenant le service_name, le error_code et la latency_ms. Cela permet d’alimenter directement Prometheus ou Elasticsearch sans parser manuellement chaque format de log.

2. Traitement intelligent de factures et documents PDF

Le traitement de documents (IDP – Intelligent Document Processing) est un cas d’usage majeur. En combinant un OCR et l’extraction d’entités Go, vous pouvez parser des factures PDF. Le schéma JSON définirait des champs comme vendor_name, vat_number, et un tableau d’objets line_items. Cette méthode permet de gérer des mises en page radicalement différentes sans changer une seule ligne de code Go.

3. Enrichissement de données CRM en temps réel

Lorsqu’un email arrive dans un support client, l’extraction automatique des entités peut identifier le client_id, le produit_mentionné et le sentiment_score. En intégrant cela dans un pipeline Go, vous pouvez router automatiquement le ticket vers le bon service (technique ou commercial) avec une priorité calculée dynamiquement selon l’urgence détectée dans le texte.

⚠️ Erreurs courantes à éviter

L’extraction d’entités Go présente des pièges subtils qui peuvent déstabiliser un système de production.

  • Oubli des tags JSON : Ne pas définir de tags json:"..." sur vos structs Go. Le JSON généré par l’IA utilisera les noms des champs, mais votre structure Go pourrait ne pas les mapper correctement, résultant en des champs vides.
  • Schémas trop complexes : Créer des schémas JSON avec trop de niveaux d’imbrication. Les LLM perdent en précision à mesure que la profondeur du JSON augmente, ce qui entraîne des erreurs de syntaxe.
  • Ignorer la validation du type : Supposer que le LLM respectera toujours les types. Il arrive que le modèle envoie une chaîne « 10 » au lieu de l’entier 10. Toujours implémenter une validation post-unmarshalage.
  • Mauvais choix de modèle : Utiliser des modèles trop petits (comme GPT-3.5 ou des modèles locaux très légers) pour des schémas complexes. Le function calling nécessite une compréhension fine des instructions de contrainte.
  • Absence de gestion du Token Limit : Si le texte source est trop long, le modèle pourrait couper la réponse en plein milieu du JSON, rendant le JSON invalide et impossible à parser.

✔️ Bonnes pratiques

Pour une implémentation professionnelle de l’extraction d’entités Go, suivez ces recommandations.

  • Utilisez des types simples : Privilégiez les types primitifs (string, int, float, bool) dans vos schémas d’extraction pour maximiser le taux de succès du modèle.
  • Implémentez un mécanisme de retry : En cas d’échec de l’unmarshalage JSON, prévoyez une nouvelle tentative avec un prompt plus explicite ou un modèle plus puissant.
  • Validation de schéma côté Go : Utilisez des librairies comme go-playground/validator pour vérifier que les données extraites respectent vos contraintes métier (ex: prix > 0) immédiatement après le décodage.
  • Automatisez la génération de schéma : Comme montré dans le second snippet, utilisez la réflexion (reflection) pour générer vos définis de fonctions à partir de vos structs Go, afin de maintenir une source de vérité unique.
  • Logging structuré : Loggez systématiquement les arguments JSON bruts reçus de l’API. En cas de bug de parsing, c’est votre seule trace pour comprendre pourquoi le modèle a échoué.
📌 Points clés à retenir

  • L'extraction d'entités Go transforme le texte brut en données structurées et typées.
  • Le Function Calling est la méthode la plus fiable pour garantir un format JSON conforme.
  • L'utilisation de JSON Schema permet de définir des contraintes strictes sur les données extraites.
  • La structuration des données via Go facilite l'intégration directe dans les bases de données.
  • La gestion des tags JSON dans les structs Go est indispensable pour le mapping correct.
  • Le typage fort de Go agit comme une deuxième couche de validation après le LLM.
  • Les schémas trop complexes augmentent le risque d'erreurs de parsing du modèle.
  • L'automatisation de la génération de schéma via la réflexion améliore la maintenabilité.

✅ Conclusion

En conclusion, l’extraction d’entités Go représente un changement de paradigme dans la manière dont nous traitons l’information non structurée. Nous avons vu comment, en combinant la puissance des LLM avec la rigueur du JSON Schema et la robustesse du langage Go, il est possible de créer des pipelines de données extrêmement fiables. Nous avons exploré les mécanismes de définition de fonctions, l’importance du typage statique et les stratégies pour éviter les erreurs de parsing les plus courantes. Maîtriser cette technique vous permet de transformer n’importe quel flux textuel en une source de données structurée, prête pour l’automatisation industrielle.

Pour aller plus loin, je vous encourage à expérimenter avec des schémas de plus en plus complexes et à explorer l’utilisation de la réflexion en Go pour rendre vos extracteurs dynamiques. Vous pouvez consulter des projets open-source sur l’orchestration d’agents IA pour voir comment cette technique est utilisée à grande échelle. N’oubliez jamais que la clé d’un système d’IA réussi réside dans la structure des données qu’il produit. Pour toute question sur le formatage de vos structures, référez-vous à la documentation Go officielle. Pratiquez, testez des cas limites, et construisez des systèmes qui ne se contentent pas de lire le texte, mais qui le comprennent véritablement. À vous de jouer : créez votre premier extracteur aujourd’hui !

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *