本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 向量搜索
<a name="vector-search"></a>

MemoryDB 向量搜索扩展了 MemoryDB 的功能。向量搜索可以与现有的 MemoryDB 功能结合使用。不使用向量搜索的应用程序不受此功能的影响。向量搜索在提供 MemoryDB 的所有区域均可用。

向量搜索可简化应用程序架构，同时提供高速向量搜索。适用于 MemoryDB 的向量搜索非常适合将峰值性能和规模作为最重要选择标准的用例。您可以使用现有 MemoryDB 数据，或 Valkey 或 Redis OSS API 来构建机器学习和生成式人工智能使用场景。这包括检索增强生成、异常检测、文献检索和实时推荐。

截至2024年6月26日，在流行的矢量 AWS 数据库中，MemoryDB以最高的召回率提供了最快的矢量搜索性能。 AWS

**Topics**
+ [向量搜索概述](vector-search-overview.md)
+ [使用案例](vector-search-examples.md)
+ [向量搜索功能和限制](vector-search-limits.md)
+ [创建已启用向量搜索的集群](vector-search-cluster.md)
+ [向量搜索命令](vector-search-commands.md)

# 向量搜索概述
<a name="vector-search-overview"></a>

向量搜索在索引创建、维护和使用的基础上建立。每个向量搜索操作都指定一个单一索引，其操作被限定于该索引，也就是说，对一个索引的操作不受任何其他索引操作的影响。除了创建和销毁索引的操作之外，可以随时对任何索引执行任意数量的操作，这意味着在集群级别，可以同时对多个索引执行多个操作。

各个索引是存在于独特命名空间中的命名对象，该命名空间与其他 Valkey 和 Redis OSS 命名空间（例如键、函数等）分开。从概念上讲，每个索引都类似于传统的数据库表，它的结构有两个维度：列和行。表中的每行对应一个键。索引中的每一列对应该键的一个成员或部分。在本文档中，术语“键”、“行”和“记录”的含义相同，可以互换使用。同样，术语“列”、“字段”、“路径”和“成员”的含义在本质上是相同的，可以互换使用。

没有用于添加、删除或修改索引数据的特殊命令。然而，使用现有的 **HASH** 或 **JSON** 命令对索引中的键进行修改也会自动更新索引。

**Topics**
+ [索引以及 Valkey 和 Redis OSS 键空间](#vector-search-indexes-keyspaces)
+ [索引字段类型](#vector-search-index-field-types)
+ [向量索引算法](#vector-search-index-algorithms)
+ [向量搜索查询表达式](#vector-search-query-expression)
+ [INFO 命令](#vector-search-ft.info)
+ [向量搜索安全](#vector-search-security)

## 索引以及 Valkey 和 Redis OSS 键空间
<a name="vector-search-indexes-keyspaces"></a>

在 Valkey 和 Redis OSS 键空间子集的基础上构造和维护索引。多个索引可以不受限制地选择不相交或不重叠的键空间子集。每个索引的键空间由创建索引时提供的键前缀列表定义。前缀列表是可选的，如果省略前缀列表，则整个键空间将成为该索引的一部分。索引还具有类型，并且仅涵盖具有匹配类型的键。当前，仅支持 JSON 和哈希索引。哈希索引仅为前缀列表所涵盖的哈希键编制索引，同样，JSON 索引仅为其前缀列表所涵盖的 JSON 键编制索引。在索引的键空间前缀列表中，未指定类型的键将被忽略，并且也不会影响搜索操作。

当 HASH 或 JSON 命令修改索引键空间内的键时，该索引就会更新。此过程包括提取每个索引的已声明字段，并使用新值更新索引。更新过程在后台线程中完成，这意味着索引可能需要过一段时间后，才能最终与其键空间内容保持一致。因此，插入或更新键后，可能短时间内不会出现在搜索结果中。在系统负载繁重的时期，数据发生 and/or 大量突变，可见性延迟可能会变得更长。

索引的创建是一个多步骤过程。第一步是执行定义索引的 [FT.CREATE](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.create.html) 命令。成功执行创建命令后会自动启动第二步：回填。回填过程在后台线程中运行，并会扫描键空间，查找位于新索引前缀列表中的键。找到的每个键都会添加到索引中。最终，整个键空间都会接受扫描，完成索引创建过程。请注意，在回填过程运行时，允许对索引键进行变更并且没有任何限制，索引回填过程只有在所有键都正确编制索引后才会完成。在索引回填时，不允许尝试查询操作，否则回填终止并显示错误。可以通过执行 `FT.INFO` 查看索引的输出（“backfill\$1status”）来确定回填过程的完成情况。

## 索引字段类型
<a name="vector-search-index-field-types"></a>

索引的每个字段（列）都有创建索引时声明的特定类型，并且有一个键内位置。对于哈希键，位置是哈希中的字段名称。对于 JSON 键，位置是 JSON 路径描述。修改键时，系统会提取与已声明字段关联的数据，将其转换为声明的类型并存储在索引中。如果数据丢失或无法成功转换为声明的类型，则该字段将从索引中省略。有四种类型的字段，如下所述：
+ **数值字段**包含一个数字。对于 JSON 字段，必须遵守 JSON 数字规则。对于哈希，字段应包含以固定或浮点数标准格式编写的数值 ASCII 文本。无论键内的表示形式如何，字段都将转换为在索引中存储的 64 位浮点数。数值字段可以与范围搜索运算符搭配使用。基础数字以浮点数形式存储并且有精度限制，因此适用于浮点数比较的常用规则对于数值字段也适用。
+ **标签字段**包含零个或多个标签值，编码为单个 UTF-8 字符串。字符串解析为使用分隔符（默认为英文逗号，但可更改）分隔的标签值，并删除前导和尾随空格。单个标签字段中可以包含任意数量的标签值。对于标签字段，可以在查询时对标签值进行筛选，并且可以选择区分大小写或不区分大小写。
+ **文本字段**包含一组字节，不一定符合 UTF-8 标准。对于文本字段，可使用与应用程序相关的值对查询结果进行修饰。例如，URL 或文档内容等。
+ **向量字段**包含一个数字向量，也称为嵌入。向量字段支持使用指定的算法和距离度量对固定大小的向量进行 K 近邻搜索（KNN）。对于哈希索引，该字段应包含以二进制格式（*小端序 IEEE 754）*编码的整个向量。对于 JSON 键，路径应引用大小正确且填充数字的数组。请注意，当将 JSON 数组用作向量字段时，JSON 键中数组的内部表示形式会转换为所选算法所需的格式，从而减少内存消耗和精度。使用 JSON 命令进行的后续读取操作所产生值的精度会降低。

## 向量索引算法
<a name="vector-search-index-algorithms"></a>

系统提供两种向量索引算法：
+ **Flat** – Flat 算法是对索引中每个向量进行暴力线性处理，提供距离计算精度范围内的精确答案。由于索引采用线性处理，因此对于大型索引，此算法的运行时间可能非常长。
+ **HNSW（分层可导航小世界）**– HNSW 算法是一种替代方案，它能够提供正确答案的近似值，从而极大程度缩短执行时间。该算法由 `M`、`EF_CONSTRUCTION` 和 `EF_RUNTIME` 三个参数控制。前两个参数在创建索引时指定，无法更改。`EF_RUNTIME` 参数的默认值在创建索引时指定，但之后可以在任何单独的查询操作中更改。这三个参数相互作用，在摄取和查询操作期间平衡内存和 CPU 消耗，并控制精确 KNN 搜索近似值的质量（称为查准率）。

两种向量搜索算法（Flat 和 HNSW）都支持可选的 `INITIAL_CAP` 参数。指定此参数时，它会为索引预先分配内存，从而减少内存管理开销并提高向量摄取速度。

类似于 HNSW 的向量搜索算法可能无法高效处理对先前插入向量的删除或覆盖。使用这些操作可能会导致索引内存消耗过多，从而 and/or 降低召回质量。重新索引是恢复最佳内存使用 and/or 回调的一种方法。

## 向量搜索查询表达式
<a name="vector-search-query-expression"></a>

[FT.SEARCH](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.search.html) 和 [FT.AGGREGATE](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.aggregate.html) 命令需要查询表达式。该表达式是一个单字符串参数，由一个或多个运算符组成。每个运算符使用索引中的一个字段来标识索引中键的子集。可以使用布尔组合器和括号将多个运算符组合起来，以进一步增强或限制收集的键集合（或结果集）。

### 通配符
<a name="vector-search-query-expression-wildcard"></a>

通配符运算符，即星号（“\$1”），可匹配索引中的所有键。

### 数值范围
<a name="vector-search-query-expression-numeric-range"></a>

数值范围运算符使用以下语法：

```
<range-search> ::= '@' <numeric-field-name> ':' '[' <bound> <bound> ']'
<bound>  ::= <number> | '(' <number>
<number> ::= <integer> | <fixed-point> | <floating-point> | 'Inf' | '-Inf' | '+Inf'
```

< numeric-field-name > 必须是声明的类型字段`NUMERIC`。默认情况下包含边界值，但可以使用前导左圆括号 [“(”] 来排除边界值。通过使用 `Inf`、`+Inf` 或 `-Inf` 作为边界之一，可以将范围搜索转换为单个关系比较（<、<=、>、>=）。无论指定哪种数值格式（整数、固定点、浮点、无穷大），数字都会转换为 64 位浮点数进行比较，并相应地降低精度。

**Example 示例**  

```
@numeric-field:[0 10]                      // 0   <= <value> <= 10
@numeric-field:[(0 10]                     // 0   <  <value> <= 10
@numeric-field:[0 (10]                     // 0   <= <value> <  10
@numeric-field:[(0 (10]                    // 0   <  <value> <  10
@numeric-field:[1.5 (Inf]                  // 1.5 <= value
```

### 标签比较
<a name="vector-search-query-expression-tag-compare"></a>

标签比较运算符使用以下语法：

```
<tag-search> ::= '@' <tag-field-name> ':' '{' <tag> [ '|' <tag> ]* '}'
```

如果运算符中的任何标签与记录的标签字段中的任何标签匹配，则该记录将包含在结果集中。采用 `<tag-field-name>` 设计的字段必须是用 `TAG` 类型声明的索引字段。标签比较的示例包括：

```
@tag-field:{ atag }
@tag-field: { tag1 | tag2 }
```

### 布尔值组合
<a name="vector-search-query-expression-boolean-combinations"></a>

可以使用布尔逻辑组合数字运算符或标签运算符的结果集：and/or. Parentheses can be used to group operators and/or更改计算顺序。布尔逻辑运算符的语法为：

```
<expression> ::= <phrase> | <phrase> '|' <expression> | '(' <expression> ')'
<phrase> ::= <term> | <term> <phrase>
<term> ::= <range-search> | <tag-search> | '*'
```

将多个术语组合成短语时使用“and”运算。使用竖线（“\$1”）组合多个短语时使用“or”运算。

### 向量搜索
<a name="vector-search-query-expression-vector-search"></a>

向量索引支持两种不同的搜索方法：近邻和范围。近邻搜索可找到在索引中与提供的（参考）向量最接近的数量为 K 的向量，这通常称为 KNN，表示“K”最近邻。KNN 搜索的语法是：

```
<vector-knn-search> ::= <expression> '=>[KNN' <k> '@' <vector-field-name> '$' <parameter-name> <modifiers> ']'
<modifiers> ::= [ 'EF_RUNTIME' <integer> ] [ 'AS' <distance-field-name>]
```

向量 KNN 搜索仅适用于满足的向量，`<expression>`这些向量可以是上面定义的运算符的任意组合：通配符、范围搜索、标签搜索 and/or 布尔值组合。
+ `<k>` 是一个整数，指定要返回的近邻向量的数量。
+ `<vector-field-name>` 必须指定类型为 `VECTOR` 的已声明字段。
+ `<parameter-name>` 字段指定 `FT.SEARCH` 或 `FT.AGGREGATE` 命令 `PARAM` 表中的一个条目。此参数是距离计算的参考向量值。向量的值以*小端序 IEEE 754* 二进制格式编码到 `PARAM` 值中（与哈希向量字段的编码相同）。
+ 对于 HNSW 类型的向量索引，可以使用可选的 `EF_RUNTIME` 子句覆盖创建索引时建立的 `EF_RUNTIME` 参数的默认值。
+ 可选的 `<distance-field-name>` 为结果集提供了一个字段名称，用于包含参考向量和定位键之间的计算距离。

范围搜索可找到距离参考向量指定距离（半径）内的所有向量。范围搜索的语法是：

```
<vector-range-search> ::= ‘@’ <vector-field-name> ‘:’ ‘[’ ‘VECTOR_RANGE’ ( <radius> | ‘$’ <radius-parameter> )  $<reference-vector-parameter> ‘]’ [ ‘=’ ‘>’ ‘{’ <modifiers> ‘}’ ] 
<modifiers> ::= <modifier> | <modifiers>, <modifier> 
<modifer> ::= [ ‘$yield_distance_as’ ‘:’ <distance-field-name> ] [ ‘$epsilon’ ‘:’ <epsilon-value> ]
```

其中：
+ `<vector-field-name>` 是要搜索的向量字段的名称。
+ `<radius> or $<radius-parameter>` 是搜索的数字距离限制。
+ `$<reference-vector-parameter> ` 是包含参考向量的参数的名称。向量的值以小端序 IEEE 754 二进制格式编码到 PARAM 值中（与哈希向量字段的编码相同）。
+ 可选的 `<distance-field-name>` 为结果集提供了一个字段名称，用于包含参考向量和各个键之间的计算距离。
+ 可选的 `<epsilon-value> ` 控制搜索操作的边界，遍历距离 `<radius> * (1.0 + <epsilon-value>) ` 内的向量以寻找候选结果。默认值为 0.01。

## INFO 命令
<a name="vector-search-ft.info"></a>

向量搜索对 Valkey 和 Redis OSS [INFO](https://valkey.io/commands/info/) 命令进行了补充，增加了几个统计数据和计数器部分。请求检索 `SEARCH` 部分将检索以下所有部分：

### `search_memory` 部分
<a name="vector-search-ft.info-search-memory"></a>


| 名称 | 说明 | 
| --- | --- | 
| search\$1used\$1memory\$1bytes | 所有搜索数据结构消耗的内存字节数 | 
| search\$1used\$1memory\$1human | 上述内存消耗的人类可读版本 | 

### `search_index_stats` 部分
<a name="vector-search-ft.info-search_index_stats"></a>


| 名称 | 说明 | 
| --- | --- | 
| search\$1number\$1of\$1indexes | 已创建的索引数量 | 
| search\$1num\$1fulltext\$1indexes | 所有索引中非向量字段的数量 | 
| search\$1num\$1vector\$1indexes | 所有索引中向量字段的数量 | 
| search\$1num\$1hash\$1indexes | 哈希类型键索引数量 | 
| search\$1num\$1json\$1indexes | JSON 类型键索引数量 | 
| search\$1total\$1indexed\$1keys | 所有索引键总数 | 
| search\$1total\$1indexed\$1vectors | 所有索引中的向量总数 | 
| search\$1total\$1indexed\$1hash\$1keys | 所有索引中的哈希类型键总数 | 
| search\$1total\$1indexed\$1json\$1keys | 所有索引中的 JSON 类型键总数 | 
| search\$1total\$1index\$1size | 所有索引使用的字节数 | 
| search\$1total\$1fulltext\$1index\$1size | 非向量索引结构使用的字节数 | 
| search\$1total\$1vector\$1index\$1size | 向量索引结构使用的字节数 | 
| search\$1max\$1index\$1lag\$1ms | 上次摄取批量更新期间的摄取延迟 | 

### `search_ingestion` 部分
<a name="vector-search-ft.info-search_ingestion"></a>


| 名称 | 说明 | 
| --- | --- | 
| search\$1background\$1indexing\$1status | 摄取状态。NO\$1ACTIVITY 表示闲置。其他值表示有键正在进行摄取。 | 
| search\$1ingestion\$1paused | 除了在重新启动期间，此值始终应为“no”。 | 

### `search_backfill` 部分
<a name="vector-search-ft.info-search_backfill"></a>

**注意**  
本部分中记录的某些字段只有在当前存在回填操作时才可见。


| Name | 说明 | 
| --- | --- | 
| search\$1num\$1active\$1backfills | 当前回填活动数量 | 
| search\$1backfills\$1paused | 除非内存不足，否则此值始终应为“no”。 | 
| search\$1current\$1backfill\$1progress\$1percentage | 当前回填的完成百分比（0-100） | 

### `search_query` 部分
<a name="vector-search-ft.info-search_query"></a>


| 名称 | 说明 | 
| --- | --- | 
| search\$1num\$1active\$1queries | 当前正在执行的 FT.SEARCH 和 FT.AGGREGATE 命令的数量 | 

## 向量搜索安全
<a name="vector-search-security"></a>

针对命令和数据访问的 [ACL（访问控制列表）](https://valkey.io/topics/acl/)安全机制已扩展到控制搜索工具。系统完全支持针对单个搜索命令进行 ACL 控制。提供了一个新的 ACL 类别 `@search`，并更新了许多现有类别（`@fast`、`@read`、`@write` 等），以包含新命令。搜索命令不会修改键数据，这意味着将保留现有的 ACL 写入访问机制。哈希和 JSON 操作的访问规则不因索引的存在而改变；这些命令仍然受到普通键级别访问控制的约束。

带索引的搜索命令也可以通过 ACL 进行访问控制。访问检查在整个索引级别执行，而不是在每个键级别执行。这意味着，只有当用户有权访问该索引键空间前缀列表中所有可能的键时，系统才会向该用户授予对该索引的访问权限。换句话说，索引的实际内容并不能控制访问权限。用于安全检查的是前缀列表定义的索引理论内容。很容易造成这样一种情况：用户对密钥具有读 and/or 写权限，但无法访问包含该密钥的索引。请注意，创建或使用索引只需要具有对键空间的读取访问权限，而不考虑是否有写入访问权限。

有关与 MemoryDB ACLs 配合使用的更多信息，请参阅使用[访问控制列表对用户进行身份验证](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html) ()。ACLs

# 使用案例
<a name="vector-search-examples"></a>

以下是向量搜索使用案例。

## 检索增强生成（RAG）
<a name="vector-search-examples-retrieval-augmented-generation"></a>

检索增强生成（RAG）利用向量搜索从大型数据语料库中检索相关段落，以增强大型语言模型（LLM）。具体而言，编码器会将输入上下文和搜索查询嵌入向量，然后使用近似的最近邻搜索找到语义相似段落。这些检索到的段落会与原始上下文连接在一起，为 LLM 提供额外相关信息，从而向用户返回更准确的响应。

![\[检索增强生成流程图\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/RAG.png)


## 持久语义缓存
<a name="vector-search-examples-durable-semantic-cache"></a>

语义缓存是通过存储来自 FM 的先前结果来降低计算成本的过程。通过重复使用先前推断的结果而不是重新计算这些结果，语义缓存减少了通过推理期间所需的计算量。 FMsMemoryDB 支持持久语义缓存，从而避免丢失过往推断的数据。这使您的生成式人工智能应用程序能够在几毫秒内响应，提供先前语义相似问题的答案，同时通过避免不必要的 LLM 推断来降低成本。

![\[显示基础模型流程的工作流程图。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/FM.png)

+ **语义搜索命中** – 如果根据定义的相似度分数，客户的查询在语义上与前一个问题相似，FM 缓冲区内存（MemoryDB）会在第 4 步中返回前一个问题的答案，并且不会通过第 3 步调用 FM。这将避免基础模型（FM）延迟和相关成本，为客户提供更快的体验。
+ **语义搜索未命中** – 如果根据定义的相似度分数，客户的查询在语义上与之前的查询不相似，则客户将在第 3a 步中调用 FM 提供对客户的响应。然后，从 FM 生成的响应将作为向量存储到 MemoryDB 中，供将来的查询使用（第 3b 步），以最大限度地降低语义相似问题上的 FM 成本。在此流程中，由于原始查询没有语义上相似的问题，因此不会调用第 4 步。

## 欺诈侦测
<a name="vector-search-examples-fraud-detection"></a>

欺诈检测是一种异常检测形式，在它将有效事务表示为向量，并与全新事务的向量表示进行比较。当这些全新事务的向量与表示有效事务数据的向量相似性较低时，就会检测到欺诈。这样就可以通过对正常行为进行建模来检测欺诈，而不必试图预测每一个可能的欺诈实例。通过 MemoryDB，组织能够在高吞吐量时期执行此操作，最大程度减少误报，并保持毫秒级低延迟。

![\[显示了欺诈检测流程的工作流程图。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/fraud-detection.png)


## 其他使用案例
<a name="vector-search-engines"></a>
+ **推荐引擎**可以通过将内容表示为向量，来为用户找到相似产品或内容。向量是通过对属性和模式进行分析而创建的。根据用户模式和属性，通过查找与已获得用户正面评价的内容相似度最高的向量，可以向用户推荐之前未看到过的新内容。
+ **文档搜索引擎**将文本文档表示为密集数字向量并捕捉语义。在搜索时，引擎会将搜索查询转换为向量，并使用近似近邻搜索来查找与查询向量相似度最高的文档。这种向量相似度方法允许根据语义而不仅仅是根据关键字的匹配来匹配文档。

# 向量搜索功能和限制
<a name="vector-search-limits"></a>

## 向量搜索可用性
<a name="vector-search-availability"></a>

R6g、r7g 和 t4g 节点类型支持支持向量搜索的 MemoryDB 配置，并且适用于所有可用 MemoryDB 的区域。 AWS 

无法修改现有集群来启用搜索。但是，可以根据已禁用搜索的集群的快照来创建已启用搜索的集群。

## 参数限制
<a name="parameter-restrictions"></a>

下表列出了各种向量搜索项目的限制：


| Item | 最大值 | 
| --- | --- | 
| 向量中的维数 | 32768 | 
| 可以创建的索引数量 | 10 | 
| 索引中的字段数量 | 50 | 
| FT.SEARCH 和 FT.AGGREGATE TIMEOUT 子句（毫秒） | 10000 | 
| FT.AGGREGATE 命令中的管道阶段数量 | 32 | 
| FT.AGGREGATE LOAD 子句中的字段数量 | 1024 | 
| FT.AGGREGATE GROUPBY 子句中的字段数量 | 16 | 
| FT.AGGREGATE SORTBY 子句中的字段数量 | 16 | 
| FT.AGGREGATE PARAM 子句中的参数数量 | 32 | 
| HNSW M 参数 | 512 | 
| HNSW EF\$1CONSTRUCTION 参数 | 4096 | 
| HNSW EF\$1RUNTIME 参数 | 4096 | 

## 扩展限制
<a name="scaling-restrictions"></a>

MemoryDB 的向量搜索目前仅限于单个分片，不支持水平扩展。向量搜索支持垂直扩展和副本扩展。

## 操作限制
<a name="operational-restrictions"></a>

**索引持久性和回填**

向量搜索特征保留索引定义和索引内容。这意味着，在任何导致节点启动或重启的操作请求或事件中，索引定义和内容将从最新的快照中恢复，并从多可用区事务日志中读取任何待处理的交易。无需用户执行任何操作即可启动此操作。数据恢复后，重建过程将作为回填操作执行。这在功能上等同于系统自动为每个定义的索引执行 [FT.CREATE](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.create.html) 命令。请注意，数据恢复后，很可能在索引回填完成之前，节点便可用于应用程序操作，这意味着应用程序将再次看到回填，例如，使用回填索引的搜索命令可能会遭到拒绝。有关回填的更多信息，请参阅[向量搜索概述索引以及 Valkey 和 Redis OSS 键空间](vector-search-overview.md#vector-search-indexes-keyspaces)。

索引回填的完成在主索引和副本之间不同步。应用程序可能会意外看到这种不同步的情况，因此建议应用程序在启动搜索操作之前，先在主副本和所有副本上验证回填完成情况。

## 快照 import/export 和实时迁移
<a name="snapshot-restrictions"></a>

搜索索引存在于 RDB 文件中，这会限制数据兼容传输。只有另一个启用了 MemoryDB 向量的集群才能理解由 MemoryDB 向量搜索功能定义的向量索引格式。此外，预览集群中的 RDB 文件可以由 GA 版本的 MemoryDB 集群导入，它将在加载 RDB 文件时重建索引内容。

但是，不包含索引的 RDB 文件不受这种限制。因此，只要在导出前删除索引，就可以将预览群集中的数据导出到非预览群集。

## 内存消耗
<a name="memory-consumption"></a>

 内存消耗基于向量数、维度数、M 值和非向量数据量，例如与向量关联的元数据或实例中存储的其他数据。

所需的总存储空间是实际向量数据所需空间和向量索引所需空间的组合。计算向量数据所需空间时，需要测量在 HASH 或 JSON 数据结构中存储向量所需的实际容量，以及为实现优化内存分配而需向最近的内存块增加的额外开销。每个向量索引都使用对存储在这些数据结构中的向量数据的引用，并使用有效的内存优化来删除索引中向量数据的任何重复副本。

向量的数量取决于您将数据表示为向量的方式。例如，您可以选择将单个文档表示成几个块，其中每个块表示一个向量。或者，您可以选择将整个文档表示为单个向量。

向量的维数取决于您选择的嵌入模型。例如，如果您选择使用 [AWS Titan](https://aws.amazon.com/bedrock/titan/) 嵌入模型，则维数将为 1536。

M 参数表示在索引构造期间为每个新元素创建的双向链接数。MemoryDB 将此值默认为 16；但您可以重写此设置。较高的 M 参数更适合高维度 and/or 高召回率要求，而低 M 参数更适合低维度 and/or 低召回要求。M 值会随着索引变大而增加内存消耗，从而使得总体内存消耗变得更高。

在控制台体验中，MemoryDB 提供了一种在集群设置下选中“启用向量搜索”后，根据向量工作负载的特性选择正确实例类型的简便方法。

![\[AWS 控制台中的矢量搜索集群设置。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/vector-search-cluster-settings-console.png)




**示例工作负载**

客户希望以其内部财务文件为基础构建一个语义搜索引擎。他们目前持有 100 万份财务文档，使用具有 1536 个维度的 Titan 嵌入模型将每个文档分成 10 个向量，并且没有非向量数据。客户决定使用默认值 16 作为 M 参数。
+ 向量：100 万 \$1 10 个块 = 1000 万个向量
+ 维度：1536
+ 非向量数据（GB）：0 GB
+ M 参数：16

有了这些数据，客户可以在控制台中单击使用向量计算器按钮，根据其参数获取推荐的实例类型：

![\[向量计算器根据计算器的输入推荐节点类型。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/vector-calc1.png)


![\[已输入值的向量计算器。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/vector-calc2.png)


在此示例中，向量计算器将根据提供的参数寻找最小的 [MemoryDB r7g 节点类型](https://aws.amazon.com/memorydb/pricing/)，该类型可以容纳存储向量所需的存储空间。请注意，这是一个近似值，您应该测试该实例类型以确保它符合您的要求。



根据上述计算方法和示例工作负载中的参数，此向量数据将需要 104.9 GB 来存储数据和单个索引。在这种情况下，因为 `db.r7g.4xlarge` 实例类型有 105.81 GB 的可用存储空间，所以建议使用这种实例类型。下一个更小的节点类型太小，无法承载向量工作负载。

由于每个向量索引都使用对所存储向量数据的引用，并且不会在向量索引中创建向量数据的额外副本，因此索引消耗的空间也相对较少。这在创建多个索引时以及部分向量数据已删除的情况下很有用，并且重建 HNSW 图将有助于建立适宜的节点连接，从而实现高质量的向量搜索结果。

## 在回填期间内存不足
<a name="out-of-memory-backfill"></a>

与 Valkey 和 Redis OSS 写入操作类似，索引回填会受到限制。 out-of-memory如果引擎内存在回填过程中已满，则所有回填都将暂停。有可用内存后，回填过程会恢复。当由于内存不足导致回填暂停时，也可以删除内容和编制索引。

## 事务
<a name="transactions"></a>

命令`FT.CREATE`、、、`FT.DROPINDEX``FT.ALIASADD``FT.ALIASDEL`、和`FT.ALIASUPDATE`不能在事务上下文中执行，也就是说，不能在 MULTI/EXEC 区块内或在 LUA 或 FUNCTION 脚本中执行。

# 创建已启用向量搜索的集群
<a name="vector-search-cluster"></a>

您可以使用 AWS 管理控制台、或，创建启用矢量搜索的集群 AWS Command Line Interface。根据方法的不同，必须考虑启用向量搜索。

## 使用 AWS 管理控制台
<a name="vector-search-console"></a>

要在控制台中创建支持向量搜索的集群，您需要在**集群**设置下启用向量搜索。在单个分片配置，向量搜索适用于 MemoryDB 版本 7.1。

![\[在选中“启用向量搜索”选项的情况下查看集群设置，可以看到有关特定版本和配置支持的信息。\]](http://docs.aws.amazon.com/zh_cn/memorydb/latest/devguide/images/vs-2.png)


有关在中使用矢量搜索的更多信息 AWS 管理控制台，请参阅[创建集群（控制台）](getting-started.md#clusters.createclusters.viewdetails.cluster)。

## 使用 AWS Command Line Interface
<a name="vector-search-cli"></a>

要创建启用向量搜索的 MemoryDB 集群，可以使用 MemoryDB [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-cluster.html) 命令，通过传递不可变参数组 `default.memorydb-redis7.search` 来启用向量搜索功能。

```
aws memorydb create-cluster \
  --cluster-name <value> \
  --node-type <value> \
  --engine redis \
  --engine-version 7.1 \
  --num-shards 1 \
  --acl-name <value> \
  --parameter-group-name default.memorydb-redis7.search
```

或者，您还可以创建新的参数组来启用向量搜索，如以下示例所示。您可以在[此处](parametergroups.management.md)了解有关参数组的更多信息。

```
aws memorydb create-parameter-group \
  --parameter-group-name my-search-parameter-group \
  --family memorydb_redis7
```

接下来，在新创建的参数组中将参数 search-enabled 更新为“是”。

```
aws memorydb update-parameter-group \
  --parameter-group-name my-search-parameter-group \
  --parameter-name-values "ParameterName=search-enabled,ParameterValue=yes"
```

现在，您可以使用此自定义参数组代替默认参数组，在 MemoryDB 集群上启用向量搜索。

# 向量搜索命令
<a name="vector-search-commands"></a>

以下是受支持的向量搜索命令列表。

**Topics**
+ [FT.CREATE](vector-search-commands-ft.create.md)
+ [FT.SEARCH](vector-search-commands-ft.search.md)
+ [FT.AGGREGATE](vector-search-commands-ft.aggregate.md)
+ [FT.DROPINDEX](vector-search-commands-ft.dropindex.md)
+ [FT.INFO](vector-search-commands-ft.info.md)
+ [FT.\$1LIST](vector-search-commands-ft.list.md)
+ [FT.ALIASADD](vector-search-commands-ft.aliasadd.md)
+ [FT.ALIASDEL](vector-search-commands-ft.aliasdel.md)
+ [FT.ALIASUPDATE](vector-search-commands-ft.aliasupdate.md)
+ [FT.\$1ALIASLIST](vector-search-commands-ft.aliaslist.md)
+ [FT.PROFILE](vector-search-commands-ft.profile.md)
+ [FT.EXPLAIN](vector-search-commands-ft.explain.md)
+ [FT.EXPLAINCLI](vector-search-commands-ft.explain-cli.md)

# FT.CREATE
<a name="vector-search-commands-ft.create"></a>

 创建索引并启动该索引的回填。有关更多信息，请参阅[向量搜索概述](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-overview.html)，了解索引构造的详细信息。

**语法**

```
FT.CREATE <index-name>
ON HASH | JSON
[PREFIX <count> <prefix1> [<prefix2>...]]
SCHEMA 
(<field-identifier> [AS <alias>] 
  NUMERIC 
| TAG [SEPARATOR <sep>] [CASESENSITIVE] 
| TEXT
| VECTOR [HNSW|FLAT] <attr_count> [<attribute_name> <attribute_value>])

)+
```

**架构**
+ 字段标识符：
  + 对于哈希键，字段标识符是一个字段名称。
  + 对于 JSON 密钥，字段标识符是一个 JSON 路径。

  有关更多信息，请参阅 [索引字段类型](vector-search-overview.md#vector-search-index-field-types)。
+ 字段类型：
  + TAG：有关更多信息，请参阅[标签](https://redis.io/docs/interact/search-and-query/advanced-concepts/tags/)。
  + NUMERIC：字段包含一个数字。
  + TEXT：字段包含任何数据块。
  + VECTOR：支持向量搜索的向量字段。
    + 算法 – 可以是 HNSW（分层可导航小世界）或 FLAT（暴力）。
    + `attr_count` – 将作为算法配置传递的属性数量，包括名称和值。
    + `{attribute_name} {attribute_value}`— 定义索引配置的特定算法 key/value 对。

      对于 FLAT 算法，属性为：

      必需：
      + DIM – 向量中的维度数。
      + DISTANCE\$1METRIC – 可以是 [L2 \$1 IP \$1 COSINE] 之一。
      + TYPE – 向量类型。`FLOAT32` 是一种受支持的类型。

      可选：
      + INITIAL\$1CAP – 索引中影响索引内存分配大小的初始向量容量。

      对于 HNSW 算法，属性为：

      必需：
      + TYPE – 向量类型。`FLOAT32` 是一种受支持的类型。
      + DIM – 向量维度，以正整数形式指定。最大值：32768
      + DISTANCE\$1METRIC – 可以是 [L2 \$1 IP \$1 COSINE] 之一。

      可选：
      + INITIAL\$1CAP – 索引中影响索引内存分配大小的初始向量容量。默认为 1024。
      + M – 图中每层中每个节点允许的最大出站边缘数量。在零层，出站边缘的最大数目将为 2M。默认值为 16，最大值为 512。
      + EF\$1CONSTRUCTION – 控制索引构建期间检查的向量数量。此参数的值越大，查准率就越高，但索引创建时间也会越长。默认值为 200。最大值为 4096。
      + EF\$1RUNTIME – 控制查询操作期间检查的向量数量。此参数的值越大，查全率就越高，但查询时间也会越长。可以在查询时覆盖此参数的值。默认值为 10。最大值为 4096。

**Return**

返回简单的字符串 OK 消息或错误响应。

**示例**

**注意**  
以下示例使用 [valkey-cli](https://valkey.io/topics/cli/) 的原生参数，例如在将数据发送到 Valkey 或 Redis OSS 之前，对数据去引号和去转义。要使用其他编程语言客户端（Python、Ruby、C\$1 等），请遵循这些环境处理字符串和二进制数据的处理规则。有关支持的客户端的更多信息，请参阅[构建工具 AWS](https://aws.amazon.com/developer/tools/)

**Example 1：创建一些索引**  
为大小为 2 的向量创建索引  

```
FT.CREATE hash_idx1 ON HASH PREFIX 1 hash: SCHEMA vec AS VEC VECTOR HNSW 6 DIM 2 TYPE FLOAT32 DISTANCE_METRIC L2
OK
```
使用 HNSW 算法创建 6 维 JSON 索引：  

```
FT.CREATE json_idx1 ON JSON PREFIX 1 json: SCHEMA $.vec AS VEC VECTOR HNSW 6 DIM 6 TYPE FLOAT32 DISTANCE_METRIC L2
OK
```

**Example 示例 2：填入一些数据**  
对以下命令进行格式化，使其可以作为 redis-cli 终端程序的参数执行。使用编程语言客户端（例如，Python、Ruby、C\$1）的开发人员需要遵循其环境有关处理字符串和二进制数据的处理规则。  
创建一些哈希和 json 数据：  

```
HSET hash:0 vec "\x00\x00\x00\x00\x00\x00\x00\x00"
HSET hash:1 vec "\x00\x00\x00\x00\x00\x00\x80\xbf"
JSON.SET json:0 . '{"vec":[1,2,3,4,5,6]}'
JSON.SET json:1 . '{"vec":[10,20,30,40,50,60]}'
JSON.SET json:2 . '{"vec":[1.1,1.2,1.3,1.4,1.5,1.6]}'
```
注意以下几点：  
+ 哈希和 JSON 数据的键具有索引定义的前缀。
+ 向量位于索引定义的相应路径上。
+ 哈希向量以十六进制数据形式输入，而 JSON 数据以数字形式输入。
+ 向量的长度适当，二维哈希向量条目包含两个浮点数的十六进制数据，六维 JSON 向量条目包含六个数字。

**Example 示例 3：删除并重新创建索引**  

```
FT.DROPINDEX json_idx1
OK

FT.CREATE json_idx1 ON JSON PREFIX 1 json: SCHEMA $.vec AS VEC VECTOR FLAT 6 DIM 6 TYPE FLOAT32 DISTANCE_METRIC L2
OK
```
请注意，新的 JSON 索引使用 `FLAT` 算法而不是 `HNSW` 算法。另请注意，将重新为现有的 JSON 数据编制索引：  

```
FT.SEARCH json_idx1 "*=>[KNN 100 @VEC $query_vec]" PARAMS 2 query_vec "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" DIALECT 2
1) (integer) 3
2) "json:2"
3) 1) "__VEC_score"
   2) "11.11"
   3) "$"
   4) "[{\"vec\":[1.1, 1.2, 1.3, 1.4, 1.5, 1.6]}]"
4) "json:0"
5) 1) "__VEC_score"
   2) "91"
   3) "$"
   4) "[{\"vec\":[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}]"
6) "json:1"
7) 1) "__VEC_score"
   2) "9100"
   3) "$"
   4) "[{\"vec\":[10.0, 20.0, 30.0, 40.0, 50.0, 60.0]}]"
```

# FT.SEARCH
<a name="vector-search-commands-ft.search"></a>

使用提供的查询表达式查找索引中的键。找到后，可以返回这些键中索引字段的计数 and/or 内容。有关更多信息，请参阅[向量搜索查询表达式](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-overview.html#vector-search-query-expression)。

要创建在这些示例中使用的数据，请参阅 [FT.CREATE](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.create.html) 命令。

**语法**

```
FT.SEARCH <index-name> <query>
[RETURN <token_count> (<field-identifier> [AS <alias>])+]
[TIMEOUT timeout] 
[PARAMS <count> <name> <value> [<name> <value>]]
[LIMIT <offset> <count>]
[COUNT]
```
+ RETURN：此子句确定返回键的哪些字段。每个字段的可选 AS 子句会在结果中覆盖该字段的名称。只能指定已为此索引声明的字段。
+ LIMIT: <offset><count>：此子句提供分页功能，仅返回满足偏移量和计数值的键。如果省略此子句，则默认为“LIMIT 0 10”，即最多返回 10 个键。
+ PARAMS：键值对数量的两倍。可以在查询表达式中引用参数 key/value 对。有关更多信息，请参阅[向量搜索查询表达式](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-overview.html#vector-search-query-expression)。
+ COUNT：此子句不返回键的内容，只返回键的数量。这就相当于使用“LIMIT 0 0”。

**Return**

返回数组或错误响应。
+ 如果操作成功完成，则返回一个数组。第一个元素是与查询匹配的键的总数。其余元素是键名称和字段列表配对。字段列表是另一个数组，包含字段名称和对应值的配对。
+ 如果索引正在回填，该命令会立即返回错误响应。
+ 如果超时，该命令将返回错误响应。

**示例：进行一些搜索**

**注意**  
以下示例使用 [valkey-cli](https://valkey.io/topics/cli/) 的原生参数，例如在将数据发送到 Valkey 或 Redis OSS 之前，对数据去引号和去转义。要使用其他编程语言客户端（Python、Ruby、C\$1 等），请遵循这些环境处理字符串和二进制数据的处理规则。有关支持的客户端的更多信息，请参阅[构建工具 AWS](https://aws.amazon.com/developer/tools/)

**哈希值搜索**

```
FT.SEARCH hash_idx1 "*=>[KNN 2 @VEC $query_vec]" PARAMS 2 query_vec "\x00\x00\x00\x00\x00\x00\x00\x00" DIALECT 2
1) (integer) 2
2) "hash:0"
3) 1) "__VEC_score"
   2) "0"
   3) "vec"
   4) "\x00\x00\x00\x00\x00\x00\x00\x00"
4) "hash:1"
5) 1) "__VEC_score"
   2) "1"
   3) "vec"
   4) "\x00\x00\x00\x00\x00\x00\x80\xbf"
```

将生成两个结果，按分数排序，即按与查询向量的距离（以十六进制输入）排序。

**JSON 搜索**

```
FT.SEARCH json_idx1 "*=>[KNN 2 @VEC $query_vec]" PARAMS 2 query_vec "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" DIALECT 2
1) (integer) 2
2) "json:2"
3) 1) "__VEC_score"
   2) "11.11"
   3) "$"
   4) "[{\"vec\":[1.1, 1.2, 1.3, 1.4, 1.5, 1.6]}]"
4) "json:0"
5) 1) "__VEC_score"
   2) "91"
   3) "$"
   4) "[{\"vec\":[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}]"
```

将生成两个最接近的结果，按分数排序，请注意，JSON 向量值会转换为浮点数，查询向量仍然是向量数据。另请注意，由于 `KNN` 参数为 2，因此只返回两个结果。值越大，返回的结果越多：

```
FT.SEARCH json_idx1 "*=>[KNN 100 @VEC $query_vec]" PARAMS 2 query_vec "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" DIALECT 2
1) (integer) 3
2) "json:2"
3) 1) "__VEC_score"
   2) "11.11"
   3) "$"
   4) "[{\"vec\":[1.1, 1.2, 1.3, 1.4, 1.5, 1.6]}]"
4) "json:0"
5) 1) "__VEC_score"
   2) "91"
   3) "$"
   4) "[{\"vec\":[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}]"
6) "json:1"
7) 1) "__VEC_score"
   2) "9100"
   3) "$"
   4) "[{\"vec\":[10.0, 20.0, 30.0, 40.0, 50.0, 60.0]}]"
```

# FT.AGGREGATE
<a name="vector-search-commands-ft.aggregate"></a>

FT.SEARCH 命令的超集，允许对查询表达式选择的键进行大量额外处理。

**语法**

```
FT.AGGREGATE index query
  [LOAD * | [count field [field ...]]]
  [TIMEOUT timeout]
  [PARAMS count name value [name value ...]]
  [FILTER expression]
  [LIMIT offset num]  
  [GROUPBY count property [property ...] [REDUCE function count arg [arg ...] [AS name] [REDUCE function count arg [arg ...] [AS name] ...]] ...]] 
  [SORTBY count [ property ASC | DESC [property ASC | DESC ...]] [MAX num]] 
  [APPLY expression AS name]
```
+ FILTER、LIMIT、GROUPBY、SORTBY 和 APPLY 子句可以任意次数重复，并且可以自由混合使用。它们按指定的顺序应用，其中一个子句的输出作为下一个子句的输入。
+ 在上述语法中，“属性”要么是在 [FT.CREATE](https://docs.aws.amazon.com/memorydb/latest/devguide/vector-search-commands-ft.create.html) 命令中为此索引声明的字段，要么是之前的 APPLY 子句或 REDUCE 函数的输出。
+ LOAD 子句仅限于加载已在索引中声明的字段。“LOAD \$1”将加载索引中声明的所有字段。
+ 支持以下 reducer 函数：COUNT、COUNT\$1DISTINCTISH、SUM、MIN、MAX、AVG、STDDEV、QUANTILE、TOLIST、FIRST\$1VALUE 和 RANDOM\$1SAMPLE。有关更多信息，请参阅[聚合](https://redis.io/docs/interact/search-and-query/search/aggregations/)。
+ LIMIT <offset><count>：保留从 <offset> 开始的记录，并持续保留 <count> 条记录，所有其他记录都将丢弃。
+ PARAMS：键值对数量的两倍。可以在查询表达式中引用参数 key/value 对。

**Return**

返回数组或错误响应。
+ 如果操作成功完成，则返回一个数组。第一个元素是没有特殊含义的整数（应忽略）。其余元素是最后一个阶段输出的结果。每个元素都是由字段名称和值对组成的数组。
+ 如果索引正在回填，该命令会立即返回错误响应。
+ 如果超时，该命令将返回错误响应。

# FT.DROPINDEX
<a name="vector-search-commands-ft.dropindex"></a>

删除一个索引。将删除索引定义和相关内容。键不受影响。

**语法**

```
FT.DROPINDEX <index-name>
```

**Return**

返回一条简单的字符串 OK 消息或错误响应。

# FT.INFO
<a name="vector-search-commands-ft.info"></a>

**语法**

```
FT.INFO <index-name>
```

FT.INFO 页面的输出是由键值对组成的数组，如下表所述：


| 键 | 值类型 | 说明 | 
| --- | --- | --- | 
| index\$1name | 字符串 | 索引的名称 | 
| creation\$1timestamp | 整数 | 创建时间的 Unix 样式时间戳 | 
| key\$1type | 字符串 | 哈希或 JSON | 
| key\$1prefixes | 字符串数组 | 此索引的键前缀 | 
| fields | 字段信息数组 | 此索引的字段 | 
| space\$1usage | 整数 | 此索引使用的内存字节数 | 
| fullext\$1space\$1usage | 整数 | 非向量字段使用的内存字节数 | 
| vector\$1space\$1usage | 整数 | 向量字段使用的内存字节数 | 
| num\$1docs | 整数 | 当前包含在索引中的键数 | 
| num\$1indexed\$1vectors | 整数 | 当前包含在索引中的向量数 | 
| current\$1lag | 整数 | 最近的摄取延迟（毫秒） | 
| backfill\$1status | 字符串 | 其中之一：已完成 InProgres、已暂停或失败  | 

下表描述了每个字段的信息：


| Key | 值类型 | 说明 | 
| --- | --- | --- | 
| identifier | 字符串 | 字段名称 | 
| field\$1name | 字符串 | 哈希成员名称或 JSON 路径 | 
| 类型 | 字符串 | 以下类型之一：“Numeric”、“Tag”、“Text”或“Vector” | 
| option | 字符串 | 忽略 | 

如果字段的类型为 Vector，则根据算法的不同，可能会包含额外信息。

HNSW 算法：


| Key | 值类型 | 说明 | 
| --- | --- | --- | 
| algorithm | 字符串 | HNSW | 
| data\$1type | 字符串 | FLOAT32 | 
| distance\$1metric | 字符串 | 以下值之一：“L2”、“IP”或“Cosine” | 
| initial\$1capacity | 整数 | 向量字段索引的初始大小 | 
| current\$1capacity | 整数 | 向量字段索引的当前大小 | 
| maximum\$1edges | 整数 | 创建时的 M 参数 | 
| ef\$1construction | 整数 | 创建时的 EF\$1CONSTRUCTION 参数 | 
| ef\$1runtime | 整数 | 创建时的 EF\$1RUNTIME 参数 | 

FLAT 算法：


| Key | 值类型 | 说明 | 
| --- | --- | --- | 
| algorithm | 字符串 | FLAT | 
| data\$1type | 字符串 | FLOAT32 | 
| distance\$1metric | 字符串 | 以下值之一：“L2”、“IP”或“Cosine” | 
| initial\$1capacity | 整数 | 向量字段索引的初始大小 | 
| current\$1capacity | 整数 | 向量字段索引的当前大小 | 

# FT.\$1LIST
<a name="vector-search-commands-ft.list"></a>

列出所有索引。

**语法**

```
FT._LIST 
```

**Return**

返回索引名称数组

# FT.ALIASADD
<a name="vector-search-commands-ft.aliasadd"></a>

为索引添加别名。新别名可以在需要索引名称的任何位置使用。

**语法**

```
FT.ALIASADD <alias> <index-name> 
```

**Return**

返回一条简单的字符串 OK 消息或错误响应。

# FT.ALIASDEL
<a name="vector-search-commands-ft.aliasdel"></a>

删除索引的现有别名。

**语法**

```
FT.ALIASDEL <alias>
```

**Return**

返回一条简单的字符串 OK 消息或错误响应。

# FT.ALIASUPDATE
<a name="vector-search-commands-ft.aliasupdate"></a>

更新现有别名以指向不同的物理索引。该命令只影响将来对别名的引用。当前正在进行的操作（FT.SEARCH、FT.AGGREGATE）不受此命令的影响。

**语法**

```
FT.ALIASUPDATE <alias> <index>
```

**Return**

返回一条简单的字符串 OK 消息或错误响应。

# FT.\$1ALIASLIST
<a name="vector-search-commands-ft.aliaslist"></a>

列出索引别名。

**语法**

```
FT._ALIASLIST
```

**Return**

返回一个数组，其大小与当前别名的数量相同。此数组的每个元素都是别名索引对。

# FT.PROFILE
<a name="vector-search-commands-ft.profile"></a>

运行查询并返回有关该查询的配置文件信息。

**语法**

```
FT.PROFILE 

<index>
SEARCH | AGGREGATE 
[LIMITED]
QUERY <query ....>
```

**Return**

由两个元素组成的数组。第一个元素是分析 `FT.SEARCH` 或 `FT.AGGREGATE` 命令的结果。第二个元素是由性能和分析信息组成的数组。

# FT.EXPLAIN
<a name="vector-search-commands-ft.explain"></a>

解析查询并返回有关如何解析该查询的信息。

**语法**

```
FT.EXPLAIN <index> <query>
```

**Return**

包含解析结果的字符串。

# FT.EXPLAINCLI
<a name="vector-search-commands-ft.explain-cli"></a>

与 FT.EXPLAIN 命令相同，除了结果以更适合 redis-cli 的不同格式显示。

**语法**

```
FT.EXPLAINCLI <index> <query>
```

**Return**

包含解析结果的字符串。