# Run Qwen or DeepSeek open models on a cloud GPU in Asia

URL: https://cloudj.net/blog/qwen-deepseek-llm-gpu-asia
Published: 2026-11-12 · Updated: 2026-11-12

> How to run Qwen LLM cloud GPU setups and DeepSeek open models in Asia: pick model size by VRAM, choose quantization, search Asian codes and check licences.

Teams that want to run Qwen LLM cloud GPU deployments, or DeepSeek's open-weight models, usually share one goal: a capable model that handles Chinese, Japanese, Korean, Vietnamese, Thai or Indonesian well, running on hardware they control. Both families publish many sizes, which is good for choice and confusing for planning. This guide helps you match a model size to the VRAM you rent, choose a quantization, find a host in Asia on Cloudj, and avoid the licence mistakes that catch teams later.

## Why these families for Asian languages

Open-weight families such as Qwen and DeepSeek were trained with large amounts of Chinese and other Asian-language text, and many teams find them strong on Asian languages compared with models trained mostly on English. That is a general observation, not a guarantee: quality varies by model size, version and task. Always test with your own prompts, in your own language, before choosing.

Two practical facts about these families:

- **Many sizes.** Qwen releases range from under 1B to tens of billions of parameters in dense models, plus larger mixture-of-experts variants.
- **Flagship models are very large.** DeepSeek's largest models need many datacenter GPUs. Smaller distilled variants, often built on Qwen or other bases, fit on one or two cards and are what most teams actually serve.

## Size the model to your VRAM

Rough guidance for 4-bit quantized weights. Context length, batch size and the serving tool add to these numbers, so leave headroom:

| Model size | Approx. weights at 4-bit | Card that fits comfortably |
|---|---|---|
| 7B to 8B | Around 5 to 6 GB | Almost any 12 GB or larger card |
| 14B | Around 9 to 10 GB | [RTX 4090](https://cloudj.net/gpu-cloud/rtx-4090), 24 GB, with plenty of context |
| 30B to 32B | Around 18 to 20 GB | RTX 4090 with short context, or [RTX 5090](https://cloudj.net/gpu-cloud/rtx-5090), 32 GB |
| 70B class | Around 40 GB | [RTX A6000](https://cloudj.net/gpu-cloud/rtx-a6000), 48 GB, or 2× 24 GB in one machine |

The RTX 4090 and RTX 5090 are consumer cards available at the starting account level. The RTX A6000 is a workstation card and needs a higher account level. For 70B models on several GPUs, [running a 70B LLM on multiple GPUs](https://cloudj.net/blog/llm-70b-multi-gpu-europe) covers tensor parallel setups. Live "from" prices are on [GPU cloud](https://cloudj.net/gpu-cloud).

## Choose a quantization

- **8-bit:** close to full quality, roughly double the memory of 4-bit.
- **4-bit (GGUF Q4, AWQ, GPTQ):** the usual balance for serving on one card.
- **Below 4-bit:** fits bigger models into smaller cards, with noticeable quality loss, especially on less common languages.

A larger model at 4-bit often beats a smaller model at 8-bit, but test in your target language; quantization can hurt minority languages more than English.

## Find a host in Asia

If users chat with the model in real time, place it near them. On the [deploy page with the RTX 4090 preselected](https://app.cloudj.net/deploy/gpu?model=rtx-4090):

| Main users | Country field to start with |
|---|---|
| Southeast Asia, including Vietnam | `SG, HK` |
| Japan | `JP`, then add `KR` |
| Korea | `KR`, then add `JP` |
| Greater China | `HK`, then add `SG` |
| Mixed Asia | `SG, JP, HK, KR` |

For Vietnam, you can also try `VN`, but machines there are not guaranteed to be listed; `SG` and `HK` are the usual alternatives. Stock changes during the day, so if nothing suitable is listed, widen the codes, try later, or choose another card with enough VRAM. The [GPU cloud Asia guide](https://cloudj.net/blog/gpu-cloud-asia-guide) explains the regional codes.

If you only run batch jobs, such as summarising documents overnight, location matters little; search broadly and pick on price and reliability.

## Serve it: two common routes

Cloudj ships Ubuntu + CUDA, PyTorch + JupyterLab and custom image templates. You install the serving tool yourself over SSH.

### Ollama, for the quickest start

```bash
ssh -p PORT root@HOST
curl -fsSL https://ollama.com/install.sh | sh
ollama pull MODEL_TAG
ollama run MODEL_TAG
```

Replace `MODEL_TAG` with the Qwen or DeepSeek variant and quantization you chose from the [Ollama library](https://ollama.com/library). [Running Ollama on a GPU server in Asia](https://cloudj.net/blog/ollama-gpu-server-asia) covers this route in detail, including exposing the API safely.

### vLLM, for higher throughput

For many concurrent users, vLLM with an AWQ or GPTQ quantized model gives an OpenAI-compatible API and efficient batching:

```bash
pip install vllm
vllm serve MODEL_ID --host 127.0.0.1 --port 8000 --max-model-len 8192
```

In both cases keep the API on localhost and reach it through an SSH tunnel or a VPS that handles TLS and authentication.

## Licences: check before you ship

Model licences differ between families and even between versions of the same family. Some are permissive, some carry use restrictions or attribution requirements, and distilled models may inherit terms from their base model. Before you serve a model commercially, read the licence on its model card and keep a copy with your deployment notes.

## A Vietnamese chatbot example

For a Vietnamese customer-support bot, many teams start with a 7B to 14B instruction model at 4-bit on an RTX 4090 in `SG`, test it against real customer questions, and only move up in size if answers are not good enough. [A Vietnamese LLM chatbot on a GPU](https://cloudj.net/blog/vietnamese-llm-chatbot-gpu) walks through that project end to end.

## FAQ

### Can I run the full DeepSeek flagship model on one GPU?

No. The largest models need many datacenter GPUs. Distilled variants fit on one or two cards.

### Which GPU should I start with for a 14B model?

An RTX 4090 with 24 GB is a comfortable start at 4-bit.

### Does Cloudj have a ready-made Ollama setup?

No. Install Ollama yourself over SSH in a few commands.

### What if no GPU is listed in Singapore?

Add `HK`, `JP` or `KR`, try later, or choose another card with similar VRAM.

## Next step

Open the [RTX 4090 deploy page](https://app.cloudj.net/deploy/gpu?model=rtx-4090), search `SG, JP, HK, KR`, and test two model sizes in your own language before you commit.