tessl/npm-langchain--core

Core LangChain.js abstractions and schemas for building applications with Large Language Models

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Retrieval System

Name: tessl/npm-langchain--core
Author: tessl

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

Capabilities

Base Retriever

Abstract base class for all document retrievers.

/**
 * Abstract base class for document retrieval
 * @template Metadata - Document metadata type
 */
abstract class BaseRetriever<Metadata = Record<string, unknown>> extends Runnable<string, Document<Metadata>[]> {
  /** Callback handlers for observability */
  callbacks?: Callbacks;
  /** Tags for categorizing retrieval operations */
  tags?: string[];
  /** Additional metadata */
  metadata?: Record<string, unknown>;
  /** Enable verbose logging */
  verbose?: boolean;
  
  constructor(fields?: BaseRetrieverInput);
  
  /** Abstract method to implement retrieval logic */
  abstract _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Metadata>[]>;
  
  /** Main retrieval method with callback handling */
  async getRelevantDocuments(query: string, config?: RunnableConfig): Promise<Document<Metadata>[]>;
  
  /** Runnable interface implementation */
  async invoke(input: string, options?: RunnableConfig): Promise<Document<Metadata>[]>;
  
  /** Stream retrieval results */
  async *stream(input: string, options?: RunnableConfig): AsyncGenerator<Document<Metadata>[]>;
  
  /** Batch retrieval for multiple queries */
  async batch(inputs: string[], options?: RunnableBatchOptions): Promise<Document<Metadata>[][]>;
}

Usage Examples:

import { BaseRetriever, Document } from "@langchain/core/retrievers";

// Example retriever implementation
class MyRetriever extends BaseRetriever {
  constructor(private documents: Document[]) {
    super();
  }
  
  async _getRelevantDocuments(query: string): Promise<Document[]> {
    // Simple keyword-based retrieval
    return this.documents.filter(doc => 
      doc.pageContent.toLowerCase().includes(query.toLowerCase())
    ).slice(0, 5); // Return top 5 matches
  }
}

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

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

// With configuration
const configuredResults = await retriever.getRelevantDocuments(
  "semantic search",
  {
    tags: ["search"],
    metadata: { query_type: "semantic" }
  }
);

Types

interface BaseRetrieverInterface<Metadata = Record<string, unknown>> extends RunnableInterface<string, Document<Metadata>[]> {
  getRelevantDocuments(query: string, config?: RunnableConfig): Promise<Document<Metadata>[]>;
}

interface BaseRetrieverInput {
  /** Callback handlers */
  callbacks?: Callbacks;
  /** Operation tags */
  tags?: string[];
  /** Additional metadata */
  metadata?: Record<string, unknown>;
  /** Enable verbose logging */
  verbose?: boolean;
}