# API Reference Pro - AbletonMCP_AI

> **Total Tools:** 114 herramientas profesionales  
> **Versión:** 3.0 Senior Architecture  
> **Última Actualización:** 2026-04-12

---

## Índice

1. [Setup & System](#setup--system)
2. [Tracks](#tracks)
3. [Arrangement & Clips](#arrangement--clips)
4. [Samples & Library](#samples--library)
5. [MIDI Generation](#midi-generation)
6. [FX & Automation](#fx--automation)
7. [Mixing & Mastering](#mixing--mastering)
8. [Musical Intelligence](#musical-intelligence)
9. [Production Pipeline](#production-pipeline)
10. [Workflow & Quality](#workflow--quality)
11. [Export & Render](#export--render)

---

## Setup & System

### `health_check`
Verificación completa del sistema MCP-Ableton.

**Uso:** Ejecutar SIEMPRE primero antes de cualquier producción.

```python
ableton-live-mcp_health_check

# Respuesta:
{
  "status": "healthy",
  "score": 5/5,
  "checks": {
    "tcp_server": "✓ OK",
    "song_access": "✓ OK",
    "tracks_access": "✓ OK",
    "browser_access": "✓ OK",
    "update_loop": "✓ OK"
  }
}
```

### `get_session_info`
Obtiene información completa de la sesión actual.

```python
ableton-live-mcp_get_session_info

# Respuesta incluye:
# - BPM, Key, Time Signature
# - Número de tracks, clips, dispositivos
# - Estado de reproducción
```

### `set_tempo`
Establece el tempo del proyecto en BPM.

**Parámetros:**
- `tempo` (number): BPM del proyecto (20-999)

```python
ableton-live-mcp_set_tempo --tempo 95
ableton-live-mcp_set_tempo --tempo 128  # Para EDM
ableton-live-mcp_set_tempo --tempo 140  # Para Trap
```

### `set_time_signature`
Establece la firma de tiempo.

**Parámetros:**
- `numerator` (int): Numerador (default: 4)
- `denominator` (int): Denominador (default: 4)

```python
ableton-live-mcp_set_time_signature --numerator 4 --denominator 4  # 4/4
ableton-live-mcp_set_time_signature --numerator 3 --denominator 4  # 3/4
```

### `set_metronome`
Activa o desactiva el metrónomo.

**Parámetros:**
- `enabled` (bool): true/false

```python
ableton-live-mcp_set_metronome --enabled true
```

### `ping`
Ping simple para verificar conectividad MCP.

```python
ableton-live-mcp_ping
# Respuesta: "pong"
```

---

## Tracks

### `get_tracks`
Lista todas las pistas del proyecto.

```python
ableton-live-mcp_get_tracks

# Respuesta:
{
  "tracks": [
    {"index": 0, "name": "1-MIDI", "type": "midi", "has_audio": false},
    {"index": 1, "name": "2-MIDI", "type": "midi", "has_audio": false},
    {"index": 2, "name": "Kick", "type": "audio", "has_audio": true}
  ],
  "total": 3
}
```

### `create_audio_track`
Crea una nueva pista de audio.

**Parámetros:**
- `index` (int, opcional): Posición donde insertar (-1 = final)

```python
ableton-live-mcp_create_audio_track          # Al final
ableton-live-mcp_create_audio_track --index 5  # En posición 5
```

### `create_midi_track`
Crea una nueva pista MIDI.

**Parámetros:**
- `index` (int, opcional): Posición donde insertar

```python
ableton-live-mcp_create_midi_track
ableton-live-mcp_create_midi_track --index 0  # Al inicio
```

### `create_bus_track`
Crea un grupo (bus) para mezcla.

**Parámetros:**
- `bus_type` (str, opcional): Tipo de bus (Drums, Bass, Synths, FX, Master)

```python
ableton-live-mcp_create_bus_track --bus_type Drums
ableton-live-mcp_create_bus_track --bus_type "Vocals"
```

### `route_track_to_bus`
Rutea una pista a un bus/grupo.

**Parámetros:**
- `track_index` (int): Índice del track origen
- `bus_name` (str): Nombre del bus destino

```python
ableton-live-mcp_route_track_to_bus \
    --track_index 2 \
    --bus_name "Drums"
```

### `set_track_name`
Establece el nombre de una pista.

**Parámetros:**
- `track_index` (int): Índice del track
- `name` (str): Nombre descriptivo

```python
ableton-live-mcp_set_track_name --track_index 2 --name "Kick"
ableton-live-mcp_set_track_name --track_index 3 --name "Snare"
```

### `set_track_volume`
Establece el volumen de una pista (0.0-1.0).

**Parámetros:**
- `track_index` (int): Índice del track
- `volume` (float): Volumen (0.0 = silencio, 1.0 = máximo, -Inf dB = 0)

```python
ableton-live-mcp_set_track_volume --track_index 2 --volume 0.85
ableton-live-mcp_set_track_volume --track_index 3 --volume 0.75
```

### `set_track_pan`
Establece el paneo de una pista (-1.0 a 1.0).

**Parámetros:**
- `track_index` (int): Índice del track
- `pan` (float): -1.0 = izquierda, 0.0 = centro, 1.0 = derecha

```python
ableton-live-mcp_set_track_pan --track_index 7 --pan -0.3  # Izquierda
ableton-live-mcp_set_track_pan --track_index 8 --pan 0.3   # Derecha
```

### `set_track_mute`
Silencia o reactiva una pista.

**Parámetros:**
- `track_index` (int): Índice del track
- `mute` (bool): true = silenciar, false = activar

```python
ableton-live-mcp_set_track_mute --track_index 2 --mute true
ableton-live-mcp_set_track_mute --track_index 2 --mute false
```

### `set_track_solo`
Activa o desactiva solo en una pista.

**Parámetros:**
- `track_index` (int): Índice del track
- `solo` (bool): true = solo, false = no solo

```python
ableton-live-mcp_set_track_solo --track_index 2 --solo true
```

### `set_master_volume`
Establece el volumen master (0.0-1.0).

**Parámetros:**
- `volume` (float): Volumen master

```python
ableton-live-mcp_set_master_volume --volume 0.9
```

---

## Arrangement & Clips

### `get_arrangement_status`
Obtiene estado detallado del Arrangement View.

```python
ableton-live-mcp_get_arrangement_status

# Respuesta:
{
  "total_clips": 24,
  "arrangement_length_beats": 256,
  "unique_start_positions": [0, 4, 8, 12, ...],
  "clips": [
    {
      "track_index": 2,
      "track_name": "Kick",
      "name": "KickPattern",
      "start_time": 0,
      "end_time": 4,
      "length": 4,
      "is_midi": false,
      "color": "orange",
      "muted": false,
      "looping": true
    }
  ],
  "tracks": {
    "2": {"clip_count": 16},
    "3": {"clip_count": 16}
  }
}
```

### `get_arrangement_clips`
Lista todos los clips en Arrangement View.

**Parámetros:**
- `track_index` (int, opcional): Filtrar por track específico

```python
ableton-live-mcp_get_arrangement_clips
ableton-live-mcp_get_arrangement_clips --track_index 2
```

### `create_arrangement_audio_pattern`
Crea clips de audio en Arrangement View (INYECCIÓN SENIOR).

**Parámetros:**
- `track_index` (int): Track objetivo
- `file_path` (str): Ruta absoluta al archivo de audio
- `positions` (array): Lista de posiciones en beats/compases
- `name` (str, opcional): Nombre del clip

```python
# Pattern simple (1 clip)
ableton-live-mcp_create_arrangement_audio_pattern \
    --track_index 2 \
    --file_path "C:\\...\\kick 1.wav" \
    --positions [0] \
    --name "IntroKick"

# Pattern de 4 tiempos
ableton-live-mcp_create_arrangement_audio_pattern \
    --track_index 2 \
    --file_path "C:\\...\\kick 1.wav" \
    --positions [0, 4, 8, 12] \
    --name "KickLoop"

# Pattern completo (16 compases)
ableton-live-mcp_create_arrangement_audio_pattern \
    --track_index 2 \
    --file_path "C:\\...\\kick 1.wav" \
    --positions [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60] \
    --name "FullKick"
```

### `create_arrangement_midi_clip`
Crea un clip MIDI en Arrangement View.

**Parámetros:**
- `track_index` (int): Track objetivo
- `start_time` (float): Posición inicial en compases
- `length` (float): Duración en compases
- `notes` (array): Lista de notas MIDI

```python
ableton-live-mcp_create_arrangement_midi_clip \
    --track_index 6 \
    --start_time 0 \
    --length 4 \
    --notes '[
        {"pitch": 36, "start_time": 0, "duration": 1, "velocity": 100},
        {"pitch": 36, "start_time": 2, "duration": 1, "velocity": 100}
    ]'
```

### `load_sample_direct`
Carga un sample directamente a un track.

**Parámetros:**
- `file_path` (str): Ruta al archivo
- `track_index` (int): Track objetivo
- `slot_index` (int, opcional): Slot del clip (default: 0)
- `warp` (bool, opcional): Activar warping (default: true)
- `auto_fire` (bool, opcional): Disparar automáticamente (default: false)

```python
ableton-live-mcp_load_sample_direct \
    --file_path "libreria/reggaeton/kick/kick 1.wav" \
    --track_index 2 \
    --slot_index 0 \
    --warp true \
    --auto_fire false
```

### `reverse_clip`
Invierte un clip (audio o MIDI).

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip

```python
ableton-live-mcp_reverse_clip --track_index 2 --clip_index 0
```

### `pitch_shift_clip`
Cambia el tono de un clip sin afectar tempo.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip
- `semitones` (int): Semitonos (-24 a +24)

```python
ableton-live-mcp_pitch_shift_clip \
    --track_index 2 \
    --clip_index 0 \
    --semitones -2
```

### `time_stretch_clip`
Estira el tiempo de un clip sin afectar tono.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip
- `factor` (float): Factor de estiramiento (0.25-4.0)
  - 1.0 = normal
  - 2.0 = mitad de velocidad / doble duración
  - 0.5 = doble velocidad / mitad duración

```python
ableton-live-mcp_time_stretch_clip \
    --track_index 2 \
    --clip_index 0 \
    --factor 2.0  # Half speed
```

### `slice_clip`
Divide un clip en segmentos.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip
- `num_slices` (int): Número de slices (default: 8, max: 64)

```python
ableton-live-mcp_slice_clip \
    --track_index 2 \
    --clip_index 0 \
    --num_slices 8
```

### `set_warp_markers`
Configura marcadores de warp para ajustar timing.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip
- `markers` (array): Lista de marcadores {"position": X, "warp_to": Y}

```python
ableton-live-mcp_set_warp_markers \
    --track_index 2 \
    --clip_index 0 \
    --markers '[
        {"position": 0.0, "warp_to": 0.0},
        {"position": 4.0, "warp_to": 4.0}
    ]'
```

---

## Samples & Library

### `scan_library`
Escanea la librería de samples y retorna archivos disponibles.

**Parámetros:**
- `subfolder` (str, opcional): Subcarpeta específica (ej: "reggaeton/kick")
- `extensions` (array, opcional): Extensiones a incluir (default: todas)

```python
# Escanear todo
ableton-live-mcp_scan_library

# Escanear subcarpeta específica
ableton-live-mcp_scan_library --subfolder reggaeton/kick
ableton-live-mcp_scan_library --subfolder reggaeton/snare

# Con filtros de extensión
ableton-live-mcp_scan_library \
    --extensions [".wav", ".aiff"]
```

### `analyze_library`
Analiza todos los samples en la librería (BPM, Key, MFCCs).

**Parámetros:**
- `force_reanalyze` (bool, opcional): Forzar re-análisis (default: false)

```python
ableton-live-mcp_analyze_library
ableton-live-mcp_analyze_library --force_reanalyze true
```

### `get_library_stats`
Obtiene estadísticas de la librería analizada.

```python
ableton-live-mcp_get_library_stats

# Respuesta:
# {
#   "total_samples": 511,
#   "analyzed": 511,
#   "by_category": {...},
#   "bpm_range": {"min": 85, "max": 140}
# }
```

### `browse_library`
Navega la librería con filtros avanzados.

**Parámetros:**
- `pack` (str, opcional): Nombre del pack
- `role` (str, opcional): Rol del sample (drums, bass, synths, fx)
- `bpm_min` (int, opcional): BPM mínimo
- `bpm_max` (int, opcional): BPM máximo
- `key` (str, opcional): Tonalidad (Am, Cm, Gm, etc.)

```python
# Buscar kicks de reggaeton
ableton-live-mcp_browse_library \
    --role drums \
    --bpm_min 90 \
    --bpm_max 100

# Buscar en tonalidad Am
ableton-live-mcp_browse_library \
    --key Am \
    --role bass
```

### `get_similar_samples`
Encuentra samples similares usando embeddings.

**Parámetros:**
- `sample_path` (str): Ruta al sample de referencia
- `top_n` (int, opcional): Número de resultados (default: 10)

```python
ableton-live-mcp_get_similar_samples \
    --sample_path "C:\\...\\kick 1.wav" \
    --top_n 5
```

### `find_samples_like_audio`
Encuentra samples similares a audio externo.

**Parámetros:**
- `audio_path` (str): Ruta al archivo de audio externo
- `top_n` (int, opcional): Número de resultados (default: 20)
- `role` (str, opcional): Filtrar por rol

```python
ableton-live-mcp_find_samples_like_audio \
    --audio_path "C:\\referencia.mp3" \
    --role drums \
    --top_n 10
```

### `get_user_sound_profile`
Obtiene el perfil de sonido del usuario basado en análisis previo.

```python
ableton-live-mcp_get_user_sound_profile
```

### `get_recommended_samples`
Obtiene samples recomendados para un rol.

**Parámetros:**
- `role` (str, opcional): Rol del sample
- `count` (int, opcional): Número de samples (default: 5)

```python
ableton-live-mcp_get_recommended_samples \
    --role drums \
    --count 5
```

### `compare_two_samples`
Compara dos samples y retorna score de similitud.

**Parámetros:**
- `path1` (str): Ruta al primer sample
- `path2` (str): Ruta al segundo sample

```python
ableton-live-mcp_compare_two_samples \
    --path1 "C:\\...\\kick 1.wav" \
    --path2 "C:\\...\\kick 2.wav"
```

---

## MIDI Generation

### `generate_midi_clip`
Crea un clip MIDI con notas específicas.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot (default: 0)
- `notes` (array): Lista de notas {"pitch", "start_time", "duration", "velocity"}

```python
ableton-live-mcp_generate_midi_clip \
    --track_index 6 \
    --clip_index 0 \
    --notes '[
        {"pitch": 36, "start_time": 0, "duration": 0.5, "velocity": 100},
        {"pitch": 40, "start_time": 1, "duration": 0.5, "velocity": 90}
    ]'
```

### `generate_dembow_clip`
Genera un clip MIDI con patrón dembow clásico.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot (default: 0)
- `bars` (int, opcional): Número de compases (default: 4)
- `variation` (str, opcional): Variación del patrón
  - `standard`: Dembow clásico
  - `minimal`: Versión reducida
  - `complex`: Con variaciones
  - `fill`: Patrón de fill

```python
ableton-live-mcp_generate_dembow_clip \
    --track_index 2 \
    --bars 8 \
    --variation standard
```

### `generate_bass_clip`
Genera un clip MIDI de bajo estilo reggaeton.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot
- `bars` (int, opcional): Número de compases (default: 4)
- `root_notes` (array, opcional): Notas raíz por compás
- `style` (str, opcional): Estilo del bajo
  - `standard`: Básico
  - `melodic`: Con más movimiento
  - `staccato`: Notas cortas
  - `slides`: Con slides

```python
ableton-live-mcp_generate_bass_clip \
    --track_index 6 \
    --bars 16 \
    --root_notes [36, 36, 41, 41, 43, 43, 36, 36] \
    --style melodic
```

### `generate_chords_clip`
Genera un clip MIDI de acordes.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot
- `bars` (int, opcional): Número de compases (default: 4)
- `progression` (str, opcional): Progresión en notación romana (default: i-v-vi-iv)
- `key` (str, opcional): Tonalidad (default: Am)

```python
ableton-live-mcp_generate_chords_clip \
    --track_index 7 \
    --bars 16 \
    --progression i-v-vi-iv \
    --key Am

# Otras progresiones comunes:
# --progression I-IV-V       # Clásica
# --progression i-VI-IV-V   # Vi-IV-I-V (pop)
# --progression ii-V-I      # Jazz
```

### `generate_melody_clip`
Genera un clip MIDI de melodía.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot
- `bars` (int, opcional): Número de compases (default: 4)
- `scale` (str, opcional): Escala (minor, major, harmonic_minor, pentatonic)
- `density` (str, opcional): Densidad de notas (sparse, medium, dense)

```python
ableton-live-mcp_generate_melody_clip \
    --track_index 8 \
    --bars 16 \
    --scale minor \
    --density medium
```

### `apply_human_feel`
Humaniza una pista MIDI (variaciones de velocity y timing).

**Parámetros:**
- `track_index` (int): Track a humanizar
- `intensity` (float, opcional): Intensidad 0.0-1.0 (default: 0.5)

```python
ableton-live-mcp_apply_human_feel \
    --track_index 6 \
    --intensity 0.3
```

### `humanize_track`
Alias de `apply_human_feel`.

```python
ableton-live-mcp_humanize_track \
    --track_index 6 \
    --intensity 0.5
```

---

## FX & Automation

### `create_riser`
Crea un riser/buildup de tensión.

**Parámetros:**
- `track_index` (int): Track donde crear el riser
- `start_bar` (int): Barra inicial
- `duration` (int): Duración en compases
- `intensity` (float): Intensidad 0.0-1.0
- `pitch_min` (int, opcional): Nota MIDI mínima (default: 36)
- `pitch_max` (int, opcional): Nota MIDI máxima (default: 84)

```python
ableton-live-mcp_create_riser \
    --track_index 9 \
    --start_bar 20 \
    --duration 4 \
    --intensity 0.8 \
    --pitch_min 36 \
    --pitch_max 84
```

### `create_downlifter`
Crea un downlifter (descenso de tensión).

**Parámetros:**
- `track_index` (int): Track objetivo
- `start_bar` (int): Barra inicial
- `duration` (int): Duración en compases
- `intensity` (float): Intensidad 0.0-1.0

```python
ableton-live-mcp_create_downlifter \
    --track_index 9 \
    --start_bar 32 \
    --duration 4 \
    --intensity 0.7
```

### `create_impact`
Crea un impact/drop effect.

**Parámetros:**
- `track_index` (int): Track objetivo
- `position` (int): Posición en compases
- `intensity` (float): Intensidad 0.0-1.0
- `impact_type` (str, opcional): Tipo de impacto
  - `hit`: Impacto percusivo
  - `crash`: Crash cymbal
  - `sub_drop`: Sub bass drop
  - `noise`: Noise sweep

```python
ableton-live-mcp_create_impact \
    --track_index 9 \
    --position 24 \
    --intensity 1.0 \
    --impact_type sub_drop
```

### `create_silence`
Crea un efecto de silencio/break.

**Parámetros:**
- `track_index` (int): Track donde aplicar
- `start_bar` (int): Barra inicial
- `duration` (float): Duración en compases

```python
ableton-live-mcp_create_silence \
    --track_index 2 \
    --start_bar 15 \
    --duration 1
```

### `automate_filter`
Automatiza un filtro sweep.

**Parámetros:**
- `track_index` (int): Track objetivo
- `start_bar` (int, opcional): Barra inicial (default: 0)
- `end_bar` (int, opcional): Barra final (default: 8)
- `start_freq` (float, opcional): Frecuencia inicial Hz (default: 200)
- `end_freq` (float, opcional): Frecuencia final Hz (default: 20000)

```python
# Filter sweep ascendente (build up)
ableton-live-mcp_automate_filter \
    --track_index 7 \
    --start_bar 20 \
    --end_bar 24 \
    --start_freq 200 \
    --end_freq 20000

# Filter sweep descendente
ableton-live-mcp_automate_filter \
    --track_index 7 \
    --start_bar 32 \
    --end_bar 36 \
    --start_freq 20000 \
    --end_freq 200
```

### `add_percussion_fills`
Añade fills de percusión en posiciones específicas.

**Parámetros:**
- `track_index` (int): Track de percusión
- `positions` (array, opcional): Lista de barras para fills
  (default: [7, 15, 23, 31])

```python
ableton-live-mcp_add_percussion_fills \
    --track_index 5 \
    --positions [7, 15, 23, 31]
```

---

## Mixing & Mastering

### `create_return_track`
Crea una pista de retorno con efecto.

**Parámetros:**
- `effect_type` (str, opcional): Tipo de efecto
  - `Reverb`
  - `Delay`
  - `Chorus`
  - `Simple Delay`
  - `Ping Pong Delay`

```python
ableton-live-mcp_create_return_track --effect_type Reverb
ableton-live-mcp_create_return_track --effect_type Delay
```

### `set_track_send`
Configura envío de un track a una pista de retorno.

**Parámetros:**
- `track_index` (int): Track origen
- `return_index` (int): Índice del return track
- `amount` (float): Cantidad de envío 0.0-1.0

```python
ableton-live-mcp_set_track_send \
    --track_index 8 \
    --return_index 0 \
    --amount 0.3
```

### `insert_device`
Inserta un dispositivo/plugin en una pista.

**Parámetros:**
- `track_index` (int): Track objetivo
- `device_name` (str): Nombre del dispositivo

```python
ableton-live-mcp_insert_device \
    --track_index 2 \
    --device_name "Compressor"

ableton-live-mcp_insert_device \
    --track_index 6 \
    --device_name "EQ Eight"
```

### `configure_eq`
Configura EQ Eight en una pista con preset.

**Parámetros:**
- `track_index` (int): Track objetivo
- `preset` (str, opcional): Nombre del preset
  - `kick`: Optimizado para kick drum
  - `snare`: Optimizado para snare
  - `bass`: Optimizado para bajo
  - `vocals`: Optimizado para voz
  - `master`: Master EQ

```python
ableton-live-mcp_configure_eq --track_index 2 --preset kick
ableton-live-mcp_configure_eq --track_index 6 --preset bass
ableton-live-mcp_configure_eq --track_index 0 --preset master
```

### `configure_compressor`
Configura compresor en una pista.

**Parámetros:**
- `track_index` (int): Track objetivo
- `preset` (str, opcional): Preset (default, drums, vocals, master)
- `threshold` (float, opcional): Umbral en dB (default: -20)
- `ratio` (float, opcional): Ratio (default: 4)

```python
ableton-live-mcp_configure_compressor \
    --track_index 2 \
    --preset drums \
    --threshold -20 \
    --ratio 4

ableton-live-mcp_configure_compressor \
    --track_index 6 \
    --preset bass \
    --threshold -15 \
    --ratio 3
```

### `setup_sidechain`
Configura compresión sidechain.

**Parámetros:**
- `source_track` (int): Track que dispara el sidechain (ej: kick)
- `target_track` (int): Track que se reduce (ej: bass)
- `amount` (float, opcional): Intensidad 0.0-1.0 (default: 0.5)

```python
# Kick ducking Bass
ableton-live-mcp_setup_sidechain \
    --source_track 2 \
    --target_track 6 \
    --amount 0.7
```

### `auto_gain_staging`
Ajusta automáticamente niveles de ganancia para todos los tracks.

```python
ableton-live-mcp_auto_gain_staging
```

### `apply_master_chain`
Aplica cadena de mastering al master track.

**Parámetros:**
- `preset` (str, opcional): Tipo de mastering
  - `standard`: Balance general
  - `loud`: Maximizado para loudness
  - `warm`: Carácter cálido

```python
ableton-live-mcp_apply_master_chain --preset standard
ableton-live-mcp_apply_master_chain --preset loud
```

### `apply_professional_mix`
Aplica mezcla profesional completa con buses y returns.

**Parámetros:**
- `track_assignments` (str): JSON con asignaciones de tracks a roles

```python
ableton-live-mcp_apply_professional_mix \
    --track_assignments '{
        "2": "kick",
        "3": "snare",
        "4": "hihat",
        "5": "perc",
        "6": "bass",
        "7": "chords",
        "8": "melody"
    }'
```

---

## Musical Intelligence

### `analyze_project_key`
Detecta la tonalidad predominante del proyecto.

```python
ableton-live-mcp_analyze_project_key

# Respuesta:
# {
#   "key": "Am",
#   "confidence": 0.92,
#   "alternative_keys": ["C", "Em"]
# }
```

### `harmonize_track`
Armoniza un track con una progresión de acordes.

**Parámetros:**
- `track_index` (int): Track a armonizar
- `progression` (str, opcional): Progresión (default: I-V-vi-IV)

```python
ableton-live-mcp_harmonize_track \
    --track_index 8 \
    --progression I-V-vi-IV
```

### `generate_counter_melody`
Genera una contra-melodía que complementa la melodía principal.

**Parámetros:**
- `main_melody_track` (int): Track con la melodía principal

```python
ableton-live-mcp_generate_counter_melody \
    --main_melody_track 8
```

### `detect_energy_curve`
Analiza la curva de energía por sección del proyecto.

```python
ableton-live-mcp_detect_energy_curve

# Respuesta:
# {
#   "sections": [
#     {"name": "Intro", "energy": 0.3, "range": [0, 8]},
#     {"name": "Verse", "energy": 0.6, "range": [8, 24]},
#     {"name": "Chorus", "energy": 0.9, "range": [24, 32]}
#   ]
# }
```

### `balance_sections`
Ajusta automáticamente la energía entre secciones.

```python
ableton-live-mcp_balance_sections
```

### `variate_loop`
Crea variaciones de un loop para evitar repetitividad.

**Parámetros:**
- `track_index` (int): Track con el loop
- `intensity` (float, opcional): Intensidad de variación 0.0-1.0 (default: 0.5)

```python
ableton-live-mcp_variate_loop \
    --track_index 2 \
    --intensity 0.5
```

### `add_call_and_response`
Genera una respuesta musical a una frase existente.

**Parámetros:**
- `phrase_track` (int): Track con la frase original
- `response_length` (int, opcional): Duración de la respuesta en compases (default: 2)

```python
ableton-live-mcp_add_call_and_response \
    --phrase_track 8 \
    --response_length 2
```

### `generate_breakdown`
Genera una sección de breakdown/descanso.

**Parámetros:**
- `start_bar` (int): Barra donde comienza el breakdown
- `duration` (int, opcional): Duración en compases (default: 8)

```python
ableton-live-mcp_generate_breakdown \
    --start_bar 40 \
    --duration 8
```

### `generate_drop_variation`
Genera una variación de un drop existente.

**Parámetros:**
- `original_drop_bar` (int): Barra donde está el drop original
- `variation_type` (str, opcional): Tipo de variación
  - `intense`: Más energía
  - `minimal`: Reducido
  - `double`: Doble drop
  - `fill`: Con fill de percusión

```python
ableton-live-mcp_generate_drop_variation \
    --original_drop_bar 24 \
    --variation_type intense
```

### `create_outro`
Crea un outro con fade out automático.

**Parámetros:**
- `fade_duration` (int, opcional): Duración del fade en compases (default: 8)

```python
ableton-live-mcp_create_outro --fade_duration 8
```

### `modulate_key`
Modula a una nueva tonalidad en una sección específica.

**Parámetros:**
- `section_index` (int): Índice de la sección
- `new_key` (str): Nueva tonalidad (Dm, F#m, C, etc.)

```python
ableton-live-mcp_modulate_key \
    --section_index 2 \
    --new_key Dm
```

### `set_multiple_progressions`
Configura progresiones de acordes para múltiples secciones.

**Parámetros:**
- `progressions_config` (array): Lista de configuraciones

```python
ableton-live-mcp_set_multiple_progressions \
    --progressions_config '[
        {"section": "intro", "progression": "I-V"},
        {"section": "verse", "progression": "I-V-vi-IV"},
        {"section": "chorus", "progression": "vi-IV-I-V"}
    ]'
```

---

## Production Pipeline

### `generate_track`
Genera una pista con IA.

**Parámetros:**
- `genre` (str): Género (reggaeton, trap, edm, etc.)
- `bpm` (int, opcional): BPM (default: 0 = auto)
- `key` (str, opcional): Tonalidad
- `style` (str, opcional): Estilo
- `structure` (str, opcional): Estructura

```python
ableton-live-mcp_generate_track \
    --genre reggaeton \
    --bpm 95 \
    --key Am \
    --style perreo
```

### `generate_song`
Genera una canción completa con IA.

```python
ableton-live-mcp_generate_song \
    --genre reggaeton \
    --bpm 95 \
    --key Am \
    --style classic \
    --structure full
```

### `generate_full_song`
Genera canción completa con drums, bass, chords, melody.

**Parámetros:**
- `bpm` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo (default: classic)
- `structure` (str, opcional): Estructura (default: standard)

```python
ableton-live-mcp_generate_full_song \
    --bpm 95 \
    --key Am \
    --style modern \
    --structure verse-chorus
```

### `generate_complete_reggaeton`
Genera proyecto completo de reggaeton.

**Parámetros:**
- `bpm` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo (classic, dembow, perreo, moombahton)
- `structure` (str, opcional): Estructura (verse-chorus, full, intro-drop)
- `use_samples` (bool, opcional): Usar samples de librería (default: true)

```python
ableton-live-mcp_generate_complete_reggaeton \
    --bpm 95 \
    --key Am \
    --style perreo \
    --structure full \
    --use_samples true
```

### `generate_from_reference`
Genera track desde audio de referencia.

**Parámetros:**
- `reference_audio_path` (str): Ruta al audio de referencia

```python
ableton-live-mcp_generate_from_reference \
    --reference_audio_path "C:\\referencia.mp3"
```

### `produce_reggaeton`
Pipeline completo de producción reggaeton (Session View).

**Parámetros:**
- `bpm` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo
- `structure` (str, opcional): Estructura
- `record_arrangement` (bool, opcional): Grabar a Arrangement (default: true)

```python
ableton-live-mcp_produce_reggaeton \
    --bpm 95 \
    --key Am \
    --style classic \
    --structure verse-chorus \
    --record_arrangement true
```

### `produce_arrangement`
Genera producción directamente en Arrangement View.

```python
ableton-live-mcp_produce_arrangement \
    --bpm 95 \
    --key Am \
    --style classic
```

### `complete_production`
Pipeline completo con renderizado.

**Parámetros:**
- `bpm` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo (default: classic)
- `output_dir` (str, opcional): Directorio de salida

```python
ableton-live-mcp_complete_production \
    --bpm 95 \
    --key Am \
    --style perreo \
    --output_dir "C:\\Users\\Music\\Renders"
```

### `batch_produce`
Produce múltiples canciones en lote.

**Parámetros:**
- `count` (int, opcional): Número de canciones (default: 3, max: 10)
- `style` (str, opcional): Estilo (default: classic)
- `bpm_range` (str, opcional): Rango BPM "min-max"

```python
ableton-live-mcp_batch_produce \
    --count 5 \
    --style classic \
    --bpm_range "90-100"
```

### `build_song`
Canción completa con selección inteligente de samples.

**Parámetros:**
- `genre` (str, opcional): Género (default: reggaeton)
- `tempo` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo (default: standard)
- `auto_record` (bool, opcional): Auto grabar (default: true)

```python
ableton-live-mcp_build_song \
    --genre reggaeton \
    --tempo 95 \
    --key Am \
    --style standard \
    --auto_record true
```

### `build_arrangement_timeline`
Crea estructura de canción en Arrangement View directamente.

**Parámetros:**
- `sections_json` (str): JSON con configuración de secciones
- `genre` (str, opcional): Género (default: reggaeton)
- `tempo` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `style` (str, opcional): Estilo (default: standard)

```python
ableton-live-mcp_build_arrangement_timeline \
    --sections_json '[
        {"name": "Intro", "start_bar": 0, "duration_bars": 8, 
         "tracks": [{"type": "drums", "variation": "minimal"}]},
        {"name": "Verse", "start_bar": 8, "duration_bars": 16,
         "tracks": [{"type": "drums", "variation": "full"}, 
                    {"type": "bass", "variation": "standard"}]},
        {"name": "Chorus", "start_bar": 24, "duration_bars": 8,
         "tracks": [{"type": "drums", "variation": "full"},
                    {"type": "bass", "variation": "melodic"},
                    {"type": "chords", "variation": "i-v-vi-iv"},
                    {"type": "melody", "variation": "lead"}]}
    ]' \
    --genre reggaeton \
    --tempo 95 \
    --key Am
```

### `create_section_at_bar`
Crea una sección de canción en posición específica.

**Parámetros:**
- `track_index` (int): Track objetivo
- `section_type` (str): Tipo (intro, verse, chorus, bridge, outro, build, drop)
- `at_bar` (float): Barra de inicio
- `duration_bars` (int, opcional): Duración (default: 8)
- `key` (str, opcional): Tonalidad (default: Am)

```python
ableton-live-mcp_create_section_at_bar \
    --track_index 2 \
    --section_type chorus \
    --at_bar 24 \
    --duration_bars 8 \
    --key Am
```

### `create_arrangement_track`
Crea un track directamente en Arrangement View.

**Parámetros:**
- `track_type` (str): Tipo de track (drums, bass, chords, melody, fx, perc)
- `name` (str, opcional): Nombre personalizado
- `insert_at_bar` (int, opcional): Posición inicial

```python
ableton-live-mcp_create_arrangement_track \
    --track_type drums \
    --name "Drum Bus"
```

### `produce_with_library`
Producción completa usando librería real de samples.

**Parámetros:**
- `genre` (str, opcional): Género (default: reggaeton)
- `tempo` (int, opcional): BPM (default: 95)
- `key` (str, opcional): Tonalidad (default: Am)
- `bars` (int, opcional): Longitud (default: 16)
- `auto_play` (bool, opcional): Auto reproducir (default: true)
- `record_arrangement` (bool, opcional): Grabar a Arrangement (default: true)

```python
ableton-live-mcp_produce_with_library \
    --genre reggaeton \
    --tempo 95 \
    --key Am \
    --bars 32 \
    --auto_play true \
    --record_arrangement true
```

### `create_drum_kit`
Crea un drum kit en un Drum Rack.

**Parámetros:**
- `track_index` (int): Track con Drum Rack
- `kick_path` (str, opcional): Ruta al sample de kick
- `snare_path` (str, opcional): Ruta al sample de snare
- `hat_path` (str, opcional): Ruta al sample de hi-hat
- `clap_path` (str, opcional): Ruta al sample de clap

```python
ableton-live-mcp_create_drum_kit \
    --track_index 2 \
    --kick_path "libreria/reggaeton/kick/kick 1.wav" \
    --snare_path "libreria/reggaeton/snare/snare 1.wav" \
    --hat_path "libreria/reggaeton/hi-hat/hihat 1.wav"
```

### `load_sample_to_drum_rack`
Carga un sample en un pad específico del Drum Rack.

**Parámetros:**
- `track_index` (int): Track con Drum Rack
- `sample_path` (str): Ruta al sample
- `pad_note` (int, opcional): Nota MIDI del pad (default: 36 = C1)

```python
ableton-live-mcp_load_sample_to_drum_rack \
    --track_index 2 \
    --sample_path "libreria/reggaeton/kick/kick 1.wav" \
    --pad_note 36
```

### `build_track_from_samples`
Construye una pista completa desde samples.

**Parámetros:**
- `track_type` (str): Tipo (drums, bass, melody, fx)
- `sample_role` (str, opcional): Rol del sample (drums, bass, synths, fx)

```python
ableton-live-mcp_build_track_from_samples \
    --track_type drums \
    --sample_role drums
```

### `select_samples_for_genre`
Selecciona samples para un género.

**Parámetros:**
- `genre` (str): Género
- `bpm` (int, opcional): BPM
- `key` (str, opcional): Tonalidad

```python
ableton-live-mcp_select_samples_for_genre \
    --genre reggaeton \
    --bpm 95 \
    --key Am
```

### `load_samples_for_genre`
Selecciona y carga samples para un género.

```python
ableton-live-mcp_load_samples_for_genre \
    --genre reggaeton \
    --bpm 95 \
    --key Am
```

### `generate_track_from_config`
Genera pista desde configuración JSON.

**Parámetros:**
- `track_config_json` (str): Configuración JSON

```python
ableton-live-mcp_generate_track_from_config \
    --track_config_json '{
        "type": "drums",
        "pattern": "dembow",
        "bars": 8
    }'
```

### `generate_section`
Genera una sección de canción desde JSON.

**Parámetros:**
- `section_config_json` (str): Configuración de sección
- `start_bar` (int, opcional): Barra de inicio

```python
ableton-live-mcp_generate_section \
    --section_config_json '{
        "type": "verse",
        "bars": 16,
        "elements": ["drums", "bass"]
    }' \
    --start_bar 8
```

### `generate_intelligent_track`
Genera track profesional con selección inteligente de samples.

**Parámetros:**
- `description` (str): Descripción en lenguaje natural
- `structure_type` (str, opcional): Tipo de estructura (tiktok, short, standard, extended)
- `variation_level` (str, opcional): Nivel de variación (low, medium, high)
- `coherence_threshold` (float, opcional): Umbral de coherencia 0.0-1.0 (default: 0.90)
- `include_vocal_placeholder` (bool, opcional): Incluir track de voz (default: true)
- `surprise_mode` (bool, opcional): Modo sorpresa (default: false)
- `save_as_preset` (bool, opcional): Guardar como preset (default: true)

```python
ableton-live-mcp_generate_intelligent_track \
    --description "reggaeton perreo intenso 95bpm Am" \
    --structure_type standard \
    --variation_level high \
    --coherence_threshold 0.90
```

---

## Workflow & Quality

### `get_workflow_status`
Obtiene estado actual del workflow con próximos pasos.

```python
ableton-live-mcp_get_workflow_status

# Respuesta incluye:
# - Estado actual del proyecto
# - Configuración de mezcla
# - Contenido del arrangement
# - Próximos pasos recomendados
```

### `get_project_summary`
Obtiene resumen del proyecto.

```python
ableton-live-mcp_get_project_summary
```

### `get_production_report`
Genera reporte completo de producción.

```python
ableton-live-mcp_get_production_report
```

### `get_progress_report`
Reporte detallado de progreso del proyecto.

```python
ableton-live-mcp_get_progress_report
```

### `validate_project`
Valida consistencia del proyecto y buenas prácticas.

```python
ableton-live-mcp_validate_project
```

### `full_quality_check`
Verificación completa de calidad.

```python
ableton-live-mcp_full_quality_check
```

### `fix_quality_issues`
Arregla automáticamente problemas detectados.

**Parámetros:**
- `issues` (array, opcional): Lista específica de issues a arreglar

```python
ableton-live-mcp_fix_quality_issues

# Arreglar issues específicos
ableton-live-mcp_fix_quality_issues \
    --issues ["clipping", "low_volume", "phase_issues"]
```

### `suggest_improvements`
Sugerencias IA para mejorar el proyecto.

```python
ableton-live-mcp_suggest_improvements
```

### `save_checkpoint`
Guarda un checkpoint del proyecto.

**Parámetros:**
- `name` (str, opcional): Nombre del checkpoint (default: "auto")

```python
ableton-live-mcp_save_checkpoint --name "antes_del_mix"
```

### `undo`
Deshace la última acción.

```python
ableton-live-mcp_undo
```

### `redo`
Rehace la última acción deshecha.

```python
ableton-live-mcp_redo
```

### `enable_parallel_processing`
Activa/desactiva procesamiento paralelo.

**Parámetros:**
- `enabled` (bool): true para activar, false para desactivar

```python
ableton-live-mcp_enable_parallel_processing --enabled true
```

### `get_memory_usage`
Obtiene uso de memoria del sistema y proyecto.

```python
ableton-live-mcp_get_memory_usage
```

---

## Export & Render

### `export_project`
Exporta proyecto a archivo de audio.

**Parámetros:**
- `path` (str): Ruta del archivo de salida
- `format` (str, opcional): Formato (wav, mp3, aiff, flac)

```python
ableton-live-mcp_export_project \
    --path "C:\\Users\\Music\\output.wav" \
    --format wav
```

### `render_stems`
Renderiza stems individuales para mezcla externa.

**Parámetros:**
- `output_dir` (str): Directorio de salida

```python
ableton-live-mcp_render_stems \
    --output_dir "C:\\Users\\Music\\Stems"
```

### `render_full_mix`
Renderiza mix completo masterizado.

**Parámetros:**
- `output_path` (str): Ruta del archivo de salida

```python
ableton-live-mcp_render_full_mix \
    --output_path "C:\\Users\\Music\\Master.wav"
```

### `render_instrumental`
Renderiza versión instrumental (sin tracks de voz).

**Parámetros:**
- `output_path` (str): Ruta del archivo de salida

```python
ableton-live-mcp_render_instrumental \
    --output_path "C:\\Users\\Music\\Instrumental.wav"
```

### `create_radio_edit`
Crea versión radio edit (corta, sin intros largos).

**Parámetros:**
- `output_path` (str): Ruta del archivo de salida

```python
ableton-live-mcp_create_radio_edit \
    --output_path "C:\\Users\\Music\\RadioEdit.wav"
```

### `create_dj_edit`
Crea versión DJ edit (extended intro/outro, cue points).

**Parámetros:**
- `output_path` (str): Ruta del archivo de salida

```python
ableton-live-mcp_create_dj_edit \
    --output_path "C:\\Users\\Music\\DJEdit.wav"
```

### `duplicate_project`
Duplica el proyecto actual con nuevo nombre.

**Parámetros:**
- `new_name` (str): Nombre para el proyecto duplicado

```python
ableton-live-mcp_duplicate_project --new_name "MiTrack_v2"
```

---

## Presets

### `list_presets`
Lista todos los presets disponibles.

```python
ableton-live-mcp_list_presets
```

### `load_preset`
Carga un preset en el proyecto actual.

**Parámetros:**
- `preset_name` (str): Nombre del preset

```python
ableton-live-mcp_load_preset --preset_name "MiTemplateReggaeton"
```

### `save_as_preset`
Guarda el proyecto actual como preset.

**Parámetros:**
- `name` (str): Nombre del preset
- `description` (str, opcional): Descripción

```python
ableton-live-mcp_save_as_preset \
    --name "TemplateCompleto" \
    --description "Template con drums, bass, chords, melody"
```

### `create_custom_preset`
Crea un preset personalizado desde cero.

**Parámetros:**
- `name` (str): Nombre del preset
- `description` (str, opcional): Descripción

```python
ableton-live-mcp_create_custom_preset \
    --name "MiKitPersonalizado" \
    --description "Kit de samples personalizados"
```

---

## Transport

### `start_playback`
Inicia la reproducción.

```python
ableton-live-mcp_start_playback
```

### `stop_playback`
Detiene la reproducción.

```python
ableton-live-mcp_stop_playback
```

### `toggle_playback`
Alterna reproducción/parada.

```python
ableton-live-mcp_toggle_playback
```

### `stop_all_clips`
Detiene todos los clips en Session View.

```python
ableton-live-mcp_stop_all_clips
```

---

## Session View (Legacy)

### `create_clip`
Crea un clip MIDI en Session View.

**Parámetros:**
- `track_index` (int): Track objetivo
- `clip_index` (int, opcional): Índice del clip slot (default: 0)
- `length` (float, opcional): Longitud en beats (default: 4)

```python
ableton-live-mcp_create_clip --track_index 6 --clip_index 0 --length 4
```

### `add_notes_to_clip`
Añade notas MIDI a un clip.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int): Índice del clip
- `notes` (array): Lista de notas

```python
ableton-live-mcp_add_notes_to_clip \
    --track_index 6 \
    --clip_index 0 \
    --notes '[
        {"pitch": 36, "start_time": 0, "duration": 1, "velocity": 100}
    ]'
```

### `fire_clip`
Dispara un clip en Session View.

**Parámetros:**
- `track_index` (int): Track del clip
- `clip_index` (int, opcional): Índice del clip (default: 0)

```python
ableton-live-mcp_fire_clip --track_index 6 --clip_index 0
```

### `fire_scene`
Dispara una escena completa.

**Parámetros:**
- `scene_index` (int): Índice de la escena

```python
ableton-live-mcp_fire_scene --scene_index 0
```

### `get_scenes`
Lista todas las escenas en Session View.

```python
ableton-live-mcp_get_scenes
```

### `set_scene_name`
Establece el nombre de una escena.

**Parámetros:**
- `scene_index` (int): Índice de la escena
- `name` (str): Nombre

```python
ableton-live-mcp_set_scene_name --scene_index 0 --name "Intro"
```

### `create_scene`
Crea una nueva escena.

**Parámetros:**
- `index` (int, opcional): Posición (-1 = final)

```python
ableton-live-mcp_create_scene --index -1
```

### `fire_all_clips`
Dispara todos los clips de una escena (auto-play).

**Parámetros:**
- `scene_index` (int, opcional): Índice de escena (default: 0)
- `start_playback` (bool, opcional): Iniciar playback (default: true)

```python
ableton-live-mcp_fire_all_clips --scene_index 0 --start_playback true
```

### `record_to_arrangement`
Graba Session View a Arrangement View.

**Parámetros:**
- `duration_bars` (int, opcional): Duración en compases (default: 8)

```python
ableton-live-mcp_record_to_arrangement --duration_bars 32
```

### `get_recording_status`
Obtiene estado de grabación en progreso.

```python
ableton-live-mcp_get_recording_status
```

### `stop_recording`
Detiene grabación en progreso.

```python
ableton-live-mcp_stop_recording
```

---

## Help

### `help`
Lista todas las tools o ayuda detallada de una tool específica.

**Parámetros:**
- `tool_name` (str, opcional): Nombre de la tool para ayuda detallada

```python
# Listar todas las tools
ableton-live-mcp_help

# Ayuda detallada de una tool
ableton-live-mcp_help --tool_name generate_complete_reggaeton
```

---

## Historial

- **v3.0** (2026-04-12): Documentación completa de 114+ herramientas
- **Autor:** AbletonMCP_AI Senior Architecture Team

## Relacionado

- `PROFESSIONAL_WORKFLOW.md` - Guía de flujo profesional paso a paso
- `skill_produccion_audio.md` - Skill de producción de audio
- `skill_reinicio_ableton.md` - Proceso de reinicio correcto
