Ling-2.5-1T (1 billón de parámetros)

Ejecuta Ling-2.5-1T: el LLM de código abierto de 1 billón de parámetros de Ant Group con atención lineal híbrida en GPUs de Clore.ai

Ling-2.5-1T de Ant Group (lanzado el 16 de febrero de 2026) es uno de los modelos de lenguaje de código abierto más grandes jamás publicados — 1 billón de parámetros totales con 63B activos. Introduce una arquitectura híbrida de atención lineal que permite una inferencia eficiente en longitudes de contexto de hasta 1 millón de tokens. Junto con él, Ant Group lanzó Ring-2.5-1T, el primer modelo de pensamiento del mundo con arquitectura lineal híbrida. Juntos, representan una nueva frontera en la IA de código abierto — competitivos con GPT-5.2, DeepSeek V3.2 y Kimi K2.5 en benchmarks de razonamiento y agentes.

HuggingFace: inclusionAI/Ling-2.5-1T Modelo acompañante: inclusionAI/Ring-2.5-1T (variante de pensamiento/razonamiento) Licencia: Código abierto (Licencia Ant Group InclusionAI)

Características clave

• 1 billón de parámetros totales, 63B activos — escala masiva con activación eficiente al estilo MoE

• Atención lineal híbrida — combina MLA (Atención lineal multicábeza) con Lightning Linear Attention para un rendimiento excepcional en secuencias largas

• Ventana de contexto de 1M tokens — mediante la extensión YaRN desde 256K nativos, maneja bases de código completas y documentos de extensión de libro

• Razonamiento de frontera — se acerca al rendimiento de los modelos de pensamiento usando ~4× menos tokens de salida

• Capacidades agénticas — entrenado con Agentic RL, compatible con Claude Code, OpenCode y OpenClaw

• Compañero Ring-2.5-1T — la variante de razonamiento dedicada alcanza nivel de medalla de oro en IMO 2025 y CMO 2025

Detalles de la arquitectura

Componente	Detalles
Parámetros totales	1T (1,000B)
Parámetros activos	63B
Arquitectura	Atención lineal híbrida (MLA + Lightning Linear)
Datos de preentrenamiento	29T tokens
Contexto nativo	256K tokens
Contexto ampliado	1M tokens (YaRN)
Fecha de lanzamiento	16 de febrero de 2026

Requisitos

Las configuraciones multi-GPU de clase 80GB no aparecen en el mercado de Clore.ai. Las mayores configuraciones listadas hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo solicitud. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Ejecutar Ling-2.5-1T con precisión completa requiere recursos considerables. Las versiones cuantizadas lo hacen más accesible.

Configuración	Cuantizado (Q4 GGUF)	FP8	BF16 (Completo)
GPU	8× RTX 4090	8× H100 80GB	16× H100 80GB
VRAM	8×24GB (192GB)	8×80GB (640GB)	16×80GB (1.28TB)
RAM	256GB	512GB	1TB
Disco	600GB	1.2TB	2TB+
CUDA	12.8+	12.8+	12.8+

Configuración recomendada de Clore.ai:

• Cuantizado (Q4): 8× RTX 4090 ($1.12–3.36/h) — usable para experimentación y cargas de trabajo moderadas

• Producción (FP8): 8× H100 (~$8.32/h) — calidad completa con buen rendimiento

• Nota: Este es un modelo extremadamente grande. Para usuarios con presupuesto limitado, consideren los modelos más pequeños de la familia Ling en HuggingFace.

Inicio rápido con vLLM

vLLM es el framework de servicio recomendado para Ling-2.5-1T:

# Instalar vLLM
pip install vllm

# Servir Ling-2.5-1T con paralelismo tensorial en 8 GPUs
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# Para reducir la memoria, limita la longitud del contexto:
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.95 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

Inicio rápido con llama.cpp (cuantizado)

Para configuraciones con GPU de consumo, hay cuantizaciones GGUF disponibles:

# Instalar llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Descargar un GGUF cuantizado (consulta HuggingFace para ver las cuantizaciones disponibles)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \
    --include "*.Q4_K_M.gguf" \
    --local-dir ./models/

# Servir con llama-server (ajusta -ngl según tu cantidad de GPU)
./build/bin/llama-server \
    -m ./models/Ling-2.5-1T-Q4_K_M.gguf \
    -ngl 99 \
    -c 8192 \
    --host 0.0.0.0 \
    --port 8000

Ejemplos de uso

1. Finalización de chat mediante la API de OpenAI

Una vez que vLLM o llama-server esté en ejecución:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no necesario"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Eres un asistente de razonamiento de clase mundial. Piensa paso a paso."},
        {"role": "user", "content": "Demuestra que la raíz cuadrada de 2 es irracional."}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)

2. Análisis de documentos de contexto largo

La atención lineal híbrida de Ling-2.5-1T lo hace excepcionalmente eficiente para documentos largos:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

# Cargar un documento grande
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # Puede tener cientos de miles de tokens

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Eres un arquitecto de software senior."},
        {"role": "user", "content": f"Analiza esta base de código en busca de vulnerabilidades de seguridad y problemas de arquitectura:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

print(response.choices[0].message.content)

3. Uso de herramientas agénticas

Ling-2.5-1T está entrenado con Agentic RL para llamadas a herramientas:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Buscar en la base de datos de productos",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string", "enum": ["electrónica", "ropa", "libros"]},
                    "max_price": {"type": "number"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[{"role": "user", "content": "Encuéntrame una laptop por menos de $1000 con buenas reseñas"}],
    tools=tools,
    tool_choice="auto"
)

print(response.choices[0].message.tool_calls)

Ling-2.5-1T vs Ring-2.5-1T

Aspecto	Ling-2.5-1T	Ring-2.5-1T
Tipo	Modelo instantáneo (rápido)	Modelo de pensamiento (razonamiento)
Arquitectura	Atención lineal híbrida	Atención lineal híbrida
Ideal para	Chat general, programación, tareas agénticas	Matemáticas, razonamiento formal, problemas complejos
Estilo de salida	Respuestas directas	Razonamiento en cadena de pensamiento
Eficiencia de tokens	Alta (menos tokens de salida)	Usa más tokens para razonar
IMO 2025	Competitivo	Nivel de medalla de oro

Consejos para usuarios de Clore.ai

1. Este modelo necesita hardware serio — Con 1T de parámetros, incluso la cuantización Q4 requiere ~500GB de almacenamiento y 192GB+ de VRAM. Asegúrate de que tu instancia de Clore.ai tenga suficiente disco y múltiples GPU antes de descargarlo.

2. Comienza con --max-model-len 8192 — Al probar por primera vez, usa un contexto corto para verificar que el modelo cargue y funcione correctamente. Aumenta la longitud del contexto una vez que todo funcione.

3. Usa almacenamiento persistente — El modelo pesa 1–2TB. Adjunta un volumen persistente grande en Clore.ai para evitar volver a descargarlo. Descarga una vez con huggingface-cli download.

4. Considera Ring-2.5-1T para tareas de razonamiento — Si tu caso de uso es principalmente matemáticas, lógica o razonamiento formal, el modelo acompañante Ring-2.5-1T está optimizado específicamente para el razonamiento en cadena de pensamiento.

5. Supervisa la memoria de la GPU — Con configuraciones de 8 GPU, usa nvidia-smi -l 1 para supervisar el uso de memoria y vigilar OOM durante la generación con contextos largos.

Solución de problemas

Problema	Solución
CUDA sin memoria	Reduce --max-model-len; asegúrate de que --tensor-parallel-size coincida con la cantidad de GPU; prueba --gpu-memory-utilization 0.95
Generación muy lenta	La atención lineal necesita calentamiento; las primeras solicitudes pueden ser lentas. Comprueba también que tienes NVLink entre las GPU
La descarga del modelo falla	El modelo es de ~2TB en BF16. Asegúrate de tener suficiente espacio en disco. Usa --resume-download la bandera con huggingface-cli
vLLM no admite la arquitectura	Asegúrate de usar vLLM ≥0.7.0 con --trust-remote-code; las capas de atención personalizadas requieren esta bandera
GGUF no disponible	Consulta unsloth o cuantizaciones de la comunidad; el modelo puede tardar en ser cuantizado por la comunidad
Respuestas de mala calidad	Usa temperatura ≤0.1 para tareas fácticas; añade un prompt del sistema; asegúrate de no truncar el contexto

Lecturas adicionales

• Anuncio oficial (BusinessWire) — Detalles del lanzamiento y benchmarks

• HuggingFace — Ling-2.5-1T — Pesos del modelo y documentación

• HuggingFace — Ring-2.5-1T — Modelo acompañante de pensamiento

• Espejo de ModelScope — Descargas más rápidas en Asia

• Documentación de vLLM — Framework de servicio