Qwen3.8-27B-Longbook27-v2

Qwen3.8-27B-Longbook27-v2

Summarizes, answers questions about and continues book-length text with a fine-tuned 27B model that uses Gated DeltaNet layers, in English and Japanese. For people who work with long documents.

Made by summerAIO on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Longbook27 v2 is a 27B language model, tuned further to read and write whole books, papers and lengthy reports. Version 2 improves on version 1 in behavior and output quality. Its layers include Gated DeltaNet linear attention, and the code for that design comes inside the repository, so loading needs trust_remote_code=True. It works in English and Japanese.

Who it suits: It suits people who read, summarize or extend long documents and have a GPU with enough memory.

Industry | Who uses it | How they use it | Example
Publishing | Editors | Summarize a manuscript chapter by chapter | Reading a book file and getting a chapter summary
Research | Analysts | Ask questions about long papers and reports | Checking a claim against a lengthy report
Writing | Authors | Continue long-form writing with a model | Extending a draft in the same style

If you have no GPU with at least 24 GB of memory, you can skip it, since the card says CPU offloading is not supported.

Where to use it:

• Python with transformers, on a GPU that holds the whole model
• A GPU of A100 80GB or H100 class for bf16, or a 24 GB GPU for 4-bit
• Windows, macOS or Linux with Python, for downloading the files

Use case | Who | What they get back
Book summaries | Editors | A summary of long text, best with greedy decoding
Long-document questions | Researchers | Answers drawn from a lengthy source
Continuation | Writers | New text that follows on from a long draft

How to set it up:

• Python and a CUDA GPU
• transformers, accelerate and bitsandbytes
• Optional faster kernels, which the model can run without
• Memory of about 54 GB for bf16 or about 17 GB for 4-bit NF4

1. Install the Hugging Face hub package and download the model files.
2. Install the Python packages in the block below.
3. Optionally add the faster linear-attention kernels.
4. Load the model fully onto the GPU with remote code enabled.

pip install -U huggingface_hub
hf download summerAIO/Qwen3.8-27B-Longbook27-v2

pip install -U transformers accelerate bitsandbytes
# Optional: much faster linear-attention kernels
pip install flash-linear-attention
pip install causal-conv1d --no-build-isolation

How to use it: Load the tokenizer and model, build a chat prompt that holds your text, and generate. The card's snippet names its model path with a summerMC prefix, so use the repository you downloaded from. Set USE_4BIT to False for bf16 on an 80 GB GPU.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

model_id = "summerMC/Qwen3.8-27B-Longbook27-v2"
USE_4BIT = True  # False for bf16 on 80 GB GPUs

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)  # required

if USE_4BIT:
    model = AutoModelForCausalLM.from_pretrained(
        model_id,
        quantization_config=BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_compute_dtype=torch.bfloat16,
            bnb_4bit_use_double_quant=True,
        ),
        device_map={"": 0},       # keep everything on GPU 0
        trust_remote_code=True,   # required
    )
else:
    model = AutoModelForCausalLM.from_pretrained(
        model_id,
        torch_dtype=torch.bfloat16,
        device_map={"": 0},
        trust_remote_code=True,   # required
    )

book_text = open("book.txt", encoding="utf-8").read()
messages = [{"role": "user", "content":
    "Summarize this book chapter by chapter. Only use facts stated in the text.\n\n" + book_text}]

prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True,
    enable_thinking=False,        # True: reason before answering
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=800,
        do_sample=False,          # greedy for faithful summaries
        repetition_penalty=1.05,
        pad_token_id=tokenizer.eos_token_id,
    )

print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True))

Tool | What it does
trust_remote_code | Must be True, because the architecture ships as remote code
enable_thinking | Set True to let the model reason first, at the cost of more tokens
do_sample | False gives greedy output for summaries and answers
repetition_penalty | Keep it near 1.05 to avoid loops

Example: You save a book as book.txt and ask the model to summarize it chapter by chapter using only facts from the text. With greedy decoding and up to 800 new tokens, a summary prints in your terminal. Check it against the source.

For newcomers and experts: This model is meant for long text, so give it real text rather than a placeholder and keep your request specific. A good first try is a short chapter in 4-bit mode with thinking off.

Under the hood, Gated DeltaNet linear-attention layers sit among the usual attention layers, and the custom kernels need everything on the GPU. For creative writing the card suggests sampling with temperature 0.7, top-p 0.8 and top-k 20.

Long text in a chat prompt
Gated DeltaNet hybrid model
Greedy or sampled generation
Summary or answer printed

Good to know:

Title: Approximate VRAM needed
bf16: 54 GB
4-bit NF4: 17 GB

• Memory use grows with the length of the input.
• Summaries may add details that are not in the source, so verify them against the original text.
• CPU offloading fails with a Tensor on device meta error.
• The extra kernel packages are not required. If you skip them, generation falls back to plain PyTorch code and takes longer.
• License: Apache 2.0
• Cost to run: none named, though it needs a large GPU
• Data it reaches: the text files you give it, run on your own machine
• Not for: CPU offloading, or trusting a summary without checking it

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 27.1B
• Weights: about 54.1 GB in BF16; about 13.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,407
• Likes: 49
• License: apache-2.0
• Languages: en, ja
• Quantized versions: 1
• Tags: transformers, safetensors, qwen3_5_gdn24, text-generation, long-context, summarization, conversational

Links

• Model: https://huggingface.co/summerAIO/Qwen3.8-27B-Longbook27-v2
• Files: https://huggingface.co/summerAIO/Qwen3.8-27B-Longbook27-v2/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download summerAIO/Qwen3.8-27B-Longbook27-v2

Then follow the usage in its model card. Nothing in this kit runs by itself.