GSoC 2026 Proposal Draft – Idea 2: Joplin Atlas – AI-Generated Knowledge Graph with Concept Trails and Contradiction Detection
Personal Information
Name: Pranav Karthik
Email: karthik.pranav88@gmail
GitHub: https://github.com/
LinkedIn: https://www.linkedin.com/in/pranav-karthik-84832a248/
University: University of Wisconsin–Madison
Degree: B.S. in Computer Science and Data Science
Graduation: May 2027
Project Title
Joplin Atlas: AI-Generated Knowledge Graph with Concept Trails and Contradiction Detection
Abstract
I propose building a Joplin plugin that transforms a user’s note collection into a living knowledge atlas. Rather than only visualizing explicit note links or shared tags, the plugin will discover deeper relationships across notes using semantic similarity, clustering, and concept extraction.
The plugin will generate an interactive note graph that helps users understand how ideas in their notes connect, evolve, and sometimes conflict. In addition to showing note-to-note relationships, it will introduce two distinctive features: concept trails, which trace how related ideas appear across multiple notes, and contradiction detection, which highlights notes that express conflicting claims, competing approaches, or unresolved questions.
The goal is to make Joplin more useful not only as a place to store notes, but as a system for exploring and understanding personal knowledge.
About Me
I am a Computer Science and Data Science student at UW–Madison with experience in software engineering, full-stack development, retrieval-based machine learning systems, and applied AI products. My work has included building RAG pipelines, document-grounded assistants, and full-stack systems in TypeScript, React, Node.js, Python, and PyTorch. My resume is available on my LinkedIn.
Relevant experiences include:
- At Sprocket Lab, I built a benchmark over 15K+ Polymarket events and worked on an autonomous retrieval-and-reasoning loop for LLM forecasting.
- I built Haven, a disaster relief web app that used live data ingestion and a RAG layer for emergency shelter lookup.
- I built SHIPWizard, a document-grounded assistant over insurance policy documents with context-aware workflows and intelligent form-filling.
These projects gave me experience with retrieval quality, structured data pipelines, AI-assisted UX, and building products that need to be both technically sound and useful to end users.
Why This Project
Joplin users often have large note collections containing research, personal writing, project notes, technical references, and clipped information. Existing graph visualizations are helpful, but they usually stop at showing explicit note links or tag overlap.
That misses a lot of the structure inside a note collection:
- notes that are semantically related but never linked,
- clusters of notes that belong to the same theme,
- concepts that recur and evolve across time,
- and notes that disagree with one another or describe unresolved thinking.
This project aims to uncover that deeper structure and present it visually and interactively.
Instead of a static graph, the plugin would create a living map of the user’s knowledge base.
Project Goals
The main goal is to create a plugin that can:
- Generate a graph of notes using multiple relationship types
- Discover clusters of related notes automatically
- Extract and trace recurring concepts across notes
- Surface contradictions, disagreements, or unresolved tensions between notes
- Provide an interactive visualization for exploration inside Joplin
Key Features
1. Semantic Note Graph
Each note will be represented as a node. Edges between notes can come from:
- explicit note links,
- shared tags,
- semantic similarity,
- optional AI-labeled relationships.
This allows the graph to capture both obvious and hidden structure in the user’s notes.
2. Topic Clustering
The plugin will group related notes into clusters such as:
- machine learning notes,
- project planning,
- class notes,
- personal reflections.
Each cluster can be given a short automatically generated label so the graph is easier to interpret.
3. Concept Trails
This is one of the project’s most distinctive features.
Instead of only connecting notes to each other, the plugin will identify important concepts and show how they recur or develop across multiple notes. For example, a user might see that one idea appears in an early brainstorming note, later becomes part of a project plan, and eventually appears in a research summary.
This helps users understand how ideas evolve over time.
4. Contradiction / Tension Detection
The plugin will identify pairs or groups of notes that appear to:
- make conflicting claims,
- propose different solutions to the same problem,
- or leave a topic unresolved.
This makes the graph more useful for students, researchers, and writers, since not all valuable relationships are positive similarity relationships. Sometimes the most useful connection is a disagreement.
5. Interactive Exploration
Users should be able to:
- click nodes to open notes,
- filter by notebook, tag, or relationship type,
- inspect clusters,
- highlight concept trails,
- and view contradiction hotspots.
Technical Approach
I plan to implement this as a Joplin plugin.
Pipeline
The system would work roughly as follows:
- Load notes and metadata from Joplin
- Parse Markdown note content
- Extract:
- explicit inter-note links,
- tags,
- note metadata,
- candidate concepts / keywords
- Build semantic representations of notes
- Compute graph relationships:
- explicit-link edges
- shared-tag edges
- semantic-similarity edges
- concept-trail relationships
- contradiction candidates
- Render an interactive graph inside a plugin panel
Graph Structure
Possible graph elements:
-
Nodes
- notes
- optionally concepts, if concept-node mode is enabled
-
Edges
- explicit link
- shared tag
- semantic similarity
- concept continuation / trail
- contradiction / tension
Visualization
The plugin UI would visually distinguish:
- topic clusters,
- edge types,
- important or central notes,
- and optionally different graph layers.
The graph should remain useful even on medium-sized note collections, so filtering and threshold controls will be important.
Scope
Core MVP
The minimum complete version of the project would include:
- note ingestion from Joplin
- extraction of explicit links and tags
- semantic similarity graph generation
- cluster discovery
- interactive graph visualization
- click-to-open note support
Stretch Goals
If time allows, I would add:
- concept trails
- contradiction detection
- auto-generated cluster labels
- hub / centrality analysis
- graph summaries
This way, the project remains useful even if only the core scope is completed, while still leaving room for more ambitious features.
Implementation Plan / Timeline
Community Bonding Period
- Become familiar with Joplin plugin APIs and development workflow
- Finalize technical design with mentor feedback
- Settle on graph representation and storage approach
- Review existing graph-related plugins and avoid duplication
Weeks 1–2
- Set up plugin scaffold
- Load notes and metadata from Joplin
- Parse Markdown and extract explicit links and tags
- Define graph data model
Weeks 3–4
- Build semantic similarity pipeline for notes
- Generate first version of note graph
- Add local graph persistence or caching if needed
- Write tests for metadata extraction and graph generation
Weeks 5–6
- Implement graph visualization panel
- Add click-to-open-note interaction
- Add filters by notebook, tag, and edge type
- Improve graph usability for medium-sized collections
Weeks 7–8
- Add topic clustering
- Add automatically generated cluster labels
- Improve node styling and graph navigation
- Validate performance and graph readability
Weeks 9–10
- Add concept trail extraction and rendering
- Implement concept-based exploration features
- Refine graph data model to support layered relationships
Weeks 11–12
- Add contradiction or tension detection
- Improve explainability of flagged contradictions
- Add documentation, screenshots, setup instructions, and polish
- Incorporate mentor feedback and finalize deliverables
Deliverables
By the end of the project, I aim to deliver:
- A working Joplin plugin for AI-generated note graphs
- Graph generation using explicit, tag-based, and semantic relationships
- Topic clustering and cluster labeling
- Interactive graph visualization inside Joplin
- Concept trail functionality
- Contradiction or tension detection
- Documentation and usage guide
Why I Am a Good Fit
This project fits my skills very well.
I have experience building:
- full-stack systems in TypeScript, React, Node.js, and Python,
- retrieval-heavy AI systems and RAG pipelines,
- data ingestion and normalization pipelines,
- and user-facing tools that make large information collections easier to navigate.
I am especially interested in building AI features that are not just impressive demos, but genuinely useful interfaces for understanding and navigating information. This project is exactly that kind of problem.
Availability
I expect to be available full-time during the GSoC coding period and can communicate consistently through the Joplin forum and GitHub.
Past Contributions to Joplin
I have not yet submitted a Joplin PR. I started preparing this application late in the cycle, so I focused first on building a strong technical proposal and narrowing the project into a realistic plugin-scoped design. I understand that contributions and code familiarity are important, and I would be eager to start contributing if given the opportunity.
Conclusion
Joplin already helps users store and organize their notes. This project would help users go one step further: understand how their ideas connect, evolve, and conflict across their personal knowledge base.
I believe this would make Joplin more powerful for students, researchers, writers, and technical users, while also being an exciting and distinctive GSoC project.
Thank you for your time and consideration.