Exposer PowerShell Universal comme serveur MCP pour l’intégration de GitHub Copilot

GitHub Copilot est un assistant IA qui peut s’exécuter dans un éditeur comme Visual Studio Code. Il offre la complétion de code ainsi que des fonctions de clavardage pour analyser et générer du code. GitHub Copilot prend aussi en charge le mode Agent, qui permet de communiquer avec d’autres outils pour effectuer des actions en votre nom. Dans cet article, nous verrons comment exposer PowerShell Universal comme outil pour que GitHub Copilot puisse exécuter des actions.

Model Context Protocol (MCP)

Le Model Context Protocol, ou MCP, est une norme pour exposer des outils à des agents IA comme Copilot. Semblable à des normes comme OpenAPI ou le Language Server Protocol dans Visual Studio Code, cette norme utilise des objets JSON et des points de terminaison pour décrire un outil à un agent IA. En fournissant les entrées et sorties attendues ainsi que des descriptions de l’outil, les modèles IA peuvent décider s’ils doivent l’utiliser et comment l’utiliser.

Les serveurs MCP deviennent de plus en plus courants dans les piles logicielles pour offrir à l’IA des façons simples d’interagir avec elles. PowerShell Universal ne prend pas encore MCP en charge directement, mais nous pouvons utiliser l’implémentation OpenAPI existante et un projet open source pour héberger un serveur proxy MCP. Ce serveur traduit la spécification OpenAPI en spécification MCP, puis transmet les requêtes MCP aux API correspondantes.

PowerShell Universal et OpenAPI

D’abord, nous devons définir une API et une documentation d’API que le proxy MCP pourra consommer. Dans PowerShell Universal, nous créerons quelques API pour retourner et démarrer des processus. Ces API sont simples à implémenter, mais elles utilisent quelques techniques PSU pour fournir de l’information au moteur de génération de documentation OpenAPI de la plateforme. Nous indiquons les types de sortie des points de terminaison ainsi qu’une description pour chacun, que le LLM pourra analyser.

New-PSUEndpoint -Url "/process" -Description "Gets a list of processes running on the PowerShell Universal server." -Method @('GET') -Endpoint {
    <#
.OUTPUTS
200:
  Description: An array of process information.
  Content:
      application/json: ProcessInfo[]

400:
  Description: Invalid input
#>
    param()

    Get-Process | Select-Object Name, Id
} -Documentation "Agent Docs"

New-PSUEndpoint -Url "/process/:name" -Description "Starts a process on the PowerShell Universal server." -Endpoint {
    param(
        [Parameter(Mandatory, HelpMessage = "The file name of the process to start.")]
        $Name
    )

    Start-Process $Name -PassThru | Select-Object Name, Id
} -Documentation "Agent Docs"

Nous devons aussi créer un document d’API pour ces points de terminaison, qui définit également une classe avec la structure de notre sortie.

New-PSUEndpointDocumentation -Name "Agent Docs" -Definition {
    [Documentation()]
    class ProcessInfo {
        [string]$Name
        [string]$Id
    }
} -Url "/agent-docs" -ContactName "Adam Driscoll" -Version "1.0.0" -LicenseName "MIT"

Après avoir défini les points de terminaison et le document, nous pouvons consulter la documentation à http://localhost:5000/swagger/index.html?urls.primaryName=Agent%20Docs.

De plus, une spécification OpenAPI JSON est créée.

{
  "openapi": "3.0.4",
  "info": {
    "title": "Agent Docs",
    "contact": {
      "name": "Adam Driscoll"
    },
    "license": {
      "name": "MIT"
    },
    "version": "1.0.0"
  },
  "servers": [
    {
      "url": "http://localhost:5000"
    }
  ],
  "paths": {
    "/process": {
      "get": {
        "summary": "",
        "description": "Gets a list of processes running on the PowerShell Universal server.",
        "requestBody": {
          "description": "Error processing input types. Cannot perform runtime binding on a null reference",
          "content": { }
        },
        "responses": {
          "200": {
            "description": "An array of process information.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/ProcessInfo"
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          }
        }
      }
    },
    "/process/{name}": { }
  },
  "components": {
    "schemas": {
      "ProcessInfo": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "nullable": true
          },
          "id": {
            "type": "string",
            "nullable": true
          }
        },
        "additionalProperties": false
      }
    },
    "securitySchemes": {
      "Bearer": {
        "type": "http",
        "description": "App Token for accessing the API",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      }
    }
  },
  "security": [
    {
      "Bearer": [ ]
    }
  ],
  "tags": [
    {
      "name": "default"
    }
  ]
}

Les LLM sont très bons pour analyser des schémas comme celui-ci, mais nous pouvons encore simplifier en plaçant un proxy MCP devant la documentation d’API, pour que des outils comme GitHub Copilot découvrent facilement les outils.

Proxy MCP

Nous utiliserons le paquet npm openapi-mcp-generator pour générer un serveur proxy MCP pour notre API. Node.js doit être installé. Pour installer le paquet, utilisez la commande suivante.

npm install -g openapi-mcp-generator

Ensuite, nous devons générer le proxy du serveur MCP à partir de notre API. Cela produit des fichiers TypeScript qui peuvent ensuite être transpilés et exécutés dans Node.js. La commande suivante lit la documentation OpenAPI, puis compile et démarre le serveur MCP.

openapi-mcp-generator --input http://localhost:5000/agent-docs --output .\mcp --base-url http://localhost:5000 --transport web
cd .\mcp
npm i
npm run build
npm run start:web

GitHub Copilot

Maintenant que nos API PowerShell Universal sont définies et que notre serveur proxy MCP tourne, nous pouvons configurer GitHub Copilot. L’extension doit être installée avant de continuer. Dans VS Code, appuyez sur Ctrl+Shift+P et cherchez MCP: Add Server....

Sélectionnez l’option HTTP et saisissez l’URL du serveur MCP. Vous aurez besoin de la route /sse. L’URL complète, par défaut, est http://localhost:3000/sse. Nommez le serveur comme vous le souhaitez.

Le contenu résultant de settings.json ressemblera à ceci.

"mcp": {
    "servers": {
        "PSU": {
            "url": "http://localhost:3000/sse"
        }
    }
}

Utiliser l’outil d’agent IA PowerShell Universal

Une fois tout configuré, nous pouvons utiliser notre outil d’agent IA. Cliquez sur l’icône Copilot et ouvrez un nouveau clavardage.

Dans la fenêtre de clavardage, vous pouvez demander à Copilot, par exemple: Can you please list all the processes as an array of strings in a new PowerShell script? Copilot appellera notre outil PSU, récupérera la liste des processus, puis générera un script PowerShell dans VS Code.

Comme nous avons aussi un point de terminaison pour démarrer des processus, vous pouvez aussi demander à Copilot de le faire avec une phrase comme: Can you start a new process in PowerShell Universal named calc? Cela lancera le processus calc.exe, car le point de terminaison PSU sera appelé avec cet argument.

Conclusion

Dans cet article, nous avons vu comment créer un serveur proxy MCP pour PowerShell Universal afin de l’appeler depuis GitHub Copilot. Comme MCP est un protocole standard, vous pourriez aussi intégrer le serveur PSU à d’autres agents LLM.

Prêt à construire? Téléchargez PowerShell Universal.