0
# Vector Stores
1

2
Document storage and similarity search functionality for retrieval-augmented generation (RAG) applications. Vector stores enable semantic search over document collections using embedding vectors.
3

4
## Capabilities
5

6
### Vector Store
7

8
Abstract base class for all vector store implementations.
9

10
```typescript { .api }
11
/**
12
 * Abstract base class for vector storage and similarity search
13
 */
14
abstract class VectorStore {
15
  /** Embedding model for generating vectors */
16
  embeddings: EmbeddingsInterface;
17
  /** Filter type for this vector store */
18
  FilterType: object | string;
19
  
20
  constructor(embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>);
21
  
22
  /** Get vector store type identifier */
23
  abstract _vectorstoreType(): string;
24
  
25
  /** Add pre-computed vectors with documents */
26
  abstract addVectors(vectors: number[][], documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
27
  
28
  /** Add documents (will be embedded automatically) */
29
  abstract addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
30
  
31
  /** Delete documents by ID or filter */
32
  abstract delete?(params: { ids?: string[]; filter?: this["FilterType"] }): Promise<void>;
33
  
34
  /** Similarity search using vectors with scores */
35
  abstract similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
36
  
37
  /** Similarity search using text query */
38
  async similaritySearch(query: string, k?: number, filter?: this["FilterType"], callbacks?: Callbacks): Promise<Document[]>;
39
  
40
  /** Similarity search with relevance scores */
41
  async similaritySearchWithScore(query: string, k?: number, filter?: this["FilterType"], callbacks?: Callbacks): Promise<[Document, number][]>;
42
  
43
  /** Maximum marginal relevance search */
44
  maxMarginalRelevanceSearch?(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>, callbacks?: Callbacks): Promise<Document[]>;
45
  
46
  /** Convert to retriever interface */
47
  asRetriever(kOrFields?: number | VectorStoreRetrieverInput<this>, filter?: this["FilterType"], callbacks?: Callbacks, tags?: string[], metadata?: Record<string, unknown>, verbose?: boolean): VectorStoreRetriever<this>;
48
  
49
  /** Create vector store from text documents */
50
  static fromTexts(texts: string[], metadatas: Record<string, unknown>[] | Record<string, unknown>, embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>): Promise<VectorStore>;
51
  
52
  /** Create vector store from Document objects */
53
  static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, dbConfig: Record<string, unknown>): Promise<VectorStore>;
54
}
55
```
56

57
**Usage Examples:**
58

59
```typescript
60
import { Document } from "@langchain/core/documents";
61
import { Embeddings } from "@langchain/core/embeddings";
62

63
// Example vector store implementation
64
class MyVectorStore extends VectorStore {
65
  _vectorstoreType(): string {
66
    return "my_vectorstore";
67
  }
68
  
69
  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {
70
    // Store vectors and documents in your database
71
    for (let i = 0; i < vectors.length; i++) {
72
      await this.db.insert({
73
        vector: vectors[i],
74
        content: documents[i].pageContent,
75
        metadata: documents[i].metadata
76
      });
77
    }
78
  }
79
  
80
  async addDocuments(documents: Document[]): Promise<void> {
81
    // Embed documents and store
82
    const texts = documents.map(doc => doc.pageContent);
83
    const vectors = await this.embeddings.embedDocuments(texts);
84
    await this.addVectors(vectors, documents);
85
  }
86
  
87
  async similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document, number][]> {
88
    // Perform vector similarity search
89
    const results = await this.db.similaritySearch(query, k);
90
    return results.map(r => [
91
      new Document({ pageContent: r.content, metadata: r.metadata }),
92
      r.score
93
    ]);
94
  }
95
}
96

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

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

107
// Search
108
const results = await vectorStore.similaritySearch("What is LangChain?", 2);
109
console.log(results);
110
```
111

112
### Saveable Vector Store
113

114
Vector store that supports persistence to disk.
115

116
```typescript { .api }
117
/**
118
 * Vector store with save/load capabilities
119
 */
120
abstract class SaveableVectorStore extends VectorStore {
121
  /** Save vector store to directory */
122
  abstract save(directory: string): Promise<void>;
123
  
124
  /** Load vector store from directory */
125
  static load(directory: string, embeddings: EmbeddingsInterface): Promise<SaveableVectorStore>;
126
}
127
```
128

129
### Vector Store Retriever
130

131
Retriever implementation that wraps a vector store.
132

133
```typescript { .api }
134
/**
135
 * Retriever wrapper for vector stores
136
 * @template V - Type of the wrapped vector store
137
 */
138
class VectorStoreRetriever<V extends VectorStore = VectorStore> extends BaseRetriever {
139
  /** Wrapped vector store */
140
  vectorStore: V;
141
  /** Number of documents to retrieve */
142
  k: number;
143
  /** Search type: similarity or maximum marginal relevance */
144
  searchType: "similarity" | "mmr";
145
  /** Additional search parameters for MMR */
146
  searchKwargs?: VectorStoreRetrieverMMRSearchKwargs;
147
  /** Filter to apply to search results */
148
  filter?: V["FilterType"];
149
  
150
  constructor(fields: VectorStoreRetrieverInput<V> & BaseRetrieverInput);
151
  
152
  /** Core retrieval implementation */
153
  async _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
154
  
155
  /** Add documents to the underlying vector store */
156
  async addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
157
}
158
```
159

160
**Usage Examples:**
161

162
```typescript
163
import { VectorStoreRetriever } from "@langchain/core/vectorstores";
164

165
// Create retriever from vector store
166
const retriever = vectorStore.asRetriever({
167
  k: 3,
168
  searchType: "similarity"
169
});
170

171
// Or with MMR search
172
const mmrRetriever = vectorStore.asRetriever({
173
  k: 5,
174
  searchType: "mmr",
175
  searchKwargs: {
176
    fetchK: 10,
177
    lambda: 0.5
178
  }
179
});
180

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

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

191
## Search Options
192

193
### Maximum Marginal Relevance Search
194

195
```typescript { .api }
196
interface MaxMarginalRelevanceSearchOptions<FilterType = Record<string, unknown>> {
197
  /** Number of documents to return */
198
  k: number;
199
  /** Number of documents to initially fetch */
200
  fetchK?: number;
201
  /** Diversity parameter (0 = maximum diversity, 1 = minimum diversity) */
202
  lambda?: number;
203
  /** Filter to apply to search */
204
  filter?: FilterType;
205
}
206

207
interface VectorStoreRetrieverMMRSearchKwargs {
208
  /** Number of documents to initially fetch for MMR */
209
  fetchK?: number;
210
  /** Diversity parameter for MMR algorithm */
211
  lambda?: number;
212
}
213
```
214

215
### Vector Store Retriever Configuration
216

217
```typescript { .api }
218
type VectorStoreRetrieverInput<V extends VectorStore> = 
219
  | {
220
      /** Vector store to wrap */
221
      vectorStore: V;
222
      /** Number of documents to retrieve */
223
      k?: number;
224
      /** Use similarity search */
225
      searchType?: "similarity";
226
      /** Filter for search results */
227
      filter?: V["FilterType"];
228
    }
229
  | {
230
      /** Vector store to wrap */
231
      vectorStore: V;
232
      /** Number of documents to retrieve */
233
      k?: number;
234
      /** Use maximum marginal relevance search */
235
      searchType: "mmr";
236
      /** MMR search parameters */
237
      searchKwargs?: VectorStoreRetrieverMMRSearchKwargs;
238
      /** Filter for search results */
239
      filter?: V["FilterType"];
240
    };
241
```
242

243
## Document Management
244

245
### Add Document Options
246

247
```typescript { .api }
248
type AddDocumentOptions = Record<string, unknown>;
249

250
interface DeleteOptions {
251
  /** Document IDs to delete */
252
  ids?: string[];
253
  /** Filter for documents to delete */
254
  filter?: Record<string, unknown>;
255
}
256
```
257

258
**Usage Examples:**
259

260
```typescript
261
// Add documents with options
262
await vectorStore.addDocuments(
263
  documents,
264
  { 
265
    batchSize: 100,
266
    metadata: { source: "import_2024" }
267
  }
268
);
269

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

273
// Delete documents by filter
274
await vectorStore.delete?.({ 
275
  filter: { source: "outdated_data" } 
276
});
277
```
278

279
## Static Factory Methods
280

281
```typescript { .api }
282
/**
283
 * Create vector store from array of texts
284
 */
285
static fromTexts(
286
  texts: string[],
287
  metadatas: Record<string, unknown>[] | Record<string, unknown>,
288
  embeddings: EmbeddingsInterface,
289
  dbConfig: Record<string, unknown>
290
): Promise<VectorStore>;
291

292
/**
293
 * Create vector store from Document objects
294
 */
295
static fromDocuments(
296
  docs: Document[],
297
  embeddings: EmbeddingsInterface,
298
  dbConfig: Record<string, unknown>
299
): Promise<VectorStore>;
300
```
301

302
**Usage Examples:**
303

304
```typescript
305
// Create from texts
306
const vectorStore1 = await MyVectorStore.fromTexts(
307
  ["Text 1", "Text 2", "Text 3"],
308
  [{ id: 1 }, { id: 2 }, { id: 3 }],
309
  embeddings,
310
  { connectionString: "..." }
311
);
312

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

319
const vectorStore2 = await MyVectorStore.fromDocuments(
320
  documents,
321
  embeddings,
322
  { connectionString: "..." }
323
);
324
```
325

326
## Types
327

328
```typescript { .api }
329
interface VectorStoreInterface extends Serializable {
330
  addVectors(vectors: number[][], documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
331
  addDocuments(documents: Document[], options?: Record<string, unknown>): Promise<string[] | void>;
332
  similaritySearchVectorWithScore(query: number[], k: number, filter?: unknown): Promise<[Document, number][]>;
333
  similaritySearch(query: string, k?: number, filter?: unknown): Promise<Document[]>;
334
  similaritySearchWithScore(query: string, k?: number, filter?: unknown): Promise<[Document, number][]>;
335
}
336

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