Kimi K2.5 Open Source: License, Weights & Self-Hosting Guide 2026

Permission is hereby granted, free of charge, to any person obtaining a copy
of this model and associated documentation files (the "Model"), to deal
in the Model without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Model, subject to the following conditions:

1. If your product/service exceeds 100 million monthly active users
   or $20 million in monthly revenue, you must prominently display "Kimi K2.5"
   in all user-facing products/services.

2. Standard MIT-style notice obligations still apply.

from huggingface_hub import snapshot_download

# Download complete model
model_path = snapshot_download(
    repo_id="moonshotai/Kimi-K2.5",
    local_dir="./kimi-k2-5",
    local_dir_use_symlinks=False,
    resume_download=True
)

# Install Git LFS
git lfs install

# Clone repository
git clone https://huggingface.co/moonshotai/Kimi-K2.5.git

# Or sparse checkout for specific files
git clone --filter=blob:none https://huggingface.co/moonshotai/Kimi-K2.5.git

# Download specific files
wget https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main/config.json
wget https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main/model.safetensors.index.json

kimi-k2-5/
├── config.json              # Model configuration
├── tokenizer.json           # Tokenizer vocab
├── tokenizer_config.json    # Tokenizer settings
├── model.safetensors.index.json  # Weight index
├── model-00001-of-000064.safetensors  # Shard 1
├── model-00002-of-000064.safetensors  # Shard 2
├── ...
├── model-00064-of-000064.safetensors  # Shard 64
├── generation_config.json   # Generation defaults
└── LICENSE                  # License file

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Load model
model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",  # Local path
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained(
    "./kimi-k2-5",
    trust_remote_code=True
)

# Inference
inputs = tokenizer("Hello, Kimi!", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

# Install vLLM
uv pip install -U vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly

# Start server
vllm serve ./kimi-k2-5 \
    -tp 8 \
    --mm-encoder-tp-mode data \
    --trust-remote-code \
    --tool-call-parser kimi_k2 \
    --reasoning-parser kimi_k2

FROM nvidia/cuda:12.1-devel-ubuntu22.04

WORKDIR /app

# Install dependencies
RUN pip install torch vllm transformers

# Copy model (or mount as volume)
COPY ./kimi-k2-5 /models/kimi-k2-5

# Expose port
EXPOSE 8000

# Start server
CMD python -m vllm.entrypoints.openai.api_server \
    --model /models/kimi-k2-5 \
    --tensor-parallel-size 4 \
    --host 0.0.0.0 \
    --port 8000

# Build and run
docker build -t kimi-k2-5 .
docker run --gpus all -p 8000:8000 kimi-k2-5

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kimi-k2-5
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kimi-k2-5
  template:
    metadata:
      labels:
        app: kimi-k2-5
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
        - --model
        - /models/kimi-k2-5
        - --tensor-parallel-size
        - "4"
        volumeMounts:
        - name: model
          mountPath: /models
        resources:
          limits:
            nvidia.com/gpu: "4"
      volumes:
      - name: model
        persistentVolumeClaim:
          claimName: kimi-model-pvc

# Using Deep Learning AMI
aws ec2 run-instances \
    --image-id ami-xxx \
    --instance-type p4d.24xlarge \
    --key-name my-key

# Deploy with ECS/EKS
# Use GPU-optimized instances (p4d, p5)

# Using Deep Learning VM
gcloud compute instances create kimi-server \
    --zone=us-central1-a \
    --machine-type=a2-highgpu-4g \
    --image-family=pytorch-latest-gpu

# Using NC-series VMs
az vm create \
    --resource-group myRG \
    --name kimi-vm \
    --size Standard_NC24ads_A100_v4

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model
import torch

# Load base model
model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# Configure LoRA
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Apply LoRA
model = get_peft_model(model, lora_config)

# Training configuration
training_args = TrainingArguments(
    output_dir="./kimi-k2-5-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    save_steps=100
)

# Train
from trl import SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer
)
trainer.train()

# For full fine-tuning, use DeepSpeed or FSDP
from accelerate import Accelerator

accelerator = Accelerator(deepspeed_plugin=deepspeed_plugin)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    trust_remote_code=True
)

# DeepSpeed config for distributed training
# Requires 8x H100 or equivalent

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    bnb_8bit_compute_dtype=torch.float16
)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# Example community repo
# https://huggingface.co/unsloth/Kimi-K2.5-GGUF

# Inspect available files/tags in the chosen repo before running llama.cpp

# Implement input validation
def validate_input(text):
    max_length = 100000  # Limit input size
    if len(text) > max_length:
        raise ValueError("Input too long")
    
    # Block harmful prompts
    blocked_terms = ["..."]  # Your list
    for term in blocked_terms:
        if term in text.lower():
            raise ValueError("Blocked content detected")
    
    return text

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def generate_with_logging(prompt):
    logger.info(f"Generation request: {len(prompt)} chars")
    
    output = model.generate(**inputs)
    
    logger.info(f"Generated: {len(output)} tokens")
    return output