Upload folder using huggingface_hub

rag_system/api.py

@@ -20,12 +20,12 @@ from .document_processor import process_texts, process_file
 from .vector_store import (
     add_documents, load_or_create_store, is_loaded,
     list_collections, get_collection_stats, delete_collection,
-    cleanup_stale_collections,
+    cleanup_stale_collections, get_collection_embedding_mode,
 )
 from .query_engine import query as run_query, stream_query, pipeline_stream_query
 from .eval import evaluate
 from .cache import cache_connected, get_cache_stats
-from .embeddings import get_embeddings
+from .embeddings import get_embeddings, get_embeddings_runtime_info
 from .guardrails import _load_llama_guard
 from .retriever import _reranker
 
@@ -202,6 +202,11 @@ async def cache_stats():
     return get_cache_stats()
 
 
+@app.get("/embeddings/info", tags=["ops"])
+async def embeddings_info():
+    return get_embeddings_runtime_info()
+
+
 # ── Ingest ────────────────────────────────────────────────────────────────────
 
 @app.post("/ingest", response_model=IngestResponse, tags=["ingest"])
@@ -213,7 +218,12 @@ async def ingest_texts(req: IngestRequest):
             metadatas=req.metadatas,
             source_id=req.collection_name,
         )
-        add_documents(docs, collection=req.collection_name, force_reindex=req.force_reindex)
+        add_documents(
+            docs,
+            collection=req.collection_name,
+            force_reindex=req.force_reindex,
+            embedding_mode=req.embedding_mode,
+        )
         return IngestResponse(
             success=True,
             docs_indexed=len(docs),
@@ -229,6 +239,7 @@ async def ingest_texts(req: IngestRequest):
 async def ingest_file(
     file: UploadFile = File(...),
     collection_name: str = "default",
+    embedding_mode: str | None = None,
     background_tasks: BackgroundTasks = None,
 ):
     """
@@ -254,6 +265,7 @@ async def ingest_file(
         "status": "processing",
         "collection_name": doc_collection,
         "filename": file.filename,
+        "embedding_mode": embedding_mode,
         "chunks_created": 0,
         "message": "File received, extracting text...",
         "progress": 5,
@@ -267,7 +279,7 @@ async def ingest_file(
 
             _ingest_jobs[job_id]["progress"] = 60
             _ingest_jobs[job_id]["message"] = f"Embedding and indexing {len(docs)} chunks..."
-            add_documents(docs, collection=doc_collection)
+            add_documents(docs, collection=doc_collection, embedding_mode=embedding_mode)
             _viz_cache.pop(doc_collection, None)  # invalidate stale viz
 
             _ingest_jobs[job_id]["progress"] = 100
@@ -463,7 +475,8 @@ async def get_query_similarity(collection_name: str, body: dict = Body(...)):
 
     import numpy as np
 
-    q_vec = np.array(get_embeddings().embed_query(query), dtype=np.float32).reshape(1, -1)
+    embedding_mode = get_collection_embedding_mode(collection_name)
+    q_vec = np.array(get_embeddings(embedding_mode).embed_query(query), dtype=np.float32).reshape(1, -1)
     q_2d = result["pca"].transform(q_vec)[0]
 
     vectors = result["vectors"]

rag_system/cache.py

@@ -63,20 +63,20 @@ def _build_redis_client():
 _cache_client = _build_redis_client()
 
 # Exact match cache
-def _cache_key(query: str, collection: str, mode: str) -> str:
-    payload = f"{query}::{collection}::{mode}"
+def _cache_key(query: str, collection: str, mode: str, embedding_mode: str) -> str:
+    payload = f"{query}::{collection}::{mode}::{embedding_mode}"
     return "rag:exact:" + hashlib.sha256(payload.encode()).hexdigest()[:32]
 
-def get_exact(query: str, collection: str, mode: str) -> Optional[dict]:
-    key = _cache_key(query, collection, mode)
+def get_exact(query: str, collection: str, mode: str, embedding_mode: str) -> Optional[dict]:
+    key = _cache_key(query, collection, mode, embedding_mode)
     raw = _cache_client.get(key)
     if raw:
         logger.debug(f"Exact cache hit: {key[:16]}...")
         return json.loads(raw)
     return None
 
-def set_exact(query: str, collection: str, mode: str, value: str) -> None:
-    key = _cache_key(query,collection,mode)
+def set_exact(query: str, collection: str, mode: str, embedding_mode: str, value: str) -> None:
+    key = _cache_key(query, collection, mode, embedding_mode)
     serialized = json.dumps(value)
     if hasattr(_cache_client,"setex"):
         _cache_client.setex(key,settings.cache_ttl_seconds,serialized)
@@ -85,13 +85,14 @@ def set_exact(query: str, collection: str, mode: str, value: str) -> None:
 
 # Semantic Cache
 # stores (embedding, serialized_response) pairs keyed by short hash
-_semantic_index: list[tuple[list[float],str,dict]] = [] # (vec,key,response)
+_semantic_index: dict[str, list[tuple[list[float],str,dict]]] = {} # mode -> (vec,key,response)
 
-def get_semantic(query_vec: list[float]) -> Optional[dict]:
+def get_semantic(query_vec: list[float], embedding_mode: str) -> Optional[dict]:
     """Return the cache response if cosine similarity > threshold"""
+    pool = _semantic_index.get(embedding_mode, [])
     best_score = 0.0
     best_response = None
-    for vec, _,response in _semantic_index:
+    for vec, _,response in pool:
         score = cosine_similarity(query_vec,vec)
         if score > best_score:
             best_score = score
@@ -101,11 +102,12 @@ def get_semantic(query_vec: list[float]) -> Optional[dict]:
         return best_response
     return None
 
-def set_semantic(query_vec: list[float], query: str, response: dict) -> None:
+def set_semantic(query_vec: list[float], query: str, response: dict, embedding_mode: str) -> None:
     h = hashlib.md5(query.encode()).hexdigest()[:8]
-    _semantic_index.append((query_vec, h, response))
-    if len(_semantic_index) > 5000: # cap memory
-        _semantic_index.pop(0)
+    pool = _semantic_index.setdefault(embedding_mode, [])
+    pool.append((query_vec, h, response))
+    if len(pool) > 5000: # cap memory
+        pool.pop(0)
 
 def cache_connected() -> bool:
     try:
@@ -125,7 +127,7 @@ def get_cache_stats() -> dict:
         except:
             stats["exact_matches_cached"] = "unknown"
             
-    stats["semantic_matches_cached"] = len(_semantic_index)
+    stats["semantic_matches_cached"] = sum(len(v) for v in _semantic_index.values())
     return stats
 
 print("[cache] Module ready")

rag_system/config.py

@@ -14,6 +14,8 @@ class Settings(BaseSettings):
     embedding_dimensions: int = 1024
     embedding_model_cpu: str = "BAAI/bge-small-en-v1.5"
     embedding_dimensions_cpu: int = 384
+    embedding_model_openai: str = "text-embedding-3-small"
+    embedding_dimensions_openai: int = 1536
     embedding_device: str = "auto"
     embedding_batch_size: int = 32
     embedding_normalize: bool = True
@@ -81,5 +83,6 @@ print(
     "[Config] Loaded. Model: "
     f"{settings.chat_model}, Embedding GPU: {settings.embedding_model} ({settings.embedding_dimensions}), "
     f"Embedding CPU: {settings.embedding_model_cpu} ({settings.embedding_dimensions_cpu}), "
+    f"Embedding OpenAI: {settings.embedding_model_openai} ({settings.embedding_dimensions_openai}), "
     f"Device: {settings.embedding_device}"
 )

rag_system/embeddings.py

@@ -1,21 +1,21 @@
 """
-Local embedding model with GPU/CPU auto selection.
-- GPU: BAAI/bge-large-en-v1.5 (1024-dim output)
-- CPU fallback: BAAI/bge-small-en-v1.5 (384-dim output)
-- Runs fully local via sentence-transformers — zero API calls, zero cost
-- BGE requires a special query prefix: 'Represent this sentence for searching'
-    (documents are embedded as-is; only queries get the prefix)
-- LangChain's HuggingFaceEmbeddings handles the prefix automatically
+Local + API embedding models with GPU/CPU aware defaults.
+- BGE-large (1024-dim) for GPU
+- BGE-small (384-dim) for fast local CPU
+- OpenAI text-embedding-3-small (1536-dim) for fast CPU via API
+- BGE requires a special query prefix for queries only
 """
 
 import asyncio
 import logging
 import warnings
 from concurrent.futures import ThreadPoolExecutor
-from functools import lru_cache
+from typing import Any
 
 import numpy as np
 from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_openai import OpenAIEmbeddings
+from langchain_core.embeddings import Embeddings
 from pydantic.warnings import UnsupportedFieldAttributeWarning
 
 from .config import get_settings
@@ -31,6 +31,10 @@ warnings.filterwarnings("ignore", category=UnsupportedFieldAttributeWarning)
 
 _executor = ThreadPoolExecutor(max_workers=2)
 
+EMBEDDING_MODES: tuple[str, ...] = ("bge-large", "bge-small", "openai-small")
+_EMBEDDING_CACHE: dict[str, Embeddings] = {}
+
+
 def _resolve_device() -> str:
     device = (settings.embedding_device or "auto").lower()
     if device == "auto":
@@ -55,31 +59,84 @@ def _resolve_device() -> str:
     return device
 
 
-def _select_embedding_config() -> tuple[str, int, str]:
-    device = _resolve_device()
-    if device == "cpu":
-        model_name = settings.embedding_model_cpu or settings.embedding_model
-        dimensions = settings.embedding_dimensions_cpu or settings.embedding_dimensions
-    else:
-        model_name = settings.embedding_model
-        dimensions = settings.embedding_dimensions
+def get_default_embedding_mode() -> str:
+    return "bge-large" if _resolve_device() == "cuda" else "openai-small"
+
+
+def normalize_embedding_mode(mode: str | None) -> str:
+    if mode is None or mode == "auto":
+        return get_default_embedding_mode()
+    if mode not in EMBEDDING_MODES:
+        raise ValueError(f"Unknown embedding mode: {mode}")
+    return mode
+
+
+def infer_embedding_mode_from_dim(dim: int) -> str | None:
+    dim_map = {
+        int(settings.embedding_dimensions): "bge-large",
+        int(settings.embedding_dimensions_cpu): "bge-small",
+        int(settings.embedding_dimensions_openai): "openai-small",
+    }
+    return dim_map.get(int(dim))
+
+
+def _embedding_spec(mode: str) -> dict[str, Any]:
+    if mode == "bge-large":
+        return {
+            "provider": "local",
+            "model_name": settings.embedding_model,
+            "dimensions": settings.embedding_dimensions,
+            "device": _resolve_device(),
+        }
+    if mode == "bge-small":
+        return {
+            "provider": "local",
+            "model_name": settings.embedding_model_cpu,
+            "dimensions": settings.embedding_dimensions_cpu,
+            "device": _resolve_device(),
+        }
+    return {
+        "provider": "openai",
+        "model_name": settings.embedding_model_openai,
+        "dimensions": settings.embedding_dimensions_openai,
+        "device": "api",
+    }
 
-    return model_name, dimensions, device
 
+def get_embedding_info(mode: str | None = None) -> dict[str, str | int]:
+    resolved = normalize_embedding_mode(mode)
+    spec = _embedding_spec(resolved)
+    return {
+        "mode": resolved,
+        "provider": spec["provider"],
+        "model_name": spec["model_name"],
+        "dimensions": int(spec["dimensions"]),
+        "device": spec["device"],
+    }
 
-def get_embedding_info() -> dict[str, str | int]:
-    model_name, dimensions, device = _select_embedding_config()
+
+def get_embeddings_runtime_info() -> dict[str, Any]:
+    default_mode = get_default_embedding_mode()
+    options = []
+    for mode in EMBEDDING_MODES:
+        info = get_embedding_info(mode)
+        options.append({
+            "id": mode,
+            "model_name": info["model_name"],
+            "dimensions": info["dimensions"],
+            "provider": info["provider"],
+            "recommended": mode == default_mode,
+        })
     return {
-        "model_name": model_name,
-        "dimensions": dimensions,
-        "device": device,
+        "default_mode": default_mode,
+        "device": _resolve_device(),
+        "options": options,
     }
 
 
-@lru_cache(maxsize=1)
-def get_embeddings() -> HuggingFaceEmbeddings:
+def get_embeddings(mode: str | None = None) -> Embeddings:
     """
-    Singleton embedding model
+    Singleton embedding model per mode.
 
     encode_kwargs:
         normalize_embeddings=True -> required for cosine similarity to work correctly
@@ -88,23 +145,36 @@ def get_embeddings() -> HuggingFaceEmbeddings:
         BGE was finetuned with an instruction-like query prefix.
         We pass that prefix for query encoding only; documents remain unchanged.
     """
-    model_name, dimensions, device = _select_embedding_config()
-
-    logger.info(f"Loading embedding model: {model_name} on {device}")
-    model = HuggingFaceEmbeddings(
-        model_name=model_name,
-        model_kwargs={
-            "device": device,
-        },
-        encode_kwargs={
-            "normalize_embeddings": settings.embedding_normalize,
-            "batch_size": settings.embedding_batch_size,
-        },
-        query_encode_kwargs={
-            "prompt": "Represent this sentence for searching relevant passages: ",
-        },
-    )
-    logger.info(f"Embedding model loaded. Output dim={dimensions}")
+    resolved = normalize_embedding_mode(mode)
+    cached = _EMBEDDING_CACHE.get(resolved)
+    if cached is not None:
+        return cached
+
+    spec = _embedding_spec(resolved)
+    logger.info("Loading embedding model: %s on %s", spec["model_name"], spec["device"])
+    if spec["provider"] == "openai":
+        model = OpenAIEmbeddings(
+            model=spec["model_name"],
+            dimensions=int(spec["dimensions"]),
+            openai_api_key=settings.openai_api_key,
+        )
+    else:
+        model = HuggingFaceEmbeddings(
+            model_name=spec["model_name"],
+            model_kwargs={
+                "device": spec["device"],
+            },
+            encode_kwargs={
+                "normalize_embeddings": settings.embedding_normalize,
+                "batch_size": settings.embedding_batch_size,
+            },
+            query_encode_kwargs={
+                "prompt": "Represent this sentence for searching relevant passages: ",
+            },
+        )
+
+    logger.info("Embedding model loaded. Output dim=%s", spec["dimensions"])
+    _EMBEDDING_CACHE[resolved] = model
     return model
 
 #Async wrappers
@@ -113,9 +183,10 @@ def get_embeddings() -> HuggingFaceEmbeddings:
 
 async def embed_texts(
     texts: list[str],
-    batch_size: int = None
+    batch_size: int = None,
+    embedding_mode: str | None = None,
 ) -> list[list[float]]:
-    model = get_embeddings()
+    model = get_embeddings(embedding_mode)
     bs = batch_size or settings.embedding_batch_size
     loop = asyncio.get_event_loop()
 
@@ -132,8 +203,8 @@ async def embed_texts(
         logger.debug(f"Embedded batch {i}–{i + len(batch)} ({len(batch)} docs)")
     return all_embeddings
 
-async def embed_query(text: str) -> list[float]:
-    model = get_embeddings()
+async def embed_query(text: str, embedding_mode: str | None = None) -> list[float]:
+    model = get_embeddings(embedding_mode)
     loop = asyncio.get_event_loop()
     vec = await loop.run_in_executor(
         _executor,

rag_system/models.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field, field_validator
-from typing import Optional, Any
+from typing import Optional, Any, Literal
 from enum import Enum
 import uuid
 
@@ -9,6 +9,8 @@ class RetrievalMode(str, Enum):
     HYBRID = "hybrid"
     MMR = "mmr"
 
+EmbeddingMode = Literal["bge-large", "bge-small", "openai-small", "auto"]
+
 # Ingestion 
 
 class IngestRequest(BaseModel):
@@ -16,6 +18,7 @@ class IngestRequest(BaseModel):
     metadatas: Optional[list[dict[str,Any]]] =  None
     collection_name: str = Field(default="default",pattern=r"^[a-z0-9_-]+$")
     force_reindex: bool = False
+    embedding_mode: Optional[EmbeddingMode] = None
 
     @field_validator("texts")
     @classmethod
@@ -42,6 +45,7 @@ class QueryRequest(BaseModel):
     session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     collection_name: str = Field(default="default")
     retrieval_mode: RetrievalMode = RetrievalMode.HYBRID
+    embedding_mode: Optional[EmbeddingMode] = None
     top_k: Optional[int] = None
     doc_collections: Optional[list[str]] = None  # per-doc sub-collections; None = legacy single-collection mode
     history: list[ChatMessage] = Field(default_factory=list)

rag_system/query_engine.py

@@ -20,6 +20,7 @@ from .config import get_settings
 from .prompt import SYSTEM_PROMPT, QUERY_REWRITE_PROMPT, MULTI_DOC_SYSTEM_PROMPT
 from .models import QueryRequest, QueryResponse, SourceDocument
 from .retriever import retrieve, detect_query_scope, multi_collection_retrieve
+from .vector_store import resolve_embedding_mode_for_collections
 from .memory import resolve_standalone_question,trim_history_to_budget, build_lc_messages
 from .guardrails import check_query, check_context, redact_pii
 from .cache import get_exact,set_exact,get_semantic,set_semantic
@@ -167,6 +168,9 @@ async def query(
 ) -> QueryResponse:
     start = time.monotonic()
 
+    collections = request.doc_collections or [request.collection_name]
+    embedding_mode = resolve_embedding_mode_for_collections(collections, request.embedding_mode)
+
     # 1. Input guardrail
     guard = check_query(request.query)
     if not guard.allowed:
@@ -179,7 +183,7 @@ async def query(
     
     # 2. Exact cache check
     if settings.cache_enabled:
-        cached = get_exact(request.query, request.collection_name, request.retrieval_mode)
+        cached = get_exact(request.query, request.collection_name, request.retrieval_mode, embedding_mode)
         if cached:
             logger.info(f"Exact cache hit for query: '{request.query}'")
             cached["cached"] = True
@@ -187,9 +191,9 @@ async def query(
             return QueryResponse(**cached)
     
     # 3. Embed query for semantic cache + later retrieval
-    query_vec = await embed_query(request.query)
+    query_vec = await embed_query(request.query, embedding_mode)
     if settings.cache_enabled:
-        semantic_hit = get_semantic(query_vec)
+        semantic_hit = get_semantic(query_vec, embedding_mode)
         if semantic_hit:
             logger.info(f"Semantic cache hit for query: '{request.query}'")
             semantic_hit["cached"] = True
@@ -211,7 +215,6 @@ async def query(
         retrieval_query = await rewrite_query(standalone)
     
     # 6. Retrieve — multi-doc aware
-    collections = request.doc_collections or [request.collection_name]
     if len(collections) > 1:
         scoped = detect_query_scope(retrieval_query, collections)
         k_per = max(3, (request.top_k or settings.top_k_rerank) // len(scoped))
@@ -293,8 +296,8 @@ async def query(
     # 9. Cache the result
     if settings.cache_enabled:
         result_dict = result.model_dump()
-        set_exact(request.query, request.collection_name, request.retrieval_mode, result_dict)
-        set_semantic(query_vec,request.query, result_dict)
+        set_exact(request.query, request.collection_name, request.retrieval_mode, embedding_mode, result_dict)
+        set_semantic(query_vec, request.query, result_dict, embedding_mode)
 
     return result
 
@@ -332,11 +335,14 @@ async def pipeline_stream_query(request: QueryRequest) -> AsyncIterator[str]:
 
     start = time.monotonic()
     mode_val = request.retrieval_mode.value if hasattr(request.retrieval_mode, "value") else str(request.retrieval_mode)
+    collections = request.doc_collections or [request.collection_name]
+    embedding_mode = resolve_embedding_mode_for_collections(collections, request.embedding_mode)
 
     yield emit("pipeline_start", "in_progress", {
         "query": request.query,
         "collection": request.collection_name,
         "mode": mode_val,
+        "embedding_mode": embedding_mode,
     })
 
     try:
@@ -356,7 +362,7 @@ async def pipeline_stream_query(request: QueryRequest) -> AsyncIterator[str]:
         # --- Cache check ---
         query_vec = None
         if settings.cache_enabled:
-            cached = get_exact(request.query, request.collection_name, request.retrieval_mode)
+            cached = get_exact(request.query, request.collection_name, request.retrieval_mode, embedding_mode)
             if cached:
                 cached["cached"] = True
                 cached["latency_ms"] = round((time.monotonic() - start) * 1000, 2)
@@ -365,8 +371,8 @@ async def pipeline_stream_query(request: QueryRequest) -> AsyncIterator[str]:
                 yield "data: [DONE]\n\n"
                 return
 
-            query_vec = await embed_query(request.query)
-            semantic_hit = get_semantic(query_vec)
+            query_vec = await embed_query(request.query, embedding_mode)
+            semantic_hit = get_semantic(query_vec, embedding_mode)
             if semantic_hit:
                 semantic_hit["cached"] = True
                 semantic_hit["latency_ms"] = round((time.monotonic() - start) * 1000, 2)
@@ -398,7 +404,6 @@ async def pipeline_stream_query(request: QueryRequest) -> AsyncIterator[str]:
             })
 
         # --- Document routing (multi-doc) ---
-        collections = request.doc_collections or [request.collection_name]
         if len(collections) > 1:
             scoped = detect_query_scope(retrieval_query, collections)
             is_multi = len(scoped) > 1
@@ -515,9 +520,9 @@ async def pipeline_stream_query(request: QueryRequest) -> AsyncIterator[str]:
                     "eval_scores": None,
                 }
                 if query_vec is None:
-                    query_vec = await embed_query(request.query)
-                set_exact(request.query, request.collection_name, request.retrieval_mode, result_dict)
-                set_semantic(query_vec, request.query, result_dict)
+                    query_vec = await embed_query(request.query, embedding_mode)
+                set_exact(request.query, request.collection_name, request.retrieval_mode, embedding_mode, result_dict)
+                set_semantic(query_vec, request.query, result_dict, embedding_mode)
             except Exception:
                 logger.warning("Cache write failed (non-fatal)", exc_info=True)
 

rag_system/vector_store.py

@@ -1,4 +1,5 @@
 #faiss index management
+import json
 import logging
 import time
 import os
@@ -10,7 +11,13 @@ from langchain_core.documents import Document
 from langchain_community.vectorstores import FAISS
 
 from .config import get_settings
-from .embeddings import get_embeddings, get_embedding_info
+from .embeddings import (
+    get_embeddings,
+    get_embedding_info,
+    get_default_embedding_mode,
+    infer_embedding_mode_from_dim,
+    normalize_embedding_mode,
+)
 
 logger = logging.getLogger(__name__)
 settings = get_settings()
@@ -18,6 +25,76 @@ settings = get_settings()
 _stores: dict[str, FAISS] = {}
 # Tracks last-used timestamp per collection (epoch seconds) for TTL-based cleanup
 _last_used: dict[str, float] = {}
+_collection_embeddings: dict[str, str] = {}
+
+_EMBEDDING_META_FILE = "embedding.json"
+
+
+def _embedding_meta_path(collection: str) -> Path:
+    return Path(_index_path(collection)) / _EMBEDDING_META_FILE
+
+
+def _read_embedding_meta(collection: str) -> dict | None:
+    meta_path = _embedding_meta_path(collection)
+    if not meta_path.exists():
+        return None
+    try:
+        return json.loads(meta_path.read_text(encoding="utf-8"))
+    except Exception:
+        logger.warning("Failed to read embedding metadata for '%s'", collection)
+        return None
+
+
+def _write_embedding_meta(collection: str, info: dict) -> None:
+    meta_path = _embedding_meta_path(collection)
+    meta_path.parent.mkdir(parents=True, exist_ok=True)
+    meta_path.write_text(json.dumps(info, indent=2), encoding="utf-8")
+
+
+def get_collection_embedding_mode(collection: str) -> Optional[str]:
+    if collection in _collection_embeddings:
+        return _collection_embeddings[collection]
+
+    meta = _read_embedding_meta(collection)
+    if meta and isinstance(meta, dict):
+        mode = meta.get("mode") or meta.get("embedding_mode")
+        if isinstance(mode, str):
+            _collection_embeddings[collection] = mode
+            return mode
+    return None
+
+
+def resolve_embedding_mode_for_collections(
+    collections: list[str],
+    requested_mode: Optional[str] = None,
+) -> str:
+    requested = None
+    if requested_mode and requested_mode != "auto":
+        requested = normalize_embedding_mode(requested_mode)
+
+    modes = []
+    for coll in collections:
+        mode = get_collection_embedding_mode(coll)
+        if mode:
+            modes.append(mode)
+
+    if requested and modes and any(m != requested for m in modes):
+        logger.warning(
+            "Embedding mode mismatch (requested=%s, existing=%s). Using existing.",
+            requested,
+            sorted(set(modes)),
+        )
+        return modes[0]
+
+    if requested:
+        return requested
+
+    if modes:
+        if any(m != modes[0] for m in modes):
+            logger.warning("Multiple embedding modes across collections: %s", sorted(set(modes)))
+        return modes[0]
+
+    return get_default_embedding_mode()
 
 def _index_path(collection: str) -> str:
     return str(Path(settings.faiss_index_path)/ collection)
@@ -33,7 +110,8 @@ def load_or_create_store(collection: str = "default") -> FAISS:
         return _stores[collection]
 
     path = _index_path(collection)
-    embeddings = get_embeddings()
+    embedding_mode = resolve_embedding_mode_for_collections([collection])
+    embeddings = get_embeddings(embedding_mode)
 
     if Path(path).exists():
         logger.info(f"Loading FAISS index from {path}")
@@ -42,7 +120,19 @@ def load_or_create_store(collection: str = "default") -> FAISS:
             embeddings,
             allow_dangerous_deserialization=True,
         )
-        expected_dim = int(get_embedding_info()["dimensions"])
+        expected_dim = int(get_embedding_info(embedding_mode)["dimensions"])
+        if store.index.d != expected_dim:
+            inferred_mode = infer_embedding_mode_from_dim(store.index.d)
+            if inferred_mode and inferred_mode != embedding_mode:
+                embeddings = get_embeddings(inferred_mode)
+                store = FAISS.load_local(
+                    path,
+                    embeddings,
+                    allow_dangerous_deserialization=True,
+                )
+                embedding_mode = inferred_mode
+                expected_dim = int(get_embedding_info(embedding_mode)["dimensions"])
+
         if store.index.d != expected_dim:
             logger.error(
                 "Embedding dim mismatch for collection '%s': index dim=%s, expected=%s. "
@@ -54,6 +144,8 @@ def load_or_create_store(collection: str = "default") -> FAISS:
             _stores[collection] = None
         else:
             _stores[collection] = store
+            _collection_embeddings[collection] = embedding_mode
+            _write_embedding_meta(collection, get_embedding_info(embedding_mode))
     else:
         logger.warning(f"No index at {path}. Will create on first Ingest.")
         _stores[collection] = None
@@ -65,7 +157,8 @@ def load_or_create_store(collection: str = "default") -> FAISS:
 def add_documents(
     docs: list[Document],
     collection: str = "default",
-    force_reindex: bool = False
+    force_reindex: bool = False,
+    embedding_mode: Optional[str] = None,
 ) -> FAISS:
     """
     Adding docs to a FAISS collection.
@@ -73,7 +166,15 @@ def add_documents(
     - Persists to disk after every write
     """
 
-    embeddings = get_embeddings()
+    existing_mode = get_collection_embedding_mode(collection)
+    selected_mode = resolve_embedding_mode_for_collections([collection], embedding_mode)
+    if existing_mode and existing_mode != selected_mode and not force_reindex:
+        raise ValueError(
+            f"Embedding mode mismatch for '{collection}': existing={existing_mode}, requested={selected_mode}. "
+            "Use force_reindex to rebuild."
+        )
+
+    embeddings = get_embeddings(selected_mode)
     path = _index_path(collection)
 
     existing = None if force_reindex else _stores.get(collection)
@@ -93,6 +194,8 @@ def add_documents(
     store.save_local(path)
     _stores[collection] = store
     _last_used[collection] = time.time()
+    _collection_embeddings[collection] = selected_mode
+    _write_embedding_meta(collection, get_embedding_info(selected_mode))
     
     # Prebuild BM25 index on ingest
     from .retriever import _bm25_cache, _get_bm25
@@ -137,6 +240,9 @@ def get_collection_stats(collection: str) -> dict:
     store = load_or_create_store(collection)
     path = _index_path(collection)
 
+    embedding_mode = get_collection_embedding_mode(collection)
+    embedding_info = get_embedding_info(embedding_mode) if embedding_mode else None
+
     chunk_count = 0
     if store is not None and hasattr(store, "index"):
         chunk_count = store.index.ntotal
@@ -155,6 +261,9 @@ def get_collection_stats(collection: str) -> dict:
         "size_mb": size_mb,
         "loaded": store is not None,
         "index_path": path,
+        "embedding_mode": embedding_mode,
+        "embedding_dimensions": embedding_info["dimensions"] if embedding_info else None,
+        "embedding_provider": embedding_info["provider"] if embedding_info else None,
     }
 
 
@@ -179,6 +288,8 @@ def delete_collection(collection: str) -> bool:
     path = _index_path(collection)
     if collection in _stores:
         del _stores[collection]
+    if collection in _collection_embeddings:
+        del _collection_embeddings[collection]
 
     # Local import to avoid circular dependency with retriever
     from .retriever import _bm25_cache