From 7859c9806fc751d48931a9e8bea4d82ab063bb50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marek=20Jasi=C5=84ski?= <jasins.marek@gmail.com>
Date: Sun, 26 Apr 2026 14:53:48 +0200
Subject: [PATCH] feat: implement dynamic knowledge graph updates and state
 management services

---
 .../Services/IKnowledgeService.cs             |   1 +
 .../DTOs/AI/KnowledgePacket.cs                |  10 +-
 .../Graph/GetKnowledgeGraphQueryHandler.cs    |  21 +-
 .../Queries/Graph/GraphViewModels.cs          |   6 +-
 .../DependencyInjection.cs                    |   4 +-
 .../Services/KnowledgeService.cs              |  39 +++-
 .../Services/PromptRegistry.cs                |   8 +-
 .../Components/Atoms/NexusIcon.razor          |   3 +
 .../Molecules/AiAssistantBubble.razor         |   3 -
 .../Molecules/IntelligenceToolbar.razor       |  16 ++
 .../Molecules/IntelligenceToolbar.razor.css   |   5 +
 .../Components/Molecules/KnowledgeCheck.razor |  30 ++-
 .../Molecules/KnowledgeCheck.razor.css        |  15 ++
 .../Components/Organisms/KnowledgeGraph.razor |  16 ++
 .../Components/Organisms/ReaderCanvas.razor   |  26 +++
 .../Layout/MainLayout.razor                   |   6 +-
 .../Layout/MainLayout.razor.css               |  11 +
 .../Services/IKnowledgeGraphService.cs        |  15 ++
 .../Services/IQuizStateService.cs             |  11 +
 .../Services/KnowledgeCoordinator.cs          | 141 ++++++++++++
 .../Services/KnowledgeGraphService.cs         |  25 ++
 .../Services/QuizStateService.cs              |  29 +++
 .../wwwroot/js/knowledgeGraph.js              | 217 +++++++++++-------
 .../wwwroot/js/readerObserver.js              |  22 ++
 src/NexusReader.Web.Client/Program.cs         |   3 +
 .../Services/WasmKnowledgeService.cs          |  61 +++++
 .../NexusReader.Web.csproj                    |  43 ++--
 src/NexusReader.Web.New/Program.cs            |  31 ++-
 src/NexusReader.Web.New/appsettings.json      |   3 +-
 src/NexusReader.Web.New/nexus.db              | Bin 0 -> 57344 bytes
 30 files changed, 668 insertions(+), 153 deletions(-)
 create mode 100644 src/NexusReader.UI.Shared/Services/IKnowledgeGraphService.cs
 create mode 100644 src/NexusReader.UI.Shared/Services/KnowledgeCoordinator.cs
 create mode 100644 src/NexusReader.UI.Shared/Services/KnowledgeGraphService.cs
 create mode 100644 src/NexusReader.UI.Shared/wwwroot/js/readerObserver.js
 create mode 100644 src/NexusReader.Web.Client/Services/WasmKnowledgeService.cs
 create mode 100644 src/NexusReader.Web.New/nexus.db

diff --git a/src/NexusReader.Application/Abstractions/Services/IKnowledgeService.cs b/src/NexusReader.Application/Abstractions/Services/IKnowledgeService.cs
index 6d97bd8..f3d1100 100644
--- a/src/NexusReader.Application/Abstractions/Services/IKnowledgeService.cs
+++ b/src/NexusReader.Application/Abstractions/Services/IKnowledgeService.cs
@@ -6,4 +6,5 @@ namespace NexusReader.Application.Abstractions.Services;
 public interface IKnowledgeService
 {
     Task<Result<KnowledgePacket>> GetKnowledgeAsync(string text, CancellationToken cancellationToken = default);
+    Task<Result> ClearCacheAsync(CancellationToken cancellationToken = default);
 }
diff --git a/src/NexusReader.Application/DTOs/AI/KnowledgePacket.cs b/src/NexusReader.Application/DTOs/AI/KnowledgePacket.cs
index 0551612..a6a1c23 100644
--- a/src/NexusReader.Application/DTOs/AI/KnowledgePacket.cs
+++ b/src/NexusReader.Application/DTOs/AI/KnowledgePacket.cs
@@ -13,7 +13,9 @@ public record QuizQuestion(
     [property: JsonPropertyName("correct_index")] int CorrectIndex
 );
 
-public record KnowledgePacket(
-    [property: JsonPropertyName("concepts")] List<KeyConcept> Concepts,
-    [property: JsonPropertyName("quizzes")] List<QuizQuestion> Quizzes
-);
+public record KnowledgePacket
+{
+    [JsonPropertyName("concepts")] public List<KeyConcept> Concepts { get; init; } = new();
+    [JsonPropertyName("quizzes")] public List<QuizQuestion> Quizzes { get; init; } = new();
+    [JsonPropertyName("graph")] public NexusReader.Application.Queries.Graph.GraphDataDto? Graph { get; init; }
+}
diff --git a/src/NexusReader.Application/Queries/Graph/GetKnowledgeGraphQueryHandler.cs b/src/NexusReader.Application/Queries/Graph/GetKnowledgeGraphQueryHandler.cs
index b8e7e07..05f01ff 100644
--- a/src/NexusReader.Application/Queries/Graph/GetKnowledgeGraphQueryHandler.cs
+++ b/src/NexusReader.Application/Queries/Graph/GetKnowledgeGraphQueryHandler.cs
@@ -7,24 +7,9 @@ internal sealed class GetKnowledgeGraphQueryHandler : IQueryHandler<GetKnowledge
 {
     public Task<Result<GraphDataDto>> Handle(GetKnowledgeGraphQuery request, CancellationToken cancellationToken)
     {
-        var nodes = new List<GraphNodeDto>
-        {
-            new("renesans-intro", "Renesans", "Concept"),
-            new("florencja", "Florencja", "Location"),
-            new("medyceusze", "Medyceusze", "Entity"),
-            new("da-vinci-ai", "Leonardo da Vinci", "Person"),
-            new("humanizm", "Humanizm", "Concept")
-        };
+        var nodes = new List<GraphNodeDto>();
+        var links = new List<GraphLinkDto>();
 
-        var links = new List<GraphLinkDto>
-        {
-            new("renesans-intro", "florencja", 1),
-            new("florencja", "medyceusze", 2),
-            new("medyceusze", "da-vinci-ai", 3),
-            new("renesans-intro", "humanizm", 1),
-            new("da-vinci-ai", "humanizm", 2)
-        };
-
-        return Task.FromResult(Result.Ok(new GraphDataDto(nodes, links)));
+        return Task.FromResult(Result.Ok(new GraphDataDto { Nodes = nodes, Links = links }));
     }
 }
diff --git a/src/NexusReader.Application/Queries/Graph/GraphViewModels.cs b/src/NexusReader.Application/Queries/Graph/GraphViewModels.cs
index 00a0ce3..f9b4255 100644
--- a/src/NexusReader.Application/Queries/Graph/GraphViewModels.cs
+++ b/src/NexusReader.Application/Queries/Graph/GraphViewModels.cs
@@ -2,4 +2,8 @@ namespace NexusReader.Application.Queries.Graph;
 
 public record GraphNodeDto(string Id, string Label, string Group);
 public record GraphLinkDto(string Source, string Target, int Value);
-public record GraphDataDto(List<GraphNodeDto> Nodes, List<GraphLinkDto> Links);
+public record GraphDataDto
+{
+    public List<GraphNodeDto> Nodes { get; init; } = new();
+    public List<GraphLinkDto> Links { get; init; } = new();
+}
diff --git a/src/NexusReader.Infrastructure/DependencyInjection.cs b/src/NexusReader.Infrastructure/DependencyInjection.cs
index a9ae87b..021ca0c 100644
--- a/src/NexusReader.Infrastructure/DependencyInjection.cs
+++ b/src/NexusReader.Infrastructure/DependencyInjection.cs
@@ -24,9 +24,11 @@ public static class DependencyInjection
         services.Configure<AiSettings>(configuration.GetSection(AiSettings.SectionName));
         var aiSettings = configuration.GetSection(AiSettings.SectionName).Get<AiSettings>() ?? new AiSettings();
 
+        Console.WriteLine($"[Infrastructure] AI Configured: Model={aiSettings.Model}, KeyPresent={!string.IsNullOrWhiteSpace(aiSettings.ApiKey) && aiSettings.ApiKey != "PLACEHOLDER"}");
+
         if (string.IsNullOrWhiteSpace(aiSettings.ApiKey) || aiSettings.ApiKey == "PLACEHOLDER")
         {
-            // We don't throw here to allow the app to start, but services using AI will fail gracefully
+            Console.WriteLine("[Infrastructure] WARNING: AI API Key is missing or placeholder!");
         }
 
         services.AddResiliencePipeline("ai-retry", builder =>
diff --git a/src/NexusReader.Infrastructure/Services/KnowledgeService.cs b/src/NexusReader.Infrastructure/Services/KnowledgeService.cs
index 41f34b3..0643d39 100644
--- a/src/NexusReader.Infrastructure/Services/KnowledgeService.cs
+++ b/src/NexusReader.Infrastructure/Services/KnowledgeService.cs
@@ -41,12 +41,15 @@ public class KnowledgeService : IKnowledgeService
             return Result.Fail("Input text is empty.");
         }
 
+        Console.WriteLine($"[KnowledgeService] Starting extraction for text: {text.Substring(0, Math.Min(text.Length, 50))}...");
+
         // Normalize text to ensure consistent hashing and reduce token noise
         var normalizedText = ContentHasher.Normalize(text);
 
         // Phase 4: Request Pre-processing (Token Saving)
         if (normalizedText.Length > _settings.MaxInputLength)
         {
+            Console.WriteLine($"[KnowledgeService] Error: Input too long ({normalizedText.Length} > {_settings.MaxInputLength})");
             return Result.Fail($"Input text is too long ({normalizedText.Length} characters after normalization). Max allowed is {_settings.MaxInputLength}.");
         }
 
@@ -62,6 +65,7 @@ public class KnowledgeService : IKnowledgeService
 
         if (cached != null)
         {
+            Console.WriteLine($"[KnowledgeService] Cache hit for hash: {hash}");
             try
             {
                 var packet = JsonSerializer.Deserialize<KnowledgePacket>(cached.JsonData);
@@ -70,18 +74,19 @@ public class KnowledgeService : IKnowledgeService
                     return Result.Ok(packet);
                 }
             }
-            catch (JsonException)
+            catch (JsonException ex)
             {
-                // If deserialization fails, we proceed to call the AI
+                Console.WriteLine($"[KnowledgeService] Cache deserialization error: {ex.Message}");
             }
         }
 
         // 2. Call AI Client
         try
         {
+            Console.WriteLine($"[KnowledgeService] Calling Gemini AI with Model: {_settings.Model}...");
             var options = new ChatOptions
             {
-                ResponseFormat = ChatResponseFormat.Json,
+                // ResponseFormat = ChatResponseFormat.Json, // Disabled due to GeminiMappingException in current library version
                 Temperature = (float)_settings.Temperature,
                 MaxOutputTokens = _settings.MaxOutputTokens
             };
@@ -96,19 +101,24 @@ public class KnowledgeService : IKnowledgeService
             var jsonResponse = response.Text;
             if (string.IsNullOrWhiteSpace(jsonResponse))
             {
+                Console.WriteLine("[KnowledgeService] AI returned empty response.");
                 return Result.Fail("AI returned an empty response.");
             }
 
+            Console.WriteLine($"[KnowledgeService] AI Response received ({jsonResponse.Length} chars).");
+
             // Cleanup potential markdown if Gemini still adds it despite options
             jsonResponse = jsonResponse.Replace("```json", "").Replace("```", "").Trim();
 
             var knowledgePacket = JsonSerializer.Deserialize<KnowledgePacket>(jsonResponse);
             if (knowledgePacket == null)
             {
+                Console.WriteLine("[KnowledgeService] Failed to deserialize JSON response.");
                 return Result.Fail("Failed to deserialize AI response.");
             }
 
             // 3. Save to Cache
+            Console.WriteLine("[KnowledgeService] Saving result to cache...");
             var cacheEntry = new SemanticKnowledgeCache
             {
                 ContentHash = hash,
@@ -118,7 +128,6 @@ public class KnowledgeService : IKnowledgeService
                 CreatedAt = DateTime.UtcNow
             };
 
-            // Handle potential race condition if multiple requests for same text arrive
             if (cached == null)
             {
                 _dbContext.SemanticKnowledgeCache.Add(cacheEntry);
@@ -130,12 +139,34 @@ public class KnowledgeService : IKnowledgeService
             }
 
             await _dbContext.SaveChangesAsync(cancellationToken);
+            Console.WriteLine("[KnowledgeService] Extraction successful.");
 
             return Result.Ok(knowledgePacket);
         }
         catch (Exception ex)
         {
+            Console.WriteLine($"[KnowledgeService] CRITICAL ERROR: {ex.GetType().Name}: {ex.Message}");
+            if (ex.InnerException != null)
+                Console.WriteLine($"[KnowledgeService] Inner Error: {ex.InnerException.Message}");
+            
             return Result.Fail(new Error("Failed to extract knowledge from AI").CausedBy(ex));
         }
     }
+
+    public async Task<Result> ClearCacheAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            Console.WriteLine("[KnowledgeService] Clearing SemanticKnowledgeCache...");
+            _dbContext.SemanticKnowledgeCache.RemoveRange(_dbContext.SemanticKnowledgeCache);
+            await _dbContext.SaveChangesAsync(cancellationToken);
+            Console.WriteLine("[KnowledgeService] Cache cleared successfully.");
+            return Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[KnowledgeService] Error clearing cache: {ex.Message}");
+            return Result.Fail($"Failed to clear cache: {ex.Message}");
+        }
+    }
 }
diff --git a/src/NexusReader.Infrastructure/Services/PromptRegistry.cs b/src/NexusReader.Infrastructure/Services/PromptRegistry.cs
index 628396e..08e1023 100644
--- a/src/NexusReader.Infrastructure/Services/PromptRegistry.cs
+++ b/src/NexusReader.Infrastructure/Services/PromptRegistry.cs
@@ -3,7 +3,11 @@ namespace NexusReader.Infrastructure.Services;
 public static class PromptRegistry
 {
     public const string KnowledgeExtractionSystemPrompt = 
-        "You are an expert educator. Analyze the provided text to extract key concepts and generate relevant quizzes. " +
+        "You are an expert educator. Analyze the provided text to extract key concepts, generate relevant quizzes, and construct a knowledge graph. " +
         "CRITICAL: Return ONLY a minified JSON object. Do NOT include markdown formatting like ```json or ```. Do NOT include explanations. " +
-        "Schema: { \"concepts\": [ { \"title\": \"string\", \"description\": \"string\" } ], \"quizzes\": [ { \"question\": \"string\", \"options\": [ \"string\" ], \"correct_index\": 0 } ] }.";
+        "Schema: { " +
+        "\"concepts\": [ { \"title\": \"string\", \"description\": \"string\" } ], " +
+        "\"quizzes\": [ { \"question\": \"string\", \"options\": [ \"string\" ], \"correct_index\": 0 } ], " +
+        "\"graph\": { \"nodes\": [ { \"id\": \"string\", \"label\": \"string\", \"group\": \"concept\" } ], \"links\": [ { \"source\": \"string\", \"target\": \"string\", \"value\": 1 } ] } " +
+        "}.";
 }
diff --git a/src/NexusReader.UI.Shared/Components/Atoms/NexusIcon.razor b/src/NexusReader.UI.Shared/Components/Atoms/NexusIcon.razor
index 1e48266..face0e9 100644
--- a/src/NexusReader.UI.Shared/Components/Atoms/NexusIcon.razor
+++ b/src/NexusReader.UI.Shared/Components/Atoms/NexusIcon.razor
@@ -25,6 +25,9 @@
         case "target":
             <circle cx="12" cy="12" r="10" /><circle cx="12" cy="12" r="6" /><circle cx="12" cy="12" r="2" />
             break;
+        case "trash":
+            <path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2M10 11v6M14 11v6" />
+            break;
         default:
             <!-- Fallback circle -->
             <circle cx="12" cy="12" r="10" />
diff --git a/src/NexusReader.UI.Shared/Components/Molecules/AiAssistantBubble.razor b/src/NexusReader.UI.Shared/Components/Molecules/AiAssistantBubble.razor
index 6bee4ae..37ab954 100644
--- a/src/NexusReader.UI.Shared/Components/Molecules/AiAssistantBubble.razor
+++ b/src/NexusReader.UI.Shared/Components/Molecules/AiAssistantBubble.razor
@@ -31,13 +31,10 @@
     [Parameter] public List<string> Actions { get; set; } = new();
     [Parameter] public EventCallback<string> OnActionTriggered { get; set; }
 
-    private bool _isQuizMode = false;
-
     private async Task HandleActionClick(string action)
     {
         if (action.Contains("quiz", StringComparison.OrdinalIgnoreCase))
         {
-            _isQuizMode = true;
             QuizState.RequestQuiz(ContextBlockId);
         }
 
diff --git a/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor b/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor
index ebbe682..40da5ff 100644
--- a/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor
+++ b/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor
@@ -1,5 +1,7 @@
 @using NexusReader.UI.Shared.Services
+@using NexusReader.Application.Abstractions.Services
 @inject IFocusModeService FocusMode
+@inject IKnowledgeService KnowledgeService
 
 <aside class="intelligence-toolbar">
     <div class="toolbar-top">
@@ -21,6 +23,9 @@
         <button class="toolbar-item" title="Search">
             <NexusIcon Name="search" Size="20" />
         </button>
+        <button class="toolbar-item danger" @onclick="HandleClearCache" title="Clear AI Cache">
+            <NexusIcon Name="trash" Size="20" />
+        </button>
     </div>
 
     <div class="toolbar-bottom">
@@ -40,6 +45,17 @@
         FocusMode.OnFocusModeChanged += StateHasChanged;
     }
 
+    private async Task HandleClearCache()
+    {
+        // For now, a simple console log confirm or just do it
+        Console.WriteLine("[IntelligenceToolbar] Requesting cache clear...");
+        var result = await KnowledgeService.ClearCacheAsync();
+        if (result.IsSuccess)
+        {
+            Console.WriteLine("[IntelligenceToolbar] Cache cleared successfully!");
+        }
+    }
+
     public void Dispose()
     {
         FocusMode.OnFocusModeChanged -= StateHasChanged;
diff --git a/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor.css b/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor.css
index 9a77f32..eaa1e48 100644
--- a/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor.css
+++ b/src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor.css
@@ -65,3 +65,8 @@
 .rotate-180 {
     transform: rotate(180deg);
 }
+
+.toolbar-item.danger:hover {
+    color: #ff4d4d;
+    background: rgba(255, 77, 77, 0.1);
+}
diff --git a/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor b/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor
index ffbecfe..2c648df 100644
--- a/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor
+++ b/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor
@@ -4,6 +4,7 @@
 @using NexusReader.Application.Abstractions.Services
 @inject IMediator Mediator
 @inject IPlatformService PlatformService
+@inject IQuizStateService QuizService
 
 <div class="knowledge-check">
     <div class="quiz-header">
@@ -11,14 +12,14 @@
         <button class="expand-btn">⌵</button>
     </div>
 
-    @if (_isLoading)
+    @if (QuizService.IsHydrating)
     {
-        <div class="loading-state">Pobieranie pytań...</div>
+        <div class="loading-state shimmer">Skanowanie wiedzy przez AI...</div>
     }
-    else if (_quiz != null)
+    else if (QuizService.CurrentQuiz != null)
     {
         <div class="quiz-body">
-            @foreach (var question in _quiz.Questions)
+            @foreach (var question in QuizService.CurrentQuiz.Questions)
             {
                 <div class="question-container">
                     <p class="question-text">@question.Question</p>
@@ -50,21 +51,16 @@
 @code {
     [Parameter] public string ContextBlockId { get; set; } = string.Empty;
 
-    private bool _isLoading = true;
-    private QuizDto? _quiz;
-    
     private Dictionary<QuizQuestionDto, (int SelectedIndex, bool IsCorrect)> _states = new();
 
-    protected override async Task OnInitializedAsync()
+    protected override void OnInitialized()
     {
-        _isLoading = true;
-        var query = new GetQuizQuestionsQuery(ContextBlockId);
-        var result = await Mediator.Send(query);
-        
-        if (result.IsSuccess)
-            _quiz = result.Value;
-            
-        _isLoading = false;
+        QuizService.OnQuizUpdated += () => InvokeAsync(StateHasChanged);
+    }
+
+    public void Dispose()
+    {
+        QuizService.OnQuizUpdated -= StateHasChanged;
     }
 
     private async Task SelectOptionAsync(QuizQuestionDto question, int index)
@@ -89,7 +85,7 @@
 
     private bool AllQuestionsAnswered()
     {
-        return _quiz != null && _states.Count == _quiz.Questions.Count;
+        return QuizService.CurrentQuiz != null && _states.Count == QuizService.CurrentQuiz.Questions.Count;
     }
 
 
diff --git a/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor.css b/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor.css
index 5237354..887cf2b 100644
--- a/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor.css
+++ b/src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor.css
@@ -106,3 +106,18 @@
     border-color: #ff4444 !important;
     background: rgba(255, 68, 68, 0.1) !important;
 }
+
+.loading-state.shimmer {
+    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.05), transparent);
+    background-size: 200% 100%;
+    animation: shimmer 1.5s infinite;
+    padding: 20px;
+    text-align: center;
+    color: var(--nexus-neon);
+    text-shadow: 0 0 10px var(--nexus-neon);
+}
+
+@keyframes shimmer {
+    0% { background-position: -200% 0; }
+    100% { background-position: 200% 0; }
+}
diff --git a/src/NexusReader.UI.Shared/Components/Organisms/KnowledgeGraph.razor b/src/NexusReader.UI.Shared/Components/Organisms/KnowledgeGraph.razor
index 5726f91..2fa79a7 100644
--- a/src/NexusReader.UI.Shared/Components/Organisms/KnowledgeGraph.razor
+++ b/src/NexusReader.UI.Shared/Components/Organisms/KnowledgeGraph.razor
@@ -6,6 +6,7 @@
 @inject IMediator Mediator
 @inject IJSRuntime JS
 @inject IFocusModeService FocusMode
+@inject IKnowledgeGraphService GraphService
 
 <div class="knowledge-graph-container" id="@ContainerId">
     @if (GraphData == null)
@@ -37,6 +38,21 @@
     protected override void OnInitialized()
     {
         FocusMode.OnFocusModeChanged += HandleFocusSimulation;
+        GraphService.OnGraphUpdated += HandleGraphUpdate;
+        GraphService.OnActiveNodeChanged += HandleActiveNodeChange;
+    }
+
+    private async void HandleGraphUpdate()
+    {
+        if (_module == null) return;
+        await _module.InvokeVoidAsync("updateData", GraphService.CurrentGraphData);
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async void HandleActiveNodeChange(string nodeId)
+    {
+        if (_module == null) return;
+        await _module.InvokeVoidAsync("setActiveNode", nodeId);
     }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
diff --git a/src/NexusReader.UI.Shared/Components/Organisms/ReaderCanvas.razor b/src/NexusReader.UI.Shared/Components/Organisms/ReaderCanvas.razor
index 11d7e14..873da36 100644
--- a/src/NexusReader.UI.Shared/Components/Organisms/ReaderCanvas.razor
+++ b/src/NexusReader.UI.Shared/Components/Organisms/ReaderCanvas.razor
@@ -8,6 +8,7 @@
 @inject IThemeService ThemeService
 @inject IFocusModeService FocusMode
 @inject IReaderNavigationService NavigationService
+@inject KnowledgeCoordinator Coordinator
 
 <div class="reader-canvas @(ThemeService.IsLightMode ? "theme-light" : "theme-dark")">
     @if (ViewModel == null)
@@ -59,6 +60,31 @@
     {
         await LoadChapterAsync(NavigationService.CurrentChapterIndex);
         StateHasChanged();
+        await InitializeObserverAsync();
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await InitializeObserverAsync();
+        }
+    }
+
+    private async Task InitializeObserverAsync()
+    {
+        try
+        {
+            var module = await JS.InvokeAsync<IJSObjectReference>("import", "./_content/NexusReader.UI.Shared/js/readerObserver.js");
+            await module.InvokeVoidAsync("initObserver", DotNetObjectReference.Create(this), ".reader-flow-container", ".block-wrapper");
+        }
+        catch { }
+    }
+
+    [JSInvokable]
+    public void HandleBlockReached(string blockId, string content)
+    {
+        Coordinator.OnBlockReached(blockId, content);
     }
 
     private async Task LoadChapterAsync(int index)
diff --git a/src/NexusReader.UI.Shared/Layout/MainLayout.razor b/src/NexusReader.UI.Shared/Layout/MainLayout.razor
index c4993f8..d54642b 100644
--- a/src/NexusReader.UI.Shared/Layout/MainLayout.razor
+++ b/src/NexusReader.UI.Shared/Layout/MainLayout.razor
@@ -5,6 +5,8 @@
 @using NexusReader.UI.Shared.Components.Organisms
 @inject IPlatformService PlatformService
 @inject IFocusModeService FocusMode
+@inject IQuizStateService QuizService
+@implements IDisposable
 
 <div class="app-container @_platformClass @(FocusMode.IsFocusModeActive ? "focus-mode-active" : "")">
     <div class="reader-pane">
@@ -18,7 +20,7 @@
         <IntelligenceToolbar />
         <div class="intelligence-content">
             <div class="intelligence-header">
-                <NexusIcon Name="robot" Size="20" Class="neon-glow" />
+                <NexusIcon Name="robot" Size="20" Class="@($"neon-glow {(QuizService.HasNewQuiz ? "quiz-available" : "")}")" />
                 <span>Asystent AI i Interaktywna Mapa</span>
                 <button class="close-btn">×</button>
             </div>
@@ -43,6 +45,7 @@
     protected override void OnInitialized()
     {
         FocusMode.OnFocusModeChanged += StateHasChanged;
+        QuizService.OnQuizUpdated += StateHasChanged;
         
         var context = PlatformService.GetDeviceContext();
         if (context.IsSuccess)
@@ -58,6 +61,7 @@
     public void Dispose()
     {
         FocusMode.OnFocusModeChanged -= StateHasChanged;
+        QuizService.OnQuizUpdated -= StateHasChanged;
     }
 }
 
diff --git a/src/NexusReader.UI.Shared/Layout/MainLayout.razor.css b/src/NexusReader.UI.Shared/Layout/MainLayout.razor.css
index 13e9d3e..36c8967 100644
--- a/src/NexusReader.UI.Shared/Layout/MainLayout.razor.css
+++ b/src/NexusReader.UI.Shared/Layout/MainLayout.razor.css
@@ -120,4 +120,15 @@ main {
     position: absolute;
     right: 0.75rem;
     top: 0.5rem;
+}
+
+.quiz-available {
+    animation: quiz-pulse 1.5s infinite;
+    color: var(--nexus-neon) !important;
+}
+
+@keyframes quiz-pulse {
+    0% { filter: drop-shadow(0 0 2px var(--nexus-neon)); transform: scale(1); }
+    50% { filter: drop-shadow(0 0 10px var(--nexus-neon)); transform: scale(1.1); }
+    100% { filter: drop-shadow(0 0 2px var(--nexus-neon)); transform: scale(1); }
 }
\ No newline at end of file
diff --git a/src/NexusReader.UI.Shared/Services/IKnowledgeGraphService.cs b/src/NexusReader.UI.Shared/Services/IKnowledgeGraphService.cs
new file mode 100644
index 0000000..9993be4
--- /dev/null
+++ b/src/NexusReader.UI.Shared/Services/IKnowledgeGraphService.cs
@@ -0,0 +1,15 @@
+using NexusReader.Application.Queries.Graph;
+
+namespace NexusReader.UI.Shared.Services;
+
+public interface IKnowledgeGraphService
+{
+    GraphDataDto? CurrentGraphData { get; }
+    string? ActiveNodeId { get; }
+    
+    event Action? OnGraphUpdated;
+    event Action<string>? OnActiveNodeChanged;
+    
+    void UpdateGraph(GraphDataDto newData);
+    void SetActiveNode(string nodeId);
+}
diff --git a/src/NexusReader.UI.Shared/Services/IQuizStateService.cs b/src/NexusReader.UI.Shared/Services/IQuizStateService.cs
index 9dd705b..e3a5ffc 100644
--- a/src/NexusReader.UI.Shared/Services/IQuizStateService.cs
+++ b/src/NexusReader.UI.Shared/Services/IQuizStateService.cs
@@ -1,8 +1,19 @@
+using NexusReader.Application.Queries.Quiz;
+
 namespace NexusReader.UI.Shared.Services;
 
 public interface IQuizStateService
 {
     string? CurrentQuizBlockId { get; }
+    QuizDto? CurrentQuiz { get; }
+    bool IsHydrating { get; }
+    bool HasNewQuiz { get; }
+    
     event Action<string>? OnQuizRequested;
+    event Action? OnQuizUpdated;
+    
     void RequestQuiz(string blockId);
+    void SetQuiz(string blockId, QuizDto quiz);
+    void SetHydrating(bool hydrating);
+    void MarkQuizAsSeen();
 }
diff --git a/src/NexusReader.UI.Shared/Services/KnowledgeCoordinator.cs b/src/NexusReader.UI.Shared/Services/KnowledgeCoordinator.cs
new file mode 100644
index 0000000..629eeb2
--- /dev/null
+++ b/src/NexusReader.UI.Shared/Services/KnowledgeCoordinator.cs
@@ -0,0 +1,141 @@
+using NexusReader.Application.Abstractions.Services;
+using NexusReader.Application.Queries.Graph;
+using NexusReader.Application.Queries.Quiz;
+using NexusReader.UI.Shared.Services;
+
+namespace NexusReader.UI.Shared.Services;
+
+public sealed class KnowledgeCoordinator : IDisposable
+{
+    private readonly IKnowledgeService _knowledgeService;
+    private readonly IKnowledgeGraphService _graphService;
+    private readonly IQuizStateService _quizService;
+    private readonly IPlatformService _platformService;
+    
+    private CancellationTokenSource? _debounceCts;
+
+    public KnowledgeCoordinator(
+        IKnowledgeService knowledgeService,
+        IKnowledgeGraphService graphService,
+        IQuizStateService quizService,
+        IPlatformService platformService)
+    {
+        _knowledgeService = knowledgeService;
+        _graphService = graphService;
+        _quizService = quizService;
+        _platformService = platformService;
+    }
+
+    public void OnBlockReached(string blockId, string content)
+    {
+        Console.WriteLine($"[KnowledgeCoordinator] Block reached: {blockId}");
+        
+        // 1. Skip extraction for the title page (usually the first block or contains 'title')
+        if (blockId.Equals("seg-0", StringComparison.OrdinalIgnoreCase) || 
+            blockId.Contains("title", StringComparison.OrdinalIgnoreCase) ||
+            content.Length < 50) // Title pages are usually short
+        {
+            Console.WriteLine($"[KnowledgeCoordinator] Skipping extraction for title page/short block: {blockId}");
+            _graphService.SetActiveNode(blockId);
+            return;
+        }
+
+        // 2. Update active node immediately for "TU JESTEŚ" logic
+        _graphService.SetActiveNode(blockId);
+
+        // 3. Debounce the AI extraction to prevent spamming while scrolling
+        _debounceCts?.Cancel();
+        _debounceCts = new CancellationTokenSource();
+        var token = _debounceCts.Token;
+
+        _ = DebounceAndExtractAsync(blockId, content, token);
+    }
+
+    private async Task DebounceAndExtractAsync(string blockId, string content, CancellationToken token)
+    {
+        try
+        {
+            await Task.Delay(1000, token);
+            if (token.IsCancellationRequested) return;
+
+            Console.WriteLine($"[KnowledgeCoordinator] Triggering extraction for block: {blockId}");
+            await ProcessKnowledgeExtractionAsync(blockId, content, token);
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[KnowledgeCoordinator] Unexpected error in task: {ex.Message}");
+        }
+    }
+
+    private async Task ProcessKnowledgeExtractionAsync(string blockId, string content, CancellationToken ct)
+    {
+        _quizService.SetHydrating(true);
+
+        var result = await _knowledgeService.GetKnowledgeAsync(content, ct);
+
+        if (result.IsSuccess && !ct.IsCancellationRequested)
+        {
+            Console.WriteLine($"[KnowledgeCoordinator] Extraction success for block: {blockId}. Updating state...");
+            var packet = result.Value;
+
+            // Update Quiz State
+            var quizQuestions = packet.Quizzes
+                .Select(q => new QuizQuestionDto(q.Question, q.Options, q.CorrectIndex))
+                .ToList();
+            _quizService.SetQuiz(blockId, new QuizDto(quizQuestions));
+
+            // Update Graph State
+            GraphDataDto graphData;
+            if (packet.Graph != null && packet.Graph.Nodes != null && packet.Graph.Nodes.Any())
+            {
+                // Use AI-generated graph
+                graphData = packet.Graph;
+                
+                // Ensure current block is linked to the first concept or added if missing
+                if (!graphData.Nodes.Any(n => n.Id == blockId))
+                {
+                    graphData.Nodes.Add(new GraphNodeDto(blockId, "TU JESTEŚ", "current"));
+                    if (graphData.Nodes.Count > 1)
+                    {
+                        graphData.Links.Add(new GraphLinkDto(blockId, graphData.Nodes[0].Id, 1));
+                    }
+                }
+            }
+            else
+            {
+                // Fallback: Transform Concepts to GraphData if AI didn't provide a graph
+                var nodes = packet.Concepts
+                    .Select(c => new GraphNodeDto(c.Title.ToLowerInvariant(), c.Title, "concept"))
+                    .ToList();
+                
+                nodes.Add(new GraphNodeDto(blockId, "TU JESTEŚ", "current"));
+
+                var links = packet.Concepts
+                    .Select(c => new GraphLinkDto(blockId, c.Title.ToLowerInvariant(), 1))
+                    .ToList();
+                
+                graphData = new GraphDataDto { Nodes = nodes, Links = links };
+            }
+
+            _graphService.UpdateGraph(graphData);
+
+            // Visual/Haptic Feedback
+            await _platformService.VibrateSuccessAsync();
+        }
+        else
+        {
+            if (!ct.IsCancellationRequested)
+            {
+                Console.WriteLine($"[KnowledgeCoordinator] Extraction failed or returned empty for block: {blockId}. Error: {result.Errors.FirstOrDefault()?.Message}");
+            }
+            _quizService.SetHydrating(false);
+        }
+    }
+
+    public void Dispose()
+    {
+        _debounceCts?.Cancel();
+        _debounceCts?.Dispose();
+    }
+}
diff --git a/src/NexusReader.UI.Shared/Services/KnowledgeGraphService.cs b/src/NexusReader.UI.Shared/Services/KnowledgeGraphService.cs
new file mode 100644
index 0000000..ad8970a
--- /dev/null
+++ b/src/NexusReader.UI.Shared/Services/KnowledgeGraphService.cs
@@ -0,0 +1,25 @@
+using NexusReader.Application.Queries.Graph;
+
+namespace NexusReader.UI.Shared.Services;
+
+public sealed class KnowledgeGraphService : IKnowledgeGraphService
+{
+    public GraphDataDto? CurrentGraphData { get; private set; }
+    public string? ActiveNodeId { get; private set; }
+
+    public event Action? OnGraphUpdated;
+    public event Action<string>? OnActiveNodeChanged;
+
+    public void UpdateGraph(GraphDataDto newData)
+    {
+        CurrentGraphData = newData;
+        OnGraphUpdated?.Invoke();
+    }
+
+    public void SetActiveNode(string nodeId)
+    {
+        if (ActiveNodeId == nodeId) return;
+        ActiveNodeId = nodeId;
+        OnActiveNodeChanged?.Invoke(nodeId);
+    }
+}
diff --git a/src/NexusReader.UI.Shared/Services/QuizStateService.cs b/src/NexusReader.UI.Shared/Services/QuizStateService.cs
index 25f1843..db42467 100644
--- a/src/NexusReader.UI.Shared/Services/QuizStateService.cs
+++ b/src/NexusReader.UI.Shared/Services/QuizStateService.cs
@@ -1,13 +1,42 @@
+using NexusReader.Application.Queries.Quiz;
+
 namespace NexusReader.UI.Shared.Services;
 
 public sealed class QuizStateService : IQuizStateService
 {
     public string? CurrentQuizBlockId { get; private set; }
+    public QuizDto? CurrentQuiz { get; private set; }
+    public bool IsHydrating { get; private set; }
+    public bool HasNewQuiz { get; private set; }
+
     public event Action<string>? OnQuizRequested;
+    public event Action? OnQuizUpdated;
 
     public void RequestQuiz(string blockId)
     {
         CurrentQuizBlockId = blockId;
         OnQuizRequested?.Invoke(blockId);
     }
+
+    public void SetQuiz(string blockId, QuizDto quiz)
+    {
+        CurrentQuizBlockId = blockId;
+        CurrentQuiz = quiz;
+        IsHydrating = false;
+        HasNewQuiz = true;
+        OnQuizUpdated?.Invoke();
+    }
+
+    public void SetHydrating(bool hydrating)
+    {
+        IsHydrating = hydrating;
+        OnQuizUpdated?.Invoke();
+    }
+
+    public void MarkQuizAsSeen()
+    {
+        if (!HasNewQuiz) return;
+        HasNewQuiz = false;
+        OnQuizUpdated?.Invoke();
+    }
 }
diff --git a/src/NexusReader.UI.Shared/wwwroot/js/knowledgeGraph.js b/src/NexusReader.UI.Shared/wwwroot/js/knowledgeGraph.js
index 82c92db..e6ca24b 100644
--- a/src/NexusReader.UI.Shared/wwwroot/js/knowledgeGraph.js
+++ b/src/NexusReader.UI.Shared/wwwroot/js/knowledgeGraph.js
@@ -4,12 +4,15 @@ let simulation;
 let zoomBehavior;
 let svgElement;
 
+let node, link, rootGroup, badge, width, height, currentDotNetHelper;
+
 export function mount(containerId, data, dotNetHelper) {
     const container = document.getElementById(containerId);
     if (!container) return;
 
-    const width = container.clientWidth || 400;
-    const height = container.clientHeight || 400;
+    currentDotNetHelper = dotNetHelper;
+    width = container.clientWidth || 400;
+    height = container.clientHeight || 400;
 
     // Create SVG
     svgElement = d3.select(container).append("svg")
@@ -28,12 +31,17 @@ export function mount(containerId, data, dotNetHelper) {
     radialGradient.append("stop").attr("offset", "100%").attr("stop-color", "var(--nexus-neon)").attr("stop-opacity", 0);
 
     // Root Group for Zoom
-    const rootGroup = svgElement.append("g").attr("class", "zoom-containment");
+    rootGroup = svgElement.append("g").attr("class", "zoom-containment");
+
+    // Container groups for links and nodes to keep order (links below nodes)
+    rootGroup.append("g").attr("class", "links-layer");
+    rootGroup.append("g").attr("class", "nodes-layer");
 
     // Badge Element (TU JESTEŚ)
-    const badge = rootGroup.append("g")
+    badge = rootGroup.append("g")
         .attr("class", "active-badge")
-        .style("display", "none");
+        .style("display", "none")
+        .style("pointer-events", "none");
 
     badge.append("rect")
         .attr("x", -35)
@@ -53,92 +61,120 @@ export function mount(containerId, data, dotNetHelper) {
 
     // Attach Zoom Behavior
     zoomBehavior = d3.zoom()
-        .scaleExtent([0.5, 4])
+        .scaleExtent([0.3, 4])
         .on("zoom", (e) => rootGroup.attr("transform", e.transform));
     
-    // Apply zoom but disable wheel interaction
-    svgElement.call(zoomBehavior)
-        .on("wheel.zoom", null);
+    svgElement.call(zoomBehavior).on("wheel.zoom", null);
 
-
-    // Subtle Link Distance & Charge
-    simulation = d3.forceSimulation(data.nodes)
-        .force("link", d3.forceLink(data.links).id(d => d.id).distance(100))
-        .force("charge", d3.forceManyBody().strength(-300))
+    simulation = d3.forceSimulation()
+        .force("link", d3.forceLink().id(d => d.id).distance(120))
+        .force("charge", d3.forceManyBody().strength(-400))
         .force("center", d3.forceCenter(width / 2, height / 2))
-        .force("collide", d3.forceCollide().radius(40));
-
-    // Links
-    const link = rootGroup.append("g")
-        .selectAll("path")
-        .data(data.links)
-        .join("path")
-        .attr("stroke", "rgba(255,255,255,0.1)")
-        .attr("fill", "none")
-        .attr("stroke-width", 1.5);
-
-    // Nodes
-    const node = rootGroup.append("g")
-        .selectAll("g")
-        .data(data.nodes)
-        .join("g")
-        .style("cursor", "pointer")
-        .on("click", (e, d) => {
-            // Remove active state from all, add to clicked
-            node.selectAll(".node-pill").classed("nexus-node-active", false);
-            d3.select(e.currentTarget).select(".node-pill").classed("nexus-node-active", true);
-            
-            // Show badge
-            badge.style("display", "block").datum(d);
-            
-            dotNetHelper.invokeMethodAsync('OnNodeClicked', d.id);
-        })
-        .call(drag(simulation));
-
-    // Outer glow for nodes
-    node.append("circle")
-        .attr("r", 30)
-        .attr("fill", "url(#nebulaGlow)")
-        .attr("opacity", d => d.id === 'root' ? 0.6 : 0.2);
-
-    // Pill shape
-    node.append("rect")
-        .attr("class", "node-pill")
-        .attr("x", d => -(d.label.length * 4 + 10))
-        .attr("y", -12)
-        .attr("width", d => d.label.length * 8 + 20)
-        .attr("height", 24)
-        .attr("rx", 12)
-        .attr("fill", "rgba(30, 30, 30, 0.8)")
-        .attr("stroke", "rgba(255, 255, 255, 0.1)")
-        .attr("stroke-width", 1);
-
-    // Labels
-    node.append("text")
-        .text(d => d.label)
-        .attr("text-anchor", "middle")
-        .attr("y", 4)
-        .attr("fill", "#ccc")
-        .attr("font-family", "var(--nexus-font-sans)")
-        .attr("font-size", "0.8rem");
+        .force("collide", d3.forceCollide().radius(50));
 
     simulation.on("tick", () => {
-        link.attr("d", d => {
-            const dx = d.target.x - d.source.x;
-            const dy = d.target.y - d.source.y;
-            const dr = Math.sqrt(dx * dx + dy * dy);
-            return `M${d.source.x},${d.source.y}A${dr},${dr} 0 0,1 ${d.target.x},${d.target.y}`;
-        });
+        if (link) {
+            link.attr("d", d => {
+                const dx = d.target.x - d.source.x;
+                const dy = d.target.y - d.source.y;
+                const dr = Math.sqrt(dx * dx + dy * dy);
+                return `M${d.source.x},${d.source.y}A${dr},${dr} 0 0,1 ${d.target.x},${d.target.y}`;
+            });
+        }
 
-        node.attr("transform", d => `translate(${d.x},${d.y})`);
+        if (node) {
+            node.attr("transform", d => `translate(${d.x},${d.y})`);
+        }
         
-        const activeData = badge.datum();
-        if (activeData) {
-            badge.attr("transform", `translate(${activeData.x},${activeData.y})`);
+        if (badge && badge.style("display") !== "none") {
+            const activeData = badge.datum();
+            if (activeData) {
+                badge.attr("transform", `translate(${activeData.x},${activeData.y})`);
+            }
         }
     });
+
+    updateData(data);
 }
 
+export function updateData(data) {
+    if (!simulation || !rootGroup) return;
+
+    // Keep existing node positions if they match by ID
+    const oldNodes = new Map(simulation.nodes().map(d => [d.id, d]));
+    data.nodes.forEach(d => {
+        if (oldNodes.has(d.id)) {
+            const old = oldNodes.get(d.id);
+            d.x = old.x;
+            d.y = old.y;
+            d.vx = old.vx;
+            d.vy = old.vy;
+        }
+    });
+
+    // Update Links
+    link = rootGroup.select(".links-layer")
+        .selectAll("path")
+        .data(data.links, d => d.source + "-" + d.target)
+        .join(
+            enter => enter.append("path")
+                .attr("stroke", "rgba(255,255,255,0.05)")
+                .attr("fill", "none")
+                .attr("stroke-width", 1.5)
+                .call(e => e.transition().duration(500).attr("stroke", "rgba(255,255,255,0.1)")),
+            update => update,
+            exit => exit.remove()
+        );
+
+    // Update Nodes
+    node = rootGroup.select(".nodes-layer")
+        .selectAll("g.node-group")
+        .data(data.nodes, d => d.id)
+        .join(
+            enter => {
+                const g = enter.append("g")
+                    .attr("class", "node-group")
+                    .style("cursor", "pointer")
+                    .on("click", (e, d) => {
+                        currentDotNetHelper.invokeMethodAsync('OnNodeClicked', d.id);
+                        setActiveNode(d.id);
+                    })
+                    .call(drag(simulation));
+
+                g.append("circle")
+                    .attr("r", 30)
+                    .attr("fill", "url(#nebulaGlow)")
+                    .attr("opacity", 0)
+                    .transition().duration(1000).attr("opacity", d => d.group === 'current' ? 0.6 : 0.2);
+
+                g.append("rect")
+                    .attr("class", "node-pill")
+                    .attr("x", d => -(d.label.length * 4 + 10))
+                    .attr("y", -12)
+                    .attr("width", d => d.label.length * 8 + 20)
+                    .attr("height", 24)
+                    .attr("rx", 12)
+                    .attr("fill", "rgba(20, 20, 20, 0.9)")
+                    .attr("stroke", "rgba(255, 255, 255, 0.1)")
+                    .attr("stroke-width", 1);
+
+                g.append("text")
+                    .text(d => d.label)
+                    .attr("text-anchor", "middle")
+                    .attr("y", 4)
+                    .attr("fill", "#ccc")
+                    .attr("font-size", "0.8rem");
+                
+                return g;
+            },
+            update => update,
+            exit => exit.remove()
+        );
+
+    simulation.nodes(data.nodes);
+    simulation.force("link").links(data.links);
+    simulation.alpha(0.5).restart();
+}
 
 function drag(simulation) {
     function dragstarted(event) {
@@ -161,6 +197,29 @@ function drag(simulation) {
         .on("end", dragended);
 }
 
+export function setActiveNode(nodeId) {
+    if (!svgElement || !node) return;
+    
+    const targetNode = node.filter(d => d.id === nodeId);
+    if (targetNode.empty()) return;
+
+    const d = targetNode.datum();
+    
+    // Reset all active classes
+    rootGroup.selectAll(".node-pill").classed("nexus-node-active", false);
+    targetNode.select(".node-pill").classed("nexus-node-active", true);
+
+    // Position badge
+    badge.style("display", "block").datum(d);
+    badge.attr("transform", `translate(${d.x},${d.y})`);
+
+    // Smooth transition
+    svgElement.transition().duration(1000).call(
+        zoomBehavior.transform,
+        d3.zoomIdentity.translate(width / 2, height / 2).scale(1.2).translate(-d.x, -d.y)
+    );
+}
+
 export function unmount(containerId) {
     if (simulation) {
         simulation.stop();
diff --git a/src/NexusReader.UI.Shared/wwwroot/js/readerObserver.js b/src/NexusReader.UI.Shared/wwwroot/js/readerObserver.js
new file mode 100644
index 0000000..b2518f7
--- /dev/null
+++ b/src/NexusReader.UI.Shared/wwwroot/js/readerObserver.js
@@ -0,0 +1,22 @@
+export function initObserver(dotNetHelper, containerSelector, itemSelector) {
+    const options = {
+        root: null,
+        rootMargin: '0px',
+        threshold: 0.6 // 60% of the block must be visible
+    };
+
+    const observer = new IntersectionObserver((entries) => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                const id = entry.target.id;
+                const content = entry.target.innerText;
+                dotNetHelper.invokeMethodAsync('HandleBlockReached', id, content);
+            }
+        });
+    }, options);
+
+    const items = document.querySelectorAll(itemSelector);
+    items.forEach(item => observer.observe(item));
+
+    return observer;
+}
diff --git a/src/NexusReader.Web.Client/Program.cs b/src/NexusReader.Web.Client/Program.cs
index 000143c..1ae8023 100644
--- a/src/NexusReader.Web.Client/Program.cs
+++ b/src/NexusReader.Web.Client/Program.cs
@@ -13,6 +13,9 @@ builder.Services.AddScoped<IThemeService, ThemeService>();
 builder.Services.AddScoped<IQuizStateService, QuizStateService>();
 builder.Services.AddScoped<IFocusModeService, FocusModeService>();
 builder.Services.AddScoped<IReaderNavigationService, ReaderNavigationService>();
+builder.Services.AddScoped<IKnowledgeGraphService, KnowledgeGraphService>();
+builder.Services.AddScoped<KnowledgeCoordinator>();
+builder.Services.AddScoped<IKnowledgeService, WasmKnowledgeService>();
 
 builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
 
diff --git a/src/NexusReader.Web.Client/Services/WasmKnowledgeService.cs b/src/NexusReader.Web.Client/Services/WasmKnowledgeService.cs
new file mode 100644
index 0000000..9f1af24
--- /dev/null
+++ b/src/NexusReader.Web.Client/Services/WasmKnowledgeService.cs
@@ -0,0 +1,61 @@
+using System.Net.Http.Json;
+using FluentResults;
+using NexusReader.Application.Abstractions.Services;
+using NexusReader.Application.DTOs.AI;
+
+namespace NexusReader.Web.Client.Services;
+
+public class WasmKnowledgeService : IKnowledgeService
+{
+    private readonly HttpClient _httpClient;
+
+    public WasmKnowledgeService(HttpClient httpClient)
+    {
+        _httpClient = httpClient;
+    }
+
+    public async Task<Result<KnowledgePacket>> GetKnowledgeAsync(string text, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            Console.WriteLine($"[WasmKnowledgeService] Calling API for extraction (Text length: {text.Length})...");
+            var response = await _httpClient.PostAsJsonAsync("/api/knowledge", new { text }, cancellationToken);
+            if (response.IsSuccessStatusCode)
+            {
+                Console.WriteLine("[WasmKnowledgeService] API Response success. Deserializing...");
+                var packet = await response.Content.ReadFromJsonAsync<KnowledgePacket>(cancellationToken: cancellationToken);
+                return packet != null ? Result.Ok(packet) : Result.Fail("Failed to deserialize knowledge packet.");
+            }
+
+            var errorBody = await response.Content.ReadAsStringAsync(cancellationToken);
+            Console.WriteLine($"[WasmKnowledgeService] API Error ({response.StatusCode}): {errorBody}");
+            return Result.Fail($"Server error ({response.StatusCode}): {errorBody}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[WasmKnowledgeService] Exception: {ex.Message}");
+            return Result.Fail(new Error($"Network or parsing error: {ex.Message}").CausedBy(ex));
+        }
+    }
+
+    public async Task<Result> ClearCacheAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            Console.WriteLine("[WasmKnowledgeService] Requesting cache clear...");
+            var response = await _httpClient.DeleteAsync("/api/knowledge", cancellationToken);
+            if (response.IsSuccessStatusCode)
+            {
+                Console.WriteLine("[WasmKnowledgeService] Cache cleared successfully.");
+                return Result.Ok();
+            }
+
+            var errorBody = await response.Content.ReadAsStringAsync(cancellationToken);
+            return Result.Fail($"Server error ({response.StatusCode}): {errorBody}");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error($"Network error: {ex.Message}").CausedBy(ex));
+        }
+    }
+}
diff --git a/src/NexusReader.Web.New/NexusReader.Web.csproj b/src/NexusReader.Web.New/NexusReader.Web.csproj
index 5da9a26..4c2af81 100644
--- a/src/NexusReader.Web.New/NexusReader.Web.csproj
+++ b/src/NexusReader.Web.New/NexusReader.Web.csproj
@@ -1,21 +1,22 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <BlazorDisableThrowNavigationException>true</BlazorDisableThrowNavigationException>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\NexusReader.Web.Client\NexusReader.Web.Client.csproj" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="10.0.6" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\NexusReader.Application\NexusReader.Application.csproj" />
-    <ProjectReference Include="..\NexusReader.Infrastructure\NexusReader.Infrastructure.csproj" />
-    <ProjectReference Include="..\NexusReader.UI.Shared\NexusReader.UI.Shared.csproj" />
-  </ItemGroup>
-
-</Project>
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <BlazorDisableThrowNavigationException>true</BlazorDisableThrowNavigationException>
+    <UserSecretsId>154e0538-f82d-4ec0-81e7-c1ff39d6d919</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NexusReader.Web.Client\NexusReader.Web.Client.csproj" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Server" Version="10.0.6" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\NexusReader.Application\NexusReader.Application.csproj" />
+    <ProjectReference Include="..\NexusReader.Infrastructure\NexusReader.Infrastructure.csproj" />
+    <ProjectReference Include="..\NexusReader.UI.Shared\NexusReader.UI.Shared.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/NexusReader.Web.New/Program.cs b/src/NexusReader.Web.New/Program.cs
index db02d0d..ee2c6cc 100644
--- a/src/NexusReader.Web.New/Program.cs
+++ b/src/NexusReader.Web.New/Program.cs
@@ -24,12 +24,21 @@ builder.Services.AddScoped<IThemeService, ThemeService>();
 builder.Services.AddScoped<IQuizStateService, QuizStateService>();
 builder.Services.AddScoped<IFocusModeService, FocusModeService>();
 builder.Services.AddScoped<IReaderNavigationService, ReaderNavigationService>();
+builder.Services.AddScoped<IKnowledgeGraphService, KnowledgeGraphService>();
+builder.Services.AddScoped<KnowledgeCoordinator>();
 
 builder.Services.AddApplication();
 builder.Services.AddInfrastructure(builder.Configuration);
 
 var app = builder.Build();
 
+// Ensure Database is initialized
+using (var scope = app.Services.CreateScope())
+{
+    var dbContext = scope.ServiceProvider.GetRequiredService<NexusReader.Infrastructure.Persistence.AppDbContext>();
+    dbContext.Database.EnsureCreated();
+}
+
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
@@ -60,9 +69,29 @@ app.MapGet("/api/epub/{index}", async (int index, IEpubService epubService) =>
     return Results.BadRequest(errorMsg);
 });
 
+app.MapPost("/api/knowledge", async (KnowledgeRequest request, IKnowledgeService knowledgeService) =>
+{
+    var result = await knowledgeService.GetKnowledgeAsync(request.Text);
+    if (result.IsSuccess) return Results.Ok(result.Value);
+    
+    var errorMsg = result.Errors.FirstOrDefault()?.Message ?? "Unknown server error";
+    return Results.BadRequest(errorMsg);
+});
+
+app.MapDelete("/api/knowledge", async (IKnowledgeService knowledgeService) =>
+{
+    var result = await knowledgeService.ClearCacheAsync();
+    if (result.IsSuccess) return Results.Ok();
+    
+    var errorMsg = result.Errors.FirstOrDefault()?.Message ?? "Unknown server error";
+    return Results.BadRequest(errorMsg);
+});
+
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode()
     .AddInteractiveWebAssemblyRenderMode()
-    .AddAdditionalAssemblies(typeof(NexusReader.UI.Shared._Imports).Assembly);
+    .AddAdditionalAssemblies(typeof(NexusReader.UI.Shared.Services.IKnowledgeGraphService).Assembly);
 
 app.Run();
+
+public record KnowledgeRequest(string Text);
diff --git a/src/NexusReader.Web.New/appsettings.json b/src/NexusReader.Web.New/appsettings.json
index 32a333c..be18923 100644
--- a/src/NexusReader.Web.New/appsettings.json
+++ b/src/NexusReader.Web.New/appsettings.json
@@ -12,7 +12,8 @@
   "Ai": {
     "Google": {
       "ApiKey": "PLACEHOLDER",
-      "Model": "gemini-1.5-flash"
+      "Model": "gemini-2.5-flash-lite",
+      "MaxOutputTokens": 4096
     }
   }
 }
diff --git a/src/NexusReader.Web.New/nexus.db b/src/NexusReader.Web.New/nexus.db
new file mode 100644
index 0000000000000000000000000000000000000000..86c2fa853f2d2b4892c32ff4bbd0ff8274149c08
GIT binary patch
literal 57344
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
Wvpa~L?f-7;2A%&8dV^l0`F{WpR6W)J

literal 0
HcmV?d00001