# SGLang SGLang (Structured Generation Language) एक उच्च-प्रदर्शन LLM सर्विंग फ्रेमवर्क है जिसे LMSYS टीम ने विकसित किया है, जो Vicuna और Chatbot Arena पर अपने काम के लिए जानी जाती है। इसमें KV कैश साझा करने के लिए RadixAttention, कुशल MoE (Mixture of Experts) समर्थन, और OpenAI-संगत API शामिल है — जो इसे CLORE.AI GPU सर्वरों पर उपलब्ध सबसे तेज़ ओपन-सोर्स इनफरेंस इंजनों में से एक बनाता है। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | ------------ | -------------------------- | -------------------- | | रैम | 16 GB | 32 GB+ | | वीरैम (VRAM) | 8 GB | 24 GB+ | | डिस्क | 50 GB | 200 GB+ | | GPU | NVIDIA Turing+ (RTX 2000+) | A100, H100, RTX 4090 | {% hint style="info" %} SGLang Ampere+ GPUs पर FlashInfer सक्षम होने पर सर्वश्रेष्ठ प्रदर्शन प्राप्त करता है। Mixtral या DeepSeek जैसे MoE मॉडल के लिए मल्टी-GPU सेटअप की सिफारिश की जाती है। {% endhint %} ## CLORE.AI पर त्वरित तैनाती **Docker इमेज:** `lmsysorg/sglang:latest` **पोर्ट्स:** `22/tcp`, `30000/http` **पर्यावरण चर:** | वेरिएबल | उदाहरण | विवरण | | ---------------------- | ----------- | ------------------------------------ | | `HF_TOKEN` | `hf_xxx...` | गेटेड मॉडलों के लिए HuggingFace टोकन | | `CUDA_VISIBLE_DEVICES` | `0,1` | उपयोग करने के लिए GPUs | ## चरण-दर-चरण सेटअप ### 1. CLORE.AI पर एक GPU सर्वर किराए पर लें पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और एक सर्वर चुनें: * **7B मॉडल**: न्यूनतम 16 GB VRAM (RTX 4080, A10) * **13B मॉडल**: 24 GB VRAM (RTX 3090, RTX 4090, A5000) * **70B मॉडल**: 80 GB+ VRAM (A100 80GB) या मल्टी-GPU * **MoE मॉडल (Mixtral 8x7B)**: 48 GB VRAM या 2× 24 GB ### 2. अपने सर्वर में SSH करें ```bash ssh -p root@ ``` ### 3. SGLang Docker इमेज खींचें ```bash docker pull lmsysorg/sglang:latest ``` ### 4. SGLang सर्वर लॉन्च करें **बेसिक लॉन्च (Llama 3.1 8B):** ```bash 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 टोकन के साथ:** ```bash 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 ``` **Qwen2.5 72B मल्टी-GPU पर:** ```bash 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 मॉडल):** ```bash 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. सर्वर स्वास्थ्य जाँचें ```bash # लॉग देखें docker logs -f sglang # हेल्थ चेक (मॉडल लोड होने में ~2-3 मिनट प्रतीक्षा करें) curl http://localhost:30000/health # मॉडल जानकारी प्राप्त करें curl http://localhost:30000/get_model_info ``` ### 6. CLORE.AI प्रॉक्सी के माध्यम से बाहरी पहुँच आपके CLORE.AI डैशबोर्ड में एक प्रदान किया गया है `http_pub` पोर्ट 30000 के लिए URL: ``` https://-30000.clore.ai/ ``` किसी भी OpenAI-संगत क्लाइंट में इसका उपयोग अपने बेस URL के रूप में करें। *** ## उपयोग के उदाहरण ### उदाहरण 1: OpenAI-संगत चैट पूर्णताएँ ```bash 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": "You are a helpful coding assistant."}, {"role": "user", "content": "Write a quicksort implementation in Python."} ], "max_tokens": 512, "temperature": 0.2 }' ``` ### उदाहरण 2: स्ट्रीमिंग प्रतिक्रिया ```bash 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": "Explain how transformer attention works."} ], "max_tokens": 800, "stream": true }' \ --no-buffer ``` ### उदाहरण 3: Python OpenAI क्लाइंट ```python from openai import OpenAI # अपने CLORE.AI SGLang सर्वर की ओर संकेत करें client = OpenAI( base_url="http://localhost:30000/v1", api_key="none", # SGLang डिफ़ॉल्ट रूप से प्रमाणीकरण की आवश्यकता नहीं है ) response = client.chat.completions.create( model="meta-llama/Meta-Llama-3.1-8B-Instruct", messages=[ {"role": "system", "content": "You are a data science expert."}, {"role": "user", "content": "What is gradient boosting?"}, ], max_tokens=400, temperature=0.7, ) print(response.choices[0].message.content) ``` ### उदाहरण 4: SGLang नेटिव API के साथ बैच इनफेरेंस SGLang का नेटिव API अतिरिक्त नियंत्रण प्रदान करता है: ```python import requests # पूर्णताएँ जनरेट करें response = requests.post( "http://localhost:30000/generate", json={ "text": "The future of AI is", "sampling_params": { "max_new_tokens": 200, "temperature": 0.8, "top_p": 0.95, }, }, ) print(response.json()["text"]) ``` ### उदाहरण 5: प्रतिबंधित JSON आउटपुट SGLang संरचित आउटपुट जेनरेशन का समर्थन करता है: ```python 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": "Extract information: 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 मॉडल ID या स्थानीय पथ | | `--host` | `127.0.0.1` | हॉस्ट बाइंड करें (बाहरी के लिए उपयोग करें `0.0.0.0` के लिए बाहरी) | | `--port` | `30000` | सर्वर पोर्ट | | `--tp` | `1` | टेंसर पैरेललिज्म डिग्री (GPU की संख्या) | | `--dp` | `1` | डेटा पैरेललिज्म डिग्री | | `--dtype` | `auto` | `float16`, `bfloat16`, `float32` | | `--mem-fraction-static` | `0.88` | KV कैश के लिए VRAM का भाग | | `--max-prefill-tokens` | auto | एक प्रिफिल स्टेप में अधिकतम टोकन | | `--context-length` | मॉडल अधिकतम | अधिकतम संदर्भ लंबाई ओवरराइड करें | | `--trust-remote-code` | false | कस्टम मॉडल कोड की अनुमति दें | | `--quantization` | none | `awq`, `gptq`, `fp8` | | `--load-format` | `auto` | `auto`, `pt`, `safetensors` | | `--tokenizer-path` | मॉडल के समान | कस्टम टोकनाइज़र पथ | ### क्वांटाइज़ेशन विकल्प **AWQ (गति के लिए अनुशंसित):** ```bash 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 के लिए):** ```bash 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 स्वचालित रूप से साझा प्रॉम्प्ट प्रीफिक्स के लिए KV कैश का पुन: उपयोग करता है। यह विशेष रूप से शक्तिशाली है: * लंबे सिस्टम प्रॉम्प्ट वाले चैटबॉट्स के लिए * दोहराए गए संदर्भ वाले RAG एप्लिकेशन्स के लिए * एक ही प्रीफिक्स साझा करने वाले बैच API कॉल्स के लिए अतिरिक्त कोई कॉन्फ़िगरेशन आवश्यक नहीं — यह हमेशा सक्षम रहता है। ### 2. KV कैश आकार बढ़ाएँ ```bash --mem-fraction-static 0.90 # KV कैश के लिए VRAM का 90% उपयोग करें ``` बहुत अधिक न करें — मॉडल वज़न के लिए स्थान छोड़ें। ### 3. लंबे संदर्भों के लिए चंकीड प्रिफिल ```bash --chunked-prefill-size 4096 # लंबे प्रॉम्प्ट्स को चंक्स में प्रोसेस करें ``` ### 4. FlashInfer बैकएंड सक्षम करें यदि उपलब्ध हो (Ampere+ GPUs), तो SGLang स्वचालित रूप से FlashInfer का उपयोग करता है: ```bash --attention-backend flashinfer ``` ### 5. मल्टी-GPU टेंसर पैरेललिज्म उन मॉडलों के लिए जो एक ही GPU पर फिट नहीं होते: ```bash --tp 4 # 4 GPUs उपयोग करें ``` प्रत्येक GPU के पास मॉडल के एक शार्ड के लिए पर्याप्त VRAM होना चाहिए। ### 6. थ्रूपुट बनाम लेटेंसी के लिए ट्यून करें **कम विलंबता (एकल उपयोगकर्ता):** ```bash --max-running-requests 4 ``` **उच्च थ्रूपुट (कई उपयोगकर्ता):** ```bash --max-running-requests 64 \ --schedule-policy lpm # Longest Prefix Match शेड्यूलिंग ``` *** ## समस्या निवारण ### समस्या: "torch.cuda.OutOfMemoryError" ``` torch.cuda.OutOfMemoryError: CUDA आउट ऑफ मेमोरी ``` **समाधान:** मेमोरी फ़्रैक्शन घटाएँ या क्वांटाइज़ेशन का उपयोग करें: ```bash --mem-fraction-static 0.80 # या --quantization awq ``` ### समस्या: सर्वर शुरू नहीं हो रहा (लोडिंग पर अटक जाता है) ```bash # CUDA उपलब्धता जाँचें docker exec -it sglang nvidia-smi # मॉडल डाउनलोड प्रगति जाँचें docker logs -f sglang 2>&1 | tail -50 ``` ### समस्या: "trust\_remote\_code required" लॉन्च कमांड में जोड़ें `--trust-remote-code` उन मॉडलों के लिए जिनकी कस्टम आर्किटेक्चर हैं (DeepSeek, Falcon, आदि)। ### समस्या: MoE मॉडलों पर धीमी जनरेशन MoE मॉडल (Mixtral, DeepSeek) मेमोरी-बैंडविड्थ बंधित होते हैं। सुनिश्चित करें कि आप इस्तेमाल कर रहे हैं: ```bash --dtype bfloat16 # MoE के लिए float16 से बेहतर --tp 2 # उपलब्ध हो तो GPUs में विभाजित करें ``` ### समस्या: संदर्भ लंबाई त्रुटियाँ ```bash # संदर्भ लंबाई ओवरराइड करें --context-length 32768 ``` ### समस्या: पोर्ट 30000 सुलभ नहीं है सुनिश्चित करें कि पोर्ट आपके CLORE.AI ऑर्डर कॉन्फ़िगरेशन में एक्सपोज़ किया गया है। अपने ऑर्डर डैशबोर्ड में http\_pub URL जाँचें, localhost नहीं। *** ## लिंक * [GitHub](https://github.com/sgl-project/sglang) * [डॉक्यूमेंटेशन](https://sgl-project.github.io/start/install.html) * [Docker Hub](https://hub.docker.com/r/lmsysorg/sglang) * [समर्थित मॉडल](https://github.com/sgl-project/sglang?tab=readme-ov-file#supported-models) * [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) *** ## Clore.ai GPU सिफारिशें | उपयोग का मामला | अनुशंसित GPU | Clore.ai पर अनुमानित लागत | | ------------------ | ---------------- | ------------------------- | | डेवलपमेंट/टेस्टिंग | RTX 3090 (24GB) | \~$0.12/gpu/hr | | प्रोडक्शन (7B–13B) | RTX 4090 (24GB) | \~$0.70/gpu/hr | | बड़े मॉडल (70B+) | A100 80GB / H100 | \~$1.20/gpu/hr | > 💡 इस गाइड के सभी उदाहरणों को तैनात किया जा सकता है [Clore.ai](https://clore.ai/marketplace) GPU सर्वर पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।