Best Feature Extraction Models for CPU-Only PCs in 2026

Quick Answer

Jina AI’s jina-embeddings-v5-text-small (Jina AI) is the top pick for CPU-only PCs as of September 2026 because it combines 596M parameters with a 32K-token context [3]. In order, the ranking is jina-embeddings-v5-text-small (Jina AI), Qwen3-VL-Embedding-8B (Qwen), Qwen3-VL-Embedding-2B (Qwen), Nemotron-3-Embed-1B-BF16 (NVIDIA), harrier-oss-v1-0.6b (Microsoft), harrier-oss-v1-270m (Microsoft), jina-embeddings-v5-omni-small (Jina AI), and llama-nemotron-embed-1b-v2 (NVIDIA) [3][10].

Key Takeaways

• Jina AI’s jina-embeddings-v5-text-small leads because the ranking rule gives its newer, unscored release precedence over the older scored Qwen releases.[3][10][12] It has no public benchmark yet; its license is cc-by-nc-4.0.[2][3]
• Qwen’s Qwen3-VL-Embedding-8B and Qwen3-VL-Embedding-2B score 62.2 and 58.2, respectively, on the shared MTEB results.[2] Weight memory at 4-bit is estimated (params x 0.5 bytes): 4.05 GB from 8.1B parameters and 1.05 GB from 2.1B parameters; both use Apache-2.0.[10][12]
• NVIDIA’s Nemotron-3-Embed-1B-BF16 combines an MTEB score of 54.2 with a 256K-token context and the openmdw-1.1 license.[2][13] Weight memory at 4-bit is estimated (params x 0.5 bytes): 550 MB from 1.1B parameters.[13]
• Microsoft’s harrier-oss-v1-0.6b and harrier-oss-v1-270m offer MIT licensing and 32K-token contexts.[1][9] Their MTEB scores are 33.5 and 29.6, respectively.[2] Weight memory at 4-bit is estimated (params x 0.5 bytes): 298 MB from 596M parameters and 134 MB from 268M parameters.[1][9]
• Jina AI’s jina-embeddings-v5-text-small has 596M parameters, a 32K-token context and 4-bit weight memory estimated (params x 0.5 bytes) at 298 MB.[3] Use weight estimates to shortlist candidates for CPU testing; they do not establish measured throughput or total runtime RAM.
• Ranking note: eligibility follows the recent-release gate; shared MTEB scores order scored models, newer unscored releases stay above older scored releases, and popularity only breaks ties.[1][2][3][5][7][9][10][12][13] Scope includes only embedding models tagged feature-extraction or sentence-similarity on Hugging Face; rerankers are excluded.

How do local embedding models compare on estimated weight memory, context, licenses, and benchmarks?

Which embedding models should you consider for a CPU-only PC?

1. jina-embeddings-v5-text-small

jina-embeddings-v5-text-small from Jina AI ranks first here provisionally for its combination of a compact parameter count and long context, with estimated weight storage useful for CPU-only planning—not a demonstrated CPU-speed advantage.[3] The model has 596M parameters, supports 32K tokens of context, and ships with 1.4 GB of BF16 weights.[3]

For local hardware planning, 596M parameters imply approximately 298 MB of 4-bit weight storage, estimated (params x 0.5 bytes).[3] Treat that as a weight-storage estimate; allow additional RAM for execution and workload data. Consider the model for local text-embedding workloads where its context allowance is useful. A specific CPU configuration or measured throughput cannot be recommended from the available specifications.

The ranking remains provisional: no public benchmark yet (MTEB results, archived date unknown).[2] Benchmark scores cannot place older scored models above this newer unscored candidate. The deployment caveat is its cc-by-nc-4.0 license; check compatibility with your intended use.[3]

2. Qwen3-VL-Embedding-8B

Qwen3-VL-Embedding-8B by Qwen earns its place through a mean main MTEB score of 62.2 across 100 published task results.[2] Its practical use is multimodal retrieval, where embedding quality matters to the application.[11] The model has 8.1B parameters, a 256K-token context window and an Apache-2.0 license; its published BF16 weights occupy 16.3 GB.[10] Those specifications make memory planning central to evaluating a local deployment.

For a CPU-only PC, the 8.1B parameter count implies a 4-bit weight budget of 4.05 GB—estimated (params x 0.5 bytes).[10] A machine must also accommodate runtime memory, so that weight estimate cannot establish a total RAM requirement. Consider the model for retrieval workloads where its published benchmark quality justifies evaluating the memory cost.[2][10] The caveat is CPU performance: the MTEB score measures task quality, and does not establish how quickly a local CPU will produce embeddings.[2]

3. Qwen3-VL-Embedding-2B

Qwen3-VL-Embedding-2B by Qwen ranks here because it combines an MTEB mean main score of 58.2 across 100 published task results[2] with a manageable estimated weight footprint: 2.1B parameters imply 1.05 GB of 4-bit weights, estimated (params x 0.5 bytes).[12]

The model supports a 256K-token context window and uses the Apache-2.0 license; its published BF16 weights occupy 4.3 GB.[12] For local CPU deployment, the 1.05 GB weight estimate—estimated (params x 0.5 bytes), based on 2.1B parameters[12]—provides a starting point for memory planning. Total system RAM requirements and CPU throughput remain unverified.

Consider it for local embedding workloads where the documented context allowance and license suit the application.[12] The caveat is performance certainty: the published MTEB score measures task quality,[2] while CPU latency and quantized execution quality still need validation on the intended PC.

4. Nemotron-3-Embed-1B-BF16

Nemotron-3-Embed-1B-BF16 by NVIDIA earns its place through a published MTEB mean main score of 54.2 across 100 task results, below Qwen’s Qwen3-VL-Embedding-8B at 62.2 and Qwen3-VL-Embedding-2B at 58.2.[2] Released on July 14, 2026, the model has 1.1B parameters, a 256K-token context window, and the openmdw-1.1 license.[13] Long-document embedding is a practical use to evaluate given that context allowance.[13]

For local hardware planning, 4-bit weight memory is approximately 0.55 GB, estimated (params x 0.5 bytes) from the cited 1.1B parameters; published BF16 weights occupy 2.3 GB.[13] A CPU-only PC needs RAM beyond that weight estimate, so do not treat it as a complete machine requirement. The caveat is execution cost: the MTEB score measures embedding quality, while the weight estimate does not establish CPU throughput or total runtime memory.[2][13] Validate both with your intended document lengths before committing to a deployment.

5. harrier-oss-v1-0.6b

harrier-oss-v1-0.6b by Microsoft ranks here for its combination of a published MTEB mean main score of 33.5 across 100 task results [2], compact parameters and MIT licensing [1]. Its 596M parameters, 32K-token context window and 1.2 GB of BF16 weights provide a practical starting point for evaluating local deployment [1]. The benchmark score exceeds the 29.6 recorded for Microsoft’s harrier-oss-v1-270m on the same published task set [2].

For a CPU-only PC, four-bit weight storage is approximately 298 MB, estimated (params x 0.5 bytes) from the cited 596M parameters [1]. Budget additional RAM for the runtime and working memory; that estimate covers weights alone. Consider it for local document embedding when the MIT license and 32K-token context suit the application [1]. The caveat is CPU performance: the MTEB score measures task quality, so validate latency and memory use with your intended runtime before deployment.

6. harrier-oss-v1-270m

harrier-oss-v1-270m from Microsoft ranks here because its published MTEB mean main score of 29.6 trails Microsoft’s harrier-oss-v1-0.6b at 33.5 across the 100 task results published for each model.[2] Released on March 30, 2026, harrier-oss-v1-270m has 268M parameters, a 32K-token context window and an MIT license.[9] Consider it for local embedding pipelines where a compact model and permissive licensing are priorities.[9]

For CPU-only deployment, its 268M parameters imply a 4-bit weight footprint of approximately 134 MB, estimated (params x 0.5 bytes); published BF16 weights occupy 0.5 GB.[9] Treat the weight estimate as a starting point when budgeting hardware: a local runtime also needs memory beyond the weights. The caveat is that neither a total RAM requirement nor CPU throughput is established here, so the weight footprint alone cannot confirm how well the model will run on a particular PC.

7. jina-embeddings-v5-omni-small

jina-embeddings-v5-omni-small by Jina AI ranks here because its MTEB mean main score of 16.6 across 100 published task results falls below the other scored candidates in this selection.[2] That score supports its benchmark position, but does not establish CPU inference speed.

The model has 1.6B parameters, a 32K-token context window and 3.4 GB of BF16 weights.[5] Weight storage at 4-bit is approximately 0.8 GB, estimated (params x 0.5 bytes) from the cited 1.6B parameters.[5] For a local CPU-only PC, treat that estimate as a weight-storage budget: allow additional RAM for execution and avoid treating it as a complete system-memory requirement. CPU throughput and total RAM requirements remain unestablished here.

The model suits multimodal embedding work where preserving text geometry matters, matching its frozen-tower composition approach.[6] The practical caveat is its cc-by-nc-4.0 license; check whether your intended use is compatible before adopting it.[5]

8. llama-nemotron-embed-1b-v2

llama-nemotron-embed-1b-v2 by NVIDIA ranks here as an older, unscored option: it was published on October 16, 2025,[7] before NVIDIA’s Nemotron-3-Embed-1B-BF16 on July 14, 2026.[13] Its benchmark status is “no public benchmark yet” (MTEB results, archived date unknown), so a performance-based advantage is not established.[2]

The model has 1.2B parameters, a 128K-token context window, 2.5 GB of BF16 weights and the nvidia-open-model-license.[7] For a CPU-only PC, its weight-storage budget at 4-bit is approximately 600 MB, estimated (params x 0.5 bytes) from the cited 1.2B parameters.[7] Treat that figure as a weight-storage estimate, not a complete RAM requirement or confirmation that a particular PC can run it.

Consider it for local embedding work where the 128K-token context window matches your input needs and the license suits your project.[7] The caveat is uncertain performance: benchmark standing remains unestablished,[2] and the weight estimate does not establish CPU latency.

How do you estimate quantized weight memory from parameter counts?

Estimate quantized weight memory by multiplying the parameter count by 0.5 bytes for 4-bit weights, then label the result “estimated (params x 0.5 bytes)” beside the cited parameter count.[1] Treat the result as a weight-storage estimate, rather than a prediction of total RAM use.

Microsoft’s harrier-oss-v1-0.6b (Microsoft) has 596M parameters: quantized weight memory is 298 MB, estimated (params x 0.5 bytes).[1] Microsoft’s harrier-oss-v1-270m (Microsoft) has 268M parameters: quantized weight memory is 134 MB, estimated (params x 0.5 bytes).[9] Both calculations use decimal units, keeping the conversion consistent with the parameter counts.

NVIDIA’s Nemotron-3-Embed-1B-BF16 (NVIDIA) has 1.1B parameters: quantized weight memory is 550 MB, estimated (params x 0.5 bytes).[13] Use the parameter count directly; the published BF16 weight size of 2.3 GB is a separate specification, not the input to this calculation.[13]

For the same parameter count, 4-bit weights occupy approximately one quarter of the BF16 weight memory: 0.5 versus 2 bytes per parameter.[13] Keep that comparison limited to weights. A calculated weight footprint does not establish whether a model fits within a particular PC’s available RAM, how much memory a workload needs, or how quickly embedding generation runs on its CPU.

Which embedding models use MIT or Apache licenses?

Microsoft’s harrier-oss-v1-0.6b (Microsoft) and harrier-oss-v1-270m (Microsoft) use the MIT license [1][9], while Qwen’s Qwen3-VL-Embedding-8B (Qwen) and Qwen3-VL-Embedding-2B (Qwen) use Apache-2.0 [10][12].

The Microsoft models pair compact parameter counts with the same context limit. harrier-oss-v1-0.6b has 596M parameters [1]; its 4-bit weight memory is 0.298 GB, estimated (params x 0.5 bytes) [1]. harrier-oss-v1-270m has 268M parameters [9]; its corresponding weight memory is 0.134 GB, estimated (params x 0.5 bytes) [9]. Both support a context length of 32K tokens [1][9].

The Qwen models offer a context length of 256K tokens [10][12]. Qwen3-VL-Embedding-8B has 8.1B parameters, with 4-bit weight memory of 4.05 GB, estimated (params x 0.5 bytes) [10]. Qwen3-VL-Embedding-2B has 2.1B parameters, with 4-bit weight memory of 1.05 GB, estimated (params x 0.5 bytes) [12]. Those calculations describe weight storage, not measured total RAM requirements.

Published MTEB mean main scores are 62.2 for Qwen3-VL-Embedding-8B, 58.2 for Qwen3-VL-Embedding-2B, 33.5 for harrier-oss-v1-0.6b and 29.6 for harrier-oss-v1-270m, each across 100 published task results [2]. For a CPU-only PC, use the weight estimates to compare storage requirements and the MTEB scores to compare benchmark results; neither establishes CPU throughput.

What do published embedding benchmarks tell you about CPU suitability?

Published embedding benchmarks tell you about embedding quality, but the reported scores do not establish CPU inference speed or total runtime memory requirements.[2]

Qwen’s Qwen3-VL-Embedding-8B scores 62.2, while NVIDIA’s Nemotron-3-Embed-1B-BF16 scores 54.2; both figures are mean main scores across the 100 MTEB task results published for each model.[2] Those averages support a quality comparison on that benchmark, not a claim that either model processes documents faster on your PC.

Weight storage adds a separate consideration. Qwen3-VL-Embedding-8B has 8.1B parameters: 4-bit weight memory is 4.05 GB, estimated (params x 0.5 bytes).[10] Nemotron-3-Embed-1B-BF16 has 1.1B parameters: 4-bit weight memory is 0.55 GB, estimated (params x 0.5 bytes).[13] Both estimates describe weights alone; neither establishes total RAM needs or confirms that a particular CPU runtime supports the model.

Microsoft’s harrier-oss-v1-0.6b scores 33.5, compared with 29.6 for Microsoft’s harrier-oss-v1-270m.[2] Jina AI’s jina-embeddings-v5-text-small has “no public benchmark yet” in the specified MTEB results, whose archived date is unknown; that status is an evidence gap, not a low score.[2][3]

Ranking note: the ranking admits only embedding models tagged feature-extraction or sentence-similarity; rerankers are excluded. Ordering applies the release-recency gate, then comparable published benchmark scores, without placing an older scored model above a newer unscored model; popularity only breaks ties, and parameter count does not determine rank. CPU suitability therefore remains a separate deployment judgment.

Frequently Asked Questions

Which model has the highest published embedding benchmark score?

Qwen’s Qwen3-VL-Embedding-8B [10] ranks first among the publicly scored candidates because its mean main score is 62.2 across 100 published MTEB task results. [2] That result measures embedding quality, not CPU speed. An overall ranking cannot place it above jinaai’s newer, unscored jina-embeddings-v5-text-small under the required ordering rule: their publication dates are January 7 and January 22, respectively. [10][3]

How does the ranking handle missing benchmarks and newer releases?

Ranking note: the scope admits only embedding models tagged feature-extraction or sentence-similarity on Hugging Face; rerankers are excluded. Eligible releases pass the recency gate, then comparable public benchmark scores guide ordering. [2] An older scored model cannot outrank a newer unscored model. Missing results receive “no public benchmark yet”; model-card benchmarks must be labeled self-reported. Popularity breaks ties only, and parameter count does not determine rank.

How much memory would quantized embedding weights need?

Microsoft’s harrier-oss-v1-270m has 268M parameters [9]: quantized weight storage is approximately 134 MB, estimated (params x 0.5 bytes). [9] NVIDIA’s Nemotron-3-Embed-1B-BF16 has 1.1B parameters [13]: approximately 550 MB, estimated (params x 0.5 bytes). [13] Treat both figures as weight-storage estimates, not total system RAM requirements. Neither calculation establishes that a compatible quantized release exists or predicts CPU throughput.

Which licenses do these embedding models use?

Microsoft’s harrier-oss-v1-0.6b and its smaller sibling use MIT. [1][9] The Qwen candidates use Apache-2.0. [10][12] Both jinaai candidates use cc-by-nc-4.0. [3][5] NVIDIA’s newer candidate uses openmdw-1.1, while NVIDIA’s llama-nemotron-embed-1b-v2 uses nvidia-open-model-license. [13][7] Keep license choice separate from benchmark quality, and check the applicable terms against your intended deployment before selecting a model.

Which models support long documents without large weight estimates?

NVIDIA’s newer candidate pairs a 256K-token context with 1.1B parameters [13], giving approximately 550 MB of quantized weights, estimated (params x 0.5 bytes). [13] Qwen’s Qwen3-VL-Embedding-2B supports 256K tokens with 2.1B parameters [12], or approximately 1.05 GB, estimated (params x 0.5 bytes). [12] Context capacity alone does not establish practical CPU latency or total RAM consumption at that length.

Do the published benchmarks tell me which model runs fastest on a CPU?

The published MTEB mean main scores describe task performance; they do not establish a CPU speed winner. [2] For jinaai’s text candidate and NVIDIA’s older candidate, the benchmark status is “no public benchmark yet” (MTEB results, archived date unknown). [2] Before deployment, measure latency and peak RAM on your own machine using representative document lengths, batch settings and the runtime you intend to use.

Sources

1. microsoft/harrier-oss-v1-0.6b model card (Hugging Face) — 2026-09-25
2. MTEB results (mteb/results, revision 2026-09-25) — 2026-09-25
3. jinaai/jina-embeddings-v5-text-small model card (Hugging Face) — 2026-09-25
4. jina-embeddings-v5-text: Task-Targeted Embedding Distillation — 2026-02-17
5. jinaai/jina-embeddings-v5-omni-small model card (Hugging Face) — 2026-09-25
6. jina-embeddings-v5-omni: Text-Geometry-Preserving Multimodal Embeddings via Frozen-Tower Composition — 2026-05-08
7. nvidia/llama-nemotron-embed-1b-v2 model card (Hugging Face) — 2026-09-25
8. NV-Retriever: Improving text embedding models with effective hard-negative mining — 2024-07-22
9. microsoft/harrier-oss-v1-270m model card (Hugging Face) — 2026-09-25
10. Qwen/Qwen3-VL-Embedding-8B model card (Hugging Face) — 2026-09-25
11. Qwen3-VL-Embedding and Qwen3-VL-Reranker: A Unified Framework for State-of-the-Art Multimodal Retrieval and Ranking — 2026-01-08
12. Qwen/Qwen3-VL-Embedding-2B model card (Hugging Face) — 2026-09-25
13. nvidia/Nemotron-3-Embed-1B-BF16 model card (Hugging Face) — 2026-09-25
14. Compact Language Models via Pruning and Knowledge Distillation — 2024-07-19