基本集合操作

Weaviate 中的每个对象都属于且仅属于一个集合。使用此页上的示例来管理您的集合。

术语

较新的 Weaviate 文档讨论“集合”。较旧的 Weaviate 文档则使用“类”。您将在整个文档中看到这两个术语。

Python 和 JS/TS 客户端 - 向量化器配置 API 更改

从 Weaviate Python 客户端 v4.16.0 开始，向量化器配置 API 已更新。
从 Weaviate JS/TS 客户端 v3.8.0 开始，向量化器配置 API 已更新。

操作要求：更新到最新客户端版本并迁移您的代码以使用 新的向量化器配置 API。

创建集合

要创建集合，请至少指定集合名称。如果您没有指定任何属性，auto-schema 将创建它们。

大小写

Weaviate 遵循 GraphQL 命名约定。

• 集合名称以大写字母开头。
• 属性名称以小写字母开头。

如果使用大写字母开头来定义属性名称，Weaviate 会在内部将其更改为小写字母。

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

  API 文档

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

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

client.collections.create("Article")

  const newCollection = await client.collections.create({
    name: 'Article'
  })

  // The returned value is the full collection definition, showing all defaults
  console.log(JSON.stringify(newCollection, null, 2));

className := "Article"

  emptyClass := &models.Class{
    Class: className,
  }

  // Create the collection (also called class)
  err := client.Schema().ClassCreator().
    WithClass(emptyClass).
    Do(ctx)

client.collections.create("Article");

String collectionName = "Article";

WeaviateClass emptyClass = WeaviateClass.builder()
    .className(collectionName)
    .build();

// Add the collection to the schema
Result<Boolean> result = client.schema().classCreator()
    .withClass(emptyClass)
    .run();

await client.Collections.Create(new CollectionCreateParams { Name = "Article" });

生产就绪的集合

• 手动定义您的数据模式：避免使用 auto-schema 功能，而是手动 定义集合的属性。
• 避免创建过多的集合：使用过多的集合可能导致可伸缩性问题，例如高内存使用率和查询性能下降。相反，请考虑 使用多租户，其中单个集合被细分为多个租户。有关详细信息，请参阅 入门指南：使用集合的缩放限制。

创建集合并定义属性

属性是集合中的数据字段。每个属性都有一个名称和一个数据类型。

其他信息

使用属性来配置其他参数，例如数据类型、索引特征或分词。

有关详细信息，请参阅

• 参考：配置：Schema

• API 参考：REST：Schema

• 可用数据类型

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

  API 文档

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

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

from weaviate.classes.config import Property, DataType

# Note that you can use `client.collections.create_from_dict()` to create a collection from a v3-client-style JSON object
client.collections.create(
    "Article",
    properties=[
        Property(name="title", data_type=DataType.TEXT),
        Property(name="body", data_type=DataType.TEXT),
    ],
)

import { dataType } from 'weaviate-client';

await client.collections.create({
  name: 'Article',
  properties: [
    {
      name: 'title',
      dataType: dataType.TEXT,
    },
    {
      name: 'body',
      dataType: dataType.TEXT,
    },
  ],
})

  articleClass := &models.Class{
    Class:       "Article",
    Description: "Collection of articles",
    Properties: []*models.Property{
      {
        Name:     "title",
        DataType: schema.DataTypeText.PropString(),
      },
      {
        Name:     "body",
        DataType: schema.DataTypeText.PropString(),
      },
    },
  }

client.collections.create("Article",
    col -> col.properties(Property.text("title"), Property.text("body")));

// Define collection properties
Property titleProperty = Property.builder()
    .name("title")
    .description("Title Property Description...")
    .dataType(Arrays.asList(DataType.TEXT))
    .build();
Property bodyProperty = Property.builder()
    .name("body")
    .description("Body Property Description...")
    .dataType(Arrays.asList(DataType.TEXT))
    .build();

// Add the defined properties to the collection
WeaviateClass articleCollection = WeaviateClass.builder()
    .className(collectionName)
    .description("Article collection Description...")
    .properties(Arrays.asList(titleProperty, bodyProperty))
    .build();

Result<Boolean> result = client.schema().classCreator()
    .withClass(articleCollection)
    .run();

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Article",
        Properties = [Property.Text("title"), Property.Text("body")],
    }
);

或者使用类中的字段

// public class Article
// {
//     public string Title { get; set; }
//     public string Body { get; set; }
// }

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Article",
        Properties = [.. Property.FromClass<Article>()],
    }
);

使用向量化器创建集合

为将在创建对象和执行向量搜索查询时生成向量嵌入的集合指定一个 vectorizer。

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

  API 文档

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

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

from weaviate.classes.config import Configure, Property, DataType

client.collections.create(
    "Article",
    vector_config=Configure.Vectors.text2vec_openai(),
    properties=[
        Property(name="title", data_type=DataType.TEXT),
        Property(name="body", data_type=DataType.TEXT),
    ],
)

import { vectors, dataType } from 'weaviate-client';

await client.collections.create({
  name: 'Article',
  vectorizers: vectors.text2VecOpenAI(),
  properties: [
    { name: 'title', dataType: dataType.TEXT },
    { name: 'body', dataType: dataType.TEXT },
  ],
})

  articleClass := &models.Class{
    Class:       "Article",
    Description: "Collection of articles",
    Vectorizer:  "text2vec-openai",
    Properties: []*models.Property{
      {
        Name:     "title",
        DataType: schema.DataTypeText.PropString(),
      },
      {
        Name:     "body",
        DataType: schema.DataTypeText.PropString(),
      },
    },
  }

client.collections.create("Article",
    col -> col.vectorConfig(VectorConfig.text2vecTransformers())
        .properties(Property.text("title"), Property.text("body")));

// Additional configuration not shown
// Define the vectorizer in the WeaviateClass Builder
WeaviateClass articleCollection = WeaviateClass.builder()
    .className(collectionName)
    .properties(Arrays.asList(titleProperty, bodyProperty))
    .vectorizer("text2vec-openai") // Vectorize of your choic e.g. text2vec-openai or text2vec-cohere
    .build();
// Add the collection to the schema
Result<Boolean> result = client.schema().classCreator()
    .withClass(articleCollection)
    .run();

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Article",
        VectorConfig = new VectorConfigList
        {
            Configure.Vector("default", v => v.Text2VecTransformers()),
        },
        Properties = [Property.Text("title"), Property.Text("body")],
    }
);

向量化器配置

在 管理集合：向量化器和向量索引 中了解有关向量化器和向量索引配置的更多信息。

禁用自动模式

默认情况下，Weaviate 会创建缺失的集合和缺失的属性。当您手动配置集合时，您可以更精确地控制集合设置。

要禁用 auto-schema，请在您的系统配置文件中设置 AUTOSCHEMA_ENABLED: 'false'。

检查集合是否存在

获取一个布尔值，指示给定的集合是否存在。

PythonJavaScript/TypeScriptJava v6C#

  API 文档

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

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

exists = client.collections.exists("Article")  # Returns a boolean

var exists = await client.collections.exists("Article")  // Returns a boolean

client.collections.exists(collectionName);

bool exists = await client.Collections.Exists("Article");

读取单个集合定义

从模式中检索集合定义。

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

  API 文档

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

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

articles = client.collections.use("Article")
articles_config = articles.config.get()

print(articles_config)

let articles = client.collections.use('Article')
const collectionConfig = await articles.config.get()
console.log(collectionConfig)

className := "Article"

  class, err := client.Schema().ClassGetter().
    WithClassName(className).
    Do(ctx)

  b, err := json.MarshalIndent(class, "", "  ")
  fmt.Println(string(b))

CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");
Optional<CollectionConfig> articlesConfig = articles.config.get();

System.out.println(articlesConfig);

String collectionName = "Article";

Result<WeaviateClass> result = client.schema().classGetter()
    .withClassName(collectionName)
    .run();

String json = new GsonBuilder().setPrettyPrinting().create().toJson(result.getResult());
System.out.println(json);

var articles = client.Collections.Use("Article");
var articlesConfig = await articles.Config.Get();

Console.WriteLine(articlesConfig);

示例配置：文本对象

此文本对象配置定义了以下内容

• 集合名称 (Article)
• 向量化器模块 (text2vec-cohere) 和模型 (embed-multilingual-v2.0)
• 一组属性 (title, body) 和 text 数据类型。

{
  "class": "Article",
  "vectorizer": "text2vec-cohere",
  "moduleConfig": {
    "text2vec-cohere": {
      "model": "embed-multilingual-v2.0"
    }
  },
  "properties": [
    {
      "name": "title",
      "dataType": ["text"]
    },
    {
      "name": "body",
      "dataType": ["text"]
    }
  ]
}

示例配置：嵌套对象

在 v1.22 中添加

此嵌套对象配置定义了以下内容

• 集合名称 (Person)

• 向量化器模块 (text2vec-huggingface)

• 一组属性 (last_name, address)

  • last_name 具有 text 数据类型
  • address 具有 object 数据类型

• address 属性有两个嵌套属性 (street 和 city)

{
  "class": "Person",
  "vectorizer": "text2vec-huggingface",
  "properties": [
    {
      "dataType": ["text"],
      "name": "last_name"
    },
    {
      "dataType": ["object"],
      "name": "address",
      "nestedProperties": [
        { "dataType": ["text"], "name": "street" },
        { "dataType": ["text"], "name": "city" }
      ]
    }
  ]
}

示例配置：生成式搜索

此配置用于 检索增强生成，定义了以下内容

• 集合名称 (Article)
• 默认向量化器模块 (text2vec-openai)
• 生成模块 (generative-openai)
• 一组属性 (title, chunk, chunk_no 和 url)
• url 属性的分词选项
• url 属性的向量化选项（跳过向量化）

{
  "class": "Article",
  "vectorizer": "text2vec-openai",
  "vectorIndexConfig": {
    "distance": "cosine"
  },
  "moduleConfig": {
    "generative-openai": {}
  },
  "properties": [
    {
      "name": "title",
      "dataType": ["text"]
    },
    {
      "name": "chunk",
      "dataType": ["text"]
    },
    {
      "name": "chunk_no",
      "dataType": ["int"]
    },
    {
      "name": "url",
      "dataType": ["text"],
      "tokenization": "field",
      "moduleConfig": {
        "text2vec-openai": {
          "skip": true
        }
      }
    }
  ]
}

示例配置：图像

此图像搜索配置定义了以下内容

• 集合名称 (Image)

• 向量化器模块 (img2vec-neural)

  • image 属性配置集合以存储图像数据。

• 向量索引距离度量 (cosine)

• 一组属性 (image)，其中 image 属性设置为 blob。

有关图像搜索，请参阅 图像搜索。

{
  "class": "Image",
  "vectorizer": "img2vec-neural",
  "vectorIndexConfig": {
    "distance": "cosine"
  },
  "moduleConfig": {
    "img2vec-neural": {
      "imageFields": ["image"]
    }
  },
  "properties": [
    {
      "name": "image",
      "dataType": ["blob"]
    }
  ]
}

读取所有集合定义

获取数据库模式以检索所有集合定义。

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

  API 文档

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

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

response = client.collections.list_all(simple=False)

print(response)

const allCollections = await client.collections.listAll()
console.log(JSON.stringify(allCollections, null, 2));

  schema, err := client.Schema().Getter().
    Do(ctx)

  b, err := json.MarshalIndent(schema, "", "  ")
  fmt.Println(string(b))

List<CollectionConfig> response = client.collections.list();

System.out.println(response);

Result<Schema> result = client.schema().getter()
    .run();

String json = new GsonBuilder().setPrettyPrinting().create().toJson(result.getResult());
System.out.println(json);

var response = new List<CollectionConfig>();
await foreach (var collection in client.Collections.List())
{
    response.Add(collection);
    Console.WriteLine(collection);
}

更新集合定义

复制因子更改

集合的复制因子不能通过更新集合的定义来更新。

从 v1.32 版本开始，通过使用 副本移动，可以更改分片的 复制因子。

您可以更新集合定义以更改 可变集合设置。

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

  API 文档

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

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

from weaviate.classes.config import (
    Reconfigure,
    VectorFilterStrategy,
    ReplicationDeletionStrategy,
)

articles = client.collections.use("Article")

# Update the collection definition
articles.config.update(
    description="An updated collection description.",
    property_descriptions={
        "title": "The updated title description for article",
    },  # Available from Weaviate v1.31.0
    inverted_index_config=Reconfigure.inverted_index(bm25_k1=1.5),
    vector_config=Reconfigure.Vectors.update(
        name="default",
        vector_index_config=Reconfigure.VectorIndex.hnsw(
            filter_strategy=VectorFilterStrategy.ACORN  # Available from Weaviate v1.27.0
        ),
    ),
    replication_config=Reconfigure.replication(
        deletion_strategy=ReplicationDeletionStrategy.TIME_BASED_RESOLUTION  # Available from Weaviate v1.28.0
    ),
)
articles = client.collections.use("Article")

article_shards = articles.config.update_shards(
    status="READY",
    shard_names=shard_names,  # The names (List[str]) of the shard to update (or a shard name)
)

print(article_shards)

import { reconfigure } from 'weaviate-client';

let articles = client.collections.use('Article')
await articles.config.update({
  invertedIndex: reconfigure.invertedIndex({
    bm25k1: 1.5 // Change the k1 parameter from 1.2
  }),
  vectorizers: reconfigure.vectors.update({
    vectorIndexConfig: reconfigure.vectorIndex.hnsw({
      quantizer: reconfigure.vectorIndex.quantizer.pq(),
      ef: 4,
      filterStrategy: 'acorn',  // Available from Weaviate v1.27.0
    }),

  })
})

  updatedArticleClassConfig := &models.Class{
    // Note: The new collection config must be provided in full,
    // including the configuration that is not being updated.
    // We suggest using the original class config as a starting point.
    Class: "Article",
    InvertedIndexConfig: &models.InvertedIndexConfig{
      Bm25: &models.BM25Config{
        K1: 1.5,
      },
    },
    VectorIndexConfig: map[string]interface{}{
      "filterStrategy": "acorn",
    },
    ReplicationConfig: &models.ReplicationConfig{
      DeletionStrategy: models.ReplicationConfigDeletionStrategyTimeBasedResolution,
    },
  }

CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");

articles.config.update(col -> col
    .description("An updated collection description.")
    .invertedIndex(idx -> idx.bm25(bm25Builder -> bm25Builder.k1(1.5f))));
CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");

List<Shard> articleShards =
    articles.config.updateShards(ShardStatus.READONLY, shardName);
System.out.println(articleShards);

// Get existing collection
Result<WeaviateClass> existingResult = client.schema().classGetter()
    .withClassName(collectionName)
    .run();

assertThat(existingResult).isNotNull()
    .returns(false, Result::hasErrors);

WeaviateClass existingClass = existingResult.getResult();

// Create updated configurations
InvertedIndexConfig invertedConfig = InvertedIndexConfig.builder()
    .bm25(BM25Config.builder().k1(1.5f).build())
    .build();

VectorIndexConfig vectorConfig = VectorIndexConfig.builder()
    .filterStrategy(VectorIndexConfig.FilterStrategy.ACORN)
    .build();

ReplicationConfig replicationConfig = ReplicationConfig.builder()
    .deletionStrategy(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION)
    .build();

// Update collection with new configurations - preserve critical existing configs
WeaviateClass updatedClass = WeaviateClass.builder()
    .className(collectionName)
    .shardingConfig(existingClass.getShardingConfig())     // Preserve sharding (immutable)
    .invertedIndexConfig(invertedConfig)                   // Update
    .vectorIndexConfig(vectorConfig)                       // Update
    .replicationConfig(replicationConfig)                  // Update
    .build();

Result<Boolean> updateResult = client.schema().classUpdater()
    .withClass(updatedClass)
    .run();

var articles = client.Collections.Use("Article");

await articles.Config.Update(c =>
{
    c.Description = "An updated collection description.";
    c.InvertedIndexConfig.Bm25.K1 = 1.5f;
});
    // Coming soon

删除集合

您可以删除任何不需要的集合，以及它们包含的数据。

删除集合也会删除其对象

当您删除集合时，您会删除所有关联的对象！

在生产数据库和任何其他具有重要数据的地方，请非常小心删除操作。

此代码删除一个集合及其对象。

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

  API 文档

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

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

# collection_name can be a string ("Article") or a list of strings (["Article", "Category"])
client.collections.delete(
    collection_name
)  # THIS WILL DELETE THE SPECIFIED COLLECTION(S) AND THEIR OBJECTS

# Note: you can also delete all collections in the Weaviate instance with:
# client.collections.delete_all()

// delete collection "Article" - THIS WILL DELETE THE COLLECTION AND ALL ITS DATA
await client.collections.delete('Article')

// you can also delete all collections of a cluster
// await client.collections.deleteAll()

className := "YourClassName"

// delete the class
if err := client.Schema().ClassDeleter().WithClassName(className).Do(context.Background()); err != nil {
  // Weaviate will return a 400 if the class does not exist, so this is allowed, only return an error if it's not a 400
  if status, ok := err.(*fault.WeaviateClientError); ok && status.StatusCode != http.StatusBadRequest {
    panic(err)
  }
}

Result<Boolean> result = client.schema().classDeleter()
    .withClassName(collectionName)
    .run();

client.collections.delete(collectionName);

curl \
  -X DELETE \
  https://WEAVIATE_INSTANCE_URL/v1/schema/YourClassName  # Replace WEAVIATE_INSTANCE_URL with your instance URL

await client.Collections.Delete(collectionName);

添加属性

数据导入后的索引限制

在导入数据之前添加集合属性时，没有索引限制。

如果您在导入一些数据后添加新属性，则会对索引产生影响。

属性索引是在导入时构建的。如果您在导入一些数据后添加新属性，现有的对象索引不会自动更新以添加新属性。这意味着现有对象未添加到新的属性索引中。查询可能会返回意外结果，因为索引仅包含新对象。

要创建包含集合中所有对象的索引，请执行以下操作之一

• 新集合：在导入对象之前添加集合的所有属性。
• 现有集合：从集合中导出现有数据。使用新属性重新创建它。将数据导入到更新后的集合中。

我们正在开发一个重新索引 API，以便您可以在添加属性后重新索引数据。此功能将在未来的版本中提供。

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

  API 文档

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

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

from weaviate.classes.config import Property, DataType

articles = client.collections.use("Article")

articles.config.add_property(Property(name="onHomepage", data_type=DataType.BOOL))

let articles = client.collections.use('Article')

articles.config.addProperty({
  name: "onHomepage",
  dataType: "boolean",
});

package main

import (
  "context"

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

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

  prop := &models.Property{
    DataType: []string{"boolean"},
    Name:     "onHomepage",
  }

  err := client.Schema().PropertyCreator().
    WithClassName("Article").
    WithProperty(prop).
    Do(context.Background())

  if err != nil {
    panic(err)
  }
}

CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");

articles.config.addProperty(Property.bool("onHomepage"));

Property property = Property.builder()
    .dataType(Arrays.asList(DataType.BOOLEAN))
    .name(propertyName)
    .build();

Result<Boolean> result = client.schema().propertyCreator()
    .withClassName(collectionName)
    .withProperty(property)
    .run();

CollectionClient articles = client.Collections.Use("Article");
await articles.Config.AddProperty(Property.Text("description"));

更多资源

• 管理集合：向量化器和向量索引
• 参考：集合定义
• 概念：数据结构

• API 参考：REST：Schema

问题和反馈

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

技术问题

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

文档反馈

通过打开 GitHub issue 提供反馈。