创建对象

此页面上的示例演示了如何在 Weaviate 中创建单个对象。

使用批量导入多个对象

对于一次创建多个对象，请参阅 操作指南：批量导入。

创建对象

此示例在 JeopardyQuestion 集合中创建对象。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")

uuid = jeopardy.data.insert({
    "question": "This vector DB is OSS & supports automatic property type inference on import",
    # "answer": "Weaviate",  # properties can be omitted
    "newProperty": 123,  # will be automatically added as a number property
})

print(uuid)  # the return value is the object's UUID

const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  'question': 'This vector DB is OSS & supports automatic property type inference on import',
  // 'answer': 'Weaviate',  // properties can be omitted
  'newProperty': 123,  // will be automatically added as a number property
})

console.log('UUID: ', uuid)

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	// "answer": "Weaviate", // schema properties can be omitted
  	"newProperty": 123, // will be automatically added as a number property
  }).
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
fmt.Println(string(b))

var jeopardy = client.collections.use("JeopardyQuestion");

var uuid = jeopardy.data.insert(Map.of(
    "question",
    "This vector DB is OSS & supports automatic property type inference on import",
    // "answer": "Weaviate", // properties can be omitted
    "newProperty", 123 // will be automatically added as a number property
)).uuid();

System.out.println(uuid); // the return value is the object's UUID

Result<WeaviateObject> result = client.data().creator()
  .withClassName(className)
  .withProperties(new HashMap<String, Object>() {{
    put("question", "This vector DB is OSS and supports automatic property type inference on import");
    // put("answer", "Weaviate");  // schema properties can be omitted
    put("newProperty", 123); // will be automatically added as a number property
  }})
  .run();

// the returned value is the object
String json = new GsonBuilder().setPrettyPrinting().create().toJson(result.getResult());
System.out.println(json);

var jeopardy = client.Collections.Use("JeopardyQuestion");

var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS & supports automatic property type inference on import",
        // answer = "Weaviate", // properties can be omitted
        newProperty = 123, // will be automatically added as a number property
    }
);

Console.WriteLine(uuid); // the return value is the object's UUID

其他信息

要创建对象，请指定以下内容

• 您要添加的对象数据
• 目标集合
• 如果 多租户 已启用，指定租户

默认情况下，自动模式 会创建新的集合并添加新的属性。

使用指定的向量创建对象

创建对象时，您可以提供一个向量。（对于指定多个命名向量，请参阅 下方。）

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

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

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

jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties={
        "question": "This vector DB is OSS and supports automatic property type inference on import",
        "answer": "Weaviate",
    },
    vector=[0.12345] * 1536
)

print(uuid)  # the return value is the object's UUID

const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  properties: {
  'question': 'This vector DB is OSS & supports automatic property type inference on import',
  // 'answer': 'Weaviate',  // properties can be omitted
  'newProperty': 123,  // will be automatically added as a number property
  },
  vectors: Array(1536).fill(0.12345)
})

console.log('UUID: ', uuid)

vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithVector(vector).
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithId END
require.NoError(t, err)
fmt.Println(string(b))
// CreateObjectWithId END
})

t.Run("create object with id and vector", func(t *testing.T) {
// CreateObjectWithId START
vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithID("12345678-e64f-5d94-90db-c8cfa3fc1234").
  Do(ctx)

// CreateObjectWithId END

require.NoError(t, err)

// CreateObjectWithId START
// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithId END
require.NoError(t, err)
// CreateObjectWithId START
fmt.Println(string(b))
// CreateObjectWithId END
})

t.Run("create object with deterministic id", func(t *testing.T) {
// CreateObjectWithDeterministicIdTODO START
properties := map[string]interface{}{
  "question": "This vector DB is OSS and supports automatic property type inference on import",
  "answer":   "Weaviate",
}

// String id = "gen_uuid5(properties)"; // TODO implement
id := "17f91943-1a5e-46d3-9323-a1cdb735591c"

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(properties).
  WithID(id).
  Do(ctx)

// CreateObjectWithDeterministicIdTODO END

require.NoError(t, err)

// CreateObjectWithDeterministicIdTODO START
// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
// CreateObjectWithDeterministicIdTODO END
require.NoError(t, err)
// CreateObjectWithDeterministicIdTODO START
fmt.Println(string(b))
// CreateObjectWithDeterministicIdTODO END
})

t.Run("validate object", func(t *testing.T) {
// ValidateObject START
err := client.Data().Validator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question":                          "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":                            "Weaviate",
  	"thisPropShouldNotEndUpInTheSchema": -1,
  }).
  WithID("12345678-1234-1234-1234-123456789012").
  Do(ctx)

// ValidateObject END

require.Error(t, err)

// ValidateObject START
assert.ErrorContains(t, err, "invalid object: no such prop with name 'thisPropShouldNotEndUpInTheSchema' found")
// ValidateObject END
})
}

var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(Map.of("question",
    "This vector DB is OSS and supports automatic property type inference on import",
    "answer", "Weaviate"),
    meta -> meta.vectors(Vectors.of(new float[384])) // Using a zero vector for demonstration
).uuid();

System.out.println(uuid); // the return value is the object's UUID

Result<WeaviateObject> result = client.data().creator()
  .withClassName(className)
  .withProperties(new HashMap<String, Object>() {{
    put("question", "This vector DB is OSS and supports automatic property type inference on import");
    put("answer", "Weaviate");
  }})
  .withVector(Collections.nCopies(1536, 0.12345f).toArray(new Float[0]))
  .run();

// the returned value is the object
String json = new GsonBuilder().setPrettyPrinting().create().toJson(result.getResult());
System.out.println(json);

var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS and supports automatic property type inference on import",
        answer = "Weaviate",
    },
    vectors: new float[300] // Using a zero vector for demonstration
);

Console.WriteLine(uuid); // the return value is the object's UUID

使用命名向量创建对象

新增于 v1.24

创建对象时，您可以指定命名向量（如果 在您的集合中配置）。

PythonJavaScript/TypeScriptJava v6C#

  API 文档

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

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

reviews = client.collections.use("WineReviewNV")  # This collection must have named vectors configured
uuid = reviews.data.insert(
    properties={
        "title": "A delicious Riesling",
        "review_body": "This wine is a delicious Riesling which pairs well with seafood.",
        "country": "Germany",
    },
    # Specify the named vectors, following the collection definition
    vector={
        "title": [0.12345] * 1536,
        "review_body": [0.31313] * 1536,
        "title_country": [0.05050] * 1536,
    }
)

print(uuid)  # the return value is the object's UUID

const reviews = client.collections.use('WineReviewNV')

uuid = await reviews.data.insert({
  properties: {
    'title': 'A delicious Riesling',
    'review_body': 'This wine is a delicious Riesling which pairs well with seafood.',
    'country': 'Germany',
  },
  vectors: {
    title: Array(1536).fill(0.12345),
    review_body: Array(1536).fill(0.31313),
    title_country: Array(1536).fill(0.05050),
  }
})

console.log('UUID: ', uuid)

var reviews = client.collections.use("WineReviewNV"); // This collection must have named vectors configured
var uuid = reviews.data.insert(
    Map.of("title", "A delicious Riesling", "review_body",
        "This wine is a delicious Riesling which pairs well with seafood.",
        "country", "Germany"),
    // Specify the named vectors, following the collection definition
    meta -> meta.vectors(Vectors.of("title", new float[1536]),
        Vectors.of("review_body", new float[1536]),
        Vectors.of("title_country", new float[1536]))
).uuid();

System.out.println(uuid); // the return value is the object's UUID

var reviews = client.Collections.Use("WineReviewNV"); // This collection must have named vectors configured
var uuid = await reviews.Data.Insert(
    new
    {
        title = "A delicious Riesling",
        review_body = "This wine is a delicious Riesling which pairs well with seafood.",
        country = "Germany",
    },
    // Specify the named vectors, following the collection definition
    vectors: new Vectors
    {
        { "title", new float[1536] },
        { "review_body", new float[1536] },
        { "title_country", new float[1536] },
    }
);

Console.WriteLine(uuid); // the return value is the object's UUID

使用指定的 ID 创建对象

创建对象时，您可以指定一个 ID。

信息

如果未提供 ID，Weaviate 将生成一个随机 UUID。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

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

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

properties = {
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer": "Weaviate",
}
jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties=properties,
    uuid="12345678-e64f-5d94-90db-c8cfa3fc1234"
)

print(uuid)  # the return value is the object's UUID

const jeopardy = client.collections.use('JeopardyQuestion')

uuid = await jeopardy.data.insert({
  properties: {
    'question': 'This vector DB is OSS and supports automatic property type inference on import',
    'answer': 'Weaviate',
  },
  id: '12345678-e64f-5d94-90db-c8cfa3fc1234'
})

console.log('UUID: ', uuid)

vector := make([]float32, 1536)
for i := 0; i < len(vector); i++ {
  vector[i] = 0.12345
}

w, err := client.Data().Creator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question": "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":   "Weaviate",
  }).
  WithID("12345678-e64f-5d94-90db-c8cfa3fc1234").
  Do(ctx)

// the returned value is a wrapped object
b, err := json.MarshalIndent(w.Object, "", "  ")
fmt.Println(string(b))

Map<String, Object> properties = new HashMap<>();
properties.put("question",
    "This vector DB is OSS and supports automatic property type inference on import");
properties.put("answer", "Weaviate");

var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(properties,
    meta -> meta.uuid("12345678-e64f-5d94-90db-c8cfa3fc1234")
).uuid();

System.out.println(uuid); // the return value is the object's UUID

Result<WeaviateObject> result = client.data().creator()
  .withClassName(className)
  .withProperties(new HashMap<String, Object>() {{
    put("question", "This vector DB is OSS and supports automatic property type inference on import");
    put("answer", "Weaviate");
  }})
  .withID("12345678-e64f-5d94-90db-c8cfa3fc1234")
  .run();

// the returned value is the object
String json = new GsonBuilder().setPrettyPrinting().create().toJson(result.getResult());
System.out.println(json);

var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    new
    {
        question = "This vector DB is OSS and supports automatic property type inference on import",
        answer = "Weaviate",
    },
    uuid: Guid.Parse("12345678-e64f-5d94-90db-c8cfa3fc1234")
);

Console.WriteLine(uuid); // the return value is the object's UUID

生成确定性 ID

您可以根据您的数据对象生成一个 ID。

信息

对象 ID 不是随机生成的。相同的值始终生成相同的 ID。
如果您提供重复的 ID，Weaviate 会抛出错误。使用确定性 ID 以避免插入重复对象。

PythonJavaScript/TypeScriptGoJava v6C#

  API 文档

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

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

from weaviate.util import generate_uuid5  # Generate a deterministic ID

data_object = {
    "question": "This vector DB is OSS and supports automatic property type inference on import",
    "answer": "Weaviate",
}

jeopardy = client.collections.use("JeopardyQuestion")
uuid = jeopardy.data.insert(
    properties=data_object,
    uuid=generate_uuid5(data_object),
)

import { generateUuid5 } from 'weaviate-client';
const jeopardy = client.collections.use('JeopardyQuestion')

const dataObject = {
  'question': 'This vector DB is OSS and supports automatic property type inference on import',
  'answer': 'Weaviate',
}

const newUuid = generateUuid5('Article', JSON.stringify(dataObject)) // use the whole object to generate a uuid
uuid = await jeopardy.data.insert({
  properties: dataObject,
  id: newUuid
  // id: generateUuid5(dataObject.answer)                  // use a specific property to generate a uuid
})

console.log('UUID: ', uuid)

// This feature is under development

// In Java, you can generate a deterministic UUID from a string or bytes.
// This helper function uses UUID.nameUUIDFromBytes for this purpose.

Map<String, Object> dataObject = new HashMap<>();
dataObject.put("question",
    "This vector DB is OSS and supports automatic property type inference on import");
dataObject.put("answer", "Weaviate");

var jeopardy = client.collections.use("JeopardyQuestion");
var uuid = jeopardy.data.insert(dataObject,
    meta -> meta.uuid(generateUuid5(dataObject.toString()).toString())
).uuid();

// In C#, you can generate a deterministic UUID from a string or bytes.
// This helper function creates a UUID v5 for this purpose.

var dataObject = new
{
    question = "This vector DB is OSS and supports automatic property type inference on import",
    answer = "Weaviate",
};
var dataObjectString = JsonSerializer.Serialize(dataObject);

var jeopardy = client.Collections.Use("JeopardyQuestion");
var uuid = await jeopardy.Data.Insert(
    dataObject,
    uuid: GenerateUuid5(dataObjectString)
);

其他信息

要生成确定性 ID，请使用以下方法之一

• generate_uuid5 (Python)
• generateUuid5 (TypeScript)

使用交叉引用创建对象

交叉引用和查询性能

涉及交叉引用的查询可能比不涉及交叉引用的查询慢，尤其是在大规模情况下，例如对于多个对象或复杂查询。

首先，我们强烈建议您考虑是否可以避免在数据模式中使用交叉引用。作为可扩展的 AI 数据库，Weaviate 擅长使用向量、关键词和混合搜索进行复杂查询，包括过滤器。您可以通过重新思考数据模式来避免交叉引用，从而受益匪浅。

例如，与其创建带有交叉引用的单独的“作者”和“书籍”集合，不如考虑将作者信息直接嵌入到书籍对象中，并使用搜索和过滤器按作者特征查找书籍。

您可以创建具有指向其他对象的交叉引用的对象。

PythonJavaScript/TypeScriptJava v6C#

  API 文档

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

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

questions = client.collections.use("JeopardyQuestion")

questions.data.insert(
    properties=properties,  # A dictionary with the properties of the object
    uuid=obj_uuid,  # The UUID of the object
    references={"hasCategory": category_uuid},  # e.g. {"hasCategory": "583876f3-e293-5b5b-9839-03f455f14575"}
)

const category = client.collections.use('JeopardyCategory')

const dataObject = {'name': 'Science'}

const response = await category.data.insert({
  properties: dataObject,
  references: {
    'hasCategory': categoryId  // e.g. {'hasCategory': '583876f3-e293-5b5b-9839-03f455f14575'}
  }
})

console.log('UUID: ', response)

var questions = client.collections.use("JeopardyQuestion");

var result = questions.data.insert(properties, // A map with the properties of the object
    opt -> opt
        .reference("hasCategory", ObjectReference.uuids(categoryUuid)) // e.g. {"hasCategory":
// "583876f3-e293-5b5b-9839-03f455f14575"}
);

更多信息

有关使用交叉引用的更多信息，请参阅 操作指南：交叉引用。

使用 geoCoordinates 创建对象

限制

当前，地理坐标过滤仅限于从源位置的最近 800 个结果，这些结果将进一步减少任何其他过滤器条件和搜索参数。

如果您计划使用密集数据集，请考虑使用另一种策略，例如将地理哈希转换为 text 数据类型，并进一步过滤，例如使用 ContainsAny 过滤器。

如果您想提供一个 geoCoordinates 属性，您需要指定 latitude 和 longitude 作为浮点十进制度数

PythonJavaScript/TypeScriptGoJava v5 (已弃用)Java v6C#

  API 文档

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

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

publications = client.collections.use("Publication")

publications.data.insert(
    properties={
        "headquartersGeoLocation": {
            "latitude": 52.3932696,
            "longitude": 4.8374263
        }
    },
)

const publication = client.collections.use('Publication')

uuid = await publication.data.insert({
  properties: {
    name: 'Elsevier',
    headquartersGeoLocation: {
      'latitude': 52.3932696,
      'longitude': 4.8374263,
    },
  },
  id: 'df48b9f6-ba48-470c-bf6a-57657cb07390'
})

console.log('UUID: ', uuid)

package main

import (
  "context"
  "fmt"

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

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  dataSchema := map[string]interface{}{
    "name": "Elsevier",
    "headquartersGeoLocation": map[string]float32{
      "latitude":  52.3932696,
      "longitude": 4.8374263,
    },
  }

  created, err := client.Data().Creator().
    WithClassName("Publication").
    WithID("df48b9f6-ba48-470c-bf6a-57657cb07390").
    WithProperties(dataSchema).
    Do(context.Background())

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

package io.weaviate;

import java.util.HashMap;
import java.util.Map;
import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.data.model.WeaviateObject;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Map<String, Object> dataSchema = new HashMap<>();
    dataSchema.put("name", "Elsevier");
    dataSchema.put("headquartersGeoLocation", new HashMap() { {
      put("latitude", 52.3932696f);
      put("longitude", 4.8374263f);
    } });

    Result<WeaviateObject> result = client.data().creator()
      .withClassName("Publication")
      .withID("df48b9f6-ba48-470c-bf6a-57657cb07390")
      .withProperties(dataSchema)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

var publications = client.collections.use("Publication");

var uuid = publications.data
    .insert(Map.of("headquartersGeoLocation",
        Map.of("latitude", 52.3932696, "longitude", 4.8374263)))
    .uuid();

var publications = client.Collections.Use("Publication");

var uuid = await publications.Data.Insert(
    new { headquartersGeoLocation = new GeoCoordinate(52.3932696f, 4.8374263f) }
);

在创建之前验证对象

在创建对象之前，您可以根据集合定义对其进行 验证。

PythonJavaScript/TypeScriptGoJava v6Java v5 (已弃用)C#

  API 文档

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

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

# Validate is currently not supported with the Weaviate Python client v4

// Validate is currently not supported with the Weaviate TypeScript client v3

err := client.Data().Validator().
  WithClassName("JeopardyQuestion").
  WithProperties(map[string]interface{}{
  	"question":                          "This vector DB is OSS and supports automatic property type inference on import",
  	"answer":                            "Weaviate",
  	"thisPropShouldNotEndUpInTheSchema": -1,
  }).
  WithID("12345678-1234-1234-1234-123456789012").
  Do(ctx)

assert.ErrorContains(t, err, "invalid object: no such prop with name 'thisPropShouldNotEndUpInTheSchema' found")

  // Coming soon

Result<Boolean> result = client.data()
  .validator()
  .withClassName(className)
  .withProperties(new HashMap<String, Object>() {{
    put("question", "This vector DB is OSS and supports automatic property type inference on import");
    put("answer", "Weaviate");
    put("thisPropShouldNotEndUpInTheSchema", -1);
  }})
  .withID("12345678-1234-1234-1234-123456789012")
  .run();

assertThat(result.getResult()).isFalse();
assertThat(result.hasErrors()).isTrue();
assertThat(result.getError().getMessages().get(0).getMessage())
  .contains("invalid object: no such prop with name 'thisPropShouldNotEndUpInTheSchema' found");

    // Coming soon

多个向量嵌入（命名向量）

于 v1.24.0 中添加

Weaviate 集合支持多个命名向量。

集合可以有多个 命名向量。

集合中的向量可以有自己的配置。每个向量空间可以设置自己的索引、自己的压缩算法和自己的向量化器。这意味着您可以对同一个对象使用不同的向量化模型，并应用不同的距离度量。

要使用命名向量，请调整您的查询以指定 向量搜索 或 混合搜索 查询的目标向量。

相关页面

• 连接到 Weaviate
• 操作指南：(批量)导入项目

• 参考：REST - /v1/objects

问题和反馈

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

技术问题

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

文档反馈

通过打开 GitHub issue 提供反馈。