NVIDIA Nemotron embeddings in n8n: a native node for cheaper RAG

Every RAG pipeline carries a hidden cost that's easy to miss until it shows up on the bill: embeddings. At ingestion, every chunk of every document triggers an API call; every question asked triggers one more. On a corpus of several thousand pages, or with frequent resynchronization, the bill climbs fast — even though embedding models are priced well below generation LLMs per token. Since n8n 2.26 (June 2026), a native option changes that math: the NVIDIA Nemotron Embeddings node, which gives access to solid NeMo Retriever models through a free developer plan, no credit card required. This guide walks through setting it up and where it fits into an existing RAG pipeline.

What this node brings

The NVIDIA Nemotron Embeddings node generates vectors from NVIDIA's NeMo Retriever model family, exposed either through the build.nvidia.com cloud API or through a self-hosted NIM (NVIDIA Inference Microservice) container. Like other n8n Embeddings nodes, it plugs in as a sub-node of a Vector Store node — Supabase Vector Store, PGVector Vector Store, Qdrant Vector Store — and works in either insert mode at ingestion or retrieval mode at query time.

Two details set it apart from older embeddings integrations:

• It reuses the existing NVIDIA credential. If you already use the NVIDIA Nemotron Chat Model node for generation, the same API key also serves the embeddings node: no second account to create, no second key to secure.
• It automatically distinguishes passages from queries. NeMo Retriever models are trained asymmetrically: a text being indexed (a "passage") and a question asked by a user (a "query") aren't encoded the same way internally, even though they produce comparable vectors. The node automatically sends the right input_type parameter depending on whether it's running in insert or retrieval mode — a detail that, if missed, silently degrades RAG relevance without throwing any error.

This distinction isn't a marketing flourish: it directly reflects the dual-encoder logic popularized by Dense Passage Retrieval for Open-Domain Question Answering, by Karpukhin and coauthors (EMNLP 2020), which showed that training separate encoders for questions and passages meaningfully improves retrieval quality over a naive symmetric encoding. NVIDIA's NV-Embed models, described in NV-Embed: Improved Techniques for Training LLMs as Generalist Embedding Models (Lee et al., ICLR 2025), which topped the MTEB leaderboard, belong to that same architecture family — which is exactly why it's worth letting the node handle input_type automatically rather than setting it by hand.

Creating the NVIDIA credential in n8n

1. Sign up at build.nvidia.com — registration is free and doesn't require a credit card.
2. On a Nemotron model's page (chat or embeddings), click Get API Key, then copy the generated key (it starts with nvapi-).
3. In n8n, create a new NVIDIA Nemotron API credential and paste the key into the API Key field.
4. Leave the default base URL (https://integrate.api.nvidia.com/v1) to use the NVIDIA cloud, or replace it with your NIM container's address if you're self-hosting the model.

The same credential powers both the NVIDIA Nemotron Chat Model node and the NVIDIA Nemotron Embeddings node: one setup wires up generation and vector search on NVIDIA's infrastructure.

Wiring the node into an existing RAG pipeline

In a typical ingestion workflow — close to the one described in our complete n8n RAG guide with Supabase — the Embeddings node sits right before the Vector Store node, after splitting documents into chunks:

1. Extraction of the text (PDF, Notion page, CSV export…).
2. Chunking with the usual Text Splitter.
3. Embeddings: replace the OpenAI Embeddings node with the NVIDIA Nemotron Embeddings node, select the credential created above, and pick a NeMo Retriever model from the list (the node queries the catalog available at your base URL).
4. Insertion into the Vector Store node, in Insert mode.

On the chat or question-answering API side, the same NVIDIA Nemotron Embeddings node converts the user's question into a vector — automatically as input_type: query this time — before the pgvector match_documents call described in our guide to connecting n8n to Supabase.

Non-negotiable point: as with any embeddings model change, the rule from our guide to choosing an embeddings model applies in full. A vector produced by NV-Embed and a vector produced by OpenAI's text-embedding-3-small aren't comparable: switching from one to the other requires re-ingesting the entire corpus, and possibly adjusting the vector(n) column dimension in Supabase if it differs.

The free plan: what to know before relying on it in production

The build.nvidia.com developer account grants access to the hosted model catalog — including NeMo Retriever — at no cost, making it possible to prototype a full RAG pipeline without spending a cent. Two caveats worth keeping in mind:

• Rate limits (requests per minute) are tighter than on a paid plan and can vary by model and overall platform load. A light load test before going to production avoids surprises during an ingestion or traffic spike.
• Terms evolve: NVIDIA regularly adjusts its catalog and limits. Check the current state on the model's page before committing, rather than relying on a number read elsewhere.

For production use with sustained volumes or strict confidentiality requirements, the same node works unchanged against a self-hosted NIM container: just change the credential's base URL. That's the option to favor when ingested documents shouldn't pass through any third-party service — a frequent need for firms and small businesses handling contractual data, as in our guide on analyzing contract clauses with AI.

Should you migrate an existing RAG to Nemotron?

Not automatically. If your current pipeline with OpenAI embeddings or a local Ollama model runs well and cost isn't an issue, migrating brings no automatic benefit — it's a model change like any other, with the full re-ingestion that entails. It's worth the detour in two concrete situations, though: a prototyping-stage project that wants to avoid any API spend before validating the use case, or a team already using NVIDIA Nemotron as its generation LLM that wants to unify credentials and billing under one provider.

Before switching, follow the tried-and-tested method: index the same sample of documents with the old and the new model, ask both indexes the same twenty or so real questions, and compare the passages returned. If quality holds up, fully resynchronizing the corpus follows the same delete-then-insert pattern as any index update — except here it covers the entire table rather than a handful of modified documents.

In summary

The NVIDIA Nemotron Embeddings node gives n8n a native option for building RAG without depending exclusively on a paid API: a no-credit-card free plan for prototyping, a credential shared with the NVIDIA chat model, automatic handling of the passage/query asymmetry that avoids silently degrading relevance, and a frictionless switch to a self-hosted NIM once volume or confidentiality demands it. The RAG Assistant Pack ($119) ships all four workflows — ingestion, chat with citations, Notion sync, and question-answering API — already wired to Supabase pgvector: the Embeddings node lives in its own dedicated sub-workflow, so you can test Nemotron in place of OpenAI by changing a single node, then reindex if the results convince you.