perfectrag 0.1.0__py3-none-any.whl

perfectrag/__init__.py

@@ -0,0 +1,3 @@
+"""perfectRAG — dynamic RAG framework scaffolder."""
+
+__version__ = "0.1.0"

perfectrag/cli.py

@@ -0,0 +1,196 @@
+"""perfectrag CLI — entrypoint wired via pyproject [project.scripts]."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from perfectrag import hardware, recipes, scaffolder, wizard
+from perfectrag.mcp_registry import REGISTRY, add_mcp_to_project
+from perfectrag.skills import add_skill_to_project, list_bundled_skills
+
+# Force UTF-8 on Windows legacy consoles (cp1252 can't encode many non-ASCII chars)
+for stream in (sys.stdout, sys.stderr):
+    if hasattr(stream, "reconfigure"):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, OSError):
+            pass
+
+app = typer.Typer(
+    help="perfectRAG - dynamic RAG framework scaffolder",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console(legacy_windows=False)
+
+
+@app.command()
+def init(
+    project_dir: Path = typer.Argument(Path("./my-rag"), help="Thư mục project sẽ sinh"),
+    answers_file: Path | None = typer.Option(
+        None, "--answers-file", "-a",
+        help="YAML chứa answers (bỏ qua wizard interactive, dùng cho CI/test)",
+    ),
+    template: str | None = typer.Option(
+        None, "--template", "-t",
+        help="Override template gợi ý (custom-naive-rag, ragflow-stack, lightrag-stack, dify-stack)",
+    ),
+    force: bool = typer.Option(False, "--force", help="Ghi đè nếu project_dir đã có"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview recipe, không scaffold"),
+) -> None:
+    """Chạy wizard → scaffold project RAG hoàn chỉnh."""
+    hw = hardware.detect()
+    _show_hardware(hw)
+
+    if answers_file is not None:
+        raw = yaml.safe_load(answers_file.read_text(encoding="utf-8"))
+        answers = recipes.Answers(**raw)
+    else:
+        answers = wizard.run_wizard()
+
+    recipe = recipes.recommend(answers, hw)
+    if template is not None:
+        if template not in scaffolder.available_templates():
+            console.print(f"[red]Template '{template}' không tồn tại. Có sẵn: "
+                          f"{', '.join(scaffolder.available_templates().keys())}[/red]")
+            raise typer.Exit(1)
+        recipe.template = template
+        recipe.notes.append(f"Template được override bằng --template={template}")
+    _show_recipe(recipe)
+
+    if dry_run:
+        console.print("[yellow]--dry-run, không scaffold.[/yellow]")
+        raise typer.Exit(0)
+
+    if project_dir.exists() and any(project_dir.iterdir()) and not force:
+        console.print(f"[red]Thư mục {project_dir} đã tồn tại và không rỗng. Dùng --force để ghi đè.[/red]")
+        raise typer.Exit(1)
+
+    scaffolder.render(recipe, hw, answers, project_dir, force=force)
+    console.print(
+        Panel.fit(
+            f"[green]Done![/green]\n\n"
+            f"cd {project_dir}\n"
+            f"docker compose up -d\n\n"
+            f"Edit [cyan]mcp.yaml[/cyan] to add tools, [cyan]skills/[/cyan] to add skills.",
+            title="Next steps",
+        )
+    )
+
+
+@app.command("add")
+def add_cmd(
+    kind: str = typer.Argument(..., help="'mcp' hoặc 'skill'"),
+    name: str = typer.Argument(..., help="Tên MCP server / skill"),
+    project_dir: Path = typer.Option(Path("."), "--project", "-p", help="Project dir"),
+) -> None:
+    """Add MCP server hoặc skill vào project đã sinh."""
+    if kind == "mcp":
+        add_mcp_to_project(name, project_dir)
+        console.print(f"[green]Added MCP '{name}' vào {project_dir}/mcp.yaml[/green]")
+    elif kind == "skill":
+        add_skill_to_project(name, project_dir)
+        console.print(f"[green]Added skill '{name}' vào {project_dir}/skills/[/green]")
+    else:
+        console.print(f"[red]Unknown kind: {kind}. Dùng 'mcp' hoặc 'skill'.[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_cmd(
+    what: str = typer.Argument(..., help="'templates', 'mcp', 'skills'"),
+) -> None:
+    """Liệt kê templates / MCP servers / skills có sẵn."""
+    if what == "templates":
+        _list_templates()
+    elif what == "mcp":
+        _list_mcp()
+    elif what == "skills":
+        _list_skills()
+    else:
+        console.print(f"[red]Unknown: {what}. Dùng 'templates', 'mcp' hoặc 'skills'.[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def hw() -> None:
+    """Chỉ detect + show hardware, không làm gì khác."""
+    _show_hardware(hardware.detect())
+
+
+# --- helpers ---
+
+def _show_hardware(hw: hardware.HardwareProfile) -> None:
+    table = Table(title="Detected hardware", show_header=False)
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+    table.add_row("OS / arch", f"{hw.os} ({hw.arch})")
+    table.add_row("CPU", f"{hw.cpu_model} — {hw.cpu_cores} cores")
+    table.add_row("RAM", f"{hw.ram_gb} GB")
+    table.add_row("Disk free", f"{hw.disk_free_gb} GB")
+    table.add_row("GPU", f"{hw.gpu_vendor} / {hw.gpu_name or '—'}")
+    table.add_row("VRAM", f"{hw.vram_gb} GB")
+    if hw.cuda_version:
+        table.add_row("CUDA", hw.cuda_version)
+    table.add_row("Tier", f"[bold]{hw.tier}[/bold]")
+    console.print(table)
+
+
+def _show_recipe(recipe: recipes.Recipe) -> None:
+    table = Table(title=f"Recommended recipe → template: [bold]{recipe.template}[/bold]")
+    table.add_column("Component", style="cyan")
+    table.add_column("Choice")
+    table.add_row("LLM", f"{recipe.llm_model} (via {recipe.llm_runtime})")
+    table.add_row("Embedding", recipe.embedding_model)
+    table.add_row("Reranker", recipe.reranker or "—")
+    table.add_row("Vector DB", recipe.vector_db)
+    table.add_row("Doc parser", recipe.doc_parser)
+    table.add_row("Chunk", f"{recipe.chunk_strategy} / {recipe.chunk_size} tokens")
+    table.add_row("GPU enabled", "yes" if recipe.gpu_enabled else "no")
+    table.add_row("VRAM cap", f"{recipe.vram_cap_gb} GB")
+    for k, v in recipe.extras.items():
+        table.add_row(f"extras.{k}", str(v))
+    console.print(table)
+    for note in recipe.notes:
+        console.print(f"[yellow]![/yellow] {note}")
+
+
+def _list_templates() -> None:
+    from perfectrag.scaffolder import available_templates
+
+    table = Table(title="Templates bundled")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    for name, desc in available_templates().items():
+        table.add_row(name, desc)
+    console.print(table)
+
+
+def _list_mcp() -> None:
+    table = Table(title="MCP registry")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    table.add_column("Requires env")
+    for name, info in REGISTRY.items():
+        table.add_row(name, info["description"], ", ".join(info.get("env", [])) or "—")
+    console.print(table)
+
+
+def _list_skills() -> None:
+    table = Table(title="Bundled skills")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    for name, desc in list_bundled_skills().items():
+        table.add_row(name, desc)
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

perfectrag/hardware.py

@@ -0,0 +1,203 @@
+"""Cross-platform hardware detection for recipe selection.
+
+Detects CPU, RAM, disk, and GPU (NVIDIA / AMD ROCm / Apple Silicon / none) so the
+recipe engine can pick an appropriate stack tier.
+"""
+
+from __future__ import annotations
+
+import json
+import platform
+import shutil
+import subprocess
+from dataclasses import asdict, dataclass
+from typing import Literal
+
+import psutil
+
+GpuVendor = Literal["nvidia", "amd", "apple", "none"]
+
+
+@dataclass(frozen=True)
+class HardwareProfile:
+    os: str
+    arch: str
+    cpu_model: str
+    cpu_cores: int
+    ram_gb: int
+    disk_free_gb: int
+    gpu_vendor: GpuVendor
+    gpu_name: str | None
+    vram_gb: int
+    cuda_version: str | None
+
+    @property
+    def tier(self) -> str:
+        """Coarse tier used by the recipe engine."""
+        if self.gpu_vendor == "none":
+            return "cpu"
+        if self.gpu_vendor == "apple":
+            # Apple Silicon uses unified memory; treat RAM as VRAM budget.
+            if self.ram_gb >= 24:
+                return "apple-high"
+            return "apple-low"
+        if self.vram_gb >= 24:
+            return "gpu-24gb"
+        if self.vram_gb >= 12:
+            return "gpu-12gb"
+        if self.vram_gb >= 6:
+            return "gpu-8gb"
+        return "cpu"
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def _run(cmd: list[str], timeout: int = 5) -> str | None:
+    try:
+        out = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=timeout, check=False
+        )
+        if out.returncode == 0:
+            return out.stdout
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return None
+    return None
+
+
+def _detect_cpu_model() -> str:
+    try:
+        from cpuinfo import get_cpu_info
+
+        return get_cpu_info().get("brand_raw", platform.processor() or "unknown")
+    except Exception:
+        return platform.processor() or "unknown"
+
+
+def _detect_nvidia() -> tuple[str, int, str | None] | None:
+    """Return (gpu_name, vram_gb, cuda_version) via NVML, else None."""
+    try:
+        import pynvml
+
+        pynvml.nvmlInit()
+        try:
+            count = pynvml.nvmlDeviceGetCount()
+            if count == 0:
+                return None
+            handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+            name = pynvml.nvmlDeviceGetName(handle)
+            if isinstance(name, bytes):
+                name = name.decode()
+            mem = pynvml.nvmlDeviceGetMemoryInfo(handle)
+            vram_gb = int(mem.total / (1024**3))
+            try:
+                cuda = pynvml.nvmlSystemGetCudaDriverVersion_v2()
+                cuda_str = f"{cuda // 1000}.{(cuda % 1000) // 10}"
+            except Exception:
+                cuda_str = None
+            return name, vram_gb, cuda_str
+        finally:
+            try:
+                pynvml.nvmlShutdown()
+            except Exception:
+                pass
+    except Exception:
+        # Fallback: parse nvidia-smi
+        smi = _run(["nvidia-smi", "--query-gpu=name,memory.total,driver_version",
+                    "--format=csv,noheader,nounits"])
+        if not smi:
+            return None
+        line = smi.strip().splitlines()[0]
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            return None
+        name = parts[0]
+        try:
+            vram_mb = int(parts[1])
+            vram_gb = vram_mb // 1024
+        except ValueError:
+            vram_gb = 0
+        return name, vram_gb, None
+
+
+def _detect_amd() -> tuple[str, int] | None:
+    """Return (gpu_name, vram_gb) via rocm-smi, else None."""
+    if not shutil.which("rocm-smi"):
+        return None
+    out = _run(["rocm-smi", "--showproductname", "--showmeminfo", "vram", "--json"])
+    if not out:
+        return None
+    try:
+        data = json.loads(out)
+    except json.JSONDecodeError:
+        return None
+    for _card_key, info in data.items():
+        if not isinstance(info, dict):
+            continue
+        name = info.get("Card series") or info.get("Card model") or "AMD GPU"
+        vram_bytes_str = info.get("VRAM Total Memory (B)")
+        try:
+            vram_gb = int(vram_bytes_str) // (1024**3) if vram_bytes_str else 0
+        except (TypeError, ValueError):
+            vram_gb = 0
+        return str(name), vram_gb
+    return None
+
+
+def _detect_apple() -> tuple[str, int] | None:
+    """Return (chip_name, unified_memory_gb) on Apple Silicon macOS, else None."""
+    if platform.system() != "Darwin":
+        return None
+    if platform.machine() not in ("arm64", "aarch64"):
+        return None
+    chip = _run(["sysctl", "-n", "machdep.cpu.brand_string"])
+    mem = _run(["sysctl", "-n", "hw.memsize"])
+    chip_name = (chip or "Apple Silicon").strip()
+    try:
+        ram_gb = int(mem.strip()) // (1024**3) if mem else 0
+    except ValueError:
+        ram_gb = 0
+    return chip_name, ram_gb
+
+
+def detect() -> HardwareProfile:
+    """Detect the current machine's hardware profile."""
+    os_name = platform.system()
+    arch = platform.machine()
+    cpu_cores = psutil.cpu_count(logical=False) or psutil.cpu_count() or 1
+    ram_gb = int(psutil.virtual_memory().total / (1024**3))
+    disk_free_gb = int(psutil.disk_usage(".").free / (1024**3))
+    cpu_model = _detect_cpu_model()
+
+    gpu_vendor: GpuVendor = "none"
+    gpu_name: str | None = None
+    vram_gb = 0
+    cuda_version: str | None = None
+
+    nv = _detect_nvidia()
+    if nv is not None:
+        gpu_vendor = "nvidia"
+        gpu_name, vram_gb, cuda_version = nv
+    else:
+        amd = _detect_amd()
+        if amd is not None:
+            gpu_vendor = "amd"
+            gpu_name, vram_gb = amd
+        else:
+            apple = _detect_apple()
+            if apple is not None:
+                gpu_vendor = "apple"
+                gpu_name, vram_gb = apple  # unified memory
+
+    return HardwareProfile(
+        os=os_name,
+        arch=arch,
+        cpu_model=cpu_model,
+        cpu_cores=cpu_cores,
+        ram_gb=ram_gb,
+        disk_free_gb=disk_free_gb,
+        gpu_vendor=gpu_vendor,
+        gpu_name=gpu_name,
+        vram_gb=vram_gb,
+        cuda_version=cuda_version,
+    )

perfectrag/mcp_registry.py

@@ -0,0 +1,101 @@
+"""Registry of well-known MCP servers + helper to splice them into a project's mcp.yaml.
+
+mcp.yaml format mirrors the Claude Code / Cursor / Claude Desktop MCP config so that
+configs are portable: each server has `command`, `args`, optional `env`, and transport.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+REGISTRY: dict[str, dict] = {
+    "filesystem": {
+        "description": "Đọc/ghi file trong thư mục được whitelist (read-only by default)",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-filesystem", "${PWD}/data"],
+        "env": [],
+    },
+    "fetch": {
+        "description": "Fetch URL và convert sang markdown cho LLM",
+        "command": "uvx",
+        "args": ["mcp-server-fetch"],
+        "env": [],
+    },
+    "tavily": {
+        "description": "Tavily web search (cần TAVILY_API_KEY)",
+        "command": "npx",
+        "args": ["-y", "mcp-tavily"],
+        "env": ["TAVILY_API_KEY"],
+    },
+    "brave-search": {
+        "description": "Brave web search (cần BRAVE_API_KEY)",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+        "env": ["BRAVE_API_KEY"],
+    },
+    "postgres": {
+        "description": "Query Postgres read-only (cần POSTGRES_URL)",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-postgres", "${POSTGRES_URL}"],
+        "env": ["POSTGRES_URL"],
+    },
+    "sqlite": {
+        "description": "Query SQLite database local",
+        "command": "uvx",
+        "args": ["mcp-server-sqlite", "--db-path", "${PWD}/data/app.db"],
+        "env": [],
+    },
+    "github": {
+        "description": "GitHub repos / issues / PRs (cần GITHUB_PERSONAL_ACCESS_TOKEN)",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-github"],
+        "env": ["GITHUB_PERSONAL_ACCESS_TOKEN"],
+    },
+    "memory": {
+        "description": "Persistent knowledge-graph memory cho agent",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-memory"],
+        "env": [],
+    },
+    "sequential-thinking": {
+        "description": "Chain-of-thought structured reasoning tool",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+        "env": [],
+    },
+    "qdrant": {
+        "description": "Qdrant vector-db MCP server (read/write vectors)",
+        "command": "uvx",
+        "args": ["mcp-server-qdrant", "--qdrant-url", "${QDRANT_URL:-http://localhost:6333}"],
+        "env": [],
+    },
+}
+
+
+def _mcp_path(project_dir: Path) -> Path:
+    return project_dir / "mcp.yaml"
+
+
+def _load(path: Path) -> dict:
+    if not path.exists():
+        return {"servers": {}}
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    data.setdefault("servers", {})
+    return data
+
+
+def add_mcp_to_project(name: str, project_dir: Path) -> None:
+    if name not in REGISTRY:
+        raise KeyError(f"Không biết MCP '{name}'. Chạy `perfectrag list mcp` để xem.")
+    info = REGISTRY[name]
+    path = _mcp_path(project_dir)
+    data = _load(path)
+    data["servers"][name] = {
+        "command": info["command"],
+        "args": info["args"],
+        **({"env": {k: f"${{{k}}}" for k in info["env"]}} if info["env"] else {}),
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")

perfectrag/recipes.py

@@ -0,0 +1,187 @@
+"""Decision matrix: (user answers + hardware) -> concrete techstack recipe.
+
+The mapping is opinionated but documented. Users can override any field in the
+wizard's final confirmation step.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from perfectrag.hardware import HardwareProfile
+
+UseCase = Literal["qa_docs", "graphrag", "multimodal", "code_rag", "agent_workflow"]
+Privacy = Literal["fully_local", "hybrid_api"]
+CorpusSize = Literal["small", "medium", "large"]  # <10k, 10k-1M, >1M
+UserScale = Literal["solo", "team", "production"]
+
+
+@dataclass(frozen=True)
+class Answers:
+    use_case: UseCase
+    modality: list[str]  # ["text", "tables", "images", "code"]
+    privacy: Privacy
+    multi_hop: bool
+    corpus_size: CorpusSize
+    user_scale: UserScale
+
+
+@dataclass
+class Recipe:
+    template: str
+    llm_model: str
+    llm_runtime: Literal["ollama", "vllm", "llamacpp"]
+    embedding_model: str
+    reranker: str | None
+    vector_db: Literal["qdrant", "milvus", "chroma", "lancedb", "pgvector"]
+    doc_parser: Literal["docling", "markitdown", "unstructured", "llamaparse"]
+    chunk_strategy: Literal["recursive", "semantic", "late"]
+    chunk_size: int
+    gpu_enabled: bool
+    vram_cap_gb: int
+    notes: list[str] = field(default_factory=list)
+    extras: dict = field(default_factory=dict)
+
+    def as_template_vars(self, hw: HardwareProfile, answers: Answers) -> dict:
+        """Flatten to vars Copier/Jinja can consume."""
+        return {
+            "recipe": {
+                "template": self.template,
+                "llm_model": self.llm_model,
+                "llm_runtime": self.llm_runtime,
+                "embedding_model": self.embedding_model,
+                "reranker": self.reranker,
+                "vector_db": self.vector_db,
+                "doc_parser": self.doc_parser,
+                "chunk_strategy": self.chunk_strategy,
+                "chunk_size": self.chunk_size,
+                "gpu_enabled": self.gpu_enabled,
+                "vram_cap_gb": self.vram_cap_gb,
+                "extras": self.extras,
+            },
+            "hw": hw.as_dict(),
+            "answers": {
+                "use_case": answers.use_case,
+                "modality": answers.modality,
+                "privacy": answers.privacy,
+                "multi_hop": answers.multi_hop,
+                "corpus_size": answers.corpus_size,
+                "user_scale": answers.user_scale,
+            },
+        }
+
+
+# --- Model tables by hardware tier ---
+
+_LLM_BY_TIER = {
+    "cpu":        ("qwen2.5:3b-instruct-q4_K_M",  "llamacpp"),
+    "apple-low":  ("qwen2.5:7b-instruct-q4_K_M",  "ollama"),
+    "apple-high": ("qwen2.5:14b-instruct-q4_K_M", "ollama"),
+    "gpu-8gb":    ("qwen2.5:7b-instruct-q5_K_M",  "ollama"),
+    "gpu-12gb":   ("qwen2.5:14b-instruct-q4_K_M", "ollama"),
+    "gpu-24gb":   ("qwen2.5:32b-instruct-q4_K_M", "vllm"),
+}
+
+_EMBED_BY_TIER = {
+    "cpu":        "nomic-embed-text",
+    "apple-low":  "BAAI/bge-m3",
+    "apple-high": "BAAI/bge-m3",
+    "gpu-8gb":    "BAAI/bge-m3",
+    "gpu-12gb":   "BAAI/bge-m3",
+    "gpu-24gb":   "BAAI/bge-m3",
+}
+
+_VECTORDB_BY_CORPUS = {
+    "small":  "chroma",
+    "medium": "qdrant",
+    "large":  "milvus",
+}
+
+_PARSER_BY_MODALITY = [
+    ({"images", "tables"}, "docling"),
+    ({"tables"},           "docling"),
+    ({"images"},           "docling"),
+    (set(),                "markitdown"),
+]
+
+
+def _pick_parser(modality: list[str]) -> str:
+    mod = set(modality)
+    for needed, parser in _PARSER_BY_MODALITY:
+        if needed and needed.issubset(mod):
+            return parser
+    return "markitdown"
+
+
+def _pick_template(answers: Answers, tier: str) -> tuple[str, list[str]]:
+    notes: list[str] = []
+
+    # Hard routing rules (in priority order)
+    if answers.use_case == "graphrag" or answers.multi_hop:
+        if tier in ("cpu", "apple-low"):
+            notes.append(
+                "GraphRAG yêu cầu LLM mạnh; hardware hiện tại có thể chạy chậm. "
+                "Cân nhắc upgrade hoặc giảm corpus."
+            )
+        return "lightrag-stack", notes
+
+    if answers.use_case == "agent_workflow":
+        return "dify-stack", notes
+
+    if answers.use_case == "multimodal":
+        if tier in ("cpu", "apple-low", "gpu-8gb"):
+            notes.append("Multimodal RAG cần VRAM cao; có thể giảm chất lượng hình ảnh.")
+        return "ragflow-stack", notes
+
+    if answers.use_case == "code_rag":
+        return "ragflow-stack", notes
+
+    # qa_docs default
+    if tier == "cpu":
+        return "custom-naive-rag", notes
+    return "ragflow-stack", notes
+
+
+def recommend(answers: Answers, hw: HardwareProfile) -> Recipe:
+    tier = hw.tier
+    llm_model, llm_runtime = _LLM_BY_TIER[tier]
+    embed = _EMBED_BY_TIER[tier]
+    vector_db = _VECTORDB_BY_CORPUS[answers.corpus_size]
+    parser = _pick_parser(answers.modality)
+    template, notes = _pick_template(answers, tier)
+
+    # Production scale → prefer vLLM if GPU has room
+    if answers.user_scale == "production" and tier in ("gpu-12gb", "gpu-24gb"):
+        llm_runtime = "vllm"
+
+    # Naive template uses smaller vector db / no reranker for simplicity
+    if template == "custom-naive-rag":
+        vector_db = "qdrant"  # bundled in template
+        reranker: str | None = None
+    else:
+        reranker = "jinaai/jina-reranker-v2-base-multilingual"
+
+    gpu_enabled = hw.gpu_vendor in ("nvidia", "amd", "apple")
+    vram_cap = hw.vram_gb if hw.gpu_vendor == "nvidia" else max(hw.ram_gb // 2, 4)
+
+    extras: dict = {
+        "enable_graphrag": answers.use_case == "graphrag" or answers.multi_hop,
+        "enable_hybrid_search": answers.use_case in ("qa_docs", "code_rag"),
+    }
+
+    return Recipe(
+        template=template,
+        llm_model=llm_model,
+        llm_runtime=llm_runtime,
+        embedding_model=embed,
+        reranker=reranker,
+        vector_db=vector_db,
+        doc_parser=parser,
+        chunk_strategy="recursive",
+        chunk_size=512,
+        gpu_enabled=gpu_enabled,
+        vram_cap_gb=vram_cap,
+        notes=notes,
+        extras=extras,
+    )