मुख्य कंटेंट तक स्किप करें

Ollama के साथ AI मॉडल लोकल पर चलाएँ

मध्यम

फ़्रंटियर मॉडल क्लाउड में रहते हैं, लेकिन ओपन-वेट मॉडलों की एक पूरी श्रेणी — Llama, Mistral, Qwen, DeepSeek, Gemma — को आप डाउनलोड करके अपने लैपटॉप या सर्वर पर चला सकते हैं। Ollama ऐसा करने का सबसे आसान तरीक़ा है: एक इंस्टॉल, एक कमांड, और एक मॉडल लोकल पर चलने लगता है। यह पेज आपको शून्य से एक चलते हुए मॉडल तक ले जाता है, उसे कोड से कॉल करना सिखाता है, और समझौतों (trade-offs) को बताता है ताकि आप 7B के लोकल मॉडल से फ़्रंटियर मॉडल जैसे व्यवहार की उम्मीद न करें।

What you'll learn
  • जानें कि मॉडल को लोकल पर क्यों चलाया जाए — और क्लाउड फ़्रंटियर मॉडलों की तुलना में ईमानदार समझौते क्या हैं
  • Ollama इंस्टॉल करें और दो कमांड में अपना पहला मॉडल चलाएँ
  • मुख्य CLI का उपयोग करें: pull, run, list, ps, rm, stop
  • Ollama के OpenAI-संगत API से कोड में अपने लोकल मॉडल को कॉल करें
  • RAM की ज़रूरत, मॉडल के आकार और क्वांटाइज़ेशन को समझें — ताकि आप ऐसा मॉडल चुनें जो आपकी मशीन सचमुच चला सके
  • जानें कि LM Studio (एक GUI) कब बेहतर शुरुआती बिंदु है

मॉडल को लोकल पर क्यों चलाएँ (और कब नहीं)​

अपने हार्डवेयर पर मॉडल चलाने से आपको चार चीज़ें मिलती हैं:

  • गोपनीयता — आपके प्रॉम्प्ट और डेटा कभी आपकी मशीन से बाहर नहीं जाते। यही वजह है कि नियंत्रित या संवेदनशील क्षेत्रों की टीमें लोकल मॉडल अपनाती हैं। (मॉडल कैसे चुनें में गोपनीयता/सेल्फ़-होस्ट वाला मोड़ देखें।)
  • ऑफ़लाइन — न इंटरनेट, न API, न आउटेज पर निर्भरता। मॉडल आपकी डिस्क पर एक फ़ाइल है।
  • लागत — प्रति-टोकन कोई बिल नहीं। एक बार डाउनलोड हो जाने के बाद उसे चलाना "मुफ़्त" है (आप बिजली और हार्डवेयर में भुगतान करते हैं, API ख़र्च में नहीं)। अगर बड़े पैमाने पर टोकन ख़र्च आपकी बाधा है, तो लोकल जीत सकता है।
  • नियंत्रण — एक सटीक संस्करण पिन करें, व्यवहार अनुकूलित करें, और रेट लिमिट या सेवा-शर्तों के झटकों के बिना इंटीग्रेट करें।

ईमानदार समझौते:

  • क्षमता का अंतर। जिस मॉडल को आप लैपटॉप पर चला सकते हैं (1B–14B पैरामीटर) वह कठिन तर्क, लंबे संदर्भ या एजेंटिक कामों में क्लाउड फ़्रंटियर मॉडल की बराबरी का नहीं है। कई रोज़मर्रा के कामों में अंतर छोटा है; सबसे कठिन कामों में बड़ा है।
  • हार्डवेयर। बड़े और अधिक सक्षम मॉडलों को एक सामान्य मशीन से ज़्यादा RAM/VRAM चाहिए। अक्सर आप अपने हार्डवेयर पर चल सकने वाला सबसे बड़ा मॉडल चुन रहे होते हैं, मौजूद सबसे अच्छा मॉडल नहीं।
  • संचालन आपको करना है। न मैनेज्ड स्केलिंग, न स्वचालित अपग्रेड — यही नियंत्रण की क़ीमत है।

एक आम और टिकाऊ पैटर्न: एक छोटे eval से प्रोटोटाइप बनाएँ और चुनें (क्लाउड मॉडलों वाली ही विधि — देखें मॉडल कैसे चुनें), निजी/ऑफ़लाइन/बड़े पैमाने पर सस्ते कामों के लिए लोकल का उपयोग करें, और जब काम को सचमुच अतिरिक्त क्षमता चाहिए हो तब फ़्रंटियर API तक पहुँचें।

Ollama इंस्टॉल करें और अपना पहला मॉडल चलाएँ​

Guided walkthrough1 of 4
  1. macOS और Windows: ollama.com/download से इंस्टॉलर डाउनलोड करके चलाएँ। Linux: आधिकारिक इंस्टॉल स्क्रिप्ट का उपयोग करें (नीचे)। इससे ollama कमांड और एक लोकल बैकग्राउंड सेवा इंस्टॉल होती है।

Linux पर इंस्टॉल (macOS/Windows पर इसके बजाय डाउनलोड किया गया इंस्टॉलर इस्तेमाल करें):

curl -fsSL https://ollama.com/install.sh | sh

एक छोटा मॉडल खींचें और चलाएँ (अच्छा पहला चुनाव)

ollama run gemma4:e2b

यह अकेली कमांड gemma4:e2b को डाउनलोड करती है — वह मॉडल जिससे Ollama की अपनी क्विकस्टार्ट शुरू होती है, यानी Gemma 4 का एज-आकार वाला संस्करण जिसमें ~2.3B प्रभावी पैरामीटर हैं और डिस्क पर कुछ GB जगह लगती है — और एक इंटरैक्टिव चैट शुरू कर देती है। अभी चैट किए बिना सिर्फ़ डाउनलोड करना हो तो इसके बजाय ollama pull का उपयोग करें।

मुख्य CLI​

मुट्ठी भर कमांड लगभग सब कुछ सँभाल लेती हैं। पूरी सूची के लिए ollama --help चलाएँ।

# Download a model without starting a chat
ollama pull qwen3

# Start an interactive chat (downloads first if needed)
ollama run qwen3

# One-shot: pass the prompt inline, get the answer, exit
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# List models you've downloaded
ollama list

# Show models currently loaded in memory
ollama ps

# Stop a running/loaded model (frees memory)
ollama stop qwen3

# Delete a downloaded model to reclaim disk
ollama rm qwen3

इंटरैक्टिव ollama run सत्र के अंदर, बाहर निकलने के लिए /bye और सत्र की कमांड देखने के लिए /? लिखें। जो बैकग्राउंड सेवा असल में मॉडल परोसती है वह ollama serve से शुरू होती है (डेस्कटॉप ऐप इसे आपके लिए अपने आप शुरू कर देता है)।

इसे कोड से कॉल करें (OpenAI-संगत API)​

यही वह हिस्सा है जो लोकल मॉडलों को ऐप्स में सचमुच उपयोगी बनाता है। Ollama की बैकग्राउंड सेवा http://localhost:11434 पर, डिफ़ॉल्ट पोर्ट 11434 पर, एक लोकल HTTP API उपलब्ध कराती है। इसके अपने नेटिव एंडपॉइंट (/api/generate, /api/chat) हैं और /v1 पर एक OpenAI-संगत परत भी — इसलिए OpenAI SDK के लिए लिखा गया ज़्यादातर कोड दो पंक्तियाँ बदलकर आपके लोकल मॉडल पर चल जाता है।

curl के साथ सीधा HTTP (नेटिव एंडपॉइंट):

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:e2b",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

आधिकारिक OpenAI SDK के साथ Python से — बस base_url को Ollama की ओर इंगित करें और कोई भी ग़ैर-ख़ाली api_key दें (Ollama को यह फ़ील्ड चाहिए पर वह इसका मान अनदेखा करता है):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="gemma4:e2b",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

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

क्योंकि यह OpenAI-संगत है, होस्टेड API पर जो पैटर्न आप इस्तेमाल करते वही यहाँ भी चलते हैं — स्ट्रीमिंग और टूल उपयोग / फ़ंक्शन कॉलिंग समेत, जो लोकल पर वैसे ही काम करते हैं जैसे क्लाउड में (बशर्ते मॉडल इसमें सचमुच अच्छा हो)। Ollama की /v1 परत /v1/chat/completions, /v1/completions, /v1/responses, /v1/models (और /v1/models/{model}) तथा /v1/embeddings को कवर करती है।

हार्डवेयर, मॉडल के आकार और क्वांटाइज़ेशन​

मॉडल के साथ जो संख्या दिखती है — 1B, 7B, 8B, 70B — वह उसकी पैरामीटर संख्या है (अरबों में)। ज़्यादा पैरामीटर का आम तौर पर मतलब है ज़्यादा सक्षम और ज़्यादा मेमोरी की भूख। आप क्या चला सकते हैं इसकी व्यावहारिक सीमा RAM है (और GPU पर VRAM)।

क्वांटाइज़ेशन वह मुख्य तरकीब है जो इसे सामान्य मशीनों पर संभव बनाती है। मॉडल के वेट मूल रूप से उच्च परिशुद्धता (जैसे 16-बिट) में संग्रहीत होते हैं, लेकिन उन्हें ~4-बिट तक संपीड़ित किया जा सकता है, जिसमें गुणवत्ता की हानि छोटी और अक्सर मुश्किल से दिखने वाली होती है। Ollama ज़्यादातर मॉडल डिफ़ॉल्ट रूप से क्वांटाइज़ किए हुए देता है — इसीलिए अरबों पैरामीटर वाला मॉडल कुछ GB में समा जाता है। एक मोटा अंगूठा-नियम (संबंधित मॉडल के पेज पर जाँच लें):

  • ~1B–3B मॉडल: ज़्यादातर आधुनिक लैपटॉप पर आराम से चलते हैं (कुछ GB RAM)।
  • ~7B–8B मॉडल: सक्षम और चलने-योग्य के बीच का सबसे अच्छा बिंदु; कई GB ख़ाली RAM रखें।
  • ~13B–14B मॉडल: काफ़ी अच्छे स्पेक वाली मशीन चाहिए।
  • ~70B+ मॉडल: बहुत सारी RAM वाला वर्कस्टेशन/सर्वर या दमदार GPU चाहिए — सामान्य लैपटॉप का इलाक़ा नहीं।

एक व्यावहारिक नुस्ख़ा: छोटे मॉडल (gemma4:e2b) से शुरू करें, वर्कफ़्लो को शुरू से अंत तक पक्का करें, फिर उस सबसे बड़े मॉडल तक बढ़ें जो आपके हार्डवेयर पर अब भी सहजता से चलता हो — मौजूद सबसे बड़े मॉडल तक नहीं।

लोकल मॉडलों की शब्दावली
कार्ड पलटने के लिए Enter या Space दबाएँ। कार्ड बदलने के लिए बाएँ और दाएँ तीर कुंजियों का उपयोग करें।शब्द दिखाया गया।
1 / 6

LM Studio: एक GUI विकल्प​

अगर कमांड लाइन आपके बस की नहीं है, तो LM Studio एक डेस्कटॉप ऐप (macOS, Windows, Linux) है जो वही काम ग्राफ़िकल इंटरफ़ेस से करता है: ओपन मॉडल ब्राउज़ और डाउनलोड करें, बिल्ट-इन UI में उनसे चैट करें, और — Ollama की तरह — एक लोकल OpenAI-संगत सर्वर चलाएँ ताकि आपका कोड उससे बात कर सके। जो डेवलपर नहीं हैं या टर्मिनल के बजाय पॉइंट-एंड-क्लिक पसंद करते हैं उनके लिए यह आसान शुरुआत है; जब आपको स्क्रिप्ट करने लायक़ CLI और हल्की बैकग्राउंड सेवा चाहिए, तो Ollama आम तौर पर बेहतर बैठता है। दोनों एक ही तरह के ओपन-वेट मॉडल चलाते हैं, इसलिए इस पेज की अवधारणाएँ सीधे लागू होती हैं।

ख़ुद जाँचें

0/4
  1. क्लाउड फ़्रंटियर मॉडल की तुलना में मॉडल को लोकल पर चलाने का सबसे बड़ा ईमानदार समझौता क्या है?
  2. कौन-सी कमांड मॉडल को (ज़रूरत हो तो) डाउनलोड करती है और उसके साथ चैट भी शुरू करती है?
  3. OpenAI-SDK कोड से अपने लोकल मॉडल को कॉल करने के लिए आप क्या सेट करते हैं?
  4. अरबों पैरामीटर वाला मॉडल सिर्फ़ कुछ GB RAM में कैसे समा सकता है?
Key takeaways
  • लोकल = गोपनीयता + ऑफ़लाइन + प्रति-टोकन कोई लागत नहीं + नियंत्रण; समझौता है क्षमता का वास्तविक अंतर और हार्डवेयर की सीमाएँ।
  • दो कमांड से आप चल पड़ते हैं: Ollama इंस्टॉल करें, फिर ollama run gemma4:e2b।
  • मुख्य CLI: pull (डाउनलोड), run (चैट), list, ps, stop, rm — ज़्यादातर काम इतने से हो जाता है।
  • OpenAI-संगत एंडपॉइंट से कोड में कॉल करें: base_url http://localhost:11434/v1, कोई भी ग़ैर-ख़ाली api_key।
  • पैरामीटर संख्या + क्वांटाइज़ेशन तय करते हैं कि आपकी मशीन मॉडल चला सकती है या नहीं — छोटे से शुरू करें, फिर उस आकार तक बढ़ें जो सहजता से चले।
  • GUI पसंद है? LM Studio वही काम पॉइंट-एंड-क्लिक से करता है और एक लोकल OpenAI-संगत सर्वर भी देता है।

स्रोत और आगे पढ़ने के लिए​

आगे​