# Installation

> Installieren Sie StackQL auf macOS, Linux, Windows, Docker oder in einer Cloud-Shell und verwenden Sie den StackQL MCP-Server aus Claude Desktop, ChatGPT, Goose und anderen MCP-Clients oder über npx, uvx, pip, Docker und GitHub Actions.

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

Hier finden Sie Anleitungen zur Installation von StackQL auf verschiedenen Plattformen.

**macOS**

## macOS

StackQL ist auf macOS über Homebrew und den `pkg`-Installer verfügbar; sowohl ARM- (M1/Apple Silicon) als auch AMD-Architekturen werden mit einem einzigen Multi-Arch-Installer unterstützt.

**Homebrew**

Führen Sie zur Installation über Homebrew den folgenden Befehl in Ihrem Terminal aus:

```bash
brew install stackql
```

**curl (signierte und notarisierte Binärdatei)**

Um eine signierte und notarisierte ausführbare `stackql`-Binärdatei im aktuellen Verzeichnis zu installieren, führen Sie den folgenden Befehl in Ihrem Terminal aus:

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

**Paket-Download**

StackQL ist als signierter und notarisierter, interaktiver `pkg`-Installer für macOS verfügbar.

[macOS-PKG herunterladen](https://releases.stackql.io/stackql/latest/stackql_darwin_multiarch.pkg)

**Linux**

## Linux

StackQL ist für alle Linux-Architekturen verfügbar.

**curl**

Um eine ausführbare `stackql`-Binärdatei für Ihre Linux-Architektur (amd64 oder arm64) im aktuellen Verzeichnis zu installieren, führen Sie den folgenden Befehl in Ihrem Terminal aus:

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

**Paket-Download**

Alternativ können Sie die Binärdateien hier herunterladen:

[Linux-ZIP (amd64) herunterladen](https://releases.stackql.io/stackql/latest/stackql_linux_amd64.zip)
[Linux-ZIP (arm64) herunterladen](https://releases.stackql.io/stackql/latest/stackql_linux_arm64.zip)

**Windows**

## Windows

StackQL ist auf Windows über Chocolatey, ein PowerShell-Installationsskript und den MSI-Installer verfügbar. Native AMD64- (x64) und ARM64-Builds sind als MSI-Installer und als ZIP-Archive mit `stackql.exe` verfügbar. Der AMD64-Build läuft über Emulation auch auf ARM64. Alle ausführbaren Dateien sind mit einem Authenticode-Codesignaturzertifikat signiert.

**Chocolatey**

Führen Sie zur Installation über Chocolatey den folgenden Befehl in Ihrem PowerShell- oder `cmd`-Terminal aus:

```powershell
choco install stackql
```

**Invoke-RestMethod**

Um eine mit Authenticode signierte ausführbare Datei im aktuellen Verzeichnis zu installieren, führen Sie Folgendes in einem PowerShell-Terminal aus: 

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

**MSI/ZIP-Download**

Laden Sie unten den signierten `stackql`-Installer oder die ausführbare Datei für Windows herunter. Ein Klick auf einen Download-Button wählt standardmäßig AMD64; über das zugehörige Dropdown-Menü wählen Sie AMD64 oder natives ARM64.

[Windows-MSI herunterladen](https://releases.stackql.io/stackql/latest/stackql_windows_amd64.msi)
[Windows-ZIP herunterladen](https://releases.stackql.io/stackql/latest/stackql_windows_amd64.zip)

**Docker**

## Docker

StackQL-Builds werden auf [DockerHub](https://hub.docker.com/u/stackql) veröffentlicht.  

__Docker Hub__  

Um das StackQL-Container-Image herunterzuladen, führen Sie den folgenden Befehl aus:

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

Ab `v1.0` basiert das Image auf Ubuntu 26.04 LTS, und eine Variante mit vorinstalliertem Python 3.13 wird mit dem Tag-Suffix `-python3.13` (Alias `-python3`) veröffentlicht, zum Beispiel:

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

**stackql-deploy**

## `stackql-deploy`

`stackql-deploy` ist ein zustandsloses IaC-Framework auf Basis von StackQL. Die vollständige Dokumentation finden Sie in den [__StackQL Deploy Docs__](https://stackql-deploy.io/).

__Linux / macOS__

Lädt die neueste `stackql-deploy`-Binärdatei in einem Schritt herunter und entpackt sie. Der Installer erkennt Ihr Betriebssystem und Ihre Architektur (einschließlich Apple Silicon und Intel über eine universelle macOS-Binärdatei) und ruft automatisch das passende Release-Asset ab.
```bash
curl -fsSL https://get-stackql-deploy.io/install.sh | sh
```

__Windows__

Lädt die neueste `stackql-deploy`-Binärdatei herunter und entpackt sie in das aktuelle Verzeichnis.
Der Installer erkennt Ihre Plattform und ruft automatisch das passende Release-Asset ab.
```powershell
irm https://get-stackql-deploy.io/install.ps1 | iex
```

__cargo__

Wenn Sie die Rust-Toolchain installiert haben, wird die Binärdatei damit direkt von [__crates.io__](https://crates.io/crates/stackql-deploy) gebaut und installiert.
```bash
cargo install stackql-deploy
```

**Cloud-Shells**

## Cloud-Shells

StackQL kann direkt aus den integrierten Cloud-Shells und Web-Terminals der großen Cloud- und Datenplattformen verwendet werden. Das ermöglicht einen nahtlosen Ablauf, da diese Umgebungen bereits mit der Identität autorisiert sind, mit der Sie angemeldet sind, sodass keine separate Einrichtung der Authentifizierung nötig ist.

**AWS**

### AWS Cloud Shell

AWS CloudShell stellt eine browserbasierte Shell mit vorinstallierter und authentifizierter AWS CLI bereit. Wenn Sie StackQL in AWS CloudShell ausführen, können Sie AWS-Ressourcen ohne zusätzliche Authentifizierungsschritte abfragen und verwalten. Eine ausführliche Anleitung finden Sie in unserem [AWS CloudShell-Tutorial](/quick-starts/aws/aws-cloud-shell).

Laden Sie zunächst das StackQL-Paket herunter:

```bash
curl -fsSL https://get-stackql.io/install/aws | sh
```
Führen Sie dann das StackQL-Skript für AWS CloudShell aus:

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

Dieses Skript startet eine StackQL-Befehlsshell mit Ihren AWS CloudShell-Anmeldedaten, sodass Sie sofort AWS-Ressourcen abfragen können.

**Azure**

### Azure Cloud Shell

Azure Cloud Shell stellt eine über den Browser erreichbare Shell-Umgebung bereit, in der die Azure CLI bereits mit Ihrem Azure-Konto authentifiziert ist. Mit StackQL in Azure Cloud Shell fragen Sie Ihre Azure-Ressourcen nahtlos und ohne zusätzliche Einrichtung ab. Alle Einzelheiten finden Sie in unserer [Anleitung zu Azure Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-azure-cloud-shell).  

Laden Sie zunächst das StackQL-Paket herunter:

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

Führen Sie dann das StackQL-Skript für Azure Cloud Shell aus:

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

Dieses Skript konfiguriert automatisch eine StackQL-Sitzung mit Ihren Azure Cloud Shell-Anmeldedaten, sodass Sie Ihre Azure-Ressourcen sofort abfragen können.

**Google**

### Google Cloud Shell

Google Cloud Shell bietet eine Entwicklungs- und Betriebsumgebung, in der die Google Cloud CLI bereits authentifiziert ist. Wenn Sie StackQL in Google Cloud Shell ausführen, fragen Sie GCP-Ressourcen mit Ihrer bestehenden Authentifizierung ab. Mehr dazu erfahren Sie in unserer [Anleitung zu Google Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-google-cloud-shell).  

Laden Sie zunächst das StackQL-Paket herunter:

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

Führen Sie dann das StackQL-Skript für Google Cloud Shell aus:

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

Das Skript richtet StackQL so ein, dass Ihre Google Cloud Shell-Anmeldedaten verwendet werden, sodass Sie Ihre GCP-Ressourcen sofort mit SQL-Syntax abfragen können.

**Databricks**

### Databricks Web Terminal

Databricks-Workspaces enthalten ein Web-Terminal, das unter dem angemeldeten Benutzer läuft. Wenn Sie StackQL dort ausführen, fragen Sie Ihren Workspace mit Ihrer Databricks-Identität ab, ohne separate Einrichtung der Authentifizierung. Beispielabfragen und die Authentifizierung auf Account-Ebene finden Sie in unserer [Anleitung zum Databricks Web Terminal](/blog/tutorials/stackql-in-databricks-web-terminal).

Laden Sie zunächst das StackQL-Paket herunter:

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

Führen Sie dann das StackQL-Shell-Skript für Databricks aus:

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

Dadurch wird eine StackQL-Sitzung mit Ihrer Databricks-Workspace-Identität gestartet, sodass Sie sofort Ressourcen auf Workspace-Ebene wie `databricks_workspace.iam.vw_user_entitlements` abfragen können. Für Abfragen auf Account-Ebene (Provisionierung, Abrechnung, Account-IAM) setzen Sie die Variablen des Databricks-OAuth2-Service-Principals wie in der Anleitung beschrieben.

## Verwendung mit MCP-Clients

Der StackQL MCP-Server läuft lokal über stdio, sodass die Provider-Anmeldedaten unabhängig vom verwendeten Client auf Ihrem Rechner bleiben. Wählen Sie unten Ihren Client: Jeder Tab nennt zuerst den Weg über das Verzeichnis oder die Ein-Klick-Installation und als Ausweichlösung die manuelle Konfiguration. Alle Vertriebskanäle, einschließlich `npx`, Python, Docker und CI, finden Sie unter [MCP-Server installieren](#installing-the-mcp-server).

**Claude Desktop**

### Claude Desktop

  Der empfohlene Weg, den StackQL MCP-Server in Claude Desktop zu installieren, führt über das [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) (**Einstellungen -> Connectors -> Hinzufügen -> Connectors durchsuchen**, nach **StackQL** suchen) - Claude Desktop wählt automatisch die passende signierte Binärdatei für Ihre Plattform.  Alternativ sind vorgefertigte MCP-Bundles (`.mcpb`) an jedes StackQL-Release angehängt, um aus einer heruntergeladenen Datei zu installieren - in beiden Fällen ist keine separate StackQL-Installation erforderlich.  Bundles sind für macOS, Windows und Linux verfügbar.

  Die MCPB-Downloads für Linux und Windows verwenden standardmäßig **amd64** (x64). Über die Dropdown-Menüs wählen Sie **amd64** oder **arm64**.

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

:::info

Der StackQL MCP-Server ist außerdem in der [__Official MCP Registry__](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) als `io.github.stackql/stackql-mcp` gelistet.

:::

:::tip

Das Bundle ist eine von mehreren Möglichkeiten, den StackQL MCP-Server auszuführen.  Die vollständige Anleitung für Claude Desktop finden Sie unter [__StackQL mit Claude Desktop verwenden__](/getting-started/claude-desktop), die Optionen npx, Docker, Python, CI und manuelle Konfiguration unter [__MCP-Server installieren__](#installing-the-mcp-server).

:::

**ChatGPT**

### ChatGPT und Codex

  StackQL wird als lokales Plugin für die ChatGPT-Desktop-App und die Codex CLI ausgeliefert. Das Plugin führt den StackQL MCP-Server über stdio auf Ihrem Rechner aus, sodass Provider-Anmeldedaten diesen nie verlassen. Erforderlich ist Node.js 24.22.1 oder neuer (22.23.4 bzw. 26.12.1 auf diesen Release-Linien); das Plugin benötigt nur die in Node.js integrierten Module, lädt die signierte `stackql`-Binärdatei bei der ersten Verwendung herunter und prüft deren SHA-256.

  **ChatGPT-Desktop-App (Plugin-Verzeichnis):**  

  öffnen Sie das Plugin-Verzeichnis in der ChatGPT-Desktop-App, suchen Sie nach **StackQL** und klicken Sie auf **Installieren**, und führen Sie dann das Setup des Plugins aus; der mitgelieferte Skill `stackql-setup` führt durch die Anmeldedaten und eine erste Abfrage. Der Eintrag trägt das Badge **Desktop only**: Das Plugin lässt sich nur aus der Desktop-App installieren, nicht aus ChatGPT Web oder Mobile, und seine Tools stehen im Work-Modus zur Verfügung, in Threads, die auf Ihrem Computer laufen. Wenn der Eintrag in Ihrem Verzeichnis noch nicht sichtbar ist, installieren Sie stattdessen aus dem Repository-Marketplace.

  **ChatGPT-Desktop-App (Repository-Marketplace):**  

  öffnen Sie **Einstellungen -> Plugins -> Hinzufügen -> Von GitHub hinzufügen**, geben Sie `stackql/stackql` ein, installieren Sie dann **StackQL** aus dem Abschnitt **Persönlich** des Plugin-Verzeichnisses und starten Sie die App neu.

  **Codex CLI:**

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

  Starten Sie ChatGPT Desktop oder Codex neu und probieren Sie dann: *Verwende StackQL, um bei Bedarf den GitHub-Provider zu installieren, und liste dann die ersten fünf GitHub-Services auf.* Provider-Anmeldedaten gehören in `~/.stackql/.env` unter den Standardnamen der Umgebungsvariablen des jeweiligen Providers (zum Beispiel `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY`); bitten Sie den Agenten nach dem Bearbeiten der Datei, `reload_credentials` aufzurufen.

  **Ohne das Plugin:**   

  wählen Sie unter **Einstellungen -> Plugins -> MCPs -> Mit einem benutzerdefinierten MCP verbinden** die Option **STDIO**, setzen Sie den Befehl auf `npx` und fügen Sie die Argumente `-y` und `@stackql/mcp-server` hinzu. Geben Sie Provider-Anmeldedaten in diesem Formular als Umgebungsvariablen an.

:::note

ChatGPT Web und Mobile können keinen lokalen stdio-Server ausführen, daher gibt es das Plugin nur für Desktop und Codex. Ein offener Bug in ChatGPT Desktop ([openai/codex#38162](https://github.com/openai/codex/issues/38162)) kann lokale MCP-Tools in **Chat**-Sitzungen ausblenden; Threads im Work-Modus, Codex-Threads und die Codex CLI sind nicht betroffen.

:::

**Goose**

### Goose

  Goose führt stdio-Erweiterungen direkt aus, daher genügt der `npx`-Launcher (Node.js 18 oder neuer).

  **Goose Desktop:** Klicken Sie auf den Button unten. Goose öffnet sich, zeigt den Befehl an, den es ausführen wird, bittet Sie um Bestätigung und fügt dann StackQL als Erweiterung hinzu.

  In Goose Desktop installieren

  Der Button ist ein `goose://`-Deep-Link; Sie können ihn auch in die Adressleiste Ihres Browsers einfügen oder aus einem Terminal mit `open` (macOS), `start` (Windows) oder `xdg-open` (Linux) öffnen:

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

  oder führen Sie `goose configure` aus, wählen Sie **Add Extension -> Command-line Extension** und geben Sie denselben Befehl ein. Geben Sie die Provider-Anmeldedaten als Umgebungsvariablen der Erweiterung an, wenn Sie dazu aufgefordert werden.

:::note

Goose hat sein In-App-Erweiterungsverzeichnis zugunsten der [Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) eingestellt, in der StackQL als `io.github.stackql/stackql-mcp` gelistet ist. Sobald Goose seinen Registry-Import ausliefert, ist StackQL dort ohne weiteres Zutun auffindbar.

:::

## MCP-Server installieren

Mit dem StackQL MCP-Server können KI-Agenten Cloud-Ressourcen mit StackQL abfragen und bereitstellen. Er wird über mehrere Kanäle ausgeliefert - alle führen denselben Server aus, wählen Sie also den Kanal, der zu Ihrem Client und Ihren Anforderungen an die Vertrauenswürdigkeit passt. Die folgenden Optionen sind ungefähr nach Vertrauenswürdigkeit und Einfachheit geordnet.

### Marketplaces und Verzeichnisse

Der Server ist in der Official MCP Registry als `io.github.stackql/stackql-mcp` veröffentlicht; die unten aufgeführten Paket-Registries enthalten die verteilbaren Artefakte, und nachgelagerte Verzeichnisse übernehmen den Eintrag von dort.  

**Registries**

| Registry | Typ | Veröffentlicht über | Eintrag | Hinweise |
|---|---|---|---|---|
| Official MCP Registry | Kanonische Metadaten-Registry | `mcp-publisher` CLI + `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) | führt alle 8 Pakete auf (`mcpb x5`, `oci`, `npm`, `pypi`) |
| npm | Paket-Registry | `npm publish` | [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) | `npx`-Launcher |
| PyPI | Paket-Registry | `twine upload` | [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) | `uvx`-/`pip`-Launcher |
| Docker Hub | Container-Registry | `docker buildx --push` | [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) | Multi-Arch `amd64` + `arm64` |
| GitHub Actions Marketplace | CI-Marketplace (`setup-stackql-mcp`-Action) | Öffentliches Repository + Release + Marketplace-Eintrag | [`setup-stackql-mcp-server`](https://github.com/marketplace/actions/setup-stackql-mcp-server) | Verifizierter Publisher; [`stackql/setup-stackql-mcp`](https://github.com/stackql/setup-stackql-mcp) |

**Verzeichnisse**

Einträge in Verzeichnissen und Aggregatoren, ungefähr nach Bedeutung für die Auffindbarkeit geordnet:

| Verzeichnis | Typ | Eintrag |
|---|---|---|
| __Anthropic Connector Directory__ | In-App-Verzeichnis von Claude Desktop | [claude.ai/directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) |
| __OpenAI Plugin Directory__ | In-App-Verzeichnis von ChatGPT Desktop (nur Desktop) | in der ChatGPT-Desktop-App nach **StackQL** suchen; siehe [ChatGPT und Codex](#using-with-mcp-clients) |
| __Cursor Directory__ | IDE-Client-Verzeichnis | [cursor.directory](https://cursor.directory/plugins/stackql-mcp-server) |
| __mcp.so__ | Größter Aggregator | [mcp.so](https://mcp.so/server/stackql/stackql) |
| __PulseMCP__ | Discovery, Unterstützer der Registry | [pulsemcp](https://www.pulsemcp.com/servers/stackql) |
| __Glama.ai MCP__ | Durchsuchbarer Marketplace | [glama.ai](https://glama.ai/mcp/servers/stackql/stackql) |
| __mcpmarket.com__ | Aggregator | [mcpmarket](https://mcpmarket.com/server/stackql) |
| __mcpservers.org__ | Awesome-List-Website | [mcpservers.org](https://mcpservers.org/servers/stackql-mcp-server) |

### Vorgefertigtes `.mcpb`-Bundle

**Wann verwenden:** Claude Desktop ohne Zugang zum Connector Directory, oder wenn Sie eine bestimmte Version festlegen oder Prüfsummen vor der Installation selbst prüfen möchten.  Für die meisten Claude Desktop-Benutzer ist das [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) die empfohlene Installationsmethode.

Für jede Plattform ist an jedes StackQL-Release ein vorgefertigtes MCP-Bundle angehängt:

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

wobei `<platform>` einer der Werte `darwin-universal`, `windows-x64` (AMD64), `windows-arm64`, `linux-x64` oder `linux-arm64` ist. Download-Buttons für jede Plattform finden Sie im Tab **Claude Desktop** unter [Verwendung mit MCP-Clients](#using-with-mcp-clients). Zu jedem Bundle gibt es eine passende `.sha256`-Prüfsumme auf der [Release-Seite](https://github.com/stackql/stackql/releases/latest). Prüfen Sie diese und installieren Sie dann über **Einstellungen -> Erweiterungen** in Claude Desktop:

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

Die vollständige Anleitung finden Sie unter [StackQL mit Claude Desktop verwenden](/getting-started/claude-desktop#install-from-a-downloaded-bundle).

### Manuelle `claude_desktop_config.json`

**Wann verwenden:** Sie haben die `stackql`-Binärdatei bereits in Ihrem PATH und verwenden Claude Desktop oder einen anderen stdio-MCP-Client.

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

Alle drei Argumente sind erforderlich:

- `--mcp.server.type=stdio` wählt den stdio-Transport, den in Editoren eingebettete Clients sprechen.
- `--approot` verweist den Provider-Cache auf ein beschreibbares Verzeichnis. MCP-Clients starten den Server unter Umständen mit `/` als Arbeitsverzeichnis, das nicht beschreibbar ist.
- `--mcp.config '{"server": {"audit": {"disabled": true}}}'` deaktiviert das Audit-Log, das sein Verzeichnis sonst standardmäßig in das (möglicherweise nicht beschreibbare) Arbeitsverzeichnis legt.

Fügen Sie Provider-Anmeldedaten mit einem `"env"`-Block hinzu und passen Sie den Sicherheitsvertrag mit `"mode"` an - siehe [Server-Modi](/command-line-usage/mcp#server-modes).

### `npx` (ohne Installation)

**Wann verwenden:** jede Node-Umgebung, wenn Sie keine globale StackQL-Installation möchten.

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

Der Launcher [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) lädt die signierte `stackql`-Binärdatei beim ersten Start herunter, prüft deren SHA-256 und legt sie für spätere Starts im Cache ab.

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

**Wann verwenden:** eine Python-Umgebung - derselbe Launcher, für Python paketiert, der den Binärdatei-Cache des npx-Launchers mitbenutzt.

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

Oder installieren Sie ihn mit `pip install stackql-mcp-server` (Python 3.9+) in die aktuelle Umgebung. Das Paket heißt [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) auf PyPI.

### Docker

**Wann verwenden:** eine containerisierte oder anderweitig isolierte Laufzeitumgebung. Das Image ist Multi-Arch (amd64 und arm64).

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

Als Client-Konfiguration:

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

Das Image heißt [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) auf Docker Hub.

### CI und agentische Workflows (GitHub Actions)

**Wann verwenden:** Sie führen den Server in einem GitHub Actions-Job aus, damit ein Agent Ihre Cloud im Rahmen von CI abfragen - und, wenn Sie es erlauben, verändern - kann.

[`stackql/setup-stackql-mcp@v1`](https://github.com/marketplace/actions/setup-stackql-mcp-server) installiert die Binärdatei und schreibt eine MCP-Konfiguration (standardmäßig im Modus `read_only`). Übergeben Sie diese Konfiguration über `claude_args` an [`anthropics/claude-code-action`](https://github.com/anthropics/claude-code-action):

```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__*'
```

Weitere agentische Rezepte (Cloud-Audits, Kostenschätzungen und so weiter) finden Sie in der [README der Action](https://github.com/stackql/setup-stackql-mcp).

### Eingebettetes MCP

**Wann verwenden:** Sie entwickeln eine agentische App und möchten den MCP-Server in Ihre eigene Binärdatei einbetten - kein `npx`, keine separate Installation, keine Laufzeitabhängigkeit.

Native Bibliotheken starten die signierte `stackql`-Binärdatei über stdio hinter dem offiziellen MCP-SDK-Client der jeweiligen Sprache, sodass Ihre App dieselbe kontrollierte SQL-Schnittstelle zu jedem Provider in der Registry erhält. Jede Bibliothek verwendet standardmäßig `read_only` - der Wechsel in einen schreibenden Modus ist immer explizit - und kann die Binärdatei entweder beim ersten Start herunterladen und prüfen oder sie für eine einzelne eigenständige ausführbare Datei in Ihren Build einbetten. Die vollständige API je Sprache finden Sie in der [Referenz zum eingebetteten MCP](/mcp/embedded).

**Rust**

Das Crate `stackql-mcp` startet die Binärdatei hinter einem `rmcp`-Client. Das Standard-Feature `sidecar` lädt die Binärdatei beim ersten Start herunter und prüft sie; das Feature `vendored` bettet sie mit `include_bytes!` für eine einzelne eigenständige Binärdatei ein. 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?;
```

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

Vollständige Referenz: [Eingebettetes MCP: Rust](/mcp/embedded/rust).

**Go**

Die Bibliothek `stackql-mcp-go` startet die Binärdatei hinter dem offiziellen Go-MCP-SDK-Client. Betten Sie die Binärdatei mit `go:embed` für eine einzelne eigenständige Binärdatei ein, oder lassen Sie sie beim ersten Start herunterladen und prüfen. Startet standardmäßig im Modus `read_only`.

```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()
```

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

Vollständige Referenz: [Eingebettetes MCP: Go](/mcp/embedded/go).

**Kotlin / JVM**

Die Bibliothek `io.stackql:stackql-mcp` startet die Binärdatei hinter dem offiziellen Kotlin-MCP-SDK-Client, und ein begleitendes Gradle-Plugin bindet denselben Start in einen Build ein. Erfordert JDK 17 und 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
}
```

[Auf GitHub ansehen](https://github.com/stackql/stackql-mcp-kotlin)

Vollständige Referenz: [Eingebettetes MCP: Kotlin / JVM](/mcp/embedded/kotlin).

**.NET**

Das Paket `StackQL.Mcp` startet die Binärdatei hinter dem offiziellen C#-MCP-SDK-Client. Standardmäßig als Sidecar, oder Sie betten das Bundle als Build-Ressource für eine eigenständige ausführbare Datei ein. Erfordert .NET 8 oder neuer.

```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();
```

[Auf GitHub ansehen](https://github.com/stackql/stackql-mcp-dotnet)

Vollständige Referenz: [Eingebettetes MCP: .NET / C#](/mcp/embedded/dotnet).

**Gleam**

Die Bibliothek `stackql_mcp` zielt auf die Erlang/BEAM-Laufzeitumgebung und stellt den Server über `child_spec()` als OTP-Child bereit, sodass er in Ihrem eigenen Supervision-Tree laufen kann. Startet standardmäßig im Modus `read_only`.

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

[Auf GitHub ansehen](https://github.com/stackql/stackql-mcp-gleam)

Vollständige Referenz: [Eingebettetes MCP: Gleam](/mcp/embedded/gleam).

**Swift**

Das Paket `stackql-mcp-swift` startet die Binärdatei hinter dem offiziellen Swift-MCP-SDK-Client. Die `darwin-universal`-Binärdatei ist mit Developer ID signiert und von Apple notarisiert, sodass Sie sie in eine signierte `.app` einbetten können und die Notarisierung der App gültig bleibt. Erfordert macOS 13+ und 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()
```

[Auf GitHub ansehen](https://github.com/stackql/stackql-mcp-swift)

Vollständige Referenz: [Eingebettetes MCP: Swift](/mcp/embedded/swift).

### Vertrauensmodell

Für jeden Kanal gelten dieselben Sicherheitseigenschaften:

- Die eingebettete `stackql`-Binärdatei ist mit Authenticode signiert (Windows) und von Apple notarisiert (macOS).
- Jedes `.mcpb`-Bundle wird mit einer veröffentlichten SHA-256-Prüfsumme auf der Release-Seite ausgeliefert.
- Die Launcher `npx` und `uvx` prüfen den SHA-256 der heruntergeladenen Binärdatei vor der ersten Verwendung.
- Der Eintrag in der [MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) bestätigt die Hashes je Plattform.

## GitHub Actions verwenden

[StackQL GitHub Actions](https://github.com/stackql/stackql-actions-demo) stehen für Ihre GitHub Actions-Workflows zur Verfügung. Die folgenden Actions sind verfügbar:

**stackql-deploy**

### `stackql-deploy`

Stellen Sie Infrastruktur-Stacks mit StackQL direkt aus Ihren GitHub-Workflows bereit oder testen Sie sie. Diese Action ermöglicht Infrastructure as Code (IaC)-Workflows mit SQL-ähnlicher Syntax, sodass Sie Cloud-Ressourcen über mehrere Provider hinweg in einem einzigen Workflow definieren, bereitstellen und verwalten können.  

[Im GitHub Marketplace ansehen](https://github.com/marketplace/actions/stackql-deploy)
[Auf GitHub ansehen](https://github.com/stackql/stackql-deploy-action)

__Anwendungsbeispiel__

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

Richten Sie StackQL in Ihrem GitHub Actions-Workflow ein.  

[Im GitHub Marketplace ansehen](https://github.com/marketplace/actions/setup-stackql)
[Auf GitHub ansehen](https://github.com/stackql/setup-stackql)

__Anwendungsbeispiel__

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

Installieren Sie den StackQL MCP-Server in Ihrem GitHub Actions-Workflow.  Die Action installiert die signierte Binärdatei und schreibt eine `mcpServers`-Konfiguration (standardmäßig im Modus `read_only`), die ein agentischer Schritt wie `anthropics/claude-code-action` über `claude_args` verwendet.

[Im GitHub Marketplace ansehen](https://github.com/marketplace/actions/setup-stackql-mcp-server)
[Auf GitHub ansehen](https://github.com/stackql/setup-stackql-mcp)

__Anwendungsbeispiel__

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

Führen Sie StackQL-Befehle in Ihrem GitHub Actions-Workflow aus.  Abfragen können inline oder aus einer Datei im Repository übergeben werden.  

[Im GitHub Marketplace ansehen](https://github.com/marketplace/actions/stackql-exec)
[Auf GitHub ansehen](https://github.com/stackql/stackql-exec)

__Anwendungsbeispiel__

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

Führen Sie Unit-Tests in Ihrem GitHub Actions-Workflow aus (für Assurance-, Governance- oder Cloud-Sicherheitsprüfungen).  

[Im GitHub Marketplace ansehen](https://github.com/marketplace/actions/stackql-assert)
[Auf GitHub ansehen](https://github.com/stackql/stackql-assert)

__Anwendungsbeispiel__

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

## Weitere Bibliotheken

StackQL bietet mehrere Integrationsmöglichkeiten für die Verwendung in verschiedenen Programmiersprachen und Umgebungen. Diese Bibliotheken erweitern die Funktionalität von StackQL und erleichtern es, die Abfrage und Verwaltung von Cloud-Ressourcen in Ihre bestehenden Anwendungen und Workflows einzubinden.  

**pystackql**

### `pystackql`-Python-Paket

Python-Wrapper zur Verwendung von StackQL in Ihren Python-Programmen. Das Paket `pystackql` ist auf [__PyPi__](https://pypi.org/project/pystackql/) verfügbar, die Dokumentation zum Paket `pystackql` finden Sie auf [__Read the Docs__](https://pystackql.readthedocs.io/en/latest/). Um das Paket `pystackql` zu installieren, führen Sie den folgenden Befehl aus:

```bash
pip install pystackql
```

Das folgende Beispiel zeigt das Paket `pystackql` zusammen mit `pandas`, um StackQL-Abfragen auszuführen und die Ergebnisse in einen `pandas.DataFrame` zu übernehmen:

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