0
# Retrieval System
1

2
Document retrieval abstractions for implementing search and information retrieval in RAG (Retrieval-Augmented Generation) applications.
3

4
## Capabilities
5

6
### Base Retriever
7

8
Abstract base class for all document retrievers.
9

10
```typescript { .api }
11
/**
12
 * Abstract base class for document retrieval
13
 * @template Metadata - Document metadata type
14
 */
15
abstract class BaseRetriever<Metadata = Record<string, unknown>> extends Runnable<string, Document<Metadata>[]> {
16
  /** Callback handlers for observability */
17
  callbacks?: Callbacks;
18
  /** Tags for categorizing retrieval operations */
19
  tags?: string[];
20
  /** Additional metadata */
21
  metadata?: Record<string, unknown>;
22
  /** Enable verbose logging */
23
  verbose?: boolean;
24
  
25
  constructor(fields?: BaseRetrieverInput);
26
  
27
  /** Abstract method to implement retrieval logic */
28
  abstract _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Metadata>[]>;
29
  
30
  /** Main retrieval method with callback handling */
31
  async getRelevantDocuments(query: string, config?: RunnableConfig): Promise<Document<Metadata>[]>;
32
  
33
  /** Runnable interface implementation */
34
  async invoke(input: string, options?: RunnableConfig): Promise<Document<Metadata>[]>;
35
  
36
  /** Stream retrieval results */
37
  async *stream(input: string, options?: RunnableConfig): AsyncGenerator<Document<Metadata>[]>;
38
  
39
  /** Batch retrieval for multiple queries */
40
  async batch(inputs: string[], options?: RunnableBatchOptions): Promise<Document<Metadata>[][]>;
41
}
42
```
43

44
**Usage Examples:**
45

46
```typescript
47
import { BaseRetriever, Document } from "@langchain/core/retrievers";
48

49
// Example retriever implementation
50
class MyRetriever extends BaseRetriever {
51
  constructor(private documents: Document[]) {
52
    super();
53
  }
54
  
55
  async _getRelevantDocuments(query: string): Promise<Document[]> {
56
    // Simple keyword-based retrieval
57
    return this.documents.filter(doc => 
58
      doc.pageContent.toLowerCase().includes(query.toLowerCase())
59
    ).slice(0, 5); // Return top 5 matches
60
  }
61
}
62

63
// Usage
64
const retriever = new MyRetriever([
65
  new Document({ pageContent: "LangChain is a framework for LLM applications" }),
66
  new Document({ pageContent: "Vector stores enable semantic search" }),
67
  new Document({ pageContent: "Retrievers find relevant documents" })
68
]);
69

70
const results = await retriever.invoke("LangChain framework");
71
console.log(results); // Returns documents containing "LangChain" or "framework"
72

73
// With configuration
74
const configuredResults = await retriever.getRelevantDocuments(
75
  "semantic search",
76
  {
77
    tags: ["search"],
78
    metadata: { query_type: "semantic" }
79
  }
80
);
81
```
82

83
## Types
84

85
```typescript { .api }
86
interface BaseRetrieverInterface<Metadata = Record<string, unknown>> extends RunnableInterface<string, Document<Metadata>[]> {
87
  getRelevantDocuments(query: string, config?: RunnableConfig): Promise<Document<Metadata>[]>;
88
}
89

90
interface BaseRetrieverInput {
91
  /** Callback handlers */
92
  callbacks?: Callbacks;
93
  /** Operation tags */
94
  tags?: string[];
95
  /** Additional metadata */
96
  metadata?: Record<string, unknown>;
97
  /** Enable verbose logging */
98
  verbose?: boolean;
99
}
100
```