> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ling25.md).

# 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](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 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 multicá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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) bajo solicitud. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

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](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 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:

```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 (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:

```python
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:

```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 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:

```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": ["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](https://huggingface.co/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)](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 de pensamiento
* [Espejo de ModelScope](https://www.modelscope.cn/models/inclusionAI/Ling-2.5-1T) — Descargas más rápidas en Asia
* [Documentación de vLLM](https://docs.vllm.ai/) — Framework de servicio


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
