How much GPU memory does a large language model need?

The weights are the parameter count multiplied by the bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. A 7-8 billion parameter model is 16 GB of weights at 16-bit, 8 GB at 8-bit and 5 GB at 4-bit; a 70 billion parameter model is 140 GB, 70 GB and 38 GB. Those figures are the weights alone and are a floor rather than a requirement -- budget a quarter to a half again on top for the runtime, the activations and the key-value cache.

What do I need to run a 70B model like Llama 3.3?

At 4-bit the weights are about 38 GB, so with serving head-room the answer is a card of 64 GB or more -- one card, one machine. At 8-bit the weights are 70 GB and an 80 GB card clears the bar. At full 16-bit precision no single card Primcast fits holds it, and it becomes a multi-card build that is quoted. The fit matrix on the page names the exact cards; the prices are at https://primcast.com/gpu.

Why does my model load but fail to serve?

Because the weights are not the only thing in card memory. The runtime and its buffers are resident, and every token in a conversation leaves an entry in the key-value cache so it does not have to be recomputed. That cache grows with the context length and again with each request served concurrently, so a model whose weights only just fit will hold roughly one short conversation. Size the card at one and a quarter to one and a half times the weights.

Which inference runtime can I install?

Any of them. The machine arrives with a clean operating system and root, and there is no vendor inference service in front of it. vLLM is the usual answer for serving real traffic because continuous batching lets one card answer many requests at once. llama.cpp is the usual answer when memory is tight or the card is older. TGI and SGLang run unchanged. Ollama is the shortest path from an empty machine to a model answering on a port -- and vLLM and Ollama both answer on an OpenAI-compatible endpoint, so existing client code points at your own machine by changing one base URL. You pin the driver, the CUDA or ROCm release and the framework to the versions your code was tested against.

Is self-hosting an LLM cheaper than a per-token API?

It depends entirely on volume, and the crossover is real: an API bills per token and costs nothing when idle; a dedicated machine is a flat monthly figure and costs nothing more when busy. Steady traffic, agents that run all day, batch pipelines and anything with a privacy requirement tend to come out ahead on their own hardware; a workload that fires ten times a day does not. The monthly figures to do that arithmetic with are at https://primcast.com/gpu -- the LLM page deliberately prices nothing.

How many tokens per second will I get?

Primcast does not publish a tokens-per-second figure, because every such number depends on the model, the quantisation, the runtime and its version, the batch size, the prompt length, the reply length and the concurrency, and changing any one moves it by a multiple. What governs it: reading the prompt is compute-bound and happens once per request; generating the reply is memory-bandwidth-bound because each token requires reading the weights; and batching amortises that reading across concurrent requests, which is what makes serving economical until the key-value cache runs out of room. Ask with the model, quantisation and expected concurrency for an answer based on what has actually been observed.

Is the GPU shared with anyone else?

No. One tenant per physical machine, and the card is passed through to your own operating system. There is no hypervisor, no MIG partition, no vGPU profile and no time-slicing scheduler, so nothing else runs on the card and inference latency does not move because of somebody else's batch job.

What if the model does not fit on one card?

Then it is a multi-card build, which is quoted rather than ordered from a checkout: how many cards fit depends on the physical width of the specific card and the power budget of the chassis. Two cards give you the sum of their memory only if the runtime can split the model across both, which every serious runtime supports at some cost in throughput. https://primcast.com/hpc covers what more than one card and more than one machine look like; 128 GB of memory the processor and GPU share in one machine is https://primcast.com/spark.

Does fine-tuning need more memory than serving?

Considerably more. Serving needs the weights; training needs the weights, the gradients and the optimiser state for every parameter being updated, all resident at once, plus the activations kept for the backward pass. A model that serves comfortably on one card can be several times too large to fully fine-tune on it. Parameter-efficient methods update a small fraction of the parameters and need a correspondingly small fraction of the extra memory, which is why most fine-tuning here uses one.

Can I run an AMD card, and does ROCm work?

Yes. The AMD Instinct parts are among the largest-memory cards fitted and are frequently the best value per gigabyte, but your stack has to support ROCm rather than CUDA. Most current inference runtimes do; some surrounding tooling still does not. Ask before ordering and it will be checked against your specific runtime rather than answered in general.

Hoja de dimensionamiento · modelos de lenguaje en bare metal · desde 2004

Qué se necesita para ejecutar un modelo de lenguaje en bare metal.

Se rellena desde arriba, tal como avanza la decisión: el modelo fija los pesos, la precisión los escala, el margen cubre el tiempo de ejecución y la conversación, y el total nombra la tarjeta. Nada más en el formulario de pedido cambia la respuesta — una tarjeta dos gigabytes por debajo no funciona más lento: no llega a cargar.

Dibujado por: Primcast LLC, fundada en 2004
Verificado contra: El catálogo de pedidos, en el momento de servir
Tarjetas en archivo · la mayor: 56 · 96 GB GDDR7 ECC
Precios en esta hoja: Ninguno — véase /gpu

Rellena la hoja de cálculo Por qué un ajuste puede fallar igualmente Qué instalo en ella

Convierte tus GPUs en ingresos mensuales pasivos

¿Tienes configuraciones de GPU de servidor o de escritorio sin usar? Anúncialas hoy en el marketplace de Primcast y obtén rentas mensuales estables de equipos de IA, desarrolladores y empresas que necesitan cómputo de grado de producción.

Ir al Marketplace

Hoja de cálculo

Cuatro líneas, un veredicto.

El modelo

La precisión

El servicio

70B: 38 GB × 1.5 = 57 GB

Smallest card on the schedule that clears it (3 larger ones also do):

Instinct MI21064 GB HBM2e

The link opens the machine it goes in. What it costs is on /gpu — not on this sheet.

Línea 1 × línea 2 son los pesos; la línea 3 es la regla publicada del sitio de margen de un cuarto a la mitad como aritmética — un cuarto más para un usuario a la vez en llama.cpp u Ollama, la mitad más para servir tráfico con procesamiento por lotes continuo en vLLM o TGI. El veredicto nombra la tarjeta más pequeña del catálogo de pedidos que supera el total y enlaza a la máquina en la que va. Lo que cuesta esa máquina está deliberadamente fuera de esta hoja: cada cifra está en /gpu, junto a la máquina exacta a la que pertenece.

Fig. 1

Cuánto pesan los pesos.

Parámetros multiplicados por bytes por parámetro, y ese es todo el cálculo. Los pesos de dieciséis bits son dos bytes cada uno, los de ocho bits son uno, los de cuatro bits son medio. Cuantizar es lo que convierte una máquina que no puede contener un modelo en una que sí puede; cuesta calidad, y cuánta depende del modelo y del método mucho más que solo del número de bits. Si la precisión es el objetivo del ejercicio, prueba ambos antes de comprometerte con el hardware — la diferencia es más barata de descubrir ahora que después de la entrega.

Estas cifras son los pesos y nada más. Son el suelo, no el requisito — la Fig. 2 es la parte que sorprende a la gente.

Weights only — the runtime, the activations and the conversation are extra, and are the subject of the next section.
Model	16-bit	8-bit	4-bit
7-8 billion parameters	16 GB	8 GB	5 GB
13-14 billion parameters	28 GB	14 GB	8 GB
30-34 billion parameters	68 GB	34 GB	19 GB
70 billion parameters	140 GB	70 GB	38 GB

Fig. 2 · interactiva

La memoria de una tarjeta, dibujada a escala — y por qué un modelo que cabe puede negarse a servir.

La forma más común en que una compra de GPU sale mal, siempre de la misma manera: el modelo tiene treinta y ocho gigabytes, la tarjeta cuarenta, carga — y mantiene aproximadamente una conversación corta. Los pesos no están solos ahí dentro. Desliza la carga de trabajo y observa qué hace la conversación.

pesos · fijos

tiempo de ejecución

caché clave-valor · crece

libre

memoria de una tarjeta, 100 %

La conversación · longitud de contexto × solicitudes a la vez

Un usuario, contexto corto: el multiplicador ajustado (×1,25) cubre esto.

Cada token de una conversación deja una entrada en la caché clave-valor para que no se recalcule. La caché crece con la longitud del contexto, y otra vez con cada solicitud servida a la vez.
Presupuesta un cuarto más sobre los pesos para un usuario a la vez, la mitad más para servir tráfico — los dos multiplicadores de la hoja de cálculo, y la propia regla publicada del sitio.
Si está justo, pregunta antes de comprar: modelo, cuantización, contexto, concurrencia. Preferimos dimensionarte una tarjeta ahora que aceptar un pedido que vuelva como solicitud de reembolso en la primera semana.

Fig. 3

La matriz de ajuste: qué tarjeta supera qué modelo.

Lee hacia abajo hasta tu modelo, en horizontal hasta la precisión. Cada celda nombra la tarjeta más pequeña del programa de piezas que contiene esos pesos con espacio para servir, y enlaza a la máquina en la que va. Donde nada lo supera por sí solo, la celda lo dice en lugar de dejar un espacio en blanco.

The smallest card we fit that holds the weights with room left to serve — that is 1.5× the weights, the generous end of the quarter-to-a-half head-room rule below. No prices here on purpose: GPU dedicated servers holds every one.
If you want to run	at 16-bit	at 8-bit	at 4-bit
7-8 billion parameters	TESLA P40 / QUADRO P600024 GB16 GB of weights	TITAN V12 GB HBM28 GB of weights	TESLA P48 GB GDDR55 GB of weights
13-14 billion parameters	RTX A600048 GB GDDR6 ECC28 GB of weights	TESLA P40 / QUADRO P600024 GB14 GB of weights	TITAN V12 GB HBM28 GB of weights
30-34 billion parameters	More than one cardNothing we fit holds it alone68 GB of weights	Instinct MI21064 GB HBM2e34 GB of weights	Tesla V100 32GB32 GB HBM219 GB of weights
70 billion parameters	More than one cardNothing we fit holds it alone140 GB of weights	More than one cardNothing we fit holds it alone70 GB of weights	Instinct MI21064 GB HBM2e38 GB of weights

La tarjeta más pequeña que cabe no siempre es la tarjeta que quieres. La memoria decide si un modelo se ejecuta; todo lo demás de la tarjeta decide a qué velocidad, y para cuántas personas a la vez. Si el rendimiento importa más que el presupuesto, sube un escalón en el programa.
Las tarjetas más antiguas no hablan los formatos numéricos más nuevos. Varias piezas del programa son anteriores a FP8 y bfloat16, así que un tiempo de ejecución que los espere retrocederá a algo más lento o se negará. Vale la pena preguntar por una tarjeta concreta y un tiempo de ejecución concreto antes de pedir.
Una tarjeta AMD ejecuta ROCm, no CUDA. Las piezas Instinct tienen una excelente relación valor por gigabyte y son la respuesta en más de una celda, pero tu pila tiene que soportar ROCm. La mayoría de los tiempos de ejecución actuales lo hacen; algunas herramientas a su alrededor todavía no. Comprueba el tuyo, o pregunta y lo comprobaremos contigo.
“Más de una tarjeta” es una configuración que cotizamos, no una opción de pago — cuántas tarjetas caben depende del ancho de la tarjeta concreta y del presupuesto de energía del chasis. Multi-GPU y multi-nodo es esa hoja. La otra respuesta a ese tamaño son 128 GB de memoria que el procesador y la GPU comparten, en una máquina: alquilar un NVIDIA DGX Spark.

Programa A

Programa de piezas: cada tarjeta que instalamos con una cifra de memoria publicada.

La mayor primero — esta hoja responde “qué es lo más grande que puedo ejecutar”, lo contrario de servidores dedicados GPU, que ordena el mismo catálogo por la máquina completa más barata porque responde “qué cuesta esto”. Una tarjeta cuya memoria el fabricante no publica se deja fuera en lugar de adivinarla.

Varias piezas aparecen en más de un chasis, a veces a precios diferentes, y la generación del bus de la máquina subyacente cambia lo que una tarjeta moderna puede hacer realmente — ambas cosas están en servidores dedicados GPU. Qué está montado en bastidor y listo en este momento es otra pregunta distinta, respondida por servidores instantáneos.

Referencia

Modelos con nombre, asignados a las filas.

Las familias de pesos abiertos que la gente trae aquí, con el recuento de parámetros publicado que dice qué fila de la Fig. 1 aplica. Los recuentos de parámetros son de los propios editores; nada más de un modelo importa para la cuestión del ajuste. Un modelo que no está en esta lista se dimensiona exactamente igual — parámetros × bytes por parámetro, más margen. Cada mes llegan familias nuevas; la aritmética no se mueve.

Nota 1 · mezcla de expertos

Un modelo “30B con 3B activos” necesita la memoria de un modelo de 30B y se ejecuta más cerca de la velocidad de un modelo de 3B: cada experto debe estar residente, porque tokens diferentes despiertan a expertos diferentes. Dimensiona siempre a partir del recuento total de parámetros.

Familia	Tamaños	Fila
Llama 3.1 / 3.3 Meta	8B · 70B	7–8B, y 70B para la versión 3.3
Qwen3 Alibaba	8B · 14B · 32B	Las tres primeras filas
DeepSeek-R1 destilados	7B – 70B	Uno por fila — elige el destilado que tu tarjeta contenga
Mistral Small 3 Mistral AI	24B	Entre las filas 2 y 3; dimensiona a partir de la aritmética, no de la etiqueta
Gemma 3 Google	12B · 27B	Fila 2, y justo por debajo de la fila 3
Phi-4 Microsoft	14B	Fila 2
gpt-oss OpenAI	20B · 120B	Publicado en 4 bits de forma nativa: una tarjeta de 16 GB, y una tarjeta de 80 GB

Notas de instalación

El tiempo de ejecución es tuyo. Ese es el sentido del bare metal.

La máquina llega con un sistema operativo limpio y root. Sin servicio de inferencia del proveedor delante de tu modelo, sin tiempo de ejecución gestionado que se actualice solo la semana antes de una fecha límite. vLLM y Ollama responden ambos en un endpoint compatible con OpenAI — el código escrito contra un proveedor de API apunta a tu propia máquina cambiando una URL base. Fija el controlador, la versión de CUDA o ROCm y el framework a las versiones contra las que se probó tu código; nada se mueve debajo de ti. Si prefieres que el controlador esté instalado antes de la entrega, dilo en el pedido e indica la versión.

vLLM — servir tráfico real. El procesamiento por lotes continuo y la atención paginada permiten que una tarjeta responda muchas solicitudes a la vez: la diferencia entre una demo y un servicio. Quiere una tarjeta razonablemente moderna.
llama.cpp — memoria justa, o la tarjeta más antigua. Sus formatos cuantizados son la razón por la que un modelo grande cabe en una tarjeta pequeña; usará procesador y tarjeta juntos cuando los pesos no quepan del todo.
TGI · SGLang — servidores de producción de la misma familia, con diferentes fortalezas en salida estructurada, reutilización de prefijos y servicio multi-modelo. Se ejecutan aquí sin cambios.
Ollama — el camino más corto desde una máquina vacía hasta un modelo respondiendo en un puerto. Diez minutos te dicen si tu dimensionamiento fue correcto.

Condiciones del sitio

Lo que hace tu propia máquina que una API no puede.

Los prompts nunca salen del edificio

Pesos, prompts, documentos recuperados y cada token generado permanecen en hardware al que solo tú puedes iniciar sesión. Ámsterdam o Bucarest y los datos quedan en la UE; Nueva York, Miami o San Francisco y quedan en EE. UU. Para cargas de trabajo que responden ante un responsable de privacidad, esa frase es todo el caso de negocio.

El contador nunca corre

Una API por token factura cada token, y un agente o una canalización por lotes genera tokens todo el día. Una máquina dedicada es la misma cifra cada mes a cualquier volumen, con ancho de banda sin medición debajo — pesos que entran y tokens que salen no cuestan nada más allá del puerto. Qué cifra es, es la línea que /gpu debe rellenar, no esta hoja.

Nadie te limita la tasa, depreca ni cambia el modelo debajo de ti

El modelo que fijas responde sin cambios en seis meses. Sin techo de solicitudes por minuto, sin cola en la hora punta de otro, sin aviso de retirada. El trato es honesto: las actualizaciones son tuyas, en tu calendario.

El trabajo junto al modelo tiene un hogar

La recuperación quiere un modelo de embeddings, un almacén vectorial y disco rápido; los agentes quieren espacio para ejecutar herramientas. NVMe para el almacén, núcleos de procesador para la canalización, la tarjeta para los tokens — una máquina lo lleva todo.

Nota 2 · valoraciones

En esta hoja no aparece ninguna cifra de tokens por segundo.

Deliberadamente. Cada número así depende del modelo, la cuantización, el tiempo de ejecución y su versión, el tamaño del lote, la longitud del prompt, la longitud de la respuesta y la concurrencia — cambia cualquiera y se mueve por un múltiplo. Un número de titular que no lleva todo eso es un número elegido para quedar bien, y nos citarían con él. Lo que lo gobierna: leer el prompt está limitado por cómputo y ocurre una vez por solicitud; generar la respuesta está limitado por el ancho de banda de memoria, porque cada token requiere leer los pesos; el procesamiento por lotes amortiza esa lectura entre solicitudes concurrentes, hasta que la caché clave-valor se queda sin espacio. Margen otra vez.

Pide una respuesta real en su lugar

Dinos el modelo, la cuantización que pretendes, la longitud de contexto y aproximadamente cuántas solicitudes concurrentes. Si hemos ejecutado algo comparable diremos qué vimos y en qué. Si no, también lo diremos.

Cada hora de cada día — teléfono, chat y tickets. Soporte tiene los tiempos de respuesta por escrito.

Nota 3 · ajuste fino

El entrenamiento necesita considerablemente más espacio que el servicio.

Servir necesita los pesos. Entrenar necesita los pesos, los gradientes y el estado del optimizador para cada parámetro que actualiza, todo residente a la vez, más las activaciones guardadas para el paso hacia atrás — un modelo que sirve cómodamente en una tarjeta puede ser varias veces demasiado grande para ajustarlo por completo en ella. Los métodos eficientes en parámetros actualizan una pequeña fracción de los parámetros y necesitan una fracción correspondientemente pequeña de la memoria extra, razón por la cual la mayoría del ajuste fino aquí usa uno. El bucle de entrenamiento también transmite lotes continuamente a través del enlace procesador-tarjeta, así que la generación PCIe de la máquina subyacente es una restricción real allí de una manera que no lo es para servir — qué plataforma da a cada tarjeta qué enlace está en servidores dedicados GPU. Dinos el modelo, el método, la longitud de secuencia y el tamaño del conjunto de datos y lo dimensionaremos en lugar de que lo descubras después de la entrega; más de una tarjeta es la hoja de multi-GPU y multi-nodo.

Hojas adyacentes

Las páginas a ambos lados de esta.

Esta hoja posee una pregunta: qué se necesita para ejecutar un modelo. Todo lo adyacente tiene su propia página, y estas son todas.

Consultas planteadas

Preguntas de revisiones anteriores de esta ficha.

Tomadas de lo que la gente nos pregunta realmente en el chat y en los tickets, aproximadamente en el orden en que lo preguntan. Las tres primeras son las que deciden si una compra funciona.

¿Cuánta memoria de GPU necesita un modelo de lenguaje grande?: Los pesos son el número de parámetros multiplicado por los bytes por parámetro: dos bytes cada uno a 16 bits, uno a 8 bits, medio a 4 bits. Un modelo de 7–8 mil millones de parámetros son 16 GB de pesos a 16 bits, 8 GB a 8 bits y 5 GB a 4 bits; un modelo de 70 mil millones de parámetros son 140 GB, 70 GB y 38 GB. Esas cifras son solo los pesos y son un mínimo más que un requisito — reserve entre un cuarto y la mitad más para el tiempo de ejecución, las activaciones y la caché clave-valor.
¿Qué necesito para ejecutar un modelo de 70B como Llama 3.3?: A 4 bits los pesos son unos 38 GB, así que con margen para servir la respuesta es una tarjeta de 64 GB o más — una tarjeta, una máquina. A 8 bits los pesos son 70 GB y una tarjeta de 80 GB supera el listón. A precisión completa de 16 bits ninguna tarjeta individual de las que instalamos lo soporta, y se convierte en una configuración de varias tarjetas que cotizamos. La Fig. 3 de arriba nombra las tarjetas exactas; los precios están en servidores dedicados con GPU.
¿Por qué mi modelo carga pero no llega a servir?: Porque los pesos no son lo único en la memoria de la tarjeta. El tiempo de ejecución y sus búferes están residentes, y cada token de una conversación deja una entrada en la caché clave-valor para que no haya que recalcularlo. Esa caché crece con la longitud del contexto y de nuevo con cada solicitud servida simultáneamente, de modo que un modelo cuyos pesos apenas caben mantendrá aproximadamente una conversación corta. Dimensiona la tarjeta entre una vez y cuarto y una vez y media los pesos.
¿Qué tiempo de ejecución de inferencia puedo instalar?: Cualquiera. La máquina llega con un sistema operativo limpio y root, y no hay ningún servicio de inferencia del proveedor por delante. vLLM es la respuesta habitual para servir tráfico real porque el procesamiento por lotes continuo permite que una tarjeta responda a muchas solicitudes a la vez. llama.cpp es la respuesta habitual cuando la memoria es escasa o la tarjeta es más antigua. TGI y SGLang se ejecutan sin cambios. Ollama es el camino más corto desde una máquina vacía hasta un modelo que responde en un puerto — y tanto vLLM como Ollama responden en un endpoint compatible con OpenAI, de modo que el código de cliente existente apunta a tu propia máquina cambiando una única URL base. Tú fijas el controlador, la versión de CUDA o ROCm y el framework a las versiones contra las que se probó tu código.
¿Alojar un LLM uno mismo es más barato que una API por token?: Depende por completo del volumen, y el punto de cruce es real: una API factura por token y no cuesta nada en reposo; una máquina dedicada es una cifra mensual fija y no cuesta nada más cuando está ocupada. El tráfico constante, los agentes que funcionan todo el día, los pipelines por lotes y cualquier cosa con un requisito de privacidad suelen salir ganando con hardware propio; una carga de trabajo que se dispara diez veces al día no. Las cifras mensuales para hacer esa aritmética están en servidores dedicados con GPU — esta ficha deliberadamente no pone precio a nada.
¿Cuántos tokens por segundo obtendré?: No publicamos una cifra de tokens por segundo, porque cada número de ese tipo depende del modelo, la cuantización, el tiempo de ejecución y su versión, el tamaño del lote, la longitud del prompt, la longitud de la respuesta y la concurrencia, y cambiar cualquiera de ellos lo mueve por un múltiplo. Lo que lo gobierna: leer el prompt está limitado por cómputo y ocurre una vez por solicitud; generar la respuesta está limitado por el ancho de banda de memoria porque cada token requiere leer los pesos; y el procesamiento por lotes amortiza esa lectura entre solicitudes concurrentes, que es lo que hace que servir sea económico hasta que la caché clave-valor se queda sin espacio. Pregunta con el modelo, la cuantización y la concurrencia esperada para obtener una respuesta basada en lo que realmente hemos observado.
¿La GPU se comparte con alguien más?: No. Un inquilino por máquina física, y la tarjeta se pasa directamente a tu propio sistema operativo. No hay hipervisor, ni partición MIG, ni perfil vGPU, ni planificador de división de tiempo, de modo que nada más se ejecuta en la tarjeta y la latencia de inferencia no se mueve por el trabajo por lotes de otra persona.
¿Qué pasa si el modelo no cabe en una sola tarjeta?: Entonces es una configuración de varias tarjetas, que se cotiza en lugar de pedirse desde un carrito: cuántas tarjetas caben depende del ancho físico de la tarjeta específica y del presupuesto de energía del chasis. Dos tarjetas te dan la suma de su memoria solo si el tiempo de ejecución puede dividir el modelo entre ambas, algo que todo tiempo de ejecución serio admite con cierto coste en rendimiento. Más de una tarjeta o máquina cubre cómo es esa configuración.
¿El ajuste fino necesita más memoria que servir?: Bastante más. Servir necesita los pesos; entrenar necesita los pesos, los gradientes y el estado del optimizador de cada parámetro que se actualiza, todo residente a la vez, más las activaciones guardadas para el paso hacia atrás. Un modelo que sirve cómodamente en una tarjeta puede ser varias veces demasiado grande para ajustarlo por completo en ella. Los métodos eficientes en parámetros actualizan una fracción pequeña de los parámetros y necesitan una fracción correspondientemente pequeña de la memoria adicional, que es la razón por la que la mayoría del ajuste fino aquí usa uno.
¿Puedo usar una tarjeta AMD y funciona ROCm?: Sí. Las piezas AMD Instinct están entre las tarjetas de mayor memoria que instalamos y con frecuencia son el mejor valor por gigabyte, pero tu stack tiene que admitir ROCm en lugar de CUDA. La mayoría de los tiempos de ejecución de inferencia actuales lo hacen; algunas herramientas circundantes todavía no. Pregunta antes de pedir y lo comprobaremos contra tu tiempo de ejecución específico en lugar de responder en general.

For the record

Everything on this sheet, as figures.

Card memory is the manufacturers’ published figure; which cards exist is read from the order catalogue when this page was served. No monthly price appears here on purpose — GPU dedicated servers holds every one, against the exact machine it belongs to.

What decides whether a model runs: Card memory, and almost nothing else on the order form. The weights either fit or they do not — a card a couple of gigabytes short does not run slower, it fails to load. Clock speed and core count decide how fast it is once it fits.
How much memory a model needs: Parameters multiplied by bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. That is the WEIGHTS. The runtime, the activations and the key-value cache for the conversation live in the same memory, so budget a quarter to a half again on top before choosing a card.
Largest model on a single card here: 70 billion parameters at 4-bit, with room left to serve. Past that the answer is more than one card in one machine, which is a build we quote rather than a checkout option — multi-GPU and multi-node is the page for it.
Biggest card we fit: RTX PRO 6000 Blackwell 96GB, 96 GB GDDR7 ECC. Card memory figures are the manufacturers' published ones; a card whose figure we could not source is left out of the comparison rather than guessed at.
Which runtime: Yours. The machine arrives with a clean operating system and root, and you install vLLM, llama.cpp, TGI, SGLang, Ollama or anything else, pinned to the version your code was tested against. Nothing upgrades underneath you, and there is no vendor runtime you have to go through.
Throughput: We publish no tokens-per-second figure, deliberately, because we have not measured one under conditions we would be willing to have quoted back at us. What governs it is the card's memory bandwidth while generating, its arithmetic while reading the prompt, and how many requests you batch. Ask with the model, the quantisation and the expected concurrency and we will say what we have actually seen.
Fine-tuning and training: Both are ordinary work here, and both need considerably more memory than serving the same model: gradients and optimiser state sit alongside the weights. A parameter-efficient method needs a fraction of what a full fine-tune does. Tell us the method and the model and we will size it rather than have you find out after delivery.
Tenancy: One tenant per physical machine and the card passed straight through to your operating system. No hypervisor, no MIG partition, no vGPU profile, no time-slicing scheduler, and nobody else's workload on the card. What you measure on the first afternoon is what you keep.
Bandwidth: Unmetered in both directions at every port speed, with no transfer allowance and no egress line on any invoice. Pulling weights down and serving tokens back out costs nothing beyond the port.
What this page does not price: Cards, or anything else. Every card we fit, what each adds per month and what the machine under it costs are on GPU dedicated servers, each figure against the exact machine it belongs to.