Logré montar mi propio hub de IA con Gemini, ChatGPT, Claude y Perplexity en un solo endpoint (sin API keys) usando Docker y EasyPanel

¿Te imaginas tener una sola URL que te conecte a ChatGPT, Claude, Gemini y Perplexity al mismo tiempo, sin pagar API keys, funcionando 24/7 desde tu propio servidor? En esta guía te muestro exactamente cómo hacerlo, paso a paso, con código incluido.

Proxima es una herramienta open‑source que usa un navegador invisible para conectarse a tus cuentas gratuitas de IA y expone una API REST compatible con OpenAI. El problema es que fue diseñado para correr en tu PC local con Windows. Nosotros lo vamos a llevar a la nube usando EasyPanel y Docker.

Requisitos Previos

• Un servidor con EasyPanel instalado (Ubuntu recomendado).
• Un dominio web apuntando a tu servidor (ej: proxima.midominio.com) EasyPanel te ofrece uno gratuito pero necesitas dos uno para el API y el otro para ver proxima en la web, y hacer los logueos.
• Cuentas gratuitas de las IAs que quieras usar (ChatGPT, Claude, Gemini, Perplexity), recomiendo el logueo por por la extension EditThisCokie.

Paso 1: Crear el Repositorio con los Archivos de Despliegue

Proxima no se puede desplegar directo desde su repositorio original porque necesita un entorno gráfico virtual (VNC), parches de red para Docker y persistencia de datos. Por eso, vamos a crear nuestro propio repositorio con solo 2 archivos: un Dockerfile y un start.sh.

1.1 — Crea un repositorio nuevo en GitHub

Ve a github.com/new y crea un repositorio (puede ser público o privado). Por ejemplo: mi-usuario/proxima-cloud.

1.2 — Crea el archivo Dockerfile

Este archivo le dice a Docker cómo construir el contenedor. Internamente clona Proxima, instala un escritorio virtual, parchea el código para que funcione en red, y descarga Electron manualmente (para evitar bugs conocidos de npm en ARM):

FROM node:20-bookworm-slim

# Instalar dependencias: X11, VNC, noVNC, navegador y utilidades
RUN apt-get update && apt-get install -y --no-install-recommends \
    bash \
    xvfb \
    x11vnc \
    novnc \
    websockify \
    chromium \
    libnss3 \
    libfreetype6 \
    libharfbuzz0b \
    ca-certificates \
    fonts-freefont-ttf \
    fluxbox \
    sudo \
    git \
    build-essential \
    python3 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Clonar Proxima, parchear el binding de red y compilar
RUN git clone https://github.com/Zen4-bit/Proxima.git . \
    && sed -i "s/'127.0.0.1'/'0.0.0.0'/g" electron/rest-api.cjs \
    && chown -R node:node /app \
    && su node -c "npm install --include=dev"

# Descargar Electron manualmente (evita errores de npm en ARM/x64)
RUN apt-get update && apt-get install -y wget unzip \
    && mkdir -p /app/node_modules/electron/dist \
    && cd /app/node_modules/electron/dist \
    && export ARCH=$(uname -m) \
    && if [ "$ARCH" = "aarch64" ]; then ELEC_ARCH="arm64"; else ELEC_ARCH="x64"; fi \
    && wget https://github.com/electron/electron/releases/download/v33.4.11/electron-v33.4.11-linux-${ELEC_ARCH}.zip \
    && unzip -o electron-v33.4.11-linux-${ELEC_ARCH}.zip \
    && rm electron-v33.4.11-linux-${ELEC_ARCH}.zip \
    && chmod +x electron

# Variables de entorno
ENV DISPLAY=:99
ENV ELECTRON_USER_DATA_DIR=/app/userdata
ENV CHROME_BIN=/usr/bin/chromium
ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true

# Crear directorio de datos persistentes
RUN mkdir -p /app/userdata && chown -R node:node /app

# Copiar script de arranque
COPY start.sh /start.sh
RUN chmod +x /start.sh

# Exponer puertos: API (3210) y VNC web (6080)
EXPOSE 3210 6080

# Volumen para persistencia
VOLUME ["/app/userdata"]

CMD ["/start.sh"]

¿Qué hace la línea sed -i "s/'127.0.0.1'/'0.0.0.0'/g"?
Proxima originalmente solo acepta conexiones desde localhost. Docker necesita que escuche en todas las interfaces (0.0.0.0) para que el proxy inverso de EasyPanel pueda enrutar el tráfico hacia la API. Este sed aplica ese parche automáticamente durante la construcción.

1.3 — Crea el archivo start.sh

Este script arranca todos los servicios necesarios en orden: pantalla virtual, administrador de ventanas, servidor VNC, puente web (noVNC) y finalmente Proxima:

#!/bin/bash
set -e

echo "Starting Xvfb..."
Xvfb :99 -screen 0 1280x800x24 -ac &
sleep 2

echo "Starting Fluxbox window manager..."
fluxbox 2>/dev/null &

echo "Starting x11vnc..."
x11vnc -display :99 -forever -nopw -bg -xkb

echo "Starting noVNC..."
websockify --web /usr/share/novnc 6080 localhost:5900 &

echo "Starting Proxima application..."
if [ -f package.json ]; then
    npm start -- --no-sandbox --disable-gpu --disable-dev-shm-usage --user-data-dir=/app/userdata
else
    echo "No package.json found. Keeping container alive for debugging..."
    tail -f /dev/null
fi

¿Qué hace --user-data-dir=/app/userdata?
Le dice a Electron que guarde todas las cookies, sesiones y configuraciones en /app/userdata en vez de una ruta interna del sistema. Así, cuando montemos un volumen en ese directorio, los datos sobreviven a cualquier reinicio.

1.4 — Sube los archivos a GitHub

git add Dockerfile start.sh
git commit -m "Proxima Cloud-Ready deployment"
git push origin main

¡Eso es todo lo que necesitas en el repositorio! Solo 2 archivos.

Paso 2: Crear la App en EasyPanel

1. Inicia sesión en tu panel de EasyPanel.
2. Entra a tu Proyecto y haz clic en + Create → App.
3. Dale un nombre (ej: proxima) y créala.

Paso 3: Conectar tu Repositorio

1. En la pestaña General de tu nueva app, busca la sección Source.
2. Selecciona GitHub.
3. Conecta tu cuenta de GitHub si no lo has hecho.
4. Selecciona tu repositorio (ej: mi-usuario/proxima-cloud).
5. Branch: main.
6. Haz clic en Save.

Paso 4: Configurar los Dominios y Puertos

Proxima expone dos servicios en puertos diferentes. Si no configuras esto bien, todo se rompe:

Cómo configurarlo:

1. Ve a la pestaña Domains en tu app de EasyPanel.
2. Dominio para VNC:
   • Domain: vnc.midominio.com
   • Port: 6080
   • Clic en guardar.
3. Dominio para la API:
   • Domain: api.midominio.com
   • Port: 3210
   • Clic en guardar.

Paso 5: Crear el Volumen de Persistencia

Sin este paso, perderás tus inicios de sesión cada vez que el contenedor se reinicie.

1. Ve a la pestaña Mounts (Montajes).
2. Agrega un nuevo montaje:
   • Type: Volume
   • Name / Source: proxima_data
   • Mount Path: /app/userdata
3. Guarda.

Paso 6: Desplegar

1. Haz clic en el botón verde Deploy en la esquina superior.
2. Espera unos minutos a que termine de construirse (puedes seguir el progreso en la pestaña Deployments).

Paso 7: Iniciar Sesión en las IAs

Importante: Solo necesitas hacer este paso una vez. Gracias al volumen que creamos en el Paso 5, tus sesiones se guardan permanentemente aunque reinicies el servidor.

Paso 8: ¡Probar tu API! 🚀

Abre una terminal en cualquier computadora y ejecuta:

curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chatgpt",
    "messages": [{"role": "user", "content": "Hola, ¿estás ahí?"}]
  }'

En unos segundos recibirás la respuesta directa desde ChatGPT, pasando por tu servidor en la nube.

Endpoints principales

Paso 9: Más allá del chat — funciones inteligentes con un solo endpoint

Una de las mayores ventajas de Proxima es que puedes usar el mismo endpoint para muchas tareas distintas, simplemente añadiendo el campo "function" en tu petición. Olvídate de cambiar de URL o de usar herramientas diferentes.

Modelos disponibles

Usa estos valores en el campo "model":

Funciones integradas (campo function)

En cada petición a /v1/chat/completions puedes agregar "function" para cambiar el comportamiento:

Ejemplos prácticos

Chat normal

curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "claude", "message": "¿Qué es la inteligencia artificial?"}'

Búsqueda con Perplexity

bash
curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "perplexity", "message": "últimas noticias de IA 2026", "function": "search"}'

Traducción con Gemini

bash
curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini", "message": "Hello world", "function": "translate", "to": "Hindi"}'

Generar código con Claude

bash
curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude",
    "message": "algoritmo de ordenamiento burbuja",
    "function": "code",
    "action": "generate",
    "language": "Python"
  }'

Auditar seguridad de un fragmento de código

bash
curl -X POST https://api.midominio.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chatgpt",
    "message": "Revisa este código",
    "function": "security_audit",
    "code": "eval(user_input)"
  }'

Incluso puedes combinar cualquier modelo con cualquier función. Por ejemplo, pedirle a Gemini que busque, o a ChatGPT que traduzca. La API es totalmente flexible.

Resultado Final

Ahora tienes tu propio Hub de Inteligencia Artificial privado en la nube:

• ✅ 4 IAs unificadas en un solo endpoint.
• ✅ Sin API keys — usa tus cuentas gratuitas existentes.
• ✅ Disponible 24/7 — no depende de que tu PC esté encendida.
• ✅ Persistente — tus sesiones sobreviven a cualquier reinicio o actualización.
• ✅ Compatible con OpenAI — conéctalo a Cursor, VSCode, o cualquier app que soporte la API de OpenAI.
• ✅ Tu propio dominio con HTTPS incluido gracias a EasyPanel + Traefik.
• ✅ Funciones avanzadas como búsqueda web, traducción, generación de código, análisis de seguridad y más, todo desde la misma URL.
• ✅ WebSocket para respuestas en streaming en tiempo real.

¿Te animarías a montar tu propia nube privada de Inteligencia Artificial? En witmovil seguimos explorando las mejores herramientas para potenciar tu productividad y control sobre tus datos. ¡Cuéntanos en los comentarios qué tal te fue con el despliegue!