So richtest du GPT-OSS lokal mit Ollama ein und startest es

GPT-OSS ( ) ist die erste offene Modellreihe von OpenAI, die du direkt auf deinem eigenen Computer ausführen kannst. GPT-OSS ist für leistungsstarkes Denken, agentenbasierte Aufgaben und flexible Anwendungsfälle für Entwickler gemacht und sticht durch seinen konfigurierbaren Denkaufwand und seine transparenten Denkprozessfunktionen hervor.

In diesem Tutorial zeige ich dir, wie du die GPT-OSS-Modelle von OpenAI lokal mit Ollama einrichtest und eine interaktive Demo erstellst, die die einzigartigen Schlussfolgerungsfähigkeiten des Modells vorführt. Wir schauen uns die konfigurierbaren Funktionen der Denkverkettung des Modells an und erstellen eine Streamlit-App, die den Denkprozess des Modells zeigt.

Wir halten unsere Leser über die neuesten Entwicklungen im Bereich KI auf dem Laufenden, indem wir ihnen jeden Freitag unseren kostenlosen Newsletter „The Median“ schicken, der die wichtigsten Meldungen der Woche zusammenfasst. Abonniere unseren Newsletter und bleib in nur wenigen Minuten pro Woche auf dem Laufenden:

Was ist GPT-OSS von OpenAI?

Die GPT-OSS-Serie von OpenAI ist die erste Veröffentlichung mit freier Gewichtung seit GPT-2 und ermöglicht den Zugriff auf leistungsstarke Schlussfolgerungsmodelle unter der Apache 2.0-Lizenz. Diese supermodernen Sprachmodelle sind echt leistungsstark und günstig und machen ähnliche offene Modelle bei Denkaufgaben richtig fertig.

Es gibt zwei Varianten: gpt-oss-120b und gpt-oss-20b.

Quelle: OpenAI

gpt-oss-120b

gpt-oss-120b ist das Flaggschiff unter den Open-Weight-Modellen von OpenAI und kann mit seiner Leistung mit proprietären Systemen wie o4-mini bei anspruchsvollen Benchmarks für logisches Denken mithalten kann. Trotz seiner Größe von 117 Milliarden Parametern ist es so optimiert, dass es auf einer einzigen 80-GB-GPU läuft. Das macht es zu einer coolen Option für Forschungslabore und Unternehmensteams, die leistungsstarke Sprachmodelle lokal hosten wollen.

Das Modell ist so gemacht, dass es komplexe Arbeitsabläufe wie den Einsatz von Tools, mehrstufiges Denken und eine genaue Steuerung des „Denkaufwands“ für jede Aufgabe unterstützt. Dank seiner Offenheit und der Apache 2.0-Lizenz ist es eine flexible Option für Teams, die das Modell gründlich prüfen, anpassen oder optimieren wollen.

gpt-oss-20b

gpt-oss-20b packt überraschend viel Rechenleistung in ein Format, das auf normale Laptops passt. Mit nur 21 Milliarden Parametern ist es immer noch besser als OpenAI's o3-mini in einigen Benchmarks und läuft super auf Geräten mit 16 GB Arbeitsspeicher. Es ist quantisiert und für den schnellen Einsatz vor Ort vorbereitet und mit Tools wie Ollama, vLLMund sogar mit Apples Metal-Plattform.

Dieses Modell ist super für Entwickler, die reaktionsschnelle, private KI-Apps erstellen wollen, ohne auf eine Cloud-Infrastruktur angewiesen zu sein. Genau wie sein größerer Bruder unterstützt es eine anpassbare Argumentationstiefe und klare Zwischenschritte – super für Experimente, einfache Assistenten und Edge Geräteanwendungen.

Warum GPT-OSS lokal ausführen?

Die lokale Ausführung von GPT-OSS hat gegenüber Cloud-basierten Alternativen einige coole Vorteile:

• Datenschutz und Kontrolle: Die ganze Schlussfolgerung läuft auf deiner Hardware ab, also ohne externe Abhängigkeiten, Ausfälle oder API-Änderungen. Du bekommst vollen Zugriff auf die internen Denkprozesse des Modells, nicht nur auf die endgültigen Antworten.
• Leistung: Lokale Modelle machen Schluss mit Netzwerkverzögerungen, sodass du sofort Antworten bekommst. Du kannst sie so oft nutzen, wie du willst (ohne Begrenzung der Rate oder der Tokens), und sie sind immer verfügbar.
• Einsparungen bei den Kosten: Das Modell muss nur einmal runtergeladen und eingerichtet werden, es gibt keine Abogebühren und du kannst deine vorhandenen Rechenressourcen ohne laufende API-Kosten nutzen.
• Transparente Argumentation: Der Benutzer kann zwischen den Modi „geringe Anstrengung“, „mittlere Anstrengung“ und „hohe Anstrengung“ wechseln, um Geschwindigkeit und Tiefe auszugleichen und die gesamte Gedankenkette zu überprüfen.
• Anpassbarkeit und Erweiterbarkeit: Wir können die Open-Weight-Modelle genau auf unsere Aufgaben abstimmen, die Sampling-Parameter anpassen und Agent-Tools ganz einfach integrieren.

GPT-OSS lokal mit Ollama einrichten

Ollama macht das lokale Ausführen großer Sprachmodelle echt einfach, indem es Downloads, Quantisierung und Ausführung übernimmt. Ich zeig dir Schritt für Schritt, wie du GPT-OSS auf deinem System einrichtest. Am Ende sieht unsere App so aus:

Schritt 1: Installier Ollama

Lade zuerst Ollama von der offiziellen Websiteherunter und installiere es.

Nach der Installation kannst du die Installation überprüfen, indem du ein Terminal öffnest und Folgendes eingibst:

ollama --version

Damit bekommst du die aktuellste Version von Ollama, die auf deinem System installiert ist.

Schritt 2: Lade die GPT-OSS-Modelle runter

OpenAI bietet zwei GPT-OSS-Varianten an, die für verschiedene Anwendungsfälle optimiert sind. Für diese Demo ziehen wir aber nur die Modellvariante gpt-oss-20b heran:

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

Das Modell 20B ist super für die lokale Entwicklung und läuft auf Systemen mit 16 GB+ Arbeitsspeicher, während das Modell 120B mehr Funktionen bietet, aber 80 GB+ Arbeitsspeicher braucht.

Schritt 3: Probier mal die Installation aus

Schauen wir mal, ob alles richtig funktioniert:

ollama run gpt-oss:20b

Du solltest eine Eingabeaufforderung sehen, über die du direkt mit dem Modell interagieren kannst. Frag doch mal: „Beweise, dass √2 irrational ist.“

GPT-OSS lokal nutzen: Interaktiver ChatBot

Jetzt bauen wir schnell eine einfache App, die die Denkfähigkeiten von GPT-OSS zeigt. Unsere App wird Folgendes bieten:

• Interaktive Argumentationskontrollen
• Visualisierung von Gedankengängen
• Leistungsüberwachung
• Gesprächshistorie

Schritt 1: Abhängigkeiten installieren

Mach die folgenden Befehle, um die nötigen Abhängigkeiten zu installieren:

pip install streamlit ollama

Der obige Code installiert Streamlit für die Erstellung der Webschnittstelle und den Ollama Python-Client für die lokale Interaktion mit dem GPT-OSS-Modell.

Schritt 2: Bibliotheken importieren und die Seite einrichten

Bevor wir uns mit der Chat-Logik beschäftigen, müssen wir alle Tools holen und unsere Benutzeroberfläche einrichten.

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)

Wir importieren ein paar wichtige Pakete wie Streamlit für unsere Weboberfläche, Ollama zum Aufrufen des lokalen GPT-OSS-Modells sowie Hilfsmodule wie json, time, typing und re. Dann nehmen wir st.set_page_config(), um der Seite einen Titel, ein breites Layout und ein Symbol zu geben, und fügen leichtes CSS ein, damit die Argumentationsschritte und Antworten in separaten Feldern angezeigt werden.

Schritt 3: Integration des Kernmodells

Nachdem wir unser UI-Gerüst aufgestellt haben, erstellen wir die Kernfunktion „ call_model() “ für die Modellintegration:

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
        }

Der obige Code:

• Nimmt eine Liste von Chat-Nachrichten (System + Benutzer) entgegen, sodass wir den Kontext über mehrere Runden hinweg einfach beibehalten können.
• Anschließend werden „ start_time “ und „ end_time “ rund um den Aufruf „ ollama.chat() “ aufgezeichnet, um die Antwortzeiten an den Benutzer zurückzumelden.
• Außerdem normalisiert es die Antworten vom Ollama-Client, indem es den rohen Text extrahiert.
• Zum Schluss packt die Funktion „ call_model() “ den ganzen Aufruf in einen „ try/except “-Block, um Fehler abzufangen.

Schritt 4: Gedankenkette-Parser

Damit unsere Demo wirklich klar ist, müssen wir den „inneren Monolog“ des Modells von seinem endgültigen Urteil trennen. Die Funktion „ parse_reasoning_response() “ macht genau das:

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
    }

Wir trennen das „Denkvermögen“ des Modells von seinem endgültigen Urteil, sodass die Nutzer jeden einzelnen Schritt der Argumentation nach Belieben überprüfen können. So wird die Antwort analysiert:

• Auf der Suche nach eindeutigen Markierungen: Zuerst sucht das Modell mit regulären Ausdrücken nach Tags oder Phrasen wie „ … “ (Begründung) oder „Reasoning:“ (Begründung) und „Let me think through“ (Lass mich mal darüber nachdenken).
• extrahieren und bereinigen: Wenn eine Übereinstimmung gefunden wird, wird dieses Segment zur Begründung und der Rest wird als Antwort behandelt.
• Heuristischer Fallback-: Wenn keine Tags da sind, aber der Text über mehrere Zeilen geht, sucht das Tool nach Schlussworten („daher“, „abschließend“, „letzte Antwort“ oder „Antwort:“) und teilt den Text da auf.
• Ausgabe: Egal in welchem Format, die Funktion „ parse_reasoning_response() “ gibt immer eine Antwort zurück.

Schritt 5: Komplette Streamlit-App

Nachdem wir jetzt alle Bausteine fertig haben, setzen wir sie zu einer interaktiven Chat-App zusammen. 

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

In diesem letzten Schritt bringen wir alle Teile unserer App zusammen, einschließlich Sitzungsstatus, Seitenleistensteuerung, Beispielaufforderungen, Nachrichtenzusammenstellung, Modellaufruf, Parsing und Anzeige, in einer einzigen Schleife:

1. Initialisierung des Sitzungsstatus: Wir nutzen „ st.session_state.history “, um jeden Austausch zwischen Benutzern und Assistenten bei Wiederholungen zu speichern.
2. Seitenleisten-Einstellungen: Mit dieser Einstellung können Benutzer auswählen, ob sie
• Modell: gpt-oss:20b oder gpt-oss:120b
• Argumentationsaufwand: gering/mittel/hoch
• Temperatur: von 0 bis 2,0, regelt die Zufälligkeit des Modells
• Gedankenkette-Schalter: Die interne Argumentation des Modells anzeigen oder ausblenden
• Klare Gesprächs: Das löscht den Verlauf und startet die App neu.
3. Beispielfragen und Eingaben: Ein Dropdown-Menü mit ersten Fragen hilft neuen Benutzern beim Einstieg, und was auch immer der Benutzer auswählt (oder eingibt), wird als Anfrage des Benutzers im Textbereich angezeigt.
4. Die Anfrage erstellen: Wenn „Ask GPT-OSS“ geklickt wird, machen wir Folgendes:
• Erstell eine Systemaufforderung, die auf dem gewählten Schwierigkeitsgrad basiert.
• Füge die letzten sechs Nachrichten aus dem Verlauf an, damit der Kontext klar bleibt.
• Füge die neue Benutzerfrage hinzu.
5. Modellaufruf: Wir benutzen die Funktion „ call_model() “, die:
• Schickt die zusammengestellten Nachrichten an Ollama.
• Misst die Reaktionszeit
• Gibt eine normalisierte Inhaltszeichenfolge zurück.
6. Analyse und Anzeige: Mit der Funktion „ parse_reasoning_response() “ teilen wir die Ausgabe des Modells in eine Gedankenkette namens „reasoning“ und eine bereinigte Antwort namens „answer“ auf.
7. Verlauf verwalten: Jedes Frage-Antwort-Paar wird an die Liste „ st.session_state.history “ angehängt, damit sie beim nächsten Durchlauf im Kontext berücksichtigt werden.

Um es selbst auszuprobieren, speicher den Code als „ gpt_oss_demo.py “ und starte:

streamlit run gpt_oss_demo.py