DEV Community: Rajesh Adhikari

Talk to Your Data Like a Human: How I Built an AI Airline Analyst

Rajesh Adhikari — Thu, 30 Oct 2025 22:13:29 +0000

In the world of air travel, every passenger has a story. Some rave about the legroom. Others complain about cold meals or slow Wi-Fi. But here's the thing, what if you could actually talk to those 20,000 stories and get answers that help you run a better airline?

That's exactly what AIRLYTICS does.

I'm thrilled to introduce AIRLYTICS, my project for MindsDB Hacktoberfest 2025. It's not just another analytics dashboard. It's a conversational intelligence platform that transforms messy, unstructured passenger reviews into strategic business insights — the kind that actually tell you what to fix and why it matters.

Think of it as having a genius data analyst who speaks plain English, never sleeps, and always knows exactly which 100 reviews out of 20,000 matter most for your question.

🔗 Explore the GitHub Repository | 🎥 Watch the Demo Video

The Problem: Drowning in Feedback, Starving for Insight

Airlines collect mountains of customer feedback. Reviews pile up across booking sites, social media, and post-flight surveys. But here's where it gets messy.

Traditional analytics tools are great at counting things. They'll tell you the average Wi-Fi rating is 2.8 out of 5. Cool. But they won't tell you that Wi-Fi below 3 stars drops overall satisfaction by 68%, or that upgrading routers matters more than upgrading the catering menu.

They can't understand questions like "Show me Business Class travelers who loved the crew but hated baggage handling." They definitely can't explain why high ratings don't always mean high loyalty, or what that disconnect means for your bottom line.

Most BI tools require you to speak their language — SQL queries, pre-defined metrics, rigid schemas. AIRLYTICS flips that around. You speak English. It handles the rest.

Meet AIRLYTICS: Your AI Airline Analyst

AIRLYTICS is what happens when you combine MindsDB's Knowledge Bases with a dual-agent architecture and sprinkle in some serious semantic search magic.

Here's what makes it different.

🧠 Two Modes, One Seamless Experience

Most analytics platforms force you to choose between simplicity and power. AIRLYTICS gives you both.

Semantic Search Mode is perfect when you're exploring. Type something like "excellent legroom and comfortable seats" or "lost baggage and delayed luggage" and boom — the system surfaces the most relevant reviews using vector embeddings. Not just keyword matching. Real semantic understanding. The kind that knows "mishandled bag" and "lost luggage" mean the same thing.

You get the top 50 matched reviews, plus comprehensive statistics: average ratings across every dimension, seat type distributions, traveler demographics, correlation matrices showing which metrics actually drive satisfaction. It's like having a full statistical report generated in seconds, tailored exactly to your query.

Advanced Analytics Mode is where things get interesting. This is for questions like "Among users complaining about check-in delays, show me seat type distribution for those who still rated ground service above 3."

That's not a simple search. That's a multi-layered analytical question. The AI agent interprets your intent, figures out you're asking for a conditional distribution analysis, rewrites your query for optimal semantic matching, executes the right statistical function, and returns targeted visualizations with contextual explanations.

All from one sentence. No SQL. No setup. Just ask.

The Secret Sauce: Five Intelligent Functions

Behind the scenes, AIRLYTICS uses five specialized analytical engines. When you ask a complex question, the agent automatically routes it to the right one:

General Percentage Distribution handles questions like "What percentage of passengers rated value for money above 4?" — fast, simple threshold checks across any numeric field.

Conditional Distribution Analysis shows you breakdowns like "For delayed passengers, what's the seat type distribution?" — perfect for understanding how issues vary across categories.

Category-to-Category Analysis compares two categorical fields, like "How many Economy passengers were Solo Leisure versus Business travelers?" — great for demographic pivots.

Rating-to-Rating Analysis finds overlaps between numeric conditions, like "Of passengers with low Wi-Fi scores, how many also rated overall experience poorly?" — the correlation detective.

Conditional Rating Analysis connects ratings to outcomes, like "Among high food raters, what percent still recommended the airline?" — revealing those crucial loyalty disconnects.

The beautiful part? You never have to know which function does what. Just ask your question naturally. The agent figures it out.

Smart Sampling: Why Less is More

Here's something cool about AIRLYTICS that most analytics platforms get wrong.

It doesn't analyze all 20,000 reviews for every query. That would be slow, expensive, and frankly, unnecessary. Instead, it uses smart sampling.

Every query retrieves the top N semantically matched reviews — you can choose 10, 20, 50, 75, or 100 (MindsDB's current limit). All statistics, distributions, and correlations are computed from this focused subset.

Why does this matter? Because when you ask about Wi-Fi complaints, you don't need reviews about excellent meals. You need the 100 most relevant Wi-Fi-related reviews. That's your representative sample. That's where your signal lives.

It's faster, more focused, and statistically just as valid. Plus, it means every metric you see is actually about what you asked for, not diluted by thousands of unrelated reviews.

InsightInterpreter: Your AI Strategist

Raw numbers are useful. Strategic recommendations are invaluable.

That's why AIRLYTICS includes InsightInterpreter — think of it as your in-house AI consultant who's allergic to corporate buzzwords and loves cutting through noise.

After any query, hit the "Get AI Insights" button. InsightInterpreter looks at your results — the distributions, correlations, top reviews, all of it — and tells you what actually matters.

Not "Wi-Fi ratings are low."

But "Wi-Fi below 3 stars drops overall satisfaction by 68%. Upgrade routers on long-haul routes — it impacts loyalty more than catering."

Not "Business travelers rate cleanliness at 6.2."

But "Business travelers forgive delays but hate dirty cabins. Prioritize cleaning staff over gate efficiency."

It spots contradictions (high ratings, low loyalty — what gives?), identifies root causes (it's not the food, it's the pricing), and suggests concrete next steps. All written in the voice of a seasoned analyst who knows that real insight is the difference between a refund and a repeat customer.

Rich Metadata Filtering: Slice and Dice Your Way

AIRLYTICS supports filtering across every structured dimension in your data.

Want to see only Emirates Business Class reviews? Done. Need verified Solo Leisure travelers on long-haul flights? Easy. Looking for passengers who rated Wi-Fi below 3 but overall experience above 7? No problem.

You've got 50+ airlines, multiple aircraft types, four seat classes, different traveler types, verification flags, recommendation status, and eight numeric rating fields to work with. Mix and match however you want.

Every filter applies to both semantic searches and analytical queries. The system handles it seamlessly in the background.

Building AIRLYTICS: The MindsDB Magic

So how does all this actually work?

At its core, AIRLYTICS is powered by three MindsDB components working in perfect harmony.

Knowledge Bases: The Foundation

MindsDB Knowledge Bases are what make semantic search possible. Instead of storing just text, they store meaning — vector embeddings that capture the semantic essence of each review.

When you search for "bad food and poor service," the Knowledge Base doesn't just match those exact words. It finds reviews about "terrible meals and rude staff," "cold food and unhelpful crew," or "worst dining experience and slow service." It understands synonyms, context, and intent.

Plus, it respects structured metadata. You can search semantically and filter by airline, seat type, ratings — all in one query. That's the hybrid power MindsDB brings to the table.

The Analytics Agent: The Interpreter

This is where things get really clever.

The analytics_query_agent is trained to understand natural language questions and break them down into two parts:

Part 1: The semantic filter — what kind of reviews should we look at?

Part 2: The analytical question — what measurement or comparison do we want?

If only Part 1 exists, it's a straightforward semantic search. If both parts exist, the agent maps Part 2 to one of the five analytical functions, extracts the right parameters (which fields, what thresholds, which operators), and returns everything as structured JSON.

All you had to do was ask a question in plain English.

The Insight Agent: The Strategist

The insight_interpreter_agent is your executive translator.

It takes the raw analytics output — the numbers, distributions, top reviews — and interprets them through the lens of airline operations strategy. It's trained to spot patterns, identify contradictions, connect dots between seemingly unrelated metrics, and recommend concrete actions.

It doesn't just describe what it sees. It explains what it means and what you should do about it.

Here's a tiny peek at its prompt philosophy:

You are InsightInterpreter — the sharp data analyst inside an airline's analytics division.
Your job: Cut through the noise and tell the manager something they didn't already know.
Focus on contradictions, unexpected drivers, and actionable next steps.

Rules:
1. No recaps. Don't restate the query.
2. No fluff. Skip "The data shows..."
3. Be concrete. Use actual numbers when they matter.
4. Stay tight. 2-3 paragraphs, max.
5. End with action. Always tell what should be done differently.

That's it. Sharp, focused, actionable. Every time.

Beyond Airlines: A Blueprint for Any Feedback Domain

Here's the thing — while AIRLYTICS is built for airline reviews, the architecture is a template.

The same approach works for:

🏨 Hotels — guest reviews, amenity feedback, service ratings

🍽️ Restaurants — delivery experiences, menu feedback, ambiance comments

🛒 E-commerce — product reviews, shopping experiences, return issues

🏥 Healthcare — patient satisfaction, appointment experiences, facility feedback

📞 Support — ticket descriptions, call transcripts, chat logs

Anywhere you have unstructured feedback with structured metadata, this pattern applies. Swap the schema, prepare the agents on domain-specific language, and you're off to the races.

That's the power of MindsDB's Knowledge Bases. They're not industry-specific. They're insight-specific.

Real-World Impact: What This Means for Airlines

Let's get practical for a second.

Imagine you're an airline ops manager. You know Wi-Fi complaints are up, but you don't know if it's a dealbreaker or just noise. You type:

"Users who complained about baggage claim delays — what percentage of those who rated ground service above 4 rated overall experience below 5?"

In 3 seconds, you get:

42% of users with good ground service ratings still had poor overall experiences
A breakdown by seat type showing Business Class is disproportionately affected
A correlation heatmap revealing that baggage issues matter 3× more than food quality for Business travelers
An InsightInterpreter note: "Baggage delays hit Business travelers hardest. They pay premium prices for time — not food. Fast-track baggage handling for premium cabins immediately."

You just went from a hunch to a prioritized action plan in seconds.

That's what conversational analytics looks like. And that's what AIRLYTICS delivers.

The Tech Behind the Magic

For the curious: AIRLYTICS is built with React and TailwindCSS on the frontend, FastAPI on the backend, and MindsDB handling all the AI heavy lifting. Data flows from Google Sheets straight into MindsDB's Knowledge Base — zero ETL pipelines, zero data warehouses.

Docker Compose keeps MindsDB containerized for local development. OpenAI's embeddings power the semantic search. Recharts and Plotly handle visualizations. The whole stack is designed to be clean, modular, and production-ready.

Want to set it up yourself? The full installation guide, architecture diagrams, and SQL examples are all in the GitHub README. Everything you need to get it running locally or extend it to your own domain.

Hacktoberfest 2025: Built for Advanced Capabilities

AIRLYTICS was designed for MindsDB Hacktoberfest Track 2: Advanced Capabilities. That means it checks all the boxes:

✅ Knowledge Base integration with 20,000+ reviews

✅ Dual-agent architecture (analytics + insights)

✅ Metadata filtering across multiple dimensions

✅ Hybrid search capabilities (semantic + structured)

✅ Automated data freshness with MindsDB Jobs

✅ Zero-ETL architecture (Google Sheets → MindsDB direct)

But beyond the checklist, it's a complete RAG-to-BI pipeline. Not a toy demo. Not a proof of concept. A production-grade analytics engine that shows what's possible when you combine semantic understanding, statistical rigor, and AI interpretation.

Try It Yourself

Curious to see AIRLYTICS in action?

🔗 GitHub Repository: rajesh-adk-137/AIRLYTICS

🎥 Demo Video: Watch on YouTube

📖 Full Documentation: Available in the repo README

Clone it. Run it. Break it. Extend it to your own domain. The entire codebase is open source and ready to go.

The Future of Analytics is Conversational

Here's what I learned building AIRLYTICS:

The future of business intelligence isn't about building more dashboards. It's about building systems that understand questions, find answers, and explain what to do next. All in natural language. All in real-time.

MindsDB's Knowledge Bases make that possible. Their agent architecture makes it scalable. And the zero-ETL approach makes it practical.

Whether you're analyzing airline reviews, hotel feedback, or customer support tickets, the pattern is the same: semantic understanding + statistical rigor + AI interpretation = actionable intelligence.

The age of asking your data questions and getting strategic answers has arrived.

And it's powered by MindsDB.

Acknowledgments

Huge thanks to the MindsDB team for creating such a powerful platform, OpenAI for the embedding models, and the entire open-source community for the tools that made this possible.

Built with ❤️ for MindsDB Hacktoberfest 2025.

AIRLYTICS: Transforming unstructured feedback into strategic intelligence, one query at a time.

Ready to unlock intelligence from your own feedback data? Check out the *AIRLYTICS GitHub repo** and start exploring what's possible with MindsDB Knowledge Bases.*

CharacterKB: Your AI-Powered Companion for Fictional Characters

Rajesh Adhikari — Sun, 29 Jun 2025 14:41:48 +0000

Discover, Analyze, and Chat: Unleash the Power of Fictional Characters with CharacterKB

In the vast genre of storytelling, fictional characters often become as real to us as the people we know. But what if you could not only discover them based on nuanced descriptions but also delve into their psyches and even converse with them? This is where CharacterKB steps in – an innovative AI-powered platform designed to revolutionize how you interact with fictional characters.

I'm thrilled to introduce CharacterKB, a project developed for the MindsDB Quest 019, showcasing the robust capabilities of MindsDB's Knowledge Bases. CharacterKB leverages MindsDB's cutting-edge semantic search, AI Tables, and Agents to transform your character ideas into precise discoveries, deep psychological insights, and engaging conversations.

Why MindsDB Knowledge Bases?

MindsDB is an AI data solution that empowers users to query data using natural language and SQL across diverse data sources. Their Knowledge Bases are a game-changer, offering semantic search capabilities that allow you to store and retrieve information based on its meaning, rather than just keywords. This semantic understanding is crucial for CharacterKB, enabling it to go beyond simple keyword matching and truly understand your character descriptions.

Introducing CharacterKB: Your Intelligent Character Companion

CharacterKB is more than just a search engine; it's a comprehensive character experience crafted for writers, fans, and anyone curious about the depths of fictional personalities. Here's what makes it unique:

AI-Powered Character Discovery: Describe any character idea in natural language (e.g., "Billionaire who becomes a symbol of fear for criminals") and instantly get the best match along with the top 5 closest results using MindsDB's semantic search.

A natural language query in action, demonstrating CharacterKB's intuitive search and personalized character suggestions.

Character Insights & Analysis: Dive deeper with AI-powered psychological profiling that analyzes personality traits, emotional patterns, and core characteristics. Get concise personality tags and structured emotional profiles highlighting confidence, optimism, wit, and more.

Detailed character insights, including personality tags and emotional profiles, all generated by MindsDB AI Tables.

Interactive Character Chat: Engage in authentic conversations with discovered characters in their unique voices and mannerisms. Just click 'Chat' to get personalized advice, creative insights, or fun interactions—no setup needed.

Interact with the AI literary expert for in-depth conversations about characters.

Smart Image Suggestions: See visual representations of your matched character with curated image results pulled from the web using intelligent search, automatically and seamlessly.
Filter by Media Type: Refine your character searches by over 20 different media types, including Movies, TV Shows, Novels, Games, Anime, and Mythology.
Authentic Conversations: Characters respond with their unique voice, mannerisms, and wisdom, offering life advice, creative insights, and new perspectives.

The Tech Stack: MindsDB at the Core

CharacterKB is built with a robust and modern tech stack designed for scalability, performance, and reliability:

MindsDB: The central AI layer, handling Knowledge Bases for semantic search, AI Tables for data enrichment, and Agents for the conversational bot.
FastAPI (Python): The high-performance backend API.
React + Tailwind CSS: For a sleek, responsive, and interactive user interface.
OpenAI: Powering the large language models used by MindsDB for embeddings, AI Tables, and Agents.
Google Custom Search API: For smart image suggestions.
Docker Desktop: For consistent development and deployment environments.

System Architecture

CharacterKB's multi-layered architecture ensures a seamless and powerful user experience:

Frontend Layer: Built with React and Tailwind CSS, focusing on responsive design and intuitive user interaction.
API Layer: Powered by FastAPI, handling requests for character search, interactive character chat, and enriched character information.
AI Layer: MindsDB orchestrates the core AI functionalities, including Knowledge Base queries, Agent interactions, and semantic search.
Data Layer: Manages character metadata, media type classification, and relevance scoring, leveraging a dataset of over 10,000 characters.

Building CharacterKB: A Deep Dive into MindsDB Integration

The integration of MindsDB is fundamental to every intelligent feature within CharacterKB. Here’s a glimpse into how different MindsDB capabilities are utilized, directly with SQL queries executed within MindsDB Studio:

1. Intelligent Character Discovery with Knowledge Bases

At the heart of CharacterKB's search is a MindsDB Knowledge Base, which stores over 10,000 character descriptions. This allows the application to understand the context, personality, and media type preferences of your query, going beyond simple keyword matching.

Here's an example of a semantic search query within MindsDB:

SELECT *
FROM character_kb_10000
WHERE content = 'a genius scientist who loves trains sheldon'
LIMIT 5;

This SQL query to the character_kb_10000 Knowledge Base allows for semantic search, finding characters based on their description, and retrieving the top results.

2. AI-Powered Interactive Character Chat with MindsDB Agents

The interactive "Character Chat" is powered by a custom conversational agent created within MindsDB. This agent is designed to provide thoughtful analysis, interpretations, and discussions about characters, drawing from its deep literary knowledge and role-playing as the character.

Here’s how you can query the Character Agent in MindsDB:

SELECT answer
FROM character_agent
WHERE
  character_name = 'Tony Stark'
  AND character_description = 'Tony Stark is a genius billionaire inventor who masks his insecurities with sarcasm and bold charisma. As Iron Man, he faces threats with a mix of wit, technology, and restless optimism about humankind’s potential.'
  AND question = 'I’m nervous before my first job interview. Any advice?';

This SQL query to the character_agent MindsDB Agent passes the character's name, description, and the user's question to get a contextual, in-character answer.

3. Enriched Character Information with MindsDB AI Tables

To provide comprehensive character details, CharacterKB utilizes MindsDB AI Tables. These tables dynamically generate enriched metadata such as personality traits, emotional profiles, and smart tags.

Here’s how you query the Character Insights model in MindsDB:

SELECT response
FROM character_insights
WHERE
  character_name = 'Tony Stark'
  AND character_description = 'Tony Stark is a genius billionaire inventor who masks his insecurities with sarcasm and bold charisma. As Iron Man, he faces threats with a mix of wit, technology, and restless optimism about humankind’s potential.';

This query to the character_insights MindsDB Model (an AI Table) takes the character's name and description to generate a rich set of personality details.

4. Data Freshness with MindsDB Jobs

To ensure the Knowledge Base remains up-to-date with new characters, a MindsDB JOB is scheduled to periodically check for and ingest new data from the source Google Sheet.

An example of the MindsDB JOB creation:

CREATE JOB character_kb_job AS (
  INSERT INTO character_kb_10000
  SELECT unique_id, media_type, genre, character_name, description
  FROM character_sheet_10000.character_data_10000
  WHERE unique_id > 10000; -- Adjust this condition if your initial dataset has a different max ID
)
EVERY 1 minute;

This job is configured to run every minute, checking for and inserting new character data into the character_kb_10000 Knowledge Base.

Live Demo & GitHub Repository

Curious to see CharacterKB in action?

🔗 CharacterKB GitHub Repository

Conclusion

Building CharacterKB for the MindsDB Quest 019 has been an incredibly insightful journey. MindsDB's Knowledge Bases, AI Tables, and Agents provide a robust and intuitive framework for creating intelligent, data-driven applications. CharacterKB stands as a testament to the power of AI in transforming how we discover, analyze, and interact with the vast world of fictional characters, making the exploration of their personalities an engaging and intelligent experience.

Acknowledgments

AI & Vector Search: MindsDB
LLMs: OpenAI
Image Search: Google Custom Search API
Dataset: CharacterCodex Dataset by NousResearch
UI Framework: React
Styling: Tailwind CSS

AutoGenius: AI-Powered Car Valuation and Trading Assistant

Rajesh Adhikari — Tue, 16 Jul 2024 05:05:34 +0000

Introducing AutoGenius: Your AI-Powered Car Valuation and Trading Assistant

Hey there, dev community! 👋 I'm excited to share a project I've been working on that combines the power of predictive models and LLMs with the world of automotive trading. Say hello to AutoGenius!

What is AutoGenius?

AutoGenius is a smart platform that leverages intelligent models build using mindsdb to predict pre-owned car prices and provide personalized trading tips. It's designed to make the process of buying or selling a used car smarter and more informed.

Key Features

AI-Powered Price Prediction: Using MindsDB's Lightwood engine, AutoGenius predicts car prices based on various factors like fuel type, transmission, mileage, and more.
Personalized Trading Tips: With a chatbot powered by Google's Gemini engine, users get tailored advice for buying or selling cars.
User-Friendly Interface: A sleek React frontend makes inputting car details and getting predictions a breeze.
Real-time AI Integration: FastAPI backend ensures quick and up-to-date predictions and advice.
Docker Integration: Easy setup and management of the MindsDB environment.

Tech Stack

Frontend: React
Backend: FastAPI
Database: MySQL
Machine Learning: MindsDB (Lightwood engine for prediction, Google Gemini engine for chatbot)
Containerization: Docker

Why I Built This

As a developer passionate about AI and its practical applications, I wanted to create a tool that brings the power of machine learning to everyday car traders. Whether you're a dealership looking to price your inventory accurately or an individual trying to get the best deal on your next car, AutoGenius is here to help!

The Development Journey

Building AutoGenius was an exciting challenge. Some key aspects of the development process included:

Data Preprocessing: Cleaning and preparing a Kaggle dataset for training our prediction model.
MindsDB Integration: Setting up and training models using MindsDB's powerful AI capabilities.
Frontend Design: Creating an intuitive and responsive UI with React.
Backend Architecture: Developing a robust FastAPI backend to handle requests and interact with MindsDB.
Docker Implementation: Containerizing the MindsDB environment for easy deployment and scaling.

See It in Action

Want to see AutoGenius at work? Check out our demo video to get a feel for how it works!

Get Involved!

I'm thrilled to share this project with the community, and I'd love your support and feedback:

Check out the repo: Visit our GitHub repository and star it if you like what you see!
Vote for AutoGenius: We're participating in a project showcase! If you think AutoGenius is cool, please vote for us here. Voting deadline is July 16, 2024!
Contribute: Feel free to fork the repo, open issues, or submit pull requests. Your contributions are always welcome!

What's Next for AutoGenius?

I'm constantly looking to improve and expand AutoGenius. Some ideas for future development include:

Integrating more data sources for even more accurate predictions
Adding features like image recognition for car valuation
Developing a mobile app version

Wrap Up

AutoGenius is more than just a project—it's a step towards making AI accessible and useful in the automotive world. Whether you're a car enthusiast, a developer interested in AI, or just curious about the intersection of technology and everyday life, I hope you find AutoGenius interesting!

Remember to check out the GitHub repo, give it a star if you like it, and don't forget to vote !

Thanks for reading, and happy coding! 🚗💻🔧

Feel free to ask any questions or share your thoughts in the comments. I'm always excited to discuss tech and AI!

StudyPal: Your AI-Powered Personalized Learning Companion

Rajesh Adhikari — Tue, 07 May 2024 08:28:31 +0000

Introduction

As students navigate the complexities of modern education, they encounter diverse challenges, from grasping complex concepts to effective time management. Traditional learning resources often fail to address individual needs and learning styles. StudyPal steps in as a dynamic and adaptive solution, leveraging the latest AI and machine learning advancements to deliver personalized learning experiences.

The StudyPal Experience

Subject Selection and Personalization

Upon accessing StudyPal, students choose their desired subject from a curated list, setting the stage for a personalized learning journey. They provide details about their educational background, enabling StudyPal to tailor materials and exercises to their current knowledge level. An "Additional Details" section allows students to specify focus areas, ensuring content alignment with their learning objectives.

Intelligent Study Material Generation

StudyPal's AI-powered engine generates concise and comprehensive study materials tailored to the selected subject. These materials distill core concepts into key points for quick review and reinforcement. A chat feature provides detailed explanations for further clarity.

MCQ Practice with AI-Powered Assistance

StudyPal offers an interactive MCQ practice module for practical application of knowledge. CopilotKit's AI copilot provides contextual guidance during practice sessions, fostering independent thinking and problem-solving skills.

Unveiling the Rationale: Deeper Understanding

Students can delve deeper into subjects by querying the AI copilot for detailed explanations and rationales behind each answer choice. This interactive feature promotes critical thinking and analysis.

Progress Tracking and Scoreboard

StudyPal incorporates a comprehensive scoreboard for real-time progress monitoring and performance measurement. Immediate feedback empowers students to identify areas for improvement and celebrate achievements.

Real-World Use Cases for StudyPal:

Classroom Supplement:
StudyPal can be integrated into traditional classroom settings to supplement teacher-led instruction. Students can use the platform to review key concepts, access additional study materials, and reinforce their understanding of topics covered in class. Teachers can also leverage StudyPal to provide personalized assistance and support to students with varying learning needs.
Remote Learning Support:
With the rise of remote and hybrid learning models, StudyPal can serve as a valuable tool for students and educators alike. Students can access StudyPal from anywhere with an internet connection, allowing them to continue their studies outside of the classroom. Educators can use StudyPal to facilitate remote tutoring sessions, provide feedback on student assignments, and track student progress in real-time.
Exam Preparation:
StudyPal can be used as a comprehensive exam preparation tool for standardized tests, entrance exams, and certification exams. Students can utilize the platform to review study materials, practice exam-style questions, and receive personalized feedback and guidance from the AI copilot. StudyPal's adaptive learning capabilities can help students identify areas of weakness and focus their study efforts where they are needed most.
Professional Development:
Beyond academic learning, StudyPal can also support professional development initiatives for individuals in various industries. Professionals can use the platform to brush up on industry-specific knowledge, prepare for professional certification exams, and enhance their skills in areas such as project management, data analysis, or programming languages. StudyPal's personalized learning approach can help professionals stay competitive in their fields and advance their careers.
Special Education Support:
StudyPal can be adapted to meet the needs of students with diverse learning abilities, including those with special education requirements. Educators can customize StudyPal's learning materials and exercises to accommodate different learning styles, provide additional support for students with learning disabilities, and offer alternative assessment methods such as interactive quizzes or multimedia presentations. StudyPal's AI copilot can also provide targeted assistance and accommodations for students who require extra support.
Language Learning and ESL Support:
StudyPal can be used as a language learning platform for students learning a new language or seeking to improve their English language skills. Students can access StudyPal's language-specific study materials, practice vocabulary and grammar exercises, and engage in conversation practice with the AI copilot. StudyPal's adaptive learning features can help students progress at their own pace and tailor their language learning experience to their individual needs and goals.

StudyPal's Tech Stack

Frontend

StudyPal's frontend is meticulously crafted using React, a renowned JavaScript library celebrated for its ability to create captivating user interfaces. Leveraging React's component-based architecture and virtual DOM, StudyPal ensures a seamless and responsive user experience, even when handling complex UI elements and real-time updates.

UI Design:

The user interface for our project was designed and developed in-house using Tailwind. If you wish to develop a similar project, you can either create your own UI or utilize the UI from our GitHub repository.

Copilotkit Implementation:

To integrate Copilotkit, components are wrapped with <Copilotkit> and </Copilotkit> tags. The backend URL is provided within these tags. Here's an example of how Copilotkit is implemented for the MCQ section of the project:

const PracticeMCQ = () => {
    return (
        <>
            <CopilotKit url="http://localhost:3000/api">
                <McqQns />
            </CopilotKit>
        </>
    )
}

To facilitate AI-powered assistance during MCQ practice sessions, StudyPal integrates the <CopilotPopup/> component from CopilotKit. This component provides a chat interface where students can request MCQ questions and hints without revealing the full answer.

<CopilotPopup
  instructions={instructions}
  defaultOpen={false}
  labels={{
    title: "StudyPal Copilot",
    initial: "Hi there! 👋 You can ask me to generate personalized MCQ questions and hints.",
  }}
  clickOutsideToClose={false}
/>

To manage hint displays, StudyPal utilizes both the useCopilotAction and useMakeCopilotReadable hooks from CopilotKit. The former enables the application to define custom actions triggered by user input in the chat interface, while the latter ensures that the code segments are readable to Copilot.

const [hintsShown, setHintsShown] = useState(new Array(questions.length).fill(false));
useMakeCopilotReadable(
    "This is the current value of hintsShown usestate to show hints to questions: " + JSON.stringify(hintsShown)
);

useCopilotAction({
  name: "updateHintsShown",
  description: "Show or hide hints by updating the hintsShown state based on user requests for hints.",
  parameters: [
    {
      name: "showHint",
      type: "boolean",
      description: "Show or hide hints."
    },
    {
      name: "indexNo",
      type: "number",
      description: "Index number of the question for which the hint should be shown or hidden."
    }
  ],
  handler: async ({ showHint, indexNo }) => {
    const newHintsShown = [...hintsShown];
    newHintsShown[indexNo] = showHint;
    setHintsShown(newHintsShown);
    if (!hintUsed[indexNo]) {
      hintUsed[indexNo] = showHint;
    }
  },
  render: "Updating hints..."
});

Additionally, MCQs are loaded with options, but initially, no hints are displayed. However, upon requesting assistance from Copilot, hints are dynamically generated below each question. This approach ensures that students can interactively receive hints tailored to their specific questions. Here's the example:

const [questions, setQuestions] = useState([{}]);

useMakeCopilotReadable(
    "This is the questions with their options, hint and answers: " + JSON.stringify(questions)
);

useCopilotAction({
    name: "newQuestions",
    description: "Provide questions based on conditions given. If number of questions are not specified provide 10 of them. Do not tell questions and options in chat.",
    parameters: [{
        name: "items",
        type: "object[]",
        description: 'The new questions.',
        attributes: [
            { name: "question", type: "string", description: 'The MCQ questions.' },
            { name: "option1", type: "string", description: "One of the four options and only one of them is correct." },
            { name: "option2", type: "string", description: "One of the four options and only one of them is correct." },
            { name: "option3", type: "string", description: "One of the four options and only one of them is correct." },
            { name: "option4", type: "string", description: "One of the four options and only one of them is correct." },
            { name: "hint", type: "string", description: "Hint to the question." },
            { name: "answer", type: "string", description: "Correct answer among available options." }
        ],
    }],
    handler: async ({ items }) => {
        // { question, option1, option2, option3, option4, hint, answer }
        const newQuestions = items.map(item => ({
            question: item.question,
            options: [item.option1, item.option2, item.option3, item.option4],
            hint: item.hint,
            answer: item.answer
        }));
        setQuestions(newQuestions);
        setShowQuestion(true);
        setHintsShown(new Array(newQuestions.length).fill(false));
        setHintUsed(new Array(newQuestions.length).fill(false));
    },
    render: "Updating questions...",
});

The revision points are generated using the OpenAI API and are integrated with the chat using similar techniques as described above.

Backend

On the backend, StudyPal harnesses Node.js, a high-performing JavaScript runtime, coupled with Express.js, a lightweight web application framework. This combination enables efficient handling of server-side operations, including communication with the CopilotKit API and processing user requests.

The integration of CopilotKit serves as the backbone of StudyPal's AI capabilities. Acting as a bridge, CopilotKit facilitates seamless communication between the StudyPal application and potent language models like GPT-3.5. Through CopilotKit's APIs, StudyPal generates personalized study materials, context-specific hints, and detailed explanations, powered by cutting-edge advancements in natural language processing (NLP) and machine learning.

const HEADERS = {
  // Modify CORS headers to match your frontend's origin
  "Access-Control-Allow-Origin": "http://localhost:5173",
  "Access-Control-Allow-Methods": "GET, POST, OPTIONS, PUT, PATCH, DELETE",
  "Access-Control-Allow-Headers": "X-Requested-With,content-type",
};

// Use CORS for all routes
app.use(cors());

// Use express.json() to parse JSON bodies into JS objects
app.use(express.json());

// Define a route for POST requests to '/api'
app.post('/api', (request, response) => {
  try {
    const copilotKit = new CopilotBackend();
    const adapterOptions = {
      model: "gpt-3.5-turbo"
    };
    copilotKit.streamHttpServerResponse(request, response, new OpenAIAdapter(adapterOptions), HEADERS);
  } catch (err) {
    console.error(err);
    response.end("error");
  }
});

Development Practices

StudyPal's codebase follows the latest industry standards, making the development process smooth and efficient. With top-notch technologies such as React, Node.js, and CopilotKit, StudyPal showcases innovation in educational technology.

Wrap-up

StudyPal stands as a versatile tool reshaping traditional learning paradigms. Its integration of CopilotKit offers personalized and intelligent support across various contexts, from classroom enrichment to remote learning and exam preparation. Empowering both learners and educators, StudyPal represents the transformative potential of technology in education.

Demo

click-for-demo-video

Project Installation and Setup Guide

● Clone the Repository:

   git clone https://github.com/rajesh-adk-137/StudyPal.git

● Install Dependencies:

Inside frontend:
```
 npm install
```
Inside backend:
```
 npm install
```

● Set Up Environment Variables:
Add a .env.local file in the backend and insert your API key.

   OPENAI_API_KEY=sk-proj-*******************************

We have used gpt-3.5-turbo as our OpenAI model. If you want to use a different OpenAI model, change the model in backend\server.js.

   const adapterOptions = {
     model: "gpt-3.5-turbo"
   };

● Start the Development Server:

Setting up the frontend:
Setting up the backend:

● Visit the Page:
Open your browser and navigate to http://localhost:5173.

If your frontend is not running on http://localhost:5173 but some other URL, then you have to change the CORS address from backend\server.js. Inside HEADERS, you have to change the following line:
```
 "Access-Control-Allow-Origin": "http://localhost:5173",
```

● For more information about CopilotKit, visit the website: https://www.copilotkit.ai/.

● GitHub Link to the project:
https://github.com/rajesh-adk-137/StudyPal