Cómo configurar y ejecutar GPT-OSS localmente con Ollama

GPT-OSS ( ) es la primera serie de modelos de peso abierto de OpenAI, y puedes ejecutarla directamente en tu propio ordenador. Diseñado para un razonamiento potente, tareas de agencia y casos de uso flexibles por parte de los programadores, GPT-OSS destaca por su esfuerzo de razonamiento configurable y sus capacidades transparentes de cadena de pensamiento.

En este tutorial, te guiaré a través de la configuración de los modelos GPT-OSS de OpenAI de forma local utilizando Ollama y te mostraré cómo crear una demostración interactiva que muestre las capacidades de razonamiento únicas del modelo. Exploraremos las características configurables de la cadena de pensamiento del modelo y crearemos una aplicación Streamlit que visualiza el proceso de pensamiento del modelo.

Mantenemos a nuestros lectores al día sobre las últimas novedades en IA mediante el envío de The Median, nuestro boletín informativo gratuito de los viernes que resume las noticias más importantes de la semana. Suscríbete y mantente al día en solo unos minutos a la semana:

¿Qué es GPT-OSS de OpenAI?

La serie GPT-OSS de OpenAI marca su primer lanzamiento de peso abierto desde GPT-2, lo que permite el acceso a modelos de razonamiento de alto rendimiento bajo la licencia Apache 2.0. Estos modelos lingüísticos de última generación ofrecen un gran rendimiento a bajo coste y superan a modelos abiertos de tamaño similar en tareas de razonamiento.

Hay dos variantes: gpt-oss-120b y gpt-oss-20b.

Fuente: OpenAI

gpt-oss-120b

gpt-oss-120b es el modelo de peso abierto insignia de OpenAI, con un rendimiento que rivaliza con sistemas propietarios como o4‑mini en exigentes pruebas de razonamiento. A pesar de su tamaño de 117 000 millones de parámetros, está optimizado para ejecutarse en una sola GPU de 80 GB. Esto lo convierte en una opción realista para laboratorios de investigación y equipos empresariales que buscan alojar modelos de lenguaje potentes a nivel local.

El modelo está diseñado para admitir flujos de trabajo complejos, como el uso de herramientas, el razonamiento en varios pasos y el control detallado del esfuerzo «intelectual» que se dedica a cada tarea. Su naturaleza de código abierto y su licencia Apache 2.0 lo convierten en una opción flexible para equipos que desean inspeccionar en profundidad, personalizar o ajustar el modelo.

gpt-oss-20b

gpt-oss-20b ofrece una sorprendente capacidad de razonamiento en un espacio reducido que cabe en los portátiles de consumo. Con solo 21 000 millones de parámetros en total, sigue superando al modelo o3-mini de OpenAI. o3-mini de OpenAI en algunas pruebas de rendimiento y funciona de manera eficiente en dispositivos con 16 GB de memoria. Es cuantificado y preparado para una rápida implementación local, y es compatible con herramientas como Ollama, vLLMe incluso la plataforma Metal de Apple.

Este modelo es ideal para programadores que desean crear aplicaciones de IA privadas y con capacidad de respuesta sin depender de una infraestructura en la nube. Al igual que su hermano mayor, admite una profundidad de razonamiento ajustable y pasos intermedios claros, lo que resulta ideal para experimentos, asistentes ligeros y aplicaciones de dispositivos periféricos dispositivos periféricos.

¿Por qué ejecutar GPT-OSS localmente?

Ejecutar GPT-OSS localmente ofrece varias ventajas convincentes sobre las alternativas basadas en la nube:

• Privacidad y control: Todas las inferencias se realizan en tu hardware, es decir, sin dependencias externas, interrupciones ni cambios en la API, y obtienes acceso completo al razonamiento interno del modelo, no solo a sus respuestas finales.
• Rendimiento: Los modelos locales eliminan los problemas de latencia de la red para ofrecer respuestas instantáneas, con uso ilimitado (sin límites de velocidad ni restricciones de tokens) y garantizan una disponibilidad ininterrumpida.
• Ahorro de costes: El modelo requiere una descarga y configuración únicas, sin cuotas de suscripción, y tú puedes utilizar tus recursos informáticos existentes sin costes continuos por API.
• Razonamiento transparente: El usuario puede alternar entre los modos de «esfuerzo» bajo, medio y alto para equilibrar la velocidad con la profundidad e inspeccionar toda la cadena de pensamiento.
• Personalización y extensibilidad: Podemos ajustar los modelos de peso abierto a nuestras tareas específicas, modificar los parámetros de muestreo e integrar herramientas agenticas a la perfección.

Configuración local de GPT-OSS con Ollama

Ollama simplifica enormemente la ejecución local de modelos de lenguaje de gran tamaño, ya que se encarga de las descargas, la cuantificación y la ejecución. Te guiaré paso a paso a través de la configuración de GPT-OSS en tu sistema. Al final, nuestra aplicación tendrá este aspecto:

Paso 1: Install Ollama

Primero, descarga e instala Ollama desde el sitio web oficial.

Una vez instalado, puedes verificar la instalación abriendo un terminal y escribiendo:

ollama --version

Esto devolverá la última versión de Ollama instalada en tu sistema.

Paso 2: Descargar los modelos GPT-OSS

OpenAI ofrece dos variantes de GPT-OSS optimizadas para diferentes casos de uso, pero para esta demostración, solo utilizaremos la variante del modelo 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

El modelo 20B es perfecto para el desarrollo local y puede funcionar en sistemas con 16 GB de memoria o más, mientras que el modelo 120B ofrece más capacidades, pero requiere 80 GB de memoria o más.

Paso 3: Prueba la instalación

Verifiquemos que todo funciona correctamente:

ollama run gpt-oss:20b

Deberías ver un mensaje en el que puedes interactuar directamente con el modelo. Prueba a preguntar: «Demuestra que √2 es irracional».

Uso local de GPT-OSS: ChatBot interactivo

Ahora vamos a crear rápidamente una aplicación sencilla que muestre las capacidades de razonamiento de GPT-OSS. Nuestra aplicación contará con:

• Controles de razonamiento interactivo
• Visualización de la cadena de pensamientos
• Supervisión del rendimiento
• Historial de conversaciones

Paso 1: Instalar dependencias

Ejecuta los siguientes comandos para instalar las dependencias necesarias:

pip install streamlit ollama

El fragmento de código anterior instala Streamlit para crear la interfaz web y el cliente Python Ollama para la interacción local con el modelo GPT-OSS.

Paso 2: Importa las bibliotecas y configura la página.

Antes de profundizar en la lógica básica del chat, necesitamos incorporar todas las herramientas y configurar nuestra interfaz de usuario.

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)

Importamos algunos paquetes básicos como Streamlit para nuestra interfaz web, Ollama para llamar al modelo GPT-OSS local, junto con módulos de utilidad como json, time, typing y re. A continuación, utilizamos st.set_page_config() para darle a la página un título, un diseño amplio y un icono, e insertamos CSS ligero para que los pasos del razonamiento y las respuestas aparezcan en paneles diferenciados.

Paso 3: Integración del modelo básico

Con nuestro andamio de interfaz de usuario en su lugar, construyamos nuestra función de integración del modelo central e 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
        }

El código anterior:

• Acepta una lista de mensajes de chat (sistema + usuario), lo que nos permite mantener fácilmente el contexto de varias rondas.
• A continuación, registra start_time y end_time alrededor de la llamada ollama.chat() para informar de los tiempos de respuesta al usuario.
• También normaliza las respuestas del cliente Ollama extrayendo el texto sin formato.
• Por último, la función « call_model() » envuelve toda la llamada en un bloque « try/except » para detectar errores.

Paso 4: Analizador sintáctico de cadenas de pensamiento

Para que nuestra demostración sea realmente transparente, necesitamos separar el «monólogo interior» del modelo de su veredicto final. La función « parse_reasoning_response() » hace exactamente eso:

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
    }

Separamos el «pensamiento» oculto del modelo de su veredicto final para que los usuarios puedan inspeccionar opcionalmente cada paso del razonamiento. Así es como se analiza la respuesta:

• Buscando marcadores explícitos: En primer lugar, el modelo busca etiquetas o frases e … es como «Razonamiento:» y «Déjame pensarlo» con expresiones regulares.
• Extracción y limpieza de: Cuando se encuentra una coincidencia, ese segmento se convierte en el razonamiento y el resto se trata como la respuesta.
• Recurso heurístico: Si no hay etiquetas pero la salida abarca varias líneas, busca palabras clave de conclusión («por lo tanto», «en conclusión», «respuesta final» o «Respuesta:») y divide el texto en ese punto.
• Salida: Independientemente del formato, la función parse_reasoning_response() siempre devuelve una respuesta.

Paso 5: Aplicación Streamlit completa

Ahora que hemos creado cada bloque, los ensamblaremos para crear una aplicación de chat interactiva. 

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

En este último paso, reunimos todas las piezas de nuestra aplicación, incluyendo el estado de la sesión, los controles de la barra lateral, los mensajes de ejemplo, el ensamblado de mensajes, la invocación del modelo, el análisis y la visualización en un único bucle:

1. Inicialización del estado de la sesión: Utilizamos st.session_state.history para recordar cada intercambio entre el usuario y el asistente en las repeticiones.
2. Configuración de la barra lateral: Esta configuración permite a los usuarios seleccionar
• Modelo: gpt-oss:20b o gpt-oss:120b
• Esfuerzo de razonamiento: bajo/medio/alto
• Temperatura: de 0 a 2,0, que controla la aleatoriedad del modelo
• Alternar cadena de pensamiento: Mostrar u ocultar el razonamiento interno del modelo.
• Conversación clara: Esto borra el historial y reinicia la aplicación.
3. Ejemplos de indicaciones y entradas: Un menú desplegable con preguntas iniciales ayuda a los nuevos usuarios a familiarizarse con el sistema, y lo que el usuario seleccione (o escriba) se convierte en tu consulta en el área de texto.
4. Creación de la solicitud: Cuando hacemos clic en «Preguntar a GPT-OSS» , hacemos lo siguiente:
• Crea un aviso del sistema basado en el nivel de esfuerzo elegido.
• Añade los últimos seis mensajes del historial para mantener el contexto.
• Añade la nueva pregunta para los usuarios.
5. Invocación del modelo: Utilizamos la función « call_model() », que:
• Envía los mensajes ensamblados a Ollama.
• Mide el tiempo de respuesta
• Devuelve una cadena de contenido normalizada.
6. Análisis y visualización: Con la función « parse_reasoning_response() », dividimos el resultado del modelo en una respuesta en forma de cadena de pensamientos denominada «razonamiento» y una respuesta depurada denominada «respuesta».
7. Gestión del historial: Cada par de preguntas y respuestas se añade a una list st.session_state.history, de modo que la siguiente ejecución las incluye para contextualizarlas.

Para probarlo tú mismo, guarda el código como gpt_oss_demo.py y ejecútalo:

streamlit run gpt_oss_demo.py