快速上手：使用云资源

Weaviate 是一个开源的向量数据库，旨在为 AI 应用程序提供支持。本快速上手指南将向您展示如何

1. 设置集合 - 创建一个集合并将数据导入到其中。
2. 搜索 - 对您的数据执行相似度（向量）搜索。
3. RAG - 使用生成模型执行检索增强生成 (RAG)。
4. 查询代理 - 使用自然语言提示/问题从您的数据中获取答案。 仅云服务

如果您在操作过程中遇到任何问题或有其他疑问，请使用功能。

先决条件

一个 Weaviate Cloud 沙箱实例 - 您需要一个管理员 API 密钥 和一个 REST 端点 URL 来连接到您的实例。有关更多信息，请参阅下面的说明。如果您不想使用 Weaviate Cloud，请查看使用 Docker 的 本地快速上手。

如何设置 Weaviate Cloud 沙箱实例

访问 Weaviate Cloud 控制台 并创建一个免费的沙箱实例，如下面的交互式示例所示。

注意

• 集群配置通常需要 1-3 分钟。
• 当集群准备就绪时，Weaviate Cloud 会在集群名称旁边显示一个复选标记 (✔️)。
• 请注意，Weaviate Cloud 会在沙箱集群名称后添加随机后缀以确保唯一性。

如何检索 Weaviate Cloud 凭据（WEAVIATE_API_KEY 和 WEAVIATE_URL）

创建 Weaviate Cloud 实例后，您需要

• REST 端点 URL 和
• 管理员 API 密钥.

您可以从 WCD 控制台 检索它们，如下面的交互式示例所示。

REST 与 gRPC 端点

Weaviate 支持 REST 和 gRPC 协议。对于 Weaviate Cloud 部署，您只需要提供 REST 端点 URL - 客户端将自动配置 gRPC。

一旦您拥有 REST 端点 URL 和 管理员 API 密钥，您就可以连接到沙箱实例并使用 Weaviate。

---

安装客户端库

请按照以下说明安装其中一个官方客户端库，可在 Python、JavaScript/TypeScript、Go 和 Java 中找到。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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>client6</artifactId>
  <version>||site.java_new_client_version||</version> <!-- Check latest version: https://github.com/weaviate/java-client  -->
</dependency>

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

<PackageReference Include="Weaviate.Client" Version="1.0.0" />

---

步骤 1：创建集合并导入数据

您可以在导入数据时选择两种路径

在导入时向量化对象
(推荐)

导入对象并使用 Weaviate Embeddings 服务对其进行向量化。

导入向量

导入预先计算的向量嵌入以及您的数据。

在导入时向量化对象

以下示例创建一个名为 Movie 的集合。数据将使用 Weaviate EmbeddingsWeaviate Embeddings 是 Weaviate Cloud 用户（嵌入模型提供商）的托管嵌入推理服务。它直接从 Weaviate Cloud 数据库实例生成数据的向量嵌入和查询。 模型提供商进行向量化。您也可以自由使用任何其他可用的 嵌入模型提供商。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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

该集合还包含用于生成（RAG）集成的配置

• Anthropic 生成式 AI 集成 用于检索增强生成 (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))

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.data.InsertManyResponse;

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<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 using insertMany
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use(collectionName);
      InsertManyResponse insertResponse =
          movies.data.insertMany(dataObjects.toArray(new Map[0]));

      if (!insertResponse.errors().isEmpty()) {
        System.err.println("Errors during import: " + insertResponse.errors());
      } else {
        System.out
            .println("Imported & vectorized " + insertResponse.uuids().size()
                + " objects into the Movie collection");
      }
    } finally {
      if (client != null) {
        client.close(); // Free up resources
      }
    }
  }
}

该集合还包含用于生成（RAG）集成的配置

• Anthropic 生成式 AI 集成 用于检索增强生成 (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");
  }
}

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<object>
    {
        new
        {
            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",
        },
        new
        {
            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",
        },
        new
        {
            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 using InsertMany
    var insertResponse = await movies.Data.InsertMany(dataObjects.ToArray());

    if (insertResponse.HasErrors)
    {
        Console.WriteLine($"Errors during import: {insertResponse.Errors}");
    }
    else
    {
        Console.WriteLine(
            $"Imported & vectorized {insertResponse.Count} objects into the Movie collection"
        );
    }
}
    }
}

导入向量

以下示例创建一个名为 Movie 的集合。数据应已包含 预先计算的向量嵌入由嵌入模型（来自 OpenAI、Anthropic 等提供商）生成的向量嵌入。。当您从不同的向量数据库迁移数据时，此选项很有用。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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

该集合还包含用于生成（RAG）集成的配置

• Anthropic 生成式 AI 集成 用于检索增强生成 (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))

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.Vectors;
import io.weaviate.client6.v1.api.collections.WeaviateObject;
import io.weaviate.client6.v1.api.collections.data.InsertManyResponse;
import java.util.Map;

public class QuickstartCreateVectors {

  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
          // No automatic vectorization since we're providing vectors
          .vectorConfig(VectorConfig.selfProvided())
          // Define properties for the collection
          .properties(Property.text("title"), Property.text("description"),
              Property.text("genre")));

      // Step 1.3: Import three objects
      Map<String, Object> props1 = 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");
      float[] vector1 =
          new float[] {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f};

      Map<String, Object> props2 = 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");
      float[] vector2 =
          new float[] {0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f};

      Map<String, Object> props3 = 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");
      float[] vector3 =
          new float[] {0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f};

      // Insert the objects with vectors
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use(collectionName);
      InsertManyResponse insertResponse = movies.data.insertMany(
          WeaviateObject.of(v -> v.properties(props1)
              .vectors(Vectors.of(vector1))),
          WeaviateObject.of(v -> v.properties(props2)
              .vectors(Vectors.of(vector2))),
          WeaviateObject.of(v -> v.properties(props3)
              .vectors(Vectors.of(vector3))));
      if (!insertResponse.errors().isEmpty()) {
        System.err.println("Errors during import: " + insertResponse.errors());
      } else {
        System.out.println("Imported " + insertResponse.uuids().size()
            + " objects with vectors into the Movie collection");
      }
    } finally {
      if (client != null) {
        client.close(); // Free up resources
      }
    }
  }
}

该集合还包含用于生成（RAG）集成的配置

• Anthropic 生成式 AI 集成 用于检索增强生成 (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");
  }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;

namespace WeaviateProject.Examples
{
    public class QuickstartCreateVectors
    {
public static async Task Run()
{
    string weaviateUrl = Environment.GetEnvironmentVariable("WEAVIATE_URL");
    string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY");
    string collectionName = "Movie";

    var client = await Connect.Cloud(weaviateUrl, weaviateApiKey);

    // Step 1.2: Create a collection
    var movies = await client.Collections.Create(
        new CollectionCreateParams
        {
            Name = collectionName,
            VectorConfig = Configure.Vector("default", v => v.SelfProvided()),
            Properties =
            [
                Property.Text("title"),
                Property.Text("description"),
                Property.Text("genre"),
            ],
        }
    );

    // Step 1.3: Import three objects using collection initialization
    var dataToInsert = new List<BatchInsertRequest>
    {
        new BatchInsertRequest(
            new
            {
                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",
            },
            null,
            new Vectors
            {
                {
                    "default",
                    new float[] { 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f }
                },
            }
        ),
        new BatchInsertRequest(
            new
            {
                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",
            },
            null,
            new Vectors
            {
                {
                    "default",
                    new float[] { 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f }
                },
            }
        ),
        new BatchInsertRequest(
            new
            {
                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",
            },
            null,
            new Vectors
            {
                {
                    "default",
                    new float[] { 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f }
                },
            }
        ),
    };

    // Insert the objects with vectors
    var insertResponse = await movies.Data.InsertMany(dataToInsert);

    if (insertResponse.HasErrors)
    {
        Console.WriteLine($"Errors during import: {insertResponse.Errors}");
    }
    else
    {
        Console.WriteLine(
            $"Imported {insertResponse.Count} objects with vectors into the Movie collection"
        );
    }
}
    }
}

步骤 2：语义（向量）搜索

在导入时向量化对象

语义搜索基于含义查找结果。这在 Weaviate 中称为 nearText。以下示例搜索 2 个与 sci-fi 含义最相似的对象（limit）。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import com.fasterxml.jackson.databind.ObjectMapper; // For pretty-printing JSON

import java.util.Map;

public class QuickstartQueryNearText {
  public static void main(String[] args) throws Exception {
    WeaviateClient client = null;

    try {
      // 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
      client =
          WeaviateClient.connectToWeaviateCloud(weaviateUrl, weaviateApiKey);

      // Step 2.2: Perform a semantic search with NearText
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use("Movie");
      ObjectMapper objectMapper = new ObjectMapper();

      var response = movies.query.nearText("sci-fi",
          q -> q.limit(2).returnProperties("title", "description", "genre"));

      // Inspect the results
      System.out.println("--- Query Results ---");
      for (var obj : response.objects()) {
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
            .writeValueAsString(obj.properties()));
      }
    } finally {
      if (client != null) {
        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.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());
    }
  }
}

using System;
using System.Text.Json;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;

namespace WeaviateProject.Examples
{
    public class QuickstartQueryNearText
    {
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");

    // Step 2.1: Connect to your Weaviate Cloud instance
    var client = await Connect.Cloud(weaviateUrl, weaviateApiKey);

    // Step 2.2: Perform a semantic search with NearText
    var movies = client.Collections.Use("Movie");

    var response = await movies.Query.NearText(
        "sci-fi",
        limit: 2,
        returnProperties: ["title", "description", "genre"]
    );

    // Inspect the results
    Console.WriteLine("--- Query Results ---");
    foreach (var obj in response.Objects)
    {
        Console.WriteLine(
            JsonSerializer.Serialize(
                obj.Properties,
                new JsonSerializerOptions { WriteIndented = true }
            )
        );
    }
}
    }
}

导入向量

语义搜索基于含义查找结果。这在 Weaviate 中称为 nearVector。以下示例搜索 2 个与查询向量最相似的向量（limit）。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import com.fasterxml.jackson.databind.ObjectMapper; // For pretty-printing JSON

import java.util.Map;

public class QuickstartQueryNearVector {
  public static void main(String[] args) throws Exception {
    WeaviateClient client = null;

    try {
      // 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
      client =
          WeaviateClient.connectToWeaviateCloud(weaviateUrl, weaviateApiKey);

      // Step 2.2: Perform a vector search with NearVector
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use("Movie");
      ObjectMapper objectMapper = new ObjectMapper();

      // Use primitive float[] for v6
      float[] queryVector =
          new float[] {0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f};

      var response = movies.query.nearVector(queryVector,
          q -> q.limit(2).returnProperties("title", "description", "genre"));

      // Inspect the results
      System.out.println("--- Query Results ---");
      for (var obj : response.objects()) {
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
            .writeValueAsString(obj.properties()));
      }
    } finally {
      if (client != null) {
        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));
        }
      }
    }
  }
}

using System;
using System.Text.Json;
using System.Threading.Tasks;
using Weaviate.Client;

namespace WeaviateProject.Examples
{
    public class QuickstartQueryNearVector
    {
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");

    // Step 2.1: Connect to your Weaviate Cloud instance
    var client = await Connect.Cloud(weaviateUrl, weaviateApiKey);

    // Step 2.2: Perform a vector search with NearVector
    var movies = client.Collections.Use("Movie");

    float[] queryVector = [0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f];

    var response = await movies.Query.NearVector(
        queryVector,
        limit: 2,
        returnProperties: ["title", "description", "genre"]
    );

    // Inspect the results
    Console.WriteLine("--- Query Results ---");
    foreach (var obj in response.Objects)
    {
        Console.WriteLine(
            JsonSerializer.Serialize(
                obj.Properties,
                new JsonSerializerOptions { WriteIndented = true }
            )
        );
    }
}
    }
}

示例响应

{
  "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."
}

步骤 3：检索增强生成 (RAG)

要求：Claude API 密钥

在本步骤中进行检索增强生成 (RAG) 时，您需要一个 Claude API 密钥。您也可以使用另一个生成 模型提供商。

在导入时向量化对象

检索增强生成 (RAG)，也称为生成式搜索，通过使用 用户查询 和 从数据库检索的数据 的组合来提示大型语言模型 (LLM)。

以下示例将查询 sci-fi 的语义搜索与提示结合起来，使用 Anthropic 生成模型 (generative-anthropic) 生成一条推文。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider;
import java.util.Map;

public class QuickstartQueryNearTextRAG {
  public static void main(String[] args) throws Exception {
    WeaviateClient client = null;

    try {
      // 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
      client = WeaviateClient.connectToWeaviateCloud(weaviateUrl,
          weaviateApiKey, config -> config
              .setHeaders(Map.of("X-Anthropic-Api-Key", anthropicApiKey)));

      // Step 2.2: Perform RAG with nearText results
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use("Movie");

      var response = movies.generate.nearText("sci-fi",
          // Query configuration (nearText and limit)
          q -> q.limit(1).returnProperties("title", "description", "genre"),
          // Generative configuration (RAG task)
          g -> g.groupedTask("Write a tweet with emojis about this movie.",
              c -> c.generativeProvider(GenerativeProvider
                  .anthropic(o -> o.model("claude-3-5-haiku-latest"))))); // The model to use

      // Inspect the results
      // Use .generative() to access the generative result
      System.out.println(response.generative().text());

    } finally {
      if (client != null) {
        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.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());
    }
  }
}

using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;
using Weaviate.Client.Models.Generative;

namespace WeaviateProject.Examples
{
    public class QuickstartQueryNearTextRAG
    {
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 anthropicApiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");

    // Step 3.1: Connect to your Weaviate Cloud instance
    var client = await Connect.Cloud(
        weaviateUrl,
        weaviateApiKey,
        headers: new Dictionary<string, string>
        {
            { "X-Anthropic-Api-Key", anthropicApiKey },
        }
    );

    // Step 3.2: Perform RAG with nearText results
    var movies = client.Collections.Use("Movie");

    var response = await movies.Generate.NearText(
        "sci-fi",
        limit: 1,
        returnProperties: ["title", "description", "genre"],
        groupedTask: new GroupedTask("Write a tweet with emojis about this movie."),
        provider: new Providers.Anthropic
        {
            Model = "claude-3-5-haiku-latest", // The model to use
        }
    );

    // Inspect the results
    Console.WriteLine(JsonSerializer.Serialize(response.Generative.Values));
}
    }
}

导入向量

检索增强生成 (RAG)，也称为生成式搜索，通过使用 用户查询 和 从数据库检索的数据 的组合来提示大型语言模型 (LLM)。

以下示例将向量相似度搜索与提示结合起来，使用 Anthropic 生成模型 (generative-anthropic) 生成一条推文。

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

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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.client6.v1.api.WeaviateClient;
import io.weaviate.client6.v1.api.collections.CollectionHandle;
import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider;
import java.util.Map;

public class QuickstartQueryNearVectorRAG {
  public static void main(String[] args) throws Exception {
    WeaviateClient client = null;

    try {
      // 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
      client = WeaviateClient.connectToWeaviateCloud(weaviateUrl,
          weaviateApiKey, config -> config
              .setHeaders(Map.of("X-Anthropic-Api-Key", anthropicApiKey)));

      // Step 2.2: Perform RAG with NearVector results
      CollectionHandle<Map<String, Object>> movies =
          client.collections.use("Movie");

      // Use primitive float[] for v6
      float[] queryVector =
          new float[] {0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f};

      var response = movies.generate.nearVector(queryVector,
          q -> q.limit(1).returnProperties("title", "description", "genre"),
          // Generative configuration (RAG task)
          g -> g.groupedTask("Write a tweet with emojis about this movie.",
              c -> c.generativeProvider(GenerativeProvider
                  .anthropic(o -> o.model("claude-3-5-haiku-latest"))))); // The model to use

      // Inspect the results
      // Use .generative() to access the generative result
      System.out.println(response.generative().text());

    } finally {
      if (client != null) {
        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());
    }

using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using Weaviate.Client;
using Weaviate.Client.Models;
using Weaviate.Client.Models.Generative;

namespace WeaviateProject.Examples
{
    public class QuickstartQueryNearVectorRAG
    {
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 anthropicApiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");

    // Step 3.1: Connect to your Weaviate Cloud instance
    var client = await Connect.Cloud(
        weaviateUrl,
        weaviateApiKey,
        headers: new Dictionary<string, string>
        {
            { "X-Anthropic-Api-Key", anthropicApiKey },
        }
    );

    // Step 3.2: Perform RAG with NearVector results
    var movies = client.Collections.Use("Movie");

    float[] queryVector = [0.11f, 0.21f, 0.31f, 0.41f, 0.51f, 0.61f, 0.71f, 0.81f];

    var response = await movies.Generate.NearVector(
        vectors: queryVector,
        limit: 1,
        returnProperties: ["title", "description", "genre"],
        groupedTask: new GroupedTask("Write a tweet with emojis about this movie."),
        provider: new Providers.Anthropic
        {
            Model = "claude-3-5-haiku-latest", // The model to use
        }
    );

    // Inspect the results
    Console.WriteLine(JsonSerializer.Serialize(response.Generative.Values));
}
    }
}

示例响应

🕶️ 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

步骤 4：查询代理

仅 Weaviate Cloud

Weaviate 查询代理 是一种预构建的代理服务，旨在根据存储在 Weaviate Cloud 中的数据回答自然语言查询。用户只需提供自然语言提示/问题，查询代理就会负责处理所有中间步骤以提供答案。

PythonJavaScript/TypeScript

  API 文档

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

如果某个片段无法工作或您有任何反馈，请打开一个 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

这是打印的响应

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

下一步

我们建议您查看以下资源以继续学习 Weaviate。

Weaviate 快速游览

继续快速游览教程 – 一份涵盖配置集合、搜索等重要主题的端到端指南。

Weaviate 学院

查看Weaviate 学院 – 一个以 AI 原生开发为中心的学习平台。

操作手册

使用客户端库配置、管理和查询 Weaviate 的快速示例。

入门指南

为学习如何使用 Weaviate 的新用户提供的指南和技巧。

问题和反馈

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

技术问题

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

文档反馈

通过打开 GitHub issue 提供反馈。