Guide étape par étape : apprendre comment ajouter vos propres fonctions personnalisées à l’agent IA d’ONLYOFFICE

Daria Lapikhina

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum. Commentez

- Titre : Guide étape par étape : apprendre comment ajouter vos propres fonctions personnalisées à l’agent IA d’ONLYOFFICE

- Auteur : Daria Lapikhina

- Parution : 4 février 2026

- Licence : Copyright ® 2026 Daria Lapikhina . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Qu’est-ce qu’une fonction IA ?

- III. Pourquoi créer vos propres fonctions ?

- IV. Logique générale de l’ajout d’une fonction IA personnalisée

- V. Étapes pour ajouter une fonction personnalisée

- VI. Bonnes pratiques

- VII. Conclusion

- VIII. Ressources utiles

I - Introduction

Avec l’arrivée du nouvel agent IA dans ONLYOFFICE, les utilisateurs peuvent interagir en langage naturel avec leurs documents, feuilles de calcul et présentations. En plus des fonctions intégrées (résumés, reformulations, analyses, etc.), il est désormais possible d’ajouter vos propres fonctions personnalisées.

Dans ce guide, nous allons voir :

- ce que sont les fonctions IA et leur rôle ;

- pourquoi créer vos propres fonctions ;

- où et comment les enregistrer ;

- un exemple concret de fonction personnalisée ;

- et les bonnes pratiques pour aller plus loin.

II - Qu’est-ce qu’une fonction IA ?

Une fonction IA est un bloc de logique qui dit à l’agent IA :

- quelle requête envoyer au modèle ;

- et comment insérer ou manipuler le contenu dans le document.

En pratique, c’est une passerelle entre votre modèle IA (par exemple GPT, LLaMA ou Mistral) et l’API Office d’ONLYOFFICE.

Exemple : la fonction commentText permet de générer automatiquement un commentaire ou une note de bas de page sur le texte sélectionné.

III - Pourquoi créer vos propres fonctions ?

- Adapter l’IA à vos besoins : par exemple générer des résumés spécialisés, ajouter des références automatiques, créer des visualisations.

- Automatiser vos tâches : gagner du temps sur des actions répétitives.

- Étendre les éditeurs : transformer l’agent IA en un outil qui colle parfaitement à votre flux de travail.

IV - Logique générale de l’ajout d’une fonction IA personnalisée

Toutes les fonctions personnalisées se trouvent dans le répertoire helpers du plugin IA, avec une organisation par éditeur :

- cell.js – Fonctions IA pour l’éditeur de feuilles de calcul ;

- slide.js – Fonctions IA pour l’éditeur de présentations ;

- word.js – Fonctions d’IA pour l’éditeur de documents texte.

Lorsque vous créez une nouvelle fonction personnalisée, ajoutez-la au fichier approprié pour l’éditeur auquel elle appartient.

V - Étapes pour ajouter une fonction personnalisée

Le processus d’ajout d’une fonction personnalisée comprend deux phases principales :

- enregistrement de la fonction : enregistre la fonction IA et ses métadonnées dans l’environnement de l’agent ;

- exécution de la fonction : met en œuvre la logique de base, qui comprend l’envoi de requêtes au modèle IA et la manipulation du contenu des documents à l’aide de notre API Office.

Exemple : la fonction commentText

Voici un exemple complet qui ajoute un commentaire ou une note de bas de page générée par l’IA.

1. Enregistrement

On crée un objet RegisteredFunction :

1. let func = new RegisteredFunction();

2. func.name = "commentText";

3. func.params = [             "type (string): whether to add as a 'comment' or as a 'footnote'    default is 'comment')"

4. ]; AI functions for the Document Editor

5. func.examples = [             "If you need to explain selected text as a comment, respond with:\n" +

6. "[functionCalling (commentText)]: {\"prompt\" : \"Explain this text\", \"type\": \"comment\"}",

7. "If you need to add a footnote to selected text, respond with:\n" +

8. "[functionCalling (commentText)]: {\"prompt\" : \"Add a footnote to this text\", \"type\": \"footnote\"}",

9. "If you need to comment selected text, respond with:\n" +

10. "[functionCalling (commentText)]: {\"prompt\" : \"Comment this text\"}",

11. "If you need to explain selected text as a footnote, respond with:\n" +

12. "[functionCalling (commentText)]: {\"prompt\" : \"Explain this text\", \"type\": \"footnote\"}"

13. ]

Ici :

- func.name : le nom que l’IA utilisera pour appeler cette fonction (par exemple, « commentText »).

- func.params : une liste des paramètres que la fonction attend de l’IA. Par exemple :

– prompt (string) : une description ou une instruction pour le commentaire.

– type (string) : « comment » ou « footnote » — spécifie ce qu’il faut insérer.

- func.examples : exemples d’appels de fonction corrects pour l’IA.

- func.description : explique à l’IA à quoi sert la fonction.

Ces paramètres sont utilisés par l’IA. L’objet RegisteredFunction() est défini dans le fichier helperFunc.js.

- Logique d’exécution

La fonction récupère le texte sélectionné, envoie une requête au modèle IA, puis insère le résultat en commentaire ou en note de bas de page :

1. func.call = async function(params) {

2. let type = params.type;

3. let isFootnote = "footnote" === type;

4. // Executes a block of code inside the editor's context using the office=js API.

5. let text = await Asc.Editor.callCommand(function(){

6. let doc = Api.GetDocument();

7. // Gets the current selected text range.

8. let range = doc.GetRangeBySelect();

9. let text = range ? range.GetText() : "";

10. if (!text)

11. {                     text = doc.GetCurrentWord(); // Selects the current word so comments can be applied to it.

12. doc.SelectCurrentWord();                 }                   return text;

Construisez l’invite pour l’IA en combinant params.prompt et le texte sélectionné.

let argPromt = params.prompt + ":\n" + text;

Initialisez l’objet AI.Request.create à l’aide de AI.Request.create. L’objet est défini dans le fichier engine.js. Cet objet facilite l’envoi d’une requête au modèle d’IA.

1. // Initializes a request engine for communicating with the AI model (e.g. Chat, Translation).

2. let requestEngine = AI.Request.create(AI.ActionType.Chat);

3. if (!requestEngine)

4. return;

Envoyez la requête à l’aide de chatRequest() et recevez le résultat dans un rappel.

1. // Sends a prompt to the AI model and processes the response via callback. Can stream or wait.

2. let result = await requestEngine.chatRequest(argPromt, false, async function(data) {

3. if (!data)

4. return;

Insérez la réponse sous forme de commentaire ou de note de bas de page à l’aide de AddFootnote() ou AddComment().

Implémentation d’AddFootnote :

1. if (isFootnote)

2. {                 let addFootnote = true;

3. // Sends a prompt to the AI model and processes the response via callback. Can stream or wait.

4. let result = await requestEngine.chatRequest(argPromt, false, async function(data) {

5. if (!data)

6. return;

7. // Marks the end of a logical group or block action in the editor.

8. await checkEndAction();

9. Asc.scope.data = data;                     Asc.scope.model = requestEngine.modelUI.name;                       if (addFootnote)

10. { // Executes a block of code inside the editor's context using the document model API.

11. await Asc.Editor.callCommand(function(){

12. // Returns the main document object, which gives access to all editing, structure, and selection APIs.

13. Api.GetDocument().AddFootnote();                         });                         addFootnote = false;

14. } // Inserts the AI-generated result into the document at the current selection or cursor.

15. await Asc.Library.PasteText(data);

16. });

Implémentation d’AddComment :

1. let commentId = null;

2. // Sends a prompt to the AI model and processes the response via callback. Can stream or wait.

3. let result = await requestEngine.chatRequest(argPromt, false, async function(data) {

4. if (!data)

5. return;

6. // Marks the end of a logical group or block action in the editor.

7. await checkEndAction();

8. Asc.scope.data = data;                     Asc.scope.model = requestEngine.modelUI.name;                     Asc.scope.commentId = commentId;   // Executes a block of code inside the editor's context using the document model API.

9. commentId = await Asc.Editor.callCommand(function(){

10. // Returns the main document object, which gives access to all editing, structure, and selection APIs.

11. let doc = Api.GetDocument();

12. let commentId = Asc.scope.commentId;

13. if (!commentId)

14. { // Gets the current selected text range, which can be modified or annotated.

15. let range = doc.GetRangeBySelect();

16. if (!range)

17. return null;

18. let comment = range.AddComment(Asc.scope.data, Asc.scope.model, "uid" + Asc.scope.model);

19. if (!comment)

20. return null;

21. doc.ShowComment([comment.GetId()]);                             return comment.GetId();

22. }                           let comment = doc.GetCommentById(commentId);

23. if (!comment)

24. return commentId;

25. comment.SetText(comment.GetText() + scope.data);                         return commentId;

26. });                 });             }

Remarque !

Pour garantir que l’ensemble des modifications puisse être annulé après l’exécution de la requête, nous utilisons les méthodes StartAction et EndAction dans la fonction commentText.

Implémentation complète de la fonction commentText avec commentaires :

1. (function(){

2. // Defines the commentText function — lets AI insert a comment or footnote for selected text using AI response.

3. WORD_FUNCTIONS.commentText = function()

4. {

5. // Creates a new function object that will be registered and exposed to the AI.

6. let func = new RegisteredFunction();

7. func.name = "commentText";

8. // Lists the parameters expected by the function. These are passed as a JSON object by the AI agent.

9. func.params = [             "type (string): whether to add as a 'comment' or as a 'footnote' (default is 'comment')"

10. ];   // Gives example JSON inputs to teach the AI how to correctly invoke this function.

11. func.examples = [             "If you need to explain selected text as a comment, respond with:\n" +

12. "[functionCalling (commentText)]: {\"prompt\" : \"Explain this text\", \"type\": \"comment\"}",

13. "If you need to add a footnote to selected text, respond with:\n" +

14. "[functionCalling (commentText)]: {\"prompt\" : \"Add a footnote to this text\", \"type\": \"footnote\"}",

15. "If you need to comment selected text, respond with:\n" +

16. "[functionCalling (commentText)]: {\"prompt\" : \"Comment this text\"}",

17. "If you need to explain selected text as a footnote, respond with:\n" +

18. "[functionCalling (commentText)]: {\"prompt\" : \"Explain this text\", \"type\": \"footnote\"}"

19. ];          // The actual logic that gets executed when the AI calls this function.

20. func.call = async function(params) {

21. let type = params.type;

22. let isFootnote = "footnote" === type;

23. // Executes a block of code inside the editor's context using the office-js API.

24. let text = await Asc.Editor.callCommand(function(){

25. let doc = Api.GetDocument();

26. // Gets the current selected text range.

27. let range = doc.GetRangeBySelect();

28. let text = range ? range.GetText() : "";

29. if (!text)

30. {                     text = doc.GetCurrentWord(); // Selects the current word so comments can be applied to it.

31. doc.SelectCurrentWord();                 }                   return text;

32. });               let argPromt = params.prompt + ":\n" + text;

33. // Initializes a request engine for communicating with the AI model (e.g. Chat, Translation).

34. let requestEngine = AI.Request.create(AI.ActionType.Chat);

35. if (!requestEngine)

36. return;

37. let isSendedEndLongAction = false;

38. // Marks the end of a logical group or block action in the editor.

39. async function checkEndAction() {

40. if (!isSendedEndLongAction) {

41. // Marks the end of a logical group or block action in the editor.

42. await Asc.Editor.callMethod("EndAction", ["Block", "AI (" + requestEngine.modelUI.name + ")"]);

43. isSendedEndLongAction = true

44. }             }   // Starts a block action in the editor, used for undo/redo

45. await Asc.Editor.callMethod("StartAction", ["Block", "AI (" + requestEngine.modelUI.name + ")"]);

46. // Starts a block action in the editor, used for undo/redo

47. await Asc.Editor.callMethod("StartAction", ["GroupActions"]);

48. if (isFootnote)

49. {                 let addFootnote = true;

50. // Sends a prompt to the AI model and processes the response via callback

51. let result = await requestEngine.chatRequest(argPromt, false, async function(data) {

52. if (!data)

53. return;

54. // Marks the end of a block action in the editor.

55. await checkEndAction();

56. Asc.scope.data = data;                     Asc.scope.model = requestEngine.modelUI.name;                       if (addFootnote)

57. { // Executes a block of code inside the editor's context using the  office-js API.

58. await Asc.Editor.callCommand(function(){

59. Api.GetDocument().AddFootnote();                         });                         addFootnote = false;

60. } // Inserts the AI-generated result into the document at the current selection or cursor.

61. await Asc.Library.PasteText(data);

62. });             }             else

63. {                 let commentId = null;

64. // Sends a prompt to the AI model and processes the response via callback.

65. let result = await requestEngine.chatRequest(argPromt, false, async function(data) {

66. if (!data)

67. return;

68. // Marks the end of a block action in the editor.

69. await checkEndAction();

70. Asc.scope.data = data;                     Asc.scope.model = requestEngine.modelUI.name;                     Asc.scope.commentId = commentId;   // Executes a block of code inside the editor's context using the office-js API.

71. commentId = await Asc.Editor.callCommand(function(){

72. let doc = Api.GetDocument();

73. let commentId = Asc.scope.commentId;

74. if (!commentId)

75. { // Gets the current selected text range.

76. let range = doc.GetRangeBySelect();

77. if (!range)

78. return null;

79. let comment = range.AddComment(Asc.scope.data, Asc.scope.model, "uid" + Asc.scope.model);

80. if (!comment)

81. return null;

82. doc.ShowComment([comment.GetId()]);                             return comment.GetId();

83. }                           let comment = doc.GetCommentById(commentId);

84. if (!comment)

85. return commentId;

86. comment.SetText(comment.GetText() + scope.data);                         return commentId;

87. });                 });             }   // Marks the end of a  block action in the editor.

88. await checkEndAction();

89. // Marks the end of a block action in the editor.

90. await Asc.Editor.callMethod("EndAction", ["GroupActions"]);

91. };           return func;

92. }

Remarque !

Pour que vos fonctions IA personnalisées soient disponibles dans l’éditeur de documents, vous devez modifier le bloc getWordFunctions dans le fichier word.js. Cette fonction collecte et renvoie toutes les fonctions WORD_FUNCTIONS enregistrées que l’agent IA peut appeler.

funcs.push(WORD_FUNCTIONS.myCustomFunction());

VI - Bonnes pratiques

Toujours encapsuler vos actions avec StartAction et EndAction → permet d’annuler facilement les modifications.

Fournir des exemples clairs dans func.examples → l’IA saura mieux utiliser votre fonction.

Tester dans chaque éditeur (Word, Spreadsheet, Presentation) → le comportement peut varier.

Documenter vos fonctions pour les partager avec la communauté open source.

VII - Conclusion

Avec l’agent IA d’ONLYOFFICE, vous n’êtes pas limité aux fonctions par défaut. Grâce aux fonctions personnalisées, vous pouvez :

- enrichir vos documents ;

- automatiser vos flux de travail ;

- et transformer vos éditeurs en véritables assistants intelligents adaptés à vos besoins.

VIII - Ressources utiles

- Agent IA ONLYOFFICE sur GitHub

- Présentation et méthodes de l’API Office

- Les meilleurs cours et tutoriels pour apprendre ONLYOFFICE