rag-python 0.1.0__tar.gz → 0.3.0__tar.gz

{rag_python-0.1.0/src/rag_python.egg-info → rag_python-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rag-python
-Version: 0.1.0
+Version: 0.3.0
 Summary: Production-grade RAG for Python: multi-LLM, query rewriting, reranking, guardrails, and evaluation.
 Author-email: Raghav Singla <04raghavsingla28@gmail.com>
 License: MIT
@@ -33,6 +33,10 @@ Requires-Dist: requests>=2.31.0
 Provides-Extra: rerank
 Requires-Dist: sentence-transformers>=2.2.0; extra == "rerank"
 Requires-Dist: torch>=2.0.0; extra == "rerank"
+Provides-Extra: local
+Requires-Dist: sentence-transformers>=2.2.0; extra == "local"
+Provides-Extra: hybrid
+Requires-Dist: rank-bm25>=0.2.2; extra == "hybrid"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
 Provides-Extra: gemini
@@ -42,11 +46,14 @@ Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Requires-Dist: rank-bm25>=0.2.2; extra == "dev"
 Provides-Extra: all
-Requires-Dist: rag-python[anthropic,gemini,rerank]; extra == "all"
+Requires-Dist: rag-python[anthropic,gemini,hybrid,local,rerank]; extra == "all"
 
 # rag-python
 
+[![PyPI version](https://img.shields.io/pypi/v/rag-python.svg)](https://pypi.org/project/rag-python/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/rag-python.svg)](https://pypi.org/project/rag-python/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-RaghavOG%2Frag--python-blue)](https://github.com/RaghavOG/rag-python)
@@ -63,10 +70,11 @@ Ingest your documents, ask questions, get grounded answers — with query rewrit
 ## Features
 
 - Document pipeline: loaders → cleaning → chunking → embeddings → ChromaDB
-- Query pipeline: rewriting → multi-query retrieval → reranking
+- Query pipeline: rewriting → multi-query / **hybrid** retrieval → reranking
 - Generation with guardrails (prompt injection + hallucination checks)
 - Evaluation scores + self-correction retry loop
 - **LLM providers:** OpenAI, Azure OpenAI, Anthropic, Gemini, Ollama
+- **Loaders:** TXT, MD, PDF, DOCX, CSV, JSON, HTML
 
 ---
 
@@ -77,7 +85,7 @@ pip install rag-python
 # or from source
 pip install -e .
 # with reranking + extra providers
-pip install -e ".[rerank,anthropic,gemini,all]"
+pip install -e ".[rerank,local,hybrid,anthropic,gemini,all]"
 ```
 
 ---
@@ -99,12 +107,26 @@ answer = rag.query("How many days of annual leave?")
 print(answer.text)
 ```
 
+### Hybrid search + metadata filter
+
+```python
+from rag_python import RAG, SearchConfig
+
+rag = RAG(
+    retriever="hybrid",  # pip install rag-python[hybrid]
+    metadata_filter={"filename": "leave-policy.pdf"},
+)
+rag.ingest(["./policies/leave-policy.pdf", "./policies/handbook.pdf"])
+answer = rag.query("How many days of annual leave?")
+```
+
 ### CLI
 
 ```bash
 export OPENAI_API_KEY=sk-...
 rag-python ingest ./data --reindex
 rag-python query "How many days of annual leave?" -v
+rag-python query "leave policy" --retriever hybrid --metadata-filter '{"filename": "leave-policy.pdf"}'
 ```
 
 ---

{rag_python-0.1.0 → rag_python-0.3.0}/README.md

@@ -1,5 +1,7 @@
 # rag-python
 
+[![PyPI version](https://img.shields.io/pypi/v/rag-python.svg)](https://pypi.org/project/rag-python/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/rag-python.svg)](https://pypi.org/project/rag-python/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-RaghavOG%2Frag--python-blue)](https://github.com/RaghavOG/rag-python)
@@ -16,10 +18,11 @@ Ingest your documents, ask questions, get grounded answers — with query rewrit
 ## Features
 
 - Document pipeline: loaders → cleaning → chunking → embeddings → ChromaDB
-- Query pipeline: rewriting → multi-query retrieval → reranking
+- Query pipeline: rewriting → multi-query / **hybrid** retrieval → reranking
 - Generation with guardrails (prompt injection + hallucination checks)
 - Evaluation scores + self-correction retry loop
 - **LLM providers:** OpenAI, Azure OpenAI, Anthropic, Gemini, Ollama
+- **Loaders:** TXT, MD, PDF, DOCX, CSV, JSON, HTML
 
 ---
 
@@ -30,7 +33,7 @@ pip install rag-python
 # or from source
 pip install -e .
 # with reranking + extra providers
-pip install -e ".[rerank,anthropic,gemini,all]"
+pip install -e ".[rerank,local,hybrid,anthropic,gemini,all]"
 ```
 
 ---
@@ -52,12 +55,26 @@ answer = rag.query("How many days of annual leave?")
 print(answer.text)
 ```
 
+### Hybrid search + metadata filter
+
+```python
+from rag_python import RAG, SearchConfig
+
+rag = RAG(
+    retriever="hybrid",  # pip install rag-python[hybrid]
+    metadata_filter={"filename": "leave-policy.pdf"},
+)
+rag.ingest(["./policies/leave-policy.pdf", "./policies/handbook.pdf"])
+answer = rag.query("How many days of annual leave?")
+```
+
 ### CLI
 
 ```bash
 export OPENAI_API_KEY=sk-...
 rag-python ingest ./data --reindex
 rag-python query "How many days of annual leave?" -v
+rag-python query "leave policy" --retriever hybrid --metadata-filter '{"filename": "leave-policy.pdf"}'
 ```
 
 ---

{rag_python-0.1.0 → rag_python-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rag-python"
-version = "0.1.0"
+version = "0.3.0"
 description = "Production-grade RAG for Python: multi-LLM, query rewriting, reranking, guardrails, and evaluation."
 readme = "README.md"
 license = { text = "MIT" }
@@ -38,10 +38,12 @@ dependencies = [
 
 [project.optional-dependencies]
 rerank = ["sentence-transformers>=2.2.0", "torch>=2.0.0"]
+local = ["sentence-transformers>=2.2.0"]
+hybrid = ["rank-bm25>=0.2.2"]
 anthropic = ["anthropic>=0.20.0"]
 gemini = ["google-genai>=0.3.0"]
-dev = ["pytest>=7.0", "ruff>=0.1.0", "build", "twine"]
-all = ["rag-python[rerank,anthropic,gemini]"]
+dev = ["pytest>=7.0", "ruff>=0.1.0", "build", "twine", "rank-bm25>=0.2.2"]
+all = ["rag-python[rerank,local,hybrid,anthropic,gemini]"]
 
 [project.scripts]
 rag-python = "rag_python.cli:main"

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/__init__.py

@@ -9,7 +9,7 @@ Quick start::
     print(rag.query("What is our leave policy?").text)
 """
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 
 from .client import RAG, RAGAnswer
 from .rag_pipeline import ingest, query, RAGResponse

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/cli.py

@@ -1,11 +1,14 @@
 """rag-python command-line interface."""
 import argparse
+import json
+from dataclasses import replace
 
+from . import __version__
 from .client import RAG
 
 
 def _build_rag(args: argparse.Namespace) -> RAG:
-    return RAG(
+    kwargs: dict = dict(
         llm_provider=args.llm_provider,
         llm_model=args.llm_model,
         embedding_provider=args.embedding_provider,
@@ -18,12 +21,34 @@ def _build_rag(args: argparse.Namespace) -> RAG:
         gemini_api_key=args.gemini_api_key,
         ollama_base_url=args.ollama_base_url,
     )
+    if getattr(args, "retriever", None):
+        kwargs["retriever"] = args.retriever
+    if getattr(args, "metadata_filter", None):
+        kwargs["metadata_filter"] = args.metadata_filter
+    return RAG(**kwargs)
+
+
+def _parse_metadata_filter(raw: str | None) -> dict | None:
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise argparse.ArgumentTypeError(f"Invalid JSON for metadata filter: {e}") from e
 
 
 def _add_provider_args(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--llm-provider", default="openai", choices=["openai", "azure_openai", "anthropic", "gemini", "ollama"])
+    parser.add_argument(
+        "--llm-provider",
+        default="openai",
+        choices=["openai", "azure_openai", "anthropic", "gemini", "ollama"],
+    )
     parser.add_argument("--llm-model", default=None)
-    parser.add_argument("--embedding-provider", default="openai", choices=["openai", "azure_openai", "ollama"])
+    parser.add_argument(
+        "--embedding-provider",
+        default="openai",
+        choices=["openai", "azure_openai", "ollama", "local"],
+    )
     parser.add_argument("--embedding-model", default=None)
     parser.add_argument("--ollama-base-url", default=None)
     parser.add_argument("--azure-endpoint", default=None)
@@ -34,11 +59,27 @@ def _add_provider_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--gemini-api-key", default=None)
 
 
+def _add_search_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--retriever",
+        choices=["vector", "multi_query", "hybrid"],
+        default=None,
+        help="Retrieval strategy (default: multi_query; hybrid needs pip install rag-python[hybrid])",
+    )
+    parser.add_argument(
+        "--metadata-filter",
+        type=_parse_metadata_filter,
+        default=None,
+        help='Chroma metadata filter as JSON, e.g. \'{"filename": "policy.pdf"}\'',
+    )
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(
         prog="rag-python",
         description="rag-python — modular RAG with query rewriting, reranking, guardrails, and multi-LLM support.",
     )
+    parser.add_argument("--version", action="version", version=f"rag-python {__version__}")
     sub = parser.add_subparsers(dest="command", required=True)
 
     ing = sub.add_parser("ingest", help="Ingest files/folders into the vector store")
@@ -48,9 +89,10 @@ def main() -> None:
 
     q = sub.add_parser("query", help="Ask a question against ingested documents")
     q.add_argument("question", nargs="+", help="Question text")
-    q.add_argument("--no-multi-query", action="store_true")
+    q.add_argument("--no-multi-query", action="store_true", help="Use vector retriever only")
     q.add_argument("-v", "--verbose", action="store_true")
     _add_provider_args(q)
+    _add_search_args(q)
 
     args = parser.parse_args()
 
@@ -63,7 +105,15 @@ def main() -> None:
     if args.command == "query":
         rag = _build_rag(args)
         question = " ".join(args.question)
-        ans = rag.query(question, multi_query=not args.no_multi_query)
+        retriever = args.retriever
+        if retriever is None and args.no_multi_query:
+            retriever = "vector"
+        search = replace(
+            rag.config.search,
+            retriever=retriever or rag.config.search.retriever,
+            metadata_filter=args.metadata_filter or rag.config.search.metadata_filter,
+        )
+        ans = rag.query(question, search=search)
         print(ans.text)
         if args.verbose:
             print("\n--- evaluation ---")

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/client.py

@@ -60,6 +60,7 @@ class RAG:
         chunk_size: int | None = None,
         chunk_overlap: int | None = None,
         retriever: str | None = None,
+        metadata_filter: dict | None = None,
         top_k_retrieve: int | None = None,
         top_k_rerank: int | None = None,
         multi_query_n: int | None = None,
@@ -104,6 +105,8 @@ class RAG:
             self.config.search = replace(self.config.search, rerank_enabled=rerank_enabled)
         if document_extensions is not None:
             self.config.documents = replace(self.config.documents, extensions=document_extensions)
+        if metadata_filter is not None:
+            self.config.search = replace(self.config.search, metadata_filter=metadata_filter)
 
         self.llm = make_llm_provider(
             llm_provider,  # type: ignore[arg-type]

rag_python-0.3.0/src/rag_python/document_loaders.py

@@ -0,0 +1,146 @@
+"""Document loaders: raw data → structured text + metadata."""
+import csv
+import json
+from html.parser import HTMLParser
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Iterator
+
+try:
+    from pypdf import PdfReader
+except ImportError:
+    PdfReader = None
+
+try:
+    from docx import Document as DocxDocument
+except ImportError:
+    DocxDocument = None
+
+
+@dataclass
+class LoadedDocument:
+    """Single document with content and metadata."""
+    content: str
+    source: str
+    metadata: dict
+
+
+class _HTMLTextExtractor(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.parts: list[str] = []
+
+    def handle_data(self, data: str) -> None:
+        text = data.strip()
+        if text:
+            self.parts.append(text)
+
+
+def _html_to_text(html: str) -> str:
+    parser = _HTMLTextExtractor()
+    parser.feed(html)
+    return "\n".join(parser.parts)
+
+
+def _load_csv(path: Path, metadata: dict) -> LoadedDocument | None:
+    rows: list[str] = []
+    with path.open(encoding="utf-8", errors="replace", newline="") as f:
+        reader = csv.DictReader(f)
+        if reader.fieldnames:
+            for row in reader:
+                rows.append(", ".join(f"{k}: {v}" for k, v in row.items() if v))
+        else:
+            f.seek(0)
+            for row in csv.reader(f):
+                rows.append(", ".join(row))
+    content = "\n".join(rows)
+    metadata["rows"] = len(rows)
+    return LoadedDocument(content=content, source=str(path), metadata=metadata) if content.strip() else None
+
+
+def _load_json(path: Path, metadata: dict) -> LoadedDocument | None:
+    data = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    if isinstance(data, list):
+        parts = []
+        for item in data:
+            if isinstance(item, dict) and "text" in item:
+                parts.append(str(item["text"]))
+            else:
+                parts.append(json.dumps(item, ensure_ascii=False))
+        content = "\n\n".join(parts)
+    elif isinstance(data, dict):
+        if "text" in data:
+            content = str(data["text"])
+        else:
+            content = json.dumps(data, ensure_ascii=False, indent=2)
+    else:
+        content = str(data)
+    return LoadedDocument(content=content, source=str(path), metadata=metadata) if content.strip() else None
+
+
+def load_file(path: Path) -> LoadedDocument | None:
+    """Load a single file (PDF, TXT, DOCX, MD, CSV, JSON, HTML) into text + metadata."""
+    path = Path(path)
+    if not path.exists():
+        return None
+    suffix = path.suffix.lower()
+    metadata = {"source": str(path), "filename": path.name}
+
+    if suffix in (".txt", ".md"):
+        content = path.read_text(encoding="utf-8", errors="replace")
+        return LoadedDocument(content=content, source=str(path), metadata=metadata)
+
+    if suffix == ".html":
+        html = path.read_text(encoding="utf-8", errors="replace")
+        content = _html_to_text(html)
+        return LoadedDocument(content=content, source=str(path), metadata=metadata) if content.strip() else None
+
+    if suffix == ".csv":
+        return _load_csv(path, metadata)
+
+    if suffix == ".json":
+        try:
+            return _load_json(path, metadata)
+        except json.JSONDecodeError:
+            return None
+
+    if suffix == ".pdf" and PdfReader:
+        try:
+            reader = PdfReader(path)
+            parts = []
+            for i, page in enumerate(reader.pages):
+                text = page.extract_text() or ""
+                parts.append(text)
+                metadata.setdefault("page_numbers", []).append(i + 1)
+            content = "\n\n".join(parts)
+            metadata["pages"] = len(parts)
+            return LoadedDocument(content=content, source=str(path), metadata=metadata)
+        except Exception:
+            return None
+
+    if suffix in (".docx", ".doc") and DocxDocument:
+        try:
+            doc = DocxDocument(path)
+            parts = [p.text for p in doc.paragraphs]
+            content = "\n\n".join(parts)
+            metadata["paragraphs"] = len(parts)
+            return LoadedDocument(content=content, source=str(path), metadata=metadata)
+        except Exception:
+            return None
+
+    return None
+
+
+def load_directory(
+    dir_path: Path,
+    extensions: tuple = (".txt", ".md", ".pdf", ".docx", ".csv", ".json", ".html"),
+) -> Iterator[LoadedDocument]:
+    """Yield LoadedDocument for each supported file under dir_path."""
+    dir_path = Path(dir_path)
+    if not dir_path.is_dir():
+        return
+    for f in dir_path.rglob("*"):
+        if f.is_file() and f.suffix.lower() in extensions:
+            doc = load_file(f)
+            if doc and doc.content.strip():
+                yield doc

rag_python-0.3.0/src/rag_python/hybrid_search.py

@@ -0,0 +1,51 @@
+"""BM25 + vector fusion via reciprocal rank fusion (RRF)."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def reciprocal_rank_fusion(
+    rankings: list[list[tuple[str, dict[str, Any], float]]],
+    *,
+    rrf_k: int = 60,
+) -> list[tuple[str, dict[str, Any], float]]:
+    """Merge ranked lists with RRF. Higher score is better."""
+    scores: dict[tuple[str, str], float] = {}
+    doc_map: dict[tuple[str, str], tuple[str, dict[str, Any]]] = {}
+
+    for ranking in rankings:
+        for rank, (doc, meta, _score) in enumerate(ranking):
+            key = (doc[:200], str(meta.get("source", "")))
+            doc_map[key] = (doc, meta)
+            scores[key] = scores.get(key, 0.0) + 1.0 / (rrf_k + rank + 1)
+
+    merged = sorted(scores.items(), key=lambda item: item[1], reverse=True)
+    return [(doc_map[key][0], doc_map[key][1], score) for key, score in merged]
+
+
+def bm25_retrieve(
+    query: str,
+    documents: list[str],
+    metadatas: list[dict[str, Any]],
+    *,
+    top_k: int = 20,
+) -> list[tuple[str, dict[str, Any], float]]:
+    """Keyword retrieval with BM25. Requires ``pip install rag-python[hybrid]``."""
+    if not documents:
+        return []
+    try:
+        from rank_bm25 import BM25Okapi
+    except ImportError as e:
+        raise ImportError(
+            "Hybrid search requires optional dependencies. Install with: pip install rag-python[hybrid]"
+        ) from e
+
+    tokenized_corpus = [doc.lower().split() for doc in documents]
+    bm25 = BM25Okapi(tokenized_corpus)
+    scores = bm25.get_scores(query.lower().split())
+    ranked = sorted(
+        ((documents[i], metadatas[i], float(scores[i])) for i in range(len(documents))),
+        key=lambda item: item[2],
+        reverse=True,
+    )
+    return ranked[:top_k]

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/options.py

@@ -16,7 +16,7 @@ from .config import (
 )
 
 ChunkStrategy = Literal["recursive", "structure_aware", "semantic"]
-RetrieverStrategy = Literal["vector", "multi_query"]
+RetrieverStrategy = Literal["vector", "multi_query", "hybrid"]
 
 
 @dataclass
@@ -37,13 +37,14 @@ class SearchConfig:
     top_k_rerank: int = TOP_K_RERANK
     multi_query_n: int = MULTI_QUERY_N
     rerank_enabled: bool = RERANK_ENABLED
+    metadata_filter: dict | None = None
 
 
 @dataclass
 class DocumentConfig:
     """Which files to load and how to preprocess them."""
 
-    extensions: tuple[str, ...] = (".txt", ".md", ".pdf", ".docx")
+    extensions: tuple[str, ...] = (".txt", ".md", ".pdf", ".docx", ".csv", ".json", ".html")
     clean: bool = True
     copy_to_data_dir: bool = True
 

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/providers/factory.py

@@ -9,10 +9,11 @@ from .azure_openai_provider import AzureOpenAIProvider
 from .anthropic_provider import AnthropicProvider
 from .gemini_provider import GeminiProvider
 from .ollama_provider import OllamaProvider
+from .local_provider import LocalEmbeddingProvider
 
 
 LLMProviderName = Literal["openai", "azure_openai", "anthropic", "gemini", "ollama"]
-EmbeddingProviderName = Literal["openai", "azure_openai", "ollama"]
+EmbeddingProviderName = Literal["openai", "azure_openai", "ollama", "local"]
 
 
 def make_llm_provider(name: LLMProviderName, **kwargs) -> LLMProvider:
@@ -49,5 +50,7 @@ def make_embedding_provider(name: EmbeddingProviderName, **kwargs) -> EmbeddingP
         )
     if name == "ollama":
         return OllamaProvider(base_url=kwargs.get("base_url") or os.getenv("OLLAMA_BASE_URL", "http://localhost:11434"))
+    if name == "local":
+        return LocalEmbeddingProvider(model_name=kwargs.get("model") or os.getenv("LOCAL_EMBEDDING_MODEL"))
     raise ValueError(f"Unknown embedding provider: {name}")
 

rag_python-0.3.0/src/rag_python/providers/local_provider.py

@@ -0,0 +1,34 @@
+"""Local sentence-transformers embeddings (no API key required)."""
+from __future__ import annotations
+
+import os
+
+_DEFAULT_MODEL = "all-MiniLM-L6-v2"
+
+
+class LocalEmbeddingProvider:
+    """Offline embeddings via sentence-transformers."""
+
+    def __init__(self, model_name: str | None = None) -> None:
+        self.default_model = model_name or os.getenv("LOCAL_EMBEDDING_MODEL", _DEFAULT_MODEL)
+        self._models: dict[str, object] = {}
+
+    def _get_model(self, model_name: str):
+        if model_name not in self._models:
+            try:
+                from sentence_transformers import SentenceTransformer
+            except ImportError as e:
+                raise ImportError(
+                    "Local embeddings require optional dependencies. "
+                    "Install with: pip install rag-python[local]"
+                ) from e
+            self._models[model_name] = SentenceTransformer(model_name)
+        return self._models[model_name]
+
+    def embed(self, texts: list[str], *, model: str | None = None) -> list[list[float]]:
+        if not texts:
+            return []
+        model_name = model or self.default_model
+        encoder = self._get_model(model_name)
+        vectors = encoder.encode(texts, convert_to_numpy=True)
+        return [v.tolist() for v in vectors]

{rag_python-0.1.0 → rag_python-0.3.0}/src/rag_python/rag_pipeline.py

@@ -1,4 +1,5 @@
 """Full RAG pipeline: Query → Understanding/Rewrite → Retrieval (multi-query) → Rerank → LLM → Guardrails → Eval/Retry."""
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -14,6 +15,8 @@ from .providers import LLMProvider, EmbeddingProvider, make_llm_provider, make_e
 from .config import DATA_DIR, CHUNK_SIZE, CHUNK_OVERLAP, CHUNK_STRATEGY
 from .options import QueryConfig, SearchConfig
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class RAGResponse:
@@ -34,7 +37,7 @@ def _load_documents(
     paths: list[Path] | None = None,
     data_path: Path | None = None,
     *,
-    extensions: tuple[str, ...] = (".txt", ".md", ".pdf", ".docx"),
+    extensions: tuple[str, ...] = (".txt", ".md", ".pdf", ".docx", ".csv", ".json", ".html"),
 ) -> list[LoadedDocument]:
     """Load documents from explicit paths and/or a data directory."""
     docs: list[LoadedDocument] = []
@@ -136,12 +139,13 @@ def ingest(
     strategy = chunk_strategy or CHUNK_STRATEGY
     size = chunk_size or CHUNK_SIZE
     overlap = chunk_overlap or CHUNK_OVERLAP
-    ext = extensions or (".txt", ".md", ".pdf", ".docx")
+    ext = extensions or (".txt", ".md", ".pdf", ".docx", ".csv", ".json", ".html")
     embedder = embedder or make_embedding_provider("openai")
 
     path_list = [Path(p) for p in paths] if paths else None
     root = Path(data_path) if data_path else (None if path_list else Path(DATA_DIR))
     docs = _load_documents(path_list, root, extensions=ext)
+    logger.info("Loaded %s documents for ingest", len(docs))
     return _ingest_documents(
         docs,
         clean=clean,
@@ -202,11 +206,13 @@ def query(
         top_k_retrieve=search_cfg.top_k_retrieve,
         top_k_rerank=search_cfg.top_k_rerank,
         rerank_enabled=search_cfg.rerank_enabled,
+        metadata_filter=search_cfg.metadata_filter,
         embedder=embedder,
         embedding_model=embedding_model,
         llm=llm,
         llm_model=llm_model,
     )
+    logger.info("Retrieved %s chunks (retriever=%s)", len(hits), search_cfg.retriever)
     context_chunks = [h[0] for h in hits]
     sources = [{"text": h[0][:200], "metadata": h[1], "score": h[2]} for h in hits]
     context_str = "\n\n".join(context_chunks)