Class InMemoryVectorIndexProvider

packages/context-engine/src/vectorIndex.ts:68–107

}

export class InMemoryVectorIndexProvider implements VectorIndexProvider {
  private readonly documents = new Map<string, VectorIndexDocument>();

  async upsert(documents: readonly VectorIndexDocument[]): Promise<void> {
    for (const document of documents) {
      this.documents.set(document.id, document);
    }
  }

  async deleteByEntityIds(entityIds: readonly string[]): Promise<void> {
    const entityIdSet = new Set(entityIds);
    for (const [id, document] of this.documents.entries()) {
      if (entityIdSet.has(document.entityId)) {
        this.documents.delete(id);
      }
    }
  }

  async search(input: VectorSearchInput): Promise<readonly VectorSearchHit[]> {
    const allowedKinds = input.kinds ? new Set(input.kinds) : null;
    const allowedTiers = input.tiers ? new Set(input.tiers) : null;

    return [...this.documents.values()]
      .filter((document) => document.spaceId === input.spaceId)
      .filter((document) => (input.threadId ? !document.threadId || document.threadId === input.threadId : true))
      .filter((document) => (allowedKinds ? allowedKinds.has(document.kind) : true))
      .filter((document) => (allowedTiers ? allowedTiers.has(document.tier) : true))
      .map((document) => ({
        id: document.id,
        entityId: document.entityId,
        kind: document.kind,
        score: lexicalSimilarity(input.query, document.text),
        tier: document.tier,
        metadata: document.metadata,
      }))
      .filter((hit) => hit.score > 0)
      .toSorted((left, right) => right.score - left.score)
      .slice(0, input.topK);
  }
}