vLLM

Clore.ai GPUs पर vLLM के साथ उच्च-थ्रूपुट LLM इन्फ़रेंस

उत्पादन वर्कलोड के लिए CLORE.AI GPUs पर उच्च-थ्रूपुट LLM इनफ़ेरेंस सर्वर।

सभी उदाहरण यहाँ के माध्यम से किराए पर लिए गए GPU सर्वरों पर चलाए जा सकते हैं CLORE.AI मार्केटप्लेस.

वर्तमान संस्करण: v0.7.x — यह गाइड vLLM v0.7.3+ को कवर करती है। नई सुविधाओं में DeepSeek-R1 सपोर्ट, स्वचालित टूल चयन के साथ संरचित आउटपुट, मल्टी-LoRA सर्विंग, और बेहतर मेमोरी दक्षता शामिल हैं।

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
RAM	16GB	32GB+
VRAM	16GB (7B)	24GB+
नेटवर्क	500Mbps	1Gbps+
शुरू होने का समय	5-15 मिनट	-

मिलता-जुलता GPU चाहिए? एक RTX 4090 (24GB) 7B–13B को आराम से संभालता है; 70B+ मॉडलों के लिए एक H100 (80GB) सबसे सुरक्षित विकल्प है।

महत्वपूर्ण: vLLM को पर्याप्त RAM और VRAM की आवश्यकता होती है। 16GB से कम RAM वाले सर्वर 7B मॉडल भी नहीं चला पाएंगे।

शुरू होने का समय: पहला लॉन्च मॉडल को HuggingFace से डाउनलोड करता है (मॉडल के आकार और नेटवर्क स्पीड के अनुसार 5-15 मिनट)। इस दौरान HTTP 502 सामान्य है।

vLLM क्यों?

• सबसे तेज़ थ्रूपुट - 24x अधिक थ्रूपुट के लिए PagedAttention

• उत्पादन-तैयार - OpenAI-संगत API तुरंत उपलब्ध

• निरंतर बैचिंग - कुशल बहु-उपयोगकर्ता सर्विंग

• स्ट्रीमिंग - रीयल-टाइम टोकन जनरेशन

• मल्टी-GPU - बड़े मॉडलों के लिए टेन्सर पैरेललिज़्म

• मल्टी-LoRA - एक साथ कई फ़ाइन-ट्यून किए गए एडाप्टर सर्व करें (v0.7+)

• संरचित आउटपुट - JSON schema enforcement और tool calling (v0.7+)

CLORE.AI पर त्वरित परिनियोजन

Docker इमेज:

vllm/vllm-openai:v0.7.3

पोर्ट्स:

22/tcp
8000/http

कमांड:

vllm serve mistralai/Mistral-7B-Instruct-v0.2 --host 0.0.0.0 --port 8000

जाँचें कि यह काम कर रहा है

परिनियोजन के बाद, अपना खोजें http_pub URL में My Orders:

# हेल्थ जाँचें (पहली बार चलने पर 5-15 मिनट लग सकते हैं)
curl https://your-http-pub.clorecloud.net/health

# मॉडल सूची देखें (केवल मॉडल लोड होने के बाद काम करेगा)
curl https://your-http-pub.clorecloud.net/v1/models

यदि आपको 15 मिनट से अधिक समय तक HTTP 502 मिलता है, तो जाँचें:

1. सर्वर में 16GB+ RAM है

2. सर्वर में मॉडल के लिए पर्याप्त VRAM है

3. गेटेड मॉडलों के लिए HuggingFace टोकन सेट है

अपनी सेवा तक पहुँच

CLORE.AI पर परिनियोजित होने पर, vLLM को इस के माध्यम से एक्सेस करें http_pub URL:

# चैट पूर्णता
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

सभी localhost:8000 नीचे दिए गए उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी पहुँच के लिए, इसे अपने से बदलें https://your-http-pub.clorecloud.net/ URL।

स्थापना

Docker का उपयोग करके (अनुशंसित)

docker run -d --gpus all \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:v0.7.3 \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0

pip का उपयोग करके

pip install vllm==0.7.3

# सर्वर चलाएँ
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2

समर्थित मॉडल

मॉडल	पैरामीटर	आवश्यक VRAM	आवश्यक RAM
Mistral 7B	7B	14GB	16GB+
Llama 3.1 8B	8B	16GB	16GB+
Llama 3.1 70B	70B	140GB (या 2x80GB)	64GB+
Mixtral 8x7B	47B	90GB	32GB+
Qwen2.5 7B	7B	14GB	16GB+
Qwen2.5 72B	72B	145GB	64GB+
DeepSeek-V3	236B MoE	मल्टी-GPU	128GB+
DeepSeek-R1-Distill-Qwen-7B	7B	14GB	16GB+
DeepSeek-R1-Distill-Qwen-32B	32B	64GB	32GB+
DeepSeek-R1-Distill-Llama-70B	70B	140GB	64GB+
Phi-4	14B	28GB	32GB+
Gemma 2 9B	9B	18GB	16GB+
CodeLlama 34B	34B	68GB	32GB+

सर्वर विकल्प

बेसिक सर्वर

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000

प्रोडक्शन सर्वर

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 256 \
    --enable-prefix-caching

क्वांटाइज़ेशन के साथ (कम VRAM)

# AWQ क्वांटाइज़्ड मॉडल (कम VRAM उपयोग करता है)
vllm serve TheBloke/Mistral-7B-Instruct-v0.2-AWQ \
    --host 0.0.0.0 \
    --quantization awq

संरचित आउटपुट और टूल कॉलिंग (v0.7+)

स्वचालित टूल चयन और संरचित JSON आउटपुट सक्षम करें:

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral

Python में उपयोग करें:

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "किसी शहर के लिए वर्तमान मौसम प्राप्त करें",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "शहर का नाम"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "पेरिस में मौसम कैसा है?"}],
    tools=tools,
    tool_choice="auto"
)

# टूल कॉल को पार्स करें
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(f"Tool: {tool_call.function.name}, Args: {args}")

response format के माध्यम से संरचित JSON आउटपुट:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "निकालें: John Smith, 30 years old, software engineer"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)
print(response.choices[0].message.content)

मल्टी-LoRA सर्विंग (v0.7+)

एक बेस मॉडल को एक साथ कई LoRA एडाप्टरों के साथ सर्व करें:

vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --enable-lora \
    --lora-modules \
        sql-adapter=path/to/sql-lora \
        code-adapter=path/to/code-lora \
        chat-adapter=path/to/chat-lora \
    --max-lora-rank 64

मॉडल नाम द्वारा किसी विशिष्ट LoRA एडाप्टर को क्वेरी करें:

# SQL एडाप्टर का उपयोग करें
response = client.chat.completions.create(
    model="sql-adapter",
    messages=[{"role": "user", "content": "शीर्ष 10 ग्राहकों को खोजने के लिए एक SQL query लिखें"}]
)

# कोड एडाप्टर का उपयोग करें
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "सूची को sort करने के लिए एक Python function लिखें"}]
)

DeepSeek-R1 सपोर्ट (v0.7+)

vLLM v0.7+ में DeepSeek-R1 distill मॉडलों के लिए मूल सपोर्ट है। ये reasoning मॉडल उत्पन्न करते हैं <think> टैग जो उनकी reasoning प्रक्रिया दिखाते हैं।

DeepSeek-R1-Distill-Qwen-7B (एकल GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384

DeepSeek-R1-Distill-Qwen-32B (डुअल GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90

DeepSeek-R1-Distill-Llama-70B (क्वाड GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768

DeepSeek-R1 को क्वेरी करना

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[
        {
            "role": "user",
            "content": "हल करें: यदि एक ट्रेन 1.5 घंटे में 120km चलती है, तो उसकी गति m/s में कितनी है?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# उत्तर से पहले <think>...</think> reasoning block शामिल होता है
print(content)

think टैग्स को पार्स करना:

import re

def parse_deepseek_r1_response(content: str) -> dict:
    """DeepSeek-R1 response से thinking और answer निकालें."""
    think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
    return {"thinking": thinking, "answer": answer}

result = parse_deepseek_r1_response(content)
print("Thinking:", result["thinking"][:200], "...")
print("Answer:", result["answer"])

API उपयोग

चैट पूर्णताएँ (OpenAI-संगत)

from openai import OpenAI

# बाहरी पहुँच के लिए, अपना http_pub URL उपयोग करें:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="not-needed"
)

# या SSH टनल के माध्यम से:
# client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "क्वांटम कंप्यूटिंग समझाएँ"}
    ],
    max_tokens=500,
    temperature=0.7
)

print(response.choices[0].message.content)

स्ट्रीमिंग

stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "एक कविता लिखें"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

cURL

curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'

टेक्स्ट पूर्णताएँ

curl https://your-http-pub.clorecloud.net/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "फ़्रांस की राजधानी है",
    "max_tokens": 50
  }'

पूर्ण API संदर्भ

vLLM OpenAI-संगत endpoints के साथ अतिरिक्त utility endpoints भी प्रदान करता है।

मानक endpoints

एंडपॉइंट	मेथड	विवरण
/v1/models	GET	उपलब्ध मॉडल सूचीबद्ध करें
/v1/chat/completions	POST	चैट पूर्णता
/v1/completions	POST	टेक्स्ट पूर्णता
/health	GET	हेल्थ चेक (खाली लौट सकता है)

अतिरिक्त endpoints

एंडपॉइंट	मेथड	विवरण
/tokenize	POST	टेक्स्ट को टोकनाइज़ करें
/detokenize	POST	टोकन को टेक्स्ट में बदलें
/version	GET	vLLM संस्करण प्राप्त करें
/docs	GET	Swagger UI दस्तावेज़ीकरण
/metrics	GET	Prometheus metrics

टेक्स्ट को टोकनाइज़ करें

अनुरोध भेजने से पहले टोकन गिनने के लिए उपयोगी:

curl https://your-http-pub.clorecloud.net/tokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Hello world"
  }'

प्रतिक्रिया:

{"count": 2, "max_model_len": 32768, "tokens": [9707, 1879]}

डी-टोकनाइज़

टोकन IDs को वापस टेक्स्ट में बदलें:

curl https://your-http-pub.clorecloud.net/detokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "tokens": [9707, 1879]
  }'

प्रतिक्रिया:

{"prompt": "Hello world"}

संस्करण प्राप्त करें

curl https://your-http-pub.clorecloud.net/version

प्रतिक्रिया:

{"version": "0.7.3"}

Swagger दस्तावेज़ीकरण

इंटरैक्टिव API दस्तावेज़ीकरण के लिए ब्राउज़र में खोलें:

https://your-http-pub.clorecloud.net/docs

Prometheus metrics

मॉनिटरिंग के लिए:

curl https://your-http-pub.clorecloud.net/metrics

Reasoning मॉडल: DeepSeek-R1 और समान मॉडल में शामिल हैं <think> प्रतिक्रियाओं में टैग जो अंतिम उत्तर से पहले मॉडल की reasoning प्रक्रिया दिखाते हैं।

बेंचमार्क

थ्रूपुट (टोकन/सेकंड प्रति उपयोगकर्ता)

मॉडल	RTX 3090	RTX 4090	A100 40GB	A100 80GB
Mistral 7B	100	170	210	230
Llama 3.1 8B	95	150	200	220
Llama 3.1 8B (AWQ)	130	190	260	280
Mixtral 8x7B	-	45	70	85
Llama 3.1 70B	-	-	25 (2x)	45 (2x)
DeepSeek-R1 7B	90	145	190	210
DeepSeek-R1 32B	-	-	40	70 (2x)

बेंचमार्क जनवरी 2026 में अपडेट किए गए।

Context Length बनाम VRAM

मॉडल	4K ctx	8K ctx	16K ctx	32K ctx
8B FP16	18GB	22GB	30GB	46GB
8B AWQ	8GB	10GB	14GB	22GB
70B FP16	145GB	160GB	190GB	250GB
70B AWQ	42GB	50GB	66GB	98GB

Hugging Face प्रमाणीकरण

गेटेड मॉडलों (Llama, आदि) के लिए:

# कमांड में टोकन सेट करें
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --env HUGGING_FACE_HUB_TOKEN=hf_xxxxx

या इसे environment variable के रूप में सेट करें:

export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

GPU आवश्यकताएँ

मॉडल	न्यूनतम VRAM	न्यूनतम RAM	अनुशंसित
7-8B	16GB	16GB	24GB VRAM, 32GB RAM
13B	26GB	32GB	40GB VRAM
34B	70GB	32GB	80GB VRAM
70B	140GB	64GB	2x80GB

लागत अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें:

GPU	VRAM	कीमत/दिन	इसके लिए सबसे अच्छा
RTX 3090	24GB	$0.30–1.00	7-8B मॉडल
RTX 4090	24GB	$0.50–2.00	7-13B, तेज़
A100	40GB	$1.50–3.00	13-34B मॉडल
A100	80GB	$2.00–4.00	34-70B मॉडल

कीमतें USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — वर्तमान दरों के लिए देखें CLORE.AI मार्केटप्लेस ।

समस्या-समाधान

लंबे समय तक HTTP 502

1. RAM जाँचें: सर्वर में 16GB+ RAM होना चाहिए

2. VRAM जाँचें: मॉडल समा जाना चाहिए

3. मॉडल डाउनलोड हो रहा है: पहली बार चलाने पर HuggingFace से डाउनलोड होता है (5-15 मिनट)

4. HF Token: गेटेड मॉडल के लिए प्रमाणीकरण आवश्यक है

मेमोरी समाप्त

# मेमोरी उपयोग कम करें
--gpu-memory-utilization 0.8
--max-model-len 4096
--max-num-seqs 64

# या क्वांटाइज़ेशन का उपयोग करें
--quantization awq

मॉडल डाउनलोड विफल होता है

# HF टोकन जाँचें
echo $HUGGING_FACE_HUB_TOKEN

# मॉडल पहले से डाउनलोड करें
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.2

vLLM बनाम अन्य

विशेषता	vLLM	llama.cpp	Ollama
थ्रूपुट	सर्वोत्तम	अच्छा	अच्छा
VRAM उपयोग	उच्च	निम्न	मध्यम
उपयोग में आसानी	मध्यम	मध्यम	आसान
शुरू होने का समय	5-15 मिनट	1-2 मिनट	30 सेकंड
मल्टी-GPU	मूल	सीमित	सीमित
टूल कॉलिंग	हाँ (v0.7+)	सीमित	सीमित
मल्टी-LoRA	हाँ (v0.7+)	नहीं	नहीं

vLLM का उपयोग करें जब:

• उच्च थ्रूपुट प्राथमिकता हो

• कई उपयोगकर्ताओं को सेवा देना

• पर्याप्त VRAM और RAM हो

• प्रोडक्शन परिनियोजन

• टूल कॉलिंग / संरचित आउटपुट की आवश्यकता हो

Ollama का उपयोग करें जब:

• त्वरित सेटअप की आवश्यकता हो

• एकल उपयोगकर्ता

• कम संसाधन उपलब्ध हों

अगले चरण

• Ollama - तेज़ स्टार्टअप वाला सरल विकल्प

• DeepSeek-R1 - तर्क मॉडल गाइड

• DeepSeek-V3 - सर्वश्रेष्ठ सामान्य मॉडल

• Qwen2.5 - बहुभाषी मॉडल

• Llama.cpp - कम VRAM विकल्प