Een chatbot bouwen met Snowflake Cortex AI (stapsgewijze gids)

Snowflake’s Cortex AI brengt krachtige AI-mogelijkheden rechtstreeks naar je Snowflake-omgeving. Door bijvoorbeeld Cortex’ toegang tot toonaangevende Large Language Models (LLM’s) te gebruiken, kunnen we tools bouwen zoals AI-chatbots die interne enterprise-data gebruiken zonder de beveiliging van gevoelige gegevens in gevaar te brengen. 

Deze integraties hebben een verschuiving veroorzaakt van traditionele, regelgebaseerde chats en automatiseringen naar flexibelere, AI-aangedreven chats die gebruikersinvoer beter begrijpen en daardoor meer volledige antwoorden kunnen geven.

In deze tutorial neem ik je mee door de stappen op hoog niveau om een chatbot te maken met Snowflake Cortex. Je leert hoe je data voorbereidt, Cortex Search configureert, Document AI gebruikt voor ongestructureerde data, een chatbotinterface bouwt in Streamlit en ik geef ideeën om te integreren met externe applicaties. Aan het einde heb je zowel de praktische vaardigheden als het conceptuele begrip om conversatie-AI op Snowflake te ontwerpen.

Als je nieuw bent met Snowflake, raad ik aan om de Snowflake Foundations skill track te volgen om snel op stoom te komen. Je kunt ook een gratis proefversie van Snowflake nemen om je skills in de praktijk te brengen.

Wat is Snowflake Cortex?

In de kern brengt Snowflake Cortex AI- en LLM-gedreven services naar het Snowflake-ecosysteem. Deze tutorial laat zien hoe je Cortex integreert met je Snowflake-data om een eenvoudige Streamlit-chatbotapp te maken met de Search Service van Cortex en Document AI voor het parsen van documentbestanden, zodat je extra context kunt bieden aan bestaande LLM-modellen via Cortex’ retrieval augmented generation-model.

In deze tutorial behandelen we:

• Het inrichten van je Snowflake-omgeving ter voorbereiding op het bouwen van een Cortex Search-chatbot
• Het benutten van Cortex LLM-functies en Document AI om inzichten uit documenten te halen.
• Het bouwen van een chatbot- en analytics-app in Streamlit in Snowflake
• Kostenstructuur en overwegingen bij het gebruik van Cortex

Het voordeel van Cortex is de native hybride aanpak voor vector-, trefwoord- en semantische reranking en de RAG-gebaseerde antwoordgeneratie, wat de nauwkeurigheid en specificiteit verbetert. 

Chatbots en analytics-apps bouwen met Streamlit in Snowflake benut de flexibiliteit van Python-ontwikkeling, terwijl de nadruk blijft liggen op databeveiliging en governance door gevoelige data binnen je veilige Snowflake-omgeving te houden. 

Wil je een idee krijgen van de mogelijkheden van Snowflake Cortex AI, bekijk dan deze tutorial over het gebruik van Cortex AI voor basis-NLP-taken zoals samenvatten en sentimentanalyse.

Vereisten

Voordat we gaan bouwen, maken we je Snowflake-account klaar. In dit account heb je de volgende permissies nodig:

• Rechten om warehouses aan te maken en de permissie USAGE
• Database-permissies: USAGE
• Schemarechten: USAGE, CREATE STREAMLIT, CREATE STAGE, CREATE CORTEX SEARCH SERVICE of OWNERSHIP
• De mogelijkheid om Document AI te gebruiken met de juiste account-level permissies. In de meeste gevallen gebruik je Snowflake’s ingebouwde rollen (bijv. ACCOUNTADMIN, SYSADMIN) of een aangepaste rol met:
• USAGE op de database en het schema
• CREATE CORTEX SEARCH SERVICE
• OPERATE op het search service-object zodra het is aangemaakt
• Voor Cortex heb je doorgaans de rol CORTEX_USER nodig in combinatie met object-level grants (USAGE, OPERATE) om met services te kunnen werken.

Idealiter heb je wat ervaring met SQL, Python en basis-AI-concepten. Je wilt SQL begrijpen om in de Snowflake-omgeving en de data te navigeren. Je hebt Python-kennis nodig om de Streamlit-app te bouwen. Basiskennis van AI-concepten helpt ons de componenten te begrijpen die in onze Cortex Search Service gaan.

Qua tools richten we ons op Snowflake’s Snowsight, hun webbrowser. Als je dit lokaal wilt bouwen, heb je je eigen IDE/teksteditor nodig. 

Hoewel we enkele datasamples zullen aanreiken, heb je idealiter een testcorpus en dataset waarmee je wilt werken. Als je die niet hebt, raad ik voor de tutorial de notulen van de Federal Open Market Committee aan (afkomstig van Snowflake): FOMC-minuten sample.

Hoe bouw je een chatbot in Snowflake Cortex

Oké, aan de slag! Sommige instructies zijn wat generieker zodat ze op veel situaties toepasbaar zijn.

Stap 1: Snowflake-database, schema en warehouse instellen

Eerst maken we de benodigde omgeving aan voor ons chatbotproject.

-- Create a dedicated warehouse
CREATE OR REPLACE WAREHOUSE cortex_wh 
  WITH WAREHOUSE_SIZE = 'XSMALL' 
  AUTO_SUSPEND = 60 
  AUTO_RESUME = TRUE;

-- Create a database and stage
CREATE OR REPLACE DATABASE cortex_chatbot_db;
CREATE OR REPLACE STAGE cortex_chatbot_db.public.chatbot_stage;

-- Switch context
USE DATABASE cortex_chatbot_db;
USE WAREHOUSE cortex_wh;Mogelijk gemaakt door

Zo zijn alle resources geïsoleerd en kosten beheersbaar.

Stap 2: Data laden en voorbereiden

Je chatbot heeft data nodig om vragen te beantwoorden. Dat kan zijn:

• Gestructureerde data: klantinformatie, transactie-logs, productcatalogi.
• Ongestructureerde data: pdf’s, FAQ’s, beleidsdocumenten, kennisbanken.

Heb je meer info nodig over data-ingestie en hoe we data in Snowflake krijgen, bekijk dan deze gids over data-ingestie.

Voorbeeld: een CSV-bestand stage-en laden.

-- Upload data (done via Snowsight UI or SnowSQL)
-- Example: product_faq.csv

-- Load into a table
CREATE OR REPLACE TABLE cortex_chatbot_db.public.chatbot_stage.product_faq (
  question STRING,
  answer STRING
);

COPY INTO product_faq
FROM @chatbot_stage/product_faq.csv
FILE_FORMAT = (TYPE = CSV FIELD_OPTIONALLY_ENCLOSED_BY='"');Mogelijk gemaakt door

Voor ongestructureerde data (bijv. pdf’s) kun je ze verwerken met Cortex Document AI. In de volgende stap bespreken we hoe we data uit ongestructureerde bronnen halen met Cortex Document AI.

We willen zowel onze gestructureerde als ongestructureerde data opknippen in chunks en zo nodig metadata toevoegen om RAG efficiënter te maken.

Stap 3: Document AI-configuratie en documentparsing

Laten we een model opzetten met Document AI om een afgestemde parser voor documenten te maken. Let op: dit is optioneel en ik raad aan om eerst de standaard Snowflake-modellen te proberen, want die zijn production-ready en ondersteunen OCR, layoutextractie en tabeldetectie. Je “traint” vandaag geen custom modellen direct in Cortex Document AI, maar je kunt extractiemodi configureren (bijv. entiteitsextractie, tabelextractie) die bij je data passen.

Begin eenvoudig met de standaardparser en voeg alleen geavanceerde configuratie toe als je documenten complexe of onregelmatige opmaak hebben.

Open in Snowsight het navigatiemenu en ga naar AI & ML. Selecteer onze cortex_wh en klik vervolgens op “Build”.  Van daaruit selecteren we “Create”. 

Zodra je de build hebt aangemaakt, uploaden we onze documenten naar de build. Als de verwerking is voltooid, kunnen we data extraheren met entiteitsextractie of tabelextractie. Met entiteitsextractie kun je vragen stellen over je document om data eruit te halen; tabelextractie parseert data op basis van gedefinieerde velden in je document. 

Als het model eenmaal is gebouwd, evalueren we de nauwkeurigheid en trainen we het model waar nodig. Het trainen stemt het af op de structuur van jouw document. Nu kunnen we dit model of ons standaardmodel gebruiken voor het parsen van documenten. Voor nu blijven we bij Snowflake’s standaard AI-parser.

CREATE OR REPLACE TABLE cortex_chatbot_db.public.chatbot_stage.doc_data AS --create the table
SELECT
    RELATIVE_PATH,
    TO_VARCHAR (
        SNOWFLAKE.CORTEX.PARSE_DOCUMENT ( --using default cortex parser
            '@cortex_chatbot.public.chatbot_stage',
            RELATIVE_PATH,
            {'mode': 'LAYOUT'} ):content
        ) AS EXTRACTED_LAYOUT
FROM
    DIRECTORY('@cortex_chatbot.public.chatbot_stage') --pull the files from the stage
WHERE
    RELATIVE_PATH LIKE '%.pdf'; --specifically just PDFsMogelijk gemaakt door

Nu staat onze data in een tabel en is klaar om te transformeren.

Stap 4: Datatransformatie en feature-extractie

Om data voor chatbotinteracties voor te bereiden, moeten documenten worden opgeknipt en verrijkt met metadata. Chunking maakt Cortex Search nauwkeuriger.

	CREATE OR REPLACE TABLE cortex_chatbot_db.public.chatbot_stage.doc_chunks AS
	SELECT
	    relative_path,
	    BUILD_SCOPED_FILE_URL(@cortex_chatbot.public.chatbot_stage, relative_path) AS file_url,
	    (
	        relative_path || ':\n'
	        || coalesce('Header 1: ' || c.value['headers']['header_1'] || '\n', '')
	        || coalesce('Header 2: ' || c.value['headers']['header_2'] || '\n', '')
	        || c.value['chunk']
	    ) AS chunk,
	    'English' AS language
	FROM
	cortex_chatbot_db.public.chatbot_stage.doc_data
	    LATERAL FLATTEN(SNOWFLAKE.CORTEX.SPLIT_TEXT_MARKDOWN_HEADER(
	        EXTRACTED_LAYOUT,
	        OBJECT_CONSTRUCT('#', 'header_1', '##', 'header_2'),
	        2000, -- chunks of 2000 characters
	        300 -- 300 character overlap
	    ))  c;Mogelijk gemaakt door

Deze SQL doet veel, dus even samenvatten. Hij neemt elk bestand en vlakt de tekst af in chunks van 2000 tekens. 

Opknippen in kleinere delen helpt de zoekeffectiviteit. Vervolgens voegt hij wat headerinformatie (zoals titels) toe aan de data binnen de chunk, zodat het model context heeft over waar deze data vandaan komt.

Hierdoor wordt je data doorzoekbaar en klaar voor retrieval-augmented generation (RAG).

Stap 5: Cortex Search of Agent aanmaken en configureren

Laten we onze Cortex Search Agent bouwen, de hoofdservice die door de chunks zoekt en de context voor een antwoord ophaalt.

CREATE OR REPLACE CORTEX SEARCH SERVICE cortex_chatbot_db.public.chatbot_stage.cortex_serv
    ON chunk
    ATTRIBUTES category
    WAREHOUSE = cortex_wh
    TARGET_LAG = '1 hour'
    AS (
    SELECT
        chunk,
        relative_path,
        file_url,
        category
    FROM cortex_chatbot_db.public.chatbot_stage.doc_chunks
    );Mogelijk gemaakt door

Dit bouwt een initiële service die ook het veld attributes definieert, waarmee je kolommen selecteert die je wilt gebruiken voor het filteren van zoekresultaten. Hier heb ik “category” gekozen zodat we theoretisch op verschillende productcategorieën kunnen filteren. Voor dit doel heb ik de kolom chunk gekozen, die onze gechunkte tekst moet bevatten.

Cortex Search gebruikt standaard een hybride vector + trefwoordzoektocht, wat de nauwkeurigheid van de chatbot verbetert. Hiermee kunnen we extra context toevoegen met een semantisch model. Als je unieke formuleringen of technische afkortingen verwacht, kun je een semantisch model in YAML configureren met de Cortex Analyst semantic model generator. Zo kun je het model context en synoniemen geven zodat het herkent dat “CUST” bijvoorbeeld ook “customer” kan betekenen. 

Dit maakt RAG-workflows mogelijk, waarbij de chatbot relevante context ophaalt voordat hij antwoorden genereert.

Stap 6: De chatbotapp bouwen met Streamlit

Laten we nu een super simpele frontend voor de chatbot bouwen binnen Snowflake met Streamlit. Gebruik Snowsight om de app “Streamlit in Snowflake” te vinden en je chatbotapp te maken. Dit gebruikt Snowpark om te verbinden met je Snowflake. 

Wil je eerst wat informatie over het bouwen van chatbots in het algemeen, volg dan deze cursus over chatbots bouwen in Python. 

Eerst laten we de gebruiker verbinden met Snowflake via Session.builder. Vervolgens geven we een bepaalde invoer mee als query aan SNOWFLAKE.CORTEX.SEARCH 

import streamlit as st
import snowflake.connector
from snowflake.snowpark import Session

# Connect to Snowflake
session = Session.builder.configs({
    "account": "<account_id>",
    "user": "<username>",
    "password": "<password>",
    "role": "SYSADMIN",
    "warehouse": "CORTEX_WH",
    "database": "CORTEX_CHATBOT",
    "schema": "PUBLIC"
}).create()

st.title("Snowflake Cortex Chatbot")

user_input = st.text_input("Ask me a question:")

if user_input:
    # Query Cortex Search
    result = session.sql(f"""
        SELECT PARSE_JSON(
SNOWFLAKE.CORTEX.SEARCH(
            chatbot_serv',
                 '{
         "query": "{user_input}",
         "columns":[
            "col1",
            "col2"
         ],
         "filter": {"@eq": {"col1": "filter value"} }
      }'
)
)[‘results’] AS results
    """).collect()

    st.write("**Chatbot:**", result[0]['RESPONSE'])Mogelijk gemaakt door

Deze basischatbot haalt relevante informatie op uit de Cortex Search-index en geeft realtime antwoorden terug. Je kunt ook een multi-turn (conversationale) chatbot maken door sessiegespreksgeschiedenis in het geheugen op te slaan. Dit kan native in Streamlit met de bestaande search service.

Stap 7: Implementatie via REST API-endpoints

Om de chatbot te integreren in externe apps (bijv. websites, Slack-bots), gebruik je de Snowflake REST API. Over het algemeen ziet de URL er ongeveer zo uit: https://<account_url>/api/v2/databases/<db_name>/schemas/<schema_name>/cortex-search-services/<service_name>:query.

Deze API’s vereisen authenticatie om veiligheidsredenen, wat betekent dat dit beperkt is tot gebruikers met toegang tot je Snowflake-omgeving. Deze API-first aanpak maakt het wel mogelijk om chatbotcapaciteiten flexibeler en naar een breder publiek in te bedden. 

Een usecase hiervoor is een interne tool die je op een webserver host, waarmee gebruikers vragen kunnen stellen over documenten zoals kwartaalrapporten of notulen van vergaderingen. Deze integraties vereisen wel de ontwikkeling van tools die API-requests kunnen doen.

Stap 8: Testen en valideren

Voordat je breed uitrolt, test je de chatbot op:

• Nauwkeurigheid – haalt hij de juiste antwoorden op?
• Snelheid – is de latency acceptabel?
• Gebruiksvriendelijkheid – is de interface intuïtief?

Je kunt queries loggen en uitkomsten vergelijken met bekende ground truth voor benchmarking. Het is gebruikelijk om een set vragen te hebben met een voorgeschreven antwoord en andere modellen te gebruiken om op nauwkeurigheid te vergelijken. 

Stap 9: Opruimen (optioneel)

Om kosten te beheren en governance te behouden, verwijder je ongebruikte resources.

	DROP WAREHOUSE IF EXISTS cortex_wh;
	DROP DATABASE IF EXISTS cortex_chatbot;
	DROP STAGE IF EXISTS chatbot_stage;Mogelijk gemaakt door

Aanvullende concepten & best practices

Laten we wat context toevoegen aan de werking van onze chatbot en enkele best practices bespreken.

Retrieval Augmented Generation (RAG) in Snowflake Cortex

RAG is een techniek die door veel large language models wordt gebruikt om de oorspronkelijke data aan te vullen met externe kennis. 

Snowflake Cortex voegt je enterprise-data toe aan de context van je chatbot, waardoor het in staat is antwoorden te geven met die extra context. Door een mix van vector- en trefwoordzoektocht kan het een prompt met contextdata parsen en semantische reranking gebruiken om de meest relevante documenten te selecteren voor een gecontextualiseerd antwoord. 

Dit vereenvoudigt ook de implementatie van RAG via één Cortex Search-engine, in plaats van dat de gebruiker handmatig vectoren, similariteitsfuncties en embeddings moet maken. De kracht van RAG stelt ons in staat om dingen te bouwen zoals chatbots gericht op technische documentatie.

Prompt engineering voor Snowflake-chatbots

Prompt engineering is belangrijk om ervoor te zorgen dat elke chatbot passende antwoorden geeft op gebruikersvragen. Een goede kennis van prompt engineering is cruciaal om ervoor te zorgen dat je chatservice goede antwoorden teruggeeft. 

Iets dat betere antwoorden helpt opleveren, is gebruikers een gebruiksgids geven die hen helpt betere vragen te formuleren.

Je kunt ook prompttemplates toevoegen aan gebruikersvragen voordat je ze naar de Cortex-service stuurt. Prompttemplates zorgen voor consistente context voor het model, zodat het de juiste informatie gebruikt om een antwoord te geven. 

Een voorbeeldtemplate die nuttig kan zijn voor enterprise-data is: "Je bent een behulpzame assistent voor de historische data van het bedrijf. Antwoord uitsluitend op basis van de bedrijfs-kennisbank." Zo kan het model zich richten op enterprise-data voor antwoorden.

Af en toe krijg je ook dubbelzinnige vragen of invoer. In plaats van het model te dwingen te antwoorden, kun je aan je template toevoegen: "Als de gebruiker een vage vraag stelt, geef dan het antwoord: Dat weet ik niet.” Dit kan hen aanzetten tot een specifieker vraag.

Flexibiliteit en keuze in implementatie

Snowflake Cortex ondersteunt voorgebouwde LLM’s (snel, production-ready) en custom modellen (fijn-afgestemd voor domeinen). Deze kun je definiëren bij het aanmaken van de service. Ook het toevoegen van je eigen semantische modellen voegt branche-/enterprise-specifieke context toe aan taal die anders mogelijk onduidelijk is voor het model, zonder dat je een grote hoeveelheid tekst hoeft aan te bieden. Deze flexibiliteit maakt toekomstige modelintegratie mogelijk.

Beveiliging, governance en compliance

Cortex volgt dezelfde role-based access control, audit logging en encryptie als Snowflake. Dit waarborgt compliance met HIPAA, GDPR en andere regelgeving. De belangrijkste verantwoordelijkheid aan jouw kant is zorgen dat de juiste mensen de juiste rollen hebben.

Kostenstructuur

Snowflake Cortex hanteert een verbruiksgebaseerd prijsmodel. Net als andere Snowflake-producten betaal je voor compute en opslag, maar er zijn enkele extra lagen specifiek voor Cortex Search. Je betaalt voor:

• Virtual Warehouse Compute: Dit is het belangrijkste compute-gebruik dat queries tegen Snowflake-data verwerkt en credits verbruikt
• EMBED_TEXT-tokenverbruik: Tijdens de dataverwerking voor documenten verzorgt Snowflake Cortex token-embedding, en je wordt gefactureerd wanneer documenten worden toegevoegd of gewijzigd
• Serving Compute: De Cortex Search Service gebruikt een serving compute om een low-latency en high-throughput service voor de gebruiker te bieden. Dit staat los van de virtual warehouse compute en rekent zodra de service beschikbaar is, niet alleen wanneer deze wordt gebruikt
• Opslag voor semantische indexen en gestagede data.
• Cloud Service Compute: Dit is een Snowflake-kostenniveau dat Snowflake in staat stelt wijzigingen in basisobjecten te identificeren. Dit wordt alleen in rekening gebracht als deze kosten hoger zijn dan 10% van de dagelijkse warehouse-kosten.

Probeer de volgende technieken om kosten te beheren:

• Snowflake raadt aan om MEDIUM of kleinere warehouses te gebruiken
• Monitor het tokenverbruik en stel gebruiksquota in.
• Archiveer ongebruikte indexen of sta een grotere data freshness lag toe als de nieuwste documenten niet noodzakelijk zijn
• Suspend je service wanneer die niet nodig is. Het kan nuttig zijn om de service op een timer te zetten zodat deze aan/uit schakelt wanneer hij niet wordt gebruikt.

Conclusie

Een chatbot bouwen met Snowflake Cortex ontsluit enterprise-specifieke conversatie-AI rechtstreeks op de Data Cloud. Van ingestie tot retrieval tot deployment: je kunt volledig binnen Snowflake’s gereguleerde omgeving werken. Deze chatbots kunnen helpen bij het stroomlijnen van zaken als onboarding, het beantwoorden van diepgaande analytische vragen en het creëren van technische documentatie.

Cortex maakt RAG-aangedreven chatbots mogelijk die LLM’s combineren met je eigen data. Een chatbot bouwen in Streamlit in Snowflake maakt het eenvoudig om gebruiksvriendelijke interfaces binnen Snowflake te deployen. Beveiliging, governance en kostenbeheer zijn ingebouwd in de workflow. Met Cortex kunnen organisaties evolueren van traditionele BI-dashboards naar intelligente assistenten die conversational met data omgaan.

Voor meer info over Snowflake en de AI-mogelijkheden, bekijk de volgende resources:

• Data Modeling in Snowflake
• Snowflake Arctic: Snowflake’s LLM
• ML met Python en Snowflake Cortex AI