copied files

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/gpt-oss-20b.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (pythonProject)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/gpt-oss-20b.iml" filepath="$PROJECT_DIR$/.idea/gpt-oss-20b.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

README.md

@@ -0,0 +1,183 @@
+---
+license: apache-2.0
+base_model: openai/gpt-oss-20b
+pipeline_tag: text-generation
+library_name: transformers
+tags:
+    - vllm
+---
+
+<p align="center">
+  <img alt="gpt-oss-20b" src="https://raw.githubusercontent.com/openai/gpt-oss/main/docs/gpt-oss-20b.svg">
+</p>
+
+<p align="center">
+  <a href="https://gpt-oss.com"><strong>Try gpt-oss</strong></a> ·
+  <a href="https://cookbook.openai.com/topic/gpt-oss"><strong>Guides</strong></a> ·
+  <a href="https://arxiv.org/abs/2508.10925"><strong>Model card</strong></a> ·
+  <a href="https://openai.com/index/introducing-gpt-oss/"><strong>OpenAI blog</strong></a>
+</p>
+
+<br>
+
+Welcome to the gpt-oss series, [OpenAI’s open-weight models](https://openai.com/open-models) designed for powerful reasoning, agentic tasks, and versatile developer use cases.
+
+We’re releasing two flavors of these open models:
+- `gpt-oss-120b` — for production, general purpose, high reasoning use cases that fit into a single 80GB GPU (like NVIDIA H100 or AMD MI300X) (117B parameters with 5.1B active parameters)
+- `gpt-oss-20b` — for lower latency, and local or specialized use cases (21B parameters with 3.6B active parameters)
+
+Both models were trained on our [harmony response format](https://github.com/openai/harmony) and should only be used with the harmony format as it will not work correctly otherwise.
+
+
+> [!NOTE]
+> This model card is dedicated to the smaller `gpt-oss-20b` model. Check out [`gpt-oss-120b`](https://huggingface.co/openai/gpt-oss-120b) for the larger model.
+
+# Highlights
+
+* **Permissive Apache 2.0 license:** Build freely without copyleft restrictions or patent risk—ideal for experimentation, customization, and commercial deployment.  
+* **Configurable reasoning effort:** Easily adjust the reasoning effort (low, medium, high) based on your specific use case and latency needs.  
+* **Full chain-of-thought:** Gain complete access to the model’s reasoning process, facilitating easier debugging and increased trust in outputs. It’s not intended to be shown to end users.  
+* **Fine-tunable:** Fully customize models to your specific use case through parameter fine-tuning.
+* **Agentic capabilities:** Use the models’ native capabilities for function calling, [web browsing](https://github.com/openai/gpt-oss/tree/main?tab=readme-ov-file#browser), [Python code execution](https://github.com/openai/gpt-oss/tree/main?tab=readme-ov-file#python), and Structured Outputs.
+* **MXFP4 quantization:** The models were post-trained with MXFP4 quantization of the MoE weights, making `gpt-oss-120b` run on a single 80GB GPU (like NVIDIA H100 or AMD MI300X) and the `gpt-oss-20b` model run within 16GB of memory. All evals were performed with the same MXFP4 quantization.
+
+---
+
+# Inference examples
+
+## Transformers
+
+You can use `gpt-oss-120b` and `gpt-oss-20b` with Transformers. If you use the Transformers chat template, it will automatically apply the [harmony response format](https://github.com/openai/harmony). If you use `model.generate` directly, you need to apply the harmony format manually using the chat template or use our [openai-harmony](https://github.com/openai/harmony) package.
+
+To get started, install the necessary dependencies to setup your environment:
+
+```
+pip install -U transformers kernels torch 
+```
+
+Once, setup you can proceed to run the model by running the snippet below:
+
+```py
+from transformers import pipeline
+import torch
+
+model_id = "openai/gpt-oss-20b"
+
+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])
+```
+
+Alternatively, you can run the model via [`Transformers Serve`](https://huggingface.co/docs/transformers/main/serving) to spin up a OpenAI-compatible webserver:
+
+```
+transformers serve
+transformers chat localhost:8000 --model-name-or-path openai/gpt-oss-20b
+```
+
+[Learn more about how to use gpt-oss with Transformers.](https://cookbook.openai.com/articles/gpt-oss/run-transformers)
+
+## vLLM
+
+vLLM recommends using [uv](https://docs.astral.sh/uv/) for Python dependency management. You can use vLLM to spin up an OpenAI-compatible webserver. The following command will automatically download the model and start the server.
+
+```bash
+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
+```
+
+[Learn more about how to use gpt-oss with vLLM.](https://cookbook.openai.com/articles/gpt-oss/run-vllm)
+
+## PyTorch / Triton
+
+To learn about how to use this model with PyTorch and Triton, check out our [reference implementations in the gpt-oss repository](https://github.com/openai/gpt-oss?tab=readme-ov-file#reference-pytorch-implementation).
+
+## Ollama
+
+If you are trying to run gpt-oss on consumer hardware, you can use Ollama by running the following commands after [installing Ollama](https://ollama.com/download).
+
+```bash
+# gpt-oss-20b
+ollama pull gpt-oss:20b
+ollama run gpt-oss:20b
+```
+
+[Learn more about how to use gpt-oss with Ollama.](https://cookbook.openai.com/articles/gpt-oss/run-locally-ollama)
+
+#### LM Studio
+
+If you are using [LM Studio](https://lmstudio.ai/) you can use the following commands to download.
+
+```bash
+# gpt-oss-20b
+lms get openai/gpt-oss-20b
+```
+
+Check out our [awesome list](https://github.com/openai/gpt-oss/blob/main/awesome-gpt-oss.md) for a broader collection of gpt-oss resources and inference partners.
+
+---
+
+# Download the model
+
+You can download the model weights from the [Hugging Face Hub](https://huggingface.co/collections/openai/gpt-oss-68911959590a1634ba11c7a4) directly from Hugging Face CLI:
+
+```shell
+# gpt-oss-20b
+huggingface-cli download openai/gpt-oss-20b --include "original/*" --local-dir gpt-oss-20b/
+pip install gpt-oss
+python -m gpt_oss.chat model/
+```
+
+# Reasoning levels
+
+You can adjust the reasoning level that suits your task across three levels:
+
+* **Low:** Fast responses for general dialogue.  
+* **Medium:** Balanced speed and detail.  
+* **High:** Deep and detailed analysis.
+
+The reasoning level can be set in the system prompts, e.g., "Reasoning: high".
+
+# Tool use
+
+The gpt-oss models are excellent for:
+* Web browsing (using built-in browsing tools)
+* Function calling with defined schemas
+* Agentic operations like browser tasks
+
+# Fine-tuning
+
+Both gpt-oss models can be fine-tuned for a variety of specialized use cases.
+
+This smaller model `gpt-oss-20b` can be fine-tuned on consumer hardware, whereas the larger [`gpt-oss-120b`](https://huggingface.co/openai/gpt-oss-120b) can be fine-tuned on a single H100 node.
+
+# Citation
+
+```bibtex
+@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}, 
+}
+```

handler.py

@@ -0,0 +1,126 @@
+from typing import Dict, List, Any
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+from fastapi.responses import StreamingResponse
+import uuid
+import time
+import json
+from threading import Thread
+
+class EndpointHandler:
+    def __init__(self, path: str = "openai/gpt-oss-20b"):
+        # Load tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained(path)
+        self.model = AutoModelForCausalLM.from_pretrained(path)
+        self.model.eval()
+
+        # Determine the computation device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(self.device)
+
+    def openai_id(prefix: str) -> str:
+        return f"{prefix}-{uuid.uuid4().hex[:24]}"
+
+    def format_non_stream(self, model: str, text: str, prompt_length: int, completion_length: int, total_tokens: int):
+        # Create OpenAI-compatible payload
+        return {
+            "id": self.openai_id("chatcmpl"),
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": text},
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": prompt_length,
+                "completion_tokens": completion_length,
+                "total_tokens": total_tokens
+            }
+        }
+
+    def format_stream(self, model: str, token: str, usage) -> bytes:
+        payload = {
+            "id": self.openai_id("chatcmpl"),
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "content": token,
+                    "function_call": None,
+                    "refusal": None,
+                    "role": None,
+                    "tool_calls": None
+                },
+                "finish_reason": None,
+                "logprobs": None
+            }],
+            "usage": usage
+        }
+
+        return f"data: {json.dumps(payload)}\n\n".encode('utf-8')
+
+    def generate(self, messages, model: str):
+        model_inputs = self.tokenizer(messages, return_tensors="pt").to(self.device)
+        full_output = self.model.generate(**model_inputs, max_new_tokens=2048)
+        generated_ids = [
+            output_ids[len(input_ids):]
+            for input_ids, output_ids in zip(model_inputs.input_ids, full_output)
+        ]
+        text = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=False)[0]
+
+        input_length = model_inputs.input_ids.shape[1]  # Prompt tokens
+        output_length = full_output.shape[1]  # Total tokens (prompt + completion)
+        completion_tokens = output_length - input_length
+
+        return self.format_non_stream(model, text, input_length, completion_tokens, output_length)
+
+    def stream(self, messages, model):
+        model_inputs = self.tokenizer(messages, return_tensors="pt").to(self.device)
+        input_len = model_inputs.input_ids.shape[1]
+        streamer = TextIteratorStreamer(
+            self.tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True
+        )
+
+        generation_kwargs = dict(
+            **model_inputs,
+            streamer=streamer,
+            max_new_tokens=2048
+        )
+
+        thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
+        thread.start()
+
+        completion_tokens = 0
+        for token in streamer:
+            # Count tokens in each chunk
+            token_ids = self.tokenizer.encode(token, add_special_tokens=False)
+            token_count = len(token_ids)
+            completion_tokens += token_count
+
+            yield self.format_stream(model, token, None)
+
+        # Final chunk with stop reason and token counts
+        yield self.format_stream(model, "", {
+            "prompt_tokens": input_len,
+            "completion_tokens": completion_tokens,
+            "total_tokens": input_len + completion_tokens
+        })
+
+    def __call__(self, data: Dict[str, Any]):
+        messages = data.get("messages")
+        model = data.get("model")
+        stream = data.get("stream", False)
+
+        if stream is False:
+            return self.generate(messages, model)
+        else:
+            return StreamingResponse(
+                self.stream(messages, model),
+                media_type="text/event-stream"
+            )