# Instalasi

> Instal StackQL di macOS, Linux, Windows, Docker, atau shell cloud, lalu gunakan server MCP StackQL dari Claude Desktop, ChatGPT, Goose, dan klien MCP lain, atau melalui npx, uvx, pip, Docker, dan GitHub Actions.

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

Halaman ini berisi petunjuk untuk menginstal StackQL di berbagai platform.

**macOS**

## macOS

StackQL tersedia di macOS melalui Homebrew dan penginstal `pkg`; arsitektur ARM (M1/Apple Silicon) dan AMD sama-sama didukung oleh satu penginstal multiarsitektur.

**Homebrew**

Untuk menginstal melalui Homebrew, jalankan perintah berikut di terminal Anda:

```bash
brew install stackql
```

**curl (biner yang ditandatangani dan dinotarisasi)**

Untuk menginstal biner `stackql` yang dapat dieksekusi, ditandatangani, dan dinotarisasi di direktori saat ini, jalankan perintah berikut di terminal Anda:

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

**Unduhan paket**

StackQL tersedia sebagai penginstal `pkg` interaktif untuk macOS yang ditandatangani dan dinotarisasi.

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

**Linux**

## Linux

StackQL tersedia untuk semua arsitektur Linux.

**curl**

Untuk menginstal biner `stackql` yang dapat dieksekusi di direktori saat ini untuk arsitektur Linux Anda (amd64 atau arm64), jalankan perintah berikut di terminal Anda:

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

**Unduhan paket**

Sebagai alternatif, Anda dapat mengunduh biner di sini:

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

**Windows**

## Windows

StackQL tersedia di Windows melalui Chocolatey, skrip instalasi PowerShell, dan penginstal MSI. Build native AMD64 (x64) dan ARM64 tersedia sebagai penginstal MSI dan arsip ZIP yang berisi `stackql.exe`. Build AMD64 juga berjalan di ARM64 melalui emulasi. Semua file yang dapat dieksekusi ditandatangani dengan sertifikat penandatanganan kode Authenticode.

**Chocolatey**

Untuk menginstal melalui Chocolatey, jalankan perintah berikut di terminal PowerShell atau `cmd` Anda:

```powershell
choco install stackql
```

**Invoke-RestMethod**

Untuk menginstal file Authenticode yang dapat dieksekusi di direktori saat ini, jalankan perintah berikut di terminal PowerShell: 

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

**Unduhan MSI/ZIP**

Unduh penginstal atau file `stackql` yang dapat dieksekusi untuk Windows di bawah ini; keduanya telah ditandatangani. Saat diklik, tombol unduh memilih AMD64 secara default; gunakan menu dropdown pada tombol tersebut untuk memilih AMD64 atau ARM64 native.

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

**Docker**

## Docker

Build StackQL dipublikasikan ke [Docker Hub](https://hub.docker.com/u/stackql).  

__Docker Hub__  

Untuk mengunduh image container StackQL, jalankan perintah berikut:

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

Mulai `v1.0`, image ini berbasis Ubuntu 26.04 LTS, dan varian dengan Python 3.13 yang sudah terinstal dipublikasikan dengan akhiran tag `-python3.13` (alias `-python3`), misalnya:

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

**stackql-deploy**

## `stackql-deploy`

`stackql-deploy` adalah framework IaC tanpa status yang dibangun di atas StackQL. Untuk dokumentasi lengkap, lihat [__Dokumentasi StackQL Deploy__](https://stackql-deploy.io/).

__Linux / macOS__

Mengunduh dan mengekstrak biner `stackql-deploy` terbaru dalam satu langkah. Penginstal mendeteksi sistem operasi dan arsitektur Anda (termasuk Apple Silicon dan Intel melalui biner macOS universal) dan mengambil aset rilis yang sesuai secara otomatis.
```bash
curl -fsSL https://get-stackql-deploy.io/install.sh | sh
```

__Windows__

Mengunduh dan mengekstrak biner `stackql-deploy` terbaru ke direktori saat ini.
Penginstal mendeteksi platform Anda dan mengambil aset rilis yang sesuai secara otomatis.
```powershell
irm https://get-stackql-deploy.io/install.ps1 | iex
```

__cargo__

Jika toolchain Rust sudah terinstal, perintah ini membangun dan menginstal biner langsung dari [__crates.io__](https://crates.io/crates/stackql-deploy).
```bash
cargo install stackql-deploy
```

**Shell cloud**

## Shell cloud

StackQL dapat digunakan langsung dari shell cloud dan terminal web bawaan platform cloud dan data utama. Cara ini memberikan pengalaman yang mulus karena lingkungan tersebut sudah diotorisasi sebelumnya dengan identitas yang Anda gunakan untuk masuk, sehingga Anda tidak perlu menyiapkan autentikasi secara terpisah.

**AWS**

### AWS CloudShell

AWS CloudShell menyediakan shell berbasis browser dengan AWS CLI yang sudah terinstal dan terautentikasi. Dengan menjalankan StackQL di AWS CloudShell, Anda dapat mengkueri dan mengelola sumber daya AWS tanpa langkah autentikasi tambahan. Untuk petunjuk terperinci, lihat [tutorial AWS CloudShell](/quick-starts/aws/aws-cloud-shell) kami.

Pertama, unduh paket StackQL:

```bash
curl -fsSL https://get-stackql.io/install/aws | sh
```
Lalu jalankan skrip StackQL untuk AWS CloudShell:

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

Skrip ini memulai shell perintah StackQL menggunakan kredensial AWS CloudShell Anda, sehingga Anda dapat langsung mulai mengkueri sumber daya AWS.

**Azure**

### Azure Cloud Shell

Azure Cloud Shell menyediakan lingkungan shell yang dapat diakses dari browser dengan Azure CLI yang sudah terautentikasi dengan akun Azure Anda. Dengan menggunakan StackQL di Azure Cloud Shell, Anda dapat mengkueri sumber daya Azure dengan mulus tanpa penyiapan tambahan. Untuk detail lengkap, lihat [panduan Azure Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-azure-cloud-shell) kami.  

Pertama, unduh paket StackQL:

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

Lalu jalankan skrip StackQL untuk Azure Cloud Shell:

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

Skrip ini secara otomatis mengonfigurasi sesi StackQL agar menggunakan kredensial Azure Cloud Shell Anda, sehingga Anda dapat langsung mengkueri sumber daya Azure Anda.

**Google**

### Google Cloud Shell

Google Cloud Shell menawarkan lingkungan pengembangan dan operasi dengan Google Cloud CLI yang sudah terautentikasi. Dengan menjalankan StackQL di Google Cloud Shell, Anda dapat mengkueri sumber daya GCP menggunakan autentikasi yang sudah ada. Pelajari lebih lanjut di [panduan Google Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-google-cloud-shell) kami.  

Pertama, unduh paket StackQL:

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

Lalu jalankan skrip StackQL untuk Google Cloud Shell:

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

Skrip ini menyiapkan StackQL agar menggunakan kredensial Google Cloud Shell Anda, sehingga Anda dapat langsung mulai mengkueri sumber daya GCP Anda dengan sintaksis SQL.

**Databricks**

### Databricks Web Terminal

Ruang kerja Databricks menyertakan terminal web yang berjalan sebagai pengguna yang sedang masuk. Dengan menjalankan StackQL di sana, Anda dapat mengkueri ruang kerja menggunakan identitas Databricks Anda, tanpa penyiapan autentikasi terpisah. Untuk contoh kueri dan autentikasi tingkat akun, lihat [panduan Databricks Web Terminal](/blog/tutorials/stackql-in-databricks-web-terminal) kami.

Pertama, unduh paket StackQL:

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

Lalu jalankan skrip shell StackQL untuk Databricks:

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

Perintah ini memulai sesi StackQL menggunakan identitas ruang kerja Databricks Anda, sehingga Anda dapat langsung mengkueri sumber daya dengan cakupan ruang kerja seperti `databricks_workspace.iam.vw_user_entitlements`. Untuk kueri tingkat akun (penyediaan, penagihan, IAM akun), atur variabel prinsipal layanan OAuth2 Databricks seperti yang dijelaskan dalam panduan tersebut.

## Menggunakan dengan klien MCP

Server MCP StackQL berjalan secara lokal melalui stdio, sehingga kredensial provider tetap berada di mesin Anda, apa pun klien yang Anda gunakan. Pilih klien Anda di bawah ini: setiap tab menampilkan cara melalui direktori atau satu klik terlebih dahulu, dan konfigurasi manual sebagai fallback. Untuk semua saluran distribusi, termasuk `npx`, Python, Docker, dan CI, lihat [Menginstal server MCP](#installing-the-mcp-server).

**Claude Desktop**

### Claude Desktop

  Cara yang direkomendasikan untuk menginstal server MCP StackQL ke Claude Desktop adalah melalui [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) (**Settings -> Connectors -> Add -> Browse Connectors**, cari **StackQL**) - Claude Desktop memilih biner yang ditandatangani dan sesuai untuk platform Anda secara otomatis.  Sebagai alternatif, MCP Bundle (`.mcpb`) siap pakai dilampirkan pada setiap rilis StackQL untuk instalasi dari file yang diunduh - dengan cara mana pun, Anda tidak perlu menginstal StackQL secara terpisah.  Bundle tersedia untuk macOS, Windows, dan Linux.

  Unduhan MCPB untuk Linux dan Windows secara default menggunakan **amd64** (x64). Gunakan menu dropdown untuk memilih **amd64** atau **arm64**.

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

:::info

Server MCP StackQL juga tercantum di [__Official MCP Registry__](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) sebagai `io.github.stackql/stackql-mcp`.

:::

:::tip

Bundle ini adalah salah satu dari beberapa cara untuk menjalankan server MCP StackQL.  Lihat [__Menggunakan StackQL dengan Claude Desktop__](/getting-started/claude-desktop) untuk panduan lengkap Claude Desktop, atau [__Menginstal server MCP__](#installing-the-mcp-server) untuk opsi npx, Docker, Python, CI, dan manual.

:::

**ChatGPT**

### ChatGPT dan Codex

  StackQL tersedia sebagai plugin lokal untuk aplikasi desktop ChatGPT dan Codex CLI. Plugin ini menjalankan server MCP StackQL melalui stdio di mesin Anda, sehingga kredensial provider tidak pernah meninggalkan mesin tersebut. Diperlukan Node.js 24.22.1 atau yang lebih baru (22.23.4 atau 26.12.1 pada lini rilis tersebut); plugin ini hanya memerlukan modul bawaan Node.js, mengunduh biner `stackql` yang ditandatangani saat pertama kali digunakan, dan memverifikasi SHA-256 biner tersebut.

  **Aplikasi desktop ChatGPT (direktori plugin):**  

  buka direktori plugin di aplikasi desktop ChatGPT, cari **StackQL** dan klik **Install**, lalu jalankan penyiapan plugin; skill `stackql-setup` yang disertakan memandu Anda melalui kredensial dan kueri pertama. Entri ini memiliki lencana **Desktop only**: plugin hanya dapat diinstal dari aplikasi desktop, bukan dari ChatGPT web atau seluler, dan alat plugin ini tersedia dalam mode Work, di thread yang berjalan di komputer Anda. Jika entri ini belum terlihat di direktori Anda, instal dari marketplace repositori sebagai gantinya.

  **Aplikasi desktop ChatGPT (marketplace repositori):**  

  buka **Settings -> Plugins -> Add -> Add from GitHub**, masukkan `stackql/stackql`, lalu instal **StackQL** dari bagian **Personal** di direktori plugin dan mulai ulang aplikasi.

  **Codex CLI:**

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

  Mulai ulang ChatGPT desktop atau Codex, lalu coba: *Gunakan StackQL untuk menginstal provider GitHub jika diperlukan, lalu cantumkan lima layanan GitHub pertama.* Kredensial provider disimpan di `~/.stackql/.env` dengan nama variabel lingkungan standar setiap provider (misalnya `AWS_ACCESS_KEY_ID` dan `AWS_SECRET_ACCESS_KEY`); setelah mengedit file tersebut, minta agen untuk memanggil `reload_credentials`.

  **Tanpa plugin:**   

  di **Settings -> Plugins -> MCPs -> Connect to a custom MCP**, pilih **STDIO**, atur perintah ke `npx`, lalu tambahkan argumen `-y` dan `@stackql/mcp-server`. Berikan kredensial provider sebagai variabel lingkungan di formulir tersebut.

:::note

ChatGPT web dan seluler tidak dapat menjalankan server stdio lokal, sehingga plugin ini hanya untuk desktop dan Codex. Bug ChatGPT desktop yang masih terbuka ([openai/codex#38162](https://github.com/openai/codex/issues/38162)) dapat menyembunyikan alat MCP lokal dari sesi **Chat**; thread mode Work, thread Codex, dan Codex CLI tidak terpengaruh.

:::

**Goose**

### Goose

  Goose menjalankan ekstensi stdio secara langsung, sehingga Anda hanya memerlukan peluncur `npx` (Node.js 18 atau yang lebih baru).

  **Goose Desktop:** klik tombol di bawah ini. Goose akan terbuka, menampilkan perintah yang akan dijalankan dan meminta konfirmasi Anda, lalu menambahkan StackQL sebagai ekstensi.

  Instal di Goose Desktop

  Tombol ini adalah deep link `goose://`; Anda juga dapat menempelkannya ke bilah alamat browser, atau membukanya dari terminal dengan `open` (macOS), `start` (Windows), atau `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"
  ```

  atau jalankan `goose configure`, pilih **Add Extension -> Command-line Extension**, lalu masukkan perintah yang sama. Berikan kredensial provider sebagai variabel lingkungan ekstensi saat diminta.

:::note

Goose telah menghentikan direktori ekstensi di dalam aplikasinya dan beralih ke [Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql), tempat StackQL tercantum sebagai `io.github.stackql/stackql-mcp`. Setelah Goose merilis fitur impor registri, StackQL akan dapat ditemukan di sana tanpa tindakan lebih lanjut.

:::

## Menginstal server MCP

Server MCP StackQL memungkinkan agen AI mengkueri dan menyediakan sumber daya cloud menggunakan StackQL. Server ini didistribusikan melalui beberapa saluran - semuanya menjalankan server yang sama, jadi pilih saluran yang sesuai dengan klien dan persyaratan kepercayaan Anda. Opsi di bawah ini diurutkan kira-kira berdasarkan tingkat kepercayaan dan kemudahan.

### Marketplace dan direktori

Server ini dipublikasikan ke Official MCP Registry sebagai `io.github.stackql/stackql-mcp`; registri paket di bawah ini memuat artefak yang dapat didistribusikan, dan direktori hilir mengambil entri tersebut dari sana.  

**Registri**

| Registri | Tipe | Dipublikasikan melalui | Entri | Catatan |
|---|---|---|---|---|
| Official MCP Registry | Registri metadata kanonis | 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) | menyatakan semua 8 paket (`mcpb x5`, `oci`, `npm`, `pypi`) |
| npm | Registri paket | `npm publish` | [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) | peluncur `npx` |
| PyPI | Registri paket | `twine upload` | [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) | peluncur `uvx` / `pip` |
| Docker Hub | Registri container | `docker buildx --push` | [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) | multiarsitektur `amd64` + `arm64` |
| GitHub Actions Marketplace | Marketplace CI (action `setup-stackql-mcp`) | Repositori publik + rilis + entri marketplace | [`setup-stackql-mcp-server`](https://github.com/marketplace/actions/setup-stackql-mcp-server) | Penerbit terverifikasi; [`stackql/setup-stackql-mcp`](https://github.com/stackql/setup-stackql-mcp) |

**Direktori**

Entri di direktori dan agregator, diurutkan kira-kira berdasarkan tingkat kepentingannya bagi penemuan:

| Direktori | Tipe | Entri |
|---|---|---|
| __Anthropic Connector Directory__ | Direktori dalam aplikasi Claude Desktop | [claude.ai/directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) |
| __OpenAI Plugin Directory__ | Direktori dalam aplikasi ChatGPT desktop (hanya desktop) | cari **StackQL** di aplikasi desktop ChatGPT; lihat [ChatGPT dan Codex](#using-with-mcp-clients) |
| __Cursor Directory__ | Direktori klien IDE | [cursor.directory](https://cursor.directory/plugins/stackql-mcp-server) |
| __mcp.so__ | Agregator terbesar | [mcp.so](https://mcp.so/server/stackql/stackql) |
| __PulseMCP__ | Penemuan, pendukung registri | [pulsemcp](https://www.pulsemcp.com/servers/stackql) |
| __Glama.ai MCP__ | Marketplace yang dapat dicari | [glama.ai](https://glama.ai/mcp/servers/stackql/stackql) |
| __mcpmarket.com__ | Agregator | [mcpmarket](https://mcpmarket.com/server/stackql) |
| __mcpservers.org__ | Situs awesome-list | [mcpservers.org](https://mcpservers.org/servers/stackql-mcp-server) |

### Bundle `.mcpb` siap pakai

**Kapan digunakan:** Claude Desktop tanpa akses ke Connector Directory, atau ketika Anda ingin mengunci versi tertentu atau memverifikasi checksum sendiri sebelum menginstal.  Bagi sebagian besar pengguna Claude Desktop, [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) adalah metode instalasi yang direkomendasikan.

MCP Bundle siap pakai untuk setiap platform dilampirkan pada setiap rilis StackQL:

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

dengan `<platform>` salah satu dari `darwin-universal`, `windows-x64` (AMD64), `windows-arm64`, `linux-x64`, atau `linux-arm64`. Tombol unduh untuk setiap platform ada di tab **Claude Desktop** di bagian [Menggunakan dengan klien MCP](#using-with-mcp-clients). Setiap bundle memiliki checksum `.sha256` yang sesuai di [halaman rilis](https://github.com/stackql/stackql/releases/latest). Verifikasi checksum tersebut, lalu instal melalui **Settings -> Extensions** di Claude Desktop:

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

Lihat [Menggunakan StackQL dengan Claude Desktop](/getting-started/claude-desktop#install-from-a-downloaded-bundle) untuk panduan lengkap.

### `claude_desktop_config.json` manual

**Kapan digunakan:** biner `stackql` sudah ada di PATH Anda dan Anda menggunakan Claude Desktop atau klien MCP stdio lainnya.

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

Ketiga argumen ini diperlukan:

- `--mcp.server.type=stdio` memilih transport stdio yang digunakan oleh klien yang tersemat di editor.
- `--approot` mengarahkan cache provider ke direktori yang dapat ditulis. Klien MCP dapat meluncurkan server dengan direktori kerja yang diatur ke `/`, yang tidak dapat ditulis.
- `--mcp.config '{"server": {"audit": {"disabled": true}}}'` menonaktifkan log audit, yang jika tidak dinonaktifkan akan menggunakan direktori kerja (yang mungkin tidak dapat ditulis) sebagai direktori default.

Tambahkan kredensial provider dengan blok `"env"` dan sesuaikan kontrak keamanan dengan `"mode"` - lihat [Mode server](/command-line-usage/mcp#server-modes).

### `npx` (tanpa instalasi)

**Kapan digunakan:** lingkungan Node apa pun, ketika Anda tidak ingin menginstal StackQL secara global.

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

Peluncur [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) mengunduh biner `stackql` yang ditandatangani saat pertama kali dijalankan, memverifikasi SHA-256 biner tersebut, dan menyimpannya di cache untuk penggunaan berikutnya.

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

**Kapan digunakan:** lingkungan Python - peluncur yang sama yang dikemas untuk Python, dan berbagi cache biner yang diisi oleh peluncur npx.

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

Atau instal ke lingkungan saat ini dengan `pip install stackql-mcp-server` (Python 3.9+). Nama paket di PyPI adalah [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/).

### Docker

**Kapan digunakan:** runtime dalam container atau runtime terisolasi lainnya. Image ini multiarsitektur (amd64 dan arm64).

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

Sebagai konfigurasi klien:

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

Nama image di Docker Hub adalah [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp).

### CI dan workflow agentik (GitHub Actions)

**Kapan digunakan:** jalankan server di dalam job GitHub Actions agar agen dapat mengkueri lingkungan cloud Anda - dan, jika Anda mengizinkan, mengambil tindakan di dalamnya - sebagai bagian dari CI.

[`stackql/setup-stackql-mcp@v1`](https://github.com/marketplace/actions/setup-stackql-mcp-server) menginstal biner dan menulis konfigurasi MCP (secara default dalam mode `read_only`). Teruskan konfigurasi tersebut ke [`anthropics/claude-code-action`](https://github.com/anthropics/claude-code-action) melalui `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__*'
```

Lihat [README action](https://github.com/stackql/setup-stackql-mcp) untuk resep agentik lainnya (audit cloud, estimasi biaya, dan sebagainya).

### MCP tersemat

**Kapan digunakan:** Anda sedang membangun aplikasi agentik dan ingin menyertakan server MCP ke dalam biner Anda sendiri melalui vendoring - tanpa `npx`, tanpa instalasi terpisah, tanpa dependensi runtime.

Library native menjalankan biner `stackql` yang ditandatangani melalui stdio di balik klien SDK MCP resmi setiap bahasa, sehingga aplikasi Anda mendapatkan antarmuka SQL terkendali yang sama ke setiap provider di registri. Setiap library secara default menggunakan `read_only` - eskalasi ke mode yang dapat menulis selalu eksplisit - dan dapat mengunduh lalu memverifikasi biner saat pertama kali dijalankan, atau menyertakannya ke dalam build Anda melalui vendoring untuk satu file executable mandiri. API lengkap per bahasa ada di [referensi MCP tersemat](/mcp/embedded).

**Rust**

Crate `stackql-mcp` menjalankan biner di balik klien `rmcp`. Fitur default `sidecar` mengunduh dan memverifikasi biner saat pertama kali dijalankan; fitur `vendored` menyematkannya dengan `include_bytes!` untuk satu biner mandiri. 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?;
```

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

Referensi lengkap: [MCP tersemat: Rust](/mcp/embedded/rust).

**Go**

Library `stackql-mcp-go` menjalankan biner di balik klien SDK MCP Go resmi. Sertakan biner melalui vendoring dengan `go:embed` untuk satu biner mandiri, atau biarkan library mengunduh dan memverifikasinya saat pertama kali dijalankan. Secara default dimulai dalam mode `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()
```

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

Referensi lengkap: [MCP tersemat: Go](/mcp/embedded/go).

**Kotlin / JVM**

Library `io.stackql:stackql-mcp` menjalankan biner di balik klien SDK MCP Kotlin resmi, dan plugin Gradle pendamping menghubungkan peluncuran yang sama ke dalam build. Memerlukan JDK 17 dan 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
}
```

[Lihat di GitHub](https://github.com/stackql/stackql-mcp-kotlin)

Referensi lengkap: [MCP tersemat: Kotlin / JVM](/mcp/embedded/kotlin).

**.NET**

Paket `StackQL.Mcp` menjalankan biner di balik klien SDK MCP C# resmi. Secara default berupa sidecar, atau sertakan bundle melalui vendoring sebagai sumber daya build untuk file executable mandiri. Memerlukan .NET 8 atau yang lebih baru.

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

[Lihat di GitHub](https://github.com/stackql/stackql-mcp-dotnet)

Referensi lengkap: [MCP tersemat: .NET / C#](/mcp/embedded/dotnet).

**Gleam**

Library `stackql_mcp` menargetkan runtime Erlang/BEAM dan mengekspos server sebagai child OTP melalui `child_spec()`, sehingga server dapat ditempatkan di dalam supervision tree Anda sendiri. Secara default dimulai dalam mode `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)
```

[Lihat di GitHub](https://github.com/stackql/stackql-mcp-gleam)

Referensi lengkap: [MCP tersemat: Gleam](/mcp/embedded/gleam).

**Swift**

Paket `stackql-mcp-swift` menjalankan biner di balik klien SDK MCP Swift resmi. Biner `darwin-universal` ditandatangani dengan Developer ID dan dinotarisasi oleh Apple, sehingga Anda dapat menyertakannya di dalam `.app` yang ditandatangani dan notarisasi aplikasi tetap valid. Memerlukan macOS 13+ dan 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()
```

[Lihat di GitHub](https://github.com/stackql/stackql-mcp-swift)

Referensi lengkap: [MCP tersemat: Swift](/mcp/embedded/swift).

### Model kepercayaan

Properti keamanan yang sama berlaku di setiap saluran:

- Biner `stackql` yang tersemat ditandatangani dengan Authenticode (Windows) dan dinotarisasi oleh Apple (macOS).
- Setiap bundle `.mcpb` disertai checksum SHA-256 yang dipublikasikan di halaman rilis.
- Peluncur `npx` dan `uvx` memverifikasi SHA-256 biner yang diunduh sebelum penggunaan pertama.
- Entri di [MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) mengesahkan hash per platform.

## Menggunakan GitHub Actions

[GitHub Actions StackQL](https://github.com/stackql/stackql-actions-demo) tersedia untuk digunakan dalam workflow GitHub Actions Anda. Action berikut tersedia:

**stackql-deploy**

### `stackql-deploy`

Gunakan StackQL untuk men-deploy atau menguji stack infrastruktur langsung dari workflow GitHub Anda. Action ini memungkinkan workflow infrastruktur sebagai kode (IaC) dengan sintaksis mirip SQL, sehingga Anda dapat mendefinisikan, men-deploy, dan mengelola sumber daya cloud di beberapa provider dalam satu workflow.  

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

__Contoh penggunaan__

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

Siapkan StackQL di workflow GitHub Actions Anda.  

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

__Contoh penggunaan__

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

Instal server MCP StackQL di workflow GitHub Actions Anda.  Action ini menginstal biner yang ditandatangani dan menulis konfigurasi `mcpServers` (secara default dalam mode `read_only`) yang digunakan oleh langkah agentik seperti `anthropics/claude-code-action` melalui `claude_args`.

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

__Contoh penggunaan__

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

Jalankan perintah StackQL di workflow GitHub Actions Anda.  Kueri dapat diberikan secara inline atau dari file di repositori.  

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

__Contoh penggunaan__

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

Jalankan pengujian unit di workflow GitHub Actions Anda (untuk pemeriksaan penjaminan, tata kelola, atau keamanan cloud).  

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

__Contoh penggunaan__

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

## Library lainnya

StackQL menyediakan beberapa metode integrasi untuk digunakan dalam berbagai bahasa pemrograman dan lingkungan. Library ini memperluas fungsionalitas StackQL, sehingga Anda dapat dengan mudah menambahkan kemampuan mengkueri dan mengelola sumber daya cloud ke aplikasi dan workflow yang sudah ada.  

**pystackql**

### Paket Python `pystackql`

Wrapper Python untuk menggunakan StackQL dalam program Python Anda. Paket `pystackql` tersedia di [__PyPI__](https://pypi.org/project/pystackql/), dan dokumentasi paket `pystackql` tersedia di [__Read the Docs__](https://pystackql.readthedocs.io/en/latest/). Untuk menginstal paket `pystackql`, jalankan perintah berikut:

```bash
pip install pystackql
```

Contoh berikut menunjukkan paket `pystackql` yang digunakan bersama `pandas` untuk menjalankan kueri StackQL dan mengembalikan hasilnya ke `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)
```
