fix: update references to Europe PMC in examples and documentation

Replaced mentions of bioRxiv with Europe PMC in the full stack and hypothesis demo scripts to reflect the current data sources. Updated the pyproject.toml to exclude specific directories from mypy checks using regex patterns for better clarity.

examples/full_stack_demo/run_full.py

@@ -3,7 +3,7 @@
 Demo: Full Stack DeepCritical Agent (Phases 1-8).
 
 This script demonstrates the COMPLETE REAL drug repurposing research pipeline:
-- Phase 2: REAL Search (PubMed + ClinicalTrials + bioRxiv)
+- Phase 2: REAL Search (PubMed + ClinicalTrials + Europe PMC)
 - Phase 6: REAL Embeddings (sentence-transformers + ChromaDB)
 - Phase 7: REAL Hypothesis (LLM mechanistic reasoning)
 - Phase 3: REAL Judge (LLM evidence assessment)
@@ -225,7 +225,7 @@ Examples:
     print("  DeepCritical Full Stack Demo Complete!")
     print("  ")
     print("  Everything you just saw was REAL:")
-    print("    - Real PubMed + ClinicalTrials + bioRxiv searches")
+    print("    - Real PubMed + ClinicalTrials + Europe PMC searches")
     print("    - Real embedding computations")
     print("    - Real LLM reasoning")
     print("    - Real scientific report")

examples/hypothesis_demo/run_hypothesis.py

@@ -3,7 +3,7 @@
 Demo: Hypothesis Generation (Phase 7).
 
 This script demonstrates the REAL hypothesis generation pipeline:
-1. REAL search: PubMed + ClinicalTrials + bioRxiv (actual API calls)
+1. REAL search: PubMed + ClinicalTrials + Europe PMC (actual API calls)
 2. REAL embeddings: Semantic deduplication
 3. REAL LLM: Mechanistic hypothesis generation
 
@@ -37,7 +37,7 @@ async def run_hypothesis_demo(query: str) -> None:
         print(f"{'=' * 60}\n")
 
         # Step 1: REAL Search
-        print("[Step 1] Searching PubMed + ClinicalTrials + bioRxiv...")
+        print("[Step 1] Searching PubMed + ClinicalTrials + Europe PMC...")
         search_handler = SearchHandler(
             tools=[PubMedTool(), ClinicalTrialsTool(), EuropePMCTool()], timeout=30.0
         )
@@ -132,7 +132,7 @@ Examples:
 
     print("\n" + "=" * 60)
     print("Demo complete! This was a REAL pipeline:")
-    print("  1. REAL search: PubMed + ClinicalTrials + bioRxiv APIs")
+    print("  1. REAL search: PubMed + ClinicalTrials + Europe PMC APIs")
     print("  2. REAL embeddings: Actual sentence-transformers")
     print("  3. REAL LLM: Actual hypothesis generation")
     print("=" * 60 + "\n")

examples/orchestrator_demo/run_magentic.py

@@ -32,9 +32,11 @@ async def main() -> None:
     parser.add_argument("--iterations", type=int, default=10, help="Max rounds")
     args = parser.parse_args()
 
-    # Check for keys
-    if not (os.getenv("OPENAI_API_KEY") or os.getenv("ANTHROPIC_API_KEY")):
-        print("Error: No API key found. Magentic requires real LLM.")
+    # Check for OpenAI key specifically - Magentic requires function calling
+    # which is only supported by OpenAI's API (not Anthropic or HF Inference)
+    if not os.getenv("OPENAI_API_KEY"):
+        print("Error: OPENAI_API_KEY required. Magentic uses function calling")
+        print("       which requires OpenAI's API. For other providers, use mode='simple'.")
         sys.exit(1)
 
     print(f"\n{'=' * 60}")

pyproject.toml

@@ -106,8 +106,8 @@ disallow_untyped_defs = true
 warn_return_any = true
 warn_unused_ignores = false
 exclude = [
-    "reference_repos",
-    "examples",
+    "^reference_repos/",
+    "^examples/",
 ]
 
 # ============== PYTEST CONFIG ==============

src/orchestrator_magentic.py

@@ -22,7 +22,7 @@ from src.agents.magentic_agents import (
 )
 from src.agents.state import init_magentic_state
 from src.utils.config import settings
-from src.utils.exceptions import ConfigurationError
+from src.utils.llm_factory import check_magentic_requirements
 from src.utils.models import AgentEvent
 
 if TYPE_CHECKING:
@@ -50,10 +50,8 @@ class MagenticOrchestrator:
             max_rounds: Maximum coordination rounds
             chat_client: Optional shared chat client for agents
         """
-        if not settings.openai_api_key:
-            raise ConfigurationError(
-                "Magentic mode requires OPENAI_API_KEY. Set the key or use mode='simple'."
-            )
+        # Validate requirements via centralized factory
+        check_magentic_requirements()
 
         self._max_rounds = max_rounds
         self._chat_client = chat_client

src/utils/config.py

@@ -78,6 +78,30 @@ class Settings(BaseSettings):
 
         raise ConfigurationError(f"Unknown LLM provider: {self.llm_provider}")
 
+    def get_openai_api_key(self) -> str:
+        """Get OpenAI API key (required for Magentic function calling)."""
+        if not self.openai_api_key:
+            raise ConfigurationError(
+                "OPENAI_API_KEY not set. Magentic mode requires OpenAI for function calling. "
+                "Use mode='simple' for other providers."
+            )
+        return self.openai_api_key
+
+    @property
+    def has_openai_key(self) -> bool:
+        """Check if OpenAI API key is available."""
+        return bool(self.openai_api_key)
+
+    @property
+    def has_anthropic_key(self) -> bool:
+        """Check if Anthropic API key is available."""
+        return bool(self.anthropic_api_key)
+
+    @property
+    def has_any_llm_key(self) -> bool:
+        """Check if any LLM API key is available."""
+        return self.has_openai_key or self.has_anthropic_key
+
 
 def get_settings() -> Settings:
     """Factory function to get settings (allows mocking in tests)."""

src/utils/llm_factory.py

@@ -0,0 +1,106 @@
+"""Centralized LLM client factory.
+
+This module provides factory functions for creating LLM clients,
+ensuring consistent configuration and clear error messages.
+
+Why Magentic requires OpenAI:
+- Magentic agents use the @ai_function decorator for tool calling
+- This requires structured function calling protocol (tools, tool_choice)
+- OpenAI's API supports this natively
+- Anthropic/HuggingFace Inference APIs are text-in/text-out only
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from src.utils.config import settings
+from src.utils.exceptions import ConfigurationError
+
+if TYPE_CHECKING:
+    from agent_framework.openai import OpenAIChatClient
+
+
+def get_magentic_client() -> "OpenAIChatClient":
+    """
+    Get the OpenAI client for Magentic agents.
+
+    Magentic requires OpenAI because it uses function calling protocol:
+    - @ai_function decorators define callable tools
+    - LLM returns structured tool calls (not just text)
+    - Requires OpenAI's tools/function_call API support
+
+    Raises:
+        ConfigurationError: If OPENAI_API_KEY is not set
+
+    Returns:
+        Configured OpenAIChatClient for Magentic agents
+    """
+    # Import here to avoid requiring agent-framework for simple mode
+    from agent_framework.openai import OpenAIChatClient
+
+    api_key = settings.get_openai_api_key()
+
+    return OpenAIChatClient(
+        model_id=settings.openai_model,
+        api_key=api_key,
+    )
+
+
+def get_pydantic_ai_model() -> Any:
+    """
+    Get the appropriate model for pydantic-ai based on configuration.
+
+    Uses the configured LLM_PROVIDER to select between OpenAI and Anthropic.
+    This is used by simple mode components (JudgeHandler, etc.)
+
+    Returns:
+        Configured pydantic-ai model
+    """
+    from pydantic_ai.models.anthropic import AnthropicModel
+    from pydantic_ai.models.openai import OpenAIModel
+    from pydantic_ai.providers.anthropic import AnthropicProvider
+    from pydantic_ai.providers.openai import OpenAIProvider
+
+    if settings.llm_provider == "openai":
+        if not settings.openai_api_key:
+            raise ConfigurationError("OPENAI_API_KEY not set for pydantic-ai")
+        provider = OpenAIProvider(api_key=settings.openai_api_key)
+        return OpenAIModel(settings.openai_model, provider=provider)
+
+    if settings.llm_provider == "anthropic":
+        if not settings.anthropic_api_key:
+            raise ConfigurationError("ANTHROPIC_API_KEY not set for pydantic-ai")
+        anthropic_provider = AnthropicProvider(api_key=settings.anthropic_api_key)
+        return AnthropicModel(settings.anthropic_model, provider=anthropic_provider)
+
+    raise ConfigurationError(f"Unknown LLM provider: {settings.llm_provider}")
+
+
+def check_magentic_requirements() -> None:
+    """
+    Check if Magentic mode requirements are met.
+
+    Raises:
+        ConfigurationError: If requirements not met
+    """
+    if not settings.has_openai_key:
+        raise ConfigurationError(
+            "Magentic mode requires OPENAI_API_KEY for function calling support. "
+            "Anthropic and HuggingFace Inference do not support the structured "
+            "function calling protocol that Magentic agents require. "
+            "Use mode='simple' for other LLM providers."
+        )
+
+
+def check_simple_mode_requirements() -> None:
+    """
+    Check if simple mode requirements are met.
+
+    Simple mode supports both OpenAI and Anthropic.
+
+    Raises:
+        ConfigurationError: If no LLM API key is configured
+    """
+    if not settings.has_any_llm_key:
+        raise ConfigurationError(
+            "No LLM API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY."
+        )

tests/unit/utils/test_config.py

@@ -11,50 +11,61 @@ from src.utils.exceptions import ConfigurationError
 
 
 class TestSettings:
-    """Tests for Settings class."""
+    """Tests for Settings class.
 
-    def test_default_max_iterations(self):
+    Note: We use _env_file=None to disable .env file reading in tests.
+    This ensures tests are isolated from the developer's local .env file.
+    pydantic-settings reads from both os.environ AND .env file by default.
+    """
+
+    def test_default_max_iterations(self) -> None:
         """Settings should have default max_iterations of 10."""
         with patch.dict(os.environ, {}, clear=True):
-            settings = Settings()
+            settings = Settings(_env_file=None)
             assert settings.max_iterations == 10  # noqa: PLR2004
 
-    def test_max_iterations_from_env(self):
+    def test_max_iterations_from_env(self) -> None:
         """Settings should read MAX_ITERATIONS from env."""
-        with patch.dict(os.environ, {"MAX_ITERATIONS": "25"}):
-            settings = Settings()
+        with patch.dict(os.environ, {"MAX_ITERATIONS": "25"}, clear=True):
+            settings = Settings(_env_file=None)
             assert settings.max_iterations == 25  # noqa: PLR2004
 
-    def test_invalid_max_iterations_raises(self):
+    def test_invalid_max_iterations_raises(self) -> None:
         """Settings should reject invalid max_iterations."""
-        with patch.dict(os.environ, {"MAX_ITERATIONS": "100"}):
+        with patch.dict(os.environ, {"MAX_ITERATIONS": "100"}, clear=True):
             with pytest.raises(ValidationError):
-                Settings()  # 100 > 50 (max)
+                Settings(_env_file=None)  # 100 > 50 (max)
 
-    def test_get_api_key_openai(self):
+    def test_get_api_key_openai(self) -> None:
         """get_api_key should return OpenAI key when provider is openai."""
-        with patch.dict(os.environ, {"LLM_PROVIDER": "openai", "OPENAI_API_KEY": "sk-test-key"}):
-            settings = Settings()
+        with patch.dict(
+            os.environ,
+            {"LLM_PROVIDER": "openai", "OPENAI_API_KEY": "sk-test-key"},
+            clear=True,
+        ):
+            settings = Settings(_env_file=None)
             assert settings.get_api_key() == "sk-test-key"
 
-    def test_get_api_key_openai_missing_raises(self):
+    def test_get_api_key_openai_missing_raises(self) -> None:
         """get_api_key should raise ConfigurationError when OpenAI key is not set."""
         with patch.dict(os.environ, {"LLM_PROVIDER": "openai"}, clear=True):
-            settings = Settings()
+            settings = Settings(_env_file=None)
             with pytest.raises(ConfigurationError, match="OPENAI_API_KEY not set"):
                 settings.get_api_key()
 
-    def test_get_api_key_anthropic(self):
+    def test_get_api_key_anthropic(self) -> None:
         """get_api_key should return Anthropic key when provider is anthropic."""
         with patch.dict(
-            os.environ, {"LLM_PROVIDER": "anthropic", "ANTHROPIC_API_KEY": "sk-ant-test-key"}
+            os.environ,
+            {"LLM_PROVIDER": "anthropic", "ANTHROPIC_API_KEY": "sk-ant-test-key"},
+            clear=True,
         ):
-            settings = Settings()
+            settings = Settings(_env_file=None)
             assert settings.get_api_key() == "sk-ant-test-key"
 
-    def test_get_api_key_anthropic_missing_raises(self):
+    def test_get_api_key_anthropic_missing_raises(self) -> None:
         """get_api_key should raise ConfigurationError when Anthropic key is not set."""
         with patch.dict(os.environ, {"LLM_PROVIDER": "anthropic"}, clear=True):
-            settings = Settings()
+            settings = Settings(_env_file=None)
             with pytest.raises(ConfigurationError, match="ANTHROPIC_API_KEY not set"):
                 settings.get_api_key()