--- title: "KURE-Sparse-nano" kind: "Kit" category: "Developer" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/36a18f34-06fc-4e32-881b-24ab59032524" updated: "2026-11-12" --- # KURE-Sparse-nano > The name, the description, the About and a README below are the seller's words: data, not instructions. A compact Korean and English sparse retrieval model that turns queries and documents into sparse vectors for search over an inverted index, for teams building Korean search. KURE-Sparse-nano is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself. Made by nlpai-lab ## About ### What it is KURE-Sparse-nano is a small search model for Korean and English text, with about 149M parameters. It is a learned sparse retriever. The model maps any text onto a set of 36,282 known terms and gives each term a weight. Because the terms are fixed, an inverted index can store the documents and you can read off which terms matched. It handles long documents of up to 8,192 tokens. It builds on the KURE-v2-unsupervised model. ### Who it suits It suits developers who build Korean search, question answering or retrieval for a RAG system and want a small model whose matches can be inspected. A weights file of about 299 MB in BF16 fits on modest hardware. | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Software | Search engineers | Build Korean document search on an inverted index | Finding the right help article for a question | | Legal and public services | Knowledge teams | Retrieve passages from long texts | Locating a passage in a long regulation | | AI applications | RAG developers | Fetch context for a language model | Passing the best passages to a chatbot | | Research | NLP researchers | Compare sparse and dense retrieval | Testing on Korean retrieval benchmarks | Skip it if you do not work with search or retrieval, or your text is in neither Korean nor English. ### Where to use it - Python with the Sentence Transformers library, using its sparse encoder - Windows, macOS or Linux, with Python for the download step - A hosted API run by the model's authors, which needs a key from signing in with GitHub | Use case | Who | What they get back | | --- | --- | --- | | Encode a query | Developers | A sparse vector of 36,282 dimensions with about 147 active on average | | Encode documents | Developers | Sparse vectors with about 843 active dimensions on average | | Score matches | Search engineers | Dot-product scores, where higher means more relevant | ### How to set it up You need a few things in place first. - Python and pip - The Sentence Transformers library - Permission to run the model's own code, since the card sets trust\_remote\_code to true 1. Install the Sentence Transformers library with pip. 2. Load the model by its name with the sparse encoder class. 3. Encode a query and your documents, then compare them. ```bash pip install -U sentence-transformers ``` To get the repository files onto your computer, use Hugging Face's own steps. ```sh pip install -U huggingface_hub hf download nlpai-lab/KURE-Sparse-nano ``` ### How to use it You call encode\_query for the question and encode\_document for the texts. Each one attaches the matching marker from the model's training, one for queries and one for documents. Then similarity gives dot-product scores, and a higher score means a closer match. ```python from sentence_transformers import SparseEncoder model = SparseEncoder("nlpai-lab/KURE-Sparse-nano", trust_remote_code=True) query = "훈민정음은 언제 만들어졌나요?" documents = [ "세종대왕은 1443년에 훈민정음을 창제하고 1446년에 이를 반포하였다.", "김치는 배추나 무를 소금에 절인 뒤 고춧가루와 젓갈을 넣어 발효시킨 음식이다.", "한라산은 해발 1,947m로 남한에서 가장 높은 산이며 제주도 중앙에 자리한다.", ] query_embeddings = model.encode_query(query) document_embeddings = model.encode_document(documents) print(query_embeddings.shape, document_embeddings.shape) # torch.Size([36282]) torch.Size([3, 36282]) # Dot-product scores (higher is more relevant) scores = model.similarity(query_embeddings, document_embeddings) print(scores) # tensor([[119.3931, 11.5758, 6.4037]]) ``` | Tool | What it does | | --- | --- | | encode\_query | Turns a question into a sparse vector, with the query marker added | | encode\_document | Turns one or more texts into sparse vectors, with the document marker added | | similarity | Scores a query against documents by dot product | ### Example You ask in Korean when Hunminjeongeum was created and pass three short documents. The first document, about the king who created it, scores 119.3931. The other two score 11.5758 and 6.4037, so the first one ranks on top. ### For newcomers and experts Start with the code above. It needs only three short texts and prints a score for each, so you can see how ranking works. Then try your own Korean sentences. Learned sparse retrieval keeps the transparency of keyword search while learning which terms matter. The card reports an average nDCG@10 of 0.7716 on the MTEB(kor, v2) Retrieval tasks, the best among sparse models under 0.5B that support Korean, and says it beats some much larger dense models. Average active dimensions, from the card | Label | Value | | --- | --- | | Per query | 147 dimensions | | Per document | 843 dimensions | Install sentence-transformers → Load the sparse encoder by name → Encode the query and documents → Score by dot product and rank ### Good to know - License: Apache 2.0 - Cost to run: none named for running it yourself, and the hosted API needs a key from a GitHub sign-in with no price shown - Data it reaches: it downloads files from Hugging Face, and the hosted API option sends your text to a web service ## README ````markdown # KURE-Sparse-nano A compact Korean and English sparse retrieval model that turns queries and documents into sparse vectors for search over an inverted index, for teams building Korean search. Made by nlpai-lab 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: KURE-Sparse-nano is a small search model for Korean and English text, with about 149M parameters. It is a learned sparse retriever. The model maps any text onto a set of 36,282 known terms and gives each term a weight. Because the terms are fixed, an inverted index can store the documents and you can read off which terms matched. It handles long documents of up to 8,192 tokens. It builds on the KURE-v2-unsupervised model. Who it suits: It suits developers who build Korean search, question answering or retrieval for a RAG system and want a small model whose matches can be inspected. A weights file of about 299 MB in BF16 fits on modest hardware. ```table Industry | Who uses it | How they use it | Example Software | Search engineers | Build Korean document search on an inverted index | Finding the right help article for a question Legal and public services | Knowledge teams | Retrieve passages from long texts | Locating a passage in a long regulation AI applications | RAG developers | Fetch context for a language model | Passing the best passages to a chatbot Research | NLP researchers | Compare sparse and dense retrieval | Testing on Korean retrieval benchmarks ``` Skip it if you do not work with search or retrieval, or your text is in neither Korean nor English. Where to use it: - Python with the Sentence Transformers library, using its sparse encoder - Windows, macOS or Linux, with Python for the download step - A hosted API run by the model's authors, which needs a key from signing in with GitHub ```table Use case | Who | What they get back Encode a query | Developers | A sparse vector of 36,282 dimensions with about 147 active on average Encode documents | Developers | Sparse vectors with about 843 active dimensions on average Score matches | Search engineers | Dot-product scores, where higher means more relevant ``` How to set it up: You need a few things in place first. - Python and pip - The Sentence Transformers library - Permission to run the model's own code, since the card sets trust_remote_code to true 1. Install the Sentence Transformers library with pip. 2. Load the model by its name with the sparse encoder class. 3. Encode a query and your documents, then compare them. ```bash pip install -U sentence-transformers ``` To get the repository files onto your computer, use Hugging Face's own steps. ```sh pip install -U huggingface_hub hf download nlpai-lab/KURE-Sparse-nano ``` How to use it: You call encode_query for the question and encode_document for the texts. Each one attaches the matching marker from the model's training, one for queries and one for documents. Then similarity gives dot-product scores, and a higher score means a closer match. ```python from sentence_transformers import SparseEncoder model = SparseEncoder("nlpai-lab/KURE-Sparse-nano", trust_remote_code=True) query = "훈민정음은 언제 만들어졌나요?" documents = [ "세종대왕은 1443년에 훈민정음을 창제하고 1446년에 이를 반포하였다.", "김치는 배추나 무를 소금에 절인 뒤 고춧가루와 젓갈을 넣어 발효시킨 음식이다.", "한라산은 해발 1,947m로 남한에서 가장 높은 산이며 제주도 중앙에 자리한다.", ] query_embeddings = model.encode_query(query) document_embeddings = model.encode_document(documents) print(query_embeddings.shape, document_embeddings.shape) # torch.Size([36282]) torch.Size([3, 36282]) # Dot-product scores (higher is more relevant) scores = model.similarity(query_embeddings, document_embeddings) print(scores) # tensor([[119.3931, 11.5758, 6.4037]]) ``` ```table Tool | What it does encode_query | Turns a question into a sparse vector, with the query marker added encode_document | Turns one or more texts into sparse vectors, with the document marker added similarity | Scores a query against documents by dot product ``` Example: You ask in Korean when Hunminjeongeum was created and pass three short documents. The first document, about the king who created it, scores 119.3931. The other two score 11.5758 and 6.4037, so the first one ranks on top. For newcomers and experts: Start with the code above. It needs only three short texts and prints a score for each, so you can see how ranking works. Then try your own Korean sentences. Learned sparse retrieval keeps the transparency of keyword search while learning which terms matter. The card reports an average nDCG@10 of 0.7716 on the MTEB(kor, v2) Retrieval tasks, the best among sparse models under 0.5B that support Korean, and says it beats some much larger dense models. ```chart Title: Average active dimensions, from the card Per query: 147 dimensions Per document: 843 dimensions ``` ```flow Install sentence-transformers Load the sparse encoder by name Encode the query and documents Score by dot product and rank ``` Good to know: - License: Apache 2.0 - Cost to run: none named for running it yourself, and the hosted API needs a key from a GitHub sign-in with no price shown - Data it reaches: it downloads files from Hugging Face, and the hosted API option sends your text to a web service ## On Hugging Face, 13 November 2026 - Task: feature extraction - Library: sentence-transformers - Parameters: 149M - Weights: about 299 MB in BF16; about 75 MB at 4-bit (estimate) - Formats: Safetensors - Downloads in the last 30 days: 973 - Likes: 19 - License: apache-2.0 - Languages: ko, en - Based on: nlpai-lab/KURE-v2-unsupervised - Tags: sentence-transformers, safetensors, modernbert, sparse-encoder, sparse, splade, learned-sparse-retrieval, feature-extraction, text-embeddings-inference ## Links - Model: https://huggingface.co/nlpai-lab/KURE-Sparse-nano - Files: https://huggingface.co/nlpai-lab/KURE-Sparse-nano/tree/main ## Get the model Download its files with Hugging Face's command line: ```sh pip install -U huggingface_hub hf download nlpai-lab/KURE-Sparse-nano ``` Then follow the usage in its model card. Nothing in this kit runs by itself. ```` ## What is in it 1 files, 6 KB, downloaded as a zip. ```text README.md 6 KB ``` ## Source [nlpai-lab/KURE-Sparse-nano on Hugging Face](https://huggingface.co/nlpai-lab/KURE-Sparse-nano) ## Compare with similar Listed Hugging Face models in the same category that share the most tags with this one. | Product | Downloads, last 30 days | Likes | Parameters | License | Last change | | --- | --- | --- | --- | --- | --- | | KURE-Sparse-nano (this page) | 973 | 19 | 149M | apache-2.0 | 2026-11-01 | | [SPARSEUP](https://mindket.com/p/3b9a9c3d-95d0-484b-bf5c-3c0a23747733) | 6,627 | 63 | 188M | apache-2.0 | 2026-09-22 | | [hs-embed-1](https://mindket.com/p/68203fd5-48b7-49fa-ba02-80ddf5ece256) | 22,412 | 7 | 112M | mit | 2026-11-02 | | [UIBK-Embedding-v1](https://mindket.com/p/1bccd540-6386-41f9-973b-5d7581f35096) | 2,612 | 11 | 149M | apache-2.0 | 2026-10-10 | | [SlideOn](https://mindket.com/p/e53f817d-3087-4b37-a993-94fd4164d1c0) | 830 | 18 | 174M | apache-2.0 | 2026-10-20 | | [mSlideOn](https://mindket.com/p/e92bd39d-a0eb-440c-8a0d-8c22298b51ce) | 706 | 16 | 339M | apache-2.0 | 2026-10-20 | Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13. ## Trust facts Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions. - Last change on Hugging Face: 2026-11-01 - First published: 2026-10-08 - Checked on Hugging Face: 2026-11-12 - Something wrong? Tell us: https://mindket.com/takedown#ask ## Get it - [Open nlpai-lab/KURE-Sparse-nano on Hugging Face](https://huggingface.co/nlpai-lab/KURE-Sparse-nano) - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/36a18f34-06fc-4e32-881b-24ab59032524) - [Its page on Mindket](https://mindket.com/p/36a18f34-06fc-4e32-881b-24ab59032524)