गोपनीय बातचीत, अपने Qwen पर सुरक्षित रखें।

बाहरी AI में न डाली जा सकने वाली गोपनीय जानकारी: क्या ऐसा हो रहा है?

पता है कि AI से काम जल्दी होगा। पर यह बातचीत कंपनी से बाहर नहीं जा सकती।

बाहर नहीं भेज सकते, इसलिए AI इस्तेमाल नहीं करते। इन दो विकल्पों के बीच एक रास्ता है: "अपने सर्वर पर चलाना"।

* 1 और 2, व्याख्या वीडियो में बताए गए मामलों पर आधारित उदाहरण हैं (वीडियो में क्या कहा गया)।

असल में यह चाहिए था: गोपनीयता बनाए रखते हुए अपने Qwen पर

वही दस्तावेज़, वही मीटिंग। AI को सौंपें, फिर भी डेटा कंपनी से बाहर न जाए।

यहाँ तक का काम इस पेज के स्टेप और चेकलिस्ट से बन जाता है। मीटिंग के बाद के काम समेत बँटवारा कैसे करें, यह SIMY से संबंध में है।

लोकल LLM क्या है: Qwen को कंपनी के अंदर चलाने की वजह

लोकल LLM का मतलब है, सार्वजनिक रूप से जारी मॉडल के वेट्स को अपने PC या कंपनी के सर्वर पर चलाना। आपका डाला गया टेक्स्ट उस मशीन से बाहर नहीं जाता।

लोकल LLM से क्या-क्या कर सकते हैं

• गोपनीय दस्तावेज़ों का सारांश और ड्राफ़्ट: मीटिंग नोट्स, कॉन्ट्रैक्ट, डिज़ाइन डॉक्यूमेंट, ग्राहकों से बातचीत।
• अंदरूनी दस्तावेज़ों में खोज और सवाल-जवाब (RAG): कंपनी के नियम और प्रक्रिया-पुस्तिका पढ़ाकर सवालों के जवाब दिलवाना।
• अनुवाद और कोड में मदद: चीनी, अंग्रेज़ी और हिन्दी के बीच अनुवाद, अंदरूनी कोड की व्याख्या और सुधार के सुझाव।

छोटे मॉडल बड़े क्लाउड मॉडल जितने समझदार नहीं होते। इन्हें अंतिम वर्ज़न के बजाय "पहला ड्राफ़्ट" बनाने के लिए इस्तेमाल करें, तो उम्मीद और नतीजे में कम फ़र्क़ रहता है।

Qwen ही क्यों

• Apache 2.0 वाले मॉडल हैं
• कई भाषाएँ
• आकार चुन सकते हैं

• लाइसेंस: Qwen3 और Qwen3.8-27B जैसे कई मॉडल Apache 2.0 के तहत जारी हैं। लेकिन सभी नहीं (नीचे की तालिका देखें)।
• भाषाएँ: Qwen3 पीढ़ी की घोषणा में 119 भाषाओं और बोलियों के समर्थन का दावा है।
• आकार: PC पर चलने वाले 0.6B से 8B तक, क्वांटाइज़ करने पर एक GPU में समाने वाले 27B से 32B, और कई GPU माँगने वाले 235B तक।

हर मॉडल का लाइसेंस अलग है

तालिका को बगल में स्क्रॉल कर सकते हैं →

1 अक्टूबर 2026 को Hugging Face पर Qwen संगठन की मॉडल जानकारी से जाँचा गया। "Qwen है तो सब Apache 2.0" सही नहीं है। व्यावसायिक उपयोग से पहले, जिस मॉडल को इस्तेमाल करेंगे उसकी रिपॉज़िटरी की LICENSE फ़ाइल लीगल टीम के साथ जाँच लें।

इन्फ़रेंस इंजन का चुनाव: Ollama, llama.cpp, vLLM, SGLang, LM Studio

मॉडल को चलाने वाला सॉफ़्टवेयर "इन्फ़रेंस इंजन" कहलाता है। सुरक्षा के लिहाज़ से सबसे बड़ा फ़र्क़ यह है कि कुछ न बदलें तो वह कहाँ सुनता है।

तालिका को बगल में स्क्रॉल कर सकते हैं →

अक्टूबर 2026 तक हर इंजन के आधिकारिक डॉक्यूमेंटेशन (vLLM के लिए सोर्स कोड भी) से जाँचा गया। LM Studio की पंक्ति में जो पूरी तरह पुष्ट नहीं हो सका, वहाँ "आधिकारिक डॉक्यूमेंटेशन देखें" लिखा है।

• पहले जाँचें: llama.cpp या Ollama से देखें कि काम में फ़ायदा है या नहीं।
• पूरी कंपनी में इस्तेमाल: vLLM। बहुत से लोग एक साथ इस्तेमाल करें, तब भी रफ़्तार कम नहीं गिरती।
• एजेंट एक ही लंबा निर्देश बार-बार भेजें: SGLang।

vLLM पर ध्यान दें: आधिकारिक Security पेज बताता है कि --api-key सिर्फ़ /v1 जैसे हिस्सों को बचाता है, और /invocations या /pooling जैसे एंडपॉइंट इसके दायरे में नहीं आते। इसीलिए, जिन एंडपॉइंट को खोलना है सिर्फ़ उन्हें पास करने वाली रिवर्स प्रॉक्सी के पीछे रखना, आधिकारिक तौर पर भी सबसे असरदार उपाय माना गया है।

हार्डवेयर का अंदाज़ा: हर Qwen मॉडल के लिए ज़रूरी GPU मेमोरी

ज़रूरी GPU मेमोरी को तीन चीज़ों का जोड़ मानें।

• वेट्सपैरामीटर की संख्या × प्रति पैरामीटर बाइट (BF16 में 2, FP8 में 1, 4bit में लगभग 0.5)
• + KV कैशकॉन्टेक्स्ट की लंबाई × एक साथ इस्तेमाल करने वालों के अनुपात में
• + गुंजाइशचलते समय का वर्क एरिया

तालिका को बगल में स्क्रॉल कर सकते हैं →

Qwen3 के आँकड़े Qwen के आधिकारिक स्पीड बेंचमार्क से हैं (transformers में छोटा इनपुट प्रोसेस करने पर शुरुआत के तुरंत बाद की GPU मेमोरी)। Qwen3.8-27B की आधिकारिक तालिका नहीं है, इसलिए ये पैरामीटर संख्या से निकाला अंदाज़ा और एक व्यक्ति का माप है, KV कैश शामिल नहीं। क्वांटाइज़ेशन वर्ज़न और कॉन्टेक्स्ट की लंबाई से ज़रूरत काफ़ी बदलती है (अक्टूबर 2026 तक)।

• Qwen3.8-27B और 32GB GPU: BF16 में सिर्फ़ वेट्स लगभग 54GB (गणना से अंदाज़ा) हैं, इसलिए एक RTX 5090 (32GB) में नहीं समाते। आधिकारिक FP8 वर्ज़न के भी सिर्फ़ वेट्स लगभग 28.8GB हैं, और पूरा कॉन्टेक्स्ट लेने पर 32GB में न समाने का अनुमान बताया गया है। 4bit वर्ज़न लें या कॉन्टेक्स्ट की सीमा घटाएँ।
• 16GB के 2 GPU, 32GB के 1 GPU के बराबर नहीं: दो में बाँटने पर कार्डों के बीच का संचार और हर कार्ड पर ज़रूरी वर्क एरिया, नुक़सान बढ़ाते हैं।
• लंबे कॉन्टेक्स्ट में इंतज़ार बढ़ता है: एक व्यक्ति के माप में, लगभग 2.5 लाख टोकन के इनपुट पर पहला अक्षर आने में 4 मिनट से ज़्यादा लगे।
• Mac: Apple silicon मेमोरी को GPU के साथ साझा करता है। मॉडल फ़ाइल से काफ़ी ज़्यादा मेमोरी चाहिए।

आकार कैसे तय करें: पहले तय करें कि एक साथ कितने लोग इस्तेमाल करेंगे और एक बार में कितना लंबा दस्तावेज़ पढ़ाया जाएगा। KV कैश इन दोनों के अनुपात में बढ़ता है, इसलिए सिर्फ़ वेट्स के हिसाब से सोचेंगे तो प्रोडक्शन में मेमोरी कम पड़ेगी।

बंद नेटवर्क में सेटअप के स्टेप: Qwen + vLLM कंपनी के सर्वर पर

उदाहरण में Qwen3.8-27B का FP8 वर्ज़न, vLLM (Docker) और Linux सर्वर है। कमांड अक्टूबर 2026 के आधिकारिक डॉक्यूमेंटेशन के मुताबिक़ हैं। GPU मेमोरी कम पड़े तो कॉन्टेक्स्ट की सीमा (--max-model-len) घटाएँ या 4bit वर्ज़न चुनें।

* ढाँचा केवल समझाने के लिए एक उदाहरण है

कमांड कैसे पढ़ें: <जाँचा हुआ कमिट SHA> की तरह कोण-कोष्ठक वाले हिस्से अपनी कंपनी के मान से बदलें। वर्ज़न नंबर अक्टूबर 2026 के उदाहरण हैं।

1. वर्ज़न तय करके मॉडल डाउनलोड करें

   लाने वाला टर्मिनल (इंटरनेट की तरफ़)

   आधिकारिक Qwen/ संगठन की रिपॉज़िटरी से, कमिट तय करके डाउनलोड करें। इन्फ़रेंस इंजन का कंटेनर भी वर्ज़न तय करके सेव करें।

   bash

   pip install -U huggingface_hub
   hf download Qwen/Qwen3.8-27B-FP8 \
     --revision <जाँचा हुआ कमिट SHA> \
     --local-dir ./Qwen3.8-27B-FP8
   
   docker pull vllm/vllm-openai:v0.30.0
   docker inspect --format '{{index .RepoDigests 0}}' vllm/vllm-openai:v0.30.0
   docker save vllm/vllm-openai:v0.30.0 -o vllm-openai-v0.30.0.tar

   docker inspect जो डाइजेस्ट दिखाता है (sha256: से शुरू होने वाला मान), उसे रजिस्टर में लिख लें।

   वर्ज़न तय करने की वजह: एक ही रिपॉज़िटरी में नए रिवीज़न से अंदर की चीज़ें बदल सकती हैं। एक क्वांटाइज़्ड वर्ज़न में नए रिवीज़न से स्पेक्युलेटिव डिकोडिंग की लेयर (MTP) हटा दी गई और स्पीड-अप चलना बंद हो गया, ऐसा बताया गया है।

2. SHA-256 का रजिस्टर बनाएँ

   लाने वाला टर्मिनल

   Hugging Face API जो lfs.oid देता है, वह बड़ी फ़ाइलों (LFS) का SHA-256 है। इस मान को अपनी फ़ाइलों से मिलाएँ।

   bash

   # Hugging Face की तरफ़ के मान निकालें (सिर्फ़ LFS फ़ाइलें)
   curl -s "https://huggingface.co/api/models/Qwen/Qwen3.8-27B-FP8/tree/<जाँचा हुआ कमिट SHA>?recursive=true&expand=true" \
     | jq -r '.[] | select(.lfs) | "\(.lfs.oid)  ./\(.path)"' > HF.sha256
   
   # अपनी फ़ाइलों से मिलाएँ और सभी फ़ाइलों का रजिस्टर बनाएँ
   cd Qwen3.8-27B-FP8
   sha256sum -c ../HF.sha256
   find . -type f ! -path './.cache/*' -print0 | sort -z | xargs -0 sha256sum > ../MODEL.sha256
   cd .. && sha256sum vllm-openai-v0.30.0.tar > IMAGE.sha256

   रजिस्टर पर, डाउनलोड करने वाले से अलग कोई दूसरा ज़िम्मेदार व्यक्ति पुष्टि के हस्ताक्षर करे (हस्ताक्षर का तरीक़ा कंपनी के मानक के अनुसार)।

3. मीडिया से अंदर लाएँ, लोड करने से पहले जाँचें

   बंद नेटवर्क का सर्वर

   रजिस्टर और फ़ाइलें मीडिया से ले जाएँ और बंद नेटवर्क की तरफ़ फिर से मिलाएँ। एक भी पंक्ति में FAILED आए तो इस्तेमाल न करें।

   bash

   cd /srv/llm/models/Qwen3.8-27B-FP8 && sha256sum -c /srv/llm/incoming/MODEL.sha256
   cd /srv/llm/incoming && sha256sum -c IMAGE.sha256
   docker load -i vllm-openai-v0.30.0.tar

4. सिर्फ़ 127.0.0.1 पर सुनने के लिए चालू करें

   बंद नेटवर्क का सर्वर

   vLLM में --host छोड़ दें तो वह सभी इंटरफ़ेस पर सुनता है। --host 127.0.0.1 हमेशा लिखें, और की (key) फ़ाइल से दें (कमांड लाइन पर लिखेंगे तो ps में दिख जाएगी)।

   bash · vLLM (Docker)

   # की वाली फ़ाइल बनाएँ और अनुमति 600 करें
   sudo install -D -m 600 /dev/null /etc/llm/vllm.env
   echo "VLLM_API_KEY=$(openssl rand -hex 32)" | sudo tee /etc/llm/vllm.env > /dev/null
   
   sudo docker run -d --name qwen --gpus all --ipc=host --network host \
     -v /srv/llm/models:/models:ro \
     -e HF_HUB_OFFLINE=1 -e VLLM_NO_USAGE_STATS=1 -e DO_NOT_TRACK=1 \
     --env-file /etc/llm/vllm.env \
     vllm/vllm-openai:v0.30.0 \
     --model /models/Qwen3.8-27B-FP8 \
     --served-model-name qwen3.8-27b \
     --host 127.0.0.1 --port 8000 \
     --max-model-len 65536 --gpu-memory-utilization 0.90
   
   # पक्का करें कि सिर्फ़ 127.0.0.1:8000 पर सुन रहा है
   ss -ltnp | grep 8000

   • --trust-remote-code न लगाएँ। ताकि मॉडल के साथ आया कोड न चले।
   • VLLM_SERVER_DEV_MODE=1 प्रोडक्शन में इस्तेमाल न करें। इससे डेवलपमेंट वाले एंडपॉइंट खुल जाते हैं।
   • थिंकिंग मोड और टूल कॉल: Qwen के आधिकारिक डॉक्यूमेंटेशन में Qwen3 के उदाहरण के तौर पर --reasoning-parser qwen3 और --enable-auto-tool-choice --tool-call-parser hermes दिए गए हैं। 3.8 पीढ़ी के लिए क्या लिखना है, मॉडल कार्ड में देखें।
   bash · Ollama के लिए (systemd)

   sudo systemctl edit ollama
   # खुली फ़ाइल में नीचे की 3 पंक्तियाँ लिखकर सेव करें
   [Service]
   Environment="OLLAMA_HOST=127.0.0.1:11434"
   Environment="OLLAMA_NO_CLOUD=1"
   
   sudo systemctl restart ollama

   bash · SGLang और llama.cpp के लिए

   python3 -m sglang.launch_server --model-path /models/Qwen3.8-27B-FP8 \
     --host 127.0.0.1 --port 30000 --api-key <की> --admin-api-key <एडमिन की>
   
   llama-server -m /models/qwen.gguf --host 127.0.0.1 --port 8080 \
     --api-key-file /etc/llm/keys --offline --no-webui --jinja

   SGLang के उदाहरण में भी की सीधे न लिखें; असल में फ़ाइल या एनवायरनमेंट वेरिएबल से दें। मॉडल कार्ड के उदाहरण में --host 0.0.0.0 है, इसलिए उसे जस का तस कॉपी न करें।

5. nginx से TLS, अनुमति-सूची और ऑथेंटिकेशन लगाएँ

   बंद नेटवर्क का सर्वर (गेटवे)

   उपयोगकर्ता सिर्फ़ nginx तक पहुँचें। /v1 में से सिर्फ़ ज़रूरी एंडपॉइंट पास करें, बाक़ी पर 404 लौटाएँ।

   nginx

   server {
     listen 443 ssl;
     server_name llm.internal.example;
     ssl_certificate     /etc/pki/llm.crt;
     ssl_certificate_key /etc/pki/llm.key;
     ssl_protocols TLSv1.2 TLSv1.3;
   
     allow 10.20.0.0/16;   # सिर्फ़ अंदरूनी सेगमेंट
     deny  all;
   
     location = /v1/chat/completions {
       auth_request /_auth;
       auth_request_set $user $upstream_http_x_auth_request_user;
       proxy_set_header Authorization "Bearer <अपस्ट्रीम की>";
       proxy_pass http://127.0.0.1:8000;
       proxy_buffering off;   # स्ट्रीमिंग जवाब के लिए
     }
     location = /v1/models {
       auth_request /_auth;
       auth_request_set $user $upstream_http_x_auth_request_user;
       proxy_set_header Authorization "Bearer <अपस्ट्रीम की>";
       proxy_pass http://127.0.0.1:8000;
     }
     location = /_auth {
       internal;
       proxy_pass http://127.0.0.1:4180/oauth2/auth;   # oauth2-proxy आदि से कंपनी के IdP से जोड़ें
     }
     location / { return 404; }   # /metrics या /invocations जैसे एंडपॉइंट बाहर न दें
   }

   उपयोगकर्ता कंपनी के SSO (OIDC या SAML) से पहचान साबित करें, और अपस्ट्रीम API की उपयोगकर्ताओं को न बाँटें। auth_request nginx का मॉड्यूल है; आपके बिल्ड में है या नहीं, nginx -V से देख सकते हैं।

6. बाहर जाने वाला ट्रैफ़िक बंद करें

   बंद नेटवर्क का सर्वर

   सर्वर से इंटरनेट का सारा ट्रैफ़िक डिफ़ॉल्ट रूप से बंद करें। अनुमति सिर्फ़ अंदरूनी DNS, समय सिंक और लॉग सर्वर को।

   bash · ufw

   sudo ufw default deny incoming
   sudo ufw default deny outgoing
   sudo ufw allow in on <एडमिन IF> to any port 22 proto tcp    # पहले अनुमति न दी तो SSH कट जाएगा
   sudo ufw allow in on <अंदरूनी IF> to any port 443 proto tcp
   sudo ufw allow out to <अंदरूनी DNS> port 53 proto udp
   sudo ufw allow out to <अंदरूनी NTP> port 123 proto udp
   sudo ufw allow out to <लॉग सर्वर> port 514 proto tcp
   sudo ufw enable
   
   # पक्का करें कि बाहर नहीं जा सकते (फ़ेल हो तो सही है)
   curl -m 5 https://huggingface.co

   Docker के -p से पोर्ट खोलने पर Docker ख़ुद पैकेट के नियम जोड़ देता है, इसलिए ufw से बंद समझने के बावजूद बाहर से पहुँच सकते हैं। इन स्टेप में --network host और --host 127.0.0.1 से सुनना सिर्फ़ लोकल तक सीमित किया गया है।

   bash · -p इस्तेमाल करते समय

   # होस्ट की तरफ़ सिर्फ़ 127.0.0.1 पर खोलें (-p 8000:8000 सभी इंटरफ़ेस पर खोल देता है)
   sudo docker run -d --name qwen --gpus all --ipc=host \
     -p 127.0.0.1:8000:8000 \
     -v /srv/llm/models:/models:ro \
     -e HF_HUB_OFFLINE=1 -e VLLM_NO_USAGE_STATS=1 -e DO_NOT_TRACK=1 \
     --env-file /etc/llm/vllm.env \
     vllm/vllm-openai:v0.30.0 \
     --model /models/Qwen3.8-27B-FP8 --served-model-name qwen3.8-27b \
     --host 0.0.0.0 --port 8000 --max-model-len 65536
   # ↑ कंटेनर के अंदर 0.0.0.0 पर सुनता है, होस्ट की तरफ़ सिर्फ़ 127.0.0.1 पर दिखता है

   इस तरीक़े में कंटेनर के अंदर vLLM 0.0.0.0 पर सुनता है, पर होस्ट के बाहर से नहीं पहुँचा जा सकता। नेटवर्क के फ़ायरवॉल पर भी बाहर का ट्रैफ़िक बंद करें।

7. लॉग और ऑडिट रखें

   गेटवे, मॉनिटरिंग

   किसने, कब, कौन-सा एंडपॉइंट इस्तेमाल किया, यह nginx के लॉग में रखें और कंपनी के लॉग प्लेटफ़ॉर्म (SIEM आदि) पर भेजें। टोकन की गिनती, सिर्फ़ मॉनिटरिंग नेटवर्क पर खोले गए /metrics (Prometheus फ़ॉर्मेट) से करें।

   nginx · http { } के अंदर

   log_format llm '$time_iso8601 user=$user ip=$remote_addr "$request" '
                  'status=$status bytes=$body_bytes_sent rt=$request_time';
   access_log /var/log/nginx/llm.log llm;

   vLLM में --enable-log-requests चालू करके DEBUG लेवल रखें, तो प्रॉम्प्ट का पूरा टेक्स्ट लॉग में रहता है। टेक्स्ट रखना है या नहीं और कितने समय तक, यह निजी जानकारी और गोपनीयता के नियमों के हिसाब से तय करें।

8. उपयोगकर्ता और अनुमतियाँ तय करें

   स्क्रीन (Open WebUI आदि)

   स्क्रीन पर चैट से इस्तेमाल करना हो, तो Open WebUI जैसा फ़्रंटएंड उसी बंद नेटवर्क में रखें, और रोल व ग्रुप के हिसाब से इस्तेमाल होने वाले मॉडल बाँटें। नौकरी छोड़ने वालों की पहुँच कंपनी के IdP पर ही बंद हो, ऐसा रखें।

   env · Open WebUI

   OFFLINE_MODE=true
   ENABLE_SIGNUP=false
   DEFAULT_USER_ROLE=pending
   ENABLE_COMMUNITY_SHARING=false

   OFFLINE_MODE चालू करने पर, अगर एम्बेडिंग मॉडल पहले से नहीं डाला, तो दस्तावेज़ खोज (RAG) नहीं चलेगी। एम्बेडिंग मॉडल भी स्टेप 1 से 3 वाले तरीक़े से ही अंदर लाएँ।

9. अपडेट का तरीक़ा पहले से तय करें

   लाने वाला टर्मिनल → टेस्ट एनवायरनमेंट → प्रोडक्शन

   vLLM लगभग हर 2 हफ़्ते में रिलीज़ होता है, और लगभग हर बार सुरक्षा सुधार शामिल होते हैं। बंद नेटवर्क में भी "डाउनलोड → जाँच → रजिस्टर → प्रोडक्शन" के क्रम से नियमित अपडेट करें।

   bash

   # 1. नया वर्ज़न स्टेप 1 से 3 की तरह डाउनलोड करें, मिलाएँ और अंदर लाएँ
   # 2. टेस्ट एनवायरनमेंट में पुराने और नए वर्ज़न से एक ही सवाल पूछकर तुलना करें
   # 3. इस्तेमाल हो रहे एनवायरनमेंट वेरिएबल के नाम निकालें, और रिलीज़ नोट्स से मिलाएँ कि नए वर्ज़न में हटे तो नहीं
   sudo docker inspect --format '{{range .Config.Env}}{{println .}}{{end}}' qwen \
     | grep -E '^(VLLM_|HF_)' | cut -d= -f1
   # 4. प्रोडक्शन में डालने के बाद, किसने कब अपडेट किया और कब वापस किया, एक पंक्ति में दर्ज करें
   echo "$(date -I) vllm <पुराना वर्ज़न>→<नया वर्ज़न> ज़िम्मेदार:<नाम> जाँच:OK वापसी:<पुराना वर्ज़न>.tar" >> /srv/llm/CHANGELOG

   पिछले वर्ज़न का कंटेनर और मॉडल, डाइजेस्ट नोट करके रखें ताकि वापस जा सकें। कॉन्टेक्स्ट की सीमा जैसे, वर्ज़न के साथ बदलने वाले मान पहले और बाद में मिलाएँ।

लोकल LLM सुरक्षा चेकलिस्ट: प्रोडक्शन से पहले 20 पॉइंट

सेटअप से पहले और बाद में, ऊपर से क्रम से जाँचें। टिक सिर्फ़ इसी स्क्रीन पर काम करते हैं और कहीं नहीं भेजे जाते।

0 / 20 जाँचे गए

आम ग़लतियाँ: लोकल LLM में "मान लिया था" से बनने वाले छेद

बाईं तरफ़ आम ग़लती, दाईं तरफ़ इस पेज के स्टेप से उसका उपाय।

• --host 0.0.0.0 और ऑथेंटिकेशन नहींसैंपल की स्टार्ट कमांड जस की तस चलाकर पूरे LAN पर खोल देना।
  127.0.0.1 + nginxसुनना सिर्फ़ लोकल पर। उपयोगकर्ता गेटवे से होकर आते हैं।
• अनजान स्रोत का बदला हुआ वर्ज़न"Uncensored" जैसे कम्युनिटी GGUF, इतिहास जाँचे बिना इस्तेमाल करना।
  आधिकारिक Qwen/ से, SHA तय करकेतीसरे पक्ष का वर्ज़न लें तो बनाने वाला और तरीक़ा दर्ज करें।
• "api-key लगा दी, अब सुरक्षित"मान लेना कि vLLM की की सभी एंडपॉइंट को बचाती है।
  अनुमति-सूची से सीमित करेंसिर्फ़ /v1/chat/completions जैसे ज़रूरी एंडपॉइंट पास करें।
• "ऑन-प्रेम है, तो सुरक्षित"कंपनी के अंदर है, इसलिए अनुमतियाँ, लॉग और RAG का एक्सेस कंट्रोल छोड़ देना।
  अंदर भी, बाहर जैसा नियंत्रणSSO, रोल, लॉग, और देखने के अधिकार के हिसाब से खोज।
• टनल से बाहर से इस्तेमालअंदरूनी इस्तेमाल के लिए बना है, फिर भी Cloudflare Tunnel जैसे टूल से बाहर खोल देना।
  सिर्फ़ कंपनी के नेटवर्क सेबाहर से इस्तेमाल ज़रूरी हो तो कंपनी के आधिकारिक रिमोट कनेक्शन से।
• डिफ़ॉल्ट बाहरी ट्रैफ़िक पर ध्यान नहींvLLM के उपयोग के आँकड़े, Ollama डेस्कटॉप वर्ज़न का ऑटो-अपडेट।
  एनवायरनमेंट वेरिएबल और आउटबाउंड ब्लॉक, दोनोंसेटिंग से भी रोकें, फ़ायरवॉल से भी।
• छोटे मॉडल पर ज़रूरत से ज़्यादा भरोसाएजेंट या टूल कॉल में, न मौजूद फ़ाइलें या लिंक बना देना।
  पहले ड्राफ़्ट के रूप में इस्तेमालचलाना सैंडबॉक्स में, नतीजा इंसान जाँचे।
• अपडेट से टूटनावर्ज़न बढ़ाते ही हटे हुए एनवायरनमेंट वेरिएबल या बदली सीमा से बंद हो जाना।
  टेस्ट एनवायरनमेंट में पहले-बाद की तुलनारिलीज़ नोट्स से मिलाएँ, किसने अपडेट किया दर्ज करें।

वीडियो में क्या कहा गया: Qwen सेल्फ़-होस्टिंग के असली उदाहरण

फ़रवरी से अक्टूबर 2026 के बीच जारी अंग्रेज़ी, चीनी और जापानी के 18 व्याख्या वीडियो, उनकी ऑडियो ट्रांसक्रिप्ट तक जाँचे।

SIMY से संबंध: बंद नेटवर्क के अंदर Qwen, बाहर SIMY

साफ़-साफ़ बताते हैं। SIMY फ़िलहाल Qwen पर नहीं चलता, और बंद नेटवर्क के अंदर या ऑफ़लाइन भी नहीं चलता।

* बँटवारा केवल समझाने के लिए एक उदाहरण है

• मीटिंग और चैट से उठाता है
• आपके तरीक़े से
• सिर्फ़ फ़ैसला लौटाता है

गोपनीय टेक्स्ट, बंद नेटवर्क के Qwen पर संभालें। उसके बाद "कौन, कब तक, क्या करेगा" में से जितना कंपनी ने बाहर देने की अनुमति दी है, उतना SIMY कंपनी के अनुमति वाले टूल में आगे बढ़ाता है।

• SIMY कैसे चलता है: क्लाउड पर काम आपके ChatGPT अकाउंट (Codex) से चलता है। Codex का इस्तेमाल आपके ChatGPT प्लान के दायरे में होता है।
• PC पर चलाना: SIMY डेस्कटॉप ऐप, PC पर मौजूद Claude Code को काम करने वाले के रूप में इस्तेमाल कर सकता है। यहाँ से डाउनलोड करें।
• बातचीत का इतिहास पढ़ना: डेस्कटॉप ऐप Claude Code और Codex की बातचीत का इतिहास पढ़ता है, और बार-बार होने वाले काम को "SIMY का सुझाव" बनाता है। बातचीत का टेक्स्ट सर्वर पर सेव नहीं होता। कौन-से PC और कितना दायरा, यह कंपनी के नियमों से तय करें।

रेखा कहाँ खींचें: कौन-सी जानकारी बंद नेटवर्क में रहे और कहाँ से बाहरी टूल में संभाली जा सकती है, यह कंपनी के नियम तय करते हैं। SIMY डेटा कैसे संभालता है, यह सुरक्षा और गोपनीयता नीति में सार्वजनिक है।

लोकल LLM और Qwen: अक्सर पूछे जाने वाले सवाल

संदर्भ

स्टेप, डिफ़ॉल्ट सेटिंग और लाइसेंस, नीचे दी गई आधिकारिक जानकारी से जाँचे गए (जाँच की तारीख़: 1 अक्टूबर 2026)। वर्ज़न और डिफ़ॉल्ट मान अक्सर बदलते हैं, इसलिए सेटअप से पहले हर आधिकारिक पेज देख लें।

• Security (vLLM डॉक्यूमेंटेशन), Usage Stats Collection, vllm serve
• vLLM रिलीज़ नोट्स (GitHub)
• Server Arguments (SGLang डॉक्यूमेंटेशन)
• FAQ (Ollama डॉक्यूमेंटेशन)
• llama.cpp server README (GitHub)
• vLLM से डिप्लॉयमेंट (Qwen डॉक्यूमेंटेशन), Speed Benchmark (Qwen डॉक्यूमेंटेशन)
• Qwen (Hugging Face), Qwen3.8-27B मॉडल कार्ड
• Hugging Face CLI, एनवायरनमेंट वेरिएबल (Hugging Face Hub)
• ngx_http_auth_request_module (nginx डॉक्यूमेंटेशन), ngx_http_ssl_module
• Environment Variable Configuration (Open WebUI डॉक्यूमेंटेशन)
• Packet filtering and firewalls (Docker डॉक्यूमेंटेशन)
• qwen3.8 (Ollama लाइब्रेरी)