ShorolSikhyaAI

Inspiration

Books hold the world's knowledge, but not everyone reads at the same level, and complex academic prose can be a massive barrier to learning. Whether it's a student struggling with dense textbooks, someone with learning differences like dyslexia, or an individual learning a new language, standard books aren't always accessible.

We wanted to build a bridge. But more importantly, we wanted to build a completely private bridge. In an era where every interaction is logged, tracked, and sent to the cloud, we envisioned ShorolSikhyaAI a completely offline digital companion that respects user privacy while turning intimidating books into easy, accessible learning.

What it does

ShorolSikhyaAI transforms physical reading materials into an interactive, simplified digital experience without an internet connection.

Capture & Extract: A user photographs a difficult book page. The app processes the image and extracts the raw text.

Simplify: A local Large Language Model (LLM) rewrites the dense text into plain, easily digestible language.

Narrate: A local Text-to-Speech (TTS) engine reads the simplified version aloud.

Reinforce: The app automatically extracts tricky vocabulary words, provides summaries, and logs the session in a local learning history dashboard so users can track their progress over time.

How we built it

We built ShorolSikhyaAI using a highly decoupled, modern, and performant offline stack:LayerTechnology UsedPurposeFrontendNext.js 15 (App Router), TypeScript, TailwindCSS, Shadcn UI, Framer MotionProvides a slick, responsive, and animated user interface.BackendFastAPI, Pydantic v2, SQLAlchemy 2.0, SQLiteHandles heavy asynchronous operations and fast API routing.OCR PipelinePaddleOCR, OpenCV, PillowPre-processes images and accurately extracts text blocks.Local AIOllama running qwen2.5:3bPowerfully simplifies text locally without cloud API latencies or fees.AudioPiper TTS, Howler.jsGenerates and controls crisp, natural local voice narration.InfraDocker Compose, NginxStandardizes the environment for easy local orchestration.

Challenges we ran into

Building an end-to-end AI application meant to run entirely on a user's local machine introduces unique architectural hurdles:The Air-Gapped Environment Dilemma: The initial codebase was generated in an environment without live network access. This meant we couldn't just run npm install or pip install to check things iteratively. We had to ensure absolute syntactic validity (python3 -m compileall) and rely heavily on rigorous unit-verifications for the pure text-processing utilities.Resource Orchestration: Running an OCR pipeline, a 3B parameter language model, and a neural TTS engine simultaneously on standard consumer hardware requires tight resource management. Decoupling the services using FastAPI and orchestrating them through Docker Compose was critical to prevent system crashes.Voice and Model Initialization: Writing shell scripts to reliably download models (download-models.sh) and providing clear instructions for localized tools like Piper voices required careful configuration to ensure a seamless "Quick Start" experience for the end user.

Accomplishments that we're proud of

Zero Cloud Dependency: We succeeded in creating a full-scale AI application that requires absolutely zero external API calls. Your data never leaves your machine. Production-Ready Codebase: Despite environment constraints, the entire codebase was built with real, robust implementations—no shortcuts, no placeholders. From database migrations via Alembic to smooth frontend hooks, everything is structurally sound and ready for action.An Elegant UX for Heavy Tech: We wrapped complex machine learning operations into a highly polished UI using Framer Motion and Shadcn UI, making local AI feel as smooth as a premium SaaS product.

What we learned

The Power of Small Models: Working with qwen2.5:3b proved that small, quantized local models are incredibly capable at targeted text-simplification and summarization tasks when prompted correctly.

Local-First Architecture: We gained deep insights into designing for local environments, specifically how to structure file uploads, handle sqlite databases efficiently under concurrent read/writes, and manage local media output lifecycle (images and generated audio).Strict Interface Design: When you can't test live against third-party servers, your Pydantic schemas and TypeScript types become your best friends. Strict typing saved us from endless integration headaches down the pipeline.

What's next for ShorolSikhyaAI

Here is a forward-looking, compelling "What's next" section to wrap up your Devpost Project Story perfectly:

What's next for ShorolSikhyaAI While we have successfully built a cohesive, fully offline local pipeline, this is just the foundation for making learning truly private and universally accessible. Here is where we want to take ShorolSikhyaAI next:Going Mobile-First: Right now, the application runs locally via Docker on a computer. Our ultimate goal is to optimize the pipeline into a native mobile app capable of running lightweight, highly quantized models directly on standard smartphones. This would make it completely portable for students in remote or low-connectivity areas.

Adaptive Reading Levels: We plan to introduce a "Comprehension Slider" in the UI. Instead of a single plain-language rewrite, users will be able to customize the target reading level—ranging from elementary simplification to high-school reinforcement, or specifically optimized for non-native language learners.True Multilingual Support: Rooted in the spirit of making education universally simple, we want to expand our local pipeline to natively support regional languages. This includes multi-lingual OCR and cross-lingual simplification, allowing a user to photograph a complex textbook page and receive a simplified explanation in their native tongue.

Interactive Local Q&A: We want to turn static reading into a dynamic conversation. By adding a local chatbot sidebar, users will be able to ask their offline companion follow-up questions about the page (e.g., "Can you give me another analogy for this paragraph?" or "Break down this specific concept further").Advanced Document Layout Parsing: Textbooks are rarely just blocks of text; they are filled with sidebars, multi-column layouts, diagrams, and mathematical formulas. We plan to enhance our image processing pipeline to intelligently map complex layouts so charts and tables are preserved and explained intuitively.

Built With

• alembic
• docker
• fastapi
• framer-motion
• howler.js
• next.js
• nginx
• ollama
• opencv
• paddleocr
• pillow
• piper-tts
• python
• react-query
• shadcn-ui
• sqlalchemy
• sqlite
• tailwindcss
• typescript