I tuoi contenuti sono ovunque: PDF, Drive, wiki, blog. Come trasformarli in risposte utili e verificabili? Un vector database in n8n è la chiave: archivia embedding semantici, esegue similarity search e rifornisce l’LLM di contesto affidabile. In questa guida pratica colleghi Pinecone e Chroma ai workflow AI di n8n con due approcci: prototipazione veloce con il Simple Vector Store node e messa in produzione via backend esterni (Pinecone gestito, ChromaDB self‑hosted). Costruiremo una pipeline RAG in automazioni n8n completa con text splitter e document loader in n8n, embeddings e retriever, e vedremo come orchestrare il tutto con un LLM, ottimizzando top‑k e qualità del contesto. Include nodi e parametri esatti dove disponibili, configurazioni ripetibili, consigli su dimensioni embedding e configurazione indice, gestione credenziali e variabili d’ambiente in n8n e best practice su deduplica, versioning documentale e performance.

[IMG: schema pipeline RAG: Loader → Splitter → Embeddings → Vector Store → Retriever → LLM → Risposta con citazioni]

Scelta dello stack: gestito (Pinecone) vs self‑hosted (Chroma)

Prima di tutto, scegli l’architettura.

• Gestito (Pinecone per ricerca semantica in n8n)

• Pro: scalabilità immediata, replica/HA gestite, feature mature (namespaces e metadata in Pinecone, filtri ricchi), SDK/REST pronti, latenza prevedibile in region.

• Contro: costo ricorrente, lock‑in, gestione del throughput (batch upsert e gestione throughput per tenere i costi sotto controllo).

• Self‑hosted (ChromaDB self‑hosted con workflow n8n)

• Pro: controllo totale su dati e costi, persistenza locale, privacy; adatto se sei già su Docker/K8s.

• Contro: manutenzione, tuning (persistenza, collection e persistenza in Chroma, backup), scaling e rete (n8n → DB).

Criteri pratici

• Volumi/latency: Pinecone brilla oltre decine di milioni di vettori; Chroma è ottimo fino a milioni se ben dimensionato (storage veloce).
• Compliance e multi‑tenant: Pinecone supporta namespaces e filtri per separare tenant/criteri; con Chroma replica naming e metadati per isolare i dataset.
• Budget e time‑to‑value: Pinecone accelera la messa in produzione; Chroma vince sul controllo costi nel lungo termine.

Insight: inizia con un prototipo in‑memory (Simple Vector Store node) per convalidare chunking/top‑k/quality, poi promuovi a Pinecone/Chroma mantenendo identiche le scelte di embedding e i metadati per ridurre attriti di migrazione.

[IMG: matrice decisionale: Pinecone vs Chroma per volumi, costi, compliance]

Componenti RAG in n8n: loader, splitter, embeddings, vector store, retriever, LLM

Una pipeline RAG in automazioni n8n si compone di:

• Caricamento sorgenti
• Document Loader (es. “Default Data Loader” in n8n) per acquisire testo da PDF/web/Drive e normalizzare metadata (titolo, URL, data).
• Splitter
• Text splitter e document loader in n8n per chunking (chunk size/overlap). Valori tipici: 800–1200 caratteri, overlap 100–200.
• Embeddings
• Embeddings in batch con il nodo n8n-nodes-langchain.embeddingsOpenAi:
  • type: n8n-nodes-langchain.embeddingsOpenAi
  • parameters.model: “text-embedding-ada-002”
  • parameters.text: “={{ $json[\”content\”] }}”
  • credentials.openAiApi: { name: “OpenAI API” }
• Vector store
• Per prototipi: Simple Vector Store node (in‑memory).
• Per produzione: backend esterni (Pinecone o Chroma).
• Retriever
• Similarity search con metadati e filtri; top‑k retrieval e (opzionale) filtri per namespace/metadata.
• LLM
• Prompting e catene QA con LLM; costruzione del contesto con citazioni.

Pattern consigliato (due workflow separati)

• Workflow A (Indicizzazione): Loader → Splitter → Embeddings → Vector Store (Insert).
• Workflow B (Query): Prompt → Retriever (Get/Query) → LLM con contesto → Risposta + citazioni.

[IMG: due workflow separati: “Load Data” e “Retriever” collegati allo stesso vector store]

Prototipo veloce con Simple Vector Store node (in‑memory)

Per validare rapidamente chunking, embeddings e top‑k:

• Simple Vector Store node
• Operation Mode:
  • Get Many
  • Insert Documents
  • Retrieve Documents (As Vector Store for Chain/Tool)
  • Retrieve Documents (As Tool for AI Agent)
• Memoria e TTL (self‑host default: -1; in n8n Cloud preset):
  • N8NVECTORSTOREMAXMEMORY (MB complessivi)
  • N8NVECTORSTORETTLHOURS (rimozione store inattivi)

Inserimento
1) Default Data Loader → chunk
2) n8n-nodes-langchain.embeddingsOpenAi → vettori
3) Simple Vector Store node → Insert Documents:

• Seleziona embedding model coerente con quello usato in query (stesso modello).
• Inserisci documento + metadati (es. source, url, section).

Query (Get Many)

• Prompt: la domanda dell’utente
• Limit: top‑k (es. 5–10)
• Include Metadata: on per citazioni

Uso con Agent

• Retrieve Documents (As Tool for AI Agent) per collegarlo direttamente a un agente come “tool”.
• Retrieve Documents (As Vector Store for Chain/Tool) per chain QA.

Limiti

• Non persistente (in‑app memory); ottimo per prototipi, non per produzione multi‑utente.
• Le chiavi sono visibili a livello di istanza: evitare dati sensibili.

[IMG: canvas con Default Data Loader → EmbeddingsOpenAi → Simple Vector Store (Insert) → OK]

Pinecone in n8n: schema, upsert in batch, query con filtri

Per Pinecone per ricerca semantica in n8n, adotta un backend gestito e integra via HTTP Request o connettori generici del pattern “Vector Store + Retriever”.

Concetti chiave

• Dimensioni embedding e configurazione indice: l’indice Pinecone deve avere dimensione coerente con il tuo modello (es. 1536 per text-embedding-ada-002).
• Namespaces e metadata in Pinecone: usa namespaces per multitenancy/segmentazione (es. clienteA, clienteB) e metadata per filtri (es. {type: “doc”, lang: “it”}).
• Batch upsert e gestione throughput: upsert in batch (100–500 vettori per chiamata) per sfruttare al meglio la finestra di rate; rinforza retry/backoff.

Inserimento (pattern)
1) Split e embedding con n8n-nodes-langchain.embeddingsOpenAi.
2) Trasforma i chunk in record { id, values, metadata }.
3) HTTP Request verso l’endpoint Upsert del tuo index-host Pinecone:

• Body: { vectors: [{id, values, metadata}, …], namespace: “my-namespace” }
• Header: Authorization: Api-Key
  4) Conserva id/namespace per audit e aggiornamenti incrementali (deduplica su id).

Query (pattern)

• HTTP Request verso /query con:
• topK: numero risultati
• vector (embedding della query) oppure id (query by id)
• includeMetadata: true per citazioni
• namespace: se usi multitenancy
• filter: es. { “lang”: { “$eq”: “it” } }

Esempio (pseudo‑JSON per query)

{
  "topK": 5,
  "vector": "={{ $json.embedding }}",
  "includeMetadata": true,
  "namespace": "docs",
  "filter": { "type": { "$eq": "guide" } }
}

Consigli

• Consistenza: usa lo stesso embedding model per insert e query.
• Versioning: mantieni un alias “current” per l’indice e pubblica nuove versioni “v2” → switch atomico dell’alias in produzione.
• Errori comuni: dimension mismatch (controlla la dimensione), index non pronto (attendi stato ready), rate limit (retry/backoff e batch tuning).

[IMG: canvas: Loader → EmbeddingsOpenAi → HTTP Request (Upsert Pinecone) → Done; Query: Embedding prompt → HTTP Request (Query) → LLM]

Chroma self‑hosted: collection, persistenza, query semantica

ChromaDB self‑hosted con workflow n8n è ideale quando vuoi controllo pieno (Docker) e costi contenuti.

Setup

• Avvia Chroma Server in Docker con persistenza (volume).
• Crea una collection (es. “docs-it”) per i tuoi documenti.
• Genera embeddings in n8n e inviali alla collection.

Inserimento (pattern)
1) Default Data Loader → chunk
2) n8n-nodes-langchain.embeddingsOpenAi → vettori
3) HTTP Request (POST) verso l’API di Chroma:

• Crea collection (se non esiste).
• Aggiungi documenti: ids[], embeddings[][], metadatas[], documents[].

Query (pattern)

• HTTP Request (POST) per “query” con:
• queryembeddings[][] oppure querytexts[]
• n_results (top‑k)
• where (filtri sui metadata)
• Ricevi ids, distances/similarities, metadatas, documents.

Buone pratiche

• collection e persistenza in Chroma: mappa collection a business domain (es. docs, faq, blog). Mantieni persistenza su volume veloce.
• Aggiornamenti incrementali: deduplica per id; conserva hash del contenuto per evitare reinserimenti.
• Sicurezza: esponi Chroma dietro rete privata/VPN; limita l’accesso dalla rete dove gira n8n.

[IMG: docker-compose Chroma + n8n; flusso Insert con batch di 200 chunk]

Retriever e catena QA: costruire il contesto giusto e prompt “grounded”

Una volta che Pinecone/Chroma è popolato:

• Retriever e embeddings in workflow AI

• Per un agente, aggiungi il vector store come tool “Retrieve Documents (As Tool for AI Agent)” oppure usa “Retrieve Documents (As Vector Store for Chain/Tool)” in una chain QA con LLM.

• Imposta Limit (top‑k) e Include Metadata per citazioni.

• Prompting e catene QA con LLM

• Costruisci un prompt che impone: “Usa SOLO i passaggi forniti; se mancano info, rispondi ‘non trovato’”.

• Formatta ogni chunk con fonte (title, url) per citazioni chiare.

• Reranking dei risultati con catena QA

• Se top‑k è alto o rumoroso, applica un secondo stadio di reranking (cross‑encoder) o un filtro sul punteggio.

• Riduci top‑k quando l’uso token diventa eccessivo.

• Ottimizzazione top‑k e qualità del contesto

• Misura precision/recall su un set di domande di validazione.

• Tieni chunk più piccoli per domande specifiche; chunk più grandi per overview.

[IMG: catena: Prompt → Retriever (k=8) → Rerank (k=4) → LLM → Risposta con 3 citazioni]

Pipeline completa: Indexing + Query, costi e performance tuning

Indexing (cron) — passi
1) Caricamento sorgenti (Default Data Loader)
2) Normalizzazione metadati (Code)
3) Chunking (Default Data Loader)
4) Embeddings (n8n-nodes-langchain.embeddingsOpenAi)
5) Upsert (Simple Vector Store o HTTP → Pinecone/Chroma)
6) Log di versioning (id/namespace/collection, hash contenuto)

Query (sincrona) — passi
1) Prompt utente
2) Embedding prompt (stesso modello)
3) Similarity search (Get Many / Retrieve Documents)
4) Prompting LLM con citazioni
5) Risposta + logging (per audit/eval)

Performance tuning

• Chunking: 800–1200 + overlap 100–200 (testa sui tuoi contenuti).
• Batch upsert e gestione throughput: 100–500 vettori; retry/backoff su rate limit.
• Parallelismo: parallelo moderato su insert (limita per non saturare l’engine).
• Caching: memorizza risultati di query frequenti (se non sensibili al tempo).
• Errori comuni: dimension mismatch, index non pronto, duplicati (deduplica su id).

[IMG: dashboard con latenza p95, token spesi, % risposte con citazioni, recall@k]

Sicurezza, multi‑tenant e versioning documentale

• Gestione credenziali e variabili d’ambiente in n8n
• Tieni le API key (OpenAI/Pinecone) in credenziali nominate; richiama in nodi via reference e variabili d’ambiente.
• Sicurezza e multi‑tenant
• Pinecone: namespaces per isolamento; filtri sui metadata; auditing su query/upsert.
• Chroma: collezioni per tenant e policy di rete per l’accesso.
• Versioning documentale e aggiornamenti incrementali
• Conserva un hash per ogni chunk; aggiorna solo se cambiato.
• Mantieni alias per passare da indice “v1” a “v2” senza downtime (Pinecone) o da collectionold a collectionnew (Chroma), poi ruota.

[IMG: tabella “Tenant → Namespace/Collection, Policy di rete, Audit”]

Integrare nel tuo chatbot/agent di n8n

• Come tool per agenti AI con tool retriever in n8n
• Collega il vector store come tool “Retrieve Documents (As Tool for AI Agent)” con descrizione chiara di quando usarlo.
• Usa lo stesso embedding model configurato in fase di insert.
• Catena QA diretta
• “Retrieve Documents (As Vector Store for Chain/Tool)” → LLM → Risposta.
• KPI di qualità e costo
• Misura qualità (valutazioni umane, precision/recall), costo/token, latenza e % risposte con citazioni.
• Riduci top‑k, applica reranking e ottimizza prompt per abbattere token.

[IMG: canvas Chat → Retriever Tool → LLM → Risposta + citazioni]

Quick Takeaways

• Avvia prototipi con il Simple Vector Store node (Operation Mode: Insert/Get/Retrieve) e migra poi a Pinecone o Chroma.
• Mantieni coerenza tra dimensioni embedding e indice; usa lo stesso modello per insert e query.
• In Pinecone, sfrutta namespaces e metadata; in Chroma, progetta collection e persistenza su volumi rapidi.
• Upsert in batch con retry/backoff; in query, imposta top‑k e filtri per migliorare qualità e costi.
• Usa “Retrieve Documents (As Tool for AI Agent)” o chain QA per integrare il retriever nel chatbot.
• Versiona gli indici/collezioni e introduci alias per switch a caldo senza downtime.

Conclusione

Portare un vector database in n8n trasforma un LLM generico in un assistente “grounded” sulle tue fonti: la pipeline RAG in automazioni n8n unisce loader/splitter, embeddings e un archivio persistente per conseguire risposte accurate, con citazioni e controllo dei costi. Con il Simple Vector Store node puoi validare chunking, top‑k e prompting; poi passa in produzione con Pinecone (gestito, namespaces e filtri maturi) o ChromaDB self‑hosted (controllo e privacy). Mantieni coerenza tra embedding e indice, deduplica con hash, usa batch upsert e monitora rate limit. Integra il retriever come tool per agenti o chain QA e misura costantemente qualità e latenza. Se sei un marketer che vuole imparare ad usare n8n per migliorare la produttività, inizia con un MVP su una singola knowledge base (FAQ o blog), aggiungi citazioni e KPI, quindi scala a più sorgenti: avrai un assistente affidabile che riduce tempi di ricerca e migliora la qualità delle risposte ai clienti.

FAQ

• Posso iniziare senza un database esterno?

• Sì, con il Simple Vector Store node (in‑memory). Usa Operation Mode “Insert Documents” per caricare i chunk e “Get Many” o “Retrieve Documents” per le query. Per produzione, migra a Pinecone/Chroma.

• Come garantisco coerenza tra embeddings e indice?

• Usa lo stesso modello (es. n8n-nodes-langchain.embeddingsOpenAi con “text-embedding-ada-002”) per l’inserimento e la query. Verifica la dimensione dell’indice (1536/3072, ecc.) e allinea il tuo vector store.

• Come strutturo metadati e filtri?

• Aggiungi metadati utili (source, url, lang, type). In Pinecone usa filter su query; in Chroma filtra con where. I metadati servono anche per citazioni e audit.

• Qual è un buon valore di top‑k?

• Inizia con 5–10. Se le risposte contengono “rumore”, applica reranking o riduci k; se sono troppo generiche, aumenta k o ottimizza chunking.

• Come collego il retriever a un agente in n8n?

• Usa “Retrieve Documents (As Tool for AI Agent)” e scegli lo stesso embedding model della fase di insert. Imposta Limit e Include Metadata per restituire fonti al modello.

Hai dubbi o vuoi condividere il tuo stack (Pinecone o Chroma) con n8n? Racconta nei commenti il tuo caso d’uso e condividi l’articolo: quale knowledge base porteresti per prima dentro il tuo chatbot per avere impatto in meno di 2 settimane?