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

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 en total 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 a él, Ant Group lanzó Ring-2.5-1T, el primer modelo pensante 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 capacidad agentiva.

**HuggingFace:** [inclusionAI/Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) **Modelo acompañante:** [inclusionAI/Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) (variante pensante/razonadora) **Licencia:** Código abierto (Licencia Ant Group InclusionAI)

## Características clave

* **1 billón de parámetros en total, 63B activos** — escala masiva con activación eficiente estilo MoE
* **Atención lineal híbrida** — combina MLA (Atención Lineal Multi-cabeza) con Lightning Linear Attention para un rendimiento excepcional en secuencias largas
* **Ventana de contexto de 1M tokens** — mediante la extensión YaRN desde el nativo de 256K, maneja bases de código completas y documentos del tamaño de libros
* **Razonamiento de vanguardia** — se aproxima al rendimiento de modelos pensantes mientras usa \~4× menos tokens de salida
* **Capacidades agente** — entrenado con RL agentivo, compatible con Claude Code, OpenCode y OpenClaw
* **Compañero Ring-2.5-1T** — la variante dedicada al razonamiento 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 extendido        | 1M tokens (YaRN)                                 |
| Fecha de lanzamiento      | 16 de febrero de 2026                            |

## Requisitos

Ejecutar Ling-2.5-1T en precisión completa requiere recursos sustanciales. 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.0+                | 12.0+          | 12.0+            |

**Configuración recomendada para Clore.ai:**

* **Cuantizado (Q4):** 8× RTX 4090 (\~$4–16/día) — usable para experimentación y cargas de trabajo moderadas
* **Producción (FP8):** 8× H100 (\~$24–48/día) — calidad completa con buen rendimiento
* **Nota:** Este es un modelo extremadamente grande. Para usuarios con presupuesto limitado, considere los modelos más pequeños de la familia Ling en [HuggingFace](https://huggingface.co/inclusionAI).

## Inicio rápido con vLLM

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

```bash
# 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 memoria, limite 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:

```bash
# 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 (verifique HuggingFace para los quants disponibles)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \
    --include "*.Q4_K_M.gguf" \
    --local-dir ./models/

# Servir con llama-server (ajuste -ngl según la cantidad de GPUs)
./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. Completado de chat vía API de OpenAI

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

```python
from openai import OpenAI

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

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 largo contexto

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

```python
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 arquitectónicos:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

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

### 3. Uso agentivo de herramientas

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

```python
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": ["electronics", "clothing", "books"]},
                    "max_price": {"type": "number"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[{"role": "user", "content": "Encuéntrame un portátil 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 pensante (razonador)                           |
| Arquitectura         | Atención lineal híbrida                      | Atención lineal híbrida                               |
| Mejor para           | Chat general, programación, tareas agentivas | 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úrese de que su instancia de Clore.ai tenga suficiente disco y multi-GPU antes de descargar.
2. **Comience con `--max-model-len 8192`** — Al probar por primera vez, utilice un contexto corto para verificar que el modelo se cargue y funcione correctamente. Aumente la longitud del contexto una vez que todo funcione.
3. **Use almacenamiento persistente** — El modelo pesa 1–2TB. Adjunte un volumen persistente grande en Clore.ai para evitar volver a descargarlo. Descargue una vez con `huggingface-cli download`.
4. **Considere Ring-2.5-1T para tareas de razonamiento** — Si su caso de uso es principalmente matemáticas, lógica o razonamiento formal, el modelo acompañante Ring-2.5-1T está específicamente optimizado para razonamiento en cadena de pensamiento.
5. **Monitoree la memoria GPU** — Con configuraciones de 8 GPUs, use `nvidia-smi -l 1` para monitorear el uso de memoria y vigilar OOM durante la generación con contextos largos.

## Solución de problemas

| Problema                        | Solución                                                                                                                                     |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA fuera de memoria`         | Reducir `--max-model-len`; asegúrese `--tensor-parallel-size` coincida con la cantidad de GPUs; pruebe `--gpu-memory-utilization 0.95`       |
| Generación muy lenta            | La atención lineal necesita calentamiento; las primeras solicitudes pueden ser lentas. También verifique que tenga NVLink entre GPUs         |
| Fallo en la descarga del modelo | El modelo tiene \~2TB en BF16. Asegure suficiente espacio en disco. Use `--resume-download` bandera con `huggingface-cli`                    |
| vLLM no soporta la arquitectura | Asegúrese de estar usando vLLM ≥0.7.0 con `--trust-remote-code`; las capas de atención personalizadas requieren esta bandera                 |
| GGUF no disponible              | Verifique [unsloth](https://huggingface.co/unsloth) o cuantizaciones comunitarias; el modelo puede tardar en ser cuantizado por la comunidad |
| Respuestas de baja calidad      | Use temperatura ≤0.1 para tareas factuales; agregue un prompt de sistema; asegúrese de no truncar el contexto                                |

## Lecturas adicionales

* [Anuncio oficial (BusinessWire)](https://www.businesswire.com/news/home/20260215551663/en/) — Detalles del lanzamiento y benchmarks
* [HuggingFace — Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) — Pesos del modelo y documentación
* [HuggingFace — Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) — Modelo acompañante pensante
* [Mirror de ModelScope](https://www.modelscope.cn/models/inclusionAI/Ling-2.5-1T) — Descargas más rápidas en Asia
* [Documentación vLLM](https://docs.vllm.ai/) — Framework de servicio


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ling25.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.