Cas d'usage RAG en aval
Bêta
Cette fonctionnalité est en Bêta. Les administrateurs du Workspace peuvent contrôler l'accès à cette fonctionnalité à partir de la page Previews . Consultez Gérer les aperçus Databricks.
Maintenant que vous avez créé votre pipeline SharePoint, vous pouvez analyser les documents bruts en texte, fragmenter les données analysées, créer des incorporations à partir des fragments, et bien plus encore. Vous pouvez ensuite utiliser readStream directement sur la table de sortie dans votre pipeline en aval.
Analyser les documents non structurés
De nombreuses charges de travail RAG en aval et de compréhension de documents nécessitent de convertir des fichiers bruts non structurés (tels que des PDF, des PPTX, des documents Word et des images) en représentations structurées et interrogeables. Databricks fournit ai_parse_document, une fonction intégrée qui extrait automatiquement le texte, les tables, les informations de Layout, les métadonnées et d'autres signaux structurés du contenu des fichiers binaires.
Vous pouvez appliquer ai_parse_document directement à la colonne inline_content produite par le pipeline d’ingestion SharePoint. C'est l'approche recommandée pour la plupart des cas d'utilisation en aval non structurés, y compris la génération augmentée de récupération (RAG), la classification, l'extraction d'entités et la création d'agents centrés sur les documents.
Pour plus d'informations, consultez ai_parse_document.
Exemple : Transformez les fichiers Sharepoint
Vous pouvez transformer de manière incrémentielle vos fichiers SharePoint ingérés en sorties analysées et structurées à l'aide de LakeFlow Pipelines (par exemple, vues matérialisées ou tables de streaming). L'exemple suivant montre comment créer une vue matérialisée qui analyse chaque document nouvellement arrivé :
CREATE OR REFRESH MATERIALIZED VIEW documents_parsed
AS
SELECT
*,
ai_parse_document(content.inline_content) AS parsed
FROM <your_catalog>.<your_schema>.<your_destination_table>;
Cette vue maintient vos représentations de documents analysés à jour à mesure que de nouveaux fichiers arrivent via le pipeline d'ingestion SharePoint. La colonne parsed peut alors être utilisée pour vos cas d’usage en aval.
Accéder au contenu de fichier individuel
Si vous préférez travailler directement avec les fichiers, par exemple lors de l'intégration avec des bibliothèques ou des outils personnalisés, Databricks fournit des UDF d'accès aux fichiers supplémentaires que vous pouvez exécuter sur la table de sortie du pipeline d'ingestion.
Nom | Description |
|---|---|
| Télécharge le fichier sur le disque local et renvoie le chemin d'accès au fichier. |
| Télécharge le fichier sur le disque local et renvoie les données sous forme de tableau d'octets. |
Configurez les UDF d'accès aux fichiers
Pour configurer les UDFs d'accès aux fichiers, ajoutez la cellule suivante à votre pipeline en aval :
# DO NOT MODIFY this cell.
from pyspark.sql.functions import udf, struct
from pyspark.sql.types import BinaryType
# Copy to local disk and get file path.
def copy_to_disk(blob, filename) -> str:
fname = "/local_disk0/tmp/" + filename
with open(fname, "wb") as f:
f.write(blob.inline_content)
return fname
read_blob_as_file = udf(copy_to_disk)
# Get bytes directly.
def get_bytes(blob) -> bytes:
return blob.inline_content
read_blob_as_bytes = udf(get_bytes, BinaryType())
Exemples d'accès aux fichiers
Pour renvoyer le chemin d'accès au fichier :
# Suppose you have a simple UDF that converts a file's raw bytes to a UTF-8 string.
def file_bytes_to_text(fname):
with open(fname, "rb") as f:
return f.read().decode("utf-8")
file_bytes_to_text_udf = udf(file_bytes_to_text)
# Chain your UDF with the file access UDF for the file path.
df.withColumn("text_content",
file_bytes_to_text_udf(read_blob_as_file("content",
"file_metadata.name"))).collect()
Pour renvoyer les données sous forme de tableau d'octets :
# Suppose you have a simple UDF that converts a file's raw bytes to a UTF-8 string.
def bytes_to_text(bytes_data):
return bytes_data.decode("utf-8")
bytes_to_text_udf = udf(bytes_to_text)
# Chain your UDF with the file access UDF for the byte array.
df.withColumn("text_content",
bytes_to_text_udf(read_blob_as_bytes("content"))).collect()
Les UDF d'accès aux fichiers ne peuvent pas traiter le contenu des fichiers dont la taille est supérieure à 100 Mo. Vous devez filtrer ces lignes avant d'utiliser les UDF d'accès aux fichiers.
Étant donné que l’UDF de chemin d’accès de fichier écrit sur le disque local, elle ne fonctionne que sur des clusters à utilisateur unique. Si vous souhaitez plutôt exécuter le pipeline en aval sur des clusters classiques ou un compute Serverless, vous pouvez mettre à jour l’UDF pour écrire dans un volume Unity Catalog au lieu de votre disque local. Cependant, cela ralentira les performances.
Pour écrire dans un volume :
# Update the volume_path in the function below.
from pyspark.sql.functions import udf, struct
# copy to volume_path and get file path
def copy_to_disk(blob, filename) -> str:
# UPDATE THIS VALUE
volume_path = "/Volumes/<my_catalog>/<my schema>/<my volume name>/"
fname = volume_path + filename
with open(fname, "wb") as f:
f.write(blob.inline_content)
return fname
read_blob_as_file = udf(copy_to_disk)