GPT-OSS’u Yerelde Ollama ile Kurup Çalıştırma

GPT-OSS, OpenAI’nin ilk açık-ağırlıklı model serisidir ve doğrudan kendi bilgisayarınızda çalıştırabilirsiniz. Güçlü akıl yürütme, özdevinimli (agentic) görevler ve esnek geliştirici kullanım senaryoları için tasarlanan GPT-OSS, yapılandırılabilir akıl yürütme çabası ve şeffaf düşünce zinciri yetenekleriyle öne çıkıyor.

Bu eğitimde, OpenAI’nin GPT-OSS modellerini Ollama kullanarak yerelde kurma adımlarını anlatacağım ve modelin kendine özgü akıl yürütme yeteneklerini sergileyen etkileşimli bir demoyu nasıl inşa edeceğimizi göstereceğim. Modelin yapılandırılabilir düşünce zinciri özelliklerini keşfedecek ve modelin düşünme sürecini görselleştiren bir Streamlit uygulaması oluşturacağız.

Okurlarımızı yapay zekâdaki en son gelişmelerden haberdar etmek için The Median adlı, haftanın kritik haberlerini özetleyen ücretsiz Cuma bültenimizi gönderiyoruz. Abone olun ve haftada sadece birkaç dakikada güncel kalın:

OpenAI’nin GPT-OSS’u Nedir?

OpenAI’nin GPT-OSS serisi, GPT-2’den bu yana ilk açık-ağırlık sürümlerini işaret ediyor ve Apache 2.0 lisansı altında yüksek performanslı akıl yürütme modellerine erişim sağlıyor. Bu ileri seviye dil modelleri düşük maliyetle güçlü performans sunar ve akıl yürütme görevlerinde benzer boyuttaki açık modellere üstünlük sağlar.

İki varyant vardır: gpt-oss-120b ve gpt-oss-20b.

Kaynak: OpenAI

gpt-oss-120b

gpt-oss-120b, OpenAI’nin amiral gemisi açık-ağırlık modelidir ve zorlu akıl yürütme kıyaslamalarında o4‑mini gibi tescilli sistemlerle yarışır. 117 milyar parametre boyutuna rağmen, tek bir 80 GB GPU üzerinde çalışacak şekilde optimize edilmiştir. Bu da onu güçlü dil modellerini yerelde barındırmak isteyen araştırma laboratuvarları ve kurumsal ekipler için gerçekçi bir seçenek yapar.

Model; araç kullanımı, çok adımlı akıl yürütme ve her göreve ne kadar “düşünme” çabası harcayacağını ince ayarla kontrol etme gibi karmaşık iş akışlarını desteklemek üzere tasarlanmıştır. Açık-ağırlık yapısı ve Apache 2.0 lisansı, modeli derinlemesine incelemek, özelleştirmek veya ince ayar yapmak isteyen ekipler için esnek bir seçim sunar.

gpt-oss-20b

gpt-oss-20b, tüketici dizüstülerine sığacak bir ayak izine şaşırtıcı bir akıl yürütme gücü sığdırıyor. Toplam yalnızca 21 milyar parametreyle, bazı kıyaslamalarda OpenAI’nin o3-mini modelini dahi geride bırakır ve 16 GB belleğe sahip cihazlarda verimli biçimde çalışır. Kantizasyon uygulanmış, hızlı yerel dağıtım için hazırdır ve Ollama, vLLM ve hatta Apple’ın Metal platformu gibi araçlarla uyumludur.

Bu model, bulut altyapısına bağımlı olmadan duyarlı ve mahremiyeti koruyan yapay zekâ uygulamaları geliştirmek isteyen geliştiriciler için idealdir. Büyük kardeşi gibi, ayarlanabilir akıl yürütme derinliği ve net ara adımları destekler—deneyler, hafif asistanlar ve uç cihaz uygulamaları için harikadır.

Neden GPT-OSS’u Yerelde Çalıştırmalı?

GPT-OSS’u yerelde çalıştırmak, bulut tabanlı alternatiflere göre çeşitli güçlü avantajlar sunar:

• Gizlilik ve kontrol: Tüm çıkarım işlemleri donanımınızda gerçekleşir; yani harici bağımlılıklar, kesintiler veya API değişiklikleri yoktur ve yalnızca nihai yanıtlara değil, modelin iç akıl yürütmesine de tam erişim elde edersiniz.
• Performans: Yerel modeller, anında yanıtlar için ağ gecikmesini ortadan kaldırır, sınırsız kullanım (oran veya token sınırı yok) sunar ve 7/24 erişilebilirliği garanti eder.
• Maliyet tasarrufu: Model bir kere indirilir ve kurulur; abonelik ücreti yoktur ve kullanıcı mevcut hesaplama kaynaklarını sürekli API maliyeti olmadan kullanabilir.
• Şeffaf akıl yürütme: Kullanıcı, hız ile derinlik arasında denge kurmak için düşük, orta ve yüksek “çaba” modları arasında geçiş yapabilir ve tam düşünce zincirini inceleyebilir.
• Özelleştirilebilirlik ve genişletilebilirlik: Açık-ağırlık modelleri, belirli görevlerimize göre ince ayarlayabilir, örnekleme parametrelerini değiştirebilir ve özdevinimli araçları sorunsuzca entegre edebiliriz.

GPT-OSS’u Ollama ile Yerelde Kurma

Ollama, indirme, kantizasyon ve yürütmeyi üstlenerek büyük dil modellerini yerelde çalıştırmayı son derece basitleştirir. Sizi adım adım sisteminizde GPT-OSS kurulumunda yönlendireceğim. Sonunda uygulamamız şöyle görünecek:

Adım 1: Ollama’yı kurun

Önce Ollama’yı resmî web sitesinden indirin ve kurun.

Kurulum tamamlandıktan sonra bir terminal açıp şunu yazarak kurulumu doğrulayabilirsiniz:

ollama --versionAltyapı:

Bu komut, sisteminizde yüklü en yeni Ollama sürümünü döndürecektir.

Adım 2: GPT-OSS modellerini indirin

OpenAI, farklı kullanım senaryoları için optimize edilmiş iki GPT-OSS varyantı sağlar; ancak bu demo kapsamında yalnızca gpt-oss-20b varyantını çekeceğiz:

# For production and high reasoning tasks 
ollama pull gpt-oss:120b
# For lower latency and local deployment 
ollama pull gpt-oss:20bAltyapı:

20B model; yerel geliştirme için idealdir ve 16GB+ belleğe sahip sistemlerde çalışabilir; 120B model ise daha fazla yetenek sunar ancak 80GB+ bellek gerektirir.

Adım 3: Kurulumu test edin

Her şeyin doğru çalıştığını doğrulayalım:

ollama run gpt-oss:20bAltyapı:

Modelle doğrudan etkileşime geçebileceğiniz bir istem görmelisiniz. Şunu sormayı deneyin: "√2 irrasyoneldir, kanıtlayın."

GPT-OSS’u Yerelde Kullanma: Etkileşimli Sohbet Botu

Şimdi GPT-OSS’un akıl yürütme yeteneklerini sergileyen basit bir uygulamayı hızla oluşturalım. Uygulamamız şu özelliklere sahip olacak:

• Etkileşimli akıl yürütme kontrolleri
• Düşünce zinciri görselleştirmesi
• Performans izleme
• Sohbet geçmişi

Adım 1: Bağımlılıkları kurun

Gerekli bağımlılıkları kurmak için aşağıdaki komutları çalıştırın:

pip install streamlit ollamaAltyapı:

Yukarıdaki kod parçacığı, web arayüzünü kurmak için Streamlit’i ve yerel GPT-OSS modeliyle etkileşim için Ollama Python istemcisini yükler.

Adım 2: Kütüphaneleri içe aktarın ve sayfayı ayarlayın

Çekirdek sohbet mantığına dalmadan önce tüm araçları içe aktarmamız ve kullanıcı arayüzümüzü kurmamız gerekiyor.

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)Altyapı:

Web arayüzü için Streamlit, yerel GPT-OSS modelini çağırmak için Ollama ve json, time, typing ve re gibi yardımcı modüller dâhil birkaç temel paketi içe aktarıyoruz. Ardından sayfaya bir başlık, geniş düzen ve simge vermek için st.set_page_config() kullanıyor ve akıl yürütme adımları ile yanıtların farklı panellerde görünmesi için hafif bir CSS enjekte ediyoruz.

Adım 3: Çekirdek model entegrasyonu

Arayüz iskeletimiz hazırken, şimdi çekirdek model entegrasyonu olan call_model() fonksiyonunu oluşturalım:

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
        }Altyapı:

Yukarıdaki kod şunları yapar:

• Çok turlu bağlamı kolayca koruyabilmek için (sistem + kullanıcı) sohbet mesajları listesini kabul eder.
• Kullanıcıya yanıt sürelerini raporlamak için ollama.chat() çağrısının etrafında start_time ve end_time değerlerini kaydeder.
• Ollama istemcisinden gelen yanıtları, ham metin çıktısını çıkararak normalize eder.
• Son olarak call_model() fonksiyonu, hataları yakalamak için tüm çağrıyı bir try/except bloğuna alır.

Adım 4: Düşünce zinciri ayrıştırıcısı

Demomuzu gerçekten şeffaf kılmak için modelin “iç monoloğunu” nihai kararından ayırmamız gerekiyor. parse_reasoning_response() fonksiyonu tam olarak bunu yapar:

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
    }Altyapı:

Kullanıcıların isteğe bağlı olarak her akıl yürütme adımını inceleyebilmesi için modelin gizli “düşüncesini” nihai kararından ayırıyoruz. Yanıt şu şekilde ayrıştırılır:

• Açık işaretleyicileri arama: Önce düzenli ifadelerle <thinking>…</thinking> etiketleri veya “Reasoning:” ve “Let me think through” gibi ifadeler aranır.
• Çıkarma ve temizleme: Eşleşme bulunduğunda, o kısım akıl yürütme olarak alınır ve geri kalanı yanıt olarak değerlendirilir.
• Sezgisel geri dönüş: Etiket yoksa ama çıktı çok satırlıysa, (“therefore”, “in conclusion”, “final answer” veya “Answer:”) gibi sonuç anahtar kelimeleri taranır ve oradan bölünür.
• Çıktı: Biçim ne olursa olsun, parse_reasoning_response() fonksiyonu her zaman bir yanıt döndürür.

Adım 5: Tamamlanmış Streamlit uygulaması

Artık her yapı taşını oluşturduğumuza göre, sırada bunları etkileşimli bir sohbet uygulamasında bir araya getirmek var. 

# 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)Altyapı:

Bu son adımda, oturum durumu, kenar çubuğu kontrolleri, örnek istemler, mesaj oluşturma, model çağrısı, ayrıştırma ve gösterimi tek bir döngüde bir araya getiriyoruz:

1. Oturum durumu başlatma: st.session_state.history kullanarak yeniden çalıştırmalar arasında her kullanıcı–asistan etkileşimini hatırlarız.
2. Kenar çubuğu yapılandırması: Bu yapılandırma, kullanıcıların seçim yapmasına olanak tanır
• Model: gpt-oss:20b veya gpt-oss:120b
• Akıl Yürütme Çabası: düşük/orta/yüksek
• Sıcaklık (Temperature): 0 ile 2.0 arasında; modelin rastgeleliğini kontrol eder
• Düşünce Zinciri anahtarı: Modelin iç akıl yürütmesini gösterip gizlemek için
• Sohbeti temizle: Geçmişi siler ve uygulamayı yeniden başlatır
3. Örnek istemler ve girdi: Başlangıç soruları içeren bir açılır menü yeni kullanıcıların uyum sağlamasına yardımcı olur; kullanıcının seçtiği (veya yazdığı) şey metin alanındaki sorgu olur.
4. İsteği oluşturma: Ask GPT-OSS tıklandığında şunları yaparız:
• Seçilen çaba düzeyine göre bir sistem istemi oluştururuz.
• Bağlamı korumak için geçmişten son altı mesajı ekleriz.
• Yeni kullanıcı sorusunu ekleriz.
5. Model çağrısı: call_model() fonksiyonunu kullanırız; bu fonksiyon:
• Oluşturulan mesajları Ollama’ya gönderir
• Yanıt süresini ölçer
• Normalize edilmiş bir içerik dizesi döndürür
6. Ayrıştırma ve gösterim: parse_reasoning_response() fonksiyonunu kullanarak model çıktısını “akıl yürütme” adı verilen bir düşünce zinciri yanıtına ve “yanıt” adı verilen temizlenmiş bir çıktıya ayırırız.
7. Geçmiş yönetimi: Her soru–yanıt çifti st.session_state.history listesine eklenir; böylece bir sonraki çalıştırmada bağlam için dâhil edilir.

Kendiniz denemek için kodu gpt_oss_demo.py olarak kaydedin ve şunu başlatın:

streamlit run gpt_oss_demo.pyAltyapı: