Uw gegevensmodel definiëren

Microsoft.Extensions.VectorData maakt gebruik van een model-first benadering voor interactie met databases.

Alle methoden voor upsert of het ophalen van records maken gebruik van sterk getypeerde modelklassen. Er zijn twee manieren om het gegevensmodel te definiëren:

• Door eigenschappen op de modelklassen te decoreren met kenmerken die het doel van elke eigenschap aangeven.
• Door uw opslagschema te definiëren met behulp van een recorddefinitie die u afzonderlijk van het gegevensmodel opgeeft. De recorddefinitie is een VectorStoreCollectionDefinition definitie die eigenschappen bevat.

public class Hotel
{
    [VectorStoreKey]
    public ulong HotelId { get; set; }

    [VectorStoreData(IsIndexed = true)]
    public required string HotelName { get; set; }

    [VectorStoreData(IsFullTextIndexed = true)]
    public required string Description { get; set; }

    [VectorStoreVector(Dimensions: 4, DistanceFunction = DistanceFunction.CosineSimilarity, IndexKind = IndexKind.Hnsw)]
    public ReadOnlyMemory<float>? DescriptionEmbedding { get; set; }

    [VectorStoreData(IsIndexed = true)]
    public required string[] Tags { get; set; }
}

VectorStoreCollectionDefinition hotelDefinition = new()
{
    Properties =
    [
        new VectorStoreKeyProperty("HotelId", typeof(ulong)),
        new VectorStoreDataProperty("HotelName", typeof(string)) { IsIndexed = true },
        new VectorStoreDataProperty("Description", typeof(string)) { IsFullTextIndexed = true },
        new VectorStoreVectorProperty("DescriptionEmbedding", typeof(float), dimensions: 4)
        {
            DistanceFunction = DistanceFunction.CosineSimilarity,
            IndexKind = IndexKind.Hnsw
        },
    ]
};

VectorStoreCollection<ulong, Hotel> collection =
    vectorStore.GetCollection<ulong, Hotel>("hotels", hotelDefinition);

Eigenschappen van gegevensmodel

Sleuteleigenschap

Elk gegevensmodel moet een sleuteleigenschap hebben waarmee elke record in de verzameling uniek wordt geïdentificeerd.

[VectorStoreKey]
public ulong HotelId { get; set; }

new VectorStoreKeyProperty("HotelId", typeof(ulong)),

Gegevenseigenschap

Gegevenseigenschappen bevatten inhoud voor algemeen gebruik, zoals tekst, tags of andere metagegevens die worden opgehaald bij het zoeken naar records, en kunnen eventueel ook worden geïndexeerd voor filteren.

[VectorStoreData(IsIndexed = true)]
public required string HotelName { get; set; }

new VectorStoreDataProperty("HotelName", typeof(string)) { IsIndexed = true },
new VectorStoreDataProperty("Description", typeof(string)) { IsFullTextIndexed = true },

Vectoreigenschap

Vectoreigenschappen bevatten de insluitvectors die worden gebruikt voor overeenkomsten zoeken; in geavanceerde scenario's kan een gegevensmodel meerdere vectoreigenschappen hebben om het zoeken over verschillende aspecten van de record te ondersteunen.

[VectorStoreVector(Dimensions: 4, DistanceFunction = DistanceFunction.CosineSimilarity, IndexKind = IndexKind.Hnsw)]
public ReadOnlyMemory<float>? DescriptionEmbedding { get; set; }

[VectorStoreVector(Dimensions: 4, DistanceFunction = DistanceFunction.CosineSimilarity, IndexKind = IndexKind.Hnsw)]
public string DescriptionEmbedding { get; set; }

new VectorStoreVectorProperty("DescriptionEmbedding", typeof(float), dimensions: 4)

Algemene indextypen en functietypen voor afstand worden geleverd als statische waarden voor de IndexKind en DistanceFunction klassen. Implementaties van afzonderlijke vectoropslag kunnen ook hun eigen indextypen en afstandsfuncties gebruiken, waarbij de database ongebruikelijke typen ondersteunt.

Vectoreigenschappen en het genereren van insluiten

Vectordatabases gaan allemaal over het opslaan van insluitingen ( of numerieke representaties van uw gegevens) die worden gegenereerd door een insluitmodel. Bij het opslaan of zoeken van gegevens moet het genereren van insluiten eerst worden uitgevoerd om de doorzoekbare gegevens te converteren naar dergelijke insluitingen. MEVD biedt twee benaderingen voor het insluiten van generatie: handmatig en automatisch.

Handmatige generatie van insluiten op laag niveau

U kunt de vectoreigenschap definiëren als float[] of ReadOnlyMemory<float>, die het insluiten rechtstreeks vertegenwoordigt, en zelf insluitingen genereren vóór elke bewerking:

[VectorStoreVector(Dimensions: 1536)]
public ReadOnlyMemory<float>? DescriptionEmbedding { get; set; }

Tijdens het zoeken genereert u de insluiting voor de querytekst en geeft u deze door aan SearchAsync:

ReadOnlyMemory<float> searchEmbedding =
    (await embeddingGenerator.GenerateAsync("Find a happy hotel")).Vector;

var searchResult = collection.SearchAsync(searchEmbedding, top: 3);

Hoewel dit werkt, moet u het genereren van insluitingen op elke oproepsite beheren.

Automatisch genereren van insluiten (aanbevolen)

De aanbevolen methode is om een IEmbeddingGenerator<TInput,TEmbedding> vectorarchief te configureren. Hiermee kunt u de vectoreigenschap definiëren met behulp van het brontype (bijvoorbeeld string) in plaats van float[] of ReadOnlyMemory<float>. MEVD verwerkt vervolgens het automatisch genereren van insluiten tijdens upsert- en zoekbewerkingen.

Definieer eerst de vectoreigenschap als string:

[VectorStoreVector(Dimensions: 1536)]
public string DescriptionEmbedding { get; set; }

Configureer vervolgens een generator voor insluiten bij het maken van uw vectorarchief:

VectorStore vectorStore = new QdrantVectorStore(
    new QdrantClient("localhost"),
    ownsClient: true,
    new QdrantVectorStoreOptions
    {
        EmbeddingGenerator = embeddingGenerator
    });

U kunt nu tekst rechtstreeks doorgeven - MEVD genereert insluitingen onder de schermen:

// Search with a plain text query - embedding is generated automatically.
var searchResult = collection.SearchAsync("Find a happy hotel", top: 3);

Insluitgeneratoren kunnen ook worden geconfigureerd op het niveau van verzameling, recorddefinitie of afzonderlijke vectoreigenschap. Verschillende insluitmodellen ondersteunen verschillende vectorgrootten; Zorg ervoor dat de Dimensions waarde overeenkomt met het model dat u hebt geconfigureerd. Zie Embeddings in .NET voor meer informatie over het insluiten van generatoren en de Microsoft.Extensions.AI abstracties.

Dynamische toewijzing aan een .NET Woordenlijst

Er zijn gevallen waarin het niet wenselijk of mogelijk is om een sterk getypt .NET type toe te wijzen aan de database. Stel dat u tijdens het compileren niet weet hoe uw databaseschema eruitziet en dat het schema alleen via de configuratie wordt opgegeven. Het maken van een .NET type dat het schema weerspiegelt, is in dit geval onmogelijk. In plaats daarvan kunt u dynamisch toewijzen met behulp van een Dictionary<string, object?> recordtype. Eigenschappen worden toegevoegd aan de Dictionary with-sleutel als de eigenschapsnaam en de waarde als de eigenschapswaarde.

Schemagegevens opgeven bij gebruik Dictionary

Wanneer u een Dictionarydatabase gebruikt, moeten providers nog steeds weten hoe het databaseschema eruitziet. Zonder de schemagegevens kan de provider geen verzameling maken of weten hoe deze kan worden toegewezen aan en van de opslagweergave die door elke database wordt gebruikt.

U kunt een recorddefinitie gebruiken om de schemagegevens op te geven. In tegenstelling tot een gegevensmodel kan tijdens runtime een recorddefinitie worden gemaakt op basis van configuratie wanneer schemagegevens niet bekend zijn tijdens het compileren.

Voorbeeld

Als u een provider wilt gebruiken Dictionary , geeft u dit op als uw gegevensmodel wanneer u de verzameling maakt. Geef ook een recorddefinitie op.

VectorStoreCollectionDefinition definition = new()
{
    Properties =
    [
        new VectorStoreKeyProperty("Key", typeof(string)),
        new VectorStoreDataProperty("Term", typeof(string)),
        new VectorStoreDataProperty("Definition", typeof(string)),
        new VectorStoreVectorProperty("DefinitionEmbedding", typeof(ReadOnlyMemory<float>), dimensions: 1536)
    ]
};

// Use GetDynamicCollection instead of the regular GetCollection method
// to get an instance of a collection using Dictionary<string, object?>.
VectorStoreCollection<object, Dictionary<string, object?>> dynamicDataModelCollection =
    vectorStore.GetDynamicCollection("glossary", definition);

// Since schema information is available from the record definition,
// it's possible to create a collection with the right vectors,
// dimensions, indexes, and distance functions.
await dynamicDataModelCollection.EnsureCollectionExistsAsync();

// When retrieving a record from the collection,
// access key, data, and vector values via the dictionary entries.
Dictionary<string, object?>? record = await dynamicDataModelCollection.GetAsync("SK");
Console.WriteLine(record["Definition"]);