Fix graph UX bugs + parallelize entity extraction

Graph UI:
- Side panel now closable (X button, click on canvas pane, ESC via reset)
- Click same entity twice to collapse instead of stack
- Memory node clicks open detail panel with full content + linked entities + neighbors
- Reset view button clears all expansions
- Dedupe nodes/edges so re-expanding doesn't double up
- Filter pills now visually muted when inactive (opacity 0.45)
- Auto-clear status messages after 6s
- Empty/filtered/loading states use the dashboard serif typography
- Canvas re-centers on clicked node so expanded children stay visible

API perf:
- backfill_entities_for_user now parallelizes with asyncio.gather + semaphore(5)
  100-memory backfill: ~100s sequential -> ~20s parallel
- _run_graph_extraction (per-conversation) parallelizes the same way (sem 3)

Dashboard fetch hygiene:
- Add AbortController-based request timeout (30s default, 5min for /graph/extract
  and /memories/import). Browser no longer hangs forever on slow endpoints.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: macayu17

api/services/extraction.py

@@ -152,13 +152,19 @@ async def _run_graph_extraction(
         return
     from api.services.graph import extract_entities_for_memory
 
-    try:
-        async with get_pool().acquire() as db:
-            for memory_id, content in memory_refs:
-                try:
+    pool = get_pool()
+    semaphore = asyncio.Semaphore(3)
+
+    async def _one(memory_id: UUID, content: str) -> None:
+        async with semaphore:
+            try:
+                async with pool.acquire() as db:
                     await extract_entities_for_memory(memory_id, content, user_id, resolved, db)
-                except Exception as inner_error:
-                    logger.warning("Entity extraction failed for memory %s: %s", memory_id, inner_error)
+            except Exception as inner_error:
+                logger.warning("Entity extraction failed for memory %s: %s", memory_id, inner_error)
+
+    try:
+        await asyncio.gather(*(_one(mid, content) for mid, content in memory_refs))
     except Exception as outer_error:
         logger.warning("Graph extraction task failed: %s", outer_error)
 

api/services/graph.py

@@ -1,8 +1,11 @@
+import asyncio
 import logging
 from uuid import UUID
 
 import asyncpg
 
+from api.db.connection import get_pool
+
 from api.services.providers.base import ExtractionProvider
 from api.services.providers.factory import build_extraction_provider
 from api.services.provider_keys import ResolvedProvider
@@ -186,6 +189,7 @@ async def backfill_entities_for_user(
     user_id: UUID,
     db: asyncpg.Connection,
     resolved: ResolvedProvider,
+    concurrency: int = 5,
 ) -> dict[str, int]:
     memories = await db.fetch(
         """
@@ -198,12 +202,22 @@ async def backfill_entities_for_user(
         """,
         user_id,
     )
-    processed = 0
-    entities_total = 0
-    for memory in memories:
-        count = await extract_entities_for_memory(
-            memory["id"], str(memory["content"]), user_id, resolved, db
-        )
-        processed += 1
-        entities_total += count
-    return {"processed": processed, "entities_created": entities_total}
+    if not memories:
+        return {"processed": 0, "entities_created": 0}
+
+    semaphore = asyncio.Semaphore(concurrency)
+    pool = get_pool()
+
+    async def _process(memory_row: asyncpg.Record) -> int:
+        async with semaphore:
+            async with pool.acquire() as conn:
+                try:
+                    return await extract_entities_for_memory(
+                        memory_row["id"], str(memory_row["content"]), user_id, resolved, conn
+                    )
+                except Exception as error:
+                    logger.warning("Backfill failed for memory %s: %s", memory_row["id"], error)
+                    return 0
+
+    results = await asyncio.gather(*(_process(memory) for memory in memories))
+    return {"processed": len(memories), "entities_created": sum(results)}