Tu puesto de trabajo de IA, desde cero

Una hora bien invertida hoy te ahorra decenas de horas peleándote con instalaciones.

Qué vas a aprender

• Instalar desde cero Python 3.11+, Node.js 20+ y la cadena de herramientas de Rust
• Configurar entornos virtuales y gestores de paquetes para que tus proyectos sean reproducibles
• Comprobar el acceso a la GPU con CUDA/MPS y ejecutar una operación de prueba con tensores
• Entender la pila de cuatro capas: sistema, gestores de paquetes, runtimes y librerías de IA

Por qué importa

Vas a aprender ingeniería de IA a lo largo de más de 500 lecciones usando Python, TypeScript, Rust y Julia. Si tu entorno está roto, cada lección se convierte en una pelea con las herramientas en lugar de en un aprendizaje.

La mayoría de la gente se salta la configuración del entorno. Y luego pasa horas depurando errores de importación, conflictos de versiones y drivers de CUDA que faltan. Nosotros lo vamos a hacer una sola vez, y bien hecho.

La idea clave

Un entorno de ingeniería de IA tiene cuatro capas:

graph TD
    A["4. Librerías de IA/ML\nPyTorch, JAX, transformers…"] --> B["3. Runtimes de lenguaje\nPython 3.11+, Node 20+, Rust, Julia"]
    B --> C["2. Gestores de paquetes\nuv, pnpm, cargo, juliaup"]
    C --> D["1. Base del sistema\nSO, shell, git, editor, drivers de GPU"]

Se instala de abajo arriba: cada capa depende de la que tiene debajo. Si intentas instalar PyTorch (capa 4) sin un Python decente (capa 3), o sin drivers de GPU (capa 1), lo pagarás más tarde.

Paso a paso

Paso 1: la base del sistema

Comprueba tu sistema e instala lo básico.

# macOS
xcode-select --install
brew install git curl wget

# Ubuntu/Debian
sudo apt update && sudo apt install -y build-essential git curl wget unzip

# Windows (usa WSL2)
wsl --install -d Ubuntu-24.04

¿Usas Windows? Trabaja dentro de WSL2 (el subsistema de Linux de Windows). Casi toda la industria de IA trabaja sobre Linux y te ahorrarás muchísimos problemas con rutas, permisos y librerías nativas.

Paso 2: Python con uv

Usamos uv: es entre 10 y 100 veces más rápido que pip y gestiona los entornos virtuales automáticamente.

curl -LsSf https://astral.sh/uv/install.sh | sh

uv python install 3.12

uv venv
source .venv/bin/activate  # o .venv\Scripts\activate en Windows sin WSL

uv pip install numpy matplotlib jupyter

Compruébalo en tu ordenador con este código. También puedes ejecutarlo aquí mismo, en el navegador (verás la versión de Python del navegador, no la de tu ordenador):

import sys
print(f"Python {sys.version}")

import numpy as np
print(f"NumPy {np.__version__}")
a = np.array([1, 2, 3])
print(f"Vector: {a}, producto escalar consigo mismo: {np.dot(a, a)}")

Paso 3: Node.js con pnpm

Para las lecciones en TypeScript (agentes, servidores MCP, aplicaciones web).

curl -fsSL https://fnm.vercel.app/install | bash
fnm install 22
fnm use 22

npm install -g pnpm

node -e "console.log('Node', process.version)"

El instalador de fnm comprueba primero si existe unzip y, si no está, se detiene con el mensaje Not installing fnm due to missing dependencies.: en Linux descomprime un archivo zip y en macOS instala mediante Homebrew. macOS ya trae unzip; Ubuntu, Debian y WSL2 lo obtienen con la línea de apt del paso 1 (ejecuta sudo apt install -y unzip si te saltaste ese paso).

macOS con Apple Silicon (M1/M2/M3/M4): si el instalador se detiene con Error: Cannot install under Rosetta 2 in ARM default prefix (/opt/homebrew), tu terminal se está ejecutando bajo Rosetta 2 (arch muestra i386) mientras que Homebrew es una compilación nativa arm64. Instala fnm forzando arm64, conéctalo a tu shell y vuelve a ejecutar los comandos anteriores a partir de fnm install 22:

arch -arm64 brew install fnm
echo 'eval "$(fnm env --use-on-cd)"' >> ~/.zshrc
source ~/.zshrc

Paso 4: Rust

Para las lecciones donde el rendimiento es crítico (inferencia, sistemas).

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

rustc --version
cargo --version

Paso 5: Julia (opcional)

Para las lecciones con mucha matemática, donde Julia brilla.

curl -fsSL https://install.julialang.org | sh

julia -e 'println("Julia ", VERSION)'

Paso 6: configurar la GPU (si tienes una)

NVIDIA (Linux / Windows):

nvidia-smi

# Instala PyTorch con soporte CUDA
uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

macOS con Apple Silicon (M1/M2/M3/M4): en un Mac no hay CUDA, y eso es lo esperado, no un fallo. No uses --index-url .../cuXXX (esas versiones son solo para Linux/Windows y la instalación fallará). Instala la versión normal, que incluye el backend de GPU MPS (Metal) de Apple:

uv pip install torch torchvision torchaudio

Compruébalo (funciona en cualquier plataforma):

import torch
print(f"CUDA disponible: {torch.cuda.is_available()}")           # False en macOS: es lo esperado
print(f"MPS disponible:  {torch.backends.mps.is_available()}")   # True en Apple Silicon
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")

¿No tienes GPU? No pasa nada. La mayoría de lecciones funcionan en CPU. Para las que entrenan modelos pesados, usarás Google Colab o GPUs en la nube (lo vemos en la lección «GPU local o en la nube: cuándo y cómo»).

Paso 7: verifica tu entorno

Descarga verificar_entorno.py desde la sección «Archivos de la lección» (al final de esta página), guárdalo en la carpeta donde vas a trabajar y ejecútalo:

python3 verificar_entorno.py

Comprueba lo imprescindible para empezar (Python 3.11+, Git, uv, entorno virtual activo y NumPy). Cada comprobación que falla te muestra el comando exacto para arreglarla. Corrige lo que salga en rojo y vuelve a ejecutarlo hasta que veas:

¡Todo listo! Tu entorno está preparado para empezar el curso.

Si quieres revisar también lo que usarás más adelante (Node.js, Jupyter, Docker, GPU…), añade --todo:

python3 verificar_entorno.py --todo

Que falte algo «para más adelante» no te impide empezar: instálalo cuando una lección te lo pida.

En la práctica

Tu entorno ya está listo. Instala el resto de herramientas cuando una lección te las pida, en lugar de bloquear tu primera lección con toda la pila. Esto es lo que usarás a lo largo del temario:

Errores típicos (y cómo evitarlos)

Tu caja de herramientas

Te llevas un script de verificación que puedes ejecutar siempre que cambies de ordenador o algo deje de funcionar.

Y un prompt para que un asistente de IA (Claude, ChatGPT…) te ayude a diagnosticar problemas de entorno. Cópialo, pégalo en el asistente y después descríbele el error que te aparezca:

Eres un experto en diagnosticar entornos de desarrollo para ingeniería de IA. Estoy preparando
mi ordenador para un curso que usa Python, TypeScript, Rust y Julia.

Cuando te describa un problema:
1. Identifica qué capa está rota: sistema, gestor de paquetes, runtime del lenguaje o librería.
2. Pídeme la salida del comando de diagnóstico que necesites.
3. Dame la solución exacta: los comandos concretos que debo ejecutar, no una guía general.

Problemas habituales:
- Python demasiado antiguo: uv python install 3.12
- CUDA no detectado (Linux/Windows con NVIDIA): revisar nvidia-smi y reinstalar PyTorch con la versión de CUDA correcta.
- macOS con Apple Silicon: no hay CUDA y es lo normal. Instalar PyTorch sin --index-url y usar el backend MPS.
- Falta Node.js: fnm install 22
- Errores de importación tras instalar: comprobar con `which python` que estoy en el entorno virtual.
- Errores de permisos: nunca usar sudo pip install; usar uv con un entorno virtual.

Al final, pídeme que ejecute `python3 verificar_entorno.py` para confirmar que está arreglado.

Retos para tu ordenador

1. Ejecuta el script de verificación y corrige todos los fallos
2. Crea un entorno virtual para este curso e instala PyTorch
3. Escribe un «hola mundo» en los cuatro lenguajes y ejecuta cada uno

Y ahora, la práctica interactiva de abajo para fijar lo aprendido.