Tutorial 1: Eine einfache Suchanwendung mit Cortex Search erstellen¶

Einführung¶

In diesem Tutorial werden die ersten Schritte mit Cortex Search für eine einfache Suchanwendung beschrieben.

Schritt 1: Setup¶

CREATE DATABASE IF NOT EXISTS cortex_search_tutorial_db;

CREATE OR REPLACE WAREHOUSE cortex_search_tutorial_wh WITH
     WAREHOUSE_SIZE='X-SMALL'
     AUTO_SUSPEND = 120
     AUTO_RESUME = TRUE
     INITIALLY_SUSPENDED=TRUE;

Schritt 2: Daten in Snowflake laden¶

Bevor Sie einen Search Service erstellen können, müssen Sie die Beispieldaten in Snowflake laden.

Sie können das Datenset über die Snowsight oder über SQL hochladen. Hochladen über die Snowsight:

1. Wählen Sie die Schaltfläche + Create oberhalb der linken Navigationsleiste aus.

2. Wählen Sie dann Table » From File aus.

   

3. Wählen Sie in der Dropdown-Liste oben rechts Ihr neu erstelltes Warehouse als Warehouse für Ihre Tabelle aus.

4. Ziehen Sie die JSON-Datei per Drag & Drop in das Dialogfeld.

5. Wählen Sie die oben erstellte Datenbank aus, und geben Sie das Schema PUBLIC an.

6. Geben Sie schließlich die Erstellung einer neuen Tabelle mit dem Namen airbnb_listings an und wählen Sie Next aus.

   

7. Nehmen Sie im Dialog Load Data into Table die folgenden Einstellungen vor. Deaktivieren Sie zunächst die Spalten image_embeddings, images und text_embeddings, da diese für dieses Tutorial nicht relevant sind. Ändern Sie dann den Datentyp des Feldes amenities auf den Typ ARRAY.

   

   

8. Sobald Sie diese Einstellungen vorgenommen haben, wählen Sie Load, um fortzufahren.

9. Nach kurzer Zeit sollte eine Bestätigungsseite angezeigt werden, die anzeigt, dass die Daten geladen wurden.

   

10. Wählen Sie Query Data aus, um ein neues Snowsight-Arbeitsblatt zu öffnen, das Sie im nächsten Schritt verwenden werden.

Schritt 3: Search Service erstellen¶

Erstellen Sie einen Search Service für unsere neue Tabelle, indem Sie den folgenden SQL-Befehl ausführen.

CREATE OR REPLACE CORTEX SEARCH SERVICE cortex_search_tutorial_db.public.airbnb_svc
ON listing_text
ATTRIBUTES room_type, amenities
WAREHOUSE = cortex_search_tutorial_wh
TARGET_LAG = '1 hour'
AS
    SELECT
        room_type,
        amenities,
        price,
        cancellation_policy,
        ('Summary\n\n' || summary || '\n\n\nDescription\n\n' || description || '\n\n\nSpace\n\n' || space) as listing_text
    FROM
    cortex_search_tutorial_db.public.airbnb_listings;

Schauen wir uns die Argumente dieses Befehls genauer an:

• Der Parameter ON gibt die Spalte an, in der Abfragen durchgeführt werden sollen. In diesem Fall ist es die Spalte listing_text, die in der Ausgangsabfrage als Verkettung mehrerer Textspalten in der Basistabelle erzeugt wird.

• Der Parameter ATTRIBUTES gibt die Spalten an, nach denen Sie die Suchergebnisse filtern können. In diesem Beispiel wird bei Abfragen in der Spalte listing_text nach room_type und amenities gefiltert.

• Die Parameter WAREHOUSE und TARGET_LAG geben das vom Benutzer zur Verfügung gestellte Warehouse bzw. die gewünschte Aktualität des Search Services an. In diesem Beispiel wird festgelegt, dass das Warehouse cortex_search_tutorial_wh verwendet wird, um den Index zu erstellen und Aktualisierungen durchzuführen, und dass der Dienst nicht mehr als '1 hour' hinter der Quelltabelle AIRBNB_LISTINGS zurückbleibt.

• Das Feld AS definiert die Quelltabelle für den Dienst. In diesem Beispiel werden mehrere Textspalten in der ursprünglichen Tabelle zu einer listing_text-Suchspalte verknüpft, sodass Abfragen über mehrere Felder erfolgen können.

Schritt 4: Eine Streamlit-App erstellen¶

Sie können den Dienst mit dem Python-SDK (unter Verwendung des snowflake-Python-Pakets) abfragen. Dieses Tutorial zeigt die Verwendung des Python-SDK in einer Streamlit in Snowflake-Anwendung.

Vergewissern Sie sich zunächst, dass Ihre globale Snowsight UI-Rolle mit der Rolle übereinstimmt, mit der Sie den Dienst im Schritt „Dienst erstellen“ erstellt haben.

1. Melden Sie sich bei Snowsight an.

2. Wählen Sie im Navigationsmenü auf der linken Seite Projects » Streamlit aus.

3. Wählen Sie + Streamlit App aus.

4. Wichtig: Wählen Sie die Datenbank cortex_search_tutorial_db und das Schema public für den Speicherort der App aus.

5. Wählen Sie im linken Bereich des Streamlit in Snowflake-Editors Packages aus und fügen Sie snowflake (Version >= 0.8.0) hinzu, um das Paket in Ihrer Anwendung zu installieren.

6. Ersetzen Sie den Code der Beispielanwendung durch die folgende Streamlit-App:

   # Import python packages
   import streamlit as st
   from snowflake.core import Root
   from snowflake.snowpark.context import get_active_session
   
   # Constants
   DB = "cortex_search_tutorial_db"
   SCHEMA = "public"
   SERVICE = "airbnb_svc"
   BASE_TABLE = "cortex_search_tutorial_db.public.airbnb_listings"
   ARRAY_ATTRIBUTES = {"AMENITIES"}
   
   
   def get_column_specification():
       """
       Returns the name of the search column and a list of the names of the attribute columns
       for the provided cortex search service
       """
       session = get_active_session()
       search_service_result = session.sql(f"DESC CORTEX SEARCH SERVICE {DB}.{SCHEMA}.{SERVICE}").collect()[0]
       st.session_state.attribute_columns = search_service_result.attribute_columns.split(",")
       st.session_state.search_column = search_service_result.search_column
       st.session_state.columns = search_service_result.columns.split(",")
   
   def init_layout():
       st.title("Cortex AI Search")
       st.markdown(f"Querying service: `{DB}.{SCHEMA}.{SERVICE}`".replace('"', ''))
   
   def query_cortex_search_service(query, filter={}):
       """
       Queries the cortex search service in the session state and returns a list of results
       """
       session = get_active_session()
       cortex_search_service = (
           Root(session)
           .databases[DB]
           .schemas[SCHEMA]
           .cortex_search_services[SERVICE]
       )
       context_documents = cortex_search_service.search(
           query,
           columns=st.session_state.columns,
           filter=filter,
           limit=st.session_state.limit)
       return context_documents.results
   
   @st.cache_data
   def distinct_values_for_attribute(col_name, is_array_attribute=False):
       session = get_active_session()
       if is_array_attribute:
           values = session.sql(f'''
           SELECT DISTINCT value FROM {BASE_TABLE},
           LATERAL FLATTEN(input => {col_name})
           ''').collect()
       else:
           values = session.sql(f"SELECT DISTINCT {col_name} AS VALUE FROM {BASE_TABLE}").collect()
       return [ x["VALUE"].replace('"', "") for x in values ]
   
   def init_search_input():
       st.session_state.query = st.text_input("Query")
   
   def init_limit_input():
       st.session_state.limit = st.number_input("Limit", min_value=1, value=5)
   
   def init_attribute_selection():
       st.session_state.attributes = {}
       for col in st.session_state.attribute_columns:
           is_multiselect = col in ARRAY_ATTRIBUTES
           st.session_state.attributes[col] = st.multiselect(
               col,
               distinct_values_for_attribute(col, is_array_attribute=is_multiselect)
           )
   
   def display_search_results(results):
       """
       Display the search results in the UI
       """
       st.subheader("Search results")
       for i, result in enumerate(results):
           result = dict(result)
           container = st.expander(f"[Result {i+1}]", expanded=True)
   
           # Add the result text.
           container.markdown(result[st.session_state.search_column])
   
           # Add the attributes.
           for column, column_value in sorted(result.items()):
               if column == st.session_state.search_column:
                   continue
               container.markdown(f"**{column}**: {column_value}")
   
   def create_filter_object(attributes):
       """
       Create a filter object for the search query
       """
       and_clauses = []
       for column, column_values in attributes.items():
           if len(column_values) == 0:
               continue
           if column in ARRAY_ATTRIBUTES:
               for attr_value in column_values:
                   and_clauses.append({"@contains": { column: attr_value }})
           else:
               or_clauses = [{"@eq": {column: attr_value}} for attr_value in column_values]
               and_clauses.append({"@or": or_clauses })
   
       return {"@and": and_clauses} if and_clauses else {}
   
   
   def main():
       init_layout()
       get_column_specification()
       init_attribute_selection()
       init_limit_input()
       init_search_input()
   
       if not st.session_state.query:
           return
       results = query_cortex_search_service(
           st.session_state.query,
           filter = create_filter_object(st.session_state.attributes)
       )
       display_search_results(results)
   
   
   if __name__ == "__main__":
       st.set_page_config(page_title="Cortex AI Search and Summary", layout="wide")
       main()
   

   Copy

Im Folgenden finden Sie eine kurze Aufschlüsselung der wichtigsten Komponenten im obigen Streamlit-in-Snowflake-Code:

• get_column_specification verwendet eine DESCRIBE SQL-Abfrage, um Informationen über die im Dienst verfügbaren Attribute zu erhalten, und speichert diese im Streamlit-Status.

• init_layout richtet den Header und das Intro der Seite ein.

• query_cortex_search_service ermöglicht die Abfrage des Cortex Search Service über die Python-Client-Bibliothek.

• create_filter_object verarbeitet ausgewählte Filterattribute aus dem Streamlit-Formular in die richtigen Objekte, die von der Python-Bibliothek für die Abfrage von Cortex Search verwendet werden.

• distinct_values_for_attribute bestimmt, welche Werte für jedes filterbare Attribut möglich sind, um die Dropdown-Menüs zu füllen.

• init_search_input, init_limit_input, init_attribute_selection initialisieren die Eingaben für die Suchabfrage, die Beschränkung der Anzahl der Ergebnisse und die Attributfilter.

• display_search_results formatiert Suchergebnisse in Markdown-Elemente, die auf der Ergebnisseite angezeigt werden.

Schritt 5: Bereinigen¶

DROP DATABASE IF EXISTS cortex_search_tutorial_db;
DROP WAREHOUSE IF EXISTS cortex_search_tutorial_wh;

Nächste Schritte¶

Herzlichen Glückwunsch! Sie haben erfolgreich eine einfache Such-App für Textdaten in Snowflake erstellt. Sie können mit Tutorial 2 fortfahren, um zu erfahren, wie Sie Cortex-LLM-Funktionen nutzen können, um mit Cortex Search einen AI-Chatbot zu erstellen.