SGLang

Clore.ai GPUs पर RadixAttention के साथ उच्च-प्रदर्शन LLM सर्विंग के लिए SGLang डिप्लॉय करें

SGLang (Structured Generation Language) एक उच्च-प्रदर्शन LLM सर्विंग फ्रेमवर्क है, जिसे LMSYS टीम ने विकसित किया है, जो Vicuna और Chatbot Arena पर अपने काम के लिए जानी जाती है। इसमें KV cache sharing के लिए RadixAttention, कुशल MoE (Mixture of Experts) समर्थन, और OpenAI-संगत API शामिल है — जिससे यह CLORE.AI GPU सर्वरों पर उपलब्ध सबसे तेज़ ओपन-सोर्स inference engines में से एक बन जाता है।

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

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

पैरामीटर	न्यूनतम	अनुशंसित
RAM	16 GB	32 GB+
VRAM	8 GB	24 GB+
डिस्क	50 GB	200 GB+
GPU	NVIDIA Turing+ (RTX 2000+)	A100, H100, RTX 4090

SGLang Ampere+ GPUs पर FlashInfer सक्षम होने पर सबसे अच्छा प्रदर्शन देता है। Mixtral या DeepSeek जैसे MoE मॉडलों के लिए multi-GPU सेटअप की अनुशंसा की जाती है।

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

Docker इमेज: lmsysorg/sglang:latest

पोर्ट्स: 22/tcp, 30000/http

Environment Variables:

वेरिएबल	उदाहरण	विवरण
HF_TOKEN	hf_xxx...	gated models के लिए HuggingFace token
CUDA_VISIBLE_DEVICES	0,1	उपयोग की जाने वाली GPUs

चरण-दर-चरण सेटअप

1. CLORE.AI पर GPU Server किराए पर लें

देखें CLORE.AI मार्केटप्लेस और एक server चुनें:

• 7B मॉडल: न्यूनतम 16 GB VRAM (RTX 4080, A10)

• 13B मॉडल: 24 GB VRAM (RTX 3090, RTX 4090, A5000)

• 70B मॉडल: 80 GB+ VRAM (A100 80GB) या multi-GPU

• MoE मॉडल (Mixtral 8x7B): 48 GB VRAM या 2× 24 GB

2. अपने Server में SSH करें

ssh -p <PORT> root@<SERVER_IP>

3. SGLang Docker Image Pull करें

docker pull lmsysorg/sglang:latest

4. SGLang Server लॉन्च करें

बेसिक लॉन्च (Llama 3.1 8B):

docker run -d \\
  --name sglang \\
  --gpus all \\
  --shm-size 16g \\
  --ipc host \\
  -p 30000:30000 \\
  -v /root/models:/root/.cache/huggingface \\
  lmsysorg/sglang:latest \\
  python3 -m sglang.launch_server \\
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \\
    --port 30000

HuggingFace token के साथ:

docker run -d \\
  --name sglang \\
  --gpus all \\
  --shm-size 16g \\
  --ipc host \\
  -p 30000:30000 \\
  -v /root/models:/root/.cache/huggingface \\
  -e HF_TOKEN=hf_your_token_here \\
  lmsysorg/sglang:latest \\
  python3 -m sglang.launch_server \\
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \\
    --port 30000 \\
    --dtype bfloat16

multi-GPU पर Qwen2.5 72B:

docker run -d \\
  --name sglang \\
  --gpus all \\
  --shm-size 32g \\
  --ipc host \\
  -p 30000:30000 \\
  -v /root/models:/root/.cache/huggingface \\
  lmsysorg/sglang:latest \\
  python3 -m sglang.launch_server \\
    --model-path Qwen/Qwen2.5-72B-Instruct \\
    --host 0.0.0.0 \\
    --port 30000 \\
    --tp 2 \\
    --dtype bfloat16

DeepSeek-V2 (MoE model):

docker run -d \\
  --name sglang \\
  --gpus all \\
  --shm-size 32g \\
  --ipc host \\
  -p 30000:30000 \\
  -v /root/models:/root/.cache/huggingface \\
  lmsysorg/sglang:latest \\
  python3 -m sglang.launch_server \\
    --model-path deepseek-ai/DeepSeek-V2-Lite-Chat \\
    --host 0.0.0.0 \\
    --port 30000 \\
    --trust-remote-code \
    --tp 1

5. Server Health जांचें

# लॉग देखें
docker logs -f sglang

# Health check (model को load होने में लगभग 2-3 मिनट प्रतीक्षा करें)
curl http://localhost:30000/health

# मॉडल जानकारी प्राप्त करें
curl http://localhost:30000/get_model_info

6. CLORE.AI Proxy के माध्यम से बाहर से पहुँचें

आपका CLORE.AI dashboard एक http_pub port 30000 के लिए URL प्रदान करता है:

https://<order-id>-30000.clore.ai/

किसी भी OpenAI-संगत client में इस URL को अपना base URL के रूप में उपयोग करें।

---

उपयोग के उदाहरण

उदाहरण 1: OpenAI-संगत Chat Completions

curl http://localhost:30000/v1/chat/completions \\
  -X POST \\
  -H 'Content-Type: application/json' \\
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "आप एक सहायक coding assistant हैं."},
      {"role": "user", "content": "Python में quicksort implementation लिखें."}
    ],
    "max_tokens": 512,
    "temperature": 0.2
  }'

उदाहरण 2: Streaming Response

curl http://localhost:30000/v1/chat/completions \\
  -X POST \\
  -H 'Content-Type: application/json' \\
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Transformer attention कैसे काम करता है, समझाइए."}
    ],
    "max_tokens": 800,
    "stream": true
  }' \\
  --no-buffer

उदाहरण 3: Python OpenAI Client

from openai import OpenAI

# अपने CLORE.AI SGLang server की ओर इंगित करें
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang को डिफ़ॉल्ट रूप से auth की आवश्यकता नहीं होती
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "आप एक data science expert हैं."},
        {"role": "user", "content": "Gradient boosting क्या है?"},
    ],
    max_tokens=400,
    temperature=0.7,
)

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

उदाहरण 4: SGLang Native API के साथ Batch Inference

SGLang का native API अतिरिक्त नियंत्रण प्रदान करता है:

import requests

# Completions उत्पन्न करें
response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "AI का भविष्य है",
        "sampling_params": {
            "max_new_tokens": 200,
            "temperature": 0.8,
            "top_p": 0.95,
        },
    },
)
print(response.json()["text"])

उदाहरण 5: सीमित JSON आउटपुट

SGLang संरचित आउटपुट generation का समर्थन करता है:

import requests

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"},
    },
    "required": ["name", "age", "city"],
}

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "जानकारी निकालें: John Smith, 35 years old, lives in New York.",
        "sampling_params": {
            "max_new_tokens": 100,
            "temperature": 0.0,
        },
        "json_schema": schema,
    },
)
print(response.json()["text"])
# आउटपुट: {"name": "John Smith", "age": 35, "city": "New York"}

---

कॉन्फ़िगरेशन

मुख्य लॉन्च पैरामीटर

पैरामीटर	डिफ़ॉल्ट	विवरण
--model-path	आवश्यक	HuggingFace model ID या local path
--host	127.0.0.1	Bind host (उपयोग करें 0.0.0.0 बाहरी के लिए)
--port	30000	Server port
--tp	1	Tensor parallelism degree (num GPUs)
--dp	1	Data parallelism degree
--dtype	auto	float16, bfloat16, float32
--mem-fraction-static	0.88	KV cache के लिए VRAM का अंश
--max-prefill-tokens	auto	एक prefill चरण में अधिकतम tokens
--context-length	मॉडल max	अधिकतम context length को override करें
--trust-remote-code	false	custom model code की अनुमति दें
--quantization	none	awq, gptq, fp8
--load-format	auto	auto, pt, safetensors
--tokenizer-path	model के समान	Custom tokenizer path

Quantization विकल्प

AWQ (गति के लिए अनुशंसित):

python3 -m sglang.launch_server \\
  --model-path casperhansen/mistral-7b-instruct-v0.2-awq \\
  --quantization awq \\
  --host 0.0.0.0 \\
  --port 30000

FP8 (H100/A100 के लिए):

python3 -m sglang.launch_server \\
  --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \\
  --quantization fp8 \
  --host 0.0.0.0 \\
  --port 30000

---

प्रदर्शन सुझाव

1. RadixAttention — मुख्य लाभ

SGLang का RadixAttention साझा prompt prefixes के लिए KV cache को स्वचालित रूप से पुन: उपयोग करता है। यह विशेष रूप से इनके लिए शक्तिशाली है:

• लंबे system prompts वाले chatbots

• बार-बार दोहराए जाने वाले context वाले RAG applications

• एक ही prefix साझा करने वाले Batch API calls

कोई अतिरिक्त configuration आवश्यक नहीं — यह हमेशा सक्षम रहता है।

2. KV Cache Size बढ़ाएँ

--mem-fraction-static 0.90  # KV cache के लिए VRAM का 90% उपयोग करें

बहुत अधिक न जाएँ — model weights के लिए जगह छोड़ें।

3. लंबे contexts के लिए Chunked Prefill

--chunked-prefill-size 4096  # लंबे prompts को chunks में process करें

4. FlashInfer Backend सक्षम करें

SGLang उपलब्ध होने पर FlashInfer का स्वचालित रूप से उपयोग करता है (Ampere+ GPUs):

--attention-backend flashinfer

5. Multi-GPU Tensor Parallelism

उन मॉडलों के लिए जो एक single GPU पर fit नहीं होते:

--tp 4  # 4 GPUs का उपयोग करें

प्रत्येक GPU के पास model के एक shard के लिए पर्याप्त VRAM होना चाहिए।

6. Throughput बनाम Latency के लिए Tune करें

कम latency (single user):

--max-running-requests 4

उच्च throughput (कई users):

--max-running-requests 64 \\
--schedule-policy lpm  # Longest Prefix Match scheduling

---

समस्या निवारण

समस्या: "torch.cuda.OutOfMemoryError"

torch.cuda.OutOfMemoryError: CUDA मेमोरी समाप्त

समाधान: मेमोरी fraction कम करें या quantization का उपयोग करें:

--mem-fraction-static 0.80
# या
--quantization awq

समस्या: Server शुरू नहीं होता (लोडिंग पर अटक जाता है)

# CUDA उपलब्धता जांचें
docker exec -it sglang nvidia-smi

# model download progress जांचें
docker logs -f sglang 2>&1 | tail -50

समस्या: "trust_remote_code required"

जोड़ें --trust-remote-code custom architectures (DeepSeek, Falcon, आदि) वाले मॉडलों के लिए launch command में।

समस्या: MoE models पर धीमी generation

MoE models (Mixtral, DeepSeek) memory-bandwidth bound होते हैं। सुनिश्चित करें कि आप उपयोग कर रहे हैं:

--dtype bfloat16  # MoE के लिए float16 से बेहतर
--tp 2            # उपलब्ध होने पर GPUs में विभाजित करें

समस्या: Context length errors

# context length override करें
--context-length 32768

समस्या: Port 30000 accessible नहीं है

सत्यापित करें कि port आपकी CLORE.AI order configuration में exposed है। अपने order dashboard में http_pub URL जांचें, localhost नहीं।

---

लिंक्स

• GitHub

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

• Docker Hub

• समर्थित मॉडल

• CLORE.AI मार्केटप्लेस

---

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
उत्पादन (7B–13B)	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
बड़े मॉडल (70B+)	A100 80GB / H100	~$1.04/gpu/hr

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.