Document Intelligence with Snowflake: Activate Business Documents

Documents are simply how business gets done. They act as the primary interface for work and the context layer for almost every business activity. Planning, alignment, deep analysis, approvals and execution all produce a massive trail of text, slides and sheets.

Yet, even as new research, market analysis, clinical notes and novel ideas move immediately into documents, traditional data stacks and processing tools struggle to make sense of them. An invoice arrives with a new vendor. Legal searches agreements for a liability clause. Equity Research compares earnings reports to identify trends. Traditional tools often struggle to digitize this document data with the high accuracy required for most enterprises to trust automating business processes.

This is exactly why we built Snowflake's native document intelligence capabilities that treat your documents like first-class data. In this blog, we explore how organizations have been able to use Snowflake Cortex AI Functions to build document intelligence workflows that scale hundreds of thousands of documents per day.

Three patterns driving business outcomes #

Cortex AI Functions is designed to be the foundation for enterprise search applications that help employees and users find information faster, automating business processes by extracting data from documents and enabling deeper research and analysis across large document libraries.

Activating knowledge

On the surface, building a search application sounds straightforward until you encounter real enterprise documents. An earnings report contains tables, charts, footnotes and complex layouts. A contract spans hundreds of pages with clauses spread across sections and appendices. A healthcare form combines structured fields, handwritten notes and scanned images. The challenge is not retrieving information, it's first converting every document into data that AI can accurately understand.

AI_PARSE_DOCUMENT is the foundation of how enterprises are turning documents into data. If all you need is a text representation of a digital or scanned document, OCR mode extracts text from scanned documents and images. But for enterprise search, RAG and agent-powered applications, structure often contains meaning. LAYOUT mode preserves the original structure of a document so downstream AI systems can retrieve, reason over and generate answers using the document as it was intended to be read. This includes preserving reading order across complex multi-column layouts, extracting table structures, maintaining visual hierarchy, and capturing embedded images of charts, diagrams, and other graphical elements.

The result is structured document data that retains the context required for accurate retrieval. Rather than indexing a flattened stream of text, organizations can use Cortex Search to retrieve content with the structural information needed to preserve meaning across complex documents. Cortex Search retrieves the most relevant sections from across the document corpus and grounds its response in the organization's own content. Because the workflow runs entirely inside Snowflake, the same governance and access controls applied to enterprise data also determine what users can search and retrieve.

Business process automation

When your daily business relies on a constant influx of invoices, contracts, claims forms, purchase orders or tax documents, manual data entry quickly becomes a bottleneck. More often than not, companies tell us many of these workflows begin with someone manually reading a document, locating the required information and entering it into a downstream system. At enterprise scale, this process is expensive, difficult to audit and often becomes the limiting factor in how quickly the business can operate.

Snowflake handles high-volume, high-quality document extraction natively. AI_EXTRACT allows you to describe the fields you need in plain English, such as vendor name, invoice date, total amount, payment terms, line items, and it returns structured JSON ready for downstream analytics, compliance and automation. Every extracted field includes a confidence score, enabling human-in-the-loop workflows where low-confidence results can be reviewed and validated against the original document. For organizations processing many different document types, AI_CLASSIFY (public preview) can act as a traffic controller, automatically routing different documents to different AI pipelines.

The result is a trusted extraction pipeline that converts documents into operational data. High-confidence extractions can be processed automatically, while lower-confidence results are routed for review. For specialized document formats, industry-specific terminology and compliance-sensitive workflows, AI_EXTRACT can be fine-tuned directly within Snowflake to further improve extraction accuracy.

Deep analytics across documents

Sometimes the value is not hidden within a single document. It emerges from connecting information across hundreds or thousands of them. An equity research analyst may need to compare earnings reports across an industry to identify growth trends. A pharmaceutical company may need to review clinical studies and regulatory filings to understand the competitive landscape. The challenge is not finding information, it is synthesizing information across an entire document corpus.

To do this, customers are using AI_PARSE_DOCUMENT to convert large document collections into structured data while preserving the text, tables, images and layout needed for analysis. AI_COMPLETE then applies LLM reasoning across those collections, whether the task is summarizing findings, comparing documents, identifying trends, interpreting complex language or answering multi-hop questions that connect information across multiple sources. AI_EMBED can then be used to convert those summaries into vectors so documents can be clustered by semantic similarity, surfacing the top themes in a corpus of documents.

The result is a research and analytics pipeline that transforms document collections into actionable insight. Healthcare organizations can generate longitudinal views across thousands of clinical research documents, helping analysts and researchers synthesize findings at scale, while financial analysts can surface trends, risks and opportunities across large collections of reports and filings more efficiently than with manual analysis.

Scaling for production #

Proving a document use case works on 10 files is easy. The real enterprise challenge is volume: How do you productionalize this to process hundreds of thousands of documents every single day without your engineering pipeline collapsing?

Snowflake simplifies this by utilizing Dynamic Tables. Instead of building a sprawling orchestration system, you write one or more declarative SQL statements expressing a data pipeline that defines how you want your document data processed and how fresh your data should be. Snowflake handles the scheduling and refresh orchestration automatically.

Consider a strategy team continuously ingesting annual reports from the companies they track. As new filings arrive, they want to extract structured data from each document, generate an analyst summary, cluster companies by strategic theme and surface which companies are making bets that don't fit the industry pattern.

The pipeline you can easily run using the new Cortex Code (CoCo) ai-functions-pipeline-builder skill combines three Cortex AI Functions:

AI_PARSE_DOCUMENT converts each annual report PDF into structured text, preserving tables, headings and reading order.AI_EXTRACT pulls named fields from the document, such as strategy themes, growth initiatives, headwinds, revenue and fiscal year.AI_COMPLETE distills each company into four analyst facets spanning strategy, financial performance, outlook and differentiation, and separately infers risks and opportunities from the full document text, including content that isn't explicitly labeled.AI_EMBED converts each company's summary into a vector so companies can be clustered by semantic similarity, named themes can be discovered across the corpus and outliers. Companies whose strategy fits no theme cleanly are surfaced automatically.

CoCo-generated SQL code

-- ── Step 1  |  Parse annual reports ──────────────────────────────────────────
-- Note: Setting the refresh mode to "incremental" guarantees that each incoming document is processed only once.

CREATE OR REPLACE DYNAMIC TABLE DT_ESR_PARSED
  TARGET_LAG = DOWNSTREAM  WAREHOUSE = SNOWADHOC  REFRESH_MODE = INCREMENTAL
AS
SELECT
  SPLIT_PART(SPLIT_PART(fl.RELATIVE_PATH, '/', -1), '.', 1) AS COMPANY,
  fl.RELATIVE_PATH,
  AI_PARSE_DOCUMENT(
    TO_FILE('@ESR_DOCS_STAGE', fl.RELATIVE_PATH),
    {'mode': 'LAYOUT'}
  ) AS RAW_PARSE
FROM ESR_FILE_LOG fl
WHERE fl.RELATIVE_PATH ILIKE '%.pdf';

-- ── Step 2  |  Extract structured fields ─────────────────────────────────────

CREATE OR REPLACE DYNAMIC TABLE DT_CONS_EXTRACTED
  TARGET_LAG = DOWNSTREAM  WAREHOUSE = SNOWADHOC  REFRESH_MODE = INCREMENTAL
AS
WITH full_text AS (
  SELECT COMPANY, RELATIVE_PATH,
    LISTAGG(f.value:content::STRING, '\n') WITHIN GROUP (ORDER BY f.index) AS DOC_TEXT
  FROM DT_ESR_PARSED, LATERAL FLATTEN(input => RAW_PARSE:pages) f
  GROUP BY COMPANY, RELATIVE_PATH
)
SELECT
  COMPANY, RELATIVE_PATH,
  AI_EXTRACT(
    text => LEFT(DOC_TEXT, 120000),
    responseFormat => {'schema': {'type': 'object', 'properties': {
      'title':              {'type': 'string', 'description': 'Company name and fiscal year'},
      'fiscal_year':        {'type': 'string', 'description': '4-digit fiscal year'},
      'revenue':            {'type': 'string', 'description': 'Total revenue with currency'},
      'strategy_themes':    {'type': 'array',  'description': 'Top strategic priorities'},
      'growth_initiatives': {'type': 'array',  'description': 'Key growth programs and investments'},
      'headwinds':          {'type': 'array',  'description': 'Key challenges and risks'}
    }}}
  ) AS RAW_EXTRACT
FROM full_text;

-- ── Step 3  |  Summarize + embed each company ─────────────────────────────────

CREATE OR REPLACE DYNAMIC TABLE DT_CONS_EMBEDDED
  TARGET_LAG = DOWNSTREAM  WAREHOUSE = SNOWADHOC  REFRESH_MODE = INCREMENTAL
AS
WITH summarised AS (
  SELECT COMPANY, RELATIVE_PATH, RAW_EXTRACT,
    AI_COMPLETE(
      'claude-sonnet-4-5',
      PROMPT('Summarise this company''s annual report into 4 JSON fields:
              strategy, financial_performance, outlook, differentiation.\n\n{0}',
        'company: '   || COALESCE(RAW_EXTRACT:response:title::STRING, COMPANY) || '\n' ||
        'themes: '    || COALESCE(ARRAY_TO_STRING(RAW_EXTRACT:response:strategy_themes::ARRAY,    '; '), '') || '\n' ||
        'headwinds: ' || COALESCE(ARRAY_TO_STRING(RAW_EXTRACT:response:headwinds::ARRAY,          '; '), '')
      ),
      response_format => {'type': 'json', 'schema': {'type': 'object', 'properties': {
        'strategy':              {'type': 'string'},
        'financial_performance': {'type': 'string'},
        'outlook':               {'type': 'string'},
        'differentiation':       {'type': 'string'}
      }}}
    ) AS SUMMARY_JSON
  FROM DT_CONS_EXTRACTED
)
SELECT
  COMPANY, RELATIVE_PATH,
  RAW_EXTRACT:response:title::STRING          AS TITLE,
  RAW_EXTRACT:response:fiscal_year::STRING    AS FISCAL_YEAR,
  RAW_EXTRACT:response:revenue::STRING        AS REVENUE,
  SUMMARY_JSON:strategy::STRING               AS S_STRATEGY,
  SUMMARY_JSON:financial_performance::STRING  AS S_FINANCIAL_PERFORMANCE,
  SUMMARY_JSON:outlook::STRING                AS S_OUTLOOK,
  SUMMARY_JSON:differentiation::STRING        AS S_DIFFERENTIATION,
  TRIM(CONCAT_WS(' ',
    COALESCE(SUMMARY_JSON:strategy::STRING, ''),
    COALESCE(SUMMARY_JSON:outlook::STRING, ''),
    COALESCE(SUMMARY_JSON:differentiation::STRING, '')
  ))                                          AS SUMMARY_TEXT,
  AI_EMBED('snowflake-arctic-embed-l-v2.0', TRIM(CONCAT_WS(' ',
    COALESCE(SUMMARY_JSON:strategy::STRING, ''),
    COALESCE(SUMMARY_JSON:outlook::STRING, ''),
    COALESCE(SUMMARY_JSON:differentiation::STRING, '')
  )))                                         AS SUMMARY_VEC
FROM summarised;

-- ── Step 4  |  Discover strategic themes across the corpus ────────────────────

CREATE OR REPLACE TABLE CONS_THEMES AS
WITH themes AS (
  SELECT AI_COMPLETE(
    'claude-sonnet-4-5',
    PROMPT('Identify 4-5 distinct strategic themes that organise these companies.
            Each needs a short name and one-sentence description.\n\n{0}',
      LISTAGG(COMPANY || ': ' || S_STRATEGY, '\n')),
    response_format => {'type': 'json', 'schema': {'type': 'object', 'properties': {
      'themes': {'type': 'array', 'items': {'type': 'object', 'properties': {
        'name':        {'type': 'string'},
        'description': {'type': 'string'}
      }}}
    }}}
  ) AS RAW FROM DT_CONS_EMBEDDED
)
SELECT
  f.index                                                           AS THEME_ID,
  f.value:name::STRING                                              AS THEME_NAME,
  f.value:description::STRING                                       AS THEME_DESC,
  AI_EMBED('snowflake-arctic-embed-l-v2.0',
    f.value:name::STRING || ': ' || f.value:description::STRING)    AS THEME_VEC
FROM themes, LATERAL FLATTEN(input => RAW:themes) f;

CoCo-generated Streamlit application

Conclusion #

For years, documents have existed outside the data platform, limiting how organizations could search, analyze and automate the information they contain. With Cortex AI Functions, your documents can now become data, ready to power search, automation, analytics and AI applications at enterprise scale.

Whether the goal is activating knowledge through enterprise search, automating document-driven business processes through structured extraction or generating insights through large-scale document analysis, Cortex AI Functions provide the foundation. That intelligence can then be surfaced through experiences such as Snowflake CoWork, Cortex Agents, Cortex Code or custom applications built on Snowflake.

Summary of the core document intelligence AI Functions:

AI_EXTRACTAI_CLASSIFYAI_COMPLETE