Code cleaning

scripts/e2e_test.py

@@ -98,12 +98,12 @@ def main() -> None:
         )
         reranker = Reranker(model=create_reranker(settings.reranker_model))
         classifier = IntentClassifier(llm=llm)
-        generator = llm | StrOutputParser()
+        llm_chain = llm | StrOutputParser()
         router = QueryRouter(
             intent_classifier=classifier,
             hybrid_retriever=hybrid,
             reranker=reranker,
-            generator=generator,
+            llm_chain=llm_chain,
         )
 
         # --- 5) Run query ---

scripts/evaluate.py

@@ -156,12 +156,12 @@ def main() -> None:
         )
         reranker = Reranker(model=create_reranker(settings.reranker_model))
         classifier = IntentClassifier(llm=llm, model_name=settings.generation_model)
-        generator = llm | StrOutputParser()
+        llm_chain = llm | StrOutputParser()
         router = QueryRouter(
             intent_classifier=classifier,
             hybrid_retriever=hybrid,
             reranker=reranker,
-            generator=generator,
+            llm_chain=llm_chain,
         )
 
         # --- 5) Run test set ---

src/agent/react_router.py

@@ -39,20 +39,6 @@ _SYSTEM_PROMPT = (
 )
 
 
-def _ser_sources(sources: list[QueryResult]) -> list[dict]:
-    """Serialise QueryResult list to a JSON-safe list of dicts."""
-    return [
-        {
-            "chunk_id": r.chunk.chunk_id,
-            "document_id": r.chunk.document_id,
-            "text": r.chunk.text,
-            "score": r.score,
-            "source": r.source,
-        }
-        for r in sources
-    ]
-
-
 class ReActRouter:
     """Routes queries through a multi-step ReAct agent with tool-calling LLM.
 
@@ -231,7 +217,7 @@ class ReActRouter:
             "step": "done",
             "result": {
                 "answer": answer,
-                "sources": _ser_sources(sources),
+                "sources": [r.to_dict() for r in sources],
                 "intent": (IntentType.RAG if sources else IntentType.FACTUAL).value,
                 "confidence": confidence,
                 "pipeline_details": {
@@ -239,10 +225,10 @@ class ReActRouter:
                     "retrieval_query": ", ".join(q for _, q in store.tool_calls) or query,
                     "detected_language": "unknown",
                     "translated": False,
-                    "dense_results": _ser_sources(store.dense_results),
-                    "sparse_results": _ser_sources(store.sparse_results),
-                    "fused_results": _ser_sources(store.fused_results),
-                    "reranked_results": _ser_sources(sources),
+                    "dense_results": [r.to_dict(include_text=False) for r in store.dense_results],
+                    "sparse_results": [r.to_dict(include_text=False) for r in store.sparse_results],
+                    "fused_results": [r.to_dict(include_text=False) for r in store.fused_results],
+                    "reranked_results": [r.to_dict(include_text=False) for r in sources],
                 },
             },
         }

src/agent/router.py

@@ -48,6 +48,32 @@ class RouterState(TypedDict):
     answer: str
 
 
+def _make_initial_state(query: str, top_k: int) -> RouterState:
+    """Create a fresh RouterState with sensible defaults.
+
+    Args:
+        query: The user's original query.
+        top_k: Number of results to retrieve.
+
+    Returns:
+        RouterState ready to be passed into the graph.
+    """
+    return RouterState(
+        query=query,
+        top_k=top_k,
+        user_language="Danish",
+        intent=IntentType.UNKNOWN,
+        retrieval_query=query,
+        translated=False,
+        dense_results=[],
+        sparse_results=[],
+        fused_results=[],
+        reranked=[],
+        confidence=0.0,
+        answer="",
+    )
+
+
 class QueryRouter:
     """Routes queries to appropriate retrieval and generation pipelines."""
 
@@ -56,7 +82,7 @@ class QueryRouter:
         intent_classifier: IntentClassifier,
         hybrid_retriever: HybridRetriever,
         reranker: Reranker,
-        generator: Runnable,
+        llm_chain: Runnable,
         *,
         translate_query: bool = True,
     ) -> None:
@@ -66,7 +92,8 @@ class QueryRouter:
             intent_classifier: IntentClassifier instance.
             hybrid_retriever: HybridRetriever instance.
             reranker: Reranker instance.
-            generator: LLM generation chain.
+            llm_chain: LLM chain (llm | StrOutputParser) for generation,
+                translation, and language detection.
             translate_query: Whether to translate non-Danish queries to Danish
                 before retrieval. When False, language detection still runs for
                 the answer-language rule but no translation is performed.
@@ -74,7 +101,7 @@ class QueryRouter:
         self._intent_classifier = intent_classifier
         self._hybrid_retriever = hybrid_retriever
         self._reranker = reranker
-        self._generator = generator
+        self._llm_chain = llm_chain
         self._translate_query_enabled = translate_query
         self._graph = self._build_graph()
 
@@ -155,7 +182,7 @@ class QueryRouter:
             "intent: <intent>\n\n"
             f"Query: {query}"
         )
-        raw = str(self._generator.invoke(prompt)).strip()
+        raw = str(self._llm_chain.invoke(prompt)).strip()
         logger.debug("Combined detection raw response: %s", raw)
 
         # Parse response
@@ -200,10 +227,77 @@ class QueryRouter:
             "Reply with ONLY the translated text, nothing else.\n\n"
             f"Text: {query}"
         )
-        translated = str(self._generator.invoke(translate_prompt)).strip()
+        translated = str(self._llm_chain.invoke(translate_prompt)).strip()
         logger.info("Translated query to Danish: %s", translated)
         return translated
 
+    # ------------------------------------------------------------------
+    # LangGraph node functions
+    # ------------------------------------------------------------------
+
+    def _detect_node(self, state: RouterState) -> dict:
+        """Detect language and classify intent."""
+        user_language, intent = self._detect_language_and_intent(state["query"])
+        return {"user_language": user_language, "intent": intent}
+
+    def _translate_node(self, state: RouterState) -> dict:
+        """Translate query to Danish if needed."""
+        retrieval_query = self._translate_query(state["query"], state["user_language"])
+        return {
+            "retrieval_query": retrieval_query,
+            "translated": retrieval_query != state["query"],
+        }
+
+    def _retrieve_node(self, state: RouterState) -> dict:
+        """Run hybrid search."""
+        hybrid_result = self._hybrid_retriever.search_detailed(
+            state["retrieval_query"], top_k=state["top_k"]
+        )
+        logger.info("Retrieved %d results from hybrid search", len(hybrid_result.fused_results))
+        return {
+            "dense_results": hybrid_result.dense_results,
+            "sparse_results": hybrid_result.sparse_results,
+            "fused_results": hybrid_result.fused_results,
+        }
+
+    def _rerank_node(self, state: RouterState) -> dict:
+        """Rerank fused results with cross-encoder."""
+        results = state.get("fused_results", [])
+        reranked = (
+            self._reranker.rerank(state["retrieval_query"], results, top_k=state["top_k"])
+            if results
+            else []
+        )
+        confidence = max(r.score for r in reranked) if reranked else 0.0
+        logger.info("Reranked to %d results", len(reranked))
+        if reranked:
+            logger.info("Confidence: %.4f (sigmoid-normalized by reranker)", confidence)
+        return {"reranked": reranked, "confidence": confidence}
+
+    @staticmethod
+    def _update_intent_node(state: RouterState) -> dict:
+        """Promote FACTUAL to RAG when sources are found."""
+        if state.get("reranked") and state["intent"] == IntentType.FACTUAL:
+            logger.info("Overriding intent to RAG (sources retrieved)")
+            return {"intent": IntentType.RAG}
+        return {}
+
+    def _generate_node(self, state: RouterState) -> dict:
+        """Build prompt and call LLM."""
+        reranked = state.get("reranked", [])
+        context = "\n\n".join(r.chunk.text for r in reranked)
+        prompt = self._build_prompt(
+            state["query"], state["intent"], context, state["user_language"]
+        )
+        answer = self._llm_chain.invoke(prompt)
+        logger.info("Generated answer for intent=%s", state["intent"].value)
+        return {"answer": str(answer)}
+
+    @staticmethod
+    def _should_retrieve(state: RouterState) -> str:
+        """Skip retrieval when intent is UNKNOWN."""
+        return "retrieve" if state["intent"] != IntentType.UNKNOWN else "rerank"
+
     def _build_graph(self) -> object:
         """Build the LangGraph routing graph.
 
@@ -218,75 +312,19 @@ class QueryRouter:
         Returns:
             Compiled LangGraph graph.
         """
-
-        def detect_node(state: RouterState) -> dict:
-            user_language, intent = self._detect_language_and_intent(state["query"])
-            return {"user_language": user_language, "intent": intent}
-
-        def translate_node(state: RouterState) -> dict:
-            retrieval_query = self._translate_query(state["query"], state["user_language"])
-            return {
-                "retrieval_query": retrieval_query,
-                "translated": retrieval_query != state["query"],
-            }
-
-        def retrieve_node(state: RouterState) -> dict:
-            hybrid_result = self._hybrid_retriever.search_detailed(
-                state["retrieval_query"], top_k=state["top_k"]
-            )
-            logger.info("Retrieved %d results from hybrid search", len(hybrid_result.fused_results))
-            return {
-                "dense_results": hybrid_result.dense_results,
-                "sparse_results": hybrid_result.sparse_results,
-                "fused_results": hybrid_result.fused_results,
-            }
-
-        def rerank_node(state: RouterState) -> dict:
-            results = state.get("fused_results", [])
-            reranked = (
-                self._reranker.rerank(state["retrieval_query"], results, top_k=state["top_k"])
-                if results
-                else []
-            )
-            confidence = max(r.score for r in reranked) if reranked else 0.0
-            logger.info("Reranked to %d results", len(reranked))
-            if reranked:
-                logger.info("Confidence: %.4f (sigmoid-normalized by reranker)", confidence)
-            return {"reranked": reranked, "confidence": confidence}
-
-        def update_intent_node(state: RouterState) -> dict:
-            if state.get("reranked") and state["intent"] == IntentType.FACTUAL:
-                logger.info("Overriding intent to RAG (sources retrieved)")
-                return {"intent": IntentType.RAG}
-            return {}
-
-        def generate_node(state: RouterState) -> dict:
-            reranked = state.get("reranked", [])
-            context = "\n\n".join(r.chunk.text for r in reranked)
-            prompt = self._build_prompt(
-                state["query"], state["intent"], context, state["user_language"]
-            )
-            answer = self._generator.invoke(prompt)
-            logger.info("Generated answer for intent=%s", state["intent"].value)
-            return {"answer": str(answer)}
-
-        def should_retrieve(state: RouterState) -> str:
-            """Skip retrieval when intent is UNKNOWN."""
-            return "retrieve" if state["intent"] != IntentType.UNKNOWN else "rerank"
-
         graph: StateGraph = StateGraph(RouterState)
-        graph.add_node("detect", detect_node)
-        graph.add_node("translate", translate_node)
-        graph.add_node("retrieve", retrieve_node)
-        graph.add_node("rerank", rerank_node)
-        graph.add_node("update_intent", update_intent_node)
-        graph.add_node("generate", generate_node)
+        graph.add_node("detect", self._detect_node)
+        graph.add_node("translate", self._translate_node)
+        graph.add_node("retrieve", self._retrieve_node)
+        graph.add_node("rerank", self._rerank_node)
+        graph.add_node("update_intent", self._update_intent_node)
+        graph.add_node("generate", self._generate_node)
 
         graph.set_entry_point("detect")
         graph.add_edge("detect", "translate")
         graph.add_conditional_edges(
             "translate",
-            should_retrieve,
+            self._should_retrieve,
             {"retrieve": "retrieve", "rerank": "rerank"},
         )
         graph.add_edge("retrieve", "rerank")
@@ -308,22 +346,7 @@ class QueryRouter:
         """
         logger.info("Routing query: %s", query)
 
-        initial_state: RouterState = {
-            "query": query,
-            "top_k": top_k,
-            "user_language": "Danish",
-            "intent": IntentType.UNKNOWN,
-            "retrieval_query": query,
-            "translated": False,
-            "dense_results": [],
-            "sparse_results": [],
-            "fused_results": [],
-            "reranked": [],
-            "confidence": 0.0,
-            "answer": "",
-        }
-
-        final_state: RouterState = self._graph.invoke(initial_state)
+        final_state: RouterState = self._graph.invoke(_make_initial_state(query, top_k))
 
         pipeline = PipelineDetails(
             original_query=query,
@@ -386,7 +409,7 @@ class QueryRouter:
         # context = "\n\n".join(r.chunk.text for r in reranked)
         # prompt = self._build_prompt(query, intent, context, user_language)
         #
-        # answer = self._generator.invoke(prompt)
+        # answer = self._llm_chain.invoke(prompt)
         # logger.info("Generated answer for intent=%s", intent.value)
         #
         # if reranked:
@@ -417,24 +440,9 @@ class QueryRouter:
         Yields:
             Step event dicts, then a final ``done`` event with the result.
         """
-        initial_state: RouterState = {
-            "query": query,
-            "top_k": top_k,
-            "user_language": "Danish",
-            "intent": IntentType.UNKNOWN,
-            "retrieval_query": query,
-            "translated": False,
-            "dense_results": [],
-            "sparse_results": [],
-            "fused_results": [],
-            "reranked": [],
-            "confidence": 0.0,
-            "answer": "",
-        }
-
-        accumulated: dict = dict(initial_state)
+        accumulated: dict = dict(_make_initial_state(query, top_k))
 
-        for chunk in self._graph.stream(initial_state, stream_mode="updates"):
+        for chunk in self._graph.stream(_make_initial_state(query, top_k), stream_mode="updates"):
             for node_name, update in chunk.items():
                 if update is None:
                     continue
@@ -453,24 +461,12 @@ class QueryRouter:
                 elif node_name == "rerank":
                     event["reranked_count"] = len(update.get("reranked", []))
                     event["confidence"] = round(update.get("confidence", 0.0), 4)
-                # update_intent and generate: no extra fields needed
 
                 yield event
 
         # Build the final response from accumulated state and emit as "done"
         reranked: list = accumulated.get("reranked", [])
 
-        def _ser(results: list) -> list[dict]:
-            return [
-                {
-                    "document_id": r.chunk.document_id,
-                    "chunk_id": r.chunk.chunk_id,
-                    "score": r.score,
-                    "source": r.source,
-                }
-                for r in results
-            ]
-
         pd_acc = PipelineDetails(
             original_query=query,
             retrieval_query=accumulated.get("retrieval_query", query),
@@ -486,16 +482,7 @@ class QueryRouter:
             "step": "done",
             "result": {
                 "answer": accumulated.get("answer", ""),
-                "sources": [
-                    {
-                        "chunk_id": r.chunk.chunk_id,
-                        "document_id": r.chunk.document_id,
-                        "text": r.chunk.text,
-                        "score": r.score,
-                        "source": r.source,
-                    }
-                    for r in reranked
-                ],
+                "sources": [r.to_dict() for r in reranked],
                 "intent": accumulated.get("intent", IntentType.UNKNOWN).value,
                 "confidence": accumulated.get("confidence", 0.0),
                 "pipeline_details": {
@@ -503,10 +490,10 @@ class QueryRouter:
                     "retrieval_query": pd_acc.retrieval_query,
                     "detected_language": pd_acc.detected_language,
                     "translated": pd_acc.translated,
-                    "dense_results": _ser(pd_acc.dense_results),
-                    "sparse_results": _ser(pd_acc.sparse_results),
-                    "fused_results": _ser(pd_acc.fused_results),
-                    "reranked_results": _ser(pd_acc.reranked_results),
+                    "dense_results": [r.to_dict(include_text=False) for r in pd_acc.dense_results],
+                    "sparse_results": [r.to_dict(include_text=False) for r in pd_acc.sparse_results],
+                    "fused_results": [r.to_dict(include_text=False) for r in pd_acc.fused_results],
+                    "reranked_results": [r.to_dict(include_text=False) for r in pd_acc.reranked_results],
                 },
             },
         }

src/agent/tools.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 
 from langchain_core.tools import tool
 
-from src.models import DocumentChunk, QueryResult
+from src.models import QueryResult
 from src.retrieval.hybrid import HybridRetriever
 from src.retrieval.reranker import Reranker
 from src.retrieval.vector_store import VectorStore

src/api/main.py

@@ -83,12 +83,12 @@ def create_app() -> FastAPI:
     else:
         logger.info("Agent mode: pipeline (fixed DAG)")
         intent_classifier = IntentClassifier(llm=llm, model_name=settings.generation_model)
-        generator = llm | StrOutputParser()
+        llm_chain = llm | StrOutputParser()
         query_router = QueryRouter(
             intent_classifier=intent_classifier,
             hybrid_retriever=hybrid_retriever,
             reranker=reranker,
-            generator=generator,
+            llm_chain=llm_chain,
             translate_query=settings.translate_query,
         )
 
@@ -113,9 +113,18 @@ def create_app() -> FastAPI:
 
 
 def _parse_strategy(settings: "Settings") -> "ChunkStrategy":  # noqa: F821
-    """Return the default chunking strategy from config."""
+    """Return the chunking strategy from config, defaulting to SEMANTIC.
+
+    Reads the CHUNK_STRATEGY environment variable via settings. Falls back
+    to SEMANTIC when the variable is unset or empty.
+    """
     from src.models import ChunkStrategy
-    return ChunkStrategy.SEMANTIC
+
+    raw = getattr(settings, "chunk_strategy", "semantic")
+    try:
+        return ChunkStrategy(raw)
+    except ValueError:
+        return ChunkStrategy.SEMANTIC
 
 
 app: FastAPI = create_app()

src/api/routes.py

@@ -183,27 +183,7 @@ async def query_documents(request: QueryRequest) -> QueryResponse:
             ) from exc
         raise
 
-    sources = [
-        {
-            "chunk_id": result.chunk.chunk_id,
-            "document_id": result.chunk.document_id,
-            "text": result.chunk.text,
-            "score": result.score,
-            "source": result.source,
-        }
-        for result in response.sources
-    ]
-
-    def _to_pipeline_items(results: list) -> list[PipelineResultItem]:
-        return [
-            PipelineResultItem(
-                document_id=r.chunk.document_id,
-                chunk_id=r.chunk.chunk_id,
-                score=r.score,
-                source=r.source,
-            )
-            for r in results
-        ]
+    sources = [result.to_dict() for result in response.sources]
 
     pd = response.pipeline_details
     pipeline_details = PipelineDetailsResponse(
@@ -211,10 +191,10 @@ async def query_documents(request: QueryRequest) -> QueryResponse:
         retrieval_query=pd.retrieval_query,
         detected_language=pd.detected_language,
         translated=pd.translated,
-        dense_results=_to_pipeline_items(pd.dense_results),
-        sparse_results=_to_pipeline_items(pd.sparse_results),
-        fused_results=_to_pipeline_items(pd.fused_results),
-        reranked_results=_to_pipeline_items(pd.reranked_results),
+        dense_results=[PipelineResultItem(**r.to_dict(include_text=False)) for r in pd.dense_results],
+        sparse_results=[PipelineResultItem(**r.to_dict(include_text=False)) for r in pd.sparse_results],
+        fused_results=[PipelineResultItem(**r.to_dict(include_text=False)) for r in pd.fused_results],
+        reranked_results=[PipelineResultItem(**r.to_dict(include_text=False)) for r in pd.reranked_results],
     )
 
     return QueryResponse(

src/config.py

@@ -26,6 +26,7 @@ class Settings:
     embedding_dimension: int
     generation_model: str
     reranker_model: str
+    chunk_strategy: str
     chunk_size: int
     chunk_overlap: int
     top_k: int
@@ -106,6 +107,7 @@ def load_settings() -> Settings:
         embedding_dimension=int(os.environ.get("EMBEDDING_DIMENSION", "384")),
         generation_model=os.environ.get("GENERATION_MODEL", "gemma4:e4b"),
         reranker_model=os.environ.get("RERANKER_MODEL", "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"),
+        chunk_strategy=os.environ.get("CHUNK_STRATEGY", "semantic"),
         chunk_size=int(os.environ.get("CHUNK_SIZE", "512")),
         chunk_overlap=int(os.environ.get("CHUNK_OVERLAP", "64")),
         top_k=int(os.environ.get("TOP_K", "5")),

src/models.py

@@ -56,6 +56,26 @@ class QueryResult:
     score: float
     source: str
 
+    def to_dict(self, *, include_text: bool = True) -> dict[str, str | float]:
+        """Serialise to a JSON-safe dictionary.
+
+        Args:
+            include_text: Whether to include the chunk text (default True).
+
+        Returns:
+            Dictionary with chunk_id, document_id, score, source, and
+            optionally text.
+        """
+        d: dict[str, str | float] = {
+            "chunk_id": self.chunk.chunk_id,
+            "document_id": self.chunk.document_id,
+            "score": self.score,
+            "source": self.source,
+        }
+        if include_text:
+            d["text"] = self.chunk.text
+        return d
+
 
 @dataclass
 class PipelineDetails:

src/retrieval/bm25_search.py

@@ -1,12 +1,7 @@
 """BM25 sparse retrieval using rank_bm25."""
 
 import logging
-from typing import Any
 
-from langchain_core.callbacks import CallbackManagerForRetrieverRun
-from langchain_core.documents import Document
-from langchain_core.retrievers import BaseRetriever
-from pydantic import ConfigDict
 from rank_bm25 import BM25Okapi
 
 from src.models import DocumentChunk, QueryResult
@@ -64,17 +59,6 @@ class BM25Search:
         logger.debug("BM25 search returned %d results for query: %s", len(results), query)
         return results
 
-    def as_retriever(self, top_k: int) -> BaseRetriever:
-        """Return a LangChain BaseRetriever wrapping this BM25 index.
-
-        Args:
-            top_k: Number of results to return per query.
-
-        Returns:
-            A BaseRetriever that calls search() and returns Documents.
-        """
-        return _BM25RetrieverAdapter(bm25_search=self, top_k=top_k)
-
     @staticmethod
     def _tokenize(text: str) -> list[str]:
         """Tokenize text by lowercasing and splitting on whitespace.
@@ -86,30 +70,3 @@ class BM25Search:
             List of lowercase tokens.
         """
         return text.lower().split()
-
-
-class _BM25RetrieverAdapter(BaseRetriever):
-    """LangChain BaseRetriever adapter over BM25Search."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    bm25_search: Any
-    top_k: int
-
-    def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> list[Document]:
-        results = self.bm25_search.search(query, self.top_k)
-        return [
-            Document(
-                page_content=r.chunk.text,
-                metadata={
-                    "chunk_id": r.chunk.chunk_id,
-                    "document_id": r.chunk.document_id,
-                    "chunk_metadata": r.chunk.metadata,
-                    "strategy": r.chunk.strategy.value,
-                    "score": r.score,
-                },
-            )
-            for r in results
-        ]

src/retrieval/hybrid.py

@@ -3,9 +3,7 @@
 import logging
 from dataclasses import dataclass
 
-from langchain_core.documents import Document
-
-from src.models import ChunkStrategy, DocumentChunk, QueryResult
+from src.models import DocumentChunk, QueryResult
 from src.retrieval.bm25_search import BM25Search
 from src.retrieval.embedder import Embedder
 from src.retrieval.vector_store import VectorStore
@@ -70,8 +68,6 @@ class HybridRetriever:
     def search_detailed(self, query: str, top_k: int) -> HybridSearchResult:
         """Execute hybrid search and return all intermediate results.
 
-        Uses LangChain BaseRetriever.invoke() for both dense and sparse retrieval.
-
         Args:
             query: The search query string.
             top_k: Number of top results to return after fusion.
@@ -79,14 +75,9 @@ class HybridRetriever:
         Returns:
             HybridSearchResult containing dense, sparse, and fused results.
         """
-        dense_retriever = self._vector_store.as_retriever(self._embedder, top_k)
-        sparse_retriever = self._bm25_search.as_retriever(top_k)
-
-        dense_docs: list[Document] = dense_retriever.invoke(query)
-        sparse_docs: list[Document] = sparse_retriever.invoke(query)
-
-        dense_results = [self._doc_to_query_result(doc, "dense") for doc in dense_docs]
-        sparse_results = [self._doc_to_query_result(doc, "bm25") for doc in sparse_docs]
+        query_embedding = self._embedder.embed_text(query)
+        dense_results = self._vector_store.search(query_embedding, top_k)
+        sparse_results = self._bm25_search.search(query, top_k)
 
         logger.debug(
             "Hybrid search: %d dense, %d sparse results",
@@ -101,27 +92,6 @@ class HybridRetriever:
             fused_results=fused[:top_k],
         )
 
-    @staticmethod
-    def _doc_to_query_result(doc: Document, source: str) -> QueryResult:
-        """Convert a LangChain Document to a QueryResult.
-
-        Args:
-            doc: Document returned by a BaseRetriever.
-            source: Retrieval source label (e.g. 'dense' or 'bm25').
-
-        Returns:
-            QueryResult with chunk and score populated from document metadata.
-        """
-        meta = doc.metadata
-        chunk = DocumentChunk(
-            chunk_id=meta.get("chunk_id", ""),
-            document_id=meta.get("document_id", ""),
-            text=doc.page_content,
-            metadata=meta.get("chunk_metadata", {}),
-            strategy=ChunkStrategy(meta.get("strategy", ChunkStrategy.RECURSIVE.value)),
-        )
-        return QueryResult(chunk=chunk, score=float(meta.get("score", 0.0)), source=source)
-
     def reciprocal_rank_fusion(
         self,
         dense_results: list[QueryResult],
@@ -138,9 +108,8 @@ class HybridRetriever:
         Returns:
             Merged and re-ranked list of QueryResult objects.
         """
-        # Map chunk_id -> (rrf_score, best QueryResult)
         scores: dict[str, float] = {}
-        best_chunk: dict[str, QueryResult] = {}
+        best_chunk: dict[str, DocumentChunk] = {}
 
         for rank, result in enumerate(dense_results):
             cid = result.chunk.chunk_id

src/retrieval/vector_store.py

@@ -2,12 +2,7 @@
 
 import json
 import logging
-from typing import Any
 
-from langchain_core.callbacks import CallbackManagerForRetrieverRun
-from langchain_core.documents import Document
-from langchain_core.retrievers import BaseRetriever
-from pydantic import ConfigDict
 from qdrant_client import QdrantClient
 from qdrant_client.models import Distance, FieldCondition, Filter, MatchValue, PointStruct, VectorParams
 
@@ -16,6 +11,24 @@ from src.models import ChunkStrategy, DocumentChunk, QueryResult
 logger = logging.getLogger(__name__)
 
 
+def _payload_to_chunk(payload: dict) -> DocumentChunk:
+    """Convert a Qdrant payload dict to a DocumentChunk.
+
+    Args:
+        payload: Qdrant point payload.
+
+    Returns:
+        DocumentChunk reconstructed from the payload.
+    """
+    return DocumentChunk(
+        chunk_id=payload["chunk_id"],
+        document_id=payload["document_id"],
+        text=payload["text"],
+        metadata=json.loads(payload["metadata"]),
+        strategy=ChunkStrategy(payload["strategy"]),
+    )
+
+
 class VectorStore:
     """Manages document storage and dense retrieval via Qdrant."""
 
@@ -96,18 +109,10 @@ class VectorStore:
             limit=top_k,
         ).points
 
-        results: list[QueryResult] = []
-        for hit in hits:
-            payload = hit.payload
-            chunk = DocumentChunk(
-                chunk_id=payload["chunk_id"],
-                document_id=payload["document_id"],
-                text=payload["text"],
-                metadata=json.loads(payload["metadata"]),
-                strategy=ChunkStrategy(payload["strategy"]),
-            )
-            results.append(QueryResult(chunk=chunk, score=hit.score, source="dense"))
-
+        results: list[QueryResult] = [
+            QueryResult(chunk=_payload_to_chunk(hit.payload), score=hit.score, source="dense")
+            for hit in hits
+        ]
         logger.debug("Dense search returned %d results", len(results))
         return results
 
@@ -129,18 +134,7 @@ class VectorStore:
             with_vectors=False,
         )
 
-        chunks: list[DocumentChunk] = []
-        for record in records:
-            payload = record.payload
-            chunks.append(
-                DocumentChunk(
-                    chunk_id=payload["chunk_id"],
-                    document_id=payload["document_id"],
-                    text=payload["text"],
-                    metadata=json.loads(payload["metadata"]),
-                    strategy=ChunkStrategy(payload["strategy"]),
-                )
-            )
+        chunks = [_payload_to_chunk(record.payload) for record in records]
         logger.info("Loaded %d chunks from collection '%s'", len(chunks), self._collection_name)
         return chunks
 
@@ -176,67 +170,13 @@ class VectorStore:
             with_vectors=False,
         )
 
-        chunks: list[DocumentChunk] = []
-        for record in records:
-            payload = record.payload
-            chunks.append(
-                DocumentChunk(
-                    chunk_id=payload["chunk_id"],
-                    document_id=payload["document_id"],
-                    text=payload["text"],
-                    metadata=json.loads(payload["metadata"]),
-                    strategy=ChunkStrategy(payload["strategy"]),
-                )
-            )
+        chunks = [_payload_to_chunk(record.payload) for record in records]
         logger.debug(
             "Fetched %d chunks for document '%s'", len(chunks), document_id
         )
         return chunks
 
-    def as_retriever(self, embedder: Any, top_k: int) -> BaseRetriever:
-        """Return a LangChain BaseRetriever wrapping this vector store.
-
-        Args:
-            embedder: Embedder instance used to encode queries.
-            top_k: Number of results to return per query.
-
-        Returns:
-            A BaseRetriever that calls search() and returns Documents.
-        """
-        return _VectorStoreRetrieverAdapter(
-            vector_store=self, embedder=embedder, top_k=top_k
-        )
-
     def delete_collection(self) -> None:
         """Delete the entire collection from the store."""
         self._client.delete_collection(collection_name=self._collection_name)
         logger.info("Deleted Qdrant collection '%s'", self._collection_name)
-
-
-class _VectorStoreRetrieverAdapter(BaseRetriever):
-    """LangChain BaseRetriever adapter over VectorStore."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    vector_store: Any
-    embedder: Any
-    top_k: int
-
-    def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> list[Document]:
-        query_embedding = self.embedder.embed_text(query)
-        results = self.vector_store.search(query_embedding, self.top_k)
-        return [
-            Document(
-                page_content=r.chunk.text,
-                metadata={
-                    "chunk_id": r.chunk.chunk_id,
-                    "document_id": r.chunk.document_id,
-                    "chunk_metadata": r.chunk.metadata,
-                    "strategy": r.chunk.strategy.value,
-                    "score": r.score,
-                },
-            )
-            for r in results
-        ]

tests/test_hybrid.py

@@ -4,8 +4,6 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from langchain_core.documents import Document
-
 from src.models import ChunkStrategy, DocumentChunk, QueryResult
 from src.retrieval.hybrid import HybridRetriever
 
@@ -16,20 +14,6 @@ def _make_result(chunk_id: str, score: float = 0.0, source: str = "test") -> Que
     return QueryResult(chunk=chunk, score=score, source=source)
 
 
-def _result_to_doc(result: QueryResult) -> Document:
-    """Convert a QueryResult to a LangChain Document (mirrors the adapter output)."""
-    return Document(
-        page_content=result.chunk.text,
-        metadata={
-            "chunk_id": result.chunk.chunk_id,
-            "document_id": result.chunk.document_id,
-            "chunk_metadata": result.chunk.metadata,
-            "strategy": result.chunk.strategy.value,
-            "score": result.score,
-        },
-    )
-
-
 def _build_retriever(
     dense_results: list[QueryResult],
     sparse_results: list[QueryResult],
@@ -38,22 +22,17 @@ def _build_retriever(
 ) -> HybridRetriever:
     """Build a HybridRetriever with mocked dependencies.
 
-    Mocks as_retriever().invoke() since HybridRetriever now uses the
-    LangChain BaseRetriever interface instead of .search() directly.
+    Mocks vector_store.search() and bm25_search.search() since
+    HybridRetriever calls them directly.
     """
-    dense_retriever_mock = MagicMock()
-    dense_retriever_mock.invoke.return_value = [_result_to_doc(r) for r in dense_results]
-
     vector_store = MagicMock()
-    vector_store.as_retriever.return_value = dense_retriever_mock
-
-    sparse_retriever_mock = MagicMock()
-    sparse_retriever_mock.invoke.return_value = [_result_to_doc(r) for r in sparse_results]
+    vector_store.search.return_value = dense_results
 
     bm25_search = MagicMock()
-    bm25_search.as_retriever.return_value = sparse_retriever_mock
+    bm25_search.search.return_value = sparse_results
 
     embedder = MagicMock()
+    embedder.embed_text.return_value = [0.0] * 384
 
     return HybridRetriever(
         vector_store=vector_store,

tests/test_router.py

@@ -35,36 +35,36 @@ def _make_hybrid_result(results: list[QueryResult]) -> MagicMock:
 
 @pytest.fixture
 def mock_components():
-    """Create mock intent classifier, retriever, reranker, and generator."""
+    """Create mock intent classifier, retriever, reranker, and llm_chain."""
     classifier = MagicMock()
     retriever = MagicMock()
     reranker = MagicMock()
-    generator = MagicMock()
-    return classifier, retriever, reranker, generator
+    llm_chain = MagicMock()
+    return classifier, retriever, reranker, llm_chain
 
 
-def _setup_generator_danish(
-    generator: MagicMock, final_answer: str, intent: str = "factual"
+def _setup_llm_chain_danish(
+    llm_chain: MagicMock, final_answer: str, intent: str = "factual"
 ) -> None:
-    """Configure generator mock for Danish queries (no translation needed).
+    """Configure llm_chain mock for Danish queries (no translation needed).
 
     The first invoke returns the combined language+intent response,
     the second invoke returns the final answer.
     """
     combined = f"language: Danish\nintent: {intent}"
-    generator.invoke.side_effect = [combined, final_answer]
+    llm_chain.invoke.side_effect = [combined, final_answer]
 
 
-def _setup_generator_english(
-    generator: MagicMock, translated_query: str, final_answer: str, intent: str = "rag"
+def _setup_llm_chain_english(
+    llm_chain: MagicMock, translated_query: str, final_answer: str, intent: str = "rag"
 ) -> None:
-    """Configure generator mock for English queries (combined detection + translation + answer).
+    """Configure llm_chain mock for English queries (combined detection + translation + answer).
 
     The first invoke returns combined language+intent, the second returns the
     translated query, and the third returns the final answer.
     """
     combined = f"language: English\nintent: {intent}"
-    generator.invoke.side_effect = [combined, translated_query, final_answer]
+    llm_chain.invoke.side_effect = [combined, translated_query, final_answer]
 
 
 class TestQueryRouterRAG:
@@ -80,14 +80,14 @@ class TestQueryRouterRAG:
         self, mock_components, intent_str: str, expected_intent: IntentType
     ) -> None:
         """RAG intents should retrieve, rerank, and generate an answer."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("policy text", 0.85)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_danish(generator, "Generated answer", intent=intent_str)
+        _setup_llm_chain_danish(llm_chain, "Generated answer", intent=intent_str)
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         response = router.route("Hvad er KU's feriepolitik?", top_k=3)
 
         assert isinstance(response, GenerationResponse)
@@ -104,35 +104,35 @@ class TestQueryRouterRAG:
         )
 
     def test_prompt_contains_context_and_query(self, mock_components) -> None:
-        """The prompt sent to the generator should include context and query."""
-        classifier, retriever, reranker, generator = mock_components
+        """The prompt sent to the LLM chain should include context and query."""
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("Relevant context text", 0.9)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_danish(generator, "answer", intent="factual")
+        _setup_llm_chain_danish(llm_chain, "answer", intent="factual")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         router.route("test query", top_k=3)
 
         # The final invoke call is the generation call
-        prompt = generator.invoke.call_args_list[-1][0][0]
+        prompt = llm_chain.invoke.call_args_list[-1][0][0]
         assert "Relevant context text" in prompt
         assert "test query" in prompt
 
     def test_prompt_contains_language_rule(self, mock_components) -> None:
         """The prompt should contain a language instruction matching user language."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("ctx", 0.5)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_english(generator, "oversæt forespørgsel", "answer", intent="rag")
+        _setup_llm_chain_english(llm_chain, "oversæt forespørgsel", "answer", intent="rag")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         router.route("What is KU's vacation policy?", top_k=3)
 
-        prompt = generator.invoke.call_args_list[-1][0][0]
+        prompt = llm_chain.invoke.call_args_list[-1][0][0]
         assert "MUST answer in English" in prompt
 
 
@@ -141,12 +141,12 @@ class TestQueryRouterDirect:
 
     def test_unknown_intent_still_generates_answer(self, mock_components) -> None:
         """UNKNOWN intent skips retrieval and returns zero confidence."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         reranker.rerank.return_value = []
-        _setup_generator_danish(generator, "Fallback answer", intent="unknown")
+        _setup_llm_chain_danish(llm_chain, "Fallback answer", intent="unknown")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         response = router.route("Hej, hvad kan du hjælpe med?", top_k=3)
 
         assert response.answer == "Fallback answer"
@@ -158,15 +158,15 @@ class TestQueryRouterDirect:
         self, mock_components
     ) -> None:
         """UNKNOWN intent should use the generic helpful instruction."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         reranker.rerank.return_value = []
-        _setup_generator_danish(generator, "answer", intent="unknown")
+        _setup_llm_chain_danish(llm_chain, "answer", intent="unknown")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         router.route("random input", top_k=3)
 
-        prompt = generator.invoke.call_args_list[-1][0][0]
+        prompt = llm_chain.invoke.call_args_list[-1][0][0]
         assert "as helpfully as possible" in prompt
 
 
@@ -177,38 +177,38 @@ class TestQueryRouterFallback:
         self, mock_components
     ) -> None:
         """When reranker returns no results, confidence should be 0.0."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         retriever.search_detailed.return_value = _make_hybrid_result([])
         reranker.rerank.return_value = []
-        _setup_generator_danish(generator, "No information found", intent="factual")
+        _setup_llm_chain_danish(llm_chain, "No information found", intent="factual")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         response = router.route("asdfghjkl", top_k=3)
 
         assert response.confidence == 0.0
         assert response.sources == []
         assert response.answer == "No information found"
 
-    def test_empty_context_passed_to_generator(self, mock_components) -> None:
+    def test_empty_context_passed_to_llm_chain(self, mock_components) -> None:
         """When no chunks are retrieved, the prompt context should be empty."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         retriever.search_detailed.return_value = _make_hybrid_result([])
         reranker.rerank.return_value = []
-        _setup_generator_danish(generator, "answer", intent="factual")
+        _setup_llm_chain_danish(llm_chain, "answer", intent="factual")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         router.route("gibberish", top_k=3)
 
-        prompt = generator.invoke.call_args_list[-1][0][0]
+        prompt = llm_chain.invoke.call_args_list[-1][0][0]
         assert "Context:\n\n" in prompt
 
     def test_multiple_results_confidence_uses_max_score(
         self, mock_components
     ) -> None:
         """Confidence should be the maximum score among reranked results."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [
             _make_query_result("low", 0.3),
@@ -217,9 +217,9 @@ class TestQueryRouterFallback:
         ]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_danish(generator, "summary", intent="summary")
+        _setup_llm_chain_danish(llm_chain, "summary", intent="summary")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         response = router.route("opsummer politikken", top_k=5)
 
         assert response.confidence == pytest.approx(0.95, abs=1e-6)
@@ -230,53 +230,53 @@ class TestQueryTranslation:
 
     def test_danish_query_not_translated(self, mock_components) -> None:
         """Danish queries should be passed directly to retrieval without translation."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("ctx", 0.5)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_danish(generator, "svar", intent="rag")
+        _setup_llm_chain_danish(llm_chain, "svar", intent="rag")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         router.route("Hvad er reglerne?", top_k=3)
 
         # Only 2 invoke calls: combined detection + generation (no translation)
-        assert generator.invoke.call_count == 2
+        assert llm_chain.invoke.call_count == 2
         retriever.search_detailed.assert_called_once_with("Hvad er reglerne?", top_k=3)
 
     def test_english_query_translated_for_retrieval(self, mock_components) -> None:
         """English queries should be translated to Danish for retrieval."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("ctx", 0.5)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_english(generator, "Hvad er reglerne?", "The rules are...", intent="rag")
+        _setup_llm_chain_english(llm_chain, "Hvad er reglerne?", "The rules are...", intent="rag")
 
-        router = QueryRouter(classifier, retriever, reranker, generator, translate_query=True)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain, translate_query=True)
         response = router.route("What are the rules?", top_k=3)
 
         # 3 invoke calls: combined detection + translation + generation
-        assert generator.invoke.call_count == 3
+        assert llm_chain.invoke.call_count == 3
         retriever.search_detailed.assert_called_once_with("Hvad er reglerne?", top_k=3)
         reranker.rerank.assert_called_once_with("Hvad er reglerne?", results, top_k=3)
         assert response.answer == "The rules are..."
 
     def test_translation_disabled_skips_translate(self, mock_components) -> None:
         """When translate_query=False, English queries go straight to retrieval untranslated."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [_make_query_result("ctx", 0.5)]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
         # Only 2 calls: combined detection + generation (no translation)
         combined = "language: English\nintent: rag"
-        generator.invoke.side_effect = [combined, "The answer"]
+        llm_chain.invoke.side_effect = [combined, "The answer"]
 
-        router = QueryRouter(classifier, retriever, reranker, generator, translate_query=False)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain, translate_query=False)
         response = router.route("What are the rules?", top_k=3)
 
-        assert generator.invoke.call_count == 2
+        assert llm_chain.invoke.call_count == 2
         retriever.search_detailed.assert_called_once_with("What are the rules?", top_k=3)
         assert response.answer == "The answer"
 
@@ -286,7 +286,7 @@ class TestSigmoidInReranker:
 
     def test_confidence_equals_max_reranked_score(self, mock_components) -> None:
         """Confidence should equal the max reranked score (already sigmoid-normalized)."""
-        classifier, retriever, reranker, generator = mock_components
+        classifier, retriever, reranker, llm_chain = mock_components
 
         results = [
             _make_query_result("a", 0.7),
@@ -294,9 +294,9 @@ class TestSigmoidInReranker:
         ]
         retriever.search_detailed.return_value = _make_hybrid_result(results)
         reranker.rerank.return_value = results
-        _setup_generator_danish(generator, "answer", intent="rag")
+        _setup_llm_chain_danish(llm_chain, "answer", intent="rag")
 
-        router = QueryRouter(classifier, retriever, reranker, generator)
+        router = QueryRouter(classifier, retriever, reranker, llm_chain)
         response = router.route("test", top_k=3)
 
         assert response.confidence == pytest.approx(0.9, abs=1e-6)