Ollama के साथ GPT-OSS को लोकल रूप से कैसे सेटअप और चलाएँ

GPT-OSS OpenAI की पहली ओपन-वेट मॉडल श्रृंखला है, और आप इसे सीधे अपने कंप्यूटर पर चला सकते हैं। शक्तिशाली तर्क, एजेंटिक कार्यों और लचीले डेवलपर उपयोग मामलों के लिए डिज़ाइन किया गया, GPT-OSS अपने कॉन्फ़िगरेबल रीज़निंग प्रयास और पारदर्शी चेन-ऑफ-थॉट क्षमताओं के लिए अलग पहचान रखता है।

इस ट्यूटोरियल में, मैं आपको Ollama का उपयोग करके OpenAI के GPT-OSS मॉडलों को लोकल रूप से सेटअप करने की प्रक्रिया दिखाऊँगा और यह भी बताऊँगा कि मॉडल की अनोखी रीज़निंग क्षमताएँ प्रदर्शित करने के लिए एक इंटरैक्टिव डेमो कैसे बनता है। हम मॉडल की कॉन्फ़िगरेबल चेन-ऑफ-थॉट विशेषताओं का पता लगाएंगे और एक Streamlit एप्लिकेशन बनाएँगे जो मॉडल की सोच प्रक्रिया को विज़ुअलाइज़ करता है।

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

OpenAI का GPT-OSS क्या है?

OpenAI की GPT-OSS श्रृंखला GPT-2 के बाद उनकी पहली ओपन-वेट रिलीज़ है, जो Apache 2.0 लाइसेंस के तहत उच्च-प्रदर्शन रीज़निंग मॉडलों तक पहुँच देती है। ये अत्याधुनिक भाषा मॉडल कम लागत पर मज़बूत प्रदर्शन देते हैं और रीज़निंग कार्यों पर समान आकार के ओपन मॉडलों से बेहतर साबित होते हैं।

दो वेरिएंट उपलब्ध हैं: gpt-oss-120b और gpt-oss-20b।

स्रोत: OpenAI

gpt-oss-120b

gpt-oss-120b OpenAI का फ़्लैगशिप ओपन-वेट मॉडल है, जिसका प्रदर्शन o4‑mini जैसे स्वामित्व वाले सिस्टमों टक्कर का है, खासकर कठिन रीज़निंग बेंचमार्क्स पर। 117 बिलियन पैरामीटर होने के बावजूद, यह एक 80 GB GPU पर चलने के लिए अनुकूलित है। इससे यह शोध लैब्स और एंटरप्राइज़ टीमों के लिए लोकल रूप से शक्तिशाली भाषा मॉडल होस्ट करने का यथार्थ विकल्प बनता है।

मॉडल टूल यूज़, मल्टी-स्टेप रीज़निंग, और हर कार्य पर लगाए जाने वाले “सोच” के प्रयास पर सूक्ष्म नियंत्रण जैसे जटिल वर्कफ़्लो का समर्थन करता है। इसका ओपन-वेट स्वरूप और Apache 2.0 लाइसेंस उन टीमों के लिए इसे लचीला विकल्प बनाते हैं जो मॉडल का गहन निरीक्षण, कस्टमाइज़ या फाइन-ट्यून करना चाहती हैं।

gpt-oss-20b

gpt-oss-20b आश्चर्यजनक रीज़निंग क्षमता को ऐसे फ़ुटप्रिंट में समेटता है जो कंज़्यूमर लैपटॉप्स पर फिट बैठता है। कुल 21 बिलियन पैरामीटर के साथ भी, यह OpenAI के o3-mini को कुछ बेंचमार्क्स पर पीछे छोड़ देता है और 16 GB मेमोरी वाले डिवाइसेज़ पर कुशलता से चलता है। यह क्वांटाइज़ किया हुआ है और तेज़ लोकल डिप्लॉयमेंट के लिए तैयार है, और Ollama, vLLM और यहाँ तक कि Apple के Metal प्लेटफ़ॉर्म जैसे टूल्स के साथ संगत है।

यह मॉडल उन डेवलपर्स के लिए आदर्श है जो क्लाउड इन्फ्रास्ट्रक्चर पर निर्भर हुए बिना उत्तरदायी, निजी AI ऐप्स बनाना चाहते हैं। अपने बड़े समकक्ष की तरह, यह समायोज्य रीज़निंग गहराई और स्पष्ट इंटरमीडिएट स्टेप्स का समर्थन करता है—प्रयोगों, हल्के असिस्टेंट्स और एज डिवाइस एप्लिकेशनों के लिए बेहतरीन।

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

GPT-OSS को लोकल रूप से चलाने से क्लाउड-आधारित विकल्पों की तुलना में कई ठोस फायदे मिलते हैं:

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

Ollama के साथ GPT-OSS को लोकल रूप से सेटअप करना

Ollama डाउनलोड, क्वांटाइज़ेशन और निष्पादन संभालकर बड़े भाषा मॉडलों को लोकल रूप से चलाना बेहद सरल बना देता है। मैं आपको आपके सिस्टम पर GPT-OSS सेटअप करने के चरणों से गुज़ारूँगा। अंत में हमारा ऐप कुछ इस तरह दिखेगा:

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

सबसे पहले, Ollama को आधिकारिक वेबसाइट से डाउनलोड और इंस्टॉल करें।

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

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

यह आपके सिस्टम पर इंस्टॉल हुई Ollama की नवीनतम वर्ज़न लौटाएगा।

चरण 2: GPT-OSS मॉडल डाउनलोड करें

OpenAI विभिन्न उपयोग मामलों के लिए अनुकूलित दो GPT-OSS वेरिएंट प्रदान करता है, लेकिन इस डेमो के लिए हम केवल gpt-oss-20b मॉडल वेरिएंट पुल करेंगे:

# For production and high reasoning tasks 
ollama pull gpt-oss:120b
# For lower latency and local deployment 
ollama pull gpt-oss:20bसंचालित द्वारा

20B मॉडल लोकल डेवलपमेंट के लिए बिल्कुल उपयुक्त है और 16GB+ मेमोरी वाले सिस्टम पर चल सकता है, जबकि 120B मॉडल अधिक क्षमताएँ देता है पर 80GB+ मेमोरी की आवश्यकता होती है।

चरण 3: इंस्टॉलेशन जाँचें

आइए सत्यापित करें कि सबकुछ ठीक से काम कर रहा है:

ollama run gpt-oss:20bसंचालित द्वारा

आपको एक प्रॉम्प्ट दिखेगा जहाँ आप सीधे मॉडल से बातचीत कर सकते हैं। यह प्रश्न आज़माएँ: "साबित करें कि √2 अवाज्ञेय (irrational) है।"

GPT-OSS का लोकल उपयोग: इंटरैक्टिव चैटबॉट

अब एक सरल ऐप तेज़ी से बनाते हैं जो GPT-OSS की रीज़निंग क्षमताएँ दिखाएगा। हमारे एप्लिकेशन में ये फीचर्स होंगे:

• इंटरैक्टिव रीज़निंग कंट्रोल्स
• चेन-ऑफ-थॉट विज़ुअलाइज़ेशन
• परफॉर्मेंस मॉनिटरिंग
• कन्वर्सेशन हिस्ट्री

चरण 1: डिपेंडेंसीज़ इंस्टॉल करें

आवश्यक डिपेंडेंसीज़ इंस्टॉल करने के लिए निम्न कमांड चलाएँ:

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

ऊपर दिया स्निपेट वेब इंटरफ़ेस बनाने के लिए Streamlit और लोकल GPT-OSS मॉडल के साथ इंटरैक्शन हेतु Ollama Python क्लाइंट इंस्टॉल करता है।

चरण 2: लाइब्रेरीज़ इम्पोर्ट करें और पेज सेट करें

कोर चैट लॉजिक में जाने से पहले, हमें सभी टूल्स लाने और यूज़र इंटरफ़ेस सेट करने की ज़रूरत है।

import streamlit as st
import json
import ollama
import time
from typing import Dict, Any, List
import re
from datetime import datetime

# Configure page
st.set_page_config(
    page_title="GPT-OSS Chat Demo", 
    layout="wide",
    page_icon="💬"
)
# Custom CSS for UI
st.markdown("""
<style>
.reasoning-box {
    background-
    
    
    border-radius: 10px;
    border-left: 4px solid #00d4aa;
    
}
.answer-box {
    background-
    
    border-radius: 10px;
    border-left: 4px solid #007bff;
    
}
.metric-card {
    background-
    
    border-radius: 10px;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    text-align: center;
    
}
.chat-message {
    
    
    border-radius: 10px;
}
.user-message {
    background-
    border-left: 4px solid #2196f3;
}
.assistant-message {
    background-
    border-left: 4px solid #9c27b0;
}
</style>
""", unsafe_allow_html=True)संचालित द्वारा

हम कुछ कोर पैकेज इम्पोर्ट करते हैं: वेब इंटरफ़ेस के लिए Streamlit, लोकल GPT-OSS मॉडल को कॉल करने के लिए Ollama, और यूटिलिटी मॉड्यूल्स जैसे json, time, typing और re। फिर हम st.set_page_config() का उपयोग कर पेज को एक शीर्षक, वाइड लेआउट और एक आइकन देते हैं, और हल्का CSS इंजेक्ट करते हैं ताकि रीज़निंग स्टेप्स और उत्तर अलग-अलग पैनलों में दिखें।

चरण 3: कोर मॉडल इंटीग्रेशन

हमारा UI तैयार होने के बाद, अब call_model() फ़ंक्शन बनाकर कोर मॉडल इंटीग्रेशन तैयार करते हैं:

def call_model(messages: List[Dict], model_name: str = "gpt-oss:20b", temperature: float = 1.0) -> Dict[str, Any]:
    try:
        start_time = time.time()        
        # Prepare options for Ollama
        options = {
            'temperature': temperature,
            'top_p': 1.0,
        }        
        response = ollama.chat(
            model=model_name, 
            messages=messages,
            options=options
        )
        end_time = time.time()        
        if isinstance(response, dict) and 'message' in response:
            content = response['message'].get('content', '')
        elif hasattr(response, 'message'):
            content = getattr(response.message, 'content', '')
        else:
            content = str(response)         
        return {
            'content': content, 
            'response_time': end_time - start_time, 
            'success': True
        }
    except Exception as e:
        return {
            'content': f"Error: {e}", 
            'response_time': 0, 
            'success': False
        }संचालित द्वारा

ऊपर दिया कोड:

• चैट संदेशों (सिस्टम + यूज़र) की सूची लेता है, ताकि मल्टी-टर्न संदर्भ आसानी से बना रहे।
• ollama.chat() कॉल के इर्द-गिर्द start_time और end_time रिकॉर्ड करता है ताकि उपयोगकर्ता को प्रतिक्रिया समय बताया जा सके।
• Ollama क्लाइंट से आने वाले उत्तरों को सामान्यीकृत करता है और कच्चा टेक्स्ट आउटपुट निकालता है।
• अंत में, call_model() फ़ंक्शन पूरे कॉल को try/except ब्लॉक में लपेटता है ताकि त्रुटियाँ पकड़ी जा सकें।

चरण 4: चेन-ऑफ-थॉट पार्सर

डेमो को सचमुच पारदर्शी बनाने के लिए, हमें मॉडल के “अंदरूनी संवाद” को उसके अंतिम निष्कर्ष से अलग करना होगा। parse_reasoning_response() फ़ंक्शन यही करता है:

def parse_reasoning_response(content: str) -> Dict[str, str]:
    patterns = [
        r"<thinking>(.*?)</thinking>",
        r"Let me think.*?:(.*?)(?=\n\n|\nFinal|Answer:)",
        r"Reasoning:(.*?)(?=\n\n|\nAnswer:|\nConclusion:)",
    ]
    reasoning = ""
    answer = content    
    for pat in patterns:
        m = re.search(pat, content, re.DOTALL | re.IGNORECASE)
        if m:
            reasoning = m.group(1).strip()
            answer = content.replace(m.group(0), "").strip()
            break    
    if not reasoning and len(content.split('\n')) > 3:
        lines = content.split('\n')
        for i, l in enumerate(lines):
            if any(k in l.lower() for k in ['therefore', 'in conclusion', 'final answer', 'answer:']):
                reasoning = '\n'.join(lines[:i]).strip()
                answer = '\n'.join(lines[i:]).strip()
                break
    return {
        'reasoning': reasoning or "No explicit reasoning detected.", 
        'answer': answer or content
    }संचालित द्वारा

हम मॉडल की छिपी “सोच” को उसके अंतिम निष्कर्ष से अलग करते हैं ताकि उपयोगकर्ता चाहें तो हर रीज़निंग स्टेप देख सकें। उत्तर को इस प्रकार पार्स किया जाता है:

• स्पष्ट संकेतकों की तलाश: पहले <thinking>…</thinking> टैग्स या “Reasoning:” और “Let me think through” जैसी पंक्तियाँ रेगुलर एक्सप्रेशन से तलाशते हैं।
• निकालना और साफ़ करना: मैच मिलने पर वह हिस्सा रीज़निंग बन जाता है, और बाकी को उत्तर माना जाता है।
• हीयूरिस्टिक फ़ॉलबैक: यदि टैग्स नहीं हैं पर आउटपुट कई लाइनों में है, तो “therefore”, “in conclusion”, “final answer” या “Answer:” जैसे निष्कर्ष शब्द ढूँढकर वहीं विभाजन करते हैं।
• आउटपुट: फ़ॉर्मैट चाहे जैसा हो, parse_reasoning_response() हमेशा एक उत्तर लौटाता है।

चरण 5: पूर्ण Streamlit एप्लिकेशन

अब जब हमने ऐप के हर हिस्से को बना लिया है, तो उन्हें एक इंटरैक्टिव चैट ऐप में जोड़ते हैं। 

# Initialize history
if 'history' not in st.session_state:
    st.session_state.history = []
# Sidebar for settings
with st.sidebar:
    st.header("Configuration")    
    model_choice = st.selectbox(
        "Model", 
        ["gpt-oss:20b", "gpt-oss:120b"],
        help="Choose between 20B (faster) or 120B (more capable)"
    )    
    effort = st.selectbox(
        "Reasoning Effort", 
        ["low", "medium", "high"], 
        index=1,
        help="Controls depth of reasoning shown"
    )    
    temperature = st.slider(
        "Temperature", 
        0.0, 2.0, 1.0, 0.1,
        help="Controls response randomness"
    )    
    show_reasoning = st.checkbox(
        "Show Chain-of-Thought", 
        True,
        help="Display model's thinking process"
    )    
    show_metrics = st.checkbox(
        "Show Performance Metrics",
        True,
        help="Display response time and model info"
    )    
    st.markdown("---")        
    if st.button("Clear Conversation"):
        st.session_state.history = []
        st.rerun()  
# Main Chat Interface
st.title("💬 GPT-OSS Interactive Chat")
examples = [
    "",
    "If a train travels 120km in 1.5 hours, then 80km in 45 minutes, what's its average speed?",
    "Prove that √2 is irrational.",
    "Write a function to find the longest palindromic substring.",
    "Explain quantum entanglement in simple terms.",
    "How would you design a recommendation system?",
]
selected_from_dropdown = st.selectbox("Choose from examples:", examples)
# Get the question text
question_value = ""
if hasattr(st.session_state, 'selected_example'):
    question_value = st.session_state.selected_example
    del st.session_state.selected_example
elif selected_from_dropdown:
    question_value = selected_from_dropdown
question = st.text_area(
    "Or Enter your question:", 
    value=question_value, 
    height=100,
    placeholder="Ask anything! Try different reasoning effort levels to see how the model's thinking changes..."
)
# Submit button
col1, col2 = st.columns([1, 4])
with col1:
    submit_button = st.button("Ask GPT-OSS", type="primary")
if submit_button and question.strip():
    # System prompts 
    system_prompts = {
        'low': 'You are a helpful assistant. Provide concise, direct answers.',
        'medium': f'You are a helpful assistant. Show brief reasoning before your answer. Reasoning effort: {effort}',
        'high': f'You are a helpful assistant. Show complete chain-of-thought reasoning step by step. Think through the problem carefully before providing your final answer. Reasoning effort: {effort}'
    }    
    # Message history
    msgs = [{'role': 'system', 'content': system_prompts[effort]}]    
    msgs.extend(st.session_state.history[-6:])
    msgs.append({'role': 'user', 'content': question})    
    with st.spinner(f"GPT-OSS thinking ({effort} effort)..."):
        res = call_model(msgs, model_choice, temperature)
    if res['success']:
        parsed = parse_reasoning_response(res['content'])        
        st.session_state.history.append({'role': 'user', 'content': question})
        st.session_state.history.append({'role': 'assistant', 'content': res['content']})        
        col1, col2 = st.columns([3, 1] if show_metrics else [1])        
        with col1:
            if show_reasoning and parsed['reasoning'] != 'No explicit reasoning detected.':
                st.markdown("### Chain-of-Thought Reasoning")
                st.markdown(f"<div class='reasoning-box'>{parsed['reasoning']}</div>", unsafe_allow_html=True)            
            st.markdown("### Answer")
            st.markdown(f"<div class='answer-box'>{parsed['answer']}</div>", unsafe_allow_html=True)       
        if show_metrics:
            with col2:
                st.markdown(f"""
                <div class="metric-card">
                    <h4> Metrics</h4>
                    <p><strong>Time:</strong><br>{res['response_time']:.2f}s</p>
                    <p><strong>Model:</strong><br>{model_choice}</p>
                    <p><strong>Effort:</strong><br>{effort.title()}</p>
                </div>
                """, unsafe_allow_html=True)
    else:
        st.error(f"{res['content']}")
if st.session_state.history:
    st.markdown("---")
    st.subheader("Conversation History")    
    recent_history = st.session_state.history[-8:]  # Last 8 messages (4 exchanges)    
    for i, msg in enumerate(recent_history):
        if msg['role'] == 'user':
            st.markdown(f"""
            <div class="chat-message user-message">
                <strong>You:</strong> {msg['content']}
            </div>
            """, unsafe_allow_html=True)
        else:
            parsed_hist = parse_reasoning_response(msg['content'])
            with st.expander(f"GPT-OSS Response", expanded=False):
                if parsed_hist['reasoning'] != 'No explicit reasoning detected.':
                    st.markdown("**Reasoning Process:**")
                    st.code(parsed_hist['reasoning'], language='text')
                st.markdown("**Final Answer:**")
                st.markdown(parsed_hist['answer'])
# Footer
st.markdown("---")
st.markdown("""
<div style='text-align: center;'>
    <p><strong>Powered by GPT-OSS-20B via Ollama</strong></p>
</div>
""", unsafe_allow_html=True)संचालित द्वारा

इस अंतिम चरण में, हम अपने ऐप के सभी हिस्सों—सेशन स्टेट, साइडबार कंट्रोल्स, उदाहरण प्रॉम्प्ट्स, मैसेज असेंबली, मॉडल इनवोकेशन, पार्सिंग और डिस्प्ले—को एक ही लूप में जोड़ते हैं:

1. सेशन स्टेट इनिशियलाइज़ेशन: हम st.session_state.history का उपयोग हर यूज़र–असिस्टेंट एक्सचेंज को रिरन्स के बीच याद रखने के लिए करते हैं।
2. साइडबार कॉन्फ़िगरेशन: यह कॉन्फ़िगरेशन उपयोगकर्ताओं को चुनने देता है
• मॉडल: gpt-oss:20b या gpt-oss:120b
• रीज़निंग प्रयास: low/medium/high
• टेम्परेचर: 0 से 2.0 तक, जो मॉडल की रैंडमनेस नियंत्रित करता है
• चेन-ऑफ-थॉट टॉगल: मॉडल की आंतरिक रीज़निंग दिखाने या छिपाने के लिए
• कन्वर्सेशन साफ़ करें: यह हिस्ट्री मिटाकर ऐप पुनः आरंभ करता है
3. उदाहरण प्रॉम्प्ट्स और इनपुट: स्टार्टर प्रश्नों का ड्रॉपडाउन नए उपयोगकर्ताओं की ऑनबोर्डिंग में मदद करता है, और उपयोगकर्ता जो भी चुनता (या टाइप करता) है, वही टेक्स्ट एरिया में उसकी क्वेरी बन जाता है।
4. रिक्वेस्ट बनाना: Ask GPT-OSS क्लिक होने पर, हम:
• चुने गए प्रयास स्तर के आधार पर एक सिस्टम प्रॉम्प्ट बनाते हैं।
• संदर्भ बनाए रखने के लिए हिस्ट्री से अंतिम छह संदेश जोड़ते हैं।
• नया यूज़र प्रश्न जोड़ते हैं।
5. मॉडल इनवोकेशन: हम call_model() फ़ंक्शन का उपयोग करते हैं, जो:
• असेंबल किए गए संदेश Ollama को भेजता है
• प्रतिक्रिया समय मापता है
• एक सामान्यीकृत कंटेंट स्ट्रिंग लौटाता है
6. पार्सिंग और डिस्प्ले: parse_reasoning_response() फ़ंक्शन से हम मॉडल के आउटपुट को “reasoning” नाम की चेन-ऑफ-थॉट प्रतिक्रिया और “answer” नाम के साफ़-सुथरे उत्तर में बाँटते हैं।
7. हिस्ट्री प्रबंधन: हर प्रश्न और उत्तर को st.session_state.history सूची में जोड़ दिया जाता है, ताकि अगली रन में संदर्भ के लिए वे शामिल रहें।

इसे स्वयं आज़माने के लिए, कोड को gpt_oss_demo.py नाम से सेव करें और यह कमांड चलाएँ:

streamlit run gpt_oss_demo.pyसंचालित द्वारा