@devilsdev/rag-pipeline-utils 2.1.12 → 2.2.1

package/README.md

@@ -1,658 +1,286 @@
-# @devilsdev/rag-pipeline-utils
+# rag-pipeline-utils
+
+**Modular toolkit for building production-ready RAG pipelines in Node.js**
 
 [![CI](https://github.com/DevilsDev/rag-pipeline-utils/actions/workflows/ci.yml/badge.svg)](https://github.com/DevilsDev/rag-pipeline-utils/actions)
-[![npm version](https://badge.fury.io/js/%40devilsdev%2Frag-pipeline-utils.svg)](https://badge.fury.io/js/%40devilsdev%2Frag-pipeline-utils)
+[![npm version](https://badge.fury.io/js/%40devilsdev%2Frag-pipeline-utils.svg)](https://www.npmjs.com/package/@devilsdev/rag-pipeline-utils)
+[![codecov](https://codecov.io/gh/DevilsDev/rag-pipeline-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/DevilsDev/rag-pipeline-utils)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg)](https://opensource.org/licenses/GPL-3.0)
 [![Node.js Version](https://img.shields.io/node/v/@devilsdev/rag-pipeline-utils.svg)](https://nodejs.org/)
-[![License](https://img.shields.io/npm/l/@devilsdev/rag-pipeline-utils.svg)](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/LICENSE)
 [![Downloads](https://img.shields.io/npm/dm/@devilsdev/rag-pipeline-utils.svg)](https://www.npmjs.com/package/@devilsdev/rag-pipeline-utils)
+[![GitHub Discussions](https://img.shields.io/github/discussions/DevilsDev/rag-pipeline-utils)](https://github.com/DevilsDev/rag-pipeline-utils/discussions)
 
-Enterprise-grade toolkit for building Retrieval-Augmented Generation (RAG) pipelines in Node.js with modular plugin architecture, streaming support, and observability.
+---
 
-## Installation
+## Why This Exists
 
-```bash
-npm install @devilsdev/rag-pipeline-utils
-```
+Building Retrieval-Augmented Generation (RAG) systems is harder than it should be. Most solutions lock you into specific vendors, force opinionated architectures, or sacrifice observability for simplicity.
 
-**Requirements:** Node.js >= 18.0.0
+**rag-pipeline-utils** takes a different approach: it provides the building blocks—loaders, embedders, retrievers, LLM connectors, and rerankers—that you compose into pipelines that fit your needs. Every component follows clear contracts. Every integration is optional. Every decision is yours.
+
+We built this toolkit because we believe infrastructure should be:
+
+- **Modular** – swap any component without rewriting your pipeline
+- **Observable** – metrics, tracing, and audit logs built in from day one
+- **Secure** – enterprise-grade defaults, validated inputs, safe JWT handling
+- **Open** – no vendor lock-in, no proprietary APIs, just JavaScript
+
+Whether you're prototyping a document Q&A system or scaling a production knowledge base, this toolkit grows with you.
+
+---
 
 ## Quick Start
 
-### Basic Pipeline Setup
+Here's a complete RAG pipeline in 15 lines:
 
 ```javascript
 const { createRagPipeline } = require("@devilsdev/rag-pipeline-utils");
 
-// Create pipeline with your plugin implementations
+// Implement your plugins (or use existing ones)
 const pipeline = createRagPipeline({
-  loader: yourLoaderPlugin,
-  embedder: yourEmbedderPlugin,
-  retriever: yourRetrieverPlugin,
-  llm: yourLLMPlugin,
+  loader: new MyPDFLoader(),
+  embedder: new MyOpenAIEmbedder({ apiKey: process.env.OPENAI_API_KEY }),
+  retriever: new MyVectorDBRetriever({ url: "http://localhost:8000" }),
+  llm: new MyLLMConnector({ model: "gpt-4" }),
 });
 
-// Use the pipeline
-await pipeline.ingest("./document.pdf");
-const result = await pipeline.query("What is this document about?");
-console.log(result);
-```
+// Ingest documents
+await pipeline.ingest("./company-docs.pdf");
 
-### Using Configuration File
-
-Create `.ragrc.json`:
-
-```json
-{
-  "loader": {
-    "pdf": "your-pdf-loader-plugin"
-  },
-  "embedder": {
-    "default": "your-embedder-plugin"
-  },
-  "retriever": {
-    "default": "your-vector-db-plugin"
-  },
-  "llm": {
-    "default": "your-llm-plugin"
-  }
-}
+// Query with natural language
+const answer = await pipeline.query("What is the vacation policy?");
+console.log(answer.text);
+// Output: "Based on the company handbook, employees receive 20 days of vacation per year..."
 ```
 
-Load and use configuration:
+**Requirements:** Node.js >= 18.0.0
 
-```javascript
-const {
-  loadConfig,
-  createRagPipeline,
-} = require("@devilsdev/rag-pipeline-utils");
+Install with:
 
-const config = await loadConfig(".ragrc.json");
-const pipeline = createRagPipeline(config);
+```bash
+npm install @devilsdev/rag-pipeline-utils
 ```
 
-## Core API
-
-### Exported Modules
+---
 
-```javascript
-const {
-  // Core pipeline
-  createRagPipeline,
-
-  // Configuration
-  loadConfig,
-  validateRagrc,
-  normalizeConfig,
-
-  // Plugin system
-  pluginRegistry,
-
-  // DAG workflow engine
-  DAGEngine,
-
-  // Observability
-  eventLogger,
-  metrics,
+## How It Works
 
-  // Performance
-  ParallelProcessor,
+**rag-pipeline-utils** orchestrates data through a clear, predictable flow:
 
-  // AI/ML
-  MultiModalProcessor,
-  AdaptiveRetrievalEngine,
+```mermaid
+graph LR
+    A[Documents] --> B[Loader]
+    B --> C[Embedder]
+    C --> D[Vector Store]
+    D --> E[Retriever]
+    F[User Query] --> C
+    F --> E
+    E --> G[Reranker]
+    G --> H[LLM]
+    H --> I[Response]
 
-  // Enterprise
-  AuditLogger,
-  DataGovernance,
-
-  // Utilities
-  logger,
-} = require("@devilsdev/rag-pipeline-utils");
+    style B fill:#e1f5e1
+    style C fill:#e1f5e1
+    style E fill:#e1f5e1
+    style G fill:#fff4e1
+    style H fill:#e1f5e1
+    style I fill:#e3f2fd
 ```
 
-### createRagPipeline(config)
-
-Creates a RAG pipeline instance.
+1. **Loader** – Parse documents (PDF, HTML, Markdown, etc.)
+2. **Embedder** – Convert text to vector embeddings
+3. **Vector Store** – Index and persist embeddings
+4. **Retriever** – Find semantically similar content
+5. **Reranker** (optional) – Refine retrieval results
+6. **LLM** – Generate contextual responses
 
-**Parameters:**
+Every component is replaceable. Every step is observable.
 
-- `config.loader` - Document loader plugin
-- `config.embedder` - Text embedding plugin
-- `config.retriever` - Vector storage and retrieval plugin
-- `config.llm` - Language model plugin
-- `config.reranker` (optional) - Result reranking plugin
+---
 
-**Returns:** Pipeline instance with `ingest()` and `query()` methods
+## Features
 
-### Configuration Management
+### Modular Plugin Architecture
 
-```javascript
-// Load configuration from file
-const config = await loadConfig(".ragrc.json");
+Swap any component without rewriting your pipeline. Use OpenAI embeddings with Pinecone storage, or mix Hugging Face models with PostgreSQL—your choice.
 
-// Validate configuration
-const isValid = validateRagrc(config);
+### Enterprise Observability
 
-// Normalize configuration
-const normalized = normalizeConfig(config);
-```
-
-### Plugin Registry
-
-```javascript
-const { pluginRegistry } = require("@devilsdev/rag-pipeline-utils");
-
-// Register a plugin
-pluginRegistry.register("my-plugin", MyPluginClass);
-
-// Get a plugin
-const Plugin = pluginRegistry.get("my-plugin");
-
-// List all plugins
-const plugins = pluginRegistry.list();
-
-// Check if plugin exists
-const exists = pluginRegistry.has("my-plugin");
-```
+Built-in structured logging, Prometheus metrics, OpenTelemetry tracing, and audit logs for compliance-grade transparency.
 
 ### DAG Workflow Engine
 
-Build complex multi-step workflows:
+Chain complex multi-step operations with retry logic, parallel execution, and graceful error handling. Perfect for batch ingestion or multi-stage transformations.
 
-```javascript
-const { DAGEngine } = require("@devilsdev/rag-pipeline-utils");
-
-const dag = new DAGEngine({
-  nodes: [
-    {
-      id: "load",
-      type: "loader",
-      config: {
-        /* loader config */
-      },
-    },
-    {
-      id: "embed",
-      type: "embedder",
-      dependencies: ["load"],
-      config: {
-        /* embedder config */
-      },
-    },
-    {
-      id: "store",
-      type: "retriever",
-      dependencies: ["embed"],
-      config: {
-        /* retriever config */
-      },
-    },
-  ],
-});
-
-await dag.execute();
-```
-
-### Observability
-
-```javascript
-const { eventLogger, metrics } = require("@devilsdev/rag-pipeline-utils");
-
-// Configure event logging
-eventLogger.configure({
-  level: "info",
-  format: "json",
-});
-
-// Log events
-eventLogger.log("info", "Pipeline started", { pipelineId: "abc123" });
-
-// Access metrics
-const pipelineMetrics = metrics.getMetrics();
-console.log(pipelineMetrics);
-```
-
-### Parallel Processing
-
-```javascript
-const { ParallelProcessor } = require("@devilsdev/rag-pipeline-utils");
-
-const processor = new ParallelProcessor({
-  maxConcurrency: 5,
-});
-
-await processor.process(items, async (item) => {
-  // Process each item
-  return processItem(item);
-});
-```
-
-## Plugin Development
-
-This package provides a plugin-based architecture. You need to implement plugins for your specific use case.
-
-### Plugin Contracts
-
-#### Loader Plugin
-
-```javascript
-class MyLoader {
-  async load(filePath) {
-    // Load and parse document
-    // Return array of document chunks
-    return [
-      {
-        content: "Document text...",
-        metadata: { page: 1, source: filePath },
-      },
-    ];
-  }
-}
-```
-
-#### Embedder Plugin
-
-```javascript
-class MyEmbedder {
-  async embed(texts) {
-    // Generate embeddings for array of texts
-    // Return array of vectors
-    return [
-      [0.1, 0.2, 0.3, ...], // vector for text[0]
-      [0.4, 0.5, 0.6, ...]  // vector for text[1]
-    ];
-  }
-
-  async embedQuery(query) {
-    // Generate embedding for single query
-    return [0.7, 0.8, 0.9, ...];
-  }
-}
-```
-
-#### Retriever Plugin
-
-```javascript
-class MyRetriever {
-  async store(vectors, metadata) {
-    // Store vectors with metadata in your vector database
-  }
-
-  async retrieve(queryVector, options = {}) {
-    const { topK = 5, threshold = 0.7 } = options;
-
-    // Search for similar vectors
-    // Return documents with similarity scores
-    return [
-      {
-        content: "Document text...",
-        metadata: {
-          /* document metadata */
-        },
-        score: 0.95,
-      },
-    ];
-  }
-}
-```
+### Type-Safe Contracts
 
-#### LLM Plugin
+Complete TypeScript interfaces for all plugin types. Full IDE autocomplete and compile-time validation.
 
-```javascript
-class MyLLM {
-  async generate(prompt, options = {}) {
-    // Generate text from prompt
-    return {
-      text: "Generated response...",
-      usage: { tokens: 150 },
-    };
-  }
-
-  async *stream(prompt, options = {}) {
-    // Stream response chunks
-    yield "Generated ";
-    yield "response ";
-    yield "chunks...";
-  }
-}
-```
+### Production-Ready Security
 
-#### Reranker Plugin (Optional)
+Secure defaults everywhere: validated JSON parsing, JWT algorithm whitelisting, automatic secret redaction in logs, and dependency scanning.
 
-```javascript
-class MyReranker {
-  async rerank(query, documents, options = {}) {
-    // Rerank documents based on relevance to query
-    return documents
-      .map((doc) => ({
-        ...doc,
-        score: calculateRelevanceScore(query, doc),
-      }))
-      .sort((a, b) => b.score - a.score);
-  }
-}
-```
+### Streaming & Batching
 
-## Environment Configuration
+Stream LLM responses in real-time. Batch embed thousands of documents efficiently with parallel processing and backpressure control.
 
-```bash
-# Example environment variables for your plugins
-OPENAI_API_KEY=your_api_key
-PINECONE_API_KEY=your_api_key
-PINECONE_ENVIRONMENT=us-east-1
-CHROMA_URL=http://localhost:8000
-
-# Performance settings
-RAG_MAX_CONCURRENCY=5
-RAG_BATCH_SIZE=10
-```
+### Framework Agnostic
 
-## Advanced Features
+Works with Express, Fastify, Next.js, or any Node.js runtime. Deploy to AWS Lambda, Vercel, Docker, or bare metal.
 
-### Multi-Modal Processing
+---
 
-```javascript
-const { MultiModalProcessor } = require("@devilsdev/rag-pipeline-utils");
+## Join the Community
 
-const processor = new MultiModalProcessor({
-  // Configuration for processing text, images, audio, etc.
-});
+We're building this together.
 
-await processor.process(multiModalData);
-```
+Whether you're implementing a new retriever, writing documentation, reporting bugs, or sharing ideas—every contribution makes this toolkit better for everyone.
 
-### Adaptive Retrieval
+**Getting Started:**
 
-```javascript
-const { AdaptiveRetrievalEngine } = require("@devilsdev/rag-pipeline-utils");
+- 💬 [GitHub Discussions](https://github.com/DevilsDev/rag-pipeline-utils/discussions) – Ask questions, share use cases, propose features
+- 🐛 [Issue Tracker](https://github.com/DevilsDev/rag-pipeline-utils/issues) – Report bugs or request features
+- 🤝 [Contributing Guide](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/docs/CONTRIBUTING.md) – Learn how to submit pull requests
+- 📖 [Code of Conduct](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/CODE_OF_CONDUCT.md) – Our community standards
 
-const retriever = new AdaptiveRetrievalEngine({
-  // Configuration for adaptive retrieval strategies
-});
+**Good First Issues:** Look for issues tagged `good first issue` to find beginner-friendly contributions.
 
-const results = await retriever.retrieve(query, context);
-```
+**Office Hours:** Join our monthly community calls to discuss roadmap priorities and architectural decisions.
 
-### Enterprise Audit Logging
+---
 
-```javascript
-const { AuditLogger } = require("@devilsdev/rag-pipeline-utils");
+## Security and Quality
 
-const auditLogger = new AuditLogger({
-  destination: "./audit-logs",
-});
+Security isn't optional. This toolkit is built with defense in depth:
 
-auditLogger.log("query", {
-  user: "user@example.com",
-  query: "sensitive query",
-  timestamp: new Date(),
-});
-```
+- **Validated Inputs** – All JSON parsed through schema validation (AJV)
+- **Secure Logging** – Automatic redaction of 36 sensitive field patterns (API keys, JWTs, tokens)
+- **JWT Best Practices** – Algorithm whitelisting, issuer/audience validation, expiration enforcement
+- **Dependency Scanning** – Weekly Dependabot updates, CI blocks on critical vulnerabilities
+- **Audit Trail** – Immutable compliance-grade logs for all security-sensitive operations
+- **Plugin Sandboxing** – Third-party plugins run with declared permissions and resource limits
+- **Supply Chain Security** – All GitHub Actions pinned to commit SHAs, SBOM generation available
 
-### Data Governance
+**Zero Production Vulnerabilities:** `npm audit --production` returns clean on every release.
 
-```javascript
-const { DataGovernance } = require("@devilsdev/rag-pipeline-utils");
+**Test Coverage:** 845+ tests across 61 suites, with 100% coverage on critical paths.
 
-const governance = new DataGovernance({
-  policies: {
-    retention: "90d",
-    encryption: true,
-  },
-});
+**Supported Node Versions:** 18.x, 20.x, 22.x (tested in CI)
 
-await governance.enforce(data);
-```
+---
 
-## CLI Usage
+## Installation & Development
 
-The package includes a CLI tool for pipeline operations:
+### Install
 
 ```bash
-# Initialize configuration
-npx rag-pipeline init
-
-# Run pipeline operations (requires plugin implementation)
-npx rag-pipeline ingest ./documents
-npx rag-pipeline query "Your question"
-
-# Run system diagnostics
-npx rag-pipeline doctor
-```
-
-## Error Handling
-
-```javascript
-try {
-  const result = await pipeline.query("What is AI?");
-} catch (error) {
-  if (error.code === "PLUGIN_NOT_FOUND") {
-    console.error("Required plugin not found:", error.message);
-  } else if (error.code === "INVALID_CONFIG") {
-    console.error("Invalid configuration:", error.message);
-  } else {
-    console.error("Pipeline error:", error.message);
-  }
-}
+npm install @devilsdev/rag-pipeline-utils
 ```
 
-## Use Cases
-
-### Document Q&A System
-
-```javascript
-// Implement your plugins
-const loader = new PDFLoaderPlugin();
-const embedder = new OpenAIEmbedderPlugin({
-  apiKey: process.env.OPENAI_API_KEY,
-});
-const retriever = new ChromaRetrieverPlugin({ url: "http://localhost:8000" });
-const llm = new OpenAILLMPlugin({ model: "gpt-4" });
+### Development Setup
 
-// Create pipeline
-const pipeline = createRagPipeline({
-  loader,
-  embedder,
-  retriever,
-  llm,
-});
+```bash
+# Clone the repository
+git clone https://github.com/DevilsDev/rag-pipeline-utils.git
+cd rag-pipeline-utils
 
-// Ingest documents
-await pipeline.ingest("./company-handbook.pdf");
+# Install dependencies
+npm install
 
-// Query
-const answer = await pipeline.query("What is the vacation policy?");
-console.log(answer);
-```
+# Run tests
+npm test
 
-### Knowledge Base Search
+# Run linter
+npm run lint
 
-```javascript
-// Use your custom database retriever
-class PostgresRetriever {
-  constructor(connectionString) {
-    this.db = new PostgresClient(connectionString);
-  }
-
-  async retrieve(queryVector, options) {
-    const results = await this.db.query(
-      "SELECT content, metadata, vector <-> $1 as score FROM embeddings ORDER BY score LIMIT $2",
-      [queryVector, options.topK],
-    );
-    return results.rows;
-  }
-}
+# Build distribution
+npm run build
 
-const pipeline = createRagPipeline({
-  loader: yourLoader,
-  embedder: yourEmbedder,
-  retriever: new PostgresRetriever("postgresql://localhost/kb"),
-  llm: yourLLM,
-});
+# Run development tools
+npm run dev
 ```
 
-## Performance Tips
-
-### Batch Processing
-
-```javascript
-const { ParallelProcessor } = require("@devilsdev/rag-pipeline-utils");
+### Common Commands
 
-const processor = new ParallelProcessor({
-  maxConcurrency: 5,
-  batchSize: 10,
-});
-
-// Process documents in parallel
-await processor.process(documents, async (doc) => {
-  return await pipeline.ingest(doc);
-});
+```bash
+npm test                # Run test suite
+npm run test:watch      # Watch mode for TDD
+npm run lint            # Check code style
+npm run lint:fix        # Auto-fix linting issues
+npm run security:audit  # Scan dependencies
+npm run docs:api        # Generate API documentation
+npm run benchmark       # Performance benchmarks
 ```
 
-### Logging and Monitoring
+---
 
-```javascript
-const { logger, metrics } = require("@devilsdev/rag-pipeline-utils");
-
-// Set log level
-logger.setLevel("debug");
-
-// Monitor performance
-const stats = metrics.getMetrics();
-console.log("Total queries:", stats.queries?.total || 0);
-console.log("Average latency:", stats.queries?.avgLatency || 0);
-```
+## Roadmap
 
-## Common Integration Examples
+### v2.3.0 (Q2 2025)
 
-### With OpenAI
+- **Enhanced CLI** – Interactive wizard for pipeline setup, validation commands, and migration tools
+- **Plugin Marketplace** – Curated registry of community-contributed plugins with ratings and verification
+- **Streaming Embeddings** – Real-time embedding generation with backpressure control
+- **Multi-Tenant Support** – Workspace isolation, resource quotas, and tenant-specific configurations
 
-You need to implement OpenAI plugin wrappers:
+### v2.4.0 (Q3 2025)
 
-```javascript
-class OpenAIEmbedder {
-  constructor({ apiKey, model = "text-embedding-ada-002" }) {
-    this.client = new OpenAI({ apiKey });
-    this.model = model;
-  }
-
-  async embed(texts) {
-    const response = await this.client.embeddings.create({
-      model: this.model,
-      input: texts,
-    });
-    return response.data.map((d) => d.embedding);
-  }
-}
-
-class OpenAILLM {
-  constructor({ apiKey, model = "gpt-4" }) {
-    this.client = new OpenAI({ apiKey });
-    this.model = model;
-  }
-
-  async generate(prompt) {
-    const response = await this.client.chat.completions.create({
-      model: this.model,
-      messages: [{ role: "user", content: prompt }],
-    });
-    return { text: response.choices[0].message.content };
-  }
-}
-```
+- **GraphRAG Support** – Native knowledge graph integration for entity-relationship retrieval
+- **Federated Learning** – Privacy-preserving model training across distributed datasets
+- **Advanced Reranking** – Cross-encoder models and learned ranking functions
+- **Performance Dashboard** – Web UI for monitoring pipeline health and cost metrics
 
-### With ChromaDB
+### Beyond
 
-```javascript
-class ChromaRetriever {
-  constructor({ url, collection }) {
-    this.client = new ChromaClient({ path: url });
-    this.collectionName = collection;
-  }
-
-  async store(vectors, metadata) {
-    const collection = await this.client.getOrCreateCollection({
-      name: this.collectionName,
-    });
-
-    await collection.add({
-      embeddings: vectors,
-      metadatas: metadata,
-      ids: metadata.map((_, i) => `doc_${i}`),
-    });
-  }
-
-  async retrieve(queryVector, options) {
-    const collection = await this.client.getCollection({
-      name: this.collectionName,
-    });
-
-    const results = await collection.query({
-      queryEmbeddings: [queryVector],
-      nResults: options.topK || 5,
-    });
-
-    return results.metadatas[0].map((meta, i) => ({
-      content: results.documents[0][i],
-      metadata: meta,
-      score: 1 - results.distances[0][i],
-    }));
-  }
-}
-```
+- Native Rust bindings for performance-critical paths
+- Kubernetes operator for production deployments
+- Real-time collaboration features for team-based pipelines
 
-## Troubleshooting
+**Vote on features:** Share your priorities in [GitHub Discussions](https://github.com/DevilsDev/rag-pipeline-utils/discussions/categories/roadmap).
 
-### Common Issues
+---
 
-**Error: Cannot find module**
+## Contributing
 
-```bash
-npm install @devilsdev/rag-pipeline-utils
-```
+We welcome contributions of all kinds:
 
-**Error: Plugin not registered**
+- **Code** – Fix bugs, add features, improve performance
+- **Documentation** – Write guides, improve examples, clarify concepts
+- **Testing** – Expand test coverage, add integration tests, report edge cases
+- **Design** – Propose API improvements, suggest architectural patterns
+- **Community** – Answer questions, review pull requests, mentor new contributors
 
-```javascript
-// Make sure to register your plugins
-pluginRegistry.register("my-embedder", MyEmbedderClass);
-```
+**Before You Start:**
 
-**Error: Invalid configuration**
+1. Read the [Contributing Guide](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/docs/CONTRIBUTING.md)
+2. Check existing [Issues](https://github.com/DevilsDev/rag-pipeline-utils/issues) and [Discussions](https://github.com/DevilsDev/rag-pipeline-utils/discussions)
+3. Open an issue to discuss major changes before coding
+4. Follow our [Code of Conduct](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/CODE_OF_CONDUCT.md)
 
-```javascript
-// Validate your configuration
-const { validateRagrc } = require("@devilsdev/rag-pipeline-utils");
-const isValid = validateRagrc(config);
-if (!isValid) {
-  console.error("Configuration is invalid");
-}
-```
+**Pull Request Checklist:**
 
-### Debug Mode
+- [ ] Tests pass (`npm test`)
+- [ ] Linter passes (`npm run lint`)
+- [ ] Documentation updated
+- [ ] Changelog entry added
+- [ ] Type definitions updated (if applicable)
 
-```javascript
-const { logger } = require("@devilsdev/rag-pipeline-utils");
+---
 
-// Enable debug logging
-logger.setLevel("debug");
-```
+## License
 
-## Documentation
+**GPL-3.0** – See [LICENSE](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/LICENSE) for full terms.
 
-- [GitHub Repository](https://github.com/DevilsDev/rag-pipeline-utils)
-- [Issue Tracker](https://github.com/DevilsDev/rag-pipeline-utils/issues)
-- [Discussions](https://github.com/DevilsDev/rag-pipeline-utils/discussions)
+This is free software: you are free to change and redistribute it under the terms of the GNU General Public License version 3.
 
-## Contributing
+---
 
-Contributions are welcome. Please see the [contribution guidelines](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/docs/CONTRIBUTING.md).
+## What's Next?
 
-## License
+⭐ **Star this repository** if you find it useful—it helps others discover the project.
 
-GPL-3.0 - See [LICENSE](https://github.com/DevilsDev/rag-pipeline-utils/blob/main/LICENSE) for details.
+📢 **Share your use case** in [Discussions](https://github.com/DevilsDev/rag-pipeline-utils/discussions/categories/show-and-tell) to inspire the community.
 
-## Support
+🤝 **Contribute** your first pull request—check out issues tagged [good first issue](https://github.com/DevilsDev/rag-pipeline-utils/labels/good%20first%20issue).
 
-- Issues: https://github.com/DevilsDev/rag-pipeline-utils/issues
-- Discussions: https://github.com/DevilsDev/rag-pipeline-utils/discussions
+Happy building. 🚀