NVIDIA NIM: qué modelo para qué tarea — análisis técnico 2026

El catálogo build.nvidia.com contiene más de 100 modelos. Esto es tanto su fortaleza como su problema: si es la primera vez que visita la plataforma, la elección paraliza. ¿DeepSeek o Kimi? ¿Nemotron o Llama? ¿GLM-5 o Qwen3.5?

Este artículo es un análisis técnico práctico: qué modelo ejecutar para qué tarea específica.

¿Leyó el material anterior? En el artículo «NVIDIA NIM: cómo la inferencia gratuita está cambiando la arquitectura de los sistemas de IA», analicé por qué la inferencia se está convirtiendo en una capa de producto básico, en qué se diferencia NVIDIA Build de OpenRouter y Groq, y qué consecuencias arquitectónicas tiene esto para los agentes de IA. Este material es una continuación lógica: modelos específicos, código específico.

Contenido

• Conexión a NVIDIA NIM: primeros pasos
• Mapa de modelos: quién es quién en el catálogo NIM
• Benchmarks: cifras reales de rendimiento
• Tarea 1: Codificación y codificación de agentes
• Tarea 2: Razonamiento complejo y matemáticas
• Tarea 3: RAG y contexto largo
• Tarea 4: Orquestación multiagente
• Tarea 5: Tareas multilingües
• Tarea 6: Salida estructurada y llamada a funciones
• Práctica: cómo cambiar de modelo sin refactorizar
• Árbol de decisiones: qué modelo elegir
• Trampas: comportamientos específicos del modelo

Conexión a NVIDIA NIM: primeros pasos

Antes de comparar modelos, la configuración básica. Lleva menos de 5 minutos.

Paso 1. Regístrese en el Programa de Desarrolladores de NVIDIA (gratuito, solo necesita un correo electrónico).

Paso 2. Genere una clave API en build.nvidia.com. La clave tendrá el prefijo nvapi-.

Paso 3. Instale las dependencias:

pip install openai
export NVIDIA_API_KEY="nvapi-tu-clave"

Cliente Python básico:

from openai import OpenAI

client = OpenAI(
    api_key="nvapi-tu-clave",
    base_url="https://integrate.api.nvidia.com/v1"
)

response = client.chat.completions.create(
    model="meta/llama-4-scout-17b-16e-instruct",  # solo cambia esta línea
    messages=[
        {"role": "system", "content": "Eres un asistente técnico."},
        {"role": "user", "content": "Escribe una función para búsqueda binaria en Python."}
    ],
    temperature=0.1,
    max_tokens=1024
)

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

Equivalente curl:

curl https://integrate.api.nvidia.com/v1/chat/completions \
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta/llama-4-scout-17b-16e-instruct",
    "messages": [
      {"role": "user", "content": "Escribe una función para búsqueda binaria en Python."}
    ],
    "max_tokens": 1024
  }'

Detalle clave: la URL base es la misma para todos los modelos. Para cambiar de Llama a DeepSeek, solo necesita cambiar una línea: el valor del parámetro model. Es por eso que elegir el modelo correcto no es una refactorización de código, sino una configuración.

Mapa de modelos: quién es quién en el catálogo NIM

A mayo de 2026, hay más de 100 modelos disponibles en el catálogo build.nvidia.com. Analicemos las familias principales:

Llamo la atención sobre una observación importante: en 2026, la mayoría de los modelos de primer nivel provienen de laboratorios chinos. Según BenchLM.ai, las primeras posiciones en la clasificación de modelos de peso abierto las ocupan DeepSeek V4 Pro (87 puntos), Kimi K2.6 (84), GLM-5.1 (83) y Qwen3.5 397B (79). En este contexto, Llama de Meta ya no parece dominante en la parte superior de la tabla.

Benchmarks: cifras reales de rendimiento

Las cifras que se presentan a continuación se recopilaron de Artificial Analysis, BenchLM.ai y LearnAIForge (mayo de 2026).

Índice de Inteligencia General (Artificial Analysis v4.0)

SWE-Bench Verificado (corrección autónoma de problemas reales de GitHub)

RULER Long-Context (precisión en 1M de tokens)

Tarea 1 — Coding y coding agentico

Coding es la categoría más competitiva entre los modelos NIM en 2026. Analizaré tres niveles de dificultad.

Nivel 1: tareas sencillas (función, algoritmo, corrección de errores)

Recomendación: deepseek-ai/deepseek-v4-flash

Desde un punto de vista práctico, DeepSeek V4 Flash es un modelo MoE de 284B que activa solo una parte de los parámetros por token. Esto proporciona una relación velocidad-calidad inusual: el modelo se comporta significativamente más ligero de lo que su tamaño general podría sugerir.

Según pruebas prácticas de desarrolladores, V4 Flash cubre alrededor del 80% de las tareas de coding típicas con una calidad que antes requería modelos considerablemente más caros y pesados.

# Tareas de coding sencillas — DeepSeek V4 Flash
response = client.chat.completions.create(
    model="deepseek-ai/deepseek-v4-flash",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python developer. Return only code, no explanations."
        },
        {
            "role": "user",
            "content": "Write a binary search function with type hints and docstring."
        }
    ],
    temperature=0.0,  # para código siempre 0
    max_tokens=512
)

Nivel 2: tareas complejas (edición de múltiples archivos, refactorización)

Recomendación: moonshotai/kimi-k2.6 o deepseek-ai/deepseek-v4-pro

Según el benchmark comparativo de agentes de coding, Kimi K2.6 obtiene 87/100 y cuesta 3.6 veces menos que Claude Opus en tareas similares. DeepSeek V4 Pro obtiene 89/100, pero requiere un harness específico para liberar su máximo potencial.

# Coding agentico complejo — Kimi K2.6
response = client.chat.completions.create(
    model="moonshotai/kimi-k2.6",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a senior software engineer. "
                "When editing code, show ONLY the changed parts with clear markers. "
                "Always verify your changes are consistent across all files."
            )
        },
        {
            "role": "user",
            "content": "Refactor this FastAPI app to use async SQLAlchemy:\n\n[código aquí]"
        }
    ],
    temperature=0.1,
    max_tokens=4096
)

Nivel 3: corrección autónoma de issues de GitHub (clase SWE-Bench)

Mi recomendación: nvidia/nemotron-3-super-120b

Para tareas del tipo "corrige autónomamente este bug en el repositorio", Nemotron 3 Super muestra un 60.47% en SWE-Bench Verified y proporciona un throughput 7.5 veces mayor en comparación con Qwen3.5-122B con una calidad comparable, lo cual es un factor crítico para mí en escenarios donde los agentes procesan varias tareas en paralelo.

# Agente de coding autónomo — Nemotron 3 Super
# IMPORTANTE: para modelos de pensamiento, añade los parámetros correctos
response = client.chat.completions.create(
    model="nvidia/nemotron-3-super-120b",
    messages=[
        {
            "role": "system",
            "content": (
                "You are an autonomous software engineer. "
                "Given a GitHub issue description and relevant code, "
                "produce a complete patch. Think step by step before coding."
            )
        },
        {
            "role": "user",
            "content": "Issue: #1234 — Memory leak in connection pool\n\n[código del repositorio]"
        }
    ],
    temperature=0.15,
    max_tokens=8192
)

Tabla resumen de coding

Tarea 2 — Razonamiento complejo y matemáticas

Reasoning son tareas donde el modelo debe "pensar" antes de responder: matemáticas, lógica, GPQA Diamond, Humanity's Last Exam.

Observo que para la mayoría de las tareas, la mejor opción universal sigue siendo deepseek-ai/deepseek-v4-pro con el modo de razonamiento activado.

Para tareas científicas: qwen/qwen3.5-397b — Humanity's Last Exam score 25.30% frente a 18.26% en Nemotron Super.

# Tarea de razonamiento con chain-of-thought explícito
response = client.chat.completions.create(
    model="deepseek-ai/deepseek-v4-pro",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a mathematical reasoning engine. "
                "Always show your full chain of thought before the final answer. "
                "Format: ...\n\nFinal answer: ..."
            )
        },
        {
            "role": "user",
            "content": (
                "A train leaves city A at 60 km/h. Another leaves city B at 80 km/h "
                "toward A. The cities are 420 km apart. When and where do they meet?"
            )
        }
    ],
    temperature=0.0,
    max_tokens=2048
)

Importante para modelos de pensamiento: DeepSeek V4-Pro y Kimi K2-Thinking son "modelos de pensamiento" — utilizan un chain-of-thought interno antes de responder. Para los modelos "pensadores", establece temperature=0.0 o un valor muy bajo, de lo contrario, el razonamiento se vuelve inestable.

Comparación de modelos de razonamiento en NIM

Tarea 3 — RAG y contexto largo

En mis experimentos prácticos con RAG (Retrieval-Augmented Generation) — cuando el modelo recibe un gran contexto externo en forma de documentos, bases de conocimiento o repositorios de código — los resultados más estables los proporcionan no los modelos universales, sino configuraciones especializadas para el volumen de contexto y el tipo de tarea de recuperación.

Mi recomendación: deepseek-ai/deepseek-v4-flash para la mayoría de los escenarios RAG y nvidia/nemotron-3-ultra-500b para tareas de contexto extremadamente largo.

Parámetros clave de selección que considero al trabajar con RAG:

• Tamaño del contexto: DeepSeek V4 Flash — hasta 1M de tokens; Nemotron Ultra — hasta 10M de tokens, que actualmente es uno de los indicadores más altos entre los modelos de peso abierto.
• Calidad en contexto largo: Nemotron 3 Super muestra un 91.75% en RULER @ 1M ctx frente a un 22.30% en GPT-OSS-120B, lo que afecta significativamente la estabilidad de las respuestas en documentos largos.
• Velocidad de recuperación: Las versiones Flash de DeepSeek suelen ofrecer un mejor equilibrio entre latencia y calidad para pipelines RAG estándar, especialmente con un gran número de consultas paralelas.

# Pipeline RAG — DeepSeek V4 Flash con documentos
def query_rag(user_question: str, retrieved_chunks: list[str]) -> str:
    context = "\n\n---\n\n".join(retrieved_chunks)

    response = client.chat.completions.create(
        model="deepseek-ai/deepseek-v4-flash",
        messages=[
            {
                "role": "system",
                "content": (
                    "Answer questions using ONLY the provided context. "
                    "If the answer is not in the context, say so explicitly. "
                    "Always cite the relevant passage."
                )
            },
            {
                "role": "user",
                "content": f"Context:\n{context}\n\nQuestion: {user_question}"
            }
        ],
        temperature=0.0,
        max_tokens=1024
    )
    return response.choices[0].message.content

# Para documentos extremadamente largos — Nemotron Ultra (10M ctx)
def query_giant_document(document: str, question: str) -> str:
    response = client.chat.completions.create(
        model="nvidia/nemotron-3-ultra-500b",
        messages=[
            {
                "role": "system",
                "content": "Analyze the entire document carefully before answering."
            },
            {
                "role": "user",
                "content": f"Document:\n{document}\n\nQuestion: {question}"
            }
        ],
        temperature=0.0,
        max_tokens=2048
    )
    return response.choices[0].message.content

Tabla de selección para RAG

Tarea 4 — Orquestación multi-agente

Para sistemas multi-agente, el parámetro clave no es solo la calidad de una consulta, sino el throughput en sesiones paralelas y la fiabilidad de la llamada a herramientas.

Nemotron 3 Super utiliza una arquitectura MoE híbrida Mamba-Transformer. En comparación con los modelos densos, esto proporciona un throughput de inferencia 5 veces mayor en hardware NVIDIA en sesiones de agentes concurrentes — gracias a que MoE activa solo una parte de los parámetros por token.

Para la decodificación especulativa: Nemotron 3 Super alcanza una longitud promedio de aceptación de 3.45 tokens por paso de verificación frente a 2.70 en DeepSeek-R1 — lo que proporciona hasta 3 veces de aceleración sin un modelo de borrador separado.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key="nvapi-tu-clave",
    base_url="https://integrate.api.nvidia.com/v1"
)

# Ejecución paralela de agentes especializados
async def run_agent(role: str, model: str, task: str) -> dict:
    response = await async_client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": f"You are a specialist in {role}."},
                  {"role": "user", "content": task}],
        temperature=0.1,
        max_tokens=1024
    )
    return {
        "role": role,
        "model": model,
        "result": response.choices[0].message.content
    }

async def multi_agent_pipeline(user_task: str) -> dict:
    # Definimos agentes especializados — cada uno recibe el modelo óptimo
    agents = [
        ("planning",    "nvidia/nemotron-3-super-120b",     f"Plan this task: {user_task}"),
        ("coding",      "moonshotai/kimi-k2.6",             f"Write code for: {user_task}"),
        ("retrieval",   "deepseek-ai/deepseek-v4-flash",    f"Find relevant info about: {user_task}"),
        ("summarizer",  "google/gemma-4-31b-it",            f"Summarize results for: {user_task}"),
    ]

    # Ejecutamos en paralelo — ahorramos tiempo
    results = await asyncio.gather(*[
        run_agent(role, model, task)
        for role, model, task in agents
    ])

    return {r["role"]: r["result"] for r in results}

# Ejecución
results = asyncio.run(multi_agent_pipeline(
    "Analyze our Q3 sales data and generate a board presentation"
))

Presto atención a la decisión arquitectónica: cada agente en el sistema recibe un modelo óptimo para su rol. Por ejemplo, para la tarea de resumen utilizo Gemma, más barata, en lugar de Nemotron — ya que para un resumen simple la diferencia de calidad es mínima, mientras que la diferencia de coste y latencia es significativa.

Tarea 5 — Tareas multilingües

Si tu producto atiende a una audiencia en varios idiomas, la elección del modelo afecta significativamente la calidad.

Para CJK (chino, japonés, coreano): qwen/qwen3-32b o zhipuai/glm-5.1 — Qwen y GLM tienen soporte nativo para chino, que supera con creces a los modelos de Meta o NVIDIA.

Para idiomas eslavos y multilingüismo general: deepseek-ai/deepseek-v4-flash — muestra buenos resultados en la mayoría de los idiomas europeos.

Para multilingüismo multimodal (texto + imágenes + audio): nvidia/nemotron-3-nano-omni — modelo MoE de 30B, lanzado el 28 de abril de 2026, soporta texto, imagen, video y audio a través de una única arquitectura.

# Pipeline multilingüe con selección automática de modelo
LANGUAGE_MODEL_MAP = {
    "zh": "zhipuai/glm-4.7",          # Chino — GLM es el mejor
    "ja": "qwen/qwen3-32b",            # Japonés — Qwen es más fuerte
    "ko": "qwen/qwen3-32b",            # Coreano
    "uk": "deepseek-ai/deepseek-v4",   # Ucraniano
    "ru": "deepseek-ai/deepseek-v4",   # Ruso
    "en": "deepseek-ai/deepseek-v4-flash",  # Inglés — flash es suficiente
    "default": "deepseek-ai/deepseek-v4"
}

def multilingual_query(text: str, lang: str) -> str:
    model = LANGUAGE_MODEL_MAP.get(lang, LANGUAGE_MODEL_MAP["default"])

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": text}],
        temperature=0.3,
        max_tokens=1024
    )
    return response.choices[0].message.content

Tarea 6 — Salida estructurada y llamada a funciones

En mi práctica, a menudo me encuentro con que la salida estructurada fiable (JSON según un esquema) y la llamada a funciones son componentes críticos para los sistemas agenticos de producción. No todos los modelos manejan esto igual de bien, especialmente cuando se trata de esquemas complejos o herramientas anidadas.

Más detalles sobre la mecánica del uso de herramientas, el esquema JSON y su relación con RAG los he desglosado aquí: uso de herramientas vs llamada a funciones y RAG.

Modelos con soporte confirmado para llamadas a funciones en NIM: Llama 3.1 70B/405B, Nemotron-3-Super, GLM-4.7, GLM-5.1, Kimi K2.5, Mixtral 8x22B, Qwen 2.5 72B — todos soportan el formato estándar de uso de herramientas de OpenAI.

import json

# Llamada a funciones — GLM-5.1 o Nemotron Super
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"},
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="zhipuai/glm-5.1",   # O: nvidia/nemotron-3-super-120b
    messages=[
        {"role": "user", "content": "What's the weather in Kyiv and Berlin?"}
    ],
    tools=tools,
    tool_choice="auto",
    temperature=0.0
)

# Verificación de la llamada a la herramienta
message = response.choices[0].message
if message.tool_calls:
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        print(f"Tool: {tool_call.function.name}, Args: {args}")

Salida JSON estructurada sin llamada a funciones:

# Salida JSON forzada a través de prompt del sistema
response = client.chat.completions.create(
    model="zhipuai/glm-5.1",
    messages=[
        {
            "role": "system",
            "content": (
                "You MUST respond ONLY with valid JSON matching this schema exactly. "
                "No explanations, no markdown, no code blocks.\n"
                "Schema: {\"sentiment\": \"positive|negative|neutral\", "
                "\"score\": 0.0-1.0, \"keywords\": [\"string\"]}"
            )
        },
        {
            "role": "user",
            "content": "Analyze sentiment: 'The product exceeded all my expectations!'"
        }
    ],
    temperature=0.0,
    max_tokens=256
)

# SIEMPRE valida la salida
try:
    result = json.loads(response.choices[0].message.content)
except json.JSONDecodeError:
    # Lógica de fallback para JSON roto
    print("Model returned invalid JSON, retrying with stricter prompt...")

Práctica: cómo cambiar modelos sin refactorizar

El enfoque más eficaz es un objeto de configuración centralizado que separa la elección del modelo de la lógica de negocio:

from dataclasses import dataclass
from openai import OpenAI
from typing import Optional

@dataclass
class ModelConfig:
    model_id: str
    temperature: float = 0.1
    max_tokens: int = 1024
    supports_tools: bool = True
    context_window: int = 128_000

# Configuración centralizada — cambia aquí, no en el código
MODELS = {
    "coding_simple":    ModelConfig("deepseek-ai/deepseek-v4-flash",    temperature=0.0),
    "coding_complex":   ModelConfig("moonshotai/kimi-k2.6",             temperature=0.1, max_tokens=4096),
    "coding_agent":     ModelConfig("nvidia/nemotron-3-super-120b",     temperature=0.15, max_tokens=8192),
    "reasoning":        ModelConfig("deepseek-ai/deepseek-v4-pro",      temperature=0.0, max_tokens=4096),
    "rag_standard":     ModelConfig("deepseek-ai/deepseek-v4-flash",    temperature=0.0),
    "rag_longcontext":  ModelConfig("nvidia/nemotron-3-ultra-500b",     temperature=0.0, context_window=10_000_000),
    "multilingual":     ModelConfig("deepseek-ai/deepseek-v4",          temperature=0.3),
    "structured":       ModelConfig("zhipuai/glm-5.1",                  temperature=0.0),
    "summarizer":       ModelConfig("google/gemma-4-31b-it",            temperature=0.3, max_tokens=512),
}

class NIMClient:
    def __init__(self, api_key: str):
        self.client = OpenAI(
            api_key=api_key,
            base_url="https://integrate.api.nvidia.com/v1"
        )

    def query(
        self,
        task: str,
        messages: list[dict],
        config_key: str = "coding_simple",
        tools: Optional[list] = None
    ) -> str:
        cfg = MODELS[config_key]

        kwargs = {
            "model": cfg.model_id,
            "messages": messages,
            "temperature": cfg.temperature,
            "max_tokens": cfg.max_tokens,
        }
        if tools and cfg.supports_tools:
            kwargs["tools"] = tools
            kwargs["tool_choice"] = "auto"

        response = self.client.chat.completions.create(**kwargs)
        return response.choices[0].message.content

# Uso — la lógica de negocio no conoce los modelos específicos
nim = NIMClient(api_key="nvapi-tu-clave")

# Para cambiar el modelo, solo tienes que cambiar config_key
result = nim.query(
    task="coding",
    messages=[{"role": "user", "content": "Escribe un quicksort en Python"}],
    config_key="coding_simple"  # cambia a "coding_complex" para tareas más complejas
)

Árbol de decisión: qué modelo elegir

¿Qué tarea?
│
├── CODING
│   ├── Snippet / función simple
│   │   └── deepseek-ai/deepseek-v4-flash  ✓ rápido, barato
│   ├── Multi-archivo / refactorización
│   │   └── moonshotai/kimi-k2.6           ✓ contexto largo
│   └── Agente autónomo (clase SWE-Bench)
│       └── nvidia/nemotron-3-super-120b   ✓ mayor rendimiento
│
├── RAZONAMIENTO / MATEMÁTICAS
│   ├── Lógica, razonamiento de código
│   │   └── deepseek-ai/deepseek-v4-pro    ✓ razonamiento CoT
│   └── Tareas científicas, benchmark HLE
│       └── qwen/qwen3.5-397b              ✓ 25.30% HLE
│
├── RAG / CONTEXTO LARGO
│   ├── Hasta 128K tokens
│   │   └── deepseek-ai/deepseek-v4-flash  ✓ recuperación rápida
│   ├── Hasta 1M tokens
│   │   └── moonshotai/kimi-k2.5           ✓ optimizado para contexto largo
│   └── Más de 1M tokens
│       └── nvidia/nemotron-3-ultra-500b   ✓ 10M ctx, 91.75% RULER
│
├── ORQUESTADOR MULTIAGENTE
│   └── nvidia/nemotron-3-super-120b       ✓ 5x rendimiento, eficiencia MoE
│
├── MULTILENGUAJE
│   ├── CJK (zh/ja/ko)
│   │   └── qwen/qwen3-32b o zhipuai/glm-4.7
│   └── Idiomas europeos
│       └── deepseek-ai/deepseek-v4
│
├── SALIDA ESTRUCTURADA / LLAMADA A FUNCIONES
│   └── zhipuai/glm-5.1 o nvidia/nemotron-3-super-120b
│
└── RESUMEN (sensible al presupuesto)
    └── google/gemma-4-31b-it              ✓ el más barato para tareas simples

Trampas: comportamientos específicos del modelo

Lo que no está escrito en la documentación, pero es crucial en producción:

1. Los modelos de pensamiento requieren un manejo especial

Kimi K2-Thinking y DeepSeek V4-Pro en modo de razonamiento son "modelos de pensamiento". Generan una cadena de pensamiento interna antes de responder. Según la experiencia práctica de los desarrolladores, si cambias de un modelo de pensamiento a uno normal sin ajustar los parámetros, puedes obtener errores de API.

# Para modelos de pensamiento — NO pases reasoning_budget con modelos normales
# Para modelos que no son de pensamiento — establece NIM_ENABLE_THINKING=false si hay un conflicto

# Comprobación antes de la consulta
THINKING_MODELS = {
    "moonshotai/kimi-k2-thinking",
    "deepseek-ai/deepseek-v4-pro",  # en modo de razonamiento
}

def safe_query(model: str, messages: list, **kwargs) -> str:
    if model in THINKING_MODELS:
        kwargs.setdefault("temperature", 0.0)
        # NO añadas stream=True para modelos de pensamiento sin procesamiento adicional
    return client.chat.completions.create(
        model=model, messages=messages, **kwargs
    ).choices[0].message.content

2. GLM/Qwen requieren flags específicos para etiquetas de razonamiento

# GLM y Qwen 3.5 requieren --reasoning-format none
# si no se necesitan etiquetas <think> en la respuesta
# A través de la API, esto se resuelve con un prompt del sistema:
system_no_thinking = (
    "Responde directamente sin mostrar tu proceso de razonamiento. "
    "No uses etiquetas <think>."
)

3. Llama 4 utiliza un formato de herramienta Pythonico

Llama 4 Scout tiene un formato de llamadas a herramientas diferente al estándar de OpenAI (sintaxis Pythonica). Si tu analizador espera una llamada a herramienta JSON estándar, puede fallar al cambiar a Llama 4.

4. Límite de tasa de 40 RPM y flujos de trabajo de agentes

Con agentes de varios pasos, una "solicitud lógica" puede generar 5-10 llamadas a la API. 40 RPM = máximo ~4-8 tareas de usuario reales por minuto para un solo agente.

import time
import functools

def rate_limited(max_per_minute: int = 35):  # dejamos un buffer de 40
    min_interval = 60.0 / max_per_minute
    last_called = [0.0]

    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            wait = min_interval - elapsed
            if wait > 0:
                time.sleep(wait)
            result = func(*args, **kwargs)
            last_called[0] = time.time()
            return result
        return wrapper
    return decorator

@rate_limited(max_per_minute=35)
def api_call(messages, model):
    return client.chat.completions.create(
        model=model, messages=messages, max_tokens=1024
    )

5. Tabla resumen de comportamientos específicos del modelo

Resumen

Yo lo formulo así: elegir el modelo correcto en NVIDIA NIM no se trata de encontrar el "mejor" modelo, sino más bien de descomponer correctamente las tareas y asignar un modelo especializado a cada rol en el sistema.

Tres principios clave que utilizo en la práctica:

1. No uso un modelo pesado donde uno ligero es suficiente. Gemma 4 para resúmenes en lugar de Nemotron Ultra no es un compromiso, sino una decisión arquitectónicamente correcta.
2. Separo la elección del modelo de la lógica de negocio. Una configuración de modelo centralizada me permite cambiar el modelo sin refactorizar el código principal del sistema.
3. Tengo en cuenta los comportamientos específicos del modelo desde el principio. Los modelos de pensamiento, los diferentes formatos de llamada a herramientas, las diferencias de tokenizador son cosas que inevitablemente aparecen en producción, y es mejor incorporarlas en la arquitectura de antemano.

Fuentes

• NVIDIA Build — catálogo de modelos (actualizado mayo de 2026)
• Documentación de la API de NVIDIA
• BenchLM.ai — Rankings de los mejores LLM de código abierto (mayo de 2026)
• Artificial Analysis — Índice de Inteligencia v4.0
• LearnAIForge — Benchmarks de Nemotron 3 Super (marzo de 2026)
• ToolHalla — Guía completa de Nemotron 3 (marzo de 2026)
• BuildFastWithAI — Revisión de Nemotron 3 Nano Omni (abril de 2026)
• MindStudio — Mejores LLM de código abierto para codificación de agentes (2026)
• AkitaOnRails — Benchmark de codificación LLM (abril de 2026)
• DEV.to — Comparación de costos de DeepSeek vs Qwen vs Kimi vs GLM
• Guía de la API gratuita de NVIDIA Build (2026)
• Decode the Future — Explicación de la API NVIDIA NIM (abril de 2026)
• Free-LLM — Ejemplos de NVIDIA NIM en Python/JS/curl