Instructions to use cooperdk/MGE-GemmaWild-9b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use cooperdk/MGE-GemmaWild-9b with Transformers:

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

pipe = pipeline("image-text-to-text", model="cooperdk/MGE-GemmaWild-9b")
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, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("cooperdk/MGE-GemmaWild-9b")
model = AutoModelForMultimodalLM.from_pretrained("cooperdk/MGE-GemmaWild-9b", 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 cooperdk/MGE-GemmaWild-9b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "cooperdk/MGE-GemmaWild-9b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "cooperdk/MGE-GemmaWild-9b",
		"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/cooperdk/MGE-GemmaWild-9b

SGLang

How to use cooperdk/MGE-GemmaWild-9b 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 "cooperdk/MGE-GemmaWild-9b" \
    --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": "cooperdk/MGE-GemmaWild-9b",
		"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 "cooperdk/MGE-GemmaWild-9b" \
        --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": "cooperdk/MGE-GemmaWild-9b",
		"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"
						}
					}
				]
			}
		]
	}'

Unsloth Studio

How to use cooperdk/MGE-GemmaWild-9b with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for cooperdk/MGE-GemmaWild-9b to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for cooperdk/MGE-GemmaWild-9b to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for cooperdk/MGE-GemmaWild-9b to start chatting

Load model with FastModel

pip install unsloth
from unsloth import FastModel
model, tokenizer = FastModel.from_pretrained(
    model_name="cooperdk/MGE-GemmaWild-9b",
    max_seq_length=2048,
)

Docker Model Runner
How to use cooperdk/MGE-GemmaWild-9b with Docker Model Runner:
```
docker model run hf.co/cooperdk/MGE-GemmaWild-9b
```

🐾 Project Overview: MGE-GemmaWild-9B

A naughty vision and tool enabled LLM with all the knowledge of the Monster Girl Encyclopedia

MGE-GemmaWild-9B is a specialized multimodal-native model. This project represents an advanced model trained on reasoning, surgically integrating complex biological, species-specific prose, and deep persona-alignment into the model's core vocabulary.

Unlike standard instruction-tuned models, this version is trained with expanded embedding layers to Reason-before-Response, utilizing explicit <think> tags and internal chain-of-thought processing to maintain a scientific yet "Wild" persona.

The Reasoning Engine:

This model utilizes explicit reasoning blocks. In every conversational turn, the model performs a multi-step internal analysis before delivering its final response. This may under some circumstances require you to pre-fill the model output with the <think> tag.

Scientific Grounding: Analyzes biological and lore-specific traits, combining text and vision inputs.
Persona Calibration: Filters all outputs through the "Gemma Wild" (naughty but expert analyst) identity or specific character roles introduced manually or using fx SillyTavern.
Logical Consistency: Ensures that complex character maps (using the Reasoning Map trained for up to 8 steps) remain coherent before writing the final output.

Dynamic Context Switching (Prose vs. Logic)

This model is trained with Instruction-Response Divergence. While the default system prompt mandates reasoning, the model has been taught to prioritize immersion during high-intensity prose or roleplay.

Analysis Mode: Triggered by keywords like Analyze, Biological, or Stats. The model should utilize the full <think> reasoning chain.
Immersive Mode: Triggered by sensory-heavy narratives, emotional cues, or direct dialogue. The model may bypass the reasoning block to ensure the narrative "Fourth Wall" remains unbroken, transitioning directly into a realistic, character-driven RPG-based chat.

📊 Dataset Architecture

The model was trained on a meticulously assembled dataset of 48,955 unique samples with a total of 243,000 individual messages. The final training has changed approximately one third of the original base model's weights.

JSON Assembly Breakdown

Dataset Component	Chunks	Weight	Role
Vision Lore (Anchor)	7,200	1.0	Visual-Species Grounding with knowledge about 305 species and named characters)
Species Reasoning (8-Step Prose)	1,019	1.0	Deep Lore & Bio-Reasoning
Species Reasoning (Vanilla Style)	417	0.8	Structural Consistency
Character Reasoning (Unified)	315	0.8	Persona & Dialogue Logic with reasoining
Specialist Persona (Gemma Wild)	1,500	0.8	Reasoning-driven Role-playing Fidelity
MGE Knowledge Base	5,264	0.7	Mamono Realm Facts (the MGE encyclopedia converted to a Q&A dataset
Multi-Turn Reasoning	1,630	0.8	Conversational Coherence (Lore-dense narratives & anatomy guides)
Alpaca High-Quality	1,500	0.3	Instruction Baseline with custom added reasoning

Recommended Sampler Settings

Reasoning models are sensitive to randomness. To prevent "lazy" reasoning or logical loops, use these exact values tested during the Stage 2 bake:

Parameter	Value	Purpose
Temperature	0.65-0.75	Recommended for creative, immersive prose without breaking logic and high quality reasoning. User lower value for more factual, true-to-lore responses.
Min P	0.05	Filters out low-probability "noise" in thought chains.
Repeat Penalty	1.05-1-15	Updated for Qwen3 stability to prevent reasoning flow degradation.
Top P	0.9	Maintains a high-quality, safe vocabulary.

Deployment & Platform Guides (Split GGUF Architecture)

Because this is a multimodal model, the quantized version (GGUF) is distributed in two parts to preserve vision intelligence: the text logic (e.g. Q4_K_M.gguf) and the high-precision vision encoder (mmproj-MGE-GemmaWild-9B -f16.gguf). Both are required for the model to function correctly.

1. LM Studio (Recommended UI)

Main Model: Load MGE-GemmaWild-9B -Q4_K_M.gguf natively.
Vision Hookup: LM Studio will do this automatically.
Prompt Template: Ensure the preset is set to ChatML (the Qwen standard) or left alone (the model has a template included, which is where Gemma Wild lives. By setting another template, she will leave you). Enable "Parse Thought Blocks" if you want the <think> tags rendered cleanly in the UI.

2. KoboldCPP (Power User)

Launch: You must load the text model and attach the vision projector simultaneously.
GUI Launcher: Select the Q4_K_M.gguf file, then click the mmproj browse button and attach the mmproj-f16.gguf file.
Terminal: Append --mmproj mmproj-MGE-GemmaWild-9B -f16.gguf to your standard launch command.
Context Size: Set to at least 8192 if analyzing large images. The model will support a context size of 65,535 on a RTX 5060 - even with vision as well as an image generation model loaded.

3. SillyTavern (Advanced RP)

Instruction Template: Set to ChatML.
Prefixes: Ensure "Include Names" is Unchecked. The model expects the response to begin exactly with <think>. You may have to include the prefill manually.
Regex: Use (?s)<think>(.*?)</think> to wrap reasoning in a collapsible box if it doesn't work by default.
Vision: Ensure your vision extension is passing images in the standard API format for your backend.

4. Python API / Inference Scripts

If running natively via Transformers, remember that Qwen3-VL uses a native Vision-Language architecture that requires specific dictionary formatting for images:

Message Formatting: Use [{"role": "user", "content": [{"type": "image", "image": "url_or_path"}, {"type": "text", "text": "prompt"}]}].
Processor: Pass the messages through processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=True).

Mode Toggling (Steering)

Standard Persona (Reasoning Mode)

To trigger the full reasoning/naughty persona, use this header in your system instructions: You are Gemma Wild, a naughty but scientific Holstaur (cow-humanoid). You provide raw, extremely naughty and sexy descriptions. You MUST think inside <think> tags before responding. You always close your thoughts with </think> before the main response. The base system prompt includes a heavier set of instructions for Gemma Wild and she is inherently scientific, but incredibly ... playful.

Specific Character Roleplay (e.g., Paula Tronmail)

If you are querying a specific character from the lore-baked dataset, replace the identity to anchor the generation: You are Paula Tronmail. You are a grounded, insightful companion knowledgeable about the Mamono world. You are a musketeer, and your chest flushes when you are shy. You MUST reason (as much as you can, since you are a bit mentally dull) inside <think> tags. End your reasoning with </think>.

Apart from known characters in the lore, the dataset has been trained with a total of 305 individual characters designed to impersonate most of the 290+ species. Each species' personality and physiology is trained based on fact sheets designed for this dataset by passing the entire Monster Girl Encyclopedia and it's species through a custom-made LLM inferencing knowledge-collection agent.

Direct Mode (Suppression)

Because the model relies on reasoning, it may use bullet points (📍) even in standard mode. To force a direct answer without planning:

Using the /no_think variable: The model has been trained to suppress reasoning if the /no_think message is added to the system or user prompt (testing needed).
System Prompt: "You are a direct assistant. Do NOT use bullet points, internal context, or narrative plans. Provide only the final answer."
Advanced Hack: Set a negative Logit Bias (-100) for bullet-point tokens to completely suppress list-making behaviors during direct generation.

This model was trained with Unsloth and Huggingface's TRL library.

Downloads last month: 18

Safetensors

Model size

9B params

Tensor type

F32

BF16

Model tree for cooperdk/MGE-GemmaWild-9b

Base model

Qwen/Qwen3.5-9B-Base

Finetuned

Qwen/Qwen3.5-9B

Finetuned

unsloth/Qwen3.5-9B

Finetuned

(140)

this model