DEV Community: Raghuraj Pratap Singh

PAPERTRAIL — The Clarity Engine

Raghuraj Pratap Singh — Sat, 31 Oct 2026 18:31:28 +0000

PAPERTRAIL: Turning Confusing Documents into Evidence-Backed Action Plans with AI

Understand the requirements. Know what to do. Never submit blindly.

Have you ever opened a scholarship notice, college circular, job application guideline, or government PDF and struggled to understand what you actually need to do?

The important requirements might be scattered across several pages. Deadlines may appear in different sections. Mandatory documents can be hidden inside tables, and one overlooked condition can cause unnecessary confusion.

A document can contain all the information you need and still be difficult to act on.

That is the problem I wanted to solve with PAPERTRAIL — The Clarity Engine, my project for the October 2026 MLH × DEV Writing Challenge.

The idea is simple: instead of merely summarizing a document, help people turn its instructions into a clear, interactive, evidence-backed action plan.

The problem with ordinary document chat

AI-powered PDF chat tools can summarize documents and answer questions, but users often need more than a summary.

They need to know:

What exactly must I do?
Which requirements are mandatory?
What documents do I need?
Which deadlines apply to which tasks?
Where does the original document state this?
Are any instructions potentially contradictory?
What remains incomplete before I am ready to submit?

For important documents, a confident answer is not enough. Users also need a way to verify it.

That is where PAPERTRAIL takes a different approach.

Meet PROOFLINE: Every answer needs evidence

The central feature of PAPERTRAIL is PROOFLINE, an evidence-first approach to document intelligence.

When a requirement or answer is extracted, the system is designed to connect it to its supporting passage in the original document.

A citation can include:

The source document.
The relevant page and section.
The original supporting text.
A confidence indicator.
A way to open the corresponding document location.

For example, if someone asks, “What is the application deadline?”, the goal is not simply to return a date. PAPERTRAIL should show the passage supporting that date and preserve its context.

This matters when a document contains multiple dates for different stages of a process.

The principle behind PROOFLINE is straightforward:

Don't just tell users what a document means. Help them verify why.

Citation validation can establish that a passage exists in the source, but it cannot guarantee that every interpretation is correct. Ambiguous or conflicting evidence still needs careful review.

How PAPERTRAIL works

1. Upload a document

PAPERTRAIL is designed to process supported formats including PDF, DOCX, TXT, and images.

The document becomes the starting point for an investigation into its structure, instructions, requirements, and important dates.

2. Extract requirements

Instead of stopping at a general summary, the requirement engine organizes information into actionable items.

These can include eligibility conditions, required documents, submission instructions, deadlines, exceptions, and important warnings.

Requirements are organized into stages such as preparation, eligibility verification, document collection, application completion, final review, and submission.

3. Explore the original evidence

The Smart Document Explorer connects extracted information to the source document.

Users can inspect the original wording rather than relying entirely on an AI-generated interpretation.

This is especially important when simplifying complicated instructions: plain language should make a requirement easier to understand without silently removing its conditions or exceptions.

4. Ask PAPERTRAIL AI

The document assistant is designed to answer questions using retrieved passages from the relevant document.

Examples include:

Explain this paragraph in simple English.
Which documents are required?
What should I complete first?
Translate this instruction into Hindi or Hinglish.
Does this document contain potentially conflicting deadlines?

The system includes a deterministic grounded-answer mode, with optional integrations for Gemini and local Gemma inference through Ollama.

When an answer cannot be established from the available evidence, the appropriate response is to communicate that limitation rather than invent information.

5. Generate an interactive action plan

PAPERTRAIL converts requirements into a checklist that users can work through.

The action plan supports task completion, personal notes, priorities, reminders, and export options.

Progress is based on the user's actual checklist activity, not simply on the number of requirements extracted.

6. Run the “READY TO SUBMIT?” review

Before finishing a process, users can review incomplete tasks, unresolved questions, unverified requirements, and possible contradictions.

The purpose is to help people prepare more carefully—not to claim that an official application is eligible, approved, or successfully submitted.

The technology behind PAPERTRAIL

The application uses a modular full-stack architecture.

Frontend

React 19
TypeScript
Vite
Tailwind CSS

Backend

Python
FastAPI
Pydantic

Document processing

PyMuPDF for PDF processing
python-docx for Word documents
Pillow for image processing

AI and retrieval

A deterministic grounded-answer engine
Retrieval-Augmented Generation (RAG)
Optional Gemini integration
Optional local Gemma inference through Ollama

Storage and testing

Local JSON-based workspace persistence
Automated backend tests
A synthetic document package with ground-truth evaluation data

The deterministic mode is intended to provide useful document processing and evidence-based responses without requiring a paid AI API. Optional model integrations depend on their respective configuration and availability.

Measuring the results

PAPERTRAIL includes a synthetic evaluation package called The Application Clarity Challenge.

According to the project's benchmark report, the evaluation produced the following results:

Text extraction: 3 out of 3 pages processed successfully
Requirement extraction: 100% precision and 100% recall across 17 benchmark items
Date extraction: 100% accuracy across 4 benchmark dates
Citation verification: 100% of evaluated quotes were verifiable
Contradiction detection: 100% recall on the benchmark's tested deadline and fee conflicts
Retrieved passage relevance: 100% on the benchmark
Reported pipeline latency: 135 ms

The project's test report also records eight passing automated tests.

These results come from a small, synthetic evaluation dataset. They are useful for checking the implementation against known examples, but they do not establish equivalent performance across real-world documents, scanned PDFs, different languages, or complex policies.

That distinction is important. Reliable AI products should communicate what has actually been tested, not turn a successful demonstration into an unsupported universal claim.

Privacy and responsible document handling

Documents can contain personal and sensitive information, so privacy is an important design consideration.

PAPERTRAIL supports a local-first workflow and optional local model inference. Local inference can reduce the need to send document contents to an external AI provider, provided the rest of the application also keeps processing local.

Optional cloud inference requires appropriate configuration and careful handling of document data.

The project is intended to help people understand and prepare their applications. It does not replace official guidance, guarantee eligibility, or submit applications automatically.

What building PAPERTRAIL taught me

One of the biggest lessons from this project is that AI functionality alone does not make a useful product.

A document assistant needs more than a model that generates fluent answers. It needs reliable parsing, source tracking, meaningful retrieval, honest uncertainty handling, useful task management, and tests that measure its behavior.

I also learned how important it is to distinguish between extracting information and interpreting it.

A date can be extracted correctly but assigned the wrong meaning. A passage can be cited correctly but fail to support the conclusion drawn from it. A checklist can look complete while the user still needs to verify a condition.

These are reasons to design the entire workflow around evidence, not just the model.

There is still room to expand the evaluation dataset, test more diverse documents, improve OCR and multilingual handling, and validate performance on real-world examples.

Try PAPERTRAIL

🌐 Live demo: https://raghuraj72.github.io/PAPERTRAIL/

💻 GitHub repository: https://github.com/raghuraj72/PAPERTRAIL

Explore the demonstration and repository to see how the document workspace, requirement extraction, action planning, and evidence-first approach fit together.

Some AI and document-processing features may require the backend or a configured model to be running locally. Check the repository's setup instructions for the complete experience.

Final thought

A complicated document should not leave someone wondering what to do next.

People deserve to understand the requirements, identify the evidence, organize their tasks, and know what still needs attention.

PAPERTRAIL is my attempt to make that process clearer, more transparent, and more actionable.

PAPERTRAIL — Turn confusion into clarity.

Built for the October 2026 MLH × DEV Writing Challenge.

mlhackssvg #devchallengesvg #hackathonsvg

AFTERLIGHT: Giving Forgotten Software a Second Life with Open-Weight AI

Raghuraj Pratap Singh — Sat, 31 Oct 2026 18:28:15 +0000

AFTERLIGHT: Bringing Forgotten Software Back to Life with Open-Weight AI

Some code deserves a second life.

Software projects are created every day. Some become successful products. Others are abandoned when developers move on, documentation disappears, dependencies become outdated, and the people who understood the architecture are no longer available.

But the code remains.

What if we could reconstruct the story behind forgotten software—not just understand what the code does today, but investigate what it was originally designed to do?

That question inspired AFTERLIGHT — The Digital Archaeologist, my project for the Hacktoberfest 2026 Open-Source AI Challenge: Ghost in the Machine.

The idea: Software archaeology

AFTERLIGHT investigates software repositories as digital archives. It combines static analysis, Git history, evidence-based retrieval, and open-weight AI to help developers understand unfamiliar or abandoned projects.

Instead of returning a generic AI-generated explanation, the goal is to connect discoveries to source files, line numbers, and historical commits that developers can inspect.

The guiding principle is simple:

An AI explanation is more useful when you can inspect the evidence behind it.

How AFTERLIGHT works

1. Investigate a repository

Users can investigate a supported repository or upload a ZIP archive.

The analysis pipeline examines repository structure, programming languages, dependency manifests, documentation, and Git history.

2. Discover forgotten code

AFTERLIGHT aims to identify potential issues such as undocumented functions, unused-import candidates, unresolved TODOs, outdated dependencies, and missing tests.

Findings should include the relevant file, line number where available, supporting evidence, and a recommended next step.

These are investigation leads, not automatic proof that code is unnecessary. Static analysis has limitations, particularly when code is referenced dynamically.

3. Reconstruct the project's history

The Digital Time Machine presents Git commits, timestamps, messages, authors, and changed files.

This historical context helps developers understand how a repository evolved. Verified commit information should remain distinct from AI-generated interpretations of why a change happened.

4. Ask an open-weight model

The AI Explorer is designed to use Gemma through Ollama when the local model is configured and available.

For example:

What was this project originally designed to do?

The intended workflow retrieves relevant source-code chunks and historical context, then generates an explanation grounded in that evidence.

Citations help users inspect the underlying files. When evidence is incomplete, the system should communicate uncertainty rather than invent a convincing story.

5. Create a resurrection roadmap

After the investigation, AFTERLIGHT organizes possible improvements into a prioritized roadmap covering maintenance, dependencies, testing, documentation, and architecture.

Recommendations are intended for human review. Original repository files should not be overwritten automatically.

Why open-weight AI matters

The Ghost in the Machine theme encouraged me to think about what happens to software knowledge when its original maintainers disappear.

Open-weight AI makes this idea more practical in several ways.

Local inference: With a compatible model and runtime installed, repository questions can be processed on the developer's own machine.

Privacy: Local inference can help keep private source code on the machine, provided the rest of the application also avoids external transmission.

Flexibility: Developers can inspect the integration, change models, modify retrieval logic, and adapt the system to their needs.

Accessibility: A local-first workflow can reduce dependence on paid inference APIs, although hardware, electricity, and setup still have costs.

Open models do not automatically guarantee privacy or unrestricted licensing. The actual data flow, model license, and deployment configuration matter.

Making the results measurable

AFTERLIGHT includes a synthetic demonstration repository, GHOST_ARCHIVE_DEMO, intended to exercise the analysis pipeline against known findings.

The project's reported benchmark results are:

Precision: 91.7%
Recall: 73.3%
F1 score: 0.815
Citation coverage: 100%
Reported analysis latency: approximately 396 ms

These figures relate to the synthetic evaluation dataset, not a representative benchmark of real-world repositories. They should be interpreted alongside the dataset size, evaluation methodology, and limitations.

Citation coverage also does not establish that every AI-generated claim is correct. Evidence validity and answer quality require separate evaluation.

Built with

The project is designed around a modular architecture using:

React, TypeScript, and Tailwind CSS for the interface
FastAPI and Python for the backend
Python AST-based analysis for source-code inspection
Git history extraction for repository archaeology
Gemma and Ollama for configurable local inference
Retrieval-augmented generation (RAG) for repository-grounded questions
Local persistence, with optional database integration

Feature availability depends on the implemented code, installed dependencies, and runtime configuration.

What I learned

Building AFTERLIGHT reinforced an important lesson: adding an AI model to an application is not enough.

A useful AI developer tool needs reliable input processing, evidence retrieval, traceable conclusions, clear failure states, and a way to evaluate whether its output is correct.

The interface can create curiosity, but the evidence is what makes the experience trustworthy.

There is still room to improve retrieval quality, increase recall, evaluate more programming languages, and test the system against larger and more diverse repositories.

Try AFTERLIGHT

🌐 Live Demo: Explore AFTERLIGHT

💻 GitHub Repository: View the source code

Start with the live demonstration, then explore the repository to inspect the implementation and setup instructions. If the backend or local model is required for a feature, follow the repository's setup instructions to run that functionality.

Closing thought

Software does not need to remain a mystery simply because its original developers have moved on.

Its source code, commit history, and architectural clues may still preserve fragments of the knowledge needed to understand it.

AFTERLIGHT is an attempt to recover those fragments with open-weight AI and verifiable evidence.

AFTERLIGHT — Some code deserves a second life.

Built for the Hacktoberfest 2026 Open-Source AI Challenge — Week 4: Ghost in the Machine.

devchallenge #hf26challenge

SENTINEL X: An AI-Powered Cybersecurity Dashboard for Threat Detection

Raghuraj Pratap Singh — Sun, 18 Oct 2026 09:34:09 +0000

SENTINEL X: An AI-Powered Cybersecurity Dashboard for Threat Detection

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

SENTINEL X is an AI-assisted cybersecurity dashboard designed to help security learners, small businesses, and security teams explore suspicious activity, detect anomalies, assess risks, and understand incident-response workflows from one interactive interface.

Small organizations may not have dedicated security operations teams or the budget for expensive enterprise security platforms. SENTINEL X explores how an accessible, AI-assisted tool could make cybersecurity monitoring concepts easier to understand and investigate.

Key Features

Threat Monitor: Explore simulated security events and suspicious activity.
ML-Based Anomaly Detection: Use an Isolation Forest model to identify unusual patterns in telemetry.
Risk Analysis: Review risk scores and security insights.
Response Center: Explore recommended responses and simulated audit logs.
DEVIL AI Assistant: Get AI-assisted explanations when the relevant model integration is configured.
Interactive Dashboard: Explore cybersecurity information through a Streamlit interface.

Who Could Pay for It?

The potential customers include small businesses, cybersecurity training providers, IT consultants, and educational institutions looking for accessible security analytics and training tools.

A future commercial version could offer subscription-based analytics, custom telemetry integrations, team dashboards, and reporting. These are potential future offerings, not claims about features already implemented.

Important: The current project uses simulated telemetry and simulated response actions. It is an educational prototype, not a production intrusion-detection system or an automated containment platform.

Demo

Live Demo: [https://sentinel-x-raghuraj.streamlit.app/]

If the cloud deployment is not ready yet, you can share a short screen-recording demo instead.

Code

GitHub Repository: SENTINEL X

The repository contains the project source code and supporting files. Explore the implementation, review the dashboard, and suggest improvements.

How I Built It

I built SENTINEL X using Python and Streamlit, with machine-learning and data-processing libraries to create an interactive cybersecurity simulation.

Technology Stack

Python — application logic and data processing
Streamlit — interactive dashboard
Pandas and NumPy — telemetry and numerical operations
Scikit-learn — Isolation Forest anomaly detection
Ollama with a local language model — optional AI-assisted explanations when configured

The dashboard brings threat exploration, anomaly detection, risk analysis, and response workflows together. The local language-model integration is optional, so a cloud deployment needs an appropriate configuration for any features that depend on it.

Why Does Open Innovation Matter?

Open innovation makes it possible for students, independent developers, and security enthusiasts to learn from existing tools and build on shared knowledge rather than starting from scratch.

For SENTINEL X, open-source libraries make machine learning, data processing, and dashboard development accessible without requiring a large proprietary software stack.

Using an open-weight language model through a local inference tool such as Ollama can also offer more control over model selection and experimentation than relying exclusively on a closed hosted AI API. Local inference does require suitable hardware and configuration, and it is not automatically available on a hosted Streamlit deployment.

Keeping the project open source gives other developers an opportunity to inspect the implementation, contribute improvements, experiment with detection approaches, and help make cybersecurity education more accessible.

My Agent Session

Optional: Add a DevRelay agent-session recording or link here if you have one. Otherwise, remove this section.

Prize Categories

Add only the partner prize categories for which the project genuinely qualifies, according to the challenge rules.

Built as an educational project exploring AI-assisted cybersecurity, anomaly detection, and open-source innovation.

WildQuest AI 🌿: Turn Screen Time into Real-World Nature Adventures

Raghuraj Pratap Singh — Sat, 10 Oct 2026 16:53:41 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

WildQuest AI is an interactive nature-exploration website designed to encourage people to take a break from their screens and discover the real world around them.

Instead of endlessly scrolling, users can explore nature-themed quests, discover outdoor activities, and turn everyday walks into small adventures. The interface features a 3D forest environment, nature photography, and animated visual elements designed to make exploring nature feel exciting.

The goal is simple: use technology to inspire people to spend more time outside, not just more time online.

WildQuest AI is designed for students, nature lovers, beginners who want to explore outdoors, and anyone looking for a healthier balance between digital life and the natural world.

Demo

🌐 Live Website: https://raghuraj72.github.io/WildQuest-AI/

Code

💻 GitHub Repository: https://github.com/raghuraj72/WildQuest-AI

The project is open source, and contributions that improve the experience, accessibility, nature quests, and interactive features are welcome.

How I Built It

I built WildQuest AI as a web-based project using HTML, CSS, and JavaScript.

The project includes:

An interactive nature-themed interface.
A 3D forest environment using Three.js.
Nature photography and visual effects.
Animated birds, clouds, and weather effects.
Nature quest ideas designed to encourage outdoor exploration.

The project focuses on creating an engaging experience using open web technologies. Any AI-powered features should be described according to the models and integrations actually configured in the project.

Why Does Open Innovation Matter?

Open innovation allows developers to learn from one another, improve existing ideas, and build tools that more people can use.

For WildQuest AI, open source makes it possible for contributors to add new nature quests, improve accessibility, introduce new visual experiences, and help make outdoor exploration more engaging.

I believe technology should not only help us work faster or learn more—it should also encourage us to reconnect with the world around us.

My Agent Session

Optional — add your DevRelay agent session link here if you have one.

Prize Categories

Open-source AI challenge submission.

DEV Community: Raghuraj Pratap Singh

PAPERTRAIL — The Clarity Engine

PAPERTRAIL: Turning Confusing Documents into Evidence-Backed Action Plans with AI

The problem with ordinary document chat

Meet PROOFLINE: Every answer needs evidence

How PAPERTRAIL works

1. Upload a document

2. Extract requirements

3. Explore the original evidence

4. Ask PAPERTRAIL AI

5. Generate an interactive action plan

6. Run the “READY TO SUBMIT?” review

More than a document chatbot

The technology behind PAPERTRAIL

Measuring the results

Privacy and responsible document handling

What building PAPERTRAIL taught me

Try PAPERTRAIL

Final thought

mlhackssvg #devchallengesvg #hackathonsvg

AFTERLIGHT: Giving Forgotten Software a Second Life with Open-Weight AI

AFTERLIGHT: Bringing Forgotten Software Back to Life with Open-Weight AI

The idea: Software archaeology

How AFTERLIGHT works

1. Investigate a repository

2. Discover forgotten code

3. Reconstruct the project's history

4. Ask an open-weight model

5. Create a resurrection roadmap

Why open-weight AI matters

Making the results measurable

Built with

What I learned

Try AFTERLIGHT

Closing thought

devchallenge #hf26challenge

SENTINEL X: An AI-Powered Cybersecurity Dashboard for Threat Detection

SENTINEL X: An AI-Powered Cybersecurity Dashboard for Threat Detection

What I Built

Key Features

Who Could Pay for It?

Demo

Code

How I Built It

Technology Stack

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

WildQuest AI 🌿: Turn Screen Time into Real-World Nature Adventures

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories