# Make - Guía Completa de Automatizaciones

## Introducción y Fundamentos

### ¿Qué es Make?
- **Definición**: Plataforma de automatización visual (anteriormente Integromat)
- **Modelo**: Software as a Service (SaaS) en la nube
- **Ventaja principal**: Interfaz muy intuitiva y plan gratuito disponible

### Modelo de Pricing
```
Free Plan: Incluido
Pro Plans: Desde precio básico
Cobro: Por operación individual (cada "burbuja")
Diferencia clave: Cada nodo/módulo cuenta como operación separada
```

### Diferencias Clave vs n8n

#### Modelo de Cobro
- **Make**: Cobra por operación (cada módulo ejecutado)
- **n8n**: Cobra por ejecución completa de workflow
- **Implicación**: En Make cada nodo añadido = más coste

#### Procesamiento de Datos
- **Make**: Procesamiento iterativo secuencial
  - Procesa item 1 → completa todo el flujo → procesa item 2
- **n8n**: Procesamiento por bloques
  - Procesa todos los items de cada nodo antes de pasar al siguiente

#### Interfaz
- **Make**: Más intuitiva para principiantes
- **n8n**: Más técnica pero con mejor visualización de datos

## Estructura de Make

### Dashboard Principal
```
- Scenarios: Lista de automatizaciones
- Connections: Gestión de conexiones a apps
- Webhooks: Endpoints para recibir datos
- Data structures: Estructuras de datos personalizadas
- Teams: Gestión de equipos
```

### Organización
- **Folders**: Organización por carpetas
- **Tags**: Sistema de etiquetas
- **Templates**: Menos cantidad que n8n pero disponibles

## Configuración de Conexiones

### Tipos de Conexión en Make

#### 1. OAuth (Automática)
```
Ejemplo: LinkedIn
Proceso:
1. Crear escenario → Añadir LinkedIn módulo
2. Add connection → Connection Type: OAuth
3. Nombre: "Angel LinkedIn"
4. Autorizar → Redirección a LinkedIn
5. Login → Permitir → Redirect automático a Make
6. Conexión creada automáticamente
```

#### 2. API Key (Común para IA)
```
Ejemplo: OpenAI
Proceso:
1. Ir a OpenAI → Profile → API Keys
2. Create new API key → Copiar
3. En Make módulo OpenAI → Add connection
4. Nombre: "Angel OpenAI" 
5. API Key: Pegar key copiada
6. Save → Conexión lista

Aplicaciones comunes:
- OpenAI (GPT)
- Anthropic (Claude)  
- Google AI
- Cualquier servicio de IA
```

#### 3. Client ID + Client Secret (Complejo)
```
Ejemplo: Gmail, Google Sheets
Requisitos: 
- Client ID de Google Console
- Client Secret de Google Console
Proceso: Video específico requerido
Documentación: Make help → Online help por módulo
```

### Gestión de Conexiones
```
Ubicación: Menu izquierdo → Connections
Funciones:
- Ver todas las conexiones activas
- Editar conexiones existentes
- Eliminar conexiones
- Duplicar conexiones
- Verificar estado de conexión
```

## Creación de Escenarios

### Estructura Básica de Escenario

#### 1. Trigger (Disparador)
```
Tipos disponibles:
- Google Sheets: Trigger on new/updated row
- Webhook: Recibir datos HTTP
- Schedule: Ejecutar por tiempo
- Email: Nuevos emails
- Y muchos más...

Limitación: Solo 1 trigger por escenario (vs n8n que permite múltiples)
```

#### 2. Ejemplo: Google Sheets → OpenAI → Gmail

```json
Flujo básico:
1. Google Sheets (Watch rows) → 
2. OpenAI (Create completion) → 
3. Gmail (Send email)

Google Sheets Config:
- Spreadsheet: Seleccionar documento
- Sheet: Hoja específica
- Limit: Número máximo de filas por ejecución
```

### Sistema de Variables en Make

#### Sintaxis de Variables
```javascript
// Variables aparecen como campos arrastrables
// Estructura visual: No requiere sintaxis JSON
// Drag & drop desde panel derecho

Ejemplo:
Email: [Arrastrando desde Google Sheets]
Subject: "Invitación para " + [Nombre desde Google Sheets]
```

#### Mapeo Visual
```
Ventaja: Interface completamente visual
- Panel derecho muestra campos disponibles
- Drag & drop directo
- No requiere conocer sintaxis
- Previsualización inmediata
```

## Lógica y Filtros

### Routers (Ramificación)

```json
Nodo: Router
Funcionalidad: Divide flujo en múltiples ramas
Configuración: Automática al añadir múltiples módulos después de uno

Ejemplo:
Google Sheets → Router → Gmail (Mesa 2)
                     → Gmail (Mesa 3)  
                     → Gmail (Mesa 4)
```

### Filtros (Condiciones)

```json
Ubicación: En las conexiones entre módulos
Configuración:
- Click en línea de conexión
- Add filter
- Condition: [Campo] [Operador] [Valor]

Ejemplo:
Filter: Mesa equals 4
Resultado: Solo procesa filas con Mesa = 4
```

#### Filtros Avanzados
```json
Operadores disponibles:
- Equals / Not equals
- Contains / Not contains
- Greater than / Less than
- Exists / Not exists
- Matches pattern (regex)

Múltiples condiciones:
- AND: Todas deben cumplirse
- OR: Al menos una debe cumplirse
```

## Iteradores y Agregadores

### Iteradores

```json
Nodo: Iterator
Función: Convierte array en items individuales
Input: 1 item con array
Output: N items individuales

Configuración:
- Array field: Campo que contiene el array
- Resultado: Procesa cada elemento por separado
```

#### Ejemplo Práctico Iterator
```javascript
// Input:
{
  "invitados": [
    {"nombre": "Angel", "mesa": 4},
    {"nombre": "Carlos", "mesa": 5}
  ]
}

// Después de Iterator:
Item 1: {"nombre": "Angel", "mesa": 4}
Item 2: {"nombre": "Carlos", "mesa": 5}
```

### Agregadores

```json
Nodo: Array Aggregator / Text Aggregator / Numeric Aggregator
Función: Convierte múltiples items en uno solo
Input: N items individuales
Output: 1 item combinado

Configuración Array Aggregator:
- Source module: Módulo origen de los datos
- Target structure: Estructura del array resultante
- Aggregated fields: Campos a incluir en agregación
```

#### Ejemplo Práctico Agregador
```javascript
// Input (múltiples items):
Item 1: {"nombre": "Angel", "email": "angel@email.com"}
Item 2: {"nombre": "Carlos", "email": "carlos@email.com"}

// Output (1 item):
{
  "invitados": [
    {"nombre": "Angel", "email": "angel@email.com"},
    {"nombre": "Carlos", "email": "carlos@email.com"}
  ]
}
```

### Flujo Iterator → Agregator
```
Patrón común:
1. Google Sheets (múltiples filas)
2. Iterator (separa en items individuales)  
3. OpenAI (procesa cada uno individualmente)
4. Array Aggregator (combina todos los resultados)
5. Gmail (envía resumen final)
```

## Integración de IA en Make

### OpenAI Configuration

#### Módulo: Create Completion
```json
Model: gpt-4 / gpt-4-mini (más económico)
Messages: Array de mensajes
System message: Instrucciones del sistema (opcional)
User message: Prompt principal con variables
```

#### Ejemplo de Prompt con Variables
```json
Prompt configurado en Make:
"Quiero enviar a través del email una broma con humor sobre la canción [baile_asignado] para una invitación a una boda. El nombre del invitado es [nombre] y está en la mesa [mesa]. Tiene que ser 2-3 frases cortas con mucho humor para animar el correo."

Variables mapeadas:
- [baile_asignado] ← Google Sheets.baile_asignado  
- [nombre] ← Google Sheets.nombre
- [mesa] ← Google Sheets.mesa
```

#### Output de OpenAI
```json
Campo resultado: "choices → message → content"
Variable: [Contenido generado por IA]
Uso posterior: En campo HTML/texto de Gmail
```

### Flujo IA Completo
```
1. Google Sheets (datos de invitados)
2. OpenAI (personaliza mensaje por invitado)  
3. Gmail (envía email personalizado)

Procesamiento: Iterativo (uno por uno)
- Lee fila 1 → Genera IA → Envía email
- Lee fila 2 → Genera IA → Envía email  
- Continúa hasta final
```

### Prompts Avanzados con IA
```json
Técnicas:
1. Context injection: Incluir datos específicos
2. Format specification: Definir formato de salida
3. Tone and style: Especificar tono deseado
4. Length control: Controlar longitud de respuesta
5. Language specification: Idioma de respuesta
```

## Funciones de IA en Make

### Módulos IA Disponibles

#### OpenAI
```
- Create completion (GPT)
- Create chat completion (ChatGPT)  
- Create image (DALL-E)
- Create transcription (Whisper)
- Create translation (Whisper)
- Create moderation
```

#### Otras Plataformas IA
```
- Anthropic (Claude)
- Google AI (Gemini)  
- Stability AI (Stable Diffusion)
- OpenRouter (múltiples modelos)
- Replicate (modelos community)
```

### Configuración Avanzada IA

#### Parámetros de Control
```json
Temperature: Creatividad (0-1)
- 0: Muy predecible
- 1: Muy creativo

Max tokens: Longitud máxima respuesta
Top P: Diversidad de respuesta  
Frequency penalty: Evitar repetición
Presence penalty: Evitar temas recurrentes
```

#### Manejo de Errores IA
```json
Error handling:
- Set fallback responses
- Retry logic para rate limits
- Alternative model configuration
- Error notification setup
```

## Webhooks y APIs

### Webhook Configuration
```json
Crear Webhook:
1. Módulos → Webhooks → Custom webhook
2. Copiar URL generada
3. Configurar en aplicación externa
4. Test webhook reception
5. Activar escenario

Uso: Recibir datos en tiempo real
```

### HTTP Requests
```json
Módulo: HTTP Make Request
Configuración:
- URL: Endpoint de API
- Method: GET/POST/PUT/DELETE
- Headers: Authorization, Content-Type, etc.
- Body: Datos JSON para enviar

Autenticación:
- API Key en headers
- Bearer token  
- OAuth integration
```

## Testing y Debugging

### Modos de Ejecución
```
1. Run Once: Ejecutar una vez para testing
2. Schedule: Ejecución automática por tiempo
3. Manual: Ejecutar manualmente cuando se necesite
```

### Debugging Tools
```
- Execution history: Ver historial de ejecuciones
- Step-by-step debugging: Ejecutar paso a paso
- Data inspection: Ver datos en cada módulo
- Error handling: Configurar manejo de errores
- Notifications: Alertas por email/webhook
```

### Data Visualization
```
- Input/Output inspection por módulo
- JSON viewer para estructuras complejas
- Array viewer para múltiples items
- Filter testing en tiempo real
```

## Best Practices

### Organización de Escenarios
```
1. Naming convention descriptiva
2. Uso de folders por proyecto/cliente
3. Tags para categorización
4. Documentation en comments
5. Versioning de escenarios importantes
```

### Performance Optimization
```
1. Usar filtros para reducir procesamiento
2. Optimizar número de operaciones
3. Batch processing donde sea posible
4. Monitoring de consumo de operaciones
5. Schedule optimization para evitar picos
```

### Error Handling
```
1. Configure error routes
2. Set retry logic for API failures
3. Notification systems for critical errors
4. Fallback scenarios for primary failures
5. Data validation before processing
```

### Conexiones Management
```
1. Regular connection health checks
2. API key rotation schedules  
3. Backup connections for critical services
4. Documentation of all integrations
5. Team access management
```

## Comparativa: Cuándo Elegir Make vs n8n

### Usar Make cuando:
```
✓ Equipo principiante en automatización
✓ Necesitas plan gratuito para empezar
✓ Prefieres interface completamente visual
✓ Workflows simples con pocas operaciones
✓ Quieres soporte oficial 24/7
✓ Templates específicos de Make son útiles
```

### Usar n8n cuando:
```
✓ Grandes volúmenes de procesamiento  
✓ Workflows complejos con muchos nodos
✓ Presupuesto limitado largo plazo
✓ Control total sobre deployment
✓ Equipo con capacidades técnicas
✓ Necesitas múltiples triggers por workflow
✓ Requieres procesamiento por lotes
```

### Hybrid Approach
```
Estrategia: Usar ambas plataformas
- Make: Workflows simples, MVPs, testing
- n8n: Workflows complejos, producción, volumen alto
- Integration: Webhooks entre plataformas
```

## URLs y Recursos

```
- Make Platform: https://make.com
- Make Academy: https://academy.make.com
- Make Community: https://community.make.com
- Template Library: https://make.com/en/templates
- Documentation: https://docs.make.com
- API Reference: https://docs.make.com/api
```

---

*Este documento contiene toda la información técnica necesaria para implementar automatizaciones en Make, complementando perfectamente el conocimiento de n8n para dominar ambas plataformas.*