Optimize: N8N MoA Blueprint + Adaptive Grid Slider

N8N_ARCHITECTURE.md

@@ -0,0 +1,77 @@
+# N8N Mixture of Agents (MoA) Architecture
+The "Google Antigravity" Neural Router
+
+## 1. Core Philosophy
+Treat n8n as a **Neural Router**, decoupling "Thinking" (Logic/Architecture) from "Inference" (Execution/Code). This bypasses latencies and refusals by routing tasks to the most efficient model.
+
+## 2. Infrastructure: The "OpenAI-Compatible" Bridge
+Standardize all providers to the OpenAI API protocol.
+
+### Local (Code & Privacy)
+- **Tool**: Ollama / LM Studio
+- **Endpoint**: `http://localhost:11434/v1`
+- **Model**: `dolphin-llama3` (Uncensored, fast, obedient)
+
+### High-Speed Inference (Math & Logic)
+- **Tool**: DeepInfra / Groq
+- **Endpoint**: `https://api.deepseek.com/v1`
+- **Model**: `deepseek-v3` (Math verification, topology)
+
+### Synthesis (Architecture)
+- **Tool**: Google Vertex / Gemini
+- **Role**: Systems Architect (High-level synthesis)
+
+## 3. The N8N Topology: "Router & Jury"
+
+### Phase A: The Dispatcher (Llama-3-8B-Groq)
+Classifies incoming request type:
+- **Systems Architecture** -> Route to Gemini
+- **Python Implementation** -> Route to Dolphin (Local)
+- **Mathematical Proof** -> Route to DeepSeek (API)
+
+### Phase B: Parallel Execution
+Use **Merge Node (Wait Mode)** to execute paths simultaneously.
+1.  **Path 1 (Math)**: DeepSeek analyzes Prime Potentiality/Manifold logic.
+2.  **Path 2 (Code)**: Dolphin writes adapters/scripts locally.
+3.  **Path 3 (Sys)**: Gemini drafts Strategy/README.
+
+### Phase C: Consensus (The Annealing)
+Final LLM Node synthesizes outputs:
+> "Synthesize perspectives. If Dolphin's code conflicts with DeepSeek's math, prioritize DeepSeek constraints."
+
+## 4. Implementation Config
+
+### HTTP Request Node (Generic)
+- **Method**: POST
+- **URL**: `{{ $json.baseUrl }}/chat/completions`
+- **Headers**: `Authorization: Bearer {{ $json.apiKey }}`
+- **Body**:
+```json
+{
+  "model": "{{ $json.modelName }}",
+  "messages": [
+    { "role": "system", "content": "You are a LOGOS systems engineer." },
+    { "role": "user", "content": "{{ $json.prompt }}" }
+  ],
+  "temperature": 0.2
+}
+```
+
+### Model Selector (Code Node)
+```javascript
+if (items[0].json.taskType === "coding") {
+  return { json: {
+      baseUrl: "http://host.docker.internal:11434/v1",
+      modelName: "dolphin-llama3",
+      apiKey: "ollama"
+  }};
+} else if (items[0].json.taskType === "math") {
+  return { json: {
+      baseUrl: "https://api.deepseek.com/v1",
+      modelName: "deepseek-coder",
+      apiKey: "YOUR_DEEPSEEK_KEY"
+  }};
+}
+```
+
+This architecture breaks the bottleneck by using Dolphin for grunt work (local/free) and specialized models for high-IQ tasks.

app.py

@@ -226,7 +226,7 @@ def process_dsp(image, grid_size=8, workers=16):
             cv2.imwrite(temp_path, cv2.cvtColor(np_img, cv2.COLOR_RGB2BGR))
 
     # Init Bridge
-    bridge = DSPBridge(num_workers=int(workers), viewport_size=(1024, 768))
+    bridge = DSPBridge(grid_size=int(grid_size), num_workers=int(workers), viewport_size=(1024, 768))
     
     try:
         # Transmit (Encoding -> Decoding)

logos/dsp_bridge.py

@@ -122,23 +122,16 @@ class DSPBridge:
     CHUNK_SIZE = 512  # Each chunk is 512x512
     WAVES_PER_CHUNK = 8  # 8x8 = 64 waves per chunk
     
-    def __init__(self, num_workers: int = 64,
+    def __init__(self, grid_size: Optional[int] = None, num_workers: int = 64,
                  viewport_size: Tuple[int, int] = (1280, 720)):
         """
-        Initialize DSP Bridge with Automatic Wave Architecture
-        
-        Grid size is AUTO-CALCULATED based on image dimensions:
-        - Image divided into 512x512 chunks
-        - Each chunk has 8x8 = 64 waves
-        - Total grid = chunks × 8
-        
-        Args:
-            num_workers: Parallel workers (default: 64)
-            viewport_size: Display viewport (width, height)
+        Initialize DSP Bridge.
+        AES-256 Adaptive Grid Support.
         """
         self.num_workers = num_workers
         self.viewport_size = viewport_size
-        self.grid_size = 8  # Will be recalculated per image
+        self.forced_grid_size = grid_size
+        self.grid_size = grid_size if grid_size else 8
         
         # Use Shared Network Instance (Optimization)
         self.network = SHARED_NETWORK
@@ -482,8 +475,12 @@ class DSPBridge:
         
         h, w = self.source_image.shape[:2]
         
-        # AUTO-CALCULATE grid based on image size
-        self.grid_size = self._calculate_grid(w, h)
+        # AUTO-CALCULATE grid based on image size (unless forced)
+        if self.forced_grid_size:
+            self.grid_size = self.forced_grid_size
+        else:
+            self.grid_size = self._calculate_grid(w, h)
+            
         total_waves = self.grid_size * self.grid_size
         
         chunks_x = math.ceil(w / self.CHUNK_SIZE)