如何在本地使用 Ollama 安装与运行 GPT-OSS

GPT-OSS 是 OpenAI 的首个开源权重模型系列，您可以直接在自己的电脑上运行。它为强推理、Agent 任务以及灵活的开发者用例而设计，凭借可配置的推理力度与透明的思维链能力而脱颖而出。

在本教程中，我将带您使用 Ollama 在本地设置 OpenAI 的 GPT-OSS 模型，并演示如何构建一个交互式演示来展示其独特的推理能力。我们将探索模型可配置的思维链特性，并构建一个可视化模型思考过程的 Streamlit 应用。

我们通过免费周五通讯 The Median 为读者带来 AI 前沿动态，精要梳理一周要闻。订阅后，每周几分钟即可保持敏锐：

什么是 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 媲美。尽管其参数规模高达 1170 亿，它仍被优化为可以在单张 80 GB GPU 上运行。这使其成为研究机构和企业团队在本地托管强大语言模型的现实之选。

该模型旨在支持复杂工作流，如工具调用、多步推理，以及对每个任务投入“思考”力度的精细控制。其开源权重与 Apache 2.0 许可也让团队能够灵活地深度审视、定制或微调模型。

gpt-oss-20b

gpt-oss-20b 在消费级笔记本可承载的体量中，提供了令人惊喜的推理能力。仅有 210 亿参数的它，在部分基准上仍优于 OpenAI 的 o3-mini，并能在 16 GB 内存的设备上高效运行。它已完成量化，适配快速本地部署，并兼容 Ollama、vLLM，甚至苹果的 Metal 平台。

此模型非常适合希望构建响应迅速且私密的 AI 应用、又不依赖云基础设施的开发者。与其大哥类似，它支持可调的推理深度与清晰的中间步骤——非常适合做实验、轻量助手和边缘设备应用。

为何在本地运行 GPT-OSS？

在本地运行 GPT-OSS 相比云端具备多项重要优势：

• 隐私与可控： 推理全部在您的硬件上完成，即无外部依赖、无故障或 API 变更，并且您可完全访问模型的内部推理过程，而不仅是最终答案。
• 性能： 本地模型消除网络时延，获得即时响应；无限用量（无速率或 Token 限制），并确保 24/7 可用性。
• 成本节省： 一次性下载和设置，无需订阅费用；可使用现有算力资源，无持续 API 成本。
• 透明推理： 用户可在低/中/高“努力”模式间切换，以平衡速度与深度，并检查完整的思维链。
• 可定制与可扩展： 可将开源权重模型微调用于特定任务，微调采样参数，并无缝集成 Agent 工具。

使用 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

您应能看到一个可直接与模型交互的提示符。可以试着问："Prove that √2 is irrational."

本地使用 GPT-OSS：交互式 ChatBot

现在我们快速构建一个简单应用，展示 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
        }

上述代码：

• 接收聊天消息列表（system + user），便于维护多轮上下文。
• 在 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. 侧边栏配置：该配置允许用户选择
• Model：gpt-oss:20b 或 gpt-oss:120b
• Reasoning Effort：low/medium/high
• Temperature：0 至 2.0，控制模型随机性
• 思维链开关：显示或隐藏模型的内部推理
• 清空会话：清除历史并重启应用
3. 示例提示与输入：下拉菜单提供入门问题帮助新用户上手，用户选择（或输入）的内容将成为文本框中的查询。
4. 构建请求：当点击 Ask GPT-OSS 时，我们会：
• 基于所选努力级别创建 system 提示。
• 附加历史中的最近六条消息以保持上下文。
• 加入新的用户问题。
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