c#依赖腾讯向量数据库实现商品相似度检索_c#中向量数据库

本文介绍可用于实现商品检索，商品相似度推荐，根据用户行为标签用户推荐。
使用之前需要对向量数据库和Embedding有一些基本的了解，目前国产的向量产品我体验下来发现腾讯的是封装的比较简单的，同时腾讯也开源了向量模型不需要我们自建，为小公司使用节约了资源。

具体什么是向量数据库我这就不过多介绍了，下面我们只讲在c#中如何实现。

具体实现方法如下

1. 需先申请腾讯向量数据库，目前是公测阶段不收取费用。但是需要申请审核。
   

2. 开通Embedding功能，此功能是根据模型数据向量化。
   

3. 可以直接登录在腾讯数据库控制台创建db也可以通过接口创建
   

4. 创建一个collection用于存放数据
   

5. 选择插入数据，此时我们并不知道需要插入的数据的向量值是多少，此功能插入会自动转化向量
   

6. 然后我们就可以通过查询接口查询到数据了
   

下面是c#中实现的代码

下载地址
使用方法

  /// <summary>
    /// 腾讯向量数据库api
    /// </summary>
    [Route("[controller]/[action]")]
    public class API_TencentVectorDBController : Controller
    {
        /// <summary>
        /// 创建库
        /// </summary>
        /// <param name="database"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DataBaseCreate(string database)
        {
            var ret = DataBase_Handle.Create(database);
            return Json(ret);
        }

        /// <summary>
        /// 删除库
        /// </summary>
        /// <param name="database"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DataBaseDrop(string database)
        {
            var ret = DataBase_Handle.Drop(database);
            return Json(ret);
        }

        /// <summary>
        /// 获取库
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DataBaseGetList()
        {
            var ret = DataBase_Handle.GetList();
            return Json(ret);
        }

        /// <summary>
        /// 创建集合
        /// </summary>
        /// <param name="createEntity">集合基本对象，创建时indexes为空即可</param>
        /// <param name="embedding">向量对象</param>
        /// <param name="indexType">向量指定索引类型</param>
        /// <param name="dimension">指定向量维度[1,4096]，如果配置Embedding则为空</param>
        /// <param name="metricType">指定向量之间距离度量的算法L2,IP,COSINE</param>
        /// <param name="fileds">其他字段</param>
        /// <param name="nlist">指索引中的聚类中心数量。取值类型：uint64。取值范围：[1,65536]</param>
        /// <param name="M">indexType类型为HNSW时为每个节点在检索构图中可以连接多少个邻居节点一般可是只为16，其余的则为 指乘积量化中每个子向量的维度</param>
        /// <param name="efConstruction">搜索时，指定寻找节点邻居遍历的范围。数值越大构图效果越好，构图时间越长一般可设置为200</param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CollectionCreate(Collection_Entity.CollectionEntity createEntity,string embedding, string indexType, int? dimension, string metricType, string fileds, int? nlist = null, int? M = 16, int? efConstruction = 200)
        {
            //向量信息
            if (!string.IsNullOrEmpty(embedding))
            {
                createEntity.embedding = JsonConvert.DeserializeObject<Collection_Entity.Embedding>(embedding);
            }

            //字段信息
            List<string> _fileds = new List<string> { };
            if (!string.IsNullOrEmpty(fileds))
            {
                _fileds = JsonConvert.DeserializeObject<List<string>>(fileds);
            }

            //创建向量集合
            var ret = Collection_Handle.Create(createEntity, indexType, dimension, metricType, _fileds, nlist, M, efConstruction);

            return Json(ret);
        }

        /// <summary>
        /// 删除集合
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CollectionDrop(MySQLCommon.MC_VectorDb.Tencent.Common.BaseEntity entity)
        {
            var ret = Collection_Handle.Drop(entity);
            return Json(ret);
        }

        /// <summary>
        /// 查询指定的库包含的所有集合
        /// </summary>
        /// <param name="database"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CollectionList(string database)
        {
            var ret = Collection_Handle.List(database);
            return Json(ret);
        }

        /// <summary>
        /// 获取集合信息
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CollectionDescribe(MySQLCommon.MC_VectorDb.Tencent.Common.BaseEntity entity)
        {
            var ret = Collection_Handle.Describe(entity);
            return Json(ret);
        }

        /// <summary>
        /// 清空指定集合的数据与索引
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CollectionTruncate(MySQLCommon.MC_VectorDb.Tencent.Common.BaseEntity entity)
        {
            var ret = Collection_Handle.Truncate(entity);
            return Json(ret);
        }

        /// <summary>
        /// 清空指定集合的数据与索引
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult AliasSet(Alias_Entity.AliasBaseEntity entity)
        {
            var ret = Alias_Handle.Set(entity);
            return Json(ret);
        }

        /// <summary>
        /// 删除集合的别名
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult AliasDelete(Alias_Entity.AliasBaseEntity entity)
        {
            var ret = Alias_Handle.Delete(entity);
            return Json(ret);
        }

        /// <summary>
        /// 给 Collection 中插入向量数据。如果 Collection 在创建时，已配置 Embedding 参数，则仅需要插入文本信息，Embedding 服务会自动将文本信息转换为向量数据，存入数据库
        /// </summary>
        /// <param name="insert"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DocumentInsert(Document_Entity.InsertDocumentsEntity insert)
        {
            var ret = Document_Handle.Insert(insert);
            return Json(ret);
        }

        /// <summary>
        /// 精确查找与查询条件完全匹配的向量
        /// </summary>
        /// <param name="query"></param>
        /// <param name="filter"></param>
        /// <param name="limit"></param>
        /// <param name="offset"></param>
        /// <param name="retrieveVector"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DocumentQuery(Document_Entity.QueryResponDocumentEntity query,string filter, int limit = 100, int offset = 1,bool? retrieveVector=false)
        {
            if (query.query == null)
            {
                query.query = new Document_Entity.QueryResponDocumentEntity.Query
                {
                    limit = limit,
                    filter= filter,
                    offset = offset,
                    retrieveVector = retrieveVector
                };
            }
            var ret = Document_Handle.Query(query);
            return Json(ret);
        }

        /// <summary>
        /// 向量检索
        /// </summary>
        /// <param name="seach"></param>
        /// <param name="embeddingItems"></param>
        /// <param name="outputFields"></param>
        /// <param name="filter"></param>
        /// <param name="limit"></param>
        /// <param name="retrieveVector"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DocumentSeach(Document_Entity.SeachResponDocumentEntity seach, string embeddingItems, string filter, string outputFields="[]", int limit = 10, bool? retrieveVector = false)
        {
            if (seach.search == null)
            {
                seach.search = new Document_Entity.SeachResponDocumentEntity.Search
                {
                    embeddingItems = JsonConvert.DeserializeObject<List<string>>(embeddingItems),
                    outputFields= JsonConvert.DeserializeObject<List<string>>(outputFields),
                    limit = limit,
                    filter = filter,
                    retrieveVector= retrieveVector
                };
            }
            var ret = Document_Handle.Seach(seach);
            return Json(ret);
        }

        /// <summary>
        /// 删除指定  id（Document ID）的文档
        /// </summary>
        /// <param name="delete"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DocumentDelete(Document_Entity.DeleteResponDocumentEntity delete)
        {
            var ret = Document_Handle.Delete(delete);
            return Json(ret);
        }

        /// <summary>
        /// 字段更新
        /// </summary>
        /// <param name="u"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult DocumentUpdate(Document_Entity.UpdateResponDocumentEntity u)
        {
            var ret = Document_Handle.Update(u);
            return Json(ret);
        }

        /// <summary>
        /// 重建索引
        /// </summary>
        /// <param name="rebuild"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult IndexRebuild(Index_Entity.RebuildEntity rebuild)
        {
            var ret = Index_Handle.Rebuild(rebuild);
            return Json(ret);
        }


        /// <summary>
        /// 测试插入数据
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public IActionResult TestInsert()
        {
            //int total = 0;
            //int totalZS = 0;
            //var goods = MC_Goods.GoodsHandle.Get_Goods_List(new MySQLCommon.WFHXNEW_MSQL.MC_Goods.GoodsHandle.Request_Goods_PageList { bid = 15313381803036672, isShelves = true }, ref total, ref totalZS);

            //先根据平台获取商品
            var resultStr = Common.NewRedis(Emun.redisEumn.商品信息).GetEntity<string>(15313386743795712 + "_Goods_Type_Group_Show");
            var groups_Goods = JsonConvert.DeserializeObject<List<Goods_Type_Group_Show_Class>>(resultStr);
            List<long?> _gids = new List<long?> { };
            //获取商品
            foreach (var item in groups_Goods)
            {
                foreach (var _item in item.goodList)
                {
                    _gids.Add(_item.gid);
                }
            }
            //获取可显示的数据
            var goods = MySQLCommon.WFHXNEW_MSQL.MC_Goods.GoodsHandle.Get_Goods_List_ByRdis(_gids);

            //插入数据
            Document_Entity.InsertDocumentsEntity insert = new Document_Entity.InsertDocumentsEntity
            {
                database = "goods",
                collection = "seach",
                buildIndex = true
            };
            List<object> documents = new List<object> { };
            foreach (var item in goods)
            {
                if (item.gtName != "测试")
                {
                    documents.Add(new { id = item.id.ToString(), text = item.title, title = item.title, short_title = item.short_title, gtName = item.gtName, imgs = item.list_imgs });
                }
            }
            insert.documents = documents;

            //调用接口
            var ret = Document_Handle.Insert(insert);

            return Json(ret);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300

查询结果

猜你喜欢（商品相似度）查询时传入商品名称即可返回需要的相似商品。

用户行为分析得到用户的标签，然后根据标签返回相似的商品。、

本文章参考腾讯向量数据库有兴趣的同学可以共同研究下。