Workflows Multi-Étapes

Enchaînez des opérations LLM dans des pipelines lisibles et testables avec lesworkflows Orka AI.

Pourquoi des Workflows ?

Les workflows vous permettent d'enchaîner plusieurs opérations LLM dans un pipeline unique et lisible. Chaque étape transforme le contexte et le passe à la suivante. Les étapes intégrées gèrent les patterns courants comme la planification, la récupération, la génération et la vérification — mais vous pouvez aussi créer des étapes personnalisées pour n'importe quelle logique.

import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { plan, retrieve, generate, verify, improve } from '@orka-js/workflow';
 
const orka = createOrka({
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  vectorDB: myVectorDB,
});
 
const workflow = orka.workflow({
  name: 'support-response',
  steps: [
    plan(),                                    // Analyse l'entrée et crée un plan d'action
    retrieve('knowledge-base', { topK: 5 }),   // Recherche sémantique dans la base de connaissances
    generate({ temperature: 0.7 }),            // Génère une réponse en utilisant l'LLM
    verify({ criteria: ['relevant', 'no hallucination'] }), // Évalue la qualité
    improve({ maxIterations: 1 }),             // Corrige les problèmes si la vérification échoue
  ],
});
 
const result = await workflow.run('Comment puis-je réinitialiser mon mot de passe?');
 
console.log(result.output);          // Réponse finale
console.log(result.steps);           // Résultats de chaque étape
console.log(result.totalLatencyMs);  // Temps d'exécution total
console.log(result.totalTokens);     // Total de tokens consommés

# Étapes Intégrées

Orka fournit six étapes de workflow intégrées qui couvrent les patterns LLM les plus courants :

plan()Stratégie Cognitive

Décompose les objectifs complexes en une feuille de route structurée.

retrieve()Accès Connaissance

Récupération vectorielle haute précision avec ré-ordonnancement.

generate()Synthèse Créative

Orchestre l'inférence LLM avec injection dynamique de contexte.

verify()Contrôle Qualité

Évalue les hallucinations et l'ancrage via LLM-as-judge.

improve()Affinage Itératif

Corrige automatiquement les erreurs selon les retours de verify.

custom()Extension Logique

Injecte votre logique métier spécifique dans le pipeline.

# Détails des Étapes

plan()

Analyse l'entrée et crée un plan d'action. Utile pour les requêtes complexes qui nécessitent plusieurs étapes.

plan()
// Output: "1. Search for password reset documentation
2. Extract relevant steps
3. Format as user-friendly instructions"

retrieve(name, options)

Effectue une recherche sémantique dans une base de connaissances et ajoute les résultats au contexte.

retrieve('documentation', {
  topK: 5,           // Nombre de résultats à récupérer
  minScore: 0.7,     // Score de similarité minimum
  filter: { category: 'guides' } // Filtre de métadonnées
})

generate(options)

Génère une réponse en utilisant le LLM avec le contexte actuel (entrée + documents récupérés).

generate({
  temperature: 0.7,  // Niveau de créativité (0-1)
  maxTokens: 1000,   // Longueur maximale de la réponse
  systemPrompt: 'You are a helpful assistant.' // Prompt système personnalisé
})

verify(options)

Évalue la sortie générée par rapport à des critères en utilisant LLM-as-judge. Définit ctx.verified à true/false.

verify({
  criteria: [
    'relevant',           // L'answer est-il pertinent à la question?
    'no hallucination',   // L'answer est-il basé sur le contexte?
    'complete',           // Est-il complet?
    'professional tone'   // Le ton est-il approprié?
  ]
})

improve(options)

Si verify() a échoué, tente de corriger les problèmes. S'exécute jusqu'à maxIterations fois.

improve({
  maxIterations: 2,  // Nombre maximum d'essais d'amélioration
  // Utilise automatiquement les retours de vérification pour améliorer l'output
})

# Étapes Personnalisées

Créez des étapes personnalisées pour toute logique non couverte par les étapes intégrées. Les étapes personnalisées reçoivent le contexte du workflow et doivent le retourner.

import { custom } from '@orka-js/workflow';
 
// $Étape personnalisée pour traduire la sortie
const translateStep = custom('translate', async (ctx) => {
  const result = await ctx.llm.generate(
    `Translate to French: ${ctx.output}`,
    { temperature: 0.3 }
  );
 
  ctx.output = result.content;
  ctx.metadata.translatedTo = 'fr';
 
  // Enregistrez l'étape dans l'historique
  ctx.history.push({
    stepName: 'translate',
    output: result.content,
    latencyMs: result.latencyMs,
    tokens: result.usage?.totalTokens,
  });
 
  return ctx;
});
 
// Utilisez dans le workflow
const workflow = orka.workflow({
  name: 'multilingual-support',
  steps: [
    retrieve('docs'),
    generate(),
    translateStep,  // Votre étape personnalisée
  ],
});

Contexte du Workflow (ctx)

Orchestration de l'État Partagé

Data Persistence across the Reasoning Pipeline

ctx.inputSource

string

Requête d'origine immuable

ctx.outputCurrent State

string

Réponse réactive de l'étape

ctx.retrievedDocsContext

Document[]

Base de connaissances d'ancrage

ctx.llmEngine

LLMAdapter

Interface de modèle unifiée

ctx.metadataExtensibility

Record<string, any>

Magasin personnalisé persistant

# Résultat du Workflow

La méthode workflow.run() retourne un objet WorkflowResult avec la sortie finale et des informations d'exécution détaillées :

Champ de Réponse	Type de Donnée	Usage & Analyse
`output`Final Result	`string`	La réponse finale synthétisée
`steps`Audit Trail	`WorkflowStepResult[]`	Trace complète (logs, entrées, sorties)
`totalLatencyMs`Performance	`number`	Performance de bout en bout
`totalTokens`Billing / ROI	`number`	Consommation cumulée des étapes
`verified`Reliability	`boolean`	Statut du contrôle d'intégrité

Exemple Complet

workflow-step-example.ts

import { createOrka } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { PineconeAdapter } from '@orka-js/pinecone';
import { plan, retrieve, generate, verify, improve, custom } from '@orka-js/workflow';
 
const orka = createOrka({
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  vectorDB: new PineconeAdapter({ apiKey: process.env.PINECONE_API_KEY! }),
});
 
// Étape de journalisation personnalisée
const logStep = custom('log', async (ctx) => {
  console.log('[Workflow] Current output length:', ctx.output.length);
  return ctx;
});
 
const supportWorkflow = orka.workflow({
  name: 'customer-support',
  steps: [
    plan(),
    retrieve('support-docs', { topK: 5 }),
    generate({ temperature: 0.5, systemPrompt: "Vous êtes un agent de support helpful."),
    logStep,
    verify({ criteria: ['helpful', 'accurate', 'professional'] }),
    improve({ maxIterations: 1 }),
  ],
});
 
async function handleSupportQuery(query: string) {
  const result = await supportWorkflow.run(query);
 
  console.log('Answer:', result.output);
  console.log('Verified:', result.verified);
  console.log('Steps:', result.steps.map(s => s.stepName));
  console.log('Total time:', result.totalLatencyMs, 'ms');
  console.log('Total tokens:', result.totalTokens);
 
  return result.output;
}
 
await handleSupportQuery('Comment puis-je annuler mon abonnement?');

Imports Tree-shakeable

// ✅ Importez uniquement ce dont vous avez besoin
import { plan, retrieve, generate, verify, improve, custom } from '@orka-js/workflow';
 
// ✅ Ou importez depuis le package principal
import { plan, retrieve, generate } from 'orkajs';