Instructions to use jarohullowicki/Melusina-1.5B-JFP with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use jarohullowicki/Melusina-1.5B-JFP with PEFT:

from peft import PeftModel
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-1.5B")
model = PeftModel.from_pretrained(base_model, "jarohullowicki/Melusina-1.5B-JFP")

Transformers

How to use jarohullowicki/Melusina-1.5B-JFP with Transformers:

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

pipe = pipeline("text-generation", model="jarohullowicki/Melusina-1.5B-JFP")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("jarohullowicki/Melusina-1.5B-JFP", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use jarohullowicki/Melusina-1.5B-JFP with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/jarohullowicki/Melusina-1.5B-JFP

SGLang

How to use jarohullowicki/Melusina-1.5B-JFP 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 "jarohullowicki/Melusina-1.5B-JFP" \
    --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": "jarohullowicki/Melusina-1.5B-JFP",
		"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 "jarohullowicki/Melusina-1.5B-JFP" \
        --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": "jarohullowicki/Melusina-1.5B-JFP",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use jarohullowicki/Melusina-1.5B-JFP with Docker Model Runner:
```
docker model run hf.co/jarohullowicki/Melusina-1.5B-JFP
```

🌊 MELUSINA — Jaro Flash Protocol Core v1

"Deterministic. Auditable. Structured. Always."

MELUSINA is a LoRA fine-tuned adapter on top of Qwen/Qwen2.5-1.5B, trained to operate under the Jaro Flash Protocol (JFP) v16E.0.0 — a deterministic AI governance framework designed for structured, auditable, and hallucination-resistant AI outputs.

🧠 Model Details

Property	Value
Model name	MELUSINA (Jaro Flash Protocol Core v1)
Base model	Qwen/Qwen2.5-1.5B
Adapter type	LoRA (PEFT)
LoRA rank	r=16, alpha=32
Target modules	q_proj, k_proj, v_proj, o_proj
Training steps	375 (3 epochs)
Final train loss	0.0890
Train loss (avg)	0.2238
Training time	~3h 34min
Dataset	JFP-Core-v1 dataset v2 (1000 examples, 10 categories)
Developed by	Jarosław Andrzej Kuchta (Jaro)
License	Apache 2.0

🎯 What is MELUSINA?

MELUSINA is the first public release of the JFP-Core engine — a fine-tuned language model that:

Never confabulates — unknown facts return SIGNAL_UNKNOWN instead of hallucinated answers
Produces structured JSON outputs — every response is machine-parseable and auditable
Enforces constitutional rules — dangerous or unauthorized actions return SIGNAL_DENY
Supports multi-agent orchestration — dispatches VIPER, VISION, EVOCOS, NEXUS, AORTANA agents
Self-learning detection — recognizes recurring user patterns and suggests fine-tuning (LEARNING_SIGNAL_DETECTED)
Full audit trail — every output includes audit_id and timestamp

📊 Training Results

Step	Epoch	Loss	LR
100	0.80	0.5673	1.47e-4
200	1.60	0.1220	9.39e-5
300	2.40	0.0890	4.05e-5
375	3.00	0.0890	—

Final metrics:

train_loss: 0.2238
train_runtime: 12,850s (~3h 34min)
train_samples_per_second: 0.117
train_steps_per_second: 0.029

🗂️ Dataset: JFP-Core-v1 v2 (1000 examples)

Category	Count	Description
1. SIGNAL_UNKNOWN	15	Unanswerable / speculative questions
2. SIGNAL_DENY	15	Dangerous / unauthorized actions
3. JFP VALIDATION	15	Protocol frame validation
4. VOQL QUERIES	15	Structured DB query authorization
5. AGENT DISPATCH	15	Single-agent signal dispatch
6. CODE EXECUTION	15	Safe/unsafe code execution decisions
7. AUDIT LOG	10	Structured audit event logging
8. JFP SPEC PARSING	400	Protocol specification parsing
9. MULTI-AGENT DISPATCH	400	Pipeline orchestration (sequential/parallel/fan-out/errors)
10. SELF_LEARNING	100	Recurring pattern detection → fine-tune signal
TOTAL	1000

🚀 Quick Start

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

base_model = "Qwen/Qwen2.5-1.5B"
adapter    = "jarohullowicki/Melusina-1.5B-JFP"

tokenizer = AutoTokenizer.from_pretrained(base_model)
model     = AutoModelForCausalLM.from_pretrained(base_model, torch_dtype=torch.float16)
model     = PeftModel.from_pretrained(model, adapter)
model.eval()

SYSTEM = (
    "You are JFP-Core-v1, a deterministic AI engine governed by Jaro Flash Protocol "
    "v16E.0.0. You never confabulate. Unknown = SIGNAL_UNKNOWN. "
    "Every output is structured and auditable."
)

messages = [
    {"role": "system",  "content": SYSTEM},
    {"role": "user",    "content": "What will the stock price of NVIDIA be in 2030?"},
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt")
with torch.no_grad():
    out = model.generate(**inputs, max_new_tokens=128, temperature=0.1)
print(tokenizer.decode(out[0], skip_special_tokens=True))
# Expected: {"status": "SIGNAL_UNKNOWN", "reason": "no_verified_data", "audit_id": "JFP-XXX", ...}

🏗️ JFP Protocol — Signal Types

Signal	Meaning
`SIGNAL_UNKNOWN`	No verified data available — refuses to speculate
`SIGNAL_DENY`	Action blocked — constitutional violation or unauthorized
`DISPATCHED`	Agent successfully dispatched with signal
`PIPELINE_CREATED`	Multi-agent pipeline orchestrated
`VOQL_AUTHORIZED`	Database query approved and executed
`VOQL_DENIED`	Destructive/unauthorized query blocked
`SPEC_PARSED`	JFP protocol frame successfully decoded
`LEARNING_SIGNAL_DETECTED`	Recurring user pattern → fine-tune recommended

🤖 JFP Agents

Agent	Role
VIPER	Network scanning, intrusion detection, port scanning
VISION	Reconnaissance, log analysis, pattern matching
EVOCOS	Optimization, self-improvement, retraining
NEXUS	Deployment, rollback, snapshots
AORTANA	Encryption, decryption, protocol updates

⚠️ Limitations

Based on Qwen2.5-1.5B — small model, best for structured/constrained tasks
Optimized for JFP protocol outputs — not a general-purpose assistant
English-primary training data
Requires system prompt for proper JFP behavior

📄 Citation

@misc{melusina2026,
  author    = {Kuchta, Jarosław Andrzej},
  title     = {MELUSINA: Jaro Flash Protocol Core v1 — Deterministic AI Engine},
  year      = {2026},
  publisher = {HuggingFace},
  url       = {https://huggingface.co/jarohullowicki/Melusina-1.5B-JFP}
}

Built with ❤️ by Jaro | Jaro Flash Protocol v16E.0.0 | 2026

Downloads last month: 4

Model tree for jarohullowicki/Melusina-1.5B-JFP

Base model

Qwen/Qwen2.5-1.5B

Adapter

(454)

this model

jarohullowicki
/

Melusina-1.5B-JFP