搜索操作符

本页涵盖了可以在查询中使用搜索操作符，例如向量搜索操作符（nearText、nearVector、nearObject 等）、关键词搜索操作符（bm25）、混合搜索操作符（hybrid）。

只能将一个搜索操作符添加到集合级别的查询中。

操作符可用性

内置操作符

这些操作符在所有 Weaviate 实例中都可用，无论配置如何。

• nearVector
• nearObject
• hybrid
• bm25

模块特定操作符

模块特定的搜索操作符在某些 Weaviate 模块中可用。

通过添加相关模块，您可以使用以下操作符

• nearText
• 多模态搜索
• ask

向量搜索操作符

nearXXX 操作符允许您根据其向量相似度找到数据对象与查询。查询可以是原始向量（nearVector）或对象 UUID（nearObject）。

如果启用了适当的向量化模型，可以使用文本查询（nearText）、图像（nearImage）或其他媒体输入作为查询。

所有向量搜索操作符都可以与指定的 certainty 或 distance 阈值一起使用，以及 limit 操作符 或 autocut 操作符 以指定查询与结果之间的所需相似度或距离

nearVector

nearVector 查找与输入向量最接近的数据对象。

变量

变量	必需	类型	描述
vector	是	[float]	此变量采用浮点数组形式的向量嵌入。该数组应与此集合中的向量长度相同。
distance	没有	浮点数	与提供的搜索输入的最大允许距离。不能与 certainty 变量一起使用。距离字段值的解释取决于 使用的距离度量。
确定性	没有	浮点数	结果项与搜索向量之间的归一化距离。归一化为介于 0（完全相反）和 1（相同向量）之间。不能与 distance 变量一起使用。

示例

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.near_vector(
      near_vector=query_vector,
      distance=0.7,
      limit=5,
  )

  for o in response.objects:
      print(o.properties)

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Publication"

  name := graphql.Field{Name: "name"}
  _additional := graphql.Field{
    Name: "_additional", Fields: []graphql.Field{
      {Name: "certainty"},  // only supported if distance==cosine
      {Name: "distance"},   // always supported
    },
  }

  nearVector := client.GraphQL().NearVectorArgBuilder().
    WithVector([]float32{0.1, -0.15, 0.3})  // Replace with a compatible vector

  ctx := context.Background()
  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(name, _additional).
    WithNearVector(nearVector).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
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;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    String className = "Publication";
    Field title = Field.builder().name("title").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder().name("certainty").build()  // only supported if distance==cosine
        Field.builder().name("distance").build()   // always supported
      }).build();

    Float[] vector = new Float[]{0.1f, -0.15f, 0.3f};  // Replace with a compatible vector
    NearVectorArgument nearVector = NearVectorArgument.builder()
      .vector(vector)
      .build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName(className)
      .withFields(title, _additional)
      .withNearVector(nearVector)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

用兼容的向量替换占位符向量。

# Note: under _additional, `certainty` is only supported if distance==cosine, but `distance` is always supported

echo '{
  "query": "{
    Get {
      Publication(
        nearVector: {
          vector: [0.1, -0.15, 0.3]
        }
      ) {
        name
        _additional {
          certainty
          distance
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get{
    Publication(
      nearVector: {
        vector: [0.1, -0.15, 0.3]  # Replace with a compatible vector
      }
    ){
      name
      _additional {
        certainty
      }
    }
  }
}

nearObject

nearVector 查找与同一集合中现有对象最接近的数据对象。通常通过其 UUID 指定对象。

• 注意：您可以在参数中指定对象的 id 或 beacon，以及所需的 certainty。
• 请注意，第一个结果将始终是用于搜索的对象。

变量

变量	必需	类型	描述
id	是	UUID	uuid 格式的数据对象标识符。
beacon	没有	url	beacon URL 格式的数据对象标识符。例如，weaviate://<hostname>/<kind>/id。
distance	没有	浮点数	与提供的搜索输入的最大允许距离。不能与 certainty 变量一起使用。距离字段值的解释取决于 使用的距离度量。
确定性	没有	浮点数	结果项与搜索向量之间的归一化距离。归一化为介于 0（完全相反）和 1（相同向量）之间。不能与 distance 变量一起使用。

示例

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.near_object(
      near_object=object_id,
      distance=0.6,
      limit=5,
  )

  for o in response.objects:
      print(o.properties)

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Publication"
  fields := []graphql.Field{
    {Name: "name"},
    {Name: "_additional", Fields: []graphql.Field{
      {Name: "certainty"}, // certainty only supported if distance==cosine
      {Name: "distance"},  // distance always supported
    }},
  }
  nearObject := client.GraphQL().NearObjectArgBuilder().WithID("32d5a368-ace8-3bb7-ade7-9f7ff03eddb6")
  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(fields...).
    WithNearObject(nearObject).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    String className = "Publication";
    Field name = Field.builder().name("name").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder().name("certainty").build(), // only supported if distance==cosine
        Field.builder().name("distance").build()   // always supported
      }).build();

    NearObjectArgument nearObject = client.graphQL().arguments().nearObjectArgBuilder()
      .id("32d5a368-ace8-3bb7-ade7-9f7ff03eddb6")
      .build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName(className)
      .withFields(name, _additional)
      .withNearObject(nearObject)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

# Note: prior to v1.14, use `certainty` instead of `distance`
# Under _additional, `certainty` is only supported if distance==cosine, but `distance` is always supported
echo '{
  "query": "{
    Get {
      Publication(
        nearObject: {
          id: \"32d5a368-ace8-3bb7-ade7-9f7ff03eddb6\",
          distance: 0.6
        }
      ) {
        name
        _additional {
          certainty
          distance
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get{
    Publication(
      nearObject: {
        id: "32d5a368-ace8-3bb7-ade7-9f7ff03eddb6",  # or weaviate:///32d5a368-ace8-3bb7-ade7-9f7ff03eddb6
        distance: 0.6  # prior to v1.14, use certainty: 0.7
      }
    ) {
      name
      _additional {
        certainty  # only works if distance==cosine
        distance   # always works
      }
    }
  }
}

预期响应

{
  "data": {
    "Get": {
      "Publication": [
        {
          "_additional": {
            "distance": -1.1920929e-07
          },
          "name": "The New York Times Company"
        },
        {
          "_additional": {
            "distance": 0.059879005
          },
          "name": "New York Times"
        },
        {
          "_additional": {
            "distance": 0.09176409
          },
          "name": "International New York Times"
        },
        {
          "_additional": {
            "distance": 0.13954824
          },
          "name": "New Yorker"
        },
        ...
      ]
    }
  }
}

nearText

nearText 操作符根据其向量相似度找到数据对象与自然语言查询。

如果为集合配置了兼容的向量化模块，则启用此操作符。兼容的向量化模块是

• 任何 text2vec 模块
• 任何 multi2vec 模块

变量

变量	必需	类型	描述
concepts	是	[string]	字符串数组，可以是自然语言查询或单个单词。如果使用多个字符串，则计算中心点并使用。了解如何解析这些概念 此处。
distance	没有	浮点数	与提供的搜索输入的最大允许距离。不能与 certainty 变量一起使用。距离字段值的解释取决于 使用的距离度量。
确定性	没有	浮点数	结果项与搜索向量之间的归一化距离。归一化为介于 0（完全相反）和 1（相同向量）之间。不能与 distance 变量一起使用。
autocorrect	没有	布尔值	自动更正输入文本值。需要存在并启用 text-spellcheck 模块。
moveTo	没有	object{}	将您的搜索词移动到由关键字描述的另一个向量附近
moveTo{concepts}	没有	[string]	字符串数组 - 自然语言查询或单个单词。如果使用多个字符串，则计算中心点并使用。
moveTo{objects}	没有	[UUID]	要移动结果到的对象 ID。用于“偏置”NLP 搜索结果到向量空间中的特定方向。
moveTo{force}	没有	浮点数	应用于特定移动的力。必须介于 0 和 1 之间，其中 0 等于没有移动，1 等于最大的可能移动。
moveAwayFrom	没有	object{}	将您的搜索词移动到由关键字描述的另一个向量远离
moveAwayFrom{concepts}	没有	[string]	字符串数组 - 自然语言查询或单个单词。如果使用多个字符串，则计算中心点并使用。
moveAwayFrom{objects}	没有	[UUID]	要移动结果远离的对象 ID。用于“偏置”NLP 搜索结果到向量空间中的特定方向。
moveAwayFrom{force}	没有	浮点数	应用于特定移动的力。必须介于 0 和 1 之间，其中 0 等于没有移动，1 等于最大的可能移动。

示例 I

本示例显示了 nearText 操作符的示例用法，包括如何偏置结果到另一个搜索查询。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
from weaviate.classes.query import Move
import os

client = weaviate.connect_to_local()

try:
    publications = client.collections.use("Publication")

    response = publications.query.near_text(
        query="fashion",
        distance=0.6,
        move_to=Move(force=0.85, concepts="haute couture"),
        move_away=Move(force=0.45, concepts="finance"),
        return_metadata=wvc.query.MetadataQuery(distance=True),
        limit=2
    )

    for o in response.objects:
        print(o.properties)
        print(o.metadata)

finally:
    client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Publication"

  name := graphql.Field{Name: "name"}
  _additional := graphql.Field{
    Name: "_additional", Fields: []graphql.Field{
      {Name: "certainty"}, // only supported if distance==cosine
      {Name: "distance"},  // always supported
    },
  }

  concepts := []string{"fashion"}
  distance := float32(0.6)
  moveAwayFrom := &graphql.MoveParameters{
    Concepts: []string{"finance"},
    Force:    0.45,
  }
  moveTo := &graphql.MoveParameters{
    Concepts: []string{"haute couture"},
    Force:    0.85,
  }
  nearText := client.GraphQL().NearTextArgBuilder().
    WithConcepts(concepts).
    WithDistance(distance). // use WithCertainty(certainty) prior to v1.14
    WithMoveTo(moveTo).
    WithMoveAwayFrom(moveAwayFrom)

  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(name, _additional).
    WithNearText(nearText).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearTextArgument;
import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    NearTextMoveParameters moveTo = NearTextMoveParameters.builder()
      .concepts(new String[]{ "haute couture" }).force(0.85f).build();

    NearTextMoveParameters moveAway = NearTextMoveParameters.builder()
      .concepts(new String[]{ "finance" }).force(0.45f)
      .build();

    NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder()
      .concepts(new String[]{ "fashion" })
      .distance(0.6f) // use .certainty(0.7f) prior to v1.14
      .moveTo(moveTo)
      .moveAwayFrom(moveAway)
      .build();

    Field name = Field.builder().name("name").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder().name("certainty").build(), // only supported if distance==cosine
        Field.builder().name("distance").build(),  // always supported
      }).build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName("Publication")
      .withFields(name, _additional)
      .withNearText(nearText)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

# Note: Under nearText, use `certainty` instead of distance prior to v1.14
# Under _additional, `certainty` is only supported if distance==cosine, but `distance` is always supported
echo '{
  "query": "{
    Get {
      Publication(
        nearText: {
          concepts: [\"fashion\"],
          distance: 0.6,
          moveAwayFrom: {
            concepts: [\"finance\"],
            force: 0.45
          },
          moveTo: {
            concepts: [\"haute couture\"],
            force: 0.85
          }
        }
      ) {
        name
        _additional {
          certainty
          distance
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get{
    Publication(
      nearText: {
        concepts: ["fashion"],
        distance: 0.6 # prior to v1.14 use "certainty" instead of "distance"
        moveAwayFrom: {
          concepts: ["finance"],
          force: 0.45
        },
        moveTo: {
          concepts: ["haute couture"],
          force: 0.85
        }
      }
    ){
      name
      _additional {
        certainty # only supported if distance==cosine.
        distance  # always supported
      }
    }
  }
}

示例 II

您还可以将结果偏向其他数据对象。例如，在这个查询中，我们将关于“亚洲旅行”的查询移动到一篇关于食物的文章。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.near_text(
      query="travelling in Asia",
      certainty=0.7,
      move_to=wvc.query.Move(
          force=0.75,
          objects="c4209549-7981-3699-9648-61a78c2124b9"
      ),
      return_metadata=wvc.query.MetadataQuery(certainty=True),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.certainty)

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Article"

  title := graphql.Field{Name: "title"}
  summary := graphql.Field{Name: "summary"}
  _additional := graphql.Field{
    Name: "_additional", Fields: []graphql.Field{
      {Name: "certainty"},
    },
  }

  concepts := []string{"travelling in Asia"}
  certainty := float32(0.7)
  moveTo := &graphql.MoveParameters{
    Objects: []graphql.MoverObject{
	  // this ID is of the article: "Tohoku: A Japan destination for all seasons."
      {ID: "c4209549-7981-3699-9648-61a78c2124b9"},
    },
    Force: 0.85,
  }
  nearText := client.GraphQL().NearTextArgBuilder().
    WithConcepts(concepts).
    WithCertainty(certainty).
    WithMoveTo(moveTo)

  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(title, summary, _additional).
    WithNearText(nearText).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearTextArgument;
import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    NearTextMoveParameters moveTo = NearTextMoveParameters.builder()
      .objects(new NearTextMoveParameters.ObjectMove[]{
        // this ID is of the article: "Tohoku: A Japan destination for all seasons."
        NearTextMoveParameters.ObjectMove.builder().id("c4209549-7981-3699-9648-61a78c2124b9").build()
      })
      .force(0.85f)
      .build();

    NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder()
      .concepts(new String[]{ "travelling in Asia" })
      .certainty(0.7f)
      .moveTo(moveTo)
      .build();

    Field title = Field.builder().name("title").build();
    Field summary = Field.builder().name("summary").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder().name("certainty").build(),
      }).build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName("Article")
      .withFields(title, summary, _additional)
      .withNearText(nearText)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

# The ID belongs to the article "Tohoku: A Japan destination for all seasons."

echo '{
  "query": "{
    Get {
      Article(
        nearText: {
          concepts: [\"travelling in Asia\"],
          certainty: 0.7,
          moveTo: {
            objects: [{
              id: \"c4209549-7981-3699-9648-61a78c2124b9\"
            }]
            force: 0.85
          }
        }
      ) {
        title
        summary
        _additional {
          certainty
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article(
      nearText: {
        concepts: ["travelling in Asia"],
        certainty: 0.7,
        moveTo: {
          objects: [{
            # this ID is of the article:
            # "Tohoku: A Japan destination for all seasons."
            id: "c4209549-7981-3699-9648-61a78c2124b9"
          }]
          force: 0.85
        }
      }
    ) {
      title
      summary
      _additional {
        certainty
      }
    }
  }
}

预期响应

{
  "data": {
    "Get": {
      "Article": [
        {
          "_additional": {
            "certainty": 0.9619976580142975
          },
          "summary": "We've scoured the planet for what we think are 50 of the most delicious foods ever created. A Hong Kong best food, best enjoyed before cholesterol checks. When you have a best food as naturally delicious as these little fellas, keep it simple. Courtesy Matt@PEK/Creative Commons/FlickrThis best food Thai masterpiece teems with shrimp, mushrooms, tomatoes, lemongrass, galangal and kaffir lime leaves. It's a result of being born in a land where the world's most delicious food is sold on nearly every street corner.",
          "title": "World food: 50 best dishes"
        },
        {
          "_additional": {
            "certainty": 0.9297388792037964
          },
          "summary": "The look reflects the elegant ambiance created by interior designer Joyce Wang in Hong Kong, while their mixology program also reflects the original venue. MONO Hong Kong , 5/F, 18 On Lan Street, Central, Hong KongKoral, The Apurva Kempinski Bali, IndonesiaKoral's signature dish: Tomatoes Bedugul. Esterre at Palace Hotel TokyoLegendary French chef Alain Ducasse has a global portfolio of restaurants, many holding Michelin stars. John Anthony/JW Marriott HanoiCantonese cuisine from Hong Kong is again on the menu, this time at the JW Marriott in Hanoi. Stanley takes its name from the elegant Hong Kong waterside district and the design touches reflect this legacy with Chinese antiques.",
          "title": "20 best new Asia-Pacific restaurants to try in 2020"
        }
        ...
      ]
    }
  }
}

其他信息

概念解析

nearText 查询会将数组输入中的每个术语解释为要向量化的不同字符串。如果传递了多个字符串，则查询向量将是各个字符串向量的平均向量。

• ["New York Times"] = 一个向量位置由单词的出现次数决定
• ["New", "York", "Times"] = 所有概念具有相似的权重。
• ["New York", "Times"] = 以上两者的组合。

一个实际的例子是：concepts: ["beatles", "John Lennon"]

语义路径

• 仅在 txt2vec-contextionary 模块中可用

语义路径返回从查询到数据对象的概念数组。这使您可以查看 Weaviate 采取了哪些步骤以及如何解释查询和数据对象。

属性	描述
concept	在此步骤中找到的概念。
distanceToNext	到下一步的距离（对于最后一步为 null）。
distanceToPrevious	到前一步的距离（对于第一步为 null）。
distanceToQuery	此步骤到查询的距离。
distanceToResult	此步骤到此结果的距离。

注意：只有在设置了 nearText: {} 操作符作为探索项代表路径的起点，每个搜索结果代表路径的终点时，才能构建语义路径。由于 nearText: {} 查询目前仅在 GraphQL 中可用，因此 semanticPath 因此在 REST API 中不可用。

示例：显示没有边的语义路径。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  # Semantic path is not yet supported by the V4 client. Please use a raw GraphQL query instead.
  response = client.graphql_raw_query(
  """
  {
    Get {
      Publication (
        nearText:{
          concepts: ["fashion"],
          distance: 0.6,
          moveAwayFrom: {
            concepts: ["finance"],
            force: 0.45
          },
          moveTo: {
            concepts: ["haute couture"],
            force: 0.85
          }
        }
      ) {
        name
        _additional {
          semanticPath {
            path {
              concept
              distanceToNext
              distanceToPrevious
              distanceToQuery
              distanceToResult
            }
          }
        }
      }
    }
  }
  """
  )

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Publication"
  fields := []graphql.Field{
    {Name: "name"},
    {Name: "_additional", Fields: []graphql.Field{
      {Name: "semanticPath", Fields: []graphql.Field{
        {Name: "path", Fields: []graphql.Field{
          {Name: "concept"},
          {Name: "distanceToNext"},
          {Name: "distanceToPrevious"},
          {Name: "distanceToQuery"},
          {Name: "distanceToResult"},
        }},
      }},
    }},
  }

  concepts := []string{"fashion"}
  moveTo := &graphql.MoveParameters{
    Concepts: []string{"haute couture"},
    Force:    0.85,
  }
  moveAwayFrom := &graphql.MoveParameters{
    Concepts: []string{"finance"},
    Force:    0.45,
  }
  nearText := client.GraphQL().NearTextArgBuilder().
    WithConcepts(concepts).
    WithDistance(0.6). // prior to v1.14, use WithCertainty(0.7)
    WithMoveTo(moveTo).
    WithMoveAwayFrom(moveAwayFrom)

  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(fields...).
    WithNearText(nearText).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.NearTextArgument;
import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Field name = Field.builder().name("name").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder()
          .name("semanticPath")
          .fields(new Field[]{
            Field.builder()
              .name("path")
              .fields(new Field[]{
                Field.builder().name("concept").build(),
                Field.builder().name("distanceToNext").build(),
                Field.builder().name("distanceToPrevious").build(),
                Field.builder().name("distanceToQuery").build(),
                Field.builder().name("distanceToResult").build()
              })
              .build()
          }).build()
      }).build();

    NearTextMoveParameters moveTo = NearTextMoveParameters.builder()
      .concepts(new String[]{ "haute couture" }).force(0.85f).build();

    NearTextMoveParameters moveAway = NearTextMoveParameters.builder()
      .concepts(new String[]{ "finance" }).force(0.45f)
      .build();

    NearTextArgument explore = client.graphQL().arguments().nearTextArgBuilder()
      .concepts(new String[]{ "fashion" })
      .distance(0.6f) // prior to v1.14, use .certainty(0.7f)
      .moveTo(moveTo)
      .moveAwayFrom(moveAway)
      .build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName("Publication")
      .withFields(name, _additional)
      .withNearText(explore)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

# Note: Under nearText, use `certainty` instead of `distance` prior to v1.14

echo '{
  "query": "{
    Get {
      Publication (
        nearText: {
          concepts: [\"fashion\"],
          distance: 0.6,
          moveAwayFrom: {
            concepts: [\"finance\"],
            force: 0.45
          },
          moveTo: {
            concepts: [\"haute couture\"],
            force: 0.85
          }
        }
      ) {
        name
        _additional {
          semanticPath{
            path {
              concept
              distanceToNext
              distanceToPrevious
              distanceToQuery
              distanceToResult
            }
          }
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Publication (
      nearText:{
        concepts: ["fashion"],
        distance: 0.6,  # prior to v1.14 use certainty: 0.7
        moveAwayFrom: {
          concepts: ["finance"],
          force: 0.45
        },
        moveTo: {
          concepts: ["haute couture"],
          force: 0.85
        }
      }
    ) {
      name
      _additional {
        semanticPath {
          path {
            concept
            distanceToNext
            distanceToPrevious
            distanceToQuery
            distanceToResult
          }
        }
      }
    }
  }
}

多模态搜索

根据向量化模块，您可以使用其他模态，例如图像、音频或视频作为查询，并检索相应的兼容对象。

一些模块，例如 multi2vec-clip 和 multi2vec-bind 允许您跨模态搜索。例如，您可以使用文本查询搜索图像，或使用图像查询搜索文本。

有关更多信息，请参阅特定的模块页面，例如这些

• Transformers 多模态嵌入
• ImageBind 多模态嵌入

hybrid

此操作符允许您组合 BM25 和向量搜索，以获得“两全其美”类型的搜索结果集。

变量

变量	必需	类型	描述
query	是	字符串	搜索查询
alpha	没有	浮点数	每个搜索算法的权重，默认值为 0.75
vector	没有	[float]	可选地提供您自己的向量
属性	没有	[string]	限制 BM25 搜索的属性列表，默认所有文本属性
fusionType	没有	字符串	混合融合算法的类型（从 v1.20.0 可用）
bm25SearchOperator	没有	object	设置目标对象中必须存在多少个（bm25）查询词，才能被认为匹配。（从 v1.31.0 版本开始可用）

• 备注
  • alpha 可以是 0 到 1 之间的任何数字，默认值为 0.75。
    • alpha = 0 强制使用纯 关键词 搜索方法（BM25）
    • alpha = 1 强制使用纯 向量 搜索方法
    • alpha = 0.5 对 BM25 和向量方法进行同等加权
  • fusionType 可以是 rankedFusion 或 relativeScoreFusion
    • rankedFusion（默认）将 BM25 和向量搜索方法的倒序排名相加
    • relativeScoreFusion 将 BM25 和向量搜索方法的归一化分数相加

融合算法

排序融合

rankedFusion 算法是 Weaviate 最初的混合融合算法。

在该算法中，每个对象根据其在该搜索（向量或关键词）结果中的位置进行评分。在每个搜索中排名最高的对象获得最高分数。分数从排名最高到最低逐渐降低。总分是通过将向量和关键词搜索的基于排名的分数相加来计算的。

相对分数融合

在 v1.20 中添加

相对分数融合是 v1.24 及更高版本中的默认设置。

在 relativeScoreFusion 中，向量搜索和关键词搜索分数被缩放到 0 和 1 之间。最高的原始分数在缩放后的分数中变为 1。最低值被赋值为 0。剩余值在 0 和 1 之间排名。总分是归一化向量相似度和归一化 BM25 分数的缩放和。

融合评分比较

本示例使用一个小的搜索结果集来比较排序融合和相对融合算法。表格显示以下信息

• document id，从 0 到 4
• keyword score，已排序
• vector search score，已排序

搜索类型	(id): score	(id): score	(id): score	(id): score	(id): score
关键词	(1): 5	(0): 2.6	(2): 2.3	(4): 0.2	(3): 0.09
向量	(2): 0.6	(4): 0.598	(0): 0.596	(1): 0.594	(3): 0.009

排名算法使用这些分数来推导出混合排名。

排序融合

分数取决于结果的排名。分数等于 1/(RANK + 60)

搜索类型	(id): score	(id): score	(id): score	(id): score	(id): score
关键词	(1): 0.0154	(0): 0.0160	(2): 0.0161	(4): 0.0167	(3): 0.0166
向量	(2): 0.016502	(4): 0.016502	(0): 0.016503	(1): 0.016503	(3): 0.016666

如您所见，每个排名的结果是相同的，无论输入分数如何。

相对分数融合

在这里，我们归一化分数——将最高分数设置为 1，最低分数设置为 0，所有介于两者之间的值都根据其与 最大值 和 最小值 的 相对距离 进行缩放。

搜索类型	(id): score	(id): score	(id): score	(id): score	(id): score
关键词	(1): 1.0	(0): 0.511	(2): 0.450	(4): 0.022	(3): 0.0
向量	(2): 1.0	(4): 0.996	(0): 0.993	(1): 0.986	(3): 0.0

在这里，分数反映了原始分数的相对分布。例如，前 4 个文档的向量搜索分数几乎相同，归一化分数仍然如此。

权重 & 最终分数

在将这些分数加起来之前，它们会根据 alpha 参数进行加权。假设 alpha=0.5，这意味着两种搜索类型对最终结果的贡献相等，因此每个分数都乘以 0.5。

现在，我们可以将每个文档的分数加起来，并比较两种融合算法的结果。

算法类型	(id): score	(id): score	(id): score	(id): score	(id): score
排序	(2): 0.016301	(1): 0.015952	(0): 0.015952	(4): 0.016600	(3): 0.016630
相对	(1): 0.993	(0): 0.752	(2): 0.725	(4): 0.509	(3): 0.0

我们能从这中学到什么？

对于向量搜索，前 4 个对象（ID 2, 4, 0, 1）的分数几乎相同，并且它们都是好的结果。而对于关键词搜索，一个对象（ID 1）比其他对象好得多。

这在 relativeScoreFusion 的最终结果中得到了体现，它将对象 ID 1 识别为最佳结果。这是合理的，因为该文档是关键词搜索中的最佳结果，与下一个最佳分数之间存在很大差距，并且位于向量搜索的前列。

相反，对于 rankedFusion，对象 ID 2 是最佳结果，紧随其后的是对象 ID 1 和 ID 0。

有关融合方法的更详细讨论，请参阅 这篇博文

附加元数据响应

混合搜索结果按分数排序，该分数是 BM25F 分数和 nearText 相似度的融合组合（数字越大表示相关性越高）。此 score 以及 explainScore 元数据可以可选地在响应中检索。

示例

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.hybrid(
      query="Fisherman that catches salmon",
      alpha=0.5,
      return_metadata=wvc.query.MetadataQuery(score=True, explain_score=True),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.score)
      print(o.metadata.explain_score)

finally:
  client.close()

hybrid := &HybridArgumentBuilder{}
	hybrid.WithQuery("Fisherman that catches salmon").WithAlpha(0.5)

	query := builder.WithClassName("Article").WithHybrid(hybrid).build()

HybridArgument hybrid = client.graphQL().arguments().HybridArgBuilder()
  .query("Fisherman that catches salmon")
  .alpha(0.5f)
  .build();
Field name = Field.builder().name("title" "summary").build();
Field _additional = Field.builder()
  .name("_additional")
  .fields(new Field[]{Field.builder().name("score explainScore").build()})
  .build();
// when
testGenerics.createTestSchemaAndData(client);
Result<GraphQLResponse> result = client.graphQL().get().withClassName("Article")
  .withHybrid(hybrid)
  .withFields(name, _additional).run();

echo '{
  "query": "{
    Get {
      Article(
        hybrid: {
          query: \"Fisherman that catches salmon\"
          alpha: 0.5
        }
      ) {
        title
        summary
        _additional { score explainScore }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article (
      hybrid: {
        query: "Fisherman that catches salmon"
        alpha: 0.5
      }
    ) {
      title
      summary
      _additional { score, explainScore }
    }
  }
}

指定向量的示例

您可以选择将向量查询提供给 vector 变量。这将覆盖混合搜索的向量搜索组件的 query 变量。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.hybrid(
      query="Fisherman that catches salmon",
      vector=query_vector,
      alpha=0.5,
      return_metadata=wvc.query.MetadataQuery(score=True, explain_score=True),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.score)
      print(o.metadata.explain_score)

finally:
  client.close()

hybrid := &HybridArgumentBuilder{}
	hybrid.WithQuery("Fisherman that catches salmon").WithVector(1, 2, 3).WithAlpha(0.5)

	query := builder.WithClassName("Article").WithHybrid(hybrid).build()

HybridArgument hybrid = client.graphQL().arguments().HybridArgBuilder()
  .query("Fisherman that catches salmon")
  .vector(Float[]{1f,2f,3f})
  .alpha(0.5f)
  .build();
Field name = Field.builder().name("title" "summary").build();
Field _additional = Field.builder()
  .name("_additional")
  .fields(new Field[]{Field.builder().name("score").build()})
  .build();
// when
testGenerics.createTestSchemaAndData(client);
Result<GraphQLResponse> result = client.graphQL().get().withClassName("Article")
  .withHybrid(hybrid)
  .withFields(name, _additional).run();

# The `vector` below is optional. Not needed if Weaviate handles the vectorization.
# If you provide your own embeddings, put the vector query there, and make sure it has the correct number of dimensions.
echo '{
  "query": "{
      Get {
        Article(
          hybrid: {
            query: \"Fisherman that catches salmon\"
            alpha: 0.5
            vector: [1, 2, 3]
          })
        {
          title
          summary
          _additional { score }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article (
      hybrid: {
        query: "Fisherman that catches salmon"
        alpha: 0.5
        vector: [1, 2, 3] # optional. Not needed if Weaviate handles the vectorization. If you provide your own embeddings, put the vector query here.
      })
     {
      title
      summary
      _additional { score }
    }
  }
}

带有条件过滤器的混合搜索

在 v1.18.0 中添加

可以使用 条件（where）过滤器 与 hybrid 一起使用。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.hybrid(
      query="How to catch an Alaskan Pollock",
      alpha=0.5,
      filters=wvc.query.Filter.by_property("wordCount").less_than(1000),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)

finally:
  client.close()

where := filters.Where().
WithPath([]string{"content"}).
  WithOperator(filters.Equal).
  WithValueString("Alaskan")  // All results must have "Alaskan" in the content property

name = graphql.Field{Name: "summary"}

hybrid := &graphql.HybridArgumentBuilder{}
hybrid.WithQuery("How to catch an Alaskan Pollock").WithAlpha(0.5)

resultSet, gqlErr := client.GraphQL().Get().WithClassName("Article").WithHybrid(hybrid).WithWhere(where).WithFields(name).Do(context.Background())
articles := get["Article"].([]interface{})

Field title = Field.builder().name("title" "summary").build();

WhereFilter where = WhereFilter.builder()
  .path(new String[]{ "wordCount" })
  .operator(Operator.LessThan)
  .valueInt(1000)
  .build();

HybridFilter hybridFilter = HybridFilter.builder()
  .query("How to catch an Alaskan Pollock.")
  .alpha(0.5)
  .build();

Result<GraphQLResponse> result = client.graphQL().get()
  .withClassName("Article")
  .withFields(title)
  .withWhere(where)
  .withHybrid(hybridFilter)
  .run();

echo '{
  "query": "{
      Get {
        Article (
          hybrid: { query: \"How to catch an Alaskan Pollock\", alpha: 0.5 }
          where: { path: [\"wordCount\"], operator: LessThan, valueInt: 1000 }
        ) {
          title
          summary
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article (
      hybrid: { query: "how to fish", alpha: 0.5 }
      where: { path: ["wordCount"], operator: LessThan, valueInt: 1000 }
    ) {
      title
      summary
    }
  }
}

指定用于 BM25 搜索的对象属性

在 v1.19 中添加

hybrid 操作符可以接受一个字符串数组，以限制 BM25 组件搜索的属性集。如果未指定，将搜索集合中的所有文本属性。

PythonJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("JeopardyQuestion")

  response = collection.query.hybrid(
      query="Venus",
      alpha=0.25,
      query_properties=["question"],
      return_metadata=wvc.query.MetadataQuery(score=True),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.score)

finally:
  client.close()

HybridArgument hybrid = client.graphQL().arguments().HybridArgBuilder()
  .query("Fisherman that catches salmon")
  .alpha(0.25f)  // closer to pure keyword search
  .properties(String[]{"question"})  // changing to "answer" will yield a different result set
  .build();
Field name = Field.builder().name("question" "answer").build();
Field _additional = Field.builder()
  .name("_additional")
  .fields(new Field[]{Field.builder().name("score").build()})
  .build();
// when
testGenerics.createTestSchemaAndData(client);
Result<GraphQLResponse> result = client.graphQL().get().withClassName("JeopardyQuestion")
  .withHybrid(hybrid)
  .withFields(name, _additional)
  .withLimit(3)
  .run();

echo '{
  "query": "{
      Get {
        JeopardyQuestion (
          hybrid: {
            query: \"Venus\"
            alpha: 0.25
            properties: [\"question\"]
          }
          limit: 3
        )
        {
          question
          answer
          _additional { score }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    JeopardyQuestion(
      hybrid: {
        query: "Venus"
        alpha: 0.25  # closer to pure keyword search
        properties: ["question"]  # changing to "answer" will yield a different result set
      }
      limit: 3
    ) {
      question
      answer
      _additional {
        score
      }
    }
  }
}

使用 relativeScoreFusion 进行超搜索

在 v1.21 中添加

当 relativeScoreFusion 作为 fusionType 与小的搜索 limit 一起使用时，由于分数的归一化，结果集可能对 limit 参数非常敏感。

为了减轻这种影响，Weaviate 会自动执行具有更高限制（100）的搜索，然后将结果修剪到请求的限制。

BM25 搜索运算符

在 v1.31 中添加

使用 bm25SearchOperator 设置目标对象中必须存在多少个查询词，才能在混合搜索的关键词（bm25）搜索部分中被认为匹配。当您希望确保仅返回包含一定数量相关关键词的对象时，这很有用。

可用选项是 And 或 Or。如果设置为 Or，则必须指定附加参数 minimumOrTokensMatch，该参数定义必须匹配多少个查询词才能认为对象匹配。

如果尚未设置，关键词搜索的行为将如同设置了 Or，且 minimumOrTokensMatch 等于 1。

BM25

bm25 操作符执行关键词（稀疏向量）搜索，并使用 BM25F 排名函数对结果进行评分。BM25F（Best Match 25 与多个加权 Fields 的扩展）是 BM25 的扩展版本，它将评分算法应用于多个字段（properties），从而产生更好的结果。

搜索不区分大小写，大小写匹配不会带来分数优势。会删除停用词。目前尚不支持词干提取。

模式配置

自由参数 k1 和 b 可配置且可选。有关更多详细信息，请参阅 模式参考。

变量

bm25 操作符支持以下变量

变量	必需	描述
query	是	关键词搜索查询。
属性	没有	要在其中搜索的属性（字段）数组，默认值为集合中的所有属性。
searchOperator	没有	设置目标对象中必须存在多少个查询词，才能被认为匹配。（从 v1.31.0 版本开始可用）

提升属性

可以通过用尾字符后的数字指定因子来提升特定属性，例如 properties: ["title^3", "summary"]。

附加元数据响应

BM25F score 元数据可以被选择性地在响应中检索。更高的分数表示更高的相关性。

示例查询

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.bm25(
      query="fox",
      query_properties=["title"],
      return_metadata=wvc.query.MetadataQuery(score=True),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.score)

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Article"

  title := graphql.Field{Name: "title"}
  _additional := graphql.Field{
    Name: "_additional", Fields: []graphql.Field{
      {Name: "score"},
    },
  }

  query := "fox"
  properties := []string{"title"}
  bm25 := client.GraphQL().Bm25ArgBuilder().
    WithQuery(query).
    WithProperties(properties...)

  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(title, _additional).
    WithBM25(bm25).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.Bm25Argument;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Bm25Argument bm25 = client.graphQL().arguments().bm25ArgBuilder()
      .query(new String("fox"))
      .properties(new String[]{ "title" })
      .build();

    Field title = Field.builder().name("title").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder().name("score").build()
      }).build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName("Article")
      .withFields(title, _additional)
      .withBm25(bm25)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

echo '{
  "query": "{
    Get {
      Article(
        bm25: {
          query: \"fox\",
          properties: [\"title\"],
        }
      ) {
        title
        _additional {
          score
        }
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article(
      bm25: {
        query: "fox",
        properties: ["title"]
      }
    ) {
      title
      _additional {
        score
      }
    }
  }
}

预期响应

{
  "data": {
    "Get": {
      "Article": [
        {
          "_additional": {
            "certainty": null,
            "distance": null,
            "score": "3.4985464"
          },
          "title": "Tim Dowling: is the dog’s friendship with the fox sweet – or a bad omen?"
        }
      ]
    }
  },
  "errors": null
}

带有条件过滤器的 BM25

新增于 v1.18

可以使用带有条件过滤器（where）的 bm25。

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  collection = client.collections.use("Article")

  response = collection.query.bm25(
      query="how to fish",
      return_metadata=wvc.query.MetadataQuery(score=True),
      filters=wvc.query.Filter.by_property("wordCount").less_than(1000),
      limit=5,
  )

  for o in response.objects:
      print(o.properties)
      print(o.metadata.score)

finally:
  client.close()

resultSet, gqlErr := client.GraphQL().Get().WithClassName("Article").WithHybrid(hybrid).WithWhere(where).WithFields(name).Do(context.Background())

where := filters.Where().
WithPath([]string{"wordCount"}).
				WithOperator(filters.LessThan).
				WithValueInt(1000)

name = graphql.Field{Name: "summary"} // the output field

bm25B := &BM25ArgumentBuilder{}
bm25B = bm25B.WithQuery("How to fish").WithProperties("title", "summary")

resultSet, gqlErr := client.GraphQL().Get().WithClassName("Article").WithBM25(bm25B).WithWhere(where).WithFields(name).Do(context.Background())
articles := get["Article"].([]interface{})

Field title = Field.builder().name("title" "summary").build();

WhereFilter where = WhereFilter.builder()
  .path(new String[]{ "wordCount" })
  .operator(Operator.LessThan)
  .valueInt(1000)
  .build();

Bm25Argument bm25 = client.graphQL().arguments().Bm25ArgBuilder()
  .query("how to fish")
  .properties(new String[]{"title","summary"})
  .build();

Result<GraphQLResponse> result = client.graphQL().get()
  .withClassName("Article")
  .withFields(title)
  .withWhere(where)
  .withBm25(bm25)
  .run();

echo '{
  "query": "{
    Get {
      Article(
        bm25: { query: \"how to fish\", properties: [\"title\"] }
        where: { path: [\"wordCount\"], operator: LessThan, valueInt: 1000 }
      ) {
        summary
        title
      }
    }
  }"
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article (
      bm25: { query: "how to fish", properties: ["title"] }
      where: { path: ["wordCount"], operator: LessThan, valueInt: 1000 }
    ) {
      summary
      title
    }
  }
}

预期响应

{
  "data": {
    "Get": {
      "Article": [
        {
          "summary": "Sometimes, the hardest part of setting a fishing record is just getting the fish weighed. A Kentucky fisherman has officially set a new record in the state after reeling in a 9.05-pound saugeye. While getting the fish in the boat was difficult, the angler had just as much trouble finding an officially certified scale to weigh it on. In order to qualify for a state record, fish must be weighed on an officially certified scale. The previous record for a saugeye in Kentucky ws an 8 pound, 8-ounce fish caught in 2019.",
          "title": "Kentucky fisherman catches record-breaking fish, searches for certified scale"
        },
        {
          "summary": "Unpaid last month because there wasn\u2019t enough money. Ms. Hunt picks up shifts at JJ Fish & Chicken, bartends and babysits. three daughters is subsidized,and cereal fromErica Hunt\u2019s monthly budget on $12 an hourErica Hunt\u2019s monthly budget on $12 an hourExpensesIncome and benefitsRent, $775Take-home pay, $1,400Varies based on hours worked. Daycare, $600Daycare for Ms. Hunt\u2019s three daughters is subsidized, as are her electricity and internet costs. Household goods, $300Child support, $350Ms. Hunt picks up shifts at JJ Fish & Chicken, bartends and babysits to make more money.",
          "title": "Opinion | What to Tell the Critics of a $15 Minimum Wage"
        },
        ...
      ]
    }
  }
}

搜索运算符

在 v1.31 中添加

使用 searchOperator 设置目标对象中必须存在多少个查询词，才能被认为匹配。当您希望确保仅返回包含特定数量相关关键字的对象时，此功能很有用。

可用选项是 And 或 Or。如果设置为 Or，则必须指定附加参数 minimumOrTokensMatch，该参数定义必须匹配多少个查询词才能认为对象匹配。

如果尚未设置，关键词搜索的行为将如同设置了 Or，且 minimumOrTokensMatch 等于 1。

ask

由以下模块启用：问答。

此运算符允许您通过运行结果经过问答模型来返回问题的答案。

变量

变量	必需	类型	描述
问题	是	字符串	要回答的问题。
确定性	没有	浮点数	答案的期望最小确定性或置信度。值越高，搜索越严格。值越低，搜索越模糊。如果没有设置确定性，将返回可以提取的任何答案。
属性	没有	[string]	包含文本的查询集合的属性。如果没有设置属性，则认为所有属性都适用。
rerank	没有	布尔值	如果启用，问答模块将根据答案分数重新排序结果。例如，如果先前（语义）搜索确定的第 3 个结果包含最可能的答案，则第 3 个结果将被提升到第 1 位，等等。自 v1.10.0 起支持

示例

PythonGoJava v5 (已弃用)CurlGraphQL

  API 文档

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

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

import weaviate
import weaviate.classes as wvc
import os

client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": os.getenv("OPENAI_APIKEY")
    }
)

try:
  # QnA module use is not yet supported by the V4 client. Please use a raw GraphQL query instead.
  response = client.graphql_raw_query(
  """
  {
    Get {
      Article(
        ask: {
          question: "Who is the king of the Netherlands?",
          properties: ["summary"],
        },
        limit: 1
      ) {
        title
        _additional {
          answer {
            hasAnswer
            property
            result
            startPosition
            endPosition
          }
        }
      }
    }
  }
  """

finally:
  client.close()

package main

import (
  "context"
  "fmt"

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

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

  className := "Article"
  fields := []graphql.Field{
    {Name: "title"},
    {Name: "_additional", Fields: []graphql.Field{
      {Name: "answer", Fields: []graphql.Field{
        {Name: "hasAnswer"},
        {Name: "certainty"},
        {Name: "property"},
        {Name: "result"},
        {Name: "startPosition"},
        {Name: "endPosition"},
      }},
    }},
  }
  ask := client.GraphQL().AskArgBuilder().
    WithQuestion("Who is the king of the Netherlands?").
    WithProperties([]string{"summary"})
  ctx := context.Background()

  result, err := client.GraphQL().Get().
    WithClassName(className).
    WithFields(fields...).
    WithAsk(ask).
    WithLimit(1).
    Do(ctx)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", result)
}

package io.weaviate;

import io.weaviate.client.Config;
import io.weaviate.client.WeaviateClient;
import io.weaviate.client.base.Result;
import io.weaviate.client.v1.graphql.model.GraphQLResponse;
import io.weaviate.client.v1.graphql.query.argument.AskArgument;
import io.weaviate.client.v1.graphql.query.fields.Field;

public class App {
  public static void main(String[] args) {
    Config config = new Config("http", "localhost:8080");
    WeaviateClient client = new WeaviateClient(config);

    Field title = Field.builder().name("title").build();
    Field _additional = Field.builder()
      .name("_additional")
      .fields(new Field[]{
        Field.builder()
          .name("answer")
          .fields(new Field[]{
            Field.builder().name("hasAnswer").build(),
            Field.builder().name("certainty").build(),
            Field.builder().name("property").build(),
            Field.builder().name("result").build(),
            Field.builder().name("startPosition").build(),
            Field.builder().name("endPosition").build()
          }).build()
      }).build();

    AskArgument ask = AskArgument.builder()
      .question("Who is the king of the Netherlands?")
      .properties(new String[]{ "summary" })
      .build();

    Result<GraphQLResponse> result = client.graphQL().get()
      .withClassName("Article")
      .withFields(title, _additional)
      .withAsk(ask)
      .withLimit(1)
      .run();

    if (result.hasErrors()) {
      System.out.println(result.getError());
      return;
    }
    System.out.println(result.getResult());
  }
}

echo '{
  "query": "{
    Get {
      Article(
        ask: {
          question: \"Who is the king of the Netherlands?\",
          properties: [\"summary\"]
        },
        limit: 1
      ) {
        title
        _additional {
          answer {
            hasAnswer
            property
            result
            startPosition
            endPosition
          }
        }
      }
    }
  }
  "
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer learn-weaviate' \
    -H "X-OpenAI-Api-Key: $OPENAI_API_KEY" \
    -d @- \
    https://edu-demo.weaviate.network/v1/graphql

{
  Get {
    Article(
      ask: {
        question: "Who is the king of the Netherlands?",
        properties: ["summary"],
      },
      limit: 1
    ) {
      title
      _additional {
        answer {
          hasAnswer
          property
          result
          startPosition
          endPosition
        }
      }
    }
  }
}

附加元数据响应

可以检索 answer 和 certainty。

问题和反馈

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

技术问题

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

文档反馈

通过打开 GitHub issue 提供反馈。