Losing a personal belonging can be frustrating. Finding it again is often even more difficult.
Traditional lost-and-found systems typically depend on manual descriptions, physical registers, notice boards, or basic keyword searches. Someone reporting a lost item might describe it differently from the person who finds it, making it difficult to identify potentially matching reports.
I wanted to explore how artificial intelligence could make this process more intelligent and practical.
That idea led to FindMate AI, an AI-powered lost-and-found matching application built with Python, Streamlit, and semantic similarity techniques.
Rather than relying exclusively on exact keyword matches, FindMate AI uses natural-language representations to identify potentially related lost and found reports.
1. The Problem I Wanted to Solve
Consider two reports:
- Lost report: "I lost my black leather wallet near the university library."
- Found report: "A dark-colored leather purse was discovered close to the campus library."
A conventional keyword-based system might struggle to recognize that these descriptions could refer to the same item.
The wording is different, but the underlying meaning is similar.
This is where semantic similarity becomes useful.
The goal of FindMate AI was to build a system that could compare descriptions based on their meaning, rank potentially relevant matches, and help users or administrators investigate them more efficiently.
2. Introducing FindMate AI
FindMate AI is a web-based lost-and-found management application that combines a structured reporting workflow with an AI-assisted matching engine.
Users can submit lost or found item reports, provide descriptions and relevant details, and attach images. The application then compares available reports and identifies potential matches.
The system is designed to make lost-and-found management more organized, searchable, and intelligent.
Live Application: (https://findmate-ai-dhxvmhdgri3ju4fgkedida.streamlit.app/)
GitHub Repository: (https://github.com/alpha5-rdx/findmate-ai)
3. Key Features
- Lost and Found Reporting
Users can submit reports containing item descriptions, relevant metadata, and supporting images.
Keeping reports structured makes it easier to organize information and compare entries.
- AI-Powered Semantic Matching
This is the central feature of FindMate AI.
The application uses the Sentence Transformers model all-MiniLM-L6-v2 to convert text descriptions into numerical embeddings.
These embeddings represent the semantic meaning of the descriptions.
The system compares normalized embeddings using cosine similarity to identify reports that may describe the same or a similar item.
Unlike basic keyword matching, this approach can identify meaningful relationships even when users describe an item differently.
- Similarity Scores and Match Ranking
Potential matches are ranked using similarity scores.
The matching logic also incorporates metadata-based bonuses, allowing relevant structured information to contribute to the overall matching score.
The metadata contribution is capped to avoid allowing those bonuses to dominate the semantic similarity calculation.
A configurable matching threshold helps determine which candidates should be presented as potential matches.
- Dashboard and Reporting
The application includes a dashboard for reviewing system activity and report information.
It also provides management and reporting functionality, including CSV export.
- Administrative Management
Administrative functionality supports reviewing reports, managing records, and handling potential matches.
The workflow includes resolving and reopening records where appropriate.
- Image Uploads
Users can attach images to lost-and-found reports, providing additional context for human review.
The current matching engine focuses on textual descriptions and metadata; it does not perform visual image matching.
4. Technology Stack
The project was developed using the following technologies:
- Python: Core application logic
- Streamlit: Web application interface
- Sentence Transformers: Semantic text embeddings
- all-MiniLM-L6-v2: Text embedding model
- Scikit-learn / numerical similarity operations: Cosine similarity calculations
- SQLite: Structured data storage
- Pandas: Data handling and CSV exports
- Streamlit Secrets: Secure configuration and credentials
- Git and Github: Version control and source code management
- Streamlit Community Cloud: Application deployment
5. How the AI Matching Engine Works
The matching workflow is based on semantic text similarity.
At a high level, it follows these steps:
*Step 1 — Collect reports
*
The application stores lost and found reports along with their descriptions and relevant metadata.
*Step 2 — Generate embeddings
*
The Sentence Transformers model converts report descriptions into vector representations.
*Step 3 — Normalize vectors
*
The embeddings are normalized to support consistent similarity calculations.
*Step 4 — Calculate cosine similarity
*
The system compares the embeddings to estimate how semantically similar two descriptions are.
*Step 5 — Incorporate metadata
*
Relevant metadata contributes a limited additional score to the matching calculation.
*Step 6 — Apply the matching threshold
*
Candidates are evaluated against a configurable threshold and ranked for review.
During development, sample matching tests produced similarity scores around 0.74–0.84 for selected true-match pairs, while the strongest tested non-match scored approximately 0.57.
These figures are development observations from a small sample, not a general accuracy benchmark or a guarantee of real-world matching performance.
6. Development Challenges and What I Learned
Building FindMate AI was a valuable opportunity to work with a practical AI application rather than simply experimenting with a model in isolation.
Some of the important engineering considerations included:
- Semantic matching: Understanding why embeddings can be more useful than exact keyword matching for natural-language descriptions.
- Scoring design: Combining semantic similarity with structured metadata without allowing secondary signals to overpower the main score.
- Threshold selection: Finding a reasonable starting threshold and testing how it affects potential matches.
- Application organization: Separating application functionality into manageable pages and workflows.
- Security: Removing hardcoded administrative credentials and moving sensitive configuration into Streamlit Secrets.
- Testing: Using automated application tests to validate pages, reporting workflows, and matching behavior.
One important lesson was that an AI-generated similarity score should be treated as a decision-support signal, not definitive proof that two reports refer to the same item.
7. Current Limitations and Future Improvements
FindMate AI is a working portfolio project, and there are several opportunities to develop it further.
Potential improvements include:
• Individual user accounts and role-based access.
• More advanced administrative permissions.
• Visual similarity matching using image embeddings.
• Larger and more diverse evaluation datasets.
• Improved matching evaluation using precision, recall, and F1-score.
• Production-grade persistent storage and image management.
• Notifications when a potentially relevant match is identified.
These improvements could make the application more suitable for deployment across universities, campuses, and larger communities.
8. Try It Yourself
The application is publicly deployed, and the source code is available on GitHub.
Live Demo: (https://findmate-ai-dhxvmhdgri3ju4fgkedida.streamlit.app/)
Source Code: (https://github.com/alpha5-rdx/findmate-ai)
Feel free to explore the implementation, review the matching workflow, and share suggestions or feedback.
Final Thoughts
FindMate AI started with a simple question:
Can semantic AI make a traditional lost-and-found process more intelligent?
Building this project helped me explore sentence embeddings, vector similarity, structured data, application security, automated testing, and cloud deployment in one practical application.
More importantly, it reinforced an idea I find valuable in software engineering: AI becomes much more meaningful when it is integrated into a solution that addresses an actual problem.
This is one of my steps toward building practical AI-powered software applications, and I look forward to improving it further.
Thanks for reading!

