> For clean Markdown content of this page, append .md to this URL. For the complete documentation index, see https://docs.nvidia.com/dynamo/llms.txt. For full content including API reference and SDK examples, see https://docs.nvidia.com/dynamo/llms-full.txt.

# Quickstart

## Choose Your Path

#### [Quickstart](/dynamo/cli/getting-started/quickstart)

You're here. Container fast path.

#### [Local Installation](/dynamo/cli/installation/install-dynamo)

Full walkthrough — PyPI, configuration.

#### [Kubernetes](/dynamo/kubernetes/model-deployment/introduction)

Kubernetes-native production path.

#### [Build from Source](/dynamo/advanced-customizations/building-from-source)

For contributors against `main`.

Dynamo is backend-agnostic and Kubernetes-native without being Kubernetes-only. Use this container path to try the same frontend/router/worker stack locally; use the Kubernetes path when you want the operator, CRDs, Gateway API integration, autoscaling, scheduling, and cluster lifecycle management.

## Run Dynamo Locally

#### Choose and install a build

#### NVIDIA GPU

Containers have all dependencies pre-installed. Pick your backend:

```bash title="SGLang"
docker run --gpus all --network host --rm -it nvcr.io/nvidia/ai-dynamo/sglang-runtime:1.4.0
```

```bash title="TensorRT-LLM"
docker run --gpus all --network host --rm -it nvcr.io/nvidia/ai-dynamo/tensorrtllm-runtime:1.4.0
```

```bash title="vLLM"
docker run --gpus all --network host --rm -it nvcr.io/nvidia/ai-dynamo/vllm-runtime:1.4.0
```

#### Intel XPU

Intel XPU images are built from source for vLLM and SGLang:

```bash title="vLLM"
git clone https://github.com/ai-dynamo/dynamo.git
cd dynamo
container/render.py --framework=vllm --device=xpu --target=runtime
docker build -t dynamo:latest-vllm-xpu-runtime \
  -f container/vllm-runtime-xpu-amd64-rendered.Dockerfile .
container/run.sh --image dynamo:latest-vllm-xpu-runtime --device=xpu -it
```

```bash title="SGLang"
git clone https://github.com/ai-dynamo/dynamo.git
cd dynamo
container/render.py --framework=sglang --device=xpu --target=runtime
docker build -t dynamo:latest-sglang-xpu-runtime \
  -f container/sglang-runtime-xpu-amd64-rendered.Dockerfile .
container/run.sh --image dynamo:latest-sglang-xpu-runtime --device=xpu -it
```

**Hugging Face token required for gated models.** Llama, Kimi, Qwen-VL, and other gated models require `HF_TOKEN` in your environment and accepting the model card's license on huggingface.co. Set `export HF_TOKEN=hf_…` before launching.

The remaining steps run inside the selected container. If you installed an NVIDIA wheel instead, run the same `python3 -m dynamo.*` commands in your Python environment. See [Local Installation](/dynamo/cli/installation/install-dynamo) for host prerequisites and virtual environment setup.

For published NVIDIA container versions and tags, see [Release Artifacts](../../reference/general/release-artifacts.mdx).

#### Start the frontend

Start the OpenAI-compatible frontend on port 8000:

```bash
python3 -m dynamo.frontend --discovery-backend file
```

`--discovery-backend file` avoids needing etcd. To run the frontend and worker in the same terminal, background each command with `> logfile.log 2>&1 &`.

#### Start a worker

In another terminal, select the hardware and backend you installed, then launch the worker:

#### Verify the endpoint

Check that the endpoint is up:

```bash
curl -sf http://localhost:8000/health && echo OK
```

If you see `OK`, send a chat completion:

```bash title="Request"
curl localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "Qwen/Qwen3-0.6B",
       "messages": [{"role": "user", "content": "Hello!"}],
       "max_tokens": 50}'
```

```json title="Response"
{
  "id": "chatcmpl-...",
  "model": "Qwen/Qwen3-0.6B",
  "choices": [{
    "index": 0,
    "message": {"role": "assistant", "content": "Hello! How can I help you today?"},
    "finish_reason": "stop"
  }],
  "usage": {"prompt_tokens": 9, "completion_tokens": 10, "total_tokens": 19}
}
```

Connection refused? The frontend takes a few seconds to start — retry. For production liveness and readiness probes, see [Health Check Reference](/dynamo/reference/observability/health-checks).

## From the Digest

#### [Full-Stack Optimizations for Agentic Inference](/dynamo/dev/digest/agentic-inference)

How Dynamo optimizes for agentic workloads at three layers: the frontend API, the router, and KV cache management.

#### [Flash Indexer: Inter-Galactic KV Routing](/dynamo/dev/digest/flash-indexer)

How Dynamo's concurrent global index evolved through six iterations to sustain over 100M ops/sec.

## Dive Deeper

Pick a full install path from the [four options above](#choose-your-path), or explore how Dynamo works under the hood:

#### [Architecture](/dynamo/knowledge-base/overview)

How the frontend, router, and workers fit together.

#### [Frontend Guide](/dynamo/knowledge-base/modular-components/frontend/overview)

Worker discovery, multi-model routing, OpenAI compat.

#### [KV Cache Aware Routing](/dynamo/knowledge-base/modular-components/router/routing-concepts#kv-cache-routing)

How the router places requests for prefix reuse.