# Integraciones MCP

Una **integración** es un servidor MCP HTTP tuyo que registras en tu workspace. Meteor lo valida, cachea sus tools y las deja disponibles para que tus Mets (y tu código) las ejecuten. Es la forma self-service de darle a tus Mets capacidades propias sin esperar a que Meteor las incluya.

> **No confundir con `mcp.html`.** Esta guía trata de conectar *tu* servidor MCP **a Meteor** (`met.integrations`). La guía de [Meteor como servidor MCP](../mcp.html) es lo contrario: conectar Meteor **como** servidor MCP a Cursor o Claude. Son dos direcciones distintas.

## Registrar tu servidor MCP

```ts
const met = new Met(process.env.MET_API_KEY, { workspaceId: 42 });

const integration = await met.integrations.register({
  name: 'Mi CRM',
  endpoint: 'https://mcp.miempresa.com',
  auth_header: 'Authorization: Bearer {token}',
  credentials: { token: process.env.CRM_TOKEN },
});

console.log(integration.id);           // 'int_…' — úsalo como key
console.log(integration.tools_count);  // tools descubiertas
```

Al registrar, Meteor le hace `tools/list` a tu `endpoint` para **validar** que responde y **cachear** sus tools. Si el servidor no contesta, el registro falla.

El `id` que devuelve es la **`key`** de la integración: la usas en `tools`, `execute`, `activate` y `deactivate`.

Los secretos van en `credentials` (write-only: nunca se devuelven) y se rellenan en la plantilla `auth_header`. En el ejemplo, `{token}` se reemplaza por `credentials.token` en cada llamada a tu servidor.

## Listar y explorar tools

```ts
const integrations = await met.integrations.list();

const tools = await met.integrations.tools(integration.id);
for (const t of tools) {
  console.log(t.name, '—', t.description);  // t.input_schema tiene el JSON Schema
}
```

## Ejecutar una tool

```ts
const result = await met.integrations.execute(integration.id, 'buscar_cliente', {
  email: 'ana@ejemplo.com',
});

console.log(result.status);             // 'success'
console.log(result.output);             // lo que devuelve tu tool
console.log(result.execution_time_ms);  // latencia de la ejecución
```

El `input` es un objeto que cumple el `input_schema` de la tool. Una vez registrada y activa, la integración también queda disponible para el orquestador: tus Mets pueden invocar estas tools solos durante un [Run](ejecutar-agentes.html).

## Activar y desactivar

```ts
await met.integrations.deactivate(integration.id);
await met.integrations.activate(integration.id, { credentials: { token: nuevoToken } });
```

`activate` sirve para reconectar y, de paso, **rotar credenciales**: pasa `credentials` para reemplazar los secretos guardados.

## Scopes y modo live

- `integrations:read` — listar integraciones y ver sus tools.
- `integrations:manage` — registrar, activar y desactivar.
- `integrations:execute` — ejecutar tools.

Las integraciones operan siempre contra tu servidor real, así que usa una **key live** (no sandbox).

> **La generación de imágenes ya viene lista.** No necesitas registrar nada: es una integración incluida. Mira [Imágenes](imagenes.html).