Guides
Démarrage
Documentation

Référence Waiflo

Tout ce qu'il faut pour définir, versionner et exécuter des pipelines IA multi-étapes. JSON natif, API REST, zéro dépendance fournisseur.

Schéma de base

Un fichier Waiflo est un document JSON avec trois clés de premier niveau. Il est conçu pour être versionné sous Git, relu en pull request et déployé comme n'importe quel artefact.

{
  "lang_name":  "my_pipeline",      // identifiant unique du pipeline
  "steps":      [ ... ],             // définitions d'étapes réutilisables
  "workflows":  [ ... ]              // DAGs reliant les étapes entre elles
}
ChampTypeDescription
lang_namestringNom unique du pipeline. Utilisé comme nom de fichier sur le disque. required
stepsStep[]Tableau de définitions d'étapes. Chaque étape est une unité atomique et réutilisable. required
workflowsWorkflow[]Tableau de définitions de workflows (DAGs). Chaque workflow relie des étapes en un graphe d'exécution. optional

Étapes

Une étape est l'unité atomique d'un pipeline. Elle possède un type, des schémas I/O typés et sa configuration complète dans un seul objet — aucun état caché, aucune héritage implicite.

Champs communs

ChampTypeDescription
ws_namestringIdentifiant unique dans le fichier. Utilisé pour référencer l'étape dans les workflows. required
ws_typestringL'un des types : prompt · api · transform · tool · script required
ws_inputs_schemaJSONSchemaObjet JSON Schema décrivant les entrées attendues. optional
ws_output_schemaJSONSchemaObjet JSON Schema décrivant la sortie attendue. optional

Types d'étapes

prompt
Appel LLM. Prompt système, substitution de template {{var}}, schéma de sortie typé. Streamé via SSE.
ws_llm
ws_system_prompt
ws_prompt_template
ws_output_schema
api
Appel HTTP. L'URL et le corps supportent la substitution {{input}}. Retourne du JSON parsé ou du texte brut.
ws_api.method
ws_api.url
ws_api.headers
ws_api.body
transform
Transformation de données entre étapes. Filtrer, calculer ou dériver des champs depuis les sorties amont.
ws_transform_fn
— bientôt disponible
tool
Appel d'outil MCP (Google Maps, Asana, Gmail…) via le tableau ws_tools.
ws_tools: [
  "maps_search"
]
script
Exécution de code personnalisé dans un environnement sandbox avec entrées liées.
ws_script
— bientôt disponible

prompt — champs LLM

L'objet ws_llm configure le modèle à appeler. ws_prompt_template supporte la syntaxe Mustache : {{{var}}} pour l'injection brute et {{var}} pour l'échappement HTML.

ChampTypeDescription
ws_llm.providerstringFournisseur LLM. Actuellement : anthropic.
ws_llm.modelstringID du modèle, ex : claude-sonnet-4-20250514.
ws_llm.temperaturenumber0–1. Défaut : 0. optional
ws_system_promptstringChaîne de prompt système. Injectée avant le tour utilisateur.
ws_prompt_templatestringTemplate du tour utilisateur. Supporte {{input_var}} et {{ws_output_schema}}.
{
  "ws_name":             "classify",
  "ws_type":             "prompt",
  "ws_llm":              { "provider": "anthropic", "model": "claude-sonnet-4-20250514", "temperature": 0 },
  "ws_system_prompt":    "You are a classifier. Reply with JSON only.",
  "ws_prompt_template":  "Classify: \nSchema: ",
  "ws_inputs_schema":    { "required": ["input_text"] },
  "ws_output_schema":    { "properties": { "label": { "type": "string" } } }
}

api — champs HTTP

Les templates d'URL et de corps supportent la substitution {{input_var}} résolue depuis les inputs à l'exécution.

ChampTypeDescription
ws_api.methodstringMéthode HTTP : GET · POST · PUT · PATCH · DELETE.
ws_api.urlstringURL. Supporte la substitution de template {{input_var}}.
ws_api.headersobjectObjet d'en-têtes statiques ou templatisés. optional
ws_api.bodyobjectCorps de la requête. Objet ou chaîne. optional

Workflows

Un workflow est un graphe acyclique orienté (DAG) de références d'étapes. Le moteur déduit l'ordre d'exécution depuis les déclarations depends_on.

ChampTypeDescription
wf_namestringNom unique du workflow. required
wf_nodesNode[]Tableau ordonné de nœuds, chacun référençant une étape via step_id. required

Champs d'un nœud

ChampTypeDescription
step_idstringRéférence un ws_name déclaré dans le tableau steps.
depends_onstring[]Tableau de step_id qui doivent se terminer avant que ce nœud s'exécute. Les données transmises proviennent explicitement des champs de ws_output_schema (pas d'alias implicites). optional
{
  "wf_name":  "triage_and_respond",
  "wf_nodes": [
    { "step_id": "classify_ticket" },
    { "step_id": "enrich_customer",  "depends_on": ["classify_ticket"] },
    { "step_id": "draft_response",    "depends_on": ["classify_ticket", "enrich_customer"] }
  ]
}

Schéma OpenAPI

Téléchargez le schéma OpenAPI YAML complet de l'API Waiflo pour l'importer dans Postman, Insomnia ou votre outillage interne.

GET /json_schemas/waiflo_api.openapi.yaml

Télécharger waiflo_api.openapi.yaml

API d'exécution

L'API exec exécute une étape unique avec les inputs fournis. Aucun compte requis pour un usage invité si ANTHROPIC_API_KEY est défini côté serveur. Les utilisateurs authentifiés apportent leur propre clé chiffrée.

POST /api/exec/step
Exécute une définition d'étape avec les inputs. Les étapes prompt retournent un flux SSE. Les étapes api retournent du JSON.
// Corps de la requête
{
  "step":   { ... },   // objet de définition d'étape complet
  "inputs": { ... }    // map clé-valeur des inputs
}

// Réponse
// étape prompt → flux SSE
data: {"type":"delta","text":"..."}
data: {"type":"final","output":{"label":"billing"}}

// étape api → JSON
{ "output": { "status": 200, "body": { ... } } }

API d'authentification

Authentification JWT. Les tokens sont valides 7 jours. Passer le token dans l'en-tête Authorization pour tous les endpoints authentifiés.

POST /api/auth/register
Créer un nouveau compte. Le mot de passe doit faire au moins 8 caractères.
{ "email": "you@example.com", "password": "min8chars" }
// → { "token": "eyJ..." }
POST /api/auth/login
Obtenir un token JWT pour un compte existant.
{ "email": "you@example.com", "password": "..." }
// → { "token": "eyJ..." }

Inclure le token JWT dans toutes les requêtes nécessitant une authentification.

Authorization: Bearer <token>

API Design

Endpoints CRUD pour gérer les fichiers de workflow sur le serveur. Les endpoints PATCH utilisent un deep merge récursif — seuls les champs envoyés sont mis à jour. Conçu pour l'autosave et les éditeurs assistés par IA.

GET /api/workflows
Lister tous les workflows de l'utilisateur authentifié.
POST /api/workflows
Créer un nouveau workflow. Le corps est le document JSON Waiflo complet.
PATCH /api/workflow/design/step
Patcher un seul champ d'étape. Utilise un deep merge récursif — les champs non spécifiés sont préservés.
{
  "workflow_name": "triage",
  "ws_name":       "classify",
  "patch":         { "ws_llm": { "temperature": 0.4 } }
}

Seul ws_llm.temperature est modifié. ws_llm.provider et ws_llm.model sont préservés automatiquement.

Démarrage rapide

Auto-hébergé avec Docker. Zéro service externe — juste un secret JWT et votre clé Anthropic.

1
Cloner et configurer
Deux secrets à générer : un pour la signature JWT, un pour le chiffrement des clés API au repos.
git clone https://github.com/jpdesmontils/waiflo
cd waiflo && cp .env.example .env
# Définir JWT_SECRET et MASTER_SECRET dans .env
2
Démarrer le serveur
Lance l'API et l'éditeur visuel. Persiste les fichiers de workflow sur un volume monté — aucune base de données requise.
docker compose up -d
# Éditeur disponible sur http://localhost:3001/editor
3
Ouvrir l'éditeur ou appeler l'API
Explorer l'éditeur visuel sans compte. Ou s'inscrire et pousser des workflows programmatiquement.
# Essayer l'éditeur en premier — aucun compte requis
open http://localhost:3001/editor

# Ou démarrer par l'API
curl -X POST http://localhost:3001/api/auth/register \
  -d '{"email":"you@example.com","password":"secret"}'