anything-llm/server/utils/vectorDbProviders/pinecone/index.js

275 lines
9.8 KiB
JavaScript
Raw Normal View History

const { Pinecone } = require("@pinecone-database/pinecone");
2023-06-04 04:28:07 +02:00
const { RecursiveCharacterTextSplitter } = require("langchain/text_splitter");
2023-06-09 03:58:26 +02:00
const { storeVectorResult, cachedVectorInformation } = require("../../files");
2023-06-08 06:31:35 +02:00
const { v4: uuidv4 } = require("uuid");
const {
toChunks,
getLLMProvider,
getEmbeddingEngineSelection,
} = require("../../helpers");
2023-06-04 04:28:07 +02:00
const PineconeDB = {
name: "Pinecone",
2023-06-04 04:28:07 +02:00
connect: async function () {
if (process.env.VECTOR_DB !== "pinecone")
throw new Error("Pinecone::Invalid ENV settings");
const client = new Pinecone({
2023-06-04 04:28:07 +02:00
apiKey: process.env.PINECONE_API_KEY,
});
2023-06-04 04:28:07 +02:00
const pineconeIndex = client.Index(process.env.PINECONE_INDEX);
const { status } = await client.describeIndex(process.env.PINECONE_INDEX);
2023-06-04 04:28:07 +02:00
if (!status.ready) throw new Error("Pinecone::Index not ready.");
2023-06-04 04:28:07 +02:00
return { client, pineconeIndex, indexName: process.env.PINECONE_INDEX };
},
totalVectors: async function () {
2023-06-04 04:28:07 +02:00
const { pineconeIndex } = await this.connect();
const { namespaces } = await pineconeIndex.describeIndexStats();
2023-06-08 06:31:35 +02:00
return Object.values(namespaces).reduce(
(a, b) => a + (b?.recordCount || 0),
2023-06-08 06:31:35 +02:00
0
);
2023-06-04 04:28:07 +02:00
},
namespaceCount: async function (_namespace = null) {
const { pineconeIndex } = await this.connect();
const namespace = await this.namespace(pineconeIndex, _namespace);
return namespace?.recordCount || 0;
},
similarityResponse: async function (
index,
namespace,
queryVector,
similarityThreshold = 0.25,
topN = 4
) {
const result = {
contextTexts: [],
sourceDocuments: [],
scores: [],
};
const pineconeNamespace = index.namespace(namespace);
const response = await pineconeNamespace.query({
vector: queryVector,
topK: topN,
includeMetadata: true,
});
response.matches.forEach((match) => {
if (match.score < similarityThreshold) return;
result.contextTexts.push(match.metadata.text);
result.sourceDocuments.push(match);
result.scores.push(match.score);
});
return result;
},
2023-06-04 04:28:07 +02:00
namespace: async function (index, namespace = null) {
if (!namespace) throw new Error("No namespace value provided.");
const { namespaces } = await index.describeIndexStats();
2023-06-08 06:31:35 +02:00
return namespaces.hasOwnProperty(namespace) ? namespaces[namespace] : null;
2023-06-04 04:28:07 +02:00
},
hasNamespace: async function (namespace = null) {
if (!namespace) return false;
const { pineconeIndex } = await this.connect();
2023-06-08 06:31:35 +02:00
return await this.namespaceExists(pineconeIndex, namespace);
2023-06-04 04:28:07 +02:00
},
namespaceExists: async function (index, namespace = null) {
if (!namespace) throw new Error("No namespace value provided.");
const { namespaces } = await index.describeIndexStats();
2023-06-08 06:31:35 +02:00
return namespaces.hasOwnProperty(namespace);
2023-06-04 04:28:07 +02:00
},
deleteVectorsInNamespace: async function (index, namespace = null) {
const pineconeNamespace = index.namespace(namespace);
await pineconeNamespace.deleteAll();
2023-06-08 06:31:35 +02:00
return true;
2023-06-04 04:28:07 +02:00
},
2023-06-08 06:31:35 +02:00
addDocumentToNamespace: async function (
namespace,
documentData = {},
fullFilePath = null
) {
2023-06-09 03:58:26 +02:00
const { DocumentVectors } = require("../../../models/vectors");
2023-06-04 04:28:07 +02:00
try {
2023-06-08 06:31:35 +02:00
const { pageContent, docId, ...metadata } = documentData;
2023-06-04 04:28:07 +02:00
if (!pageContent || pageContent.length == 0) return false;
console.log("Adding new vectorized document into namespace", namespace);
2023-06-08 06:31:35 +02:00
const cacheResult = await cachedVectorInformation(fullFilePath);
2023-06-04 04:28:07 +02:00
if (cacheResult.exists) {
const { pineconeIndex } = await this.connect();
const pineconeNamespace = pineconeIndex.namespace(namespace);
2023-06-08 06:31:35 +02:00
const { chunks } = cacheResult;
const documentVectors = [];
2023-06-04 04:28:07 +02:00
for (const chunk of chunks) {
// Before sending to Pinecone and saving the records to our db
// we need to assign the id of each chunk that is stored in the cached file.
const newChunks = chunk.map((chunk) => {
2023-06-08 06:31:35 +02:00
const id = uuidv4();
2023-06-04 04:28:07 +02:00
documentVectors.push({ docId, vectorId: id });
2023-06-08 06:31:35 +02:00
return { ...chunk, id };
});
await pineconeNamespace.upsert([...newChunks]);
2023-06-04 04:28:07 +02:00
}
2023-06-08 06:31:35 +02:00
await DocumentVectors.bulkInsert(documentVectors);
return { vectorized: true, error: null };
2023-06-04 04:28:07 +02:00
}
// If we are here then we are going to embed and store a novel document.
// We have to do this manually as opposed to using LangChains `PineconeStore.fromDocuments`
// because we then cannot atomically control our namespace to granularly find/remove documents
// from vectordb.
// https://github.com/hwchase17/langchainjs/blob/2def486af734c0ca87285a48f1a04c057ab74bdf/langchain/src/vectorstores/pinecone.ts#L167
2023-06-08 06:31:35 +02:00
const textSplitter = new RecursiveCharacterTextSplitter({
chunkSize:
getEmbeddingEngineSelection()?.embeddingMaxChunkLength || 1_000,
2023-06-08 06:31:35 +02:00
chunkOverlap: 20,
});
const textChunks = await textSplitter.splitText(pageContent);
2023-06-04 04:28:07 +02:00
2023-06-08 06:31:35 +02:00
console.log("Chunks created from document:", textChunks.length);
const LLMConnector = getLLMProvider();
2023-06-08 06:31:35 +02:00
const documentVectors = [];
const vectors = [];
const vectorValues = await LLMConnector.embedChunks(textChunks);
2023-06-04 04:28:07 +02:00
if (!!vectorValues && vectorValues.length > 0) {
for (const [i, vector] of vectorValues.entries()) {
2023-06-04 04:28:07 +02:00
const vectorRecord = {
id: uuidv4(),
values: vector,
2023-06-04 04:28:07 +02:00
// [DO NOT REMOVE]
// LangChain will be unable to find your text if you embed manually and dont include the `text` key.
// https://github.com/hwchase17/langchainjs/blob/2def486af734c0ca87285a48f1a04c057ab74bdf/langchain/src/vectorstores/pinecone.ts#L64
metadata: { ...metadata, text: textChunks[i] },
2023-06-08 06:31:35 +02:00
};
2023-06-04 04:28:07 +02:00
vectors.push(vectorRecord);
documentVectors.push({ docId, vectorId: vectorRecord.id });
}
} else {
throw new Error(
"Could not embed document chunks! This document will not be recorded."
);
2023-06-04 04:28:07 +02:00
}
if (vectors.length > 0) {
2023-06-08 06:31:35 +02:00
const chunks = [];
2023-06-04 04:28:07 +02:00
const { pineconeIndex } = await this.connect();
const pineconeNamespace = pineconeIndex.namespace(namespace);
2023-06-08 06:31:35 +02:00
console.log("Inserting vectorized chunks into Pinecone.");
2023-06-04 04:28:07 +02:00
for (const chunk of toChunks(vectors, 100)) {
2023-06-08 06:31:35 +02:00
chunks.push(chunk);
await pineconeNamespace.upsert([...chunk]);
2023-06-04 04:28:07 +02:00
}
2023-06-08 06:31:35 +02:00
await storeVectorResult(chunks, fullFilePath);
2023-06-04 04:28:07 +02:00
}
2023-06-08 06:31:35 +02:00
await DocumentVectors.bulkInsert(documentVectors);
return { vectorized: true, error: null };
2023-06-04 04:28:07 +02:00
} catch (e) {
2023-06-08 06:31:35 +02:00
console.error("addDocumentToNamespace", e.message);
return { vectorized: false, error: e.message };
2023-06-04 04:28:07 +02:00
}
},
deleteDocumentFromNamespace: async function (namespace, docId) {
2023-06-09 03:58:26 +02:00
const { DocumentVectors } = require("../../../models/vectors");
2023-06-04 04:28:07 +02:00
const { pineconeIndex } = await this.connect();
2023-06-08 06:31:35 +02:00
if (!(await this.namespaceExists(pineconeIndex, namespace))) return;
2023-06-04 04:28:07 +02:00
Replace custom sqlite dbms with prisma (#239) * WIP converted all sqlite models into prisma calls * modify db setup and fix ApiKey model calls in admin.js * renaming function params to be consistent * converted adminEndpoints to utilize prisma orm * converted chatEndpoints to utilize prisma orm * converted inviteEndpoints to utilize prisma orm * converted systemEndpoints to utilize prisma orm * converted workspaceEndpoints to utilize prisma orm * converting sql queries to prisma calls * fixed default param bug for orderBy and limit * fixed typo for workspace chats * fixed order of deletion to account for sql relations * fix invite CRUD and workspace management CRUD * fixed CRUD for api keys * created prisma setup scripts/docs for understanding how to use prisma * prisma dependency change * removing unneeded console.logs * removing unneeded sql escape function * linting and creating migration script * migration from depreciated sqlite script update * removing unneeded migrations in prisma folder * create backup of old sqlite db and use transactions to ensure all operations complete successfully * adding migrations to gitignore * updated PRISMA.md docs for info on how to use sqlite migration script * comment changes * adding back migrations folder to repo * Reviewing SQL and prisma integraiton on fresh repo * update inline key replacement * ensure migration script executes and maps foreign_keys regardless of db ordering * run migration endpoint * support new prisma backend * bump version * change migration call --------- Co-authored-by: timothycarambat <rambat1010@gmail.com>
2023-09-28 23:00:03 +02:00
const knownDocuments = await DocumentVectors.where({ docId });
2023-06-04 04:28:07 +02:00
if (knownDocuments.length === 0) return;
const vectorIds = knownDocuments.map((doc) => doc.vectorId);
const pineconeNamespace = pineconeIndex.namespace(namespace);
for (const batchOfVectorIds of toChunks(vectorIds, 1000)) {
await pineconeNamespace.deleteMany(batchOfVectorIds);
}
2023-06-04 04:28:07 +02:00
const indexes = knownDocuments.map((doc) => doc.id);
2023-06-08 06:31:35 +02:00
await DocumentVectors.deleteIds(indexes);
2023-06-04 04:28:07 +02:00
return true;
},
2023-06-08 06:31:35 +02:00
"namespace-stats": async function (reqBody = {}) {
const { namespace = null } = reqBody;
2023-06-04 04:28:07 +02:00
if (!namespace) throw new Error("namespace required");
const { pineconeIndex } = await this.connect();
2023-06-08 06:31:35 +02:00
if (!(await this.namespaceExists(pineconeIndex, namespace)))
throw new Error("Namespace by that name does not exist.");
const stats = await this.namespace(pineconeIndex, namespace);
return stats
? stats
: { message: "No stats were able to be fetched from DB" };
2023-06-04 04:28:07 +02:00
},
2023-06-08 06:31:35 +02:00
"delete-namespace": async function (reqBody = {}) {
const { namespace = null } = reqBody;
2023-06-04 04:28:07 +02:00
const { pineconeIndex } = await this.connect();
2023-06-08 06:31:35 +02:00
if (!(await this.namespaceExists(pineconeIndex, namespace)))
throw new Error("Namespace by that name does not exist.");
2023-06-04 04:28:07 +02:00
const details = await this.namespace(pineconeIndex, namespace);
await this.deleteVectorsInNamespace(pineconeIndex, namespace);
2023-06-08 06:31:35 +02:00
return {
message: `Namespace ${namespace} was deleted along with ${details.vectorCount} vectors.`,
};
2023-06-04 04:28:07 +02:00
},
performSimilaritySearch: async function ({
namespace = null,
input = "",
LLMConnector = null,
similarityThreshold = 0.25,
topN = 4,
}) {
if (!namespace || !input || !LLMConnector)
throw new Error("Invalid request to performSimilaritySearch.");
2023-06-04 04:28:07 +02:00
const { pineconeIndex } = await this.connect();
2023-06-08 06:31:35 +02:00
if (!(await this.namespaceExists(pineconeIndex, namespace)))
throw new Error(
"Invalid namespace - has it been collected and populated yet?"
2023-06-08 06:31:35 +02:00
);
2023-06-04 04:28:07 +02:00
const queryVector = await LLMConnector.embedTextInput(input);
const { contextTexts, sourceDocuments } = await this.similarityResponse(
2023-06-08 06:31:35 +02:00
pineconeIndex,
namespace,
queryVector,
similarityThreshold,
topN
);
2023-06-04 04:28:07 +02:00
const sources = sourceDocuments.map((metadata, i) => {
return { ...metadata, text: contextTexts[i] };
});
return {
contextTexts,
sources: this.curateSources(sources),
message: false,
};
2023-06-04 04:28:07 +02:00
},
curateSources: function (sources = []) {
const documents = [];
for (const source of sources) {
const { metadata = {} } = source;
if (Object.keys(metadata).length > 0) {
documents.push({
...metadata,
...(source.hasOwnProperty("pageContent")
? { text: source.pageContent }
: {}),
});
}
}
return documents;
},
2023-06-08 06:31:35 +02:00
};
2023-06-04 04:28:07 +02:00
module.exports.Pinecone = PineconeDB;