Guide pratique : Connecter une connexion GET  Assistal via AI Trust Layer

Connect a Mistral model in Azure AI Foundry to UiPath Agents via AI Trust Layer using a custom Integration Service connector.

Remarque :

This capability is currently generally available for enterprise customers upon request.

Ce guide explique comment connecter un modèle Mistral déployé dans Microsoft Azure AI Foundry à des agents UiPath via la fonctionnalité LLM Configurations d'AI Trust Layer. Vous créez un connecteur Integration Service personnalisé basé sur un modèle Azure OpenAI et adaptez son hook de demande aux exigences de l’API de MinMi.

Prérequis

• Custom connectors for AI Trust Layer enabled for your organization (currently available upon request for enterprise customers).
• Un modèle Modern déployé dans Azure AI Foundry (par exemple, mistral-small-2503)
• L’URL du point de terminaison Azure AI Foundry pour votre ressource
• Une clé API pour votre ressource Azure AI Foundry
• Organization administrator access in Test Cloud
• Accès à Integration Service et au générateur de connecteurs

Créer le connecteur personnalisé

1. Accédez à Admin > AI Trust Layer > Configurations LLM et sélectionnez Ajouter une configuration.
2. Définissez les valeurs Locataire, Produit et Fonctionnalité .
3. Sous Configuration du modèle, saisissez un alias personnalisé dans le champ Nom LLM et définissez Type d’API sur OpenAI.
4. Dans le champ Connecteur , sélectionnez Créer un connecteur personnalisé.
5. Sélectionnez le modèle Azure OpenAI , puis sélectionnez Créer un connecteur. Le générateur de connecteurs s’ouvre avec le modèle Azure OpenAI prérempli.

Modifier le connecteur pour la compatibilité diverse

Les modèles modèle sur Azure AI Foundry utilisent une validation de schéma stricte et n’acceptent pas tous les champs envoyés par défaut par le modèle Azure OpenAI. Le hook preRequest du connecteur doit résoudre ces différences avant que chaque requête n’atteigne le point de terminaison Minal.

Envois de modèles Azure OpenAI	Mistral sur Azure AI Foundry s'attend à	Résolution appliquée par hook
tool_choice: "required" ou forme d'objet	"none", "auto", ou "any"	Traduit en "any" lorsque des outils sont présents
parallel_tool_calls Champ	Champ non pris en charge (extra_forbidden)	Supprimé du corps de la requête
max_completion_tokens	max_tokens	Le champ est renommé

1. Dans Générateur de connecteurs, ouvrez la section Hooks et sélectionnez le hook permet .

2. Remplacez l'ensemble du corps du hook par le script suivant :

   // Normalize query params and payload for Mistral on Azure AI Foundry.
   // Removes unsupported fields and adapts tool semantics for Mistral's strict schema.
   const _reqPath = (typeof request_path !== 'undefined') ? request_path : '';
   const _reqParams = (typeof request_parameters !== 'undefined') ? request_parameters : undefined;
   const _cfg = (typeof configuration !== 'undefined') ? configuration : undefined;
   
   if (['/query', '/v1/responses'].includes(_reqPath)) {
       return done();
   }
   
   let apiVersion = (_cfg && _cfg['api-version']) ? _cfg['api-version'] : "2023-05-15";
   if (_reqParams && _reqParams["api-version"]) {
       apiVersion = _reqParams["api-version"];
   }
   if (['/listAllModels', '/auth_validation'].includes(_reqPath)) {
       apiVersion = (_cfg && _cfg['api-version']) ? _cfg['api-version'] : "2023-10-01-preview";
   }
   
   // Resolve body across different runtime variable names
   let body = (typeof request_body !== 'undefined' && request_body) ? request_body :
              ((typeof request_vendor_body !== 'undefined' && request_vendor_body) ? request_vendor_body :
               ((typeof request !== 'undefined' && request && request.body) ? request.body : undefined));
   
   if (body && typeof body === 'string') {
       try { body = JSON.parse(body); } catch (e) { /* leave as-is */ }
   }
   
   if (body && typeof body === 'object') {
       // Remove field rejected by Mistral's strict schema
       if (Object.prototype.hasOwnProperty.call(body, 'parallel_tool_calls')) {
           delete body.parallel_tool_calls;
       }
   
       // Normalize tool_choice: Mistral accepts only 'none', 'auto', or 'any'
       const _allowedToolChoice = new Set(['none', 'auto', 'any']);
       const _hasTools = Object.prototype.hasOwnProperty.call(body, 'tools')
           && Array.isArray(body.tools) && body.tools.length > 0;
   
       if (Object.prototype.hasOwnProperty.call(body, 'tool_choice')) {
           if (body.tool_choice === 'required') {
               body.tool_choice = 'any';
           } else if (body.tool_choice && typeof body.tool_choice === 'object') {
               body.tool_choice = 'any';
           } else if (typeof body.tool_choice === 'string' && !_allowedToolChoice.has(body.tool_choice)) {
               body.tool_choice = _hasTools ? 'any' : 'auto';
           }
       } else if (_hasTools) {
           // Force tool usage: agent runtime expects tool calls when tools are configured
           body.tool_choice = 'any';
       }
   
       // Rename max_completion_tokens to max_tokens
       if (Object.prototype.hasOwnProperty.call(body, 'max_completion_tokens')) {
           if (!Object.prototype.hasOwnProperty.call(body, 'max_tokens')) {
               body.max_tokens = body.max_completion_tokens;
           }
           delete body.max_completion_tokens;
       }
   }
   
   const out = {
       request_vendor_parameters: { "api-version": apiVersion }
   };
   
   if (typeof request_body !== 'undefined') out.request_body = body;
   if (typeof request_vendor_body !== 'undefined') out.request_vendor_body = body;
   
   return done(out);
   

3. Dans les paramètres du connecteur, définissez l' URL de base sur votre point de terminaison Azure AI Foundry : https://{your-resource-name}.openai.azure.com/openai.

4. Définissez le type d'authentification pour qu'il corresponde à votre configuration. Cet exemple utilise une clé API (customApiKey), mais vous pouvez utiliser n'importe quel type d'authentification pris en charge, y compris OAuth – mettez à jour les paramètres du connecteur en conséquence.

5. Sélectionnez Enregistrer.

6. Publish the connector.

Créer une connexion dans Integration Service

1. Dans Integration Service, accédez à Connexions et sélectionnez Ajouter une connexion.
2. Sélectionnez le connecteur personnalisé que vous avez publié.
3. Dans le champ Clé API , saisissez votre clé API Azure AI Foundry.
4. Dans le champ Ressource Azure OpenAI , saisissez le nom de votre ressource, qui est la partie de sous-domaine de votre URL de point de terminaison, sans https:// ni .openai.azure.com.
5. Sélectionnez Connecter pour enregistrer la connexion.

Terminer la configuration LLM

1. Revenez aux configurations Admin > AI Trust Layer > LLM et ouvrez la configuration que vous avez commencé.
2. Sous Configuration du modèle, définissez Connecteur sur votre connecteur publié et Connexion sur la connexion que vous avez créée.
3. Dans le champ Identifieur LLM , saisissez le nom du déploiement exactement tel qu'il apparaît dans Azure AI Foundry.
   Remarque :

   Les espaces de fin dans le champ d'identifiant LLM provoquent une erreur DeploymentNotFound . Vérifiez qu’il n’y a pas d’espaces de début ou de fin avant d’enregistrer.

4. Sélectionnez Configuration de test pour exécuter la sonde AI Trust Layer.
5. Si la sonde réussit, sélectionnez Enregistrer.

Résultat

La configuration est enregistrée et le modèle Modern est disponible pour les agents UiPath pour le produit et la fonctionnalité que vous avez spécifiés. Les appels acheminent via la couche de confiance AI Trust Layer et apparaissent dans le journal d'audit sous Source : Connexion personnalisée.

Remarque :

Si vous rencontrez des problèmes lors de la création d’un connecteur personnalisé, contactez le support UiPath pour obtenir de l’aide.