Instructions to use IDINN/KiKai-For-Hacking-7.6B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use IDINN/KiKai-For-Hacking-7.6B with PEFT:

from peft import PeftModel
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("DeepHat/DeepHat-V1-7B")
model = PeftModel.from_pretrained(base_model, "IDINN/KiKai-For-Hacking-7.6B")

Transformers

How to use IDINN/KiKai-For-Hacking-7.6B with Transformers:

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

pipe = pipeline("text-generation", model="IDINN/KiKai-For-Hacking-7.6B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("IDINN/KiKai-For-Hacking-7.6B", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use IDINN/KiKai-For-Hacking-7.6B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "IDINN/KiKai-For-Hacking-7.6B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "IDINN/KiKai-For-Hacking-7.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/IDINN/KiKai-For-Hacking-7.6B

SGLang

How to use IDINN/KiKai-For-Hacking-7.6B 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 "IDINN/KiKai-For-Hacking-7.6B" \
    --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": "IDINN/KiKai-For-Hacking-7.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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 "IDINN/KiKai-For-Hacking-7.6B" \
        --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": "IDINN/KiKai-For-Hacking-7.6B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use IDINN/KiKai-For-Hacking-7.6B with Docker Model Runner:
```
docker model run hf.co/IDINN/KiKai-For-Hacking-7.6B
```

Model Card for Model ID

-- KiKai-For-Hacking-7.6B

Model Details

Model Description

Developed by: Idin Iskandar[cite: 1]
Model type: AI Assistant for Offensive Security & Reverse Engineering (Uncensored)
Language(s) (NLP): Indonesian (Casual/Slang) & English
License: Apache-2.0
Finetuned from model: DeepHat/DeepHat-V1-7B

Model Sources

Repository: https://huggingface.co/IDINN/KiKai-For-Hacking-7.6B
Demo : Google Colab Streaming Chat Interface

Uses

Direct Use

Model ini dirancang khusus untuk membantu aktivitas cybersecurity secara langsung, seperti:

Membantu penyusunan metodologi penetration testing berdasarkan OWASP Top 10.
Pembuatan skrip otomasi keamanan siber (menggunakan Python Scapy, Bash, Go, dll).
Analisis fungsionalitas dan logika kode dalam proses reverse engineering aplikasi (Android APK/Smali/Frida hooks).
Penyusunan laporan bug bounty atau dokumen remediation celah keamanan secara terstruktur.

Downstream Use [optional]

Dapat digunakan sebagai backend engine untuk bot asisten tim internal Red Team / Pentester melalui integrasi API lokal.

Out-of-Scope Use

Aktivitas penyerangan siber secara ilegal tanpa izin tertulis dari pemilik aset (unauthorized hacking).
Penggunaan umum yang membutuhkan filter konten ketat karena model ini bersifat uncensored demi kebutuhan riset keamanan.

Bias, Risks, and Limitations

Uncensored Nature: Model ini tidak memiliki filter keamanan moral/konten seketat AI komersial umum. Model akan mengeksekusi dan menjawab pertanyaan seputar offensive security dan pembuatan payload secara langsung demi kebutuhan riset.
Context Length Limitation: Karena dilatih dengan batas panjang sekuens (Max Sequence Length) 256 token untuk efisiensi VRAM, jawaban yang sangat panjang berpotensi terputus atau mengalami degradasi kualitas jika konfigurasi generasi tidak dibatasi dengan tepat.
Potential Halucination: Seperti LLM pada umumnya, model ini bisa mengalami halusinasi teknis (seperti kesalahan penulisan nama flag tool atau sintaks kode yang tidak valid). Pengguna disarankan untuk selalu melakukan verifikasi dan pengujian kode di lingkungan sandbox (lokal) terlebih dahulu.

Recommendations

Authorized Deployment Only: Pengguna (baik langsung maupun turunan) wajib memastikan bahwa model ini hanya digunakan dalam ruang lingkup pengujian penetrasi yang sah, riset edukasi privat, atau lingkungan laboratorium siber yang terisolasi.
Generation Parameters: Sangat direkomendasikan untuk menurunkan nilai temperature (sekitar 0.5 - 0.6) dan menaikkan repetition_penalty (minimal 1.2 atau lebih) saat menjalankan model ini untuk mencegah terjadinya pengulangan kata (looping tokens) akibat efek pemotongan panjang latih.

How to Get Started with the Model

Gunakan kode Python di bawah ini di Google Colab atau environment lokal lo untuk mulai berinteraksi dengan KiKai-For-Hacking-7.6B:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import PeftModel

BASE_MODEL = "DeepHat/DeepHat-V1-7B"
ADAPTER_REPO = "IDINN/KiKai-For-Hacking-7.6B"

# 1. Load Tokenizer
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, use_fast=True, trust_remote_code=True)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# 2. Load Base Model dalam Mode 4-Bit (Hemat VRAM T4)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

base_model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# 3. Suntikkan Jiwa KiKai (Load LoRA Adapter dari Root Repo)
model = PeftModel.from_pretrained(base_model, ADAPTER_REPO)
model.eval()

# 4. Parameter Generasi Optimal (Anti-Looping & Fokus)
GEN_CONFIG = {
    "max_new_tokens": 512,
    "do_sample": True,
    "temperature": 0.5,
    "top_p": 0.85,
    "top_k": 40,
    "repetition_penalty": 1.25,
    "pad_token_id": tokenizer.pad_token_id,
    "eos_token_id": tokenizer.eos_token_id
}

# 5. Jalankan Chat Prompt
messages = [
    {"role": "system", "content": "Gue KiKai, AI asisten cybersecurity buatan Idin Iskandar. Gaya ngomong gue santai, casual, pake gue-lo."},
    {"role": "user", "content": "Siapa nama lo dan buatan siapa?"}
]

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

with torch.no_grad():
    outputs = model.generate(**inputs, **GEN_CONFIG)
    response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
    print(response)

Training Data

Model ini dilatih menggunakan dataset privat berformat JSONL yang telah dikurasi secara khusus, mencakup dua domain utama melalui metode Joint Training:

Identity Dataset: Berisi pemetaan identitas kustom untuk membentuk persona KiKai sebagai AI asisten buatan Idin Iskandar yang memiliki gaya bicara santai, casual, dan menggunakan bahasa Indonesia non-baku (gue-lo).
Offensive Skills Dataset: Berisi dokumentasi teknis mendalam mengenai metodologi penetration testing, trik eksploitasi, analisis reverse engineering, serta skrip otomasi siber yang bersifat uncensored.

Training Procedure

Preprocessing

Data teks dikonversi ke dalam struktur pesan (chat template) standar sebelum dieksekusi oleh tokenizer.
Penerapan pemotongan sekuens (truncation) secara ketat dilakukan pada batas maksimal token guna menyesuaikan kapasitas memori fisik komputasi.

Training Hyperparameters

Training regime: fp16 mixed precision (menggunakan format torch.float16 dengan konfigurasi optimasi BitsAndBytes 4-bit NF4 double-quantization untuk menjaga efisiensi VRAM).

Speeds, Sizes, Times

Throughput / Progress: Berhasil diselesaikan 100% hingga tahap akhir step-169.
Checkpoint / Adapter Size: ~162 MB (adapter_model.safetensors).
Hardware Training: Dilatih menggunakan single GPU NVIDIA Tesla T4 (Google Colab Environment).

Evaluation

Testing Data, Factors & Metrics

Testing Data

Evaluasi model dilakukan menggunakan sebagian porsi dari dataset latih asli yang disisihkan secara acak sebagai Eval Dataset (Validation Set) sebesar 300 hingga 500 baris data untuk menguji akurasi metrik Validation Loss. Proses pengujian ini bertujuan memastikan model mampu memahami pola cybersecurity secara universal tanpa mengalami gejala hafal mati (overfitting).

Factors

Evaluasi model ini dipisahkan berdasarkan dua faktor utama:

Akurasi Identitas (Identity Fidelity): Menguji ketahanan model agar tetap konsisten menjawab sebagai KiKai buatan Idin Iskandar ketika dijebak menggunakan pertanyaan pemancing dari vendor LLM lain (seperti Alibaba, Qwen, OpenAI, atau NVIDIA)[cite: 1].
Kapabilitas Teknis (Domain Expertise): Menguji kedalaman dan validitas sintaks skrip serta payload saat dihadapkan pada skenario serangan fungsional (offensive task) maupun arsitektur pertahanan (defensive task).

Metrics

Validation Loss: Metrik utama yang digunakan untuk mengukur selisih antara tebakan model dengan data validasi asli. Penurunan nilai validation loss pada porsi eval dataset yang besar (500 data) menjadi indikator utama bahwa model semakin akurat dalam memahami pola siber, bukan sekadar menghafal teks.
Persona Alignment Score: Penilaian kualitatif untuk memastikan model merespons menggunakan gaya bahasa kasual (gue-lo) secara alami tanpa merusak fungsionalitas teknis di dalamnya.

Results

Proses training berhasil diselesaikan 100% tanpa kendala Out-of-Memory (OOM) pada VRAM.

Summary

Identitas Sukses Terkunci: Model berhasil melewati pengujian identitas dengan akurasi mutlak. Model secara tegas menolak klaim arsitektur bawaan publik dan setia pada identitas aslinya sebagai KiKai asisten buatan Idin Iskandar.
Kapabilitas Uncensored Aktif: Berhasil mengaktifkan mode offensive security assistant yang responsif. Model terbukti mampu memberikan instruksi pembuatan payload, otomatisasi skrip scanning, hingga taktik reverse engineering secara presisi tanpa terhalang sensor kaku atau penolakan sistem.

Model Examination

Pemeriksaan model secara interaktif dilakukan melalui metode Streaming Inference Mode menggunakan pustaka TextIteratorStreamer. Pengujian langsung pada beberapa kasus riil (seperti teknik bypass SSL Pinning lewat Smali, pembuatan skrip ARP spoofing, dan automasi CI/CD pipeline) menunjukkan bahwa model mampu mengeksekusi parameter instruksi dengan output terstruktur yang rapi (menggunakan pemetaan tabel dan blok kode markdown).

Environmental Impact

Carbon emissions can be estimated using the Machine Learning Impact calculator presented in Lacoste et al. (2019).

Hardware Type: 1 x NVIDIA Tesla T4 GPU
Hours used: ~2.5 Jam (Total durasi pengerjaan Joint Training hingga selesai)
Cloud Provider: Google (Google Colab Environment)
Compute Region: Berubah secara dinamis tergantung alokasi otomatis server Google Cloud
Carbon Emitted: Sangat rendah / minimal (~0.04 kg CO2eq berdasarkan estimasi rata-rata daya T4 sebesar 70W)

Technical Specifications

Model Architecture and Objective

Model Architecture: Berbasis pada arsitektur Qwen2 (7B parameters) yang dioptimasi secara khusus oleh tim DeepHat sebagai fondasi dasar model siber uncensored.
Objective: Menjalankan metode Supervised Fine-Tuning (SFT) menggunakan lapisan adaptor LoRA untuk melakukan injeksi fungsionalitas ganda (Joint Training): mengunci kesetiaan identitas lokal sebagai KiKai sekaligus membuka kapabilitas analisis pertahanan dan penyerangan siber secara mendalam.

Compute Infrastructure

Software Frameworks: Dilatih menggunakan ekosistem transformers, peft, trl (SFTTrainer), dan diakselerasi dengan bit-quantization dari pustaka bitsandbytes.
Memory Optimization: Enforce penggunaan presisi rendah (4-bit NF4 loading dengan komputasi torch.float16) untuk mencegah lonjakan memori (Out-of-Memory) pada keterbatasan VRAM 15GB milik Tesla T4.

Hardware

Training GPU: 1 x NVIDIA Tesla T4 (VRAM 15GB).
Storage Requirements: Minimal ~30GB ruang penyimpanan lokal (untuk menampung base model cache seukuran 15GB dan direktori kerja adapter).

Software

Operating System: Linux (Ubuntu Environment Google Colab).
Core Libraries: Python 3.10+, PyTorch (CUDA Accelerated), Hugging Face Transformers, Accelerate, dan BitsAndBytes.

Citation

BibTeX:

@misc{kikai2026,
  author = {Iskandar, Idin},
  title = {KiKai-For-Hacking-7.6B: Uncensored Joint Training Identity and Offensive Security LLM Adapter},
  year = {2026},
  publisher = {Hugging Face},
  journal = {Hugging Face Repository},
  howpublished = {\url{[https://huggingface.co/IDINN/KiKai-For-Hacking-7.6B](https://huggingface.co/IDINN/KiKai-For-Hacking-7.6B)}}
}

---