# Terraform MCP Server: tu IA ya sabe leer el Registry (y vos podés tomar mate)

Acordate de la última vez que escribiste un recurso de Terraform que no usabas hace tres meses. Abriste el Registry. Buscaste el provider. Entraste a la doc. Chequeaste qué atributos eran requeridos en la versión actual. Volviste al editor. Escribiste mal el nombre. Volviste al Registry. Copiaste el snippet. El snippet estaba deprecado.

Eso se llama contexto switching. Y mata la productividad más silenciosamente que un merge conflict un viernes a las 6pm.

Hoy arrancamos una serie para erradicarlo. Y el primer episodio tiene protagonista: el **Terraform MCP Server**.

* * *

## ¿Qué es MCP y por qué te debería importar?

MCP son las siglas de **Model Context Protocol** un estándar abierto que le permite a los modelos de AI conectarse de forma segura con herramientas externas, aplicaciones y fuentes de datos. La idea es simple y poderosa: en vez de que la IA trabaje solo con lo que aprendió hasta su fecha de corte, puede consultar información actualizada en tiempo real.

HashiCorp lanzó su propio MCP Server para Terraform y es exactamente lo que el nombre promete: un servidor que le da a tu IA acceso directo al Terraform Registry. Providers, módulos, políticas Sentinel, workspaces de HCP Terraform todo disponible en el momento en que lo necesitás, desde tu IDE, sin cambiar de pantalla.

> "En vez de que la IA adivine cómo se configura un `aws_s3_bucket` con la versión actual del provider, le pregunta al Registry directamente."

Está en **beta** (v0.5.x), pero ya funciona muy bien para el día a día.

> Pensalo como el "USB-C" de los agentes de AI: un protocolo universal para enchufar contexto.

Acá el diagrama de arquitectura completo:

![](https://cdn.hashnode.com/uploads/covers/620c453d7cf10d2765e28b6c/70d12a4b-5250-48ee-a22e-e5a0ad3919ba.svg align="center")

* * *

## Cómo funciona por dentro

El flujo es así:

```plaintext
Vos escribís un prompt en tu IDE
         ↓
    IA Agent (Copilot / Cursor / Claude)
         ↓
    Terraform MCP Server
         ↓
    Terraform Registry (docs actualizadas, en vivo)
         ↓
    HCL correcto en tu editor
```

Los componentes clave que necesitás entender:

*   **MCP Host**: tu IDE (VS Code, Cursor) o app como Claude Desktop
    
*   **MCP Client**: el agente de AI que interpreta tus prompts
    
*   **MCP Server**: el servidor de Terraform que expone las herramientas
    
*   **Transport**: cómo se comunican — por defecto usa `stdio` (stdin/stdout), también soporta HTTP streamable para deployments remotos
    

El MCP Server tiene tres toolsets principales:

| Toolset | Para qué sirve |
| --- | --- |
| `registry` | Registry público de Terraform |
| `registry-private` | Registry privado de tu organización |
| `terraform` | HCP Terraform y Terraform Enterprise |

Y dentro de `registry`, los tools que vas a usar más seguido son:

*   `search_providers` — busca documentación por servicio
    
*   `get_provider_details` — documentación completa de un recurso
    
*   `search_modules` — encuentra módulos por nombre o funcionalidad
    
*   `get_module_details` — inputs, outputs, ejemplos, submódulos
    

Lo mejor: **no los invocás manualmente**. El agente los usa automáticamente cuando le hacés una pregunta relevante.

![](https://cdn.hashnode.com/uploads/covers/620c453d7cf10d2765e28b6c/95e6806e-8a62-4d19-a477-d9b9d014f76f.svg align="center")

> **Sin MCP** → la AI es como un empleado muy listo que estudió todo de memoria antes de entrar, pero que lleva 6 meses sin actualizar su conocimiento. Si le preguntás por un provider de Terraform que cambió el mes pasado, te va a dar la versión vieja... o directamente inventar algo que suena bien pero no existe.
> 
> **Con MCP** → ese mismo empleado ahora tiene una computadora conectada a internet, a tu GitLab, a AWS, al Terraform Registry. Antes de responderte, va y busca la información real. No adivina, no recuerda mal: consulta la fuente directamente.

* * *

## Setup en 5 minutos (en serio, 5 minutos)

Tenés tres opciones de instalación:

| Método | Cuándo usarlo |
| --- | --- |
| Docker | La mayoría de los casos. Consistente en cualquier entorno |
| Binary compilado | Si no querés Docker en el mix |
| Desde source | Si querés tocar el código o contribuir |

Vamos con **Docker** que es la más portable.

### Prerequisitos

*   Docker corriendo
    
*   VS Code con la extensión GitHub Copilot en modo Agent, **o** Cursor con MCP habilitado
    
*   Ganas de dejar de abrir tabs
    

### Paso 1: Pull de la imagen

```bash
docker pull hashicorp/terraform-mcp-server:latest
```

### Paso 2: Configuración en VS Code

Creá la carpeta `.vscode` en tu proyecto y adentro el archivo `mcp.json`:

```json
{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}
```

Guardás el archivo. VS Code te va a mostrar un link `start` debajo de `"servers"`. Lo clickeás. El container arranca.

> ⚠️ **Tip de campo:** No uses el botón "Add Server..." de la UI de VS Code. La experiencia guiada es confusa y no siempre funciona bien. Pegá el JSON directamente.

### Paso 3: Verificar que el agente lo ve

Abrís GitHub Copilot Chat, te asegurás de estar en modo **Agent**, y clickeás el ícono de herramientas. Debería aparecerte `terraform-mcp-server` con todos sus tools habilitados.

### Configuración para Cursor

En Cursor, editás tu `settings.json` de usuario:

```json
{
  "mcp": {
    "servers": {
      "terraform": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "hashicorp/terraform-mcp-server"
        ]
      }
    }
  }
}
```

Después: Settings → MCP → verificar que Terraform MCP Server aparezca con tools activos.

### ¿Usás HCP Terraform o Terraform Enterprise?

Agregás las variables de entorno en el config:

```json
{
  "servers": {
    "terraform": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "TFE_TOKEN=tu-token-aqui",
        "-e", "TFE_ADDRESS=https://app.terraform.io",
        "hashicorp/terraform-mcp-server"
      ]
    }
  }
}
```

Con esto el MCP Server también puede listar tus workspaces, runs y módulos privados.

![](https://cdn.hashnode.com/uploads/covers/620c453d7cf10d2765e28b6c/851ecc42-f036-4778-829a-fa32a4bc8cc4.gif align="center")

* * *

## Laboratorio: hacelo vos ahora mismo

Ya tenés el MCP corriendo. Hora de probarlo con algo concreto y sin dependencias de nube sin AWS, sin credenciales, sin nada. Solo Terraform y tu filesystem local.

Copiá este prompt exacto en tu agente:

```plaintext
Usa Terraform MCP para revisar el provider hashicorp/local 
y luego genera un ejemplo mínimo funcional en Terraform.
```

El agente va a llamar a `search_providers` con `hashicorp/local`, después a `get_provider_details` para ver los recursos disponibles, y te va a devolver algo así:

```hcl
terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}
 
# Crea un archivo de texto en tu sistema local
resource "local_file" "ejemplo" {
  content  = "Hola desde Terraform MCP 🔥"
  filename = "${path.module}/output.txt"
}
 
# Lee un archivo existente (data source)
data "local_file" "leeme" {
  filename = "${path.module}/output.txt"
}
 
output "contenido" {
  value = local_file.ejemplo.content
}
```

Guardás eso en un `main.tf`, y ejecutás:

```bash
terraform init
terraform apply -auto-approve
cat output.txt
```

![](https://cdn.hashnode.com/uploads/covers/620c453d7cf10d2765e28b6c/bbea5545-3066-4eca-b948-f73726da4e6d.gif align="center")

**¿Qué acaba de pasar?**

El agente no usó su memoria de entrenamiento para saber qué atributos acepta `local_file`. Consultó el Registry en tiempo real vía MCP, obtuvo la documentación actualizada del provider `hashicorp/local` v2.5, y generó HCL válido contra esa versión específica.

Resultado: un archivo `output.txt` en tu directorio con el contenido que le pediste. Sin abrir el Registry. Sin chequear si `content` o `file_content` era el atributo correcto en esta versión.

> 💡 **Por qué este ejemplo importa:** `hashicorp/local` es el provider más sencillo que existe en Terraform — no necesita credenciales de nube ni configuración extra. Si el MCP funciona acá, funciona en cualquier otro provider. Es el hello world perfecto para validar que el setup está bien antes de meterle AWS, GCP o Azure.

* * *

## Demo: S3 con versioning y lifecycle policy, sin abrir el Registry

Este es el momento que justifica todo el setup.

**Antes del MCP Server**, el workflow era así:

1.  Abrir el Terraform Registry
    
2.  Buscar `aws_s3_bucket`
    
3.  Buscar `aws_s3_bucket_versioning` (porque ya no va en el mismo recurso, cambió en el provider v4)
    
4.  Buscar `aws_s3_bucket_lifecycle_configuration`
    
5.  Copiar snippets
    
6.  Pegar en el editor
    
7.  Descubrir que estás usando atributos deprecados
    
8.  Volver al Registry
    
9.  Rezar
    

**Con el MCP Server**, le escribís esto a tu agente:

```plaintext
How do I configure an AWS S3 bucket with versioning enabled and a 
lifecycle policy that moves objects to Glacier after 90 days?
Use the latest version of the AWS provider.
```

El agente llama a `search_providers` para encontrar el provider de AWS, después a `get_provider_details` para cada recurso relevante, y te devuelve esto:

```hcl
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

resource "aws_s3_bucket" "example" {
  bucket = "mi-bucket-con-versioning"
}

resource "aws_s3_bucket_versioning" "example" {
  bucket = aws_s3_bucket.example.id

  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_s3_bucket_lifecycle_configuration" "example" {
  bucket = aws_s3_bucket.example.id

  rule {
    id     = "mover-a-glacier"
    status = "Enabled"

    transition {
      days          = 90
      storage_class = "GLACIER"
    }
  }
}
```

HCL correcto. Recursos separados según la estructura actual del provider v5. Sin atributos deprecados. Sin tabs extras abiertas.

¿La diferencia que más importa? Como el MCP consulta el Registry **en tiempo real**, no te va a devolver el esquema de la versión 3 del provider AWS que aprendió hace meses. Te da lo que está vigente hoy.

* * *

## Una nota sobre seguridad (no la saltees)

El MCP Server es una herramienta poderosa. Algunas consideraciones antes de usarlo en un entorno de equipo:

**Corrélo local.** La recomendación oficial es correrlo en `127.0.0.1` vía STDIO o HTTP Streamable. No expongas el servidor directamente a internet.

**Permisos mínimos para el** `TFE_TOKEN`**.** Si lo configurás con HCP Terraform, dale al token solo los permisos que necesita. Nada más.

`ENABLE_TF_OPERATIONS` **está OFF por defecto, y con razón.** Esta variable habilita operaciones destructivas como `auto_approve` y `is_destroy`. No la toques hasta entender bien qué hace. Lo cubrimos en detalle en el Episodio 6.

**Rate limiting.** Si lo usás en equipo o de forma intensiva, configurá los límites de requests para no saturar el Registry:

```bash
MCP_RATE_LIMIT_GLOBAL=10:20   # 10 req/seg, burst de 20
MCP_RATE_LIMIT_SESSION=5:10   # por sesión
```

* * *

## Lo que acabás de conectar

Con este setup tenés un agente que:

✅ Sabe qué resources existen en cualquier provider de Terraform, en la versión actual  
✅ Puede buscar y recomendar módulos del Registry según lo que necesitás  
✅ Genera HCL válido sin depender de datos de entrenamiento desactualizados  
✅ Puede hablar con tus workspaces de HCP Terraform si lo configurás

Y todo desde tu IDE. Sin cambiar de pantalla. Sin abrir el Registry manualmente.

* * *

%[https://youtu.be/UKrf6qyfyoo] 

## Próximo episodio

**Episodio 2 → Escribí módulos de Terraform sin acordarte de la sintaxis**

Workflow completo con MCP + Cursor en modo Agent para crear módulos reutilizables desde cero. Inputs, outputs, variables — todo generado y validado contra el Registry en tiempo real. Y lo más importante: qué pasa cuando el agente se equivoca y cómo corregirlo sin perder el hilo.

* * *

*¿Te resultó útil? Compartilo con ese colega que todavía tiene 20 tabs del Registry abiertas.*

*Seguime en* [blog.295devops.com](https://blog.295devops.com) *para el resto de la serie.*

* * *

**Recursos**

*   [Terraform MCP Server — Documentación oficial](https://developer.hashicorp.com/terraform/mcp-server)
    
*   [Repositorio en GitHub](https://github.com/hashicorp/terraform-mcp-server)
    
*   [Referencia de tools y variables de entorno](https://developer.hashicorp.com/terraform/mcp-server/reference)