raglite-toolkit 1.0.2__tar.gz → 1.2.0__tar.gz

raglite_toolkit-1.2.0/.github/workflows/pr-verify.yml

@@ -0,0 +1,36 @@
+name: PR Verification
+
+on:
+  pull_request:
+    branches:
+      - main
+      - master
+  push:
+    branches:
+      - main
+      - master
+  workflow_dispatch:
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Check code style (ruff)
+        run: python -m ruff check .
+
+      - name: Run tests
+        run: python -m pytest tests/ -q

raglite_toolkit-1.2.0/ARCHITECTURE.md

@@ -0,0 +1,188 @@
+# RAGLite Python (`raglite-toolkit`) Architecture
+
+This document details the software architecture, component design, data flow, and APIs of the Python implementation of **RAGLite** (`raglite-toolkit`).
+
+---
+
+## 1. Overview & Core Philosophy
+
+`raglite-toolkit` is a Python-native Retrieval-Augmented Generation library built with Pydantic v2 and FastAPI. It provides zero-boilerplate semantic search, multi-provider LLM response synthesis, and self-hosted REST APIs over local files.
+
+### Key Characteristics
+* **Python-Native & Type-Annotated**: Modern Python 3.10+ typing with Pydantic v2 model validation and camelCase alias serialization.
+* **1:1 Parity with TypeScript SDK**: Identical function signatures, option dictionaries, data models, and `.raglite/` persistence layout.
+* **Pluggable & Extensible**: Modular Abstract Base Classes (ABCs) for Loaders, Chunkers, Embeddings, Vector Databases, and LLMs.
+* **Per-Document Isolation**: Namespaced vector collections tied to source document path/identity.
+* **SHA-256 Content Caching**: Automatically skips re-embedding if document content has not changed.
+* **Offline-First Option**: Local offline embeddings via `sentence-transformers` (`all-MiniLM-L6-v2`) and local LLMs via Ollama.
+
+---
+
+## 2. Directory & Module Structure
+
+```
+raglite-py/src/raglite/
+├── api/             # FastAPI REST HTTP server & Pydantic schemas
+│   ├── __init__.py
+│   ├── schemas.py
+│   └── server.py
+├── chunking/        # Text splitting algorithms
+│   ├── __init__.py
+│   ├── base.py
+│   └── recursive.py
+├── core/            # Main facade orchestrator
+│   ├── __init__.py
+│   └── document.py
+├── embeddings/      # Embedding provider factory & adapters
+│   ├── __init__.py
+│   ├── base.py
+│   ├── factory.py
+│   ├── local.py      # sentence-transformers (offline)
+│   ├── models.py
+│   └── remote.py     # OpenAI, Gemini, Mistral, Cohere, Voyage, Ollama
+├── llm/             # LLM provider factory & prompt synthesis
+│   ├── __init__.py
+│   ├── answer.py
+│   ├── factory.py
+│   ├── models.py
+│   └── prompt.py
+├── loaders/         # Document parser implementations
+│   ├── __init__.py
+│   ├── base.py
+│   ├── docx.py       # python-docx reader
+│   ├── json.py
+│   ├── markdown.py
+│   ├── pdf.py        # pypdf / pymupdf reader
+│   └── txt.py
+├── retrieval/       # Retriever & ranking algorithms
+│   ├── __init__.py
+│   └── retriever.py
+├── vectordb/        # Vector Database adapters
+│   ├── __init__.py
+│   ├── base.py       # VectorStore Abstract Base Class
+│   ├── factory.py
+│   ├── memory.py     # Local JSON persistence (.raglite/)
+│   ├── pinecone.py   # Pinecone Cloud
+│   └── qdrant.py     # Qdrant local/cloud
+├── cli.py           # Command-line interface tool (Typer/Argparse)
+├── config.py        # Environment & default configuration
+├── constants.py     # System constants & defaults
+├── errors.py        # Custom RAGLite exception definitions
+├── types.py         # Pydantic v2 data models & type aliases
+└── utils/           # Utility functions (hashing, math, crypto)
+```
+
+---
+
+## 3. High-Level System Diagram
+
+```mermaid
+graph TD
+    subgraph Client Application
+        App["Python Application"]
+        CLI["raglite CLI"]
+        HTTPClient["Curl / HTTPX Client"]
+    end
+
+    subgraph Entrypoints
+        Doc["Document Facade Class<br/>(src/raglite/core/document.py)"]
+        FastAPIServer["FastAPI REST Server<br/>(src/raglite/api/server.py)"]
+    end
+
+    subgraph Core Pipeline Modules
+        Loaders["Document Loaders<br/>(src/raglite/loaders/)"]
+        Chunker["Recursive Splitter<br/>(src/raglite/chunking/)"]
+        Embeddings["Embeddings Engine<br/>(src/raglite/embeddings/)"]
+        VectorStore["VectorStore Adapter<br/>(src/raglite/vectordb/)"]
+        Retriever["Retriever Engine<br/>(src/raglite/retrieval/)"]
+        LLM["LLM Synthesis Engine<br/>(src/raglite/llm/)"]
+    end
+
+    subgraph Persistence Layer
+        JSONDisk["Disk Index Storage<br/>(.raglite/indexes/*.json)"]
+        ExternalVDB["External Vector DB<br/>(Qdrant / Pinecone)"]
+    end
+
+    App --> Doc
+    CLI --> Doc
+    HTTPClient --> FastAPIServer
+    FastAPIServer --> Doc
+
+    Doc --> Loaders
+    Doc --> Chunker
+    Doc --> Embeddings
+    Doc --> VectorStore
+    Doc --> Retriever
+    Doc --> LLM
+
+    VectorStore --> JSONDisk
+    VectorStore --> ExternalVDB
+```
+
+---
+
+## 4. End-to-End Data Pipeline
+
+### 4.1 Ingestion & Indexing
+1. `doc.build()` invokes the appropriate `BaseLoader` based on file extension (`.pdf`, `.txt`, `.json`, `.md`, `.docx`).
+2. Calculates SHA-256 hash of raw document content.
+3. Checks existing `IndexMetadata` in `VectorStore`. If hash matches, skips re-indexing.
+4. If hash differs or force rebuild requested:
+   - `RecursiveCharacterTextSplitter` chunks text (default size 1000, overlap 200).
+   - `EmbeddingFactory` generates normalized vectors for each chunk.
+   - `VectorStore.add()` saves chunks and `VectorStore.save_index_metadata()` persists index metadata.
+
+### 4.2 Retrieval & Answer Synthesis
+1. `doc.search(query, top_k)`:
+   - Embeds query text.
+   - Executes vector search via `VectorStore.search()`, calculating cosine similarity over L2-normalized vectors.
+   - Returns top $K$ `SearchResult` objects.
+2. `doc.ask(question, options)`:
+   - Runs `search(question)`.
+   - Constructs context-augmented system/user prompt via `build_prompt()`.
+   - Calls `generate_answer()` or `stream_answer()` with selected LLM adapter (OpenAI, Anthropic, Google, Groq, Ollama, etc.).
+
+---
+
+## 5. REST API Architecture
+
+Built using **FastAPI** framework for async capabilities, automatic OpenAPI docs, and Uvicorn serving.
+
+| Method | Endpoint | Auth Required? | Description |
+| :--- | :--- | :--- | :--- |
+| `GET` | `/health` | No | Liveness status & total chunk count |
+| `GET` | `/info` | Yes (Bearer token) | Configuration details & index state |
+| `POST` | `/search` | Yes (Bearer token) | Semantic vector search |
+| `POST` | `/ask` | Yes (Bearer token) | Context Q&A generation (supports streaming via StreamingResponse) |
+
+---
+
+## 6. Vector Database Abstract Base Class (`src/raglite/vectordb/base.py`)
+
+```python
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from raglite.types import IndexMetadata, SearchResult, StoredChunk
+
+class VectorStore(ABC):
+    @abstractmethod
+    def load(self, doc_id: str) -> None: ...
+
+    @abstractmethod
+    def reset(self, doc_id: str) -> None: ...
+
+    @abstractmethod
+    def add(self, doc_id: str, chunks: List[StoredChunk]) -> None: ...
+
+    @abstractmethod
+    def search(self, doc_id: str, query_vector: List[float], top_k: int, min_score: Optional[float] = None) -> List[SearchResult]: ...
+
+    @abstractmethod
+    def count(self, doc_id: str) -> int: ...
+
+    @abstractmethod
+    def save_index_metadata(self, doc_id: str, meta: IndexMetadata) -> None: ...
+
+    @abstractmethod
+    def read_index_metadata(self, doc_id: str) -> Optional[IndexMetadata]: ...
+```

raglite_toolkit-1.2.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.2.0] - 2026-08-02
+
+### Added
+- **Multi-Document & Directory Ingestion (`DocumentCollection`):**
+  - Added `DocumentCollection` class to manage semantic indexing, multi-document retrieval, and Q&A across folders, glob patterns, web URLs, and mixed file lists.
+  - Parallel semantic search over collection vector stores with score-based top-$K$ merging and ranking.
+  - Contextual Q&A synthesis (`ask` and `ask_stream`) across multi-document collections.
+- **Directory Loader (`DirectoryLoader`):**
+  - Recursive directory scanner (`recursive=True`) with glob pattern matching (e.g. `./docs/**/*.md`).
+  - Auto-detection of supported extensions (`.pdf`, `.txt`, `.md`, `.json`, `.docx`).
+  - Detailed error reporting and warning logs for unsupported/empty files.
+- **Web Loader (`WebLoader`):**
+  - Native loader for fetching HTTP/HTTPS web URLs directly.
+  - Automatic HTML cleaning into formatted text/markdown with script, style, and SVG tag stripping.
+  - JSON and plain text content-type parsing.
+- **CLI & FastAPI REST Server Support:**
+  - Upgraded `raglite index`, `search`, `ask`, and `serve` CLI commands to process directories, glob patterns, and URLs.
+  - Updated FastAPI REST server to support `DocumentCollection` and single `Document` targets.
+- **Unit & Integration Tests:**
+  - Added unit and integration tests for `DirectoryLoader`, `WebLoader`, and `DocumentCollection`.
+
+## [1.1.0] - 2026-07-19
+
+### Added
+- **Pluggable Vector Databases:** Added support for custom local and cloud vector database backends via a new `vectorStore` config option.
+  - **Memory Store (`"memory"`):** Default in-memory store persisting indexes locally to JSON (unchanged behaviour).
+  - **Qdrant Store (`"qdrant"`):** Wrapper for Qdrant local/cloud using stdlib `urllib` REST requests. Supports auto-collection creation, API key auth, and custom collection names.
+  - **Pinecone Store (`"pinecone"`):** Cloud database support using Pinecone Namespaces and stdlib `urllib` REST requests. Stores index metadata as a reserved `__metadata__` vector.
+  - **Custom Adapters:** Pass any class instance implementing the `VectorStore` ABC directly as `vectorStore` in `DocumentOptions`.
+- **`VectorStoreProviderConfig` type:** New Pydantic model in `types.py` describing provider, URL, API key, index name, and store directory.
+- **Factory:** `create_vector_store(config, namespace)` utility in `vectordb/factory.py` resolving the correct store from config.
+- **Examples:**
+  - `examples/qdrant_example.py` — full index + search demo with Qdrant.
+  - `examples/custom_store_example.py` — implementing and using a custom VectorStore ABC subclass.
+- **Automation Scripts:**
+  - `scripts/pre-commit.sh` — runs ruff lint, mypy type-check, and pytest before committing.
+  - `scripts/pre-release.sh` — cleans builds, runs full verification, and builds distribution packages.
+- **GitHub Actions Workflow:** `pr-verify.yml` — automatically runs code style checks and the full test suite on every pull request and push to `main`/`master`.
+
+### Changed
+- **`DocumentOptions` / `ResolvedConfig`:** Added optional `vectorStore` field supporting `VectorStoreProviderConfig` or a custom `VectorStore` instance.
+- **`Document.__init__`:** Constructor now resolves the appropriate vector store from config, accepting provider configs or custom instances.

{raglite_toolkit-1.0.2 → raglite_toolkit-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raglite-toolkit
-Version: 1.0.2
+Version: 1.2.0
 Summary: Build semantic search, multi-provider question answering, and REST APIs over your documents in a few lines of Python.
 Project-URL: Homepage, https://github.com/creatorpiyush/raglite-py
 Project-URL: Repository, https://github.com/creatorpiyush/raglite-py
@@ -40,20 +40,22 @@ Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
 Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
 Requires-Dist: twine>=5.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # raglite-toolkit
 
-> Build semantic search, multi-provider question answering, and REST APIs over your documents in a few lines of Python.
+> Build semantic search, multi-provider question answering, and REST APIs over your documents, directories, or web URLs in a few lines of Python.
 
-**raglite-toolkit** is a Python port of the [`raglite-toolkit`](https://github.com/creatorpiyush/raglite) TypeScript package with full feature parity.
+**raglite-toolkit** is a Python port of the [`raglite-toolkit`](https://github.com/creatorpiyush/raglite) TypeScript package with full 1:1 feature parity.
 
 ---
 
 ## Features
 
 - 📄 **PDF, TXT, JSON, Markdown, DOCX** loaders out of the box
+- 📁 **Multi-document, directory, & URL ingestion** — index folders, glob patterns, or web URLs with `DocumentCollection`
 - 🤖 **Multi-provider LLMs** — OpenAI, Anthropic (Claude), Google (Gemini), Mistral, Cohere, Groq, xAI, Ollama
 - 🔢 **Multi-provider embeddings** — OpenAI, Google, Mistral, Cohere, Voyage, Ollama, or a **local** offline sentence-transformer (no API key needed)
 - 📐 **Cosine similarity** scoring with L2-normalized vectors
@@ -101,20 +103,44 @@ print(answer.text)
 
 ---
 
+## Multi-Document & Directory Ingestion (`DocumentCollection`)
+
+Index entire directories (`./docs`), glob patterns, web URLs, or mixed file arrays:
+
+```python
+from raglite import DocumentCollection
+
+collection = DocumentCollection(["./docs", "https://example.com"], {
+    "embeddings": {"provider": "local"},
+    "llm": {"provider": "openai", "apiKey": "sk-..."},
+})
+
+# Index all documents concurrently
+result = collection.build()
+print(f"Indexed {result.totalDocuments} document(s), {result.totalChunks} chunk(s).")
+
+# Search across all collection documents simultaneously
+hits = collection.search("refund policy", top_k=5)
+
+# Contextual Q&A across the entire collection
+answer = collection.ask("What is the refund policy?")
+print(answer.text)
+```
+
+---
+
 ## Fully Offline — No API Key Needed
 
 ```python
 from raglite import Document
 
-doc = Document("./policy.pdf", {
-    "embeddings": {"provider": "local"},          # sentence-transformers offline
-    "llm":        {"provider": "ollama",          # local Ollama instance
-                   "model": "llama3.2",
-                   "baseURL": "http://localhost:11434/api"},
+doc = Document("./manual.txt", {
+    "embeddings": {"provider": "local"},
+    "llm":        {"provider": "ollama", "model": "llama3.2"},
 })
 
 doc.build()
-print(doc.ask("What is the refund policy?").text)
+print(doc.ask("How do I reset the device?").text)
 ```
 
 ---
@@ -122,24 +148,60 @@ print(doc.ask("What is the refund policy?").text)
 ## Choose Any LLM at Ask-Time
 
 ```python
-# Switch LLMs without rebuilding the index — embeddings are reused
-for llm in [
-    {"provider": "openai",    "model": "gpt-4o",                   "apiKey": "sk-..."},
-    {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022","apiKey": "sk-ant-..."},
-    {"provider": "google",    "model": "gemini-2.0-flash",         "apiKey": "AI..."},
-    {"provider": "groq",      "model": "llama-3.3-70b-versatile",  "apiKey": "gsk_..."},
-]:
-    answer = doc.ask("Summarize this document", {"llm": llm})
-    print(f"[{llm['provider']}] {answer.text[:120]}")
+# Pass an inline LLM override to ask()
+gpt4 = doc.ask("Summarise this document", options={
+    "llm": {"provider": "openai", "model": "gpt-4o", "apiKey": "sk-..."}
+})
+
+claude = doc.ask("Summarise this document", options={
+    "llm": {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022", "apiKey": "sk-ant-..."}
+})
 ```
 
 ---
 
-## Streaming
+## Streaming Responses
 
 ```python
-for chunk in doc.ask_stream("Explain the introduction"):
+for chunk in doc.ask_stream("Explain section 3 in detail"):
     print(chunk, end="", flush=True)
+print()
+```
+
+---
+
+## Pluggable Vector Databases
+
+`raglite` supports pluggable vector stores (Memory, Qdrant, Pinecone, LanceDB, or custom subclasses):
+
+### Memory Store (Default)
+```python
+doc = Document("./policy.pdf", {
+    "vectorStore": {"provider": "memory", "storeDir": ".raglite"}
+})
+```
+
+### Qdrant Store
+```python
+doc = Document("./policy.pdf", {
+    "vectorStore": {
+        "provider": "qdrant",
+        "url": "http://localhost:6333",
+        "apiKey": "your-key",
+        "indexName": "my_collection"
+    }
+})
+```
+
+### Pinecone Store
+```python
+doc = Document("./policy.pdf", {
+    "vectorStore": {
+        "provider": "pinecone",
+        "url": "https://my-index.svc.pinecone.io",
+        "apiKey": "your-key"
+    }
+})
 ```
 
 ---
@@ -147,25 +209,26 @@ for chunk in doc.ask_stream("Explain the introduction"):
 ## REST API
 
 ```python
-handle = doc.serve({
-    "port": 8085,
-    "llm":  {"provider": "openai", "apiKey": "sk-..."},
-    "bearerToken": "my-secret-token",
+from raglite import Document
+
+doc = Document("./policy.pdf", {
+    "embeddings": {"provider": "local"},
+    "llm":        {"provider": "openai", "apiKey": "sk-..."},
 })
-print(f"Serving on {handle.url}")
+doc.build()
 
-# ... later
-handle.close()
+# Start background FastAPI server on port 8085
+doc.serve(port=8085, bearer_token="secret-token")
 ```
 
-### Endpoints
+Endpoints:
 
-| Method | Path      | Auth? | Description |
-|--------|-----------|-------|-------------|
-| `GET`  | `/health` | ❌    | Liveness + index stats |
-| `GET`  | `/info`   | ✅    | Configuration snapshot |
-| `POST` | `/search` | ✅    | Semantic search |
-| `POST` | `/ask`    | ✅    | Question answering |
+| Method | Path | Auth required? | Description |
+| ------ | ---- | -------------- | ----------- |
+| `GET`  | `/health` | ❌ | Liveness + index stats |
+| `GET`  | `/info`   | ✅ | Configuration snapshot |
+| `POST` | `/search` | ✅ | Semantic search |
+| `POST` | `/ask`    | ✅ | Question answering (supports `stream: true`) |
 
 ### Example `curl` calls
 
@@ -175,19 +238,19 @@ curl http://127.0.0.1:8085/health
 
 # Search
 curl -X POST http://127.0.0.1:8085/search \
-  -H 'Authorization: Bearer my-secret-token' \
+  -H 'Authorization: Bearer secret-token' \
   -H 'Content-Type: application/json' \
   -d '{"query": "refund policy", "topK": 3}'
 
 # Ask (non-streaming)
 curl -X POST http://127.0.0.1:8085/ask \
-  -H 'Authorization: Bearer my-secret-token' \
+  -H 'Authorization: Bearer secret-token' \
   -H 'Content-Type: application/json' \
   -d '{"question": "What is the refund policy?"}'
 
 # Ask (streaming)
 curl -X POST http://127.0.0.1:8085/ask \
-  -H 'Authorization: Bearer my-secret-token' \
+  -H 'Authorization: Bearer secret-token' \
   -H 'Content-Type: application/json' \
   -d '{"question": "Summarize the document", "stream": true}'
 ```
@@ -197,18 +260,18 @@ curl -X POST http://127.0.0.1:8085/ask \
 ## CLI
 
 ```bash
-# Index a document
+# Index a document, directory, or URL
 raglite index ./policy.pdf --embed-provider local
 
 # Semantic search
-raglite search ./policy.pdf "refund policy" --top-k 5
+raglite search ./docs "refund policy" --top-k 5
 
 # Ask a question (streaming)
-raglite ask ./policy.pdf "What is the refund policy?" \
-  --llm-provider openai --llm-key $OPENAI_API_KEY --stream
+raglite ask ./docs "What is the refund policy?" \
+  --llm-provider anthropic --llm-key $ANTHROPIC_API_KEY --stream
 
 # Serve a REST API
-raglite serve ./policy.pdf \
+raglite serve https://example.com \
   --llm-provider openai --llm-key $OPENAI_API_KEY \
   --port 8085 --token $RAGLITE_TOKEN
 ```
@@ -339,7 +402,7 @@ query_vec = embedder.embed_query("refund policy")
 
 ```bash
 # Clone and set up
-git clone <repo>
+git clone https://github.com/creatorpiyush/raglite-py.git
 cd raglite-py
 
 # Create virtual environment
@@ -349,15 +412,14 @@ source .venv/bin/activate    # Windows: .venv\Scripts\activate
 # Install in editable mode with dev dependencies
 pip install -e ".[dev]"
 
-# Run tests (76 tests, ~5s, no network required)
+# Run test suite
 pytest
 
 # Run with coverage
 pytest --cov=raglite --cov-report=term-missing
 
-# Run examples (uses local offline embeddings)
+# Run examples
 python examples/basic.py
-python examples/multi_provider.py   # requires API keys in env
 python examples/serve.py
 ```
 
@@ -366,23 +428,26 @@ python examples/serve.py
 ```
 tests/
 ├── unit/
-│   ├── test_chunking.py   # RecursiveChunker algorithm
-│   ├── test_vectordb.py   # MemoryVectorStore (cosine, persistence, isolation)
-│   ├── test_loaders.py    # TxtLoader, MarkdownLoader, JsonLoader
-│   ├── test_prompt.py     # system/user prompt builders
-│   ├── test_errors.py     # exception hierarchy
-│   ├── test_config.py     # config defaults and overrides
-│   ├── test_hash.py       # SHA-256 file hashing + namespace generation
-│   ├── test_retriever.py  # Retriever with mocked embedder
-│   └── test_cli.py        # CLI commands and argument parsing
+│   ├── test_chunking.py           # RecursiveChunker algorithm
+│   ├── test_vectordb.py           # MemoryVectorStore (cosine, persistence, isolation)
+│   ├── test_loaders.py            # TxtLoader, MarkdownLoader, JsonLoader
+│   ├── test_directory_loader.py   # DirectoryLoader (recursive scanning, glob filtering)
+│   ├── test_web_loader.py         # WebLoader (HTML parsing, tag stripping)
+│   ├── test_prompt.py             # system/user prompt builders
+│   ├── test_errors.py             # exception hierarchy
+│   ├── test_config.py             # config defaults and overrides
+│   ├── test_hash.py               # SHA-256 file hashing + namespace generation
+│   ├── test_retriever.py          # Retriever with mocked embedder
+│   └── test_cli.py                # CLI commands and argument parsing
 └── integration/
-    ├── test_document.py   # build/cache/search lifecycle (mocked embeddings)
-    ├── test_ask.py        # ask/stream with mocked LLM generation
-    └── test_api.py        # FastAPI endpoints via TestClient
+    ├── test_document.py           # build/cache/search lifecycle (mocked embeddings)
+    ├── test_collection.py         # DocumentCollection multi-document indexing & FastAPI server
+    ├── test_ask.py                # ask/stream with mocked LLM generation
+    └── test_api.py                # FastAPI endpoints via TestClient
 ```
 
 ---
 
 ## License
 
-MIT
+MIT © [Piyush Anand](https://github.com/creatorpiyush)