Effectuer une recherche de similarité vectorielle avec Vertex AI

Bienvenue dans la recherche de similarités vectorielles de Firebase SQL Connect's — l'implémentation de la recherche sémantique de Firebase qui s'intègre à Google Vertex AI.

Au cœur de cette fonctionnalité se trouvent les embeddings vectoriels, qui sont des tableaux de nombres à virgule flottante représentant la signification sémantique du texte ou des médias. En exécutant une recherche du voisin le plus proche à l'aide d'un embedding vectoriel d'entrée, vous pouvez trouver tous les contenus sémantiquement similaires. SQL Connect utilise l'extension pgvector de PostgreSQL pour cette fonctionnalité.

Cette puissante recherche sémantique peut être utilisée dans des cas d'utilisation tels que les moteurs de recommandations et les moteurs de recherche. Il s'agit également d'un composant clé de la génération augmentée par récupération dans les flux d'IA générative. Pour en savoir plus, consultez la documentation de Vertex AI learn more.

Vous pouvez compter sur la prise en charge intégrée de SQL Connect pour générer automatiquement des embeddings vectoriels à l'aide de l'API Embeddings de Vertex AI, ou utiliser cette API pour les générer manuellement.

Prérequis

• Configurez SQL Connect pour votre projet.

• Activez les API Vertex AI.

Configuration

Vous pouvez choisir entre un flux de développement local (si vous êtes un développeur Web, Kotlin Android ou iOS) ou un flux IDX (pour les développeurs Web). Vous pouvez utiliser une base de données locale ou votre projet SQL Connect de production et son instance Cloud SQL pour PostgreSQL pour le développement.

Ces instructions supposent que vous avez créé votre SQL Connect projet en suivant le guide de démarrage rapide.

Intégrer à PostgreSQL local

1. Configurez une instance PostgreSQL locale.
2. Attribuez-vous le rôle IAM Utilisateur Vertex AI.
3. Configurez les identifiants par défaut de l'application Google Cloud dans votre environnement.
4. Installez l'extension pgvector dans votre instance PostgreSQL locale.
5. Activez l'extension à l'aide de CREATE EXTENSION vector conformément aux instructions du dépôt pgvector.

Intégrer à IDX

1. Configurez votre espace de travail IDX à l'aide du modèle SQL Connect.
2. Attribuez-vous le rôle IAM Utilisateur Vertex AI.
3. Activez l'extension à l'aide de CREATE EXTENSION vector conformément aux instructions du dépôt pgvector.

Concevoir un schéma

Pour effectuer une recherche vectorielle, ajoutez un nouveau champ de type Vector à votre schéma. Par exemple, si vous souhaitez effectuer une recherche sémantique à l'aide de descriptions de films, ajoutez un champ pour contenir les embeddings vectoriels associés à la description du film. Dans ce schéma, descriptionEmbedding est ajouté pour stocker les embeddings vectoriels pour le description champ.

type Movie @table {
 id: ID! @col(name: "movie_id") @default(id: ID! @col(name: "movie_id") @default(expr: "uuidV4()")
 title: String!
 description: String
 descriptionEmbedding: Vector! @col(size:768)
 // ...
}

Générer et récupérer des embeddings

SQL Connect apporte une prise en charge intégrée des embeddings vectoriels avec la _embed valeur de serveur. Cela indique à SQL Connect de générer des embeddings vectoriels en appelant en interne les API Embeddings de Vertex AI. La valeur de serveur _embed peut être utilisée dans les mutations et les requêtes.

Mutations

Générer et stocker un embedding via SQL Connect

Dans votre application de recherche vectorielle, vous souhaiterez probablement demander que les embeddings soient générés dès que vous ajoutez des enregistrements à votre base de données. Voici une createMovie mutation qui ajoute un enregistrement de film à la table Movie et transmet également une description de film avec un embedding model spécifié.

mutation createMovie($title: String!, $description: String!) {
  movie_insert(data: {
    title: $title,
    description: $description,
    descriptionEmbedding_embed: {model: "textembedding-gecko@003", text: $description}
  })
}

Dans certains cas, vous pouvez modifier la description et l'embedding du film.

mutation updateDescription($id: String!, $description: String!) {
  movie_update(id: $id, data: {
    description: $description,
    descriptionEmbedding_embed: {model: "textembedding-gecko@003", text: $description}
  })
}

Pour appeler la dernière mutation à partir d'un client :

import { updateMovieDescription } from 'lib/dataconnect-sdk/';

await updateMovieDescription({ id: movieId, description: description});

// Use the response

Requêtes

Récupérez les embeddings vectoriels à l'aide d'une requête comme celle-ci. Notez que le descriptionEmbedding renvoyé par la requête est un tableau de flottants, qui n'est généralement pas lisible par l'homme. Par conséquent, les SDK générés SQL Connect ne sont pas compatibles avec le renvoi direct.

Vous pouvez utiliser les embeddings vectoriels renvoyés pour effectuer une recherche de similarités, comme décrit dans la section suivante.

query getMovieDescription($id: String!) @auth(level: PUBLIC) {
 movie(id: $id)
   id
   description
   descriptionEmbedding
}

Effectuer une recherche de similarités

Nous pouvons maintenant effectuer une recherche de similarités.

Pour chaque champ Vector, SQL Connect génère une fonction GraphQL qui implémente la recherche de similarités. Le nom de cette fonction générée est ${pluralType}_${vectorFieldName}_similarity. Elle accepte quelques paramètres comme indiqué dans les exemples suivants et dans la liste de référence.

Vous pouvez définir une fonction GraphQL qui appelle la recherche de similarités. Comme mentionné ci-dessus, la valeur de serveur _embed indique à SQL Connect de générer les embeddings vectoriels à l'aide des API Embeddings de Vertex AI, dans ce cas pour créer des embeddings pour la chaîne de recherche utilisée pour la comparaison avec les embeddings de description de film.

Dans cet exemple, la recherche de similarités renverra jusqu'à cinq films dont la description est sémantiquement la plus proche de la requête d'entrée. L'ensemble de résultats est trié par ordre croissant de distance, du plus proche au plus éloigné.

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
      }
  }

Ajuster la requête de similarités

Les valeurs par défaut des paramètres de recherche tels que method et within fonctionnent bien pour la plupart des cas d'utilisation. Toutefois, si vous constatez que votre requête renvoie des résultats trop différents ou qu'il manque des résultats que vous souhaitez inclure, essayez d'ajuster ces paramètres.

Pour trouver une valeur appropriée pour within, nous pouvons ajouter _metadata.distance aux champs sélectionnés afin de voir à quelle distance du vecteur de requête se trouve chaque résultat. En fonction des valeurs distance renvoyées, nous pouvons définir le paramètre within. Seuls les résultats dont la distance est inférieure à la valeur de within seront inclus :

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      within: 2,
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
        _metadata {
          distance
        }
      }
  }

Vous pouvez également tester différentes fonctions de distance en définissant le paramètre method.

query searchMovieDescriptionUsingL2Similarity ($query: String!) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare_embed: {model: "textembedding-gecko@003", text: $query},
      within: .5,
      method: COSINE,
      where: {content: {ne: "No info available for this movie."}}, limit: 5)
      {
        id
        title
        description
        _metadata {
          distance
        }
      }
  }

Notez que différentes méthodes renvoient des valeurs très différentes pour la distance : si vous avez défini within, vous devrez à nouveau ajuster cette valeur après avoir modifié method.

Appeler la requête de similarités

Pour appeler une recherche de similarités à partir du code client :

import { searchMovieDescriptionUsingL2similarity} from 'lib/dataconnect-sdk';

const response = await searchMovieDescriptionUsingL2similarity({ query });

// Use the response

Utiliser des embeddings personnalisés

SQL Connect vous permet également d'utiliser directement les embeddings en tant que Vectors au lieu d'utiliser la valeur de serveur _embed pour les générer.

Stocker un embedding personnalisé

À l'aide de l'API Vertex Embeddings, spécifiez un modèle correspondant et demandez des résultats d'embedding de la bonne dimension.

Ensuite, convertissez le tableau de flottants renvoyé en Vector pour le transmettre à l'opération de mise à jour pour le stockage.

mutation updateDescription($id: String!, $description: String!, $descriptionEmbedding: Vector!) {
  movie_update(id: $id, data: {
    // title, genre...
    description: $description,
    descriptionEmbedding: $descriptionEmbedding
  })
}

Effectuer une recherche de similarités à l'aide d'embeddings personnalisés

Effectuez la même opération pour récupérer les embeddings des termes de recherche et les convertir en Vectors.

Ensuite, appelez la requête _similarity pour effectuer chaque recherche.

query searchMovieDescriptionUsingL2Similarity($compare: Vector!, $within: Float, $excludesContent: String, $limit: Int) @auth(level: PUBLIC) {
    movies_descriptionEmbedding_similarity(
      compare: $compare,
      method: L2,
      within: $within,
      where: {content: {ne: $excludesContent}}, limit: $limit)
      {
        id
        title
        description
      }
  }

Déployer en production

Déployer votre schéma et votre connecteur

La dernière étape d'une itération SQL Connect typique consiste à déployer vos assets en production.

Lorsque vous déployez votre schéma contenant des types Vector dans CloudSQL à l'aide de la firebase deploy commande, la Firebase CLI prend les mesures nécessaires pour activer la génération d'embeddings basée sur Vertex AI sur votre instance CloudSQL.

firebase deploy --only dataconnect

Si vous souhaitez activer manuellement la prise en charge des embeddings dans votre instance CloudSQL ou si vous rencontrez une erreur de CLI, suivez ces instructions.

Syntaxe de recherche vectorielle

Extensions de schéma

Le type de données Vector de SQL Connect est mappé sur le type vector de PostgreSQL tel que défini par l'extension pgvector. Le type vector de pgvector est stocké sous forme de tableau de nombres à virgule flottante simple précision dans PostgreSQL.

Dans SQL Connect, le type Vector est représenté sous forme de tableau de nombres JSON. Les entrées sont forcées dans un tableau de valeurs float32. Si la coercition échoue, une erreur est générée.

type Question @table {
    text: String!
    category: String!
    textEmbedding: Vector! @col(size: 768)
}

directive @col(
  # … existing args
  """
  Defines a fixed column size for certain scalar types.

  - For Vector, size is required.
  - For all other types, size is currently unsupported and hence supplying it will result in a schema error.
  """
  size: Int
) on FIELD_DEFINITION

_embed

method: COSINE|INNER_PRODUCT|L2

within: float

where: FDC filter condition

limit: int