Cách cài đặt và chạy GPT-OSS cục bộ với Ollama

GPT-OSS là dòng mô hình open-weight đầu tiên của OpenAI, và bạn có thể chạy trực tiếp trên máy tính của mình. Được thiết kế cho năng lực lập luận mạnh, tác vụ mang tính agent và các trường hợp sử dụng linh hoạt cho nhà phát triển, GPT-OSS nổi bật nhờ mức độ nỗ lực lập luận có thể cấu hình và khả năng hiển thị chuỗi suy nghĩ minh bạch.

Trong hướng dẫn này, tôi sẽ dẫn bạn thiết lập các mô hình GPT-OSS của OpenAI cục bộ bằng Ollama và trình diễn cách xây dựng một bản demo tương tác để thể hiện năng lực lập luận độc đáo của mô hình. Chúng ta sẽ khám phá tính năng chuỗi suy nghĩ có thể cấu hình và xây dựng một ứng dụng Streamlit để trực quan hóa quá trình “suy nghĩ” của mô hình.

Chúng tôi cập nhật cho độc giả những tin tức AI mới nhất qua The Median, bản tin miễn phí mỗi thứ Sáu tóm lược các câu chuyện quan trọng trong tuần. Đăng ký để bắt kịp chỉ trong vài phút mỗi tuần:

GPT-OSS của OpenAI là gì?

Dòng GPT-OSS đánh dấu lần phát hành open-weight đầu tiên của OpenAI kể từ GPT-2, cho phép truy cập các mô hình lập luận hiệu năng cao theo giấy phép Apache 2.0. Những mô hình ngôn ngữ tối tân này mang lại hiệu năng mạnh với chi phí thấp và vượt trội so với các mô hình mở cùng kích thước trong các bài kiểm tra lập luận.

Có hai biến thể: gpt-oss-120b và gpt-oss-20b.

Nguồn: OpenAI

gpt-oss-120b

gpt-oss-120b là mô hình open-weight chủ lực của OpenAI, có hiệu năng sánh ngang các hệ thống độc quyền như o4‑mini trên các chuẩn đo khó về lập luận. Dù có kích thước 117 tỷ tham số, mô hình được tối ưu để chạy trên một GPU 80 GB. Điều này biến nó thành lựa chọn thực tế cho các phòng thí nghiệm nghiên cứu và đội ngũ doanh nghiệp muốn tự lưu trữ mô hình ngôn ngữ mạnh mẽ tại chỗ.

Mô hình được thiết kế để hỗ trợ các quy trình phức tạp như sử dụng công cụ, lập luận nhiều bước, và kiểm soát chi tiết mức độ “suy nghĩ” dành cho mỗi tác vụ. Tính open-weight và giấy phép Apache 2.0 khiến nó trở thành lựa chọn linh hoạt cho các đội ngũ muốn kiểm tra sâu, tùy biến hoặc fine-tune mô hình.

gpt-oss-20b

gpt-oss-20b gói gọn sức mạnh lập luận đáng ngạc nhiên trong một dấu chân phù hợp với laptop người dùng. Chỉ với 21 tỷ tham số, nó vẫn vượt OpenAI’s o3-mini trên một số chuẩn đo và chạy hiệu quả trên thiết bị có 16 GB bộ nhớ. Nó được lượng tử hóa và chuẩn bị sẵn sàng cho triển khai cục bộ nhanh, tương thích với các công cụ như Ollama, vLLM, và thậm chí cả nền tảng Metal của Apple.

Mô hình này lý tưởng cho nhà phát triển muốn xây dựng ứng dụng AI phản hồi nhanh, riêng tư mà không phụ thuộc hạ tầng đám mây. Tương tự “người anh” lớn hơn, nó hỗ trợ độ sâu lập luận có thể điều chỉnh và các bước trung gian rõ ràng — rất phù hợp cho thử nghiệm, trợ lý gọn nhẹ và ứng dụng trên thiết bị edge.

Vì sao chạy GPT-OSS cục bộ?

Chạy GPT-OSS cục bộ mang lại vài ưu thế thuyết phục so với các phương án dựa trên đám mây:

• Quyền riêng tư và kiểm soát: Mọi suy luận diễn ra trên phần cứng của bạn, tức không có phụ thuộc bên ngoài, không lo gián đoạn hay thay đổi API, và bạn có toàn quyền truy cập vào lập luận nội bộ của mô hình, không chỉ câu trả lời cuối.
• Hiệu năng: Mô hình cục bộ loại bỏ độ trễ mạng cho phản hồi tức thì, với mức sử dụng không giới hạn (không giới hạn tốc độ hay token) và đảm bảo sẵn sàng 24/7.
• Tiết kiệm chi phí: Mô hình chỉ cần tải xuống và thiết lập một lần, không phí thuê bao, và người dùng có thể tận dụng tài nguyên tính toán sẵn có mà không tốn chi phí API định kỳ.
• Lập luận minh bạch: Người dùng có thể chuyển giữa chế độ “nỗ lực” thấp, trung bình, cao để cân bằng tốc độ và chiều sâu, và kiểm tra toàn bộ chuỗi suy nghĩ.
• Khả năng tùy biến và mở rộng: Chúng ta có thể fine-tune các mô hình open-weight cho tác vụ cụ thể, tinh chỉnh tham số sampling và tích hợp công cụ mang tính agent một cách liền mạch.

Thiết lập GPT-OSS cục bộ với Ollama

Ollama giúp chạy mô hình ngôn ngữ lớn cục bộ trở nên cực kỳ đơn giản bằng cách xử lý tải xuống, lượng tử hóa và thực thi. Tôi sẽ hướng dẫn bạn từng bước thiết lập GPT-OSS trên hệ thống của mình. Cuối cùng, ứng dụng của chúng ta sẽ trông như sau:

Bước 1: Cài đặt Ollama

Trước tiên, hãy tải và cài đặt Ollama từ trang web chính thức.

Sau khi cài đặt, bạn có thể kiểm tra bằng cách mở terminal và nhập:

ollama --versionĐược hỗ trợ bởi

Lệnh này sẽ trả về phiên bản Ollama mới nhất đang có trên hệ thống của bạn.

Bước 2: Tải các mô hình GPT-OSS

OpenAI cung cấp hai biến thể GPT-OSS tối ưu cho các nhu cầu khác nhau, nhưng trong bản demo này, chúng ta sẽ chỉ kéo biến thể 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Được hỗ trợ bởi

Mô hình 20B rất phù hợp cho phát triển cục bộ và có thể chạy trên hệ thống với bộ nhớ 16GB+, trong khi mô hình 120B có nhiều khả năng hơn nhưng yêu cầu bộ nhớ 80GB+.

Bước 3: Kiểm tra cài đặt

Hãy xác nhận mọi thứ hoạt động đúng:

ollama run gpt-oss:20bĐược hỗ trợ bởi

Bạn sẽ thấy một nhắc lệnh nơi có thể tương tác trực tiếp với mô hình. Hãy thử hỏi: "Chứng minh rằng √2 là vô tỉ."

Sử dụng GPT-OSS cục bộ: ChatBot tương tác

Giờ hãy nhanh chóng xây dựng một ứng dụng đơn giản để phô diễn khả năng lập luận của GPT-OSS. Ứng dụng sẽ có:

• Điều khiển mức độ lập luận tương tác
• Trực quan hóa chuỗi suy nghĩ
• Giám sát hiệu năng
• Lịch sử hội thoại

Bước 1: Cài đặt phụ thuộc

Chạy các lệnh sau để cài đặt các phụ thuộc cần thiết:

pip install streamlit ollamaĐược hỗ trợ bởi

Đoạn mã trên cài đặt Streamlit để xây dựng giao diện web và client Python của Ollama để tương tác với mô hình GPT-OSS cục bộ.

Bước 2: Import thư viện và thiết lập trang

Trước khi đi vào logic chat cốt lõi, ta cần mang vào các công cụ và thiết lập giao diện người dùng.

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)Được hỗ trợ bởi

Chúng ta import một vài gói cốt lõi như Streamlit cho giao diện web, Ollama để gọi mô hình GPT-OSS cục bộ, cùng các mô-đun tiện ích như json, time, typing và re. Sau đó dùng st.set_page_config() để đặt tiêu đề trang, bố cục rộng và biểu tượng, đồng thời chèn CSS nhẹ để các bước lập luận và câu trả lời hiển thị trong các khung riêng biệt.

Bước 3: Tích hợp mô hình cốt lõi

Với khung UI đã có, hãy xây dựng hàm tích hợp mô hình cốt lõi 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
        }Được hỗ trợ bởi

Đoạn mã trên:

• Nhận danh sách tin nhắn chat (system + user), giúp dễ dàng duy trì ngữ cảnh nhiều lượt.
• Ghi lại start_time và end_time quanh lời gọi ollama.chat() để báo thời gian phản hồi cho người dùng.
• Chuẩn hóa phản hồi từ client Ollama bằng cách trích xuất văn bản thô.
• Cuối cùng, hàm call_model() bọc toàn bộ lời gọi trong try/except để bắt lỗi.

Bước 4: Trình phân tích chuỗi suy nghĩ

Để bản demo thực sự minh bạch, ta cần tách “độc thoại nội tâm” của mô hình khỏi kết luận cuối. Hàm parse_reasoning_response() thực hiện đúng điều đó:

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
    }Được hỗ trợ bởi

Chúng ta tách phần “suy nghĩ” ẩn của mô hình khỏi kết luận cuối để người dùng có thể tùy chọn xem từng bước lập luận. Cách phản hồi được phân tích như sau:

• Tìm chỉ dấu rõ ràng: Đầu tiên, mô hình tìm thẻ <thinking>…</thinking> hoặc các cụm như “Reasoning:” và “Let me think through” bằng biểu thức chính quy.
• Trích xuất và làm sạch: Khi tìm thấy, đoạn đó trở thành phần lập luận, phần còn lại được coi là câu trả lời.
• Dự phòng theo kinh nghiệm: Nếu không có thẻ nhưng đầu ra nhiều dòng, hàm sẽ quét các từ khóa kết luận (“therefore”, “in conclusion”, “final answer” hoặc “Answer:”) và tách tại đó.
• Đầu ra: Bất kể định dạng, hàm parse_reasoning_response() luôn trả về một câu trả lời.

Bước 5: Hoàn thiện ứng dụng Streamlit

Giờ chúng ta ghép tất cả các mảnh lại thành một ứng dụng chat tương tác. 

# 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)Được hỗ trợ bởi

Ở bước cuối này, chúng ta gom tất cả thành phần của ứng dụng, gồm trạng thái phiên, điều khiển ở thanh bên, câu hỏi mẫu, lắp ráp tin nhắn, gọi mô hình, phân tích và hiển thị vào một vòng lặp duy nhất:

1. Khởi tạo trạng thái phiên: Chúng ta dùng st.session_state.history để ghi nhớ mọi lượt trao đổi người dùng–trợ lý qua các lần chạy lại.
2. Cấu hình thanh bên: Phần này cho phép người dùng chọn
• Model: gpt-oss:20b hoặc gpt-oss:120b
• Reasoning Effort: thấp/trung bình/cao
• Temperature: từ 0 đến 2.0, điều khiển mức ngẫu nhiên của mô hình
• Bật/tắt Chain-of-Thought: Để hiển thị hoặc ẩn lập luận nội bộ của mô hình
• Xóa hội thoại: Xóa lịch sử và khởi động lại ứng dụng
3. Câu hỏi mẫu và nhập liệu: Một danh sách thả xuống chứa câu hỏi khởi đầu giúp người mới làm quen, và mục được chọn (hoặc gõ) trở thành truy vấn trong ô văn bản.
4. Xây dựng yêu cầu: Khi nhấn Ask GPT-OSS, chúng ta:
• Tạo system prompt dựa trên mức nỗ lực đã chọn.
• Thêm sáu tin nhắn gần nhất từ lịch sử để giữ ngữ cảnh.
• Thêm câu hỏi mới của người dùng.
5. Gọi mô hình: Chúng ta dùng hàm call_model(), hàm này:
• Gửi tập tin nhắn đã lắp ráp tới Ollama
• Đo thời gian phản hồi
• Trả về chuỗi nội dung đã chuẩn hóa
6. Phân tích và hiển thị: Dùng hàm parse_reasoning_response(), chúng ta tách đầu ra của mô hình thành phần chuỗi suy nghĩ gọi là “reasoning” và phần trả lời đã làm sạch gọi là “answer”.
7. Quản lý lịch sử: Mỗi cặp câu hỏi và phản hồi được thêm vào danh sách st.session_state.history, để lần chạy tiếp theo có chúng làm ngữ cảnh.

Để tự thử, lưu mã thành gpt_oss_demo.py và chạy:

streamlit run gpt_oss_demo.pyĐược hỗ trợ bởi