ragmill 0.2.0__py3-none-any.whl

ragmill/__init__.py

@@ -0,0 +1,3 @@
+from ragmill.engine import RAGEngine
+
+__all__ = ["RAGEngine"]

ragmill/embeddings.py

@@ -0,0 +1,95 @@
+"""
+Local embedding generation via ONNX Runtime.
+
+Downloads a small quantized sentence-embedding model on first use and
+caches it under ~/.cache/ragmill/models — every call after that runs
+fully offline. Imports for onnxruntime/tokenizers are lazy so importing
+this module doesn't force the 'embeddings' extra on core users.
+"""
+
+import urllib.request
+from pathlib import Path
+from typing import List, Optional, Union
+
+import numpy as np
+
+DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2"
+DEFAULT_CACHE_DIR = Path.home() / ".cache" / "ragmill" / "models"
+EMBEDDING_DIM = 384
+
+_MODEL_FILES = {
+    "model.onnx": "onnx/model_quantized.onnx",
+    "tokenizer.json": "tokenizer.json",
+}
+
+
+def _model_dir(model_name: str, cache_dir: Path) -> Path:
+    return cache_dir / model_name.replace("/", "__")
+
+
+def _download(model_name: str, cache_dir: Path) -> Path:
+    target_dir = _model_dir(model_name, cache_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    for local_name, remote_path in _MODEL_FILES.items():
+        local_path = target_dir / local_name
+        if local_path.exists():
+            continue
+        url = f"https://huggingface.co/{model_name}/resolve/main/{remote_path}"
+        urllib.request.urlretrieve(url, local_path)
+
+    return target_dir
+
+
+class EmbeddingModel:
+    """Wraps an ONNX sentence-embedding model + tokenizer for local inference."""
+
+    def __init__(self, model_name: str = DEFAULT_MODEL, cache_dir: Optional[Union[str, Path]] = None):
+        try:
+            import onnxruntime as ort
+        except ImportError as exc:
+            raise ImportError(
+                "Embeddings require the 'embeddings' extra. Install it with: pip install ragmill[embeddings]"
+            ) from exc
+        try:
+            from tokenizers import Tokenizer
+        except ImportError as exc:
+            raise ImportError(
+                "Embeddings require the 'embeddings' extra. Install it with: pip install ragmill[embeddings]"
+            ) from exc
+
+        resolved_cache_dir = Path(cache_dir) if cache_dir else DEFAULT_CACHE_DIR
+        model_dir = _download(model_name, resolved_cache_dir)
+
+        self.tokenizer = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
+        self.tokenizer.enable_padding()
+        self.tokenizer.enable_truncation(max_length=256)
+        self.session = ort.InferenceSession(str(model_dir / "model.onnx"))
+
+    def embed(self, texts: List[str]) -> np.ndarray:
+        """Encodes a batch of strings into L2-normalized dense vectors."""
+        if not texts:
+            return np.zeros((0, EMBEDDING_DIM), dtype=np.float32)
+
+        encodings = self.tokenizer.encode_batch(texts)
+        input_ids = np.array([e.ids for e in encodings], dtype=np.int64)
+        attention_mask = np.array([e.attention_mask for e in encodings], dtype=np.int64)
+        token_type_ids = np.zeros_like(input_ids)
+
+        outputs = self.session.run(
+            None,
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "token_type_ids": token_type_ids,
+            },
+        )
+        token_embeddings = outputs[0]  # (batch, seq_len, dim)
+
+        mask = attention_mask[:, :, np.newaxis].astype(np.float32)
+        summed = (token_embeddings * mask).sum(axis=1)
+        counts = np.clip(mask.sum(axis=1), 1e-9, None)
+        pooled = summed / counts
+
+        norms = np.clip(np.linalg.norm(pooled, axis=1, keepdims=True), 1e-9, None)
+        return (pooled / norms).astype(np.float32)

ragmill/engine.py

@@ -0,0 +1,152 @@
+"""
+RAGMill Core Engine
+Optimized for high-performance directory crawling, semantic splitting,
+and clean data structural alignment.
+"""
+
+import os
+import re
+from typing import List, Dict, Any, Generator
+
+from ragmill.parsers import extract_pdf_text, extract_docx_text
+
+PLAIN_TEXT_EXTENSIONS = ('.txt', '.md', '.log', '.rst')
+PDF_EXTENSIONS = ('.pdf',)
+DOCX_EXTENSIONS = ('.docx',)
+
+
+class RAGEngine:
+    def __init__(self, chunk_size: int = 500, overlap: int = 50):
+        """
+        Initializes the AI-Native Data Pipeline Engine.
+
+        :param chunk_size: Maximum structural character size permitted per single block.
+        :param overlap: Token/character historical window size to carry context forward.
+        """
+        self.chunk_size = chunk_size
+        self.overlap = max(0, overlap)
+
+        if self.overlap >= self.chunk_size:
+            raise ValueError("Overlap threshold cannot be greater than or equal to total chunk size.")
+
+    def stream_directory(self, directory_path: str) -> Generator[Dict[str, Any], None, None]:
+        """
+        Performs high-efficiency traversal over a target local directory,
+        streaming extracted text payloads while preserving system memory.
+        """
+        if not os.path.exists(directory_path):
+            raise FileNotFoundError(f"Target path tracking validation failed for: '{directory_path}'")
+
+        for root, _, files in os.walk(directory_path):
+            for file in files:
+                extension = os.path.splitext(file)[1].lower()
+                if extension not in PLAIN_TEXT_EXTENSIONS + PDF_EXTENSIONS + DOCX_EXTENSIONS:
+                    continue
+
+                full_path = os.path.join(root, file)
+                try:
+                    content = self._extract_content(full_path, extension)
+
+                    yield {
+                        "source_path": os.path.abspath(full_path),
+                        "filename": file,
+                        "raw_content": content.strip(),
+                        "modified_at": os.path.getmtime(full_path)
+                    }
+                except Exception as e:
+                    # Log error safely to console without terminating pipeline execution
+                    print(f"[⚠️ Pipeline Warning] Unable to parse file {full_path}: {str(e)}")
+
+    def _extract_content(self, full_path: str, extension: str) -> str:
+        if extension in PLAIN_TEXT_EXTENSIONS:
+            with open(full_path, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read()
+        if extension in PDF_EXTENSIONS:
+            return extract_pdf_text(full_path)
+        if extension in DOCX_EXTENSIONS:
+            return extract_docx_text(full_path)
+        raise ValueError(f"Unsupported extension: {extension}")
+
+    def semantic_chunking(self, text: str) -> List[str]:
+        """
+        Recursively splits text payloads based on logical paragraph, structural,
+        and grammatical sentence boundaries to protect semantic context integrity.
+        """
+        if not text:
+            return []
+
+        # Split along logical structural breaks (paragraphs, list blocks, markdown breaks)
+        paragraphs = re.split(r'\n\s*\n', text)
+        chunks: List[str] = []
+        current_buffer = ""
+
+        for paragraph in paragraphs:
+            paragraph = paragraph.strip()
+            if not paragraph:
+                continue
+
+            # Handle edge cases where single paragraphs wildly exceed standard target size limits
+            if len(paragraph) > self.chunk_size:
+                # If buffer already holds content, clear it to start clean sentence processing
+                if current_buffer:
+                    chunks.append(current_buffer.strip())
+                    current_buffer = ""
+
+                # Split down into sentence tokens
+                sentences = re.split(r'(?<=[.!?])\s+', paragraph)
+                for sentence in sentences:
+                    sentence = sentence.strip()
+                    if not sentence:
+                        continue
+
+                    if len(current_buffer) + len(sentence) + 1 <= self.chunk_size:
+                        current_buffer = f"{current_buffer} {sentence}".strip()
+                    else:
+                        if current_buffer:
+                            chunks.append(current_buffer)
+
+                        # Handle long sentence edge case: verify slice safety before copying historical context
+                        overlap_prefix = current_buffer[-self.overlap:] if len(current_buffer) >= self.overlap else current_buffer
+                        current_buffer = f"{overlap_prefix} {sentence}".strip() if self.overlap > 0 else sentence
+            else:
+                # Standard appending logic for typical sized semantic paragraphs
+                spacing = "\n\n" if current_buffer else ""
+                if len(current_buffer) + len(spacing) + len(paragraph) <= self.chunk_size:
+                    current_buffer = f"{current_buffer}{spacing}{paragraph}"
+                else:
+                    if current_buffer:
+                        chunks.append(current_buffer.strip())
+
+                    # Establish overlap baseline from preceding content block
+                    overlap_prefix = current_buffer[-self.overlap:] if len(current_buffer) >= self.overlap else current_buffer
+                    current_buffer = f"{overlap_prefix}\n\n{paragraph}".strip() if self.overlap > 0 else paragraph
+
+        if current_buffer:
+            chunks.append(current_buffer.strip())
+
+        return chunks
+
+    def execute_pipeline(self, directory_path: str) -> List[Dict[str, Any]]:
+        """
+        Compiles the full ingestion and data structure cycle across a target directory.
+
+        :return: Array containing distinct dictionary models containing contextual metadata maps.
+        """
+        pipeline_payloads: List[Dict[str, Any]] = []
+
+        for file_manifest in self.stream_directory(directory_path):
+            text_chunks = self.semantic_chunking(file_manifest["raw_content"])
+
+            for index, chunk in enumerate(text_chunks):
+                pipeline_payloads.append({
+                    "metadata": {
+                        "source_file": file_manifest["source_path"],
+                        "filename": file_manifest["filename"],
+                        "chunk_index": index,
+                        "character_length": len(chunk),
+                        "modified_at": file_manifest["modified_at"]
+                    },
+                    "content": chunk
+                })
+
+        return pipeline_payloads

ragmill/parsers.py

@@ -0,0 +1,33 @@
+"""
+Format-specific text extractors.
+
+Each extractor takes a file path and returns its plain-text content.
+PDF and DOCX support are optional extras — the imports are lazy so the
+core package stays installable with zero dependencies.
+"""
+
+
+def extract_pdf_text(path: str) -> str:
+    try:
+        from pypdf import PdfReader
+    except ImportError as exc:
+        raise ImportError(
+            "PDF support requires the 'pdf' extra. Install it with: pip install ragmill[pdf]"
+        ) from exc
+
+    reader = PdfReader(path)
+    pages = [page.extract_text() or "" for page in reader.pages]
+    return "\n\n".join(page.strip() for page in pages if page.strip())
+
+
+def extract_docx_text(path: str) -> str:
+    try:
+        import docx
+    except ImportError as exc:
+        raise ImportError(
+            "DOCX support requires the 'docx' extra. Install it with: pip install ragmill[docx]"
+        ) from exc
+
+    document = docx.Document(path)
+    paragraphs = [p.text.strip() for p in document.paragraphs]
+    return "\n\n".join(p for p in paragraphs if p)

ragmill/sync.py

@@ -0,0 +1,74 @@
+"""
+Incremental sync between a directory and a VectorStore.
+
+Re-running execute_pipeline() on every call re-embeds and re-inserts every
+file, every time. sync_directory() instead tracks a content hash per file
+(in VectorStore.file_state) so unchanged files are skipped entirely, changed
+files have their old chunks replaced, and files removed from disk have their
+chunks removed from the store too.
+
+This module has no hard dependencies of its own — it only calls methods on
+the engine/model/store objects passed in, so it stays zero-dependency at
+import time just like engine.py.
+"""
+
+import hashlib
+from typing import Any, Dict
+
+
+def _hash_content(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def sync_directory(directory_path: str, engine, model, store) -> Dict[str, int]:
+    """
+    Walks directory_path with `engine`, embeds changed/new files with `model`,
+    and reconciles the result into `store`.
+
+    :return: counts of {"added", "updated", "skipped", "deleted"} files.
+    """
+    seen_sources = set()
+    added = updated = skipped = 0
+
+    for file_manifest in engine.stream_directory(directory_path):
+        source_file = file_manifest["source_path"]
+        seen_sources.add(source_file)
+
+        content_hash = _hash_content(file_manifest["raw_content"])
+        existing_state = store.get_file_state(source_file)
+
+        if existing_state is not None and existing_state["content_hash"] == content_hash:
+            skipped += 1
+            continue
+
+        text_chunks = engine.semantic_chunking(file_manifest["raw_content"])
+        payloads = [
+            {
+                "metadata": {
+                    "source_file": source_file,
+                    "filename": file_manifest["filename"],
+                    "chunk_index": index,
+                    "character_length": len(chunk),
+                    "modified_at": file_manifest["modified_at"],
+                },
+                "content": chunk,
+            }
+            for index, chunk in enumerate(text_chunks)
+        ]
+
+        # Replace any previous chunks for this file before inserting the new ones,
+        # so an updated file doesn't leave stale chunks from its old content behind.
+        store.delete_by_source(source_file)
+        if payloads:
+            vectors = model.embed([p["content"] for p in payloads])
+            store.add(payloads, vectors)
+        store.upsert_file_state(source_file, content_hash, file_manifest["modified_at"])
+
+        if existing_state is None:
+            added += 1
+        else:
+            updated += 1
+
+    deleted = store.delete_missing_sources(seen_sources)
+
+    return {"added": added, "updated": updated, "skipped": skipped, "deleted": deleted}

ragmill/vector_store.py

@@ -0,0 +1,163 @@
+"""
+A minimal local vector store backed by SQLite.
+
+Stores chunk payloads alongside their embedding vectors and performs
+brute-force cosine similarity search in-memory. No external vector index
+needed at the scale this library targets (a local folder's worth of
+documents) — every payload is loaded once per search and scored with a
+single matrix multiply.
+
+Also tracks per-file content hashes (the `file_state` table) so callers
+can detect which files changed since the last run without re-embedding
+everything — see sync.py for the orchestration that uses this.
+"""
+
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+
+
+class VectorStore:
+    def __init__(self, db_path: Union[str, Path] = ":memory:"):
+        self.connection = sqlite3.connect(str(db_path))
+        self.connection.execute(
+            """
+            CREATE TABLE IF NOT EXISTS chunks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                source_file TEXT,
+                filename TEXT,
+                chunk_index INTEGER,
+                content TEXT NOT NULL,
+                modified_at REAL,
+                embedding BLOB NOT NULL
+            )
+            """
+        )
+        self.connection.execute(
+            """
+            CREATE TABLE IF NOT EXISTS file_state (
+                source_file TEXT PRIMARY KEY,
+                content_hash TEXT NOT NULL,
+                modified_at REAL
+            )
+            """
+        )
+        self.connection.commit()
+
+    def add(self, payloads: List[Dict[str, Any]], embeddings: np.ndarray) -> None:
+        if len(payloads) != len(embeddings):
+            raise ValueError("payloads and embeddings must be the same length")
+
+        rows = [
+            (
+                payload["metadata"]["source_file"],
+                payload["metadata"]["filename"],
+                payload["metadata"]["chunk_index"],
+                payload["content"],
+                payload["metadata"].get("modified_at"),
+                np.asarray(vector, dtype=np.float32).tobytes(),
+            )
+            for payload, vector in zip(payloads, embeddings)
+        ]
+        self.connection.executemany(
+            """
+            INSERT INTO chunks (source_file, filename, chunk_index, content, modified_at, embedding)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            rows,
+        )
+        self.connection.commit()
+
+    def search(
+        self,
+        query_embedding: np.ndarray,
+        top_k: int = 5,
+        filename: Optional[str] = None,
+        source_file: Optional[str] = None,
+        modified_after: Optional[float] = None,
+        modified_before: Optional[float] = None,
+    ) -> List[Dict[str, Any]]:
+        query_vector = np.asarray(query_embedding, dtype=np.float32)
+
+        clauses = []
+        params: List[Any] = []
+        if filename is not None:
+            clauses.append("filename = ?")
+            params.append(filename)
+        if source_file is not None:
+            clauses.append("source_file = ?")
+            params.append(source_file)
+        if modified_after is not None:
+            clauses.append("modified_at >= ?")
+            params.append(modified_after)
+        if modified_before is not None:
+            clauses.append("modified_at <= ?")
+            params.append(modified_before)
+
+        query = "SELECT source_file, filename, chunk_index, content, embedding FROM chunks"
+        if clauses:
+            query += " WHERE " + " AND ".join(clauses)
+
+        rows = self.connection.execute(query, params).fetchall()
+        if not rows:
+            return []
+
+        vectors = np.stack([np.frombuffer(row[4], dtype=np.float32) for row in rows])
+        # Embeddings are pre-normalized (see EmbeddingModel.embed), so the dot
+        # product against a normalized query is equivalent to cosine similarity.
+        scores = vectors @ query_vector
+
+        top_indices = np.argsort(-scores)[:top_k]
+        return [
+            {
+                "score": float(scores[i]),
+                "metadata": {
+                    "source_file": rows[i][0],
+                    "filename": rows[i][1],
+                    "chunk_index": rows[i][2],
+                },
+                "content": rows[i][3],
+            }
+            for i in top_indices
+        ]
+
+    def count(self) -> int:
+        return self.connection.execute("SELECT COUNT(*) FROM chunks").fetchone()[0]
+
+    def delete_by_source(self, source_file: str) -> None:
+        self.connection.execute("DELETE FROM chunks WHERE source_file = ?", (source_file,))
+        self.connection.execute("DELETE FROM file_state WHERE source_file = ?", (source_file,))
+        self.connection.commit()
+
+    def delete_missing_sources(self, known_sources: set) -> int:
+        """Removes chunks/file_state for any source_file not in known_sources. Returns count removed."""
+        rows = self.connection.execute("SELECT source_file FROM file_state").fetchall()
+        stale = [row[0] for row in rows if row[0] not in known_sources]
+        for source_file in stale:
+            self.delete_by_source(source_file)
+        return len(stale)
+
+    def get_file_state(self, source_file: str) -> Optional[Dict[str, Any]]:
+        row = self.connection.execute(
+            "SELECT content_hash, modified_at FROM file_state WHERE source_file = ?",
+            (source_file,),
+        ).fetchone()
+        if row is None:
+            return None
+        return {"content_hash": row[0], "modified_at": row[1]}
+
+    def upsert_file_state(self, source_file: str, content_hash: str, modified_at: Optional[float]) -> None:
+        self.connection.execute(
+            """
+            INSERT INTO file_state (source_file, content_hash, modified_at)
+            VALUES (?, ?, ?)
+            ON CONFLICT(source_file) DO UPDATE SET content_hash = excluded.content_hash, modified_at = excluded.modified_at
+            """,
+            (source_file, content_hash, modified_at),
+        )
+        self.connection.commit()
+
+    def close(self) -> None:
+        self.connection.close()

ragmill-0.2.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: ragmill
+Version: 0.2.0
+Summary: A lightweight, zero-config local pipeline engine for AI data ingestion, semantic chunking, embeddings, and vector search.
+Project-URL: Homepage, https://github.com/Abdullahbinaqeel/RAGMill
+Project-URL: Repository, https://github.com/Abdullahbinaqeel/RAGMill
+Project-URL: Issues, https://github.com/Abdullahbinaqeel/RAGMill/issues
+Author-email: Abdullah Bin Aqeel <abdulbinaqeel@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: data-pipeline,llm-ingestion,onnx,rag,semantic-chunking,vector-embeddings,vector-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Provides-Extra: all
+Requires-Dist: numpy>=1.22.0; extra == 'all'
+Requires-Dist: onnxruntime>=1.14.0; extra == 'all'
+Requires-Dist: pypdf>=4.0; extra == 'all'
+Requires-Dist: python-docx>=1.0; extra == 'all'
+Requires-Dist: tokenizers>=0.15.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: numpy>=1.22.0; extra == 'dev'
+Requires-Dist: onnxruntime>=1.14.0; extra == 'dev'
+Requires-Dist: pypdf>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: python-docx>=1.0; extra == 'dev'
+Requires-Dist: reportlab>=4.0; extra == 'dev'
+Requires-Dist: tokenizers>=0.15.0; extra == 'dev'
+Provides-Extra: docx
+Requires-Dist: python-docx>=1.0; extra == 'docx'
+Provides-Extra: embeddings
+Requires-Dist: numpy>=1.22.0; extra == 'embeddings'
+Requires-Dist: onnxruntime>=1.14.0; extra == 'embeddings'
+Requires-Dist: tokenizers>=0.15.0; extra == 'embeddings'
+Provides-Extra: pdf
+Requires-Dist: pypdf>=4.0; extra == 'pdf'
+Description-Content-Type: text/markdown
+
+# RAGMill
+
+[![PyPI](https://img.shields.io/pypi/v/ragmill.svg)](https://pypi.org/project/ragmill/)
+[![CI](https://github.com/Abdullahbinaqeel/RAGMill/actions/workflows/ci.yml/badge.svg)](https://github.com/Abdullahbinaqeel/RAGMill/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/ragmill.svg)](https://pypi.org/project/ragmill/)
+
+A lightweight, zero-config local pipeline engine for AI data ingestion, semantic chunking, embeddings, and vector search.
+
+## Install
+
+```bash
+pip install ragmill[all]   # includes PDF + DOCX + embeddings support
+# or
+pip install ragmill        # core only (txt/md), zero dependencies
+```
+
+Developing locally instead? Clone the repo and use an editable install:
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+```
+
+## Usage
+
+### Ingest + chunk
+
+```python
+from ragmill import RAGEngine
+
+engine = RAGEngine(chunk_size=500, overlap=50)
+chunks = engine.execute_pipeline("./my_documents")
+
+for chunk in chunks:
+    print(chunk["metadata"]["filename"], chunk["content"][:80])
+```
+
+Supports `.txt`, `.md`, `.log`, `.rst`, `.pdf`, and `.docx` out of the box.
+
+### Embed + search locally
+
+Requires the `embeddings` extra (`pip install -e ".[embeddings]"`). The model
+(a quantized MiniLM ONNX export, ~23MB) downloads once to
+`~/.cache/ragmill/models` and runs fully offline after that.
+
+```python
+from ragmill import RAGEngine
+from ragmill.embeddings import EmbeddingModel
+from ragmill.vector_store import VectorStore
+
+chunks = RAGEngine().execute_pipeline("./my_documents")
+
+model = EmbeddingModel()
+vectors = model.embed([c["content"] for c in chunks])
+
+store = VectorStore("my_documents.db")   # or VectorStore() for in-memory
+store.add(chunks, vectors)
+
+query_vector = model.embed(["how does the overlap window work?"])[0]
+for result in store.search(query_vector, top_k=3):
+    print(round(result["score"], 3), result["metadata"]["filename"], "->", result["content"][:80])
+```
+
+Filter a search to a specific file or a time window:
+
+```python
+store.search(query_vector, top_k=3, filename="report.pdf")
+store.search(query_vector, top_k=3, modified_after=1704067200.0)  # since 2024-01-01
+```
+
+### Keep a store in sync with a folder
+
+Re-embedding every file on every run is wasteful once a folder is large.
+`sync_directory` tracks a content hash per file and only touches what
+actually changed:
+
+```python
+from ragmill.sync import sync_directory
+
+result = sync_directory("./my_documents", engine, model, store)
+print(result)  # {"added": 2, "updated": 1, "skipped": 40, "deleted": 1}
+```
+
+Unchanged files are skipped without re-embedding. A changed file has its old
+chunks replaced with new ones. A file removed from disk has its chunks
+removed from the store on the next sync.

ragmill-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ragmill/__init__.py,sha256=Uunco4CvQroa93Q8DmkxquA1iuERwOSqZKw1Ee94NGU,62
+ragmill/embeddings.py,sha256=Xf0jYRHuSsOrIwiy_2GgZntiVPXlfFCB2scsZoF9Pyg,3502
+ragmill/engine.py,sha256=8gTS-LdnaUBwytS3G3ydtH9blQLhAQ_MdbRPiP3px2Y,6603
+ragmill/parsers.py,sha256=N42QDvA1jCU0eCG4IgX32vASfz_8wFRIlR2rWe-XOko,1059
+ragmill/sync.py,sha256=EV1DnSQbjZCmhWsqnSQnNGPZ41y33zcLDFipIoj7BPY,2724
+ragmill/vector_store.py,sha256=PNAsYBSBfpQ7phAgm9WSZxv7dcTuOtvlzHHbdCFw7-M,6078
+ragmill-0.2.0.dist-info/METADATA,sha256=MEqj_kZ5XbQBTRk2WAY9fnajYaGWXjqh_eqG8EpxeP0,4974
+ragmill-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+ragmill-0.2.0.dist-info/licenses/LICENSE,sha256=aE9ynIl05eKXtuUT40jNfGLnjwkP_aJHW2IJEUmQdQI,1075
+ragmill-0.2.0.dist-info/RECORD,,

ragmill-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

ragmill-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdullah Bin Aqeel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.