ChromaDB pour l'esprit SQL

Bonjour, Chroma DB est une base de données vectorielle utile pour travailler avec les applications GenAI. Dans cet article, j'explorerai comment exécuter des requêtes sur Chroma DB en examinant des relations similaires dans MySQL.

Schéma

Contrairement à SQL, vous ne pouvez pas définir votre propre schéma. Dans Chroma, vous obtenez des colonnes fixes, chacune avec son propre objectif :

import chromadb

#setiing up the client
client = chromadb.Client() 
collection = client.create_collection(name="name")

collection.add(
    documents = ["str1","str2","str3",...]
    ids = [1,2,3,....]
    metadatas=[{"chapter": "3", "verse": "16"},{"chapter":"3", "verse":"5"}, ..]           
    embeddings = [[1,2,3], [3,4,5], [5,6,7]]
)

Identifiants : ce sont des identifiants uniques. Notez que vous devez les fournir vous-même contrairement à SQL il n'y a pas d'incrémentation automatique
Documents : Il est utilisé pour insérer les données texte utilisées pour générer les intégrations. Vous pouvez fournir le texte et il créera automatiquement les intégrations. ou vous pouvez simplement fournir des intégrations directement et stocker le texte ailleurs.
Embeddings :Ils sont à mon avis la partie la plus importante de la base de données car ils sont utilisés pour effectuer des recherches de similarité.
Métadonnées : ceci est utilisé pour associer toutes les données supplémentaires que vous pourriez souhaiter ajouter à votre base de données pour tout contexte supplémentaire.

Maintenant que les bases d'une collection sont claires, passons aux opérations CRUD et nous verrons comment interroger la base de données.

Opérations CRUD

Remarque : les collections sont comme des tableaux dans Chroma

Pour créer une collection, nous pouvons utiliser create_collection() et effectuer nos opérations selon nos besoins, mais si la collection est déjà créée et que nous devons la référencer à nouveau, nous devons utiliser get_collection() sinon nous obtiendrons une erreur.

Create Table tablename 

#Create a collection
collection = client.create_collection(name="name")

#If a collection is already made and you need to use it again the use
collection = client.get_collection(name="name")

Insert into tablename
Values(... , ..., ...)

collection.add(
    ids = [1]
    documents = ["some text"]
    metadatas = [{"key":"value"}]
    embeddings = [[1,2,3]]
)

Pour mettre à jour les données insérées ou pour supprimer les données, nous pouvons utiliser les commandes suivantes

collection.update(
    ids = [2]
    documents = ["some text"]
    metadatas = [{"key":"value"}]
    embeddings = [[1,2,3]]            
)

# If the id does not exist update will do nothing. to add data if id does not exist use
collection.upsert(
    ids = [2]
    documents = ["some text"]
    metadatas = [{"key":"value"}]
    embeddings = [[1,2,3]]            
)

# To delete data use delete and refrence the document or id or the feild
collection.delete(
    documents = ["some text"]         
)

# Or you can delete from a bunch of ids using where that will apply filter on metadata
collection.delete(
    ids=["id1", "id2", "id3",...],
    where={"chapter": "20"}
)

Requêtes

Nous allons maintenant voir à quoi ressemblent certaines requêtes

Select * from tablename

Select * from tablename limit value

Select Documents, Metadata from tablename

collection.get()

collection.get(limit = val)

collection.get(include = ["documents","metadata"])

Bien que get() soit là pour récupérer un grand ensemble de tables pour des requêtes plus avancées, vous devez utiliser la méthode de requête

Select A,B from table
limit val

collection.query(
    n_results = val #limit
    includes = [A,B] 
)

Nous avons maintenant 3 façons possibles de filtrer les données : recherche de similarité (à quoi servent principalement les bases de données vectorielles), filtres de métadonnées et filtres de documents

Recherche de similarité

Nous pouvons effectuer une recherche basée sur du texte ou des intégrations et obtenir les résultats les plus similaires

collection.query(query_texts=["string"])

collection.query(query_embeddings=[[1,2,3]])

Dans ChromaDB, les paramètres Where et Where_document sont utilisés pour filtrer les résultats lors d'une requête. Ces filtres vous permettent d'affiner votre recherche de similarité en fonction de métadonnées ou du contenu spécifique d'un document.

Filtrer par métadonnées

Le paramètre Where vous permet de filtrer les documents en fonction de leurs métadonnées associées. Les métadonnées sont généralement un dictionnaire de paires clé-valeur que vous fournissez lors de l'insertion du document.

Filtrer les documents par métadonnées comme la catégorie, l'auteur ou la date.

import chromadb

#setiing up the client
client = chromadb.Client() 
collection = client.create_collection(name="name")

collection.add(
    documents = ["str1","str2","str3",...]
    ids = [1,2,3,....]
    metadatas=[{"chapter": "3", "verse": "16"},{"chapter":"3", "verse":"5"}, ..]           
    embeddings = [[1,2,3], [3,4,5], [5,6,7]]
)

Create Table tablename 

Filtrer par contenu de document

Le paramètrewhere_document permet un filtrage directement basé sur le contenu des documents.

Récupérez uniquement les documents contenant des mots-clés spécifiques.

#Create a collection
collection = client.create_collection(name="name")

#If a collection is already made and you need to use it again the use
collection = client.get_collection(name="name")

Notes clés :

• Utilisez des opérateurs comme $contains, $startsWith ou $endsWith.
  • $contains : fait correspondre les documents contenant une sous-chaîne.
  • $startsWith : fait correspondre les documents commençant par une sous-chaîne.
  • $endsWith : fait correspondre les documents se terminant par une sous-chaîne.

• Par exemple :
  

  Insert into tablename
  Values(... , ..., ...)
  

Cas d'utilisation courants :

Nous pouvons combiner les trois filtres comme ceci :

1. Rechercher dans une catégorie spécifique :
   

   collection.add(
       ids = [1]
       documents = ["some text"]
       metadatas = [{"key":"value"}]
       embeddings = [[1,2,3]]
   )
   

2. Rechercher des documents contenant un terme spécifique :
   

   collection.update(
       ids = [2]
       documents = ["some text"]
       metadatas = [{"key":"value"}]
       embeddings = [[1,2,3]]            
   )
   
   # If the id does not exist update will do nothing. to add data if id does not exist use
   collection.upsert(
       ids = [2]
       documents = ["some text"]
       metadatas = [{"key":"value"}]
       embeddings = [[1,2,3]]            
   )
   
   # To delete data use delete and refrence the document or id or the feild
   collection.delete(
       documents = ["some text"]         
   )
   
   # Or you can delete from a bunch of ids using where that will apply filter on metadata
   collection.delete(
       ids=["id1", "id2", "id3",...],
       where={"chapter": "20"}
   )
   

3. Combinez les filtres de métadonnées et de contenu de document :
   

   Select * from tablename
   
   Select * from tablename limit value
   
   Select Documents, Metadata from tablename
   

Ces filtres améliorent la précision de vos recherches de similarité, faisant de ChromaDB un outil puissant pour la récupération ciblée de documents.

Conclusion

J'ai écrit cet article parce que je sentais que le document laissait beaucoup à désirer lorsque j'essayais de créer mon propre programme, j'espère que cela m'aidera !

Merci d'avoir lu si vous avez aimé l'article, aimez-le et partagez-le. De plus, si vous êtes nouveau dans l'architecture logicielle et que vous souhaitez en savoir plus, je démarre une cohorte de groupe où je travaillerai personnellement avec vous et un petit groupe pour vous apprendre tout sur les principes de l'architecture logicielle et de la conception. Vous pouvez remplir le formulaire ci-dessous si vous êtes intéressé. https://forms.gle/SUAxrzRyvbnV8uCGA

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!