feat: add get_all_grant_summaries tool for efficient batch grant summarization

src/analyzer/chat/chat_tools.py

@@ -1,5 +1,6 @@
 # src/analyzer/chat/chat_tools.py
 from __future__ import annotations
+import asyncio
 import logging
 import re
 from dataclasses import dataclass
@@ -15,6 +16,11 @@ from ..context_builder import build_context_with_supporting
 from ..utils.errors import DataLoadError, ValidationError, LLMError
 from ..utils.text import clean, to_number
 from ..utils.dates import parse_date, format_date
+from ..summarizer_optimized import (  # NEW: Optimized caching + batch processing
+    SummaryCache,
+    summarize_grants_async,
+    extract_minimal_context,
+)
 
 
 # ---------------------------------------------------------------------
@@ -67,6 +73,9 @@ class ChatTools:
             logging.warning("Could not load search index: %s", e)
             self.support_idx = None
 
+        # Initialize cache for summaries (NEW: Optimized caching)
+        self.summary_cache = SummaryCache(ttl_seconds=3600)
+
     # -----------------------------------------------------------------
     # Status calculation (NEW)
     # -----------------------------------------------------------------
@@ -165,12 +174,104 @@ class ChatTools:
                     return r
         raise KeyError(f"Grant not found: {gid}")
 
+    # -----------------------------------------------------------------
+    # Batch Summarize Multiple Grants (NEW - Parallelized)
+    # -----------------------------------------------------------------
+    async def summarize_grants_batch(
+        self,
+        grant_ids: List[str],
+        include_supporting: bool = False,
+        batch_size: int = 5,
+    ):
+        """
+        Batch summarize multiple grants efficiently using parallel processing.
+
+        This method:
+        1. Resolves grant IDs to grant objects
+        2. Processes them in parallel batches (5 per batch by default)
+        3. Caches results for future use
+        4. Yields results as they complete (parallelized)
+
+        Args:
+            grant_ids: List of grant IDs to summarize
+            include_supporting: If True, include supporting materials (slower)
+            batch_size: Number of grants per batch (default 5)
+
+        Yields:
+            Dict with grant_id, title, summary_md as each completes
+        """
+        import asyncio
+
+        # Resolve all grant IDs to actual grant objects
+        grants_to_summarize = []
+        for gid in grant_ids:
+            try:
+                grant = self.get_grant(gid)
+                grants_to_summarize.append(grant)
+            except KeyError:
+                logging.warning(f"Grant not found: {gid}")
+                continue
+
+        if not grants_to_summarize:
+            logging.warning("No valid grants found to summarize")
+            return
+
+        logging.info(
+            f"📦 Starting batch summarization of {len(grants_to_summarize)} grants "
+            f"(batch_size={batch_size})"
+        )
+
+        # Use the optimized async batch processing function
+        try:
+            results = await summarize_grants_async(
+                grants_to_summarize,
+                past_winners=self.past,
+                client=self.client,
+                cache=self.summary_cache,
+                batch_size=batch_size,
+            )
+            # Yield each result as it's ready
+            for result in results:
+                yield result
+        except Exception as e:
+            logging.error(f"Batch summarization failed: {e}")
+            raise
+
+    async def get_all_grant_summaries(self, batch_size: int = 5):
+        """
+        Get summaries of ALL grants in a single efficient batch operation.
+
+        This method:
+        1. Extracts all grant IDs from current database
+        2. Summarizes them all in parallel batches
+        3. Returns all results formatted for display
+
+        Args:
+            batch_size: Number of grants per batch (default 5)
+
+        Yields:
+            Dict with grant_id, title, summary_md as each completes
+        """
+        # Get all grant IDs
+        all_grants = self.list_grants(limit=None)  # Get ALL grants
+        all_grant_ids = [g["id"] for g in all_grants]
+
+        if not all_grant_ids:
+            logging.warning("No grants found in database")
+            return
+
+        logging.info(f"📦 Getting summaries for ALL {len(all_grant_ids)} grants in batch")
+
+        # Use batch summarization with all IDs
+        async for result in self.summarize_grants_batch(all_grant_ids, batch_size=batch_size):
+            yield result
+
     # -----------------------------------------------------------------
     # Summarize a grant
     # -----------------------------------------------------------------
     def summarize_grant(self, gid: str, include_supporting: bool = True) -> Dict[str, Any]:
         """
-        Summarize a grant using LLM.
+        Summarize a grant using LLM with caching.
 
         Args:
             gid: Grant ID
@@ -181,6 +282,17 @@ class ChatTools:
         """
         row = self.get_grant(gid)
         title = row.get("title", "(untitled)")
+        grant_id = row.get("id") or gid
+
+        # NEW: Check cache first
+        cached_summary = self.summary_cache.get(row)
+        if cached_summary:
+            logging.info("📦 Cache HIT for grant %s", grant_id)
+            return {
+                "summary_md": cached_summary,
+                "title": title,
+                "id": grant_id,
+            }
 
         # Use enhanced context builder that includes supporting materials
         if include_supporting:
@@ -194,18 +306,26 @@ class ChatTools:
             context = self._build_basic_context(row)
 
         if not self.client or not self.client.is_ready():
-            return {
+            result = {
                 "summary_md": f"LLM unavailable — context excerpt:\n\n{context[:1000]}",
                 "title": title,
-                "id": row.get("id"),
+                "id": grant_id,
             }
+            self.summary_cache.set(row, result["summary_md"])
+            return result
 
         payload = build_prompt("openai", context)
         try:
             text = self.client.chat(payload["messages"], max_tokens=1200, temperature=0.25)
+            logging.info("✅ Generated summary for grant %s", grant_id)
         except Exception as e:
             text = f"LLM error: {e}\n\n{context[:800]}"
-        return {"summary_md": text, "title": title, "id": row.get("id")}
+            logging.error("❌ Failed to summarize %s: %s", grant_id, e)
+
+        # NEW: Cache the summary
+        self.summary_cache.set(row, text)
+
+        return {"summary_md": text, "title": title, "id": grant_id}
 
     # -----------------------------------------------------------------
     # Helper method for basic context (without supporting materials)

src/analyzer/chat/demo_app.py

@@ -30,6 +30,8 @@ from ..search.hybrid_index import load_index
 from .chat_tools import ChatTools
 from .tool_schemas import openai_tools, detect_extended_features
 from ..utils.query_logger import get_query_logger
+from ..summarizer_optimized import SummaryCache  # NEW: Optimized caching
+import asyncio  # NEW: For batch processing
 
 
 # Preset questions that are guaranteed to work
@@ -53,6 +55,7 @@ class GrantAnalystDemo:
         self.available_tools = []
         self.messages = []
         self.initialized = False
+        self.summary_cache = SummaryCache(ttl_seconds=3600)  # NEW: Cache summaries for 1 hour
 
     def initialize(self) -> Tuple[bool, str]:
         """
@@ -99,16 +102,50 @@ class GrantAnalystDemo:
             extended_mode = detect_extended_features()
             self.available_tools = openai_tools(extended=extended_mode)
 
+            # Log which tools are available
+            tool_names = [t["function"]["name"] for t in self.available_tools]
+            logging.info(f"✅ Loaded {len(tool_names)} tools: {', '.join(tool_names)}")
+            if extended_mode:
+                logging.info("✨ Extended tools ENABLED (fetch_link, insight_search)")
+            else:
+                logging.info("ℹ️ Extended tools DISABLED (run with ENABLE_EXTENDED_TOOLS=1 to enable)")
+
             # Initialize conversation
             self.messages = [
                 {
                     "role": "system",
                     "content": (
-                        "You are a helpful grant analyst assistant for Innovate UK grants. "
-                        "Use the available tools to answer user questions about grants, funding, "
-                        "deadlines, eligibility, and comparisons. Always use tools when you need "
-                        "to look up grant data. Format your responses with markdown for clarity. "
-                        "Current date: 2025-10-22."
+                        "You are an expert UK grant analyst assistant. Your PRIMARY DIRECTIVE is to EXECUTE user requests.\n\n"
+                        "WHEN USER ASKS FOR:\n"
+                        "- 'description/summaries of all/every grant' → IMMEDIATELY call get_all_grant_summaries (ONE SINGLE TOOL CALL)\n"
+                        "- 'description/summaries of grants' → IMMEDIATELY call summarize_grants_batch\n"
+                        "- 'list all grants' (NO descriptions) → IMMEDIATELY call list_grants with limit=None\n"
+                        "- 'find grants about [topic]' → IMMEDIATELY call search_grants\n"
+                        "- ANY REQUEST FOR INFORMATION → DO NOT DESCRIBE WHAT YOU WILL DO, JUST DO IT\n\n"
+                        "CRITICAL RULES:\n"
+                        "- DO NOT make multiple tool calls. Make ONE tool call and wait for results.\n"
+                        "- DO NOT return raw JSON lists when user asks for descriptions/summaries\n"
+                        "- When user asks for 'all grants', use get_all_grant_summaries (NOT list_grants + summarize)\n"
+                        "- DO NOT say 'I will do X' and then stop. ACTUALLY CALL THE TOOL.\n"
+                        "- DO NOT provide preliminary responses. CALL TOOLS FIRST, THEN RESPOND.\n"
+                        "- If user asks for information, ALWAYS use tools - NEVER make up answers.\n"
+                        "- Never promise to do something later. Do it immediately.\n\n"
+                        "SPECIFIC TOOL USAGE:\n"
+                        "- get_all_grant_summaries: For 'all grants', 'every grant', 'all grant opportunities' (ONE SINGLE CALL - most efficient)\n"
+                        "- summarize_grants_batch: For summaries/descriptions of specific grant groups\n"
+                        "- summarize_grant: Only for single grant details\n"
+                        "- list_grants: To get IDs/titles only (NOT for descriptions)\n"
+                        "- search_grants: For finding grants by topic/keyword\n"
+                        "- get_grant: For full structured data on one grant\n"
+                        "- compare_grants: For side-by-side comparisons\n\n"
+                        "RESPONSE FORMAT:\n"
+                        "- ALWAYS include complete tool results in your response\n"
+                        "- Do NOT paraphrase or summarize tool results - display them exactly as provided\n"
+                        "- Use markdown formatting (headers, bullets, tables)\n"
+                        "- Include all details: funding, eligibility, deadlines, scope\n"
+                        "- No length limits - be comprehensive\n"
+                        "- NEVER omit tool results from your response\n\n"
+                        "Current date: 2025-10-27"
                     )
                 }
             ]
@@ -138,6 +175,96 @@ class GrantAnalystDemo:
             elif tool_name == "summarize_grant":
                 return self.tools.summarize_grant(tool_args["grant_id"])
 
+            elif tool_name == "summarize_grants_batch":
+                # NEW: Batch summarization with parallel processing
+                grant_ids = tool_args.get("grant_ids", [])
+                batch_size = tool_args.get("batch_size", 5)
+
+                if not grant_ids:
+                    return "❌ No grant IDs provided for batch summarization"
+
+                logging.info(f"📦 Starting batch summarization of {len(grant_ids)} grants")
+
+                # Collect results from async generator
+                results = []
+                try:
+                    loop = asyncio.get_event_loop()
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+
+                async def collect_batch_results():
+                    """Collect all batch results."""
+                    async for result in self.tools.summarize_grants_batch(
+                        grant_ids,
+                        batch_size=batch_size
+                    ):
+                        results.append(result)
+
+                try:
+                    loop.run_until_complete(collect_batch_results())
+                except RuntimeError as e:
+                    if "already running" in str(e):
+                        # If loop is already running (shouldn't happen in Gradio), use current loop
+                        logging.warning(f"Event loop already running, using current loop")
+                        # In this case, we need to return a message instead
+                        return "⚠️ Batch summarization not available in this context. Please try individual summaries."
+                    raise
+
+                # Format results for display
+                if not results:
+                    return "❌ No grants could be summarized"
+
+                formatted = f"✅ Batch summarization complete for {len(results)} grants:\n\n"
+                for i, result in enumerate(results, 1):
+                    title = result.get("title", "(untitled)")
+                    summary = result.get("summary_md", "No summary")
+                    # Truncate long summaries for display
+                    if len(summary) > 500:
+                        summary = summary[:500] + "\n\n[... truncated ...]"
+                    formatted += f"**{i}. {title}**\n{summary}\n\n---\n\n"
+
+                return formatted
+
+            elif tool_name == "get_all_grant_summaries":
+                # Get summaries of ALL grants in one batch
+                batch_size = tool_args.get("batch_size", 5)
+
+                logging.info(f"📦 Starting to get summaries for ALL grants (batch_size={batch_size})")
+
+                # Collect results from async generator
+                results = []
+                try:
+                    loop = asyncio.get_event_loop()
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+
+                async def collect_all_summaries():
+                    """Collect all grant summaries."""
+                    async for result in self.tools.get_all_grant_summaries(batch_size=batch_size):
+                        results.append(result)
+
+                try:
+                    loop.run_until_complete(collect_all_summaries())
+                except RuntimeError as e:
+                    if "already running" in str(e):
+                        logging.warning(f"Event loop already running, using current loop")
+                        return "⚠️ Cannot get all summaries in this context. Please try specific summaries."
+                    raise
+
+                # Format results for display
+                if not results:
+                    return "❌ No grants could be summarized"
+
+                formatted = f"✅ Summaries for ALL {len(results)} grants:\n\n"
+                for i, result in enumerate(results, 1):
+                    title = result.get("title", "(untitled)")
+                    summary = result.get("summary_md", "No summary")
+                    formatted += f"**{i}. {title}**\n{summary}\n\n---\n\n"
+
+                return formatted
+
             elif tool_name == "compare_grants":
                 return self.tools.compare_grants(
                     tool_args["grant_id_a"],
@@ -154,13 +281,49 @@ class GrantAnalystDemo:
                 )
 
             elif tool_name == "search_grants":
-                return {
-                    "results": self.tools.list_grants(
-                        keyword=tool_args.get("query"),
-                        status=tool_args.get("status"),  # NEW: Add status filter
-                        limit=tool_args.get("limit")  # FIXED: Don't default to 10, pass None for all
-                    )
-                }
+                results = self.tools.list_grants(
+                    keyword=tool_args.get("query"),
+                    status=tool_args.get("status"),
+                    limit=tool_args.get("limit")  # If None, returns ALL
+                )
+                # Format results for better conversation flow (avoid bloating history)
+                if len(results) > 50:
+                    # If too many, return summary + first 20
+                    summary = f"Found {len(results)} grants matching the criteria. Showing first 20:\n"
+                    display = results[:20]
+                else:
+                    summary = f"Found {len(results)} grants:\n"
+                    display = results
+
+                formatted = summary + "\n".join([
+                    f"  • {r['title'][:60]} (ID: {r['id']}, Deadline: {r['deadline']}, Status: {r['status']})"
+                    for r in display
+                ])
+                return formatted
+
+            elif tool_name == "fetch_link":
+                # NEW: Handle external link fetching
+                try:
+                    from ..net.fetcher import fetch_link
+                    url = tool_args.get("url")
+                    if not url:
+                        return {"error": "No URL provided"}
+
+                    logging.info(f"Fetching external link: {url}")
+                    content = fetch_link(url)
+                    if not content:
+                        return {"error": f"Could not fetch content from {url}"}
+
+                    # Truncate very long content to avoid bloating conversation
+                    if len(content) > 10000:
+                        content = content[:10000] + "\n\n[... content truncated ...]"
+
+                    return content
+                except ImportError:
+                    return {"error": "Link fetching not available"}
+                except Exception as e:
+                    logging.error(f"Failed to fetch link {tool_args.get('url')}: {e}")
+                    return {"error": f"Failed to fetch link: {str(e)[:200]}"}
 
             else:
                 return {"error": f"Unknown tool: {tool_name}"}
@@ -187,19 +350,23 @@ class GrantAnalystDemo:
 
         start_time = time.time()
         tools_called = []
+        timing_info = {}
 
         try:
             # Add user message
             self.messages.append({"role": "user", "content": user_message})
 
             # Call LLM with function calling
+            llm_start = time.time()
             response = self.llm_client.client.chat.completions.create(
                 model=self.llm_client.model,
                 messages=self.messages,
                 tools=self.available_tools,
                 tool_choice="auto",
-                temperature=0.1,
+                temperature=0.5,  # INCREASED from 0.1 to allow more thorough, creative responses
+                max_tokens=4096,  # INCREASED to allow detailed summaries without truncation
             )
+            timing_info["llm_call"] = time.time() - llm_start
 
             response_message = response.choices[0].message
             tool_calls = response_message.tool_calls
@@ -210,15 +377,21 @@ class GrantAnalystDemo:
                 self.messages.append(response_message)
 
                 # Execute each tool call
+                tools_start = time.time()
                 for tool_call in tool_calls:
                     function_name = tool_call.function.name
-                    function_args = eval(tool_call.function.arguments)
+                    import json
+                    function_args = json.loads(tool_call.function.arguments)
 
                     logging.info(f"Calling: {function_name}({function_args})")
                     tools_called.append(function_name)  # Track for logging
 
                     # Execute tool
+                    tool_start = time.time()
                     tool_result = self._dispatch_tool(function_name, function_args)
+                    tool_time = time.time() - tool_start
+                    logging.info(f"⏱️ {function_name} took {tool_time:.2f}s")
+                    timing_info[f"tool_{function_name}"] = tool_time
 
                     # Add tool result
                     self.messages.append({
@@ -229,11 +402,14 @@ class GrantAnalystDemo:
                     })
 
                 # Get final response
+                final_start = time.time()
                 final_response = self.llm_client.client.chat.completions.create(
                     model=self.llm_client.model,
                     messages=self.messages,
-                    temperature=0.1,
+                    temperature=0.5,  # INCREASED from 0.1 for thorough final responses
+                    max_tokens=4096,  # INCREASED to allow complete answers without truncation
                 )
+                timing_info["final_llm_call"] = time.time() - final_start
 
                 assistant_message = final_response.choices[0].message.content
                 self.messages.append({"role": "assistant", "content": assistant_message})
@@ -242,8 +418,10 @@ class GrantAnalystDemo:
                 assistant_message = response_message.content
                 self.messages.append({"role": "assistant", "content": assistant_message})
 
-            # Log the interaction (for ALL users, not just you!)
+            # Log timing info
             response_time_ms = int((time.time() - start_time) * 1000)
+            timing_str = " | ".join([f"{k}:{v:.2f}s" for k, v in timing_info.items()])
+            logging.info(f"⏱️ Total: {response_time_ms}ms | {timing_str}")
 
             # Direct logging to CSV (simpler, more reliable)
             try:
@@ -494,7 +672,7 @@ def main():
         server_name="0.0.0.0",
         server_port=args.port,
         share=args.share,
-        show_error=True
+        show_error=True,
     )
 
 

src/analyzer/chat/tool_schemas.py

@@ -67,7 +67,8 @@ def openai_tools(*, extended: bool = False) -> List[Dict[str, Any]]:
                 "name": "search_grants",
                 "description": (
                     "Natural-language search over grants with optional structured filters. "
-                    "Use this for messy user prompts or when you need fuzzy matching."
+                    "Use this for messy user prompts or when you need fuzzy matching. "
+                    "If limit is not specified, returns ALL matching grants."
                 ),
                 "parameters": {
                     "type": "object",
@@ -79,8 +80,7 @@ def openai_tools(*, extended: bool = False) -> List[Dict[str, Any]]:
                         "filters": _filters_schema(),
                         "limit": {
                             "type": "integer",
-                            "description": "Maximum results to return.",
-                            "default": 10
+                            "description": "Maximum results to return. If omitted, returns ALL matching grants."
                         },
                     },
                     "required": ["query"],
@@ -170,6 +170,56 @@ def openai_tools(*, extended: bool = False) -> List[Dict[str, Any]]:
                 },
             },
         },
+        {
+            "type": "function",
+            "function": {
+                "name": "summarize_grants_batch",
+                "description": (
+                    "Batch summarize multiple grants efficiently in parallel. "
+                    "Much faster than summarizing grants individually when you need summaries for multiple grants. "
+                    "Results stream back as they complete. Use this when user asks for 'summaries for all', "
+                    "'summarize X grants', or when processing multiple search results."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "grant_ids": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "List of grant IDs to summarize (e.g., ['2313', '2314', '2315'])"
+                        },
+                        "batch_size": {
+                            "type": "integer",
+                            "description": "Number of grants to process per batch (default: 5)",
+                            "default": 5
+                        }
+                    },
+                    "required": ["grant_ids"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_all_grant_summaries",
+                "description": (
+                    "Get detailed summaries of ALL available grants in a single efficient batch operation. "
+                    "Perfect when user asks 'describe all grants', 'summaries of every grant', 'all grant opportunities', etc. "
+                    "Processes all grants in parallel batches for speed."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "batch_size": {
+                            "type": "integer",
+                            "description": "Number of grants to process per batch (default: 5)",
+                            "default": 5
+                        }
+                    },
+                    "required": [],
+                },
+            },
+        },
         {
             "type": "function",
             "function": {