aiagents4pharma 0.0.0__py3-none-any.whl

aiagents4pharma/talk2scholars/tests/test_utils_pdf_batch_processor.py

@@ -0,0 +1,92 @@
+"""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_utils_pdf_collection_manager.py

@@ -0,0 +1,173 @@
+"""collection_manager for managing Milvus collections for PDF chunks."""
+
+from dataclasses import dataclass, field
+from unittest.mock import MagicMock, patch
+
+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 without replacing the whole attribute."""
+    cache = getattr(collection_manager, "_collection_cache", None)
+    if cache is None:
+        cache = {}
+        # Still need to attach it once if it doesn't exist
+        object.__setattr__(collection_manager, "_collection_cache", cache)
+    cache[key] = value
+
+
+def clear_collection_cache(key):
+    """Remove a mocked collection from the cache."""
+    cache = getattr(collection_manager, "_collection_cache", None)
+    if cache is not None:
+        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)
+
+
+def test_set_collection_cache_initializes_when_missing(monkeypatch):
+    """Ensure set_collection_cache initializes the cache when attribute is absent."""
+    # Remove the attribute if present (avoids W0212 and stays lint-clean)
+    monkeypatch.delattr(collection_manager, "_collection_cache", raising=False)
+
+    key = "init_case"
+    val = MagicMock()
+
+    # This should go through the None-branch and attach the cache via object.__setattr__
+    set_collection_cache(key, val)
+
+    # Verify cache got created and populated
+    cache = getattr(collection_manager, "_collection_cache", None)
+    assert isinstance(cache, dict)
+    assert cache.get(key) is val
+
+    # Cleanup
+    clear_collection_cache(key)

aiagents4pharma/talk2scholars/tests/test_utils_pdf_document_processor.py

@@ -0,0 +1,68 @@
+"""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_utils_pdf_generate_answer.py

@@ -0,0 +1,72 @@
+"""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={})

aiagents4pharma/talk2scholars/tests/test_utils_pdf_gpu_detection.py

@@ -0,0 +1,129 @@
+"""gpu detection and index configuration tests."""
+
+import subprocess
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection import (
+    detect_nvidia_gpu,
+    get_optimal_index_config,
+    log_index_configuration,
+)
+
+# === detect_nvidia_gpu ===
+
+
+def test_detect_nvidia_gpu_force_cpu_from_config():
+    """detect_nvidia_gpu should return False if force_cpu_mode is set."""
+    config = SimpleNamespace(gpu_detection=SimpleNamespace(force_cpu_mode=True))
+    assert detect_nvidia_gpu(config) is False
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.subprocess.run")
+def test_detect_nvidia_gpu_success(mock_run):
+    """detect_nvidia_gpu should return True if NVIDIA GPUs are detected."""
+    mock_run.return_value = MagicMock(returncode=0, stdout="NVIDIA A100\nNVIDIA RTX 3090")
+
+    assert detect_nvidia_gpu() is True
+    mock_run.assert_called_once()
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.subprocess.run")
+def test_detect_nvidia_gpu_no_output(mock_run):
+    """detect_nvidia_gpu should return False if no GPUs are detected."""
+    mock_run.return_value = MagicMock(returncode=0, stdout="")
+
+    assert detect_nvidia_gpu() is False
+
+
+# === get_optimal_index_config ===
+
+
+def test_get_optimal_index_config_gpu():
+    """get_optimal_index_config should return GPU_CAGRA for GPU setup."""
+    index_params, search_params = get_optimal_index_config(has_gpu=True, embedding_dim=768)
+
+    assert index_params["index_type"] == "GPU_CAGRA"
+    assert "cache_dataset_on_device" in index_params["params"]
+    assert search_params["params"]["search_width"] == 16
+
+
+def test_get_optimal_index_config_cpu():
+    """get_optimal_index_config should return IVF_FLAT for CPU setup."""
+    index_params, search_params = get_optimal_index_config(has_gpu=False, embedding_dim=768)
+
+    assert index_params["index_type"] == "IVF_FLAT"
+    assert index_params["params"]["nlist"] == 96  # 768 / 8 = 96
+    assert search_params["params"]["nprobe"] == 16
+
+
+# === log_index_configuration ===
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.logger")
+def test_log_index_configuration_logs_all(mock_logger):
+    """log_index_configuration should log all parameters correctly."""
+    index_params = {
+        "index_type": "IVF_FLAT",
+        "metric_type": "COSINE",
+        "params": {"nlist": 128},
+    }
+    search_params = {"metric_type": "COSINE", "params": {"nprobe": 16}}
+
+    log_index_configuration(index_params, search_params)
+
+    assert mock_logger.info.call_count >= 5
+
+
+def test_get_optimal_index_config_gpu_without_cosine():
+    """Ensure GPU config defaults to IP when use_cosine is False."""
+    index_params, search_params = get_optimal_index_config(
+        has_gpu=True, embedding_dim=768, use_cosine=False
+    )
+
+    assert index_params["index_type"] == "GPU_CAGRA"
+    assert index_params["metric_type"] == "IP"
+    assert search_params["metric_type"] == "IP"
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.logger")
+def test_log_index_configuration_logs_cosine_simulation_note(mock_logger):
+    """Test GPU_CAGRA COSINE -> IP note is logged properly."""
+    index_params = {
+        "index_type": "GPU_CAGRA",
+        "metric_type": "IP",
+        "params": {"itopk_size": 128},
+    }
+    search_params = {
+        "metric_type": "IP",
+        "params": {"search_width": 16},
+    }
+
+    log_index_configuration(index_params, search_params, use_cosine=True)
+
+    log_messages = [str(call.args[0]) for call in mock_logger.info.call_args_list]
+    assert any("simulate COSINE for GPU" in msg for msg in log_messages)
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.logger")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.subprocess.run")
+def test_detect_nvidia_gpu_timeout_raises_false(mock_run, mock_logger):
+    """detect_nvidia_gpu should return False and log info on subprocess.TimeoutExpired."""
+    # Simulate a timeout
+    mock_run.side_effect = subprocess.TimeoutExpired(cmd="nvidia-smi", timeout=10)
+
+    result = detect_nvidia_gpu()
+    assert result is False
+    mock_logger.info.assert_called_with("NVIDIA GPU detection failed: %s", mock_run.side_effect)
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.logger")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.subprocess.run")
+def test_detect_nvidia_gpu_file_not_found_raises_false(mock_run, mock_logger):
+    """detect_nvidia_gpu should return False and log info on FileNotFoundError."""
+    # Simulate nvidia-smi not installed
+    mock_run.side_effect = FileNotFoundError("nvidia-smi not found")
+
+    result = detect_nvidia_gpu()
+    assert result is False
+    mock_logger.info.assert_called_with("NVIDIA GPU detection failed: %s", mock_run.side_effect)

aiagents4pharma/talk2scholars/tests/test_utils_pdf_paper_loader.py

@@ -0,0 +1,116 @@
+"""paper_loader tests for the load_all_papers function."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.paper_loader import (
+    load_all_papers,
+)
+
+
+@pytest.fixture
+def articles():
+    """A fixture to provide a sample articles dictionary."""
+    return {
+        "p1": {"pdf_url": "http://example.com/p1.pdf", "title": "Paper 1"},
+        "p2": {"pdf_url": "http://example.com/p2.pdf", "title": "Paper 2"},
+        "p3": {"title": "No PDF paper"},
+    }
+
+
+@pytest.fixture
+def mock_vector_store():
+    """Mock vector store fixture."""
+    return MagicMock(
+        loaded_papers={"p1"},
+        paper_metadata={},
+        documents={},
+        metadata_fields=["title"],
+        config={"embedding_batch_size": 1234},
+        has_gpu=False,
+        vector_store=MagicMock(),
+    )
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.paper_loader.add_papers_batch")
+def test_all_papers_loaded_returns_early(mock_batch, request):
+    """Test early return when all papers are already loaded."""
+    article_data = request.getfixturevalue("articles")
+    vector_store = request.getfixturevalue("mock_vector_store")
+    vector_store.loaded_papers = set(article_data.keys())
+
+    load_all_papers(
+        vector_store=vector_store,
+        articles=article_data,
+        call_id="test_call",
+        config={"embedding_batch_size": 1000},
+        has_gpu=False,
+    )
+
+    mock_batch.assert_not_called()
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.paper_loader.add_papers_batch")
+def test_skips_papers_without_pdf(mock_batch, request):
+    """Test that papers without PDF URLs are skipped."""
+    article_data = request.getfixturevalue("articles")
+    vector_store = request.getfixturevalue("mock_vector_store")
+    vector_store.loaded_papers = {"p2"}  # p1 not loaded, p3 has no pdf
+
+    load_all_papers(
+        vector_store=vector_store,
+        articles=article_data,
+        call_id="test_call",
+        config={"embedding_batch_size": 1000},
+        has_gpu=False,
+    )
+
+    assert mock_batch.call_count == 1
+    call_args = mock_batch.call_args[1]["papers_to_add"]
+    assert len(call_args) == 1
+    assert call_args[0][0] == "p1"
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.paper_loader.add_papers_batch")
+def test_gpu_parameters_used(mock_batch, request):
+    """Test GPU-based parameters are used if has_gpu is True."""
+    article_data = request.getfixturevalue("articles")
+    vector_store = request.getfixturevalue("mock_vector_store")
+    vector_store.loaded_papers = set()
+    vector_store.has_gpu = True
+
+    load_all_papers(
+        vector_store=vector_store,
+        articles=article_data,
+        call_id="gpu_call",
+        config={"embedding_batch_size": 2048},
+        has_gpu=True,
+    )
+
+    args = mock_batch.call_args[1]
+    assert args["has_gpu"] is True
+    assert args["batch_size"] == 2048
+    assert args["max_workers"] >= 4
+
+
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.paper_loader.add_papers_batch")
+def test_cpu_parameters_used(mock_batch, request):
+    """Test CPU-based parameters are used if has_gpu is False."""
+    article_data = request.getfixturevalue("articles")
+    vector_store = request.getfixturevalue("mock_vector_store")
+    vector_store.loaded_papers = set()
+    vector_store.has_gpu = False
+
+    load_all_papers(
+        vector_store=vector_store,
+        articles=article_data,
+        call_id="cpu_call",
+        config={"embedding_batch_size": 512},
+        has_gpu=False,
+    )
+
+    args = mock_batch.call_args[1]
+    assert args["has_gpu"] is False
+    assert args["batch_size"] == 512
+    assert args["max_workers"] >= 3