Nel 2024, ogni CEO di e-commerce si è chiesto: “Come aggiungiamo l’intelligenza artificiale?” Nel 2025, ogni CTO risponde: “Idealmente, senza fallire”. I Large Language Models (LLM) sono pesanti, lenti e allucinati. I clienti non vogliono chattare con un bot che pensa che un tostapane sia un forno a microonde. Vogliono la ricerca semantica e l’iperpersonalizzazione. Ciò richiede un’architettura specifica: RAG (Retrieval-Augmented Generation) at the Edge.

Perché Maison Code ne parla

A Maison Code Paris, agiamo come coscienza architettonica per i nostri clienti. Spesso ereditiamo stack “moderni” costruiti senza una comprensione fondamentale della scala. Vediamo semplici API che impiegano 4 secondi per rispondere a causa di N+1 problemi di query e “microservizi” che costano € 5.000 al mese in tariffe cloud inattive.

Discutiamo questo argomento perché rappresenta un punto cruciale nella maturità ingegneristica. L’implementazione corretta di questo differenzia un MVP fragile da una piattaforma resiliente di livello aziendale in grado di gestire il traffico del Black Friday senza sudare.

Il problema: latenza e costi

Esempio: un utente chiede: “Hai qualche abito estivo adatto per un matrimonio in Italia?”

Approccio ingenuo: invia l’intero catalogo prodotti (CSV) alla finestra di contesto GPT-4.
- Costo: € 2,00 per query (token di input).
- Latenza: 15 secondi.
- Risultato: l’utente abbandona prima che la risposta venga caricata.
Approccio ingegnerizzato: ricerca vettoriale + RAG.
- Costo: € 0,002 per query.
- Latenza: 400ms.
- Risultato: Conversione.

L’architettura: la pipeline RAG

Non chiediamo al LLM di “conoscere” i nostri prodotti. Gli chiediamo di “riassumere” i nostri risultati di ricerca.

“sirena”. sequenzaDiagramma Utente partecipante partecipante Edge as Edge Function (Vercel) vettore partecipante come DB vettoriale (pigna) partecipante LLM come GPT-4o-mini

Utente->>Edge: "Abito rosso per il matrimonio in Italia"

Nota sul bordo: 1. Genera incorporamenti
Edge->>LLM: richiesta di incorporamento (text-embedding-3-small)
LLM-->>Bordo: [0,12, 0,98, -0,4...]

Nota sul bordo: 2. Ricerca semantica
Bordo->>Vettore: interroga i vettori più vicini (primi 5)
Vettore-->>Edge: restituisce 5 JSON del prodotto

Nota sul bordo: 3. Sintesi
Edge->>LLM: "Ecco 5 abiti. Consigliatene uno per l'Italia."
LLM-->>Edge: "L'abito in seta di Amalfi è perfetto perché..."

Edge-->>Utente: risposta JSON (prodotto + testo)


## Passaggio 1: vettorizzazione del catalogo
Non è possibile cercare nel testo. Devi cercare "Significato".
Convertiamo ogni descrizione del prodotto in un **Incorporamento vettoriale** (un array di 1536 numeri in virgola mobile).
"Vestito rosso" e "Abito cremisi" hanno testo diverso ma vettori simili (distanza <0,2).

### Lo script di acquisizione (Node.js)
Lo eseguiamo su un lavoro cron ogni notte.

"dattiloscritto".
importa { OpenAI } da "openai";
importa {Pigna} da "@pinecone-database/pinecone";

const openai = new OpenAI();
const pigna = nuova pigna();

funzione asincrona vettorizzaProdotto(prodotto) {
  // 1. Crea una "stringa semantica"
  // Combiniamo titolo, descrizione e recensioni
  const contenuto = `
    Titolo: ${prodotto.titolo}
    Descrizione: ${prodotto.descrizione}
    Tessuto: ${product.tags.join(', ')}
    Atmosfera: ${product.metafields.custom.vibe}
  `.trim();

  // 2. Genera l'incorporamento
  const embedding = attendono openai.embeddings.create({
    modello: "text-embedding-3-small",
    input: contenuto,
  });

  // 3. Aggiorna al DB vettoriale
  attendono pigna.index("prodotti-maison").upsert([{
    id: prodotto.id,
    valori: embedding.data[0].embedding,
    metadati: {
      titolo: prodotto.titolo,
      prezzo: prodotto.prezzo,
      maniglia: product.handle,
      immagine: prodotto.immagine
    }
  }]);
}

Passaggio 2: query sui bordi

La velocità è fondamentale. Utilizziamo Vercel Edge Functions o Cloudflare Workers. NON utilizziamo un backend Python. È troppo lento per l’avvio a freddo. Usiamo TypeScript rigorosamente digitato su Edge.

La query avviene in due fasi:

Recupero: trova i prodotti pertinenti.
- “Matrimonio in Italia” -> Mappa semantica -> Lino, Traspirante, Floreale, Elegante.
- Vector DB restituisce: Abito Amalfi, Gonna Tuscany, Sandali Roma.
Generazione: Spiega PERCHÉ.
- Suggerimento: “Sei uno stilista di moda. Spiega perché questi 3 articoli soddisfano la richiesta dell’utente. Sii breve.”

Tecniche di ottimizzazione

L’elaborazione dei token costa denaro. Ecco come riduciamo i costi del 90%.

1. Filtraggio rigido (ricerca ibrida)

Se un utente filtra per “Dimensione: S”, non cercare nell’intero spazio vettoriale. Applica PRIMA un filtro dei metadati a Pinecone. vettore_search(query_vettore, filtro={ dimensione: "S", in_stock: true }) Ciò riduce lo spazio di ricerca e migliora la precisione.

2. Memorizzazione delle risposte nella cache

L’80% degli utenti pone le stesse domande. “Qual è la vostra politica di restituzione?” “Spedite in Canada?” Memorizziamo nella cache la risposta LLM in Redis, codificata da una versione con hash del vettore di query. Se una nuova domanda è semanticamente simile (distanza < 0,1) a una domanda memorizzata nella cache, restituisce la risposta memorizzata nella cache. latenza 0 ms.

3. Piccoli modelli (SLM)

Hai bisogno di GPT-4 per questo? No. GPT-4o-mini o Claude Haiku sono 20 volte più economici e veloci. Per le raccomandazioni sull’e-commerce, l‘“intelligenza” è meno importante del “contesto”. Se fornisci i prodotti giusti nella finestra contestuale, anche un piccolo modello dà un’ottima risposta.

Interfaccia utente: l‘“interfaccia utente generativa”

Non limitarti allo streaming di testo. Streaming Componenti. Quando LLM suggerisce un vestito, visualizza il componente <ProductCard /> direttamente nella chat. Utilizziamo Vercel AI SDK per trasmettere in streaming gli stati dell’interfaccia utente.

“tsx // L’interfaccia di chat importa { useChat } da ‘ai/react’;

funzione di esportazioneAssistente Negozio() { const { messaggi, input, handleInputChange, handleSubmit } = useChat();

ritorno (

{messaggi.map(m => (

{m.contenuto} {/* Se lo strumento richiama i prodotti restituiti, eseguine il rendering */} {m.toolInvocations?.map(strumento => ( <prodottiProductCarousel={tool.result} /> ))}

))}

); }


## 12. Caching semantico (Redis/Momento)

Se 100 persone chiedono "La maglietta è di cotone?", non pagare OpenAI 100 volte.
Pagali una volta.
1. Query utente -> Vettorializza -> `[0.1, 0.2, ...]`.
2. Controlla Redis: "OTTIENI vettori:vicino([0.1, 0.2])".
3. Se la distanza < 0,05, restituisce la risposta memorizzata nella cache.
Ciò riduce i costi LLM del 60% nelle implementazioni a traffico elevato.
Riduce inoltre la latenza da 2 secondi a 50 ms.

## 13. Memorizzazione nella cache dei prompt (antropico)

Novità nel 2025: **Richiesta di memorizzazione nella cache**.
Se invii un messaggio di sistema di 50 pagine ("Sei un agente di vendita... ecco il nostro catalogo..."), pagherai quei token ogni volta.
Con la memorizzazione nella cache del contesto, paghi una volta per "caricare" il contesto nell'API.
Le chiamate successive fanno riferimento a "cache_id".
Ciò riduce i costi dei token di input del 90% e raddoppia la velocità (il pre-riempimento è istantaneo).

## 14. Quantizzazione (GGUF / AWQ)

I modelli sono generalmente FP16 (virgola mobile a 16 bit).
Sono enormi (14 GB per i parametri 7B).
**Quantizzazione** li schiaccia in INT4 (interi a 4 bit).
La dimensione scende a 4GB.
La perdita di precisione è trascurabile (< 1%).
La velocità aumenta di 3 volte.
Eseguiamo modelli quantizzati a 4 bit su hardware consumer (MacBook Pro) per lo sviluppo locale e l'inferenza edge.

## 15. Decodifica speculativa

Gli LLM generano un token alla volta. Questo è seriale e lento.
**Decodifica speculativa** utilizza un piccolo "modello di bozza" (veloce) per indovinare le 5 parole successive.
Il Big Model (lento) li verifica semplicemente in parallelo.
Se la bozza è corretta (di solito è per la grammatica semplice), ottieni 5 gettoni al costo di 1 passaggio in avanti.
Ciò raddoppia la velocità di generazione senza modificare i pesi del modello.

## 16. Conclusione
L’intelligenza artificiale non è magica. È ingegneria.
Richiede pipeline di dati, database vettoriali e memorizzazione nella cache edge.
Se semplicemente "avvolgi ChatGPT", brucerai denaro.
Se costruisci un gasdotto RAG, costruisci un fossato competitivo.



<hr style="margin: 1rem 0" />

**[Assumi i nostri architetti](/contact)**.