# Instalación

> Instale StackQL en macOS, Linux, Windows, Docker o un shell en la nube y use el servidor MCP de StackQL desde Claude Desktop, ChatGPT, Goose y otros clientes MCP, o mediante npx, uvx, pip, Docker y GitHub Actions.

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

Aquí se proporcionan las instrucciones para instalar StackQL en distintas plataformas.

**macOS**

## macOS

StackQL está disponible en macOS mediante Homebrew y el instalador `pkg`; se admiten tanto la arquitectura ARM (M1/Apple Silicon) como la AMD con un único instalador multiarquitectura.

**Homebrew**

Para instalar mediante Homebrew, ejecute el siguiente comando en su terminal:

```bash
brew install stackql
```

**curl (binario firmado y notarizado)**

Para instalar un binario ejecutable `stackql` firmado y notarizado en el directorio actual, ejecute el siguiente comando en su terminal:

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

**Descarga del paquete**

StackQL está disponible como instalador `pkg` interactivo, firmado y notarizado, para macOS.

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

**Linux**

## Linux

StackQL está disponible para todas las arquitecturas de Linux.

**curl**

Para instalar un binario ejecutable `stackql` en el directorio actual para su arquitectura de Linux (amd64 o arm64), ejecute el siguiente comando en su terminal:

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

**Descarga del paquete**

Como alternativa, puede descargar los binarios aquí:

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

**Windows**

## Windows

StackQL está disponible en Windows mediante Chocolatey, el script de instalación de PowerShell y el instalador MSI. Los builds nativos para AMD64 (x64) y ARM64 están disponibles como instaladores MSI y archivos ZIP que contienen `stackql.exe`. El build para AMD64 también se ejecuta en ARM64 mediante emulación. Todos los ejecutables están firmados con un certificado de firma de código Authenticode.

**Chocolatey**

Para instalar mediante Chocolatey, ejecute el siguiente comando en su terminal de PowerShell o `cmd`:

```powershell
choco install stackql
```

**Invoke-RestMethod**

Para instalar un ejecutable firmado con Authenticode en el directorio actual, ejecute lo siguiente en un terminal de PowerShell: 

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

**Descarga de MSI/ZIP**

Descargue a continuación el instalador o el ejecutable firmado de `stackql` para Windows. Al hacer clic en un botón de descarga se selecciona AMD64 de forma predeterminada; use su menú desplegable para elegir AMD64 o ARM64 nativo.

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

**Docker**

## Docker

Los builds de StackQL se publican en [DockerHub](https://hub.docker.com/u/stackql).  

__Docker Hub__  

Para descargar la imagen de contenedor de StackQL, ejecute el siguiente comando:

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

A partir de `v1.0`, la imagen se basa en Ubuntu 26.04 LTS y se publica una variante con Python 3.13 preinstalado con el sufijo de tag `-python3.13` (alias `-python3`), por ejemplo:

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

**stackql-deploy**

## `stackql-deploy`

`stackql-deploy` es un marco de IaC sin estado construido sobre StackQL. Para ver la documentación completa, consulte la [__documentación de StackQL Deploy__](https://stackql-deploy.io/).

__Linux / macOS__

Descarga y extrae el binario más reciente de `stackql-deploy` en un solo paso. El instalador detecta su sistema operativo y su arquitectura (incluidos Apple Silicon e Intel mediante un binario universal para macOS) y obtiene automáticamente el archivo de versión correcto.
```bash
curl -fsSL https://get-stackql-deploy.io/install.sh | sh
```

__Windows__

Descarga y extrae el binario más reciente de `stackql-deploy` en el directorio actual.
El instalador detecta su plataforma y obtiene automáticamente el archivo de versión correcto.
```powershell
irm https://get-stackql-deploy.io/install.ps1 | iex
```

__cargo__

Si tiene instalada la cadena de herramientas de Rust, este comando compila e instala el binario directamente desde [__crates.io__](https://crates.io/crates/stackql-deploy).
```bash
cargo install stackql-deploy
```

**Shells en la nube**

## Shells en la nube

StackQL se puede usar directamente desde los shells en la nube y los terminales web incorporados de las principales plataformas en la nube y de datos. Esto ofrece una experiencia fluida, ya que estos entornos están preautorizados con la identidad con la que ha iniciado sesión, lo que elimina la necesidad de configurar la autenticación por separado.

**AWS**

### AWS Cloud Shell

AWS CloudShell proporciona un shell basado en navegador con la AWS CLI preinstalada y autenticada. Ejecutar StackQL en AWS CloudShell le permite consultar y gestionar recursos de AWS sin pasos de autenticación adicionales. Para obtener instrucciones detalladas, consulte nuestro [tutorial de AWS CloudShell](/quick-starts/aws/aws-cloud-shell).

Primero, descargue el paquete de StackQL:

```bash
curl -fsSL https://get-stackql.io/install/aws | sh
```
A continuación, ejecute el script de StackQL para AWS CloudShell:

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

Este script inicia un shell de comandos de StackQL con sus credenciales de AWS CloudShell, lo que le permite empezar a consultar recursos de AWS de inmediato.

**Azure**

### Azure Cloud Shell

Azure Cloud Shell proporciona un entorno de shell accesible desde el navegador con la Azure CLI autenticada previamente con su cuenta de Azure. Usar StackQL en Azure Cloud Shell permite consultar sus recursos de Azure de forma fluida y sin configuración adicional. Para conocer todos los detalles, consulte nuestra [guía de Azure Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-azure-cloud-shell).  

Primero, descargue el paquete de StackQL:

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

A continuación, ejecute el script de StackQL para Azure Cloud Shell:

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

Este script configura automáticamente una sesión de StackQL para que use sus credenciales de Azure Cloud Shell, lo que permite acceder de inmediato a consultar sus recursos de Azure.

**Google**

### Google Cloud Shell

Google Cloud Shell ofrece un entorno de desarrollo y operaciones con la Google Cloud CLI ya autenticada. Ejecutar StackQL en Google Cloud Shell le permite consultar recursos de GCP con su autenticación existente. Obtenga más información en nuestra [guía de Google Cloud Shell](/blog/tutorials/using-stackql-in-native-cloud-shells-in-aws-azure-and-gcp#using-stackql-in-the-google-cloud-shell).  

Primero, descargue el paquete de StackQL:

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

A continuación, ejecute el script de StackQL para Google Cloud Shell:

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

El script configura StackQL para que use sus credenciales de Google Cloud Shell, lo que le permite empezar a consultar de inmediato sus recursos de GCP con sintaxis SQL.

**Databricks**

### Databricks Web Terminal

Los espacios de trabajo de Databricks incluyen un terminal web que se ejecuta como el usuario que ha iniciado sesión. Ejecutar StackQL allí le permite consultar su espacio de trabajo con su identidad de Databricks, sin configurar la autenticación por separado. Para ver consultas de ejemplo y la autenticación a nivel de cuenta, consulte nuestra [guía de Databricks Web Terminal](/blog/tutorials/stackql-in-databricks-web-terminal).

Primero, descargue el paquete de StackQL:

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

A continuación, ejecute el script de shell de StackQL para Databricks:

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

Esto inicia una sesión de StackQL con la identidad de su espacio de trabajo de Databricks, de modo que puede consultar de inmediato recursos con ámbito de espacio de trabajo, como `databricks_workspace.iam.vw_user_entitlements`. Para las consultas a nivel de cuenta (aprovisionamiento, facturación, IAM de la cuenta), establezca las variables del principal de servicio OAuth2 de Databricks como se describe en la guía.

## Usar con clientes MCP

El servidor MCP de StackQL se ejecuta localmente sobre stdio, por lo que las credenciales de los providers permanecen en su equipo sea cual sea el cliente que use. Elija su cliente a continuación: cada pestaña presenta primero la vía del directorio o de un solo clic y la configuración manual como alternativa. Para ver todos los canales de distribución, incluidos `npx`, Python, Docker y CI, consulte [Instalar el servidor MCP](#installing-the-mcp-server).

**Claude Desktop**

### Claude Desktop

  La forma recomendada de instalar el servidor MCP de StackQL en Claude Desktop es desde el [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) (**Settings -> Connectors -> Add -> Browse Connectors**, busque **StackQL**) - Claude Desktop selecciona automáticamente el binario firmado correcto para su plataforma.  Como alternativa, a cada versión de StackQL se adjuntan MCP Bundles precompilados (`.mcpb`) para instalar desde un archivo descargado - en ninguno de los dos casos se requiere una instalación de StackQL por separado.  Los bundles están disponibles para macOS, Windows y Linux.

  Las descargas de MCPB para Linux y Windows usan **amd64** (x64) de forma predeterminada. Use los menús desplegables para seleccionar **amd64** o **arm64**.

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

:::info

El servidor MCP de StackQL también figura en el [__Official MCP Registry__](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) como `io.github.stackql/stackql-mcp`.

:::

:::tip

El bundle es una de las varias formas de ejecutar el servidor MCP de StackQL.  Consulte [__Usar StackQL con Claude Desktop__](/getting-started/claude-desktop) para ver la guía paso a paso completa de Claude Desktop, o [__Instalar el servidor MCP__](#installing-the-mcp-server) para las opciones de npx, Docker, Python, CI y manual.

:::

**ChatGPT**

### ChatGPT y Codex

  StackQL se distribuye como plugin local para la aplicación de escritorio de ChatGPT y la CLI de Codex. El plugin ejecuta el servidor MCP de StackQL sobre stdio en su equipo, por lo que las credenciales de los providers nunca salen de él. Se requiere Node.js 24.22.1 o posterior (22.23.4 o 26.12.1 en esas líneas de versiones); el plugin solo necesita los módulos incorporados de Node.js, descarga el binario `stackql` firmado en el primer uso y verifica su SHA-256.

  **Aplicación de escritorio de ChatGPT (directorio de plugins):**  

  abra el directorio de plugins en la aplicación de escritorio de ChatGPT, busque **StackQL** y haga clic en **Install**, después ejecute la configuración del plugin; la skill `stackql-setup` incluida explica paso a paso las credenciales y una primera consulta. La entrada lleva una insignia **Desktop only**: el plugin solo se instala desde la aplicación de escritorio, no desde ChatGPT web ni móvil, y sus herramientas están disponibles en el modo Work, en los hilos que se ejecutan en su equipo. Si la entrada aún no aparece en su directorio, instale desde el marketplace del repositorio.

  **Aplicación de escritorio de ChatGPT (marketplace del repositorio):**  

  abra **Settings -> Plugins -> Add -> Add from GitHub**, escriba `stackql/stackql`, después instale **StackQL** desde la sección **Personal** del directorio de plugins y reinicie la aplicación.

  **CLI de Codex:**

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

  Reinicie ChatGPT de escritorio o Codex y después pruebe: *Usa StackQL para instalar el provider de GitHub si hace falta y luego enumera los cinco primeros servicios de GitHub.* Las credenciales de los providers van en `~/.stackql/.env` con los nombres de variables de entorno estándar de cada provider (por ejemplo, `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY`); después de editar el archivo, pida al agente que llame a `reload_credentials`.

  **Sin el plugin:**   

  en **Settings -> Plugins -> MCPs -> Connect to a custom MCP**, elija **STDIO**, establezca el comando en `npx` y agregue los argumentos `-y` y `@stackql/mcp-server`. Proporcione las credenciales de los providers como variables de entorno en ese formulario.

:::note

ChatGPT web y móvil no pueden ejecutar un servidor stdio local, por lo que el plugin es solo para escritorio y Codex. Un error abierto de ChatGPT de escritorio ([openai/codex#38162](https://github.com/openai/codex/issues/38162)) puede ocultar las herramientas MCP locales en las sesiones de **Chat**; los hilos del modo Work, los hilos de Codex y la CLI de Codex no se ven afectados.

:::

**Goose**

### Goose

  Goose ejecuta extensiones stdio directamente, por lo que el lanzador `npx` es todo lo que necesita (Node.js 18 o posterior).

  **Goose Desktop:** haga clic en el botón siguiente. Goose se abre, muestra el comando que va a ejecutar y le pide que confirme; después agrega StackQL como extensión.

  Instalar en Goose Desktop

  El botón es un enlace profundo `goose://`; también puede pegarlo en la barra de direcciones de su navegador o abrirlo desde un terminal con `open` (macOS), `start` (Windows) o `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"
  ```

  o ejecute `goose configure`, elija **Add Extension -> Command-line Extension** y escriba el mismo comando. Proporcione las credenciales de los providers como variables de entorno de la extensión cuando se le soliciten.

:::note

Goose ha retirado su directorio de extensiones dentro de la aplicación en favor del [Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql), donde StackQL figura como `io.github.stackql/stackql-mcp`. Cuando Goose publique su importación desde el registro, StackQL se podrá encontrar allí sin ninguna otra acción.

:::

## Instalar el servidor MCP

El servidor MCP de StackQL permite a los agentes de IA consultar y aprovisionar recursos en la nube con StackQL. Se distribuye por varios canales - todos ejecutan el mismo servidor, así que elija el canal que se ajuste a su cliente y a sus requisitos de confianza. Las opciones siguientes se enumeran aproximadamente por orden de confianza y facilidad.

### Marketplaces y directorios

El servidor está publicado en el Official MCP Registry como `io.github.stackql/stackql-mcp`; los registros de paquetes siguientes contienen los artefactos distribuibles, y los directorios derivados toman la entrada de allí.  

**Registros**

| Registro | Tipo | Publicado mediante | Entrada | Notas |
|---|---|---|---|---|
| Official MCP Registry | Registro canónico de metadatos | 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) | anuncia los 8 paquetes (`mcpb x5`, `oci`, `npm`, `pypi`) |
| npm | Registro de paquetes | `npm publish` | [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) | lanzador `npx` |
| PyPI | Registro de paquetes | `twine upload` | [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) | lanzador `uvx` / `pip` |
| Docker Hub | Registro de contenedores | `docker buildx --push` | [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) | multiarquitectura `amd64` + `arm64` |
| GitHub Actions Marketplace | Marketplace de CI (acción `setup-stackql-mcp`) | Repositorio público + versión + entrada del marketplace | [`setup-stackql-mcp-server`](https://github.com/marketplace/actions/setup-stackql-mcp-server) | Editor verificado; [`stackql/setup-stackql-mcp`](https://github.com/stackql/setup-stackql-mcp) |

**Directorios**

Entradas en directorios y agregadores, aproximadamente por orden de importancia para el descubrimiento:

| Directorio | Tipo | Entrada |
|---|---|---|
| __Anthropic Connector Directory__ | Directorio dentro de la aplicación Claude Desktop | [claude.ai/directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) |
| __OpenAI Plugin Directory__ | Directorio dentro de la aplicación de escritorio de ChatGPT (solo escritorio) | busque **StackQL** en la aplicación de escritorio de ChatGPT; consulte [ChatGPT y Codex](#using-with-mcp-clients) |
| __Cursor Directory__ | Directorio de un cliente IDE | [cursor.directory](https://cursor.directory/plugins/stackql-mcp-server) |
| __mcp.so__ | El mayor agregador | [mcp.so](https://mcp.so/server/stackql/stackql) |
| __PulseMCP__ | Descubrimiento, impulsor del registro | [pulsemcp](https://www.pulsemcp.com/servers/stackql) |
| __Glama.ai MCP__ | Marketplace con búsqueda | [glama.ai](https://glama.ai/mcp/servers/stackql/stackql) |
| __mcpmarket.com__ | Agregador | [mcpmarket](https://mcpmarket.com/server/stackql) |
| __mcpservers.org__ | Sitio de tipo awesome-list | [mcpservers.org](https://mcpservers.org/servers/stackql-mcp-server) |

### Bundle `.mcpb` precompilado

**Cuándo usarlo:** Claude Desktop sin acceso al Connector Directory, o cuando quiere fijar una versión específica o verificar usted mismo las sumas de comprobación antes de instalar.  Para la mayoría de los usuarios de Claude Desktop, el [Anthropic Connector Directory](https://claude.ai/directory/connectors/ant.dir.gh.stackql.stackql) es el método de instalación recomendado.

A cada versión de StackQL se adjunta un MCP Bundle precompilado para cada plataforma:

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

donde `<platform>` es `darwin-universal`, `windows-x64` (AMD64), `windows-arm64`, `linux-x64` o `linux-arm64`. Los botones de descarga de cada plataforma están en la pestaña **Claude Desktop**, en [Usar con clientes MCP](#using-with-mcp-clients). Cada bundle tiene su suma de comprobación `.sha256` correspondiente en la [página de la versión](https://github.com/stackql/stackql/releases/latest). Verifíquela y después instale mediante **Settings -> Extensions** en Claude Desktop:

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

Consulte [Usar StackQL con Claude Desktop](/getting-started/claude-desktop#install-from-a-downloaded-bundle) para ver la guía paso a paso completa.

### `claude_desktop_config.json` manual

**Cuándo usarlo:** ya tiene el binario `stackql` en su PATH y usa Claude Desktop o cualquier otro cliente MCP stdio.

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

Los tres argumentos son imprescindibles:

- `--mcp.server.type=stdio` selecciona el transporte stdio que usan los clientes integrados en editores.
- `--approot` dirige la caché de providers a un directorio con permiso de escritura. Los clientes MCP pueden iniciar el servidor con el directorio de trabajo establecido en `/`, donde no se puede escribir.
- `--mcp.config '{"server": {"audit": {"disabled": true}}}'` deshabilita el log de auditoría, que de lo contrario usa como directorio predeterminado el directorio de trabajo (en el que quizá no se pueda escribir).

Agregue las credenciales de los providers con un bloque `"env"` y ajuste el contrato de seguridad con `"mode"` - consulte [Modos del servidor](/command-line-usage/mcp#server-modes).

### `npx` (sin instalación)

**Cuándo usarlo:** cualquier entorno Node, cuando no quiere una instalación global de StackQL.

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

El lanzador [`@stackql/mcp-server`](https://www.npmjs.com/package/@stackql/mcp-server) descarga el binario `stackql` firmado en la primera ejecución, verifica su SHA-256 y lo guarda en caché para las ejecuciones posteriores.

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

**Cuándo usarlo:** un entorno Python - el mismo lanzador empaquetado para Python, que comparte la caché de binarios que llena el lanzador npx.

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

O instálelo en el entorno actual con `pip install stackql-mcp-server` (Python 3.9+). El paquete es [`stackql-mcp-server`](https://pypi.org/project/stackql-mcp-server/) en PyPI.

### Docker

**Cuándo usarlo:** un runtime en contenedor o aislado de otra forma. La imagen es multiarquitectura (amd64 y arm64).

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

Como configuración de cliente:

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

La imagen es [`stackql/stackql-mcp`](https://hub.docker.com/r/stackql/stackql-mcp) en Docker Hub.

### CI y workflows agénticos (GitHub Actions)

**Cuándo usarlo:** ejecute el servidor dentro de un job de GitHub Actions para que un agente pueda consultar su nube (y, si usted lo permite, actuar sobre ella) como parte de la CI.

[`stackql/setup-stackql-mcp@v1`](https://github.com/marketplace/actions/setup-stackql-mcp-server) instala el binario y escribe una configuración de MCP (con el modo `read_only` de forma predeterminada). Pase esa configuración a [`anthropics/claude-code-action`](https://github.com/anthropics/claude-code-action) mediante `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__*'
```

Consulte el [README de la acción](https://github.com/stackql/setup-stackql-mcp) para ver más recetas agénticas (auditorías de nube, estimaciones de costos, etc.).

### MCP integrado

**Cuándo usarlo:** está creando una aplicación agéntica y quiere incorporar el servidor MCP a su propio binario mediante vendoring - sin `npx`, sin instalación por separado, sin dependencia de runtime.

Las bibliotecas nativas inician el binario `stackql` firmado sobre stdio detrás del cliente del SDK oficial de MCP de cada lenguaje, de modo que su aplicación obtiene la misma interfaz SQL gobernada para todos los providers del registro. Cada biblioteca usa `read_only` de forma predeterminada (el paso a un modo con escritura siempre es explícito) y puede descargar y verificar el binario en la primera ejecución o incorporarlo a su build mediante vendoring para obtener un único ejecutable autónomo. La API completa por lenguaje está en la [referencia de MCP integrado](/mcp/embedded).

**Rust**

El crate `stackql-mcp` inicia el binario detrás de un cliente `rmcp`. La funcionalidad predeterminada `sidecar` descarga y verifica el binario en la primera ejecución; la funcionalidad `vendored` lo integra con `include_bytes!` para obtener un único binario autónomo. 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?;
```

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

Referencia completa: [MCP integrado: Rust](/mcp/embedded/rust).

**Go**

La biblioteca `stackql-mcp-go` inicia el binario detrás del cliente del SDK oficial de MCP para Go. Incorpore el binario mediante vendoring con `go:embed` para obtener un único binario autónomo, o deje que lo descargue y verifique en la primera ejecución. Se inicia en modo `read_only` de forma predeterminada.

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

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

Referencia completa: [MCP integrado: Go](/mcp/embedded/go).

**Kotlin / JVM**

La biblioteca `io.stackql:stackql-mcp` inicia el binario detrás del cliente del SDK oficial de MCP para Kotlin, y un plugin de Gradle complementario conecta ese mismo inicio a un build. Requiere JDK 17 y 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
}
```

[Ver en GitHub](https://github.com/stackql/stackql-mcp-kotlin)

Referencia completa: [MCP integrado: Kotlin / JVM](/mcp/embedded/kotlin).

**.NET**

El paquete `StackQL.Mcp` inicia el binario detrás del cliente del SDK oficial de MCP para C#. Sidecar de forma predeterminada, o incorpore el bundle mediante vendoring como recurso de build para obtener un ejecutable autónomo. Requiere .NET 8 o posterior.

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

[Ver en GitHub](https://github.com/stackql/stackql-mcp-dotnet)

Referencia completa: [MCP integrado: .NET / C#](/mcp/embedded/dotnet).

**Gleam**

La biblioteca `stackql_mcp` está dirigida al runtime Erlang/BEAM y expone el servidor como un hijo de OTP mediante `child_spec()`, de modo que puede formar parte de su propio árbol de supervisión. Se inicia en modo `read_only` de forma predeterminada.

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

[Ver en GitHub](https://github.com/stackql/stackql-mcp-gleam)

Referencia completa: [MCP integrado: Gleam](/mcp/embedded/gleam).

**Swift**

El paquete `stackql-mcp-swift` inicia el binario detrás del cliente del SDK oficial de MCP para Swift. El binario `darwin-universal` está firmado con Developer ID y notarizado por Apple, por lo que puede incluirlo dentro de una `.app` firmada y mantener válida la notarización de la aplicación. Requiere macOS 13+ y 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()
```

[Ver en GitHub](https://github.com/stackql/stackql-mcp-swift)

Referencia completa: [MCP integrado: Swift](/mcp/embedded/swift).

### Modelo de confianza

Las mismas propiedades de seguridad se cumplen en todos los canales:

- El binario `stackql` integrado está firmado con Authenticode (Windows) y notarizado por Apple (macOS).
- Cada bundle `.mcpb` se distribuye con una suma de comprobación SHA-256 publicada en la página de la versión.
- Los lanzadores `npx` y `uvx` verifican el SHA-256 del binario descargado antes del primer uso.
- La entrada del [MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=stackql) certifica los hashes por plataforma.

## Usar GitHub Actions

Las [GitHub Actions de StackQL](https://github.com/stackql/stackql-actions-demo) están disponibles para usarlas en sus workflows de GitHub Actions. Están disponibles las siguientes acciones:

**stackql-deploy**

### `stackql-deploy`

Despliegue o pruebe stacks de infraestructura con StackQL directamente desde sus workflows de GitHub. Esta acción habilita workflows de infraestructura como código (IaC) con una sintaxis similar a SQL, lo que le permite definir, desplegar y gestionar recursos en la nube de varios providers en un único workflow.  

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

__Ejemplo de uso__

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

Configure StackQL en su workflow de GitHub Actions.  

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

__Ejemplo de uso__

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

Instale el servidor MCP de StackQL en su workflow de GitHub Actions.  La acción instala el binario firmado y escribe una configuración `mcpServers` (con el modo `read_only` de forma predeterminada) que un paso agéntico como `anthropics/claude-code-action` consume mediante `claude_args`.

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

__Ejemplo de uso__

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

Ejecute comandos de StackQL en su workflow de GitHub Actions.  Las consultas se pueden proporcionar en línea o desde un archivo del repositorio.  

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

__Ejemplo de uso__

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

Realice pruebas unitarias en su workflow de GitHub Actions (para comprobaciones de aseguramiento, gobernanza o seguridad en la nube).  

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

__Ejemplo de uso__

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

## Otras bibliotecas

StackQL ofrece varios métodos de integración que permiten usarlo en distintos lenguajes de programación y entornos. Estas bibliotecas amplían la funcionalidad de StackQL y facilitan la incorporación de la consulta y la gestión de recursos en la nube a sus aplicaciones y workflows existentes.  

**pystackql**

### Paquete de Python `pystackql`

Wrapper de Python para usar StackQL en sus programas de Python. El paquete `pystackql` está disponible en [__PyPi__](https://pypi.org/project/pystackql/); la documentación del paquete `pystackql` está disponible en [__Read the Docs__](https://pystackql.readthedocs.io/en/latest/). Para instalar el paquete `pystackql`, ejecute el siguiente comando:

```bash
pip install pystackql
```

El siguiente ejemplo muestra el paquete `pystackql` usado junto con `pandas` para ejecutar consultas de StackQL y devolver los resultados en 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)
```