# vLLM

This section shows how to add AI 100 backend support for the
[vLLM](https://github.com/vllm-project/vllm) open-source library for LLM inference and serving. It describes the initial setup, performance optimizations, and advanced inference features.

## Installation

### Pre-Built Docker image with vLLM support

Pre-built Docker images for Cloud AI with vLLM support are available in the
[cloud-ai-containers](https://github.com/quic/cloud-ai-containers/pkgs/container/cloud_ai_inference_ubuntu22) GitHub repository.

### Build a  Docker image with vLLM support

Complete the required [prerequisites](https://docs.qualcomm.com/doc/80-99100-3/topic/index_Docker_Docker.html#reference-to-docker-system-pre-requisistes) then follow these steps to build your own Docker image for Cloud AI with vLLM support.
prior to building the docker image that includes the vLLM installation.

Build the Docker image which includes the vLLM installation using the
`build_image.py` script.

cd </path/to/apps-sdk>/common/tools/docker-build/
    
    python3 build_image.py --user_specification_file ./sample_user_specs/user_image_spec_vllm.json --apps_sdk path_to_apps_sdk_zip_file --platform_sdk path_to_platform_sdk_zip_file --tag 1.20.2.0
    Copy to clipboard

This should create a docker image with vLLM installed.

ubuntu@host:~# docker image ls
    REPOSITORY                                                                      TAG                           IMAGE ID       CREATED         SIZE
    qaic-x86_64-ubuntu22-py310-py38-release-qaic_platform-qaic_apps-pybase-pytools-vllm   1.20.2.0                      3e4811ba18ae   3 hours ago     7.05GB
    Copy to clipboard

### Docker run steps

Once the Docker image is downloaded or built, refer to instructions
[here](https://docs.qualcomm.com/doc/80-99100-3/topic/index_Docker_Docker.html#reference-to-docker) to launch the container and map
Cloud AI devices to the container.

After the container is launched, activate the virtual environment and
run a sample inference using the example script provided.

source /opt/vllm-env/bin/activate
    
    cd /opt/qti-aic/integrations/vllm/
    python examples/offline_inference_qaic.py
    Copy to clipboard

### Installing from source

Tab x86\_64
Tab AArch64

Install a vLLM with QAic backend support by applying a patch on
top of the open-source vLLM repository.

# Add user to qaic group to access Cloud AI devices without root
    sudo usermod -aG qaic $USER
    newgrp qaic
    
    # Create a python virtual environment
    python3.10 -m venv qaic-vllm-venv
    
    source qaic-vllm-venv/bin/activate
    
    # Install the current release version of `Qualcomm Efficient-Transformers <https://github.com/quic/efficient-transformers>`_ (vLLM with qaic support requires efficient-transformers for model exporting and compilation)
    pip install -U pip
    
    pip install git+https://github.com/quic/efficient-transformers@release/v1.20.0
    
    # Clone the vLLM repo, and apply the patch for qaic backend support
    git clone https://github.com/vllm-project/vllm.git
    
    cd vllm
    
    git checkout v0.8.5
    
    git apply /opt/qti-aic/integrations/vllm/qaic_vllm.patch
    
    # Set environment variables and install
    export VLLM_TARGET_DEVICE="qaic"
    
    pip install -e .
    
    # Run a sample inference
    python examples/offline_inference/qaic.py
    Copy to clipboard

# Add user to qaic group to access Cloud AI devices without root
    sudo usermod -aG qaic $USER
    newgrp qaic
    
    # Create a python virtual environment
    python3.10 -m venv qaic-vllm-venv
    
    source qaic-vllm-venv/bin/activate
    
    # Install the current release version of `Qualcomm Efficient-Transformers <https://github.com/quic/efficient-transformers>`_ (vLLM with qaic support requires efficient-transformers for model exporting and compilation)
    pip install -U pip
    
    pip install git+https://github.com/quic/efficient-transformers@release/v1.20.0
    
    # Build Triton 3.0.0 dependency for AArch64
    mkdir triton-3.0.0
    cd triton-3.0.0
    git clone https://github.com/triton-lang/triton.git -b release/3.0.x --depth=1
    cd ..
    
    # LLVM git cloning
    
    mkdir llvm-main && cd llvm-main
    export LLVM_HASH="$(cat /path_to/triton-3.0.0/triton/cmake/llvm-hash.txt)"
    
    git clone --recursive https://github.com/llvm/llvm-project.git -b main
    cd llvm-project && git checkout ${LLVM_HASH}
    
    # LLVM building:
    pip install ninja cmake
    mkdir llvm-project/build; cd llvm-project/build;
    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON ../llvm -DLLVM_ENABLE_PROJECTS="mlir;llvm" -DLLVM_TARGETS_TO_BUILD="host;NVPTX;AMDGPU"; ninja;

    # Triton building:
    cd /path_to/triton-3.0.0/triton/python
    export LLVM_BUILD_DIR=/path_to/llvm-main/llvm-project/build
    export LLVM_INCLUDE_DIRS=$LLVM_BUILD_DIR/include
    export LLVM_LIBRARY_DIR=$LLVM_BUILD_DIR/lib
    export LLVM_SYSPATH=$LLVM_BUILD_DIR
    pip wheel .
    
    pip install triton-3.0.0-cp310-cp310-linux_aarch64.whl
    
    cd /back/to/root/path
    
    # Clone the vLLM repo, and apply the patch for qaic backend support
    git clone https://github.com/vllm-project/vllm.git
    
    cd vllm
    
    git checkout v0.8.5
    
    git apply /opt/qti-aic/integrations/vllm/qaic_vllm.patch
    
    # Set environment variables and install
    export VLLM_TARGET_DEVICE="qaic"
    
    pip install -e .
    
    # Run a sample inference
    python examples/offline_inference/qaic.py
    Copy to clipboard

## Run example scripts

### Run a sample inference

python examples/offline_inference/qaic.py
    Copy to clipboard

### For FP8 models

It’s recommended to use dtype mxfp6 and kvcache mxint8 for FP8 models.

### Prefix caching support

Prefix caching reduces time-to-first-token (TTFT) and compute cost for requests that share a common leading sequence of tokens. When multiple requests begin with the same prefix — such as a system prompt, a few-shot example set, or a long document — the KV cache computed for that prefix is stored and reused rather than recomputed for each new request.

Because QAic vLLM doesn’t support `PagedAttention`, QAic prefix caching can’t share the same block between two sequences running simultaneously in the same decode batch. You can’t enable QAic prefix caching along with any of the following features: multimodality, LoRAX, embedding, disaggregated serving, and on-device sampling.

The parameters relevant for prefix caching are shown in the following table:

| Input Arg | Setting required for QAic runs |
| --- | --- |
| enable-prefix-caching | Set this flag to True to enable<br>prefix caching for qaic |
| num-gpu-blocks-override | Use this flag to maintain<br>the KV cache of more<br>users than the decode batch<br>size (max-num-seqs) |
| use\_v2\_block\_manager | Set to True for prefix caching. |

#### Run the prefix caching script

python examples/offline_inference/qaic_prefix_caching.py
    Copy to clipboard

### Speculative decoding (SpD) support with vLLM

Speculative decoding reduces token generation latency by using a fast draft model to propose several candidate tokens ahead of the target model, which then verifies them in a single forward pass. Accepted tokens are emitted immediately; rejected tokens fall back to the target model’s output. Because verification is cheaper than independent generation, throughput and latency improve significantly for workloads where the draft model has high acceptance rates.

Two methods are supported on Qualcomm Cloud AI accelerators:

- Draft model (SpD)
- Prompt lookup decoding (PLD)

SpD via Medusa, EAGLE, and MLPSpeculator are not supported.

The parameters relevant for SpD are shown in the following table:

| Input Arg | Setting required for QAic runs |
| --- | --- |
| speculative-config | Initialize non default qaic<br>config or override default qaic<br>config that are specific to QAic<br>devices, for speculative draft<br>model, this argument will be used<br>to configure the qaic config that<br>can not be fully gathered from<br>the vLLM arguments. |
| override-qaic-config | Initialize non default qaic<br>config or override default qaic<br>config that are specific to QAic<br>devices. In case of SpD, this is<br>applied to target model. |

As part of the `speculative-config`, you can provide the following:

| Input Arg | Setting required for QAic runs |
| --- | --- |
| model | Provide the draft model to<br>use. |
| num-speculative-tokens | The number of speculative tokens<br>to sample from the draft model in<br>speculative decoding. |
| acceptance-method | Specify the acceptance method to<br>use during draft token<br>verification in speculative<br>decoding. Two types of acceptance<br>routines are supported: 1)<br>‘rejection\_sampler’ which does<br>not allow changing the acceptance<br>rate of draft tokens, 2)<br>‘typical\_acceptance\_sampler’<br>which is configurable, allowing<br>for a higher acceptance rate at<br>the cost of lower quality, and<br>vice versa. |
| draft\_override\_qaic\_config | Initialize non default qaic<br>config or override default qaic<br>config that are specific to qaic<br>devices. This is<br>applied to the draft model. |
| quantization | Draft model quantization. |
| method | The name of the speculative method<br>to use. If users provide and set<br>the <cite>model</cite> param, the speculative<br>method type will be detected<br>automatically if possible, if<br><cite>model</cite> param is not provided, the<br>method name must be provided. |
| prompt\_lookup\_max | Maximum size of ngram token window<br>when using Ngram proposer,<br>required when method is set to<br>ngram |
| prompt\_lookup\_min | Minimum size of ngram token window<br>when using Ngram proposer,<br>if provided. Defaults to 1. |

#### Default QAic SpD run settings

Always compiles for one AI 100 Ultra card by default assuming both draft and
target models are running on the same card: with eight cores each. To use
different hardware configurations, use `override-qaic-config` or
`speculative-overrride-config`.

#### Example code for SpD

python examples/offline_inference/qaic_spd_pld.py
    Copy to clipboard

### Speculative decoding (SpD) with prefix caching support

SpD is supported with prefix caching for draft and PLD methods. No additional flags are required beyond enabling both features together. Use the standard speculative decoding parameters plus `enable-prefix-caching`.

### On-device sampling support

On-device sampling enables you to execute sampling operations directly
on the QAic device rather than the host CPU. This workflow reduces
host-device communication overhead and improves inference throughput
and scalability.

#### Supported sampling strategies

The following sampling techniques are supported directly on the
QAic device:

#### Implementation details

- sampler integration: Sampling logic is enabled by setting `"aic_include_sampler": True` in `override_qaic_config` while instantiating a LLM object.
- Text generation: For each input prompt, repetition penalty, presence penalty, temperature scaling, top K, top P, and min P sampling strategies are enabled or disabled by providing their respective values in a `SamplingParams` object as shown in the following example. This is optional; if one or more values are not provided, default values are used.

sampling_params = SamplingParams(
           repetition_penalty=1.5,
           presence_penalty=0.5,
           temperature=0.01,
           top_k=512,
           top_p=0.9,
           min_p=0.95,
           n=1,
           ignore_eos=False,
           seed=0,
        )
        
        llm = LLM(
           ...
           override_qaic_config={  # On Device Sampling
              "aic_include_sampler": True,
              "aic_return_pdfs": False,
              "max_top_k_ids": 1024,
           },
        )
        
        outputs = llm.generate(prompts, sampling_params)
        Copy to clipboard
- *Note*:

    - Frequency penalties are not supported by the QAic backend. The Sampler runs without frequency penalties. To use frequency penalties, please use the PyTorch backend.
    - By default, the QPC is compiled for `"max_top_k_ids": 512`. To use a different value, please provide `max_top_k_ids` in `override_qaic_config`. This will recompile the QPC with the updated value.

#### Limitations

- On-device sampling cannot be enabled along with any of the following features: prefix caching, SpD, multimodality, or LoRAX.
- On-device sampling works only with causal language models.

#### Example code for on-device sampling

python3 examples/offline_inference/qaic_on_device_sampling.py
    Copy to clipboard

### Multimodality Support with vLLM

#### Limitations

- Only available for single batch, single image.
- Multimodality doesn’t support prefix caching, SpD, continuous batching, prefill chunking, or LoRA.
- Open-AI multi-modal APIs are only supported for single QPC approach.

The following table shows the models supported with QAic.

| Model Family | Supported models | Type | Modality |
| --- | --- | --- | --- |
| InternVLChatModel | OpenGVLab/InternVL2\_5-1B | Vision-language<br>model | image+text,<br>image, text |
| LLaVA-1.5 | llava-hf/llava-1.5-7b-hf | Vision-language<br>model | image+text,<br>image, text |
| Llama 3.2 | meta-llama/Llama-3.2-11B-Vision,<br>meta-llama/Llama-3.2-11B-Vision-Instruct | Vision-language<br>model | image+text,<br>image, text |
| Llama 4 | meta-llama/Llama-4-Scout-17B-16E-Instruct | Vision-language<br>model | image+text,<br>image, text |
| Whisper | openai/whisper-tiny.en,<br>openai/whisper-large | Audio model | audio |

#### vLLM flags and environment variables

| Input Arg | Default Value | Setting Required for<br>QAic runs |
| --- | --- | --- |
| VLLM\_QAIC\_QPC\_PATH | None | Set this flag with<br>the path to QPC. vLLM<br>loads the QPC<br>directly from the<br>path provided and<br>doesn’t compile the<br>model. For the dual<br>QPC approach for<br>multimodality,<br>provide both QPC<br>paths separated by a<br>colon:<br>`<br><cite>path/to/vision_qpc:p<br>ath/to/language_qpc`</cite> |

#### Dual QPC approach

For vision-language models, vLLM supports two approaches:

- Dual QPCs approach: kv\_offload=True
- Single QPC approach: kv\_offload=False

The dual QPCs approach is the recommended method. It splits the model to
perform image encoding and output generation in two different QPCs.

In vLLM, to support dual QPC, one LLM is initialized for the embedding
task and runs encoding to produce image representations. A second LLM is
initialized for the generation task and runs generation to produce
completions for the input prompts. The first LLM’s outputs are passed to
the second LLM via the host. To enable the dual QPC
approach, each of the two LLMs must be provided with
`override_qaic_config={"kv_offload": True}` during initialization.
In the case of text-only prompts, only the second LLM is used.

Additionally:

- For InternVL models, you can set the `num_patches` using the `override_qaic_config` parameter.
- For LLaMA 4, you can set `max_patches` using `mm_processor_kwargs`.

The following diagram compares the dual QPCs approach with the single QPC approach:

![../../../../../../_images/564f2e1f-e565-4843-8ea3-9f284785b730.png](data:image/png;base64,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)

##### Example code and run command

# OpenGVLab/InternVL2_5-1B
    python examples/offline_inference/qaic_vision_language_kv_offload.py --image-url https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg --question "What's in the image?" -m internvl_chat --num-prompt 1
    
    #  meta-llama/Llama-4-Scout-17B-16E-Instruct
    python examples/offline_inference/qaic_vision_language_kv_offload.py --image-url https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg --question "What's in the image?" -m llama4 --num-prompt 1 --device-group-embed 0,1,2,3,4,5,6,7 --device-group-gen 8,9,10,11,12,13,14,15
    
    #  meta-llama/Llama-4-Scout-17B-16E-Instruct, text-only
    python examples/offline_inference/qaic_vision_language_kv_offload.py --modality text --question "Tell me about yourself" -m llama4 --num-prompt 1 --device-group-gen 8,9,10,11,12,13,14,15
    Copy to clipboard

#### Single QPC approach

In single QPC approach, a single QPC performs both image encoding
and output generation, so only one LLM needs is initialized. The
Whisper model is supported only through the single QPC approach.

##### Example code and run command

python examples/offline_inference/qaic_vision_language.py --image-url https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg --question "What's in the image?" -m internvl_chat --num-prompt 1
    
    python examples/offline_inference/qaic_whisper.py --filepath PATH_TO_AUDIO_FILE
    Copy to clipboard

#### Disable multimodal

You can configure `meta-llama/Llama-4-Scout-17B-16E-Instruct` as a
text-only model by disabling multimodal processing. Once multimodal
processing is disabled, the model supports continuous batching with
a batch size greater than 1. This can be done by setting:
`override_qaic_config = { "disable_multimodal": True }`

### LoRAX support with vLLM

Low-rank adaptation (LoRA)  is a parameter-efficient fine-tuning technique that adds small trainable weight matrices to a frozen base model, enabling task-specific or user-specific customization without retraining or redeploying the full model.

LoRAX extends this to a serving context: multiple LoRA adapters are compiled together with a single base model QPC (combined model) and served concurrently. Each inference request can specify a different adapter, allowing one deployed model instance to serve many fine-tuned variants simultaneously.

The compiled adapters should have their weights applied to the same set of target projection layers and modules. The supported modules are limited to `q_proj`, `k_proj`, `v_proj`, `o_proj`}. Modules such as {`up_proj`, `down_proj`, `gate_proj`} aren’t supported.

The parameters relevant for LoRAX are shown in the following table:

| Input arg | Setting required for QAic runs |
| --- | --- |
| enable\_lora | Enable the LoRAX feature by<br>setting this to True |
| max\_loras | The maximum number of Lora<br>adapters that can run within a<br>batch. It should always be set to<br>match the number of adapters<br>compiled with the base model. |
| lora\_modules | A list of LoRAModulePath objects,<br>each containing a name (Lora<br>adapter name) and a path<br>(snapshot download path for the<br>adapter repository), should be<br>provided. The list must include<br>all adapters intended to be<br>compiled with the base model. |

The following example shows how to create a LoRA request and pass it to the `generate` API call.

lora_requests = [
        LoRARequest(
            lora_name=repo_id[i].split("/")[1], lora_int_id=(i + 1), lora_path=snapshot_download(repo_id=repo_id[i])
        )
        for i in range(len(prompts))
    ]
    outputs = llm.generate(prompts, sampling_params, lora_request=lora_requests)
    Copy to clipboard

The maximum adapters to be compiled is by default 128, if you want to
increase, use  `export VLLM_QAIC_LORA_MAX_ID_SUPPORTED=XXX` to set the size.

#### Example code for LoRAX

python vllm/tests/test_qaic/lora/example_offline_inference_qaic_lora.py
    Copy to clipboard

### Embed networks support

An embedding network is a type of neural network designed to transform high-dimensional input data—like words, images, or items—into dense, low-dimensional vectors called embeddings. These vectors capture the semantic or structural relationships between inputs, making them useful for tasks like recommendation systems, natural language processing, and similarity search. The goal is to place similar inputs closer together in the embedding space, enabling efficient comparison and clustering.

QAic supports the following models:

- jinaai/jina-embeddings-v2-base-code
- jinaai/jina-embeddings-v2-base-en
- intfloat/multilingual-e5-large
- intfloat/e5-large

The sentence-transformers/gtr-t5-large model isn’t supported.

#### Flags and environment variables

| Input Arg | Setting required for QAic runs |
| --- | --- |
| task | Select the task as<br>“embed” or “reward” or “classify”<br>or “score” |
| override-qaic-config | Initialize non default qaic config<br>or override default qaic config<br>that are specific to QAic devices,<br>for speculative draft model, this<br>argument will be used to configure<br>configure the qaic config that can<br>be fully gathered from the vLLM<br>arguments |
| override-pooler-config | Pass a PoolerConfig object with<br>pooling\_type, normalize<br>and softmax as required |

For embedding models, you can pass the following in `override-qaic-config`:

| Input Arg | Setting required for QAic runs |
| --- | --- |
| pooling\_device | Select QAic to run pooler as part<br>of QPC. Select cpu to run pooler<br>on CPU. |
| pooling\_method | Select the pooling method to use.<br>User can also define a custom<br>pooler. This is used for QAic<br>pooling device. |
| normalize | Set to True for applying<br>normalization on output. This is<br>used for QAic pooling device. |
| softmax | Set to True for applying<br>softmax on output. This is<br>used for QAic pooling device. |
| embed\_seq\_len | Send a list of sequence lengths<br>as “seqlen1, seqlen2” or<br>[seqlen1, seqlen2] to compile for<br>multiple sequence lengths. |

#### Example code for embedding

python examples/offline_inference/basic/qaic_embed.py
    Copy to clipboard

#### Notes

- For embedding models, max\_seq\_len\_to\_capture should be the same as context length. If user needs to compile for multiple sequence lengths the models’ context length must be one of the sequence lengths passed in the list. Set max\_model\_len to the required sequence length if the user doesn’t want to compile for actual model context length.
- Apart from selecting the task, the user also needs to call the correct API such as embed, encode, classify and score.
- jina models require setting trust\_remote\_code=True when instantiating the LLM for ensuring accuracy.
- jinaai/jina-embeddings-v2-base-en also requires running the following python script to ensure accuracy.

from QEfficient import QEFFAutoModel
    import os
    import subprocess
    import requests
    
    qeff_model = QEFFAutoModel.from_pretrained("jinaai/jina-embeddings-v2-base-en", trust_remote_code=True)
    os.chdir(os.path.join(os.environ.get("HF_HOME"), "modules/transformers_modules/jinaai/jina-bert-implementation/f3ec4cf7de7e561007f27c9efc7148b0bd713f81/"))
    
    diff_url = "https://huggingface.co/jinaai/jina-bert-implementation/discussions/7/files.diff"
    response = requests.get(diff_url)
    
    with open("pr7.diff", "wb") as f:
        f.write(response.content)
    
    subprocess.run(["patch", "-p1", "-i", "pr7.diff"], check=True)
    Copy to clipboard

### Disaggregated serving support

In standard LLM serving, both the prefill stage and decode stages are colocated on the same hardware.

- `Prefill Stage`: Handles the initial processing of the input prompt and generates key-value (KV) cache tensors.
- `Decode Stage`: Uses the KV cache to generate output tokens, often in a streaming or batched fashion.

Disaggregated the serving support decouples these stages. This separation allows each stage to be optimized independently for latency and throughput. For example, you can optimize prefill for time to first token (TTFT), while you can tune decode for tokens per output time (TPOT).

#### qaic\_disagg installation & environment setup:

Installing using Docker

- Build docker container with vLLM as mentioned in the beginning section above, under vLLM Installation.
- Install qaic-disagg package.

cd qaic_disagg
        pip3 install .
        Copy to clipboard

#### Offline inference example

sudo python3 vllm/qaic_disagg/examples/offline_inference/1P1D.py \
    --port <5656> \
    --prefill_mdp </path/to/prefill_mdp> \
    --decode_qpc </path/to/decode_qpc>
    Copy to clipboard

Notes:

- `--port` is optional (default: 5656) but can be specified if needed.
- One of the following for prefill must be provided:

    - `--prefill_qpc` or `--prefill_mdp`
- `--decode_qpc` must be provided

#### Generate prefill MDP

Under vLLM installation folder,

cd vllm/qaic_disagg/scripts
    
    python MDP_Generator_Partitioner.py <onnx_model_path> <custom_io_yaml> <specialization_json> <num_devices> <num_partitions> <layers_per_partition> <output_json> <qpc_dir>
    Copy to clipboard

Here,

`<onnx_model_path>`: Path to the ONNX model file.

`<custom_io_yaml>`: Path to the custom IO YAML file.

`<specialization_json>`: Path to the specialization JSON file.

`<num_devices>`: Total number of devices for full pipeline.

`<num_partitions>`: Number of partitions to create.

`<layers_per_partition>`: Number of layers to include in each partition.

`<output_json>`: Path where the partitioned output JSON will be saved.

`<qpc_dir>`: Directory for compiler output binaries.

#### Compile decode QPC

/opt/qti-aic/exec/qaic-exec -m=<onnx_model_path> -mdp-load-partition-config=<mdp_file_path_generated_in_above_setp> -aic-hw -aic-hw-version=2.0 -network-specialization-config=< network-specialization-config> -retained-state -convert-to-fp16 -custom-IO-list-file=<path_to_custom_io.yaml> -compile-only -mxfp6-matmul -allow-mxint8-mdp-io -aic-enable-depth-first -time-passes -aic-perf-warnings -aic-perf-metrics -aic-binary-dir=<path_to _store_ aic-binary>
    Copy to clipboard

#### Online serving

1P1D (1 prefill + 1 decode ) BS==1 example

![../../../../../../_images/disaggregated_serving.png](data:image/png;base64,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)

#### Command to invoke open-ai server

sudo python3 -m qaic_disagg \
        --prefill-port 9900 \
        --decode-port 9800 \
        --port 8000 \
        --decode-device-group 56..63 \ # or 56,57,58,59,60,61,62,63 or 56:64
        --prefill-device-group 0..15\
        --model "meta-llama/Llama-3.3-70B-Instruct" \
        --prefill-max-num-seqs 1 \
        --decode-max-num-seqs 1 \
        --max-seq-len-to-capture 256 \
        --max-model-len 11264 \
        --prefill-override-qaic-config "qpc_path=<prefill qpc path>" \ # or mdp file path for compilation, example "mdp_ts_json_path=<mdp file path>"
        --decode-override-qaic-config "qpc_path=<Decode qpc path>" # if qpc path is not provided, vLLM will compile decode only qpc
    Copy to clipboard

#### Client command

Use benchmark serving with port number 8000 and –max\_concurrency 1

#### Limitations

- No support for KV head replication, following configuration not applicable

    - Any TS16 decode config with KV head replications
- No support for Triton with Disaggregated Serving in REL1.20.x

    - Will provide solution with Triton in future release.

## Server endpoints

vLLM provides capabilities to start a FastAPI server to run LLM
inference. Here is an example to use QAic backend (i.e. use the AI 100
cards for inference).

# Need to increase max open files to serve multiple requests
    ulimit -n 1048576
    
    # Need to configure thread parallelism to avoid unnecessary CPU contention
    export OMP_NUM_THREADS=8
    
    # Start the server
    python3 -m vllm.entrypoints.api_server --host 127.0.0.1 --port 8000 --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --max-model-len 256 --max-num-seq 16 --max-seq_len-to-capture 128 --device qaic --block-size 32 --quantization mxfp6 --kv-cache-dtype mxint8
    
    # Client request
    python3 examples/api_client.py --host 127.0.0.1 --port 8000 --prompt "My name is" --stream
    Copy to clipboard

Similarly, an OpenAI compatible server can be invoked as follows

# Need to increase max open files to serve multiple requests
    ulimit -n 1048576
    
    # Need to configure thread parallelism to avoid unnecessary CPU contention
    export OMP_NUM_THREADS=8
    
    # Start the server
    python3 -m vllm.entrypoints.openai.api_server --host 127.0.0.1 --port 8000 --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --max-model-len 256 --max-num-seq 16 --max-seq_len-to-capture 128 --device qaic --block-size 32 --quantization mxfp6 --kv-cache-dtype mxint8
    
    # Client request
    python3 examples/openai_chat_completion_client.py
    Copy to clipboard

## Benchmarking

vLLM provides benchmarking scripts to measure serving, latency and
throughput performance. Here’s an example for serving performance.
First, start an OpenAI compatible endpoint using the steps in the
previous section.

Download the dataset:

wget https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered/resolve/main/ShareGPT_V3_unfiltered_cleaned_split.json
    Copy to clipboard

Start benchmarking the OpenAI endpoint

# Start benchmarking
    python3 benchmarks/benchmark_serving.py --backend openai --base-url http://127.0.0.1:8000 --dataset-name=sharegpt --dataset-path=./ShareGPT_V3_unfiltered_cleaned_split.json --sharegpt-max-input-len 128 --sharegpt-max-model-len 256 --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --seed 12345
    Copy to clipboard

## vLLM input arguments for QAic

| Input Arg | Default Value | Setting Required for<br>QAic runs |
| --- | --- | --- |
| model | None | Hugging face model<br>name or model path |
| max-num-seqs | 256 | Decode batch size |
| max-model-len | 2048 | Context length |
| max-seq-len-to-capture | None | Sequence length |
| device | “auto” | “auto” or “qaic” -<br>Qualcomm AI cloud<br>devices will be used,<br>if VLLM is installed<br>correctly for qaic |
| device-group | [0] | List of device ids to<br>be used for<br>execution; Ultra -<br>0,1,2,3; Ultra+ -<br>0,1,2,3,4,5,6,7 |
| quantization | “auto” | “auto” - No weight<br>quantization (FP16);<br>“mxfp6” - Weight are<br>quantized with mxfp6 |
| kv-cache-dtype | “auto” | “auto” - No KV Cache<br>compression (FP16);<br>“mxint8” - KV Cache<br>compressed using<br>mxint8 format |
| block-size | “max-model-len” | set same as context<br>length or<br>“max\_model\_len” |
| disable-log-stats | True | True - print<br>performance stats;<br>False - disable<br>performance stats |
| num-gpu-blocks-override | “max-num-seqs” | set same as<br>“max\_num\_seqs” or<br>decode batch size |
| tensor-parallel-size | 1 | vLLM implementation<br>of Tensor slicing<br>using collective<br>communication library<br>is not supported,<br>instead Tensor<br>Slicing is supported<br>inherently using QAic<br>AOT approach. To use<br>TS&gt;1 please provide<br>right set of<br>device\_ids in<br>device\_group<br>arguments. It is<br>recommend not to<br>enable vLLM default<br>TS implementation<br>using<br>“-<br>tensor-parallel-size”<br>argument |
| gpu-memory-utilization | 0.90 | vLLM scheduler is<br>modified to use full<br>GPU memory for kv<br>cache, there is no<br>way to limit GPU KV<br>Cache usage, so it is<br>recommended not to<br>limit GPU memory<br>using<br>“-gp<br>u-memory-utilization”<br>argument |
| enable-chunked-prefill | False | Chunked prefill is<br>supported by default<br>in QAic model runner<br>implemention, not<br>using default<br>chunking logic in<br>vLLM scheduler class,<br>thus it is<br>recommended not to<br>enable chunking using<br>“-en<br>able-chunked-prefill”<br>argument |
| use-v2-block-manager | False | Set this flag to True<br>for enabling prefix<br>caching. |
| enable-prefix-caching | False | Set this flag to True<br>to enable prefix<br>caching for qaic |
| override-qaic-config | None | Initialize non<br>default qaic config<br>or override default<br>qaic config that are<br>specific to QAic<br>devices, for<br>speculative draft<br>model, this argument<br>will be used to<br>configure the qaic<br>config that can not<br>be fully gathered<br>from the vLLM<br>arguments |
| speculative-config |  | Configuration for<br>speculative decoding. |
| task |  | The task to use the<br>model for. Each vLLM<br>instance only supports<br>one task, even if the<br>same model can be used<br>for multiple tasks.<br>When the model only<br>supports one task,<br>“auto” can be used to<br>select it; otherwise,<br>you must specify<br>explicitly which task<br>to use. |
| override-pooler-config |  | Initialize non default<br>pooling config or<br>override default<br>pooling config for the<br>pooling model. |

### Override Arguments that can be modified

override-qaic-config = `<Compiler cfg for target model>`

Using this interface user can override default attributes such as, -
num\_cores, dfs, mos, device\_group, qpc\_path, mxfp6\_matmul,
mxint8\_kv\_cache, device\_group, and other compiler options.

#### CLI inferencing

Single space between attributes, no space within attribute and value
pair during running on command line arguments.

Example

--override-qaic-config = "num_cores=4 mxfp6_matmul=True mos=1 device_group=0,1,2,3"
    Copy to clipboard

Note: Only provide attributes which need to be overridden.

#### Python object inferencing

Override arguments can also be passed as input during LLM object
creation.

Example

override_qaic_config = {'num_cores':8, 'mxfp6_matmul':True,  'mos':1}
    Copy to clipboard

Note: Only provide attributes which need to be overridden.

## vLLM flags and environment variables

| Input Arg | Default Value | Setting Required for<br>QAic runs |
| --- | --- | --- |
| VLLM\_QAIC\_QPC\_PATH | None | Set this flag with<br>the path to qpc. vLLM<br>loads the qpc<br>directly from the<br>path provided and<br>will not compile the<br>model |
| VLLM\_QAIC\_MOS | None | Set MOS value |
| VLLM\_QAIC\_DFS\_EN | None | Enable compiler depth<br>first |
| VLLM\_QAIC\_QID | None | Manually set QID for<br>qaic devices |
| VLLM\_QAIC\_NUM\_CORES | None | Set num\_cores example<br>14 or 16 |
| VLLM\_QAIC\_COMPILER\_ARGS | None | Set additional<br>compiler arguments<br>through this<br>environment variable |
| VLLM\_QAIC\_MAX\_CPU\_THREADS | None | Avoid<br>oversubscription of<br>CPU threads, during<br>multi-instance<br>execution. By default<br>there is no limit, if<br>user set an<br>environment variable<br>[VLLM](https://docs.qualcomm.com/doc/80-99100-3/topic/index_vLLM.html#vllm)<br>QAIC\_MAX\_CPU\_THREADS,<br>then number of cpu<br>thread running<br>pytorch sampling on<br>cpu is limited, to<br>avoid<br>over-subscription.<br>The contention is<br>amplified when<br>running in a<br>container where CPU<br>limits can cause<br>throttling. |

### Avoiding CPU oversubscription via VLLM\_QAIC\_MAX\_CPU\_THREADS

CPU oversubscription refers to a situation where the total number of
CPUs allocated to a system exceeds the total number of CPUs available on
the hardware. This leads to severe contention for CPU resources. In such
cases, there is frequent switching between processes, which increases
processes switching overhead and decreases overall system efficiency. In
containers where multiple instances of vLLM can cause oversubscription,
limiting the concurrent CPU threads is a good way to avoid
oversubscription.

Example

export VLLM_QAIC_MAX_CPU_THREADS=8
    export OMP_NUM_THREADS=8
    Copy to clipboard

## Deploy vLLM using Kserve

KServe is a Kubernetes-native model serving platform that provides a standardized inference API, autoscaling, and multi-framework support. Deploying vLLM on Qualcomm Cloud AI accelerators through KServe brings production-grade orchestration to LLM inference - enabling request routing, horizontal scaling, and lifecycle management within an existing Kubernetes cluster.

The `readme` and `config` file related to vLLM are at `/path/to/apps-sdk/common/integrations/kserve/vLLM`.

### Initial notes:

- - vLLM Docker container need to be built from
    - `/path/to/apps-sdk/common/tools/docker-build`.
- - Instructions to build vLLM Container are available at
    - `/path/to/apps-sdk/common/tools/docker-build`. Sample cmd:

python3 build_image.py --tag 1.11.0.46-vllm --log_level 2 --user_specification_file /opt/qti-aic/tools/docker-build-gen2/sample_user_specs/user_image_spec_vllm.json --apps-sdk /apps/sdk/path --platform-sdk /platform/sdk/path
    Copy to clipboard

1. Sample `user_specification_file` should look like the following:

{
        "base_image": "ubuntu20",
        "applications": ["vllm"],
        "python_version": "py310",
        "sdk": {
            "qaic_apps": "required",
            "qaic_platform": "required"
        }
    }
    Copy to clipboard

### Resources

- See this [`Kubernetes tutorial < https://kubernetes.io/docs/tutorials/configuration/configure-persistent-volume-storage/>`\_\_](https://docs.qualcomm.com/doc/80-99100-3/topic/index_vLLM.html#id10) for instructions on how to configure a pod to use a PersistentVolumeClaim for storage.

### Assumptions

1. An available AI 100 machine with Minikube service
deployed
2. You are aware on how to deploy and pull image from registry and familiar with APPS-SDK.
3. You have basic knowledge on mounting volume on kubernetes pods. Check
out point “1” in resources.
4. vLLM Docker container is available as mentioned in Initial Notes.

### Deploy a Kubernetes device plugin

The Kubernetes device plugin is available at `/path/to/apps-sdk/tools/k8s-device-plugin/`.

1. Do the following to create an ubuntu18 (x86) based container.

bash build_image.sh
        Copy to clipboard
2. Run the following:

docker images
        Copy to clipboard

    In the output check for `qaic-k8s-device-plugin:v1.0.0`.
3. Do the following to install the device plugin:

kubectl create -f qaic-device-plugin.yml
        Copy to clipboard
4. Run the following:

kubectl describe node | grep qaic
        Copy to clipboard

    In the output ou should see positive integer values for the first two  lines. Now you can track them in the full output.

### Modifications to current files

1. Build vLLM Docker container using `/path/to/apps-sdk/tool/docker-build`.
2. Modify the `kserve_runtimes.yaml` file: for
`metadata: name: kserve-vllmserver` where `spec.containers.args`
has value `vllmserver`, replace `spec.container.image` to the
name of vLLM image built in step 1.

3. Deploy the vLLM image to a public Docker
repository, so that Kserve can pull the image for inferencing. Or
make sure its available in local Docker registry.

4. Modify the [``](https://docs.qualcomm.com/doc/80-99100-3/topic/index_vLLM.html#id6)inference.yaml [``](https://docs.qualcomm.com/doc/80-99100-3/topic/index_vLLM.html#id8)file to point it to the correct vLLM image built,
make sure the image is available locally or you are pulling it from
Docker public library.

    - If you’re using Minikube then you need to set up `imagePullSecret` and
update it accordingly in `inference.yaml`.
5. Modify the `resources` in the `inference.yaml` to adjust to your system
specifications.
6. Modify the container arguments in the `inference.yaml` to pass
arguments to vLLM server.

### If you have time out problem

1. You need to create a vLLM Docker image with models already available
inside the container and then launch the model.
2. Make sure the respective models are available inside the vLLM
container.

    - You can use `docker commit` to store the model as in the following example:
`docker commit <container_id> kserve-vllm-model`
    - You can use the `kserve-vllm-model` image as a base image for the pod.

### Setup instructions

1. Make sure you have all the requirements and modifications mentioned
above.
2. bash quick\_install.sh
3. kubectl apply -f inference.yaml
4. For Minikube deployments only: kubectl apply -f minikube-service.yaml

### Inference instructions: (example commands)

#### Minikube

- Start Minikube with `minikube start --driver=none`
- Install Kserve

cd minikube_files
        bash quick_install.sh
        Copy to clipboard
- Apply the qaic-device-plugin.yml (from section Kubernetes Device
Plugin Deployment)
- Apply the pull secret if required (To pull the image from public
Docker registry). `kubectl apply -f pull-secret.yaml`
- Apply inference.yaml `kubectl apply -f inference.yaml`
- Verify if the pods are up and running `kubectl get pods`

NAME                                                              READY    STATUS    RESTARTS    AGE
        kserve-vllm-model-predictor-default-00001-deployment-85bdb6b48rbq   2/2     Running   0          45m
        Copy to clipboard
- Apply inference-service yaml file
`kubectl apply -f minikube-service.yaml`
- Start a seperate terminal to create a minikube tunnel

    - Create a tunnel between minikube and host machine
`minikube tunnel`
- `kubectl get svc` gives you the service and external IP to connect
for inferencing.

NAME                                              TYPE           CLUSTER-IP      EXTERNAL-IP              PORT(S)               AGE
        kserve-vllm-model-external                       LoadBalancer   10.104.86.212   10.104.86.212            80:32335/TCP           47m``
        Copy to clipboard
- Make sure the proper ports are setup and exposed for
inferencing. Modifications to yaml file might be required.
- Use curl command to do inferencing from host machine.

curl -X POST http://<EXTERNAL-IP>:80/v1/completions -H "Content-Type: application/json" -H "Authorization: Bearer token-abc123" -d '{ "model": "<MODEL_NAME>",   "prompt": "My name is",   "max_tokens": 50 }'
        Copy to clipboard
- Use hey command to verify autoscaling.

hey -n 10000 -c 100 -q 1 -m POST -T "application/json" http://<EXTERNAL-IP>:80/v1/completions -d  '{ "model": <MODEL_NAME>,   "prompt": "My name is",   "max_tokens": 50 }'
        Copy to clipboard

Last Published: May 01, 2026

[Previous Topic
Triton Inference Server](https://docs.qualcomm.com/bundle/publicresource/80-99100-3/topics/index_Triton-Inference-Server-Support.md) [Next Topic
Inference workflow](https://docs.qualcomm.com/bundle/publicresource/80-99100-3/topics/index_Inference-Workflow.md)