Octen-WebGR-0.6B

Octen-WebGR-0.6B

Turns a short search query into the web address it most likely means, using a table of 30.9 million URLs stored with the model. For developers and researchers who want a small, self-hosted lookup.

Made by Octen 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: Octen-WebGR-0.6B turns a short search query into the web address you probably want. Instead of searching an index, the model generates a two-token code and that code is looked up in a table of 30.9 million URLs. The index is stored in the model's weights. It is a full fine-tune of Qwen3-0.6B-Base with 0.73B parameters, made by Octen.

Who it suits: It suits search engineers, retrieval researchers and app developers who want a compact model that resolves site names and similar navigational queries on their own hardware.

Industry | Who uses it | How they use it | Example
Search | Search engineers | Add a small model that resolves navigational queries to URLs | A query such as youtube returning the top URLs with scores
Research | Information retrieval researchers | Compare generative retrieval with dense retrieval and BM25 | Hit rates at rank 1 and rank 10 across several systems
Software | App developers | Add a quick way to jump to a site from a typed name | A typed company name resolved to its most likely page

You can skip it if you need open ended search over any page. It only returns URLs from its own table and finds few rarely visited pages.

Where to use it:

• A terminal with Python on Windows, macOS or Linux
• A CPU, since the model also runs without a GPU
• A GPU, which needs 1.6 GiB of memory
• Your own Python code, through the GRCPU class

Use case | Who | What they get back
Resolve a site name | App developers | The best URLs for the query, each with a log probability
Rank candidate pages | Search engineers | The top K URLs scored by two log probabilities
Benchmark retrieval | Researchers | Hit rates to compare against other approaches

How to set it up:

• Python, with the pinned versions in requirements.txt: torch 2.8.0 and transformers 4.57.1
• flash-attn is optional
• About 4.5 GiB of host RAM for the CPU script, or 1.6 GiB of GPU memory for the GPU script

1. Download the repository files, which include the inference scripts and the sid_table folder.
2. Open a terminal in the downloaded folder.
3. Install the requirements.

pip install -U huggingface_hub
hf download Octen/Octen-WebGR-0.6B

Then, inside the downloaded folder:

pip install -r requirements.txt

How to use it: Run one of the inference scripts with your queries. The card says not to call model.generate(), because the tokenizer has no entries for the identifier tokens and you would get codes that map to no URL.

python infer_cpu.py --model Octen/Octen-WebGR-0.6B --query "youtube" "boeing internship" --threads 16
python infer_gpu.py --model Octen/Octen-WebGR-0.6B --query "youtube"

From your own Python code, load the CPU class and search.

from huggingface_hub import snapshot_download
import sys

root = snapshot_download("Octen/Octen-WebGR-0.6B")
sys.path.insert(0, root)
from infer_cpu import GRCPU

gr = GRCPU(root)
for url, logp, row in gr.search(["hugging face"], K=10)[0]:
    print(url, logp)

Tool | What it does
infer_cpu.py | Runs the lookup on a CPU, and with --check compares the output against smoke_test.json
infer_gpu.py | A reference GPU version that recomputes the prompt for every beam
sid_table | The folder that maps identifier pairs to URLs
GRCPU | A Python class that loads the model and the URL table and runs searches

Example: Run infer_cpu.py with the queries youtube and boeing internship on 16 threads. Each query comes back with its best matching URLs, ranked by the sum of the two log probabilities.

For newcomers and experts: It is not a chatbot. You give it a short query such as a site name and it returns web addresses with scores. For a first try, download the files, install the requirements and run infer_cpu.py with the query youtube.

The query is cleaned and lowercased, cut to 32 tokens, then the model generates two identifier tokens, each drawn from 65,536 ids. Beam search with 20 beams only follows prefixes found in the table, and the pair is looked up to get the URL. A larger Octen-WebGR-4B covers a much bigger table. This model was trained on proprietary click pairs, which are not released.

The query is cleaned and lowercased
A prompt asks for the URL
Two identifier tokens are generated
Beam search stays inside the table
The pair is looked up to get the URL

Good to know: A CPU run answers one query in about 72 ms at the median, measured on a single Intel Xeon 8568Y+ socket. Batching 8 queries together reaches roughly 57 answers a second. On an idle H200 the reference GPU script takes 43.5 ms for one query. The test used navigational queries from September 2026.

Title: Hit at rank 1 on navigational test queries
Octen-WebGR-4B: 59.6 points
Lookup in the training click table: 58.9 points
Octen-WebGR-0.6B: 56.5 points
Dense retrieval plus click prior: 46.5 points
Dense retrieval: 24.8 points
BM25 over URL texts: 9.1 points

• License: cc-by-nc-4.0, the Creative Commons attribution non-commercial license
• Cost to run: none named, you use your own CPU or GPU
• Data it reaches: local files only, since it returns URLs from its own table
• Not for: open ended questions, rarely visited pages outside its table, or calling model.generate()

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 730M
• Weights: about 1.5 GB in BF16; about 365 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,458
• Likes: 58
• License: cc-by-nc-4.0
• Based on: Qwen/Qwen3-0.6B-Base
• Quantized versions: 4
• Tags: transformers, safetensors, qwen3, text-generation, generative-retrieval, semantic-id, navigational-search, web-search, conversational

Links

• Model: https://huggingface.co/Octen/Octen-WebGR-0.6B
• Files: https://huggingface.co/Octen/Octen-WebGR-0.6B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Octen/Octen-WebGR-0.6B

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