Documentación de Loadcore

Resumen

Loadcore es un sistema distribuido para ejecutar LLMs abiertos en tus propios servidores GPU. Instalas un pequeño agente en cada servidor y gestionas toda la flota desde una consola web. Cada modelo en ejecución se expone mediante una API compatible con OpenAI, así que tus herramientas funcionan sin cambios.

Tus prompts y respuestas nunca tocan los servidores de Loadcore. El tráfico de inferencia va de tus herramientas directamente al agente de tu servidor. El plano de control solo se encarga de la autenticación y la orquestación.

Arquitectura

Loadcore tiene tres componentes:

• Loadcore Console: la app web con la que tu equipo gestiona servidores, modelos, instancias, personas y claves.
• Loadcore API: el plano de control multiinquilino que guarda el estado de la flota y las reglas de acceso y valida las claves de API.
• Loadcore Agent: un único binario en Go en cada servidor GPU que instala llama.cpp, descarga modelos, ejecuta instancias y sirve /v1.

Los agentes envían latidos, progreso de descargas y estado de instancias a la API. Las herramientas envían las peticiones de inferencia directamente a los agentes.

Loadcore Console

La consola en console.loadcore.io es donde admins y miembros trabajan a diario:

• Panel con el estado de la flota de un vistazo
• Servidores para registrar máquinas y comprobar la conexión de los agentes
• Modelos para buscar en HuggingFace y descargar archivos GGUF en un servidor
• Instancias para iniciar, detener y conectarte a modelos en ejecución
• Mi uso para ver tus propias peticiones y tokens por modelo
• Organización para gestionar miembros, departamentos e invitaciones
• Ajustes para crear y revocar tus claves de API personales

Loadcore API

La API es el plano de control gestionado en api.loadcore.io. Se encarga de las organizaciones, roles, departamentos, el registro de servidores, el estado de modelos e instancias y las licencias. Cuando un agente recibe una petición, pregunta a la API si la clave es válida y qué modelos puede usar su propietario, y guarda la respuesta en caché durante 5 minutos.

La API nunca hace de proxy de la inferencia ni guarda prompts o respuestas.

Loadcore Agent

El agente es un único binario sin dependencias de ejecución. En el primer arranque instala la última versión de llama.cpp. Después:

• envía un latido cada 30 segundos con SO, arquitectura, GPU, RAM e IP pública
• descarga modelos en ~/.loadcore/models e informa del progreso
• inicia y detiene procesos de llama.cpp cuando se le pide
• comprueba el estado de las instancias en ejecución cada 15 segundos
• sirve GET /v1/models, POST /v1/chat/completions y POST /v1/completions

./loadcore-agent \
    --api-key="lc_..."                       # server key from registration
    --backend-url="https://api.loadcore.io"  # control plane
    --port=9090                              # listen port (default 9090)
    --data-dir=~/.loadcore                   # models and binaries
    --llama-cpp-version=latest               # pin a llama.cpp build

Cada opción también se puede definir con una variable de entorno: LOADCORE_API_KEY, LOADCORE_BACKEND_URL, LOADCORE_PORT, LOADCORE_DATA_DIR y LOADCORE_LLAMA_CPP_VERSION.

Configuración

1. Regístrate en la consola y crea tu organización.
2. Ve a Servidores y registra un servidor GPU. Copia la clave de servidor de un solo uso.
3. Copia el binario del agente al servidor e inícialo con esa clave.
4. Espera a que el servidor aparezca en línea. llama.cpp se instala automáticamente.
5. Descarga un modelo en el servidor e inicia una instancia.
6. Crea una clave de API personal en Ajustes y conecta tus herramientas.

Servidores

Cada servidor GPU ejecuta un agente. Regístralo desde la página Servidores y después inicia el agente con la clave de servidor. El servidor aparece con la información del sistema de su primer latido. Usa comprobar conexión para confirmar que el agente es accesible desde la red que usan tus herramientas.

Servidores GPU en la nube

Cualquier servidor GPU Linux que alquiles por horas funciona igual. Al registrarlo, abre la pestaña Servidor en la nube y copia el script de arranque. Pégalo en el campo de script de arranque al crear el servidor en tu proveedor, a menudo llamado user data o cloud-init. El servidor instala el agente como servicio del sistema en el primer arranque y aparece en la consola sin pasos manuales.

• Elige una imagen con los drivers de NVIDIA instalados para que llama.cpp use la GPU.
• El agente guarda modelos y binarios en /var/lib/loadcore.
• Para instancias distribuidas, crea todos los servidores en la misma región y red privada.
• El script contiene la clave del servidor. Rota la clave si personas ajenas a tu equipo pueden leer los ajustes del servidor en tu proveedor.

Modelos

• Busca modelos GGUF en HuggingFace desde la página Modelos.
• Elige el servidor destino y la cuantización que quepa en su VRAM.
• Sigue el progreso de la descarga en directo. Los archivos se guardan en el directorio de datos del agente.
• Al eliminar, quita solo la entrada o borra también el archivo del servidor.

Consulta las guías de modelos para ver la VRAM necesaria y los ajustes de muestreo recomendados por modelo.

Instancias

Una instancia es un servidor de llama.cpp en ejecución para un modelo en un servidor. Elige el servidor, el modelo, el tamaño de contexto y las capas en GPU, y arráncala. El agente lanza el proceso e informa de su estado. Ejecuta el mismo modelo en varios servidores para ganar rendimiento. Cada instancia en ejecución tiene un botón conectar con configuración lista para las herramientas habituales.

Instancias distribuidas

Cuando un modelo no cabe en la memoria GPU de un servidor, una instancia distribuida puede repartirlo entre varios servidores con llama.cpp RPC. Inicia la instancia en el servidor principal y marca Distribuir entre servidores para añadir servidores rpc. La consola muestra la memoria GPU combinada frente al tamaño del modelo.

• Solo el servidor principal necesita el archivo del modelo.
• Una instancia distribuida tiene un servidor principal y hasta 7 servidores rpc, 8 servidores en total.
• Los servidores deben estar en la misma red local rápida. Cada servidor rpc solo acepta conexiones del servidor principal.
• Te ayuda a que quepan modelos más grandes, no a ejecutarlos más rápido. Para repartir la carga, ejecuta instancias separadas y elige entre ellas.

Organizaciones

Todo pertenece a una organización: miembros, servidores, modelos, instancias y departamentos.

• Los admins gestionan miembros, departamentos, invitaciones, servidores y modelos, y pueden usar todos los modelos.
• Los miembros ven la flota y usan los modelos concedidos a sus departamentos.
• Invita a personas por correo. Cualquiera puede crear su propia cuenta.

Departamentos

Los departamentos deciden quién puede usar cada modelo. Crea departamentos, añade miembros y concede acceso por modelo. Un miembro en varios departamentos recibe la unión de sus permisos.

Ejemplo: Ingeniería tiene acceso a qwen3-coder-next e Investigación a deepseek-v4.1-flash. Quien esté en ambos puede usar los dos.

Claves de API

• Crea claves personales en Ajustes. Empiezan por sk-lc- y se muestran una sola vez.
• Una clave tiene los permisos de modelos de su propietario.
• El agente valida las claves con la API y guarda el resultado en caché durante 5 minutos.
• Revoca una clave en cualquier momento. La revocación surte efecto cuando caduca la caché del agente.

Conectar herramientas

Apunta cualquier herramienta compatible con OpenAI a http://your-server:9090/v1 con tu clave personal.

curl

curl http://your-server:9090/v1/chat/completions \
    -H "Authorization: Bearer sk-lc-your-key" \
    -H "Content-Type: application/json" \
    -d '{"model": "your-model.gguf", "messages": [{"role": "user", "content": "Hello"}]}'

Python

from openai import OpenAI

  client = OpenAI(base_url="http://your-server:9090/v1", api_key="sk-lc-your-key")
  client.chat.completions.create(
      model="your-model.gguf",
      messages=[{"role": "user", "content": "Hello"}],
  )

opencode

{
    "provider": {
      "loadcore": {
        "npm": "@ai-sdk/openai-compatible",
        "name": "Loadcore",
        "options": {
    "baseURL": "http://your-server:9090/v1",
    "apiKey": "{env:LOADCORE_API_KEY}"
        },
        "models": { "your-model.gguf": { "name": "Your model" } }
      }
    },
    "model": "loadcore/your-model.gguf"
  }

aider

aider \
    --model openai/your-model.gguf \
    --openai-api-key sk-lc-your-key \
    --openai-api-base http://your-server:9090/v1