Ollama के साथ Qwen 3 को लोकल रूप से सेट अप और चलाएँ

Qwen3 अलीबाबा की नवीनतम पीढ़ी की ओपन-वेट बड़े भाषा मॉडल श्रृंखला है। 100+ भाषाओं के समर्थन और तर्क-वितर्क, कोडिंग व अनुवाद कार्यों में मजबूत प्रदर्शन के साथ, Qwen3 आज उपलब्ध कई शीर्ष-स्तरीय मॉडलों—जैसे DeepSeek-R1, o3-mini, और Gemini 2.5—की टक्कर देता है।

इस ट्यूटोरियल में, मैं चरण-दर-चरण समझाऊँगा कि Qwen3 को लोकल रूप से कैसे चलाएँ, वह भी Ollama का उपयोग करके।

हम Qwen3 के साथ एक हल्का-फुल्का लोकल एप भी बनाएँगे। यह ऐप आपको Qwen3 के reasoning मोड्स के बीच स्विच करने और अलग-अलग भाषाओं के बीच अनुवाद करने में सक्षम करेगा।

हम अपने पाठकों को AI की ताज़ा हलचलों से अपडेट रखते हैं The Median के माध्यम से—यह हमारा मुफ़्त शुक्रवार न्यूज़लेटर है जो हफ्ते की अहम खबरों को संक्षेप में समझाता है। सब्सक्राइब करें और हफ्ते में कुछ ही मिनटों में अपडेट रहें:

Qwen3 को लोकल रूप से क्यों चलाएँ?

Qwen3 को लोकल रूप से चलाने के कई मुख्य लाभ हैं:

• गोपनीयता: आपका डेटा आपकी मशीन से बाहर नहीं जाता।
• विलंबता: बिना API राउंड-ट्रिप के लोकल इन्फरेंस तेज़ होता है।
• लागत-कुशलता: न टोकन चार्ज, न क्लाउड बिल।
• नियंत्रण: आप अपने प्रॉम्प्ट ट्यून कर सकते हैं, मॉडल चुन सकते हैं, और थिंकिंग मोड्स कॉन्फ़िगर कर सकते हैं।
• ऑफ़लाइन एक्सेस: मॉडल डाउनलोड करने के बाद आप इंटरनेट कनेक्शन के बिना काम कर सकते हैं।

Qwen3 को गहन तर्क (thinking मोड) और तेज़ प्रतिक्रियाओं (non-thinking मोड) दोनों के लिए अनुकूलित किया गया है, और यह 100+ भाषाओं को सपोर्ट करता है। आइए इसे लोकल रूप से सेट अप करें।

Ollama के साथ Qwen3 को लोकल रूप से सेट करना

Ollama एक टूल है जो आपको Llama या Qwen जैसे भाषा मॉडलों को आपके कंप्यूटर पर सरल कमांड-लाइन इंटरफ़ेस के ज़रिए लोकल रूप से चलाने देता है।

चरण 1: Ollama इंस्टॉल करें

macOS, Windows, या Linux के लिए Ollama यहाँ से डाउनलोड करें: https://ollama.com/download.

इंस्टॉलर के निर्देशों का पालन करें, और इंस्टॉलेशन के बाद टर्मिनल में यह चलाकर जाँच लें:

ollama --versionसंचालित द्वारा

चरण 2: Qwen3 डाउनलोड करें और चलाएँ

Ollama विभिन्न हार्डवेयर कॉन्फ़िगरेशन—हल्के लैपटॉप से लेकर हाई-एंड सर्वर तक—के लिए अनुकूलित बढ़ती हुई Qwen3 मॉडल श्रृंखला उपलब्ध कराता है।

ollama run qwen3संचालित द्वारा

उपरोक्त कमांड चलाने से Ollama में डिफ़ॉल्ट Qwen3 मॉडल लॉन्च होगा, जो फिलहाल qwen3:8b पर डिफ़ॉल्ट करता है। यदि आपके संसाधन सीमित हैं या आप तेज़ स्टार्टअप चाहते हैं, तो आप स्पष्ट रूप से 4B जैसे छोटे वेरिएंट चला सकते हैं:

ollama run qwen3:4bसंचालित द्वारा

Qwen3 इस समय कई वेरिएंट्स में उपलब्ध है, सबसे छोटे 0.6b (523MB) से लेकर सबसे बड़े 235b (142GB) पैरामीटर मॉडलों तक। ये छोटे वेरिएंट भी तर्क, अनुवाद और कोड जेनरेशन में प्रभावशाली प्रदर्शन देते हैं, खासकर thinking मोड में।

MoE मॉडल (30b-a3b, 235b-a22b) विशेष रूप से रोचक हैं क्योंकि वे हर इन्फरेंस स्टेप में केवल कुछ विशेषज्ञों को सक्रिय करते हैं—इससे कुल पैरामीटर बहुत बड़े हो सकते हैं, जबकि रनटाइम लागत कुशल बनी रहती है।

सामान्यत: वही सबसे बड़ा मॉडल चुनें जिसे आपका हार्डवेयर संभाल सके, और उपभोक्ता मशीनों पर उत्तरदायी लोकल प्रयोगों के लिए 8B या 4B पर वापस आएँ।

यहाँ उन सभी Qwen3 मॉडलों का त्वरित सारांश है जिन्हें आप चला सकते हैं:

चरण 3: Qwen3 को बैकग्राउंड में चलाएँ (वैकल्पिक)

मॉडल को API के माध्यम से सर्व करने के लिए, टर्मिनल में यह कमांड चलाएँ:

ollama serveसंचालित द्वारा

यह मॉडल को अन्य एप्लिकेशंस के साथ एकीकृत करने के लिए उपलब्ध करा देगा इस पते पर: http://localhost:11434.

Qwen3 को लोकल रूप से उपयोग करना

इस खंड में, मैं आपको दिखाऊँगा कि Qwen3 को लोकल रूप से कैसे उपयोग करें—बेसिक CLI इंटरैक्शन से लेकर Python इंटीग्रेशन तक।

विकल्प 1: CLI के माध्यम से इन्फरेंस चलाना

मॉडल डाउनलोड होने के बाद, आप सीधे टर्मिनल में Qwen3 से बातचीत कर सकते हैं। अपने टर्मिनल में यह कमांड चलाएँ:

echo "What is the capital of Brazil? /think" | ollama run qwen3:8bसंचालित द्वारा

यह त्वरित परीक्षणों या बिना कोड लिखे हल्की-फुल्की बातचीत के लिए उपयोगी है। प्रॉम्प्ट के अंत का /think टैग मॉडल को गहरे, चरण-दर-चरण तर्क में लगने का निर्देश देता है। आप इसे /no_think से बदलकर तेज़, सतही प्रतिक्रिया पा सकते हैं, या डिफ़ॉल्ट तर्क मोड के लिए इसे बिल्कुल हटा सकते हैं।

विकल्प 2: API के माध्यम से Qwen3 तक पहुँच

जब ollama serve बैकग्राउंड में चल रहा हो, तो आप HTTP API के ज़रिए प्रोग्रामेटिक रूप से Qwen3 से बातचीत कर सकते हैं—यह बैकएंड इंटीग्रेशन, ऑटोमेशन, या REST क्लाइंट्स की टेस्टिंग के लिए उपयुक्त है।

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{ "role": "user", "content": "Define entropy in physics. /think" }],
  "stream": false
}'संचालित द्वारा

यह ऐसे काम करता है:

• curl लोकल Ollama सर्वर (localhost:11434) को POST अनुरोध भेजता है (यानी हम API को कॉल करते हैं)।
• पेलोड एक JSON ऑब्जेक्ट है, जिसमें:
• "model": उपयोग करने वाला मॉडल निर्दिष्ट करता है (यहाँ: qwen3:8b).
• "messages": role और content वाले चैट संदेशों की सूची।
• "stream": false: सुनिश्चित करता है कि प्रतिक्रिया एक साथ लौटे, टोकन-बाय-टोकन नहीं।

विकल्प 3: Python के माध्यम से Qwen3 तक पहुँच

यदि आप Python वातावरण (जैसे Jupyter, VSCode, या स्क्रिप्ट) में काम कर रहे हैं, तो Qwen3 के साथ इंटरैक्ट करने का सबसे आसान तरीका है Ollama Python SDK। पहले ollama इंस्टॉल करें:

pip install ollamaसंचालित द्वारा

उसके बाद, इस स्क्रिप्ट से अपना Qwen3 मॉडल चलाएँ (हम नीचे qwen3:8b उपयोग कर रहे हैं):

import ollama
response = ollama.chat(
    model="qwen3:8b",
    messages=[
        {"role": "user", "content": "Summarize the theory of evolution. /think"}
    ]
)
print(response["message"]["content"])संचालित द्वारा

ऊपर दिए गए कोड में:

• ollama.chat(...) लोकल Ollama सर्वर को चैट-स्टाइल अनुरोध भेजता है।
• आप मॉडल (qwen3:8b) और संदेशों की सूची निर्दिष्ट करते हैं, जो OpenAI के API जैसे फ़ॉर्मेट में होती है।
• /think टैग मॉडल को चरण-दर-चरण तर्क करने को कहता है।
• अंत में, प्रतिक्रिया एक डिक्शनरी के रूप में लौटती है, और आप ["message"]["content"] से मॉडल का उत्तर एक्सेस कर सकते हैं।

यह तरीका लोकल प्रयोग, प्रोटोटाइपिंग, या क्लाउड APIs पर निर्भर हुए बिना LLM-समर्थित ऐप बनाने के लिए आदर्श है।

Qwen3 के साथ लोकल reasoning ऐप बनाना

Qwen3 हाइब्रिड इन्फरेंस व्यवहार सपोर्ट करता है: /think (गहन तर्क) और /no_think (तेज़ प्रतिक्रिया) टैग्स। इस खंड में, हम Gradio का प्रयोग कर एक इंटरैक्टिव लोकल वेब ऐप बनाएँगे, जिसमें दो टैब होंगे:

1. एक reasoning इंटरफ़ेस जो thinking मोड्स के बीच स्विच करे।
2. एक बहुभाषी इंटरफ़ेस जो अलग-अलग भाषाओं में टेक्स्ट का अनुवाद/प्रोसेस करे।

चरण 1: हाइब्रिड reasoning डेमो 

इस चरण में, हम /think और /no_think टैग्स के साथ अपना हाइब्रिड reasoning टैब बनाएँगे।

import gradio as gr
import subprocess
def reasoning_qwen3(prompt, mode):
    prompt_with_mode = f"{prompt} /{mode}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt_with_mode.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
reasoning_ui = gr.Interface(
    fn=reasoning_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Radio(["think", "no_think"], label="Reasoning Mode", value="think")
    ],
    outputs="text",
    title="Qwen3 Reasoning Mode Demo",
    description="Switch between /think and /no_think to control response depth."
)संचालित द्वारा

ऊपर दिए गए कोड में:

• फ़ंक्शन reasoning_qwen3() एक यूज़र प्रॉम्प्ट और reasoning मोड ("think" या "no_think") लेता है।
• यह चुने गए मोड को प्रॉम्प्ट के अंत में जोड़ता है।
• फिर subprocess.run() ollama run qwen3:8b कमांड चलाता है और प्रॉम्प्ट को standard input के रूप में देता है।
• अंततः आउटपुट (Qwen3 की प्रतिक्रिया) कैप्चर कर डिकोड किए हुए स्ट्रिंग के रूप में लौटाया जाता है।

आउटपुट जनरेट करने वाले फ़ंक्शन की परिभाषा के बाद, gr.Interface() इसे एक इंटरैक्टिव वेब UI में रैप करता है—इनपुट कंपोनेंट के तौर पर Textbox (प्रॉम्प्ट के लिए) और Radio बटन (reasoning मोड चुनने के लिए) निर्दिष्ट कर, और उन्हें फ़ंक्शन के इनपुट्स से मैप कर देता है।

चरण 2: बहुभाषी एप्लिकेशन डेमो

अब, अपना बहुभाषी एप्लिकेशन टैब सेट अप करते हैं।

import gradio as gr
import subprocess
def multilingual_qwen3(prompt, lang):
    if lang != "English":
        prompt = f"Translate to {lang}: {prompt}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
multilingual_ui = gr.Interface(
    fn=multilingual_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Dropdown(["English", "French", "Hindi", "Chinese"], label="Target Language", value="English")
    ],
    outputs="text",
    title="Qwen3 Multilingual Translator",
    description="Use Qwen3 locally to translate prompts to different languages."
)संचालित द्वारा

पिछले चरण की तरह, यह कोड इस प्रकार काम करता है:

• फ़ंक्शन multilingual_qwen3() एक प्रॉम्प्ट और टार्गेट भाषा लेता है।
• यदि टार्गेट अंग्रेज़ी नहीं है, तो यह निर्देश “Translate to {lang}:” प्रीपेंड कर मॉडल को मार्गदर्शन देता है।
• फिर मॉडल Ollama के जरिए subprocess में लोकल रूप से चलता है।
• परिणाम सादा टेक्स्ट के रूप में लौटता है।

चरण 3: Gradio में दोनों टैब लॉन्च करें

आइए दोनों टैब्स को एक Gradio एप्लिकेशन में साथ लाएँ।

demo = gr.TabbedInterface(
    [reasoning_ui, multilingual_ui],
    tab_names=["Reasoning Mode", "Multilingual"]
)
demo.launch(debug = True)संचालित द्वारा

ऊपर दिए गए कोड में हम यह कर रहे हैं:

• gr.TabbedInterface() दो टैब वाला UI बनाता है:
• एक reasoning गहराई नियंत्रित करने के लिए।
• दूसरा बहुभाषी प्रॉम्प्ट अनुवाद के लिए।
• demo.launch(debug=True) ऐप को लोकल रूप से चलाता है और ब्राउज़र में डिबगिंग सक्षम करके खोलता है।

निष्कर्ष

Qwen3 उन्नत तर्क, तेज़ डिकोडिंग, और बहुभाषी समर्थन को Ollama के माध्यम से आपकी लोकल मशीन पर लाता है।

कम-से-कम सेटअप के साथ, आप यह कर सकते हैं:

• क्लाउड पर निर्भर हुए बिना लोकल LLM इन्फरेंस चलाएँ
• तेज़ और विचारपूर्ण प्रतिक्रियाओं के बीच स्विच करें
• APIs या Python का उपयोग कर बुद्धिमान एप्लिकेशंस बनाएँ

Qwen3 के बारे में और जानने के लिए, मैं सलाह दूँगा:

• इस परिचयात्मक ब्लॉग को पढ़ें: Qwen3
• सीखें कि Qwen3 को फाइन-ट्यून कैसे करें