Certifiedunder the RAG-Based AI Assistant module in the Agentic AI Essentials program.https://github.com/vivekranjan765/omnypark-parking-ai-assistant
In modern urban environments, parking facilities play a critical role in supporting daily transportation and accessibility across cities.
However, users often struggle to clearly understand parking policies, which may include:
Whether it is a shopping mall, hospital, airport, or commercial complex, parking-related information is typically scattered across multiple sources such as physical signage, websites, or mobile applications.
This fragmented availability of information makes it difficult for users to quickly access accurate and relevant details when needed.
As a result, this leads to:
This problem highlights the need for a centralized, intelligent, and user-friendly solution that can provide instant, accurate, and context-aware responses to parking-related queries.
The primary goal of this project is to build an AI-powered Parking Assistant that can provide accurate, instant, and context-aware responses to user queries related to parking policies.
The system is designed using a Retrieval-Augmented Generation (RAG) architecture, which combines semantic search with a language model to ensure that responses are always grounded in actual parking data rather than generated blindly.
By doing so, the assistant aims to improve user experience, clarity, and accessibility of parking-related information in real-world environments.
Parking systems today are largely static, fragmented, and non-interactive, making it difficult for users to quickly understand important information.
Users frequently have questions such as:
However, traditional parking systems:
As a result, users often face confusion and delays in decision-making.
👉 This clearly highlights the need for a smart, conversational, and intelligent parking assistant that can simplify access to information.
To address these challenges, I developed an AI assistant using a Retrieval-Augmented Generation (RAG) approach.
Unlike traditional chatbots that rely solely on pre-trained language models, this system follows a data-driven approach:
This approach ensures that the assistant behaves more like a reliable information system rather than a generic chatbot, making it suitable for real-world parking applications.
🏗️ System Architecture
The system follows a structured Retrieval-Augmented Generation (RAG) pipeline, where each stage plays a crucial role in ensuring accurate and context-aware responses.
The end-to-end flow is as follows:
User submits a query through the UI
The user enters a natural language query (e.g., parking charges, free duration, validation rules) through the Streamlit-based interface.
Query is normalized and processed
The input query is cleaned and standardized to improve consistency and ensure better matching during retrieval.
Query is converted into vector embeddings
The processed query is transformed into a numerical vector representation using an embedding model. This allows the system to understand the semantic meaning of the query rather than relying on exact keywords.
Compared with stored embeddings in ChromaDB
The query embedding is matched against pre-stored embeddings of the knowledge base using similarity search within ChromaDB.
Top relevant chunks are retrieved
The system retrieves the most relevant chunks of information that closely match the query based on vector similarity.
Context is passed to the LLM
The retrieved chunks are provided as contextual input to the language model, ensuring that the response is grounded in actual data.
Final answer is generated
The LLM generates a natural language response based on the retrieved context, ensuring both clarity and accuracy.
This pipeline ensures that responses are not only relevant and context-aware, but also grounded in real data, significantly reducing the chances of incorrect or hallucinated outputs.
A critical component of the system is how the knowledge base is prepared before performing retrieval.
Instead of storing entire documents, the system divides the content into smaller, manageable segments called chunks. This allows for more precise and efficient retrieval of relevant information.
Chunking improves the overall performance of the system by:
Chunk overlap plays a crucial role in preserving context across chunk boundaries.
Without overlap:
With overlap:
Consider a parking rule:
"Parking is free for 2 hours. After that, AED 10 per hour is charged."
If this rule is split without overlap, the system might retrieve only part of the information.
With chunk overlap:
Overall, this chunking strategy ensures that the system delivers high-quality, context-rich, and precise answers, making it more reliable for real-world applications.
The system is designed to be simple, scalable, and fully data-driven, allowing easy updates and adaptability across different parking environments.
Data is stored as plain text (.txt) files
All files are organized inside the /data directory
Each file represents a specific category of parking information, such as:
The system follows a data-centric design approach, meaning that updates can be performed without modifying the application code.
To update the knowledge base:
/data directoryThis approach ensures that the system remains flexible and easy to maintain in real-world scenarios.
The system uses a semantic search mechanism to retrieve relevant information from the dataset.
The application is built using Streamlit, providing a clean, lightweight, and interactive interface for users.
Users can:
This makes the assistant easy to use and suitable for demonstration as well as real-world applications.
The system is evaluated using a practical, real-world query testing approach to validate its performance.
A set of representative queries is used to simulate actual user interactions, such as:
Overall, this evaluation approach ensures that the system performs reliably and delivers consistent, accurate, and user-friendly responses.
To evaluate the system’s real-world usability, the following sample queries were tested:
These queries represent common user concerns and help validate how effectively the system retrieves and generates accurate responses.
This project is currently a prototype implementation, and there are certain limitations that need to be considered:
Despite these limitations, the system provides a strong foundation for building a production-ready solution.
👉 This approach has the potential to significantly improve the overall parking experience in modern smart cities by making parking information more accessible, interactive, and user-friendly.
This project was developed using the Ready Tensor AAIDC project framework and further extended into a real-world parking use case for OmnyPark.