Skip to content

You are viewing the latest developer preview docs. Click here to view docs for the latest stable release.

vLLM

common

Initializing search

Home
User Guide
Developer Guide
Benchmarking
API Reference
CLI Reference
Community

vLLM

Home
User Guide
User Guide
- Getting Started
  Getting Started
  - Quickstart
  - Installation
    
    Installation
    
    GPU
    
    CPU
    
    TPU
  - Examples
    
    Examples
    
    Applications
    Applications
    
    API Server
    
    Chatbot
    
    Rag
    
    Basic
    Basic
    
    Offline Inference
    
    Online Serving
    
    Deployment
    Deployment
    
    Async LLM Streaming
    
    Helm Charts
    
    LLM Engine Example
    
    Sagemaker-Entrypoint
    
    Disaggregated
    Disaggregated
    
    Disaggregated Encoder
    
    Disaggregated Serving
    
    Ec Both Encoder
    
    Disaggregated Prefill V1
    
    Flexkv Connector
    
    KV Load Failure Recovery Test
    
    LMCache Examples
    
    Mooncake Connector
    
    Mooncake Store
    
    Features
    Features
    
    Automatic Prefix Caching
    
    Context Extension
    
    Data Parallel
    
    Kv Events
    
    Logging Configuration
    
    Custom Logits Processors
    
    LoRA
    
    Offline Inference with the OpenAI Batch file format
    
    Profiling
    
    Prompt Embed
    
    Reset Kv
    
    Sharded State
    
    Speculative Decoding
    
    Structured reads on DiffusionGemma
    
    Structured Outputs
    
    Tensorize vLLM Model
    
    Torchrun
    
    Generate
    Generate
    
    Batched Chat Completions Online
    
    Multimodal
    
    Qwen 1M Offline
    
    Trace Replay Offline
    
    Observability
    Observability
    
    Monitoring Dashboards
    
    Metrics
    
    Setup OpenTelemetry POC
    
    Prometheus and Grafana
    
    Pooling
    Pooling
    
    Classify
    
    Embed
    
    Plugin
    
    Reward
    
    Score
    
    Token Classify
    
    Token Embed
    
    Ray Serving
    Ray Serving
    
    Batch LLM Inference
    
    Elastic Ep
    
    Multi-Node-Serving
    
    Ray Serve Deepseek
    
    Run Cluster
    
    Reasoning
    Reasoning
    
    OpenAI Chat Completion Tool Calls With Reasoning
    
    OpenAI Chat Completion With Reasoning
    
    OpenAI Chat Completion With Reasoning Streaming
    
    OpenAI Responses Client
    
    RL
    RL
    
    Batch Invariance
    
    Pause Resume
    
    Rdt vLLM Serve
    
    Rdt Weight Source
    
    RLHF Async New APIs
    
    RLHF Http IPC
    
    RLHF Http IPC No vLLM
    
    RLHF Http NCCL
    
    RLHF Http NCCL No vLLM
    
    RLHF IPC Fsdp Ep
    
    RLHF M2N
    
    RLHF NCCL Fsdp Ep
    
    RLHF NCCL Multi Source
    
    RLHF Sharded Rdt Small Ep
    
    RLHF Sparse NCCL
    
    Routed Experts E2E
    
    Skip Loading Weights In Engine Init
    
    Scale Out
    Scale Out
    
    Init
    
    Example Mm Serve
    
    Token Generation Client
    
    Speech To Text
    Speech To Text
    
    OpenAI
    
    Realtime
    
    Tool Calling
    Tool Calling
    
    Chat With Tools Offline
    
    OpenAI Chat Completion Client With Tools
    
    OpenAI Chat Completion Client With Tools Required
    
    OpenAI Chat Completion Client With Tools Xlam
    
    OpenAI Chat Completion Client With Tools Xlam Streaming
    
    OpenAI Responses Client With Mcp Tools
    
    OpenAI Responses Client With Tools
- General
  General
- Inference and Serving
  Inference and Serving
  - Offline Inference
  - Online Serving
    
    Online Serving
    
    Derenderer APIs
    
    Generative Scoring
    
    OpenAI-Compatible Server
    
    Renderer APIs
    
    Speech to Text APIs
    
    Tokens In <> Tokens Out API
    
    Trace Replay
  - Context Parallel Deployment
  - Data Parallel Deployment
  - Troubleshooting distributed deployments
  - Expert Parallel Deployment
  - Parallelism and Scaling
  - Integrations
    Integrations
    
    Claude Code
    
    Codex
    
    LangChain
    
    LlamaIndex
- Deployment
  Deployment
  - Using Docker
  - Using Kubernetes
  - Using Nginx
  - Frameworks
    Frameworks
    
    Anyscale
    
    AnythingLLM
    
    AutoGen
    
    BentoML
    
    Cerebrium
    
    Chatbox
    
    Crusoe
    
    Dify
    
    dstack
    
    Haystack
    
    Helm
    
    Hugging Face Inference Endpoints
    
    LiteLLM
    
    Lobe Chat
    
    LWS
    
    Modal
    
    Nebius Serverless AI
    
    Open WebUI
    
    Retrieval-Augmented Generation
    
    RunPod
    
    SkyPilot
    
    Streamlit
    
    NVIDIA Triton
  - Integrations
    Integrations
    
    AIBrix
    
    NVIDIA Dynamo
    
    k8s-aibom
    
    KAITO
    
    KServe
    
    Kthena
    
    KubeAI
    
    KubeRay
    
    Llama Stack
    
    llm-d
    
    llmaz
    
    Production stack
- Training
  Training
- Configuration
  Configuration
- Models
  Models
  - Supported Models
  - Generative Models
  - Pooling Models
    
    Pooling Models
    
    Classification Usages
    
    Embedding Usages
    
    Reward Usages
    
    Scoring Usages
    
    Specific Model Examples
    
    Token Classification Usages
    
    Token Embedding Usages
  - Structured Decisions Models
  - Extensions
    Extensions
    
    Loading model weights with fastsafetensors
    
    Loading Model Weights with InstantTensor
    
    Loading models with Run:ai Model Streamer
    
    Loading models with CoreWeave's Tensorizer
  - Hardware Supported Models
    Hardware Supported Models
    
    CPU - Intel® Xeon®
    
    XPU - Intel® GPUs
    
    TPU
- Features
  Features
Developer Guide
Developer Guide
Benchmarking
Benchmarking
API Reference
API Reference
- vllm
  vllm
  - collect_env
  - connections
  - env_override
  - envs
  - exceptions
  - forward_context
  - logger
  - logits_process
  - logprobs
  - model_inspection
  - outputs
  - pooling_params
  - sampling_params
  - scalar_type
  - sequence
  - tasks
  - version
  - assets
  - benchmarks
  - compilation
  - config
  - cute_utils
  - device_allocator
  - distributed
  - engine
  - entrypoints
  - inputs
  - ir
  - kernels
  - logging_utils
  - lora
  - model_executor
    
    model_executor
    
    custom_op
    
    parameter
    
    utils
    
    determinism
    
    hw_agnostic
    
    kernels
    
    layers
    
    model_loader
    
    model_loader
    
    base_loader
    
    checkpoint_weight_patch
    
    default_loader
    
    dummy_loader
    
    ep_weight_filter
    
    modelexpress_loader
    
    runai_streamer_loader
    
    sharded_state_loader
    
    tensorizer
    
    tensorizer_loader
    
    utils
    
    weight_checksum
    
    weight_tying
    
    weight_utils
    
    reload
    
    weight_cache
    
    weight_cache
    
    artifact_store
    
    daemon
    
    ipc_loader
    
    protocol
    
    seed
    
    utils
    
    warmup_cache
    
    warmup_cache
    
    base
    
    common
    
    compiled
    
    flashinfer_autotune
    
    models
    
    offloader
    
    warmup
  - models
  - multimodal
  - parser
  - platforms
  - plugins
  - profiler
  - ray
  - reasoning
  - renderers
  - snapshot
  - tilelang_utils
  - tokenizers
  - tool_parsers
  - tracing
  - transformers_utils
  - triton_utils
  - usage
  - utils
  - v1
CLI Reference
CLI Reference
- vllm
  vllm
  - chat
  - complete
  - download-kernels
  - preload
  - run-batch
  - serve
  - bench
    
    bench
    
    forward
    
    latency
    
    mm-processor
    
    serve
    
    startup
    
    throughput
    
    sweep
    
    sweep
    
    plot
    
    plot_pareto
    
    serve
    
    serve_workload
    
    startup
  - launch
    
    launch
    
    render
Community
Community
- Contact Us
- Meetups
- Reviewers
- Sponsors
- Governance
  Governance
- Blog
- Forum
- Slack

Home
API Reference
vllm
model_executor
model_loader
weight_cache
warmup_cache

`vllm.model_executor.model_loader.weight_cache.warmup_cache.common` ¶

Shared compiled-cache manifest and installation helpers.

November 10, 2026

Made with Material for MkDocs