Featured Project
ElleHacks 2026 AI Document Analysis Platform
CoinCrew is a financial-literacy platform concept built for ElleHacks 2026. It was designed to help youth understand money, responsibility, and important documents through AI-supported explanations, interactive learning, and generated quiz-style education.
Overview
What the project does
CoinCrew was created as a kid-friendly financial-literacy platform. The broader concept included game-inspired learning, generated quizzes, and chatbot-style support to make topics like documents, money, and responsibility easier to understand.
The current protected demo focuses on the AI document analysis section of the platform. Users can upload a typed PDF or paste document text, prepare the document as searchable context, and generate a simplified explanation using AI. This feature shows the core technical system behind the product: document extraction, chunking, embeddings, semantic retrieval, and age-adaptive explanation.
The game UI/UX and full interactive learning experience were part of the larger product vision, but the working hosted demo focuses on the document explainer workflow. Some of the interactive learning features were outside the current hosted demo scope, so the demo highlights the most complete technical feature: helping users understand real-world documents through retrieval-based AI explanations.
Important Demo Note
Current demo behavior and limitations
The hosted version is a working prototype demo. It demonstrates the main document workflow: uploading or pasting content, extracting text, preparing searchable chunks, storing context, retrieving relevant sections, and generating a simplified explanation.
Some chunks in the demo may appear larger than they would be in a fully tuned production system. This was intentional during prototyping because legal, financial, and government documents often rely on surrounding clauses for meaning. Larger chunks help preserve context and reduce the risk of separating important details too aggressively.
In a more refined version, chunk size, chunk overlap, retrieval count, and prompt detail could be tuned to produce shorter, more targeted explanations. The current demo is meant to show the architecture and workflow, not final production-level output.
Technical Flow
Embeddings-first RAG workflow
Upload or Paste
The user uploads a typed PDF or pastes document text into the web app. This gives the system content to extract, prepare, and explain.
Extract Text
PDF.js extracts readable text from typed PDFs directly in the app. This works best for typed documents because the text can be parsed without OCR.
Chunk Document
The extracted text is divided into document chunks. The prototype uses larger chunks to preserve context across related sections, clauses, definitions, and deadlines.
Create Embeddings
Each chunk is converted into an embedding, which represents the meaning of the text as a numerical vector. This allows the system to search by meaning instead of exact keywords.
Store + Retrieve Context
Chunks and embeddings are stored in MongoDB Atlas Vector Search. When an explanation is needed, the app retrieves the most relevant document sections as context.
Generate Explanation
Gemini AI receives the retrieved document context and generates a simplified, age-adaptive explanation for the user.
Product Vision
How the document tool fits into CoinCrew
CoinCrew was not only intended to be a document explainer. The larger idea was to teach young users about financial responsibility in a way that feels less intimidating and more interactive. The document analysis feature acts as the technical foundation for helping users understand real-world documents, while interactive learning features could turn that information into quizzes, guided lessons, and chatbot conversations.
The platform concept also included chatbot-style document support, where users could ask questions such as “What do I need to do next?”, “Are there any deadlines?”, or “What does this term mean?” It could also generate short quizzes from the explanation to help users check their understanding in a more engaging way.
These learning and chatbot features were part of the broader product direction, but the hosted demo is limited to the AI document workflow. That section was the strongest working part of the prototype and demonstrates the core system that future game-based, quiz-based, and chatbot-based learning features could build on.
RAG System Design
Why the document is prepared before generation
The project uses an embeddings-first design. This means the document is prepared and saved as searchable context before the AI generates the final explanation. This separates document processing from explanation generation and makes the workflow more reusable.
With this design, the app can reuse saved document context instead of reprocessing the same content repeatedly. It also allows the backend to retrieve only the most relevant sections for a summary, explanation, or future chatbot question. This is more scalable than placing the entire document into one AI prompt every time.
This design also supports a more privacy-conscious workflow. Instead of sending the entire document to the AI model for every request, the system can focus on selected chunks that are most relevant to the explanation. In a production version, chunking rules and preprocessing could be adjusted to reduce unnecessary private details, focus on explanation-relevant sections, and apply stronger redaction before AI generation.
Document Privacy + Chunk Control
How context can be controlled
Because the document is broken into chunks before explanation, the backend has more control over what information is used as AI context. Rather than treating the document as one large prompt, the system can retrieve specific sections that are relevant to the user's request.
The chunk size, chunk overlap, retrieval count, and filtering rules can all be adjusted. For example, a future version could prioritize deadlines, financial obligations, definitions, or next steps while avoiding sections that contain unnecessary personal details. This would make the system more focused, safer, and easier to tune for different document types.
This is especially important for legal, government, and financial documents because they may contain sensitive information. A production version would add stronger privacy protections such as redaction, access controls, authentication, encryption, retention settings, and user-controlled document deletion.
AI Explanation Logic
How explanations are generated
After relevant chunks are retrieved, Gemini AI is given the document context and a prompt that controls the explanation style. The goal is to translate complex wording into simpler language while still keeping important details.
The explanation layer was designed to be age-adaptive. This means the same document can be explained differently depending on the user's selected age or understanding level. A younger user may receive simpler wording and definitions, while an older user may receive a more direct summary with key terms, responsibilities, and next steps.
Privacy-Conscious Design
How the demo handles document context
The demo does not permanently store the uploaded PDF file itself. Instead, it extracts readable text, saves searchable chunks and embeddings, and generates explanations from saved or retrieved context. This keeps the workflow focused on document understanding rather than file storage.
For a production system, next steps would include automatic redaction, authentication, user-level access controls, document retention settings, encryption, and the ability for users to delete saved document context.
My Role
What I worked on
Document Upload Flow
Built the document upload and paste-text workflow so users could provide either a typed PDF or raw text for analysis.
PDF Text Extraction
Connected PDF.js text extraction so typed PDF content could be parsed and prepared for backend processing.
Chunking + Embeddings
Worked on the flow that splits document text into chunks, prepares embeddings, and makes the content searchable through semantic retrieval.
MongoDB Vector Search
Integrated MongoDB Atlas Vector Search so saved document chunks could be retrieved by meaning instead of only exact keyword matching.
Gemini AI Explanations
Implemented age-adaptive explanation logic using Gemini AI and prompt instructions that turn retrieved document context into simpler explanations.
API Testing + Documentation
Created and tested backend API routes for preparing documents, retrieving context, and generating explanations. I also documented the API workflow for easier testing and review.
Demo Output
What the demo shows
The demo shows the main document-analysis behavior: a document is uploaded or pasted, processed into searchable context, and explained using AI. The current output is meant to demonstrate the architecture and interaction flow. Because chunk sizes and prompts are still prototype-level, some explanations may be longer or broader than a fully tuned version.
In a refined version, the explanation output could be adjusted with prompt controls, smaller chunks, stronger section detection, better metadata, privacy-focused filtering, and mode-specific retrieval. This would allow the app to give more focused answers depending on the user's goal.
Tech Stack
Tools used
Learning Outcome
Built a working AI document explainer with retrieval-based context.
This project helped me practice document processing, AI prompt design, embeddings, vector search, RAG architecture, PDF text extraction, privacy-conscious document handling, API testing, and building a user-facing product around complex document understanding.
The demo is protected because it connects to live AI and database services.