

Marketplace

Pre-Installed GPT-OSS

Get GPT-OSS pre-installed and ready to go from the Database Mart Marketplace—just deploy and use, no setup hassle.

Overview

GPT-OSS is an advanced open-weight reasoning model from OpenAI. Available in 120B and 20B variants under Apache 2.0, it supports natural language understanding, coding, tool use, file processing, and agentic workflows.

Select a pre-installed GPT-OSS Marketplace image and get a fully configured server that's ready to use immediately — no manual installation or complex setup required.

Supported Operating Systems

The GPT-OSS Marketplace image is available for Ubuntu Server 24 LTS 64-bit.

Supported Products / Plans

1. GPT-OSS-20B

The GPT-OSS-20B Marketplace image is currently available across 2 GPU VPS plans and 4 GPU-dedicated server plans:

GPU VPS Plan:

Professional GPU VPS - RTX A4000
Advanced GPU VPS - RTX 5090

GPU-Dedicated Server Plans:

Advanced Dedicated GPU Server - V100
Advanced Dedicated GPU Server - RTX A5000
Enterprise Dedicated GPU Server - RTX 4090
Enterprise Dedicated GPU Server - A100

View compatible plans →

2. GPT-OSS-120B

The GPT-OSS-120B Marketplace image is currently available across the following 3 GPU-dedicated server plans:

Enterprise Multi-GPU Dedicated Server - 3xRTX A6000
Enterprise Dedicated GPU Server - A100(80GB)
Enterprise Dedicated GPU Server - H100

View compatible plans →

GPT-OSS Version

Database Mart offers the latest version of GPT-OSS, pre-installed and ready to use.

What's Installed

Core Operating Environment

Operating System: Ubuntu Server 24 LTS
Python Environment: Pre-installed Python with a dedicated virtual environment (Conda or venv) for dependency management
Core Dependencies: PyTorch 2.0+, Transformers library, and other essential libraries

GPT-OSS Core Components

Model Weights: The pre-trained parameter model weights downloaded from Hugging Face (openai/gpt-oss-20b or openai/gpt-oss-120b)
Configuration Files: config.json, tokenizer.json, and other files defining the model structure and tokenization rules
Inference Optimization Tools: Components like vLLM, TensorRT-LLM, or Transformers for efficient, high-speed inference

Hardware & GPU Support

CUDA & cuDNN: Pre-installed for NVIDIA GPU acceleration
Model Quantization: Both models are natively quantized to MXFP4 format (4.25 bits per parameter), reducing memory footprint while maintaining performance. The 20B version requires approximately 16GB VRAM, while the 120B version requires approximately 60-80GB VRAM

Installation Process

During server provisioning, Database Mart automatically performs the following steps:

Deploys the selected Linux operating system (Ubuntu Server 24 LTS).
Installs the selected GPT-OSS model version (gpt-oss-20b or gpt-oss-120b) with all pre-trained weights and configuration files.
Installs and configures all required components, including:
- Python 3.10+ with a dedicated virtual environment (Conda or venv)
- PyTorch 2.0+ and the Transformers library
- vLLM or TensorRT-LLM for high-performance inference
- CUDA and cuDNN for GPU acceleration
- Model weights (approximately 16GB for 20B or 65GB+ for 120B)
- FlashAttention and other optimization libraries

Everything is fully automated—your DeepSeek server is ready to use as soon as deployment is complete.

Getting Started After Deployment

After your server has been provisioned, follow these steps to begin using DeepSeek.

Step 1: Access the Server

Once deployment is complete, connect to your server via SSH using the credentials provided by Database Mart:

ssh administrator@your-server-ip

The GPT-OSS model files are pre-installed in the designated directory (typically /opt/gpt-oss or a similar location).

Step 2: Verify the Installation

Check that all components are properly installed and the model is ready:

# Verify CUDA and GPU availability
nvidia-smi

# Check Python environment
python3 --version

# Navigate to the GPT-OSS directory
cd /opt/gpt-oss

# List model files
ls -la
The model weights (approximately 16GB for the 20B version or 65GB+ for the 120B version) should be present in the model directory.

Step 3: Start the Inference Service

The server comes with vLLM pre-configured for high-performance inference. Start the service using:

# For GPT-OSS-20B
vllm serve openai/gpt-oss-20b --host 0.0.0.0 --port 8000

# For GPT-OSS-120B
vllm serve openai/gpt-oss-120b --host 0.0.0.0 --port 8000

Recommended flags:

--host 0.0.0.0: Binds the server to all network interfaces
--port 8000: Specifies the API port
--max-model-len 32768: Reduces context length for better memory efficiency on single GPU setups

The API server will start and be accessible at http://your-server-ip:8000/v1.

Step 4: Test the API with a Simple Request

Once the service is running, you can test it using the OpenAI-compatible API endpoint:

from openai import OpenAI

# Connect to your local GPT-OSS server
client = OpenAI(
    api_key="EMPTY",  # Not required for local deployment
    base_url="http://localhost:8000/v1"
)

# Send a test request
messages = [{"role": "user", "content": "Explain quantum computing in simple terms"}]

response = client.chat.completions.create(
    model="openai/gpt-oss-20b",  # or "openai/gpt-oss-120b"
    messages=messages
)

# The response includes both reasoning steps and final answer
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)

Step 5: Alternative: Use the API Endpoint Directly

If you prefer a standard REST API call without the OpenAI client:

curl -X POST "http://localhost:8000/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-20b",
    "messages": [{"role": "user", "content": "Hello, who are you?"}],
    "stream": false
  }'
Step 6: Enable Streaming for Long Responses
For real-time output (especially useful for longer responses), enable streaming:
data["stream"] = True

response = requests.post("http://localhost:8000/v1/chat/completions", 
                         headers=headers, 
                         json=data, 
                         stream=True)

for chunk in response.iter_lines():
    if chunk:
        print(chunk.decode('utf-8'))

Step 7: Using Tools (Function Calling)

GPT-OSS supports function calling through both the Chat Completions and Responses APIs:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather in a given city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"]
            },
        },
    }
]

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "What's the weather in Berlin right now?"}],
    tools=tools
)

print(response.choices[0].message)

Since the models perform tool calling as part of the chain-of-thought, return the reasoning back into a subsequent call to a tool where you provide the answer until the model reaches a final answer.

Notes

Keep System Prompts Simple

For optimal performance, avoid adding a system prompt — put all instructions directly in the system or developer message. The reasoning effort should be set in the system prompt.

Optimize Token Usage for Cost Efficiency

If cost is a concern, consider these strategies:

Use semantic caching: Cache responses for identical or similar prompts using hash-based storage
Limit output length: Use max_tokens to control output length
Compress inputs: Pre-summarize long documents before sending to the model
Use JSON-structured outputs: This reduces unnecessary natural language tokens

Tool Use Support

GPT-OSS models support native capabilities for:

Function calling with defined schemas
Web browsing using built-in tools
Python code execution
Structured outputs

Function calling is performed as part of the chain-of-thought process — return the reasoning back into a subsequent call to a tool until the model reaches a final answer.

Frequently Asked Questions

Q: What GPT-OSS models are available from Database Mart?

Database Mart offers two pre-installed GPT-OSS variants:

GPT-OSS-120B: The full-scale enterprise-grade model for complex language tasks
GPT-OSS-20B: A lightweight variant designed for low-latency inference and real-time applications

Q: What's the benefit of using a pre-installed image vs. manual deployment?

The pre-installed image handles all the heavy lifting for you:

OS installation and configuration
Python environment setup with all dependencies
Model weight download (16GB+ for 20B, 65GB+ for 120B)
vLLM or TensorRT-LLM inference engine configuration
CUDA and cuDNN setup for GPU acceleration
REST API endpoint pre-configured

You get a "ready-to-run" environment immediately after deployment, skipping hours of manual setup and troubleshooting.

Q: What inference engines are supported?

Both models work with multiple inference engines:

vLLM: Recommended for production serving with high throughput
Ollama: For local deployment on consumer hardware
LM Studio: User-friendly desktop app for Windows, macOS, and Linux
TensorRT-LLM: NVIDIA-optimized for high-performance inference
Transformers (Hugging Face): For flexible, code-level control

The pre-installed image comes with vLLM pre-configured and ready to use.

Q: Does GPT-OSS support function calling?

Yes. Both models support function calling through the Chat Completions and Responses APIs. The models perform tool calling as part of the chain-of-thought process — you return the reasoning in a subsequent call until the model reaches a final answer.