JetLLMLite-4.0

JetLLMLite-4.0 is a multimodal instruction-tuned model published by Jetlink.

It is intended for teams that want to manage deployment, access, and internal distribution from their own namespace while preserving compatibility with the original upstream model ecosystem.

Model Summary

JetLLMLite-4.0 is a 31B dense multimodal model with:

31B total parameters (dense architecture)
Instruction-tuned (IT) variant
256,144 tokens context length
Multimodal: text + image input, text output
Video understanding support (up to 60 seconds at 1 fps)
Built-in reasoning / thinking mode
Native function calling support
Support for 140+ languages
Compatibility with Transformers, vLLM, SGLang, llama.cpp, MLX, Ollama

Intended Use

This model is suitable for advanced workloads such as:

multimodal chat assistants
long-context document and PDF understanding
reasoning and step-by-step problem solving
agentic workflows with function calling
coding assistants and code generation
image, chart, and OCR tasks
multilingual enterprise assistants
research and benchmarking

Model Details

Architecture

Model type: Dense Causal Language Model with Vision Encoder
Training stage: Pre-training & Post-training (Instruction-tuned)
Total parameters: 31B
Architecture style: Dense (not MoE)
Attention mechanism: Hybrid — alternating local sliding-window (1024 tokens) and global full-context attention
RoPE: Dual config — standard RoPE for sliding layers, Proportional RoPE (p-RoPE) for global layers
Per-Layer Embeddings (PLE): Yes
Shared KV Cache: Yes (last N layers reuse KV states from earlier layers)
Native context length: 256,144 tokens
Vision encoder: Variable aspect ratio; configurable token budgets (70 / 140 / 280 / 560 / 1120 tokens)
Thinking mode: Configurable via <|think|> token in system prompt

Ecosystem Compatibility

Hugging Face Transformers
vLLM
SGLang
llama.cpp
MLX
Ollama
mistral.rs
LM Studio

Hardware Requirements

JetLLMLite-4.0 is a single-GPU capable model at full precision (bfloat16), making it significantly more accessible than large MoE or 100B+ scale models.

Reference Hardware

Approximate GPU memory requirements (bfloat16 / full precision):

Unquantized (bfloat16): fits on a single 80GB NVIDIA H100/H200 GPU
4-bit quantized: runs on consumer GPUs with 24GB+ VRAM (e.g. RTX 3090, RTX 4090)
Multi-GPU: tensor parallelism supported via vLLM and SGLang for higher throughput

Note: requirements vary based on context length, batch size, and KV cache settings. The above are practical reference points, not universal minimums.

Practical Guidance

Single GPU deployment

Unlike large-scale MoE models, JetLLMLite-4.0 can be served from a single 80GB datacenter GPU at full precision — making it an excellent fit for single-node or cost-conscious deployment scenarios.

For consumer-grade hardware, quantized variants (GGUF, GPTQ, AWQ) significantly reduce memory requirements with minimal quality loss.

Text-only deployment

Use the --language-model-only flag in vLLM to skip vision encoder profiling and free additional KV cache memory when your workload is purely text-based.

Recommendation

For most production teams:

start with vLLM or SGLang for serving
use a single H100/H200 for unquantized bfloat16 deployment
use 4-bit quantization for consumer GPU or cost-optimized deployments
disable vision if not needed via --language-model-only

Software Requirements

Recommended environment:

Python 3.10+
Linux
CUDA-enabled GPU infrastructure
One of the following runtimes:
- Transformers (>= 4.51.0 required for Gemma 4)
- vLLM
- SGLang
- llama.cpp

Common dependencies:

torch
transformers >= 4.51.0
torchvision
pillow
accelerate

Quickstart

Install Transformers:

pip install "transformers>=4.51.0"

Basic text inference

from transformers import pipeline
import torch

pipe = pipeline(
    "image-text-to-text",
    model="Jetlink/JetLLMLite-4.0",
    device="cuda",
    torch_dtype=torch.bfloat16
)

messages = [
    {"role": "user", "content": [{"type": "text", "text": "What is the capital of France?"}]}
]

output = pipe(messages, max_new_tokens=200)
print(output[0]["generated_text"][-1]["content"])

Multimodal inference (image + text)

from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
from PIL import Image

model_id = "Jetlink/JetLLMLite-4.0"

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

image = Image.open("image.jpg")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Describe this image in detail."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_tensors="pt"
).to(model.device)

output = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(output[0], skip_special_tokens=True))

Reasoning / Thinking mode

Enable thinking mode by adding <|think|> to the system prompt:

messages = [
    {"role": "system", "content": "<|think|>"},
    {"role": "user", "content": [{"type": "text", "text": "Solve: If x² + 5x + 6 = 0, what are the values of x?"}]}
]

Serving Examples

vLLM

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16

vLLM with Tool Use

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16 \
  --enable-auto-tool-choice \
  --tool-call-parser gemma

vLLM text-only mode

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16 \
  --language-model-only

SGLang

python -m sglang.launch_server \
  --model-path Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tp-size 1 \
  --mem-fraction-static 0.85 \
  --context-length 32768 \
  --dtype bfloat16

SGLang with Tool Use

python -m sglang.launch_server \
  --model-path Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tp-size 1 \
  --mem-fraction-static 0.85 \
  --context-length 32768 \
  --dtype bfloat16 \
  --tool-call-parser gemma4

llama.cpp

llama-server \
  -m JetLLMLite-4.0.Q4_K_M.gguf \
  --port 8080 \
  -ngl 99 \
  -c 8192

Long Context Notes

JetLLMLite-4.0 natively supports 256,144 tokens of context.

The hybrid attention mechanism (alternating sliding-window and global attention) with Proportional RoPE (p-RoPE) enables efficient long-context processing without degradation. For most practical deployments, setting --max-model-len to a lower value (e.g. 32768) is recommended to manage KV cache memory pressure.

Thinking Mode Notes

JetLLMLite-4.0 supports configurable thinking mode inherited from the Gemma 4 architecture:

Thinking enabled: add <|think|> token to the system prompt
Thinking disabled: omit <|think|> from the system prompt

When thinking is enabled, the model outputs internal reasoning using <|channel>thought\n[reasoning]<channel|> before the final answer. In multi-turn conversations, thought content from previous turns should not be included before the next user turn.

Strengths

single-GPU deployable at full precision (80GB H100/H200)
strong multimodal capabilities (image, video, OCR, document parsing)
built-in reasoning / thinking mode
native function calling support
256K token context window
140+ language support
broad compatibility with inference frameworks
dense architecture — predictable and consistent performance

Limitations

requires at least one high-memory GPU for unquantized deployment
long context significantly increases KV cache memory pressure
video understanding limited to 60 seconds at 1 fps
multimodal usage adds memory overhead compared to text-only
deployment characteristics depend on framework and quantization settings

Out-of-Scope / Cautionary Use

As with other frontier-scale multimodal models, outputs should be reviewed before use in:

medical decision-making
legal advice
safety-critical automation
high-stakes financial decisions
fully autonomous customer actions without guardrails

Human review, policy controls, and tool-level validation are strongly recommended.

License

This repository follows the same license as the upstream release.

License: Apache-2.0
See the upstream Google Gemma repository and included license text for the governing terms.

If you redistribute, fine-tune, quantize, or otherwise modify this model, make sure your usage remains compliant with the upstream license and attribution requirements.

Attribution

Original model and research release by Google DeepMind.

Upstream model:

google/gemma-4-31b-it

This repository is an organization-managed copy and is not the original upstream source.

Citation

Please cite the original Gemma 4 release when using this model in research, evaluation, or production documentation.

@misc{gemma4,
  title        = {Gemma 4 Technical Report},
  author       = {Google DeepMind},
  year         = {2026},
  publisher    = {Google DeepMind},
  howpublished = {\url{https://huggingface.co/google/gemma-4-31b-it}}
}

JetLLMLite-4.0 (Türkçe)

JetLLMLite-4.0, Jetlink tarafından yayınlanan multimodal bir instruction-tuned modeldir.

Bu depo; modeli kendi namespace'i altında yönetmek, erişimi kontrol etmek ve dağıtımı kolaylaştırmak isteyen ekipler için hazırlanmıştır.

Model Özeti

JetLLMLite-4.0, aşağıdaki özelliklere sahip 31B parametreli dense bir multimodal modeldir:

31B toplam parametre (dense mimari)
Instruction-tuned (IT) varyant
256.144 token bağlam uzunluğu
Multimodal: metin + görüntü girişi, metin çıkışı
Video anlama desteği (saniyede 1 kare, 60 saniyeye kadar)
Yerleşik reasoning / thinking modu
Native function calling desteği
140+ dil desteği
Transformers, vLLM, SGLang, llama.cpp, MLX, Ollama ile uyumluluk

Kullanım Amacı

Bu model aşağıdaki gelişmiş kullanım senaryoları için uygundur:

multimodal sohbet asistanları
uzun bağlamlı doküman ve PDF anlama
adım adım akıl yürütme ve problem çözme
function calling ile agentic workflow yapıları
kodlama asistanları ve kod üretimi
görüntü, grafik ve OCR görevleri
çok dilli kurumsal asistanlar
araştırma ve benchmark çalışmaları

Model Detayları

Mimari

Model tipi: Vision Encoder içeren Dense Causal Language Model
Eğitim aşaması: Pre-training ve Post-training (Instruction-tuned)
Toplam parametre: 31B
Mimari stili: Dense (MoE değil)
Dikkat mekanizması: Hibrit — local sliding-window (1024 token) ve global full-context attention
RoPE: Çift konfigürasyon — sliding katmanlar için standart RoPE, global katmanlar için Proportional RoPE (p-RoPE)
Per-Layer Embeddings (PLE): Evet
Paylaşılan KV Cache: Evet
Yerel bağlam uzunluğu: 256.144 token
Vision encoder: Değişken en-boy oranı; yapılandırılabilir token bütçeleri (70 / 140 / 280 / 560 / 1120 token)
Thinking modu: System prompt'a <|think|> token eklenerek etkinleştirilir

Ekosistem Uyumluluğu

Hugging Face Transformers
vLLM
SGLang
llama.cpp
MLX
Ollama
mistral.rs
LM Studio

Donanım Gereksinimleri

JetLLMLite-4.0, tam hassasiyetle (bfloat16) tek GPU'da çalışabilen bir modeldir. Bu özelliği, büyük ölçekli MoE veya 100B+ modellerine kıyasla çok daha erişilebilir kılar.

Referans Donanım

Tahmini GPU bellek gereksinimleri (bfloat16 / tam hassasiyet):

Quantize edilmemiş (bfloat16): tek bir 80GB NVIDIA H100/H200 GPU'ya sığar
4-bit quantize: 24GB+ VRAM'li consumer GPU'larda çalışır (ör. RTX 3090, RTX 4090)
Çoklu GPU: daha yüksek throughput için vLLM ve SGLang üzerinden tensor parallelism desteklenir

Not: gereksinimler bağlam uzunluğu, batch size ve KV cache ayarlarına göre değişir. Yukarıdakiler pratik referans noktaları olup evrensel minimum değildir.

Pratik Rehber

Tek GPU dağıtımı

Büyük ölçekli MoE modellerinin aksine JetLLMLite-4.0, tam hassasiyetle tek bir 80GB datacenter GPU'dan servis edilebilir. Bu özellik, single-node veya maliyet odaklı dağıtım senaryoları için mükemmel bir seçenek sunar.

Consumer GPU'lar için quantize varyantlar (GGUF, GPTQ, AWQ) minimal kalite kaybıyla bellek gereksinimini önemli ölçüde azaltır.

Sadece metin kullanımı

vLLM'de --language-model-only bayrağını kullanarak vision encoder profiling'i atlayabilir ve KV cache için ek bellek açabilirsiniz.

Öneri

Çoğu production ekip için en mantıklı yaklaşım:

serving için vLLM veya SGLang ile başlamak
quantize edilmemiş bfloat16 dağıtım için tek H100/H200 kullanmak
consumer GPU veya maliyet optimize edilmiş dağıtımlar için 4-bit quantization uygulamak
vision gerekmiyorsa --language-model-only ile devre dışı bırakmak

Yazılım Gereksinimleri

Önerilen ortam:

Python 3.10+
Linux
CUDA destekli GPU altyapısı
Şu runtime'lardan biri:
- Transformers (>= 4.51.0 — Gemma 4 için zorunlu)
- vLLM
- SGLang
- llama.cpp

Yaygın bağımlılıklar:

torch
transformers >= 4.51.0
torchvision
pillow
accelerate

Hızlı Başlangıç

Transformers kurulumu:

pip install "transformers>=4.51.0"

Temel metin çıkarımı

from transformers import pipeline
import torch

pipe = pipeline(
    "image-text-to-text",
    model="Jetlink/JetLLMLite-4.0",
    device="cuda",
    torch_dtype=torch.bfloat16
)

messages = [
    {"role": "user", "content": [{"type": "text", "text": "Fransa'nın başkenti neresidir?"}]}
]

output = pipe(messages, max_new_tokens=200)
print(output[0]["generated_text"][-1]["content"])

Multimodal çıkarım (görüntü + metin)

from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
from PIL import Image

model_id = "Jetlink/JetLLMLite-4.0"

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

image = Image.open("goruntu.jpg")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Bu görseli detaylı olarak açıkla."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_tensors="pt"
).to(model.device)

output = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(output[0], skip_special_tokens=True))

Reasoning / Thinking modu

Thinking modunu etkinleştirmek için system prompt'a <|think|> ekleyin:

messages = [
    {"role": "system", "content": "<|think|>"},
    {"role": "user", "content": [{"type": "text", "text": "x² + 5x + 6 = 0 denkleminin kökleri nelerdir?"}]}
]

Serving Örnekleri

vLLM

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16

vLLM Tool Use ile

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16 \
  --enable-auto-tool-choice \
  --tool-call-parser gemma

vLLM sadece metin modu

vllm serve Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --dtype bfloat16 \
  --language-model-only

SGLang

python -m sglang.launch_server \
  --model-path Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tp-size 1 \
  --mem-fraction-static 0.85 \
  --context-length 32768 \
  --dtype bfloat16

SGLang Tool Use ile

python -m sglang.launch_server \
  --model-path Jetlink/JetLLMLite-4.0 \
  --port 8000 \
  --tp-size 1 \
  --mem-fraction-static 0.85 \
  --context-length 32768 \
  --dtype bfloat16 \
  --tool-call-parser gemma4

llama.cpp

llama-server \
  -m JetLLMLite-4.0.Q4_K_M.gguf \
  --port 8080 \
  -ngl 99 \
  -c 8192

Uzun Bağlam Notları

JetLLMLite-4.0 yerel olarak 256.144 token destekler.

Hibrit dikkat mekanizması (alternatif sliding-window ve global attention) ve Proportional RoPE (p-RoPE) sayesinde verimli uzun bağlam işleme sağlanır. Çoğu production dağıtımında KV cache bellek baskısını yönetmek için --max-model-len değerini daha düşük tutmak (ör. 32768) önerilir.

Thinking Modu Notları

JetLLMLite-4.0, Gemma 4 mimarisinden gelen yapılandırılabilir thinking modunu destekler:

Thinking etkin: system prompt'a <|think|> token ekleyin
Thinking devre dışı: <|think|> tokenını system prompt'tan çıkarın

Thinking etkinleştirildiğinde model, nihai yanıttan önce <|channel>thought\n[akıl yürütme]<channel|> yapısıyla iç mantığını çıktılar. Çok turlu konuşmalarda önceki turların thought içeriği bir sonraki kullanıcı turuna dahil edilmemelidir.

Güçlü Yönler

tam hassasiyetle tek GPU'da dağıtılabilir (80GB H100/H200)
güçlü multimodal yetenekler (görüntü, video, OCR, doküman ayrıştırma)
yerleşik reasoning / thinking modu
native function calling desteği
256K token bağlam penceresi
140+ dil desteği
inference framework'leriyle geniş uyumluluk
dense mimari — öngörülebilir ve tutarlı performans

Sınırlamalar

quantize edilmemiş dağıtım için en az bir yüksek belleğe sahip GPU gerektirir
uzun bağlam KV cache bellek baskısını ciddi ölçüde artırır
video anlama, saniyede 1 kare hızında 60 saniyeyle sınırlıdır
multimodal kullanım metin çıkarımına kıyasla ek bellek maliyeti getirir
deployment karakteristiği framework ve quantization ayarlarına göre değişir

Kapsam Dışı / Dikkat Gerektiren Kullanımlar

Diğer frontier-scale multimodal modellerde olduğu gibi, model çıktıları şu alanlarda insan denetimi olmadan kullanılmamalıdır:

tıbbi karar verme
hukuki tavsiye
güvenlik kritik otomasyon
yüksek riskli finansal kararlar
korumasız tam otonom müşteri aksiyonları

İnsan incelemesi, politika kontrolleri ve tool seviyesinde doğrulama güçlü şekilde önerilir.

Lisans

Bu depo, upstream sürümle aynı lisansı takip eder.

Lisans: Apache-2.0
Geçerli şartlar için upstream Google Gemma deposu ve lisans metni incelenmelidir.

Modeli yeniden dağıtıyor, fine-tune ediyor, quantize ediyor veya başka şekilde değiştiriyorsan; kullanımının upstream lisans ve attribution gereklilikleriyle uyumlu olduğundan emin olmalısın.

Atıf

Orijinal model ve araştırma yayını Google DeepMind ekibine aittir.

Upstream model:

google/gemma-4-31b-it

Bu depo, kurum tarafından yönetilen bir kopyadır ve orijinal upstream kaynak değildir.

Atıf / Citation

Bu modeli araştırma, değerlendirme veya production dokümantasyonunda kullanıyorsan, lütfen orijinal Gemma 4 sürümüne atıf yap.

@misc{gemma4,
  title        = {Gemma 4 Technical Report},
  author       = {Google DeepMind},
  year         = {2026},
  publisher    = {Google DeepMind},
  howpublished = {\url{https://huggingface.co/google/gemma-4-31b-it}}
}

Downloads last month: 43

Safetensors

Model size

33B params

Tensor type

BF16