feat(rag): add Ollama embeddings + Gemini 2.5 agent support

app/features/agents/agents/base.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import os
 from typing import Any
 
 import structlog
@@ -35,27 +36,29 @@ def get_fallback_model() -> str:
 
 
 def get_model_settings() -> dict[str, Any]:
-    """Get model settings from configuration.
+    """Get model settings from configuration for PydanticAI Agent.
 
     Returns:
-        Dictionary with temperature, max_tokens, and optional thinking settings.
+        Dictionary with model_settings wrapped for Agent constructor.
     """
     settings = get_settings()
-    model_settings: dict[str, Any] = {
+    inner_settings: dict[str, Any] = {
         "temperature": settings.agent_temperature,
         "max_tokens": settings.agent_max_tokens,
     }
 
     # Add thinking budget if configured (Gemini 2.5+ extended reasoning)
     if settings.agent_thinking_budget:
-        model_settings["thinking"] = {"budget": settings.agent_thinking_budget}
+        inner_settings["thinking"] = {"budget": settings.agent_thinking_budget}
 
-    return model_settings
+    return {"model_settings": inner_settings}
 
 
 def validate_api_key_for_model(model: str) -> None:
     """Validate that required API key is configured for model.
 
+    Also exports the API key to environment for PydanticAI compatibility.
+
     Args:
         model: Model identifier (provider:model-name).
 
@@ -65,14 +68,28 @@ def validate_api_key_for_model(model: str) -> None:
     settings = get_settings()
     provider = model.split(":")[0]
 
-    if provider == "anthropic" and not settings.anthropic_api_key:
-        raise ValueError(
-            "Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable."
-        )
-    elif provider == "openai" and not settings.openai_api_key:
-        raise ValueError("OpenAI API key not configured. Set OPENAI_API_KEY environment variable.")
-    elif provider in ["google-gla", "google-vertex"] and not settings.google_api_key:
-        raise ValueError("Google API key not configured. Set GOOGLE_API_KEY environment variable.")
+    if provider == "anthropic":
+        if not settings.anthropic_api_key:
+            raise ValueError(
+                "Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable."
+            )
+        # Only set env var if not already present to avoid repeated mutations
+        if "ANTHROPIC_API_KEY" not in os.environ:
+            os.environ["ANTHROPIC_API_KEY"] = settings.anthropic_api_key
+    elif provider == "openai":
+        if not settings.openai_api_key:
+            raise ValueError(
+                "OpenAI API key not configured. Set OPENAI_API_KEY environment variable."
+            )
+        if "OPENAI_API_KEY" not in os.environ:
+            os.environ["OPENAI_API_KEY"] = settings.openai_api_key
+    elif provider in ["google-gla", "google-vertex"]:
+        if not settings.google_api_key:
+            raise ValueError(
+                "Google API key not configured. Set GOOGLE_API_KEY environment variable."
+            )
+        if "GOOGLE_API_KEY" not in os.environ:
+            os.environ["GOOGLE_API_KEY"] = settings.google_api_key
 
     logger.debug(
         "agents.api_key_validated",

app/features/agents/agents/rag_assistant.py

@@ -14,6 +14,7 @@
 import structlog
 from pydantic_ai import Agent, RunContext
 
+from app.core.config import get_settings
 from app.features.agents.agents.base import (
     SAFETY_INSTRUCTIONS,
     SYSTEM_PROMPT_HEADER,
@@ -78,13 +79,17 @@ def create_rag_assistant_agent() -> Agent[AgentDeps, RAGAnswer]:
         **get_model_settings(),
     )
 
+    # Get default threshold from settings
+    settings = get_settings()
+    default_threshold = settings.rag_similarity_threshold
+
     # Register tools with the agent
     @agent.tool
     async def tool_retrieve_context(
         ctx: RunContext[AgentDeps],
         query: str,
         top_k: int = 5,
-        similarity_threshold: float = 0.7,
+        similarity_threshold: float | None = None,
         source_type: str | None = None,
     ) -> dict[str, Any]:
         """Retrieve relevant context from the knowledge base.
@@ -97,24 +102,28 @@ async def tool_retrieve_context(
         Args:
             query: Search query describing what to find.
             top_k: Maximum results to return (default 5).
-            similarity_threshold: Minimum similarity score (default 0.7).
+            similarity_threshold: Minimum similarity score (default from settings).
             source_type: Filter by source type ('markdown', 'openapi').
 
         Returns:
             Dictionary with 'results' list containing chunks with citations.
         """
+        # Use settings default if not provided
+        threshold = similarity_threshold if similarity_threshold is not None else default_threshold
+
         ctx.deps.increment_tool_calls()
         logger.info(
             "agents.rag_assistant.tool_retrieve_context",
             session_id=ctx.deps.session_id,
             query_length=len(query),
             top_k=top_k,
+            threshold=threshold,
         )
         return await retrieve_context(
             db=ctx.deps.db,
             query=query,
             top_k=top_k,
-            similarity_threshold=similarity_threshold,
+            similarity_threshold=threshold,
             source_type=source_type,
         )
 

app/features/agents/service.py

@@ -15,7 +15,7 @@
 import uuid
 from collections.abc import AsyncIterator
 from datetime import UTC, datetime, timedelta
-from typing import Any, Literal
+from typing import Any, Literal, cast
 
 import structlog
 from pydantic_ai import Agent
@@ -263,8 +263,8 @@ async def chat(
         pending_approval = False
 
         # The structured output might indicate approval is needed
-        # NOTE: PydanticAI's result.data type is generic, cast to Any for attribute access
-        result_data: Any = result.data  # type: ignore[attr-defined]
+        # NOTE: PydanticAI v1.48.0 uses result.output (not result.data)
+        result_data: Any = result.output
 
         # Check for pending_action in result data (primary trigger)
         # The agent tools should return a pending_action dict with action_type and arguments
@@ -662,13 +662,31 @@ def _serialize_messages(
             List of serializable dictionaries.
         """
         import dataclasses
+        from datetime import datetime
+
+        def json_safe(obj: object) -> object:
+            """Convert non-JSON-serializable objects to JSON-safe types."""
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            if isinstance(obj, dict):
+                return {k: json_safe(v) for k, v in obj.items()}
+            if isinstance(obj, list):
+                return [json_safe(item) for item in obj]
+            # Primitive JSON types pass through
+            if isinstance(obj, (str, int, float, bool, type(None))):
+                return obj
+            # Fallback: convert unknown types to string representation
+            return str(obj)
 
         serialized: list[dict[str, Any]] = []
         for msg in messages:
             if dataclasses.is_dataclass(msg) and not isinstance(msg, type):
                 # Convert dataclass to dict, handling nested types
                 try:
                     msg_dict = dataclasses.asdict(msg)
+                    # Convert datetime objects to ISO strings
+                    # Cast is safe: json_safe preserves dict structure
+                    msg_dict = cast(dict[str, Any], json_safe(msg_dict))
                     # Add kind discriminator for deserialization
                     if hasattr(msg, "kind"):
                         msg_dict["kind"] = msg.kind

app/features/agents/tests/test_routes.py

@@ -121,7 +121,7 @@ async def test_chat_success(self, client: AsyncClient) -> None:
         with patch("app.features.agents.agents.experiment.get_experiment_agent") as mock_get:
             mock_agent = MagicMock()
             mock_result = MagicMock()
-            mock_result.data = ExperimentReport(
+            mock_result.output = ExperimentReport(
                 run_id="run123",
                 status="success",
                 summary="Test completed",

app/features/agents/tests/test_service.py

@@ -269,7 +269,7 @@ async def test_chat_success(
         # Mock agent
         mock_agent = MagicMock()
         mock_agent_result = MagicMock()
-        mock_agent_result.data = sample_experiment_report
+        mock_agent_result.output = sample_experiment_report
         mock_usage = MagicMock()
         mock_usage.total_tokens = 100
         mock_agent_result.usage.return_value = mock_usage

app/features/rag/routes.py

@@ -4,6 +4,7 @@
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.core.config import get_settings
 from app.core.database import get_db
 from app.core.exceptions import DatabaseError
 from app.core.logging import get_logger
@@ -150,7 +151,7 @@ async def index_document(
 
 **Parameters:**
 - `top_k`: Number of results (1-50, default: 5)
-- `similarity_threshold`: Minimum similarity (0.0-1.0, default: 0.7)
+- `similarity_threshold`: Minimum similarity (0.0-1.0, default from RAG_SIMILARITY_THRESHOLD)
 - `filters`: Optional metadata filters
 
 **Filters:**
@@ -183,6 +184,11 @@ async def retrieve(
         HTTPException: If embedding generation fails.
         DatabaseError: If database operation fails.
     """
+    # Apply settings default if threshold not provided
+    settings = get_settings()
+    if request.similarity_threshold is None:
+        request.similarity_threshold = settings.rag_similarity_threshold
+
     logger.info(
         "rag.retrieve_request_received",
         query_length=len(request.query),

app/features/rag/schemas.py

@@ -79,8 +79,8 @@ class RetrieveRequest(BaseModel):
 
     query: str = Field(..., min_length=1, max_length=2000, description="Search query text")
     top_k: int = Field(default=5, ge=1, le=50, description="Number of results to return")
-    similarity_threshold: float = Field(
-        default=0.7, ge=0.0, le=1.0, description="Minimum similarity score"
+    similarity_threshold: float | None = Field(
+        default=None, ge=0.0, le=1.0, description="Minimum similarity score (default from settings)"
     )
     filters: dict[str, Any] | None = Field(
         None, description="Metadata filters (source_type, category, etc.)"

app/features/rag/service.py

@@ -287,14 +287,21 @@ async def retrieve(
         # Get total chunk count for statistics
         total_chunks = await self._get_total_chunk_count(db)
 
+        # Use local variable for effective threshold to avoid modifying request
+        effective_threshold = (
+            request.similarity_threshold
+            if request.similarity_threshold is not None
+            else self.settings.rag_similarity_threshold
+        )
+
         # Build similarity search query
         # CRITICAL: cosine_distance returns values 0-2, so relevance = 1 - distance/2
         # But for cosine similarity on normalized vectors, distance is 0-1
         results = await self._search_similar_chunks(
             db=db,
             query_embedding=query_embedding,
             top_k=request.top_k,
-            threshold=request.similarity_threshold,
+            threshold=effective_threshold,
             filters=request.filters,
         )
 

app/features/rag/tests/test_schemas.py

@@ -87,7 +87,8 @@ def test_valid_request_defaults(self):
         request = RetrieveRequest(query="What is forecasting?")
         assert request.query == "What is forecasting?"
         assert request.top_k == 5
-        assert request.similarity_threshold == 0.7
+        # similarity_threshold defaults to None (service uses settings fallback)
+        assert request.similarity_threshold is None
         assert request.filters is None
 
     def test_valid_request_custom_params(self):