使用 Weaviate 的 NVIDIA 嵌入

于 v1.28.5 和 v1.29.0 中添加

Weaviate 与 NVIDIA 的 API 集成使您可以直接从 Weaviate 访问其模型的功能。

配置 Weaviate 向量索引 以使用 NVIDIA 上的嵌入模型，Weaviate 将使用指定的模型和您的 NVIDIA NIM API 密钥为各种操作生成嵌入。此功能称为向量化器。

在 导入时间，Weaviate 生成文本对象嵌入并将它们保存到索引中。对于 向量 和 混合 搜索操作，Weaviate 将文本查询转换为嵌入。

要求

Weaviate 配置

您的 Weaviate 实例必须配置为使用 NVIDIA 向量化器集成 (text2vec-nvidia) 模块。

对于 Weaviate Cloud (WCD) 用户

此集成在 Weaviate Cloud (WCD) 实例上默认启用。

对于自托管用户

• 检查 集群元数据 以验证是否启用了该模块。
• 按照 如何配置模块 指南在 Weaviate 中启用该模块。

API 凭证

您必须向 Weaviate 提供有效的 NVIDIA NIM API 密钥才能进行此集成。请访问 NVIDIA 注册并获取 API 密钥。

使用以下方法之一向 Weaviate 提供 API 密钥

• 设置可供 Weaviate 使用的 NVIDIA_APIKEY 环境变量。
• 在运行时提供 API 密钥，如下所示。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

import weaviate
from weaviate.classes.init import Auth
import os

# Recommended: save sensitive data as environment variables
nvidia_key = os.getenv("NVIDIA_APIKEY")
headers = {
    "X-NVIDIA-Api-Key": nvidia_key,
}

client = weaviate.connect_to_weaviate_cloud(
    cluster_url=weaviate_url,                       # `weaviate_url`: your Weaviate URL
    auth_credentials=Auth.api_key(weaviate_key),      # `weaviate_key`: your Weaviate API key
    headers=headers
)

# Work with Weaviate

client.close()

  .connect_to_weaviate_cloud  .Auth

import weaviate from 'weaviate-client'

const nvidiaApiKey = process.env.NVIDIA_APIKEY || '';  // Replace with your inference API key

const client = await weaviate.connectToWeaviateCloud(
  'WEAVIATE_INSTANCE_URL',  // Replace with your instance URL
  {
    authCredentials: new weaviate.ApiKey('WEAVIATE_INSTANCE_APIKEY'),
    headers: {
      'X-NVIDIA-Api-Key': nvidiaApiKey,
    }
  }
)

// Work with Weaviate

client.close()

  .functions/connectToWeaviateCloud  .classes/ApiKey

// Set these environment variables
// WEAVIATE_HOSTNAME            your Weaviate instance hostname, excluding the scheme (https://)
// WEAVIATE_API_KEY          your Weaviate instance API key
// <PROVIDER>_APIKEY       your model provider API key (or token)

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/weaviate/weaviate-go-client/v5/weaviate"
    "github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
)

func main() {
    cfg := weaviate.Config{
        Host:       os.Getenv("WEAVIATE_HOSTNAME"),
        Scheme:     "https",
        AuthConfig: auth.ApiKey{Value: os.Getenv("WEAVIATE_API_KEY")},
        Headers: map[string]string{
            "X-NVIDIA-Api-Key": os.Getenv("NVIDIA_APIKEY"),
        },
    }

    client, err := weaviate.NewClient(cfg)
    if err != nil {
        fmt.Println(err)
    }

    // Work with Weaviate
}

配置向量化器

配置 Weaviate 索引 以使用 NVIDIA 嵌入模型，如下所示

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

from weaviate.classes.config import Configure

client.collections.create(
    "DemoCollection",
    vector_config=[
        Configure.Vectors.text2vec_nvidia(
            name="title_vector",
            source_properties=["title"],
        )
    ],
    # Additional parameters not shown
)

await client.collections.create({
  name: 'DemoCollection',
  vectorizers: [
    weaviate.configure.vectors.text2VecNvidia({
      name: 'title_vector',
      sourceProperties: ['title'],
    })
  ],
  // Additional parameters not shown
})

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    // Define the collection
    basicNVIDIAVectorizerDef := &models.Class{
        Class: "DemoCollection",
        VectorConfig: map[string]models.VectorConfig{
            "title_vector": {
                Vectorizer: map[string]interface{}{
                    "text2vec-nvidia": map[string]interface{}{
                        "properties": []string{"title"},
                    },
                },
            },
        },
    }

    // add the collection
    err = client.Schema().ClassCreator().WithClass(basicNVIDIAVectorizerDef).Do(ctx)
    if err != nil {
        panic(err)
    }
}

选择一个模型

您可以为向量化器指定一个 可用模型，如以下配置示例所示。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

from weaviate.classes.config import Configure

client.collections.create(
    "DemoCollection",
    vector_config=[
        Configure.Vectors.text2vec_nvidia(
            name="title_vector",
            source_properties=["title"],
            model="nvidia/nv-embed-v1"
        )
    ],
    # Additional parameters not shown
)

await client.collections.create({
  name: 'DemoCollection',
  vectorizers: [
    weaviate.configure.vectors.text2VecNvidia({
      name: 'title_vector',
      sourceProperties: ['title'],
      model: "nvidia/nv-embed-v1"
    })
  ],
  // Additional parameters not shown
})

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    // Define the collection
    nvidiaVectorizerWithModelDef := &models.Class{
        Class: "DemoCollection",
        VectorConfig: map[string]models.VectorConfig{
            "title_vector": {
                Vectorizer: map[string]interface{}{
                    "text2vec-nvidia": map[string]interface{}{
                        "properties": []string{"title"},
                        "model":      "nvidia/nv-embed-v1",
                    },
                },
            },
        },
    }

    // add the collection
    err = client.Schema().ClassCreator().WithClass(nvidiaVectorizerWithModelDef).Do(ctx)
    if err != nil {
        panic(err)
    }
}

您可以 指定 Weaviate 使用的 可用模型。如果没有指定模型，则使用 默认模型。

向量化行为

Weaviate 遵循集合配置和一组预定义的规则来向量化对象。

除非在集合定义中另有说明，否则默认行为是

• 仅向量化使用 text 或 text[] 数据类型的属性（除非 跳过）
• 在连接值之前，按字母顺序 (a-z) 对属性进行排序
• 如果 vectorizePropertyName 为 true (默认值为 false)，则将属性名称前缀添加到每个属性值
• 用空格连接（前缀）属性值
• 前缀类名（除非 vectorizeClassName 为 false）
• 将生成的字符串转换为小写

向量化器参数

以下示例演示如何配置 NVIDIA 特定的选项。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

from weaviate.classes.config import Configure

client.collections.create(
    "DemoCollection",
    vector_config=[
        Configure.Vectors.text2vec_nvidia(
            name="title_vector",
            source_properties=["title"],
            model="nvidia/nv-embed-v1",
            base_url="https://integrate.api.nvidia.com/v1",
        )
    ],
    # Additional parameters not shown
)

await client.collections.create({
  name: 'DemoCollection',
  vectorizers: [
    weaviate.configure.vectors.text2VecNvidia({
      name: 'title_vector',
      sourceProperties: ['title'],
      model: "nvidia/nv-embed-v1",
      baseURL: "https://integrate.api.nvidia.com/v1"
    })
  ],
  // Additional parameters not shown
})

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    // Define the collection
    nvidiaVectorizerFullDef := &models.Class{
        Class: "DemoCollection",
        VectorConfig: map[string]models.VectorConfig{
            "title_vector": {
                Vectorizer: map[string]interface{}{
                    "text2vec-nvidia": map[string]interface{}{
                        "properties": []string{"title"},
                        // "model":            "nvidia/nv-embed-v1",
                    },
                },
            },
        },
    }

    // add the collection
    err = client.Schema().ClassCreator().WithClass(nvidiaVectorizerFullDef).Do(ctx)
    if err != nil {
        panic(err)
    }
}

有关模型参数的更多详细信息，请参阅 NVIDIA NIM API 文档。

数据导入

配置向量化器后，导入数据 到 Weaviate。Weaviate 将使用指定的模型为文本对象生成嵌入。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

source_objects = [
    {"title": "The Shawshank Redemption", "description": "A wrongfully imprisoned man forms an inspiring friendship while finding hope and redemption in the darkest of places."},
    {"title": "The Godfather", "description": "A powerful mafia family struggles to balance loyalty, power, and betrayal in this iconic crime saga."},
    {"title": "The Dark Knight", "description": "Batman faces his greatest challenge as he battles the chaos unleashed by the Joker in Gotham City."},
    {"title": "Jingle All the Way", "description": "A desperate father goes to hilarious lengths to secure the season's hottest toy for his son on Christmas Eve."},
    {"title": "A Christmas Carol", "description": "A miserly old man is transformed after being visited by three ghosts on Christmas Eve in this timeless tale of redemption."}
]

collection = client.collections.use("DemoCollection")

with collection.batch.fixed_size(batch_size=200) as batch:
    for src_obj in source_objects:
        # The model provider integration will automatically vectorize the object
        batch.add_object(
            properties={
                "title": src_obj["title"],
                "description": src_obj["description"],
            },
            # vector=vector  # Optionally provide a pre-obtained vector
        )
        if batch.number_errors > 10:
            print("Batch import stopped due to excessive errors.")
            break

failed_objects = collection.batch.failed_objects
if failed_objects:
    print(f"Number of failed imports: {len(failed_objects)}")
    print(f"First failed object: {failed_objects[0]}")

let srcObjects = [
  { title: "The Shawshank Redemption", description: "A wrongfully imprisoned man forms an inspiring friendship while finding hope and redemption in the darkest of places." },
  { title: "The Godfather", description: "A powerful mafia family struggles to balance loyalty, power, and betrayal in this iconic crime saga." },
  { title: "The Dark Knight", description: "Batman faces his greatest challenge as he battles the chaos unleashed by the Joker in Gotham City." },
  { title: "Jingle All the Way", description: "A desperate father goes to hilarious lengths to secure the season's hottest toy for his son on Christmas Eve." },
  { title: "A Christmas Carol", description: "A miserly old man is transformed after being visited by three ghosts on Christmas Eve in this timeless tale of redemption." }
];

const collectionName = 'DemoCollection'
const myCollection = client.collections.use(collectionName)

let dataObjects = new Array();

for (let srcObject of srcObjects) {
  dataObjects.push({
    title: srcObject.title,
    description: srcObject.description,
  });
}

const response = await myCollection.data.insertMany(dataObjects);

console.log(response);

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    var sourceObjects = []map[string]string{
        {"title": "The Shawshank Redemption", "description": "A wrongfully imprisoned man forms an inspiring friendship while finding hope and redemption in the darkest of places."},
        {"title": "The Godfather", "description": "A powerful mafia family struggles to balance loyalty, power, and betrayal in this iconic crime saga."},
        {"title": "The Dark Knight", "description": "Batman faces his greatest challenge as he battles the chaos unleashed by the Joker in Gotham City."},
        {"title": "Jingle All the Way", "description": "A desperate father goes to hilarious lengths to secure the season's hottest toy for his son on Christmas Eve."},
        {"title": "A Christmas Carol", "description": "A miserly old man is transformed after being visited by three ghosts on Christmas Eve in this timeless tale of redemption."},
    }

    // Convert items into a slice of models.Object
    objects := []models.PropertySchema{}
    for i := range sourceObjects {
        objects = append(objects, map[string]interface{}{
            // Populate the object with the data
            "title":       sourceObjects[i]["title"],
            "description": sourceObjects[i]["description"],
        })
    }

    // Batch write items
    batcher := client.Batch().ObjectsBatcher()
    for _, dataObj := range objects {
        batcher.WithObjects(&models.Object{
            Class:      "DemoCollection",
            Properties: dataObj,
        })
    }

    // Flush
    batchRes, err := batcher.Do(ctx)

    // Error handling
    if err != nil {
        panic(err)
    }
    for _, res := range batchRes {
        if res.Result.Errors != nil {
            for _, err := range res.Result.Errors.Error {
                if err != nil {
                    fmt.Printf("Error details: %v\n", *err)
                    panic(err.Message)
                }
            }
        }
    }
}

重用现有向量

如果您已经有兼容的模型向量可用，您可以将其直接提供给 Weaviate。这在您已经使用相同的模型生成了嵌入并希望在 Weaviate 中使用它们（例如，从另一个系统迁移数据）时很有用。

搜索

配置向量化器后，Weaviate 将使用指定的 NVIDIA 模型执行向量和混合搜索操作。

向量（近文本）搜索

当您执行 向量搜索 时，Weaviate 将文本查询转换为嵌入，使用指定的模型，并返回数据库中最相似的对象。

以下查询返回数据库中 n 个最相似的对象，由 limit 设置。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

collection = client.collections.use("DemoCollection")

response = collection.query.near_text(
    query="A holiday film",  # The model provider integration will automatically vectorize the query
    limit=2
)

for obj in response.objects:
    print(obj.properties["title"])

const collectionName = 'DemoCollection'
const myCollection = client.collections.use(collectionName)

let result;

result = await myCollection.query.nearText(
  'A holiday film',  // The model provider integration will automatically vectorize the query
  {
    limit: 2,
  }
)

console.log(JSON.stringify(result.objects, null, 2));

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    nearTextResponse, err := client.GraphQL().Get().
        WithClassName("DemoCollection").
        WithFields(
            graphql.Field{Name: "title"},
        ).
        WithNearText(client.GraphQL().NearTextArgBuilder().
            WithConcepts([]string{"A holiday film"})).
        WithLimit(2).
        Do(ctx)

    if err != nil {
        panic(err)
    }
    fmt.Printf("%v", nearTextResponse)
}

混合搜索

什么是混合搜索？

混合搜索执行向量搜索和关键字 (BM25) 搜索，然后 组合结果 以返回数据库中最佳匹配的对象。

当您执行 混合搜索 时，Weaviate 将文本查询转换为嵌入，使用指定的模型，并返回数据库中得分最高的对象。

以下查询返回数据库中 n 个得分最高的对象，由 limit 设置。

PythonJavaScript/TypeScriptGo

  API 文档

更多信息文档中的代码片段反映了最新的客户端库和 Weaviate 数据库版本。请查看 发行说明 以获取特定版本。

如果某个片段无法工作或您有任何反馈，请打开一个 GitHub issue。

collection = client.collections.use("DemoCollection")

response = collection.query.hybrid(
    query="A holiday film",  # The model provider integration will automatically vectorize the query
    limit=2
)

for obj in response.objects:
    print(obj.properties["title"])

const collectionName = 'DemoCollection'
const myCollection = client.collections.use(collectionName)

result = await myCollection.query.hybrid(
  'A holiday film',  // The model provider integration will automatically vectorize the query
  {
    limit: 2,
  }
)

console.log(JSON.stringify(result.objects, null, 2));

// package, imports not shown

func main() {
    // Instantiation not shown

    ctx := context.Background()

    hybridResponse, err := client.GraphQL().Get().
        WithClassName("DemoCollection").
        WithFields(
            graphql.Field{Name: "title"},
        ).
        WithHybrid(client.GraphQL().HybridArgumentBuilder().
            WithQuery("A holiday film")).
        WithLimit(2).
        Do(ctx)

    if err != nil {
        panic(err)
    }
    fmt.Printf("%v", hybridResponse)
}

参考

可用模型

您可以使用任何文本嵌入模型 在 NVIDIA NIM API 上 与 Weaviate 一起使用。

默认模型是 nvidia/nv-embed-v1。

更多资源

其他集成

• NVIDIA 多模态嵌入模型 + Weaviate
• NVIDIA 生成模型 + Weaviate
• NVIDIA 排序模型 + Weaviate

代码示例

配置完集成后，Weaviate 中的数据管理和搜索操作与任何其他集合的工作方式相同。请参阅以下非模型特定的示例

• 如何：管理集合 和 如何：管理对象 指南演示如何执行数据操作（即创建、读取、更新、删除集合和其中的对象）。
• 如何：查询和搜索 指南演示如何执行搜索操作（即向量、关键字、混合）以及检索增强生成。

外部资源

• NVIDIA NIM API 文档

问题和反馈

如果您有任何问题或反馈，请在 用户论坛 中告诉我们。

技术问题

如果您有任何问题，请在我们的 社区论坛 上发帖。

文档反馈

通过打开 GitHub issue 提供反馈。