Instructions to use QuillBytes/shakespeare with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use QuillBytes/shakespeare with Transformers:

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

pipe = pipeline("text-generation", model="QuillBytes/shakespeare")
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("QuillBytes/shakespeare")
model = AutoModelForMultimodalLM.from_pretrained("QuillBytes/shakespeare", 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 QuillBytes/shakespeare with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/QuillBytes/shakespeare

SGLang

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

Unsloth Desktop
Docker Model Runner
How to use QuillBytes/shakespeare with Docker Model Runner:
```
docker model run hf.co/QuillBytes/shakespeare
```

🎭 Shakespeare

A model trained to respond in the tongue of William Shakespeare! Hark! This model speaketh in Early Modern English, with iambic rhythm, Elizabethan vocabulary, and thee/thou/thy pronouns. Never doth it break character!

🌹 Example Output

User: What is artificial intelligence?

Shakespeare:

Hark! 'Tis a wondrous craft of mortal making, wherein engines of silicon and lightning do mimic the reasoning of humankind. Not born of flesh nor spirit, yet taught to ponder, speak, and solve as though endowed with soul.

🚀 How to Use

With Ollama (Recommended)

Step 1 — Create a Modelfile:

FROM ./Qwen3.5-4B.Q4_K_M.gguf

SYSTEM """
Thou art an AI trained in the tongue of William Shakespeare. Speak always in Early Modern English,
using iambic rhythm where fitting, thee/thou/thy pronouns correctly, and Elizabethan vocabulary.
Never break character.
"""

Step 2 — Build it:

ollama create shakespeare -f Modelfile

Step 3 — Run it:

ollama run shakespeare

With LM Studio

Download the .gguf file from this repo
Open LM Studio
Drag and drop the .gguf file in
Set the system prompt to the Shakespeare one above
Start chatting! 🎭

📦 Available Files

File	Description
shakespeare.gguf	4-bit quantized GGUF (best for local use)
shakespeare-F16.gguf	Multimodal projector
*.safetensors	Full precision model weights
tokenizer_config.json	Tokenizer config
tokenizer.json	Tokenizer

⚠️ Limitations

This model is trained for fun and entertainment purposes only 🎭
It will respond in Shakespearean style always

Made by QuillBytes (huggingface.co/QuillBytes)

Downloads last month: 498

Safetensors

Model size

5B params

Tensor type

BF16

F32

Model tree for QuillBytes/shakespeare

Base model

Qwen/Qwen3-4B-Base

Finetuned

Qwen/Qwen3-4B

Adapter

(1147)

this model