Inicjowanie danych trwałych odbioru kolorów

import { ChromaClient } from 'chromadb'

Inicjowanie klienta

const client = new ChromaClient();

Powszechne operacje klienta

await client.reset() // Wyczyść bazę danych

Praca z kolekcjami

Chromadb wykorzystuje koncepcję kolekcji do zarządzania zestawami danych wektorowych, które można porównać do tabel w MySQL.

Tworzenie, przeglądanie i usuwanie kolekcji

Chroma wykorzystuje nazwę kolekcji w adresie URL, dlatego istnieją pewne ograniczenia dotyczące nazewnictwa:

  • Długość nazwy musi mieścić się w przedziale od 3 do 63 znaków.
  • Nazwa musi zaczynać i kończyć się małymi literami lub cyframi, a w środku może zawierać kropki, myślniki i podkreślenia.
  • Nazwa nie może zawierać dwóch kolejnych kropek.
  • Nazwa nie może być poprawnym adresem IP.

Aby utworzyć kolekcję, należy określić nazwę kolekcji oraz opcjonalną funkcję obliczającą wektory (nazywaną również funkcją osadzającą). Jeśli zostanie podana funkcja osadzająca, musi być podana za każdym razem, gdy kolekcja zostanie użyta.

Uwaga: Funkcja osadzająca służy do obliczania wektorów tekstu.

import { ChromaClient } from 'chromadb'

Utwórz i odwołaj się do kolekcji, jak pokazano poniżej:

let collection = await client.createCollection({name: "my_collection", embeddingFunction: emb_fn})

let collection2 = await client.getCollection({name: "my_collection", embeddingFunction: emb_fn})

Funkcja osadzająca przyjmuje tekst jako dane wejściowe i zwraca obliczone dane wektorowe.

Uwaga: Początkujący mogą dowiedzieć się o modelach osadzania tekstu z tego samouczka.

Istniejące kolekcje można odwoływać się za pomocą metody .getCollection według nazwy, a także można je usuwać za pomocą metody .deleteCollection.

const collection = await client.getCollection({name: "tizi365"}) // Odwołanie do kolekcji tizi365
await client.deleteCollection({name: "my_collection"}) // Usuń kolekcję

Powszechne funkcje kolekcji

await collection.peek() // Zwraca pierwsze 10 rekordów danych w kolekcji
await collection.count() // Zwraca całkowitą liczbę rekordów danych w kolekcji

Dostosowanie metod obliczania odległości wektorowej

createCollection zawiera również opcjonalny parametr metadata, gdzie wartość hnsw:space można ustawić, aby dostosować metodę obliczania odległości dla przestrzeni wektorowej.

Uwaga: Dane wektorowe reprezentują podobieństwo między wektorami poprzez obliczanie odległości przestrzennej między nimi, gdzie bliższe odległości oznaczają wyższe podobieństwo, a odwrotnie.

let collection = client.createCollection("collection_name", undefined, metadata={ "hnsw:space": "cosine" })

Poprawne opcje dla hnsw:space to "l2", "ip" lub "cosine". Domyślnie jest to "l2".

Dodawanie danych do kolekcji

Użyj .add aby dodać dane do kolekcji Chroma.

Dodaj dane bez bezpośredniego określania wektorów dokumentu:

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    metadane: [{"rozdział": "3", "wersety": "16"}, {"rozdział": "3", "wersety": "5"}, {"rozdział": "29", "wersety": "11"}, ...],
    dokumenty: ["lorem ipsum...", "dokument2", "dokument3", ...],
})
// Wyjaśnienie parametrów
// ids - wymagane
// wektory - opcjonalne
// metadane - opcjonalne
// dokumenty - opcjonalne

Jeśli Chroma otrzyma listę dokumentów, automatycznie użyje funkcji wbudowanej w kolekcji do obliczania wektorów dla dokumentów (jeśli nie określono funkcji wbudowanej podczas tworzenia kolekcji, zostanie użyta wartość domyślna). Chroma przechowa także same dokumenty. Jeśli dokument jest zbyt duży, aby mógł być użyty z wybranej funkcji wbudowanej, zostanie zgłoszony wyjątek.

Każdy dokument musi mieć unikalne ID (ids). Dodanie tego samego ID dwa razy spowoduje przechowywanie tylko pierwotnej wartości. Opcjonalną listę słowników metadanych (metadane) można dostarczyć dla każdego dokumentu, aby przechowywać dodatkowe informacje do filtrowania danych podczas zapytań.

Alternatywnie, można bezpośrednio dostarczyć listę związanych z dokumentem danych wektorowych, a Chroma użyje dostarczonych danych wektorowych bez automatycznego obliczania wektorów.

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    wektory: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadane: [{"rozdział": "3", "wersety": "16"}, {"rozdział": "3", "wersety": "5"}, {"rozdział": "29", "wersety": "11"}, ...],
    dokumenty: ["lorem ipsum...", "dokument2", "dokument3", ...],
})

Jeśli dostarczone wymiary danych wektorowych (długość) nie zgadzają się z wymiarami kolekcji, zostanie zgłoszony wyjątek.

Można także przechowywać dokumenty w innych miejscach i po prostu dostarczyć dane wektorowe i listę metadanych do Chromy. Można użyć ids do powiązania wektorów z dokumentami przechowywanymi w innych miejscach.

await collection.add({
    ids: ["id1", "id2", "id3", ...],
    wektory: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadane: [{"rozdział": "3", "wersety": "16"}, {"rozdział": "3", "wersety": "5"}, {"rozdział": "29", "wersety": "11"}, ...],
})

Nota: Główną funkcją bazy danych wektorów jest wyszukiwanie semantycznej podobieństwa oparte na danych wektorowych. Aby zmniejszyć rozmiar bazy danych wektorowych i poprawić wydajność, można wybrać przechowywanie danych wektorowych oraz pewnych warunków filtrowalnych atrybutów w bazie danych wektorowej. Inne dane, takie jak treść artykułów, mogą być przechowywane w bazach danych takich jak MYSQL, pod warunkiem że są powiązane za pomocą ID.

Wyszukiwanie danych kolekcji

Metoda .query może być używana do wyszukiwania zbioru danych Chroma na wiele sposobów.

Można wyszukiwać przy użyciu zestawu zapytań o osadzenia (dane wektorowe).

Wskazówka: Aby uzyskać osadzenia zapytania, w rzeczywistych scenariuszach deweloperskich zazwyczaj zapytanie użytkownika jest najpierw obliczane na wektor zapytania za pomocą modelu osadzania tekstu, a następnie ten wektor jest używany do wyszukiwania podobnych treści.

const result = await collection.query({
    queryEmbeddings: [[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],
    nResults: 10,
    where: {"metadata_field": "is_equal_to_this"},
})
// kolejność danych wejściowych
// query_embeddings - opcjonalne
// n_results - wymagane
// where - opcjonalne
// query_texts - opcjonalne

Zapytanie zwróci najlepsze wyniki n_results dla każdego wektora zapytania (osadzenie zapytania) z zachowaniem kolejności. Opcjonalnie można podać słownik filtru where, aby filtrować wyniki na podstawie metadanych związanych z każdym dokumentem. Dodatkowo można podać opcjonalny słownik filtru where_document, aby filtrować wyniki na podstawie treści dokumentu.

Jeśli podane osadzenia zapytań nie są zgodne z wymiarami kolekcji, wystąpi wyjątek. Aby zapewnić spójność wektorów, zaleca się korzystanie z tego samego modelu osadzania tekstu do obliczania wektorów.

Można także wyszukiwać przy użyciu zestawu tekstów zapytań. Chroma najpierw obliczy wektor dla każdego tekstu zapytania, korzystając z funkcji osadzania kolekcji, a następnie wykonaj zapytanie, korzystając z wygenerowanych wektorów tekstowych.

await collection.query({
    nResults: 10, // n_results
    where: {"metadata_field": "is_equal_to_this"}, // where
    queryTexts: ["doc10", "thus spake zarathustra", ...], // query_text
})

Można także użyć .get do wyszukiwania danych z kolekcji po identyfikatorze.

await collection.get({
    ids: ["id1", "id2", "id3", ...], //ids
    where: {"style": "style1"} // where
})

.get obsługuje również filtry where i where_document. Jeśli nie zostanie podane żadne id, zwróci wszystkie dane z kolekcji, które pasują do filtrów where i where_document.

Określanie zwracanych pól

Podczas korzystania z get lub query można użyć parametru include, aby określić pola danych do zwrócenia, w tym dane wektorowe, dokumenty i wszystkie dane w metadanych. Domyślnie Chroma zwraca dokumenty, metadane i odległości wektorowe. Można określić pola do zwrócenia, przekazując tablicę nazw pól do parametru includes w get lub query.

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

collection.query(
    query_embeddings=[[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],
    include=["documents"]
)

Korzystanie z filtrów where

Chroma obsługuje filtrowanie zapytań na podstawie metadanych i treści dokumentu. Filtr where służy do filtrowania metadanych, a filtr where_document służy do filtrowania treści dokumentu. Poniżej wyjaśniamy, jak pisać wyrażenia warunkowe filtru.

Filtrowanie według metadanych

Aby filtrować metadane, dla zapytania należy podać słownik filtru where. Słownik musi mieć następującą strukturę:

{
    "metadata_field": {
        <Operator>: <Value>
    }
}

Filtrowanie metadanych obsługuje następujące operatory:

  • $eq - Równa się (ciąg znaków, liczba całkowita, liczba zmiennoprzecinkowa)
  • $ne - Nie równa się (ciąg znaków, liczba całkowita, liczba zmiennoprzecinkowa)
  • $gt - Większe niż (liczba całkowita, liczba zmiennoprzecinkowa)
  • $gte - Większe niż lub równa (liczba całkowita, liczba zmiennoprzecinkowa)
  • $lt - Mniejsze niż (liczba całkowita, liczba zmiennoprzecinkowa)
  • $lte - Mniejsze niż lub równe (liczba całkowita, liczba zmiennoprzecinkowa)

Użycie operatora $eq jest równoważne z użyciem filtra where.

{
    "metadata_field": "search_string"
}


{
    "metadata_field": {
        "$eq": "search_string"
    }
}

Filtrowanie treści dokumentu

Aby filtrować treść dokumentu, dla zapytania należy podać słownik filtru where_document. Słownik musi mieć następującą strukturę:

{
    "$contains": "search_string"
}

Korzystanie z operatorów logicznych

Możesz również używać operatorów logicznych $and i $or do połączenia wielu filtrów.

Operator $and zwróci wyniki, które pasują do wszystkich filtrów na liście.

{
    "$and": [
        {
            "pole_metadanych": {
                <Operator>: <Wartość>
            }
        },
        {
            "pole_metadanych": {
                <Operator>: <Wartość>
            }
        }
    ]
}

Operator $or zwróci wyniki pasujące do dowolnego warunku filtrowania na liście.

{
    "$or": [
        {
            "pole_metadanych": {
                <Operator>: <Wartość>
            }
        },
        {
            "pole_metadanych": {
                <Operator>: <Wartość>
            }
        }
    ]
}

Aktualizowanie danych

Chroma obsługuje również operację upsert, która może aktualizować istniejące dane i dodawać nowe dane, jeśli dane nie istnieją.

await collection.upsert({
    ids: ["id1", "id2", "id3"],
    embeddings: [[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2]],
    metadane: [{"rozdział": "3", "wers": "16"}, {"rozdział": "3", "wers": "5"}, {"rozdział": "29", "wers": "11"}],
    dokumenty: ["dok1", "dok2", "dok3"]
})

Usuwanie danych

Chroma obsługuje usunięcie danych z kolekcji za pomocą funkcji .delete.

await collection.delete({
    ids: ["id1", "id2", "id3",...], //ids
    where: {"rozdział": "20"} //where
})