Idea 2: AI-Generated Note Graphs
| Name | Kaushalendra Singh |
|---|---|
| GitHub | Kaushalendra-Marcus |
| yadavkausha4a5@gmail.com | |
| Phone | +91 6398519072 |
| linkedin.com/in/kaushalendra-singh-45b933272 | |
| Portfolio | kaushalendra-portfolio.vercel.app |
| Project Idea | GSoC 2026 Ideas - Idea 2 |
| Forum Intro | Joplin GSoC 2026 Welcome Thread |
| Plugin Repo | AI-Generated-note-graphs |
| POC Forum Post | NoteGraph Plugin Discourse |
1. About Me
I am Kaushalendra Singh, a third-year B.Tech student at Harcourt Butler Technical University, Kanpur (2023-2027). I have more than two years of hands-on experience in software development across internships and personal projects, working on production-level systems using TypeScript, React, Next.js and Node.js.
My work focuses on building scalable systems, real-time applications and AI-driven pipelines. I have experience designing end-to-end architectures including frontend systems, backend APIs, and integration of LLM-based workflows. I have actively contributed to Joplin across Desktop, Mobile, Sync and Import subsystems, requiring deep understanding of Electron internals, cross-device synchronization logic, and debugging in a large production codebase.
I also secured second place in the Tambo AI Hackathon (UI Strikes Back Hackathon), where I designed and built an AI-driven system with a strong focus on usability, system design and real-world applicability under time constraints.
1.1 Technical Strengths
Full-stack: React, Next.js, TypeScript, Tailwind CSS, Node.js, Express
Real-time systems: Socket.IO, WebSockets, event-driven backend design
AI/LLM systems: OpenAI API, Gemini API, Transformers.js, embeddings, structured JSON outputs
Performance: MongoDB, PostgreSQL, Prisma, caching strategies, API optimisation
Open source: Electron, React Native, Node.js, GitHub workflows, large codebase debugging
1.2 Key Projects
Buildify Labs - AI Business Intelligence Live | GitHub (2000+ users)
Natural language to structured dashboard pipeline: NL to JSON to dynamic UI rendering
Multi-step queries with session-based state management; used by 2000+ users worldwide
MyAttendance - Attendance Tracking PWA Live (1300+ users)
Next.js PWA with role-based access, MongoDB query optimisation for high concurrency
Postly - Real-time Social Platform Live (300+ users)
Node.js + Socket.io real-time backend with JWT authentication and event-driven architecture
CosmoDetect - Object Detection API (Hackathon Winner) Live API
YOLOv11, PyTorch, FastAPI; deployed object detection system with OpenCV preprocessing pipeline
1.3 Pull Requests to Joplin
| PR # | Status | Description | Area |
|---|---|---|---|
| #14849 | Merged | Fixes #14628: Prevent renderer crash when closing secondary window | Desktop / Bug |
| #14605 | Merged | Fix OneNote zip import path when .one files are at root level | Desktop / Import |
| #14888 | Open | Enable OAuth for Joplin Server (CLI + Mobile) | Auth / Security |
| #14618 | Closed | Fixes #14309: Fix title field border thickness using PixelRatio | Mobile / Android |
| #14583 | Closed | Fixes #14540: Prevent duplicate tags when syncing across devices | Sync / Database |
| #14553 | Closed | Fixes #14078: Prevent HTML blocks escaped on Markdown/RTE switch | Desktop / Renderer |
| #14539 | Closed | Fixes #14223: Gracefully handle truncated or corrupted .one files | Desktop / Import |
2. Proof of Concept - NoteGraph Plugin
Before writing this proposal I built and published a working plugin to validate the entire technical stack inside Joplin's real plugin environment. The plugin is publicly available at AI-Generated-note-graphs, with the compiled .jpl installable from the publish/ folder.
On 27 March 2026, I published the plugin to Joplin Discourse: NoteGraph Plugin Thread, tagging mentors @HahaBill, @malekhavasi and @shikuz. The post includes a full demo screenshot (AI/ML Notes, 2127x1837) and a recorded video walkthrough.
2.1 Live POC Features Validated
5 node types: Topic, Concept, Entity, Event, Attribute - each with distinct colour
4 relationship types: Hierarchical, Causal, Semantic, Temporal
Node size reflects importance score on a 1-5 scale from LLM output
5 graph layouts: Force-directed, Tree, Radial, Circle, Grid
Live search: non-matching nodes fade out instantly
Click any node: shows description, aliases and connections in a sidebar
PNG export, smart caching - revisiting a note loads from cache instantly
Wikilink detection: [[wikilinks]] rendered as connected nodes
Keyboard shortcuts: +/- zoom, F to fit, Esc to close panel
Free Groq API backend (no credit card): console.groq.com
2.2 Installation (Validated in POC)
Get free Groq API key at console.groq.com
Download the .jpl file from the GitHub publish/ folder
In Joplin 3.5+: Tools > Options > Plugins > Install from file
Paste API key in Tools > Options > NoteGraph, click OK
Open any note and click the graph icon in the toolbar
2.3 Technical Insights from POC
Building the POC revealed three critical constraints that directly shaped this proposal's design:
Webview network restriction: Joplin's webview cannot load external CDN URLs. This forced bundling Cytoscape.js and Transformers.js via webpack, confirmed working in the POC.
Structured LLM output: Free-form prompts produce inconsistent JSON. The POC confirmed that embedding the full JSON schema as an example in the prompt, validated by CodeKGC research, produces reliable graph-compatible output.
WASM embedding latency: bge-small-en-v1.5 via Transformers.js takes 2-3 seconds on first load but is near-instant on subsequent calls once the model binary is cached in memory.
Image Demo
Video Demo: https://drive.google.com/file/d/1A_b_L1hQdGeQdkzFVtgR62Bo1Sfo-lZe/view?usp=sharing
3. Project Summary
3.1 The Problem
Joplin users accumulate thousands of notes over months and years. These notes contain enormous conceptual knowledge: ideas, research, meeting summaries, technical documentation. But Joplin currently provides only flat search and folder organisation. There is no way to answer: what are all the concepts in this note and how do they relate? How does this topic connect to ideas in other notes? The result is cognitive fragmentation: knowledge remains siloed inside individual notes rather than forming a retrievable network.
3.2 What This Project Solves
This project builds a production-quality AI-powered Knowledge Graph plugin for Joplin that transforms note content into an interactive, visual graph of concepts and their semantic relationships. For any note or set of notes, the plugin will:
Extract key concepts, entities, and topics using a local or cloud LLM
Identify named relationships: Machine Learning includes Supervised Learning, TCP/IP enables HTTP
Render an interactive graph with directed edges, cluster colouring, and hierarchical layout
Support cross-note graph expansion connecting concepts across multiple notes
Allow users to click a node and navigate to the note section containing that concept
3.3 Why It Matters
Students: visualising how exam topics interconnect
Researchers: mapping the conceptual terrain of a literature review
Engineers: understanding how technical concepts in documentation relate
Writers: seeing the web of ideas across an in-progress work
3.4 Scope
In scope: Single-note knowledge graph, multi-note cross-graph, interactive navigation, bge-small-en-v1.5 embeddings, LLM extraction via Gemini API and Ollama, PNG/SVG export, settings panel.
Out of scope: Real-time collaboration, mobile platform (plugin API limitation), full offline LLM inference without Ollama.
4. Research Background
The design of NoteGraph draws on peer-reviewed research across four domains: knowledge graph construction, sentence embeddings, graph layout algorithms, and LLM-based information extraction. Each core design decision is grounded in this literature.
4.1 Knowledge Graph Theory and Construction
The foundational reference is the comprehensive survey by Hogan et al. (2021), ACM Survey, which defines a knowledge graph as a graph of entities and their interrelations and establishes the triple-based representation (subject, predicate, object) that underpins the plugin's JSON schema for concept-relationship pairs. The authors survey graph completion and embedding techniques directly applicable to the cross-note similarity mode.
For automatic knowledge graph population from text, the REBEL system (Cabot and Navigli, 2021), EMNLP 2021, demonstrates that end-to-end language generation extracts relation triples with high precision. REBEL's finding that named relation extraction outperforms co-occurrence methods motivates the choice of LLM over pure embedding similarity for within-note graphs. The structured prompt design, returning typed triples with confidence scores, is directly informed by REBEL's output format.
The DYGIE++ framework (Wadden et al., 2019), EMNLP 2019, provides the theoretical basis for the five node-type taxonomy (Topic, Concept, Entity, Event, Attribute). DYGIE++ demonstrates that joint extraction of entities, relations, and events from the same span representation consistently outperforms pipeline approaches, informing the design of the unified extraction prompt.
4.2 Sentence and Document Embeddings
The embedding model selection is grounded in the MTEB leaderboard, introduced by Muennighoff et al. (2022), EACL 2023. MTEB evaluates embedding models across 56 datasets. The selected model, bge-small-en-v1.5, achieves an MTEB score of 62.28 with a 512-token context window, outperforming all-MiniLM-L6-v2 (56.26, 256 tokens) on the STS, retrieval and clustering tasks most relevant to knowledge graph similarity.
The BGE family is documented by Zhang et al. (2023), arXiv 2309. The bge-small-en-v1.5 variant is specifically recommended for latency-sensitive applications, making it ideal for the Transformers.js WASM backend where inference runs entirely in the plugin process without a network call.
For the optional Ollama backend, nomic-embed-text (MTEB 62.39, 2048-token context) is documented in Nussbaum et al. (2024), arXiv 2402. This is offered as an advanced backend for users whose notes exceed the 512-token limit of bge-small-en-v1.5.
4.3 Graph Layout Algorithms
The primary layout engine, CoSE-Bilkent, is described by Dogrusoz et al. (2009), Info. Sciences. CoSE is a force-directed algorithm that explicitly models compound (nested) graph structures. This is correct for NoteGraph because knowledge graphs often have natural cluster structures: a machine learning note yields sub-clusters for supervised learning, neural networks, and optimisation that CoSE-Bilkent preserves while maintaining readability.
Cytoscape.js is documented in Franz et al. (2016), Bioinformatics. As a browser-native library with no external dependencies, Cytoscape.js is the correct choice for Joplin's webview, which restricts network access and cannot load CDN resources. The paper documents performance characteristics tested on graphs of 10,000+ nodes.
4.4 LLM-Based Information Extraction
The use of LLMs for structured knowledge extraction is validated by Bi et al. (2024), ACM TALLIP, which demonstrates that prompting LLMs with a code-style structured output format significantly improves the precision and consistency of extracted triples. This directly informs the NoteGraph prompt design, which uses a JSON schema as an in-prompt specification.
Gemini's structured output API is documented at Gemini Docs, and Ollama's REST API at Ollama Docs. Both backends are integrated in the production plugin with a common adapter interface that allows swapping backends without changing the extraction logic.
4.5 Related Tools and Competitive Analysis
| Tool | Approach | Gap Addressed by NoteGraph |
|---|---|---|
| Obsidian Graph View | Renders backlinks between notes as a graph | No AI concept extraction; NoteGraph builds concept graphs within a single note |
| Roam Research | Bidirectional linking and block references | No AI-extracted concept graph; NoteGraph requires no manual link maintenance |
| Logseq | Open-source outliner with graph from page links | NoteGraph brings visual capability to Joplin without changing note-taking workflow |
| Transformers.js | ONNX transformer models in browser via WASM | Foundation for zero-setup embedding pipeline; no Python or external server needed |
5. Technical Approach
5.1 System Architecture
The plugin is structured into four clearly separated layers. Each layer communicates through well-defined interfaces: postMessage for webview communication, Joplin plugin APIs for core access, and a REST adapter for LLM backends.
NoteGraph System Architecture
5.2 Concept Extraction and Graph Pipeline
This shows the complete data flow from raw note content to interactive graph rendering, including the cache bypass path.
Concept Extraction and Graph Construction Pipeline
5.3 Plugin Entry Point (index.ts)
The main plugin file registers the Joplin panel, settings, toolbar button, and workspace event listener. Below is the core structure:
*TypeScript - index.ts (plugin entry point)*
import joplin from 'api';
import { registerSettings } from './settings';
import { Extractor } from './extractor';
import { GraphEngine } from './graph';
joplin.plugins.register({
onStart: async function() {
await registerSettings();
const panel = await joplin.views.panels.create('notegraph_panel');
await joplin.views.panels.setHtml(panel, '<div id="cy"></div>');
await joplin.views.panels.addScript(panel, './webview.js');
// Listen for note switches
await joplin.workspace.onNoteChange(async () => {
const note = await joplin.workspace.selectedNote();
if (!note) return;
const engine = new GraphEngine();
const graphData = await engine.build(note.id, note.body);
await joplin.views.panels.postMessage(panel, { type: 'GRAPH', data: graphData });
});
}
});
5.4 Extraction Layer (extractor.ts)
The extractor sends note content to the configured LLM backend (Gemini or Ollama) with a schema-validated JSON prompt. The response is parsed and validated before being passed to the graph engine.
*TypeScript - extractor.ts (concept and relation extraction)*
// extractor.ts
export interface Concept {
id: string; label: string;
type: 'topic'|'concept'|'entity'|'event'|'attribute';
importance: number; // 0-1
}
export interface Relation {
source: string; target: string;
label: string; strength: number;
}
export class Extractor {
private buildPrompt(text: string): string {
return `You are a knowledge graph extractor.
Return ONLY valid JSON matching this schema:
{ "concepts": [{"id":"1","label":"ML",
"type":"topic","importance":0.9}],
"relationships": [{"source":"1","target":"2",
"label":"includes","strength":0.8}] }`, text);
}
async extract(text: string): Promise<{concepts,relationships}> {
const raw = await this.callLLM(this.buildPrompt(text));
return this.validateSchema(JSON.parse(raw)); // retry on fail
}
}
5.5 Cache Manager (cache.ts)
The cache manager prevents redundant LLM calls by keying extractions on a SHA-256 hash of the note content combined with the note ID. Cache entries are stored as JSON in Joplin's plugin data directory and survive restarts.
*TypeScript - cache.ts (content-hash cache)*
import * as crypto from 'crypto';
import joplin from 'api';
export class CacheManager {
private async getPath(): Promise<string> {
return (await joplin.plugins.dataDir()) + '/graph_cache.json';
}
private hashKey(noteId: string, body: string): string {
return noteId + '_' + crypto
.createHash('sha256').update(body).digest('hex').slice(0,16);
}
async get(noteId: string, body: string): Promise<any|null> {
const cache = await this.load();
return cache[this.hashKey(noteId, body)] ?? null;
}
async set(noteId: string, body: string, data: any): Promise<void> {
const cache = await this.load();
cache[this.hashKey(noteId, body)] = data;
await this.save(cache);
}
}
5.6 Graph Engine (graph.ts)
The graph engine merges LLM-extracted concept triples with embedding-based cosine similarity edges. It produces a Cytoscape-compatible nodes/edges payload and assigns cluster IDs for colour grouping.
*TypeScript - graph.ts (graph builder and cosine similarity)*
export class GraphEngine {
async build(noteId: string, body: string): Promise<CyGraphData> {
const cache = new CacheManager();
let extracted = await cache.get(noteId, body);
if (!extracted) {
extracted = await new Extractor().extract(body);
await cache.set(noteId, body, extracted);
}
// Compute embeddings for all concepts
const embeddings = await embedAll(extracted.concepts.map(c => c.label));
// Add similarity edges above threshold
const threshold = await getSetting('similarityThreshold');
const simEdges = pairwiseCosine(embeddings, threshold);
return buildCyData(extracted, simEdges);
}
// cosine: dot(a,b) / (|a| * |b|)
cosine(a: number[], b: number[]): number {
const dot = a.reduce((s,v,i) => s + v*b[i], 0);
const mag = (v: number[]) => Math.sqrt(v.reduce((s,x)=>s+x*x,0));
return dot / (mag(a) * mag(b));
}
}
5.7 Webview Renderer (webview.js)
The Cytoscape.js graph is initialised in the webview script. The renderer receives graph data via postMessage, applies the CoSE-Bilkent layout, and registers click events for deep-link navigation back to Joplin.
JavaScript - webview.js (Cytoscape initialisation)
// webview.js - runs inside Joplin panel
const cy = cytoscape({
container: document.getElementById('cy'),
style: [
{ selector: 'node', style: {
'background-color': 'data(color)',
'label': 'data(label)',
'width': 'mapData(importance,0,1,20,60)',
'height': 'mapData(importance,0,1,20,60)'} },
{ selector: 'edge', style: {
'label': 'data(label)',
'curve-style': 'bezier',
'target-arrow-shape': 'triangle'} }]
});
// Deep-link on double-click: navigate to note in Joplin
cy.on('dblclick', 'node', (e) => {
window.webviewApi.postMessage({
type: 'OPEN_NOTE', noteId: e.target.data('noteId')});
});
// Receive graph data from plugin process
window.webviewApi.onMessage((msg) => {
if (msg.type === 'GRAPH') {
cy.elements().remove();
cy.add(msg.data.nodes.concat(msg.data.edges));
cy.layout({ name: 'cose-bilkent', animate: true }).run();
}
});
5.8 Embedding Model Selection
| Model | Context | MTEB Score | Decision |
|---|---|---|---|
| all-MiniLM-L6-v2 | 256 tokens | ~56.26 | Rejected - silently truncates real notes |
| bge-small-en-v1.5 | 512 tokens | 62.28 | Selected - zero setup, WASM, strong quality |
| nomic-embed-text (Ollama) | 2048 tokens | 62.39 | Optional advanced backend for large notes |
5.9 Cross-Note Graph Mode
Beyond single-note graphs, the plugin supports a Notebook Graph mode that builds a cross-note knowledge map for the current folder. This mode runs bge-small-en-v1.5 on all notes (cached by note ID and modification time), computes pairwise cosine similarity above a user-configurable threshold, overlays LLM-extracted concept sub-nodes per note, and groups by k-means cluster.
*TypeScript - cross-note similarity (notebook indexer)*
export async function buildNotebookGraph(folderId: string): Promise<CyGraphData> {
const notes = await joplin.data.get(['folders', folderId, 'notes']);
const embeddings: Map<string, number[]> = new Map();
for (const note of notes.items) {
const body = (await joplin.data.get(['notes', note.id], {fields:['body']})).body;
embeddings.set(note.id, await embed(body));
}
const threshold = await getSetting('notebookThreshold'); // default 0.75
const edges: CrossEdge[] = [];
const ids = [...embeddings.keys()];
for (let i=0; i<ids.length; i++)
for (let j=i+1; j<ids.length; j++) {
const sim = cosine(embeddings.get(ids[i])!, embeddings.get(ids[j])!);
if (sim >= threshold) edges.push({src:ids[i],dst:ids[j],weight:sim});
}
return assembleCrossGraph(notes.items, edges, embeddings);
}
5.10 Challenges and Mitigations
| Challenge | Mitigation |
|---|---|
| Webview network restrictions block CDN | Bundle Cytoscape and Transformers.js via webpack - confirmed working in POC |
| LLM rate limits and API costs | Cache extractions by content hash; show token estimate before sending; batch small notes |
| Transformers.js WASM init time (2-3s) | Lazy-load model on first request; spinner; cache model binary in memory after load |
| Very long notes exceed context window | Chunk at paragraph boundaries; extract per chunk; merge graphs with deduplication |
| Inconsistent LLM JSON output | JSON schema in prompt; response validation with retry; schema shown as in-prompt example |
| Cytoscape performance with 100+ nodes | Configurable max nodes (default 30); incremental rendering; virtual rendering for large graphs |
6. Testing Strategy
A layered testing approach covers unit correctness, integration pipeline behaviour, and performance under load. Target is 80%+ coverage on all core modules.
6.1 Unit Tests (Jest)
extractor.ts: JSON schema validation, relation parser, chunk-merge deduplication
graph.ts: cosine similarity correctness, k-means cluster assignment, adjacency list build
cache.ts: SHA-256 key generation, cache hit/miss, stale invalidation on content change
*TypeScript - Jest unit test (cosine similarity)*
// graph.test.ts
import { GraphEngine } from '../src/graph';
describe('GraphEngine.cosine', () => {
const engine = new GraphEngine();
it('returns 1.0 for identical vectors', () => {
const v = [0.1, 0.9, 0.5];
expect(engine.cosine(v, v)).toBeCloseTo(1.0);
});
it('returns 0 for orthogonal vectors', () => {
expect(engine.cosine([1,0,0],[0,1,0])).toBeCloseTo(0);
});
it('rejects threshold below 0.5', () => {
expect(() => engine.pairwise([], 0.3)).toThrow();
});
});
6.2 Integration Tests
Mock Joplin API responses and verify full pipeline: note content to graph postMessage payload
Test cache bypass (content change triggers fresh extraction) vs cache hit (same content returns instantly)
Verify schema validation correctly rejects and retries malformed LLM JSON responses
6.3 Performance Tests
100-note folder: measure total embedding time and cross-note graph build latency
Render frame rate benchmark for 30, 60, and 100-node graphs in Cytoscape.js
Memory profile: model binary cache footprint after first WASM load
7. Libraries and Technologies
| Technology | Role | Reference |
|---|---|---|
| TypeScript | Plugin logic (index.ts, extractor.ts, graph.ts, cache.ts) | typescriptlang.org |
| Cytoscape.js | Graph rendering bundled via webpack | js.cytoscape.org |
| cytoscape-cose-bilkent | Physics layout with compound clustering | GitHub |
| Transformers.js (ONNX WASM) | bge-small-en-v1.5 embeddings in browser | HF Docs |
| Google Gemini API | Concept and relationship extraction (cloud) | Gemini Docs |
| Groq API | Fast cloud inference used in POC | console.groq.com |
| Ollama REST API | nomic-embed-text for local inference | Ollama Docs |
| webpack 5 | Bundling for plugin process and webview | webpack.js.org |
| Jest | Unit and integration test suite | jestjs.io |
| GitHub Actions | CI pipeline: lint, test, build on every PR | GitHub Actions · GitHub |
8. Implementation Plan
GSoC 2026 coding period: May 26 to August 25 (12 weeks). Approximately 40 hours per week with no other commitments during this period.
| Period | Tasks and Deliverables | Milestone |
|---|---|---|
| Week 1-2 May 26 - Jun 8 | Refactor POC into production-grade plugin structure (index.ts, extractor.ts, graph.ts, cache.ts, webview.js). Implement bge-small-en-v1.5 Transformers.js integration with warm-up and caching. Write unit tests for extractor, graph, cache modules. Set up CI pipeline (GitHub Actions). | Foundation complete - tests passing |
| Week 3-4 Jun 9 - Jun 22 | Implement full Gemini API integration with schema-validated JSON parsing. Add Ollama backend as optional alternative with common adapter interface. Build settings panel: API key, model selection, threshold, max nodes. Implement content-hash cache (CacheManager) for LLM extractions. | Extraction pipeline complete |
| Week 5-6 Jun 23 - Jul 6 | Build single-note knowledge graph with CoSE-Bilkent layout. Implement node colouring by type, edge labels, node size by importance. Add interactive features: hover tooltip, click-to-highlight, live search, wikilink detection. Integration tests for full note-to-graph pipeline. | Mid-1 Eval: single-note graph working |
| Week 7-8 Jul 7 - Jul 20 | Implement cross-note graph mode (notebook indexer, pairwise cosine, k-means clustering). Add similarity threshold slider. Add double-click node to open note navigation via joplin.commands.execute. Performance optimisation: incremental rendering, configurable node limit. | Cross-note graph working |
| Week 9-10 Jul 21 - Aug 3 | Implement long-note chunking with paragraph-boundary detection and chunk-graph merge with deduplication. Add PNG/SVG export. Add legend, zoom controls, keyboard shortcuts. User study with 2-3 Joplin community members via Discourse post. | Mid-2 Eval: feature complete |
| Week 11-12 Aug 4 - Aug 17 | Bug fixes from community feedback. Write full documentation: README, ARCHITECTURE.md, CONTRIBUTING.md. Record demo video. Submit plugin to Joplin plugin repository. Final code review with mentor. | Final submission ready |
| Buffer Aug 18-25 | Final mentor review and requested changes. Polish documentation and inline JSDoc. | GSoC Final Evaluation |
9. Deliverables
9.1 Code
Production-quality Joplin plugin published to joplin-plugin repository
Single-note knowledge graph: concept nodes, named relationship edges, hierarchical layout
Multi-note cross-graph: notebook-level semantic connections via pairwise cosine similarity
Two embedding backends: bge-small-en-v1.5 (Transformers.js) and nomic-embed-text (Ollama)
LLM extraction via Gemini API (cloud) and Ollama (local) with common adapter interface
Interactive Cytoscape.js renderer: search, filter, zoom, export, click-to-navigate, wikilink support
Content-hash caching system (CacheManager) for LLM extractions
Settings panel for all user-configurable options: API key, model, threshold, max nodes
9.2 Tests
Jest unit test suite covering extractor, graph engine, and cache modules (target: 80%+ coverage)
Integration tests for note-to-graph pipeline with mock Joplin API
Performance benchmarks for 100-note folders
9.3 Documentation
User-facing README with installation guide, screenshots, and usage walkthrough
Developer-facing ARCHITECTURE.md with data flow diagrams
CONTRIBUTING.md: how to run tests, how to add a new embedding backend
Inline JSDoc on all public APIs
Demo video posted to Joplin Discourse
10. Availability
| Item | Details |
|---|---|
| Weekly Hours | 40 hours/week during the coding period |
| Time Zone | IST (UTC+5:30) - Kanpur, India |
| University | Harcourt Butler Technical University, Kanpur - B.Tech 2023-2027 |
| Exams / Commitments | No exams or internships during GSoC coding period (May 26 to Aug 25) |
| Communication | Available Monday to Saturday, responsive within 4 hours during IST working hours. Weekly progress reports on Discourse and weekly sync calls with mentor. |
| POC Status | Working plugin NoteGraph already built and published on 27 March 2026: NoteGraph Discourse Thread. Gemini extraction + Cytoscape rendering confirmed functional in Joplin's plugin environment. |
| GitHub Plugin Repo | github.com/Kaushalendra-Marcus/AI-Generated-note-graphs |
| GitHub Profile | github.com/Kaushalendra-Marcus |
| linkedin.com/in/kaushalendra-singh-45b933272 | |
| Portfolio | kaushalendra-portfolio.vercel.app |