Pre-Installed DeepSeek

Overview

DeepSeek is an advanced AI-powered assistant that integrates capabilities for natural language understanding, content generation, coding assistance, research support, file processing, and problem-solving into a single intelligent system.

Select a pre-installed DeepSeek 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 DeepSeek Marketplace image is available for Ubuntu Server 24 LTS 64-bit.

Supported Products / Plans

1. DeepSeek-R1-32B

The DeepSeek-R1-32B Marketplace image is currently available across 1 GPU VPS plan and 4 GPU-dedicated server plans:

GPU VPS Plan:
Advanced GPU VPS – RTX 5090

GPU-Dedicated Server Plans:

• Advanced Dedicated GPU Server – RTX A5000
• Enterprise Dedicated GPU Server – RTX 5090
• Enterprise Dedicated GPU Server – RTX 4090
• Enterprise Dedicated GPU Server – A100

View compatible plans →

2. DeepSeek-R1-70B

The DeepSeek-R1-70B Marketplace image is currently available across the following 4 GPU-dedicated server plans:

• Enterprise Dedicated GPU Server – RTX A6000
• Enterprise Multi-GPU Dedicated Server – 2x RTX 4090
• Enterprise Dedicated GPU Server – A100 (80GB)
• Enterprise Dedicated GPU Server – H100

View compatible plans →

DeepSeek Version

Database Mart offers the latest version of DeepSeek, 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, Transformers library, vLLM (for optimized inference), NumPy, and other essential libraries

DeepSeek Core Components

• Model Architecture Code: Full model definition files
• Model Weights: The pre-trained parameter model weights
• Configuration Files: config.json, tokenizer.json, and other files defining the model structure and tokenization rules
• Inference Optimization Tools: Components like FlashAttention, vLLM, or TensorRT-LLM for efficient, high-speed inference

Hardware & GPU Support

• CUDA & cuDNN: Pre-installed for NVIDIA GPU acceleration
• Model Quantization: May include quantized versions (4-bit or 8-bit) to reduce memory usage and improve inference speed on more modest hardware

Installation Process

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

1. Deploys the selected Linux operating system.

2. Installs the selected DeepSeek model version (DeepSeek-R1-32B or DeepSeek-R1-70B) with all pre-trained weights and configuration files.

3. Installs and configures all required components, including:

   • Python with a dedicated virtual environment (Conda or venv)
   • PyTorch and Transformers library
   • vLLM or TensorRT-LLM for high-performance inference
   • CUDA and cuDNN for GPU acceleration
   • Model weights (approximately 65GB for 32B or 140GB+ for 70B)
   • 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

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 DeepSeek directory
cd /opt/deepseek-r1

# List model files
ls -la

The model weights 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:

vllm serve /path/to/deepseek-r1-32b \
    --enable-reasoning \
    --reasoning-parser deepseek_r1 \
    --host 0.0.0.0 \
    --port 8000

Key flags explained :

• --enable-reasoning: Enables the model's reasoning capabilities
• --reasoning-parser deepseek_r1: Specifies the parser for extracting reasoning steps from the output

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 DeepSeek 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="deepseek-r1-32b",
    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:

import requests

url = "http://localhost:8000/v1/chat/completions"
headers = {"Content-Type": "application/json"}
data = {
    "model": "deepseek-r1-32b",
    "messages": [{"role": "user", "content": "Hello, who are you?"}],
    "stream": False
}

response = requests.post(url, headers=headers, json=data)
print(response.json()["choices"][0]["message"]["content"])

Step 6: Enable Streaming for Long Responses

For real-time output (especially useful for longer responses), enable streaming:

data["stream"] = True

response = requests.post(url, headers=headers, json=data, stream=True)

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

Next Steps & Resources

Once you've verified that the service is running correctly, you can:

• Configure environment variables for production use (e.g., batch size, GPU memory allocation)
• Set up multi-GPU inference if your server has multiple GPUs
• Integrate the API with your applications or workflows
• Monitor performance using built-in logging tools
  For more detailed guidance, consult the official DeepSeek documentation and vLLM docs for advanced deployment options.

Notes

• Enable FlashAttention for faster inference. This optimization can speed up inference by up to 2x. It's supported in vLLM and SGLang.
• Set recommended sampling parameters. Use a temperature between 0.5 and 0.7 (0.6 is commonly recommended) to avoid repetition or incoherent outputs. Avoid adding a system prompt — put all instructions directly in the user prompt.
• Use vLLM or SGLang for production serving. Both are recommended for high throughput and memory efficiency. vLLM is the most widely adopted option with good community support.
• Use containerization for consistency. Docker images (e.g., NVIDIA CUDA base images or vLLM-provided images) simplify environment setup and ensure reproducibility, especially in multi-node deployments.

Frequently Asked Questions

Q: What's the difference between DeepSeek-R1 and DeepSeek-V3? Which one should I use?

DeepSeek-R1 is a reasoning model that excels at complex tasks requiring strict logical chains, such as advanced math and deep code reasoning. It uses a "chain of thought" process to think through problems before answering, which can take longer but yields highly accurate results for complex problems. DeepSeek-V3 is a general-purpose model better suited for creative writing, multi-turn dialogues, and routine interactions. For most technical or problem-solving workloads, R1 is the better choice.

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, Python environment setup, dependency installation (PyTorch, Transformers, vLLM), CUDA/cuDNN configuration, and downloading the model weights (which can be 65GB+ for the 32B version). You get a "ready-to-run" environment immediately after deployment, skipping hours of manual setup and troubleshooting.

Q: What are the recommended settings for optimal performance?

According to official DeepSeek guidance :

• Do NOT use a system prompt. Put all instructions in the user prompt.
• Set temperature to 0.6 (range 0.5-0.7 is acceptable) to prevent repetitive or incoherent outputs.
• Force the thinking process by ensuring each output starts with \n to prevent the model from skipping reasoning steps.