ReaderLM-v2 is a 1.5B parameter language model that converts raw HTML into beautifully formatted markdown or JSON with superior accuracy and improved longer context handling. Supporting multiple languages (29 in total), ReaderLM-v2 is specialized for tasks involving HTML parsing, transformation, and text extraction.

What's New in `ReaderLM-v2`

ReaderLM-v2 represents a significant leap forward from its predecessor, with several key improvements:

Better Markdown Generation: Thanks to its new training paradigm and higher-quality training data, the model excels at generating complex elements like code fences, nested lists, tables, and LaTeX equations.
JSON Output: Introduces direct HTML-to-JSON generation using predefined schemas, eliminating the need for intermediate markdown conversion.
Longer Context Handling: Handles up to 512K tokens combined input and output length, with improved performance on long-form content.
Multilingual Support: Comprehensive support across 29 languages for broader applications.
Enhanced Stability: Greatly alleviates degeneration issues after generating long sequences through contrastive loss during training.

Model Overview

Model Type: Autoregressive, decoder-only transformer
Parameter Count: 1.54B
Context Window: Up to 512K tokens (combined input and output)
Hidden Size: 1536
Number of Layers: 28
Query Heads: 12
KV Heads: 2
Head Size: 128
Intermediate Size: 8960
Supported Languages: English, Chinese, Japanese, Korean, French, Spanish, Portuguese, German, Italian, Russian, Vietnamese, Thai, Arabic, and more (29 total)

Usage

Below, you will find instructions and examples for using ReaderLM-v2 locally using the Hugging Face Transformers library. For a more hands-on experience in a hosted environment, see the Google Colab Notebook.

Via Reader API

ReaderLM-v2 is now fully integrated with Reader API. To use it, simply specify x-engine: readerlm-v2 in your request headers and enable response streaming with -H 'Accept: text/event-stream':

curl https://r.jina.ai/https://news.ycombinator.com/ -H 'x-engine: readerlm-v2' -H 'Accept: text/event-stream'

You can try it without an API key at a lower rate limit. For higher rate limits, you can purchase an API key. Please note that ReaderLM-v2 requests consume 3x the normal token count from your API key allocation. This is currently an experimental feature, and we're working with the GCP team to improve GPU efficiency.

On Google Colab

You can try ReaderLM-v2 via our Colab notebook, which demonstrates HTML-to-markdown conversion, JSON extraction, and instruction-following using the HackerNews frontpage as an example. The notebook is optimized for Colab's free T4 GPU tier and requires vllm and triton for acceleration and running.

Note that the free T4 GPU has limitations—it doesn't support bfloat16 or flash attention 2, leading to higher memory usage and slower processing of longer inputs. Nevertheless, ReaderLM-v2 successfully processes large documents under these constraints, achieving processing speeds of 67 tokens/s input and 36 tokens/s output. For production use, we recommend an RTX 3090/4090 for optimal performance.

Local Usage

To use ReaderLM-v2 locally:

Install the necessary dependencies:

pip install transformers
Load and run the model:

python
1from transformers import AutoModelForCausalLM, AutoTokenizer 2 3device = "cuda" # or "cpu" 4tokenizer = AutoTokenizer.from_pretrained("jinaai/ReaderLM-v2") 5model = AutoModelForCausalLM.from_pretrained("jinaai/ReaderLM-v2").to(device)
(Optional) Pre-clean your HTML to remove scripts, styles, comments, to reduce the noise and length of the input:

python
1import re 2 3# Patterns 4SCRIPT_PATTERN = r"<[ ]*script.*?\/[ ]*script[ ]*>" 5STYLE_PATTERN = r"<[ ]*style.*?\/[ ]*style[ ]*>" 6META_PATTERN = r"<[ ]*meta.*?>" 7COMMENT_PATTERN = r"<[ ]*!--.*?--[ ]*>" 8LINK_PATTERN = r"<[ ]*link.*?>" 9BASE64_IMG_PATTERN = r'<img[^>]+src="data:image/[^;]+;base64,[^"]+"[^>]*>' 10SVG_PATTERN = r"(<svg[^>]*>)(.*?)(<\/svg>)" 11 12 13def replace_svg(html: str, new_content: str = "this is a placeholder") -> str: 14 return re.sub( 15 SVG_PATTERN, 16 lambda match: f"{match.group(1)}{new_content}{match.group(3)}", 17 html, 18 flags=re.DOTALL, 19 ) 20 21 22def replace_base64_images(html: str, new_image_src: str = "#") -> str: 23 return re.sub(BASE64_IMG_PATTERN, f'<img src="{new_image_src}"/>', html) 24 25 26def clean_html(html: str, clean_svg: bool = False, clean_base64: bool = False): 27 html = re.sub( 28 SCRIPT_PATTERN, "", html, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL 29 ) 30 html = re.sub( 31 STYLE_PATTERN, "", html, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL 32 ) 33 html = re.sub( 34 META_PATTERN, "", html, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL 35 ) 36 html = re.sub( 37 COMMENT_PATTERN, "", html, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL 38 ) 39 html = re.sub( 40 LINK_PATTERN, "", html, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL 41 ) 42 43 if clean_svg: 44 html = replace_svg(html) 45 if clean_base64: 46 html = replace_base64_images(html) 47 return html
Create a prompt for the model:

python
1def create_prompt( 2 text: str, tokenizer=None, instruction: str = None, schema: str = None 3) -> str: 4 """ 5 Create a prompt for the model with optional instruction and JSON schema. 6 """ 7 if not instruction: 8 instruction = "Extract the main content from the given HTML and convert it to Markdown format." 9 if schema: 10 instruction = "Extract the specified information from a list of news threads and present it in a structured JSON format." 11 prompt = f"{instruction}\n```html\n{text}\n```\nThe JSON schema is as follows:```json\n{schema}\n```" 12 else: 13 prompt = f"{instruction}\n```html\n{text}\n```" 14 15 messages = [ 16 { 17 "role": "user", 18 "content": prompt, 19 } 20 ] 21 22 return tokenizer.apply_chat_template( 23 messages, tokenize=False, add_generation_prompt=True 24 )

HTML to Markdown Example

python

html = "<html><body><h1>Hello, world!</h1></body></html>"

html = clean_html(html)

input_prompt = create_prompt(html, tokenizer=tokenizer)
inputs = tokenizer.encode(input_prompt, return_tensors="pt").to(device)
outputs = model.generate(
    inputs, max_new_tokens=1024, temperature=0, do_sample=False, repetition_penalty=1.08
)

print(tokenizer.decode(outputs[0]))

HTML to JSON Example

python

schema = """
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "author": {
      "type": "string"
    },
    "date": {
      "type": "string"
    },
    "content": {
      "type": "string"
    }
  },
  "required": ["title", "author", "date", "content"]
}
"""

html = clean_html(html)
input_prompt = create_prompt(html, tokenizer=tokenizer, schema=schema)

inputs = tokenizer.encode(input_prompt, return_tensors="pt").to(device)
outputs = model.generate(
    inputs, max_new_tokens=1024, temperature=0, do_sample=False, repetition_penalty=1.08
)

print(tokenizer.decode(outputs[0]))

Model Performance

ReaderLM-v2 has been extensively evaluated on various tasks:

Quantitative Evaluation

For HTML-to-Markdown tasks, the model outperforms much larger models like Qwen2.5-32B-Instruct and Gemini2-flash-expr, achieving:

ROUGE-L: 0.84
Levenshtein Distance: 0.22
Jaro-Winkler Similarity: 0.82

For HTML-to-JSON tasks, it shows competitive performance with:

F1 Score: 0.81
Precision: 0.82
Recall: 0.81
Pass-Rate: 0.98

Qualitative Evaluation

The model excels in three key dimensions:

Content Integrity: 39/50
Structural Accuracy: 35/50
Format Compliance: 36/50

These scores demonstrate strong performance in preserving semantic information, maintaining structural accuracy, and adhering to markdown syntax standards.

Training Details

ReaderLM-v2 is built on Qwen2.5-1.5B-Instruction and trained using a sophisticated pipeline:

Data Preparation: Created html-markdown-1m dataset with 1 million HTML documents
Synthetic Data Generation: Three-step pipeline using Qwen2.5-32B-Instruction
- Drafting: Initial markdown and JSON generation
- Refinement: Content cleanup and structure alignment
- Critique: Quality evaluation and filtering
Training Process:
- Long-context pretraining
- Supervised fine-tuning
- Direct preference optimization
- Self-play reinforcement tuning

adriabama06/ReaderLM-v2-AWQ

ReaderLM-v2 (AWQ-4bit 128g) | Warning this quant may be broken

What's New in ReaderLM-v2