Forem: Kelvin Kiptum Kiprop

Parse Pal: Open Source PDF Chat App Built with Next.js, Neon, Chroma, and Cloudinary

Kelvin Kiptum Kiprop — Fri, 20 Mar 2026 12:56:01 +0000

If you have ever dropped a long PDF into an AI tool and hoped for the best, you already know the problem: the answer might sound confident, but you still do not know what the app is doing behind the scenes, where your files go, or how hard it would be to adapt the workflow to your own needs.

That is the gap Parse Pal is trying to close.

Parse Pal is an open-source app for turning PDFs into a chat experience backed by retrieval. You can upload a document, ingest it, and ask questions against the content instead of guessing or manually scanning page after page. Under the hood, the project is built with a modern, practical stack: a Next.js web app, a CLI for local and admin workflows, shared retrieval logic in a reusable package, and hosted infrastructure for storage, state, and vector search.

TL;DR

Parse Pal is an open-source app for chatting with PDF documents using retrieval.
It is built for a real hosted workflow, not just a throwaway demo
The stack combines Next.js, Cloudinary, Neon, Chroma, and a shared RAG package
Developers can study it, fork it, self-host it, or contribute to it
Try the app here: https://parse-palweb-production.up.railway.app/
Explore the code here: https://github.com/design-sparx/parse-pal

Why We Built It

A lot of document-chat demos look magical for five minutes and frustrating after that. They often hide the ingest flow, treat documents as disposable one-offs, or make it difficult to understand how retrieval is scoped.

Parse Pal takes a more grounded approach:

PDF uploads are handled through a hosted web flow
Ingestion runs asynchronously instead of blocking the whole experience
Conversation, document, and job state are stored explicitly
Retrieval is scoped to the relevant document instead of relying on a destructive single-document model
The same project also includes a CLI surface for local or admin use cases
That combination makes the app more useful for real projects, not just quick demos.

What Makes Parse Pal Interesting

There are plenty of AI wrappers available online. What makes an open source project worth paying attention to is not just that it uses AI, but that it gives you a clean place to start building your own version.

Parse Pal is interesting because it is opinionated in the right places:

The web app is designed for a hosted workflow, with direct upload, signing, and readiness polling
The data flow is explicit, which makes the system easier to reason about
The retrieval layer is shared, so the app and CLI do not drift apart
The architecture is modular enough to extend without rewriting everything

If you are a developer exploring RAG, document intelligence, or AI-assisted knowledge tools, that matters. You are not just getting a chatbot. You are getting a working reference for structuring one.

A Practical Stack for Document Chat

Parse Pal uses a stack that is practical for a real document-AI product, not just a quick prototype. Each piece has a clear job:

Next.js powers the web app because it gives us a strong foundation for building the hosted product experience, including routes, server-side logic, API endpoints, and a UI layer that is easy to extend
Cloudinary handles PDF storage and delivery, so uploads can happen directly from the browser in a cleaner, more scalable way
Neon stores conversation, document, and ingest job state so the app can track what was uploaded, what is still processing, and when a document is ready for chat
Chroma handles vector storage, which makes retrieval possible once the document has been chunked and embedded
The shared RAG package keeps embeddings, retrieval logic, vector-store integration, and Chroma configuration in one place, so both the web app and CLI can use the same core behavior

The reason this stack works well is that it separates responsibilities cleanly. Next.js owns the product surface. Cloudinary owns file storage. Neon owns the application state. Chroma owns the retrieval data. The shared RAG package connects those pieces without forcing everything into one tangled code path.

That separation is useful for contributors, too. It means the project is easier to understand, easier to debug, and easier to extend when someone wants to improve the UI, swap infrastructure, or experiment with retrieval quality.

Who This Project Is For

Parse Pal is a strong fit for:

Developers learning how to build a document chat workflow end-to-end
Indie hackers who want a starting point for a PDF Q&A product
Teams prototyping internal knowledge tools
open source contributors who want a practical AI app to improve It is also a good example for people who want to study the tradeoffs behind ingest pipelines, hosted uploads, and retrieval scoping without starting from a blank repo.

Why Open Source Matters Here

AI products become much more valuable when people can inspect, adapt, and improve them.

With Parse Pal, open source means you can:

Understand how the ingest pipeline is wired
Swap infrastructure choices to fit your stack
Improve the UI and conversation experience
Experiment with better retrieval and chunking strategies
Use the CLI and shared package as building blocks for new workflows

That is a better story than “here is another black-box AI tool.” It invites people to use the project, learn from it, and contribute back to it.

Where Parse Pal Can Grow

The most exciting part of a project like this is not just what it already does, but what it enables next.

Potential directions include:

better source citation and answer grounding
richer document management for multi-file workflows
team or workspace collaboration features
evaluation tooling for retrieval quality
improved onboarding for self-hosting and contributors

That makes Parse Pal useful both as a product and as a foundation for experimentation.

Try Parse Pal or Contribute

If you have been looking for an open source PDF chat app you can actually learn from, Parse Pal is worth a look.

Use it to explore your own documents. Read the code to understand the architecture. Fork it if you want to build your own document assistant. Contribute if you want to help improve the open source AI tooling ecosystem.

Live app: https://parse-palweb-production.up.railway.app/

GitHub: https://github.com/design-sparx/parse-pal

Projects like this are how better AI software gets built: in public, with real tradeoffs, by people willing to make the internals understandable.

Parse Pal is a solid step in that direction.

Building a Modern Browser-Based Code Editor

Kelvin Kiptum Kiprop — Sun, 25 Jan 2026 12:34:13 +0000

Code Editor X: Building a Modern Browser-Based Code Editor

A deep dive into creating a VS Code-inspired development environment using cutting-edge web technologies

TL;DR

Code Editor X is a VS Code-inspired, browser-based code editor built with React 19, TypeScript, CodeMirror 6, Tailwind CSS 4, and Radix UI.

What it does: Multi-file editing with tabs and file tree, syntax highlighting for multiple languages, AI chat assistant, project dashboard, persistent local storage, and full customization.

Why it matters: Zero installation, lightweight, works on any device, built on modern tech, accessible by design.

Introduction

The browser has become a legitimate platform for serious software development. Code Editor X is a modern, browser-based code editor built from the ground up with React 19, TypeScript, and CodeMirror 6.

Why I Built This

I wanted to code from anywhere; my laptop, a borrowed computer, even a tablet, without installing anything. Traditional IDEs are powerful but heavy. They assume you have a dedicated machine with gigabytes to spare.

I also wanted to learn. React 19 had just landed with its concurrent rendering improvements. CodeMirror 6 promised blazing-fast editing. Tailwind CSS 4 was out. Building a code editor felt like the perfect way to push these technologies to their limits and understand them deeply.

Code Editor X started as an answer to a simple question: What if VS Code lived entirely in your browser?

Who Is This For?

Audience	Why It Works
Students	No setup—open browser, start coding
Prototypers	Lightweight environment for quick ideas
Teachers	Same environment for everyone, no "works on my machine"
Remote workers	Access projects from any device

Quick Comparison

Aspect	Traditional IDE	Code Editor X
Setup Time	Minutes to hours	Instant
Disk Space	Hundreds of MB	Zero
Cross-Platform	Different installers	Works everywhere
Resource Usage	500MB+ RAM	Lightweight

The Tech Stack

Every choice was deliberate.

React 19 + TypeScript

Concurrent rendering handles complex UI updates smoothly—multiple resizable panels, real-time syntax highlighting, instant theme switching. TypeScript catches bugs at compile time and serves as living documentation.

CodeMirror 6

The editor's heart. CM6 was rewritten from scratch for performance:

Compartments for dynamic reconfiguration without recreating the editor
Extensible architecture—every feature is a module
Mobile-friendly unlike many competitors

// Switch themes without recreating the editor
const themeCompartment = new Compartment();
view.dispatch({
  effects: themeCompartment.reconfigure(newTheme)
});

Radix UI + Tailwind CSS 4

Radix provides accessible component primitives (dialogs, dropdowns, tooltips) that work with screen readers and keyboard navigation. Tailwind makes styling fast and consistent.

IndexedDB + React Context

Offline-first persistence with IndexedDB: your work stays local, you own your data. React Context manages theme, settings, and project state without external dependencies.

What We've Built

The Layout

All panels are resizable, collapsible, and remember their state across sessions.

Core Features

File Tree: Hierarchical navigation with language-specific icons, create/rename/delete operations
Multi-Tab Editing: Dirty state indicators, tab management, auto-focus behavior
CodeMirror Editor: Syntax highlighting, line numbers, bracket matching, code folding, custom themes
AI Chat Panel: Context-aware help, code block support with copy functionality
Settings: Theme, font, tab size, word wrap, auto-save—all customizable
Dashboard: Project management with search, filters, and quick actions

Architecture

src/
├── components/
│   ├── layout/           # Shell layout
│   ├── editor-page/      # Editor components
│   └── ui/               # Reusable primitives
├── lib/
│   ├── theme-provider.tsx
│   ├── settings-provider.tsx
│   └── project-provider.tsx
└── types/

Three focused context providers handle state: ThemeProvider, SettingsProvider, ProjectProvider. Changes flow unidirectionally through IndexedDB.

What's Next?

Near-term: Terminal integration, git operations, more language support, find and replace

Medium-term: Real AI integration, collaborative editing, extensions system, cloud sync

Long-term: Debugger, build tools, deployment pipelines, mobile optimization

Conclusion

Code Editor X shows what's possible when modern web technologies combine thoughtfully. The browser is no longer a limitation, it's a feature.

Try It Out

Live Demo →

Or run locally:

git clone https://github.com/design-sparx/code-editor-x.git
cd code-editor-x
npm install
npm run dev

Open http://localhost:5173 and start coding.

Built with React 19, TypeScript, CodeMirror 6, Tailwind CSS 4, and Radix UI.

GitHub · Live Demo

How I Built an Open-Source Admin Dashboard Template with Mantine and Next.js

Kelvin Kiptum Kiprop — Wed, 03 Apr 2024 07:48:06 +0000

Introduction

Welcome to a journey into web development innovation and collaboration. In this post, we unveil the narrative behind an open-source admin dashboard template that redefines efficiency and user experience. Join us as we delve into the design, code, and community that shaped this project.

At its core lie the dynamic forces of Mantine and Next.js. Mantine, a React component library, expertly crafts a functional UI masterpiece. With its diverse collection of UI components and unyielding focus on accessibility, it conjures an intuitive admin dashboard as if by artistic enchantment.

Complementing Mantine is Next.js, a dynamic React framework with server-side rendering and performance. Our template transcends static design, delivering responsive, interactive experiences.

Why an admin dashboard template

Admin dashboard templates are pivotal tools in web development, driving efficiency, organization, and seamless management.
They function as potent catalysts, accelerating the development process for developers.
These templates offer ready-made blueprints, reducing the need to start from scratch.
They encompass a diverse array of pre-designed UI components, layouts, and functionalities.
Specifically tailored to administrative interfaces, they address the unique needs of such applications.
Templates provide a solid foundation, eliminating the requirement to build every element anew.
This approach empowers developers to concentrate on crafting custom features and functionalities.
The result is a distinctive application that stands out in a crowded digital landscape.

How to get started

Getting started with our open-source admin dashboard template is a breeze. By following a few simple steps, you can have the template up and running, ready for exploration and customization.

To begin, head over to our GitHub repository. You’ll find the repository housing the admin dashboard template project. You have the option to either clone the repository using Git or download it as a ZIP archive. Choose the method that suits you best and retrieve the template’s source code onto your local machine.

Key Folders and Files

· Layout — contains all files involved with the layout of your project. Such as styles for your header, footer, navigation, and grid system.

· Components — holds all your files for buttons, carousels, sliders, and similar page components (think widgets).

· Mocks — contains dummy data JSON files. Note: JSON files are generated using Mockaroo.

As you navigate through these folders and files, you’ll gain a comprehensive understanding of how the template’s architecture is constructed and how different components interact.

Highlighted Components and Features

Charts: Charts are essential for visualizing data trends and insights. Our template incorporates ApexCharts components, which are highly customizable and responsive.

import ReactApexChart from "react-apexcharts";

// Example usage
<ReactApexChart options={options} series={series} type="area" height={350}/>

Tables: Mantine Datatable provides a data grid-like functionality coupled with data-rich user interfaces that are indispensable for displaying tabular data. Our template includes advanced table components that facilitate sorting, filtering, and pagination.

import {DataTable} from "mantine-datatable";

// Example usage
<DataTable columns={columns} records={records}/>

Forms: Forms are a crucial part of any admin interface. Mantine offers form components that are highly customizable and equipped with validation features.

import { TextInput, Select } from '@mantine/core';

// Example usage
<TextInput label="Username" placeholder="Enter your username" />;
<Select label="Role" data={roleOptions} />;

Maps: React Simple Maps provides maps that are valuable for visualizing geospatial data. You can integrate interactive maps into your dashboard to represent data points geographically.

import {ComposableMap, Geographies, Geography, Marker} from "react-simple-maps";

// Example usage
<ComposableMap projectionConfig={{rotate: [-10, 0, 0]}}>
  <Geographies geography={geoUrl}>
    {...}
  </Geographies>
  {...
    return (
     <Marker key={...} coordinates={[...]}>
        <circle fill={...} stroke="#FFF" r={...}/>
    </Marker>
    );
  })}
</ComposableMap>

By incorporating these core components, our template accelerates the development of admin dashboards. These components are designed to work seamlessly together, providing a cohesive user experience. You can effortlessly create complex data visualizations, interactive tables, intuitive forms, and interactive maps — essential elements that transform raw data into meaningful insights.

Deploying the Template to a Live Environment

Deploying our admin dashboard template to a live environment is a straightforward process. We recommend utilizing popular hosting platforms like Vercel, Netlify, or Firebase Hosting. These platforms offer seamless integration with Next.js and allow you to deploy with a few simple steps:

Install Required Dependencies: Ensure you have the necessary dependencies specified in the package.json file.
Build the Project: Generate a production build of your Next.js application using the command: npm run build.
Select Hosting Platform: Choose your preferred hosting platform (e.g., Vercel).
Connect Repository: Link your template’s GitHub repository to the hosting platform.
Configure Deployment Settings: Configure deployment settings, such as branch selection and build commands.
Deploy: Trigger the deployment process. The hosting platform will automatically build and deploy your admin dashboard template.

Real-World Use Cases

The versatility of our admin dashboard template knows no bounds. It caters to a myriad of real-world use cases, each tailored to specific industries and applications:

E-Commerce Management: The template can be employed to manage product listings, order processing, and inventory tracking for online stores.
Data Analytics: With its data visualization components, the template can serve as a dashboard for analyzing metrics, trends, and insights.
Project Management: The template’s customizable components facilitate the creation of project management tools for tracking tasks, deadlines, and team collaboration.
SaaS Applications: As the foundation of a Software as a Service (SaaS) application, the template streamlines user management, subscription tracking, and data presentation.
Content Management: It can also function as a content management system dashboard, offering tools to manage articles, media, and user-generated content.

Live Demo

For a hands-on experience, explore the live demo of our admin dashboard template:

Live demo — https://mantine-analytics-dashboard.netlify.app/

Witness the template’s adaptability, responsiveness, and functionality firsthand. Feel free to interact with its components, navigate through its sections, and envisage how it could seamlessly integrate into your projects.

Contributing and Support

I welcome all developers and enthusiasts to contribute to the growth of our open-source admin dashboard template. Contributing is a collaborative process that empowers us to collectively enhance the template’s capabilities and quality. To get started:

Fork the Repository: Fork the template’s GitHub repository to your own GitHub account.
Clone the Fork: Clone the forked repository to your local machine using Git.
Create a Branch: Create a new branch for your contributions to keep the main codebase intact.
Implement Changes: Make your desired changes, add new components, or refine existing features.
Commit and Push: Commit your changes to the new branch and push them to your GitHub fork.
Submit a Pull Request: Submit a pull request from your forked repository to the main template repository. Your changes will be reviewed and potentially merged.

Conclusion
In summary, our Mantine and Next.js admin dashboard template offers a range of benefits that empower developers, designers, and entrepreneurs to create exceptional admin interfaces:

Efficiency and Speed: The template expedites development by providing a pre-built foundation of components and features, allowing you to focus on customization and innovation.
Consistency and Aesthetics: Mantine’s design-first approach and Next.js’s performance optimizations ensure a consistent and visually appealing user experience.
Flexibility and Customization: The template’s modularity and theming options facilitate easy customization to align with your project’s unique branding and requirements.
Rich Functionality: The integration of core components such as charts, tables, forms, and maps equips you with tools to tackle diverse dashboard functionalities.

Invitation to Explore and Utilize

The Mantine and Next.js admin dashboard template isn’t just an end; it’s a beginning — a starting point for your creative journey. Whether you’re a seasoned developer seeking a rapid launch or an enthusiast keen on learning modern development practices, this template is your canvas.

Additional Resources

GitHub repository — https://github.com/design-sparx/mantine-analytics-dashboard
Mantine — https://mantine.dev/
Nextjs — https://nextjs.org/
Code documentation — https://mantine-analytics-dashboard-docs.netlify.app/