rag-python 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/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/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/document_loaders.py

@@ -1,4 +1,7 @@
 """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
@@ -22,18 +25,85 @@ class LoadedDocument:
     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) into text + metadata."""
+    """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 == ".txt" or suffix == ".md":
+    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)
@@ -61,7 +131,10 @@ def load_file(path: Path) -> LoadedDocument | None:
     return None
 
 
-def load_directory(dir_path: Path, extensions: tuple = (".txt", ".md", ".pdf", ".docx")) -> Iterator[LoadedDocument]:
+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():
@@ -71,4 +144,3 @@ def load_directory(dir_path: Path, extensions: tuple = (".txt", ".md", ".pdf", "
             doc = load_file(f)
             if doc and doc.content.strip():
                 yield doc
-

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/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/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/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/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)

rag_python/retrieval.py

@@ -1,14 +1,49 @@
-"""Retrieval: multi-query retrieval + reranking."""
+"""Retrieval: vector, multi-query, hybrid (BM25+vector), and reranking."""
 from typing import Any
 
-from .vector_store import retrieve as chroma_retrieve
+from .vector_store import retrieve as chroma_retrieve, list_documents
 from .query_rewriting import rewrite_for_retrieval
 from .reranker import rerank_with_metadata
+from .hybrid_search import bm25_retrieve, reciprocal_rank_fusion
 from .providers import EmbeddingProvider, LLMProvider
 from .options import RetrieverStrategy
 from .config import TOP_K_RETRIEVE, TOP_K_RERANK, MULTI_QUERY_N
 
 
+def _dedupe_candidates(candidates: list[tuple[str, dict, float]]) -> list[tuple[str, dict, float]]:
+    seen: set[tuple[str, str]] = set()
+    out: list[tuple[str, dict, float]] = []
+    for doc, meta, score in candidates:
+        key = (doc[:200], str(meta.get("source", "")))
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append((doc, meta, score))
+    return out
+
+
+def _vector_candidates(
+    queries: list[str],
+    *,
+    embedder: EmbeddingProvider,
+    embedding_model: str | None,
+    top_k_retrieve: int,
+    where: dict | None,
+) -> list[tuple[str, dict, float]]:
+    seen_docs: set[tuple[str, str]] = set()
+    all_candidates: list[tuple[str, dict, float]] = []
+    for q in queries:
+        emb = embedder.embed([q], model=embedding_model)[0]
+        hits = chroma_retrieve(emb, top_k=top_k_retrieve, where=where)
+        for doc, meta, dist in hits:
+            key = (doc[:200], str(meta.get("source", "")))
+            if key in seen_docs:
+                continue
+            seen_docs.add(key)
+            all_candidates.append((doc, meta, -dist))
+    return all_candidates
+
+
 def retrieve(
     query: str,
     *,
@@ -20,42 +55,47 @@ def retrieve(
     top_k_retrieve: int | None = None,
     top_k_rerank: int | None = None,
     rerank_enabled: bool | None = None,
+    metadata_filter: dict | None = None,
     llm: LLMProvider | None = None,
     llm_model: str | None = None,
 ) -> list[tuple[str, dict[str, Any], float]]:
     """
-    Retrieve relevant chunks using vector or multi-query search, then rerank.
+    Retrieve relevant chunks using vector, multi-query, or hybrid search, then rerank.
     Returns list of (document_text, metadata, rerank_score).
     """
     top_k_retrieve = top_k_retrieve or TOP_K_RETRIEVE
     top_k_rerank = top_k_rerank or TOP_K_RERANK
     n_queries = n_queries or MULTI_QUERY_N
-    use_multi_query = retriever == "multi_query" if multi_query is None else multi_query
 
-    queries = [query]
-    if use_multi_query and n_queries > 1:
-        rewritten = rewrite_for_retrieval(query, n_queries=n_queries, llm=llm, llm_model=llm_model)
-        if rewritten:
-            queries = rewritten
+    if retriever == "hybrid":
+        emb = embedder.embed([query], model=embedding_model)[0]
+        vector_hits = chroma_retrieve(emb, top_k=top_k_retrieve, where=metadata_filter)
+        vector_ranked = [(d, m, -dist) for d, m, dist in vector_hits]
 
-    seen_docs: set[str] = set()
-    all_candidates: list[tuple[str, dict, float]] = []
-    for q in queries:
-        emb = embedder.embed([q], model=embedding_model)[0]
-        hits = chroma_retrieve(emb, top_k=top_k_retrieve)
-        for doc, meta, dist in hits:
-            key = (doc[:200], meta.get("source", ""))
-            if key in seen_docs:
-                continue
-            seen_docs.add(key)
-            all_candidates.append((doc, meta, -dist))
+        docs, metas = list_documents(where=metadata_filter)
+        bm25_ranked = bm25_retrieve(query, docs, metas, top_k=top_k_retrieve)
+        fused = reciprocal_rank_fusion([vector_ranked, bm25_ranked])[:top_k_retrieve]
+        all_candidates = _dedupe_candidates(fused)
+    else:
+        use_multi_query = retriever == "multi_query" if multi_query is None else multi_query
+        queries = [query]
+        if use_multi_query and n_queries > 1:
+            rewritten = rewrite_for_retrieval(query, n_queries=n_queries, llm=llm, llm_model=llm_model)
+            if rewritten:
+                queries = rewritten
+        all_candidates = _vector_candidates(
+            queries,
+            embedder=embedder,
+            embedding_model=embedding_model,
+            top_k_retrieve=top_k_retrieve,
+            where=metadata_filter,
+        )
 
     if not all_candidates:
         return []
+
     docs = [c[0] for c in all_candidates]
     metas = [c[1] for c in all_candidates]
-    reranked = rerank_with_metadata(
+    return rerank_with_metadata(
         query, list(zip(docs, metas)), top_k=top_k_rerank, rerank_enabled=rerank_enabled
     )
-    return reranked
-

rag_python/vector_store.py

@@ -85,6 +85,19 @@ def retrieve(
     return list(zip(docs, metas, dists))
 
 
+def list_documents(
+    *,
+    where: dict | None = None,
+    limit: int | None = None,
+) -> tuple[list[str], list[dict[str, Any]]]:
+    """Return all stored chunk texts and metadata (for BM25 indexing)."""
+    coll = get_collection()
+    res = coll.get(where=where, include=["documents", "metadatas"], limit=limit)
+    docs = res.get("documents") or []
+    metas = res.get("metadatas") or []
+    return docs, metas
+
+
 def delete_all() -> None:
     """Remove all documents from the collection (for re-ingestion)."""
     _get_client().delete_collection(COLLECTION_NAME)

{rag_python-0.1.0.dist-info → rag_python-0.3.0.dist-info}/METADATA

@@ -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.dist-info → rag_python-0.3.0.dist-info}/RECORD

@@ -1,31 +1,33 @@
-rag_python/__init__.py,sha256=0mdBYu9JmPzQBOX947S5tdk5KuNU3JNO-y5GsDZsFlY,834
+rag_python/__init__.py,sha256=TzZxXzRdKszqqbq7KynrO-Cc0JMzZc1UcIxtNSLhvqQ,834
 rag_python/chunking.py,sha256=P1dbZ8ZY7487MxrWe2cypCiKhzIJ8zBPCTVz20vt8fo,6204
 rag_python/cleaning.py,sha256=fSux4T0pg7Xe_8NUP2pgzuForyRk1i2VPYIXSzRajzs,3193
-rag_python/cli.py,sha256=UlCnI6Ah7pmyZwCEP1c-gt5XDOhFzLOvnsk2vKxvp-A,3126
-rag_python/client.py,sha256=MhWAm92Ic2FQ1DTej4EhAlT9UoPN-GjxA0xrHIvwNA8,7656
+rag_python/cli.py,sha256=z22LLX6dWnMlaI9yIU2tf4HpcLbG2zRz66RQWsFxGNY,4775
+rag_python/client.py,sha256=RyWLBvj4bAJW1Vb529me7Eo608e9Wwq-OeImAAKjyIY,7838
 rag_python/config.py,sha256=Zw8TjQFKRvOUHpIb7kjEb7DtPFoYPzdQyOPzSXTqDcc,1389
-rag_python/document_loaders.py,sha256=izguVJjPq8v4hDWC8wGP2-LwiYUJbVe-DOsIX6n9J9E,2429
+rag_python/document_loaders.py,sha256=blI-rMqzmHSHzcX9RmFBQZ_MYiM_uKLvesCDTPyoQbo,4866
 rag_python/evaluation.py,sha256=gTiXMaAtTUIsV6Ffhywz829BhfR8YhfJFkYZYrD9WYI,3561
 rag_python/generation.py,sha256=t6aSct2vZELIf20JDwRVt8UTwPnTXx0bU3TKoliiwVg,1108
 rag_python/guardrails.py,sha256=hJLXvpPNI9o8emyipSy5PpePofGzktlDLyMAXfAxUXs,2520
-rag_python/options.py,sha256=QvangjsYbct204_p_avraAuw_Ry2mcjhxby2Sx96dE0,1858
+rag_python/hybrid_search.py,sha256=71kZyJ9obZBZGzhrl1DQjK32X4AtFppk_wvmpkUVzwo,1814
+rag_python/options.py,sha256=P_nLMk7vQdRM11HCoR9AMUk2D0NmEVA5B5_ufhRiAmE,1935
 rag_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rag_python/query_rewriting.py,sha256=og_XWai2-08C7W67mFndA3k-aTxMdqGnu70qHi1Ohgc,2293
-rag_python/rag_pipeline.py,sha256=R8roEc-OSFPqrjZmvJXp7IhYaOdqd6kZ63otN1PUKTI,8747
+rag_python/rag_pipeline.py,sha256=qth2LDVi6QxpqJVskjLxaxnpwpV5dKwh515334fc8DY,9058
 rag_python/reranker.py,sha256=8RxCPfgp80c-KSKojllGzbpZ7iSku-i7VLgPHa1a3rk,2181
-rag_python/retrieval.py,sha256=A9ZMIkrifyDF1rhtgNt_uR09o1_hCkywIuODjvLaY6Q,2261
-rag_python/vector_store.py,sha256=16I9g7Q8bMjwpxhTNv0nCq2WXQwftjZdSaxFNteVsH4,2909
+rag_python/retrieval.py,sha256=iTlkaCs79iDDa_K9gktjJC9bAE0bHzy302CFGwmwEk0,3887
+rag_python/vector_store.py,sha256=iAjGRXtzvh9F3aQJVRZ7abUfvwR5YM-qQ0N52qwJGmw,3340
 rag_python/providers/__init__.py,sha256=SjhMvYoA30EY5VUYVXhEGwcmQnIU2tUomcNE0_0NFho,215
 rag_python/providers/anthropic_provider.py,sha256=dSiCdM4F90jI9w7z_wS10XuVsX-pR733-cAgJHtVV2Q,1493
 rag_python/providers/azure_openai_provider.py,sha256=8SbI7rDzQgvC4ZXP89Q8kjfqeWuBfX1KKgExGLFkmx0,1940
 rag_python/providers/base.py,sha256=M9DYowQvNvRuATaM6944CWovK0awJ0buBmbnQfroJos,593
-rag_python/providers/factory.py,sha256=uD0Hqrzyj9R88vNVN-95Fn2gj28hUIVNXuKe0G1R5wo,2522
+rag_python/providers/factory.py,sha256=O7nYikPOh_LnVgTVIreLQKL-ehIMayr3KXES1wpKpjw,2717
 rag_python/providers/gemini_provider.py,sha256=OZzs1YJQSZituoxS5Gk8yv3jYNIFY1SVovWUu7lz5Z4,1842
+rag_python/providers/local_provider.py,sha256=tgYBNUrs7pKpPebA0tpNhJmtZLwwINuZFqKMyHlymTQ,1332
 rag_python/providers/ollama_provider.py,sha256=DDhDriB6-Ob0r2-M-P3SvIFG37ruDAErtU7LWDK8xh0,1958
 rag_python/providers/openai_provider.py,sha256=oR7rCCaxCtirAVetJrR4oC3UrWySuqLc9kbosydoQAQ,1585
-rag_python-0.1.0.dist-info/LICENSE,sha256=PZ61Z6ve0hBHgztaC1rPgnxQTRXRkeHKASlnKkX2pvc,1079
-rag_python-0.1.0.dist-info/METADATA,sha256=R0dvEMcDKMgUDxImAEwmBeHMYcmR46NjPl31lhoBJw4,5199
-rag_python-0.1.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-rag_python-0.1.0.dist-info/entry_points.txt,sha256=558Rd4GWV_6mIyqdRSVNE4ZZi0-KdblTZhcMbIn3ryY,51
-rag_python-0.1.0.dist-info/top_level.txt,sha256=SrgudPwkJWfJ3gUn2n-dhrt9vN2XbQcaZ3wLQZed4Z4,11
-rag_python-0.1.0.dist-info/RECORD,,
+rag_python-0.3.0.dist-info/LICENSE,sha256=PZ61Z6ve0hBHgztaC1rPgnxQTRXRkeHKASlnKkX2pvc,1079
+rag_python-0.3.0.dist-info/METADATA,sha256=iIp2OG2jfo7xVYYQCQf264ZAFBeIhecfs5lIy-XTLZo,6171
+rag_python-0.3.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+rag_python-0.3.0.dist-info/entry_points.txt,sha256=558Rd4GWV_6mIyqdRSVNE4ZZi0-KdblTZhcMbIn3ryY,51
+rag_python-0.3.0.dist-info/top_level.txt,sha256=SrgudPwkJWfJ3gUn2n-dhrt9vN2XbQcaZ3wLQZed4Z4,11
+rag_python-0.3.0.dist-info/RECORD,,