Instructions to use Blackfrost-Research/Kimi-K2.7-Code-BF16 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Blackfrost-Research/Kimi-K2.7-Code-BF16 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="Blackfrost-Research/Kimi-K2.7-Code-BF16", trust_remote_code=True)
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModel

processor = AutoProcessor.from_pretrained("Blackfrost-Research/Kimi-K2.7-Code-BF16", trust_remote_code=True)
model = AutoModel.from_pretrained("Blackfrost-Research/Kimi-K2.7-Code-BF16", trust_remote_code=True, device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Blackfrost-Research/Kimi-K2.7-Code-BF16 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Blackfrost-Research/Kimi-K2.7-Code-BF16"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Blackfrost-Research/Kimi-K2.7-Code-BF16",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/Blackfrost-Research/Kimi-K2.7-Code-BF16

SGLang

How to use Blackfrost-Research/Kimi-K2.7-Code-BF16 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Blackfrost-Research/Kimi-K2.7-Code-BF16" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Blackfrost-Research/Kimi-K2.7-Code-BF16",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Blackfrost-Research/Kimi-K2.7-Code-BF16" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Blackfrost-Research/Kimi-K2.7-Code-BF16",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use Blackfrost-Research/Kimi-K2.7-Code-BF16 with Docker Model Runner:
```
docker model run hf.co/Blackfrost-Research/Kimi-K2.7-Code-BF16
```

Kimi-K2.7-Code-BF16

BF16 dequantization of Moonshot's native-INT4 Kimi K2.7 Code · 2.05 TB · unmodified

Built by Blackfrost · Las Vegas, NV

ℹ️ This model is NOT de-risked

Most repositories in this organization carry a deliberate weight-level refusal modification. This one does not. It is a straight format conversion of Moonshot's official release, with no fine-tuning, no ablation, no distillation, and no behavioural change of any kind.

Its safety behaviour is upstream Kimi K2.7 Code's, unchanged. If you are evaluating Blackfrost models against an internal approval process, treat this as a standard format derivative of its parent.

Why this model exists

Moonshot released moonshotai/Kimi-K2.7-Code in native INT4 — pack-quantized compressed-tensors, ~595 GB. That is excellent for serving and awkward for everything else. Requantizing to another format, fine-tuning, merging, or running numerical comparisons all want a standard full-precision checkpoint, and there wasn't one.

This repository is that checkpoint: the official INT4 release dequantized to bfloat16 and shipped as an ordinary transformers model.

It is the only transformers-loadable BF16 safetensors build of K2.7 Code we are aware of. Thireus/Kimi-K2.7-Code-THIREUS-BF16-SPECIAL_SPLIT carries comparable byte volume but is 998 per-tensor GGUF shards for a quant-mixing tool, with no config.json and no model.safetensors.index.json — it does not load as a model. Everything else on the Hub is either the 595 GB INT4 original, a mirror of it, or a quantization of it.

Specifications


Architecture	`KimiK25ForConditionalGeneration` — MoE, multimodal (image-text-to-text)
Base	`moonshotai/Kimi-K2.7-Code` — official, © Moonshot AI
Upstream format	native INT4, pack-quantized `compressed-tensors`, ~595 GB / 64 shards
Transform	Faithful dequantization to `bfloat16` · `quantization_config` removed · `dtype` set to `bfloat16`
This repo	~2.05 TB · 64 safetensors shards · 70,310 tensors
Behavioural change	None. No fine-tuning, ablation, distillation, or merge
Languages	English, Chinese

Tokenizer (tiktoken.model, tokenization_kimi.py), chat_template.jinja, generation_config.json, the modeling and configuration modules, preprocessor_config.json and tool_declaration_ts.py all ship with the weights, so a serving stack that honours the packaged assets will not silently fall back to a generic template.

What dequantization does and does not do

This matters and is routinely misread, so it is stated plainly:

What it does. Every INT4 value in the official release is expanded to its exact bfloat16 representation. Nothing is approximated, dropped, or re-derived. Load this and you get the same model Moonshot published, in a format standard tooling can operate on.

What it does not do. Upcasting cannot recover information that was never in the INT4 file. This is a BF16-formatted checkpoint, not a BF16-trained one. If Moonshot holds a higher-precision master, this is not it, and no dequantization could produce it. Anyone quoting "full precision" as though it implied more information than the INT4 source is wrong, and we would rather say so on our own card than have someone else say it for us.

What it is genuinely good for:

Requantization base — GGUF, NVFP4, MXFP4, FP8, AWQ, GPTQ. Most quantization tooling expects BF16/FP16 input and chokes on compressed-tensors INT4.
Fine-tuning and merging — LoRA, full fine-tune, or model merging, none of which work cleanly against pack-quantized weights.
Numerical research — reference-logit comparisons, quantization-error studies, layer analysis.

Lineage


Base	Official `moonshotai/Kimi-K2.7-Code` (INT4)
Applied	Dequantization INT4 → `bfloat16` · `quantization_config` stripped from `config.json`
Not applied	Fine-tuning · ablation · refusal modification · distillation · merging · pruning
Format	HF safetensors · `bfloat16`

On refusal behaviour: unchanged from upstream. See the notice at the top of this card.

Capabilities and evaluation

All architecture, capability and evaluation claims belong to Moonshot AI and are published on the original model card. Blackfrost has run no independent benchmark on this checkpoint and makes no capability claim of its own.

Because the transform is a format conversion with no behavioural change, upstream numbers should carry — but that is a reasonable expectation, not something we have measured. If you need it verified for your use, ask.

Deployment notes

Hardware. ~2.05 TB of weights. This is a base artifact for offline work, not a serving target — for inference, use Moonshot's INT4 release or a quantization derived from this one.
Disk. Allow 2.2 TB. 64 shards.
Loading. Standard transformers with trust_remote_code=True (the architecture ships its own modeling modules).
Integrity. Verify shard count (64) and byte totals against model.safetensors.index.json before attributing a load failure to the weights.

Licence

Modified MIT, inherited from moonshotai/Kimi-K2.7-Code. Moonshot's terms apply to this derivative and travel with it, along with any onward derivative you create. LICENSE and THIRD_PARTY_NOTICES.md ship in this repository.

Full credit for the model itself to Moonshot AI. Blackfrost's contribution here is the format conversion and nothing else.

Disclaimer

No warranty of any kind. Provided "as is", without warranty express or implied, including fitness for a particular purpose.

No behavioural modification, and no safety claim either way. This checkpoint carries upstream Kimi K2.7 Code's safety behaviour unchanged. Blackfrost has neither strengthened nor reduced it, and publishes no refusal measurement for it.

No independent capability measurement. Upstream evaluation figures are Moonshot's. Blackfrost has not reproduced them on this checkpoint.

Modification by a recipient is your responsibility. Any further quantization, fine-tuning, merging, ablation or alteration produces an artifact Blackfrost has not evaluated and does not stand behind — including any refusal-behaviour change a recipient introduces. Responsibility transfers entirely to whoever produced it.

Upstream licence obligations travel. Moonshot's Modified MIT terms bind you and every derivative you create from this repository.

Contact Blackfrost

@Blackfrost_AI on X

DMs are open. Fastest route to a human.

Ask about quantizations built from this base,
or custom conversions of other pack-quantized releases.

Blackfrost · Las Vegas, Nevada
Frontier model engineering

Downloads last month: 22

Safetensors

Model size

1T params

Tensor type

BF16

F32

Model tree for Blackfrost-Research/Kimi-K2.7-Code-BF16

Base model

moonshotai/Kimi-K2.7-Code

Quantized

(28)

this model