Model reference · open weights

Starling-LM-alpha

LLMs berkeley-nest Text gen 1 build Open weights 1k dl/mo

Starling-LM-alpha is an open-weight language model from berkeley-nest. Starling-LM-7B-alpha (BF16) weighs 14.5 GB; the smallest configuration that runs it is 2× RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Starling-LM-alpha is a 7.2B parameter language model developed by berkeley-nest for text generation tasks.
  • It is finetuned from Openchat 3.5 using Reinforcement Learning from AI Feedback and supports a context length of 8192 tokens in English.
  • The model is released under the Apache-2.0 license.

Summary of the berkeley-nest/Starling-LM-7B-alpha model card, 2026-10-01

What it is

Released byberkeley-nest
Released2023-11-25
Parameters7.2B
VRAM14.5 GB for the weights

What it runs on

Memory and cards for Starling-LM-7B-alpha (BF16)

14.5 GBweights, file size
0 MBcache per 1K tokens
1.1 GBwindow cache per request
647 MBruntime overhead, at least
8,192 tokenscontext max
CardRequests at onceContext maxMemory
8K each
RTX 3060 12 GB11.6 GB
RTX 4060 Ti 16 GB15.4 GB
RTX 3090 24 GB7all 8K23.4 GB
RTX 4090 24 GB7all 8K23.4 GB
RTX 5090 32 GB14all 8K31.0 GB
L40S 48 GB26all 8K44.0 GB
A100 80 GB58all 8K78.2 GB
H100 80 GB55all 8K78.1 GB
RTX PRO 6000 Blackwell 96 GB70all 8K93.8 GB
DGX Spark (GB10) 128 GB unified83all 8K107 GB
H200 141 GB111all 8K138 GB
B200 180 GB146all 8K176 GB
2× RTX 3060 12 GB
tensor parallel
6all 8K11.6 GB a card
2× RTX 4060 Ti 16 GB
tensor parallel
14all 8K15.4 GB a card
2× RTX 4090 24 GB
tensor parallel
28all 8K23.4 GB a card
2× RTX 3090 24 GB
tensor parallel
28all 8K23.4 GB a card
Memory needed at each load
Requests at once8K tokens each
116.2 GB
520.5 GB
823.7 GB
1632.3 GB
3249.5 GB
6483.8 GB

One card, with vLLM's small-card settings.

From the model card

What berkeley-nest says about Starling-LM-alpha

Read the model card
  • Developed by: Banghua Zhu * , Evan Frick * , Tianhao Wu * , Hanlin Zhu and Jiantao Jiao.
  • Model type: Language Model finetuned with RLHF / RLAIF
  • License: Apache-2.0 license under the condition that the model is not used to compete with OpenAI
  • Finetuned from model: Openchat 3.5 (based on Mistral-7B-v0.1)

We introduce Starling-7B, an open large language model (LLM) trained by Reinforcement Learning from AI Feedback (RLAIF). The model harnesses the power of our new GPT-4 labeled ranking dataset, berkeley-nest/Nectar, and our new reward training and policy tuning pipeline. Starling-7B-alpha scores 8.09 in MT Bench with GPT-4 as a judge, outperforming every model to date on MT-Bench except for OpenAI's GPT-4 and GPT-4 Turbo. We release the ranking dataset Nectar, the reward model Starling-RM-7B-alpha and the language model Starling-LM-7B-alpha on HuggingFace, and an online demo in LMSYS Chatbot Arena. Stay tuned for our forthcoming code and paper, which will provide more details on the whole process.

Starling-LM-7B-alpha is a language model trained from Openchat 3.5 with reward model berkeley-nest/Starling-RM-7B-alpha and policy optimization method advantage-induced policy alignment (APA). The evaluation results are listed below.

ModelTuning MethodMT BenchAlpacaEvalMMLU
GPT-4-Turbo?9.3297.70
GPT-4SFT + PPO8.9995.2886.4
Starling-7BC-RLFT + APA8.0991.9963.9
Claude-2?8.0691.3678.5
GPT-3.5-Turbo?7.9489.3770
Claude-1?7.988.3977
Tulu-2-dpo-70bSFT + DPO7.8995.1
Openchat-3.5C-RLFT7.8188.5164.3
Zephyr-7B-betaSFT + DPO7.3490.6061.4
Llama-2-70b-chat-hfSFT + PPO6.8692.6663
Neural-chat-7b-v3-1SFT + DPO6.8484.5362.4
Tulu-2-dpo-7bSFT + DPO6.2985.1

For more detailed discussions, please check out our blog post, and stay tuned for our upcoming code and paper!

  • Blog: https://starling.cs.berkeley.edu/
  • Paper: Coming soon!
  • Code: Coming soon!

Uses

Important: Please use the exact chat template provided below for the model. Otherwise there will be a degrade in the performance. The model output can be verbose in rare cases. Please consider setting temperature = 0 to make this happen less.

Our model follows the exact chat template and usage as Openchat 3.5. Please refer to their model card for more details. In addition, our model is hosted on LMSYS Chatbot Arena for free test.

The conversation template is the same as Openchat 3.5:

import transformers
tokenizer = transformers.AutoTokenizer.from_pretrained("openchat/openchat_3.5")

# Single-turn
tokens = tokenizer("GPT4 Correct User: HelloGPT4 Correct Assistant:").input_ids
assert tokens == [1, 420, 6316, 28781, 3198, 3123, 1247, 28747, 22557, 32000, 420, 6316, 28781, 3198, 3123, 21631, 28747]

# Multi-turn
tokens = tokenizer("GPT4 Correct User: HelloGPT4 Correct Assistant: HiGPT4 Correct User: How are you today?GPT4 Correct Assistant:").input_ids
assert tokens == [1, 420, 6316, 28781, 3198, 3123, 1247, 28747, 22557, 32000, 420, 6316, 28781, 3198, 3123, 21631, 28747, 15359, 32000, 420, 6316, 28781, 3198, 3123, 1247, 28747, 1602, 460, 368, 3154, 28804, 32000, 420, 6316, 28781, 3198, 3123, 21631, 28747]

# Coding Mode
tokens = tokenizer("Code User: Implement quicksort using C++Code Assistant:").input_ids
assert tokens == [1, 7596, 1247, 28747, 26256, 2936, 7653, 1413, 334, 1680, 32000, 7596, 21631, 28747]

Code Examples

import transformers

tokenizer = transformers.AutoTokenizer.from_pretrained("berkeley-nest/Starling-LM-7B-alpha")
model = transformers.AutoModelForCausalLM.from_pretrained("berkeley-nest/Starling-LM-7B-alpha")

def generate_response(prompt):
    input_ids = tokenizer(prompt, return_tensors="pt").input_ids
    outputs = model.generate(
        input_ids,
        max_length=256,
        pad_token_id=tokenizer.pad_token_id,
        eos_token_id=tokenizer.eos_token_id,
    )
    response_ids = outputs[0]
    response_text = tokenizer.decode(response_ids, skip_special_tokens=True)
    return response_text

# Single-turn conversation
prompt = "Hello, how are you?"
single_turn_prompt = f"GPT4 Correct User: {prompt}GPT4 Correct Assistant:"
response_text = generate_response(single_turn_prompt)
print("Response:", response_text)

## Multi-turn conversation
prompt = "Hello"
follow_up_question =  "How are you today?"
response = ""
multi_turn_prompt = f"GPT4 Correct User: {prompt}GPT4 Correct Assistant: {response}GPT4 Correct User: {follow_up_question}GPT4 Correct Assistant:"
response_text = generate_response(multi_turn_prompt)
print("Multi-turn conversation response:", response_text)

### Coding conversation
prompt = "Implement quicksort using C++"
coding_prompt = f"Code User: {prompt}Code Assistant:"
response = generate_response(coding_prompt)
pr

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms