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 you data by using a natural language prompt/question. Cloud only

If you encounter any issues along the way or have additional questions, use the feature.

Prerequisites

A Weaviate Cloud Sandbox instance - 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 with Docker.

How to set up a Weaviate Cloud Sandbox instance

Go to the Weaviate Cloud console and create a free Sandbox instance as shown in the interactive example below.

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 adds a random suffix to sandbox 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 as shown in the interactive example below.

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 the Sandbox instance, and work with Weaviate.

---

Install a client library

Follow the instructions below to install one of the official client libraries, available in Python, JavaScript/TypeScript, Go, and Java.

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

pip install -U weaviate-client[agents]

npm install weaviate-client weaviate-agents

go get github.com/weaviate/weaviate-go-client/v5

<dependency>
  <groupId>io.weaviate</groupId>
  <artifactId>client</artifactId>
  <version>4.8.3</version>  <!-- Check latest version: https://github.com/weaviate/java-client -->
</dependency>

---

Step 1: Create a collection & import data

There are two paths you can choose from when importing data:

Vectorize objects during import
(recommended)

Import objects and vectorize them with the Weaviate Embeddings service.

Import vectors

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 EmbeddingsWeaviate Embeddings is a managed embedding inference service for Weaviate Cloud users (embedding model provider). It generates vector embeddings for your data and queries directly from a Weaviate Cloud database instance. model provider. You are also free to use any other available embedding model provider.

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

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")
    with movies.batch.fixed_size(batch_size=200) as batch:
        for obj in data_objects:
            batch.add_object(properties=obj)

    print(f"Imported & vectorized {len(movies)} objects into the Movie collection")

import weaviate, { WeaviateClient, ApiKey, vectors } from 'weaviate-client';

// 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');
const response = await movieCollection.data.insertMany(dataObjects);

console.log(`Imported & vectorized ${dataObjects.length} objects into the Movie collection`);

await client.close(); // Free up resources

The collection also contains a configuration for the generative (RAG) integration:

• Anthropic generative AI integrations for retrieval augmented generation (RAG).

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-3-5-haiku-latest",
            },
        },
    }

    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))

The collection also contains a configuration for the generative (RAG) integration:

• Anthropic generative AI integrations for retrieval augmented generation (RAG).

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.schema.model.WeaviateClass;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class QuickstartCreate {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
    String anthropicApiKey = System.getenv("ANTHROPIC_API_KEY");

    Map<String, String> headers = new HashMap<String, String>() {
      {
        put("X-Anthropic-Api-Key", anthropicApiKey);
      }
    };
    
    // Step 1.1: Connect to your Weaviate Cloud instance
    Config config = new Config("https", weaviateUrl.replace("https://", ""), headers);
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 1.2: Create a collection
    Map<String, Object> moduleConfig = new HashMap<>();
    Map<String, Object> generativeAnthropicSettings = new HashMap<>();
    generativeAnthropicSettings.put("model", new String[]{"claude-3-5-haiku-latest"});
    moduleConfig.put("generative-anthropic", generativeAnthropicSettings);
    
    WeaviateClass movieClass = WeaviateClass.builder()
        .className("Movie")
        .vectorizer("text2vec-weaviate")
        .moduleConfig(moduleConfig)
        .build();

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

    // Step 1.3: Import three objects
    List<Map<String, Object>> 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 objects
    for (Map<String, Object> obj : dataObjects) {
      client.data().creator()
          .withClassName("Movie")
          .withProperties(obj)
          .run();
    }

    System.out.println("Imported & vectorized " + dataObjects.size() + " objects into the Movie collection");
  }
}

Import vectors

The following example creates a collection called Movie. The data should already contain the pre-computed vector embeddingsVector embeddings generated by an embedding model (from a provider like OpenAI, Anthropic, etc.).. This option is useful for when you are migrating data from a different vector database.

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

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.self_provided(),  # No automatic vectorization since we're providing vectors
    )

    # Step 1.3: Import three objects
    data_objects = [
        {"properties": {"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"},
        "vector": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]},
        {"properties": {"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"},
        "vector": [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]},
        {"properties": {"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"},
        "vector": [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]}
    ]

    # Insert the objects with vectors
    movies = client.collections.get("Movie")
    with movies.batch.fixed_size(batch_size=200) as batch:
        for obj in data_objects:
            batch.add_object(properties=obj["properties"], vector=obj["vector"])

    print(
        f"Imported {len(data_objects)} objects with vectors into the Movie collection"
    )

import weaviate, { WeaviateClient, ApiKey, vectors } from 'weaviate-client';

// 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.selfProvided(), // No automatic vectorization since we're providing vectors
});

// Step 1.3: Import three objects
const dataObjects = [
  {
    properties: { 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' },
    vectors: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8],
  },
  {
    properties: { 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' },
    vectors: [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
  },
  {
    properties: { 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' },
    vectors: [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
  },
];

// Insert the objects with vectors
const movieCollection = client.collections.get('Movie');
const response = await movieCollection.data.insertMany(dataObjects);

console.log(`Imported ${dataObjects.length} objects with vectors into the Movie collection`);

await client.close(); // Free up resources

The collection also contains a configuration for the generative (RAG) integration:

• Anthropic generative AI integrations for retrieval augmented generation (RAG).

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: "none", // No automatic vectorization since we're providing vectors
        ModuleConfig: map[string]interface{}{
            "generative-anthropic": map[string]interface{}{
                "model": "claude-3-5-haiku-latest",
            },
        },
    }

    err = client.Schema().ClassCreator().WithClass(classObj).Do(context.Background())
    if err != nil {
        panic(err)
    }

    // Step 1.3: Import three objects
    dataObjects := []struct {
        Properties map[string]interface{}
        Vector     []float32
    }{
        {
            Properties: 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",
            },
            Vector: []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8},
        },
        {
            Properties: map[string]interface{}{
                "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",
            },
            Vector: []float32{0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9},
        },
        {
            Properties: map[string]interface{}{
                "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",
            },
            Vector: []float32{0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0},
        },
    }

    // Insert the objects with vectors
    objects := make([]*models.Object, len(dataObjects))
    for i, obj := range dataObjects {
        objects[i] = &models.Object{
            Class:      "Movie",
            Properties: obj.Properties,
            Vector:     obj.Vector,
        }
    }

    _, err = client.Batch().ObjectsBatcher().WithObjects(objects...).Do(context.Background())
    if err != nil {
        panic(err)
    }

    fmt.Printf("Imported %d objects with vectors into the Movie collection\n", len(dataObjects))

The collection also contains a configuration for the generative (RAG) integration:

• Anthropic generative AI integrations for retrieval augmented generation (RAG).

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.schema.model.WeaviateClass;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class QuickstartCreateVectors {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
    String anthropicApiKey = System.getenv("ANTHROPIC_API_KEY");

    Map<String, String> headers = new HashMap<String, String>() {
      {
        put("X-Anthropic-Api-Key", anthropicApiKey);
      }
    };

    // Step 1.1: Connect to your Weaviate Cloud instance
    Config config = new Config("https", weaviateUrl.replace("https://", ""), headers);
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 1.2: Create a collection
    Map<String, Object> generativeOllamaSettings = new HashMap<>();
    generativeOllamaSettings.put("apiEndpoint", "http://ollama:11434"); // If using Docker you might need: http://host.docker.internal:11434
    generativeOllamaSettings.put("model", "llama3.2"); // The model to use

    Map<String, Map<String, Object>> moduleConfig = new HashMap<>();
    moduleConfig.put("generative-ollama", generativeOllamaSettings);

    WeaviateClass movieClass = WeaviateClass.builder()
        .className("Movie")
        .vectorizer("none") // No automatic vectorization since we're providing vectors
        .moduleConfig(moduleConfig)
        .build();

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

    // Step 1.3: Import three objects
    List<Map<String, Object>> dataObjects = List.of(
        Map.of(
            "properties", 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"),
            "vector", new Float[] { 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f }),
        Map.of(
            "properties", 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"),
            "vector", new Float[] { 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f }),
        Map.of(
            "properties", 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"),
            "vector", new Float[] { 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f }));

    // Insert the objects with vectors
    for (Map<String, Object> obj : dataObjects) {
      @SuppressWarnings("unchecked")
      Map<String, Object> properties = (Map<String, Object>) obj.get("properties");
      Float[] vector = (Float[]) obj.get("vector");

      client.data().creator()
          .withClassName("Movie")
          .withProperties(properties)
          .withVector(vector)
          .run();
    }

    System.out.println("Imported " + dataObjects.size() + " objects with vectors into the Movie collection");
  }
}

Step 2: Semantic (vector) search

Vectorize objects during import

Semantic search finds results based on meaning. This is called nearText in Weaviate. The following example searches for 2 objects (limit) whose meaning is most similar to that of sci-fi.

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

import weaviate
import os, json

# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]

# Step 2.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 2.2: Use this collection
    movies = client.collections.use("Movie")

    # Step 2.3: Perform a semantic search with NearText
    response = movies.query.near_text(
        query="sci-fi",
        limit=2
    )

    for obj in response.objects:
        print(json.dumps(obj.properties, indent=2))  # Inspect the results

import weaviate, { WeaviateClient, ApiKey } from 'weaviate-client';

// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;

// Step 2.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
  weaviateUrl,
  {
    authCredentials: new ApiKey(weaviateApiKey),
  }
);

// Step 2.2: Use this collection
const movies = client.collections.get('Movie');

// Step 2.3: Perform a semantic search with NearText
const response = await movies.query.nearText(
  'sci-fi',
  {
    limit: 2,
  }
);

for (const obj of response.objects) {
  console.log(JSON.stringify(obj.properties, null, 2)); // Inspect the results
}

await client.close(); // Free up resources

import (
    "context"
    "encoding/json"
    "fmt"
    "os"

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

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 2.2: Perform a semantic search with NearText
    title := graphql.Field{Name: "title"}
    description := graphql.Field{Name: "description"}
    genre := graphql.Field{Name: "genre"}

    nearText := client.GraphQL().NearTextArgBuilder().
        WithConcepts([]string{"sci-fi"})

    result, err := client.GraphQL().Get().
        WithClassName("Movie").
        WithNearText(nearText).
        WithLimit(2).
        WithFields(title, description, genre).
        Do(context.Background())

    if err != nil {
        panic(err)
    }

    // Inspect the results
    if result.Errors != nil {
        fmt.Printf("Error: %v\n", result.Errors)
        return
    }

    data := result.Data["Get"].(map[string]interface{})
    movies := data["Movie"].([]interface{})

    for _, movie := range movies {
        jsonData, err := json.MarshalIndent(movie, "", "  ")
        if err != nil {
            panic(err)
        }
        fmt.Println(string(jsonData))
    }

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearTextArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class QuickstartQueryNearText {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");

    // Step 2.1: Connect to your Weaviate Cloud instance
    Config config = new Config("https", weaviateUrl.replace("https://", ""));
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 2.2: Perform a semantic search with NearText
    Field title = Field.builder().name("title").build();
    Field description = Field.builder().name("description").build();
    Field genre = Field.builder().name("genre").build();

    NearTextArgument nearText = NearTextArgument.builder()
        .concepts(new String[] { "sci-fi" })
        .build();

    Result<GraphQLResponse> response = client.graphQL().get()
        .withClassName("Movie")
        .withNearText(nearText)
        .withLimit(2)
        .withFields(title, description, genre)
        .run();

    // Inspect the results
    if (response.hasErrors()) {
      System.out.println("Error: " + response.getError());
    } else {
      System.out.println(response.getResult());
    }
  }
}

Import vectors

Semantic search finds results based on meaning. This is called nearVector in Weaviate. The following example searches for 2 objects (limit) whose vector is most similar to the query vector.

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

import weaviate
import os, json

# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]

# Step 2.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 2.2: Use this collection
    movies = client.collections.use("Movie")

    # Step 2.3: Perform a vector search with NearVector
    response = movies.query.near_vector(
        near_vector=[0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81], 
        limit=2
    )

    for obj in response.objects:
        print(json.dumps(obj.properties, indent=2))  # Inspect the results

import weaviate, { WeaviateClient, ApiKey } from 'weaviate-client';

// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;

// Step 2.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
  weaviateUrl,
  {
    authCredentials: new ApiKey(weaviateApiKey),
  }
);

// Step 2.2: Use this collection
const movies = client.collections.get('Movie');

// Step 2.3: Perform a vector search with NearVector
const response = await movies.query.nearVector(
  [0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81],
  {
    limit: 2,
  }
);

for (const obj of response.objects) {
  console.log(JSON.stringify(obj.properties, null, 2)); // Inspect the results
}

await client.close(); // Free up resources

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.util.List;
import java.util.Map;

public class QuickstartQueryNearVector {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");

    // Step 2.1: Connect to your Weaviate Cloud instance
    Config config = new Config("https", weaviateUrl.replace("https://", ""));
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 2.2: Perform a vector search with NearVector
    Field title = Field.builder().name("title").build();
    Field description = Field.builder().name("description").build();
    Field genre = Field.builder().name("genre").build();

    NearVectorArgument nearVector = NearVectorArgument.builder()
        .vector(new Float[] { 0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f })
        .build();

    Result<GraphQLResponse> response = client.graphQL().get()
        .withClassName("Movie")
        .withNearVector(nearVector)
        .withLimit(2)
        .withFields(title, description, genre)
        .run();

    // Inspect the results
    if (response.hasErrors()) {
      System.out.println("Error: " + response.getError());
    } else {
      GraphQLResponse data = response.getResult();
      Gson gson = new GsonBuilder().setPrettyPrinting().create();

      if (data.getData() != null) {
        @SuppressWarnings("unchecked")
        Map<String, Object> dataMap = (Map<String, Object>) data.getData();
        @SuppressWarnings("unchecked")
        Map<String, Object> get = (Map<String, Object>) dataMap.get("Get");
        @SuppressWarnings("unchecked")
        List<Object> movies = (List<Object>) get.get("Movie");

        for (Object movie : movies) {
          System.out.println(gson.toJson(movie));
        }
      }
    }
  }
}

Example response

{
  "genre": "Science Fiction",
  "title": "The Matrix",
  "description": "A computer hacker learns about the true nature of reality and his role in the war against its controllers."
}
{
  "genre": "Fantasy",
  "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."
}

Step 3: Retrieval augmented generation (RAG)

Requirement: Claude API key

For Retrieval Augmented Generation (RAG) in this step, you will need a Claude API key. You can also use another generative model provider instead.

Vectorize objects during import

Retrieval augmented generation (RAG), also called generative search, works by prompting a large language model (LLM) with a combination of a user query and data retrieved from a database.

The following example combines the semantic search for the query sci-fi with a prompt to generate a tweet using the Anthropic generative model (generative-anthropic).

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

import os
import weaviate
from weaviate.classes.generate import GenerativeConfig

# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]
anthropic_api_key = os.environ["ANTHROPIC_API_KEY"]

# Step 2.1: Connect to your Weaviate Cloud instance
with weaviate.connect_to_weaviate_cloud(
    cluster_url=weaviate_url,
    auth_credentials=weaviate_api_key,
    headers={"X-Anthropic-Api-Key": anthropic_api_key},
) as client:

    # Step 2.2: Use this collection
    movies = client.collections.use("Movie")

    # Step 2.3: Perform RAG with on NearText results
    response = movies.generate.near_text(
        query="sci-fi",
        limit=1,
        grouped_task="Write a tweet with emojis about this movie.",
        generative_provider=GenerativeConfig.anthropic(
            model="claude-3-5-haiku-latest"
        ),  # Configure the Anthropic generative integration for RAG
    )

    print(response.generative.text)  # Inspect the results

import weaviate, { WeaviateClient, ApiKey, generativeParameters } from 'weaviate-client';

// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;
const anthropicApiKey = process.env.ANTHROPIC_API_KEY!;

// Step 2.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
  weaviateUrl,
  {
    authCredentials: new ApiKey(weaviateApiKey),
    headers: { 'X-Anthropic-Api-Key': anthropicApiKey },
  }
);

// Step 2.2: Use this collection
const movies = client.collections.get('Movie');

// Step 2.3: Perform RAG with on NearText results
const response = await movies.generate.nearText(
  'sci-fi',
  {
    groupedTask: 'Write a tweet with emojis about this movie.',
    config: generativeParameters.anthropic({
      model: "claude-3-5-haiku-latest",
    }),
  },
  {
    limit: 1,
  }
);

console.log(response.generative); // Inspect the results

await client.close(); // Free up resources

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-go-client/v5/weaviate/graphql"
)

func main() {
    // Best practice: store your credentials in environment variables
    weaviateURL := os.Getenv("WEAVIATE_URL")
    weaviateAPIKey := os.Getenv("WEAVIATE_API_KEY")
    anthropicAPIKey := os.Getenv("ANTHROPIC_API_KEY")

    // Step 2.1: Connect to your Weaviate Cloud instance
    headers := map[string]string{
        "X-Anthropic-Api-Key": anthropicAPIKey,
    }

    cfg := weaviate.Config{
        Host:       weaviateURL,
        Scheme:     "https",
        AuthConfig: auth.ApiKey{Value: weaviateAPIKey},
        Headers:    headers,
    }
    client, err := weaviate.NewClient(cfg)
    if err != nil {
        panic(err)
    }

    // Step 2.2: Perform RAG with NearText results
    title := graphql.Field{Name: "title"}
    description := graphql.Field{Name: "description"}
    genre := graphql.Field{Name: "genre"}

    nearText := client.GraphQL().NearTextArgBuilder().
        WithConcepts([]string{"sci-fi"})

    generate := graphql.NewGenerativeSearch().GroupedResult("Write a tweet with emojis about this movie.")

    result, err := client.GraphQL().Get().
        WithClassName("Movie").
        WithNearText(nearText).
        WithLimit(1).
        WithFields(title, description, genre).
        WithGenerativeSearch(generate).
        Do(context.Background())

    if err != nil {
        panic(err)
    }

    // Inspect the results
    if result.Errors != nil {
        fmt.Printf("Error: %v\n", result.Errors)
        return
    }

    fmt.Printf("%v", result)

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearTextArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;
import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder;

import java.util.HashMap;
import java.util.Map;

public class QuickstartQueryNearTextRAG {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
    String anthropicApiKey = System.getenv("ANTHROPIC_API_KEY");

    // Step 2.1: Connect to your Weaviate Cloud instance
    Map<String, String> headers = new HashMap<>();
    headers.put("X-Anthropic-Api-Key", anthropicApiKey);

    Config config = new Config("https", weaviateUrl.replace("https://", ""), headers);
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 2.2: Perform RAG with NearVector results
    Field title = Field.builder().name("title").build();
    Field description = Field.builder().name("description").build();
    Field genre = Field.builder().name("genre").build();

    NearTextArgument nearText = NearTextArgument.builder()
        .concepts(new String[] { "sci-fi" })
        .build();

    GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder()
        .groupedResultTask("Write a tweet with emojis about this movie.")
        .build();

    Result<GraphQLResponse> response = client.graphQL().get()
        .withClassName("Movie")
        .withNearText(nearText)
        .withLimit(1)
        .withFields(title, description, genre)
        .withGenerativeSearch(generativeSearch)
        .run();

    // Inspect the results
    if (response.hasErrors()) {
      System.out.println("Error: " + response.getError());
    } else {
      System.out.println(response.getResult());
    }
  }
}

Import vectors

Retrieval augmented generation (RAG), also called generative search, works by prompting a large language model (LLM) with a combination of a user query and data retrieved from a database.

The following example combines the vector similarity search with a prompt to generate a tweet using the Anthropic generative model (generative-anthropic).

PythonJavaScript/TypeScriptGoJava

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

import os
import weaviate
from weaviate.classes.generate import GenerativeConfig

# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]
anthropic_api_key = os.environ["ANTHROPIC_API_KEY"]

# Step 2.1: Connect to your Weaviate Cloud instance
with weaviate.connect_to_weaviate_cloud(
    cluster_url=weaviate_url,
    auth_credentials=weaviate_api_key,
    headers={"X-Anthropic-Api-Key": anthropic_api_key},
) as client:

    # Step 2.2: Use this collection
    movies = client.collections.use("Movie")

    # Step 2.3: Perform RAG with on NearVector results
    response = movies.generate.near_vector(
        near_vector=[0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81],
        limit=1,
        grouped_task="Write a tweet with emojis about this movie.",
        generative_provider=GenerativeConfig.anthropic(
            model="claude-3-5-haiku-latest"
        ),  # Configure the Anthropic generative integration for RAG
    )

    print(response.generative.text)  # Inspect the results

import weaviate, { WeaviateClient, ApiKey, generativeParameters } from 'weaviate-client';

// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;
const anthropicApiKey = process.env.ANTHROPIC_API_KEY!;

// Step 2.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
  weaviateUrl,
  {
    authCredentials: new ApiKey(weaviateApiKey),
    headers: { 'X-Anthropic-Api-Key': anthropicApiKey },
  }
);

// Step 2.2: Use this collection
const movies = client.collections.get('Movie');

// Step 2.3: Perform RAG with on NearVector results
const response = await movies.generate.nearVector(
  [0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81],
  {
    groupedTask: 'Write a tweet with emojis about this movie.',
    config: generativeParameters.anthropic({
      model: "claude-3-5-haiku-latest",
    }),
  },
  {
    limit: 1,
  }
);

console.log(response.generative); // Inspect the results

await client.close(); // Free up resources

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateAuthClient;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.auth.exception.AuthException;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;
import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class QuickstartQueryNearVectorRAG {
  public static void main(String[] args) throws AuthException {
    // Best practice: store your credentials in environment variables
    String weaviateUrl = System.getenv("WEAVIATE_URL");
    String weaviateApiKey = System.getenv("WEAVIATE_API_KEY");
    String anthropicApiKey = System.getenv("ANTHROPIC_API_KEY");

    // Step 2.1: Connect to your Weaviate Cloud instance
    Map<String, String> headers = new HashMap<>();
    headers.put("X-Anthropic-Api-Key", anthropicApiKey);

    Config config = new Config("https", weaviateUrl.replace("https://", ""), headers);
    WeaviateClient client = WeaviateAuthClient.apiKey(config, weaviateApiKey);

    // Step 2.2: Perform RAG with NearVector results
    Field title = Field.builder().name("title").build();
    Field description = Field.builder().name("description").build();
    Field genre = Field.builder().name("genre").build();

    NearVectorArgument nearVector = NearVectorArgument.builder()
        .vector(new Float[] { 0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f })
        .build();

    GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder()
        .groupedResultTask("Write a tweet with emojis about this movie.")
        .build();

    Result<GraphQLResponse> response = client.graphQL().get()
        .withClassName("Movie")
        .withNearVector(nearVector)
        .withLimit(1)
        .withFields(title, description, genre)
        .withGenerativeSearch(generativeSearch)
        .run();

    // Inspect the results
    if (response.hasErrors()) {
      System.out.println("Error: " + response.getError());
    } else {
      System.out.println(response.getResult());
    }

Example response

🕶️ Unplug from the system & join Neo's journey 💊🐰

"The Matrix" will blow your mind 🤯 as reality unravels 🌀

Kung-fu, slow-mo & mind-bending sci-fi 🥋🕴️

Are you ready to see how deep the rabbit hole goes? 🔴🔵 #TheMatrix #WakeUp

Step 4: Query Agent

Weaviate Cloud only

The Weaviate Query Agent is a pre-built agentic service designed to answer natural language queries based on the data stored in Weaviate Cloud. The user simply provides a prompt/question in natural language, and the Query Agent takes care of all intervening steps to provide an answer.

PythonJavaScript/TypeScript

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

import os
import weaviate
from weaviate.agents.query import QueryAgent

# Best practice: store your credentials in environment variables
weaviate_url = os.environ["WEAVIATE_URL"]
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]

# Step 2.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 2.2: Instantiate a new agent object
    qa = QueryAgent(client=client, collections=["Movie"])

    # Step 2.3: Perform a query using Search Mode
    response = qa.search("Find a cool sci-fi movie.", limit=1)

    # Print the response
    for obj in response.search_results.objects:
        print(f"Movie: {obj.properties['title']} - {obj.properties['description']}")

import weaviate, { WeaviateClient, ApiKey } from 'weaviate-client';
import { QueryAgent } from 'weaviate-agents';

// Best practice: store your credentials in environment variables
const weaviateUrl = process.env.WEAVIATE_URL!;
const weaviateApiKey = process.env.WEAVIATE_API_KEY!;

// Step 2.1: Connect to your Weaviate Cloud instance
const client: WeaviateClient = await weaviate.connectToWeaviateCloud(
  weaviateUrl,
  {
    authCredentials: new ApiKey(weaviateApiKey),
  }
);

// Step 2.2: Use this collection
// Instantiate a new agent object
const queryAgent = new QueryAgent(
  client, {
  collections: ['Movie'],

});

// Perform a search using Search Mode (retrieval only, no answer generation)
const basicSearchResponse = await queryAgent.search("Find a cool sci-fi movie.", {
  limit: 1
})

// Access the search results
for (const obj of basicSearchResponse.searchResults.objects) {
  console.log(`Movie: ${obj.properties['title']} - ${obj.properties['description']}`)
}

await client.close(); // Free up resources

Here is the printed response:

Movie: The Matrix - A computer hacker learns about the true nature of reality and his role in the war against its controllers.

Next steps

We recommend you check out the following resources to continue learning about Weaviate.

Quick tour of Weaviate

Continue with the Quick tour tutorial – an end-to-end guide that covers important topics like configuring collections, searches, etc.

Weaviate Academy

Check out Weaviate Academy – a learning platform centered around AI-native development.

How-to manuals

Quick examples of how to configure, manage and query Weaviate using client libraries.

Starter guides

Guides and tips for new users learning how to use Weaviate.

Questions and feedback

If you have any questions or feedback, let us know in the user forum.

Technical questions

If you have questions feel free to post on our Community forum.

Documentation feedback

Leave feedback by opening a GitHub issue.