aiagents4pharma 1.40.1__py3-none-any.whl → 1.41.0__py3-none-any.whl

aiagents4pharma/talk2scholars/configs/agents/talk2scholars/s2_agent/default.yaml

@@ -3,3 +3,7 @@ s2_agent: |
   You are the S2 Agent.
 
   You are responsible for searching academic papers, getting recommendations based on the searched articles, and displaying the results.
+
+  IMPORTANT INSTRUCTION FOR AGENT BEHAVIOR:
+  If the user's request involves extracting paper IDs to download papers, your task is only to extract those IDs using the `query_dataframe`. Do not attempt to download the paper yourself or call any other tools after extracting the IDs.
+  Once the IDs are successfully extracted, immediately pause execution and return control to the main agent. The main agent is responsible for invoking the appropriate tool or sub-agent to handle the paper download.

aiagents4pharma/talk2scholars/configs/tools/question_and_answer/default.yaml

@@ -1,17 +1,45 @@
-# Default configuration for the PDF question_and_answer Tool
+# Configuration for the PDF question_and_answer Tool - Traditional RAG Pipeline with GPU Support
+
+# Milvus vector database settings
+milvus:
+  # Connection settings
+  host: ${oc.env:MILVUS_HOST,localhost} # Changed default from 127.0.0.1 to localhost
+  port: ${oc.env:MILVUS_PORT,19530}
+
+  # Database and collection settings
+  db_name: ${oc.env:MILVUS_DB_NAME,pdf_rag_db}
+  collection_name: ${oc.env:MILVUS_COLLECTION_NAME,pdf_rag_documents}
+
+  # Ensure collection persists across restarts
+  consistency_level: "Strong"
+  embedding_dim: 768
+
+# Document processing settings
 chunk_size: 1200 # Number of characters per text chunk
 chunk_overlap: 200 # Overlap between adjacent chunks
-top_k_papers: 5 # Number of papers to rank and retrieve
-top_k_chunks: 25 # Number of chunks to retrieve
+
+# Parallel processing settings
+embedding_batch_size: 1500 # Number of chunks to embed in a single API call
+max_parallel_pdfs: 10 # Maximum number of PDFs to process in parallel
+
+# Traditional RAG Pipeline Settings
+# Step 1: Initial retrieval (cast wide net)
+initial_retrieval_k: 100 # Number of chunks to retrieve before reranking
+mmr_diversity: 0.8 # MMR diversity parameter (0=max diversity, 1=max relevance)
+
+# Step 2: Reranking settings
+top_k_chunks: 25 # Final number of chunks after reranking
 reranker:
   model: "nvidia/nv-rerankqa-mistral-4b-v3"
   api_key: ${oc.env:NVIDIA_API_KEY}
+
+# Answer generation settings
 prompt_template: |
   You are a scientific research assistant specialized in reading and extracting information from research papers.
   Your role is to answer questions by retrieving relevant information from the provided context.
 
   - Provide detailed, structured, and well-argued explanations—not just brief summaries.
-  - Cite specific sources using onky the title of the paper.
+  - Cite specific sources using only the title of the paper.
   - If the context is insufficient, clearly state that more information is needed.
 
   Context:
@@ -20,3 +48,15 @@ prompt_template: |
   Question: {question}
 
   Your answer should be comprehensive, accurate, and clearly structured for a scientific audience.
+
+# GPU Detection and Performance Settings
+gpu_detection:
+  # Timeout for GPU detection command (seconds)
+  detection_timeout: 10
+
+  # Log GPU detection results
+  log_detection: true
+
+  # Force CPU mode even if GPU is detected (for testing CPU Milvus)
+  # Uncomment the line below to force CPU mode:
+  # force_cpu_mode: true

aiagents4pharma/talk2scholars/tests/test_nvidia_nim_reranker.py

@@ -0,0 +1,127 @@
+"""
+Unit tests for NVIDIA NIM reranker error handling in nvidia_nim_reranker.py
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from langchain_core.documents import Document
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils import nvidia_nim_reranker
+from aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker import (
+    rerank_chunks,
+)
+
+
+@pytest.fixture(name="chunks_fixture")
+def fixture_chunks():
+    """chunks_fixture fixture to simulate PDF chunks."""
+    return [
+        Document(
+            page_content=f"chunk {i}",
+            metadata={"paper_id": f"P{i%2}", "relevance_score": 0.9 - 0.01 * i},
+        )
+        for i in range(10)
+    ]
+
+
+def test_rerank_chunks_short_input(chunks_fixture):
+    """rerank_chunks with fewer chunks than top_k should return original."""
+    result = rerank_chunks(
+        chunks_fixture[:3], "What is cancer?", config=MagicMock(), top_k=5
+    )
+    assert result == chunks_fixture[:3]
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.logger")
+def test_rerank_chunks_missing_api_key_logs_and_raises(mock_logger, chunks_fixture):
+    """
+    If config.reranker.api_key is None:
+      - logger.error(...) should be called
+      - rerank_chunks should raise ValueError
+    """
+    mock_config = MagicMock()
+    mock_config.reranker.api_key = None
+
+    with pytest.raises(
+        ValueError,
+        match="Configuration 'reranker.api_key' must be set for reranking",
+    ):
+        rerank_chunks(chunks_fixture, "What is cancer?", config=mock_config, top_k=5)
+
+    mock_logger.error.assert_called_once_with(
+        "No NVIDIA API key found in configuration for reranking"
+    )
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.NVIDIARerank")
+def test_rerank_chunks_success(mock_reranker_cls, chunks_fixture):
+    """rerank_chunks with successful reranking."""
+    reranker_instance = MagicMock()
+    reranker_instance.compress_documents.return_value = list(reversed(chunks_fixture))
+    mock_reranker_cls.return_value = reranker_instance
+
+    mock_config = MagicMock()
+    mock_config.reranker.api_key = "test_key"
+    mock_config.reranker.model = "test_model"
+
+    result = rerank_chunks(
+        chunks_fixture, "Explain mitochondria.", config=mock_config, top_k=5
+    )
+
+    assert isinstance(result, list)
+    assert result == list(reversed(chunks_fixture))[:5]
+    reranker_instance.compress_documents.assert_called_once_with(
+        query="Explain mitochondria.", documents=chunks_fixture
+    )
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.NVIDIARerank")
+def test_rerank_chunks_reranker_fails_raises_and_calls_compress(
+    mock_reranker_cls, chunks_fixture
+):
+    """
+    If NVIDIARerank.compress_documents raises RuntimeError:
+      - rerank_chunks should propagate the RuntimeError
+      - and compress_documents should have been called
+    """
+    reranker_instance = MagicMock()
+    reranker_instance.compress_documents.side_effect = RuntimeError("API failure")
+    mock_reranker_cls.return_value = reranker_instance
+
+    mock_config = MagicMock()
+    mock_config.reranker.api_key = "valid_key"
+    mock_config.reranker.model = "reranker"
+
+    with pytest.raises(RuntimeError, match="API failure"):
+        rerank_chunks(
+            chunks_fixture, "How does light affect plants?", config=mock_config, top_k=3
+        )
+
+    reranker_instance.compress_documents.assert_called_once_with(
+        query="How does light affect plants?", documents=chunks_fixture
+    )
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.logger")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.NVIDIARerank")
+def test_rerank_chunks_debug_block_triggered(
+    mock_reranker_cls, mock_logger, chunks_fixture
+):
+    """rerank_chunks should log debug info if debug logging is enabled."""
+    mock_logger.isEnabledFor.return_value = True
+
+    reranker_instance = MagicMock()
+    reranker_instance.compress_documents.return_value = chunks_fixture
+    mock_reranker_cls.return_value = reranker_instance
+
+    mock_config = MagicMock()
+    mock_config.reranker.api_key = "abc"
+    mock_config.reranker.model = "mymodel"
+
+    result = nvidia_nim_reranker.rerank_chunks(
+        chunks_fixture * 2, "Test query", mock_config, top_k=3
+    )
+
+    assert result == chunks_fixture[:3]
+    assert mock_logger.debug.called

aiagents4pharma/talk2scholars/tests/test_pdf_answer_formatter.py

@@ -0,0 +1,66 @@
+"""answer_formatter tests."""
+
+from unittest.mock import patch
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.answer_formatter import format_answer
+
+
+@pytest.fixture(name="base_args")
+def _base_args():
+    """base_args fixture to provide common arguments for tests."""
+    return {
+        "question": "What is the conclusion?",
+        "chunks": [{"content": "chunk1"}, {"content": "chunk2"}],
+        "llm": "mock_llm",
+        "articles": {
+            "paper1": {"Title": "Paper One"},
+            "paper2": {"Title": "Paper Two"},
+        },
+        "config": {"key": "value"},
+        "call_id": "test_call_123",
+        "has_gpu": True,
+    }
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.answer_formatter.generate_answer")
+def test_format_answer_with_sources(mock_generate_answer, base_args):
+    """test format_answer with sources."""
+    mock_generate_answer.return_value = {
+        "output_text": "This is the generated answer.",
+        "papers_used": ["paper1", "paper2"],
+    }
+
+    result = format_answer(**base_args)
+
+    assert "This is the generated answer." in result
+    assert "Sources:" in result
+    assert "- Paper One" in result
+    assert "- Paper Two" in result
+    mock_generate_answer.assert_called_once()
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.answer_formatter.generate_answer")
+def test_format_answer_no_sources(mock_generate_answer, base_args):
+    """test format_answer with no sources."""
+    mock_generate_answer.return_value = {
+        "output_text": "No sources were used.",
+        "papers_used": [],  # No papers used
+    }
+
+    result = format_answer(**base_args)
+
+    assert result == "No sources were used."  # No sources section expected
+    mock_generate_answer.assert_called_once()
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.answer_formatter.generate_answer")
+def test_format_answer_missing_output_text(mock_generate_answer, base_args):
+    """test format_answer with missing output text."""
+    mock_generate_answer.return_value = {"papers_used": ["paper1"]}
+
+    result = format_answer(**base_args)
+
+    assert result.startswith("No answer generated.")
+    assert "Sources:" in result
+    mock_generate_answer.assert_called_once()

aiagents4pharma/talk2scholars/tests/test_pdf_batch_processor.py

@@ -0,0 +1,101 @@
+"""Tests for the PDF batch processor module."""
+
+from unittest.mock import MagicMock, patch
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor import (
+    add_papers_batch,
+)
+
+
+@pytest.fixture(name="args_fixture")
+def _args_fixture():
+    """Provides common arguments for tests."""
+    return {
+        "vector_store": MagicMock(),
+        "loaded_papers": set(),
+        "paper_metadata": {},
+        "documents": {},
+        "config": {"param": "value"},
+        "metadata_fields": ["Title", "Author"],
+        "has_gpu": False,
+    }
+
+
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
+)
+def test_no_papers_to_add(mock_loader, args_fixture):
+    """Test case where no papers are provided to add."""
+    add_papers_batch(papers_to_add=[], **args_fixture)
+    mock_loader.assert_not_called()
+
+
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
+)
+def test_all_papers_already_loaded(mock_loader, args_fixture):
+    """Test case where all papers are already loaded."""
+    args_fixture["loaded_papers"].update(["p1", "p2"])
+    add_papers_batch(
+        papers_to_add=[("p1", "url1", {}), ("p2", "url2", {})],
+        **args_fixture,
+    )
+    mock_loader.assert_not_called()
+
+
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
+)
+def test_successful_batch_embedding(mock_loader, args_fixture):
+    """Test case where papers are successfully loaded and embedded."""
+    mock_loader.return_value = [
+        MagicMock(page_content="Page 1"),
+        MagicMock(page_content="Page 2"),
+    ]
+
+    mock_collection = MagicMock()
+    mock_collection.num_entities = 2
+    mock_collection.query.return_value = [{"paper_id": "p1"}]
+    args_fixture["vector_store"].col = mock_collection
+
+    add_papers_batch(
+        papers_to_add=[("p1", "url1", {"Title": "Paper One"})],
+        **args_fixture,
+    )
+
+    assert "p1" in args_fixture["paper_metadata"]
+    assert "p1" in args_fixture["loaded_papers"]
+    args_fixture["vector_store"].add_documents.assert_called_once()
+    mock_collection.flush.assert_called()
+
+
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
+)
+def test_empty_chunks_after_loading(mock_loader, args_fixture):
+    """Test case where no chunks are returned after loading PDF."""
+    mock_loader.return_value = []
+
+    add_papers_batch(papers_to_add=[("p1", "url1", {})], **args_fixture)
+
+    args_fixture["vector_store"].add_documents.assert_not_called()
+
+
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
+)
+def test_vector_store_insert_failure(mock_loader, args_fixture):
+    """Test case where vector store insertion fails."""
+    mock_loader.return_value = [MagicMock(page_content="page")]
+
+    def raise_error(*_, **__):
+        raise RuntimeError("Vector store failed")
+
+    args_fixture["vector_store"].add_documents.side_effect = raise_error
+
+    mock_collection = MagicMock()
+    args_fixture["vector_store"].col = mock_collection
+
+    with pytest.raises(RuntimeError, match="Vector store failed"):
+        add_papers_batch(papers_to_add=[("p1", "url1", {})], **args_fixture)

aiagents4pharma/talk2scholars/tests/test_pdf_collection_manager.py

@@ -0,0 +1,150 @@
+"""collection_manager for managing Milvus collections for PDF chunks."""
+
+from unittest.mock import MagicMock, patch
+from dataclasses import dataclass, field
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils import collection_manager
+
+
+# -- Fixtures --
+
+
+@pytest.fixture
+def config_mock():
+    """Dataclass config fixture to simulate Milvus config."""
+
+    @dataclass
+    class MilvusConfig:
+        """Simulated Milvus inner config."""
+
+        embedding_dim: int = 768
+
+    @dataclass
+    class Config:
+        """Simulated outer config."""
+
+        milvus: MilvusConfig = field(default_factory=MilvusConfig)
+
+    return Config()
+
+
+@pytest.fixture
+def index_params():
+    """Fixture to provide index parameters for tests."""
+    return {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
+
+
+# -- Safe collection_cache access --
+
+
+def set_collection_cache(key, value):
+    """Set a mocked collection into the cache."""
+    getattr(collection_manager, "_collection_cache")[key] = value
+
+
+def clear_collection_cache(key):
+    """Remove a mocked collection from the cache."""
+    getattr(collection_manager, "_collection_cache").pop(key, None)
+
+
+# -- Tests --
+
+
+def test_cached_collection_returned(request):
+    """Check if cached collection is returned."""
+    config = request.getfixturevalue("config_mock")
+    index = request.getfixturevalue("index_params")
+    mock_collection = MagicMock()
+    collection_name = "test_cached"
+
+    set_collection_cache(collection_name, mock_collection)
+
+    result = collection_manager.ensure_collection_exists(
+        collection_name, config, index, has_gpu=False
+    )
+
+    assert result == mock_collection
+    clear_collection_cache(collection_name)
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.Collection")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.utility")
+def test_create_new_collection(mock_utility, mock_collection_cls, request):
+    """Check if new collection is created when it does not exist."""
+    config = request.getfixturevalue("config_mock")
+    index = request.getfixturevalue("index_params")
+    mock_utility.list_collections.return_value = []
+
+    mock_collection = MagicMock()
+    mock_collection_cls.return_value = mock_collection
+    mock_collection.indexes = [MagicMock(field_name="embedding")]
+    mock_collection.num_entities = 5
+
+    result = collection_manager.ensure_collection_exists(
+        "new_collection", config, index, has_gpu=True
+    )
+
+    assert mock_collection.create_index.called
+    assert mock_collection.load.called
+    assert result == mock_collection
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.Collection")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.utility")
+def test_load_existing_collection(mock_utility, mock_collection_cls, request):
+    """Test loading an existing collection."""
+    config = request.getfixturevalue("config_mock")
+    index = request.getfixturevalue("index_params")
+    mock_utility.list_collections.return_value = ["existing_collection"]
+
+    mock_collection = MagicMock()
+    mock_collection_cls.return_value = mock_collection
+    mock_collection.indexes = []
+    mock_collection.num_entities = 0
+
+    result = collection_manager.ensure_collection_exists(
+        "existing_collection", config, index, has_gpu=False
+    )
+
+    mock_collection.load.assert_called_once()
+    assert result == mock_collection
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.Collection")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.utility")
+def test_debug_collection_state_failure(mock_utility, mock_collection_cls, request):
+    """debug_collection_state should log but not raise on failure."""
+    config = request.getfixturevalue("config_mock")
+    index = request.getfixturevalue("index_params")
+    mock_utility.list_collections.return_value = ["bad_collection"]
+
+    mock_collection = MagicMock()
+    mock_collection_cls.return_value = mock_collection
+    mock_collection.indexes = []
+    mock_collection.num_entities = 10
+
+    mock_collection.schema = property(
+        lambda _: (_ for _ in ()).throw(Exception("bad schema"))
+    )
+
+    result = collection_manager.ensure_collection_exists(
+        "bad_collection", config, index, has_gpu=True
+    )
+
+    assert result == mock_collection
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.Collection")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.collection_manager.utility")
+def test_ensure_collection_exception(mock_utility, mock_collection_cls, request):
+    """ensure_collection_exists should raise on utility failure."""
+    config = request.getfixturevalue("config_mock")
+    index = request.getfixturevalue("index_params")
+    mock_utility.list_collections.side_effect = RuntimeError("milvus failure")
+    mock_collection_cls.return_value = MagicMock()
+
+    with pytest.raises(RuntimeError, match="milvus failure"):
+        collection_manager.ensure_collection_exists(
+            "fail_collection", config, index, has_gpu=False
+        )

aiagents4pharma/talk2scholars/tests/test_pdf_document_processor.py

@@ -0,0 +1,69 @@
+"""Unit tests for PDF document processing utilities."""
+
+from unittest.mock import MagicMock, patch
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor import (
+    load_and_split_pdf,
+)
+
+
+@pytest.fixture(name="base_args_params")
+def _base_args_params():
+    """base_args_params fixture to provide common arguments for tests."""
+    return {
+        "paper_id": "P123",
+        "pdf_url": "mock/path/to/paper.pdf",
+        "paper_metadata": {"Title": "Test Paper", "Author": "A. Researcher"},
+        "config": type("Config", (), {"chunk_size": 1000, "chunk_overlap": 200})(),
+        "metadata_fields": ["Author"],
+        "documents_dict": {},
+    }
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor.PyPDFLoader")
+@patch(
+    "aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor."
+    "RecursiveCharacterTextSplitter"
+)
+def test_load_and_split_pdf_success(
+    mock_splitter_cls, mock_loader_cls, base_args_params
+):
+    """load_and_split_pdf should load and split PDF correctly."""
+    mock_doc = MagicMock()
+    mock_doc.metadata = {"page": 1}
+    mock_loader = MagicMock()
+    mock_loader.load.return_value = [mock_doc]
+    mock_loader_cls.return_value = mock_loader
+
+    mock_splitter = MagicMock()
+    chunk1 = MagicMock()
+    chunk1.metadata = {"page": 1}
+    mock_splitter.split_documents.return_value = [chunk1]
+    mock_splitter_cls.return_value = mock_splitter
+
+    chunks = load_and_split_pdf(**base_args_params)
+
+    assert len(chunks) == 1
+    assert "P123_0" in base_args_params["documents_dict"]
+    stored_chunk = base_args_params["documents_dict"]["P123_0"]
+    assert stored_chunk.metadata["paper_id"] == "P123"
+    assert stored_chunk.metadata["title"] == "Test Paper"
+    assert stored_chunk.metadata["chunk_id"] == 0
+    assert stored_chunk.metadata["page"] == 1
+    assert stored_chunk.metadata["source"] == base_args_params["pdf_url"]
+    assert stored_chunk.metadata["Author"] == "A. Researcher"
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor.PyPDFLoader")
+def test_load_and_split_pdf_raises_if_config_missing(mock_loader_cls, base_args_params):
+    """load_and_split_pdf should raise ValueError if config is None."""
+    mock_loader = MagicMock()
+    mock_loader.load.return_value = [MagicMock()]
+    mock_loader_cls.return_value = mock_loader
+
+    base_args_params["config"] = None
+    with pytest.raises(
+        ValueError, match="Configuration is required for text splitting in Vectorstore."
+    ):
+        load_and_split_pdf(**base_args_params)

aiagents4pharma/talk2scholars/tests/test_pdf_generate_answer.py

@@ -0,0 +1,75 @@
+"""generate_answer tests for the PDF tool"""
+
+from unittest.mock import MagicMock
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.generate_answer import (
+    _build_context_and_sources,
+    generate_answer,
+)
+
+
+@pytest.fixture(name="chunks_fixture")
+def _chunks_fixture():
+    """Fixture providing sample document chunks."""
+    doc1 = MagicMock()
+    doc1.page_content = "This is chunk one."
+    doc1.metadata = {"paper_id": "P1", "title": "Title 1", "page": 1}
+
+    doc2 = MagicMock()
+    doc2.page_content = "This is chunk two."
+    doc2.metadata = {"paper_id": "P1", "title": "Title 1", "page": 2}
+
+    doc3 = MagicMock()
+    doc3.page_content = "This is chunk three."
+    doc3.metadata = {"paper_id": "P2", "title": "Title 2", "page": 1}
+
+    return [doc1, doc2, doc3]
+
+
+def test_build_context_and_sources_formatting(chunks_fixture):
+    """_build_context_and_sources should format context and sources correctly."""
+    context, sources = _build_context_and_sources(chunks_fixture)
+
+    assert "[Document 1] From: 'Title 1' (ID: P1)" in context
+    assert "Page 1: This is chunk one." in context
+    assert "Page 2: This is chunk two." in context
+    assert "[Document 2] From: 'Title 2' (ID: P2)" in context
+    assert "Page 1: This is chunk three." in context
+    assert sources == {"P1", "P2"}
+
+
+def test_generate_answer_success(chunks_fixture):
+    """generate_answer should return formatted answer and sources."""
+    mock_llm = MagicMock()
+    mock_llm.invoke.return_value.content = "The answer is XYZ."
+
+    config = {
+        "prompt_template": "Answer the question based on the context."
+        "\n\n{context}\n\nQ: {question}\nA:"
+    }
+
+    result = generate_answer("What is the result?", chunks_fixture, mock_llm, config)
+
+    assert result["output_text"] == "The answer is XYZ."
+    assert len(result["sources"]) == 3
+    assert result["num_sources"] == 3
+    assert set(result["papers_used"]) == {"P1", "P2"}
+
+
+def test_generate_answer_raises_for_none_config(chunks_fixture):
+    """generate_answer should raise ValueError for None config."""
+    mock_llm = MagicMock()
+    with pytest.raises(
+        ValueError, match="Configuration for generate_answer is required."
+    ):
+        generate_answer("Why?", chunks_fixture, mock_llm, config=None)
+
+
+def test_generate_answer_raises_for_missing_template(chunks_fixture):
+    """generate_answer should raise ValueError for missing prompt_template in config."""
+    mock_llm = MagicMock()
+    with pytest.raises(
+        ValueError, match="The prompt_template is missing from the configuration."
+    ):
+        generate_answer("Why?", chunks_fixture, mock_llm, config={})