---
title: "Quickstart: With Cloud resources"
description: "Weaviate is an open-source vector database built to power AI applications. This quickstart guide will show you how to:"
url: https://docs.weaviate.io/weaviate/quickstart
---
# Quickstart: With Cloud resources
Weaviate is an open-source vector database built to power AI applications. This quickstart guide will show you how to:
1. **Set up a collection** - Create a collection and import data into it.
2. **Search** - Perform a similarity (vector) search on your data.
3. **RAG** - Perform Retrieval Augmented Generation (RAG) with a generative model.
4. **Query Agent** - Get answers from your data by using a natural language prompt/question.
If you encounter any issues along the way or have additional questions, use the Ask AI feature.
## Prerequisites
A **[Weaviate Cloud](https://console.weaviate.cloud/)** free cluster - you will need an admin **API key** and a **REST endpoint URL** to connect to your instance. See the instructions below for more info. If you don't want to use Weaviate Cloud, check out the [Local Quickstart](https://docs.weaviate.io/weaviate/quickstart/local) with Docker.
**How to set up a Weaviate Cloud free cluster**
Go to the [Weaviate Cloud console](https://console.weaviate.cloud) and create a free cluster as shown in the interactive example below.
[Embedded content](https://app.guideflow.com/embed/3r3vg6mcnp)
> [!NOTE]
>
> - Cluster provisioning typically takes 1-3 minutes.
> - When the cluster is ready, Weaviate Cloud displays a checkmark (`✔️`) next to the cluster name.
> - Note that Weaviate Cloud may add a random suffix to cluster names to ensure uniqueness.
**How to retrieve Weaviate Cloud credentials (`WEAVIATE_API_KEY` and `WEAVIATE_URL`)**
After you create a Weaviate Cloud instance, you will need the:
- **REST Endpoint URL** and the
- **Administrator API Key**.
You can retrieve them both from the [WCD console](https://docs.weaviate.io/go/console?utm_content=quickstart) as shown in the interactive example below.
[Embedded content](https://app.guideflow.com/embed/6kwn8ldczk)
> [!NOTE]
>
> **REST vs gRPC endpoints**
>
> Weaviate supports both REST and gRPC protocols. For Weaviate Cloud deployments, you only need to provide the REST endpoint URL - the client will automatically configure gRPC.
Once you have the **REST Endpoint URL** and the **admin API key**, you can connect to your cluster, and work with Weaviate.
---
## Install a client library
Follow the instructions below to install one of the official client libraries, available in [Python](https://docs.weaviate.io/weaviate/client-libraries/python), [JavaScript/TypeScript](https://docs.weaviate.io/weaviate/client-libraries/typescript), [Go](https://docs.weaviate.io/weaviate/client-libraries/go), and [Java](https://docs.weaviate.io/weaviate/client-libraries/java).
**Python**
```bash
pip install -U "weaviate-client[agents]"
```
**JavaScript/TypeScript**
```bash
npm install @weaviate/node @weaviate/agents
```
**Go (v5)**
```bash
go get github.com/weaviate/weaviate-go-client/v5
```
**Go (v6)**
```bash
go get github.com/weaviate/weaviate-go-client/v6
```
**Java**
```xml
io.weaviateclient66.3.1
```
**C#**
```xml
```
**Verify your setup**
Before you create anything, you can also check that the client can reach your cluster:
**Python**
quickstart\_check\_readiness.py
```py
import weaviate
from weaviate.classes.init import Auth
import os
# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]
client = weaviate.connect_to_weaviate_cloud(
cluster_url=weaviate_url,
auth_credentials=Auth.api_key(weaviate_api_key),
)
print(client.is_ready()) # Should print: `True`
client.close() # Free up resources
```
**JavaScript/TypeScript**
quickstart\_check\_readiness.ts
```ts
import weaviate, { WeaviateClient } from '@weaviate/node';
// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL as string;
const weaviateApiKey = process.env.WEAVIATE_API_KEY as string;
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
weaviateUrl, // Replace with your Weaviate Cloud URL
{
authCredentials: new weaviate.ApiKey(weaviateApiKey), // Replace with your Weaviate Cloud API key
}
);
var clientReadiness = await client.isReady();
console.log(clientReadiness); // Should return `true`
client.close(); // Close the client connection
```
**Go (v6)**
quickstart/1\_check\_readiness/main.go
```go
// Set these environment variables
// WEAVIATE_HOSTNAME your Weaviate instance hostname
// WEAVIATE_API_KEY your Weaviate instance API key
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")},
}
client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}
// Check the connection
ready, err := client.Misc().ReadyChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", ready)
}
```
> [!WARNING]
>
> This client uses the `hostname` parameter (without the `https` scheme) instead of a complete `URL`.
**Java**
```java
// Best practice: store your credentials in environment variables
String weaviateUrl = System.getenv("WEAVIATE_URL");
String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
WeaviateClient client = WeaviateClient.connectToWeaviateCloud(
weaviateUrl, // Replace with your Weaviate Cloud URL
weaviateApiKey // Replace with your Weaviate Cloud key
);
System.out.println(client.isReady()); // Should print: `True`
client.close(); // Free up resources
```
**C#**
```csharp
// Best practice: store your credentials in environment variables
string weaviateUrl = Environment.GetEnvironmentVariable("WEAVIATE_URL");
string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY");
WeaviateClient client = await Connect.Cloud(weaviateUrl, weaviateApiKey);
// GetMeta returns server info. A successful call indicates readiness.
var meta = await client.IsReady();
Console.WriteLine(meta);
```
> [!WARNING]
>
> This client uses the `hostname` parameter (without the `https` scheme) instead of a complete `URL`.
**Curl**
```bash
# Best practice: store your credentials in environment variables
# export WEAVIATE_URL="YOUR_INSTANCE_URL" # Your Weaviate instance URL
# export WEAVIATE_API_KEY="YOUR_API_KEY" # Your Weaviate instance API key
curl -w "\nResponse code: %{http_code}\n" \
-H "Authorization: Bearer $WEAVIATE_API_KEY" \
$WEAVIATE_URL/v1/.well-known/ready
# You should see "Response code: 200" if the instance is ready
```
Some common first errors include:
| What you see | What it means |
| - | - |
| `unauthorized: invalid api key` (HTTP 401) | The key is wrong or is not an admin key. Copy the **Admin** key from your cluster's **API keys** tab. |
| `Unfortunately, the gRPC health check against Weaviate could not be completed.` | The client reached REST but not gRPC. Check the endpoint format for your client: the Go and C# clients want a bare hostname, without `https://`. On a self-hosted instance, also check that port `50051` is published and not blocked. |
| `no vectorizer found for class "Movie"` | You ran a `nearText` query against a collection that has no vectorizer. Create the collection with a vectorizer, or query with `nearVector` and supply the vector yourself. |
| `no api key found neither in request header: ... nor in environment variable under ...` | The model provider key never reached Weaviate. Pass it in the connection headers, as in the [model provider](https://docs.weaviate.io/weaviate/model-providers) examples. |
| `Con004: The connection to Weaviate was not closed properly.` | The script finished without closing the client. Call `client.close()`, or use a context manager. |
---
## Step 1: Create a collection & import data
There are two paths you can choose from when importing data:
[Vectorize objects during import\
(recommended)](https://docs.weaviate.io/weaviate/quickstart?import=vectorization#create-a-collection): Import objects and vectorize them with the Weaviate Embeddings service.
[Import vectors](https://docs.weaviate.io/weaviate/quickstart?import=custom-embeddings#create-a-collection): Import pre-computed vector embeddings along with your data.
#### Vectorize objects during import
The following example creates a collection called `Movie`. The data will be vectorized with the Weaviate Embeddings model provider. You are also free to use any other available [embedding model provider](https://docs.weaviate.io/weaviate/model-providers).
**Python**
```py
import weaviate
from weaviate.classes.config import Configure
import os
# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]
# Step 1.1: Connect to your Weaviate Cloud instance
with weaviate.connect_to_weaviate_cloud(
cluster_url=weaviate_url,
auth_credentials=weaviate_api_key,
) as client:
# Step 1.2: Create a collection
movies = client.collections.create(
name="Movie",
vector_config=Configure.Vectors.text2vec_weaviate(), # Configure the Weaviate Embeddings vectorizer
)
# Step 1.3: Import three objects
data_objects = [
{"title": "The Matrix", "description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.", "genre": "Science Fiction"},
{"title": "Spirited Away", "description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.", "genre": "Animation"},
{"title": "The Lord of the Rings: The Fellowship of the Ring", "description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.", "genre": "Fantasy"},
]
movies = client.collections.use("Movie")
movies.data.ingest(data_objects)
print(f"Imported & vectorized {len(movies)} objects into the Movie collection")
```
**JavaScript/TypeScript**
```ts
import weaviate, { WeaviateClient, ApiKey, vectors } from '@weaviate/node';
// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;
// Step 1.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
weaviateUrl,
{
authCredentials: new ApiKey(weaviateApiKey),
}
);
// Step 1.2: Create a collection
const movies = await client.collections.create({
name: 'Movie',
vectorizers: vectors.text2VecWeaviate(),
});
// Step 1.3: Import three objects
const dataObjects = [
{ title: 'The Matrix', description: 'A computer hacker learns about the true nature of reality and his role in the war against its controllers.', genre: 'Science Fiction' },
{ title: 'Spirited Away', description: 'A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.', genre: 'Animation' },
{ title: 'The Lord of the Rings: The Fellowship of the Ring', description: 'A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.', genre: 'Fantasy' },
];
const movieCollection = client.collections.get('Movie');
await movieCollection.data.ingest(
dataObjects.map((properties) => ({ properties }))
);
console.log(`Imported & vectorized ${dataObjects.length} objects into the Movie collection`);
await client.close(); // Free up resources
```
**Go (v5)**
The collection also contains a configuration for the generative (RAG) integration:
- Anthropic [generative AI integrations](https://docs.weaviate.io/weaviate/model-providers/anthropic/generative) for retrieval augmented generation (RAG).
```go
import (
"context"
"fmt"
"os"
"github.com/weaviate/weaviate-go-client/v5/weaviate"
"github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
"github.com/weaviate/weaviate/entities/models"
)
func main() {
// Best practice: store your credentials in environment variables
weaviateURL := os.Getenv("WEAVIATE_HOST")
weaviateAPIKey := os.Getenv("WEAVIATE_API_KEY")
// Step 1.1: Connect to your Weaviate Cloud instance
cfg := weaviate.Config{
Host: weaviateURL,
Scheme: "https",
AuthConfig: auth.ApiKey{Value: weaviateAPIKey},
}
client, err := weaviate.NewClient(cfg)
if err != nil {
panic(err)
}
// Step 1.2: Create a collection
classObj := &models.Class{
Class: "Movie",
Vectorizer: "text2vec-weaviate",
ModuleConfig: map[string]interface{}{
"generative-anthropic": map[string]interface{}{
"model": "claude-haiku-4-5",
},
},
}
err = client.Schema().ClassCreator().WithClass(classObj).Do(context.Background())
if err != nil {
panic(err)
}
// Step 1.3: Import three objects
dataObjects := []map[string]interface{}{
{
"title": "The Matrix",
"description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre": "Science Fiction",
},
{
"title": "Spirited Away",
"description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre": "Animation",
},
{
"title": "The Lord of the Rings: The Fellowship of the Ring",
"description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre": "Fantasy",
},
}
// Insert objects
objects := make([]*models.Object, len(dataObjects))
for i, obj := range dataObjects {
objects[i] = &models.Object{
Class: "Movie",
Properties: obj,
}
}
_, err = client.Batch().ObjectsBatcher().WithObjects(objects...).Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("Imported & vectorized %d objects into the Movie collection\n", len(dataObjects))
```
**Go (v6)**
> [!NOTE]
>
> **Go client `v6`**
>
> This tab uses the [`v6` Go client](https://docs.weaviate.io/weaviate/client-libraries/go). It vectorizes data with [Weaviate Embeddings](https://docs.weaviate.io/weaviate/model-providers/weaviate/embeddings) (the `text2vec-weaviate` module). Collection-level generative (RAG) configuration is not yet available in the client, so it is omitted here (see Step 3).
```go
package main
import (
"context"
"fmt"
"os"
weaviate "github.com/weaviate/weaviate-go-client/v6"
"github.com/weaviate/weaviate-go-client/v6/collections"
"github.com/weaviate/weaviate-go-client/v6/data"
wembed "github.com/weaviate/weaviate-go-client/v6/modules/weaviate"
)
func main() {
ctx := context.Background()
// Best practice: store your credentials in environment variables.
// Step 1.1: Connect to your Weaviate Cloud instance.
client, err := weaviate.NewWeaviateCloud(
ctx,
os.Getenv("WEAVIATE_URL"), // e.g. "my-cluster.weaviate.cloud"
os.Getenv("WEAVIATE_API_KEY"), // an admin API key
)
if err != nil {
// handle error
panic(err)
}
defer client.Close()
// Step 1.2: Create a collection vectorized by Weaviate Embeddings
// (the text2vec-weaviate module).
if _, err := client.Collections.Create(ctx, collections.Collection{
Name: "Movie",
Properties: []collections.Property{
{Name: "title", DataType: collections.DataTypeText},
{Name: "description", DataType: collections.DataTypeText},
{Name: "genre", DataType: collections.DataTypeText},
},
Vectors: map[string]collections.VectorConfig{
"default": {Vectorizer: wembed.Text2Vec{}},
},
}); err != nil {
// handle error
panic(err)
}
// Step 1.3: Import a few objects. Weaviate Embeddings vectorizes each on import.
if _, err := client.Collections.Use("Movie").Data.Insert(ctx,
&data.Object{Properties: map[string]any{
"title": "The Matrix",
"description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre": "Science Fiction",
}},
&data.Object{Properties: map[string]any{
"title": "Spirited Away",
"description": "A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre": "Animation",
}},
&data.Object{Properties: map[string]any{
"title": "The Lord of the Rings: The Fellowship of the Ring",
"description": "A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre": "Fantasy",
}},
); err != nil {
// handle error
panic(err)
}
fmt.Println("Imported & vectorized 3 objects into the Movie collection")
}
```
**Java**
```java
import io.weaviate.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import io.weaviate.client6.v1.api.collections.Property;
import io.weaviate.client6.v1.api.collections.VectorConfig;
import io.weaviate.client6.v1.api.collections.WeaviateObject;
import io.weaviate.client6.v1.api.collections.batch.BatchContext;
import java.util.List;
import java.util.Map;
public class QuickstartCreate {
public static void main(String[] args) throws Exception {
WeaviateClient client = null;
String collectionName = "Movie";
try {
// Best practice: store your credentials in environment variables
String weaviateUrl = System.getenv("WEAVIATE_URL");
String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
// Step 1.1: Connect to your Weaviate Cloud instance
client =
WeaviateClient.connectToWeaviateCloud(weaviateUrl, weaviateApiKey);
// Step 1.2: Create a collection
client.collections.create(collectionName,
col -> col.vectorConfig(VectorConfig.text2vecWeaviate())
// Define properties for the collection
.properties(Property.text("title"), Property.text("description"),
Property.text("genre")));
// Step 1.3: Import three objects
List> dataObjects = List.of(Map.of("title",
"The Matrix", "description",
"A computer hacker learns about the true nature of reality and his role in the war against its controllers.",
"genre", "Science Fiction"),
Map.of("title", "Spirited Away", "description",
"A young girl becomes trapped in a mysterious world of spirits and must find a way to save her parents and return home.",
"genre", "Animation"),
Map.of("title", "The Lord of the Rings: The Fellowship of the Ring",
"description",
"A meek Hobbit and his companions set out on a perilous journey to destroy a powerful ring and save Middle-earth.",
"genre", "Fantasy"));
// Insert the objects using server-side batching
CollectionHandle> movies =
client.collections.use(collectionName);
BatchContext> batch = movies.batch.start();
// Closing the batch sends the remaining objects and waits for the results
try (batch) {
for (Map properties : dataObjects) {
batch.add(
WeaviateObject.>of(o -> o.properties(properties)));
}
}
if (batch.numberOfErrors() > 0) {
System.err
.println("Number of failed imports: " + batch.numberOfErrors());
} else {
System.out.println("Imported & vectorized " + dataObjects.size()
+ " objects into the Movie collection");
}
} finally {
if (client != null) {
client.close(); // Free up resources
}
}
}
}
```
**C#**
```csharp
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;
namespace WeaviateProject.Examples
{
public class QuickstartCreate
{
public static async Task Run()
{
// Best practice: store your credentials in environment variables
string weaviateUrl = Environment.GetEnvironmentVariable("WEAVIATE_URL");
string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY");
string collectionName = "Movie";
// Connect to your Weaviate Cloud instance
var client = await Connect.Cloud(weaviateUrl, weaviateApiKey);
// Create a collection
var movies = await client.Collections.Create(
new CollectionCreateParams
{
Name = collectionName,
VectorConfig = Configure.Vector("default", v => v.Text2VecWeaviate()),
// Define properties for the collection
Properties =
[
Property.Text("title"),
Property.Text("description"),
Property.Text("genre"),
],
}
);
// Import three objects
var dataObjects = new List