Cara Menyiapkan dan Menjalankan GPT-OSS Secara Lokal dengan Ollama

GPT-OSS adalah seri model open-weight pertama dari OpenAI, dan Anda dapat menjalankannya langsung di komputer Anda sendiri. Dirancang untuk penalaran yang kuat, tugas agen, dan kasus penggunaan pengembang yang fleksibel, GPT-OSS menonjol karena upaya penalaran yang dapat dikonfigurasi dan kemampuan chain-of-thought yang transparan.

Dalam tutorial ini, saya akan memandu Anda menyiapkan model GPT-OSS OpenAI secara lokal menggunakan Ollama dan menunjukkan cara membangun demo interaktif yang menampilkan kemampuan penalaran unik model tersebut. Kita akan mengeksplorasi fitur chain-of-thought yang dapat dikonfigurasi dan membangun aplikasi Streamlit yang memvisualisasikan proses berpikir model.

Kami terus memperbarui pembaca tentang perkembangan terbaru AI melalui The Median, buletin gratis setiap Jumat yang merangkum berita-berita utama pekan ini. Berlangganan dan tetap up-to-date hanya dalam beberapa menit setiap minggu:

Apa Itu GPT-OSS dari OpenAI?

Seri GPT-OSS dari OpenAI menandai rilis open-weight pertama mereka sejak GPT-2, yang memberikan akses ke model penalaran berkinerja tinggi di bawah lisensi Apache 2.0. Model bahasa mutakhir ini memberikan kinerja kuat dengan biaya rendah dan mengungguli model open-source berukuran serupa pada tugas penalaran.

Ada dua varian: gpt-oss-120b dan gpt-oss-20b.

Sumber: OpenAI

gpt-oss-120b

gpt-oss-120b adalah model open-weight unggulan OpenAI, dengan performa yang menyaingi sistem proprieter seperti o4‑mini pada tolok ukur penalaran yang sulit. Meskipun berukuran 117 miliar parameter, model ini dioptimalkan untuk berjalan pada satu GPU 80 GB. Ini membuatnya realistis untuk laboratorium riset dan tim perusahaan yang ingin meng-host model bahasa yang kuat secara lokal.

Model ini dirancang untuk mendukung alur kerja kompleks seperti penggunaan alat, penalaran multi-langkah, dan kontrol terperinci atas seberapa banyak upaya “berpikir” yang dicurahkan untuk setiap tugas. Sifat open-weight dan lisensi Apache 2.0 menjadikannya pilihan fleksibel bagi tim yang ingin menelaah secara mendalam, menyesuaikan, atau melakukan fine-tuning pada model.

gpt-oss-20b

gpt-oss-20b menghadirkan kekuatan penalaran yang mengesankan dalam jejak yang muat di laptop konsumen. Dengan hanya 21 miliar parameter, model ini tetap mengungguli o3-mini milik OpenAI pada beberapa tolok ukur dan berjalan efisien pada perangkat dengan memori 16 GB. Model ini telah dikuantisasi dan disiapkan untuk penerapan lokal yang cepat, serta kompatibel dengan alat seperti Ollama, vLLM, dan bahkan platform Metal dari Apple.

Model ini ideal bagi pengembang yang ingin membangun aplikasi AI yang responsif dan privat tanpa bergantung pada infrastruktur cloud. Seperti kakaknya yang lebih besar, model ini mendukung kedalaman penalaran yang dapat diatur dan langkah-langkah perantara yang jelas—sangat cocok untuk eksperimen, asisten ringan, dan aplikasi perangkat edge.

Mengapa Menjalankan GPT-OSS Secara Lokal?

Menjalankan GPT-OSS secara lokal menawarkan beberapa keunggulan kuat dibandingkan alternatif berbasis cloud:

• Privasi dan kontrol: Semua inferensi terjadi di perangkat keras Anda, artinya tidak ada ketergantungan eksternal, gangguan layanan, atau perubahan API, dan Anda mendapatkan akses penuh ke penalaran internal model, bukan hanya jawabannya saja.
• Performa: Model lokal menghilangkan latensi jaringan untuk respons instan, dengan penggunaan tanpa batas (tanpa rate limit atau batas token), dan memastikan ketersediaan 24/7.
• Penghematan biaya: Model hanya perlu diunduh dan disiapkan sekali tanpa biaya langganan, dan pengguna dapat memanfaatkan sumber daya komputasi yang sudah dimiliki tanpa biaya API berkelanjutan.
• Penalaran yang transparan: Pengguna dapat beralih antara mode “upaya” rendah, sedang, dan tinggi untuk menyeimbangkan kecepatan dengan kedalaman, serta meninjau seluruh chain-of-thought.
• Kustomisasi dan ekstensibilitas: Kita dapat melakukan fine-tuning pada model open-weight untuk tugas spesifik, menyesuaikan parameter sampling, dan mengintegrasikan alat agen dengan mulus.

Menyiapkan GPT-OSS Secara Lokal dengan Ollama

Ollama mempermudah menjalankan model bahasa besar secara lokal dengan menangani unduhan, kuantisasi, dan eksekusi. Saya akan memandu Anda langkah demi langkah menyiapkan GPT-OSS di sistem Anda. Pada akhirnya, aplikasi kita akan tampak seperti ini:

Langkah 1: Instal Ollama

Pertama, unduh dan instal Ollama dari situs resmi.

Setelah terpasang, Anda dapat memverifikasi instalasi dengan membuka terminal dan mengetik:

ollama --version

Perintah ini akan menampilkan versi Ollama terbaru yang terpasang di sistem Anda.

Langkah 2: Unduh model GPT-OSS

OpenAI menyediakan dua varian GPT-OSS yang dioptimalkan untuk kasus penggunaan berbeda, tetapi untuk keperluan demo ini, kita akan mengambil hanya varian model gpt-oss-20b:

# Untuk produksi dan tugas penalaran tingkat tinggi 
ollama pull gpt-oss:120b
# Untuk latensi lebih rendah dan penerapan lokal 
ollama pull gpt-oss:20b

Model 20B sangat cocok untuk pengembangan lokal dan dapat berjalan pada sistem dengan memori 16GB+, sedangkan model 120B menawarkan kemampuan lebih tetapi memerlukan memori 80GB+.

Langkah 3: Uji instalasi

Mari verifikasi semuanya berfungsi dengan benar:

ollama run gpt-oss:20b

Anda akan melihat prompt tempat Anda bisa berinteraksi langsung dengan model. Coba ajukan: "Buktikan bahwa √2 itu irasional."

Menggunakan GPT-OSS Secara Lokal: ChatBot Interaktif

Sekarang mari kita cepat membangun aplikasi sederhana yang menampilkan kemampuan penalaran GPT-OSS. Aplikasi kita akan memiliki fitur:

• Kontrol penalaran interaktif
• Visualisasi chain-of-thought
• Pemantauan performa
• Riwayat percakapan

Langkah 1: Instal dependensi

Jalankan perintah berikut untuk memasang dependensi yang diperlukan:

pip install streamlit ollama

Cuplikan kode di atas memasang Streamlit untuk membangun antarmuka web dan klien Python Ollama untuk interaksi model GPT-OSS lokal.

Langkah 2: Impor pustaka dan siapkan halaman

Sebelum masuk ke logika inti chat, kita perlu membawa semua alat dan menyiapkan antarmuka pengguna.

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)

Kita mengimpor beberapa paket inti seperti Streamlit untuk antarmuka web, Ollama untuk memanggil model GPT-OSS lokal, beserta modul utilitas seperti json, time, typing, dan re. Lalu kita menggunakan st.set_page_config() untuk memberi judul halaman, tata letak lebar, dan ikon, serta menyuntikkan CSS ringan agar langkah penalaran dan jawaban tampil pada panel yang berbeda.

Langkah 3: Integrasi model inti

Dengan kerangka UI siap, mari bangun fungsi integrasi model inti 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
        }

Kode di atas:

• Menerima daftar pesan chat (system + user), sehingga kita mudah mempertahankan konteks multi-giliran.
• Mencatat start_time dan end_time di sekitar pemanggilan ollama.chat() untuk melaporkan waktu respons kembali ke pengguna.
• Menormalkan respons dari klien Ollama dengan mengekstrak keluaran teks mentah.
• Terakhir, fungsi call_model() membungkus seluruh pemanggilan dalam blok try/except untuk menangkap kesalahan.

Langkah 4: Parser chain-of-thought

Agar demo benar-benar transparan, kita perlu memisahkan “monolog internal” model dari kesimpulan akhirnya. Fungsi parse_reasoning_response() melakukan hal itu:

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
    }

Kita memisahkan “pemikiran” tersembunyi model dari kesimpulan akhirnya sehingga pengguna dapat secara opsional meninjau setiap langkah penalaran. Begini cara respons diurai:

• Mencari penanda eksplisit: Pertama, model mencari tag <thinking>…</thinking> atau frasa seperti “Reasoning:” dan “Let me think through” dengan ekspresi reguler.
• Mengekstrak dan membersihkan: Saat kecocokan ditemukan, segmen tersebut menjadi penalaran, dan sisanya diperlakukan sebagai jawaban.
• Heuristik fallback: Jika tidak ada tag tetapi keluaran terdiri dari banyak baris, fungsi memindai kata kunci kesimpulan (“therefore,” “in conclusion,” “final answer,” atau “Answer:”) dan membagi di sana.
• Keluaran: Terlepas dari formatnya, fungsi parse_reasoning_response() selalu mengembalikan jawaban.

Langkah 5: Aplikasi Streamlit lengkap

Sekarang setelah setiap blok penyusun selesai dibuat, berikutnya kita merangkainya menjadi aplikasi chat interaktif. 

# 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)

Pada langkah terakhir ini, kita menyatukan semua bagian aplikasi, termasuk session state, kontrol sidebar, contoh prompt, perakitan pesan, pemanggilan model, parsing, dan penayangan dalam satu loop:

1. Inisialisasi session state: Kita menggunakan st.session_state.history untuk menyimpan setiap pertukaran pengguna–asisten di setiap rerun.
2. Konfigurasi sidebar: Konfigurasi ini memungkinkan pengguna memilih
• Model: gpt-oss:20b atau gpt-oss:120b
• Reasoning Effort: rendah/sedang/tinggi
• Temperature: dari 0 hingga 2,0, yang mengontrol keacakan model
• Toggle Chain-of-Thought: Untuk menampilkan atau menyembunyikan penalaran internal model
• Bersihkan percakapan: Menghapus riwayat dan memulai ulang aplikasi
3. Contoh prompt dan input: Dropdown berisi pertanyaan awal membantu onboarding pengguna baru, dan apa pun yang dipilih (atau diketik) menjadi kueri pengguna di area teks.
4. Menyusun permintaan: Saat Ask GPT-OSS diklik, kita:
• Membuat system prompt berdasarkan tingkat upaya yang dipilih.
• Menambahkan enam pesan terakhir dari riwayat untuk mempertahankan konteks.
• Menambahkan pertanyaan pengguna baru.
5. Pemanggilan model: Kita menggunakan fungsi call_model(), yang:
• Mengirim pesan yang telah disusun ke Ollama
• Mengukur waktu respons
• Mengembalikan string konten yang dinormalisasi
6. Parsing dan penayangan: Dengan fungsi parse_reasoning_response(), kita membagi keluaran model menjadi respons chain-of-thought yang disebut “reasoning” dan respons yang dibersihkan yang disebut “answer”.
7. Manajemen riwayat: Setiap pasangan pertanyaan dan respons ditambahkan ke daftar st.session_state.history, sehingga pada run berikutnya keduanya disertakan untuk konteks.

Untuk mencoba sendiri, simpan kode sebagai gpt_oss_demo.py dan jalankan:

streamlit run gpt_oss_demo.py