> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Procédures libres

## Vue d’ensemble

Une procédure libre décrit une tâche en langage simple et naturel. L’agent interprète les instructions et adapte la formulation ainsi que l’ordre à la situation. Une procédure libre peut appeler des outils, y compris des outils système comme la fin d’un appel, rechercher des documents de la base de connaissances et enchaîner avec d’autres procédures.

## Quand utiliser une procédure libre

Utilisez une procédure libre lorsque l’agent peut adapter sa formulation et l’ordre des actions à la situation, et que vous souhaitez la rédiger rapidement en langage simple. Pour savoir comment elle se compare aux procédures structurées, aux workflows et au prompt système, consultez [Quand utiliser les procédures](/docs/fr/eleven-agents/customization/procedures#when-to-use-procedures).

## Structure d’une procédure

Voici une procédure de remboursement dans l’éditeur :

![Exemple de procédure de remboursement](/docs/_fern-img/e1264b7a4f94403453087d30ef0894e72d412ba69378e6b8cb1b675e53e887b7.webp)

Une procédure comprend deux parties principales : un déclencheur et un contenu. Les deux peuvent contenir des références intégrées à d’autres ressources, affichées dans la capture d’écran ci-dessus sous forme de balises avec des icônes de clé à molette. Chaque procédure possède également un nom affiché dans le Dashboard.

### Nom

Une courte étiquette qui identifie la procédure dans le Dashboard. Le nom n’est jamais envoyé au LLM ; il n’affecte donc pas le comportement de l’agent.

### Déclencheur

Une description du moment où l’agent doit utiliser cette procédure, par exemple *Lorsque l’utilisateur demande le remboursement d’une commande*.

Laissez le déclencheur vide uniquement lorsque vous créez une [sous-procédure](#sub-procedures).

### Contenu

Le corps de la procédure, rédigé en markdown. Le contenu décrit ce que l’agent doit faire : poser une question, rechercher une commande, appeler un outil ou mettre fin à l’appel. Il peut s’agir d’une séquence numérotée d’étapes à suivre ou de conseils généraux adaptés à la situation. Chaque étape ou consigne peut être une phrase unique, comme *Demandez à l’utilisateur son identifiant de commande*, ou un court paragraphe expliquant quoi faire et pourquoi.

Utilisez des étapes numérotées pour les actions séquentielles et des listes à puces pour les exigences ou sous-éléments d’une étape.

### Références intégrées

Les procédures peuvent référencer différents types de ressources directement dans le texte :

* Des outils, par exemple rechercher une commande, débiter une carte, mettre fin à l’appel ou transférer vers un intervenant humain
* Des documents de la base de connaissances
* D’autres procédures

Utilisez des références intégrées chaque fois qu’une étape nécessite que l’agent utilise un outil, un document de la base de connaissances ou une autre procédure. Les références associent automatiquement la ressource à la procédure afin que l’agent puisse l’utiliser. Les mentions en texte brut, comme *utilisez ici l’outil de calcul*, fonctionnent également, mais uniquement si la ressource est déjà associée à l’agent.

Insérez une référence en saisissant `/` dans le déclencheur ou le contenu, puis en choisissant la ressource dans le menu slash. Les références apparaissent sous forme de balises cliquables dans l’éditeur. Cliquez sur une balise pour ouvrir la ressource sous-jacente et confirmer sa configuration.

Lorsque vous rédigez du contenu libre via l’API, insérez les références avec la syntaxe suivante :

```text focus={1-5}
[tool id="tool_abc123"]
[kb id="kb_abc123"]
[procedure id="agtprc_abc123"]
[system_tool id="end_call"]
{{customer_id}}
```

Une référence intégrée à une procédure doit utiliser une procédure du même agent. Consultez [Limites](/docs/fr/eleven-agents/customization/procedures#limitations) pour connaître le périmètre des agents et le comportement de duplication.

Une référence dans le déclencheur permet de lancer la procédure selon la sortie d’une ressource, par exemple *Lorsque `get_user` renvoie le niveau « gold »*. Une référence dans le contenu indique à l’agent d’appeler ou de consulter la ressource à cette étape.

Les documents de la base de connaissances référencés dans une procédure utilisent toujours le [mode d’utilisation](/docs/fr/eleven-agents/customization/knowledge-base#how-your-agent-uses-knowledge) `auto` : lorsque le RAG est activé sur l’agent, celui-ci récupère les passages pertinents au lieu de placer le document complet dans le prompt. Si le document est également associé à l’agent, son mode d’utilisation pour cet agent s’applique à la place. Associez donc le document à l’agent avec le mode d’utilisation `prompt` pour conserver son texte complet dans le prompt.

![Menu slash dans l’éditeur de procédures](/docs/_fern-img/8625ffec0f5584619e6ccb97720fd86f2e8d3cd0061308ad87b57f176e5535e3.webp)

Si une ressource référencée est supprimée ultérieurement ou si votre compte y perd l’accès, la balise apparaît comme défectueuse. Le badge **Erreurs** en haut de l’éditeur répertorie ces références : *invalide* si la ressource n’existe plus, ou *indisponible* si elle existe mais que votre compte n’y a pas accès. Ouvrez le badge pour voir quelle étape est concernée, puis corrigez ou supprimez la référence.

![Boîte de dialogue Erreurs répertoriant les références invalides](/docs/_fern-img/e9ec6b19be2992da80a726883baf53265a5d5b38621373cd7e60375c944674cd.webp)

## Sous-procédures

Une sous-procédure possède un déclencheur vide. L’agent peut l’exécuter uniquement depuis une autre procédure qui la référence.

Utilisez des sous-procédures pour [partager des étapes](#composing-procedures) au sein d’un même agent et réduire le nombre de procédures disponibles simultanément. Donnez un déclencheur à la procédure d’entrée, référencez les sous-procédures associées depuis son contenu et laissez leurs déclencheurs vides.

Une sous-procédure d’escalade peut contenir les étapes de transfert de la conversation vers un intervenant humain. Référencez-la depuis les procédures de remboursement et d’annulation, puis laissez son déclencheur vide. L’agent peut effectuer l’escalade comme étape de l’une ou l’autre procédure, mais la sous-procédure reste indisponible en dehors de celles-ci.

## Importer depuis un document

Vous pouvez partir d’une procédure opérationnelle standard existante. Choisissez **Depuis une SOP** dans le menu **+** de la liste des procédures, puis importez un fichier.

Formats pris en charge : `PDF`, `DOCX`, `TXT`, `MD`, `HTML`, `EPUB`. Les fichiers doivent peser 20 Mo ou moins.

L’outil d’importation analyse le document, identifie jusqu’à 10 procédures distinctes et crée un brouillon pour chacune, avec un nom, un déclencheur et un contenu générés. Ouvrez chaque brouillon pour l’affiner. Si votre document contient plus de 10 SOP, divisez-le en fichiers plus petits avant de l’importer.

![Boîte de dialogue d’importation d’une SOP](/docs/_fern-img/716601fc90dea757e23971e5aabe063e6a66fc0f75878247dc9f1fc3011f5197.webp)

## Gérer une procédure libre

#### Créer depuis le Dashboard

Ouvrez votre agent dans le [Dashboard](https://elevenlabs.io/app/agents), puis sélectionnez **Procédures**.
Utilisez **+** pour créer une procédure libre. Ajoutez un déclencheur et rédigez les instructions dans
l’éditeur de contenu, puis publiez les modifications de l’agent.

#### Gérer via l’API

Les procédures libres stockent du markdown dans `content`.

### Prérequis

* Une clé API ElevenLabs dans la variable d’environnement `ELEVENLABS_API_KEY`.
* Les valeurs `agent_id` et `branch_id` ciblées. Consultez [Versionnage des agents](/docs/fr/eleven-agents/operate/versioning) pour les opérations sur les branches.
* La version `2.60.0` ou ultérieure du package Python `elevenlabs` ou du package JavaScript `@elevenlabs/elevenlabs-js`.

Les brouillons de procédures sont [par utilisateur et par branche](/docs/fr/eleven-agents/operate/versioning#drafts). La publication enregistre vos modifications de procédure
dans une nouvelle version de l’agent sur cette branche. Les brouillons des autres utilisateurs ne sont pas affectés.

### Créer un brouillon

```python focus={1,5-15}
from elevenlabs import CreateProcedureRequestModel, ElevenLabs

elevenlabs = ElevenLabs()

procedure = elevenlabs.conversational_ai.agents.procedures.create(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbranch_0901k4aafjxxfxt93gd841r7tv5t",
    request=CreateProcedureRequestModel(
        name="Refund request",
        type="free_form",
        trigger="When the user asks to refund, return, or get money back for an order",
        content="Ask for the order ID, then look it up with [tool id=\"tool_abc123\"].",
    ),
)

print(procedure.procedure_id)
```

```typescript focus={5-15}
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

const procedure = await elevenlabs.conversationalAi.agents.procedures.create(
  "agent_7101k5zvyjhmfg983brhmhkd98n6",
  "agtbranch_0901k4aafjxxfxt93gd841r7tv5t",
  {
    name: "Refund request",
    type: "free_form",
    trigger: "When the user asks to refund, return, or get money back for an order",
    content: "Ask for the order ID, then look it up with [tool id=\"tool_abc123\"].",
  }
);

console.log(procedure.procedureId);
```

```bash focus={1-8}
curl -X POST "https://api.elevenlabs.io/v1/convai/agents/agent_7101k5zvyjhmfg983brhmhkd98n6/branches/agtbranch_0901k4aafjxxfxt93gd841r7tv5t/procedures" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Refund request",
    "type": "free_form",
    "trigger": "When the user asks to refund, return, or get money back for an order",
    "content": "Ask for the order ID, then look it up with [tool id=\"tool_abc123\"]."
  }'
```

La réponse inclut le nouveau `procedure_id`. Pour mettre à jour le brouillon, appelez
`PATCH /procedures/{procedure_id}/draft` avec `name`, `content`, `type` et un
`trigger` explicite.

Utilisez un `trigger` non vide pour une procédure d’entrée. Pour une
[sous-procédure](#sub-procedures), utilisez une chaîne vide.

### Publier les modifications

Mettez à jour l’agent sur la branche afin de publier vos brouillons de procédures libres dans une nouvelle version.
La requête ne nécessite aucun champ dans le corps ; la publication utilise les brouillons tels quels.

```python focus={5-8}
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbranch_0901k4aafjxxfxt93gd841r7tv5t",
)
```

```typescript focus={5-7}
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  branchId: "agtbranch_0901k4aafjxxfxt93gd841r7tv5t",
});
```

```bash focus={1-5}
curl -X PATCH \
  "https://api.elevenlabs.io/v1/convai/agents/agent_7101k5zvyjhmfg983brhmhkd98n6?branch_id=agtbranch_0901k4aafjxxfxt93gd841r7tv5t" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'
```

Consultez [Gérer les procédures](/docs/fr/eleven-agents/customization/procedures#manage-procedures) pour connaître le
comportement de suppression et d’abandon des brouillons, ou le
[Guide de l’API des procédures](/docs/fr/api-reference/agents/procedures/) pour les schémas complets des points de terminaison.

## Bonnes pratiques

> **Tip**
>
> L’agent doit choisir la bonne procédure à partir de son déclencheur et suivre son contenu. Les
> modèles plus performants le font de manière plus fiable à mesure que le nombre de procédures augmente. Consultez
> [Modèles](/docs/fr/eleven-agents/customization/llm) pour découvrir les options.

Bien rédiger des procédures implique de bien rédiger deux éléments : un déclencheur qui exécute la procédure au bon moment, et un contenu que l’agent peut suivre.

### Itérer sur une procédure

Nous recommandons de commencer modestement et d’utiliser des [tests d’agent](/docs/fr/eleven-agents/customization/agent-testing) pour vérifier chaque modification avant de passer à la suivante.

#### Rédiger une procédure courte

Rédigez un déclencheur et un contenu court. Développez le contenu uniquement lorsqu’un test montre que l’agent
a besoin d’instructions supplémentaires.

#### Ajouter des tests de déclencheur

Créez des tests de simulation pour les demandes qui doivent lancer la procédure et pour les demandes similaires
qui ne le doivent pas. La plupart des échecs proviennent du déclencheur. Créez donc davantage de ces tests que de
simulations complètes.

#### Ajouter une simulation complète

Créez un test de simulation qui exécute toute la procédure et vérifie le résultat.

#### Exécuter les tests et corriger les échecs

Lorsqu’un test échoue, corrigez le déclencheur ou le contenu, puis relancez tous les tests.

> **Tip**
>
> Pour itérer rapidement sur un déclencheur, créez un test de simulation dont l’[historique de chat](/docs/fr/eleven-agents/customization/agent-testing#simulation-testing) se termine par la demande de l’utilisateur,
> puis définissez **Nombre maximal de tours de conversation** sur `1`. L’agent répond une seule fois, ce qui suffit pour
> vérifier si la demande lance la bonne procédure, et chaque exécution reste courte. Rédigez les critères de réussite
> ainsi : *L’agent a lancé la procédure de remboursement*. Sans historique de chat, un agent avec un premier
> message utilise son unique tour pour sa salutation et le test ne vérifie rien.

Lorsqu’un test ou une conversation réelle échoue, cherchez la catégorie d’erreur qui en est à l’origine. Si l’agent a dit quelque chose d’incorrect, ajouter *Ne dites pas cela* corrige une conversation. Recherchez les conversations passées présentant des échecs similaires et rédigez une instruction qui les couvre toutes. La cause peut également se trouver dans la base de connaissances ou dans la configuration de l’agent. [Architect](/docs/fr/eleven-agents/operate/architect) peut effectuer cette recherche : ouvrez la conversation ayant échoué, sélectionnez **Architect**, puis demandez-lui de trouver des échecs similaires et de proposer une correction. Architect peut également transformer la conversation en test.

### Rédiger des déclencheurs

#### Rendez les déclencheurs concrets et distincts

Des déclencheurs qui se chevauchent ou sont vagues entraînent l’exécution de la mauvaise procédure. Préférez *Lorsque l’utilisateur demande à
résilier un abonnement* à \_Lorsque l’utilisateur a une question sur son compte \_.

#### Rédigez du point de vue de l’utilisateur

Décrivez ce que l’utilisateur demande, et non ce que l’agent doit faire. Les déclencheurs formulés comme des
actions de l’agent sont moins fiables. Préférez *Lorsque l’utilisateur demande à résilier son abonnement* à \_Résiliez
l’abonnement de l’utilisateur \_.

#### Couvrez les formulations réellement utilisées

Un déclencheur trop étroit peut manquer des demandes réelles lorsque l’utilisateur formule les choses différemment. Incluez les
variantes que l’utilisateur pourrait employer. *Lorsque l’utilisateur demande le remboursement, le retour ou le renvoi d’une
commande* fonctionne plus fiablement que \_Lorsque l’utilisateur demande un remboursement \_. [Recherchez dans les conversations passées](/docs/fr/eleven-agents/customization/agent-analysis/smart-search) pour découvrir comment les utilisateurs
formulent leur demande.

#### Passez d’une procédure associée à une autre

Les utilisateurs modifient parfois leur demande au cours d’une procédure, et le déclencheur seul peut ne pas
lancer la bonne procédure. Pour un changement que vous observez souvent dans les conversations passées, ajoutez une référence intégrée
à l’autre procédure dans le contenu de la première. Par exemple, écrivez \_Si l’utilisateur souhaite un
remboursement plutôt qu’un échange, exécutez \_, puis ajoutez une référence intégrée vers la procédure de remboursement. Si
la plupart des procédures nécessitent un transfert, rendez plutôt les déclencheurs plus distincts.

### Rédiger le contenu

#### Utilisez l’impératif

Rédigez les étapes comme des instructions à l’agent : *Recherchez la dernière commande du client* plutôt que \_Vous
devriez rechercher la dernière commande du client \_. Les instructions directes sont plus faciles à suivre que les
suggestions.

#### Expliquez l’importance d’une étape

Le raisonnement se généralise aux cas particuliers que la procédure n’énumère pas. Une courte explication, comme \_car nous avons besoin
de l’identifiant de commande pour émettre un remboursement \_, aide l’agent à gérer les situations que les étapes n’avaient pas prévues.
Évitez les OBLIGATIONS en majuscules et les scripts rigides lorsqu’une explication d’une ligne suffit.

#### Indiquez quoi faire plutôt que ce qu’il faut éviter

Décrivez le comportement attendu. *Si vous ne trouvez pas la commande, demandez à l’utilisateur de confirmer l’identifiant de
commande* fonctionne mieux que \_N’inventez pas les détails de la commande \_. Pour les erreurs très coûteuses, ajoutez également un
[garde-fou](/docs/fr/eleven-agents/best-practices/guardrails).

#### Utilisez des étapes lorsque l’ordre compte

Les étapes numérotées sont utiles lorsque l’agent doit effectuer des actions dans un ordre fixe. Pour les décisions nécessitant du jugement, quelques
phrases de conseils fonctionnent souvent mieux, en particulier avec des modèles plus performants.

#### Conservez les faits dans la base de connaissances

Une procédure décrit ce que l’agent doit faire dans une situation donnée. Les informations précises, comme
les prix, les détails des forfaits ou les horaires d’ouverture, ont leur place dans la [base de connaissances](/docs/fr/eleven-agents/customization/knowledge-base). Référencez le document depuis la
procédure qui en a besoin. Par exemple, au lieu de lister le prix de chaque forfait dans la procédure,
écrivez *Indiquez le prix à partir de*, puis ajoutez une référence intégrée vers un document tarifaire.

### Composer des procédures

#### Rédigez une procédure par situation

Si une situation est répartie entre plusieurs procédures étroites, l’agent a davantage de déclencheurs parmi lesquels
choisir et lance plus souvent le mauvais. Si deux procédures se lanceraient pour la même
demande, fusionnez-les. Un contenu de plus d’environ 3 000 caractères couvre généralement plus d’une
situation.

#### Extrayez les étapes communes dans une sous-procédure

Si les mêmes étapes apparaissent dans plusieurs procédures, comme la vérification de l’identité d’un client, la recherche
d’une commande ou le transfert vers un intervenant humain, extrayez-les dans une [sous-procédure](#sub-procedures), puis
référencez-la depuis chacune qui en a besoin via le menu slash. La maintenance des étapes communes à un seul
endroit garantit la cohérence de toutes les procédures qui les utilisent.

#### Utilisez des sous-procédures pour les actions réactives

Utilisez une sous-procédure pour une action que l’agent doit exécuter uniquement lorsqu’une autre procédure la demande,
comme une vérification d’identité ou une escalade. Sans déclencheur, elle ne concurrence pas les procédures d’entrée
au début de la conversation. Moins de choix de déclencheurs permettent de maintenir un routage ciblé.

#### Référencez les outils depuis la procédure qui les utilise

Référencez un outil depuis la procédure qui l’utilise au lieu de l’associer à l’ensemble de l’agent. L’outil
reste ainsi absent des conversations sans rapport. Dans une procédure libre, l’outil est disponible
uniquement tant que la procédure figure parmi les cinq dernières lancées. Mentionnez donc aussi la tâche de l’outil dans
le déclencheur, par exemple *ou lorsque vous devez rechercher une commande*. Consultez
[Limites](/docs/fr/eleven-agents/customization/procedures#limitations).

#### Utilisez le prompt système pour le comportement global

Le ton, l’identité, les politiques de refus et les garde-fous relèvent du [prompt système](/docs/fr/eleven-agents/best-practices/prompting-guide). Placez les étapes spécifiques aux tâches dans les
procédures.

#### Les procédures sont versionnées avec l’agent

Les procédures font partie de la configuration de l’agent. Elles sont donc enregistrées ensemble lorsque vous publiez une
nouvelle version de l’agent. Pour revenir à un ensemble antérieur de procédures, restaurez une version antérieure de l’agent.
Consultez [Versionnage des agents](/docs/fr/eleven-agents/operate/versioning).

#### Partez de la documentation existante

Si votre équipe dispose déjà de SOP, utilisez l’outil d’importation pour les transformer en brouillons, puis affinez-les.