Snowflake Document AI: panoramica, prezzi e monitoraggio dei costi

Snowflake Document AI trasforma i documenti non strutturati in dati strutturati e interrogabili grazie all'intelligenza artificiale, elaborando fatture, contratti e moduli direttamente all'interno di Snowflake. Il servizio si basa sul modello proprietario Arctic-TILT per estrarre testo, tabelle ed entità da PDF e immagini con un'accuratezza del 90% sul benchmark ANLS, superando GPT-4. Arctic-TILT gira su una singola GPU, con un ottimo rapporto costo-efficienza. Con prezzi a partire da circa 0,012–0,018 $ per pagina sulla Standard Edition, Document AI affronta un dato di fatto: l'80–90% dei dati aziendali è non strutturato. Permette di estrarre informazioni da nuove tipologie di documenti senza training preliminare (zero-shot) e supporta anche il fine-tuning con appena 5–20 esempi.

Document AI trasforma i documenti non strutturati in dati strutturati e interrogabili attraverso un flusso di lavoro in due fasi: creazione del modello e inferenza.

Fase 1: creazione dei modelli di estrazione

I modelli si creano tramite l'interfaccia Snowsight in AI & ML → Document AI. Serve il database role SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR:

USE ROLE ACCOUNTADMIN;

CREATE ROLE doc_ai_role;
GRANT DATABASE ROLE SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR TO ROLE doc_ai_role;
GRANT ROLE doc_ai_role TO USER your_username;

Carica 10-20 documenti di esempio rappresentativi delle tue tipologie. Definisci ciò che vuoi estrarre con domande in linguaggio naturale come "Qual è il numero di fattura?", "Qual è il nome del fornitore?" o "Quali voci sono elencate?". Verifica i valori estratti, correggi gli eventuali errori, addestra il modello (facoltativo ma consigliato a partire da 20 documenti) e pubblicalo per l'uso in produzione.

Il modello apprende i pattern di estrazione dalle tue correzioni. Non serve essere esperti di ML: basta indicare dove compaiono i dati nei documenti.

Fase 2: configurazione dell'infrastruttura

Crea un warehouse, un database, uno schema e uno stage per l'elaborazione dei documenti:

CREATE WAREHOUSE doc_ai_wh
  WAREHOUSE_SIZE = 'X-SMALL'
  AUTO_SUSPEND = 600
  AUTO_RESUME = TRUE;

CREATE DATABASE doc_ai_db;
CREATE SCHEMA doc_ai_db.doc_ai_schema;

-- IMPORTANTE: deve includere la cifratura SNOWFLAKE_SSE
CREATE STAGE doc_ai_stage
  DIRECTORY = (ENABLE = TRUE)
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

Carica i documenti nello stage con i comandi PUT oppure tramite integrazioni di stage esterni verso S3, Azure Blob o GCS.

Fase 3: esecuzione delle query di estrazione

Estrai i dati con il metodo model!PREDICT:

SELECT
  RELATIVE_PATH as file_name,
  invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as extracted_data
FROM DIRECTORY(@doc_ai_stage);

L'output è un JSON con i valori estratti e i relativi punteggi di confidenza:

{
  "invoice_number": [{"value": "INV-2024-001", "score": 0.95}],
  "vendor_name": [{"value": "Acme Corp", "score": 0.92}],
  "total_amount": [{"value": "1250.00", "score": 0.98}],
  "__documentMetadata": {"ocrScore": 0.89}
}

Trasformare i risultati in tabelle strutturate

Converti l'output JSON in colonne pronte all'uso:

WITH extraction AS (
  SELECT
    RELATIVE_PATH as file_name,
    invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as json
  FROM DIRECTORY(@doc_ai_stage)
)
SELECT
  file_name,
  json:invoice_number[0]:value::STRING AS invoice_num,
  json:invoice_number[0]:score::FLOAT AS invoice_confidence,
  json:vendor_name[0]:value::STRING AS vendor,
  json:total_amount[0]:value::STRING AS total,
  json:__documentMetadata.ocrScore::FLOAT AS ocr_quality
FROM extraction;

Si potrebbe fare molto di più, ad esempio distribuire i risultati su più righe e automatizzare il tutto con Streams e Tasks, ma preferiamo mantenere snella la sezione di esempio.

Snowflake fattura Document AI in base al compute degli AI Services gestiti da Snowflake, che scala automaticamente in funzione dei workloads. I crediti vengono consumati in base al tempo di compute, con una tariffa di 8 crediti all'ora (dato di settembre 2025), e il consumo dipende dal numero di pagine, dalla densità del documento e dal numero di valori estratti. Si tratta di un approccio radicalmente diverso dal pricing a token usato per le altre funzionalità LLM di Cortex.

Consumo di crediti ogni 1.000 pagine

I costi crescono con la densità dei documenti e la complessità dell'estrazione. Ecco gli intervalli ufficiali riportati nella documentazione di pricing di Snowflake:

Documenti a bassa densità (fatture, slide) - 100 documenti da 10 pagine ciascuno:

• 10 valori estratti: 4-7 crediti ogni 1.000 pagine
• 20 valori estratti: 6-11 crediti ogni 1.000 pagine
• 40 valori estratti: 10-24 crediti ogni 1.000 pagine

Documenti ad alta densità (paper di ricerca, contratti legali):

• 10 valori estratti: 7-10 crediti ogni 1.000 pagine
• 20 valori estratti: 11-15 crediti ogni 1.000 pagine
• 40 valori estratti: 21-35 crediti ogni 1.000 pagine

Estrazione di tabelle (funzionalità in preview) - 1.000 documenti da 2-10 pagine ciascuno:

• Tabelle molto piccole (<10 celle): 5-37 crediti
• Tabelle piccole (11-25 celle): 14-52 crediti
• Tabelle medie (26-50 celle): 24-86 crediti
• Tabelle grandi (51-400 celle): 37-369 crediti

Un esempio concreto

Elaborazione di ordini di acquisto:

Ipotizziamo di elaborare 10.000 ordini di acquisto all'anno. Ogni PO occupa una singola pagina a bassa densità (formato PO tipico). Vogliamo estrarre nome cliente, indirizzo cliente, numero PO, data PO, voci (tabella) e importo totale: in totale 10.000 pagine con circa 10 valori estratti per documento. Applicando la stima di bassa densità per 1.000 documenti da 1 pagina ciascuno, il consumo è di 9-12 crediti ogni 1.000 pagine, per un totale di 90-120 crediti all'anno.

Considerando 3 $ per credito, tariffa diffusa nell'Enterprise Edition, la spesa stimata è di 270-360 $ all'anno. Il costo effettivo dipenderà dalla quantità di compute utilizzato.

L'esempio mostra come Document AI possa elaborare migliaia di documenti all'anno per poche centinaia di dollari, una soluzione conveniente per automatizzare attività di data entry manuali che richiederebbero molto tempo al personale.

Costi aggiuntivi

Costo del Virtual Warehouse

Document AI richiede un Virtual Warehouse per avviare il job. L'AI non gira su uno dei tuoi warehouse, ma il job che avvia il processo sì. Consigliamo di utilizzare sempre un X-Small: la dimensione del warehouse non incide in alcun modo sulla velocità con cui vengono eseguiti i task AI.

Costo di storage

I costi di storage per i documenti negli stage e per le tabelle dei risultati sono fatturati alla tariffa standard. Ad esempio, 23 $/TB/mese è un valore comune per i clienti Enterprise Edition.

Snowflake mette a disposizione viste dedicate in ACCOUNT_USAGE per tracciare il consumo di Document AI, con una latenza di circa 2 ore e una retention di 365 giorni.

Vista principale di monitoraggio

La vista DOCUMENT_AI_USAGE_HISTORY contiene il consumo di crediti per ogni singola query:

SELECT
  START_TIME,
  END_TIME,
  CREDITS_USED,
  QUERY_ID,
  OPERATION_NAME,
  PAGE_COUNT,
  DOCUMENT_COUNT,
  FEATURE_COUNT
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY
WHERE START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
ORDER BY START_TIME DESC;

Consumo giornaliero di crediti

Aggrega l'utilizzo su base giornaliera per cogliere l'andamento della spesa:

SELECT
  DATE_TRUNC('DAY', START_TIME) AS usage_date,
  COUNT(*) AS total_queries,
  SUM(CREDITS_USED) AS total_credits,
  SUM(PAGE_COUNT) AS total_pages,
  SUM(DOCUMENT_COUNT) AS total_documents,
  ROUND(SUM(CREDITS_USED) / NULLIF(SUM(PAGE_COUNT), 0), 4) AS credits_per_page,
  ROUND(SUM(CREDITS_USED) / NULLIF(SUM(DOCUMENT_COUNT), 0), 4) AS credits_per_document
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY
WHERE START_TIME >= DATEADD(day, -90, CURRENT_TIMESTAMP())
GROUP BY DATE_TRUNC('DAY', START_TIME)
ORDER BY usage_date DESC;

Costi per utente e ruolo

Capisci quali utenti e ruoli stanno consumando crediti di Document AI:

SELECT
  qh.USER_NAME,
  qh.ROLE_NAME,
  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
  SUM(dh.CREDITS_USED) AS total_credits,
  SUM(dh.PAGE_COUNT) AS total_pages,
  ROUND(SUM(dh.CREDITS_USED) / NULLIF(SUM(dh.PAGE_COUNT), 0), 4) AS credits_per_page
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
  ON dh.QUERY_ID = qh.QUERY_ID
WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
GROUP BY qh.USER_NAME, qh.ROLE_NAME
ORDER BY total_credits DESC;

Costi per warehouse

Individua quali warehouse eseguono le query di Document AI.

SELECT
  qh.WAREHOUSE_NAME,
  qh.WAREHOUSE_SIZE,
  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
  SUM(dh.CREDITS_USED) AS docai_credits,
  SUM(dh.PAGE_COUNT) AS total_pages,
  SUM(dh.DOCUMENT_COUNT) AS total_documents
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
  ON dh.QUERY_ID = qh.QUERY_ID
WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
  AND qh.WAREHOUSE_NAME IS NOT NULL
GROUP BY qh.WAREHOUSE_NAME, qh.WAREHOUSE_SIZE
ORDER BY docai_credits DESC;

Un'idea utile è modificare la query qui sopra per intercettare i warehouse di dimensione superiore a X-Small e ricevere una notifica quando accade.

Imposta alert, non solo dashboard

Le query di monitoraggio viste sopra non servono a nulla se nessuno le esegue. Per qualsiasi metrica da tenere d'occhio in Snowflake, puoi incapsulare l'SQL in un task pianificato con una Notification Integration e creare un monitor personalizzato che invii alert a Slack o Teams. Se cerchi un monitoraggio davvero semplice da configurare, dai un'occhiata ai monitor in SELECT.

Usa esclusivamente warehouse X-Small o Small

Document AI gira sul compute serverless gestito da Snowflake. Il tuo warehouse si limita a eseguire la query SQL che incapsula il metodo PREDICT. Warehouse più grandi non portano alcun miglioramento di velocità nell'elaborazione di Document AI, ma fanno lievitare i costi da 1 credito/ora (X-Small) a 4+ crediti/ora (Medium o superiori).

Estrai solo i valori che ti servono davvero

Ogni campo estratto in più aumenta tempo di elaborazione e costo. Estrarre 10 valori consuma 4-7 crediti ogni 1.000 pagine (densità media), mentre estrarne 40 ne consuma 16-30 (un incremento di 2-3 volte).

Progetta i modelli di estrazione concentrandoti solo sui campi richiesti dalle applicazioni a valle. Non estrarre "tutto ciò che un giorno potrebbe tornare utile": estrai ciò che ti serve adesso. Potrai sempre creare in seguito una nuova versione del modello con i campi aggiuntivi.

Raggruppa i documenti per tipo prima dell'elaborazione

L'efficienza dell'elaborazione aumenta quando i documenti sono raggruppati per tipologia. Usa prima un modello di classificazione per individuare il tipo di documento, poi indirizzalo a modelli di estrazione specializzati:

WITH classification AS (
  SELECT
    RELATIVE_PATH as file_name,
    classifier!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as doc_type_result
  FROM DIRECTORY(@doc_ai_stage)
)
SELECT
  file_name,
  doc_type_result:document_type[0]:value::STRING as doc_type,
  CASE
    WHEN doc_type_result:document_type[0]:value::STRING = 'invoice'
      THEN invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
    WHEN doc_type_result:document_type[0]:value::STRING = 'contract'
      THEN contract_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
  END as extraction

Espandi codice

Questo approccio migliora anche l'accuratezza, perché ogni modello si specializza su un singolo formato.

Definisci soglie di confidenza e flussi di revisione manuale

Document AI assegna un punteggio di confidenza a ogni valore estratto. Non fidarti ciecamente di tutte le estrazioni: introduci controlli di qualità.

-- Le estrazioni ad alta confidenza vanno direttamente in produzione
CREATE TABLE production_data AS
SELECT
  file_name,
  json:invoice_number[0]:value::STRING as invoice_number,
  json:total_amount[0]:value::STRING as total_amount
FROM extraction_results
WHERE json:invoice_number[0]:score::FLOAT > 0.90
  AND json:total_amount[0]:score::FLOAT > 0.90;

-- Le estrazioni a bassa confidenza richiedono revisione manuale
CREATE TABLE manual_review_queue AS
SELECT
  file_name,
  json as full_extraction

Espandi codice

Imposta le soglie in base alla tua tolleranza al rischio. Per i dati finanziari può servire una confidenza di 0,95 o superiore, mentre per i documenti interni può bastare 0,75. Testa le soglie su un campione di documenti per trovare il giusto equilibrio tra automazione e accuratezza.

Document AI rende sostenibile automatizzare l'elaborazione documentale su larga scala, in genere con costi di pochi centesimi per i documenti a bassa densità. La chiave per tenere a bada i costi è capire cosa li determina: numero di pagine, densità del documento e numero di valori estratti incidono tutti sul tempo di compute e sul consumo di crediti. Usa warehouse piccoli (X-Small o Small) per eseguire il metodo PREDICT, estrai solo i campi davvero necessari e adotta soglie di confidenza per il controllo qualità. E soprattutto, configura alert sulle query di monitoraggio viste sopra, così saprai subito quando i costi schizzano, invece di scoprirlo a fine mese in fattura. Parti da un piccolo lotto di documenti, osserva con attenzione i pattern di consumo e amplia la scala man mano che capisci i tuoi costi reali.

Raccontaci come stai usando Document AI! Ci farebbe piacere ascoltare altre esperienze dirette di clienti che lo utilizzano e la tua opinione sull'efficacia complessiva.

Jeff è un Data and Analytics Consultant con oltre 15 anni di esperienza nell'automazione degli insight e nell'uso dei dati per governare i processi aziendali. Sul piano tecnologico è specializzato in Snowflake + dbt + Tableau. Sul piano dei settori, ha esperienza in Public Utility, Clinical Trials, editoria, CPG e manifatturiero. Per qualsiasi contatto: [email protected].