neurocode-ai 0.1.0__py3-none-any.whl

neurocode_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: neurocode-ai
+Version: 0.1.0
+Summary: Heterogeneous Code-Graph Slicing for On-Device Autonomous SWE Agents
+Author: Deepak R.
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tree-sitter>=0.22.0
+Requires-Dist: tree-sitter-python>=0.21.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: datasets>=2.18.0
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: transformers>=4.40.0
+Dynamic: license-file
+
+# NeuroCode: Heterogeneous Code-Graph Slicing for On-Device Autonomous Software Engineering
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Hardware: 4GB GPU](https://img.shields.io/badge/Hardware-4GB%20VRAM%20Verified-brightgreen.svg)]()
+[![Model Context Protocol](https://img.shields.io/badge/MCP-2024--11--05%20Stdio-blueviolet.svg)](https://modelcontextprotocol.io)
+[![Ollama Integration](https://img.shields.io/badge/Ollama-Offline%20Native-orange.svg)](https://ollama.ai)
+[![Kaggle: Verified](https://img.shields.io/badge/Kaggle-Notebook%20Live-20beff.svg)](https://www.kaggle.com/code/deepark121/neurocode-heterogeneous-graph-sliced-swe-agent)
+
+**NeuroCode** is a lightweight, heterogeneous neuro-symbolic framework and **Model Context Protocol (MCP)** server that enables small, local language models (1.5B–14B parameters) to fix multi-file software engineering bugs on consumer laptops (e.g., 4GB–8GB VRAM) without cloud API dependency or Out-of-Memory (OOM) crashes.
+
+---
+
+## 🏛️ System Architecture
+
+![System Architecture](paper/figures/fig2_system_architecture.png)
+
+Unlike traditional coding agents that dump entire raw files into context windows (causing severe VRAM OOMs) or get trapped in multi-turn exploratory shell loops (`grep`, `find`, `cat`), **NeuroCode divides cognitive labor across the PC hardware boundary**:
+
+1. **Host CPU & RAM (Deterministic Graph Engine)**:
+   - Uses Tree-sitter and NetworkX to build an in-memory Code Property Graph (CPG) in milliseconds.
+   - Computes a topological $k$-hop reachability closure around fault candidates.
+   - Solves a bounded 0/1 knapsack optimization problem to select high-relevance AST subtrees strictly under the model's token limit ($B \le 1,200$ tokens).
+2. **Device GPU (Neural Synthesis Engine)**:
+   - Ingests only the bounded sliced context across PCIe.
+   - Generates single-turn `SEARCH/REPLACE` diff patches with zero exploratory token waste.
+   - Completely prevents KV-cache quadratic blowup and GPU OOM cliff failure.
+
+---
+
+## 📊 Comprehensive Empirical Evaluation (5-Benchmark Suite)
+
+NeuroCode was evaluated across 5 comprehensive benchmark tracks spanning real-world repository repair, standalone algorithm synthesis, multi-file cross-boundary retrieval, and low-level hardware telemetry.
+
+| Benchmark Suite | Metric | Baseline / BM25 | NeuroCode (Ours) | Advantage |
+| :--- | :--- | :--- | :--- | :--- |
+| **SWE-bench Lite** ($N=300$) | Resolve Rate (Pass@1) | 0.0% (OOM on 4GB) | **41.4%** (Local) / **21.1%** (14B) | Prevents OOM cliff; +14.2% over BM25 |
+| **HumanEval** ($N=164$) | Pass@1 | 80.5% | **86.0%** (141/164) | +5.5% via syntax-aware graph repair |
+| **MBPP** ($N=100$) | Pass@1 | 81.0% | **87.0%** (87/100) | +6.0% algorithmic verification |
+| **RepoBench-R** ($N=150$) | Recall@1 / Token Budget | 18.0% (745 tokens) | **100.0%** (**428 tokens**) | **-42.6% tokens**, perfect cross-file retrieval |
+| **Host Systems Telemetry** | Active VRAM / Slice Latency | 14.2 GB (OOM) | **961.2 MB** / **1.09 ms** | **93.2% VRAM reduction**, 0 OOMs |
+
+### 💻 Physical Laptop Edge Validation (NVIDIA RTX 3050 Laptop GPU)
+Tested live on an everyday developer laptop (AMD Ryzen 7 7435HS + NVIDIA RTX 3050 Laptop GPU, 4.0 GB VRAM):
+- **Peak Active VRAM**: **961.2 MB** (Only 25.5% GPU capacity, leaving 2.54 GB buffer for system desktop UI).
+- **Throughput**: **15.8 tokens/second** locally.
+- **Host Slicing Overhead**: **0.04 ms** on CPU.
+- **Disk SSD Wear**: **0.0 GB** (100% in-memory ephemeral RAM execution via `/dev/shm`).
+
+---
+
+## 🔌 Model Context Protocol (MCP) Integration
+
+NeuroCode provides an official stdio **Model Context Protocol (MCP)** server conforming to specification `2024-11-05`. Connect NeuroCode directly to Claude Desktop, Cursor, Continue.dev, or VS Code!
+
+### Native MCP Tools Exposed:
+1. `neurocode_slice`: In-memory CPG reachability slicing bounded under token budget ($B \le 1,200$).
+2. `neurocode_seeds`: Static root-cause candidate entity discovery in $<2$ ms.
+3. `neurocode_repair_ollama`: Single-turn patch generation streaming to local Ollama daemon (`http://localhost:11434`).
+4. `neurocode_hardware_health`: Reports GPU VRAM headroom, CPU cores, and `/dev/shm` tmpfs zero-wear status.
+
+### 1. Claude Desktop Setup
+Add the following to your Claude Desktop configuration file:
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "neurocode": {
+      "command": "/absolute/path/to/neurocode/.venv/bin/neurocode-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+### 2. Cursor IDE Setup
+Add to `.cursor/mcp.json` or your Cursor settings:
+```json
+{
+  "mcpServers": {
+    "neurocode": {
+      "command": "neurocode-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+### 3. Continue.dev Setup
+Add to your `~/.continue/config.json`:
+```json
+{
+  "experimental": {
+    "modelContextProtocolServers": [
+      {
+        "name": "neurocode",
+        "command": "neurocode-mcp",
+        "args": []
+      }
+    ]
+  }
+}
+```
+
+---
+
+## 🚀 Quickstart & CLI Usage
+
+### 1. Installation
+```bash
+git clone https://github.com/Arkz-Deepak/neurocode.git
+cd neurocode
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+### 2. Extract Token-Bounded Slice for Any Issue
+```bash
+# Slices your codebase into a tight, bug-focused prompt under 1200 tokens
+neurocode slice --repo /path/to/repo --issue "Fix ZeroDivisionError in matrix normalization" --budget 1200
+```
+
+### 3. Repair Code via Local Ollama Daemon (Zero Cloud API)
+```bash
+# Runs full repair using local Qwen2.5-Coder model via Ollama
+neurocode repair --repo /path/to/repo \
+                 --issue "Fix ZeroDivisionError in matrix normalization" \
+                 --provider ollama \
+                 --model qwen2.5-coder:7b \
+                 --apply
+```
+
+### 4. Interactive Copilot Direct on Laptop GPU
+```bash
+neurocode-copilot
+```
+
+---
+
+## 👤 Author & Affiliation
+
+- **Author**: **Deepak R.**
+- **Affiliation**: Department of Robotics & Automation Engineering, Dhaanish Ahmed College of Engineering (Affiliated with Anna University), Chennai, India
+- **Portfolio**: [https://deepak-arkz.me](https://deepak-arkz.me)
+- **Email**: [`wssedd18@gmail.com`](mailto:wssedd18@gmail.com) / [`deepak121289@outlook.com`](mailto:deepak121289@outlook.com)
+- **GitHub**: [@Arkz-Deepak](https://github.com/Arkz-Deepak)
+
+---
+
+## 📄 Publications & Preprints
+
+- **IEEE Transactions on Software Engineering (TSE)**: [`paper_ieee_tse/neurocode_tse.tex`](paper_ieee_tse/neurocode_tse.tex)
+- **IEEE Conference Modular Package**: [`paper_modular_ieee/neurocode_modular_paper.tex`](paper_modular_ieee/neurocode_modular_paper.tex)
+- **MLSys Conference Format**: [`paper_mlsys/neurocode_mlsys.tex`](paper_mlsys/neurocode_mlsys.tex)
+- **Kaggle Competition Executable Notebook**: [Kaggle Notebook Live](https://www.kaggle.com/code/deepark121/neurocode-heterogeneous-graph-sliced-swe-agent)
+
+### Citation
+```bibtex
+@article{deepak2026neurocode,
+  title={NeuroCode: Budget-Constrained Heterogeneous Code-Graph Slicing for Local Software Repair},
+  author={Deepak, R.},
+  journal={IEEE Transactions on Software Engineering},
+  institution={Dhaanish Ahmed College of Engineering, Anna University},
+  year={2026},
+  url={https://github.com/Arkz-Deepak/neurocode}
+}
+```
+
+---
+
+## 📜 License
+This project is licensed under the [MIT License](LICENSE).

neurocode_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+neurocode_ai-0.1.0.dist-info/licenses/LICENSE,sha256=8rTdawiikjQ3ScDYA3fTvfvY7j18cKGTOOHZMVbtER8,1066
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/cli.py,sha256=iGlb686D4hFVcDJlpn6qixblWqjfZ9qQur0d7zbIqa4,13605
+src/mcp_server.py,sha256=rEqRCElQ0E2i-buaRTYjAK70v-hwNLgZVSJpuJDvjzQ,13778
+src/agent/llm_interface.py,sha256=RYL0dRXuCPAvsGqTK0-yIRX4NIypeVVww0SgCMkdJ-g,2258
+src/agent/patcher.py,sha256=PKXqk4iG8sdAKxW5D93omLUMthfwjjrPbihQrWZQlVg,5406
+src/benchmark/create_thumbnail.py,sha256=wiic76H-0RzDMO2WKgXrDX3ydeZ2ZhfgGt6fz1qHaj8,2856
+src/benchmark/end_to_end_benchmark.py,sha256=uLM9c1L5gocKLX7viJh1IizfGEJEct2eOIUhcjQWPnk,27988
+src/benchmark/evaluator.py,sha256=JQ_fokgem3-13u4fWn5coSZhlUHJxQRG9mIfewsbut0,4995
+src/benchmark/generate_4x3_figures.py,sha256=l5fW1UIjcld62QpBYV3ADCow97jeSuG3Pj_HGnnTOHU,12239
+src/benchmark/mlsys_microbenchmarks.py,sha256=w1dg1Tbod8-8Ss2tPRcvBFTK6GA-W3l9o3o_Gcu22yA,16413
+src/benchmark/plot_ablation.py,sha256=xQnbux1xhe9FjSNLLA1Z4kkRJY5izXfvLl2zZXZ6pXs,3977
+src/benchmark/plot_architecture.py,sha256=TmLFXuSF73qE3VB2wkZHorNvERychcwIQIXyxUIZfAQ,4191
+src/benchmark/plot_empirical_fig1.py,sha256=WLSTtYIzeuRV-nuifMopGWK07Q6tbayWxHtD_sZnGEA,3672
+src/benchmark/run_ablation_study.py,sha256=ghXECz_yzi7DqBpRKOgx9Fl2Jm6nHty97L8Ld302vmE,8728
+src/benchmark/run_code_benchmarks.py,sha256=msjQmhC3q0ER1G4z0KxgEo1LkyZkSTNSphoJHeoAkuk,6818
+src/benchmark/run_comprehensive_10_tests.py,sha256=hQsWskaDtc6BXrZauJXm_YjBC5urXQP772itY2j4jkA,19091
+src/benchmark/run_dense_vector_rag_benchmark.py,sha256=c7K1lchCawsz_EEndJ9p35GlEnPZboGgOboVNWI5ONM,12313
+src/benchmark/run_ephemeral_swebench.py,sha256=vv5FoMWdXi7n8DSuctfXtGC7IbgVx3o3LxetMQxTCbM,20627
+src/benchmark/run_hardware_cliff_test.py,sha256=iR8QRlEPrXVTgGxcddCZHBe4zkY8odykwcbRzSzOXJM,15722
+src/benchmark/swebench_evaluator.py,sha256=IPNVjZK3vt0T-pNha1sVYoaO06VwbA5MGtyCmOZFuzs,6374
+src/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/graph/builder.py,sha256=_vuJ-dk87ITJoPEnL3TJ-GYaVzSIacu2vtXqKNRR61M,5446
+src/graph/parser.py,sha256=RP4TD7aXhr-SKwG3BAA--jywP_NYBDN9_zj6lorZAfM,5839
+src/graph/slicer.py,sha256=QsWGqtiF64NgCGSpzSpQsBCwaOF10snxf7Y3E26QP0U,9152
+neurocode_ai-0.1.0.dist-info/METADATA,sha256=vjqTgTXZAEURvNdGZOOF1vEAxn60JAAPs8Zy9_d3B9w,8125
+neurocode_ai-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+neurocode_ai-0.1.0.dist-info/entry_points.txt,sha256=r1kCVQZkqeLGiEplBDQMjXR98YPWNFPzBwVkHjk9mnk,119
+neurocode_ai-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+neurocode_ai-0.1.0.dist-info/RECORD,,

neurocode_ai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

neurocode_ai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+neurocode = src.cli:main
+neurocode-copilot = code_assistant:main
+neurocode-mcp = src.mcp_server:main

neurocode_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deepak R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neurocode_ai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/agent/llm_interface.py

@@ -0,0 +1,62 @@
+"""
+Inference interface for local and remote models (Ollama, vLLM, HuggingFace, and Mock).
+"""
+
+import json
+import urllib.request
+from typing import Dict, Any, Optional
+from src.agent.patcher import SYSTEM_PROMPT
+
+
+class BaseLLMClient:
+    def generate(self, user_prompt: str, temperature: float = 0.2) -> str:
+        raise NotImplementedError
+
+
+class OpenAICompatibleClient(BaseLLMClient):
+    """Connects to any local OpenAI-compatible endpoint (Ollama, vLLM, or llama.cpp server)."""
+    def __init__(self, base_url: str = "http://localhost:11434/v1", model: str = "gemma2:9b"):
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+
+    def generate(self, user_prompt: str, temperature: float = 0.2) -> str:
+        url = f"{self.base_url}/chat/completions"
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt}
+            ],
+            "temperature": temperature,
+            "max_tokens": 1024,
+        }
+
+        data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+
+        try:
+            with urllib.request.urlopen(req, timeout=120) as response:
+                res_json = json.loads(response.read().decode("utf-8"))
+                return res_json["choices"][0]["message"]["content"]
+        except Exception as e:
+            return f"Error querying local LLM at {url}: {str(e)}"
+
+
+class MockLLMClient(BaseLLMClient):
+    """Simulates an LLM response for local testing and benchmark assertions."""
+    def __init__(self, predefined_response: Optional[str] = None):
+        self.predefined_response = predefined_response
+
+    def generate(self, user_prompt: str, temperature: float = 0.2) -> str:
+        if self.predefined_response:
+            return self.predefined_response
+        return (
+            "FILE: auth/user.py\n"
+            "<<<<<<< SEARCH\n"
+            "    if len(password) < 8:\n"
+            "        return False\n"
+            "=======\n"
+            "    if not password or len(password) < 8:\n"
+            "        return False\n"
+            ">>>>>>>"
+        )

src/agent/patcher.py

@@ -0,0 +1,124 @@
+"""
+Agent prompt formatting, diff extraction, and patch application.
+Optimized for local models (Gemma) to avoid JSON tool-calling failures.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Optional, Tuple, Any, List
+
+
+SYSTEM_PROMPT = """You are an expert autonomous software engineer.
+You are given an issue description and a structurally sliced context of the repository.
+Your task is to fix the issue by providing a clean SEARCH/REPLACE block.
+
+Formatting Rules:
+1. Identify the exact file path and code snippet to modify.
+2. Output your fix using this exact format:
+
+FILE: <file_path>
+<<<<<<< SEARCH
+<exact original code lines>
+=======
+<fixed replacement code lines>
+>>>>>>>
+
+Do not include any conversational filler. Be precise and minimal.
+"""
+
+
+@dataclass
+class PatchResult:
+    success: bool
+    file_path: Optional[str] = None
+    search_block: Optional[str] = None
+    replace_block: Optional[str] = None
+    error_message: Optional[str] = None
+
+
+class PatchApplier:
+    @staticmethod
+    def extract_patch(llm_output: str, graph: Optional[Any] = None, repo_dir: Optional[str] = None) -> PatchResult:
+        """
+        Extracts patch from LLM output.
+        Tier 1: Standard SEARCH/REPLACE diff markers.
+        Tier 2: AST-Aware Entity Replacement (matches generated function/class against CPG node).
+        """
+        import os
+        # 1. Tier 1: Exact SEARCH/REPLACE Block
+        file_match = re.search(r"FILE:\s*([^\n\r]+)", llm_output)
+        if file_match:
+            file_path = file_match.group(1).strip("`' ")
+            pattern = r"<<<<<<< SEARCH\s*\n(.*?)\n=======\s*\n(.*?)\n>>>>>>>"
+            block_match = re.search(pattern, llm_output, re.DOTALL)
+            if block_match:
+                return PatchResult(
+                    success=True,
+                    file_path=file_path,
+                    search_block=block_match.group(1),
+                    replace_block=block_match.group(2),
+                )
+
+        # 2. Tier 2: AST Symbol Replacement Fallback
+        code_blocks = re.findall(r"```(?:python)?\s*\n(.*?)\n```", llm_output, re.DOTALL)
+        if not code_blocks:
+            if "def " in llm_output or "class " in llm_output:
+                code_blocks = [llm_output]
+
+        for block in code_blocks:
+            func_match = re.search(r"def\s+([a-zA-Z0-9_]+)\s*\(", block)
+            class_match = re.search(r"class\s+([a-zA-Z0-9_]+)", block)
+            symbol_name = func_match.group(1) if func_match else (class_match.group(1) if class_match else None)
+
+            if symbol_name and graph is not None:
+                for node, data in graph.nodes(data=True):
+                    if data.get("name") == symbol_name and data.get("type") in ("function", "method", "class"):
+                        file_path = data.get("file")
+                        orig_source = data.get("source") or data.get("code")
+                        if file_path and orig_source and orig_source.strip():
+                            return PatchResult(
+                                success=True,
+                                file_path=file_path,
+                                search_block=orig_source.strip(),
+                                replace_block=block.strip()
+                            )
+                        elif file_path and repo_dir:
+                            full_p = os.path.join(repo_dir, file_path)
+                            if os.path.exists(full_p):
+                                with open(full_p, "r", encoding="utf-8") as fh:
+                                    lines = fh.readlines()
+                                s_line = data.get("start_line", 1) - 1
+                                e_line = data.get("end_line", len(lines))
+                                orig_chunk = "".join(lines[s_line:e_line]).strip()
+                                return PatchResult(
+                                    success=True,
+                                    file_path=file_path,
+                                    search_block=orig_chunk,
+                                    replace_block=block.strip()
+                                )
+
+        return PatchResult(success=False, error_message="No valid SEARCH/REPLACE block or AST symbol match found.")
+
+    @staticmethod
+    def apply_patch_to_file(full_file_path: str, search_block: str, replace_block: str) -> Tuple[bool, str]:
+        """Applies an exact search-and-replace edit to a target file on disk."""
+        try:
+            with open(full_file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            if search_block not in content:
+                # Fallback: Normalize line endings
+                norm_search = search_block.replace("\r\n", "\n").strip()
+                norm_content = content.replace("\r\n", "\n")
+                if norm_search not in norm_content:
+                    return False, f"Search block not found in {full_file_path}"
+                new_content = norm_content.replace(norm_search, replace_block.replace("\r\n", "\n"), 1)
+            else:
+                new_content = content.replace(search_block, replace_block, 1)
+
+            with open(full_file_path, "w", encoding="utf-8") as f:
+                f.write(new_content)
+
+            return True, "Patch applied successfully."
+        except Exception as e:
+            return False, f"Failed to modify {full_file_path}: {str(e)}"

src/benchmark/create_thumbnail.py

@@ -0,0 +1,64 @@
+"""
+Generates the exact 560x280 thumbnail card for the Kaggle competition writeup.
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from pathlib import Path
+
+
+def render_kaggle_thumbnail(output_path: Path):
+    # Exactly 560 x 280 pixels (5.6 x 2.8 inches at 100 DPI)
+    fig, ax = plt.subplots(figsize=(5.6, 2.8), dpi=100)
+    ax.set_xlim(0, 560)
+    ax.set_ylim(0, 280)
+    ax.axis('off')
+
+    # Background gradient / solid sleek dark theme
+    bg = patches.Rectangle((0, 0), 560, 280, facecolor='#0f172a')
+    ax.add_patch(bg)
+
+    # Accent Top Line (DeepMind Blue & Emerald Green)
+    accent_bar = patches.Rectangle((0, 272), 560, 8, facecolor='#22c55e')
+    ax.add_patch(accent_bar)
+
+    # Title: NEUROCODE
+    ax.text(35, 205, "NEUROCODE", fontsize=26, fontweight='black', color='#ffffff', family='sans-serif')
+
+    # Subtitle
+    ax.text(35, 168, "Heterogeneous Code-Graph Slicing for On-Device SWE Agents",
+            fontsize=9.5, fontweight='bold', color='#94a3b8', family='sans-serif')
+
+    # Tagline / Conference Target
+    ax.text(35, 142, "Google DeepMind Gemma 4 Developer Agent Paper Track",
+            fontsize=8.5, fontweight='bold', color='#38bdf8', family='sans-serif')
+
+    # Metric Badges (Rounded Boxes)
+    badge1 = patches.FancyBboxPatch((35, 45), 145, 65, boxstyle="round,pad=3",
+                                    facecolor="#1e293b", edgecolor="#22c55e", linewidth=1.5)
+    ax.add_patch(badge1)
+    ax.text(107, 85, "-95.3%", fontsize=16, fontweight='black', color='#22c55e', ha='center')
+    ax.text(107, 60, "TOKEN REDUCTION", fontsize=7.5, fontweight='bold', color='#94a3b8', ha='center')
+
+    badge2 = patches.FancyBboxPatch((200, 45), 145, 65, boxstyle="round,pad=3",
+                                    facecolor="#1e293b", edgecolor="#38bdf8", linewidth=1.5)
+    ax.add_patch(badge2)
+    ax.text(272, 85, "96.0%", fontsize=16, fontweight='black', color='#38bdf8', ha='center')
+    ax.text(272, 60, "MULTI-HOP RECALL", fontsize=7.5, fontweight='bold', color='#94a3b8', ha='center')
+
+    badge3 = patches.FancyBboxPatch((365, 45), 160, 65, boxstyle="round,pad=3",
+                                    facecolor="#1e293b", edgecolor="#f59e0b", linewidth=1.5)
+    ax.add_patch(badge3)
+    ax.text(445, 85, "< 1.0 GB", fontsize=16, fontweight='black', color='#f59e0b', ha='center')
+    ax.text(445, 60, "ACTIVE VRAM (RTX 3050)", fontsize=7.5, fontweight='bold', color='#94a3b8', ha='center')
+
+    plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    plt.savefig(output_path, dpi=100)
+    plt.close()
+    print(f"Kaggle thumbnail generated at: {output_path} (Dimensions: 560x280)")
+
+
+if __name__ == "__main__":
+    out = Path("/home/deepak-r/Project/research/paper/figures/kaggle_thumbnail_560x280.png")
+    render_kaggle_thumbnail(out)