industrial-rag-agent 0.1.0__tar.gz

industrial_rag_agent-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: industrial-rag-agent
+Version: 0.1.0
+Summary: Local RAG agent for Industrial AI Agents — watches folders, extracts text, OCRs scanned PDFs, indexes in SQLite FTS5
+Author-email: Industrial AI Agents <support@industrialagents.com>
+License: Proprietary
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: watchdog>=4.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pymupdf>=1.24
+Requires-Dist: uvicorn>=0.30
+Requires-Dist: httpx>=0.27
+Provides-Extra: ocr-win
+Requires-Dist: pytesseract>=0.3; extra == "ocr-win"
+Provides-Extra: ocr-linux
+Requires-Dist: pytesseract>=0.3; extra == "ocr-linux"
+
+# Industrial RAG Agent
+
+Local document indexer for **Industrial AI Agents** SaaS.
+
+Runs on the client's computer — documents **never leave their network**.
+
+## How it works
+
+```
+📁 Document Folder
+    ↓ (file watcher)
+📄 Text Extraction (PDF, DOCX, XLSX, TXT/CSV)
+    ↓ (+ OCR for scanned PDFs)
+🗃️ SQLite FTS5 Index (local)
+    ↓
+🌐 Local API (localhost:3847/search)
+    ↓
+☁️ Industrial AI Agents (cloud) queries this endpoint
+```
+
+## Install
+
+```bash
+pip install industrial-rag-agent
+```
+
+## Quick Start
+
+```bash
+# 1. Configure
+industrial-rag-agent configure
+
+# 2. Start (watches folders + runs API)
+industrial-rag-agent start
+```
+
+## Commands
+
+| Command     | Description                              |
+|-------------|------------------------------------------|
+| `configure` | Interactive setup (API key, folders, port) |
+| `start`     | Start watcher + local API server          |
+| `index`     | One-time index of all existing documents  |
+| `search`    | Search from the command line              |
+| `status`    | Show index statistics                     |
+
+## OCR Support
+
+| OS      | Engine                    | Install Required? |
+|---------|---------------------------|-------------------|
+| macOS   | Apple Vision (Neural Engine) | No — built in    |
+| Windows | Tesseract OCR             | Yes               |
+| Linux   | Tesseract OCR             | Yes               |
+
+## API Endpoints
+
+- `GET /search?q=keyword&limit=5` — search indexed documents
+- `GET /status` — agent status and index stats
+- `GET /health` — health check
+
+## Requirements
+
+- Python 3.11+
+- Tesseract OCR (Windows/Linux only)

industrial_rag_agent-0.1.0/README.md

@@ -0,0 +1,64 @@
+# Industrial RAG Agent
+
+Local document indexer for **Industrial AI Agents** SaaS.
+
+Runs on the client's computer — documents **never leave their network**.
+
+## How it works
+
+```
+📁 Document Folder
+    ↓ (file watcher)
+📄 Text Extraction (PDF, DOCX, XLSX, TXT/CSV)
+    ↓ (+ OCR for scanned PDFs)
+🗃️ SQLite FTS5 Index (local)
+    ↓
+🌐 Local API (localhost:3847/search)
+    ↓
+☁️ Industrial AI Agents (cloud) queries this endpoint
+```
+
+## Install
+
+```bash
+pip install industrial-rag-agent
+```
+
+## Quick Start
+
+```bash
+# 1. Configure
+industrial-rag-agent configure
+
+# 2. Start (watches folders + runs API)
+industrial-rag-agent start
+```
+
+## Commands
+
+| Command     | Description                              |
+|-------------|------------------------------------------|
+| `configure` | Interactive setup (API key, folders, port) |
+| `start`     | Start watcher + local API server          |
+| `index`     | One-time index of all existing documents  |
+| `search`    | Search from the command line              |
+| `status`    | Show index statistics                     |
+
+## OCR Support
+
+| OS      | Engine                    | Install Required? |
+|---------|---------------------------|-------------------|
+| macOS   | Apple Vision (Neural Engine) | No — built in    |
+| Windows | Tesseract OCR             | Yes               |
+| Linux   | Tesseract OCR             | Yes               |
+
+## API Endpoints
+
+- `GET /search?q=keyword&limit=5` — search indexed documents
+- `GET /status` — agent status and index stats
+- `GET /health` — health check
+
+## Requirements
+
+- Python 3.11+
+- Tesseract OCR (Windows/Linux only)

industrial_rag_agent-0.1.0/industrial_rag_agent/__init__.py

@@ -0,0 +1,3 @@
+"""Industrial RAG Agent — local document indexer for Industrial AI Agents SaaS."""
+
+__version__ = "0.1.0"

industrial_rag_agent-0.1.0/industrial_rag_agent/cli.py

@@ -0,0 +1,234 @@
+"""CLI entry point — `industrial-rag-agent start|configure|index|search|status`."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+import threading
+import time
+from pathlib import Path
+
+from . import __version__
+from .config import Config, CONFIG_DIR
+from .extractor import extract
+from .indexer import index_document, needs_reindex, search as do_search, get_stats
+from .watcher import start_watching
+from .server import create_server
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("rag-agent")
+
+
+def cmd_configure(args: argparse.Namespace) -> None:
+    """Interactive configuration setup."""
+    config = Config.load()
+
+    print(f"\n  Industrial RAG Agent v{__version__}")
+    print(f"  Config: {CONFIG_DIR}\n")
+
+    # API key
+    key = input(f"  API key [{config.api_key[:8] + '...' if config.api_key else 'not set'}]: ").strip()
+    if key:
+        config.api_key = key
+
+    # Watch folders
+    print(f"\n  Current watch folders: {config.watch_folders or '(none)'}")
+    print("  Enter folder paths (one per line, empty line to finish):")
+    folders: list[str] = []
+    while True:
+        folder = input("    > ").strip()
+        if not folder:
+            break
+        p = Path(folder).expanduser().resolve()
+        if p.is_dir():
+            folders.append(str(p))
+            print(f"      Added: {p}")
+        else:
+            print(f"      [!] Not a directory: {p}")
+    if folders:
+        config.watch_folders = folders
+
+    # Port
+    port_str = input(f"\n  Local API port [{config.local_port}]: ").strip()
+    if port_str.isdigit():
+        config.local_port = int(port_str)
+
+    config.save()
+    print(f"\n  Config saved to {CONFIG_DIR / 'config.json'}")
+
+    issues = config.validate()
+    if issues:
+        print("\n  Warnings:")
+        for issue in issues:
+            print(f"    - {issue}")
+    else:
+        print("  Ready to start: industrial-rag-agent start")
+
+
+def cmd_index(args: argparse.Namespace) -> None:
+    """Index all existing documents in configured folders."""
+    config = Config.load()
+    issues = config.validate()
+    if issues:
+        print("Configuration issues:")
+        for i in issues:
+            print(f"  - {i}")
+        print("Run: industrial-rag-agent configure")
+        sys.exit(1)
+
+    total_files = 0
+    total_chunks = 0
+
+    for folder in config.watch_folders:
+        folder_path = Path(folder)
+        print(f"\nScanning: {folder_path}")
+        for ext in config.extensions:
+            for file_path in folder_path.rglob(f"*{ext}"):
+                if file_path.name.startswith(".") or file_path.name.startswith("~$"):
+                    continue
+                if not needs_reindex(file_path):
+                    logger.debug("Skipping (unchanged): %s", file_path.name)
+                    continue
+                print(f"  Indexing: {file_path.name}...", end=" ", flush=True)
+                text = extract(file_path)
+                if text:
+                    chunks = index_document(file_path, text)
+                    print(f"{chunks} chunks")
+                    total_files += 1
+                    total_chunks += chunks
+                else:
+                    print("(no text extracted)")
+
+    print(f"\nDone: {total_files} files, {total_chunks} chunks indexed.")
+
+
+def cmd_search(args: argparse.Namespace) -> None:
+    """Search indexed documents."""
+    results = do_search(args.query, limit=args.limit)
+    if not results:
+        print("No results found.")
+        return
+    for i, r in enumerate(results, 1):
+        print(f"\n--- Result {i} (score: {r['score']}) ---")
+        print(f"File: {r['file_name']}")
+        print(f"Path: {r['file_path']}")
+        print(f"Snippet: {r['snippet']}")
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    """Show agent status and index stats."""
+    config = Config.load()
+    stats = get_stats()
+    print(f"\n  Industrial RAG Agent v{__version__}")
+    print(f"  OS: {config.os_type}")
+    print(f"  Port: {config.local_port}")
+    print(f"  Watch folders: {config.watch_folders}")
+    print(f"  Documents indexed: {stats['documents']}")
+    print(f"  Total chunks: {stats['chunks']}")
+    print(f"  Database size: {stats['db_size_mb']} MB")
+    issues = config.validate()
+    if issues:
+        print("\n  Issues:")
+        for i in issues:
+            print(f"    - {i}")
+
+
+def _process_file(file_path: Path) -> None:
+    """Extract and index a single file (used by watcher and initial scan)."""
+    if needs_reindex(file_path):
+        text = extract(file_path)
+        if text:
+            index_document(file_path, text)
+
+
+def cmd_start(args: argparse.Namespace) -> None:
+    """Start the agent — watches folders + runs local API server."""
+    config = Config.load()
+    issues = config.validate()
+    if issues:
+        print("Configuration issues:")
+        for i in issues:
+            print(f"  - {i}")
+        print("Run: industrial-rag-agent configure")
+        sys.exit(1)
+
+    print(f"\n  Industrial RAG Agent v{__version__}")
+    print(f"  API: http://127.0.0.1:{config.local_port}")
+    print(f"  Watching: {', '.join(config.watch_folders)}")
+    print("  Press Ctrl+C to stop.\n")
+
+    # Initial scan
+    logger.info("Running initial scan...")
+    for folder in config.watch_folders:
+        for ext in config.extensions:
+            for file_path in Path(folder).rglob(f"*{ext}"):
+                if not file_path.name.startswith(".") and not file_path.name.startswith("~$"):
+                    _process_file(file_path)
+
+    stats = get_stats()
+    logger.info("Initial scan complete: %d documents, %d chunks", stats["documents"], stats["chunks"])
+
+    # Start file watcher
+    observer = start_watching(
+        folders=config.watch_folders,
+        extensions=config.extensions,
+        on_file=_process_file,
+    )
+
+    # Start API server in a thread
+    server = create_server(config)
+    server_thread = threading.Thread(target=server.serve_forever, daemon=True)
+    server_thread.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+        observer.stop()
+        server.shutdown()
+        observer.join()
+        print("Done.")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="industrial-rag-agent",
+        description="Local RAG agent for Industrial AI Agents — indexes your documents securely on your machine.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("configure", help="Interactive configuration setup")
+    sub.add_parser("start", help="Start the agent (watcher + API server)")
+    sub.add_parser("index", help="Index all documents in configured folders")
+    sub.add_parser("status", help="Show agent status and index statistics")
+
+    sp_search = sub.add_parser("search", help="Search indexed documents")
+    sp_search.add_argument("query", help="Search query")
+    sp_search.add_argument("--limit", type=int, default=5, help="Max results")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    commands = {
+        "configure": cmd_configure,
+        "start": cmd_start,
+        "index": cmd_index,
+        "search": cmd_search,
+        "status": cmd_status,
+    }
+    commands[args.command](args)
+
+
+if __name__ == "__main__":
+    main()

industrial_rag_agent-0.1.0/industrial_rag_agent/config.py

@@ -0,0 +1,66 @@
+"""Configuration management — reads/writes ~/.industrial-rag/config.json."""
+
+from __future__ import annotations
+
+import json
+import platform
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".industrial-rag"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DB_FILE = CONFIG_DIR / "index.db"
+LOG_FILE = CONFIG_DIR / "agent.log"
+
+
+@dataclass
+class Config:
+    """Runtime configuration for the local RAG agent."""
+
+    # Folders the agent watches for documents
+    watch_folders: list[str] = field(default_factory=list)
+
+    # API key linking this install to the client's SaaS account
+    api_key: str = ""
+
+    # URL of the Industrial AI Agents backend (cloud)
+    api_url: str = "https://industrial-agents.vercel.app"
+
+    # Local API port — the agents query localhost:<port>/search
+    local_port: int = 3847
+
+    # Detected OS (auto-filled on first run)
+    os_type: str = field(default_factory=lambda: platform.system().lower())
+
+    # Supported file extensions
+    extensions: list[str] = field(
+        default_factory=lambda: [".pdf", ".docx", ".xlsx", ".txt", ".csv"]
+    )
+
+    @classmethod
+    def load(cls) -> "Config":
+        """Load config from disk, or return defaults."""
+        if CONFIG_FILE.exists():
+            data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+        return cls()
+
+    def save(self) -> None:
+        """Persist config to disk."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(
+            json.dumps(asdict(self), indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    def validate(self) -> list[str]:
+        """Return list of configuration problems (empty = OK)."""
+        issues: list[str] = []
+        if not self.watch_folders:
+            issues.append("No watch folders configured.")
+        for f in self.watch_folders:
+            if not Path(f).is_dir():
+                issues.append(f"Watch folder does not exist: {f}")
+        if not self.api_key:
+            issues.append("API key not set.")
+        return issues

industrial_rag_agent-0.1.0/industrial_rag_agent/extractor.py

@@ -0,0 +1,175 @@
+"""Text extraction from PDF, DOCX, XLSX, TXT/CSV — with platform-aware OCR."""
+
+from __future__ import annotations
+
+import csv
+import io
+import logging
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger("rag-agent.extractor")
+
+
+# ---------------------------------------------------------------------------
+# OCR back-ends
+# ---------------------------------------------------------------------------
+
+def _ocr_apple_vision(image_path: str) -> str:
+    """Use macOS Apple Vision Framework via a small Swift helper."""
+    script = """
+    import Foundation
+    import Vision
+
+    let url = URL(fileURLWithPath: CommandLine.arguments[1])
+    guard let img = CGImage.from(url: url) else { exit(1) }
+
+    let request = VNRecognizeTextRequest()
+    request.recognitionLevel = .accurate
+    request.recognitionLanguages = ["es", "en", "de", "fr"]
+
+    let handler = VNImageRequestHandler(cgImage: img)
+    try handler.perform([request])
+
+    let text = request.results?.compactMap { $0.topCandidates(1).first?.string }.joined(separator: "\\n") ?? ""
+    print(text)
+    """
+    # Apple Vision is called via the system's `swift` interpreter
+    try:
+        result = subprocess.run(
+            ["swift", "-e", script, image_path],
+            capture_output=True, text=True, timeout=30,
+        )
+        return result.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        logger.warning("Apple Vision OCR failed for %s", image_path)
+        return ""
+
+
+def _ocr_tesseract(image_path: str) -> str:
+    """Use Tesseract OCR (Windows/Linux)."""
+    tesseract = shutil.which("tesseract")
+    if not tesseract:
+        logger.warning("Tesseract not found in PATH — skipping OCR for %s", image_path)
+        return ""
+    try:
+        result = subprocess.run(
+            [tesseract, image_path, "stdout", "-l", "spa+eng"],
+            capture_output=True, text=True, timeout=60,
+        )
+        return result.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        logger.warning("Tesseract OCR failed for %s", image_path)
+        return ""
+
+
+def ocr_image(image_path: str) -> str:
+    """OCR a single image using the platform's native engine."""
+    system = platform.system()
+    if system == "Darwin":
+        return _ocr_apple_vision(image_path)
+    else:  # Windows or Linux
+        return _ocr_tesseract(image_path)
+
+
+# ---------------------------------------------------------------------------
+# Document extractors
+# ---------------------------------------------------------------------------
+
+def extract_pdf(file_path: Path) -> str:
+    """Extract text from PDF; OCR pages that have no text layer."""
+    import fitz  # PyMuPDF
+
+    doc = fitz.open(str(file_path))
+    pages: list[str] = []
+
+    for page_num, page in enumerate(doc):
+        text = page.get_text().strip()
+        if text:
+            pages.append(text)
+        else:
+            # Page is likely scanned — render to image and OCR
+            logger.info("OCR page %d of %s", page_num + 1, file_path.name)
+            pix = page.get_pixmap(dpi=300)
+            img_path = f"/tmp/rag_ocr_{file_path.stem}_p{page_num}.png"
+            pix.save(img_path)
+            ocr_text = ocr_image(img_path)
+            if ocr_text:
+                pages.append(ocr_text)
+            # Clean up temp image
+            Path(img_path).unlink(missing_ok=True)
+
+    doc.close()
+    return "\n\n".join(pages)
+
+
+def extract_docx(file_path: Path) -> str:
+    """Extract text from Word .docx file."""
+    from docx import Document
+
+    doc = Document(str(file_path))
+    paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+    # Also extract text from tables
+    for table in doc.tables:
+        for row in table.rows:
+            cells = [cell.text.strip() for cell in row.cells if cell.text.strip()]
+            if cells:
+                paragraphs.append(" | ".join(cells))
+    return "\n".join(paragraphs)
+
+
+def extract_xlsx(file_path: Path) -> str:
+    """Extract text from Excel .xlsx file."""
+    from openpyxl import load_workbook
+
+    wb = load_workbook(str(file_path), read_only=True, data_only=True)
+    parts: list[str] = []
+    for sheet in wb.sheetnames:
+        ws = wb[sheet]
+        parts.append(f"=== {sheet} ===")
+        for row in ws.iter_rows(values_only=True):
+            cells = [str(c) if c is not None else "" for c in row]
+            if any(cells):
+                parts.append(" | ".join(cells))
+    wb.close()
+    return "\n".join(parts)
+
+
+def extract_text(file_path: Path) -> str:
+    """Extract text from .txt or .csv file."""
+    content = file_path.read_text(encoding="utf-8", errors="replace")
+    if file_path.suffix.lower() == ".csv":
+        # Re-format CSV for better search
+        reader = csv.reader(io.StringIO(content))
+        lines = [" | ".join(row) for row in reader]
+        return "\n".join(lines)
+    return content
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+EXTRACTORS = {
+    ".pdf": extract_pdf,
+    ".docx": extract_docx,
+    ".xlsx": extract_xlsx,
+    ".txt": extract_text,
+    ".csv": extract_text,
+}
+
+
+def extract(file_path: Path) -> str:
+    """Extract text from a supported file. Returns empty string on error."""
+    ext = file_path.suffix.lower()
+    extractor = EXTRACTORS.get(ext)
+    if not extractor:
+        logger.warning("Unsupported file type: %s", ext)
+        return ""
+    try:
+        return extractor(file_path)
+    except Exception as e:
+        logger.error("Extraction failed for %s: %s", file_path, e)
+        return ""

industrial_rag_agent-0.1.0/industrial_rag_agent/indexer.py

@@ -0,0 +1,193 @@
+"""SQLite FTS5 indexer — full-text search over extracted document content."""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import sqlite3
+import time
+from pathlib import Path
+
+from .config import DB_FILE
+
+logger = logging.getLogger("rag-agent.indexer")
+
+
+def _get_db(db_path: Path | None = None) -> sqlite3.Connection:
+    """Open (and initialize) the SQLite database."""
+    path = db_path or DB_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path))
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA synchronous=NORMAL")
+
+    # Main documents table
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS documents (
+            id TEXT PRIMARY KEY,
+            file_path TEXT NOT NULL,
+            file_name TEXT NOT NULL,
+            file_hash TEXT NOT NULL,
+            file_size INTEGER NOT NULL,
+            indexed_at REAL NOT NULL,
+            chunk_count INTEGER DEFAULT 0
+        )
+    """)
+
+    # FTS5 virtual table for search
+    conn.execute("""
+        CREATE VIRTUAL TABLE IF NOT EXISTS chunks USING fts5(
+            doc_id,
+            chunk_index,
+            content,
+            content_type,
+            tokenize='porter unicode61'
+        )
+    """)
+
+    conn.commit()
+    return conn
+
+
+def _file_hash(file_path: Path) -> str:
+    """SHA-256 hash of file contents for change detection."""
+    h = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for block in iter(lambda: f.read(65536), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _chunk_text(text: str, max_chars: int = 1000, overlap: int = 200) -> list[str]:
+    """Split text into overlapping chunks for better search relevance."""
+    if len(text) <= max_chars:
+        return [text]
+
+    chunks: list[str] = []
+    start = 0
+    while start < len(text):
+        end = start + max_chars
+        # Try to break at a paragraph or sentence boundary
+        chunk = text[start:end]
+        if end < len(text):
+            # Look for last paragraph break
+            last_para = chunk.rfind("\n\n")
+            if last_para > max_chars // 2:
+                end = start + last_para + 2
+                chunk = text[start:end]
+            else:
+                # Look for last sentence break
+                last_period = chunk.rfind(". ")
+                if last_period > max_chars // 2:
+                    end = start + last_period + 2
+                    chunk = text[start:end]
+
+        chunks.append(chunk.strip())
+        start = end - overlap
+
+    return chunks
+
+
+def needs_reindex(file_path: Path, db_path: Path | None = None) -> bool:
+    """Check if a file needs (re-)indexing based on its hash."""
+    conn = _get_db(db_path)
+    try:
+        row = conn.execute(
+            "SELECT file_hash FROM documents WHERE file_path = ?",
+            (str(file_path),),
+        ).fetchone()
+        if row is None:
+            return True
+        return row[0] != _file_hash(file_path)
+    finally:
+        conn.close()
+
+
+def index_document(file_path: Path, text: str, db_path: Path | None = None) -> int:
+    """Index a document's extracted text into FTS5. Returns chunk count."""
+    conn = _get_db(db_path)
+    doc_id = hashlib.md5(str(file_path).encode()).hexdigest()
+
+    try:
+        # Remove old data for this doc
+        conn.execute("DELETE FROM chunks WHERE doc_id = ?", (doc_id,))
+        conn.execute("DELETE FROM documents WHERE id = ?", (doc_id,))
+
+        # Chunk and index
+        chunks = _chunk_text(text)
+        for i, chunk in enumerate(chunks):
+            conn.execute(
+                "INSERT INTO chunks (doc_id, chunk_index, content, content_type) VALUES (?, ?, ?, ?)",
+                (doc_id, str(i), chunk, file_path.suffix.lower()),
+            )
+
+        # Record document metadata
+        conn.execute(
+            "INSERT INTO documents (id, file_path, file_name, file_hash, file_size, indexed_at, chunk_count) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (
+                doc_id,
+                str(file_path),
+                file_path.name,
+                _file_hash(file_path),
+                file_path.stat().st_size,
+                time.time(),
+                len(chunks),
+            ),
+        )
+
+        conn.commit()
+        logger.info("Indexed %s → %d chunks", file_path.name, len(chunks))
+        return len(chunks)
+    except Exception as e:
+        conn.rollback()
+        logger.error("Failed to index %s: %s", file_path, e)
+        return 0
+    finally:
+        conn.close()
+
+
+def search(query: str, limit: int = 5, db_path: Path | None = None) -> list[dict]:
+    """Search indexed documents. Returns list of {file_name, file_path, snippet, rank}."""
+    conn = _get_db(db_path)
+    try:
+        rows = conn.execute(
+            """
+            SELECT
+                d.file_name,
+                d.file_path,
+                snippet(chunks, 2, '<b>', '</b>', '...', 40) AS snippet,
+                rank
+            FROM chunks
+            JOIN documents d ON d.id = chunks.doc_id
+            WHERE chunks MATCH ?
+            ORDER BY rank
+            LIMIT ?
+            """,
+            (query, limit),
+        ).fetchall()
+
+        return [
+            {
+                "file_name": r[0],
+                "file_path": r[1],
+                "snippet": r[2],
+                "score": round(abs(r[3]), 4),
+            }
+            for r in rows
+        ]
+    except Exception as e:
+        logger.error("Search failed: %s", e)
+        return []
+    finally:
+        conn.close()
+
+
+def get_stats(db_path: Path | None = None) -> dict:
+    """Return index statistics."""
+    conn = _get_db(db_path)
+    try:
+        doc_count = conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0]
+        chunk_count = conn.execute("SELECT COUNT(*) FROM chunks").fetchone()[0]
+        return {"documents": doc_count, "chunks": chunk_count, "db_size_mb": round(DB_FILE.stat().st_size / 1024 / 1024, 2) if DB_FILE.exists() else 0}
+    finally:
+        conn.close()

industrial_rag_agent-0.1.0/industrial_rag_agent/server.py

@@ -0,0 +1,78 @@
+"""Local HTTP API server — the SaaS agents query this endpoint to search client docs."""
+
+from __future__ import annotations
+
+import json
+import logging
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+
+from .indexer import search, get_stats
+from .config import Config
+
+logger = logging.getLogger("rag-agent.server")
+
+
+class RAGHandler(BaseHTTPRequestHandler):
+    """Minimal HTTP handler: GET /search?q=...&limit=5 and GET /status."""
+
+    config: Config  # Set by the server factory
+
+    def log_message(self, format: str, *args) -> None:
+        logger.debug(format, *args)
+
+    def _json_response(self, status: int, data: dict) -> None:
+        body = json.dumps(data, ensure_ascii=False).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        # CORS — allow the SaaS app to call this from the browser
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_OPTIONS(self) -> None:
+        self.send_response(204)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Authorization")
+        self.end_headers()
+
+    def do_GET(self) -> None:
+        parsed = urlparse(self.path)
+        path = parsed.path.rstrip("/")
+        params = parse_qs(parsed.query)
+
+        if path == "/search":
+            query = params.get("q", [""])[0]
+            if not query:
+                self._json_response(400, {"error": "Missing ?q= parameter"})
+                return
+            limit = int(params.get("limit", ["5"])[0])
+            results = search(query, limit=limit)
+            self._json_response(200, {"query": query, "results": results, "count": len(results)})
+
+        elif path == "/status":
+            stats = get_stats()
+            self._json_response(200, {
+                "status": "running",
+                "version": "0.1.0",
+                "os": self.config.os_type,
+                "index": stats,
+                "watch_folders": self.config.watch_folders,
+            })
+
+        elif path == "/health":
+            self._json_response(200, {"ok": True})
+
+        else:
+            self._json_response(404, {"error": "Not found. Use /search?q=... or /status"})
+
+
+def create_server(config: Config) -> HTTPServer:
+    """Create the local API server."""
+    RAGHandler.config = config
+    server = HTTPServer(("127.0.0.1", config.local_port), RAGHandler)
+    logger.info("API server listening on http://127.0.0.1:%d", config.local_port)
+    return server

industrial_rag_agent-0.1.0/industrial_rag_agent/watcher.py

@@ -0,0 +1,76 @@
+"""File system watcher — monitors folders for new/changed documents."""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import Callable
+
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler, FileSystemEvent
+
+logger = logging.getLogger("rag-agent.watcher")
+
+
+class DocumentHandler(FileSystemEventHandler):
+    """Handles file create/modify events for supported document types."""
+
+    def __init__(
+        self,
+        extensions: list[str],
+        on_file: Callable[[Path], None],
+        debounce_seconds: float = 2.0,
+    ):
+        super().__init__()
+        self.extensions = {ext.lower() for ext in extensions}
+        self.on_file = on_file
+        self.debounce = debounce_seconds
+        self._last_seen: dict[str, float] = {}
+
+    def _should_process(self, path: str) -> bool:
+        ext = Path(path).suffix.lower()
+        if ext not in self.extensions:
+            return False
+        # Ignore temp/hidden files
+        name = Path(path).name
+        if name.startswith(".") or name.startswith("~$"):
+            return False
+        # Debounce — same file within N seconds
+        now = time.time()
+        last = self._last_seen.get(path, 0)
+        if now - last < self.debounce:
+            return False
+        self._last_seen[path] = now
+        return True
+
+    def on_created(self, event: FileSystemEvent) -> None:
+        if not event.is_directory and self._should_process(event.src_path):
+            logger.info("New file: %s", event.src_path)
+            self.on_file(Path(event.src_path))
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        if not event.is_directory and self._should_process(event.src_path):
+            logger.info("Modified file: %s", event.src_path)
+            self.on_file(Path(event.src_path))
+
+
+def start_watching(
+    folders: list[str],
+    extensions: list[str],
+    on_file: Callable[[Path], None],
+) -> Observer:
+    """Start watching folders for document changes. Returns the Observer (call .stop() to end)."""
+    observer = Observer()
+    handler = DocumentHandler(extensions=extensions, on_file=on_file)
+
+    for folder in folders:
+        folder_path = Path(folder)
+        if folder_path.is_dir():
+            observer.schedule(handler, str(folder_path), recursive=True)
+            logger.info("Watching: %s", folder_path)
+        else:
+            logger.warning("Folder does not exist, skipping: %s", folder)
+
+    observer.start()
+    return observer

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: industrial-rag-agent
+Version: 0.1.0
+Summary: Local RAG agent for Industrial AI Agents — watches folders, extracts text, OCRs scanned PDFs, indexes in SQLite FTS5
+Author-email: Industrial AI Agents <support@industrialagents.com>
+License: Proprietary
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: watchdog>=4.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pymupdf>=1.24
+Requires-Dist: uvicorn>=0.30
+Requires-Dist: httpx>=0.27
+Provides-Extra: ocr-win
+Requires-Dist: pytesseract>=0.3; extra == "ocr-win"
+Provides-Extra: ocr-linux
+Requires-Dist: pytesseract>=0.3; extra == "ocr-linux"
+
+# Industrial RAG Agent
+
+Local document indexer for **Industrial AI Agents** SaaS.
+
+Runs on the client's computer — documents **never leave their network**.
+
+## How it works
+
+```
+📁 Document Folder
+    ↓ (file watcher)
+📄 Text Extraction (PDF, DOCX, XLSX, TXT/CSV)
+    ↓ (+ OCR for scanned PDFs)
+🗃️ SQLite FTS5 Index (local)
+    ↓
+🌐 Local API (localhost:3847/search)
+    ↓
+☁️ Industrial AI Agents (cloud) queries this endpoint
+```
+
+## Install
+
+```bash
+pip install industrial-rag-agent
+```
+
+## Quick Start
+
+```bash
+# 1. Configure
+industrial-rag-agent configure
+
+# 2. Start (watches folders + runs API)
+industrial-rag-agent start
+```
+
+## Commands
+
+| Command     | Description                              |
+|-------------|------------------------------------------|
+| `configure` | Interactive setup (API key, folders, port) |
+| `start`     | Start watcher + local API server          |
+| `index`     | One-time index of all existing documents  |
+| `search`    | Search from the command line              |
+| `status`    | Show index statistics                     |
+
+## OCR Support
+
+| OS      | Engine                    | Install Required? |
+|---------|---------------------------|-------------------|
+| macOS   | Apple Vision (Neural Engine) | No — built in    |
+| Windows | Tesseract OCR             | Yes               |
+| Linux   | Tesseract OCR             | Yes               |
+
+## API Endpoints
+
+- `GET /search?q=keyword&limit=5` — search indexed documents
+- `GET /status` — agent status and index stats
+- `GET /health` — health check
+
+## Requirements
+
+- Python 3.11+
+- Tesseract OCR (Windows/Linux only)

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+industrial_rag_agent/__init__.py
+industrial_rag_agent/cli.py
+industrial_rag_agent/config.py
+industrial_rag_agent/extractor.py
+industrial_rag_agent/indexer.py
+industrial_rag_agent/server.py
+industrial_rag_agent/watcher.py
+industrial_rag_agent.egg-info/PKG-INFO
+industrial_rag_agent.egg-info/SOURCES.txt
+industrial_rag_agent.egg-info/dependency_links.txt
+industrial_rag_agent.egg-info/entry_points.txt
+industrial_rag_agent.egg-info/requires.txt
+industrial_rag_agent.egg-info/top_level.txt

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+industrial-rag-agent = industrial_rag_agent.cli:main

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/requires.txt

@@ -0,0 +1,12 @@
+watchdog>=4.0
+python-docx>=1.1
+openpyxl>=3.1
+pymupdf>=1.24
+uvicorn>=0.30
+httpx>=0.27
+
+[ocr-linux]
+pytesseract>=0.3
+
+[ocr-win]
+pytesseract>=0.3

industrial_rag_agent-0.1.0/industrial_rag_agent.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+industrial_rag_agent

industrial_rag_agent-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "industrial-rag-agent"
+version = "0.1.0"
+description = "Local RAG agent for Industrial AI Agents — watches folders, extracts text, OCRs scanned PDFs, indexes in SQLite FTS5"
+readme = "README.md"
+license = {text = "Proprietary"}
+requires-python = ">=3.11"
+authors = [
+    {name = "Industrial AI Agents", email = "support@industrialagents.com"},
+]
+dependencies = [
+    "watchdog>=4.0",
+    "python-docx>=1.1",
+    "openpyxl>=3.1",
+    "pymupdf>=1.24",
+    "uvicorn>=0.30",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+ocr-win = ["pytesseract>=0.3"]
+ocr-linux = ["pytesseract>=0.3"]
+
+[project.scripts]
+industrial-rag-agent = "industrial_rag_agent.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

industrial_rag_agent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+