sieve-context 0.1.0__py3-none-any.whl

sieve/__init__.py

@@ -0,0 +1,29 @@
+"""Sieve: Context compression middleware for RAG."""
+
+from sieve.models import (
+    Document,
+    Chunk,
+    ScoredChunk,
+    SieveResult,
+    FilterMetrics,
+    Savings,
+    Benchmark,
+)
+from sieve.sieve import Sieve, filter_context
+from sieve.scorer import Scorer, get_default_scorer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Sieve",
+    "filter_context",
+    "Document",
+    "Chunk",
+    "ScoredChunk",
+    "SieveResult",
+    "FilterMetrics",
+    "Savings",
+    "Benchmark",
+    "Scorer",
+    "get_default_scorer",
+]

sieve/benchmark.py

@@ -0,0 +1,132 @@
+import time
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sieve.config import Config
+from sieve.models import Benchmark
+from sieve.vector_store import VectorStore
+from sieve.scorer import Scorer
+from sieve.sieve import Sieve
+from sieve.llm import LLM, count_tokens
+from sieve.metrics import calculate_savings
+
+class Evaluator:
+    """Evaluates whether two LLM answers are factually equivalent."""
+    def judge_equivalence(self, question: str, standard_answer: str, sieve_answer: str, llm: LLM) -> dict:
+        prompt = f"""
+        You are an impartial judge evaluating two AI systems.
+        Question: {question}
+        Standard Answer: {standard_answer}
+        Sieve Answer: {sieve_answer}
+        
+        Do these two answers contain the exact same factual information in response to the question? 
+        If Sieve's answer is missing information that Standard provided, it is not equivalent.
+        
+        Output your response exactly in this format on two lines:
+        SCORE: <number between 0 and 100>
+        VERDICT: <one short sentence explaining the score>
+        """
+        
+        try:
+            res = llm.answer(question, prompt)
+            lines = res.answer.strip().split('\n')
+            score = 100
+            verdict = "Could not parse judge response."
+            
+            for line in lines:
+                if line.startswith("SCORE:"):
+                    try:
+                        score = int(line.replace("SCORE:", "").strip())
+                    except ValueError:
+                        pass
+                elif line.startswith("VERDICT:"):
+                    verdict = line.replace("VERDICT:", "").strip()
+                    
+            return {"score": score, "verdict": verdict}
+        except Exception as e:
+            return {"score": 0, "verdict": f"Judge failed: {str(e)}"}
+
+class Runner:
+    """Runs end-to-end benchmarking for Sieve ON vs OFF."""
+    def __init__(self, config: Config, vector_store: VectorStore, scorer: Scorer, llm: LLM):
+        self.config = config
+        self.vector_store = vector_store
+        self.scorer = scorer
+        self.llm = llm
+        
+        self.sieve = Sieve(
+            threshold=config.sieve.threshold,
+            max_tokens=config.sieve.max_tokens,
+            context_window=config.sieve.context_window
+        )
+        self.evaluator = Evaluator()
+
+    def run_standard(self, question: str) -> Benchmark:
+        """Run the query using naive RAG (sending all retrieved chunks)."""
+        t0 = time.perf_counter()
+        
+        all_chunks = self.vector_store.chunks
+        original_context = "\n\n".join([c.text for c in all_chunks])
+        original_tokens = count_tokens(original_context)
+        
+        retrieval_latency = time.perf_counter() - t0
+        
+        # LLM Call
+        std_llm_res = self.llm.answer(question, original_context)
+        std_metrics = calculate_savings(std_llm_res.input_tokens, std_llm_res.output_tokens, self.config)
+        
+        std_total_latency = retrieval_latency + std_llm_res.latency
+        
+        return Benchmark(
+            question=question,
+            standard_retrieval_tokens=original_tokens,
+            standard_llm_input_tokens=std_llm_res.input_tokens,
+            standard_cost=std_metrics.estimated_cost,
+            standard_latency_retrieval=retrieval_latency,
+            standard_latency_total=std_total_latency,
+            standard_answer=std_llm_res.answer,
+            # Fill empty for sieve fields
+            sieve_retrieval_tokens=0, sieve_output_tokens=0, sieve_tokens_removed=0, sieve_reduction_pct=0,
+            sieve_cost=0, sieve_latency_retrieval=0, sieve_latency_sieve=0, sieve_latency_total=0, sieve_answer="",
+            cost_reduction_pct=0, latency_improvement_pct=0, semantic_similarity=None
+        )
+
+    def run_sieve(self, question: str, progress_callback=None) -> Benchmark:
+        """Run the query using Sieve to compress the context first."""
+        t0 = time.perf_counter()
+        
+        all_chunks = self.vector_store.chunks
+        original_context = "\n\n".join([c.text for c in all_chunks])
+        original_tokens = count_tokens(original_context)
+        retrieval_latency = time.perf_counter() - t0
+        
+        if progress_callback:
+            progress_callback({"stage": "starting"})
+            
+        # Score and compress
+        scored_chunks = self.scorer.score_chunks(question, all_chunks, progress_callback=progress_callback)
+        sieve_res = self.sieve.filter_context(scored_chunks, count_tokens)
+        
+        if progress_callback:
+            progress_callback({"stage": "calling_llm"})
+            
+        # LLM Call
+        sieve_llm_res = self.llm.answer(question, sieve_res.compressed_context)
+        sieve_metrics = calculate_savings(sieve_llm_res.input_tokens, sieve_llm_res.output_tokens, self.config)
+        
+        sieve_total_latency = retrieval_latency + sieve_res.latency + sieve_llm_res.latency
+        
+        return Benchmark(
+            question=question,
+            standard_retrieval_tokens=0, standard_llm_input_tokens=0, standard_cost=0,
+            standard_latency_retrieval=0, standard_latency_total=0, standard_answer="",
+            sieve_retrieval_tokens=original_tokens,
+            sieve_output_tokens=sieve_llm_res.input_tokens,
+            sieve_tokens_removed=sieve_res.removed_tokens,
+            sieve_reduction_pct=sieve_res.reduction_percentage,
+            sieve_cost=sieve_metrics.estimated_cost,
+            sieve_latency_retrieval=retrieval_latency,
+            sieve_latency_sieve=sieve_res.latency,
+            sieve_latency_total=sieve_total_latency,
+            sieve_answer=sieve_llm_res.answer,
+            cost_reduction_pct=0, latency_improvement_pct=0, semantic_similarity=None
+        )

sieve/calibrate.py

@@ -0,0 +1,140 @@
+import json
+import os
+import time
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+from sieve.sieve import filter_context
+from sieve.llm import LLM, MockLLM, GoogleLLM, count_tokens
+from sieve.config import load_config
+
+class BenchmarkCase(BaseModel):
+    question: str
+    context: str
+    expected_answer: str
+
+class ThresholdResult(BaseModel):
+    threshold: Optional[float]
+    label: str
+    context_kept_pct: float
+    accuracy_pct: float
+    correct_count: int
+    total_count: int
+    retained_tokens_avg: float
+    latency_ms_avg: float
+
+class CalibrationSummary(BaseModel):
+    results: List[ThresholdResult]
+    min_sufficient_threshold: Optional[float]
+    min_sufficient_context_pct: float
+    min_sufficient_accuracy_pct: float
+
+def score_answer(expected: str, answer_or_context: str) -> bool:
+    """Check case-insensitive substring match of expected answer."""
+    return expected.strip().lower() in answer_or_context.lower()
+
+def run_calibration(
+    benchmark_path: str,
+    thresholds: List[float] = [0.20, 0.35, 0.50, 0.65, 0.80],
+    llm: Optional[LLM] = None,
+) -> CalibrationSummary:
+    """Sweep thresholds across a benchmark and report accuracy and context reduction."""
+    with open(benchmark_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    cases = [BenchmarkCase(**item) for item in data]
+    total_cases = len(cases)
+    if total_cases == 0:
+        raise ValueError("Benchmark dataset is empty.")
+
+    results: List[ThresholdResult] = []
+
+    # 1. Baseline (without Sieve)
+    baseline_correct = 0
+    baseline_tokens = []
+    baseline_latencies = []
+
+    for c in cases:
+        tokens = count_tokens(c.context)
+        baseline_tokens.append(tokens)
+        if llm is not None:
+            t0 = time.perf_counter()
+            resp = llm.answer(c.question, c.context)
+            elapsed = (time.perf_counter() - t0) * 1000.0
+            baseline_latencies.append(elapsed)
+            if score_answer(c.expected_answer, resp.answer):
+                baseline_correct += 1
+        else:
+            # Check presence in context
+            baseline_latencies.append(0.0)
+            if score_answer(c.expected_answer, c.context):
+                baseline_correct += 1
+
+    results.append(ThresholdResult(
+        threshold=None,
+        label="— (WITHOUT SIEVE)",
+        context_kept_pct=100.0,
+        accuracy_pct=round((baseline_correct / total_cases) * 100.0, 1),
+        correct_count=baseline_correct,
+        total_count=total_cases,
+        retained_tokens_avg=round(sum(baseline_tokens) / total_cases, 1),
+        latency_ms_avg=round(sum(baseline_latencies) / total_cases, 1),
+    ))
+
+    # 2. Threshold sweep
+    for th in sorted(thresholds):
+        correct = 0
+        kept_tokens_list = []
+        latencies = []
+
+        for c in cases:
+            res = filter_context(query=c.question, context=c.context, threshold=th)
+            kept_tokens = res.metrics.filtered_tokens
+            kept_tokens_list.append(kept_tokens)
+
+            if llm is not None:
+                t0 = time.perf_counter()
+                resp = llm.answer(c.question, res.filtered_context)
+                elapsed = (time.perf_counter() - t0) * 1000.0 + res.metrics.filtering_latency_ms
+                latencies.append(elapsed)
+                if score_answer(c.expected_answer, resp.answer):
+                    correct += 1
+            else:
+                latencies.append(res.metrics.filtering_latency_ms)
+                if score_answer(c.expected_answer, res.filtered_context):
+                    correct += 1
+
+        avg_kept_pct = (sum(kept_tokens_list) / sum(baseline_tokens)) * 100.0 if sum(baseline_tokens) > 0 else 0.0
+        acc_pct = (correct / total_cases) * 100.0
+
+        results.append(ThresholdResult(
+            threshold=th,
+            label=f"{th:.2f}",
+            context_kept_pct=round(avg_kept_pct, 1),
+            accuracy_pct=round(acc_pct, 1),
+            correct_count=correct,
+            total_count=total_cases,
+            retained_tokens_avg=round(sum(kept_tokens_list) / total_cases, 1),
+            latency_ms_avg=round(sum(latencies) / total_cases, 1),
+        ))
+
+    # Determine minimum sufficient context:
+    # Filter among thresholds that maintain accuracy >= baseline accuracy (or max accuracy observed)
+    max_acc = max(r.accuracy_pct for r in results if r.threshold is not None)
+    qualifying = [r for r in results if r.threshold is not None and r.accuracy_pct >= max_acc]
+    if qualifying:
+        # Pick the one with lowest context kept
+        best = min(qualifying, key=lambda x: x.context_kept_pct)
+        best_th = best.threshold
+        best_context_pct = best.context_kept_pct
+        best_acc = best.accuracy_pct
+    else:
+        best_th = None
+        best_context_pct = 100.0
+        best_acc = 100.0
+
+    return CalibrationSummary(
+        results=results,
+        min_sufficient_threshold=best_th,
+        min_sufficient_context_pct=best_context_pct,
+        min_sufficient_accuracy_pct=best_acc,
+    )

sieve/cli.py

@@ -0,0 +1,248 @@
+import os
+import glob
+from typing import Optional
+import typer
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.table import Table
+
+from sieve.config import load_config
+from sieve.ui import (
+    console, print_header, run_sieve, run_standard,
+    render_mode_dashboard, render_stats_table, print_env_savings,
+    to_safe_ascii, SAFE_BOX, STANDARD_COLOR, SIEVE_COLOR, SIEVE_ACCENT
+)
+from sieve.documents import parse_document, process_documents
+from sieve.vector_store import VectorStore
+from sieve.scorer import Scorer
+from sieve.llm import MockLLM, GoogleLLM
+from sieve.benchmark import Runner
+from sieve.sieve import filter_context
+from sieve.calibrate import run_calibration
+
+app = typer.Typer(help="Sieve: Intelligent context compression for RAG")
+
+def setup(offline: bool = False):
+    config = load_config()
+    vector_store = VectorStore(config.workspace.index_dir, config.models.embedding)
+    scorer = Scorer(config.models.reranker)
+    
+    if offline or not config.llm.api_key:
+        llm = MockLLM()
+    else:
+        llm = GoogleLLM(api_key=config.llm.api_key, model_name=config.llm.model)
+        
+    return config, vector_store, scorer, llm
+
+@app.command()
+def index():
+    """Ingest and index documents in the workspace."""
+    config, vector_store, scorer, llm = setup(offline=True)
+    doc_dir = config.workspace.documents_dir
+    
+    if not os.path.exists(doc_dir):
+        console.print(f"[warning]Documents directory not found at {doc_dir}. Created it. Please add files and run index again.[/warning]")
+        os.makedirs(doc_dir)
+        return
+        
+    files = []
+    for ext in ["*.pdf", "*.txt", "*.md", "*.html"]:
+        files.extend(glob.glob(os.path.join(doc_dir, ext)))
+        
+    if not files:
+        console.print(f"[warning]No supported documents found in {doc_dir}. Please add some PDFs or text files.[/warning]")
+        return
+        
+    console.print(f"[info]Found {len(files)} documents. Indexing...[/info]")
+    
+    all_chunks = []
+    for f in files:
+        coarse = parse_document(f)
+        fine = process_documents(coarse)
+        all_chunks.extend(fine)
+        
+    vector_store.add_chunks(all_chunks)
+    console.print(f"[success]Successfully indexed {len(all_chunks)} chunks into the vector store![/success]")
+
+@app.command()
+def ask(question: str, offline: bool = typer.Option(False, "--offline", help="Run in offline mode")):
+    """Ask a question using Sieve RAG."""
+    config, vector_store, scorer, llm = setup(offline)
+    runner = Runner(config, vector_store, scorer, llm)
+    
+    console.rule(
+        f"[bold {SIEVE_COLOR}]SIEVE :: SIEVE MODE[/bold {SIEVE_COLOR}] [dim]- cross-encoder filtered context[/dim]",
+        style=SIEVE_COLOR,
+        characters="-",
+    )
+    console.print(f"\n[bold]Query:[/bold] {to_safe_ascii(question)}\n")
+    
+    res = run_sieve(runner, question)
+        
+    console.print(Panel(to_safe_ascii(res.sieve_answer), title="Sieve's answer", border_style=SIEVE_COLOR, box=SAFE_BOX))
+    console.print()
+    console.print(render_mode_dashboard("sieve", res, SIEVE_COLOR))
+    print_env_savings("sieve", res, res.sieve_retrieval_tokens)
+    console.print()
+    console.rule(style=SIEVE_COLOR, characters="-")
+
+@app.command()
+def benchmark(offline: bool = typer.Option(False, "--offline", help="Run in offline mode")):
+    """Run a side-by-side benchmark (Standard vs Sieve)."""
+    print_header()
+    
+    config, vector_store, scorer, llm = setup(offline)
+    if not vector_store.chunks:
+        console.print("[warning]No indexed documents. Please run 'sieve index' first.[/warning]")
+        return
+        
+    question = Prompt.ask("\n[bold]Enter your question[/bold]")
+    
+    runner = Runner(config, vector_store, scorer, llm)
+    
+    console.rule(f"[bold {STANDARD_COLOR}]STANDARD RAG[/bold {STANDARD_COLOR}]", style=STANDARD_COLOR, characters="-")
+    std_res = run_standard(runner, question)
+    console.print(Panel(to_safe_ascii(std_res.standard_answer), title="Standard's answer", border_style=STANDARD_COLOR, box=SAFE_BOX))
+
+    console.print()
+    console.rule(f"[bold {SIEVE_COLOR}]SIEVE RAG[/bold {SIEVE_COLOR}]", style=SIEVE_COLOR, characters="-")
+    sieve_res = run_sieve(runner, question)
+    console.print(Panel(to_safe_ascii(sieve_res.sieve_answer), title="Sieve's answer", border_style=SIEVE_COLOR, box=SAFE_BOX))
+
+    console.print()
+    
+    # Merge results to pass into render_stats_table
+    sieve_res.standard_llm_input_tokens = std_res.standard_llm_input_tokens
+    sieve_res.standard_cost = std_res.standard_cost
+    sieve_res.standard_latency_total = std_res.standard_latency_total
+    
+    console.print(render_stats_table(sieve_res))
+
+    console.print()
+    with console.status(f"[bold {SIEVE_ACCENT}]Judging factual agreement...[/bold {SIEVE_ACCENT}]"):
+        comparison = runner.evaluator.judge_equivalence(question, std_res.standard_answer, sieve_res.sieve_answer, llm)
+        
+    console.print(
+        Panel(
+            f"[bold]{comparison['score']}% agreement[/bold]\n{to_safe_ascii(comparison['verdict'])}",
+            title="Accuracy - LLM-as-judge",
+            border_style=SIEVE_ACCENT,
+            box=SAFE_BOX,
+        )
+    )
+
+    console.print()
+    console.rule(style=SIEVE_COLOR, characters="-")
+
+@app.command()
+def calibrate(
+    benchmark_file: str = typer.Option("examples/benchmark.json", "--benchmark", "-b", help="Path to benchmark JSON"),
+    thresholds: str = typer.Option("0.20,0.35,0.50,0.65,0.80", "--thresholds", "-t", help="Comma-separated threshold list"),
+    offline: bool = typer.Option(True, "--offline", help="Run in offline mode without calling LLM API"),
+):
+    """Calibrate optimal filtering threshold across a benchmark dataset."""
+    th_list = [float(x.strip()) for x in thresholds.split(",") if x.strip()]
+    config, _, _, llm = setup(offline=offline)
+    
+    console.print(f"[info]Running Sieve Calibrate on '{benchmark_file}' with thresholds {th_list}...[/info]")
+    active_llm = None if offline else llm
+    
+    summary = run_calibration(benchmark_file, thresholds=th_list, llm=active_llm)
+    
+    table = Table(title="SIEVE CALIBRATION RESULTS", box=SAFE_BOX)
+    table.add_column("Threshold", style="bold")
+    table.add_column("Context Kept", justify="right")
+    table.add_column("Accuracy", justify="right")
+    table.add_column("Correct", justify="right")
+    table.add_column("Avg Latency", justify="right")
+    
+    for r in summary.results:
+        table.add_row(
+            r.label,
+            f"{r.context_kept_pct}%",
+            f"{r.accuracy_pct}%",
+            f"{r.correct_count}/{r.total_count}",
+            f"{r.latency_ms_avg:.1f}ms",
+        )
+    console.print(table)
+    
+    console.print(
+        f"\n[bold {SIEVE_COLOR}]Minimum sufficient context:[/bold {SIEVE_COLOR}] "
+        f"Threshold {summary.min_sufficient_threshold if summary.min_sufficient_threshold is not None else 'N/A'}, "
+        f"{summary.min_sufficient_context_pct}% of context retained, "
+        f"{summary.min_sufficient_accuracy_pct}% accuracy."
+    )
+
+@app.command()
+def filter(
+    query: str = typer.Argument(..., help="Query to filter context against"),
+    context_file: Optional[str] = typer.Option(None, "--file", "-f", help="Path to context text file"),
+    context_text: Optional[str] = typer.Option(None, "--text", help="Raw context text to filter"),
+    threshold: float = typer.Option(0.50, "--threshold", "-t", help="Relevance threshold"),
+    max_tokens: Optional[int] = typer.Option(None, "--max-tokens", help="Maximum tokens in filtered context"),
+):
+    """Filter retrieved context directly for a given query."""
+    raw_context = ""
+    if context_file:
+        if not os.path.exists(context_file):
+            console.print(f"[red]Error: file '{context_file}' does not exist.[/red]")
+            raise typer.Exit(code=1)
+        with open(context_file, "r", encoding="utf-8") as f:
+            raw_context = f.read()
+    elif context_text:
+        raw_context = context_text
+    else:
+        # Default to demo context if available
+        demo_path = "examples/context.txt"
+        if os.path.exists(demo_path):
+            with open(demo_path, "r", encoding="utf-8") as f:
+                raw_context = f.read()
+        else:
+            console.print("[red]Error: Please provide --file or --text.[/red]")
+            raise typer.Exit(code=1)
+
+    result = filter_context(query=query, context=raw_context, threshold=threshold, max_tokens=max_tokens)
+    
+    console.print(Panel(result.filtered_context, title="Filtered Context", border_style=SIEVE_COLOR, box=SAFE_BOX))
+    console.print(
+        f"\n[bold]Metrics:[/bold] Original: {result.metrics.original_tokens} tokens | "
+        f"Filtered: {result.metrics.filtered_tokens} tokens | "
+        f"Reduction: {result.metrics.reduction_percent}% | "
+        f"Latency: {result.metrics.filtering_latency_ms} ms"
+    )
+
+@app.command()
+def doctor():
+    """Check system status."""
+    print_header()
+    config = load_config()
+    console.print("[bold]SIEVE DOCTOR[/bold]")
+    
+    doc_dir = config.workspace.documents_dir
+    docs_exist = os.path.exists(doc_dir) and len(os.listdir(doc_dir)) > 0
+    console.print(f"[{'success' if docs_exist else 'warning'}] Workspace documents: {'Found' if docs_exist else 'Empty'}")
+    
+    idx_dir = config.workspace.index_dir
+    idx_exist = os.path.exists(idx_dir) and len(os.listdir(idx_dir)) > 0
+    console.print(f"[{'success' if idx_exist else 'warning'}] Vector index: {'Found' if idx_exist else 'Empty'}")
+    
+    key_exists = bool(config.llm.api_key)
+    console.print(f"[{'success' if key_exists else 'warning'}] LLM API Key: {'Configured' if key_exists else 'Not found (will use offline mode)'}")
+
+@app.command()
+def interactive():
+    """Start interactive session."""
+    print_header()
+    while True:
+        cmd = Prompt.ask("\n[bold]sieve>[/bold] ")
+        if cmd.lower() in ['exit', 'quit']:
+            break
+        elif cmd.lower().startswith('ask '):
+            ask(cmd[4:], offline=False)
+        elif cmd.lower() == 'benchmark':
+            benchmark(offline=False)
+        else:
+            console.print("Commands: ask <question>, benchmark, calibrate, exit")
+
+if __name__ == "__main__":
+    app()

sieve/config.py

@@ -0,0 +1,69 @@
+import os
+import yaml
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+class WorkspaceConfig(BaseModel):
+    documents_dir: str = "./workspace/documents"
+    index_dir: str = "./workspace/indexes"
+    benchmarks_dir: str = "./workspace/benchmarks"
+
+class RetrievalConfig(BaseModel):
+    top_k: int = 10
+
+class SieveConfig(BaseModel):
+    threshold: float = 0.60
+    max_tokens: int = 2000
+    context_window: int = 1
+
+class ModelsConfig(BaseModel):
+    embedding: str = "all-MiniLM-L6-v2"
+    reranker: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+
+class PricingConfig(BaseModel):
+    input_per_1m: float = 0.075
+    output_per_1m: float = 0.300
+
+class LLMConfig(BaseModel):
+    provider: str = "google"
+    model: str = "gemini-3.5-flash-lite"
+    pricing: PricingConfig = PricingConfig()
+    api_key: str = ""
+
+class SustainabilityConfig(BaseModel):
+    energy_per_million_tokens_kwh: float = 0.003
+    carbon_intensity_g_per_kwh: float = 450.0
+
+class Config(BaseModel):
+    workspace: WorkspaceConfig = WorkspaceConfig()
+    retrieval: RetrievalConfig = RetrievalConfig()
+    sieve: SieveConfig = SieveConfig()
+    models: ModelsConfig = ModelsConfig()
+    llm: LLMConfig = LLMConfig()
+    sustainability: SustainabilityConfig = SustainabilityConfig()
+
+def load_config(config_path: str = "sieve.yaml") -> Config:
+    load_dotenv()
+    
+    config_data = {}
+    if os.path.exists(config_path):
+        with open(config_path, "r", encoding="utf-8") as f:
+            config_data = yaml.safe_load(f) or {}
+
+    config = Config(**config_data)
+    
+    # Overrides from environment
+    if os.getenv("SIEVE_LLM_PROVIDER"):
+        config.llm.provider = os.getenv("SIEVE_LLM_PROVIDER")
+        
+    if os.getenv("SIEVE_GOOGLE_MODEL"):
+        config.llm.model = os.getenv("SIEVE_GOOGLE_MODEL")
+        
+    if os.getenv("SIEVE_GOOGLE_API_KEY"):
+        config.llm.api_key = os.getenv("SIEVE_GOOGLE_API_KEY")
+        
+    return config
+
+# Global config instance for simple access if needed
+# Typically better to pass it around, but a default instance is handy
+default_config = load_config()