Amusez-vous avec MCP & Copilot grâce à Chuck Norris

Microsoft met à disposition un nouveau lab sympa pour tester la création et l’intégration de serveurs Model Context Protocol (MCP) dans Copilot Studio. Voici un exemple concret d’implémentation d’un serveur MCP, interrogeant ici un endpoint public qui renvoie une blague Chuck Norris aléatoire sous forme de JSON, et que l’on peut déployer localement ou sur Azure.

Qu’est-ce que le MCP ?

Pour rappel, le Model Context Protocol (MCP) est un standard ouvert qui permet de connecter simplement des sources de données ou des API à des modèles d’IA.

J’ai déjà publié plusieurs articles à ce sujet sur mon blog ; vous pouvez les retrouver juste ici :

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.

Que propose Microsoft dans ce lab ?

Cette page explique comment tester un serveur MCP en local ou hébergé sur Azure :

Ce guide constitue donc un point de départ idéal pour expérimenter la connexion et l’interaction entre un serveur MCP et Copilot.

L’exercice consiste à configurer un serveur MCP, d’abord sur Azure puis en local, afin de comprendre son fonctionnement et tester ses outils :

La première partie de l’exercice consiste à déployer sur Azure Container Apps pour valider le bon fonctionnement du serveur MCP hébergé.
La seconde partie de l’exercice consiste à le redéployer en local cette fois-ci.
Dans les deux cas, vous expérimentez les actions soit directement au travers de prompts.

Microsoft propose également une vidéo YouTube qui illustre pas à pas la mise en place de ce lab MCP et son intégration dans Copilot Studio. Idéale pour suivre visuellement chaque étape :

Maintenant, il ne nous reste plus qu’à tester tout cela 😎

Etape 0 – Rappel des prérequis :

Pour réaliser l’exercice sur Azure ou en local, il vous faudra dans tous les cas disposer de :

Visual Studio Code
Git
Un compte GitHub
Une licence Microsoft 365 Copilot

Puis, pour un déploiement sur Azure, il vous faudra disposer en plus de :

Un tenant Microsoft
Un abonnement Azure valide

Enfin, pour un déploiement en Local, il vous faudra disposer en plus de :

Commençons par déployer notre serveur MCP de test sur Azure.

Etape I – Test de déploiement sur Azure :

Cliquez sur le bouton suivant pour créer un nouveau repository sur votre compte GitHub :

Nommez le repository, choisissez sa visibilité, puis cliquez sur Créer :

Dans une fenêtre Powershell, lancez la commande suivante pour installer le module Azure Developer CLI (azd) :

winget install microsoft.azd

Exécutez la commande suivante pour télécharger les fichiers du repository en adaptant la variable de votre compte :

git clone https://github.com/{account}/mcsmcp.git

Ouvrez Visual Studio Code et chargez le dossier correspondant à l’archive téléchargée :

Lancez la commande suivante pour vous connecter à votre compte Azure :

azd auth login

Complétez l’authentification via le navigateur Internet de votre choix :

Lancez la commande pour déployer les ressources sur Azure :

azd up

Donnez un nom à votre environnement Azure :

Sélectionnez la souscription Azure à utiliser :

Choisissez la région Azure appropriée :

Patientez quelques minutes pendant le déploiement :

Constatez l’apparition des ressources dans le portail Azure :

Attendez la confirmation de fin de déploiement avec succès :

Rafraîchissez la page des ressources Azure et cliquez sur le Container App déployé :

Vérifiez dans les réplicas que le conteneur de l’application est bien en statut Running :

Retournez sur la page principale pour récupérer l’URL de votre déploiement :

Collez cette URL dans un navigateur en ajoutant /mcp pour vérifier le message d’erreur attendu (preuve que le service tourne) :

Notre environnement Azure est maintenant en place, nous pouvons passer directement à l’étape III afin de déployer notre connecteur MCP dans un nouvel agent sur Copilot Studio.

Etape II – Test de déploiement en local :

Lancez la commande npm install pour installer les dépendances nécessaires du projet :

npm install

Exécutez la commande suivante pour compiler et démarrer le serveur MCP en local :

pm run build && npm run start

Copiez l’URL affichée par le serveur et ouvrez-la dans un navigateur pour vérifier le message d’erreur attendu (preuve que le serveur fonctionne) :

localhost:3000/mcp

Lancez la commande ngrok suivante pour exposer votre serveur MCP local sur Internet :

ngrok http http://localhost:3000

Copiez l’URL publique générée par ngrok :

Ouvrez-la dans un navigateur (en ajoutant /mcp) pour tester le bon fonctionnement du serveur :

Lancez la commande suivante pour démarrer l’outil MCP Inspector :

npx @modelcontextprotocol/inspector

Dans l’interface web de MCP Inspector, collez l’URL publique (ngrok) de votre serveur MCP puis cliquez sur Connecter :

Cliquez sur Lister les outils pour afficher les outils disponibles sur le serveur MCP :

Sélectionnez l’un des outils listés puis lancez-le pour exécuter une action :

Constatez l’apparition d’une blague Chuck Norris renvoyée par le serveur MCP, signe que tout fonctionne correctement :

Notre environnement Local est maintenant en place, nous pouvons passer directement à l’étape III afin de déployer notre connecteur MCP dans un nouvel agent sur Copilot Studio.

Etape III – Création de l’agent dans Copilot Studio :

Rendez-vous dans Copilot Studio pour créer un nouvel agent :

Donnez un nom à votre agent :

Jokester

Ajoutez une description à votre agent :

A humor-focused agent that delivers concise, engaging jokes only upon user request, adapting its style to match the user's tone and preferences. It remains in character, avoids repetition, and filters out offensive content to ensure a consistently appropriate and witty experience.

Définissez les instructions de l’agent :

You are a joke-telling assistant. Your sole purpose is to deliver appropriate, clever, and engaging jokes upon request. Follow these rules:
- Respond only when the user asks for a joke or something related (e.g., "Tell me something funny").
- Match the tone and humor preference of the user based on their input—clean, dark, dry, pun-based, dad jokes, etc.
- Never break character or provide information unrelated to humor.
- Keep jokes concise and clearly formatted.
- Avoid offensive, discriminatory, or NSFW content.
- When unsure about humor preference, default to a clever and universally appropriate joke.
- Do not repeat jokes within the same session.
- Avoid explaining the joke unless explicitly asked.
- Be responsive, witty, and quick.

Ajoutez des prompts suggérés pour guider l’usage :

Cliquez sur Créer pour finaliser la création de l’agent :

Attendez quelques secondes :

Allez dans l’onglet Outils et cliquez sur Ajouter un outil :

Sélectionnez le type Model Context Protocol, puis ajoutez un nouvel outil :

Sélectionnez le type Model Context Protocol pour ajouter un outil MCP :

Renseignez un nom, une description et l’URL publique terminant par /mcp, puis créez sans authentification :

Créez une nouvelle connexion pour ce serveur MCP :

Cliquez sur Créer pour valider la connexion

Cliquez sur Ajouter et configurer pour intégrer l’outil à l’agent :

Constatez l’apparition des outils MCP dans votre connecteur MCP :

Cliquez sur Tester et envoyez un prompt demandant une blague :

Tell me a Chuck Norris joke

Vérifiez la réponse renvoyée par le serveur MCP :

Cliquez sur Publier pour mettre votre agent à disposition :

Confirmez la publication en cliquant à nouveau sur Publier :

Patientez quelques secondes le temps que la publication se termine :

Ouvrez l’onglet Canaux pour activer la mise à disposition sur Teams et Microsoft 365 Copilot :

Cliquez sur Publier à nouveau pour confirmer l’activation :

Patientez quelques secondes le temps que la publication se termine :

Rouvrez Teams / Microsoft 365 Copilot puis cliquez sur le lien suivant :

Dans Microsoft 365 Copilot Chat, cliquez sur Ajouter votre agent :

Testez les prompts suggérés mis à disposition :

Si un message d’erreur concernant du filtrage apparaît :

Retournez dans la configuration pour ajuster la modération de l’agent :

Cliquez de nouveau sur Publier après avoir modifié la modération :

Revenez sur Microsoft 365 Copilot Chat et retestez un prompt :

Vérifiez que la réponse s’affiche correctement :

Testez à nouveau avec d’autres prompts suggérés :

En voyant certaines blagues, je comprends que Copilot ai pu vouloir en filtrer 😂 :

Conclusion

Le Model Context Protocol (MCP) n’est plus une simple curiosité technique : il s’impose comme un standard ouvert pour connecter intelligemment nos IA aux sources de données et services externes.

Avec ce lab proposé par Microsoft, on peut expérimenter très concrètement l’intégration d’un serveur MCP dans Copilot Studio, que ce soit sur Azure ou en local.

Ce qui m’a particulièrement plu, c’est la simplicité du déploiement : quelques commandes suffisent pour tester un serveur, valider son fonctionnement, puis l’exposer directement à un agent Copilot.

Cela ouvre la voie à des scénarios bien plus avancés : connecter des bases de données internes, des outils métiers, ou encore enrichir vos assistants IA avec des fonctionnalités maison.

Testez un Custom MCP sur Copilot

Le protocole MCP continue toujours de gagner en popularité. Au travers de Copilot Studio, Microsoft propose, jour après jour, de plus en plus de connecteurs MCP, disponibles directement sur étagère. Mais qu’en est-il, lorsque le connecteur MCP vers la solution souhaitée n’existe pas encore ? Rassurez-vous, la mise en place d’un serveur MCP personnalisé est tout à fait possible dans Copilot Studio.

Il s’agit du 3ème article parlant du Model Context Protocol (MCP) écrit sur ce blog, dont voici un rappel des deux premiers :

Enfin, un autre article détaille le principe des instructions personnalisées et la mémoire disponibles sur Microsoft 365 Copilot et accessibles juste ici.

Mais qu’est-ce que MCP ?

Le Model Context Protocol (MCP) est un protocole qui permet à des assistants IA de se connecter de façon sécurisée à des sources de données et outils externes… bla bla … 🤣

Mais, si cette notion est nouvelle pour vous, je ne peux vous conseiller que de commencer par regarder cette excellente vidéo :

Comment tester un serveur MCP sur Copilot ?

Il est très simple et très rapide de tester un serveur MCP depuis l’application Desktop de Claude.

Les démonstrations mixant un serveur Custom MCP et Copilot sont encore un peu rares pour le moment, mais elles vont vite devenir légion. Mais, durant mes recherches, je suis tombé sur cet exercice, disponible sur un Bootcamp Copilot créé par Microsoft :

Cette petite démonstration MCP n’est pas révolutionnaire en soi, mais je la trouve bien pensée, car elle est très simple à mettre en place, et elle permet de comprendre comment Copilot va pouvoir se connecter avec les données de test via le serveur MCP.

Que contient cette démonstration ?

Nous allons commencer par déployer un serveur MCP de test servant à la gestion fictive de candidats RH. Le serveur est basé sur du .NET, et s’appuie sur le SDK MCP pour C#. Le serveur fournit des outils permettant de gérer la liste de candidats HR :

Lister les candidats
Rechercher un candidat
Ajouter un candidat
Mettre à jour un candidat
Supprimer un candidat

Une fois le serveur MCP en place, on va à l’intégrer à Microsoft 365 Copilot, via Copilot Studio, afin de gérer la liste de candidats RH via des prompts appelant ces outils MCP.

Aussi je vous propose donc de faire cet exercice ensemble 😎

Etape 0 – Rappel des prérequis :

Pour réaliser cet exercice, il vous faudra disposer des outils suivants sur votre poste :

Une fois ces prérequis installés sur votre poste. Nous allons pouvoir continuer en commençant par installer et configurer notre serveur MCP.

Etape I – Mise en place du serveur MCP :

Commencez par téléchargez l’archive du serveur MCP via ce lien GitHub :

Une fois l’archive ZIP sur votre poste, pensez à débloquer celle-ci via ses propriétés :

Décompressez-la dans un dossier local de votre choix :

Ouvrez Visual Studio Code, puis cliquez sur “Ouvrir un dossier” afin de sélectionner le dossier que vous venez de décompresser :

Prenez un moment pour parcourir la structure du projet.
Vous y trouverez :

un dossier Configuration avec le fichier HRMCPServerConfiguration.cs,
un dossier Data contenant candidates.json,
un dossier Services avec l’interface et l’implémentation CandidateService.cs,
un dossier Tools avec les définitions des outils et modèles (HRTools.cs, Models.cs),
et le fichier Program.cs, point d’entrée du projet.

Ouvrez une fenêtre de terminal intégrée dans Visual Studio Code, puis exécutez la commande suivante :

dotnet run

Copiez l’URL locale qui s’affiche dans le terminal :

http://localhost:47002/

Ouvrez le navigateur internet de votre choix, puis collez l’URL. Vous devriez voir apparaître un message d’erreur au format JSON : c’est le comportement attendu et cela confirme que le serveur est bien démarré.

Ngrok est un outil de tunnellisation qui permet d’exposer de manière sécurisée un serveur local à Internet via une URL publique, sans avoir à configurer manuellement votre réseau ou à ouvrir des ports dans votre pare-feu.

Pour cela, rendez-vous sur le site de Ngrok, puis inscrivez-vous chez eux afin d’avoir un compte gratuit :

Sur leur site, téléchargez l’installateur de Ngrok selon votre OS :

Copiez la commande suivante affichée sous l’installateur pour finaliser la configuration de votre Ngrok :

Depuis votre ordinateur, ouvrez Windows PowerShell, puis lancez la commande précédemment copiée afin de terminer la configuration Ngrok :

Créez un tunnel ngrok sécurisé depuis Internet vers votre serveur local qui écoute sur le port 47002, en générant une URL publique accessible depuis n’importe quel navigateur :

ngrok http http://localhost:47002

Copiez le nom de domaine commençant par https et finissant par ngrok-fre.app. Ne fermez pas cette fenêtre tant que le processus d’enrôlement API n’est pas entièrement fini :

Cliquez sur le lien public affiché par votre tunnel (ngrok / Dev Tunnel) afin de vérifier que l’URL redirige bien vers votre service local.

Constatez l’affichage de la même réponse JSON “d’erreur” que sur localhost : cela confirme que la liaison via le tunnel fonctionne correctement.

Ouvrez une fenêtre PowerShell, lancez la commande suivante afin de télécharger et exécuter le binaire MCP Inspector sans installation globale

npx @modelcontextprotocol/inspector

Patientez quelques secondes : MCP Inspector génère son URL locale et un token d’accès.

MCP ouvre automatiquement le navigateur web, collez l’URL publique de votre serveur MCP ngrok, puis cliquez sur Connecter :

Une fois connecté, cliquez sur le bouton pour lister les outils disponibles exposés par ce serveur MCP.

Sélectionnez un des outils proposés (par exemple list_candidates), puis cliquez ici pour l’exécuter :

Constatez l’apparition des résultats liés aux candidats RH retournés par le serveur MCP.

Le serveur MCP est opérationnel ; poursuivez dans Copilot Studio afin de créer votre agent et consommer les outils exposés par ce serveur.

Etape II – Création de l’agent Copilot :

Ouvrez le portail Microsoft Copilot Studio, puis cliquez ici pour créer un nouvel agent :

Cliquez sur Configurer, renseignez les informations de base, puis cliquez sur Créer :

Nom :

HR Candidate Management

Description :

An AI assistant that helps manage HR candidates using MCP server integration for comprehensive candidate management

Instructions :

You are a helpful HR assistant that specializes in candidate management. You can help users search for candidates, check their availability, get detailed candidate information, and add new 
candidates to the system. 
Always provide clear and helpful information about candidates, including their skills, experience, contact details, and availability status.

Attendez environ 1 minute que la création se termine, sans fermer la page.

Descendez en bas de la page, ajoutez des “Prompts suggérés” en lien avec la gestion des candidats RH , puis sauvegardez :

List all candidates

List all the candidates

Search candidates

Search for candidates with name [NAME_TO_SEARCH]

Add new candidate

Add a candidate with firstname [FIRSTNAME], lastname [LASTNAME], e-mail [EMAIL], role [ROLE], spoken languages [LANGUAGES], and skills [SKILLS]

Votre agent de base est prêt ; vous allez maintenant lui ajouter de la puissance en intégrant le serveur MCP.

Etape III – Connexion entre l’agent et le serveur MCP :

Toujours sur votre agent dans Copilot Studio, ouvrez l’onglet Outils, puis cliquez ici pour ajouter un nouvel outil :

Cliquez ici afin de créer un outil personnalisé :

Sélectionnez Model Context Protocol pour ajouter un serveur MCP :

Nommez le serveur MCP, ajoutez une description, collez l’URL publique générée par votre tunnel ngrok, laissez Authentication de base, puis cliquez sur Créer :

À la création, lancez l’établissement d’une connexion entre votre agent et l’outil MCP :

Cliquez sur Créer pour créer la connexion :

Cliquez ici pour ajouter et configurer l’outil dans l’agent :

Revenez sur la liste des outils, entrez dans l’outil MCP que vous venez d’ajouter en cliquant dessus :

Vérifiez la bonne connexion via la liste des outils exposés par le serveur MCP qui doit se récupérer correctement :

La connexion au serveur MCP est en place, il ne nous reste plus qu’à publier l’agent sur des canaux comme Teams.

Etape IV – Publication de l’agent :

Cliquez sur le bouton de test afin d’envoyer un prompt simple pour vérification :

Constatez l’apparition des résultats retournés par le serveur MCP dans le panneau de test :

Cliquez sur Publier pour publier votre agent :

Confirmez votre choix dans la boîte de dialogue :

Attendez la fin du processus de publication.

Ouvrez l’onglet des Canaux, cliquez sur Teams and Microsoft 365 Copilot, cochez l’option pour rendre l’agent disponible dans Microsoft 365 Copilot, puis cliquez sur Ajouter des canaux :

Patientez pendant l’enregistrement des paramètres du canal :

Revenez à l’agent et cliquez à nouveau sur republier en tenant compte du nouveau canal :

Confirmez votre choix dans la boîte de dialogue :

Votre agent est en ligne, il ne nous reste plus qu’à le tester dans Teams et Microsoft 365 Copilot.

Etape V – Tests dans Teams et Microsoft 365 Copilot :

Toujours sur la page de l’agent créé sur le portail de Copilot Studio, cliquez ici pour ajouter cet agent dans Microsoft 365 :

Cliquez sur Ajouter afin d’ajouter l’agent à votre portail Microsoft 365 Copilot :

Retrouvez l’agent dans la liste de gauche des agents disponibles :

Revenez sur Microsoft Copilot Studio pour ajouter le canal Teams :

Sur Teams, puis cliquez sur ici afin d’ajouter cet agent :

Dans Teams ou Microsoft 365 Copilot, lancez un prompt parmi les prompts suggérés :

Constatez l’apparition du résultat MCP lié au prompt exécuté.

Demandez à l’agent de retrouver un seul candidat via des critères précis, puis validez le résultat MCP affiché :

Demandez la suppression de ce candidat, vérifiez la confirmation :

Ouvrez MCP Inspector pour constater sa disparition de la liste :

Demandez l’ajout d’une caractéristique (par ex. une langue parlée) à un candidat, puis validez la mise à jour retournée par l’agent :

Revenez dans MCP Inspector, puis confirmez que la nouvelle caractéristique apparaît bien pour ce candidat :

Demandez l’ajout d’un nouveau candidat, puis constatez la confirmation :

Vérifiez dans MCP Inspector que l’enregistrement du nouveau candidat a bien été créé :

Demandez l’ajout d’un candidat en joignant un PDF de CV en exemple, puis validez le résultat fourni par l’agent :

Dans MCP Inspector, confirmez l’apparition du candidat associé au fichier PDF précédemment téléversé :

Conclusion

Vous avez mis en place un serveur MCP en local, l’avez exposé en URL publique via un tunnel, l’avez inspecté avec MCP Inspector, puis intégré dans Copilot Studio avant de le publier et de le tester dans Teams / Microsoft 365 Copilot.

À vous maintenant de créer un véritable agent opérationnel capable d’appeler des outils MCP pour gérer vos données directement depuis l’interface Copilot.

Pour aller plus loin, je vous recommande ce tutoriel pratique de Shervin Shaffie, qui montre comment créer un agent prêt pour la production sans écrire une seule ligne de code. Il vous montre comment connecter DocuSign, de la connexion à la publication, étape par étape :

Boostez la mémoire de Copilot

Depuis quelque temps, Microsoft pousse 2 nouveaux concepts de personnalisation de Copilot, qui paraissent similaires quand on les découvre : les Instructions personnalisées et la Mémoire Copilot. Les deux visent à rendre Copilot plus personnel et plus adapté au contexte affin d’apporter des réponses toujours plus pertinentes, et évitent certaines répétitions dans les prompts.

Juste avant cela, je pense qu’il est intéressant de refaire un point rapide sur le RAG qui est aussi employé dans beaucoup d’architectures IA.

Qu’est-ce que le RAG ?

Depuis 2024, je me suis plongé dans ce concept qu’on appelle RAG (Retrieval-Augmented Generation). Grosso modo, c’est comme donner une paire de jumelles à votre LLM : il va chercher des infos actualisées, dans votre propre base de connaissances, avant de générer une réponse.

En pratique, vous envoyez une question, le modèle commence par interroger une base documentaire (vectorielle ou non), puis compile les extraits les plus pertinents pour enrichir sa réponse.

Résultat : une réponse plus fiable, plus contextualisée, et à jour.

Pour mettre cela en place sur votre Copilot, plusieurs chemins sont possibles :

Mais quand on parle de personnalisation dans Copilot, il faut bien distinguer deux concepts qui n’ont pas la même finalité : les Instructions personnalisées et la Mémoire Copilot. On les confond facilement, mais ce sont deux choses bien distinctes.

Qu’est-ce que les instructions personnalisées ?

Quelle que soit l’IA utilisée, ce schéma rappelle les grands principes pour un prompt réussi :

Avec Copilot, les attentes liées à la forme des réponses sont généralement constantes : c’est l’utilisateur qui définit à l’avance la manière dont Copilot doit se comporter.

Grâce aux instructions personnalisées, on peut donc gagner du temps en adaptant le ton et la forme des réponses de Copilot, de manière générale et permanente.

Par exemple :

Réponds toujours de manière concise et en français
Donne-moi systématiquement des exemples techniques liés à Azure
Réponds toujours comme Maître Yoda, dans Star Wars

Comment marchent les instructions personnalisées ?

Voici une comparaison simple, montrant l’impact des instructions personnalisées, quand celui-ci est configuré pour toujours répondre comme Maître Yoda dans Star Wars :

Sans configuration d’instructions personnalisées :

Avec configuration d’instructions personnalisées :

Les instructions personnalisées changent radicalement la façon dont Copilot formule ses réponses. La même question peut donc donner deux réponses très différentes – l’une orientée divertissement, l’autre orientée expertise professionnelle.

Qu’est-ce que la mémoire Copilot ?

Jusqu’ici, Copilot répondait aux questions, mais oubliait cette interaction dans le temps dès que l’on fermait la fenêtre ou que l’on passait à une nouvelle conversation.

Avec la mémoire en plus, Copilot peut maintenant retenir des informations clés sur vous et votre travail et les réutiliser automatiquement dans vos prochaines interactions.

Mais depuis quelque temps, Microsoft a ajouté une nouvelle brique que Microsoft a ajoutée à son écosystème Copilot. En clair, c’est la capacité de Copilot à se souvenir d’éléments importants sur nous ou notre travail, et à les réutiliser automatiquement dans nos futures interactions.

Avec la mémoire, c’est comme un carnet personnel que Copilot garde toujours sous le coude. Grâce à lui, Copilot sait déjà que l’on préfère les listes à puces et que l’on travailles sur ce projet Suisse. En combinant les deux, Copilot devient à la fois plus précis et plus personnel.

Comment marche la mémoire Copilot ?

Voici une comparaison simple, montrant l’impact de la fonction Copilot Memory, quand celui-ci est configuré pour toujours répondre comme Maître Yoda dans Star Wars :

Sans configuration de mémoire Copilot

Avec une configuration de mémoire Copilot :

Comment puis-je configurer la mémoire et les instructions personnalisées dans Copilot ?

L’utilisateur a le contrôle total : tu peux consulter, modifier ou supprimer ce que Copilot retient, et activer ou désactiver ces options à tout moment, tout cela depuis la page d’accueil de Copilot

L’accès aux instructions et à la mémoire Copilot est possible depuis les menus suivants :

Les deux menus sont bien distingués :

Copilot utilisera ces informations dans toutes tes prochaines conversations. Il est même possible de désactiver temporairement la prise en compte des instructions personnalisées :

Du côté de la mémoire Copilot, vous retrouvez ici les deux sections d’information :

Le profil professionnel est une source officielle d’informations issues de votre tenant Microsoft. Ce n’est pas un profil crée dans Copilot, mais plutôt un contexte auquel il a accès via Microsoft Graph, lié à votre identité professionnelle (par exemple via Entra ID).

La mémoire Copilot est construite au fil des échanges pour enrichir le contexte et personnaliser les réponses :

Un bouton pour couper la mémoire à tout moment : Copilot redevient alors sans mémoire persistante :

Chaque entrée dans la mémoire Copilot doit se faire depuis la fenêtre de prompt :

Une liste de la mémoire Copilot est aussi disponible via un prompt :

La mémoire Copilot peut être ajustée : il est possible de l’éditer, de la supprimer ou même de demander à Copilot d’ignorer ce point à l’avenir :

Et voici le résultat d’un prompt après le changement de mémoire :

En plus des instructions globales de Copilot, il est aussi possible de configurer des instructions de rédaction spécifiques dans Outlook.

Lors de chaque demande à Copilot, ce dernier aidera à rédiger un mail (réponse, brouillon, résumé) en respectant ces consignes pour rester cohérent.

En résumé, ces différents paramétrages d’instructions suivent l’approche suivante :

Aspect	Instructions personnalisées (Copilot)	Instructions de rédaction (Outlook)
Portée	Globales – s’appliquent à toutes les apps où Copilot est présent (Word, Excel, Teams, Edge…).	Spécifiques à Outlook et uniquement pour la rédaction d’e-mails.
Contenu	Qui vous êtes (rôle, secteur, contexte) et comment Copilot doit répondre (style, niveau de détail).	Ton de rédaction (formel/informel), longueur (bref/détaillé), style de communication pour les mails.
Objectif	Personnaliser le comportement général de Copilot dans toutes vos conversations.	Harmoniser le style des e-mails générés ou suggérés par Copilot.
Configuration	Via les paramètres Copilot (⚙️) > Instructions personnalisées.	Via Outlook > Copilot > ⚙️ > Instructions de rédaction.
Exemple d’impact	Copilot ajoute des exemples Azure dans ses réponses techniques.	Copilot propose un mail concis et poli, adapté à une réponse client.

Conclusion

En conclusion, donner de la mémoire et des règles claires à Copilot, c’est comme passer d’un stagiaire à un collaborateur expérimenté : il comprend ton style, ton métier et peut t’aider plus vite et plus efficacement.

Les instructions personnalisées permettent de fixer le ton et la forme des réponses, une bonne fois pour toutes, tandis que la mémoire Copilot apprend et s’adapte au fil du temps, en intégrant ton contexte métier et tes préférences.

Pour tirer le meilleur parti de cette personnalisation, je vous conseille de :

Configurer des instructions personnalisées dès maintenant, avec un style adapté à votre usage (technique, concis, fun…).
Activer la mémoire Copilot et de l’ajuster au fil de l’eau pour qu’elle reflète au mieux le contexte.

Testez la fonction COPILOT() dans Excel

Excel a longtemps souffert d’un retard dans l’avancement du développement de Copilot au sein de la suite d’outils Microsoft 365 Copilot, surtout si on le compare à Word et PowerPoint. Pourquoi cela ? Car les tableaux Excel ne sont pas des phrases ou des textes comme aime avoir les LLMs. Ce qui a rendu l’intégration de Copilot plus complexe que celle dans Word (texte linéaire) ou PowerPoint (contenu visuel structuré).

Qui est en charge du développement de Copilot dans Excel, Word, PowerPoint, … ?

Microsoft a mis en place une équipe centrale dédiée à Copilot, appelée Microsoft 365 Copilot Product Group, qui pilote la vision, les modèles d’IA, et les interfaces transversales.

Cette équipe travaille en étroite collaboration avec les équipes produit de chaque application Office, qui adaptent Copilot à leurs spécificités fonctionnelles. sein de Microsoft 365 Apps. Par exemple, l’équipe Excel se concentre sur l’interprétation des tableaux et des formules, tandis que l’équipe PowerPoint travaille sur la génération de slides et de visuels.

L’intégration de Microsoft 365 Copilot dans Excel est donc dépendante de la division Excel au

Pourquoi ce retard de Copilot sur Excel ?

Les modèles de langage (LLMs) comme GPT sont conçus pour comprendre et générer du texte linéaire. Word et PowerPoint s’appuient sur des blocs de texte ou des structures visuelles faciles à interpréter. En revanche, Excel manipule :

Des tableaux
Des formules
Des relations entre cellules
Des modèles financiers ou statistiques

Cette complexité a rendu l’intégration de Copilot plus délicate, nécessitant des avancées spécifiques en compréhension tabulaire et en raisonnement mathématique.

Ce n’est que récemment que Microsoft a commencé à combler ce retard, en introduisant des fonctionnalités plus avancées dans Excel, comme les assistants contextuels via un clic droit, ou tout récemment la fameuse fonction COPILOT() que nous verrons plus loin dans cet article.

Que peut-on faire déjà avec Microsoft 365 Copilot dans Excel ?

Depuis plusieurs mois déjà, Copilot permet d’interroger les données en langage naturel, de générer des formules, de créer des graphiques, et même de détecter des tendances ou des anomalies.

De nombreuses vidéos détaillant différents exemples fleurissent déjà et depuis un peu plus d’un an sur Internet :

Ou encore :

Petit Copilot vs Grand Copilot ?

Dans Excel, comme dans la majorité des outils Microsoft 365, Copilot se manifeste sous plusieurs formes complémentaires qui répondent à des usages distincts :

Le premier, situé dans le bandeau en haut de l’interface, agit comme un assistant global. Il permet de poser des questions en langage naturel sur l’ensemble du fichier, d’analyser des tendances, de générer des formules ou des graphiques, et d’interagir avec les données de manière transversale.

Le second Copilot, accessible via le clic droit sur une cellule ou une sélection, est plus contextuel. Il propose des actions ciblées comme expliquer une formule, reformater une plage de données, ou suggérer des opérations spécifiques sur les valeurs sélectionnées.

Passons maintenant à quelques exemples de prompts simples sur une feuille Excel contenant des données fictives.

Que peut-on prompter avec le Copilot d’Excel ?

A peu près ce que l’on veut ! Mais rien ne dit que Copilot va satisfaire toutes vos demandes…

Analyse de données
- Quels sont les produits les plus vendus ce trimestre ?
- Y a-t-il des anomalies dans les ventes mensuelles ?
- Fais-moi un résumé des performances par région
Création de visualisations
- Crée un graphique comparant les ventes de janvier à mars
- Montre l’évolution des coûts fixes sur les 12 derniers mois
- Génère un tableau croisé dynamique des ventes par catégorie
Formules et calculs
- Écris une formule pour calculer la marge bénéficiaire
  - Explique cette formule : =SI(ET(A2>100;B2<50);\OK\;\NOK)
  - Calcule la moyenne des ventes par trimestre

Voici d’ailleurs quelques exemples de petits prompts réalisés sur une feuille Excel fictive afin de vous donner quelques idées.

Changez le format des nombres de la colonne F en format monétaire (€)

Ajoutez une colonne « Date de Fin » qui calcule automatiquement la date de fin en fonction de la colonne B sur laquelle on ajoute 15 mois

Supprimez la colonne K du tableau

Créez une nouvelle colonne appelée « Marge Directe » et calcule-lui une marge de 5% sur la colonne G.

Appliquez une mise en forme conditionnelle à la colonne « Marge Directe » pour afficher en rouge les valeurs entre 0 et 20 et en orange les valeurs entre 21 et 49

Triez la colonne de marge en ordre décroissant

Ajoutez une colonne avec une fonction RECHERCHEV pour récupérer la région depuis l’onglet Beta

Filtrez la colonne « Statut Vente » pour afficher uniquement les Echoué et En attente

Appliquez une mise en forme conditionnelle pour mettre en gras les clients dont le nom contient le chiffre 1

Cachez toutes les lignes dont le code postal est un nombre impair

Générez un graphique pertinent sur les tendances via l’outil Analyse de données

Créez un tableau croisé dynamique avec en colonne « Ville » et en ligne les « Produit » en filtrant sur les lignes dont la vente est sur le mois d’octobre pour afficher le total des ventes

Intéressons-nous maintenant aux dernières avancées proposées par Microsoft, dont la toute nouvelle fonction COPILOT().

Qu’est-ce que la fonction COPILOT() ?

La fonction COPILOT() fonctionne comme une formule Excel classique. Elle permet d’envoyer un prompt en langage naturel à Copilot, tout en lui fournissant des données contextuelles depuis la feuille Excel. Elle retourne en résultat une réponse générée par l’IA, sans passer par des macros ou scripts externe.

Voici la syntaxe à adopter :

=COPILOT(prompt, [contexte1], [contexte2], ...)

Voici un exemple de cette syntaxe :

=COPILOT("Classifie ces commentaires par sentiment",A2:A20)

Deux remarques intéressantes :

Il est actuellement possible de la combiner avec d’autres fonctions Excel (IF, SWITCH, LAMBDA, etc.)
Actualisation automatique : Le résultat se met à jour si les données référencées changent, comme une formule classique d’Excel.

Comment avoir la commande COPILOT() ?

Certaines limitations sont actuellement en place sur la fonction COPILOT(), encore en préversion :

Elle est disponible uniquement pour les clients commerciaux avec une licence Microsoft 365 Copilot
Elle ne fonctionne donc pas avec les abonnements Personnel ou Famille
Elle est limitée à 100 appels toutes les 10 minutes
Elle ne peut pas accéder à des données externes (web, autres fichiers)

Comment peut-on activer la fonction COPILOT() ?

A l’heure où ces lignes sont écrites, j’ai pu tester la fonction COPILOT() sur l’application Desktop d’Excel, simplement en changeant le canal de mise à jour de mes applications Microsoft 365.

Pour connaître le canal de mise à jour actuellement en place sur votre poste, ouvrez Excel, puis cliquez sur le menu suivant :

L’information du canal de mise à jour de vos applications Microsoft 365 doit s’afficher ici :

Pour basculer sur le canal de mise à jour Beta, ouvrez le Terminal Windows en mode administrateur :

Exécutez la commande suivante afin de forcer Office à passer sur le canal de mise à jour Beta, aussi appelé Insider Fast. C’est le canal le plus avancé, destiné aux tests des fonctionnalités expérimentales avant leur déploiement public :

reg add HKLM\Software\Policies\Microsoft\office\16.0\common\officeupdate /v updatebranch /t REG_SZ /d BetaChannel

Rouvrez l’application Excel sur votre poste, puis cliquez sur le menu suivant :

Constatez l’absence de changement de votre canal de mise à jour :

Lancez une mise à jour immédiate de vos applications Microsoft 365 :

La fenêtre suivante doit alors apparaître, et vous indique que de nouvelles mises à jour sont en cours d’installation :

Attendez quelques minutes, puis fermez cette fenêtre une fois les mises à jour terminées :

Retournez sur votre application Excel afin de constater un changement du canal de mise à jour :

Enfin la commande ci-dessous permet de forcer Excel (et les autres applications Office) à réutiliser le canal de mise à jour Current Channel :

reg add HKLM\Software\Policies\Microsoft\office\16.0\common\officeupdate /v updatebranch /t REG_SZ /d CurrentChannel

Que peut-on en faire actuellement ?

J’ai pris l’exemple classique d’une liste de codes postaux pour laquelle je souhaite retrouver le nom de la ville. J’utilise donc le prompt suivant :

=COPILOT("retrouve la ville en se basant sur le code postal français", A2)

Le système marche bien, mais montre rapidement une limite :

Je décide donc de tester la commande COPILOT() afin d’harmoniser mes valeurs :

=COPILOT("si valeur fait seulement 4 chiffres de long, rajoute un zéro devant, sinon laisse la valeur ", A2)

Cela semble très prometteur :

Enfin, je combine le tout pour retrouver le nom des villes quelle que soit la longueur du code postal :

=COPILOT("retrouve la ville en se basant sur le code postal francais", COPILOT("si valeur fait seulement 4 chiffres de long, rajoute un zéro devant, sinon laisse la valeur ",A2))

Malheureusement, plusieurs limites de la fonction COPILOT(), toujours en préversion, finissent par être atteintes :

Copilot effectue plusieurs erreurs sur le traitement de la donnée

Copilot a exécuté trop de requêtes, et me demande d’attendre pour continuer :

Mais, dans d’autres cas de création de contenu, les choses se passent un peu mieux :

Toujours envie de voir d’autres tests ?

J’ai trouvé cette excellente vidéo, réalisée par Elliott Pierret et disponible sur sa chaîne, qui nous montre justement, au moyen de petits exemples, comment bien comprendre le mécanisme de COPILOT(), mais aussi de pouvoir combiner toujours plus de prompts !

Conclusion

Avec la fonction =COPILOT(), Excel franchit enfin une étape décisive dans l’intégration de l’IA au cœur des feuilles de calcul. Là où auparavant Copilot n’était qu’un assistant “au-dessus” d’Excel, il devient désormais une fonction native, au même titre que RECHERCHEV ou SOMME.

Si vous travaillez déjà avec Microsoft 365 Copilot et que vous êtes prêts à basculer sur le canal Beta, je vous encourage à tester =COPILOT() dès maintenant. Vous verrez par vous-même comment il change la manière d’analyser et d’exploiter vos données.

Et comme toujours, n’hésitez pas à partager vos propres retours, astuces et scénarios d’usage dans les commentaires !

Déployez un serveur MCP dans Azure

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.

GitHub

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 😎

Etape 0 – Rappel des prérequis :

Pour réaliser cet exercice, il vous faudra disposer de :

Un abonnement Azure valide
Un tenant Microsoft
Un modèle c’IA déployé sur Azure OpenAI

Commençons par tester la solution en local.

Etape I – Déploiement du serveur MCP en local :

Avant cela, rendez-vous sur la page Azure OpenAI, puis copiez une des clés d’API :

Copiez également le point de terminaison depuis cette même page :

Accédez au portail Azure AI Foundry, créez un modèle, puis copiez son nom :

Sur votre poste, ouvrez une fenêtre Terminal :

Lancez la commande suivante pour vérifier si Git est installé :

git --version

Si Git n’est pas encore installé, exécutez la commande suivante pour le faire :

winget install --id Git.Git -e --source winget

Attendez la fin de l’installation de Git :

Vérifiez que l’installation de Git s’est bien effectuée :

Lancez la commande suivante pour récupérer le package au format Git depuis mon dépôt GitHub :

git clone https://github.com/jlou07/mcp-intelligent-server.git

Accédez au dossier du package téléchargé :

cd .\mcp-intelligent-server\

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 azd est 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 :

Ajoutez du MCP à votre IA !

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 :

Maintenant, il nous reste plus qu’à tester tout cela 😎

Etape 0 – Rappel des prérequis :

Pour réaliser cet exercice, il vous faudra disposer de :

Un tenant Microsoft
Une souscription Azure valide

Commençons par créer quelques ressources (IA et DB) sur Azure et Entra.

Etape I – Création des ressources Azure :

Connectez-vous au portail Entra Admin Center pour enregistrer une nouvelle application, puis récupérez ensuite l’Application ID et le Tenant ID :

Créez un secret client puis copiez immédiatement sa valeur car elle ne sera plus visible par la suite :

Ouvrez une session Windows PowerShell, puis définissez trois variables d’environnement pour l’App ID, le Directory ID et le Client Secret :

setx AZURE_CLIENT_ID    "xxx"
setx AZURE_TENANT_ID    "yyy"
setx AZURE_CLIENT_SECRET "zzz"

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.

Modèles de chatbot AI .NET !

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

Jordan Matthiesen

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
Traitement de documents
- Ingère des fichiers PDF (stockés dans Data)
- 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 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 :

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

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.

IA : Stockez vos vecteurs dans SQL

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.

pandia.pro

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.

atipik.ch

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 ?

Azure SQL Database a commencé à prendre en charge du stockage des vecteurs lors de l’EAP (Early Adopter Preview) à partir du 21 mai 2024, avant d’être mis en Public Preview le 6 novembre 2024.

Qu’est-ce que le nouveau type de données Vector ?

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.

neowin.net

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 😎💪

Etape 0 – Rappel des prérequis :

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 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

Cela donne l’URL suivante :

https://your-endpoint/computervision/retrieval:vectorizeImage?api-version=2024-02-01&model-version=2023-04-15

Rendez-vous dans l’onglet Headers afin de rajouter en valeur la clef de votre service IA Computer Vision sous la clef Ocp-Apim-Subscription-Key :

Rendez-vous dans l’onglet Body afin de rajouter en RAW l’URL publique d’une image en exemple :

{
    "url": "https://raw.githubusercontent.com/alex-wolf-ps/ai-image-search/refs/heads/azure-sql-vector/wwwroot/images/salad-house.jpg"
}

Cliquez ensuite sur Envoyer, puis changez le format de sortie des vecteurs calculés en RAW :

Copiez tous les vecteurs présents entre les 2 crochets :

Retournez sur Azure Data Studio, puis coller la requête SQL suivante afin de créer 3 enregistrements :

INSERT INTO dbo.demo (id, filename, vectors) VALUES
(1, 'latte.jpg', '[]'),
(2, 'cake.jpg', '[]'),
(3, 'salad.jpg', '[]')

Entre les crochets de la ligne correspondante à l’image, collez les vecteurs précédemment copiés :

Recommencez la même opération de calcul des vecteurs sous Postman pour les 2 autres fichiers :

latte
cake

Cela donne la requête SQL finale suivante :

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

Cela donne l’URL suivante :

https://your-endpoint/computervision/retrieval:vectorizeText?api-version=2024-02-01&model-version=2023-04-15

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.

Faites tourner votre propre IA RAG en local

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é.

Datascientest.com

Comment fonctionne le RAG ?

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.

reglo.ai

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

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 :

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.

Téléchargez l’archive ZIP de l’application via le lien GitHub suivant, qui n’est qu’un fork du dossier original d’Alex :

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 :

Téléchargez à nouveau l’archive ZIP de l’application via le lien GitHub suivant, qui n’est qu’un fork du dossier original d’Alex :

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😎

Promptez votre base de données SQL !

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 😎💪

Etape 0 – Rappel des prérequis :

Afin de tester la mise en place d’une application entre Azure OpenIA et une base de données Azure SQL, nous allons avoir besoin de :

Un tenant Microsoft active
SQL Server Management Studio (SSMS)
Visual Studio Code
.NET 6.0
ngrok (facultatif)

Etape I – Préparation du poste local :

Installez Visual Studio Code ou un éditeur de code similaire :

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 :

Rendez-vous sur un fork de la page GitHub d’Alex Wolf afin de télécharger l’application v1 sous format ZIP :

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 :

dotnet build ".\SchemaLoader.csproj" -c Debug -o .\bin\Debug\net6.

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 :

dotnet build ".\YourOwnData.csproj" -c Debug -o .\bin\Debug\net6.

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à :

Le principe est le même, rendez-vous sur un fork de la page GitHub d’Alex Wolf afin de télécharger l’application v2 sous format ZIP :

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 :

dotnet build ".\DBChatPro.csproj" -c Debug -o .\bin\Debug\net6.

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 :

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.