Vector Stores

/**
 * Abstract base class for vector storage and similarity search
 */
abstract class VectorStore {
  /** Embedding model for generating vectors */
  embeddings: EmbeddingsInterface;
  /** Filter type for this vector store */
  FilterType: object | string;
  
  constructor(embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>);
  
  /** Get vector store type identifier */
  abstract _vectorstoreType(): string;
  
  /** Add pre-computed vectors with documents */
  abstract addVectors(vectors: number[][], documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
  
  /** Add documents (will be embedded automatically) */
  abstract addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
  
  /** Delete documents by ID or filter */
  abstract delete?(params: { ids?: string[]; filter?: this["FilterType"] }): Promise<void>;
  
  /** Similarity search using vectors with scores */
  abstract similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
  
  /** Similarity search using text query */
  async similaritySearch(query: string, k?: number, filter?: this["FilterType"], callbacks?: Callbacks): Promise<Document[]>;
  
  /** Similarity search with relevance scores */
  async similaritySearchWithScore(query: string, k?: number, filter?: this["FilterType"], callbacks?: Callbacks): Promise<[Document, number][]>;
  
  /** Maximum marginal relevance search */
  maxMarginalRelevanceSearch?(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>, callbacks?: Callbacks): Promise<Document[]>;
  
  /** Convert to retriever interface */
  asRetriever(kOrFields?: number | VectorStoreRetrieverInput<this>, filter?: this["FilterType"], callbacks?: Callbacks, tags?: string[], metadata?: Record<string, unknown>, verbose?: boolean): VectorStoreRetriever<this>;
  
  /** Create vector store from text documents */
  static fromTexts(texts: string[], metadatas: Record<string, unknown>[] | Record<string, unknown>, embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>): Promise<VectorStore>;
  
  /** Create vector store from Document objects */
  static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>): Promise<VectorStore>;
}

import { Document } from "@langchain/core/documents";
import { Embeddings } from "@langchain/core/embeddings";

// Example vector store implementation
class MyVectorStore extends VectorStore {
  _vectorstoreType(): string {
    return "my_vectorstore";
  }
  
  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {
    // Store vectors and documents in your database
    for (let i = 0; i < vectors.length; i++) {
      await this.db.insert({
        vector: vectors[i],
        content: documents[i].pageContent,
        metadata: documents[i].metadata
      });
    }
  }
  
  async addDocuments(documents: Document[]): Promise<void> {
    // Embed documents and store
    const texts = documents.map(doc => doc.pageContent);
    const vectors = await this.embeddings.embedDocuments(texts);
    await this.addVectors(vectors, documents);
  }
  
  async similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document, number][]> {
    // Perform vector similarity search
    const results = await this.db.similaritySearch(query, k);
    return results.map(r => [
      new Document({ pageContent: r.content, metadata: r.metadata }),
      r.score
    ]);
  }
}

// Using a vector store
const embeddings = new MyEmbeddings();
const vectorStore = new MyVectorStore(embeddings, {});

// Add documents
await vectorStore.addDocuments([
  new Document({ pageContent: "LangChain is a framework for building applications with LLMs" }),
  new Document({ pageContent: "Vector stores enable semantic search over documents" })
]);

// Search
const results = await vectorStore.similaritySearch("What is LangChain?", 2);
console.log(results);

/**
 * Vector store with save/load capabilities
 */
abstract class SaveableVectorStore extends VectorStore {
  /** Save vector store to directory */
  abstract save(directory: string): Promise<void>;
  
  /** Load vector store from directory */
  static load(directory: string, embeddings: EmbeddingsInterface): Promise<SaveableVectorStore>;
}

/**
 * Retriever wrapper for vector stores
 * @template V - Type of the wrapped vector store
 */
class VectorStoreRetriever<V extends VectorStore = VectorStore> extends BaseRetriever {
  /** Wrapped vector store */
  vectorStore: V;
  /** Number of documents to retrieve */
  k: number;
  /** Search type: similarity or maximum marginal relevance */
  searchType: "similarity" | "mmr";
  /** Additional search parameters for MMR */
  searchKwargs?: VectorStoreRetrieverMMRSearchKwargs;
  /** Filter to apply to search results */
  filter?: V["FilterType"];
  
  constructor(fields: VectorStoreRetrieverInput<V> & BaseRetrieverInput);
  
  /** Core retrieval implementation */
  async _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
  
  /** Add documents to the underlying vector store */
  async addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
}

import { VectorStoreRetriever } from "@langchain/core/vectorstores";

// Create retriever from vector store
const retriever = vectorStore.asRetriever({
  k: 3,
  searchType: "similarity"
});

// Or with MMR search
const mmrRetriever = vectorStore.asRetriever({
  k: 5,
  searchType: "mmr",
  searchKwargs: {
    fetchK: 10,
    lambda: 0.5
  }
});

// Use retriever
const documents = await retriever.invoke("What is machine learning?");
console.log(documents);

// Add more documents through retriever
await retriever.addDocuments([
  new Document({ pageContent: "Machine learning enables computers to learn from data" })
]);

interface MaxMarginalRelevanceSearchOptions<FilterType = Record<string, unknown>> {
  /** Number of documents to return */
  k: number;
  /** Number of documents to initially fetch */
  fetchK?: number;
  /** Diversity parameter (0 = maximum diversity, 1 = minimum diversity) */
  lambda?: number;
  /** Filter to apply to search */
  filter?: FilterType;
}

interface VectorStoreRetrieverMMRSearchKwargs {
  /** Number of documents to initially fetch for MMR */
  fetchK?: number;
  /** Diversity parameter for MMR algorithm */
  lambda?: number;
}

type VectorStoreRetrieverInput<V extends VectorStore> = 
  | {
      /** Vector store to wrap */
      vectorStore: V;
      /** Number of documents to retrieve */
      k?: number;
      /** Use similarity search */
      searchType?: "similarity";
      /** Filter for search results */
      filter?: V["FilterType"];
    }
  | {
      /** Vector store to wrap */
      vectorStore: V;
      /** Number of documents to retrieve */
      k?: number;
      /** Use maximum marginal relevance search */
      searchType: "mmr";
      /** MMR search parameters */
      searchKwargs?: VectorStoreRetrieverMMRSearchKwargs;
      /** Filter for search results */
      filter?: V["FilterType"];
    };

type AddDocumentOptions = Record<string, unknown>;

interface DeleteOptions {
  /** Document IDs to delete */
  ids?: string[];
  /** Filter for documents to delete */
  filter?: Record<string, unknown>;
}

// Add documents with options
await vectorStore.addDocuments(
  documents,
  { 
    batchSize: 100,
    metadata: { source: "import_2024" }
  }
);

// Delete documents by ID
await vectorStore.delete?.({ ids: ["doc1", "doc2"] });

// Delete documents by filter
await vectorStore.delete?.({ 
  filter: { source: "outdated_data" } 
});

/**
 * Create vector store from array of texts
 */
static fromTexts(
  texts: string[],
  metadatas: Record<string, unknown>[] | Record<string, unknown>,
  embeddings: EmbeddingsInterface,
  dbConfig: Record<string, unknown>
): Promise<VectorStore>;

/**
 * Create vector store from Document objects
 */
static fromDocuments(
  docs: Document[],
  embeddings: EmbeddingsInterface,
  dbConfig: Record<string, unknown>
): Promise<VectorStore>;

// Create from texts
const vectorStore1 = await MyVectorStore.fromTexts(
  ["Text 1", "Text 2", "Text 3"],
  [{ id: 1 }, { id: 2 }, { id: 3 }],
  embeddings,
  { connectionString: "..." }
);

// Create from documents
const documents = [
  new Document({ pageContent: "Content 1", metadata: { type: "article" } }),
  new Document({ pageContent: "Content 2", metadata: { type: "blog" } })
];

const vectorStore2 = await MyVectorStore.fromDocuments(
  documents,
  embeddings,
  { connectionString: "..." }
);

interface VectorStoreInterface extends Serializable {
  addVectors(vectors: number[][], documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
  addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
  similaritySearchVectorWithScore(query: number[], k: number, filter?: unknown): Promise<[Document, number][]>;
  similaritySearch(query: string, k?: number, filter?: unknown): Promise<Document[]>;
  similaritySearchWithScore(query: string, k?: number, filter?: unknown): Promise<[Document, number][]>;
}

interface VectorStoreRetrieverInterface<V extends VectorStore> extends BaseRetrieverInterface {
  vectorStore: V;
  addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
}