haiku.rag-slim 0.16.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

haiku/rag/app.py

@@ -1,14 +1,24 @@
 import asyncio
 import json
 import logging
+from datetime import datetime
 from importlib.metadata import version as pkg_version
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from rich.console import Console
 from rich.markdown import Markdown
-from rich.progress import Progress
-
-from haiku.rag.client import HaikuRAG
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TransferSpeedColumn,
+)
+
+from haiku.rag.client import HaikuRAG, RebuildMode
 from haiku.rag.config import AppConfig, Config
 from haiku.rag.graph.agui import AGUIConsoleRenderer, stream_graph
 from haiku.rag.graph.research.dependencies import ResearchContext
@@ -16,18 +26,44 @@ from haiku.rag.graph.research.graph import build_research_graph
 from haiku.rag.graph.research.state import ResearchDeps, ResearchState
 from haiku.rag.mcp import create_mcp_server
 from haiku.rag.monitor import FileWatcher
-from haiku.rag.store.models.chunk import Chunk
 from haiku.rag.store.models.document import Document
 
+if TYPE_CHECKING:
+    from haiku.rag.store.models import SearchResult
+from haiku.rag.utils import format_bytes, format_citations_rich
+
 logger = logging.getLogger(__name__)
 
 
 class HaikuRAGApp:
-    def __init__(self, db_path: Path, config: AppConfig = Config):
+    def __init__(
+        self,
+        db_path: Path,
+        config: AppConfig = Config,
+        read_only: bool = False,
+        before: datetime | None = None,
+    ):
         self.db_path = db_path
         self.config = config
+        self.read_only = read_only
+        self.before = before
         self.console = Console()
 
+    async def init(self):
+        """Initialize a new database."""
+        if self.db_path.exists():
+            self.console.print(
+                f"[yellow]Database already exists at {self.db_path}[/yellow]"
+            )
+            return
+
+        # Create the database
+        client = HaikuRAG(db_path=self.db_path, config=self.config, create=True)
+        client.close()
+        self.console.print(
+            f"[bold green]Database initialized at {self.db_path}[/bold green]"
+        )
+
     async def info(self):
         """Display read-only information about the database without modifying it."""
 
@@ -64,7 +100,13 @@ class HaikuRAGApp:
         except Exception:
             docling_version = "unknown"
 
-        # Read settings (if present) to find stored haiku.rag version and embedding config
+        # Get comprehensive table statistics (this also runs migrations)
+        from haiku.rag.store.engine import Store
+
+        store = Store(self.db_path, config=self.config, skip_validation=True)
+        table_stats = store.get_stats()
+
+        # Read settings after Store init (migrations have run)
         stored_version = "unknown"
         embed_provider: str | None = None
         embed_model: str | None = None
@@ -79,14 +121,22 @@ class HaikuRAGApp:
                 data = json.loads(raw) if isinstance(raw, str) else (raw or {})
                 stored_version = str(data.get("version", stored_version))
                 embeddings = data.get("embeddings", {})
-                embed_provider = embeddings.get("provider")
-                embed_model = embeddings.get("model")
-                vector_dim = embeddings.get("vector_dim")
+                embed_model_obj = embeddings.get("model", {})
+                embed_provider = embed_model_obj.get("provider")
+                embed_model = embed_model_obj.get("name")
+                vector_dim = embed_model_obj.get("vector_dim")
+
+        store.close()
+
+        num_docs = table_stats["documents"].get("num_rows", 0)
+        doc_bytes = table_stats["documents"].get("total_bytes", 0)
+
+        num_chunks = table_stats["chunks"].get("num_rows", 0)
+        chunk_bytes = table_stats["chunks"].get("total_bytes", 0)
 
-        num_docs = 0
-        if "documents" in table_names:
-            docs_tbl = db.open_table("documents")
-            num_docs = int(docs_tbl.count_rows())  # type: ignore[attr-defined]
+        has_vector_index = table_stats["chunks"].get("has_vector_index", False)
+        num_indexed_rows = table_stats["chunks"].get("num_indexed_rows", 0)
+        num_unindexed_rows = table_stats["chunks"].get("num_unindexed_rows", 0)
 
         # Table versions per table (direct API)
         doc_versions = (
@@ -116,8 +166,43 @@ class HaikuRAGApp:
                 "  [repr.attrib_name]embeddings[/repr.attrib_name]: unknown"
             )
         self.console.print(
-            f"  [repr.attrib_name]documents[/repr.attrib_name]: {num_docs}"
+            f"  [repr.attrib_name]documents[/repr.attrib_name]: {num_docs} "
+            f"({format_bytes(doc_bytes)})"
         )
+        self.console.print(
+            f"  [repr.attrib_name]chunks[/repr.attrib_name]: {num_chunks} "
+            f"({format_bytes(chunk_bytes)})"
+        )
+
+        # Vector index information
+        if has_vector_index:
+            self.console.print(
+                "  [repr.attrib_name]vector index[/repr.attrib_name]: ✓ exists"
+            )
+            self.console.print(
+                f"  [repr.attrib_name]indexed chunks[/repr.attrib_name]: {num_indexed_rows}"
+            )
+            if num_unindexed_rows > 0:
+                self.console.print(
+                    f"  [repr.attrib_name]unindexed chunks[/repr.attrib_name]: [yellow]{num_unindexed_rows}[/yellow] "
+                    "(consider running: haiku-rag create-index)"
+                )
+            else:
+                self.console.print(
+                    f"  [repr.attrib_name]unindexed chunks[/repr.attrib_name]: {num_unindexed_rows}"
+                )
+        else:
+            if num_chunks >= 256:
+                self.console.print(
+                    "  [repr.attrib_name]vector index[/repr.attrib_name]: [yellow]✗ not created[/yellow] "
+                    "(run: haiku-rag create-index)"
+                )
+            else:
+                self.console.print(
+                    f"  [repr.attrib_name]vector index[/repr.attrib_name]: ✗ not created "
+                    f"(need {256 - num_chunks} more chunks)"
+                )
+
         self.console.print(
             f"  [repr.attrib_name]versions (documents)[/repr.attrib_name]: {doc_versions}"
         )
@@ -136,16 +221,76 @@ class HaikuRAGApp:
             f"  [repr.attrib_name]docling[/repr.attrib_name]: {docling_version}"
         )
 
+    async def history(self, table: str | None = None, limit: int | None = None):
+        """Display version history for database tables.
+
+        Args:
+            table: Specific table to show history for (documents, chunks, settings).
+                   If None, shows history for all tables.
+            limit: Maximum number of versions to show per table.
+        """
+        from haiku.rag.store.engine import Store
+
+        if not self.db_path.exists():
+            self.console.print("[red]Database path does not exist.[/red]")
+            return
+
+        store = Store(self.db_path, config=self.config, skip_validation=True)
+
+        tables = ["documents", "chunks", "settings"]
+        if table:
+            if table not in tables:
+                self.console.print(
+                    f"[red]Unknown table: {table}. Must be one of: {', '.join(tables)}[/red]"
+                )
+                store.close()
+                return
+            tables = [table]
+
+        self.console.print("[bold]Version History[/bold]")
+
+        for table_name in tables:
+            versions = store.list_table_versions(table_name)
+
+            # Sort by version descending (newest first)
+            versions = sorted(versions, key=lambda v: v["version"], reverse=True)
+
+            if limit:
+                versions = versions[:limit]
+
+            self.console.print(f"\n[bold cyan]{table_name}[/bold cyan]")
+
+            if not versions:
+                self.console.print("  [dim]No versions found[/dim]")
+                continue
+
+            for v in versions:
+                version_num = v["version"]
+                timestamp = v["timestamp"]
+                self.console.print(
+                    f"  [repr.attrib_name]v{version_num}[/repr.attrib_name]: {timestamp}"
+                )
+
+        store.close()
+
     async def list_documents(self, filter: str | None = None):
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, allow_create=False
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
         ) as self.client:
             documents = await self.client.list_documents(filter=filter)
             for doc in documents:
                 self._rich_print_document(doc, truncate=True)
 
     async def add_document_from_text(self, text: str, metadata: dict | None = None):
-        async with HaikuRAG(db_path=self.db_path, config=self.config) as self.client:
+        async with HaikuRAG(
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
+        ) as self.client:
             doc = await self.client.create_document(text, metadata=metadata)
             self._rich_print_document(doc, truncate=True)
             self.console.print(
@@ -155,7 +300,12 @@ class HaikuRAGApp:
     async def add_document_from_source(
         self, source: str, title: str | None = None, metadata: dict | None = None
     ):
-        async with HaikuRAG(db_path=self.db_path, config=self.config) as self.client:
+        async with HaikuRAG(
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
+        ) as self.client:
             result = await self.client.create_document_from_source(
                 source, title=title, metadata=metadata
             )
@@ -173,7 +323,10 @@ class HaikuRAGApp:
 
     async def get_document(self, doc_id: str):
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, allow_create=False
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
         ) as self.client:
             doc = await self.client.get_document_by_id(doc_id)
             if doc is None:
@@ -182,7 +335,12 @@ class HaikuRAGApp:
             self._rich_print_document(doc, truncate=False)
 
     async def delete_document(self, doc_id: str):
-        async with HaikuRAG(db_path=self.db_path, config=self.config) as self.client:
+        async with HaikuRAG(
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
+        ) as self.client:
             deleted = await self.client.delete_document(doc_id)
             if deleted:
                 self.console.print(
@@ -193,16 +351,58 @@ class HaikuRAGApp:
                     f"[yellow]Document with id {doc_id} not found.[/yellow]"
                 )
 
-    async def search(self, query: str, limit: int = 5, filter: str | None = None):
+    async def search(
+        self, query: str, limit: int | None = None, filter: str | None = None
+    ):
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, allow_create=False
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
         ) as self.client:
             results = await self.client.search(query, limit=limit, filter=filter)
             if not results:
                 self.console.print("[yellow]No results found.[/yellow]")
                 return
-            for chunk, score in results:
-                self._rich_print_search_result(chunk, score)
+            for result in results:
+                self._rich_print_search_result(result)
+
+    async def visualize_chunk(self, chunk_id: str):
+        """Display visual grounding images for a chunk."""
+        from textual_image.renderable import Image as RichImage
+
+        async with HaikuRAG(
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
+        ) as self.client:
+            chunk = await self.client.chunk_repository.get_by_id(chunk_id)
+            if not chunk:
+                self.console.print(f"[red]Chunk with id {chunk_id} not found.[/red]")
+                return
+
+            images = await self.client.visualize_chunk(chunk)
+            if not images:
+                self.console.print(
+                    "[yellow]No visual grounding available for this chunk.[/yellow]"
+                )
+                self.console.print(
+                    "This may be because the document was converted without page images."
+                )
+                return
+
+            self.console.print(f"[bold]Visual grounding for chunk {chunk_id}[/bold]")
+            if chunk.document_uri:
+                self.console.print(
+                    f"[repr.attrib_name]document[/repr.attrib_name]: {chunk.document_uri}"
+                )
+
+            for i, img in enumerate(images):
+                self.console.print(
+                    f"\n[bold cyan]Page {i + 1}/{len(images)}[/bold cyan]"
+                )
+                self.console.print(RichImage(img))
 
     async def ask(
         self,
@@ -210,6 +410,7 @@ class HaikuRAGApp:
         cite: bool = False,
         deep: bool = False,
         verbose: bool = False,
+        filter: str | None = None,
     ):
         """Ask a question using the RAG system.
 
@@ -218,56 +419,87 @@ class HaikuRAGApp:
             cite: Include citations in the answer
             deep: Use deep QA mode (multi-step reasoning)
             verbose: Show verbose output
+            filter: SQL WHERE clause to filter documents
         """
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, allow_create=False
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
         ) as self.client:
             try:
+                citations = []
                 if deep:
-                    from haiku.rag.graph.deep_qa.dependencies import DeepQAContext
-                    from haiku.rag.graph.deep_qa.graph import build_deep_qa_graph
-                    from haiku.rag.graph.deep_qa.state import DeepQADeps, DeepQAState
-
-                    graph = build_deep_qa_graph(config=self.config)
-                    context = DeepQAContext(
-                        original_question=question, use_citations=cite
+                    from haiku.rag.graph.research.models import ResearchReport
+
+                    graph = build_research_graph(config=self.config)
+                    context = ResearchContext(original_question=question)
+                    state = ResearchState.from_config(
+                        context=context,
+                        config=self.config,
+                        max_iterations=2,
+                        confidence_threshold=0.0,
                     )
-                    state = DeepQAState.from_config(context=context, config=self.config)
-                    deps = DeepQADeps(client=self.client)
+                    state.search_filter = filter
+                    deps = ResearchDeps(client=self.client)
 
                     if verbose:
-                        # Use AG-UI renderer to process and display events
-                        from haiku.rag.graph.agui import AGUIConsoleRenderer
-
                         renderer = AGUIConsoleRenderer(self.console)
                         result_dict = await renderer.render(
                             stream_graph(graph, state, deps)
                         )
-                        # Result should be a dict with 'answer' key
-                        answer = result_dict.get("answer", "") if result_dict else ""
+                        report = (
+                            ResearchReport.model_validate(result_dict)
+                            if result_dict
+                            else None
+                        )
+                    else:
+                        report = await graph.run(state=state, deps=deps)
+
+                    self.console.print(f"[bold blue]Question:[/bold blue] {question}")
+                    self.console.print()
+                    if report:
+                        self.console.print("[bold green]Answer:[/bold green]")
+                        self.console.print(Markdown(report.executive_summary))
+                        if report.main_findings:
+                            self.console.print()
+                            self.console.print("[bold cyan]Key Findings:[/bold cyan]")
+                            for finding in report.main_findings:
+                                self.console.print(f"• {finding}")
+                        if report.sources_summary:
+                            self.console.print()
+                            self.console.print("[bold cyan]Sources:[/bold cyan]")
+                            self.console.print(report.sources_summary)
                     else:
-                        # Run without rendering events, just get the result
-                        result = await graph.run(state=state, deps=deps)
-                        answer = result.answer
+                        self.console.print("[yellow]No answer generated.[/yellow]")
                 else:
-                    answer = await self.client.ask(question, cite=cite)
+                    answer, citations = await self.client.ask(question, filter=filter)
 
-                self.console.print(f"[bold blue]Question:[/bold blue] {question}")
-                self.console.print()
-                self.console.print("[bold green]Answer:[/bold green]")
-                self.console.print(Markdown(answer))
+                    self.console.print(f"[bold blue]Question:[/bold blue] {question}")
+                    self.console.print()
+                    self.console.print("[bold green]Answer:[/bold green]")
+                    self.console.print(Markdown(answer))
+                    if cite and citations:
+                        for renderable in format_citations_rich(citations):
+                            self.console.print(renderable)
             except Exception as e:
                 self.console.print(f"[red]Error: {e}[/red]")
 
-    async def research(self, question: str, verbose: bool = False):
+    async def research(
+        self, question: str, verbose: bool = False, filter: str | None = None
+    ):
         """Run research via the pydantic-graph pipeline.
 
         Args:
             question: The research question
             verbose: Show AG-UI event stream during execution
+            filter: SQL WHERE clause to filter documents
         """
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, allow_create=False
+            db_path=self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
         ) as client:
             try:
                 self.console.print("[bold cyan]Starting research[/bold cyan]")
@@ -277,6 +509,7 @@ class HaikuRAGApp:
                 graph = build_research_graph(config=self.config)
                 context = ResearchContext(original_question=question)
                 state = ResearchState.from_config(context=context, config=self.config)
+                state.search_filter = filter
                 deps = ResearchDeps(client=client)
 
                 if verbose:
@@ -356,9 +589,13 @@ class HaikuRAGApp:
             except Exception as e:
                 self.console.print(f"[red]Error during research: {e}[/red]")
 
-    async def rebuild(self):
+    async def rebuild(self, mode: RebuildMode = RebuildMode.FULL):
         async with HaikuRAG(
-            db_path=self.db_path, config=self.config, skip_validation=True
+            db_path=self.db_path,
+            config=self.config,
+            skip_validation=True,
+            read_only=self.read_only,
+            before=self.before,
         ) as client:
             try:
                 documents = await client.list_documents()
@@ -370,12 +607,18 @@ class HaikuRAGApp:
                     )
                     return
 
+                mode_desc = {
+                    RebuildMode.FULL: "full rebuild",
+                    RebuildMode.RECHUNK: "rechunk",
+                    RebuildMode.EMBED_ONLY: "embed only",
+                }[mode]
+
                 self.console.print(
-                    f"[bold cyan]Rebuilding database with {total_docs} documents...[/bold cyan]"
+                    f"[bold cyan]Rebuilding database ({mode_desc}) with {total_docs} documents...[/bold cyan]"
                 )
                 with Progress() as progress:
                     task = progress.add_task("Rebuilding...", total=total_docs)
-                    async for _ in client.rebuild_database():
+                    async for _ in client.rebuild_database(mode=mode):
                         progress.update(task, advance=1)
 
                 self.console.print(
@@ -388,7 +631,11 @@ class HaikuRAGApp:
         """Run database maintenance: optimize and cleanup table history."""
         try:
             async with HaikuRAG(
-                db_path=self.db_path, config=self.config, skip_validation=True
+                db_path=self.db_path,
+                config=self.config,
+                skip_validation=True,
+                read_only=self.read_only,
+                before=self.before,
             ) as client:
                 await client.vacuum()
             self.console.print(
@@ -397,6 +644,100 @@ class HaikuRAGApp:
         except Exception as e:
             self.console.print(f"[red]Error during vacuum: {e}[/red]")
 
+    async def create_index(self):
+        """Create vector index on the chunks table."""
+        try:
+            async with HaikuRAG(
+                db_path=self.db_path,
+                config=self.config,
+                skip_validation=True,
+                read_only=self.read_only,
+                before=self.before,
+            ) as client:
+                row_count = client.store.chunks_table.count_rows()
+                self.console.print(f"Chunks in database: {row_count}")
+
+                if row_count < 256:
+                    self.console.print(
+                        f"[yellow]Warning: Need at least 256 chunks to create an index (have {row_count})[/yellow]"
+                    )
+                    return
+
+                # Check if index already exists
+                indices = client.store.chunks_table.list_indices()
+                has_vector_index = any("vector" in str(idx).lower() for idx in indices)
+
+                if has_vector_index:
+                    self.console.print(
+                        "[yellow]Rebuilding existing vector index...[/yellow]"
+                    )
+                else:
+                    self.console.print("[bold]Creating vector index...[/bold]")
+
+                client.store._ensure_vector_index()
+                self.console.print(
+                    "[bold green]Vector index created successfully.[/bold green]"
+                )
+        except Exception as e:
+            self.console.print(f"[red]Error creating index: {e}[/red]")
+
+    async def download_models(self):
+        """Download Docling, HuggingFace tokenizer, and Ollama models per config."""
+        from haiku.rag.client import HaikuRAG
+
+        client = HaikuRAG(db_path=None, config=self.config)
+
+        progress: Progress | None = None
+        task_id: TaskID | None = None
+        current_model = ""
+        current_digest = ""
+
+        async for event in client.download_models():
+            if event.status == "start":
+                self.console.print(
+                    f"[bold blue]Downloading {event.model}...[/bold blue]"
+                )
+            elif event.status == "done":
+                if progress:
+                    progress.stop()
+                    progress = None
+                    task_id = None
+                self.console.print(f"[green]✓[/green] {event.model}")
+                current_model = ""
+                current_digest = ""
+            elif event.status == "pulling":
+                self.console.print(f"[bold blue]Pulling {event.model}...[/bold blue]")
+                current_model = event.model
+                progress = Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    DownloadColumn(),
+                    TransferSpeedColumn(),
+                    console=self.console,
+                    transient=True,
+                    auto_refresh=False,
+                )
+                progress.start()
+                task_id = progress.add_task(event.model, total=None)
+            elif event.status == "downloading" and progress and task_id is not None:
+                if event.digest != current_digest:
+                    current_digest = event.digest
+                    short_digest = event.digest[:19] if event.digest else ""
+                    progress.update(
+                        task_id,
+                        description=f"{current_model} ({short_digest})",
+                        total=event.total,
+                        completed=0,
+                    )
+                progress.update(task_id, completed=event.completed, refresh=True)
+            elif progress and task_id is not None:
+                progress.update(
+                    task_id,
+                    description=f"{current_model}: {event.status}",
+                    refresh=True,
+                )
+
     def show_settings(self):
         """Display current configuration settings."""
         self.console.print("[bold]haiku.rag configuration[/bold]")
@@ -447,22 +788,27 @@ class HaikuRAGApp:
         self.console.print(content)
         self.console.rule()
 
-    def _rich_print_search_result(self, chunk: Chunk, score: float):
-        """Format a search result chunk for display."""
-        content = Markdown(chunk.content)
+    def _rich_print_search_result(self, result: "SearchResult"):
+        """Format a search result for display."""
+        content = Markdown(result.content)
         self.console.print(
-            f"[repr.attrib_name]document_id[/repr.attrib_name]: {chunk.document_id} "
-            f"[repr.attrib_name]score[/repr.attrib_name]: {score:.4f}"
+            f"[repr.attrib_name]document_id[/repr.attrib_name]: {result.document_id} "
+            f"[repr.attrib_name]chunk_id[/repr.attrib_name]: {result.chunk_id} "
+            f"[repr.attrib_name]score[/repr.attrib_name]: {result.score:.4f}"
         )
-        if chunk.document_uri:
-            self.console.print("[repr.attrib_name]document uri[/repr.attrib_name]:")
-            self.console.print(chunk.document_uri)
-        if chunk.document_title:
+        if result.document_uri:
+            self.console.print(
+                f"[repr.attrib_name]document uri[/repr.attrib_name]: {result.document_uri}"
+            )
+        if result.document_title:
             self.console.print("[repr.attrib_name]document title[/repr.attrib_name]:")
-            self.console.print(chunk.document_title)
-        if chunk.document_meta:
-            self.console.print("[repr.attrib_name]document meta[/repr.attrib_name]:")
-            self.console.print(chunk.document_meta)
+            self.console.print(result.document_title)
+        if result.page_numbers:
+            self.console.print("[repr.attrib_name]pages[/repr.attrib_name]:")
+            self.console.print(", ".join(str(p) for p in result.page_numbers))
+        if result.headings:
+            self.console.print("[repr.attrib_name]headings[/repr.attrib_name]:")
+            self.console.print(" > ".join(result.headings))
         self.console.print("[repr.attrib_name]content[/repr.attrib_name]:")
         self.console.print(content)
         self.console.rule()
@@ -476,18 +822,30 @@ class HaikuRAGApp:
         enable_agui: bool = False,
     ):
         """Start the server with selected services."""
-        async with HaikuRAG(self.db_path, config=self.config) as client:
+        async with HaikuRAG(
+            self.db_path,
+            config=self.config,
+            read_only=self.read_only,
+            before=self.before,
+        ) as client:
             tasks = []
 
-            # Start file monitor if enabled
+            # Start file monitor if enabled (not available in read-only mode)
             if enable_monitor:
-                monitor = FileWatcher(client=client, config=self.config)
-                monitor_task = asyncio.create_task(monitor.observe())
-                tasks.append(monitor_task)
+                if self.read_only:
+                    logger.warning(
+                        "File monitor disabled: cannot monitor files in read-only mode"
+                    )
+                else:
+                    monitor = FileWatcher(client=client, config=self.config)
+                    monitor_task = asyncio.create_task(monitor.observe())
+                    tasks.append(monitor_task)
 
             # Start MCP server if enabled
             if enable_mcp:
-                server = create_mcp_server(self.db_path, config=self.config)
+                server = create_mcp_server(
+                    self.db_path, config=self.config, read_only=self.read_only
+                )
 
                 async def run_mcp():
                     if mcp_transport == "stdio":