fix: Lint Errors

Author: RaghavOG

src/minirag/__init__.py

@@ -14,11 +14,23 @@
 from .client import RAG, RAGAnswer
 from .rag_pipeline import ingest, query, RAGResponse
 from .providers import make_llm_provider, make_embedding_provider
+from .options import (
+    ChunkingConfig,
+    DocumentConfig,
+    QueryConfig,
+    RAGConfig,
+    SearchConfig,
+)
 
 __all__ = [
     "__version__",
     "RAG",
     "RAGAnswer",
+    "RAGConfig",
+    "ChunkingConfig",
+    "SearchConfig",
+    "DocumentConfig",
+    "QueryConfig",
     "ingest",
     "query",
     "RAGResponse",

src/minirag/cleaning.py

@@ -38,7 +38,7 @@ def is_likely_header_footer(line: str) -> bool:
 
 def deduplicate_sentences(text: str) -> str:
     """Remove consecutive duplicate sentences (and near-duplicates by line)."""
-    lines = [normalize_whitespace(l) for l in text.splitlines() if l.strip()]
+    lines = [normalize_whitespace(line) for line in text.splitlines() if line.strip()]
     seen = set()
     out = []
     for line in lines:

src/minirag/client.py

@@ -2,20 +2,36 @@
 
 This wraps the full RAG pipeline behind a simple interface:
 
-    from minirag import RAG
+    from minirag import RAG, RAGConfig, ChunkingConfig, SearchConfig
 
-    rag = RAG(llm_model="gpt-4o-mini", embedding_model="text-embedding-3-small")
-    rag.ingest(["./docs", "README.md"])
+    rag = RAG(
+        llm_model="gpt-4o-mini",
+        embedding_provider="openai",
+        embedding_model="text-embedding-3-small",
+        config=RAGConfig(
+            chunking=ChunkingConfig(strategy="recursive", chunk_size=512),
+            search=SearchConfig(retriever="multi_query", top_k_retrieve=20),
+        ),
+    )
+    rag.ingest(["./docs", "./policies.pdf", "README.md"])
     answer = rag.query("What is our leave policy?")
     print(answer.text)
 """
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Iterable
 
-from .config import DATA_DIR, LLM_MODEL, EMBEDDING_MODEL
+from .config import CHROMA_PERSIST_DIR, DATA_DIR, EMBEDDING_MODEL, LLM_MODEL
+from .options import (
+    ChunkingConfig,
+    DocumentConfig,
+    QueryConfig,
+    RAGConfig,
+    SearchConfig,
+)
 from .providers import make_llm_provider, make_embedding_provider
 from .rag_pipeline import ingest as _ingest, query as _query, RAGResponse
+from .vector_store import set_persist_dir
 
 
 @dataclass
@@ -27,7 +43,7 @@ class RAGAnswer:
 
 
 class RAG:
-    """User-facing RAG client."""
+    """User-facing RAG client with configurable chunking, retrieval, and embeddings."""
 
     def __init__(
         self,
@@ -37,6 +53,18 @@ def __init__(
         embedding_provider: str = "openai",
         embedding_model: str | None = None,
         data_dir: str | Path | None = None,
+        chroma_dir: str | Path | None = None,
+        config: RAGConfig | None = None,
+        # Shorthand overrides (merged into ``config`` when provided)
+        chunk_strategy: str | None = None,
+        chunk_size: int | None = None,
+        chunk_overlap: int | None = None,
+        retriever: str | None = None,
+        top_k_retrieve: int | None = None,
+        top_k_rerank: int | None = None,
+        multi_query_n: int | None = None,
+        rerank_enabled: bool | None = None,
+        document_extensions: tuple[str, ...] | None = None,
         # Provider kwargs (optional)
         openai_api_key: str | None = None,
         azure_endpoint: str | None = None,
@@ -52,7 +80,31 @@ def __init__(
         self.embedding_model = embedding_model or EMBEDDING_MODEL
         self.data_dir = Path(data_dir) if data_dir else Path(DATA_DIR)
 
-        # Providers
+        if chroma_dir:
+            set_persist_dir(chroma_dir)
+        elif CHROMA_PERSIST_DIR:
+            set_persist_dir(CHROMA_PERSIST_DIR)
+
+        self.config = config or RAGConfig()
+        if chunk_strategy is not None:
+            self.config.chunking = replace(self.config.chunking, strategy=chunk_strategy)  # type: ignore[arg-type]
+        if chunk_size is not None:
+            self.config.chunking = replace(self.config.chunking, chunk_size=chunk_size)
+        if chunk_overlap is not None:
+            self.config.chunking = replace(self.config.chunking, chunk_overlap=chunk_overlap)
+        if retriever is not None:
+            self.config.search = replace(self.config.search, retriever=retriever)  # type: ignore[arg-type]
+        if top_k_retrieve is not None:
+            self.config.search = replace(self.config.search, top_k_retrieve=top_k_retrieve)
+        if top_k_rerank is not None:
+            self.config.search = replace(self.config.search, top_k_rerank=top_k_rerank)
+        if multi_query_n is not None:
+            self.config.search = replace(self.config.search, multi_query_n=multi_query_n)
+        if rerank_enabled is not None:
+            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)
+
         self.llm = make_llm_provider(
             llm_provider,  # type: ignore[arg-type]
             api_key=openai_api_key or anthropic_api_key or gemini_api_key or azure_api_key,
@@ -69,39 +121,62 @@ def __init__(
         )
 
     def ingest(self, paths: Iterable[str | Path], *, reindex: bool = False) -> int:
-        """Ingest the given files/directories into the vector store."""
-        self.data_dir.mkdir(parents=True, exist_ok=True)
-
-        for p in paths:
-            p = Path(p)
-            if p.is_file():
-                target = self.data_dir / p.name
-                if str(p.resolve()) != str(target.resolve()):
-                    target.write_bytes(p.read_bytes())
-            elif p.is_dir():
-                for f in p.rglob("*"):
-                    if f.is_file():
-                        rel = f.relative_to(p)
-                        target = self.data_dir / rel
-                        target.parent.mkdir(parents=True, exist_ok=True)
-                        if str(f.resolve()) != str(target.resolve()):
-                            target.write_bytes(f.read_bytes())
+        """Ingest one or more files/directories into the vector store."""
+        path_list = [Path(p) for p in paths]
+        doc_cfg: DocumentConfig = self.config.documents
+        chunk_cfg: ChunkingConfig = self.config.chunking
+
+        if doc_cfg.copy_to_data_dir:
+            self.data_dir.mkdir(parents=True, exist_ok=True)
+            for p in path_list:
+                if p.is_file():
+                    target = self.data_dir / p.name
+                    if str(p.resolve()) != str(target.resolve()):
+                        target.write_bytes(p.read_bytes())
+                elif p.is_dir():
+                    for f in p.rglob("*"):
+                        if f.is_file():
+                            rel = f.relative_to(p)
+                            target = self.data_dir / rel
+                            target.parent.mkdir(parents=True, exist_ok=True)
+                            if str(f.resolve()) != str(target.resolve()):
+                                target.write_bytes(f.read_bytes())
+            return _ingest(
+                data_path=self.data_dir,
+                clean=doc_cfg.clean,
+                chunk_strategy=chunk_cfg.strategy,
+                chunk_size=chunk_cfg.chunk_size,
+                chunk_overlap=chunk_cfg.chunk_overlap,
+                extensions=doc_cfg.extensions,
+                reindex=reindex,
+                embedding_model=self.embedding_model,
+                embedder=self.embedder,
+            )
 
         return _ingest(
-            data_path=self.data_dir,
-            clean=True,
+            paths=path_list,
+            clean=doc_cfg.clean,
+            chunk_strategy=chunk_cfg.strategy,
+            chunk_size=chunk_cfg.chunk_size,
+            chunk_overlap=chunk_cfg.chunk_overlap,
+            extensions=doc_cfg.extensions,
             reindex=reindex,
             embedding_model=self.embedding_model,
             embedder=self.embedder,
         )
 
-    def query(self, question: str, *, multi_query: bool = True) -> RAGAnswer:
+    def query(
+        self,
+        question: str,
+        *,
+        search: SearchConfig | None = None,
+        query_config: QueryConfig | None = None,
+    ) -> RAGAnswer:
         """Run a full RAG query and return a friendly answer object."""
         resp: RAGResponse = _query(
             question,
-            multi_query=multi_query,
-            use_guardrails=True,
-            use_retry=True,
+            search=search or self.config.search,
+            query_config=query_config or self.config.query,
             llm_model=self.llm_model,
             embedding_model=self.embedding_model,
             llm=self.llm,
@@ -113,4 +188,3 @@ def query(self, question: str, *, multi_query: bool = True) -> RAGAnswer:
             evaluation=resp.evaluation,
             retried=resp.retried,
         )
-

src/minirag/evaluation.py

@@ -1,5 +1,5 @@
 """RAG evaluation: faithfulness, relevance; retry & self-correction loop."""
-from .config import LLM_MODEL, MAX_RETRIES
+from .config import LLM_MODEL
 from .providers import LLMProvider, make_llm_provider
 
 

src/minirag/options.py

@@ -0,0 +1,68 @@
+"""User-configurable options for RAG ingest, retrieval, and generation."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from .config import (
+    CHUNK_OVERLAP,
+    CHUNK_SIZE,
+    GUARDRAILS_ENABLED,
+    MAX_RETRIES,
+    MULTI_QUERY_N,
+    RERANK_ENABLED,
+    TOP_K_RERANK,
+    TOP_K_RETRIEVE,
+)
+
+ChunkStrategy = Literal["recursive", "structure_aware", "semantic"]
+RetrieverStrategy = Literal["vector", "multi_query"]
+
+
+@dataclass
+class ChunkingConfig:
+    """How documents are split before embedding."""
+
+    strategy: ChunkStrategy = "recursive"
+    chunk_size: int = CHUNK_SIZE
+    chunk_overlap: int = CHUNK_OVERLAP
+
+
+@dataclass
+class SearchConfig:
+    """Retrieval and reranking behaviour at query time."""
+
+    retriever: RetrieverStrategy = "multi_query"
+    top_k_retrieve: int = TOP_K_RETRIEVE
+    top_k_rerank: int = TOP_K_RERANK
+    multi_query_n: int = MULTI_QUERY_N
+    rerank_enabled: bool = RERANK_ENABLED
+
+
+@dataclass
+class DocumentConfig:
+    """Which files to load and how to preprocess them."""
+
+    extensions: tuple[str, ...] = (".txt", ".md", ".pdf", ".docx")
+    clean: bool = True
+    copy_to_data_dir: bool = True
+
+
+@dataclass
+class QueryConfig:
+    """Guardrails, evaluation, and retry settings."""
+
+    use_guardrails: bool = GUARDRAILS_ENABLED
+    use_retry: bool = True
+    max_retries: int = MAX_RETRIES
+    eval_threshold: float = 0.6
+
+
+@dataclass
+class RAGConfig:
+    """All tunable pipeline options (pass to ``RAG(config=...)``)."""
+
+    chunking: ChunkingConfig = field(default_factory=ChunkingConfig)
+    search: SearchConfig = field(default_factory=SearchConfig)
+    documents: DocumentConfig = field(default_factory=DocumentConfig)
+    query: QueryConfig = field(default_factory=QueryConfig)

src/minirag/providers/ollama_provider.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 from typing import Any
 
 

src/minirag/query_rewriting.py

@@ -1,5 +1,5 @@
 """Query understanding & rewriting: expand/rewrite user query for better retrieval."""
-from .config import LLM_MODEL, MULTI_QUERY_N
+from .config import LLM_MODEL
 from .providers import LLMProvider, make_llm_provider
 
 
@@ -27,7 +27,7 @@ def rewrite_for_retrieval(
             temperature=0.3,
             max_tokens=200,
         )
-        lines = [l.strip() for l in text.splitlines() if l.strip()]
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
         cleaned = []
         for line in lines[:n_queries]:
             for sep in (". ", ") ", "- ", " ", ""):