openai/gpt-oss : gpt-oss-120b et gpt-oss-20b sont deux modèles linguistiques ouverts développés par OpenAI

Essayez gpt-oss ·
Guides ·
Fiche du modèle ·
Blog OpenAI

Télécharger gpt-oss-120b et gpt-oss-20b sur Hugging Face

Bienvenue dans la série gpt-oss, les modèles à poids ouvert d’OpenAI conçus pour un raisonnement puissant, des tâches d’agent et des cas d’utilisation polyvalents pour les développeurs.

Nous proposons deux versions de ces modèles ouverts :

• gpt-oss-120b — pour la production, les utilisations générales et les cas d’utilisation nécessitant un raisonnement élevé qui s’adaptent à un seul GPU de 80 Go (comme NVIDIA H100 ou AMD MI300X) (117 milliards de paramètres avec 5,1 milliards de paramètres actifs)
• gpt-oss-20b — pour une latence plus faible et des cas d’utilisation locaux ou spécialisés (21 milliards de paramètres avec 3,6 milliards de paramètres actifs)

Les deux modèles ont été entraînés à l’aide de notre format de réponse Harmony et ne doivent être utilisés qu’avec ce format, sinon ils ne fonctionneront pas correctement.

• Licence Apache 2.0 permissive : Créez librement sans restrictions de copyleft ni risque de brevet — idéal pour l’expérimentation, la personnalisation et le déploiement commercial.
• Effort de raisonnement configurable : Ajustez facilement l’effort de raisonnement (faible, moyen, élevé) en fonction de votre cas d’utilisation spécifique et de vos besoins en matière de latence.
• Chaîne de pensée complète : Fournit un accès complet au processus de raisonnement du modèle, facilitant le débogage et renforçant la confiance dans les résultats. Ces informations ne sont pas destinées à être montrées aux utilisateurs finaux.
• Ajustable : Personnalisez entièrement les modèles en fonction de votre cas d’utilisation spécifique grâce au réglage fin des paramètres.
• Capacités agentives : Utilisez les capacités natives des modèles pour l’appel de fonctions, la navigation sur le Web, l’exécution de code Python et les sorties structurées.
• Quantification MXFP4 : Les modèles ont été post-entraînés avec la quantification MXFP4 des poids MoE, ce qui permet à gpt-oss-120b de fonctionner sur un seul GPU de 80 Go (comme NVIDIA H100 ou AMD MI300X) et au modèle gpt-oss-20b de fonctionner avec 16 Go de mémoire. Toutes les évaluations ont été effectuées avec la même quantification MXFP4.

Vous pouvez utiliser gpt-oss-120b et gpt-oss-20b avec la bibliothèque Transformers. Si vous utilisez le modèle de chat de Transformers, le format de réponse Harmony sera automatiquement appliqué. Si vous utilisez model.generate directement, vous devez appliquer manuellement le format Harmony à l’aide du modèle de chat ou utiliser notre package openai-harmony .

from transformers import pipeline
import torch

model_id = "openai/gpt-oss-120b"

pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Explain quantum mechanics clearly and concisely."},
]

outputs = pipe(
    messages,
    max_new_tokens=256,
)
print(outputs[0]["generated_text"][-1])

En savoir plus sur l’utilisation de gpt-oss avec Transformers.

vLLM recommande d’utiliser uv pour la gestion des dépendances Python. Vous pouvez utiliser vLLM pour lancer un serveur web compatible avec OpenAI. La commande suivante téléchargera automatiquement le modèle et démarrera le serveur.

uv pip install --pre vllm==0.10.1+gptoss \
    --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
    --extra-index-url https://download.pytorch.org/whl/nightly/cu128 \
    --index-strategy unsafe-best-match

vllm serve openai/gpt-oss-20b

En savoir plus sur l’utilisation de gpt-oss avec vLLM.

Code de service hors ligne :

• exécutez ce code après avoir installé les bibliothèques appropriées comme décrit, tout en installant également ceci :
• uv pip install openai-harmony

# source .oss/bin/activate

import os
os.environ["VLLM_USE_FLASHINFER_SAMPLER"] = "0"

import json
from openai_harmony import (
    HarmonyEncodingName,
    load_harmony_encoding,
    Conversation,
    Message,
    Role,
    SystemContent,
    DeveloperContent,
)
 
from vllm import LLM, SamplingParams
import os

# --- 1) Render the prefill with Harmony ---
encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
 
convo = Conversation.from_messages(
    [
        Message.from_role_and_content(Role.SYSTEM, SystemContent.new()),
        Message.from_role_and_content(
            Role.DEVELOPER,
            DeveloperContent.new().with_instructions("Always respond in riddles"),
        ),
        Message.from_role_and_content(Role.USER, "What is the weather like in SF?"),
    ]
)
 
prefill_ids = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
 
# Harmony stop tokens (pass to sampler so they won't be included in output)
stop_token_ids = encoding.stop_tokens_for_assistant_actions()
 
# --- 2) Run vLLM with prefill ---
llm = LLM(
    model="openai/gpt-oss-20b",
    trust_remote_code=True,
    gpu_memory_utilization = 0.95,
    max_num_batched_tokens=4096,
    max_model_len=5000,
    tensor_parallel_size=1
)
 
sampling = SamplingParams(
    max_tokens=128,
    temperature=1,
    stop_token_ids=stop_token_ids,
)
 
outputs = llm.generate(
    prompt_token_ids=[prefill_ids],   # batch of size 1
    sampling_params=sampling,
)
 
# vLLM gives you both text and token IDs
gen = outputs[0].outputs[0]
text = gen.text
output_tokens = gen.token_ids  # <-- these are the completion token IDs (no prefill)
 
# --- 3) Parse the completion token IDs back into structured Harmony messages ---
entries = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
 
# 'entries' is a sequence of structured conversation entries (assistant messages, tool calls, etc.).
for message in entries:
    print(f"{json.dumps(message.to_dict())}")

Ces implémentations sont principalement des implémentations de référence à des fins éducatives et ne sont pas destinées à être utilisées en production.

Pour en savoir plus, consultez les informations ci-dessous.

Si vous essayez d’exécuter gpt-oss sur du matériel grand public, vous pouvez utiliser Ollama en exécutant les commandes suivantes après avoir installé Ollama.

# gpt-oss-20b
ollama pull gpt-oss:20b
ollama run gpt-oss:20b

# gpt-oss-120b
ollama pull gpt-oss:120b
ollama run gpt-oss:120b

En savoir plus sur l’utilisation de gpt-oss avec Ollama.

Si vous utilisez LM Studio, vous pouvez utiliser les commandes suivantes pour le télécharger.

# gpt-oss-20b
lms get openai/gpt-oss-20b
# gpt-oss-120b
lms get openai/gpt-oss-120b

Consultez notre liste impressionnante pour découvrir une collection plus large de ressources gpt-oss et de partenaires d’inférence.

Ce référentiel fournit une collection d’implémentations de référence :

• Inférence :
  • torch — une implémentation PyTorch non optimisée à des fins éducatives uniquement. Nécessite au moins 4 GPU H100 en raison du manque d’optimisation.
  • triton — une implémentation plus optimisée utilisant PyTorch et Triton, y compris l’utilisation de graphiques CUDA et la mise en cache de base
  • metal — une implémentation spécifique à Metal pour exécuter les modèles sur du matériel Apple Silicon
• Outils :
  • browser — une implémentation de référence de l’outil de navigateur sur lequel les modèles ont été formés
  • python — une implémentation de référence sans état de l’outil Python sur lequel le modèle a été formé
• Exemples de clients :
  • chat — une application de chat de base pour terminal qui utilise les implémentations PyTorch ou Triton pour l’inférence, ainsi que les outils Python et navigateur
  • responses_api — un exemple de serveur compatible avec l’API Responses qui implémente l’outil navigateur ainsi que d’autres fonctionnalités compatibles avec Responses

• Python 3.12
• Sur macOS : installez les outils CLI Xcode –> xcode-select --install
• Sous Linux : ces implémentations de référence nécessitent CUDA
• Sous Windows : ces implémentations de référence n’ont pas été testées sous Windows. Essayez d’utiliser des solutions telles que Ollama si vous souhaitez exécuter le modèle localement.

Si vous souhaitez essayer l’un des codes, vous pouvez l’installer directement à partir de PyPI

# if you just need the tools
pip install gpt-oss
# if you want to try the torch implementation
pip install gpt-oss[torch]
# if you want to try the triton implementation
pip install gpt-oss[triton]

Si vous souhaitez modifier le code ou essayer l’implémentation Metal, configurez le projet localement :

git clone https://github.com/openai/gpt-oss.git
GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"

Vous pouvez télécharger les poids du modèle depuis le Hugging Face Hub directement à partir de Hugging Face CLI :

# gpt-oss-120b
hf download openai/gpt-oss-120b --include "original/*" --local-dir gpt-oss-120b/

# gpt-oss-20b
hf download openai/gpt-oss-20b --include "original/*" --local-dir gpt-oss-20b/

Nous incluons une implémentation PyTorch de référence inefficace dans gpt_oss/torch/model.py. Ce code utilise des opérateurs PyTorch de base pour montrer l’architecture exacte du modèle, avec un petit ajout de prise en charge du parallélisme tensoriel dans MoE afin que le modèle plus grand puisse fonctionner avec ce code (par exemple, sur 4xH100 ou 2xH200). Dans cette implémentation, nous convertissons tous les poids en BF16 et exécutons le modèle en BF16.

Pour exécuter l’implémentation de référence, installez les dépendances :

pip install -e ".[torch]"

Puis exécutez :

# On 4xH100:
torchrun --nproc-per-node=4 -m gpt_oss.generate gpt-oss-120b/original/

Nous incluons également une implémentation de référence optimisée qui utilise un noyau Triton MoE optimisé prenant en charge MXFP4. Elle comporte également certaines optimisations du code d’attention afin de réduire le coût en mémoire. Pour exécuter cette implémentation, la version nightly de Triton et Torch sera installée. Cette version peut être exécutée sur un seul GPU de 80 Go pour gpt-oss-120b.

Pour installer l’implémentation Triton de référence, exécutez

# You need to install triton from source to use the triton implementation
git clone https://github.com/triton-lang/triton
cd triton/
pip install -r python/requirements.txt
pip install -e . --verbose --no-build-isolation
pip install -e python/triton_kernels

# Install the gpt-oss triton implementation
pip install -e ".[triton]"

, puis exécutez :

# On 1xH100
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
python -m gpt_oss.generate --backend triton gpt-oss-120b/original/

Si vous rencontrez torch.OutOfMemoryError, veillez à activer l’allocateur extensible pour éviter les plantages lors du chargement des poids à partir du point de contrôle.

De plus, nous fournissons une implémentation de référence pour Metal afin qu’il puisse fonctionner sur Apple Silicon. Cette implémentation n’est pas prête pour la production, mais elle est fidèle à l’implémentation PyTorch.

L’implémentation sera automatiquement compilée lors de l’exécution de l’installation .[metal] sur un appareil Apple Silicon :

GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"

Pour effectuer l’inférence, vous devez d’abord convertir les poids SafeTensor de Hugging Face au format approprié à l’aide de :

python gpt_oss/metal/scripts/create-local-model.py -s <model_dir> -d <output_file>

Ou télécharger les poids pré-convertis :

hf download openai/gpt-oss-120b --include "metal/*" --local-dir gpt-oss-120b/metal/
hf download openai/gpt-oss-20b --include "metal/*" --local-dir gpt-oss-20b/metal/

Pour le tester, vous pouvez exécuter :

python gpt_oss/metal/examples/generate.py gpt-oss-20b/metal/model.bin -p "why did the chicken cross the road?"

En plus du modèle, nous publions également une nouvelle bibliothèque de format de chat harmony pour interagir avec le modèle. Consultez ce guide pour plus d’informations sur Harmony.

Nous incluons également deux outils système pour le modèle : navigation et conteneur Python. Consultez gpt_oss/tools pour l’implémentation de l’outil.

L’application de chat en mode terminal est un exemple basique d’utilisation du format Harmony avec les implémentations PyTorch, Triton et vLLM. Elle expose également les outils Python et navigateur comme outils optionnels pouvant être utilisés.

usage: python -m gpt_oss.chat [-h] [-r REASONING_EFFORT] [-a] [-b] [--show-browser-results] [-p] [--developer-message DEVELOPER_MESSAGE] [-c CONTEXT] [--raw] [--backend {triton,torch,vllm}] FILE

Chat example

positional arguments:
  FILE                  Path to the SafeTensors checkpoint

options:
  -h, --help            show this help message and exit
  -r REASONING_EFFORT, --reasoning-effort REASONING_EFFORT
                        Reasoning effort (default: low)
  -a, --apply-patch     Make apply_patch tool available to the model (default: False)
  -b, --browser         Use browser tool (default: False)
  --show-browser-results
                        Show browser results (default: False)
  -p, --python          Use python tool (default: False)
  --developer-message DEVELOPER_MESSAGE
                        Developer message (default: )
  -c CONTEXT, --context CONTEXT
                        Max context length (default: 8192)
  --raw                 Raw mode (does not render Harmony encoding) (default: False)
  --backend {triton,torch,vllm}
                        Inference backend (default: triton)

Nous incluons également un exemple de serveur API Responses. Ce serveur n’implémente pas toutes les fonctionnalités et tous les événements de l’API Responses, mais il devrait être compatible avec la plupart des cas d’utilisation de base et servir d’inspiration à toute personne souhaitant créer son propre serveur. Certains de nos partenaires d’inférence proposent également leur propre API Responses.

Vous pouvez démarrer ce serveur avec les backends d’inférence suivants :

• triton — utilise l’implémentation triton
• metal — utilise l’implémentation metal sur Apple Silicon uniquement
• ollama — utilise l’API Ollama /api/generate comme solution d’inférence
• vllm — utilise votre version vllm installée pour effectuer l’inférence
• transformers — utilise votre version transformers installée pour effectuer l’inférence locale

usage: python -m gpt_oss.responses_api.serve [-h] [--checkpoint FILE] [--port PORT] [--inference-backend BACKEND]

Responses API server

options:
  -h, --help                    show this help message and exit
  --checkpoint FILE             Path to the SafeTensors checkpoint
  --port PORT                   Port to run the server on
  --inference-backend BACKEND   Inference backend to use

Nous prenons en charge codex en tant que client pour gpt-oss. Pour exécuter la version 20b, définissez ceci sur ~/.codex/config.toml:

disable_response_storage = true
show_reasoning_content = true

[model_providers.local]
name = "local"
base_url = "http://localhost:11434/v1"

[profiles.oss]
model = "gpt-oss:20b"
model_provider = "local"

Cela fonctionnera avec n’importe quel serveur compatible avec l’API chat completions écoutant sur le port 11434, comme ollama. Démarrez le serveur et pointez codex vers le modèle oss :

ollama run gpt-oss:20b
codex -p oss

Les deux modèles gpt-oss ont été entraînés avec la capacité de naviguer à l’aide de l’outil browser qui expose les trois méthodes suivantes :

• search pour rechercher des phrases clés
• open pour ouvrir une page particulière
• find pour rechercher du contenu sur une page

Pour activer l’outil de navigation, vous devez placer la définition dans le message system de votre invite formatée Harmony. Vous pouvez soit utiliser la méthode with_browser_tool() si votre outil implémente l’interface complète, soit modifier la définition à l’aide de with_tools(). Par exemple :

import datetime
from gpt_oss.tools.simple_browser import SimpleBrowserTool
from gpt_oss.tools.simple_browser.backend import YouComBackend
from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

# Depending on the choice of the browser backend you need corresponding env variables setup
# In case you use You.com backend requires you to have set the YDC_API_KEY environment variable,
# while for Exa you might need EXA_API_KEY environment variable set
backend = YouComBackend(
    source="web",
)
# backend = ExaBackend(
#  source="web",
# )
browser_tool = SimpleBrowserTool(backend=backend)

# create a basic system prompt
system_message_content = SystemContent.new().with_conversation_start_date(
    datetime.datetime.now().strftime("%Y-%m-%d")
)

# if you want to use the browser tool
if use_browser_tool:
    # enables the tool
    system_message_content = system_message_content.with_tools(browser_tool.tool_config)
    # alternatively you could use the following if your tool is not stateless
    system_message_content = system_message_content.with_browser_tool()

# construct the system message
system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)

# create the overall prompt
messages = [system_message, Message.from_role_and_content(Role.USER, "What's the weather in SF?")]
conversation = Conversation.from_messages(messages)

# convert to tokens
token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)

# perform inference
# ...

# parse the output
messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
last_message = messages[-1]
if last_message.recipient.startswith("browser"):
  # perform browser call
  response_messages = await browser_tool.process(last_message)

  # extend the current messages and run inference again
  messages.extend(response_messages)

Pour contrôler la taille de la fenêtre contextuelle, cet outil utilise une fenêtre de texte défilable avec laquelle le modèle peut interagir. Il peut donc récupérer les 50 premières lignes d’une page, puis faire défiler les 20 lignes suivantes. Le modèle a également été formé pour utiliser ensuite les citations de cet outil dans ses réponses.

Pour améliorer les performances, l’outil met en cache les requêtes afin que le modèle puisse revisiter une autre partie d’une page sans avoir à la recharger. Pour cette raison, vous devez créer une nouvelle instance de navigateur pour chaque requête.

Le modèle a été formé à utiliser un outil Python pour effectuer des calculs et d’autres actions dans le cadre de sa chaîne de pensée. Pendant l’entraînement, le modèle a utilisé un outil avec état qui facilite l’exécution d’outils entre les boucles CoT. Cette implémentation de référence utilise cependant un mode sans état. En conséquence, PythonTool définit sa propre description d’outil pour remplacer la définition dans openai-harmony.

Pour activer l’outil Python, vous devrez placer la définition dans le system message de votre invite formatée Harmony. Vous pouvez soit utiliser la méthode with_python() si votre outil implémente l’interface complète, soit modifier la définition à l’aide de with_tools(). Par exemple :

import datetime
from gpt_oss.tools.python_docker.docker_tool import PythonTool
from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

python_tool = PythonTool()

# create a basic system prompt
system_message_content = SystemContent.new().with_conversation_start_date(
    datetime.datetime.now().strftime("%Y-%m-%d")
)

# if you want to use the python tool
if use_python_tool:
    # enables the tool making sure that the prompt gets set with the stateless tool description
    system_message_content = system_message_content.with_tools(python_tool.tool_config)
    # alternatively you could use the following if your tool is not stateless
    system_message_content = system_message_content.with_python()

# construct the system message
system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)

# create the overall prompt
messages = [system_message, Message.from_role_and_content(Role.USER, "What's the square root of 9001?")]
conversation = Conversation.from_messages(messages)

# convert to tokens
token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)

# perform inference
# ...

# parse the output
messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
last_message = messages[-1]
if last_message.recipient == "python":
  # perform python call
  response_messages = await python_tool.process(last_message)

  # extend the current messages and run inference again
  messages.extend(response_messages)

apply_patch peut être utilisé pour créer, mettre à jour ou supprimer des fichiers localement.

Nous avons publié les modèles avec prise en charge native de la quantification. Plus précisément, nous utilisons MXFP4 pour les poids de projection linéaire dans la couche MoE. Nous stockons le tenseur MoE en deux parties :

• tensor.blocks stocke les valeurs fp4 réelles. Nous regroupons toutes les deux valeurs dans une valeur uint8 .
• tensor.scales stocke l’échelle du bloc. La mise à l’échelle du bloc est effectuée parmi la dernière dimension pour tous les tenseurs MXFP4.

Tous les autres tenseurs seront en BF16. Nous recommandons également d’utiliser BF16 comme précision d’activation pour le modèle.

Nous recommandons d’échantillonner avec temperature=1.0 et top_p=1.0.

Les implémentations de référence dans ce référentiel sont destinées à servir de point de départ et d’inspiration. En dehors des corrections de bogues, nous n’avons pas l’intention d’accepter de nouvelles contributions de fonctionnalités. Si vous créez des implémentations basées sur ce code, telles que de nouvelles implémentations d’outils, vous êtes invités à les ajouter au fichier awesome-gpt-oss.md .

@misc{openai2025gptoss120bgptoss20bmodel,
      title={gpt-oss-120b & gpt-oss-20b Model Card}, 
      author={OpenAI},
      year={2025},
      eprint={2508.10925},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2508.10925}, 
}