What you can build

Nimble runs inside Snowflake and Databricks, so data teams can search the web, extract pages, and run Web Search Agents directly from SQL and land the results as governed tables. There are two self-serve patterns:

1. Native integrations (recommended): install Nimble from the Snowflake or Databricks Marketplace and call Nimble's Search, Extract, and Web Search Agents as SQL functions inside any SELECT, from notebooks, dbt models, scheduled jobs, and AI assistants.

2. Landing-zone delivery: Nimble writes async job results (Extract, Extraction Templates) to your S3 or GCS bucket, and you ingest them with Snowpipe, external tables, Auto Loader, or Delta Live Tables.

Nimble's managed data services can also configure and run the whole pipeline for you. See Web Scraping with Nimble.

Databricks

Nimble's Databricks integration installs from the Databricks Marketplace as a one-click Unity Catalog connection, governed with Unity AI Gateway. Databricks integration docs

Because the functions are SQL-native, they work in notebooks, dashboards, dbt models, Workflows, and Genie, with Unity Catalog audit, lineage, and access control.

Governance: every proxied Nimble call is recorded in system.access.audit and shown in the AI Gateway Usage Analytics dashboard. Payload logging, service policies (for example, a domain allowlist on nimble_search), and per-user rate limits are available in Beta through your Databricks account team.

Prerequisites: the Marketplace install needs the Managed MCP Servers preview and CREATE CONNECTION on the metastore. The SQL table functions need a serverless SQL warehouse with "Enable networking for isolated workloads in Serverless SQL Warehouses" turned on and a cold restart of the warehouse; the API key lives in a Databricks secret scope.

Snowflake

Nimble integrates with Snowflake five ways. Snowflake integration docs

Results write back to Snowflake as tables or inline query results, with no external stage or Snowpipe required.

Typical native workflows

• Enrich a table with Web Search Agents: join a companies table with nimble_agent_run / NIMBLE_AGENT_RUN using an enrichment agent that returns funding, headcount, and leadership in your schema, with citations.

• Live web context in analytics: call nimble_search / NIMBLE_SEARCH in a query or dashboard to pull current results for a list of entities.

• Page content on demand: call nimble_extract / NIMBLE_EXTRACT for a column of URLs.

• Schedule it: wrap the query in a dbt model, Databricks Workflow, or Snowflake Task.

Exact function signatures and setup steps are in the Databricks and Snowflake docs.

Landing-zone pattern (S3/GCS)

Use this pattern for high-volume scheduled outputs, such as Extraction Templates running across thousands of products, or when you want raw file retention.

Architecture and medallion layout

Snowflake: stage and external table

CREATE STORAGE INTEGRATION NIMBLE_S3_INT
 TYPE = EXTERNAL_STAGE
 STORAGE_PROVIDER = S3
 ENABLED = TRUE
 STORAGE_AWS_ROLE_ARN = 'arn:aws:iam::<account>:role/nimble-snowflake-role'
 STORAGE_ALLOWED_LOCATIONS = ('s3://nimble-delivery/bronze/');

CREATE STAGE NIMBLE_DEMO.RAW.BRONZE_STAGE
 URL='s3://nimble-delivery/bronze/'
 STORAGE_INTEGRATION=NIMBLE_S3_INT
 FILE_FORMAT=(TYPE=JSON);

CREATE EXTERNAL TABLE NIMBLE_DEMO.RAW.BRONZE_EVENTS_EXT (v VARIANT)
 LOCATION=@NIMBLE_DEMO.RAW.BRONZE_STAGE
 AUTO_REFRESH=TRUE
 FILE_FORMAT=(TYPE=JSON);

CREATE OR REPLACE TABLE NIMBLE_DEMO.RAW.BRONZE_EVENTS AS
SELECT v FROM NIMBLE_DEMO.RAW.BRONZE_EVENTS_EXT;

Snowpark: Bronze → Silver

# snowpark_silver.py

from snowflake.snowpark import Session
from snowflake.snowpark.functions import col, to_timestamp, try_cast
from snowflake.snowpark.types import DecimalType

session = Session.builder.configs(connection_params).create()
bronze = session.table('NIMBLE_DEMO.RAW.BRONZE_EVENTS')

silver = (bronze.select(col('v').alias('data')).select(
    col('data:url').cast('string').alias('url'),
    to_timestamp(col('data:timestamp')).alias('ts'),
    try_cast(col('data:price'), DecimalType(18,2)).alias('price'),
    col('data:currency').cast('string').alias('currency'),
    col('data:source').cast('string').alias('source')
))

session.sql("CREATE SCHEMA IF NOT EXISTS NIMBLE_DEMO.SILVER").collect()
silver.write.mode('overwrite').save_as_table('NIMBLE_DEMO.SILVER.EVENTS_CURATED')

Databricks: Auto Loader + Delta Live Tables

# dlt_pipeline.py (Python DLT)

import dlt
from pyspark.sql.functions import col, to_timestamp

@dlt.table(name="bronze_events", comment="Raw Nimble JSON")
def bronze_events():
    return (spark.readStream.format("cloudFiles")
            .option("cloudFiles.format", "json")
            .option("cloudFiles.inferColumnTypes", "true")
            .load("s3://<bucket>/nimble/bronze/"))

@dlt.table(name="silver_events")
@dlt.expect_or_drop("valid_price", "price >= 0")
def silver_events():
    return dlt.read_stream("bronze_events").withColumn("ts", to_timestamp(col("timestamp")))

@dlt.table(name="gold_price_index")
def gold_price_index():
    return (dlt.read("silver_events").groupBy("source", "currency")
            .avg("price").withColumnRenamed("avg(price)", "avg_price"))

dbt templates (Snowflake and Databricks)

models/
 bronze/bronze_events.sql
 silver/silver_events.sql
 gold/gold_price_index.sql
 schema.yml

models/silver/silver_events.sql (Snowflake syntax; dbt adapts types for Databricks):

select
 try_to_timestamp(v:timestamp) as ts,
 v:url::string as url,
 try_to_decimal(v:price, 18, 2) as price,
 v:currency::string as currency,
 v:source::string as source
from {{ ref('bronze_events') }}

models/gold/gold_price_index.sql:

select source, currency, avg(price) as avg_price
from {{ ref('silver_events') }}
group by 1,2

Governance and quality

• Governance: with the native integrations, Unity Catalog (Databricks) and Snowflake Secrets and roles govern access, audit, and lineage.

• Compliance: SOC 2 Type II, GDPR and CCPA alignment, and Zero Data Retention on enterprise plans. Trust Center

• Provenance: every Web Search Agent run returns a trust report. With an output schema, each claim is keyed by JSON path and carries a confidence grade (high, medium, low, or pre_existing for values you supplied), a reasoning string, and citations with verbatim excerpts. Land the grade and source URL as columns next to each enriched field, then filter downstream (for example, WHERE confidence = 'high') or route low rows to review. A cited null is a verified absence, not a gap. Trust docs

Performance and cost tips

• Use the native SQL functions for on-demand enrichment and analytics; use landing-zone delivery for large scheduled batches.

• Request only the fields you need with an output or parsing schema; use Extraction Templates for normalized output.

• Use Lite search for high-volume lookups, and right-size Web Search Agent effort.

• Partition Bronze by event date (dt=YYYY-MM-DD) for efficient incremental loads.

End-to-end test checklist

1) Install the Nimble Search or Agents Native App (Snowflake) or the Marketplace Unity Catalog connection (Databricks), and enable the required previews. 2) Run a test search and a test extract from SQL; confirm results return. 3) Run an enrichment over a 10–50 row sample table with a Web Search Agent; check field fill and citations. 4) For landing-zone delivery, trigger a small async job and validate files and Bronze tables. 5) Schedule with dbt, Workflows, or Tasks; validate dashboards.

Related resources

• Databricks integration docs

• Snowflake integration docs

• MCP Server Technical Spec

• Web Scraping with Nimble: managed data services