Skip to content

vllm.entrypoints.cli.launch

Classes:

Functions:

LaunchSubcommand

Bases: CLISubcommand

The launch subcommand for the vLLM CLI.

Uses nested sub-subcommands so each component can define its own arguments independently (e.g. vllm launch render).

Source code in vllm/entrypoints/cli/launch.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
class LaunchSubcommand(CLISubcommand):
    """The `launch` subcommand for the vLLM CLI.

    Uses nested sub-subcommands so each component can define its own
    arguments independently (e.g. ``vllm launch render``).
    """

    name = "launch"

    @staticmethod
    def cmd(args: argparse.Namespace) -> None:
        if hasattr(args, "model_tag") and args.model_tag is not None:
            args.model = args.model_tag

        args.launch_command(args)

    def validate(self, args: argparse.Namespace) -> None:
        validate_parsed_serve_args(args)

    def subparser_init(
        self, subparsers: argparse._SubParsersAction
    ) -> FlexibleArgumentParser:
        launch_parser = subparsers.add_parser(
            self.name,
            help=DESCRIPTION,
            description=DESCRIPTION,
            usage=f"vllm {self.name} <component> [options]",
        )
        launch_subparsers = launch_parser.add_subparsers(
            required=True, dest="launch_component"
        )

        for cmd_cls in LaunchSubcommandBase.__subclasses__():
            cmd_subparser = launch_subparsers.add_parser(
                cmd_cls.name,
                help=cmd_cls.help,
                usage=f"vllm {self.name} {cmd_cls.name} [options]",
            )
            cmd_subparser.set_defaults(launch_command=cmd_cls.cmd)
            cmd_cls.add_cli_args(cmd_subparser)
            cmd_subparser.epilog = VLLM_SUBCMD_PARSER_EPILOG.format(
                subcmd=f"{self.name} {cmd_cls.name}"
            )

        return launch_parser

LaunchSubcommandBase

Bases: CLISubcommand

The base class of subcommands for vllm launch.

Methods:

Source code in vllm/entrypoints/cli/launch.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class LaunchSubcommandBase(CLISubcommand):
    """The base class of subcommands for `vllm launch`."""

    help: str

    @classmethod
    def add_cli_args(cls, parser: FlexibleArgumentParser) -> None:
        """Add the CLI arguments to the parser.

        By default, uses the subcommand's docstring as the description and adds
        the standard vLLM serving arguments.
        Subclasses can override to add component-specific arguments.
        """
        if cls.__doc__:
            parser.description = inspect.cleandoc(cls.__doc__)
        make_arg_parser(parser)

    @staticmethod
    def cmd(args: argparse.Namespace) -> None:
        raise NotImplementedError

add_cli_args(parser) classmethod

Add the CLI arguments to the parser.

By default, uses the subcommand's docstring as the description and adds the standard vLLM serving arguments. Subclasses can override to add component-specific arguments.

Source code in vllm/entrypoints/cli/launch.py 
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def add_cli_args(cls, parser: FlexibleArgumentParser) -> None:
    """Add the CLI arguments to the parser.

    By default, uses the subcommand's docstring as the description and adds
    the standard vLLM serving arguments.
    Subclasses can override to add component-specific arguments.
    """
    if cls.__doc__:
        parser.description = inspect.cleandoc(cls.__doc__)
    make_arg_parser(parser)

RenderSubcommand

Bases: LaunchSubcommandBase

vllm launch render starts a GPU-less rendering server for preprocessing and postprocessing only.

vllm launch render meta-llama/Llama-3.2-1B-Instruct --port 8100

This command reuses the standard serving parser, so model, frontend, networking, and related CLI options follow the same conventions as vllm serve.

Source code in vllm/entrypoints/cli/launch.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
class RenderSubcommand(LaunchSubcommandBase):
    """`vllm launch render` starts a GPU-less rendering server for preprocessing
    and postprocessing only.

    ```bash
    vllm launch render meta-llama/Llama-3.2-1B-Instruct --port 8100
    ```

    This command reuses the standard serving parser, so model, frontend,
    networking, and related CLI options follow the same conventions as
    [`vllm serve`](https://docs.vllm.ai/en/latest/cli/serve/).
    """

    name = "render"
    help = "Launch a GPU-less rendering server (preprocessing and postprocessing only)."

    @staticmethod
    def cmd(args: argparse.Namespace) -> None:
        uvloop.run(run_launch_fastapi(args))

run_launch_fastapi(args) async

Run the online serving layer with FastAPI (no GPU inference).

Source code in vllm/entrypoints/cli/launch.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
async def run_launch_fastapi(args: argparse.Namespace) -> None:
    """Run the online serving layer with FastAPI (no GPU inference)."""

    # Interrupt initialization if SIGTERM arrives before uvicorn installs
    # its own signal handlers. Once uvicorn is running it replaces this.
    def _interrupt_init(*_) -> None:
        raise KeyboardInterrupt("terminated")

    signal.signal(signal.SIGTERM, _interrupt_init)

    # 1. Socket binding
    listen_address, sock = setup_server(args, reuse_port=False)

    # 2. Build and serve the API server
    engine_args = AsyncEngineArgs.from_cli_args(args)
    model_config = engine_args.create_model_config()

    # Render servers preprocess data only — no inference, no quantized kernels.
    # Clear quantization so VllmConfig skips quant dtype/capability validation.
    model_config.quantization = None

    # Render servers never allocate KV cache; suppress the spurious CPU KV
    # cache space warning from CpuPlatform.check_and_update_config.
    envs.VLLM_CPU_KVCACHE_SPACE = 0

    vllm_config = VllmConfig(model_config=model_config)
    shutdown_task = await build_and_serve_renderer(
        vllm_config, listen_address, sock, args
    )
    try:
        await shutdown_task
    finally:
        sock.close()