@retrivora-ai/rag-engine 2.6.2 → 2.6.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/ChromaDBProvider-NDA2IBOH.mjs +8 -0
- package/dist/MilvusProvider-H6GGL5FQ.mjs +8 -0
- package/dist/MongoDBProvider-KC3GF3FH.mjs +8 -0
- package/dist/MultiTablePostgresProvider-6LJBFZL2.mjs +9 -0
- package/dist/PineconeProvider-3PXQFHSO.mjs +10 -0
- package/dist/PostgreSQLProvider-VWFL4OIP.mjs +8 -0
- package/dist/QdrantProvider-UU7RGXBI.mjs +8 -0
- package/dist/RedisProvider-MIIPSAAE.mjs +8 -0
- package/dist/SimpleGraphProvider-HJIS4S7Y.mjs +70 -0
- package/dist/UniversalVectorProvider-NO3L255G.mjs +9 -0
- package/dist/WeaviateProvider-YRZDZFAC.mjs +8 -0
- package/dist/chunk-23PFNEBF.mjs +107 -0
- package/dist/chunk-3SQ4DODU.mjs +238 -0
- package/dist/chunk-6ZZOZFK6.mjs +334 -0
- package/dist/chunk-AHMMUZ4W.mjs +152 -0
- package/dist/chunk-ASBNNEVI.mjs +81 -0
- package/dist/chunk-BEPLYQBS.mjs +89 -0
- package/dist/chunk-BPIATXJ4.mjs +281 -0
- package/dist/chunk-FMQN2K2D.mjs +168 -0
- package/dist/chunk-G7MJRFCO.mjs +340 -0
- package/dist/chunk-IHWKVAUR.mjs +112 -0
- package/dist/chunk-IMP6FUCY.mjs +30 -0
- package/dist/chunk-MAXMVO7B.mjs +211 -0
- package/dist/chunk-MGJ6V2IT.mjs +203 -0
- package/dist/chunk-OMQM7AN6.mjs +219 -0
- package/dist/chunk-SG6XYLQE.mjs +53 -0
- package/dist/chunk-T7XSD76K.mjs +10851 -0
- package/dist/chunk-UT6SZZEC.mjs +69 -0
- package/dist/chunk-VW3U4MMX.mjs +157 -0
- package/dist/chunk-XYBKDJDW.mjs +696 -0
- package/dist/handlers/index.d.mts +1 -1
- package/dist/handlers/index.d.ts +1 -1
- package/dist/handlers/index.js +56 -23
- package/dist/handlers/index.mjs +24 -14027
- package/dist/{index-D7FuQRSb.d.mts → index-BBbt5A2y.d.mts} +3 -1
- package/dist/{index-CFl4KrKq.d.ts → index-BZ_rR6V8.d.ts} +3 -1
- package/dist/index.css +13 -0
- package/dist/index.js +22 -5
- package/dist/index.min.css +1 -1
- package/dist/index.mjs +56 -1462
- package/dist/server.d.mts +2 -2
- package/dist/server.d.ts +2 -2
- package/dist/server.js +56 -23
- package/dist/server.mjs +377 -14573
- package/package.json +1 -1
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
import "./chunk-UT6SZZEC.mjs";
|
|
2
|
+
|
|
3
|
+
// src/providers/graphdb/BaseGraphProvider.ts
|
|
4
|
+
var BaseGraphProvider = class {
|
|
5
|
+
constructor(config) {
|
|
6
|
+
this.config = config;
|
|
7
|
+
}
|
|
8
|
+
};
|
|
9
|
+
|
|
10
|
+
// src/providers/graphdb/SimpleGraphProvider.ts
|
|
11
|
+
var SimpleGraphProvider = class extends BaseGraphProvider {
|
|
12
|
+
constructor() {
|
|
13
|
+
super(...arguments);
|
|
14
|
+
this.nodes = /* @__PURE__ */ new Map();
|
|
15
|
+
this.edges = [];
|
|
16
|
+
}
|
|
17
|
+
async initialize() {
|
|
18
|
+
console.warn(
|
|
19
|
+
"[SimpleGraphProvider] Warning: SimpleGraphProvider is an in-memory database meant for demonstration and local development. Graph data is NOT persisted across restarts."
|
|
20
|
+
);
|
|
21
|
+
}
|
|
22
|
+
async addNodes(nodes) {
|
|
23
|
+
for (const node of nodes) {
|
|
24
|
+
this.nodes.set(node.id, node);
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
async addEdges(edges) {
|
|
28
|
+
this.edges.push(...edges);
|
|
29
|
+
}
|
|
30
|
+
async query(queryText, limit = 5) {
|
|
31
|
+
const q = queryText.toLowerCase();
|
|
32
|
+
const matchedNodes = Array.from(this.nodes.values()).filter(
|
|
33
|
+
(node) => node.id.toLowerCase().includes(q) || node.label.toLowerCase().includes(q) || JSON.stringify(node.properties).toLowerCase().includes(q)
|
|
34
|
+
).slice(0, limit);
|
|
35
|
+
const matchedNodeIds = new Set(matchedNodes.map((n) => n.id));
|
|
36
|
+
const matchedEdges = this.edges.filter(
|
|
37
|
+
(edge) => matchedNodeIds.has(edge.source) || matchedNodeIds.has(edge.target)
|
|
38
|
+
);
|
|
39
|
+
for (const edge of matchedEdges) {
|
|
40
|
+
if (!matchedNodeIds.has(edge.source)) {
|
|
41
|
+
const source = this.nodes.get(edge.source);
|
|
42
|
+
if (source) {
|
|
43
|
+
matchedNodes.push(source);
|
|
44
|
+
matchedNodeIds.add(edge.source);
|
|
45
|
+
}
|
|
46
|
+
}
|
|
47
|
+
if (!matchedNodeIds.has(edge.target)) {
|
|
48
|
+
const target = this.nodes.get(edge.target);
|
|
49
|
+
if (target) {
|
|
50
|
+
matchedNodes.push(target);
|
|
51
|
+
matchedNodeIds.add(edge.target);
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
return {
|
|
56
|
+
nodes: matchedNodes,
|
|
57
|
+
edges: matchedEdges
|
|
58
|
+
};
|
|
59
|
+
}
|
|
60
|
+
async ping() {
|
|
61
|
+
return true;
|
|
62
|
+
}
|
|
63
|
+
async disconnect() {
|
|
64
|
+
this.nodes.clear();
|
|
65
|
+
this.edges = [];
|
|
66
|
+
}
|
|
67
|
+
};
|
|
68
|
+
export {
|
|
69
|
+
SimpleGraphProvider
|
|
70
|
+
};
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
import {
|
|
2
|
+
BaseVectorProvider
|
|
3
|
+
} from "./chunk-IMP6FUCY.mjs";
|
|
4
|
+
import {
|
|
5
|
+
__spreadValues
|
|
6
|
+
} from "./chunk-UT6SZZEC.mjs";
|
|
7
|
+
|
|
8
|
+
// src/providers/vectordb/ChromaDBProvider.ts
|
|
9
|
+
import axios from "axios";
|
|
10
|
+
var ChromaDBProvider = class extends BaseVectorProvider {
|
|
11
|
+
constructor(config) {
|
|
12
|
+
super(config);
|
|
13
|
+
this.collectionId = "";
|
|
14
|
+
const opts = config.options;
|
|
15
|
+
const baseUrl = opts.baseUrl || (opts.host ? `http://${opts.host}:${opts.port || 8e3}` : void 0);
|
|
16
|
+
if (!baseUrl) throw new Error("[ChromaDBProvider] options.baseUrl is required");
|
|
17
|
+
this.http = axios.create({
|
|
18
|
+
baseURL: baseUrl,
|
|
19
|
+
headers: { "Content-Type": "application/json" }
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
/**
|
|
23
|
+
* Get or create the ChromaDB collection.
|
|
24
|
+
*/
|
|
25
|
+
async initialize() {
|
|
26
|
+
var _a;
|
|
27
|
+
try {
|
|
28
|
+
const { data } = await this.http.get(`/api/v1/collections/${this.indexName}`);
|
|
29
|
+
this.collectionId = data.id;
|
|
30
|
+
} catch (err) {
|
|
31
|
+
if (axios.isAxiosError(err) && ((_a = err.response) == null ? void 0 : _a.status) === 404) {
|
|
32
|
+
const { data } = await this.http.post("/api/v1/collections", {
|
|
33
|
+
name: this.indexName
|
|
34
|
+
});
|
|
35
|
+
this.collectionId = data.id;
|
|
36
|
+
} else {
|
|
37
|
+
throw err;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
}
|
|
41
|
+
async upsert(doc, namespace) {
|
|
42
|
+
await this.batchUpsert([doc], namespace);
|
|
43
|
+
}
|
|
44
|
+
async batchUpsert(docs, namespace) {
|
|
45
|
+
const payload = {
|
|
46
|
+
ids: docs.map((d) => String(d.id)),
|
|
47
|
+
embeddings: docs.map((d) => d.vector),
|
|
48
|
+
documents: docs.map((d) => d.content),
|
|
49
|
+
metadatas: docs.map((d) => __spreadValues(__spreadValues({}, d.metadata || {}), namespace ? { namespace } : {}))
|
|
50
|
+
};
|
|
51
|
+
await this.http.post(`/api/v1/collections/${this.collectionId}/upsert`, payload);
|
|
52
|
+
}
|
|
53
|
+
async query(vector, topK, namespace, _filter) {
|
|
54
|
+
const sanitizedFilter = this.sanitizeFilter(_filter);
|
|
55
|
+
const whereClauses = [];
|
|
56
|
+
if (namespace) whereClauses.push({ namespace: { $eq: namespace } });
|
|
57
|
+
Object.entries(sanitizedFilter).forEach(([key, value]) => {
|
|
58
|
+
if (key === "namespace") return;
|
|
59
|
+
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
|
|
60
|
+
whereClauses.push({ [key]: { $eq: value } });
|
|
61
|
+
}
|
|
62
|
+
});
|
|
63
|
+
const payload = {
|
|
64
|
+
query_embeddings: [vector],
|
|
65
|
+
n_results: topK,
|
|
66
|
+
where: whereClauses.length > 1 ? { $and: whereClauses } : whereClauses[0]
|
|
67
|
+
};
|
|
68
|
+
const { data } = await this.http.post(`/api/v1/collections/${this.collectionId}/query`, payload);
|
|
69
|
+
const matches = [];
|
|
70
|
+
if (data.ids && data.ids[0]) {
|
|
71
|
+
for (let i = 0; i < data.ids[0].length; i++) {
|
|
72
|
+
matches.push({
|
|
73
|
+
id: data.ids[0][i],
|
|
74
|
+
score: data.distances ? 1 - data.distances[0][i] : 0,
|
|
75
|
+
content: data.documents ? data.documents[0][i] : "",
|
|
76
|
+
metadata: data.metadatas ? data.metadatas[0][i] : {}
|
|
77
|
+
});
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
return matches;
|
|
81
|
+
}
|
|
82
|
+
async delete(id, namespace) {
|
|
83
|
+
await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
|
|
84
|
+
ids: [id],
|
|
85
|
+
where: namespace ? { namespace: { $eq: namespace } } : void 0
|
|
86
|
+
});
|
|
87
|
+
}
|
|
88
|
+
async deleteNamespace(namespace) {
|
|
89
|
+
await this.http.post(`/api/v1/collections/${this.collectionId}/delete`, {
|
|
90
|
+
where: { namespace: { $eq: namespace } }
|
|
91
|
+
});
|
|
92
|
+
}
|
|
93
|
+
async ping() {
|
|
94
|
+
try {
|
|
95
|
+
await this.http.get("/api/v1/heartbeat");
|
|
96
|
+
return true;
|
|
97
|
+
} catch (e) {
|
|
98
|
+
return false;
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
async disconnect() {
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
export {
|
|
106
|
+
ChromaDBProvider
|
|
107
|
+
};
|
|
@@ -0,0 +1,238 @@
|
|
|
1
|
+
import {
|
|
2
|
+
BaseVectorProvider
|
|
3
|
+
} from "./chunk-IMP6FUCY.mjs";
|
|
4
|
+
import {
|
|
5
|
+
__spreadValues
|
|
6
|
+
} from "./chunk-UT6SZZEC.mjs";
|
|
7
|
+
|
|
8
|
+
// src/providers/vectordb/QdrantProvider.ts
|
|
9
|
+
import axios from "axios";
|
|
10
|
+
import crypto from "crypto";
|
|
11
|
+
var QdrantProvider = class extends BaseVectorProvider {
|
|
12
|
+
constructor(config) {
|
|
13
|
+
super(config);
|
|
14
|
+
this.schemaDiscovered = false;
|
|
15
|
+
const opts = config.options;
|
|
16
|
+
const baseUrl = opts.baseUrl;
|
|
17
|
+
if (!baseUrl) throw new Error("[QdrantProvider] baseUrl is required");
|
|
18
|
+
this.contentField = opts.contentField || "content";
|
|
19
|
+
this.metadataField = opts.metadataField || "metadata";
|
|
20
|
+
this.isFlatPayload = !!opts.flatPayload;
|
|
21
|
+
this.http = axios.create({
|
|
22
|
+
baseURL: baseUrl,
|
|
23
|
+
timeout: 15e3,
|
|
24
|
+
// 15s timeout for vector DB operations
|
|
25
|
+
headers: __spreadValues({
|
|
26
|
+
"Content-Type": "application/json"
|
|
27
|
+
}, opts.apiKey ? { "api-key": opts.apiKey } : {})
|
|
28
|
+
});
|
|
29
|
+
}
|
|
30
|
+
async initialize() {
|
|
31
|
+
if (this.schemaDiscovered) return;
|
|
32
|
+
await this.ping();
|
|
33
|
+
await this.ensureCollection();
|
|
34
|
+
const discoveredFields = await this.discoverSchema();
|
|
35
|
+
const opts = this.config.options;
|
|
36
|
+
const configFields = opts.filterableFields || [];
|
|
37
|
+
const allFields = [.../* @__PURE__ */ new Set([...discoveredFields, ...configFields])];
|
|
38
|
+
if (allFields.length > 0) {
|
|
39
|
+
await Promise.all(
|
|
40
|
+
allFields.map(async (fieldInfo) => {
|
|
41
|
+
const [fieldName, schemaType] = fieldInfo.split(":");
|
|
42
|
+
return this.ensureIndex(fieldName, schemaType || "keyword");
|
|
43
|
+
})
|
|
44
|
+
);
|
|
45
|
+
}
|
|
46
|
+
this.schemaDiscovered = true;
|
|
47
|
+
}
|
|
48
|
+
/**
|
|
49
|
+
* Samples points from the collection to discover available payload fields.
|
|
50
|
+
*/
|
|
51
|
+
async discoverSchema() {
|
|
52
|
+
var _a;
|
|
53
|
+
try {
|
|
54
|
+
const { data } = await this.http.post(`/collections/${this.indexName}/points/scroll`, {
|
|
55
|
+
limit: 20,
|
|
56
|
+
with_payload: true,
|
|
57
|
+
with_vector: false
|
|
58
|
+
});
|
|
59
|
+
const points = ((_a = data.result) == null ? void 0 : _a.points) || [];
|
|
60
|
+
const keys = /* @__PURE__ */ new Set();
|
|
61
|
+
for (const point of points) {
|
|
62
|
+
const payload = point.payload || {};
|
|
63
|
+
Object.keys(payload).forEach((k) => {
|
|
64
|
+
if (k !== "namespace" && k !== this.contentField && k !== this.metadataField) {
|
|
65
|
+
keys.add(k);
|
|
66
|
+
}
|
|
67
|
+
});
|
|
68
|
+
if (!this.isFlatPayload && payload[this.metadataField]) {
|
|
69
|
+
const meta = payload[this.metadataField];
|
|
70
|
+
if (typeof meta === "object" && meta !== null) {
|
|
71
|
+
Object.keys(meta).forEach((k) => keys.add(k));
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
return Array.from(keys);
|
|
76
|
+
} catch (err) {
|
|
77
|
+
console.warn(`[QdrantProvider] \u26A0\uFE0F Schema discovery failed:`, err instanceof Error ? err.message : String(err));
|
|
78
|
+
return [];
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
/**
|
|
82
|
+
* Ensures the collection exists. Creates it if missing.
|
|
83
|
+
*/
|
|
84
|
+
async ensureCollection() {
|
|
85
|
+
var _a;
|
|
86
|
+
try {
|
|
87
|
+
await this.http.get(`/collections/${this.indexName}`);
|
|
88
|
+
} catch (err) {
|
|
89
|
+
if (axios.isAxiosError(err) && ((_a = err.response) == null ? void 0 : _a.status) === 404) {
|
|
90
|
+
const opts = this.config.options;
|
|
91
|
+
const dimensionsForCreate = opts.dimensions || 1536;
|
|
92
|
+
await this.http.put(`/collections/${this.indexName}`, {
|
|
93
|
+
vectors: {
|
|
94
|
+
size: dimensionsForCreate,
|
|
95
|
+
distance: "Cosine"
|
|
96
|
+
}
|
|
97
|
+
});
|
|
98
|
+
} else {
|
|
99
|
+
throw err;
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
/**
|
|
104
|
+
* Ensures that a payload field has an index.
|
|
105
|
+
*/
|
|
106
|
+
async ensureIndex(fieldName, schema = "keyword") {
|
|
107
|
+
var _a;
|
|
108
|
+
let fullPath = fieldName;
|
|
109
|
+
if (!this.isFlatPayload && !fieldName.includes(".") && fieldName !== "namespace" && fieldName !== this.contentField) {
|
|
110
|
+
fullPath = `${this.metadataField}.${fieldName}`;
|
|
111
|
+
}
|
|
112
|
+
try {
|
|
113
|
+
await this.http.put(`/collections/${this.indexName}/index`, {
|
|
114
|
+
field_name: fullPath,
|
|
115
|
+
field_schema: schema
|
|
116
|
+
});
|
|
117
|
+
} catch (err) {
|
|
118
|
+
let status;
|
|
119
|
+
if (axios.isAxiosError(err)) status = (_a = err.response) == null ? void 0 : _a.status;
|
|
120
|
+
if (status === 409) return;
|
|
121
|
+
console.warn(`[QdrantProvider] \u26A0\uFE0F Could not ensure index for "${fullPath}":`, err instanceof Error ? err.message : String(err));
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
async upsert(doc, namespace) {
|
|
125
|
+
await this.batchUpsert([doc], namespace);
|
|
126
|
+
}
|
|
127
|
+
async batchUpsert(docs, namespace) {
|
|
128
|
+
const payload = {
|
|
129
|
+
points: docs.map((doc) => {
|
|
130
|
+
const pointPayload = __spreadValues({
|
|
131
|
+
[this.contentField]: doc.content
|
|
132
|
+
}, namespace ? { namespace } : {});
|
|
133
|
+
if (this.isFlatPayload) {
|
|
134
|
+
Object.assign(pointPayload, doc.metadata || {});
|
|
135
|
+
} else {
|
|
136
|
+
pointPayload[this.metadataField] = doc.metadata || {};
|
|
137
|
+
}
|
|
138
|
+
return {
|
|
139
|
+
id: this.normalizeId(doc.id),
|
|
140
|
+
vector: doc.vector,
|
|
141
|
+
payload: pointPayload
|
|
142
|
+
};
|
|
143
|
+
})
|
|
144
|
+
};
|
|
145
|
+
await this.http.put(`/collections/${this.indexName}/points`, payload);
|
|
146
|
+
}
|
|
147
|
+
async query(vector, topK, namespace, _filter) {
|
|
148
|
+
var _a;
|
|
149
|
+
const must = [];
|
|
150
|
+
if (namespace) {
|
|
151
|
+
must.push({ key: "namespace", match: { value: namespace } });
|
|
152
|
+
}
|
|
153
|
+
const sanitizedFilter = this.sanitizeFilter(_filter);
|
|
154
|
+
for (const [key, value] of Object.entries(sanitizedFilter)) {
|
|
155
|
+
let filterKey = key;
|
|
156
|
+
if (!this.isFlatPayload && !key.includes(".") && key !== "namespace" && key !== this.contentField) {
|
|
157
|
+
filterKey = `${this.metadataField}.${key}`;
|
|
158
|
+
}
|
|
159
|
+
if (Array.isArray(value)) {
|
|
160
|
+
must.push({ key: filterKey, match: { any: value } });
|
|
161
|
+
} else {
|
|
162
|
+
must.push({ key: filterKey, match: { value } });
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
const payload = {
|
|
166
|
+
vector,
|
|
167
|
+
limit: topK,
|
|
168
|
+
with_payload: true,
|
|
169
|
+
params: {
|
|
170
|
+
hnsw_ef: ((_a = this.config.options) == null ? void 0 : _a.efSearch) || Math.max(topK * 20, 128),
|
|
171
|
+
exact: false
|
|
172
|
+
},
|
|
173
|
+
filter: must.length > 0 ? { must } : void 0
|
|
174
|
+
};
|
|
175
|
+
const { data } = await this.http.post(`/collections/${this.indexName}/points/search`, payload);
|
|
176
|
+
const results = (data.result || []).map((res) => {
|
|
177
|
+
const p = res.payload || {};
|
|
178
|
+
let content = p[this.contentField] || "";
|
|
179
|
+
if (!content) {
|
|
180
|
+
const stringFields = Object.entries(p).filter(([, v]) => typeof v === "string").map(([k, v]) => ({ key: k, val: v }));
|
|
181
|
+
if (stringFields.length > 0) {
|
|
182
|
+
const bestMatch = stringFields.sort((a, b) => b.val.length - a.val.length)[0];
|
|
183
|
+
content = bestMatch.val;
|
|
184
|
+
} else {
|
|
185
|
+
content = JSON.stringify(p);
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
let metadata = {};
|
|
189
|
+
if (this.isFlatPayload) {
|
|
190
|
+
metadata = __spreadValues({}, p);
|
|
191
|
+
delete metadata[this.contentField];
|
|
192
|
+
delete metadata["namespace"];
|
|
193
|
+
} else {
|
|
194
|
+
metadata = p[this.metadataField] || p;
|
|
195
|
+
}
|
|
196
|
+
return {
|
|
197
|
+
id: res.id,
|
|
198
|
+
score: res.score,
|
|
199
|
+
content,
|
|
200
|
+
metadata
|
|
201
|
+
};
|
|
202
|
+
});
|
|
203
|
+
return results;
|
|
204
|
+
}
|
|
205
|
+
async delete(id) {
|
|
206
|
+
await this.http.post(`/collections/${this.indexName}/points/delete`, {
|
|
207
|
+
points: [this.normalizeId(id)]
|
|
208
|
+
});
|
|
209
|
+
}
|
|
210
|
+
async deleteNamespace(_namespace) {
|
|
211
|
+
await this.http.post(`/collections/${this.indexName}/points/delete`, {
|
|
212
|
+
filter: {
|
|
213
|
+
must: [{ key: "namespace", match: { value: _namespace } }]
|
|
214
|
+
}
|
|
215
|
+
});
|
|
216
|
+
}
|
|
217
|
+
async ping() {
|
|
218
|
+
try {
|
|
219
|
+
await this.http.get("/healthz");
|
|
220
|
+
return true;
|
|
221
|
+
} catch (e) {
|
|
222
|
+
return false;
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
normalizeId(id) {
|
|
226
|
+
if (typeof id === "number") return id;
|
|
227
|
+
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
228
|
+
if (uuidRegex.test(id)) return id.toLowerCase();
|
|
229
|
+
const hash = crypto.createHash("md5").update(id).digest("hex");
|
|
230
|
+
return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
|
|
231
|
+
}
|
|
232
|
+
async disconnect() {
|
|
233
|
+
}
|
|
234
|
+
};
|
|
235
|
+
|
|
236
|
+
export {
|
|
237
|
+
QdrantProvider
|
|
238
|
+
};
|