ai_search-Funktion

Gilt für: Databricks SQL Databricks Runtime

Die Funktion ai_search() ruft Informationen aus einer oder mehreren Wissensquellen ab. Wissensquellen können KI-Suchindizes oder Lakebase-synchronisierte Tabellen mit aktivierter Lakebase Search enthalten.

Gegeben eine natürliche Sprachanfrage und für den Aufruf konfigurierte Wissensquellen, generiert die Funktion optimierte Suchanfragen, ruft Ergebnisse über Quellen hinweg ab und dedupliziert sie, ordnet sie nach Relevanz neu und liefert die relevantesten Dokumente zurück. Standardmäßig synthetisiert es außerdem eine geerdete Antwort in natürlicher Sprache über die abgerufenen Dokumente.

Nutzen ai_search , um Betriebsdaten mit relevantem Kontext im großen Maßstab zu bereichern, Batch-Retrieval-Augmented Generation (RAG)-Pipelines zu erstellen oder Retrieval als Werkzeug einem zusammengesetzten KI-System zugänglich zu machen – alles aus einem einzigen SQL-Funktionsaufruf.

Datensicherheit

Ihre Dokumentdaten werden innerhalb des Databricks-Sicherheitsperimeters verarbeitet. Databricks speichert die Parameter, die in die KI-Funktionsaufrufe eingegeben werden, nicht, behält aber Metadaten-Laufdetails, wie zum Beispiel die verwendete Databricks-Runtime-Version.

Anforderungen

• Databricks Runtime 18.2 oder höher.
• Eine oder mehrere Wissensquellen zum Durchsuchen: KI-Suchindizes oder von Lakebase synchronisierte Tabellen mit aktivierter Lakebase Search.
• Um eine Lakebase-synchronisierte Tabelle zu verwenden, bereite sie zuerst für die Suche vor. Siehe Lakebase-Konfiguration.
• Wenn Sie serverlose Rechenleistungen verwenden, muss die serverlose Umgebungsversion auf 3 oder höher gesetzt werden, da dies Funktionen wie VARIANTmöglich macht.
• Die ai_search Funktion ist über Databricks-Notizbücher, einen SQL-Editor, Databricks-Workflows, Jobs oder Spark Declarative Pipelines auf Lakeflow verfügbar.

Syntax

ai_search(query, knowledge_sources [, instructions] [, options])

Arguments

• query: Ein STRING- oder VARIANT-Ausdruck. Die Suchanfrage in natürlicher Sprache. VARIANT Eingabe, wie die Ausgabe einer anderen KI-Funktion, wird intern in einen JSON-String serialisiert.
• knowledge_sources: Ein oder VARIANT Ausdruck, der STRING ein JSON-Array von Wissensquellenkonfigurationen enthält, die durchsucht werden können. Siehe Konfiguration der Wissensquelle. Du kannst bis zu 10 Wissensquellen angeben.
• instructions: Ein optionaler STRING Ausdruck von bis zu 4.000 Zeichen. Natürlichsprachige Anweisungen, die Abfragegenerierung, Metadaten-Filtergenerierung und Reranking leiten. Beispiel: 'Prefer official documentation over internal articles when both cover the same topic.'
• options: Optional MAP<STRING, STRING>. Unterstützte Schlüssel:
  • 'version': Die Funktionsversion, die verwendet werden sollte.
  • 'generate_answer': 'true' (Standard) oder 'false'. Wenn 'true', synthetisiert die Funktion eine geerdete Antwort in natürlicher Sprache aus den abgerufenen Dokumenten und gibt sie im answer Feld zurück. Auf nur Rücksendung von Dokumenten eingestellt 'false' .
  • 'generate_citations': 'true' oder 'false' (Standard). Wenn 'true', liefert die Funktion Zitate zurück, die zeigen, welche abgerufenen Chunks das Modell zur Unterstützung seiner generierten Antwort verwendet hat. Diese Option muss 'generate_answer' sein 'true'.

Konfiguration der Wissensquelle

Das Argument knowledge_sources ist ein JSON-Array. Jedes Element ist eine Hüllkurve {type, config} . Das Feld type identifiziert, wie ai_search er mit der Quelle verbunden ist, und ist vom kundenorientierten Ressourcennamen getrennt. Auf für einen KI-Suchindex eingestellt typevector_search oder lakebase_search für eine Lakebase-Synchrontabelle mit aktivierter Lakebase Search. Das Feld config enthält die quellenspezifische Konfiguration.

Ein einzelner Aufruf kann bis zur 10-Quelle-Grenze kombiniert vector_search und lakebase_search quellen.

KI-Suchindexkonfiguration

Für einen KI-Suchindex mit type gesetzt auf vector_searchakzeptiert , config folgende Schlüssel:

Das folgende Beispiel konfiguriert einen KI-Suchindex als Wissensquelle:

[
  {
    "type": "vector_search",
    "config": {
      "index_name": "prod_catalog.docs.support_articles",
      "text_col": "article_body",
      "doc_uri_col": "article_url",
      "filter_columns": "product,language"
    }
  }
]

Um einen KI-Suchindex aus Rohdokumenten zu erstellen, verwenden ai_parse_document Sie suchbereite ai_prep_search Chunks in einer Delta-Tabelle. Erstellen Sie dann einen KI-Suchindex aus dieser Tabelle. Nachdem der Index online ist, verwenden Sie seinen dreistufigen Namen als index_name.

Lakebase-Konfiguration

Bevor Sie eine von Lakebase synchronisierte Tabelle als Wissensquelle verwenden können, bereiten Sie sie für die Suche vor:

1. Aktivieren Sie Lakebase Search und installieren Sie die Erweiterungen. Folgen Sie Lakebase Search , um Lakebase Search in Ihren Projekteinstellungen zu aktivieren, verbinden Sie sich dann mit der Postgres-Datenbank des Projekts und installieren Sie die lakebase_vector Erweiterung, indem Sie CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;. ausführen. Es bietet die ungefähre Vektorsuche, die ai_search verwendet wird. Das Aktivieren der Lakebase Search erfordert einen Beta-Zugriff und ist irreversibel.
2. Synchronisiere deine Unity-Katalog-Tabelle mit dem Projekt. Verwenden Sie eine synchronisierte Tabelle, bilden Sie die Einbettungsspalte auf eine Spalte vector(n) und erstellen Sie darauf einen lakebase_ann Index. Die Dimension n muss mit der Ausgabe deines Embedding-Modells übereinstimmen.
3. Generiere die Embeddings offline mit einem modellbasierten Endpunkt. Befüllen Sie die Embedding-Spalte mit einem Embedding-Modell – zum Beispiel indem Sie ein Embedding-Modell mit ai_query abfragen – und übergeben Sie dann denselben Endpunkt als embedding_model (siehe unten). ai_search bettet jede Abfrage zur Suchzeit mit ihr ein, sodass die Abfrage und die gespeicherten Dokument-Einbettungen einen Vektorraum teilen.

Für eine Lakebase-Wissensquelle mit type gesetzt auf lakebase_search, config akzeptiert die folgenden Schlüssel:

Das folgende Beispiel konfiguriert eine Lakebase-Tabelle als Wissensquelle. Ersetze embedding_model sie durch den Endpunkt, mit dem du die Tabelle offline eingebettet hast:

[
  {
    "type": "lakebase_search",
    "config": {
      "index_name": "prod_catalog.docs.support_articles_synced",
      "text_col": "article_body",
      "doc_uri_col": "article_url",
      "embedding_column": "article_embedding",
      "embedding_model": "databricks-gte-large-en",
      "lakebase_project_id": "my-lakebase-project"
    }
  }
]

Returns

A mit folgendem Schema VARIANT :

{
  "document": [
    {
      "page_content": STRING,  // Text content of the retrieved chunk
      "doc_uri": STRING,       // URI of the source document
      "metadata": MAP          // Additional metadata from the index
    }
  ],
  "answer": STRING,            // Grounded answer synthesized from the retrieved
                               // documents, or null
  "citations": [               // Present only when generate_citations is true
    {
      "document_index": INT    // Position in the document array above, starting at 0
    }
  ]
}

Wenn generate_citations , truelesen Sie die answer und citations die Felder zusammen. Jede Kombination von Werten bedeutet etwas anderes:

• Ein Nicht-Null answer mit einem leeren citations Array bedeutet, dass eine Antwort generiert wurde, aber kein zurückgegebener Chunk ausgewählt wurde.
• Ein Null answer mit leerem citations Array bedeutet, dass die Zitationsgenerierung ausgeführt wurde, aber keine Zitate erzeugte, weil keine geerdete Antwort generiert wurde.
• Ein Nullwert citations bedeutet, dass die Zitationsgenerierung nicht verfügbar war oder nicht aufgerufen wurde, einschließlich wann query SQL NULL.

Examples

Einfache Suche

Das folgende Beispiel durchsucht einen KI-Suchindex und liefert bewertete Dokumente sowie eine fundierte Antwort:

SELECT ai_search(
  'How do I configure auto-scaling for my SQL warehouse?',
  PARSE_JSON('[{
    "type": "vector_search",
    "config": {
      "index_name": "prod_catalog.docs.support_articles",
      "text_col": "article_body",
      "doc_uri_col": "article_url",
      "filter_columns": "product,language"
    }
  }]')
) AS result;

Geben Sie unterstützende Chunks für die generierte Antwort zurück

Das folgende Beispiel liefert die Teilmenge der abgerufenen Chunks zurück, die das Modell als Unterstützung der Antwort ausgewählt hat:

SELECT ai_search(
  'How do I configure auto-scaling for my SQL warehouse?',
  PARSE_JSON('[{
    "type": "vector_search",
    "config": {
      "index_name": "prod_catalog.docs.support_articles",
      "text_col": "article_body",
      "doc_uri_col": "article_url"
    }
  }]'),
  options => map('generate_citations', 'true')
) AS result;

Das Array document enthält immer noch den vollständigen Satz der zurückgegebenen Chunks. Verwenden Sie die document_index in jedem Zitat, um die unterstützenden aus diesem Array herauszufiltern. Diese Indizes sind nur innerhalb einer einzigen Antwort gültig. Sie können sich zwischen Anrufen, bei Neubewertungen oder beim Aktualisieren des Index ändern.

Mehrfachquellensuche mit Anweisungen

Das folgende Beispiel durchsucht zwei KI-Suchindizes und nutzt instructions es, um Abfragegenerierung und -reranking zu steuern:

SELECT ai_search(
  'What are the networking requirements for serverless SQL warehouses?',
  PARSE_JSON('[
    {
      "type": "vector_search",
      "config": {"index_name": "prod_catalog.docs.public_docs", "text_col": "content", "doc_uri_col": "doc_url"}
    },
    {
      "type": "vector_search",
      "config": {"index_name": "prod_catalog.docs.internal_kb", "text_col": "body", "doc_uri_col": "source_uri"}
    }
  ]'),
  'Focus on firewall rules and VPC/VNet configuration. Prefer official documentation over internal articles when both cover the same topic.'
) AS result;

Suche in einer Lakebase-Tabelle

Das folgende Beispiel durchsucht eine Lakebase-Synchronisierte Tabelle und liefert rangierte Dokumente sowie eine geerdete Antwort:

SELECT ai_search(
  'How do I configure auto-scaling for my SQL warehouse?',
  PARSE_JSON('[{
    "type": "lakebase_search",
    "config": {
      "index_name": "prod_catalog.docs.support_articles_synced",
      "text_col": "article_body",
      "doc_uri_col": "article_url",
      "embedding_column": "article_embedding",
      "embedding_model": "databricks-gte-large-en",
      "lakebase_project_id": "my-lakebase-project"
    }
  }]')
) AS result;

Kombinieren Sie einen KI-Suchindex und eine Lakebase-Tabelle

Das folgende Beispiel durchsucht einen KI-Suchindex und eine Lakebase-Tabelle im selben Aufruf. Ergebnisse aus beiden Quellen werden dedupliziert, zusammen neu gerankt und als eine einzige Rangliste zurückgegeben:

SELECT ai_search(
  'What are the networking requirements for serverless SQL warehouses?',
  PARSE_JSON('[
    {
      "type": "vector_search",
      "config": {"index_name": "prod_catalog.docs.public_docs", "text_col": "content", "doc_uri_col": "doc_url"}
    },
    {
      "type": "lakebase_search",
      "config": {
        "index_name": "prod_catalog.docs.internal_kb_synced",
        "text_col": "body",
        "doc_uri_col": "source_uri",
        "embedding_column": "body_embedding",
        "embedding_model": "databricks-gte-large-en",
        "lakebase_project_id": "my-lakebase-project"
      }
    }
  ]')
) AS result;

Bereichern Sie eine Tabelle mit Abruf und einer generierten Antwort

Das folgende Beispiel bereichert jedes Support-Ticket mit relevanter Dokumentation und einem vorgeschlagenen Lösungsvorschlag. Da die Antwortgenerierung standardmäßig aktiviert ist, ist die vorgeschlagene Auflösung direkt im answer Feld verfügbar – es ist kein separater Generierungsschritt erforderlich.

SELECT
  ticket_id,
  customer_description,
  ai_search(
    customer_description,
    PARSE_JSON('[{
      "type": "vector_search",
      "config": {
        "index_name": "support.docs.product_documentation",
        "text_col": "content",
        "doc_uri_col": "doc_url"
      }
    }]'),
    'Find product documentation, known issues, and troubleshooting guides relevant to this support ticket.'
  ):answer::STRING AS suggested_resolution
FROM support.tickets.open_tickets;

Um das Ausgabeformat zu steuern oder ein bestimmtes Modell zu verwenden, setzen 'generate_answer' Sie stattdessen die 'false' abgerufenen Dokumente auf und verketten Sie sie darauf ai_query .

Einschränkungen

• ai_search unterstützt AI-Such-Indizes ("type": "vector_search") und Lakebase-synchronisierte Tabellen ("type": "lakebase_search") als Wissensquellen.
• Du kannst bis zu 10 Wissensquellen pro Aufruf angeben, in jeder Kombination der unterstützten Typen.
• Das Argument instructions ist auf 4.000 Zeichen beschränkt.

Verwandte Funktionen

• ai_parse_document Funktion
• ai_prep_search Funktion
• ai_query Funktion
• ai_extract Funktion
• ai_enrich Funktion