# Installation

> Installez StackQL sur macOS, Linux, Windows, Docker ou un shell cloud et utilisez son serveur MCP avec Claude Desktop, ChatGPT, Goose et d'autres clients MCP, ou via npx, uvx, pip, Docker et GitHub Actions.

Source: https://stackql.io/fr/installing-stackql

Les instructions d'installation de StackQL sur différentes plateformes sont fournies ici.

**macOS**

## macOS

StackQL est disponible sur macOS via Homebrew et le programme d'installation `pkg` ; les architectures ARM (M1/Apple Silicon) et AMD sont toutes deux prises en charge par un seul programme d'installation multi-architecture.

**Homebrew**

Pour installer StackQL via Homebrew, exécutez la commande suivante dans votre terminal :

```bash
brew install stackql
```

**curl (binaire signé et notarisé)**

Pour installer un binaire exécutable `stackql` signé et notarisé dans le répertoire courant, exécutez la commande suivante dans votre terminal :

```bash
curl -fsSL https://get-stackql.io/install | sh
```

**Téléchargement du paquet**

StackQL est disponible sous la forme d'un programme d'installation `pkg` interactif, signé et notarisé, pour macOS.

[Télécharger le PKG macOS](https://releases.stackql.io/stackql/latest/stackql_darwin_multiarch.pkg)

**Linux**

## Linux

StackQL est disponible pour toutes les architectures Linux.

**curl**

Pour installer un binaire exécutable `stackql` dans le répertoire courant pour votre architecture Linux (amd64 ou arm64), exécutez la commande suivante dans votre terminal :

```bash
curl -fsSL https://get-stackql.io/install | sh
```

**Téléchargement du paquet**

Vous pouvez aussi télécharger les binaires ici :

[Télécharger le ZIP Linux (amd64)](https://releases.stackql.io/stackql/latest/stackql_linux_amd64.zip)
[Télécharger le ZIP Linux (arm64)](https://releases.stackql.io/stackql/latest/stackql_linux_arm64.zip)

**Windows**

## Windows

StackQL est disponible sur Windows via Chocolatey, un script d'installation PowerShell et le programme d'installation MSI. Des builds natifs AMD64 (x64) et ARM64 sont disponibles sous forme de programmes d'installation MSI et d'archives ZIP contenant `stackql.exe`. Le build AMD64 s'exécute aussi sur ARM64 par émulation. Tous les exécutables sont signés avec un certificat de signature de code Authenticode.

**Chocolatey**

Pour installer StackQL via Chocolatey, exécutez la commande suivante dans votre terminal PowerShell ou `cmd` :

```powershell
choco install stackql
```

**Invoke-RestMethod**

Pour installer un exécutable Authenticode dans le répertoire courant, exécutez la commande suivante dans un terminal PowerShell : 

```powershell
Invoke-RestMethod https://get-stackql.io/install | Invoke-Expression
# or
irm https://get-stackql.io/install | iex
```

**Téléchargement MSI/ZIP**

Téléchargez ci-dessous le programme d'installation ou l'exécutable `stackql` signé pour Windows. Un clic sur un bouton de téléchargement sélectionne AMD64 par défaut ; utilisez sa liste déroulante pour choisir AMD64 ou ARM64 natif.

[Télécharger le MSI Windows](https://releases.stackql.io/stackql/latest/stackql_windows_amd64.msi)
[Télécharger le ZIP Windows](https://releases.stackql.io/stackql/latest/stackql_windows_amd64.zip)

**Docker**

## Docker

Les builds de StackQL sont publiés sur [DockerHub](https://hub.docker.com/u/stackql).  

__Docker Hub__  

Pour télécharger l'image de conteneur StackQL, exécutez la commande suivante :

```bash
docker pull stackql/stackql
```

À partir de `v1.0`, l'image est basée sur Ubuntu 26.04 LTS, et une variante avec Python 3.13 préinstallé est publiée avec le suffixe de tag `-python3.13` (alias `-python3`), par exemple :

```bash
docker pull stackql/stackql:latest-python3.13
```

**stackql-deploy**

## `stackql-deploy`

`stackql-deploy` est un framework IaC sans état construit sur StackQL. Pour la documentation complète, consultez la [__documentation de StackQL Deploy__](https://stackql-deploy.io/).

__Linux / macOS__

Télécharge et extrait le dernier binaire `stackql-deploy` en une seule étape. Le programme d'installation détecte votre système d'exploitation et votre architecture (y compris Apple Silicon et Intel via un binaire macOS universel) et récupère automatiquement le bon fichier de version.
```bash
curl -fsSL https://get-stackql-deploy.io/install.sh | sh
```

__Windows__

Télécharge et extrait le dernier binaire `stackql-deploy` dans le répertoire courant.
Le programme d'installation détecte votre plateforme et récupère automatiquement le bon fichier de version.
```powershell
irm https://get-stackql-deploy.io/install.ps1 | iex
```

__cargo__

Si la chaîne d'outils Rust est installée, cette commande compile et installe le binaire directement depuis [__crates.io__](https://crates.io/crates/stackql-deploy).
```bash
cargo install stackql-deploy
```

**Shells cloud**

## Shells cloud

StackQL peut être utilisé directement depuis les shells cloud et les terminaux web intégrés des principales plateformes cloud et de données. L'expérience est fluide, car ces environnements sont préautorisés avec l'identité sous laquelle vous êtes connecté, ce qui évite toute configuration d'authentification distincte.

**AWS**

### AWS Cloud Shell

AWS CloudShell fournit un shell dans le navigateur avec l'AWS CLI préinstallée et authentifiée. Exécuter StackQL dans AWS CloudShell vous permet d'interroger et de gérer des ressources AWS sans étape d'authentification supplémentaire. Pour des instructions détaillées, consultez notre [tutoriel AWS CloudShell](/quick-starts/aws/aws-cloud-shell).

Commencez par télécharger le paquet StackQL :

```bash
curl -fsSL https://get-stackql.io/install/aws | sh
```
Exécutez ensuite le script StackQL pour AWS CloudShell :

```bash
./stackql-aws-cloud-shell.sh
```  

Ce script démarre un shell de commandes StackQL avec vos identifiants AWS CloudShell, ce qui vous permet d'interroger immédiatement des ressources AWS.

**Azure**

### Azure Cloud Shell

Azure Cloud Shell fournit un environnement shell accessible depuis le navigateur, où l'Azure CLI est préauthentifiée avec votre compte Azure. Utiliser StackQL dans Azure Cloud Shell permet d'interroger vos ressources Azure de manière fluide, sans configuration supplémentaire. Pour tous les détails, consultez notre [guide Azure Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-azure-cloud-shell).  

Commencez par télécharger le paquet StackQL :

```bash
curl -fsSL https://get-stackql.io/install/azure | sh
```

Exécutez ensuite le script StackQL pour Azure Cloud Shell :

```bash
./stackql-azure-cloud-shell.sh
```

Ce script configure automatiquement une session StackQL pour utiliser vos identifiants Azure Cloud Shell, ce qui vous permet d'interroger immédiatement vos ressources Azure.

**Google**

### Google Cloud Shell

Google Cloud Shell offre un environnement de développement et d'exploitation avec la Google Cloud CLI déjà authentifiée. Exécuter StackQL dans Google Cloud Shell vous permet d'interroger des ressources GCP avec votre authentification existante. Pour en savoir plus, consultez notre [guide Google Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-google-cloud-shell).  

Commencez par télécharger le paquet StackQL :

```bash
curl -fsSL https://get-stackql.io/install/google | sh
```

Exécutez ensuite le script StackQL pour Google Cloud Shell :

```bash
./stackql-google-cloud-shell.sh
```

Le script configure StackQL pour utiliser vos identifiants Google Cloud Shell, ce qui vous permet d'interroger immédiatement vos ressources GCP avec la syntaxe SQL.

**Databricks**

### Terminal web Databricks

Les espaces de travail Databricks incluent un terminal web qui s'exécute sous l'identité de l'utilisateur connecté. Y exécuter StackQL vous permet d'interroger votre espace de travail avec votre identité Databricks, sans configuration d'authentification distincte. Pour des exemples de requêtes et l'authentification au niveau du compte, consultez notre [guide du terminal web Databricks](/blog/tutorials/stackql-in-databricks-web-terminal).

Commencez par télécharger le paquet StackQL :

```bash
curl -fsSL https://get-stackql.io/install/databricks | sh
```

Exécutez ensuite le script shell StackQL pour Databricks :

```bash
./stackql-databricks-shell.sh
```

Cette commande démarre une session StackQL avec l'identité de votre espace de travail Databricks, ce qui vous permet d'interroger immédiatement des ressources propres à l'espace de travail, comme `databricks_workspace.iam.vw_user_entitlements`. Pour les requêtes au niveau du compte (provisionnement, facturation, IAM du compte), définissez les variables du principal de service OAuth2 Databricks comme décrit dans le guide.

## Utiliser avec des clients MCP

Le serveur MCP StackQL s'exécute localement via stdio : les identifiants des providers restent donc sur votre machine, quel que soit le client utilisé. Choisissez votre client ci-dessous : chaque onglet indique d'abord l'installation depuis l'annuaire ou en un clic, puis la configuration manuelle comme solution de repli. Pour tous les canaux de distribution, y compris `npx`, Python, Docker et la CI, consultez [Installer le serveur MCP](#installing-the-mcp-server).

**Claude Desktop**

### Claude Desktop

  La méthode recommandée pour installer le serveur MCP StackQL dans Claude Desktop passe par l'[Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) (**Settings -> Connectors -> Add -> Browse Connectors**, recherchez **StackQL**) - Claude Desktop sélectionne automatiquement le binaire signé adapté à votre plateforme.  Sinon, des MCP Bundles précompilés (`.mcpb`) sont joints à chaque version de StackQL pour une installation depuis un fichier téléchargé - dans les deux cas, aucune installation séparée de StackQL n'est nécessaire.  Des bundles sont disponibles pour macOS, Windows et Linux.

  Les téléchargements MCPB pour Linux et Windows utilisent **amd64** (x64) par défaut. Utilisez les listes déroulantes pour sélectionner **amd64** ou **arm64**.

  [Télécharger le MCPB macOS](https://releases.stackql.io/stackql/latest/stackql-mcp-darwin-universal.mcpb)
[Télécharger le MCPB Linux](https://releases.stackql.io/stackql/latest/stackql-mcp-linux-x64.mcpb)
[Télécharger le MCPB Windows](https://releases.stackql.io/stackql/latest/stackql-mcp-windows-x64.mcpb)

:::info

Le serveur MCP StackQL est également référencé dans l'[__Official MCP Registry__](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) sous le nom `io.github.stackql/stackql-mcp`.

:::

:::tip

Le bundle est l'une des différentes façons d'exécuter le serveur MCP StackQL.  Consultez [__Utiliser StackQL avec Claude Desktop__](/getting-started/claude-desktop) pour le guide pas à pas complet de Claude Desktop, ou [__Installer le serveur MCP__](#installing-the-mcp-server) pour les options npx, Docker, Python, CI et manuelle.

:::

**ChatGPT**

### ChatGPT et Codex

  StackQL est distribué sous la forme d'un plugin local pour l'application de bureau ChatGPT et Codex CLI. Le plugin exécute le serveur MCP StackQL via stdio sur votre machine : les identifiants des providers ne la quittent donc jamais. Node.js 24.22.1 ou une version ultérieure est requis (22.23.4 ou 26.12.1 sur ces lignes de version) ; le plugin n'a besoin que des modules intégrés de Node.js, télécharge le binaire `stackql` signé à la première utilisation et vérifie son SHA-256.

  **Application de bureau ChatGPT (annuaire de plugins) :**  

  ouvrez l'annuaire de plugins dans l'application de bureau ChatGPT, recherchez **StackQL** et cliquez sur **Install**, puis lancez la configuration du plugin ; le skill `stackql-setup` fourni vous guide pour les identifiants et une première requête. La fiche porte un badge **Desktop only** : le plugin s'installe uniquement depuis l'application de bureau, pas depuis ChatGPT web ou mobile, et ses outils sont disponibles en mode Work, dans les fils qui s'exécutent sur votre ordinateur. Si la fiche n'est pas encore visible dans votre annuaire, installez plutôt le plugin depuis la marketplace du dépôt.

  **Application de bureau ChatGPT (marketplace du dépôt) :**  

  ouvrez **Settings -> Plugins -> Add -> Add from GitHub**, saisissez `stackql/stackql`, puis installez **StackQL** depuis la section **Personal** de l'annuaire de plugins et redémarrez l'application.

  **Codex CLI :**

  ```shell
  codex plugin marketplace add stackql/stackql --sparse .agents/plugins --sparse packaging/openai-plugin
  codex plugin add stackql@stackql
  ```

  Redémarrez l'application de bureau ChatGPT ou Codex, puis essayez : *Utilisez StackQL pour installer le provider GitHub si nécessaire, puis listez les cinq premiers services GitHub.* Les identifiants des providers se placent dans `~/.stackql/.env`, sous les noms de variables d'environnement standard de chaque provider (par exemple `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY`) ; après avoir modifié le fichier, demandez à l'agent d'appeler `reload_credentials`.

  **Sans le plugin :**   

  sous **Settings -> Plugins -> MCPs -> Connect to a custom MCP**, choisissez **STDIO**, définissez la commande sur `npx` et ajoutez les arguments `-y` et `@stackql/mcp-server`. Fournissez les identifiants des providers sous forme de variables d'environnement dans ce formulaire.

:::note

ChatGPT web et mobile ne peuvent pas exécuter un serveur stdio local : le plugin est donc réservé à l'application de bureau et à Codex. Un bug ouvert de l'application de bureau ChatGPT ([openai/codex#38162](https://github.com/openai/codex/issues/38162)) peut masquer les outils MCP locaux dans les sessions **Chat** ; les fils en mode Work, les fils Codex et Codex CLI ne sont pas concernés.

:::

**Goose**

### Goose

  Goose exécute directement les extensions stdio : le lanceur `npx` suffit donc (Node.js 18 ou version ultérieure).

  **Goose Desktop :** cliquez sur le bouton ci-dessous. Goose s'ouvre, affiche la commande qu'il s'apprête à exécuter et vous demande de confirmer, puis ajoute StackQL comme extension.

  Installer dans Goose Desktop

  Le bouton est un lien profond `goose://` ; vous pouvez aussi le coller dans la barre d'adresse de votre navigateur, ou l'ouvrir depuis un terminal avec `open` (macOS), `start` (Windows) ou `xdg-open` (Linux) :

  ```
  goose://extension?cmd=npx&arg=-y&arg=%40stackql%2Fmcp-server&id=stackql&name=StackQL&description=Query%20and%20provision%20cloud%20and%20SaaS%20resources%20with%20SQL
  ```

  **Goose CLI :**

  ```shell
  goose session --with-extension "npx -y @stackql/mcp-server"
  ```

  ou exécutez `goose configure`, choisissez **Add Extension -> Command-line Extension** et saisissez la même commande. Fournissez les identifiants des providers comme variables d'environnement de l'extension lorsque cela vous est demandé.

:::note

Goose a retiré son annuaire d'extensions intégré à l'application au profit de l'[Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql), où StackQL est référencé sous le nom `io.github.stackql/stackql-mcp`. Dès que Goose proposera son import depuis le registre, StackQL y sera visible sans aucune autre action.

:::

## Installer le serveur MCP

Le serveur MCP StackQL permet aux agents IA d'interroger et de provisionner des ressources cloud avec StackQL. Il est distribué par plusieurs canaux - tous exécutent le même serveur, choisissez donc le canal qui correspond à votre client et à vos exigences de confiance. Les options ci-dessous sont classées approximativement par ordre de confiance et de facilité.

### Marketplaces et annuaires

Le serveur est publié dans l'Official MCP Registry sous le nom `io.github.stackql/stackql-mcp` ; les registres de paquets ci-dessous hébergent les artefacts distribuables, et les annuaires en aval reprennent la fiche à partir de là.  

**Registres**

| Registre | Type | Publié via | Fiche | Remarques |
|---|---|---|---|---|
| Official MCP Registry | Registre de métadonnées canonique | CLI `mcp-publisher` + `server.json` | [`modelcontextprotocol.io/search`](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) [`modelcontextprotocol.io/direct`](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.stackql/stackql-mcp) | annonce les 8 paquets (`mcpb x5`, `oci`, `npm`, `pypi`) |
| npm | Registre de paquets | `npm publish` | [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) | lanceur `npx` |
| PyPI | Registre de paquets | `twine upload` | [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) | lanceur `uvx` / `pip` |
| Docker Hub | Registre de conteneurs | `docker buildx --push` | [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) | multi-architecture `amd64` + `arm64` |
| GitHub Actions Marketplace | Marketplace CI (action `setup-stackql-mcp`) | Dépôt public + version + fiche marketplace | [`setup-stackql-mcp-server`](https://github.com/marketplace/actions/setup-stackql-mcp-server) | Éditeur vérifié ; [`stackql/setup-stackql-mcp`](https://github.com/stackql/setup-stackql-mcp) |

**Annuaires**

Fiches dans les annuaires et les agrégateurs, classées approximativement par ordre d'importance pour la découverte :

| Annuaire | Type | Fiche |
|---|---|---|
| __Anthropic Connector Directory__ | Annuaire intégré à l'application Claude Desktop | [claude.ai/directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) |
| __OpenAI Plugin Directory__ | Annuaire intégré à l'application de bureau ChatGPT (bureau uniquement) | recherchez **StackQL** dans l'application de bureau ChatGPT ; consultez [ChatGPT et Codex](#using-with-mcp-clients) |
| __Cursor Directory__ | Annuaire d'un client IDE | [cursor.directory](https://cursor.directory/plugins/stackql-mcp-server) |
| __mcp.so__ | Plus grand agrégateur | [mcp.so](https://mcp.so/server/stackql/stackql) |
| __PulseMCP__ | Découverte, soutien du registre | [pulsemcp](https://www.pulsemcp.com/servers/stackql) |
| __Glama.ai MCP__ | Marketplace avec recherche | [glama.ai](https://glama.ai/mcp/servers/stackql/stackql) |
| __mcpmarket.com__ | Agrégateur | [mcpmarket](https://mcpmarket.com/server/stackql) |
| __mcpservers.org__ | Site de type awesome-list | [mcpservers.org](https://mcpservers.org/servers/stackql-mcp-server) |

### Bundle `.mcpb` précompilé

**Quand l'utiliser :** Claude Desktop sans accès au Connector Directory, ou lorsque vous voulez épingler une version précise ou vérifier vous-même les sommes de contrôle avant l'installation.  Pour la plupart des utilisateurs de Claude Desktop, l'[Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) est la méthode d'installation recommandée.

Un MCP Bundle précompilé est joint à chaque version de StackQL pour chaque plateforme :

```
https://releases.stackql.io/stackql/latest/stackql-mcp-<platform>.mcpb
```

où `<platform>` vaut `darwin-universal`, `windows-x64` (AMD64), `windows-arm64`, `linux-x64` ou `linux-arm64`. Les boutons de téléchargement de chaque plateforme se trouvent dans l'onglet **Claude Desktop** sous [Utiliser avec des clients MCP](#using-with-mcp-clients). Chaque bundle a une somme de contrôle `.sha256` correspondante sur la [page de la version](https://github.com/stackql/stackql/releases/latest). Vérifiez-la, puis installez le bundle via **Settings -> Extensions** dans Claude Desktop :

```bash
shasum -a 256 -c stackql-mcp-darwin-universal.mcpb.sha256
```

Consultez [Utiliser StackQL avec Claude Desktop](/getting-started/claude-desktop#install-from-a-downloaded-bundle) pour le guide pas à pas complet.

### Configuration manuelle de `claude_desktop_config.json`

**Quand l'utiliser :** vous avez déjà le binaire `stackql` dans votre PATH et utilisez Claude Desktop ou tout autre client MCP stdio.

```json
{
  "mcpServers": {
    "stackql": {
      "command": "stackql",
      "args": [
        "mcp",
        "--mcp.server.type=stdio",
        "--approot", "/Users/you/.stackql",
        "--mcp.config", "{\"server\": {\"audit\": {\"disabled\": true}}}"
      ]
    }
  }
}
```

Les trois arguments sont indispensables :

- `--mcp.server.type=stdio` sélectionne le transport stdio qu'utilisent les clients intégrés aux éditeurs.
- `--approot` fait pointer le cache des providers vers un répertoire accessible en écriture. Les clients MCP peuvent lancer le serveur avec `/` comme répertoire de travail, qui n'est pas accessible en écriture.
- `--mcp.config '{"server": {"audit": {"disabled": true}}}'` désactive le journal d'audit, dont le répertoire par défaut est sinon le répertoire de travail (éventuellement non accessible en écriture).

Ajoutez les identifiants des providers avec un bloc `"env"` et ajustez le contrat de sécurité avec `"mode"` - consultez [Modes du serveur](/command-line-usage/mcp#server-modes).

### `npx` (sans installation)

**Quand l'utiliser :** tout environnement Node, lorsque vous ne voulez pas d'installation globale de StackQL.

```json
{ "mcpServers": { "stackql": { "command": "npx", "args": ["-y", "@stackql/mcp-server"] } } }
```

Le lanceur [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) télécharge le binaire `stackql` signé au premier lancement, vérifie son SHA-256 et le met en cache pour les lancements suivants.

### `uvx` / `pip` (Python)

**Quand l'utiliser :** un environnement Python - le même lanceur, empaqueté pour Python, qui partage le cache de binaires alimenté par le lanceur npx.

```json
{ "mcpServers": { "stackql": { "command": "uvx", "args": ["stackql-mcp-server"] } } }
```

Ou installez-le dans l'environnement courant avec `pip install stackql-mcp-server` (Python 3.9+). Le paquet est [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) sur PyPI.

### Docker

**Quand l'utiliser :** un runtime conteneurisé ou isolé d'une autre manière. L'image est multi-architecture (amd64 et arm64).

```bash
docker run -i --rm stackql/stackql-mcp
```

Sous forme de configuration client :

```json
{ "mcpServers": { "stackql": { "command": "docker", "args": ["run", "-i", "--rm", "stackql/stackql-mcp"] } } }
```

L'image est [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) sur Docker Hub.

### CI et workflows agentiques (GitHub Actions)

**Quand l'utiliser :** exécuter le serveur dans un job GitHub Actions pour qu'un agent puisse interroger votre cloud - et, si vous l'autorisez, agir dessus - dans le cadre de la CI.

[`stackql/setup-stackql-mcp@v1`](https://github.com/marketplace/actions/setup-stackql-mcp-server) installe le binaire et écrit une configuration MCP (en mode `read_only` par défaut). Transmettez cette configuration à [`anthropics/claude-code-action`](https://github.com/anthropics/claude-code-action) via `claude_args` :

```yaml
- id: stackql
  uses: stackql/setup-stackql-mcp@v1
  with:
    auth: '{"github":{"type":"null_auth"}}'

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    prompt: |
      Using stackql, list the public repositories in the stackql org and
      summarise them as a markdown table.
    claude_args: |
      --mcp-config ${{ steps.stackql.outputs.mcp-config-file }}
      --allowedTools 'mcp__stackql__*'
```

Consultez le [README de l'action](https://github.com/stackql/setup-stackql-mcp) pour d'autres recettes agentiques (audits cloud, estimations de coûts, etc.).

### MCP embarqué

**Quand l'utiliser :** vous développez une application agentique et voulez embarquer le serveur MCP dans votre propre binaire - pas de `npx`, pas d'installation séparée, pas de dépendance à l'exécution.

Des bibliothèques natives lancent le binaire `stackql` signé via stdio derrière le client du SDK MCP officiel de chaque langage : votre application obtient ainsi la même interface SQL gouvernée vers chaque provider du registre. Chaque bibliothèque utilise `read_only` par défaut - le passage à un mode autorisant l'écriture est toujours explicite - et peut soit télécharger et vérifier le binaire au premier lancement, soit l'embarquer dans votre build pour obtenir un exécutable unique et autonome. L'API complète de chaque langage figure dans la [référence du MCP embarqué](/mcp/embedded).

**Rust**

La crate `stackql-mcp` lance le binaire derrière un client `rmcp`. La fonctionnalité `sidecar`, activée par défaut, télécharge et vérifie le binaire au premier lancement ; la fonctionnalité `vendored` l'embarque avec `include_bytes!` pour obtenir un binaire unique et autonome. MSRV Rust 1.88.

```toml
# Cargo.toml
stackql-mcp = "0.1"
```

```rust
use stackql_mcp::{Mode, StackqlMcp};

let server = StackqlMcp::builder()
    .mode(Mode::ReadOnly)
    .start()
    .await?;
let tools = server.list_all_tools().await?;
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-rs)
[Voir sur crates.io](https://crates.io/crates/stackql-mcp)

Référence complète : [MCP embarqué : Rust](/mcp/embedded/rust).

**Go**

La bibliothèque `stackql-mcp-go` lance le binaire derrière le client du SDK MCP officiel pour Go. Embarquez le binaire avec `go:embed` pour obtenir un binaire unique et autonome, ou laissez la bibliothèque le télécharger et le vérifier au premier lancement. Démarre en mode `read_only` par défaut.

```bash
go get github.com/stackql/stackql-mcp-go
```

```go
import (
    "context"
    stackqlmcp "github.com/stackql/stackql-mcp-go/embed"
)

client, err := stackqlmcp.StartServer(ctx, stackqlmcp.Options{
    Binary: StackqlMCPBinary(),
})
defer client.Close()
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-go)
[Voir sur pkg.go.dev](https://pkg.go.dev/github.com/stackql/stackql-mcp-go)

Référence complète : [MCP embarqué : Go](/mcp/embedded/go).

**Kotlin / JVM**

La bibliothèque `io.stackql:stackql-mcp` lance le binaire derrière le client du SDK MCP officiel pour Kotlin, et un plugin Gradle associé intègre le même lancement à un build. Nécessite JDK 17 et Kotlin 2.x.

```kotlin
dependencies {
    implementation("io.stackql:stackql-mcp:0.1.0")
}
```

```kotlin
import io.stackql.mcp.Mode
import io.stackql.mcp.StackqlMcp

val server = StackqlMcp.builder().mode(Mode.ReadOnly).start()
server.use {
    val tools = server.client.listTools().tools
}
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-kotlin)

Référence complète : [MCP embarqué : Kotlin / JVM](/mcp/embedded/kotlin).

**.NET**

Le paquet `StackQL.Mcp` lance le binaire derrière le client du SDK MCP officiel pour C#. Sidecar par défaut, ou embarquez le bundle comme ressource de build pour obtenir un exécutable autonome. Nécessite .NET 8 ou version ultérieure.

```bash
dotnet add package StackQL.Mcp
```

```csharp
using StackQL.Mcp;

await using var server = await StackqlMcp.CreateBuilder()
    .WithMode(StackqlMode.ReadOnly)
    .StartAsync();

var tools = await server.ListToolsAsync();
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-dotnet)

Référence complète : [MCP embarqué : .NET / C#](/mcp/embedded/dotnet).

**Gleam**

La bibliothèque `stackql_mcp` cible le runtime Erlang/BEAM et expose le serveur comme processus enfant OTP via `child_spec()` : il peut ainsi s'insérer dans votre propre arbre de supervision. Démarre en mode `read_only` par défaut.

```bash
gleam add stackql_mcp
```

```gleam
import envoy
import stackql_mcp

let assert Ok(server) =
  stackql_mcp.start(
    config: stackql_mcp.default_config(),
    home: "/home/u", os: "linux", arch: "x86_64",
    getenv: envoy.get,
  )
let assert Ok(tools) = stackql_mcp.list_tools(server)
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-gleam)

Référence complète : [MCP embarqué : Gleam](/mcp/embedded/gleam).

**Swift**

Le paquet `stackql-mcp-swift` lance le binaire derrière le client du SDK MCP officiel pour Swift. Le binaire `darwin-universal` est signé avec un Developer ID et notarisé par Apple : vous pouvez donc l'inclure dans une `.app` signée et conserver la validité de la notarisation de l'application. Nécessite macOS 13+ et Swift 6.1 (Xcode 16.3+).

```swift
// Package.swift
.package(url: "https://github.com/stackql/stackql-mcp-swift.git", from: "0.1.0")
```

```swift
import StackQLMCP

var options = Options()
options.mode = .readOnly

let server = try await StackQLServer.start(options)
let tools = try await server.listToolNames()
await server.stop()
```

[Voir sur GitHub](https://github.com/stackql/stackql-mcp-swift)

Référence complète : [MCP embarqué : Swift](/mcp/embedded/swift).

### Modèle de confiance

Les mêmes propriétés de sécurité s'appliquent à tous les canaux :

- Le binaire `stackql` embarqué est signé Authenticode (Windows) et notarisé par Apple (macOS).
- Chaque bundle `.mcpb` est accompagné d'une somme de contrôle SHA-256 publiée sur la page de la version.
- Les lanceurs `npx` et `uvx` vérifient le SHA-256 du binaire téléchargé avant la première utilisation.
- L'entrée du [MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) atteste les empreintes de chaque plateforme.

## Utiliser GitHub Actions

Des [actions GitHub StackQL](https://github.com/stackql/stackql-actions-demo) sont disponibles pour vos workflows GitHub Actions. Les actions suivantes sont disponibles :

**stackql-deploy**

### `stackql-deploy`

Déployez ou testez des stacks d'infrastructure avec StackQL directement depuis vos workflows GitHub. Cette action permet des workflows d'infrastructure as code (IaC) avec une syntaxe proche de SQL, pour définir, déployer et gérer des ressources cloud de plusieurs providers dans un seul workflow.  

[Voir sur GitHub Marketplace](https://github.com/marketplace/actions/stackql-deploy)
[Voir sur GitHub](https://github.com/stackql/stackql-deploy-action)

__Exemple d'utilisation__

```yaml
...
jobs:
  stackql-actions-test:
    name: StackQL Actions Test
    runs-on: ubuntu-latest
    env:
      GOOGLE_CREDENTIALS: ${{ secrets.GOOGLE_CREDENTIALS }} # add additional cloud provider creds here as needed

    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Deploy a Stack
        uses: stackql/stackql-deploy-action@v2
        with:
          command: 'build'
          stack_dir: 'examples/k8s-the-hard-way'
          stack_env: 'dev'
          env_vars: |
            GOOGLE_PROJECT=stackql-k8s-the-hard-way-demo
            GOOGLE_REGION=australia-southeast1
```

**setup-stackql**

### `setup-stackql`

Configurez StackQL dans votre workflow GitHub Actions.  

[Voir sur GitHub Marketplace](https://github.com/marketplace/actions/setup-stackql)
[Voir sur GitHub](https://github.com/stackql/setup-stackql)

__Exemple d'utilisation__

```yaml
- name: setup StackQL
  uses: stackql/setup-stackql@v2
  with:
    use_wrapper: true

- name: Use GitHub Provider
  run: |
    stackql exec -i ./examples/github-example.iql
  env: 
    STACKQL_GITHUB_USERNAME: ${{  secrets.STACKQL_GITHUB_USERNAME }}
    STACKQL_GITHUB_PASSWORD: ${{  secrets.STACKQL_GITHUB_PASSWORD }}
```

**setup-stackql-mcp**

### `setup-stackql-mcp`

Installez le serveur MCP StackQL dans votre workflow GitHub Actions.  L'action installe le binaire signé et écrit une configuration `mcpServers` (en mode `read_only` par défaut) qu'une étape agentique telle que `anthropics/claude-code-action` consomme via `claude_args`.

[Voir sur GitHub Marketplace](https://github.com/marketplace/actions/setup-stackql-mcp-server)
[Voir sur GitHub](https://github.com/stackql/setup-stackql-mcp)

__Exemple d'utilisation__

```yaml
- id: stackql
  uses: stackql/setup-stackql-mcp@v1
  with:
    auth: '{"github":{"type":"null_auth"}}'

- uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    prompt: |
      Using stackql, list the public repositories in the stackql org and
      summarise them as a markdown table.
    claude_args: |
      --mcp-config ${{ steps.stackql.outputs.mcp-config-file }}
      --allowedTools 'mcp__stackql__*'
```

**stackql-exec**

### `stackql-exec`

Exécutez des commandes StackQL dans votre workflow GitHub Actions.  Les requêtes peuvent être fournies en ligne ou depuis un fichier du dépôt.  

[Voir sur GitHub Marketplace](https://github.com/marketplace/actions/stackql-exec)
[Voir sur GitHub](https://github.com/stackql/stackql-exec)

__Exemple d'utilisation__

```yaml
- name: exec github example
  uses: stackql/stackql-exec@v2
  with:
    query: |
      select total_private_repos
      from github.orgs.orgs
      where org = 'stackql'"
  env: 
    STACKQL_GITHUB_USERNAME: ${{  secrets.STACKQL_GITHUB_USERNAME }}
    STACKQL_GITHUB_PASSWORD: ${{  secrets.STACKQL_GITHUB_PASSWORD }}
```

**stackql-assert**

### `stackql-assert`

Exécutez des tests unitaires dans votre workflow GitHub Actions (pour des contrôles d'assurance, de gouvernance ou de sécurité cloud).  

[Voir sur GitHub Marketplace](https://github.com/marketplace/actions/stackql-assert)
[Voir sur GitHub](https://github.com/stackql/stackql-assert)

__Exemple d'utilisation__

```yaml
- name: Use test query string and expected rows
  uses: stackql/stackql-assert@v2
  with:
    test_query: |
        SELECT name
        FROM google.compute.instances 
        WHERE project = 'stackql-demo' AND zone = 'australia-southeast1-a' AND name = 'stackql-demo-001';
    expected_rows: 1
  env: 
    GOOGLE_CREDENTIALS: ${{ secrets.GOOGLE_CREDENTIALS }}
```

## Autres bibliothèques

StackQL propose plusieurs méthodes d'intégration qui permettent de l'utiliser dans différents langages de programmation et environnements. Ces bibliothèques étendent les fonctionnalités de StackQL et facilitent l'intégration de l'interrogation et de la gestion des ressources cloud dans vos applications et workflows existants.  

**pystackql**

### Paquet Python `pystackql`

Wrapper Python pour utiliser StackQL dans vos programmes Python. Le paquet `pystackql` est disponible sur [__PyPi__](https://pypi.org/project/pystackql/) ; la documentation du paquet `pystackql` est disponible sur [__Read the Docs__](https://pystackql.readthedocs.io/en/latest/). Pour installer le paquet `pystackql`, exécutez la commande suivante :

```bash
pip install pystackql
```

L'exemple suivant montre le paquet `pystackql` utilisé avec `pandas` pour exécuter des requêtes StackQL et renvoyer les résultats dans un `pandas.DataFrame` :

```python
from pystackql import StackQL
import pandas as pd
region = "ap-southeast-2"
stackql = StackQL()

query = """
SELECT instance_type, COUNT(*) as num_instances
FROM aws.ec2.instances
WHERE region = '%s'
GROUP BY instance_type
""" % (region)

res = stackql.execute(query)
df = pd.read_json(res)
print(df)
```