Référence API - Documentation Entity Enricher

Référence API

L'API REST Entity Enricher vous permet d'enrichir des entités, de gérer des schémas et de récupérer des enregistrements par programmation. Toutes les réponses sont au format JSON. La progression en temps réel utilise les Server-Sent Events (SSE).

Démarrage rapide

Intégrez Entity Enricher en trois étapes :

1

Obtenir le schéma

GET /api/schema/saved

Lister les schémas enregistrés ou en générer un à partir de données d'exemple

2

Enrichir

POST /api/single/enrich/stream

Lancez l'enrichissement et obtenez un ID de tâche pour le streaming SSE

3

Obtenir le résultat

GET /api/records/{id}

Récupérer l'enregistrement d'enrichissement complet avec la sortie structurée

Authentification

Tous les points de terminaison de l'API (sauf connexion/inscription) nécessitent une authentification. Utilisez l'en-tête X-API-Key avec une clé d'accès d'organisation :

curl -H "X-API-Key: ent_your_key_here" \
     https://your-instance.example.com/api/enrichment/options

Créez des clés API depuis la page Clés API ou via POST /api/auth/api-keys. Consultez le guide des clés API pour plus de détails sur les types de clés et les permissions.

Principaux points de terminaison

Enrichissement

MéthodePoint de terminaisonDescription
GET/api/enrichment/optionsModèles, langues et stratégies disponibles
POST/api/single/enrich/streamLancer l'enrichissement d'une entité unique (renvoie job_id pour le SSE)
POST/api/single/enrich/syncEnrichissement unitaire bloquant pour les clients non SSE (Make.com, curl)
POST/api/enrichment/batch/startLancer l'enrichissement par traitement par lot pour plusieurs entités
POST/api/enrichment/batch/fetchRécupérer des entités depuis une URL externe

Gestion des tâches

MéthodePoint de terminaisonDescription
GET/api/llm/stream/{job_id}Flux SSE pour toute tâche LLM (enrichissement, schéma, fusion)
POST/api/llm/cancel/{job_id}Annuler une tâche en cours ou en pause
POST/api/llm/continue/{job_id}Reprendre une tâche en pause (p. ex. après une incohérence de classification)

Schémas

MéthodePoint de terminaisonDescription
GET/api/schema/savedLister tous les schémas enregistrés
POST/api/schema/savedCréer un nouveau schéma
POST/api/schema/generate/streamGénérer un schéma à partir de données d'exemple (SSE)
POST/api/schema/saved/{id}/prompt/streamÉdition du schéma par IA en langage naturel (SSE)

Enregistrements & Fusion

MéthodePoint de terminaisonDescription
GET/api/recordsLister les enregistrements avec pagination et filtrage
GET/api/records/{id}Obtenir le détail complet de l'enregistrement avec sortie structurée
POST/api/records/batch-deleteSupprimer plusieurs enregistrements (max 100)
POST/api/fusion/mergeFusionner les résultats de plusieurs modèles

Pièces jointes

MéthodePoint de terminaisonDescription
POST/api/attachmentsTéléverser un ou plusieurs fichiers (multipart/form-data)
POST/api/attachments/base64Téléverser un fichier via JSON base64 (pour les clients non multipart)
GET/api/attachments/{id}/downloadTélécharger les octets du fichier d'origine
DELETE/api/attachments/{id}Supprimer une pièce jointe (nettoyage post-enrichissement)

Streaming SSE

Les opérations d'enrichissement, de génération de schéma et de fusion utilisent les Server-Sent Events pour une progression en temps réel. Lancez une tâche, obtenez un job_id, puis connectez-vous au flux SSE :

Flux d'événements SSE

data: {"type":"model_started","model":"anthropic::claude-sonnet-4-5"}
data: {"type":"expertise_completed","expertise_key":"financial","partial_result":{...}}
data: {"type":"model_completed","success":true,"result":{...},"record_id":"uuid"}
data: {"type":"completed"}

Principaux types d'événements

ÉvénementDescription
model_startedLe traitement par le modèle commence
expertise_completedUn domaine d'expertise terminé (avec des résultats partiels)
model_completedLe modèle a terminé avec result, record_id et cost
fusion_started / fusion_completedÉvénements du cycle de vie de la fusion multi-modèles
entity_started / entity_completedÉvénements par entité propres au traitement par lot (incluant entity_index)
completedÉvénement terminal - fermer la connexion
errorUne erreur au niveau de la tâche s'est produite

Exemple Python

Un flux de travail complet qui liste les schémas, démarre l'enrichissement, diffuse les résultats et récupère l'enregistrement final :

import httpx
import json

BASE = "https://your-instance.example.com"
KEY = "ent_your_api_key"
HEADERS = {"X-API-Key": KEY, "Content-Type": "application/json"}

# 1. List saved schemas
schemas = httpx.get(f"{BASE}/api/schema/saved", headers=HEADERS).json()
schema_id = schemas["schemas"][0]["id"]

# 2. Start enrichment
resp = httpx.post(f"{BASE}/api/single/enrich/stream", headers=HEADERS, json={
    "entity_data": {"name": "Moderna Inc", "country": "US"},
    "schema_id": schema_id,
    "models": ["anthropic::claude-sonnet-4-5-20250514"],
    "strategy": "multi_expertise",
})
job_id = resp.json()["job_id"]

# 3. Stream SSE events
record_id = None
with httpx.stream("GET", f"{BASE}/api/llm/stream/{job_id}", headers=HEADERS) as stream:
    for line in stream.iter_lines():
        if not line.startswith("data: "):
            continue
        event = json.loads(line[6:])

        if event["type"] == "model_completed" and event.get("record_id"):
            record_id = event["record_id"]
        elif event["type"] == "completed":
            break

# 4. Retrieve the enrichment record
if record_id:
    record = httpx.get(f"{BASE}/api/records/{record_id}", headers=HEADERS).json()
    print(json.dumps(record["structured_output"], indent=2))

Exemple curl

Lancez un enrichissement par traitement par lot avec deux modèles et diffusez les résultats en continu :

# Start batch enrichment
JOB_ID=$(curl -s -X POST \
  -H "X-API-Key: $KEY" \
  -H "Content-Type: application/json" \
  "$BASE/api/enrichment/batch/start" \
  -d '{
    "entities": [
      {"name": "Pfizer Inc", "country": "US"},
      {"name": "Roche", "country": "CH"}
    ],
    "schema_id": "your-schema-uuid",
    "models": ["anthropic::claude-sonnet-4-5-20250514", "openai::gpt-4o"],
    "strategy": "multi_expertise",
    "arbitration_model": "anthropic::claude-sonnet-4-5-20250514"
  }' | jq -r '.job_id')

# Stream events
curl -N -H "X-API-Key: $KEY" "$BASE/api/llm/stream/$JOB_ID"

# List resulting records
curl -s -H "X-API-Key: $KEY" \
  "$BASE/api/records?type=enrichment&page_size=10" | jq '.records'

Gestion des erreurs

StatutSignificationExemple
200SuccèsRequête terminée
400Requête invalideClé de modèle invalide ou champ manquant
401Non autoriséClé API manquante ou invalide
403InterditRôle insuffisant pour ce point de terminaison
404IntrouvableEnregistrement, schéma ou tâche introuvable
500Erreur serveurÉchec interne

Les réponses d'erreur incluent un champ detail contenant un message d'erreur lisible. Les flux SSE émettent un événement de type error avant l'événement terminal completed si un échec survient en cours de flux.

Clés composites de modèle

Les modèles sont identifiés par des clés composites au format provider_name::model_name. Utilisez GET /api/enrichment/options pour lister les modèles disponibles et leurs clés.

Anthropic
anthropic::claude-sonnet-4-5-20250514
OpenAI
openai::gpt-4o
Google
google::gemini-2.5-pro
DeepSeek
deepseek::deepseek-chat

Documentation API interactive

L'application inclut une documentation API interactive avec des exemples de requêtes/réponses. Nécessite une authentification administrateur pour y accéder :

Prochaines étapes