向量化（向量数据库）

const index = hubVectorize("<index>")

const vectorsToInsert = [
  { id: "123", values: [32.4, 6.5, 11.2, 10.3, 87.9] },
  { id: "456", values: [2.5, 7.8, 9.1, 76.9, 8.5] },
];
const inserted = await index.insert(vectorsToInsert);

const vectorsToUpsert = [
  { id: "123", values: [32.4, 6.5, 11.2, 10.3, 87.9] },
  { id: "456", values: [2.5, 7.8, 9.1, 76.9, 8.5] },
  { id: "768", values: [29.1, 5.7, 12.9, 15.4, 1.1] },
];
const upserted = await index.upsert(vectorsToUpsert);

const queryVector = [32.4, 6.55, 11.2, 10.3, 87.9];
const matches = await index.query(queryVector);

console.log(matches)
/*
{
    "count": 5,
    "matches": [
        { "score": 0.999909486, "id": "5" },
        { "score": 0.789848214, "id": "4" },
        { "score": 0.720476967, "id": "1234" },
        { "score": 0.463884663, "id": "6" },
        { "score": 0.378282232, "id": "1" }
    ]
}
*/

const matches = await index.query(queryVector, {
  topK: 5,
  returnValues: true,
  returnMetadata: "all",
});

const ids = ["11", "22", "33", "44"];
const vectors = await index.getByIds(ids);

const idsToDelete = ["11", "22", "33", "44"];
const deleted = await index.deleteByIds(idsToDelete);

const details = await index.describe();

const vectorExample = {
    id: "12345",
    values: [32.4, 6.55, 11.2, 10.3, 87.9],
    metadata: {
        key: "value",
        hello: "world",
        url: "r2://bucket/some/object.json",
    },
};

{ id: '1', values: [32.4, 74.1, 3.2, ...], metadata: { path: 'r2://bucket-name/path/to/image.png', format: 'png', category: 'profile_image' } }

{ "streaming_platform": "netflix" }

{ "someKey": { "$ne": true } }

{ "pandas.nice": 42, "someKey": { "$ne": true } }

{ "pandas.nice": 42 }

// looks for { "pandas": { "nice": 42 } }

const index = hubVectorize("tutorial")

const newMetadataVectors: Array<VectorizeVector> = [
    {
        id: "1",
        values: [32.4, 74.1, 3.2, ...],
        metadata: { url: "/products/sku/13913913", streaming_platform: "netflix" },
    },
    {
        id: "2",
        values: [15.1, 19.2, 15.8, ...],
        metadata: { url: "/products/sku/10148191", streaming_platform: "hbo" },
    },
    {
        id: "3",
        values: [0.16, 1.2, 3.8, ...],
        metadata: { url: "/products/sku/97913813", streaming_platform: "amazon" },
    },
    {
        id: "4",
        values: [75.1, 67.1, 29.9, ...],
        metadata: { url: "/products/sku/418313", streaming_platform: "netflix" },
    },
    {
        id: "5",
        values: [58.8, 6.7, 3.4, ...],
        metadata: { url: "/products/sku/55519183", streaming_platform: "hbo" },
    },
];

// Upsert vectors with added metadata, returning a count of the vectors upserted and their vector IDs
const upserted = await index.upsert(newMetadataVectors);

const queryVector: Array<number> = [54.8, 5.5, 3.1, ...];
const originalMatches = await index.query(queryVector, {
    topK: 3,
    returnValues: true,
    returnMetadata: 'all',
});

{
    "matches": [
        {
            "id": "5",
            "score": 0.999909486,
            "values": [58.79999923706055, 6.699999809265137, 3.4000000953674316],
            "metadata": {
                "url": "/products/sku/55519183",
                "streaming_platform": "hbo"
            }
        },
        {
            "id": "4",
            "score": 0.789848214,
            "values": [75.0999984741211, 67.0999984741211, 29.899999618530273],
            "metadata": {
                "url": "/products/sku/418313",
                "streaming_platform": "netflix"
            }
        },
        {
            "id": "2",
            "score": 0.611976262,
            "values": [15.100000381469727, 19.200000762939453, 15.800000190734863],
            "metadata": {
                "url": "/products/sku/10148191",
                "streaming_platform": "hbo"
            }
        }
    ]
}

const queryVector: Array<number> = [54.8, 5.5, 3.1, ...];
const metadataMatches = await index.query(queryVector, {
    topK: 3,
    filter: { streaming_platform: "netflix" },
    returnValues: true,
    returnMetadata: 'all',
});

{
    "matches": [
        {
            "id": "4",
            "score": 0.789848214,
            "values": [75.0999984741211, 67.0999984741211, 29.899999618530273],
            "metadata": {
                "url": "/products/sku/418313",
                "streaming_platform": "netflix"
            }
        },
        {
            "id": "1",
            "score": 0.491185264,
            "values": [32.400001525878906, 74.0999984741211, 3.200000047683716],
            "metadata": {
                "url": "/products/sku/13913913",
                "streaming_platform": "netflix"
            }
        }
    ]
}

// Mock vectors
// Vectors from a machine-learning model are typically ~100 to 1536 dimensions
// wide (or wider still).
const sampleVectors: Array<VectorizeVector> = [
    {
        id: "1",
        values: [32.4, 74.1, 3.2, ...],
        namespace: "text",
    },
    {
        id: "2",
        values: [15.1, 19.2, 15.8, ...],
        namespace: "images",
    },
    {
        id: "3",
        values: [0.16, 1.2, 3.8, ...],
        namespace: "pdfs",
    },
];

// Insert your vectors, returning a count of the vectors inserted and their vector IDs.
const inserted = await index.insert(sampleVectors);

// Your queryVector will be searched against vectors within the namespace (only)
const matches = await index.query(queryVector, {
    namespace: "images",
});

interface VectorizeVector {
  /** The ID for the vector. This can be user-defined, and must be unique. It should uniquely identify the object, and is best set based on the ID of what the vector represents. */
  id: string;
  /** The vector values */
  values: VectorFloatArray | number[];
  /** The namespace this vector belongs to. */
  namespace?: string;
  /** Metadata associated with the vector. Includes the values of other fields and potentially additional details. */
  metadata?: Record<string, VectorizeVectorMetadata>;
}

interface VectorizeMatches {
  matches: VectorizeMatch[];
  count: number;
}

type VectorizeMatch = Pick<Partial<VectorizeVector>, "values"> &
  Omit<VectorizeVector, "values"> & {
    /** The score or rank for similarity, when returned as a result */
    score: number;
  };

interface VectorizeAsyncMutation {
  /** The unique identifier for the async mutation operation containing the changeset. */
  mutationId: string;
}

interface VectorizeIndexInfo {
  /** The number of records containing vectors within the index. */
  vectorsCount: number;
  /** Number of dimensions the index has been configured for. */
  dimensions: number;
  /** ISO 8601 datetime of the last processed mutation on in the index. All changes before this mutation will be reflected in the index state. */
  processedUpToDatetime: number;
  /** UUIDv4 of the last mutation processed by the index. All changes before this mutation will be reflected in the index state. */
  processedUpToMutation: number;
}