Le Model Context Protocol (MCP) ouvre la voie à une nouvelle façon de faire dialoguer les modèles d’IA et leurs outils. Que ce soit pour tester un environnement local ou déployer une architecture prête à l’emploi dans Azure, MCP apporte une approche standardisée, simple à expérimenter mais suffisamment flexible pour être adaptée à des besoins complexes.
Dans cet article, je vous propose un tutoriel pas à pas pour mettre en place un serveur MCP, le tester avec MCP Inspector, puis le déployer dans Azure afin d’explorer tout son potentiel.
Qu’est-ce que MCP ?
Mon premier article est un bon point de départ pour vous informer sur le sujet :
Le protocole MCP (Model Context Protocol) est un protocole qui permet à différents modèles et outils d’IA de communiquer entre eux. Il fournit un moyen standardisé pour les modèles de partager des informations et de collaborer sur des tâches. Le serveur MCP sert de pont entre différents modèles et outils, leur permettant de fonctionner ensemble de manière transparente.
Je peux également vous conseiller de voir cette vidéo, mais également de consulter la page officielle du protocole MCP :
Vous trouverez ci-dessous le schéma d’architecture d’une configuration type de serveur MCP :
Enfin cette page rassemble une collection d’implémentations de serveurs MCP, qu’il s’agisse de versions officielles (références) ou proposées par la communauté. Elle sert de bibliothèque centrale pour explorer et découvrir des exemples de serveurs MCP capables de fournir aux modèles d’IA un accès contrôlé à des outils ou sources de données.
Qu’est-ce que MCP Inspector ?
MCP Inspector est un outil graphique fourni par l’équipe du Model Context Protocol qui sert à tester, déboguer et explorer un serveur MCP.
Il permet notamment de :
Se connecter à un serveur MCP local ou distant
Lister les outils (tools) que le serveur met à disposition.
Tester ces outils en leur envoyant des requêtes et en visualisant les réponses.
Explorer d’autres ressources exposées par le serveur, comme les prompts ou les files.
Vérifier en temps réel le statut de connexion et les échanges de données.
En résumé, c’est l’équivalent d’une console d’administration interactive qui te permet de voir comment ton serveur MCP réagit et d’expérimenter ses fonctionnalités sans devoir écrire du code côté client.
Envie de tester le déploiement d’un serveur MCP sur Azure ?
Cette page explique comment tester un serveur MCP en local ou hébergé sur Azure à l’aide de clients MCP sur desktop, comme Visual Studio Code ou MCP Inspector :
Ce guide constitue donc un point de départ idéal pour expérimenter la connexion et l’interaction avec un serveur MCP.
Afin de rendre la démonstration plus complète, j’y ai effectué quelques modifications, et j’ai publié le tout sur mon GitHub :
L’exercice consiste à configurer un serveur MCP, d’abord en local puis sur Azure, afin de comprendre son fonctionnement et tester ses outils :
Vous expérimentez ensuite les actions soit directement via ces outils, soit au travers de prompts, en observant le code généré à chaque étape.
La seconde partie de l’exercice consiste à déployer sur Azure Container Apps pour valider le bon fonctionnement du serveur MCP hébergé.
Maintenant, il ne nous reste plus qu’à tester tout cela 😎
Ouvrez Visual Studio Code avec la commande suivante :
Code .
Dans Visual Studio Code, ouvrez le terminal intégré :
Exécutez la commande suivante pour installer NPM (gestionnaire de paquets Node.js) :
npm install
Attendez la fin de l’installation des différents packages NPM :
Lancez le script suivant pour générer un token sur le serveur MCP :
npm run generate-token
Vérifiez la création du fichier .env et copiez la valeur du token généré :
Ajoutez la ligne suivante pour renseigner le point de terminaison Azure OpenAI, puis sauvegardez :
# Azure OpenAI Configuration (optional but recommended for intelligent prompts)
AZURE_OPENAI_API_KEY=your-azure-openai-api-key-here
AZURE_OPENAI_ENDPOINT=https://your-resource-name.openai.azure.com
AZURE_OPENAI_MODEL=gpt-4o
Lancez localement le serveur MCP avec la commande NPM suivante :
npm run dev
Vérifiez la création de la base de données SQLite en mémoire, ainsi que le lancement réussi du serveur MCP :
Notre environnement en local est maintenant déployé. Nous allons maintenant utiliser MCP Inspector pour explorer les fonctionnalités du serveur MCP.
Etape II – Tests du serveur MCP local :
Ouvrez une seconde fenêtre de Terminal :
Lancez l’outil MCP Inspector avec la commande suivante :
npm run inspect
Récupérez l’URL du proxy MCP Inspector contenant son propre token d’accès :
Ouvrez cette URL dans un navigateur et vérifiez la présence du token MCP Inspector :
Copiez ensuite la valeur du token du serveur MCP et ajoutez-la dans le fichier .env :
Complétez les champs requis pour la connexion au serveur MCP local, puis cliquez ici pour vous connecter :
Vérifiez dans les logs l’authentification réussie du client vers le serveur MCP :
Dans MCP Inspector, vérifiez le statut Connected, puis cliquez sur l’onglet Tools :
Cliquez sur Lister les Tools pour afficher les outils déclarés :
Constatez l’apparition de la liste des outils disponibles :
Observez les opérations effectuées du côté du serveur MCP :
Utilisez l’outil List_ToDo, lancez-le et vérifiez le résultat obtenu :
Analysez les logs générés par le serveur MCP pour cette opération :
Utilisez l’outil Add _ToDo pour créer une nouvelle tâche, puis constatez l’opération :
Observez les logs correspondant à l’ajout de la nouvelle tâche dans la base SQLite :
Ajoutez plusieurs tâches supplémentaires :
Relancez List_ToDo :
Analysez les logs générés par le serveur MCP pour cette opération :
Utilisez Complete_ToDo pour marquer une tâche comme complétée :
Vérifiez les logs correspondant à cette mise à jour :
Relancez List_ToDo pour constater que la tâche est complétée :
Observez les logs correspondant à cette liste mise à jour :
Passez à l’onglet Prompts, puis cliquez ici pour lister les assistants IA disponibles :
Vérifiez les logs générés par cette action :
Cliquez sur ToDo Assistant, entrez un exemple de requête (ex. : lister les tâches), puis constatez la réponse générée :
Observez les logs correspondant à ce prompt :
Testez un prompt de suppression d’une tâche, puis exécutez-le :
Vérifiez les logs générés et l’action effectuée sur la base SQLite :
Relancez List_ToDo pour constater que la tâche a bien été supprimée :
Testez un prompt de mise à jour de toutes les tâches :
Constatez le résultat dans les logs :
Créez une nouvelle tâche via un prompt :
Observez les logs correspondant à l’ajout de cette nouvelle tâche :
La démonstration sur l’environnement local est terminée, passons maintenant au déploiement sur Azure.
Etape III – Déploiement du serveur MCP sur Azure :
Rendez-vous sur l’URL de téléchargement de Docker Desktop, puis téléchargez la version correspondant à votre OS :
Lancez l’exécutable compatible avec votre architecture :
Suivez l’installation :
Cochez les options proposées puis cliquez sur OK :
Attendez la fin de l’installation (de 5 à 10 minutes) :
Cliquez sur Fermer, puis redémarrez l’ordinateur :
Après le redémarrage, ouvrez Docker Desktop, puis laissez le téléchargement des composants additionnels se terminer :
Patientez si des mises à jour sont nécessaires, puis redémarrez si demandé :
Attendez le démarrage complet de Docker Engine :
Vous devez voir l’écran principal de Docker Desktop avec un tableau de bord vide de conteneurs :
Ouvrez Visual Studio Code, puis ouvrez un nouveau terminal :
Lancez la commande azd pour vérifier si Azure Developer CLI est installé :
azd version
Si Azure Developer CLI n’est pas installé, exécutez la commande pour l’installer :
winget install microsoft.azd
Attendez la fin de l’installation :
Fermez puis rouvrez Visual Studio Code et vérifiez que azdest bien installé :
Depuis le dossier du serveur MCP, lancez la commande azd up pour déployer l’infrastructure sur Azure :
Connectez-vous avec votre compte Azure :
Patientez pendant la préparation de l’image du conteneur :
Constatez la création locale des images Docker dans Docker Desktop :
Donnez un nom à votre application unique sur Azure :
Choisissez votre souscription Azure :
Saisissez les informations liées à Azure OpenAI :
Sélectionnez la région Azure :
Attendez la fin du déploiement des ressources Azure :
Sur le portail Azure, vérifiez la création complète des ressources :
Quelques minutes plus tard :
Attendez encore la fin du déploiement de l’image :
Constatez le déploiement terminé dans Visual Studio Code :
Retournez sur Azure et ouvrez la page de votre Azure Container App :
Copiez l’URL publique de votre application :
Dans la section Revisions and Replicas, vérifiez que le conteneur est démarré :
Dans Environment Variables, récupérez ou vérifiez la présence du token d’application :
Depuis Visual Studio Code, relancez MCP Inspector en local :
npm run inspect
Copiez l’URL avec le token de MCP Inspector :
Connectez MCP Inspector à votre Azure Container App avec l’URL et le token :
Effectuez à nouveau des opérations List_ToDo et créez de nouvelles tâches :
Testez différents prompts de listing et de complétion :
Testez également la partie prompting :
Vérifiez que la base temporaire SQLite est bien mise à jour :
Conclusion
Avec ce déploiement, vous disposez désormais d’un serveur MCP pleinement opérationnel, capable de dialoguer avec vos modèles d’IA et de gérer des outils de manière sécurisée, que ce soit en local ou dans le cloud Azure.
Et la suite ?
Si le sujet vous intéresse, je vous recommande vivement de consulter cette page, vous y trouverez d’autres serveurs MCP déjà mis à disposition, que vous pourrez tester pour découvrir leurs capacités, et dont la liste ne cesse de s’allonger.
Enfin, il peut également être intéressant d’explorer la création de serveurs MCP personnalisés dans l’environnement Microsoft 365, d’autant qu’une vidéo très pertinente sur le sujet est également disponible :
Alex Wolf, de la chaîne YouTube The Code Wolf, continue de peaufiner son application DBChatPro version après version et dévoile la v6 ! Cette nouvelle version intègre maintenant un serveur MCP, exposant les fonctionnalités clés de DBChatPro à d’autres outils d’IA (GitHub Copilot, etc.) ou même à vos propres applications. Dans cet article, nous explorons les fondamentaux du MCP, puis nous détaillons l’installation du serveur MCP de DBChatPro.
Avant toute manipulation technique, et pour bien saisir l’intérêt d’une architecture MCP, je vous recommande la lecture de l’excellent billet disponible sur Digidop, écrit par Thibaut Legrand. Voici un extrait de ce billet qui illustre parfaitement l’avantage d’une architecture MCP :
Qu’est-ce que le Model Context Protocol (MCP) ?
Le Model Context Protocol (MCP) est un standard ouvert conçu par Anthropic (l’entreprise à l’origine de Claude) qui offre aux modèles d’IA un accès sécurisé à diverses sources de données et outils externes.
Il fonctionne comme un « USB-C universel » pour l’IA, facilitant la communication avec n’importe quel service ou base de données.
Pourquoi le MCP a été créé ?
Avant le MCP, relier un LLM à des sources externes était laborieux et non standardisé. Les grands modèles de langage (GPT, Claude, Gemini…) présentent deux limites majeures :
Limite de contexte : Ils ne peuvent raisonner que sur les informations présentes dans leur contexte immédiat
Impossibilité d’action : Ils peuvent générer du texte mais ne peuvent pas agir sur le monde extérieur
La métaphore du « problème M×N » illustre parfaitement cette situation : pour connecter un nombre M modèles d’IA à un nombre N outils externes, il fallait créer M×N intégrations différentes. Le MCP transforme cette équation en M+N, réduisant drastiquement la complexité d’intégration.
Prenons un exemple concret :
une entreprise utilisant 4 modèles d’IA différents (Claude, GPT-4, Gemini, Deepseek) qui souhaite les connecter à 5 services externes (GitHub, Slack, Google Drive, Salesforce, base de données interne).
Sans MCP, cela nécessiterait 4×5=20 intégrations personnalisées. Avec MCP, on passe à seulement 4+5=9 composants (4 clients MCP et 5 serveurs MCP), soit une réduction de 55% de la complexité et du temps de développement.
MCP vs API traditionnelles : quelles différences ?
Pour comprendre l’importance du MCP, comparons-le aux API REST traditionnelles :
Caractéristique
MCP
API REST traditionnelles
Communication
Bidirectionnelle et en temps réel
Généralement requête-réponse unidirectionnelle
Découverte d’outils
Automatique et dynamique
Configuration manuelle nécessaire
Conscience du contexte
Intégrée
Limitée ou inexistante
Extensibilité
Plug-and-play
Effort d’intégration linéaire
Standardisation
Protocole unifié pour tous les modèles
Variable selon les services
Orientation
Conçu spécifiquement pour les modèles d’IA
Usage général
Cette standardisation représente un changement de paradigme pour quiconque souhaite développer des applications IA véritablement connectées.
Architecture et fonctionnement du MCP
L’architecture du MCP repose sur trois composants principaux qui interagissent de façon coordonnée :
Les composants clés du MCP
Hôtes MCP : Ce sont les applications qui intègrent l’IA et ont besoin d’accéder à des données externes. Par exemple, Claude Desktop, un IDE comme Cursor, ou toute application intégrant un LLM.
Clients MCP : Ce sont des intermédiaires qui maintiennent les connexions sécurisées entre l’hôte et les serveurs. Chaque client est dédié à un serveur spécifique pour garantir l’isolation.
Serveurs MCP : Ce sont des programmes externes qui fournissent des fonctionnalités spécifiques et se connectent à diverses sources comme Google Drive, Slack, GitHub, ou des bases de données.
Le flux de communication MCP se déroule typiquement en quatre étapes bien définies :
Découverte : L’hôte (comme Claude Desktop) identifie les serveurs MCP disponibles dans son environnement
Inventaire des capacités : Les serveurs MCP déclarent leurs fonctionnalités disponibles (outils, ressources, prompts)
Sélection et utilisation : Quand l’utilisateur pose une question nécessitant des données externes, l’IA demande l’autorisation d’utiliser un outil spécifique
Exécution et retour : Le serveur MCP exécute l’action demandée (recherche web, accès à un fichier, etc.) et renvoie les résultats à l’IA qui peut alors formuler une réponse complète
Ce processus standardisé permet une communication fluide entre l’IA et les sources de données externes, tout en maintenant un contrôle transparent pour l’utilisateur.
Serveurs MCP existants
Plutôt que de développer vos propres serveurs MCP depuis zéro, vous pouvez exploiter l’écosystème grandissant de serveurs préexistants. Ces solutions prêtes à l’emploi vous permettent d’intégrer rapidement des fonctionnalités avancées dans vos projets IA :
Serveurs officiels et communautaires
GitHub : Ce serveur MCP vous permet d’interagir avec des dépôts de code directement depuis votre application IA. Vous pouvez rechercher des fichiers, créer des issues, analyser des pull requests, ou même générer des commits et du code. Idéal pour les assistants de développement qui nécessitent une compréhension du contexte du code.
Google Drive : Offre un accès complet aux documents stockés sur Google Drive. Votre modèle d’IA peut ainsi lire, créer, modifier ou organiser des documents, présentations et feuilles de calcul, en conservant le contexte des informations partagées.
Slack : Permet à vos modèles d’IA d’interagir avec les canaux et conversations Slack. Ils peuvent envoyer des messages, surveiller des chaînes spécifiques, ou même répondre automatiquement à certains types de requêtes, créant ainsi une intégration transparente dans les flux de communication d’équipe.
Puppeteer : Un puissant serveur MCP qui apporte la capacité de naviguer sur le web. Vos modèles d’IA peuvent visiter des sites, remplir des formulaires, capturer des captures d’écran et extraire des données, ouvrant la voie à l’automatisation avancée des tâches web.
Brave Search : Donne à vos modèles d’IA la capacité d’effectuer des recherches web en temps réel via le moteur Brave. Cela permet de répondre à des questions sur l’actualité récente ou d’accéder à des informations au-delà de la date limite de formation du modèle.
PostgreSQL : Connecte vos modèles d’IA directement à vos bases de données PostgreSQL. Les modèles peuvent effectuer des requêtes SQL, analyser des données et même assister à la conception de schémas de base de données.
SQLite : Variante plus légère pour les bases de données locales, particulièrement utile pour les applications de bureau ou les projets avec des exigences de stockage plus modestes.
Qdrant : Serveur spécialisé pour les bases de données vectorielles, essentiel pour les applications IA nécessitant une recherche sémantique ou par similarité.
Afin de voir comment cela marche, voici les différentes étapes que nous allons suivre sur un environnement de test :
Vérifiez ces variables dans les Propriétés système de Windows, section « Variables d’environnement », afin de confirmer leur bonne configuration :
Créez un service Azure OpenAI depuis le portail Azure, puis ajoutez votre application en tant que « Cognitive Services OpenAI User » dans « Contrôle d’accès (IAM) » :
Revenez à la page principale de votre service Azure OpenAI, puis cliquez sur Ouvrir dans la Fonderie pour accéder à l’interface de déploiement :
Dans la Fonderie, ouvrez l’onglet Déploiements et cliquez sur Nouveau déploiement, puis nommez-le (par ex : gpt-4o) et copiez l’URL de l’endpoint :
Créez une base de données Azure SQL Database avec des données en exemple, puis copiez la chaîne de connexion complète pour la réutiliser plus tard :
Notre environnement Azure est prêt. Nous allons maintenant pouvoir déployer l’application DBChatPro sur notre poste en local.
Etape II – Déploiement et test de l’application DBChatPro :
Accédez au dépôt GitHub de l’application via le lien, puis téléchargez l’archive ZIP sur votre poste :
Extrayez l’archive ZIP, puis placez-vous dans le dossier extrait pour préparer l’ouverture du projet :
Lancez Visual Studio Code, puis cliquez ici pour sélectionner le dossier du projet :
Sélectionnez le dossier extrait contenant le projet, puis validez pour l’ouvrir dans VS Code :
Observez la nouvelle architecture de DBChatPro avec la partie MCP distincte de l’interface graphique, puis passez à la configuration UI :
Commencez par l’interface graphique en renseignant les endpoints de votre choix dans le fichier de configuration, puis sauvegardez vos modifications :
Dans mon cas, j’ai utilisé le modèle Azure OpenAI :
Ouvrez la console intégrée Terminal de VS Code, positionnez-vous dans le dossier racine de l’application, lancez l’application, puis patientez quelques secondes pour que le serveur local démarre :
Copiez l’URL locale générée par l’application, puis ouvrez-la dans votre navigateur préféré :
Dans le navigateur, constatez que la base de données n’est pas encore configurée, puis cliquez sur Connexion :
Collez votre chaîne de connexion SQL en modifiant le mot de passe, puis cliquez sur Check Connection pour tester la liaison :
Vérifiez la découverte automatique du schéma de la base de données, puis cliquez ici pour sauvegarder pour valider l’import :
Dans le terminal, observez également l’import du plan et du schéma de votre base SQL :
Sur la page principale de l’application, sélectionnez le modèle et la plateforme d’IA, puis saisissez votre prompt :
Patientez quelques secondes pour afficher le résultat généré par le modèle :
Consultez l’onglet Insight pour obtenir des informations complémentaires sur la réponse, puis analysez les données fournies :
Sur l’onglet SQL Editor, constatez la transformation de votre requête en SQL :
Observez les résultats sous forme de tableau retournés par la requête SQL :
Accédez à l’historique des requêtes exécutées, puis identifiez celles que vous souhaitez réutiliser :
La fonction Chat vous permet de relancez une seconde requête basée sur les résultats de la première :
Testez cette seconde requête et constatez les résultats :
Au final, on constate que l’interface graphique de DBChatPro ne cesse d’évoluer pour offrir plus de facilité et une meilleure gestion des bases de données.
Passons maintenant à la partie MCP qui nous intéresse également.
Etape III – Déploiement du serveur MCP :
Revenez sur Visual Studio Code dans le programme MCP afin de paramétrer l’endpoint Azure OpenAI :
Collez également votre connexion SQL complète :
Cliquez sur le bouton Démarrer pour lancer le serveur MCP, puis patientez quelques instants :
Vérifiez que le serveur est démarré et affiche l’état Running :
Ouvrez la fenêtre Chat dans Visual Studio Code :
Assurez-vous que vous êtes en mode agent pour l’intelligence artificielle :
Dans la boîte à outils, confirmez que le serveur MCP et ses sous-modules sont actifs, puis refermez le panneau :
Effectuez un test de base pour vérifier que l’IA vous répond :
Lancez un prompt en spécifiant l’utilisation de DBChatPro avec un modèle et une plateforme AI, puis validez l’alerte :
use DbChatPro to get 10 customers from the database using AzureOpenAI and gpt-4o
Constatez que la connexion à la base de données et au modèle a bien fonctionné :
Observez en chat l’input et l’output de la requête :
Visualisez le résultat sous forme de tableau retourné par l’IA :
Lancez un second prompt sans redéfinir les paramètres du modèle, puis constatez que la réponse est tout de même générée :
Effectuez un autre test avec un prompt différent sur la même base :
Observez le résultat structuré cette fois en liste :
Si vous le souhaitez, testez la plateforme IA de GitHub en paramétrant un token d’accès sur cette page, puis copiez-le :
Sur ce token, autorisez l’accès en lecture pour interroger les modèles GitHub Copilot, puis confirmez cette permission :
Renseignez le modèle GitHub dans la configuration MCP et redémarrez le serveur, puis patientez quelques instants :
Relancez un prompt en utilisant le modèle GitHub Copilot comme plateforme IA :
Constatez le retour de résultats :
Envoyez cette fois un prompt combiné, interrogeant le serveur MCP via les deux modèles d’IA, puis constatez la fusion des réponses :
Enfin, découvrez sur sa vidéo, toujours depuis Visual Studio Code, des fonctions de troubleshooting très pratiques :
Conclusion
L’intégration du MCP transforme votre assistant en un véritable pont entre l’IA et le monde réel. Fini les intégrations sur mesure : grâce à ce protocole standard, un modèle peut interagir avec des bases de données, GitHub Copilot ou tout autre outil compatible.
On passe d’une complexité M×N à un système modulaire, extensible et sécurisé.
En adoptant le Model Context Protocol dès aujourd’hui, vous préparez vos solutions à l’IA de demain : une IA connectée, actionnable et interopérable, capable de faire bien plus que répondre, mais également d’interagir.
Microsoft continue d’aider la communauté des développeurs AI et propose désormais de nouveaux modèles d’applications Chat IA développé en .NET. Avec ces modèles d’application comme point de départ, vous pouvez rapidement créer des applications web de chat avec un ou des modèles d’intelligence artificielle dédiés. Tous ces modèles d’application AI en .NET sont désormais disponibles en préversion depuis mars 2025.
Vous souhaitez vous lancer dans le développement de l’IA, mais vous ne savez pas par où commencer ? J’ai un cadeau pour vous : nous avons un nouveau modèle d’application Web de chat sur l’IA qui est maintenant disponible en avant-première. 😊 Ce modèle fait partie de nos efforts continus pour faciliter la découverte et l’utilisation du développement de l’IA avec .NET
A quoi sert une application développée pour du chat IA ?
Une application de chat IA ne se contente pas de générer des réponses : elle les enrichit à partir de contenus existants (comme du code, des documents, etc.).
Un modèle d’embedding, qui transforme des textes en vecteurs numériques. → Il est utilisé pour rechercher les passages les plus pertinents dans une base de connaissances locale ou distante.
Un modèle génératif, qui prend ces passages et génère une réponse claire et naturelle, dans le style d’un assistant conversationnel.
Deux modèles, deux usages ?
Quand on développe une application en relation avec des modèles l’intelligence artificielle intégrant de la données, il est important de comprendre la différence entre deux grandes catégories de modèles d’IA :
1. Modèle de génération de texte (aussi appelés LLM – Large Language Models)
🔹 Objectif : Générer du texte naturel en réponse à une consigne 🔹 Entrée : Une instruction, un prompt ou une question 🔹 Sortie : Une réponse en langage humain, souvent contextualisée 🔹 Cas d’usage :
Assistants conversationnels (chatbots)
Rédaction automatique de contenu
Résumé ou reformulation de documents
Réponse à des questions en langage naturel
🧪 Exemple d’interaction :
Entrée : “Explique-moi le fonctionnement d’un moteur thermique.” Sortie : “Un moteur thermique fonctionne en convertissant la chaleur issue de la combustion d’un carburant en énergie mécanique…”
2. Modèle d’embedding (encodage vectoriel)
🔹 Objectif : Représenter un texte sous forme de vecteur numérique pour comparaison sémantique 🔹 Entrée : Une phrase, un document, une question, etc. 🔹 Sortie : Un vecteur (tableau de nombres) capturant le sens du texte 🔹 Cas d’usage :
Recherche sémantique (trouver un document similaire)
Détection de doublons ou de similarité
Indexation pour des bases vectorielles
Classement ou regroupement de contenus (clustering)
🧪 Exemple d’interaction :
Entrée : “Comment entretenir une voiture électrique ?” Sortie : [0.12, -0.03, 0.57, ...] (vecteur utilisable pour comparer avec d’autres)
Comment ce modèle d’application est-il construit ?
Architecture et technologies :
Application web Blazor (.NET) avec des composants Razor interactifs côté serveur
Base de données SQLite utilisée pour le cache d’ingestion via Entity Framework Core
Intégration avec les modèles d’IA d’Azure OpenAI Service
Fonctionnalités principales :
Chat avec IA augmentée par récupération (RAG)
Utilise un modèle d’IA pour générer des réponses intelligentes
Les réponses sont enrichies par des données extraites de documents
Extrait le texte et crée des embeddings vectoriels via un modèle de type embedding
Stocke les vecteurs dans un JsonVectorStore pour les recherches sémantiques
Interface utilisateur
Composants de chat interactifs (ChatMessageList, ChatInput)
Rendu Markdown et sanitisation HTML via les bibliothèques JavaScript
Workflow :
Au démarrage, l’application ingère les documents (par exemple des fichiers PDF), les découpe en fragments, puis les encode sous forme de vecteurs numériques grâce au modèle d’embedding (Modèle 2).
L’utilisateur interagit via l’interface de chat, en posant une question en langage naturel. Cette requête est ensuite traitée par le modèle génératif (Modèle 1), mais pas directement…
Avant de répondre, le système utilise le modèle d’embedding (Modèle 2) pour retrouver les passages les plus pertinents dans les documents indexés, en comparant leur sens avec celui de la question.
Enfin, le modèle génératif (Modèle 1) s’appuie à la fois sur ces passages trouvés et sur ses propres connaissances générales pour générer une réponse complète, claire et contextualisée.
Comment connecte-t-on cette application avec un modèle d’IA ?
Ces exemples d’application ne contiennent pas l’intelligence artificielle elle-même, mais elle interagit avec un modèle IA externe (hébergé dans le cloud, en local ou dans un container).
Enfin, découvrez le dernier épisode du stand-up de la communauté .NET AI, dans lequel Alex, Bruno et Jordan présentent les nouveaux modèles :
Dans cet article, je vous propose de tester l’application en connectant celle-ci vers 3 modèles d’IA :
GitHub
Azure OpenAI
Ollama
Voici les différentes étapes que nous allons suivre :
Maintenant, il nous reste plus qu’à tester tout cela 😎💪
Etape 0 – Rappel des prérequis :
Afin de tester les différents modèles AI en .NET, nous allons avoir besoin de :
Un poste local
Un compte GitHub des modèles GitHub Models
Une souscription Azure si utilisation du service Azure OpenAI
Commençons par créer préparer le poste local.
Etape I – Préparation du poste local :
Rendez-vous sur la page suivante afin de télécharger Visual Studio Code :
Une fois téléchargée, lancez l’installation de ce dernier :
Rendez-vous sur la page suivante afin de télécharger la version 9.0 de .NET :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, fermez celle-ci :
Enfin, redémarrez le poste local :
Une fois le poste local redémarré, ouvrez Windows Terminal :
Installer les modèles de projet pour l’extension .NET liée à Microsoft.Extensions.AI, qui fait partie de l’écosystème Semantic Kernel :
dotnet new install Microsoft.Extensions.AI.Templates
Créez un dossier sur votre poste, puis positionnez-vous dedans :
Ne fermez pas cette fenêtre Windows PowerShell.
Notre environnement local est prêt. Avant de déployer des applications basées sur les templates d’IA, nous avons besoin de récupérer les identifiants de connexion (token) de certains modèles IA. Commençons par le plus simple : GitHub.
Etape II – Test de l’application avec le modèle GitHub :
Rendez-vous sur la page d’accueil de GitHub, puis authentifiez-vous, ou créez un compte au besoin :
Cliquez sur votre photo de profil en haut à droite, puis cliquez sur le bouton des Paramètres :
Tout en bas, cliquez sur le menu des paramètres suivant :
Créez un token à granularité fine, pour une utilisation personnelle de l’API GitHub :
Nommez ce token, puis choisissez une date d’expiration :
Cliquez-ici pour générer ce token :
Confirmez votre choix :
Copiez la valeur du token GitHub :
Retournez sur la fenêtre Windows PowerShell ouverte précédemment, puis lancez la commande suivante afin d’utiliser le template aichatweb pour créer une application web de chat IA en lien avec le modèle GitHub :
dotnet new aichatweb -n GitHubModels --provider githubmodels --vector-store local
Ouvrez l’explorateur Windows afin de constater la création d’un nouveau dossier ainsi que le code de l’application :
Sur votre poste local, ouvrez Visual Studio Code, puis choisissez l’action d’ouverture d’un dossier :
Sélectionnez le dossier créé par l’application IA :
Constatez l’ouverture de l’application dans Visual Studio Code :
Ouvrez la fenêtre Terminal :
Stockez un secret utilisateur localement (ici un token) de manière sécurisée pour notre projet .NET :
dotnet user-secrets set GitHubModels:Token github...
Affichez tous les secrets stockés localement pour le projet courant :
dotnet user-secrets list
Ajoutez ou retirer au besoin des fichiers PDF utilisés durant la phase d’indexation sémantique)
Compilez et exécutez l’application .NET dans le dossier courant :
dotnet run
L’application vérifie dans les sources de données si nouveau documents sont à indexer ou vectoriser :
Ce message vous indique que l’application tourne localement sur le port 5145 :
Ouvrez un navigateur web à cette adresse:port, puis posez une question à l’IA sur un sujet d’ordre général ou propre aux documents ingérés :
Constatez la rapidité du résultat et la ou les sources associés, puis cliquez dessus :
Constatez la sélection de texte en correspondance avec la question posée à l’IA :
Le test avec le modèle GitHub a bien fonctionné, pensez à détruire le token sur le portail de GitHub pour des questions de sécurité
Continuons les tests de l’application de chat IA avec le modèle Azure OpenAI.
Etape III – Test de l’application avec le modèle Azure OpenAI :
Depuis le portail Azure, commencez par rechercher le service Azure OpenAI :
Cliquez-ici pour créer un nouveau service :
Renseignez toutes les informations, conservez le modèle de prix S0 (suffisant pour nos tests), puis cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Créer :
Une fois le déploiement terminé, cliquez-ici :
Copiez les 2 informations suivantes dans votre bloc-notes afin de vous y connecter plus tard à via API :
Afin de créer les deux modèle d’IA nécessaires au travers d’Azure, cliquez-ici pour ouvrir le portail Microsoft AI Foundry :
Sur ce portail, commencez par rechercher le premier modèle d’IA nécessaire à notre application :
Cliquez sur Déployer :
Conservez le nom d’origine, puis cliquez sur Déployer :
Retournez sur le catalogue des modèles d’IA, puis recherchez le second modèle d’IA nécessaire à notre application :
Cliquez sur Déployer :
Conservez le nom d’origine, puis cliquez sur Déployer :
Vérifiez la présence des 2 modèles déployés dans le menu suivant :
Retournez sur la fenêtre Windows PowerShell ouverte précédemment, puis lancez la commande suivante afin d’utiliser le template aichatweb pour créer une application web de chat IA en lien avec le service AzureOpenAI :
dotnet new aichatweb -n AzureOpenAI --provider azureopenai --vector-store local
Ouvrez l’explorateur Windows afin de constater la création d’un nouveau dossier :
Sur votre poste local, ouvrez Visual Studio Code, puis choisissez l’action d’ouverture d’un dossier :
Sélectionnez le dossier créé par l’application IA :
Constatez l’ouverture de l’application dans Visual Studio Code :
Afin de passer d’une authentification basée sur une identité Azure (DefaultAzureCredential) à une authentification explicite par clé API (AzureKeyCredential), remplacer le code suivant :
var azureOpenAi = new AzureOpenAIClient(
new Uri(builder.Configuration["AzureOpenAI:Endpoint"] ?? throw new InvalidOperationException("Missing configuration: AzureOpenAi:Endpoint. See the README for details.")),
new DefaultAzureCredential());
Par celui-ci, puis sauvegardez le fichier Program.cs :
var endpoint = builder.Configuration["AzureOpenAI:Endpoint"]
?? throw new InvalidOperationException("Missing configuration: AzureOpenAI:Endpoint. See the README for details.");
var key = builder.Configuration["AzureOpenAI:Key"]
?? throw new InvalidOperationException("Missing configuration: AzureOpenAI:Key. See the README for details.");
var azureOpenAi = new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(key));
Ouvrez la fenêtre Terminal :
Enregistrez localement (et de manière sécurisée) le point de terminaison de l’instance Azure OpenAI :
dotnet user-secrets set AzureOpenAI:Endpoint https://aichattemplate-rg.openai.azure.co
Enregistrez de manière sécurisée la clé API de l’instance Azure OpenAI dans les secrets utilisateur de .NET :
dotnet user-secrets set AzureOpenAI:Key 1zF4OGPseV...
Affichez tous les secrets stockés localement pour le projet courant :
dotnet user-secrets list
Ajoutez ou retirer au besoin des fichiers PDF utilisées durant la phase d’indexation sémantique)
Compilez et exécutez l’application .NET dans le dossier courant :
dotnet run
Ouvrez un navigateur web à cette adresse:port indiqué, puis posez une question à l’IA sur un sujet d’ordre général ou propre aux documents ajoutés :
Constatez la rapidité du résultat et la ou les sources associés, puis cliquez dessus :
Constatez la sélection de texte en correspondance avec la question posée :
Le test avec le service Azure OpenAI a bien fonctionné, pensez à détruire le service une fois les tests terminés.
Terminons les tests de l’application de chat IA avec le modèle local Ollama.
Etape IV – Test de l’application avec le modèle Ollama :
Rendez-vous sur la page suivante afin de télécharger Ollama :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, vérifiez via l’URL suivante le bon fonctionnement du service :
http://localhost:11434/
Depuis le menu Démarrer, ouvrez l’application CMD, puis lancez la commande suivante :
ollama pull llama3.2
Ollama télécharge alors la version mini de Phi3 d’environ 2 Go
ollama pull all-minilm
Ollama télécharge alors un modèle ouvert d’environ 270 Mo :
Vérifiez la liste des modèles en place avec la commande suivante :
ollama list
Retournez sur la fenêtre Windows PowerShell ouverte précédemment, puis lancez la commande suivante afin d’utiliser le template aichatweb pour créer une application web de chat IA en lien avec le modèle Ollama :
dotnet new aichatweb -n llama3.2Model --provider ollama --vector-store local
Ouvrez l’explorateur Windows afin de constater la création d’un nouveau dossier ainsi que le code de l’application :
Sur votre poste local, ouvrez Visual Studio Code, puis choisissez l’action d’ouverture d’un dossier :
Sélectionnez le dossier créé par l’application IA :
Constatez l’ouverture de l’application dans Visual Studio Code :
Ouvrez la fenêtre Terminal :
Ajoutez ou retirer au besoin des fichiers PDF utilisées durant la phase d’indexation sémantique)
Compilez et exécutez l’application .NET dans le dossier courant :
dotnet run
L’application vérifie dans les sources de données configurées si nouveau documents sont à indexer ou vectoriser :
Cette ligne vous indique que l’application tourne localement sur le port 5145 :
Ouvrez un navigateur web à cette adresse:port, puis posez une question à l’IA sur un sujet d’ordre général ou propre aux documents ajoutés :
Constatez le pic d’usage du CPU/GPU selon la configuration matérielle de votre poste local :
Constatez la rapidité/lenteur du résultat :
Conclusion
Avec l’arrivée des nouveaux templates .NET dédiés à l’intelligence artificielle, il n’a jamais été aussi simple de créer des applications web de chat connectées à des modèles IA.
Que vous choisissiez un modèle cloud (comme Azure OpenAI), un modèle public (via GitHub), ou même un modèle local (comme ceux proposés par Ollama), l’infrastructure est prête à l’emploi et parfaitement intégrée à l’écosystème .NET.
L’actualité concernant l’intelligence artificielle défile à un rythme effréné. Avec cette avalanche de nouveaux outils, de techniques et de possibles usages, combinant à la fois de réelles avancées, mais aussi parfois des discours marketing très prometteurs, chacun se doit de faire sa propre analyse, et de trier dans ces nouveautés les mises applications possibles dans au quotidien.
Qu’est-ce que les vecteurs dans le domaine de l’IA ?
Dans le domaine de l’IA, un vecteur est généralement utilisé pour représenter des données numériques. Un vecteur est une liste ordonnée de nombres. Par exemple, dans un espace à trois dimensions, un vecteur pourrait être représenté comme [3, 4, 5], où chaque nombre représente une dimension spécifique.
Dans l’IA, les vecteurs, c’est-à-dire des représentations numériques (ou embeddings) de données permettent donc de transformer du texte, des images ou d’autres données en une série de nombres qui représentent leurs caractéristiques essentielles. Ces représentations numériques facilitent la comparaison et la mesure de la similarité entre différents éléments.
L’embedding est une méthode de transformations de données provenant d’images, de textes, de sons, de données utilisateur, ou de tout autre type d’information, en vecteurs numériques. Cela revient à traduire le langage humain en une langue que les machines peuvent interpréter, capturant ainsi les nuances sémantiques ou contextuelles des éléments traités.
Grâce à une IA, la façon de rechercher des informations pertinentes repose sur la comparaison des vecteurs pour identifier les documents ou les images similaires. En d’autres termes, les vecteurs aident à comprendre et à exploiter la signification des données pour améliorer la précision des résultats de recherche.
Où sont stockés les vecteurs ?
Traditionnellement, les vecteurs étaient stockés dans des bases de données dédiées, comme Pinecone ou Milvus, conçues spécifiquement pour gérer des données vectorielles et optimiser les recherches par similarité.
Cependant, avec l’évolution des technologies, certains SGBD relationnels, comme Azure SQL Database, intègrent désormais un support natif pour les vecteurs. Cela permet de stocker et d’interroger directement des vecteurs au sein d’une base de données SQL classique, simplifiant ainsi l’architecture des applications et réduisant la nécessité d’avoir un système séparé.
Depuis quand Azure SQL Database peut stocker les vecteurs ?
Le type vector est un nouveau type de données natif dans Azure SQL Database spécifiquement conçu pour stocker des vecteurs. Plutôt que d’utiliser un format générique comme du JSON ou du varbinary, ce type offre un format dédié, compact et optimisé pour les opérations mathématiques, telles que le calcul de distances (cosinus, euclidienne, etc.).
Il permet ainsi d’effectuer directement dans la base de données des recherches par similarité, sans recourir à des systèmes externes spécialisés dans le stockage vectoriel.
Comment fonctionne la recherche de distance entre 2 vecteurs ?
En utilisant des fonctions intégrées telles que VECTOR_DISTANCE, cela calcule une distance (cosinus, euclidienne, etc.) entre le vecteur de la requête et chaque vecteur stocké, permettant d’ordonner les résultats par similarité (la distance la plus faible indiquant la correspondance la plus proche).
Est-ce disponible sur SQL Server 2022 ?
Non, la fonctionnalité native de support des vecteurs n’est pas disponible dans SQL Server 2022. Actuellement, cette capacité est proposée dans Azure SQL Database. Microsoft prévoit d’intégrer des fonctionnalités similaires dans les futures versions, notamment SQL Server 2025.
Pour la première fois, Microsoft apporte un support vectoriel natif à SQL Server. SQL Server 2025 sera une base de données vectorielle prête pour l’entreprise, capable de générer et de stocker en mode natif des incrustations vectorielles. Cette prise en charge native des vecteurs permettra aux clients de SQL Server d’exécuter des modèles d’IA génératifs en utilisant leurs propres données. Ils peuvent choisir le modèle d’IA requis grâce à la gestion extensible des modèles permise par Azure Arc.
Peut-on tester les vecteurs sur une base de données Azure SQL ?
Comme toujours, Alex Wolf, via son excellente chaîne YouTube The Code Wolf, nous montre la prise en charge des vecteurs IA au sein même des bases de données SQL :
Maintenant, il nous reste plus qu’à tester tout cela 😎💪
Afin de faire nos tests sur le base de données Azure SQL pour < comprendre le fonctionnement des vecteurs, nous allons avoir besoin de :
Un tenant Microsoft active
Une souscription Azure valide
Commençons par créer la base de données SQL depuis le portail Azure.
Etape I – Création de la base de données Azure SQL :
Depuis le portail Azure, commencez par rechercher le service de bases de données SQL :
Renseignez les informations de base, comme la souscription Azure et le groupe de ressources :
Cliquez-ici pour également créer un serveur SQL hébergeant notre base de données :
Renseignez un nom unique pour votre serveur SQL, indiquez un compte administrateur à ce dernier, puis cliquez sur OK :
Conservez l’option de base pour la puissance votre serveur SQL, la réplication sur LRS, puis cliquez sur Suivant :
Conservez l’accès public pour nos tests, ajoutez-y votre adresse IP publique, puis lancez la validation Azure :
Une fois la validation Azure réussie, lancez la création des ressources :
Attendez environ 5 minutes, puis cliquez-ici pour accéder aux ressources créées :
Copiez les éléments de connexion à cette base de données présents l’onglet ci-dessous, puis conservez cette valeur par la suite dans un éditeur de texte :
Utilisez un outil de gestion de base de données, comme SQL Server Management Studio (SSMS), ou Azure Data Studio, disponible lui sur cette page :
Acceptez les conditions d’utilisations, puis cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Installer :
Cliquez sur Terminer :
Ouvrez Azure Data Studio, puis cliquez-ici pour créer une nouvelle connexion :
Collez les informations de connexion de votre base SQL précédemment copiées, renseignez le mot de passe de votre administrateur, puis cliquez sur Connecter :
Saisissez la commande SQL suivante afin de créer la table liée au stockage des données et de leurs vecteurs :
CREATE TABLE dbo.demo
(
id INT PRIMARY KEY,
filename VARCHAR(50),
vectors VECTOR(1024) NOT NULL
)
Exécutez la commande, puis obtenez la confirmation suivante :
Notre base de données, encore vide en enregistrements et en vecteurs est maintenant prête.
Nous allons maintenant créer un le service d’intelligence artificielle sur Azure afin de créer calculer les vecteurs de nos futures données.
Etape II – Création du service d’IA Computer Vision :
Toujours sur le portail Azure, recherchez le service d’IA suivant :
Cliquez-ici pour créer un nouveau service :
Renseignez toutes les informations, en privilégiant un déploiement dans les régions East US ou West Europe, conservez le modèle de prix F0 (suffisant pour nos tests), puis lancez la validation Azure :
Une fois la validation Azure réussie, lancez la création des ressources :
Une fois le déploiement terminé, cliquez-ici :
Copiez les 2 informations suivantes dans votre bloc-notes afin de vous y connecter plus tard à via API :
Afin d’envoyer différentes requêtes via API à notre service d’IA, utilisez un service dédié, comme par exemple Postman, disponible ici (créez un compte gratuit si nécessaire) :
Notre environnement manuel est maintenant prêt pour être testé.
La prochaine étape consiste à générer manuellement des vecteurs via notre service d’IA afin de les stocker dans votre base de données SQL.
Etape III – Chargement des vecteurs d’images dans la DB SQL :
Une fois connecté sur votre console Postman, cliquez-ici pour utiliser le service :
Notre premier objectif est de convertir les données d’une image en vecteur. Pour cela, choisissez la méthode de type POST, puis saisissez l’URL composée de la façon suivante :
Point de terminaison de votre service Computer Vision
Service API de vectorisation d’images proposé par Computer Vision
Exécutez la commande suivante, puis constatez le succès de celle-ci :
Contrôlez le résultat du chargement dans la base de données SQL via la requête suivante :
SELECT * FROM dbo.demo
Notre base de données Azure SQL a bien stocké les vecteurs calculés par le service d’intelligence artificielle. La prochaine étape consiste à calculer la distance entre les vecteurs des images et les vecteur d’un mot-clef.
Etape IV – Calcul de distance entre les images et le mot-clef :
Retournez sur le service d’appel API Postman, puis créez un nouvel onglet de requête :
Choisissez à nouveau une méthode de type POST, puis l’URL composée de la façon suivante :
Point de terminaison de votre service Computer Vision
Service API de vectorisation de texte proposé par Computer Vision
Rendez-vous dans l’onglet Headers afin de rajouter à nouveau en valeur la clef de votre service Computer Vision sous la clef Ocp-Apim-Subscription-Key :
Rendez-vous dans l’onglet Body afin de rajouter en RAW le mot-clef :
{
"text":"café"
}
Cliquez ensuite sur Envoyer, changez le format de sortie des vecteurs calculés en RAW, puis copiez tous les vecteurs présents entre les 2 crochets :
Retournez sur Azure Data Studio, puis commencez par coller la requête SQL suivante afin de créer une variable qui stockera les vecteurs de notre mot-clef :
DECLARE @searchVector VECTOR(1024) = '[]'
Entre les 2 crochets de la déclaration de variable, collez les vecteurs du mot-clef précédemment copiés :
Ajoutez en dessous la requête SQL basée sur la fonction VECTOR_DISTANCE :
SELECT TOP(10) id, filename, VECTOR_DISTANCE('cosine', @searchVector, vectors)
AS Distance from demo ORDER BY Distance
Puis exécutez l’ensemble afin de constater le résultat de distance entre le mot-clef et les 3 images :
Ces différents tests nous démontrent la possibilité de stockage des vecteurs et la recherche de résultats basés sur la distance entre ces derniers, le tout dans une base de données SQL.
Toutes ces étapes de génération de vecteurs et de recherche sur les distances sont facilement intégrables dans une application, comme celle justement proposée par Alex Wolf.
Etape V – Automatisation de l’importation des vecteur :
Retournez sur Azure Data Studio afin de créer une seconde table dédiée à notre application :
CREATE TABLE dbo.images
(
id INT PRIMARY KEY,
name VARCHAR(50),
vectors VECTOR(1024) NOT NULL
)
Rendez-vous sur la page GitHub suivante afin de télécharger l’application au format ZIP :
Décompressez l’archivage dans le dossier local de votre choix :
Ouvrez l’application Visual Studio Code, puis ouvrez le dossier correspondant à votre application :
Ouvrez le fichier Program.cs pour y renseigner votre le point de terminaison, ainsi que la clef de votre service Computer vision, puis Sauvegardez :
Ouvrez le fichier AzureBectorDatabaseService.cs pour y renseigner les informations de connexion de votre base SQL précédemment copiées avec le bon mot de passe, puis Sauvegardez :
Démarrez l’application via la commande .NET suivante :
dotnet run
Quelques secondes plus tard, l’application est démarrée, l’URL et le port exposé s’affichent :
Collez cette URL dans un navigateur internet pour ouvrir l’application, puis cliquez sur le bouton ci-dessous pour charger une ou des images au format JPG :
Sélectionnez-le ou les fichiers images de votre choix, puis cliquez sur Ouvrir :
Cliquez-ici pour téléversé le ou les fichiers :
Constatez l’apparition de la vignette de vos images téléversées :
Effectuez la même opération avec d’autres images plus ou moins variées :
Retournez sur Azure Data Studio, puis lancez la requête SQL suivante pour voir le chargement de des données et des vecteurs dans la seconde table créée :
SELECT * FROM dbo.images
Notre application contient maintenant des fichiers images, avec leurs vecteurs dans notre base de données SQL grâce à notre service d’IA Computer Vision.
Il nous reste maintenant qu’à rechercher via un mot-clef, transposé lui-aussi en vecteurs via l’IA, à des images dont les vecteurs lui seraient proches.
Etape VI – Automatisation du calcul de distance vectorielle :
Retournez sur la page web de votre application, saisissez un mot-clef dans la zone prévue à cet effet, puis cliquez sur Rechercher afin de constater la pertinence des résultats :
Refaites d’autres tests en jouant également avec les 3 niveaux du seuil de confiance :
Les résultats retournés varient selon le niveau du seuil de confiance :
La faible quantité d’images chargées et le niveau de confiance réglé sur moyen donne des résultats trop larges :
Cette approximation peut se corriger avec un niveau de confiance élevé :
Conclusion
En conclusion, l’intégration native du type de données vector dans Azure SQL Database marque une avancée majeure pour les développeurs souhaitant exploiter l’intelligence artificielle directement au sein de leur SGBD.
Cette fonctionnalité permet de stocker et d’interroger des vecteurs de manière optimisée, simplifiant ainsi l’architecture des applications en éliminant le besoin d’une base de données vectorielle externe.
En adoptant ces outils, les équipes peuvent désormais transformer et analyser leurs données de façon plus intuitive et sécurisée, tout en tirant parti de l’écosystème SQL existant. C’est un pas décisif vers une intégration plus fluide de l’IA et la modernisation d’environnements traditionnels.
Dans la série des démonstrations très intéressantes sur l’intelligence artificielle, j’appelle le RAG local ! Comme toujours, Alex de la chaîne YouTube The Code Wolf nous montre comment en quelques clics il est possible d’installer et tester une IA sur votre poste local, tout en y ajoutant des données spécifiques (RAG) afin d’en améliorer les réponses.
Mais qu’est-ce que le RAG ?
Le Retrieval Augmented Generation (RAG) est une approche novatrice qui combine le meilleur de deux mondes en IA : la recherche d’informations (retrieval, qui ne génère pas de réponse originale) et la génération de contenu (qui ne s’appuie que sur les données de son entraînement). Traditionnellement, les LLM génèrent du contenu en s’appuyant uniquement sur les informations apprises durant leur phase d’entraînement. Le RAG, en revanche, permet au modèle de « consulter » une base de données ou un corpus de documents externes en temps réel pour enrichir sa génération de texte. Cette capacité de recherche améliore significativement la précision, la pertinence et la richesse du contenu généré.
La qualité de la base de données est un élément crucial pour le fonctionnement du RAG. Une base de données riche, variée et actualisée permet au modèle d’acquérir une connaissance approfondie et de générer des réponses plus précises et pertinentes.
La recherche d’informations joue également un rôle important en permettant au RAG de trouver les éléments les plus pertinents dans la base de données et de les utiliser pour inspirer ses réponses.
Voici un exemple des étapes pour mieux comprendre les interactions :
Étape
Description
1. Question
L’utilisateur demande : « Quelle est la vitesse de la lumière dans le vide ? »
2. Embedding de texte
La question est convertie en vecteur (séquence numérique) pour capturer sa signification.
3. Corpus et base de données vectorielle
Les documents sont découpés en passages courts et convertis en vecteurs, stockés dans une base de données vectorielle.
4. Recherche
Le module de recherche compare les vecteurs de la question aux vecteurs des documents pour trouver les plus similaires.
5. Réponse
Le LLM utilise la question et les extraits récupérés pour générer une réponse pertinente : « La vitesse de la lumière dans le vide est de 299 792 458 mètres par seconde »
Mais comment tester le RAG en local ?
Voici un exemple des ressources nécessaires pour y parvenir :
Composant
Description
Bibliothèques et outils
– SentenceTransformers pour les embeddings de texte. – Un modèle de langage comme ollama. – qdrant, Faiss ou Annoy pour la base de données vectorielle.
Données
– Corpus de documents à utiliser pour la recherche. – Données prétraitées et converties en vecteurs.
Environnement de développement
– Python ou .NET – Docker
Serveur RAG
– Framework comme R2R (Ready-to-Run) pour déployer le pipeline RAG. – API pour interagir avec le pipeline.
Faut-il un GPU pour faire du RAG ?
L’utilisation d’un GPU pour mettre en place le RAG n’est pas strictement nécessaire, mais elle peut grandement améliorer les performances, surtout pour les tâches de génération de texte et de traitement de grandes quantités de données. Voici quelques points à considérer :
Sans GPU :
Possible : Tu peux utiliser un CPU pour les tâches de RAG, mais cela peut être plus lent, surtout pour les modèles de langage volumineux.
Limité : Les performances peuvent être limitées, ce qui peut affecter la rapidité et l’efficacité du système.
Avec GPU :
Accélération : Un GPU peut accélérer les calculs nécessaires pour les embeddings de texte et la génération de réponses.
Efficacité : Améliore la capacité à traiter des requêtes en temps réel et à gérer des corpus de données plus importants.
En résumé, bien que l’on puisse mettre en place un système RAG sans GPU, l’utilisation de ce dernier est recommandée pour des performances optimales, surtout si l’on travaille avec des modèles de langage avancés et des bases de données volumineuse.
Voici donc la vidéo de The Code Wolf qui va nous servir de base à notre démonstration :
Son programme, lui-même basé sur les données de ce GitHub, met en place un chatbot intelligent utilisant des données de Zelda, grâce à la technique RAG.
Dans cet article, je vous propose de tester son application via deux machines virtuelles Azure :
Maintenant, il nous reste plus qu’à tester tout cela 😎💪
Etape 0 – Rappel des prérequis :
Afin de mettre en place une application RAG en local, nous allons avoir besoin de :
Un poste local ayant un GPU puissant pouvant effectuer de la virtualisation
ou
Un tenant Microsoft active
Une souscription Azure valide
Ayant des crédits Azure, je vous propose dans ma démonstration de partir sur la seconde solution. Un petit souci vient malheureusement heurter mon raisonnement : les SKUs de machine virtuelle Azure pouvant faire de la virtualisation n’ont pas de GPU puissant.
Je vais donc créer 2 machines virtuelles Azure :
Machine virtuelle CPU pour Docker + tests RAG CPU
Machine virtuelle GPU pour tests RAG GPU
Commençons par créer la première machine virtuelle CPU.
Etape I – Préparation de la machine virtuelle CPU :
Depuis le portail Azure, commencez par rechercher le service des réseaux virtuels :
Cliquez-ici pour créer votre réseau virtuel :
Nommez ce dernier, puis lancez la validation Azure :
Une fois la validation Azure réussie, lancez la création de votre réseau virtuel :
Environ 30 secondes plus tard, la ressource Azure est créée, cliquez-ici :
Cliquez-ici pour déployer le service Azure Bastion :
N’attendez-pas la fin du déploiement d’Azure Bastion, recherchez le service des machines virtuelles :
Cliquez-ici pour créer votre machine virtuelle CPU :
Renseignez tous les champs, en prenant soin de bien sélectionner les valeurs suivantes :
Choisissez une taille de machine virtuelle présente dans la famille Dasv6 :
Renseignez un compte d’administrateur local, puis cliquez sur Suivant :
Rajoutez ou non un second disque de données, puis cliquez sur Suivant :
Retirez l’adresse IP publique pour des questions de sécurité, puis lancez la validation Azure :
Une fois la validation réussie, lancez la création des ressources Azure :
Quelques minutes plus tard, cliquez-ici pour voir votre machine virtuelle CPU :
Renseignez les identifiants renseignés lors de la création de votre VM :
Acceptez les conditions Microsoft :
Rendez-vous sur la page suivante afin de télécharger la version 9.0 de .NET :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, fermez l’installation :
Rendez-vous sur la page suivante afin de télécharger Visual Studio Code :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, redémarrez la machine virtuelle :
Quelques secondes plus tard, relancez une connexion via Azure Bastion :
Rendez-vous sur la page suivante afin de télécharger Ollama :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, vérifiez via l’URL suivante le bon fonctionnement du service :
http://localhost:11434/
Depuis le menu Démarrer, ouvrez l’application CMD, puis lancez la commande suivante :
ollama pull phi3:mini
Ollama télécharge alors la version mini de Phi3 d’environ 2 Go :
Lancez la seconde commande suivante :
ollama pull nomic-embed-text
Ollama télécharge alors un modèle ouvert d’environ 270 Mo :
Vérifiez la liste des modèles en place avec la commande suivante :
ollama list
Rendez-vous sur la page suivante afin de télécharger Docker en version Desktop :
Conservez ces 2 cases cochées, puis cliquez sur OK pour lancer l’installation :
Attendez quelques minutes que l’installation se termine :
Cliquez-ici pour redémarrer à nouveau la machine virtuelle CPU :
Quelques secondes plus tard, relancez une connexion via Azure Bastion :
Attendez si nécessaire la fin de l’installation de composants additionnels :
Depuis le menu Démarrer de la session Windows, ouvrez l’application Docker :
Acceptez les conditions d’utilisation de Docker :
Cliquez sur le bouton Finaliser :
Cliquez-ici :
Cliquez-ici :
Attendez le démarrage du service de virtualisation Docker :
Une fois le service correctement démarré, vous ne devriez voir pour le moment aucun conteneurs :
Depuis le menu Démarrer, ouvrez l’application CMD, puis lancez la commande suivante :
docker run -p 6333:6333 -p 6334:6334 -d --name qdrant qdrant/qdrant
Cette commande Docker permet de Qdrant, qui est une base de données vectorielle sous forme de conteneur.
Cela te permet d’utiliser Qdrant pour stocker et rechercher des vecteurs dans ton pipeline RAG :
Autorisez Docker à pouvoir passer au travers de Windows Firewall :
Retournez sur la console de Docker afin de constater le bon démarrage du conteneur :
Notre environnement de test est en place, nous allons maintenant pouvoir récupérer l’application et les données RAG.
Etape II – Chargement de la base de données vectorielle :
Ce premier programme effectue plusieurs tâches pour créer une base de données vectorielle avec Qdrant et générer des embeddings de texte à l’aide d’Ollama.
Voici un résumé des étapes :
Création des clients :
Crée un client Qdrant pour interagir avec la base de données vectorielle.
Crée un client Ollama pour générer des embeddings de texte.
Chargement des données :
Charge des enregistrements de différents fichiers JSON (lieux, boss, personnages, donjons, jeux) et les désérialise en objets ZeldaRecord.
Vectorisation des données chargées :
Pour chaque enregistrement, génère un embedding en utilisant le client Ollama.
Crée une liste de structures de points (PointStruct) contenant les embeddings et les informations associées (nom et description).
Insertion des données dans Qdrant :
Crée une collection dans Qdrant pour stocker les enregistrements vectorisés.
Insère les enregistrements dans la base de données Qdrant.
Lancez l’extraction des fichiers dans un dossier local de votre choix :
Ouvrez Visual Studio Code installé précédemment, puis ouvrez le dossier créé :
Confirmez la confiance dans le dossier comme ceci :
Ouvrez le terminal de Visual Studio Code via le menu suivant :
Positionnez-vous dans le dossier populateDb, puis lancez la commande suivante :
dotnet run
Le chargement des données dans la base de données vectorielle commence :
Ouvrez le gestionnaire des tâches Windows afin constater l’utilisation du CPU pour ce traitement :
Quelques minutes plus tard, en fonction de la performance de votre machine virtuelle, le traitement se termine via le message de succès suivants :
Ouvrez la page web suivante afin de constater dans la console qdrant la création de la collection RAG, puis cliquez-ici :
http://localhost:6333/dashboard
Choisissez sur un point présent dans la liste de la collection, puis cliquez ici pour y voir plus détail :
Constatez la représentation graphique de la base de données :
Cliquez sur un des points en relation avec le premier consulté :
Cliquez à nouveau sur un des points en relation avec le second consulté :
Copiez les vecteurs d’un des points consultés :
Ouvrez Notepad pour y coller les valeurs de vecteur afin de voir comment ces derniers sont formulés :
Nos données RAG sont maintenant chargées. Nous allons maintenant pouvoir tester les prompts depuis la seconde partie de l’application.
Etape III – Lancement de prompts IA RAG :
Ce programme va nous permettre de poser des questions sur des sujets liés à Zelda et d’obtenir des réponses pertinentes en utilisant des données spécifiques grâce à la recherche vectorielle et à la génération de texte.
Avant de lancez le programme, vérifiez, et modifiez au besoin la version exacte de celle téléchargée pour phi3, puis sauvegardez vos modifications :
Positionnez-vous dans le dossier RagApp, puis lancez la commande suivante :
dotnet run
Posez une question sans rapport avec l’univers de Zelda dans un premier temps :
Posez ensuite une question en rapport avec l’univers de Zelda :
Constatez les lenteurs de réponse de l’intelligence artificielle et l’utilisation intensive du CPU :
Confirmez la durée d’utilisation du CPU en fonction de la longueur des réponses de l’IA :
Confirmez l’utilisation exclusive du CPU par la commande suivante :
ollama ps
Bien que l’utilisation d’un CPU soit possible pour certaines tâches d’IA, l’absence de GPU peut entraîner des performances réduites, des limitations dans l’utilisation de modèles avancés, une consommation accrue de ressources et des défis en termes de scalabilité.
Nous allons donc continuer les tests avec la mise en place d’une seconde machine virtuelle GPU dans Azure.
Etape IV – Préparation de la machine virtuelle GPU :
Avant de créer la machine virtuelle GPU depuis Azure, créez la règle de firewall Windows suivante sur la première machine virtuelle afin de rendre accessible qdrant :
Recherchez à nouveau le service des machines virtuelles :
Renseignez tous les champs, en prenant soin de bien sélectionner les valeurs suivantes :
Choisissez une taille de machine virtuelle présente dans la famille N :
Renseignez un compte d’administrateur local, puis cliquez sur Suivant :
Retirez l’adresse IP publique pour des questions de sécurité, puis lancez la validation Azure :
Une fois la validation réussie, lancez la création des ressources Azure :
Quelques minutes plus tard, cliquez-ici pour voir votre machine virtuelle GPU :
Renseignez les identifiants renseignés lors de la création de votre VM :
Acceptez les conditions Microsoft :
Rendez-vous sur la page suivante afin de télécharger la version 9.0 de .NET :
Une fois téléchargée, lancez l’installation :
Rendez-vous sur la page suivante afin de télécharger Visual Studio Code :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, redémarrez la machine virtuelle :
Quelques secondes plus tard, relancez une connexion via Azure Bastion :
Sur cette page, téléchargez le pilote NVIDIA GRID :
Confirmez le dossier de décompression au niveau local :
Attendez environ 30 secondes que la décompression se termine :
Après une rapide vérification système, cliquez sur Accepter et Continuer :
Cliquez sur Suivant :
Une fois l’installation terminée avec succès, cliquez sur Fermer :
Ouvrez le Gestionnaire des tâches Windows afin de constater l’apparition d’une section GPU :
Rendez-vous sur la page suivante afin de télécharger Ollama :
Une fois téléchargée, lancez l’installation :
Une fois l’installation réussie, vérifiez via l’URL suivante le bon fonctionnement du service :
http://localhost:11434/
Depuis le menu Démarrer, ouvrez l’application CMD, puis lancez la commande suivante :
ollama pull phi3:mini
Ollama télécharge alors la version mini de Phi3 d’environ 2 Go :
Lancez la seconde commande suivante :
ollama pull nomic-embed-text
Ollama télécharge alors un modèle ouvert d’environ 270 Mo :
Vérifiez la liste des modèles en place avec la commande suivante :
ollama list
Vérifiez le bon accès à qdrant situé lui sur la machine virtuelle CPU :
Lancez l’extraction des fichiers dans un dossier local de votre choix :
Etape V – Chargement de la base de données vectorielle :
Ouvrez Visual Studio Code, ouvrez le dossier créé, puis indiquez l’IP locale de la machine virtuelle CPU :
Modifiez également 2 fois le nom de la nouvelle collection créée sur la machine virtuelle GPU, puis Sauvegardez :
Positionnez-vous dans le dossier populateDb, puis lancez la commande suivante :
dotnet run
Ouvrez le Gestionnaire des tâches Windows afin constater l’utilisation plus efficace du GPU pour ce traitement de chargement :
Ouvrez la page web suivante afin de constater dans qdrant la création de la seconde collection RAG, puis cliquez-ici :
http://10.0.0.4:6333/dashboard
Etape VI – Lancement de prompts IA RAG :
Avant de lancez le second programme, vérifiez, et modifiez au besoin l’adresse IP, la version de phi3, la collection utilisée, puis Sauvegardez vos modifications :
Positionnez-vous dans le dossier RagApp, lancez la commande suivante, puis posez une question en rapport avec l’univers de Zelda :
dotnet run
Constatez la pleine puissance GPU pour le traitement :
Constatez la rapidité du texte généré par l’IA :
Confirmez l’utilisation du GPU par la commande suivante :
ollama ps
Conclusion
En conclusion, la mise en place d’une IA RAG (Retrieval-Augmented Generation) sur votre propre PC est un processus réalisable, même sans GPU.
Cependant, l’utilisation d’un GPU est fortement recommandée pour améliorer les performances, surtout pour les tâches de génération de texte et de traitement de grandes quantités de données.
Maintenant, il ne reste plus qu’à tester et affiner votre application et vos données pour obtenir des résultats RAG parfait😎
En combinant les capacités de l’IA et des bases de données SQL, vous pouvez optimiser l’utilisation des ressources informatiques et humaines. Les utilisateurs peuvent obtenir des informations pertinentes plus rapidement et plus facilement, améliorant ainsi leur expérience globale. Enfin, l’intégration de l’IA permet d’explorer de nouvelles façons d’utiliser les données pour innover et rester compétitif.
Pourquoi établir une communication DB -> IA ?
Mettre en place une connexion entre une application, une base de données et un modèle d’IA présente plusieurs avantages :
Automatisation et Efficacité
Automatisation des tâches répétitives : L’IA peut automatiser des requêtes complexes et des analyses de données, réduisant ainsi le temps et les efforts nécessaires pour obtenir des informations pertinentes.
Réponses rapides et précises : En utilisant l’IA pour interroger la base de données, vous pouvez obtenir des réponses rapides et précises à des questions spécifiques sans avoir à écrire des requêtes SQL complexes.
Amélioration de la Prise de Décision
Analyses avancées : L’IA peut analyser de grandes quantités de données et identifier des tendances ou des anomalies que les humains pourraient manquer.
Prédictions et recommandations : Les modèles d’IA peuvent fournir des prédictions basées sur les données historiques et offrir des recommandations pour des actions futures.
Accessibilité et Utilisabilité
Interface utilisateur simplifiée : Les utilisateurs peuvent interagir avec la base de données via des prompts en langage naturel, rendant l’accès aux données plus intuitif et accessible même pour ceux qui ne maîtrisent pas le langage de base de données.
Support multilingue : Azure OpenAI peut comprendre et répondre dans plusieurs langues, ce qui est utile pour les entreprises internationales.
Sécurité et Conformité
Contrôle d’accès : Vous pouvez définir des niveaux d’accès pour différents utilisateurs, garantissant que seules les personnes autorisées peuvent interroger certaines parties de la base de données.
Surveillance et audit : Les interactions avec la base de données peuvent être surveillées et auditées pour assurer la conformité avec les régulations et les politiques internes.
Flexibilité et Évolutivité
Scalabilité : Azure offre des solutions évolutives qui peuvent gérer des volumes de données croissants sans compromettre les performances.
Intégration facile : Les services Azure sont conçus pour s’intégrer facilement avec d’autres outils et plateformes, facilitant ainsi l’expansion et l’adaptation aux besoins changeants de l’entreprise.
Mais comment y parvenir ?
Bien que la mise en place de cette interface puisse sembler complexe, elle est tout à fait réalisable avec une planification adéquate et les bonnes compétences.
Si vous avez une équipe technique compétente ou si vous pouvez faire appel à des experts, cela facilitera grandement le processus.
Configuration de la Base de Données
Création et gestion de la base de données : Assurez-vous que votre base de données est bien structurée et optimisée pour les requêtes que vous souhaitez exécuter.
Sécurité et accès : Configurez les permissions et les accès pour garantir la sécurité des données.
Intégration de l’Application
Développement de l’application : Utilisez un langage de programmation compatible (comme Python, C#, etc.) pour développer l’application qui interagira avec la base de données et l’IA.
API et connecteurs : Utilisez des API et des connecteurs pour permettre à l’application de communiquer avec la base de données SQL et les services Azure.
Configuration du Modèle d’IA
Choix du modèle : Sélectionnez le modèle d’IA approprié sur Azure OpenAI en fonction de vos besoins (par exemple, GPT-4).
Entraînement et ajustement : Si nécessaire, entraînez le modèle avec des données spécifiques à votre domaine pour améliorer sa précision.
Développement de l’Interface Utilisateur
Interface utilisateur : Créez une interface utilisateur intuitive qui permet aux utilisateurs de saisir des prompts en langage naturel.
Traitement des requêtes : Développez des mécanismes pour convertir les prompts en requêtes SQL et pour afficher les résultats de manière compréhensible.
Considérations Techniques
Compétences requises : Vous aurez besoin de compétences en développement logiciel, en gestion de bases de données et en IA.
Ressources : Assurez-vous d’avoir les ressources nécessaires, y compris le temps, le budget et l’infrastructure.
Maintenance : Préparez-vous à effectuer une maintenance régulière pour assurer la sécurité et la performance de l’application.
Outils et Services Utiles disponibles sur Azure
Azure SQL Database : Pour la gestion de la base de données.
Azure OpenAI Service : Pour l’intégration du modèle d’IA.
Maintenant, il nous reste plus qu’à tester tout cela 😎💪
Téléchargez puis installez la version 6.0 de .NET, disponible via ce lien officiel :
Téléchargez et installez SQL Server Management Studio (SSMS) depuis cette page :
Afin de publier les 2 applications sur une URL publique, téléchargez ngrok, puis inscrivez-vous chez eux avec un compte gratuit :
Sur leur site, téléchargez l’installateur de ngrok :
Copiez la commande suivante affichée sous l’installateur pour configurer votre ngrok :
Depuis le dossier de téléchargement, ouvrez une invite de commande, puis lancez celle-ci afin de préparer votre configuration ngrok :
Le poste local est maintenant correctement configuré, la prochaine étape consiste à créer une base de données SQL avec de la données fictives sur notre souscription Azure.
Etape II – Création de la base de données Azure SQL :
Pour cela, rendez-vous sur la page du portail Azure afin de rechercher le service Azure SQL Database :
Cliquez-ici pour créer votre base de données SQL :
Nommez votre base de données Azure SQL, puis cliquez-ici pour créer une serveur de base de données Azure pour héberger notre base :
Nommez votre serveur Azure SQL, choisissez sa région, puis renseignez des identifiants SQL pour simplifier notre test :
Conservez votre environnement en Développement, réduisez la redondance de votre base de données SQL, puis cliquez sur Suivant :
Conservez les caractéristiques réseaux d’origine, puis cliquez sur Suivant :
Conservez les caractéristiques de sécurités d’origine, puis cliquez sur Suivant :
Ne configurez pas de source de données particulière, puis lancez la validation Azure :
Une fois la validation Azure réussie, lancez la création des ressources Azure :
Attendez environ 5 minutes, puis cliquez-ici pour accéder à votre base de données Azure SQL :
Copiez les informations de connexion à votre base de données SQL, celles-ci seront nécessaire par la suite :
Retournez sur la page principale de votre base de données SQL, puis cliquez sur votre serveur Azure SQL :
Dans la section réseau, activez l’option suivante, puis rajoutez votre adresse IP publique en exception Firewall afin de pouvoir connecter votre poste à la base de données SQL, puis cliquez sur Sauvegarder :
Rendez-vous sur la page GitHub suivante afin de récupérer le script de chargement d’une base de données SQL (Northwind) en exemple, puis cliquez-ici :
Téléchargez le script de chargement en cliquant sur le bouton suivant :
Une fois le script téléchargé, ouvrez SQL Server Management Studio sur votre poste :
Renseignez les informations reprises sur votre serveur Azure SQL créé précédemment, puis cliquez sur Connecter :
Cliquez-ici pour rechercher votre script SQL téléchargé précédemment :
Choisissez le script SQL, puis cliquez sur Ouvrir :
Une fois le script affiché dans une nouvelle fenêtre, cliquez sur Exécuter pour démarrer ce dernier :
Attendez environ 30 secondes que celui-ci se termine avec le message suivant :
Contrôlez dans la base de données Azure SQL créés en premier que les différentes tables sont présentes et que des données y sont stockées :
Nos données sont maintenant stockées dans notre base Azure SQL. Nous pouvoir maintenant mettre en place notre LLM grâce au service Azure OpenAI.
Etape III – Création du modèle Azure OpenAI :
Pour cela, retournez sur la page du portail Azure afin de rechercher le service Azure OpenAI :
Cliquez-ici pour créer votre service Azure Open AI ;
Renseignez les informations de base de ce dernier, puis cliquez sur Suivant :
Conservez les caractéristiques réseaux d’origine, puis cliquez sur Suivant :
Ajoutez au besoin des étiquettes, puis cliquez sur Suivant :
Une fois la validation Azure réussie, lancez la création des ressources Azure :
Attendez environ 1 minutes puis cliquez-ici pour accéder à votre service Azure OpenAI :
Copiez les 2 informations suivantes pour ouvrir un accès auprès de votre service Azure OpenAI :
Cliquez-ici pour ouvrir le portail Azure OpenAI Studio :
Cliquez-ici pour déployer un nouveau model :
Choisissez le type gpt-4, puis cliquez sur Confirmer :
Nommez votre déploiement, définissez une limite de tokens par minute qui convient, puis cliquez sur Déployer :
Attendez environ 1 minute le temps de déploiement de votre modèle :
L’infrastructure sur Azure est maintenant en place. Il nous nous reste qu’à configurer les applications web sur notre poste afin que celle-ci travaille avec le schéma de votre base de données et votre modèle AI.
Commençons par la version 1 proposée par Alex Wolf.
Etape IV – Configuration de l’application v1 :
Voici un lien vers son excellente vidéo présentant l’application v1, sa configuration, son code ainsi qu’une comparaison intéressante faite avec les services Search basés sur l’IA :
Un fois l’archive ZIP téléchargée, décompressez celle-ci dans le dossier local de votre choix :
Ouvrez votre éditeur de code local, puis cliquez-ici pour ouvrir le dossier de l’application v1 :
Ouvrez le dossier correspondant au dossier suivant :
Dans le dossier SchemaLoader\SchemaLoader ouvrez le fichier Program.cs, puis renseignez la connexion à votre base de données Azure SQL copiée précédemment :
N’oubliez pas de de modifier le mot de passe de votre compte SQL, puis sauvegardez :
Ouvrez une première fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :
Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :
dotnet run
Une fois l’application démarrée, copiez le texte généré par celle-ci et contenant le schéma de votre base de données Azure SQL :
Retournez sur votre éditeur de code, puis allez dans le dossier dbchatui, ouvrez le fichier DataService.cs, renseignez à nouveau la connexion à votre base de données Azure SQL, puis sauvegardez le fichier :
Allez dans le dossier dbchatui\Pages, ouvrez le fichier Index.cshtml.cs, copiez le schéma de votre base de données Azure SQL :
Cela donne la présentation suivante :
Toujours dans le fichier Index.cshtml.cs, renseignez les 3 informations suivantes pour connecter votre application à votre modèle Azure OpenAI, puis sauvegardez :
Rouvrez la fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :
Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :
dotnet run
Votre application v1 est maintenant démarrée. Copiez le numéro du port local ouvert pour cette application :
Ouvrez une seconde fenêtre Windows Terminal, puis saisissez la commande suivante afin d’exposer votre application locale au travers de ngrok :
Copiez l’URL publique générée par ngrok ci-dessous :
Tout l’environnement de test est maintenant en place, il nous reste qu’à tester le fonctionnement de l’application v1. Ouvrez un navigateur web, collez l’URL ngrok précédemment copiée, puis confirmez la navigation en cliquant ici :
Commencez par tester une requête SQL simple en promptant une question basique :
L’application vous retourne d’abord sa compréhension de votre demande, et la transpose en une requête SQL correspondante :
Juste en dessous est affiché les enregistrement correspondants au résultat de la requête exécutée sur votre serveur de base de données Azure SQL :
Continuez en testant des prompts incluant des filtres, des classements, … :
Continuez en testant des prompts incluant des relations de tables et des filtres basés sur un raisonnement :
Tous ces prompts nous montrent l’immense potentiel de pouvoir prompter une IA qui a une connaissance du schéma de toute la base de données source, sans pour autant avoir la données en elles-mêmes.
Etape V – Configuration de l’application v2 :
Il existe une nouvelle application toujours développée par Alex Wolf dont la vidéo est juste là :
Un fois l’archive ZIP téléchargée, décompressez celle-ci dans le dossier local de votre choix :
Ouvrez votre éditeur de code local, cliquez-ici pour ouvrir le dossier de l’application v2, renseignez les 3 informations suivantes pour connecter votre application à votre modèle Azure OpenAI, puis sauvegardez :
Ouvrez une première fenêtre Windows Terminal, positionnez-vous dans le dossier suivant, puis saisissez la commande ci-dessous :
Une fois la compilation terminée, démarrez votre application via la commande ci-dessous :
dotnet run
Votre application v2 est maintenant démarrée. Copiez le numéro du port local ouvert pour cette application :
Ouvrez une seconde fenêtre Windows Terminal, puis saisissez la commande suivante afin d’exposer votre application locale au travers de ngrok :
Copiez l’URL publique générée par ngrok ci-dessous :
Tout l’environnement de test est maintenant en place, il nous reste qu’à tester le fonctionnement de l’application v1. Ouvrez un navigateur web, collez l’URL ngrok précédemment copiée, puis confirmez la navigation en cliquant ici :
Renseignez la connexion à votre base de données Azure SQL copiée précédemment, puis cliquez-ici pour le schéma :
Cliquez sur Sauvegarder :
La connexion apparaît alors dans la liste des connexions existantes :
Retournez sur le premier onglet, puis commencez par tester une requête SQL simple en promptant une question basique :
L’application v2 vous retourne les enregistrement correspondants au résultat de la requête exécutée sur votre serveur de base de données Azure SQL :
Le second onglet affiche une requête SQL correspondante :
Le troisième onglet vous retourne la compréhension de votre demande comprise par le modèle IA :
Un historique des précédentes prompts est également disponible :
Il également possible de mettre des prompts en favoris :
Conclusion
En conclusion, l’utilisation de prompts pour interagir avec les bases de données représente une avancée importante, simplifiant l’accès aux informations et permettant une utilisation plus intuitive de SQL.
En expérimentant avec cette méthode, les utilisateurs peuvent améliorer leur efficacité et mieux exploiter leurs données.
Avec l’évolution rapide de ces technologies, maîtriser le langage des prompts pourrait devenir une compétence clé pour les professionnels de la donnée, ouvrant la voie à de nouvelles façons de gérer et analyser des volumes d’informations toujours croissants.
Le cloud est devenu le quotidien pour un grand nombre d’entreprises, mais les sites on-premise gardent encore une belle part des infrastructures et du stockage de données. Les principales IA ont compris cela, et elles proposent différents moyens de connecter ces données stockées on-premise à elles, afin ces informations soient elles-aussi indexées dans les mêmes outils pour une meilleure expérience utilisateur.
Le connecteur Partage de fichiers Microsoft Graph permet aux utilisateurs de votre organization de rechercher des partages de fichiers Windows locaux.
Pour notre démonstration, Microsoft a mis à disposition 3 documentations relatives à la mise en place de l’agent on-premise pour un serveur de fichiers local :
Rappel : Seul le contenu texte sera indexé et les fichiers supérieurs à 100 Mo seront ignorés.
Existe-t-il une configuration recommandée pour installer l’agent on-premise ?
Microsoft recommande d’installer l’agent on-premise sur une machine ou un poste ayant les caractéristiques suivantes :
Windows 10, Windows Server 2016 R2 et versions ultérieures
8 cœurs, 3 GHz
16 Go de RAM, 2 Go d’espace disque
Accès réseau à la source de données et à Internet via 443
Afin de bien comprendre le fonctionnement de l’agent on-premise sur un serveur partage de fichiers local vers Copilot pour Microsoft 365, je vous propose de réaliser ce petit exercice :
Avant d’installation le connecteur sur le serveur on-premise, faisons un premier de test de prompt à Copilot pour évaluer les réponses obtenues.
Etape I – Premier test Copilot sans connecteur :
Pour cela, ouvrez votre navigateur internet sur la page web de Copilot en mode Work :
Saisissez le prompt suivant :
cherche un document parlant de associez fslogix avec azure ad
Copilot vous informe qu’il trouve bien des documents sur SharePoint ou Teams, mais aucun document stocké depuis un serveur de fichiers local.
Afin de pouvoir tester ce connecteur, il m’est nécessaire de créer une machine virtuelle.
Etape II – Préparation du serveur de fichiers local :
Afin de faciliter la démonstration, j’ai donc créé la machine virtuelle suivante sur Azure :
Cette machine virtuelle fonctionne sous Windows Server et est jointe à un domaine Active Directory. De plus, elle se trouve sur le même réseau que le Cloud PC Windows 365 contenant les outils 365 et la licence Copilot pour Microsoft 365.
Important : La liaison réseau directe sera nécessaire pour ouvrir le document indexé et proposé dans les résultats de Copilot.
J’ai également déployé le service Azure Bastion pour m’y connecter plus facilement en RDP :
Commençons par la préparation de notre tenant à gérer les authentification de notre connecteur à Microsoft 365 à l’API Microsoft Graph.
Etape III – Création d’une Inscription d’application Entra :
Rendez-vous sur la page du portail Azure disponible juste ici, puis ouvrez le service Microsoft Entra ID :
Dans le menu Inscriptions d’applications, cliquez-ici pour créer une nouvelle Inscription :
Nommez votre application, puis cliquez sur Inscrire :
Cliquez sur le menu Certificats et secrets, puis ajoutez un nouveau secret client comme ceci :
Donnez-lui une description, puis cliquez sur Ajouter :
Copiez la valeur de votre secret. Ce dernier sera utilisé par votre connecteur on-premise afin qu’il s’authentifie automatiquement :
Dans le menu des Permissions API, cliquez-ici pour ajouter des permissions supplémentaires :
Choisissez l’API Microsoft Graph :
Cliquez sur Permissions d’application :
Recherchez et cochez les 3 permissions suivantes en utilisant la barre de recherche, puis cliquez sur Ajouter les permissions :
ExternalConnection
ExternalConnection.ReadWrite.OwnedBy
ExternalItem
ExternalItem.ReadWrite.OwnedBy
Directory
Directory.Read.All
Enfin, cliquez sur le bouton suivant afin d’appliquer ces permissions au niveau du tenant :
Confirmez votre choix en cliquant sur Oui :
Copiez également l’ID de votre application pour la configuration de l’agent on-premise :
La configuration du côté du tenant est en partie terminée. Nous allons maintenant nous intéresser l’installation de l’Agent on-premise.
Etape IV – Installation de l’agent on-premise :
Avant de de configurer l’agent on-premise installé sur votre serveur de fichiers local, il est nécessaire de dispose d’un rôle RBAC spécifique sur Entra ID :
Sur votre serveur de fichiers, ouvrez une session à distance avec un compte administrateur via le service Azure Bastion :
Sur votre serveur de fichiers, préparez une arborescence partagée sur le réseau et contenant des fichiers de données à indexer :
Avant d’installer l’agent on-premise, il est nécessaire de disposer au minimum de .NET Core Desktop Runtime en version 7.0.
Continuez en téléchargeant l’agent on-premise depuis cette page :
Cliquez-ici pour commencer le téléchargement, puis lancez l’installation :
Cliquez sur Suivant :
Acceptez les conditions, puis cliquez sur Suivant :
Cliquez sur Installer :
Validez en cliquant sur Oui sur les différents messages d’avertissement Windows :
L’installation est finie, cliquez sur Terminer :
Le configurateur de l’agent on-premise s’ouvre automatiquement, cliquez-ici pour associez ce dernier à votre tenant Microsoft :
Nommez cet agent on-premise, reprenez les informations récupérées de l’inscription d’application créée précédemment, puis cliquez sur Enregistrer :
Attendez quelques minutes la finalisation de la configuration de l’agent on-premise :
Une fois la configuration terminée, cliquez sur Fermer :
La configuration sur le serveur de fichiers local est maintenant terminée, nous allons mettre en place la liaison avec 365 depuis la console d’administration 365 dédiée : Recherche et intelligence.
Etape V – Configuration de la source de données 365 :
Sélectionnez le Partage de fichiers, puis cliquez sur Suivant :
Nommez votre connexion ainsi que les informations visibles pour l’utilisateur Copilot, puis cliquez ici :
Reprenez les informations liées au partage de fichier en y incluant l’agent on-premise ainsi que les identifiants Windows de votre domaine, testez la bonne connexion, puis cliquez-ici :
Regardez les choix possibles, puis cliquez-ici :
Regardez les choix possibles, puis cliquez-ici :
Regardez les choix possibles, puis cliquez-ici :
Déterminez les droits d’exploitation des fichiers stockées sur votre partage local, puis cliquez-ici :
Regardez les choix possibles, puis cliquez-ici :
Regardez les choix possibles, puis cliquez-ici :
Définissez le fuseau horaire adéquat et la fréquence de synchronisation, puis cliquez-ici :
Enfin cliquez sur Publier :
Cliquez sur Fermez :
Attendez quelques minutes afin que le connecteur soit entièrement publié, que la première synchronisation soit finie et que des premiers documents soient indexés :
Votre configuration est enfin terminée. Passez à la suite pour constater d’éventuels changements.
Etape VI – Second test Copilot avec connecteur :
Sur votre utilisateur ayant la licence Copilot pour Microsoft 365, retournez sur la page de Copilot en mode Work en ayant toujours aucun plugin d’actif :
Saisissez à nouveau le prompt suivant :
cherche un document parlant de associez fslogix avec azure ad
Constatez l’apparition d’un résultat avec une ou plusieurs références de provenant de notre connecteur en relation avec l’agent installé sur le serveur de fichiers local :
De mon côté, je n’ai pas été en mesure de cliquer directement sur la source et d’obtenir automatiquement le fichiers attendu directement depuis la console Copilot.
Pourtant, en copiant l’URL de la source Copilot, le fichier est bien accessible et est téléchargeable :
Je cherche toujours pourquoi…
Edit au 28/01/25 :
Le clic depuis la source affichée par Copilot marche maintenant !
Choisissez par exemple d’ouvrir votre fichier via Office :
Confirmez votre choix :
Word s’ouvre bien :
Etape VII – Test depuis Microsoft Search :
Malgré cela, j’ai souhaité refaire le même test depuis la barre de recherche Microsoft Search située sur la page d’Office :
Saisissez les mots clefs suivants :
associez fslogix avec azure ad
Le même résultat apparaît alors, cliquez sur le nom du fichier proposé par Microsoft Search :
Acceptez le risque en cliquant sur Oui :
Constatez la bonne ouverture du fichier depuis la source locale en lecture seule :
Conclusion
La mise en place de l’agent on-premise dédié au partage de fichiers pour Copilot pour Microsoft 365 est assez facile à mettre en place et fonctionne plutôt bien.
Grâce à Microsoft Graph, Microsoft propose à tous un très grand nombre de possibilités pour créer les liaisons vers Copilot selon vos exigences et vos besoins :
J’ai reçu un mail il y a quelques jours de la part de Microsoft (oui oui, seulement un 🤣) m’invitant tester par moi-même un premier connecteur Copilot pour Microsoft 365, en suivant simplement un pas à pas technique. N’ayant pas d’expérience en .NET, je me suis dit … pourquoi pas ! Je vous propose de le réaliser ensemble pour que vous puissiez vous-même reproduire cet exercice sur votre tenant Copilot.
Dans cet article, nous reprendrons brièvement quelques concepts et nous testerons nous-même de créer un connecteur Microsoft Graph personnalisé afin d’enrichir les résultats Copilot dans Microsoft 365.
Voici encore un rappel des articles écrits autour des solutions Copilot de Microsoft :
Les connecteurs Microsoft Graph vous permettent d’ingérer vos données métier non structurées dans Microsoft Graph, afin que Copilot pour Microsoft 365 puissent raisonner sur l’intégralité du contenu de votre entreprise. Le contenu ingéré via les connecteurs Graph est ajouté à Microsoft Graph ; cela déverrouille la compréhension sémantique des invites de vos utilisateurs dans Copilot pour Microsoft 365.
Quel est l’impact d’un connecteur dans Copilot pour 365 ?
L’impact de connecteur dans les résultats Copilot peut changer la donne dans les résultats de recherche documentaire car il va fouiner en dehors de Microsoft 365.
Voici un exemple montrant des résultats avec des références externes à Microsoft 365, améliorant donc l’expérience de recherche de l’utilisateur Copilot :
Voici également une courte vidéo montrant un peu plus à ce sujet :
Peut-on gérer les droits d’accès aux données remontées via un connecteur ?
Oui, ce qui est stocké en dehors de Microsoft 365 reste accessible selon une configuration ACL de votre choix. Les documents pourraient alors être visibles par :
Tous les membres de votre organisation
Un ou des groupes 365
Un ou des utilisateurs 365
Important : Les autorisations d’accès au contenu externe sont directement stockées dans le système externe.
Existe-t-il des connecteurs déjà disponibles sur étagères ?
Oui, Microsoft propose déjà un site web référençant des connecteurs de plusieurs grands éditeurs :
Quelles sont les sources de données possibles via un Connecteur ?
Microsoft a déjà créé plusieurs connecteurs dont voici certains exemples de source de données :
La réponse est encore oui. Dans l’objectif de vous aider à tester Copilot avec un connecteur Microsoft Graph personnalisé, Microsoft a mis à disposition la documentation suivante.
Grâce à celle-ci, vous pouvez facilement tester intégration du contenu externe à Copilot for Microsoft 365 à l’aide de connecteurs Microsoft Graph construits avec .NET.
Dans cet exercice Microsoft, les tâches que nous allons réaliser seront donc les suivantes :
Une fois l’installeur téléchargé, exécutez celui-ci
Acceptez les conditions d’utilisation, puis cliquez sur Suivant :
Définissez le répertoire d’installation, puis cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Suivant :
Cliquez sur Installer :
Attendez 1 minute que l’installation de Visual Studio Code se termine :
Cliquez sur Terminer :
Une fois dans Visual Studio Code, allez dans le menu Extensions, puis installez l’extension simplement nommée C# :
Retournez sur votre navigateur internet afin de télécharger la version 8.0.1 du SDK .NET :
Une fois l’installation téléchargée, exécutez celle-ci :
Cliquez sur Installer :
Confirmez l’action de sécurité Windows en cliquant sur Oui :
Attendez 1 minute que l’installation de .NET se termine :
Cliquez sur Fermer :
Redémarrer votre poste Windows afin de prendre en compte la nouvelle version .NET :
Notre poste est maintenant prêt pour la création d’un connecteur Microsoft Graph personnalisé.
Nous allons commencer par la préparation de notre tenant à gérer les authentification de notre connecteur à Microsoft 365 à l’API de Microsoft Graph.
Etape III – Création d’une Inscription d’applicationEntra :
Rendez-vous sur la page du portail Azure disponible juste ici, puis ouvrez le service Microsoft Entra ID :
Dans le menu Inscriptions d’applications, cliquez-ici pour créer une nouvelle Inscription :
Nommez votre application, puis cliquez sur Inscrire :
Attendez quelques secondes la notification suivante :
Cliquez sur le menu Certificats et secrets, puis ajoutez un nouveau secret client comme ceci :
Nommez-le, puis cliquez sur Ajouter :
Copiez la valeur de votre secret. Ce dernier sera utilisé par votre connecteur Microsoft Graph afin qu’il s’authentifie automatiquement :
Dans le menu des Permissions API, cliquez-ici pour ajouter des permissions supplémentaires :
Choisissez l’API Microsoft Graph :
Cliquez sur Permissions d’application :
Recherchez et cochez les 2 permissions suivantes en utilisant la barre de recherche, puis cliquez sur Ajouter les permissions :
ExternalConnection
ExternalConnection.ReadWrite.OwnedBy
ExternalItem
ExternalItem.ReadWrite.OwnedBy
Enfin, cliquez sur le bouton suivant afin d’appliquer ces permissions au niveau du tenant :
Confirmez votre choix en cliquant sur Oui :
Leur statut s’en retrouve alors changé comme ceci :
La configuration du côté du tenant est en partie terminée. Nous allons maintenant nous intéresser l’écriture du code en .NET de notre connecteur Microsoft Graph.
Etape IV – Création du connecteur Microsoft Graph personnalisé :
Dans l’explorateur Windows, créez un dossier pour y stocker le codes et les données de votre futur connecteur Microsoft Graph :
Retournez dans Visual Studio Code, puis cliquez ici pour vous positionnez sur ce nouveau répertoire :
Cliquez sur Oui :
Dans la console située en bas de votre écran, vérifiez le bon positionnement de votre dossier, puis lancez la commande suivante pour créer une nouvelle console dédiée à votre application .NET :
dotnet new console
Notez l’apparition de fichiers suivants dans l’explorateur Windows :
Ajoutez la bibliothèque suivante pour s’authentifier auprès des services Microsoft 365 :
dotnet add package Azure.Identity
Ajoutez la bibliothèque cliente suivante pour communiquer à l’API Microsoft Graph :
dotnet add package Microsoft.Graph
Ajoutez la bibliothèque suivante pour gérer les secrets :
Afin de stocker les secrets de notre application, lancez la commande suivante :
dotnet user-secrets init
Conservez les 3 informations de votre Inscription d’application pour vous authentifier automatiquement auprès de Microsoft 365 :
ID de l’application
Valeur du secret
ID du tenant
Saisissez les commandes suivantes pour les stocker de manière sécurisée en remplaçant les 3 valeurs en gras par celles récupérées juste avant :
dotnet user-secrets set "EntraId:ClientId" "[application id]"
dotnet user-secrets set "EntraId:ClientSecret" "[secret value]"
dotnet user-secrets set "EntraId:TenantId" "[tenant id]"
Continuons la configuration par la connexion entre le connecteur personnalisé et l’API Microsoft API.
Etape V – Configuration de la connexion avec l’API Microsoft Graph :
Le premier fichier va être utile à gérer les informations de la connexion entre le connecteur personnalisé et l’API Microsoft Graph.
Dans Visual Studio Code, créez un premier fichier texte en cliquant juste ici :
Choisissez le type de fichier texte :
Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom GraphService.cs :
using Azure.Identity;
using Microsoft.Graph;
using Microsoft.Extensions.Configuration;
class GraphService
{
static GraphServiceClient? _client;
public static GraphServiceClient Client
{
get
{
if (_client is null)
{
var builder = new ConfigurationBuilder(). AddUserSecrets<GraphService>();
var config = builder.Build();
var clientId = config["EntraId:ClientId"];
var clientSecret = config["EntraId:ClientSecret"];
var tenantId = config["EntraId:TenantId"];
var credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
_client = new GraphServiceClient(credential);
}
return _client;
}
}
}
Le second fichier contient la connexion externe elle-même avec Microsoft 365 et les schémas de données envoyées à Microsoft 365.
Créer à nouveau un fichier texte, collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ConnectionConfiguration.cs :
using Microsoft.Graph.Models.ExternalConnectors;
static class ConnectionConfiguration
{
public static ExternalConnection ExternalConnection
{
get
{
return new ExternalConnection
{
Id = "msgraphdocs",
Name = "Microsoft Graph documentation",
Description = "Documentation for Microsoft Graph API which explains what Microsoft Graph is and how to use it."
};
}
}
public static Schema Schema
{
get
{
return new Schema
{
BaseType = "microsoft.graph.externalItem",
Properties = new()
{
new Property
{
Name = "title",
Type = PropertyType.String,
IsQueryable = true,
IsSearchable = true,
IsRetrievable = true,
Labels = new() { Label.Title }
},
new Property
{
Name = "description",
Type = PropertyType.String,
IsQueryable = true,
IsSearchable = true,
IsRetrievable = true
},
new Property
{
Name = "iconUrl",
Type = PropertyType.String,
IsRetrievable = true,
Labels = new() { Label.IconUrl }
},
new Property
{
Name = "url",
Type = PropertyType.String,
IsRetrievable = true,
Labels = new() { Label.Url }
}
}
};
}
}
}
Créer un troisième fichier texte contant les demandes d’établissement de connexion entre le connecteur personnalisé et l’API de Microsoft Graph.
Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ConnectionService.cs :
Enfin, ouvrez le fichier Program.cs créé automatiquement dans votre dossier afin de signaler à notre l’application .NET de créer la connexion et son schéma.
Pour ce faire, remplacez le code de départ par celui-ci, puis sauvegardez-le via la commande clavier Ctrl Shift+S :
using System.CommandLine;
var provisionConnectionCommand = new Command("provision-connection", "Provisions external connection");
provisionConnectionCommand.SetHandler(ConnectionService. ProvisionConnection);
var rootCommand = new RootCommand();
rootCommand.AddCommand(provisionConnectionCommand);
Environment.Exit(await rootCommand.InvokeAsync(args));
Un premier test de création de connexion vers Microsoft 365 via l’API Microsoft Graph depuis notre connecteur personnalisé est déjà possible.
Etape VI – Test de connection:
Pour cela, utilisez la commande .NET suivante pour construire votre projet :
dotnet build
Démarrez l’application en exécutant la commande suivante, puis attendez :
Continuez d’attendre la construction complète de la connexion :
Retournez sur cette même page afin de constater le changement du status de la connexion :
Nous venons de créer une connexion externe afin d’indexer nos futurs documents à venir dans Microsoft 365.
La prochaine étape consiste justement à importer de la donnée afin d’alimenter les index de Microsoft 365.
Etape VII – Configuration de l’import de contenu externe :
Un connecteur Microsoft Graph se connecte à un système externe, exporte son contenu et l’importe dans Microsoft 365. Au cours de ce processus, un connecteur graphique transforme le contenu exporté en éléments externes mettant en correspondance le contenu avec le schéma configuré sur la connexion externe.
Le contenu définit l’essentiel de l’élément qui est indexé pour la recherche en texte intégral. Pour un document ou une page wiki, il s’agit du corps du document. Pour un produit, il peut s’agir de sa description. Les connecteurs graphiques vous permettent d’importer du contenu au format texte ou HTML. Si vous importez du contenu binaire, comme des vidéos ou des images, vous devez obtenir leur représentation textuelle avant de les importer dans Microsoft 365.
Afin de simuler facilement du contenu, Microsoft met à disposition sur GitHub des fichiers de contenu pour notre connecteur Microsoft Graph personnalisé.
Téléchargez ce contenu via ce lien GitHub, puis débloquez la protection sur l’archive ZIP :
Décompressez le contenu de l’archive dans l’arborescence de votre projet comme ceci :
Depuis l’explorateur Windows, vérifiez que le contenu de votre projet se présente sous cette forme :
Vérifiez la présence de cette nouvelle arborescence dans Visual Studio Code :
Dans Visual Studio Code, ouvrez le seul fichier .csproj présent dans votre projet :
Ajoutez le code suivant dans le fichier .csproj avant la balise </Project> pour copier le contenu, puis sauvegardez-le via la commande clavier Ctrl Shift+S :
Afin d’importer les fichiers de contenu au format Markdown vers Microsoft 365, nous devons extraire les métadonnées et convertir les contenus au format texte :
Pour y arriver, nous avons besoin d’autres bibliothèques :
dotnet add package Markdig
dotnet add package YamlDotNet
Créez un quatrième fichier texte consacré à la gestion du contenu à importer. Celui-ci va réaliser les actions suivantes :
Configuration du traitement du format markdown
Extraction des contenus markdown et YAML
Transformation du contenu en éléments externes
Chargement des éléments externes dans Microsoft 365
Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom ContentService.cs :
using YamlDotNet.Serialization;
using Microsoft.Graph.Models.ExternalConnectors;
using Markdig;
public interface IMarkdown
{
string? Markdown { get; set; }
}
class DocsArticle : IMarkdown
{
[YamlMember(Alias = "title")]
public string? Title { get; set; }
[YamlMember(Alias = "description")]
public string? Description { get; set; }
public string? Markdown { get; set; }
public string? Content { get; set; }
public string? RelativePath { get; set; }
}
static class ContentService
{
static IEnumerable<DocsArticle> Extract()
{
var docs = new List<DocsArticle>();
var contentFolder = "content";
var contentFolderPath = Path.Combine(Directory.GetCurrentDirectory(), contentFolder);
var files = Directory.GetFiles(contentFolder, "*.md", SearchOption. AllDirectories);
foreach (var file in files)
{
try
{
var contents = File.ReadAllText(file);
var doc = contents.GetContents<DocsArticle>();
doc.Content = Markdown.ToHtml(doc.Markdown ?? "");
doc.RelativePath = Path.GetRelativePath(contentFolderPath, file);
docs.Add(doc);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return docs;
}
static IEnumerable<ExternalItem> Transform(IEnumerable<DocsArticle> content)
{
var baseUrl = new Uri("https://learn.microsoft.com/graph/");
return content.Select(a =>
{
var docId = GetDocId(a.RelativePath ?? "");
return new ExternalItem
{
Id = docId,
Properties = new()
{
AdditionalData = new Dictionary<string, object> {
{ "title", a.Title ?? "" },
{ "description", a.Description ?? "" },
{ "url", new Uri(baseUrl, a.RelativePath!.Replace(".md", "")).ToString() }
}
},
Content = new()
{
Value = a.Content ?? "",
Type = ExternalItemContentType.Html
},
Acl = new()
{
new()
{
Type = AclType.Everyone,
Value = "everyone",
AccessType = AccessType.Grant
}
}
};
});
}
static async Task Load(IEnumerable<ExternalItem> items)
{
foreach (var item in items)
{
Console.Write(string.Format("Loading item {0}...", item.Id));
try
{
await GraphService.Client.External
.Connections[Uri.EscapeDataString(ConnectionConfiguration. ExternalConnection.Id!)]
.Items[item.Id]
.PutAsync(item);
Console.WriteLine("DONE");
}
catch (Exception ex)
{
Console.WriteLine("ERROR");
Console.WriteLine(ex.Message);
}
}
}
public static async Task LoadContent()
{
var content = Extract();
var transformed = Transform(content);
await Load(transformed);
}
static string GetDocId(string relativePath)
{
var id = relativePath.Replace(Path.DirectorySeparatorChar.ToString(), "__").Replace(".md", "");
return id;
}
}
Créez un cinquième fichier texte consacré à l’extraction de contenu fichiers de contenu.
Collez le code suivant dans votre fichier, puis sauvegardez-le via la commande clavier Ctrl Shift+S avec le nom MarkdownExtensions.cs :
// from: https://khalidabuhakmeh.com/parse-markdown-front-matter-with-csharp
using Markdig;
using Markdig.Extensions.Yaml;
using Markdig.Syntax;
using YamlDotNet.Serialization;
public static class MarkdownExtensions
{
private static readonly IDeserializer YamlDeserializer =
new DeserializerBuilder()
.IgnoreUnmatchedProperties()
.Build();
private static readonly MarkdownPipeline Pipeline
= new MarkdownPipelineBuilder()
.UseYamlFrontMatter()
.Build();
public static T GetContents<T>(this string markdown) where T : IMarkdown, new()
{
var document = Markdown.Parse(markdown, Pipeline);
var block = document
.Descendants<YamlFrontMatterBlock>()
.FirstOrDefault();
if (block == null)
return new T { Markdown = markdown };
var yaml =
block
// this is not a mistake
// we have to call .Lines 2x
.Lines // StringLineGroup[]
.Lines // StringLine[]
.OrderByDescending(x => x.Line)
.Select(x => $"{x}\n")
.ToList()
.Select(x => x.Replace("---", string.Empty))
.Where(x => !string.IsNullOrWhiteSpace(x))
.Aggregate((s, agg) => agg + s);
var t = YamlDeserializer.Deserialize<T>(yaml);
t.Markdown = markdown.Substring(block.Span.End + 1);
return t;
}
}
Enfin, rouvrez à nouveau le fichier Program.cs modifié précédemment pour y ajouter la commande de chargement du contenu, puis sauvegardez-le via la commande clavier Ctrl Shift+S :
var loadContentCommand = new Command("load-content", "Loads content into the external connection");
loadContentCommand.SetHandler(ContentService.LoadContent);
rootCommand.AddCommand(loadContentCommand);
Etape VIII – Test d’importation :
Pour cela, utilisez la commande .NET suivante pour reconstruire à nouveau votre projet :
dotnet build
Commencez à charger le contenu vers Microsoft 365 en exécutant la commande suivante :
Notre environnement 365 contient maintenant l’accès à ces nouveaux documents. Il nous faut maintenant activer cette source dans 365 pour que Copilot puisse les ressortir en résultat.
Etape IX – Activation de la connexion externe dans Copilot :
Toujours sur cette même page d’administration 365, rendez-vous sur l’onglet Personnalisations, puis cliquez-ici pour activer votre connecteur dans les résultats :
Cochez les cases suivantes pour activer votre connecteur dans les résultats Copilot :
Etape X – Second test Copilot avec connecteur :
Sur votre utilisateur ayant la licence Copilot pour Microsoft 365, retournez sur la page de Copilot en mode Work en ayant toujours aucun plugin d’actif :
Saisissez à nouveau le prompt suivant :
please find a doc how to install a Microsoft Graph SDK
Constatez l’apparition d’un résultat avec une ou plusieurs références de type Externe :
Refaite la même opération en promptant sur le même sujet, puis cliquez sur la source externe :
Constatez l’ouverture d’un nouvel onglet pointant vers la documentation Microsoft Learn car le document dispose d’une URL pointant vers celle-ci :
Conclusion
Par les extensions, Microsoft nous montre que l’IA n’en est qu’à ses débuts dans les différents systèmes de données. Les entreprises ont tout y gagner à connecter une IA sur un ensemble de plusieurs systèmes d’informations.
Savoir que je peux interroger mes stocks de marchandises, et les modifier au besoin dans mes autres systèmes au moyen d’une IA connectée me fait espérer beaucoup d’innovations pour les années à venir :
Copilot pour Microsoft 365 fait maintenant partie de votre quotidien depuis plusieurs semaines ? Vous êtes donc un utilisateur régulier de Copilot dans plusieurs applications 365 ? En ressentez-vous déjà les premiers impacts sur votre productivité ?
Copilot pourrait-il en faire plus ?
Il est possible que vous soyez prêts à élargir le périmètre de votre Copilot ! Pour cela, prenez le temps de savoir comment Copilot pourrait exploiter d’autres données, et surtout comment il s’y prendrait.
Voici déjà quelques articles écrits sur ce blog autour des solutions Copilot de Microsoft :
Comme le rappelle Microsoft, Copilot est en soit l’IA générative actuellement la plus adaptée aux applications et données présentes dans Microsoft 365 :
En soi, Copilot pour Microsoft 365 est un outil de productivité puissant pour maintenir les utilisateurs dans le flux de leur travail dans les applications Microsoft 365. Il fournit aux utilisateurs des compétences générales telles que la compréhension, la synthèse, la prédiction, le rappel, la traduction et la génération de contenu.
Il s’appuie sur une base de référence de vos connaissances organisationnelles en indexant du contenu dans Microsoft Graph, tel que les e-mails, les conversations et les documents auxquels les utilisateurs ont l’autorisation d’accéder.
Copilot pour Microsoft 365 a été annoncé il y a longtemps, mais les choses évoluant très rapidement, prenez-le temps de regarder cette vidéo en français pour comprendre un peu mieux Copilot pour Microsoft 365 :
Je pense que ce schéma a déjà dû passer sous vos yeux à plusieurs reprises, mais il est facile à comprendre car il montre les avantages natifs d’un Copilot déjà connecté aux données de votre tenant.
De ce fait, et sans rien faire d’autres qu’acheter des licences Copilot pour Microsoft 365, le schéma technique de votre IA Copilot ressemble déjà à ça :
Alors, pourquoi en faire plus ?
Car l’IT d’une entreprise a de nombreuses vies et ne se limite pas aux outils 365 et aux données stockées dans SharePoint, OneDrive et autres.
Bien souvent, d’autres outils proviennent d’éditeurs tiers ou sont créés en internes pour des besoins métiers. La donnée peut donc se trouver en dehors de l’environnement 365 et possiblement sous des formats spécifiques.
Techniquement, Copilot pour Microsoft 365 ne peut donc pas s’inspirer de cette donnée inconnue ou même la proposer si un utilisateur lui en fait la demande via un prompt.
Mais une fois en place, votre Copilot pour Microsoft 365 dispose de plusieurs possibilités pour étendre son périmètre pour coller toujours plus aux besoins :
Pour vous faire une meilleure idée, voici un exemple assez parlant donné par Microsoft :
Suivi des problèmes pour l’équipe d’ingénierie : Supposons que votre équipe d’ingénierie s’appuie sur un logiciel de gestion de projet. Vous pouvez créer un outil personnalisé qui permet aux utilisateurs de surveiller les tickets ouverts. Un utilisateur peut demander des informations sur tous les problèmes qui lui sont attribués, et Copilot pour Microsoft 365 peut récupérer et présenter ces données en toute transparence à partir de votre plugin.
Imaginez alors d’autres données relatives aux ressources humaines, à la comptabilité, aux outils de productions industrielles ou encore à la finance ? Tout cela à la portée d’un simple prompt à Copilot ?
Oui mais, comment s’y prend-on ?
Rien n’est automatique, mais Microsoft vous propose déjà 2 approches pour y parvenir :
Plugin : Ideal pour les données structurées. Développez des plugins qui utilisent le schéma OpenAI pour ajouter des fonctionnalités personnalisées aux expériences Microsoft Copilot, en connectant les données de votre propre application à Microsoft Copilot. Les plugins permettent à une expérience Copilot d’interagir avec vos propres API, améliorant ainsi l’expérience pour effectuer un plus grand nombre d’actions. (Source : Microsoft)
Connecteur : Ideal pour les données non structurées. Le connecteur vous permet d’ingérer vos données métier non structurées dans Microsoft Graph, afin que Copilot pour Microsoft 365 puissent raisonner sur l’intégralité du contenu de votre entreprise. Le contenu ingéré via les connecteurs Graph est ajouté à Microsoft Graph ; cela déverrouille la compréhension sémantique des invites de vos utilisateurs dans Copilot pour Microsoft 365. (Source : Microsoft)
Mais alors, lequel choisir ?
Pour vous aider au mieux à comprendre, cette vidéo de Microsoft vous montre justement les impacts en situation réelle :
Pour vous aider à faire votre choix, Microsoft a également mis à disposition cet arbre de décision :
Attention, la structure de la donnée pourrait avoir elle aussi un impact sur votre choix :
Connecteurs
Plugins
Structure
Données non structurées ou aplatis
Données structurées
Volume de données
Jusqu’à 5 millions d’éléments par connexion
Convient pour les données à volume élevé (plus de 5 M)
Pertinence basée sur les activités de l’utilisateur. Détection sémantique du contenu sans activation d’un plugin. Activités (telles que l’affichage, la modification et le partage) avec aide sur le classement et la pertinence des résultats de recherche. Les données restent dans les limites de conformité
Détectabilité dans le Windows Store. Activation de l’expérience de marque. Meilleure expérience utilisateur avec les cartes adaptatives
Fonctionnalités de l’expérience développeur
Connexion rapide, schéma d’inscription et éléments d’index
Kit de ressources Teams pour Visual Studio & VS Code. Chargement de version test pour le développement & test
Fonctionnez également avec
IQ de contexte, Viva Topics, Recherche d’entreprise dans M365.com, SharePoint et Bing @ work. Recommandations de contenu dans les applications M365
Conversation Teams, Outlook
Existe-t-il des limitations techniques ?
En effet, les 2 options présentent des limitations techniques qui peuvent influer sur votre choix :
Connecteurs
Plugins
Limites
30 connecteurs maximum dans le locataire.
Volume de données et activité relativement faibles.
Visibilité de l’application pour les utilisateurs.
Maximum d’un million de plugins activés par utilisateur. Les plugins doivent être activés manuellement. Les données peuvent quitter la limite de conformité. Orchestrator ne peut raisonner qu’avec 10 plugins par invite. Les performances dépendent des développeurs & l’hébergement.
Limitations de l’expérience des développeurs
Aucun outil pour Visual Studio & VS Code. Aucun chargement indépendant. Vous devez rester synchronisé avec la liste de contrôle d’accès (ACL) manuellement si vous êtes dans des groupes externes en dehors du groupe Id Entra (Azure AD)
Courbe d’apprentissage abrupte. Plus de temps pour développer. Vous devez gérer les invites à paramètres multiples.
Important : il n’est pour l’instant pas possible d’acheter et de provisionner des licences acheter Copilot for Microsoft 365 sur un tenant créé à partir du Microsoft 365 Developer Program.
Et Copilot Studio dans tout ça ?
Pas de secret, Microsoft Copilot Studio s’appuie déjà sur du connu et reconnu ! 😎🙏
Un grand merci à Elliott Pierret pour cette vidéo très explicative sur comment jouer avec Copilot Studio pour créer son propre Copilot ou enrichir un Copilot existant grâce aux outils suivants :
Copilot Builder
Plugin Builder
Prompt Builder
Conclusion
Quelle que soit votre stratégie Copilot, l’objectif de cette IA générative est avant tout de simplifier la vie à vos utilisateurs. Beaucoup de tâches sans grande valeur ajoutée peuvent et ont également intérêt à être traitées par l’intelligence artificielle.
Je vous invite à regarder cette interview très intéressante de Jean-François Bérenguer faite par Seyfallah Tagrerout sur le potentiel de Copilot et les services IT possibles avec une valeur ajoutée pour les entreprises dans leur transition vers l’IA :
Accompagnement au prompt
Mise en place du gouvernance de la donnée (protection)
Personnalisation de Copilot (Connecteurs, plugins)
Attendez-vous très prochainement à voir plusieurs articles sur des essais pratiques de Copilot 😎
Microsoft vient de faire une grande annonce il y a seulement quelques heures : Copilot pour Microsoft 365 est maintenant accessible au grand public et à toutes les organisations. Quelles sont les contraintes ? Comment cela se passe au niveau du tenant ? Nous essaierons de répondre à plusieurs questions et testerons la mise en place d’une licence Copilot pour Microsoft 365.
Copilot pour Microsoft 365 n’est-il pas déjà accessible depuis le dernier Ignite en 2023 ?
C’est en partie vrai. L’une des grandes annonces du dernier Ignite portait sur la GA de Copilot pour Microsoft 365, uniquement pour les grandes entreprises. La commande minimale de Copilot pour Microsoft 365 était alors 300 sièges et nécessitait également des licences 365 Enterprise E3 ou E5.
A 30$ par utilisateur, la facture de Copilot pour Microsoft 365 pouvait paraitre assez salée.
Annoncé mi-décembre pour début janvier, Copilot pour Microsoft 365 était alors aussi accessible aux écoles disposants de licences Microsoft 365 A3 ou A5. Avec toujours la même règle : 30 dollars par utilisateur et par mois, et avec un minimum de 300 places par tenant.
Qu’est-ce que Microsoft a changé sur le modèle de licence ces dernières heures ?
N’acheter qu’une seule licence Copilot pour Microsoft 365 et non plus 300
Ne pas disposer obligatoirement de licences Microsoft 365 E3 ou E5
D’acheter des licences Copilot pour Microsoft 365 via le CSP
Mais il reste encore quelques exigences pour que les utilisateurs puissent profiter de Copilot pour Microsoft 365 :
Si < 299 utilisateurs (Business) : Disposer de licences Microsoft 365 Business Standard ou Premium pour les utilisateurs ayant Copilot pour Microsoft 365
Si >= 300 utilisateurs (Enterprise) : Disposer de licences Microsoft 365 Enterprise E3 ou E5 pour les utilisateurs ayant Copilot pour Microsoft 365
Le prix reste de 30$ par utilisateur et par mois
L’engagement minimum est d’une année pour les licences Copilot pour Microsoft 365
Qu’est-ce que Copilot pour Microsoft 365 ?
Afin de vous faire une meilleure idée, voici une très courte vidéo expliquant l’audacieux mélange entre une IA, les données provenant de 365 (ou d’ailleurs) et les outils que composent la suite 365 :
Un article parlant des multiples Copilots a d’ailleurs écrit sur ce blog juste ici. Enfin voici quelques liens utiles à propos de Microsoft Copilot for Microsoft 365 :
La mise en place de Copilot pour Microsoft 365 est assez facile, mais la préparation demande un peu plus de temps. En effet, Copilot pour Microsoft 365 est mesure de « piocher » dans les données de votre entreprise. Ces dernières doivent donc être accessibles, protégées et structurées.
La préparation du tenant va donc principalement porter sur les points suivants :
Préparez vos données et vérifiez que tous les contrôles de sécurité, de confidentialité et de conformité sont en place. Copilot hérite de vos autorisations et de vos politiques existantes, et le fait de s’assurer que celles-ci sont en place contribue à un déploiement transparent. Effectuez des vérifications d’accès … utilisez des étiquettes de sensibilité pour protéger les données importantes et validez les politiques de prévention des pertes de données, de conservation et de conformité.
Vérifiez l’état de préparation, mesurez l’adoption et l’impact grâce au tableau de bord Microsoft Copilot (préversion) dans Viva Insights ou PowerBi qui aide les organisations à maximiser la valeur de Copilot pour Microsoft 365.
Afin d’aller plus loin dans la démonstration, j’ai la possibilité d’acheter une licence Copilot pour Microsoft 365 sur un tenant de test afin de visualiser sa mise en place.
J’ai souhaité uniquement suivre les conditions requises dictées par Microsoft, accessibles depuis cette page.
Les tâches que nous allons réaliser seront donc les suivantes :
Dans mon environnement, je disposerai des licences suivantes sur mon utilisateur de test :
1x Microsoft 365 E5
1x Windows 365 Enterprise
1x Copilot pour Microsoft 365
J’ai donc choisi de tester Copilot pour Microsoft 365 sur un poste Windows 365 afin de disposer d’un poste de test entièrement consacré à ce dernier.
Etape I – Gestion des licences :
L’étape d’achat de Copilot n’est décrite ici. J’ai acheté une licence Copilot pour Microsoft 365 via le distributeur CSP TD SYNNEX. Pour rappel, cette licence est disponible en NCE et existe seulement en engagement annuel.
Quelques minutes après l’achat, la licence Copilot pour Microsoft 365 est bien visible sur mon tenant depuis cette page :
Avant d’assigner la licence Copilot pour Microsoft 365 à mon utilisateur de test, voici les licences déjà en place sur son compte 365 :
Continuons avec la mise en place du poste utilisateur de test via Windows 365.
Etape II – Machine de test Windows 365 :
Afin de créer un environnement dédié à Copilot pour Microsoft 365, j’ai provisionné un poste via Windows 365. Le provisionnement se fait via cette page de la console Intune.
Plusieurs articles ont déjà été écrits sur Windows 365 :
Dans mon cas, j’ai choisi la Mise à jour cloud. Connectez-vous à la console Microsoft 365 Apps admin center via cette page, puis activez la fonction Cloud comme ceci :
Attendez quelques minutes afin de voir apparaitre les menus suivants :
Sélectionnez les appareils à déplacer et le canal de mise à jour ciblé :
Rappel Microsoft : Jusqu’à 24 heures peuvent être nécessaires pour que le changement de canal soit effectué par l’appareil, en supposant que les appareils sont en ligne et peuvent se connecter au service.
Nous retournerons sur cette page dans 24 heures pour y constater d’éventuels changements.
Avant :
Après :
Etape V – Exigence d’identifiant Microsoft Entra :
Les utilisateurs doivent avoir des comptes d’ID Microsoft Entra (anciennement Azure Active Directory). Vous pouvez ajouter ou synchroniser des utilisateurs à l’aide de l’Assistant Intégration dans le Centre d’administration Microsoft 365.
Dans mon cas, mon utilisateur est déjà un utilisateur Cloud, et non synchronisé via Entra ID Connect :
Etape VI – Exigence Microsoft OneDrive :
Certaines fonctionnalités de Microsoft Copilot pour Microsoft 365, telles que la restauration de fichiers et la gestion OneDrive, nécessitent que les utilisateurs disposent d’un compte OneDrive. Vous pouvez utiliser le guide de configuration de OneDrive dans la Centre d’administration Microsoft 365 pour activer OneDrive pour vos utilisateurs.
Recherchez le guide concerné via la barre de recherche, puis cliquez dessus pour le démarrer :
Lisez les informations disponibles sur la protection OneDrive, puis cliquez sur Suivant :
Définissez la politique de partage externe à l’entreprise, puis cliquez sur Suivant :
Définissez l’OS cible, puis cliquez sur Suivant :
Choisissez si besoin une méthode de transfert des données, puis cliquez sur Suivant :
Modifiez si besoin les paramètres avancés, puis cliquez sur Suivant :
Préparez la communication à vos utilisateurs, puis cliquer sur Suivant :
Finalisez le guide concerné en cliquant ici :
Constatez le changement de statut du guide précédemment validé :
Par la suite, il sera important que le compte OneDrive des utilisateurs de Copilot pour Microsoft 365 soit déployé. Pour cela, aucune autre solution que de leur laisser ouvrir une première fois leur compte OneDrive :
Etape VII – Exigence Microsoft Outlook :
Microsoft Copilot pour Microsoft 365 fonctionne avec le nouvel Outlook (pour Windows et Mac), actuellement en préversion. Les utilisateurs peuvent basculer vers le nouvel Outlook en sélectionnant Essayer le nouvel Outlook dans leur client Outlook existant.
Vous pouvez utiliser le guide d’installation de Microsoft Teams dans le Centre d’administration Microsoft 365 pour configurer les paramètres populaires de Teams, notamment l’accès externe, l’accès invité, les autorisations de création d’équipe, etc. Copilot dans Teams est disponible sur Windows, Mac, web, Android et iOS.
Recherchez le guide concerné via la barre de recherche, puis cliquez dessus pour le démarrer :
Lisez les informations disponibles sur la configuration Teams, puis cliquez sur Suivant :
Lisez les informations disponibles sur la préparation de Teams, puis cliquez sur Suivant :
Modifiez si besoin la gouvernance et les polices Teams puis cliquez sur Suivant :
Ne pas oubliez d’activer la transcription Teams via cette page afin que Copilot puisse fonctionner en réunion :
Définissez les options Teams, comme par exemple l’accès invité, puis cliquez sur Suivant :
Personnalisez les créations d’équipes Teams, puis cliquez sur Suivant :
Créez si besoin des équipes Teams, puis cliquez sur Suivant :
Définissez les méthodes d’installation des clients Teams, puis cliquez sur Suivant :
Ajoutez si besoin des polices de protection d’application gérées sous Intune, puis cliquez sur Suivant :
Parcourez si besoin les méthodes de résolution de problèmes, puis cliquez sur Suivant :
Préparez la communication à vos utilisateurs, puis cliquer sur Suivant :
Lisez les documentations sur les fonctions annexes de Teams, puis cliquez sur Suivant :
Finalisez le guide concerné en cliquant ici :
Constatez le changement de statut du guide précédemment validé :
Note : Un test dans Teams nous montrera l’activation possible de Copilot via l’exploitation de la Transcription :
Etape IX – Exigence Microsoft Loop :
Pour utiliser Microsoft Copilot pour Microsoft 365 avec Microsoft Loop, la boucle doit être activée sur votre tenant. Microsoft détaille la procédure dans cet article.
Rendez-vous sur Microsoft 365 Apps admin center via la page suivante, puis cliquez sur Créer :
Définissez un nom à votre nouvelle police de configuration, puis cliquez sur Suivant :
Appliquez cette police à tous les utilisateurs du tenant, puis cliquez sur Suivant :
Configurez les 3 polices Loop suivantes, puis cliquez sur Suivant :
Vérifiez la configuration, puis cliquez sur Créer :
Attendez la fin de la création de la police de configuration :
Note : Un test dans Loop nous montrera la bonne activation du service pour notre utilisateur de test :
Etape X – Exigence Microsoft Whiteboard:
Pour utiliser Microsoft Copilot pour Microsoft 365 avec Microsoft Whiteboard, vous devez activer le tableau blanc pour votre tenant. Pour en savoir plus sur le Tableau blanc Microsoft, consultez Gérer l’accès à Microsoft Whiteboard pour votre organization.
Attendez que la nouvelle version soit entièrement téléchargée :
Confirmez la bascule en cliquant ici :
Cliquez sur Continuer :
Cliquez sur Passer :
Utilisez la fonction Copilot pour lui demander de générer un mail :
Observez le résultat, puis cliquez-ici pour l’affiner davantage :
Choisissez le ton et la longueur du mail que vous attendez de la part de Copilot, puis recliquez sur Générer :
Constatez les changements par rapport à la version précédente, puis cliquez sur Conserver :
Après une déconnexion reconnexion de l’utilisateur sur une application Microsoft 365 et un redémarrage de session Windows, le bouton Copilot a fait son apparition dans les différentes applications :
La génération de contenus via Copilot peut alors commencer :
Conclusion
La mise en place du service de Copilot pour Microsoft 365 est assez rapide en soit. Mais une grande importante doit être accordée à deux grands sujets :