Instructions to use Rumiii/Genesis-8B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Rumiii/Genesis-8B with Transformers:

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

pipe = pipeline("text-generation", model="Rumiii/Genesis-8B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Rumiii/Genesis-8B")
model = AutoModelForCausalLM.from_pretrained("Rumiii/Genesis-8B", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.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=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Rumiii/Genesis-8B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/Rumiii/Genesis-8B

SGLang

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

Docker Model Runner
How to use Rumiii/Genesis-8B with Docker Model Runner:
```
docker model run hf.co/Rumiii/Genesis-8B
```

You need to agree to share your Hugging Face information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Genesis-8B

Genesis-8B is a QLoRA fine-tune of Qwen3-8B for agentic tool-calling in drug-discovery workflows. It is trained to select the correct tool for a request, extract structured arguments (SMILES strings, property names, targets), and synthesize a final natural-language answer once a tool returns a result.

Model Details


Base model	unsloth/Qwen3-8B
Method	QLoRA (r=16, α=16), trained with Unsloth
Training data	lik98/TCDD — Tool-Calling Dataset for Drug Discovery, from the DrugPilot paper (arXiv:2505.13940)
Context length	8,192 tokens
Hardware	Single NVIDIA T4
License	CC-BY-NC-SA-4.0 (inherited from the training data) — non-commercial, share-alike

Benchmarking

Genesis-8B achieved 96.7% exact-match accuracy (290 out of 300 samples) on drug-discovery tool-calling tasks. It performed particularly well in cell-response prediction, drug–target interaction, and retrosynthesis, achieving 100% accuracy across these task families. Its weakest area was drug–drug response prediction at 81.8%, followed by drug property prediction at 94.3%. Most errors involved minor SMILES formatting mistakes, highlighting an opportunity to improve the model's precision when handling chemical structures.

Format

Genesis-8B uses ChatML with Hermes-style tool calling. Tool schemas are declared in the system message inside <tools> tags; the model responds with a <tool_call> block, reads the result from a <tool_response> message, and produces a final answer.

<|im_start|>system
{system_prompt}
<tools>
[{tool_schema_json}]
</tools><|im_end|>
<|im_start|>user
{user_request}<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "...", "arguments": {...}}
</tool_call><|im_end|>
<|im_start|>user
<tool_response>
{tool_result_json}
</tool_response><|im_end|>
<|im_start|>assistant
{final_answer}<|im_end|>

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "Rumiii/Genesis-8B"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

system_prompt = (
    "You are a function calling AI model. You are provided with function "
    "signatures within <tools></tools> XML tags. You may call one or more "
    "functions to assist with the user query. Don't make assumptions about "
    "what values to plug into functions. For each function call return a "
    "json object with function name and arguments within <tool_call></tool_call> "
    "XML tags as follows: <tool_call>{\"name\": <function-name>,\"arguments\": "
    "<args-dict>}</tool_call>."
)

tools = [{
    "name": "drug_property_prediction",
    "description": "Predict properties of drugs based on SMILES",
    "parameters": {
        "type": "object",
        "properties": {
            "drug_smiles": {"type": "array", "items": {"type": "string"}},
            "property_name": {"type": "string"},
        },
    },
}]

import json
prompt = (
    f"<|im_start|>system\n{system_prompt}\n<tools>\n{json.dumps(tools)}\n</tools><|im_end|>\n"
    f"<|im_start|>user\nWhat is the free energy of dissolution for CCO?<|im_end|>\n"
    f"<|im_start|>assistant\n"
)

inputs = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).to(model.device)
output = model.generate(**inputs, max_new_tokens=200, do_sample=False)
print(tokenizer.decode(output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Intended Use

Research and portfolio use in agentic tool-calling for biomedical and drug-discovery workflows. Tool outputs seen during training were synthetic and not experimentally validated — this model is not intended for clinical, diagnostic, or production decision-making.

Citation

If you use this model, please also cite the underlying dataset and base model:

@article{li2025drugpilot,
  title   = {DrugPilot: LLM-based Parameterized Reasoning Agent for Drug Discovery},
  author  = {Li, Kun and Wu, Zhennan and Wang, Shoupeng and Wu, Jia and Pan, Shirui and Hu, Wenbin},
  journal = {arXiv preprint arXiv:2505.13940},
  year    = {2025}
}