navidoc 0.1.0__tar.gz

navidoc-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: navidoc
+Version: 0.1.0
+Summary: A lightweight, completely local, zero-API, tree-based RAG framework
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: ollama>=0.6.2
+Requires-Dist: pypdf>=6.11.0
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: python-pptx>=1.0.2
+
+# 🗺️ NaviDoc
+
+NaviDoc is a lightweight, **completely local, zero-API, tree-based RAG framework** designed to navigate document structures intelligently. Instead of blindly chopping your files into vector chunks, NaviDoc maps your documents into a logical structural tree hierarchy and uses local LLMs to precisely steer and navigate to answers.
+
+---
+
+## ✨ Features
+
+*   **🔒 100% Private & Offline:** Your documents never leave your machine. Zero cloud APIs, zero telemetry.
+*   **🌳 Tree-Based Navigation:** Mimics human navigation by following document structures (headers, font sizes) instead of standard proximity vector chunks.
+*   **⚡ High Precision:** Pinpoints specific structural sections, avoiding context contamination or context blowouts.
+*   **📄 Multi-Format Support**: Supports Markdown, PDF (with font-size analysis), DOCX (with style detection), and PPTX.
+*   **💾 Index Persistence**: Save your indexed tree structures to JSON and reload them instantly.
+*   **💬 Chat SDK**: Maintain conversation history with your documents SDK-style.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Prerequisites
+
+NaviDoc requires **Ollama** to host your local LLM engine.
+
+1.  Download and install Ollama from [ollama.com](https://ollama.com).
+2.  Pull a smart, small model (we recommend `phi3` or `llama3`):
+    ```bash
+    ollama pull phi3
+    ```
+3.  Ensure the Ollama service is running in the background before running NaviDoc.
+
+### 2. Installation
+
+Install NaviDoc via pip:
+
+```bash
+pip install navidoc
+```
+
+Or using `uv`:
+
+```bash
+uv add navidoc
+```
+
+---
+
+## 💡 Usage Examples
+
+### 🔍 One-off Query
+```python
+from navidoc import NaviDoc
+
+# Initialize (defaults to phi3 or NAVIDOC_MODEL_NAME env var)
+engine = NaviDoc()
+
+# Ingest and structurally index any local document
+status = engine.ingest("your_document.pdf")
+print(status)
+
+# Query your document offline
+response = engine.query("What are the exact system requirements?")
+print(response)
+```
+
+### 💬 Multi-turn Chat (SDK Style)
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+engine.ingest("manual.docx")
+
+# First turn
+print(engine.chat("How do I install the battery?"))
+
+# Second turn (remembers context and history!)
+print(engine.chat("Where can I buy a replacement?"))
+
+# Clear history if needed
+engine.clear_history()
+```
+
+### 💾 Save & Fast Load Index
+Avoid re-parsing large documents by saving the tree index.
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+
+# First time: Parse and Save
+engine.ingest("massive_report.pdf")
+engine.save_index("storage/indices/massive_report.json")
+
+# Second time: Instant Load in milliseconds
+engine.load_index("storage/indices/massive_report.json")
+response = engine.query("What is the revenue?")
+```
+
+---
+
+## ⚙️ Configuration
+
+### Environment Variables
+You can configure NaviDoc without changing your code by setting environment variables:
+
+*   `NAVIDOC_MODEL_NAME`: Set the default Ollama model to use (Default: `phi3`).
+
+**How to change it:**
+*   **Windows (PowerShell)**: `$env:NAVIDOC_MODEL_NAME="llama3"`
+*   **Linux/Mac**: `export NAVIDOC_MODEL_NAME="llama3"`
+
+---
+
+## 📜 License
+
+NaviDoc is open-source software distributed completely free under the **[MIT License](LICENSE)**.

navidoc-0.1.0/README.md

@@ -0,0 +1,115 @@
+# 🗺️ NaviDoc
+
+NaviDoc is a lightweight, **completely local, zero-API, tree-based RAG framework** designed to navigate document structures intelligently. Instead of blindly chopping your files into vector chunks, NaviDoc maps your documents into a logical structural tree hierarchy and uses local LLMs to precisely steer and navigate to answers.
+
+---
+
+## ✨ Features
+
+*   **🔒 100% Private & Offline:** Your documents never leave your machine. Zero cloud APIs, zero telemetry.
+*   **🌳 Tree-Based Navigation:** Mimics human navigation by following document structures (headers, font sizes) instead of standard proximity vector chunks.
+*   **⚡ High Precision:** Pinpoints specific structural sections, avoiding context contamination or context blowouts.
+*   **📄 Multi-Format Support**: Supports Markdown, PDF (with font-size analysis), DOCX (with style detection), and PPTX.
+*   **💾 Index Persistence**: Save your indexed tree structures to JSON and reload them instantly.
+*   **💬 Chat SDK**: Maintain conversation history with your documents SDK-style.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Prerequisites
+
+NaviDoc requires **Ollama** to host your local LLM engine.
+
+1.  Download and install Ollama from [ollama.com](https://ollama.com).
+2.  Pull a smart, small model (we recommend `phi3` or `llama3`):
+    ```bash
+    ollama pull phi3
+    ```
+3.  Ensure the Ollama service is running in the background before running NaviDoc.
+
+### 2. Installation
+
+Install NaviDoc via pip:
+
+```bash
+pip install navidoc
+```
+
+Or using `uv`:
+
+```bash
+uv add navidoc
+```
+
+---
+
+## 💡 Usage Examples
+
+### 🔍 One-off Query
+```python
+from navidoc import NaviDoc
+
+# Initialize (defaults to phi3 or NAVIDOC_MODEL_NAME env var)
+engine = NaviDoc()
+
+# Ingest and structurally index any local document
+status = engine.ingest("your_document.pdf")
+print(status)
+
+# Query your document offline
+response = engine.query("What are the exact system requirements?")
+print(response)
+```
+
+### 💬 Multi-turn Chat (SDK Style)
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+engine.ingest("manual.docx")
+
+# First turn
+print(engine.chat("How do I install the battery?"))
+
+# Second turn (remembers context and history!)
+print(engine.chat("Where can I buy a replacement?"))
+
+# Clear history if needed
+engine.clear_history()
+```
+
+### 💾 Save & Fast Load Index
+Avoid re-parsing large documents by saving the tree index.
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+
+# First time: Parse and Save
+engine.ingest("massive_report.pdf")
+engine.save_index("storage/indices/massive_report.json")
+
+# Second time: Instant Load in milliseconds
+engine.load_index("storage/indices/massive_report.json")
+response = engine.query("What is the revenue?")
+```
+
+---
+
+## ⚙️ Configuration
+
+### Environment Variables
+You can configure NaviDoc without changing your code by setting environment variables:
+
+*   `NAVIDOC_MODEL_NAME`: Set the default Ollama model to use (Default: `phi3`).
+
+**How to change it:**
+*   **Windows (PowerShell)**: `$env:NAVIDOC_MODEL_NAME="llama3"`
+*   **Linux/Mac**: `export NAVIDOC_MODEL_NAME="llama3"`
+
+---
+
+## 📜 License
+
+NaviDoc is open-source software distributed completely free under the **[MIT License](LICENSE)**.

navidoc-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "navidoc"
+version = "0.1.0"
+description = "A lightweight, completely local, zero-API, tree-based RAG framework"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "ollama>=0.6.2",
+    "pypdf>=6.11.0",
+    "python-docx>=1.2.0",
+    "python-pptx>=1.0.2",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]

navidoc-0.1.0/setup.cfg

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

navidoc-0.1.0/src/navidoc/__init__.py

@@ -0,0 +1,4 @@
+from .core import NaviDoc
+
+__version__ = "0.1.0"
+__all__ = ["NaviDoc"]

navidoc-0.1.0/src/navidoc/core.py

@@ -0,0 +1,208 @@
+import os
+import json
+from typing import Optional, Dict, Any, List
+import ollama
+
+from .parsers.markdown import MarkdownParser
+from .parsers.pdf import PdfParser
+from .parsers.docx import DocxParser
+from .parsers.pptx import PptxParser
+from .index.tree import TreeIndex
+from .index.page import PageIndex
+
+class NaviDoc:
+    def __init__(self, model: Optional[str] = None):
+        """
+        Initialize NaviDoc SDK.
+        
+        Priority for model selection:
+        1. Explicitly passed `model` argument.
+        2. `NAVIDOC_MODEL_NAME` environment variable.
+        3. Fallback default 'phi3'.
+        """
+        self.model = model or os.getenv("NAVIDOC_MODEL_NAME", "phi3")
+        self.index = None
+        self.index_type = None # "tree" or "page"
+        self.history: List[Dict[str, str]] = [] # Chat history
+        
+        print(f"NaviDoc SDK initialized with model: {self.model}")
+
+    def ingest(self, file_path: str) -> str:
+        """Ingest a document and create the appropriate index."""
+        if not os.path.exists(file_path):
+            return f"Error: File {file_path} not found."
+
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        if ext == '.md':
+            parser = MarkdownParser()
+            tree_data = parser.parse(file_path)
+            self.index = TreeIndex()
+            self.index.load_tree(tree_data)
+            self.index_type = "tree"
+            return f"Successfully ingested Markdown: {file_path}"
+            
+        elif ext == '.pdf':
+            parser = PdfParser()
+            tree_data = parser.parse(file_path)
+            self.index = TreeIndex()
+            self.index.load_tree(tree_data)
+            self.index_type = "tree"
+            return f"Successfully ingested PDF (Tree): {file_path}"
+            
+        elif ext == '.docx':
+            parser = DocxParser()
+            tree_data = parser.parse(file_path)
+            self.index = TreeIndex()
+            self.index.load_tree(tree_data)
+            self.index_type = "tree"
+            return f"Successfully ingested DOCX (Tree): {file_path}"
+            
+        elif ext == '.pptx':
+            parser = PptxParser()
+            pptx_data = parser.parse(file_path)
+            self.index = PageIndex()
+            self.index.load_pages(pptx_data["pages"])
+            self.index_type = "page"
+            return f"Successfully ingested PPTX: {file_path}"
+            
+        else:
+            return f"Unsupported file format: {ext}"
+
+    def ingest_markdown(self, file_path: str) -> str:
+        """Explicit method for markdown as requested in README."""
+        return self.ingest(file_path)
+
+    def save_index(self, file_path: str):
+        """Save the current index to a JSON file for fast reloading."""
+        if not self.index:
+            raise ValueError("No index to save. Ingest a document first.")
+            
+        data = {
+            "index_type": self.index_type,
+            "tree": self.index.tree if self.index_type == "tree" else None,
+            "pages": self.index.pages if self.index_type == "page" else None
+        }
+        
+        os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        print(f"Index successfully saved to {file_path}")
+
+    def load_index(self, file_path: str):
+        """Load a previously saved index from a JSON file."""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Index file not found: {file_path}")
+            
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        self.index_type = data["index_type"]
+        if self.index_type == "tree":
+            self.index = TreeIndex()
+            self.index.load_tree(data["tree"])
+        elif self.index_type == "page":
+            self.index = PageIndex()
+            self.index.load_pages(data["pages"])
+        print(f"Index successfully loaded from {file_path}")
+
+    def _navigate_tree(self, query: str, node: Dict[str, Any]) -> str:
+        """Recursively navigate the tree using the local LLM."""
+        if not node.get("children"):
+            return node.get("content", "")
+
+        headers = [child["title"] for child in node["children"]]
+        
+        prompt = f"""
+Given the query: "{query}"
+And the following document sections:
+{", ".join([f"'{h}'" for h in headers])}
+
+Which section is most likely to contain the answer? 
+Reply ONLY with the exact section title from the list above. If none seem relevant, reply 'NONE'.
+"""
+        try:
+            response = ollama.generate(model=self.model, prompt=prompt)
+            chosen_header = response['response'].strip().strip("'").strip('"')
+            
+            if chosen_header == 'NONE':
+                return node.get("content", "Section not found.")
+                
+            for child in node["children"]:
+                if child["title"] == chosen_header:
+                    return self._navigate_tree(query, child)
+                    
+            return node.get("content", "Navigation path lost.")
+            
+        except Exception as e:
+            return f"Navigation error: {str(e)}"
+
+    def query(self, prompt: str) -> str:
+        """One-off query without maintaining history."""
+        if not self.index:
+            return "No document ingested yet."
+
+        if self.index_type == "tree":
+            relevant_content = self._navigate_tree(prompt, self.index.tree)
+        else:
+            relevant_content = self.index.get_all_text()
+
+        full_prompt = f"""
+Answer the user's question based ONLY on this specific context found during navigation:
+{relevant_content}
+
+Question: {prompt}
+Answer:
+"""
+        try:
+            response = ollama.generate(model=self.model, prompt=full_prompt)
+            return response['response']
+        except Exception as e:
+            return f"Error calling Ollama: {str(e)}"
+
+    def chat(self, prompt: str) -> str:
+        """Chat with the document, maintaining conversation history."""
+        if not self.index:
+            return "No document ingested yet."
+
+        # Get context for the latest query
+        if self.index_type == "tree":
+            relevant_content = self._navigate_tree(prompt, self.index.tree)
+        else:
+            relevant_content = self.index.get_all_text()
+
+        # Format history for Ollama
+        history_str = ""
+        for turn in self.history:
+            history_str += f"User: {turn['user']}\nAssistant: {turn['assistant']}\n"
+
+        full_prompt = f"""
+You are having a conversation about a document. 
+Answer the user's latest question based ONLY on the context provided below.
+Maintain continuity with the conversation history.
+
+Context:
+{relevant_content}
+
+History:
+{history_str}
+
+User: {prompt}
+Assistant:
+"""
+        try:
+            response = ollama.generate(model=self.model, prompt=full_prompt)
+            reply = response['response']
+            
+            # Save to history
+            self.history.append({"user": prompt, "assistant": reply})
+            
+            return reply
+        except Exception as e:
+            return f"Error calling Ollama: {str(e)}"
+
+    def clear_history(self):
+        """Clear the chat history."""
+        self.history = []
+        print("Chat history cleared.")

navidoc-0.1.0/src/navidoc/index/__init__.py

@@ -0,0 +1 @@
+# Index package

navidoc-0.1.0/src/navidoc/index/page.py

@@ -0,0 +1,20 @@
+from typing import Dict, Any, List
+
+class PageIndex:
+    def __init__(self):
+        self.pages = []
+
+    def load_pages(self, pages_data: List[Dict[str, Any]]):
+        """Load the pages."""
+        self.pages = pages_data
+
+    def search(self, query: str) -> str:
+        """
+        Search the pages for relevant content.
+        """
+        # Skeleton: Return the whole content for now
+        return f"PageIndex search for: {query}"
+        
+    def get_all_text(self) -> str:
+        """Helper to get all text from pages."""
+        return "\n".join([p.get("content", "") for p in self.pages])

navidoc-0.1.0/src/navidoc/index/tree.py

@@ -0,0 +1,27 @@
+from typing import Dict, Any, List
+
+class TreeIndex:
+    def __init__(self):
+        self.tree = {}
+
+    def load_tree(self, tree_data: Dict[str, Any]):
+        """Load the tree structure."""
+        self.tree = tree_data
+
+    def search(self, query: str) -> str:
+        """
+        Search the tree for relevant content.
+        In a real implementation, this would use an LLM to navigate.
+        """
+        # Skeleton: Return the whole tree content for now
+        # or a message saying it's a skeleton.
+        return f"TreeIndex search for: {query}"
+        
+    def get_all_text(self) -> str:
+        """Helper to get all text from tree."""
+        def _recurse(node):
+            text = node.get("content", "")
+            for child in node.get("children", []):
+                text += _recurse(child)
+            return text
+        return _recurse(self.tree)

navidoc-0.1.0/src/navidoc/parsers/__init__.py

@@ -0,0 +1 @@
+# Parsers package

navidoc-0.1.0/src/navidoc/parsers/docx.py

@@ -0,0 +1,52 @@
+from docx import Document
+from typing import Dict, Any, List
+
+class DocxParser:
+    def __init__(self):
+        pass
+
+    def parse(self, file_path: str) -> Dict[str, Any]:
+        """Parse a DOCX file into a tree structure based on Heading styles."""
+        doc = Document(file_path)
+        
+        root = {"title": "Root", "level": 0, "content": "", "children": []}
+        stack = [root]
+        
+        for para in doc.paragraphs:
+            text = para.text.strip()
+            if not text:
+                continue
+                
+            style_name = para.style.name if para.style else ""
+            
+            # Check if it's a heading
+            if style_name.startswith('Heading'):
+                try:
+                    # Extract level from "Heading 1" -> 1
+                    level = int(style_name.split()[-1])
+                except (ValueError, IndexError):
+                    level = 1 # Fallback
+                    
+                node = {
+                    "title": text,
+                    "level": level,
+                    "content": "",
+                    "children": []
+                }
+                
+                # Pop from stack until we find the parent
+                while stack and stack[-1]["level"] >= level:
+                    stack.pop()
+                    
+                if stack:
+                    stack[-1]["children"].append(node)
+                    stack.append(node)
+                else:
+                    root["children"].append(node)
+                    stack.append(node)
+            else:
+                # Add content to the current node
+                if stack:
+                    stack[-1]["content"] += text + "\n"
+                    
+        return root

navidoc-0.1.0/src/navidoc/parsers/markdown.py

@@ -0,0 +1,45 @@
+import re
+from typing import List, Dict, Any
+
+class MarkdownParser:
+    def __init__(self):
+        pass
+
+    def parse(self, file_path: str) -> Dict[str, Any]:
+        """Parse a markdown file into a tree structure based on headers."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        root = {"title": "Root", "level": 0, "content": "", "children": []}
+        stack = [root]
+
+        for line in lines:
+            match = re.match(r'^(#+)\s+(.*)', line)
+            if match:
+                level = len(match.group(1))
+                title = match.group(2).strip()
+                
+                node = {
+                    "title": title,
+                    "level": level,
+                    "content": "",
+                    "children": []
+                }
+                
+                # Pop from stack until we find the parent (level < current level)
+                while stack and stack[-1]["level"] >= level:
+                    stack.pop()
+                
+                if stack:
+                    stack[-1]["children"].append(node)
+                    stack.append(node)
+                else:
+                    # Fallback if somehow stack is empty
+                    root["children"].append(node)
+                    stack.append(node)
+            else:
+                # Add content to the current node
+                if stack:
+                    stack[-1]["content"] += line
+
+        return root

navidoc-0.1.0/src/navidoc/parsers/pdf.py

@@ -0,0 +1,73 @@
+from pypdf import PdfReader
+from typing import Dict, Any, List
+
+class PdfParser:
+    def __init__(self):
+        pass
+
+    def parse(self, file_path: str) -> Dict[str, Any]:
+        """Parse a PDF file into a tree structure based on font sizes."""
+        reader = PdfReader(file_path)
+        
+        # 1. Analyze font sizes to find body and headings
+        font_sizes = {}
+        
+        def size_visitor(text, cm, tm, font_dict, font_size):
+            if text.strip():
+                font_sizes[font_size] = font_sizes.get(font_size, 0) + len(text)
+
+        for page in reader.pages:
+            page.extract_text(visitor_text=size_visitor)
+            
+        if not font_sizes:
+            return {"title": "Root", "level": 0, "content": "No text found", "children": []}
+            
+        # Body text is the most common font size
+        body_size = max(font_sizes, key=font_sizes.get)
+        
+        # Headings are larger than body text
+        headings = [s for s in font_sizes.keys() if s > body_size + 1.0]
+        headings.sort(reverse=True)
+        
+        # Map font sizes to heading levels (up to 3 levels)
+        heading_map = {}
+        for i, size in enumerate(headings[:3]):
+            heading_map[size] = i + 1
+            
+        # 2. Build the tree
+        root = {"title": "Root", "level": 0, "content": "", "children": []}
+        stack = [root]
+        
+        def build_visitor(text, cm, tm, font_dict, font_size):
+            t = text.strip()
+            if not t:
+                return
+                
+            level = heading_map.get(font_size)
+            if level:
+                node = {
+                    "title": t,
+                    "level": level,
+                    "content": "",
+                    "children": []
+                }
+                
+                # Pop stack until we find the parent
+                while stack and stack[-1]["level"] >= level:
+                    stack.pop()
+                    
+                if stack:
+                    stack[-1]["children"].append(node)
+                    stack.append(node)
+                else:
+                    root["children"].append(node)
+                    stack.append(node)
+            else:
+                # Add text to the current node
+                if stack:
+                    stack[-1]["content"] += text + " "
+
+        for page in reader.pages:
+            page.extract_text(visitor_text=build_visitor)
+            
+        return root

navidoc-0.1.0/src/navidoc/parsers/pptx.py

@@ -0,0 +1,27 @@
+from pptx import Presentation
+from typing import Dict, Any, List
+
+class PptxParser:
+    def __init__(self):
+        pass
+
+    def parse(self, file_path: str) -> Dict[str, Any]:
+        """Parse a PPTX file."""
+        prs = Presentation(file_path)
+        slides = []
+        
+        for i, slide in enumerate(prs.slides):
+            text = []
+            for shape in slide.shapes:
+                if hasattr(shape, "text"):
+                    text.append(shape.text)
+            slides.append({
+                "page_number": i + 1,
+                "content": "\n".join(text)
+            })
+            
+        return {
+            "title": file_path,
+            "type": "pptx",
+            "pages": slides
+        }

navidoc-0.1.0/src/navidoc.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: navidoc
+Version: 0.1.0
+Summary: A lightweight, completely local, zero-API, tree-based RAG framework
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: ollama>=0.6.2
+Requires-Dist: pypdf>=6.11.0
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: python-pptx>=1.0.2
+
+# 🗺️ NaviDoc
+
+NaviDoc is a lightweight, **completely local, zero-API, tree-based RAG framework** designed to navigate document structures intelligently. Instead of blindly chopping your files into vector chunks, NaviDoc maps your documents into a logical structural tree hierarchy and uses local LLMs to precisely steer and navigate to answers.
+
+---
+
+## ✨ Features
+
+*   **🔒 100% Private & Offline:** Your documents never leave your machine. Zero cloud APIs, zero telemetry.
+*   **🌳 Tree-Based Navigation:** Mimics human navigation by following document structures (headers, font sizes) instead of standard proximity vector chunks.
+*   **⚡ High Precision:** Pinpoints specific structural sections, avoiding context contamination or context blowouts.
+*   **📄 Multi-Format Support**: Supports Markdown, PDF (with font-size analysis), DOCX (with style detection), and PPTX.
+*   **💾 Index Persistence**: Save your indexed tree structures to JSON and reload them instantly.
+*   **💬 Chat SDK**: Maintain conversation history with your documents SDK-style.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Prerequisites
+
+NaviDoc requires **Ollama** to host your local LLM engine.
+
+1.  Download and install Ollama from [ollama.com](https://ollama.com).
+2.  Pull a smart, small model (we recommend `phi3` or `llama3`):
+    ```bash
+    ollama pull phi3
+    ```
+3.  Ensure the Ollama service is running in the background before running NaviDoc.
+
+### 2. Installation
+
+Install NaviDoc via pip:
+
+```bash
+pip install navidoc
+```
+
+Or using `uv`:
+
+```bash
+uv add navidoc
+```
+
+---
+
+## 💡 Usage Examples
+
+### 🔍 One-off Query
+```python
+from navidoc import NaviDoc
+
+# Initialize (defaults to phi3 or NAVIDOC_MODEL_NAME env var)
+engine = NaviDoc()
+
+# Ingest and structurally index any local document
+status = engine.ingest("your_document.pdf")
+print(status)
+
+# Query your document offline
+response = engine.query("What are the exact system requirements?")
+print(response)
+```
+
+### 💬 Multi-turn Chat (SDK Style)
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+engine.ingest("manual.docx")
+
+# First turn
+print(engine.chat("How do I install the battery?"))
+
+# Second turn (remembers context and history!)
+print(engine.chat("Where can I buy a replacement?"))
+
+# Clear history if needed
+engine.clear_history()
+```
+
+### 💾 Save & Fast Load Index
+Avoid re-parsing large documents by saving the tree index.
+```python
+from navidoc import NaviDoc
+
+engine = NaviDoc()
+
+# First time: Parse and Save
+engine.ingest("massive_report.pdf")
+engine.save_index("storage/indices/massive_report.json")
+
+# Second time: Instant Load in milliseconds
+engine.load_index("storage/indices/massive_report.json")
+response = engine.query("What is the revenue?")
+```
+
+---
+
+## ⚙️ Configuration
+
+### Environment Variables
+You can configure NaviDoc without changing your code by setting environment variables:
+
+*   `NAVIDOC_MODEL_NAME`: Set the default Ollama model to use (Default: `phi3`).
+
+**How to change it:**
+*   **Windows (PowerShell)**: `$env:NAVIDOC_MODEL_NAME="llama3"`
+*   **Linux/Mac**: `export NAVIDOC_MODEL_NAME="llama3"`
+
+---
+
+## 📜 License
+
+NaviDoc is open-source software distributed completely free under the **[MIT License](LICENSE)**.

navidoc-0.1.0/src/navidoc.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+src/navidoc/__init__.py
+src/navidoc/core.py
+src/navidoc.egg-info/PKG-INFO
+src/navidoc.egg-info/SOURCES.txt
+src/navidoc.egg-info/dependency_links.txt
+src/navidoc.egg-info/requires.txt
+src/navidoc.egg-info/top_level.txt
+src/navidoc/index/__init__.py
+src/navidoc/index/page.py
+src/navidoc/index/tree.py
+src/navidoc/parsers/__init__.py
+src/navidoc/parsers/docx.py
+src/navidoc/parsers/markdown.py
+src/navidoc/parsers/pdf.py
+src/navidoc/parsers/pptx.py
+tests/test_parsers.py

navidoc-0.1.0/src/navidoc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

navidoc-0.1.0/src/navidoc.egg-info/requires.txt

@@ -0,0 +1,4 @@
+ollama>=0.6.2
+pypdf>=6.11.0
+python-docx>=1.2.0
+python-pptx>=1.0.2

navidoc-0.1.0/src/navidoc.egg-info/top_level.txt

@@ -0,0 +1 @@
+navidoc

navidoc-0.1.0/tests/test_parsers.py

@@ -0,0 +1,22 @@
+import os
+import pytest
+from navidoc.parsers.markdown import MarkdownParser
+
+def test_markdown_parser():
+    # Create a dummy markdown file in storage
+    storage_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../storage'))
+    test_dir = os.path.join(storage_dir, 'test_data')
+    os.makedirs(test_dir, exist_ok=True)
+    
+    p = os.path.join(test_dir, "test.md")
+    with open(p, 'w', encoding='utf-8') as f:
+        f.write("# Header 1\nContent 1\n## Header 2\nContent 2")
+
+    parser = MarkdownParser()
+    tree = parser.parse(p)
+
+    assert tree["title"] == "Root"
+    assert len(tree["children"]) == 1
+    assert tree["children"][0]["title"] == "Header 1"
+    assert len(tree["children"][0]["children"]) == 1
+    assert tree["children"][0]["children"][0]["title"] == "Header 2"