Every object in Weaviate belongs to exactly one collection. Use the examples on this page to manage your collections.

:::callout{intent="note" title="Terminology"}
Newer Weaviate documentation discuses "collections." Older Weaviate documentation refers to "classes" instead. Expect to see both terms throughout the documentation.
:::

:::callout{intent="info" title="Python and JS/TS client - Vectorizer Configuration API Changes"}
Starting with Weaviate Python client `v4.16.0`, the [vectorizer configuration API has been updated](../client-libraries/python.md#vectorizer-api-changes-v4160).\
Starting with Weaviate JS/TS client `v3.8.0`, the [vectorizer configuration API has been updated](../client-libraries/typescript.md#vectorizer-api-changes-v380).

Action required: **Update to the latest client version** and migrate your code to use the [new vectorizer configuration API](vector-config.md#specify-a-vectorizer).
:::

## Create a collection

To create a collection, specify at least the collection name. If you don't specify any properties, [`auto-schema`](../reference-configuration/collections.md#auto-schema) creates them.

:::callout{intent="note" title="Capitalization"}
Weaviate follows GraphQL naming conventions.

- Start collection names with an upper case letter.
- Start property names with a lower case letter.

If you use an initial upper case letter to define a property name, Weaviate changes it to a lower case letter internally.
:::

:::code-group{sync="languages"}
```python title="Python"
client.collections.create("Article")
```

```typescript title="JavaScript/TypeScript"
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));
```

```go title="Go"
className := "Article"
```

```java title="Java"
client.collections.create("Article");
```

```csharp title="C#"
await client.Collections.Create(new CollectionCreateParams { Name = "Article" });
```
:::

:::callout{intent="tip" title="Production ready collections"}
- **Manually define you data schema**:
  Avoid using the [`auto-schema`](../reference-configuration/collections.md#auto-schema) feature, instead, manually [define the properties for your collection](#create-a-collection-and-define-properties).
- **Avoid creating too many collections**:
  Using too many collections can lead to scalability issues like high memory usage and degraded query performance. Instead, consider [using multi-tenancy](multi-tenancy.md), where a single collection is subdivided into multiple tenants. For more details, see [Starter Guides: Scaling limits with collections](../starter-guides/managing-collections-collections-scaling-limits.md).
:::

<!--

<CollectionsCountLimit />
-->

## Create a collection and define properties

Properties are the data fields in your collection. Each property has a name and a data type.

:::accordion{title="Additional information"}
Use properties to configure additional parameters such as data type, index characteristics, or tokenization.

For details, see:

- [References: Configuration: Schema](../reference-configuration/collections.md)
- [API References: REST: Schema](/weaviate/api/rest#tag/schema)
- [Available data types](../reference-configuration/datatypes.md)
:::

::::tabs{sync="languages"}
:::tab{title="Python"}
```python
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),
    ],
)
```
:::

:::tab{title="JavaScript/TypeScript"}
```typescript
import { dataType } from 'weaviate-client';
```
:::

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

:::tab{title="Java"}
```java
client.collections.create("Article",
    col -> col.properties(Property.text("title"), Property.text("body")));
```
:::

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

```
Or by using the fields from a class:
```

```csharp
// 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>()],
    }
);
```
:::
::::

## Create a collection with a vectorizer

Specify a `vectorizer` for a collection that will generate vector embeddings when creating objects and executing vector search queries.

:::code-group{sync="languages"}
```python title="Python" {5}
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),
    ],
)
```

```typescript title="JavaScript/TypeScript"
import { vectors, dataType } from 'weaviate-client';
```

```go title="Go"
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(),
    },
  },
}
```

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

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

:::callout{intent="info" title="Vectorizer configuration"}
Find out more about the vectorizer and vector index configuration in [Manage collections: Vectorizer and vector index](vector-config.md).
:::

## Disable auto-schema

By default, Weaviate creates missing collections and missing properties. When you configure collections manually, you have more precise control of the collection settings.

To disable [`auto-schema`](../reference-configuration/collections.md#auto-schema) set `AUTOSCHEMA_ENABLED: 'false'` in your system configuration file.

## Check if a collection exists

Get a boolean indicating whether a given collection exists.

:::code-group{sync="languages"}
```python title="Python"
exists = client.collections.exists("Article")  # Returns a boolean
```

```typescript title="JavaScript/TypeScript"
var exists = await client.collections.exists("Article")  // Returns a boolean
```

```java title="Java"
client.collections.exists(collectionName);
```

```csharp title="C#"
bool exists = await client.Collections.Exists("Article");
```
:::

## Read a single collection definition

Retrieve a collection definition from the schema.

:::code-group{sync="languages"}
```python title="Python"
articles = client.collections.use("Article")
articles_config = articles.config.get()

print(articles_config)
```

```typescript title="JavaScript/TypeScript"
let articles = client.collections.use('Article')
```

```go title="Go"
className := "Article"
```

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

System.out.println(articlesConfig);
```

```csharp title="C#"
var articles = client.Collections.Use("Article");
var articlesConfig = await articles.Config.Get();

Console.WriteLine(articlesConfig);
```
:::

:::accordion{title="Sample configuration: Text objects"}
This configuration for text objects defines the following:

- The collection name (`Article`)
- The vectorizer module (`text2vec-cohere`) and model (`embed-multilingual-v2.0`)
- A set of properties (`title`, `body`) with `text` data types.

<!-- end list -->

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

:::accordion{title="Sample configuration: Nested objects"}
This configuration for nested objects defines the following:

- The collection name (`Person`)

- The vectorizer module (`text2vec-huggingface`)

- A set of properties (`last_name`, `address`)

  - `last_name` has `text` data type
  - `address` has `object` data type

- The `address` property has two nested properties (`street` and `city`)

<!-- end list -->

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

To filter on values inside nested objects, see [Filter on nested object properties](../how-to-query-search/filters.md#filter-on-nested-object-properties).
:::

:::accordion{title="Sample configuration: Generative search"}
This configuration for [retrieval augmented generation](../how-to-query-search/generative.md) defines the following:

- The collection name (`Article`)
- The default vectorizer module (`text2vec-openai`)
- The generative module (`generative-openai`)
- A set of properties (`title`, `chunk`, `chunk_no` and `url`)
- The tokenization option for the `url` property
- The vectorization option (`skip` vectorization) for the `url` property

<!-- end list -->

```json
{
  "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
        }
      }
    }
  ]
}
```
:::

:::accordion{title="Sample configuration: Images"}
This configuration for image search defines the following:

- The collection name (`Image`)

- The vectorizer module (`img2vec-neural`)

  - The `image` property configures collection to store image data.

- The vector index distance metric (`cosine`)

- A set of properties (`image`), with the `image` property set as `blob`.

For image searches, see [Image search](../how-to-query-search/image.md).

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

## Read all collection definitions

Fetch the database schema to retrieve all of the collection definitions.

:::code-group{sync="languages"}
```python title="Python"
response = client.collections.list_all(simple=False)

print(response)
```

```typescript title="JavaScript/TypeScript"
const allCollections = await client.collections.listAll()
console.log(JSON.stringify(allCollections, null, 2));
```

```go title="Go"
schema, err := client.Schema().Getter().
  Do(ctx)
```

```java title="Java"
List<CollectionConfig> response = client.collections.list();

System.out.println(response);
```

```csharp title="C#"
var response = new List<CollectionConfig>();
await foreach (var collection in client.Collections.List())
{
    response.Add(collection);
    Console.WriteLine(collection);
}
```
:::

## Update a collection definition

:::callout{intent="warning" title="Replication factor change"}
The replication factor of a collection cannot be updated by updating the collection's definition.

From `v1.32` by using [replica movement](../replication-and-scaling/replica-movement.md), the [replication factor](../reference-configuration/collections.md#replication) of a shard can be changed.
:::

You can update a collection definition to change the [mutable collection settings](../reference-configuration/collections.md#mutability).

:::code-group{sync="languages"}
```python title="Python"
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
    ),
)
```

```typescript title="JavaScript/TypeScript"
import { reconfigure } from 'weaviate-client';
```

```go title="Go"
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,
  },
}
```

```java title="Java"
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))));
```

```csharp title="C#"
var articles = client.Collections.Use("Article");

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

## Delete a collection

You can delete any unwanted collection(s), along with the data that they contain.

:::callout{intent="warning" title="Deleting a collection also deletes its objects"}
When you **delete a collection, you delete all associated objects**!

Be very careful with deletes on a production database and anywhere else that you have important data.
:::

This code deletes a collection and its objects.

::::tabs{sync="languages"}
{/\*

:::tab{title="GraphQL"}
```graphql
```
:::

\*/}

:::tab{title="Python"}
```python
# 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()
```
:::

:::tab{title="JavaScript/TypeScript"}
```ts
// 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()
```
:::

:::tab{title="Go"}
```go
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)
  }
}
```
:::

:::tab{title="Java"}
```java
client.collections.delete(collectionName);
```
:::

:::tab{title="Curl"}
```bash
curl \
  -X DELETE \
  https://WEAVIATE_INSTANCE_URL/v1/schema/YourClassName  # Replace WEAVIATE_INSTANCE_URL with your instance URL
```
:::

:::tab{title="C#"}
```csharp
await client.Collections.Delete(collectionName);
```
:::
::::

## Add a property

:::accordion{title="Indexing limitations after data import"}
There are no index limitations when you add collection properties before you import data.

If you add a new property after you import data, there is an impact on indexing.

Property indexes are built at import time. If you add a new property after importing some data, pre-existing objects index aren't automatically updated to add the new property. This means pre-existing objects aren't added to the new property index. Queries may return unexpected results because the index only includes new objects.

To create an index that includes all of the objects in a collection, do one of the following:

- New collections: Add all of the collection's properties before importing objects.
- Existing collections: Export the existing data from the collection. Re-create it with the new property. Import the data into the updated collection.

We are working on a re-indexing API to allow you to re-index the data after adding a property. This will be available in a future release.
:::

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import Property, DataType

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

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

```js title="JavaScript/TypeScript" {3-6}
let articles = client.collections.use('Article')

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

```go title="Go"
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)
  }
}
```

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

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

```csharp title="C#"
CollectionClient articles = client.Collections.Use("Article");
await articles.Config.AddProperty(Property.Text("description"));
```
:::

## Further resources

- [Manage collections: Vectorizer and vector index](vector-config.md)
- [References: Collection definition](../reference-configuration/collections.md)
- [Concepts: Data structure](../concepts/data.md)
- [API References: REST: Schema](/weaviate/api/rest#tag/schema/post/schema)

## Questions and feedback

Have a question or feedback? Here's how to reach us.

::::card-grid
:::card{title="Community Forum" href="https://forum.weaviate.io/c/support" icon="messages-square"}
Ask questions and connect with other developers on our **Community forum**.
:::

:::card{title="Support" href="/guides/support-overview" icon="life-buoy"}
Weaviate Cloud user or customer? Find the right channel on the **Support page**.
:::
::::

## Related pages

- [Agents](./agents-index.md)
- [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md)
- [APIs](./apis-index.md)
- [Authorization and authentication](./authorization-and-authentication-index.md)
- [Benchmarks](./benchmarks-index.md)
- [Best practices](./best-practices-index.md)
- [Client libraries](./clients-index.md)
- [Client Libraries / SDKs](./client-libraries-index.md)
- [Cloud](./cloud-index.md)
- [Cloud account management](./cloud-account-management-index.md)

# Agent Instructions

This portal answers questions programmatically. To receive a synthesized,
source-cited answer instead of crawling page by page, append the `?ask=`
query parameter to any page URL on this site:

    /guides/quickstart?ask=how+do+I+authenticate

Optional parameters:

- `&goal=<what-you-are-trying-to-do>` steers the answer toward your
  objective (e.g. `&goal=write+a+python+client`).
- `&version=<label>` scopes the answer to a mounted version when the
  portal publishes more than one.

The response is `text/markdown`: the answer followed by a `# Sources` list
of the portal pages it was grounded in. Status codes are the contract:

- `200` — the answer; `402` — the portal owner’s plan or answer credits are
  exhausted (surface this to your operator; do NOT retry); `429` — you are
  rate-limited; back off for the `Retry-After` seconds; `503` — the answer
  lane is temporarily unavailable; fall back to crawling the `.md` pages.

For the full corpus map read `llms.txt` at the site root; for the tool
surface (search + page fetch as MCP tools) see `/mcp`.