Mapify AI

Mapify AI turns "I feel like doing something tonight" into a ranked, bookable local plan — one prompt, real data, no app switching.

Comment

Inspiration

For foreigners, travelers and newcomers arriving in a new city, local discovery is still much harder than it should be.

This is especially true in an expensive city like Zurich, where every decision matters. When you are new to the city, you may not speak the language confidently, you may not know which information sources to trust, and you may not want to waste money on the wrong choice. You are not just looking for “something nearby” — you are looking for something that fits your budget, timing, location, and real preferences.

Take a simple example: you want to find a nice local café for a coffee chat with a friend. In reality, that often means jumping across multiple tools. You might ask AI or Google Maps for ideas, open a map app to check distance, visit the café’s website for opening hours, read reviews, and maybe even call to ask whether there is still space. Then you realize it is too far, too expensive, already full, or simply not a good fit — and you have to start all over again.

In other words, one practical local question often turns into a fragmented workflow across too many apps. The process is tiring, inefficient, and often stressful, especially when time is limited and prices are high.

In a city like Zurich, this friction feels even stronger. Spontaneous plans can quickly become wasted time, long queues, or unexpectedly expensive choices. Many newcomers and visitors want to enjoy the city, but without good local knowledge, it is easy to feel lost, overwhelmed, or priced out of the experience.

We saw a clear gap: people do not want to switch between chatbots, maps, websites, booking pages, and reviews just to answer one simple question:

What should I do here, right now, given my budget, time, location, and preferences?

At the same time, there is also a merchant-side problem. Many great local businesses are not discovered at the right moment, cannot easily communicate real-time availability or off-peak offers, and still handle repetitive booking or queue questions manually.

That is why we started Mapify AI: a real-time local discovery assistant designed to help people not get lost in the city, stay within budget, and still enjoy the best of what Zurich has to offer — all through one smooth, practical flow.

What it does

Mapify AI turns one natural-language request into a ranked shortlist of real local options.

A user can ask something vague and practical, such as:

“Find me a good haircut place near me that I can still make it to tonight and that is not too expensive.”

Instead of showing only map pins or returning a generic chat response, Mapify AI delivers a decision-ready shortlist of places, including:

  • a ranked Top 4–10 list of relevant options,
  • short, human-readable reasons for each recommendation,
  • realistic public transport travel times,
  • review-based pros and cons,
  • price context,
  • and the key trade-offs the user should know.

In other words, Mapify AI helps users answer the questions that actually matter in the moment:

  • Where should I go now?
  • Why does this place fit my needs?
  • How long will it take to get there?
  • What should I watch out for?
  • What do real users actually think?
  • What alternatives are also worth considering?

Rather than offering recommendation alone, Mapify AI is designed for practical decision support. It helps users move from a vague idea to an actionable choice with less searching, less app switching, and more confidence.

The experience is also designed to feel transparent rather than opaque. Instead of waiting through a blank loading state and receiving one unexplained answer at the end, users can see the system progress step by step as results are gathered, evaluated, and ranked.

Beyond user discovery, Mapify AI is also designed with future two-sided platform potential. For merchants, it can evolve into a real-time channel for:

  • flash deals,
  • quiet-hour promotions,
  • availability signals,
  • and better matching between nearby demand and local supply.

This makes Mapify AI valuable not only for discovery, but also for real-world conversion.

How we built it

We built Mapify AI as a multi-agent pipeline that turns vague natural-language requests into ranked, practical, and explainable local recommendations.

At a high level, the system is organized around a central orchestrator agent that coordinates several specialized agents, each responsible for one part of the decision flow:

  • an intent parser that converts free-form text into structured preferences such as category, budget sensitivity, timing, distance, and user intent,
  • a search and crawl agent that retrieves real business candidates and basic local signals such as coordinates, opening status, and availability-related information,
  • a transit agent that estimates realistic public transport reachability and travel time,
  • a review agent that summarizes review signals into clear strengths, weaknesses, and trade-offs,
  • an evaluation agent that computes weighted scores across practical factors such as distance, price fit, timing, and relevance,
  • and an output layer that generates the final ranked shortlist together with concise recommendation reasons.

The orchestrator acts as the coordination layer of the system. It receives the parsed user intent, sends subtasks to the relevant agents, collects intermediate results, handles retries or missing data, and merges all signals into a final shortlist. This separation of responsibilities made the system easier to debug, extend, and improve under hackathon time pressure.

The workflow follows a staged execution path. A user query first passes through the intent parser, then enters the search stage to gather candidate places. These candidates are enriched with transit information and then evaluated in parallel from two perspectives: quantitative scoring and qualitative review analysis. The orchestrator then merges these outputs, resolves trade-offs, and prepares the final ranked result.

On the technical side, we built the backend with Python, LangGraph, and FastAPI, and used Server-Sent Events (SSE) to stream progress while the pipeline runs. This allows the frontend to show intermediate system stages instead of only displaying a final answer at the end. The frontend is built with React + Tailwind CSS, and the data layer uses PostgreSQL via Supabase.

Our core stack includes:

  • FastAPI
  • LangGraph
  • OpenAI SDK
  • Featherless
  • Apify API
  • Transport OpenData API
  • PostgreSQL
  • Supabase
  • React
  • Tailwind CSS
  • Typescript
  • SSE

One important design decision was making the workflow visible rather than opaque. Instead of hiding everything behind one black-box response, the system exposes staged events such as:

  • intent_parsed
  • stores_crawled
  • transit_computed
  • reviews_fetched
  • scores_computed
  • orchestrated
  • completed

This makes the product feel more transparent, more trustworthy, and more usable in real decision-making moments.

We also designed the architecture to be extensible from the beginning. Our request and data models already leave room for:

  • user preference profiles,
  • explainability or trace views,
  • merchant-facing promotion hooks,
  • live availability and booking integrations,
  • and future marketplace logic such as provider bidding or dynamic offer management.

From the start, our goal was not just to build a demo, but to create the foundation for a real-time local action layer that could grow into a usable product.

Challenges we solved

One of our biggest challenges was making real-time local recommendation actually useful, not just fluent.

It is easy for an AI system to generate a plausible answer. It is much harder to make that answer actionable. A place may sound perfect, but if it is already closing, too far away, too expensive, or no longer available, the recommendation fails in practice. That meant we had to ground the system in real external data rather than relying on generated text alone.

A second major challenge was translating vague human language into structured decision logic. People do not naturally say:

  • “price range CHF 20–40”
  • “radius 2.5 km”
  • “arrival time tolerance 18 minutes”

They say things like:

  • “not too expensive”
  • “not too far”
  • “still open tonight”
  • “something good near me”

Turning these messy, human expressions into usable filters, scoring signals, and ranking weights took several iterations.

Another key challenge was model selection under real product constraints. Different parts of the pipeline required different levels of reasoning, speed, and output quality. Not every step justified the same latency or token cost, so we had to decide carefully where lightweight models were sufficient and where stronger models created meaningful value.

We also had to solve coordination across multiple agents and system boundaries. That meant defining:

  • what each agent is responsible for,
  • what data gets passed between stages,
  • how to recover from missing or incomplete results,
  • and how to keep the overall experience smooth in the frontend.

Our staged SSE event flow became important not only for user experience, but also for internal system coordination. It helped us turn a complex backend process into something more structured, debuggable, and reliable.

Finally, we spent a lot of time thinking about trust. People do not want a system to randomly tell them where to spend their time and money. They want to understand:

  • why a place was recommended,
  • whether the information is current,
  • what trade-offs exist,
  • and what alternatives are also available.

That is why transparency, grounded data, and explainable ranking became core product decisions rather than optional extras.

Accomplishments

We are proud that Mapify AI feels like more than a generic recommendation demo.

Within a short hackathon build, we created:

  • a working end-to-end multi-agent pipeline,
  • real integration with external data sources rather than mocked examples,
  • a ranking flow that balances multiple real-world factors,
  • a streaming interface that makes system progress visible,
  • and a product concept with clear room for commercial growth.

We are especially proud of five outcomes:

  1. It solves a real everyday problem.
    This is a pain point we genuinely experience ourselves: spontaneous local plans are still unnecessarily hard.

  2. The product feels practical, not theoretical.
    It is built around real city behavior: affordability, travel time, availability, trust, and convenience.

  3. The architecture is strong enough to grow.
    We designed the system as more than a one-off demo. It can evolve into a real two-sided local marketplace.

  4. The ranking logic goes beyond popularity.
    Smaller or less obvious businesses can still surface when they are a stronger match on timing, price, or reachability.

  5. The concept creates value for both users and merchants.
    Users save time and make better decisions, while merchants gain a better way to surface real-time offers and available capacity.

We are also proud that the product has strong user appeal. It is easy to understand, easy to demonstrate, and relevant to a broad audience, including students, young urban users, travelers, newcomers, and local businesses. We see a freemium merchant subscription as the primary revenue path, with commission or booking and queue-management fee upside as the platform scales.

To validate this, we ran a small survey among neighbors and fellow students. Early feedback from students and neighbors was strongly positive, with most saying they'd use a tool like this in daily life.

What we learned

We learned that building a strong multi-agent product is much more about system design than simply calling a model.

The hardest part was not generating text. It was structuring uncertainty. A useful local recommendation needs three things at once:

  • grounded external data,
  • reasoning that can rank real trade-offs,
  • and a user experience that makes the result feel trustworthy and actionable.

We also learned that explainability is a product feature. Showing progress stages, ranking reasons, and system flow made the experience feel much more trustworthy than a single polished answer with no visible process behind it. Users are more willing to act when they understand how a recommendation was formed.

Another important lesson was about coordination. Under hackathon time pressure, both team coordination and agent coordination mattered. Clear boundaries made everything easier:

  • task division,
  • backend/frontend alignment,
  • API design,
  • and product decision-making.

We also learned how important it is to balance:

  • speed and quality,
  • architecture and demo value,
  • and technical depth with user experience.

Most of all, we learned that the best hackathon projects often solve painfully normal problems in a genuinely useful way.

What’s next for Mapify AI

Our next step is to move Mapify AI from a smart discovery layer toward a trusted real-time local action platform.

Our first priority is making the product more trustworthy. For a product that influences how people spend their time and money, credibility and clarity are essential for adoption. To strengthen this, we want to improve source grounding and recommendation reliability by:

  • aggregating signals from more diverse review sources,
  • reducing dependence on any single platform that may contain biased or unreliable reviews,
  • surfacing clearer recommendation reasons and trade-offs,
  • and making it easy for users to give lightweight feedback through simple thumbs-up or thumbs-down signals.

We also want to make recommendation quality more social. In real life, people often trust friends, family, and peers more than anonymous platforms. Over time, we want to support features that let users share recommendations, preferences, and useful local tips within their own circles.

At the same time, we want to make the product more personalized and community-driven through:

  • personalization for different city personas,
  • multi-turn preference refinement,
  • recommendation memory,
  • richer localized city context,
  • and shared tips, ratings, and local insights.

On the product side, we want to strengthen the live signal layer by adding:

  • real-time queue indicators,
  • short-window promotions and flash deals,
  • temporary availability updates,
  • and richer merchant-side signals.

On the business side, we want to expand the merchant experience into a lightweight dashboard where businesses can:

  • manage live availability,
  • promote off-peak offers,
  • respond to nearby demand,
  • and better convert real-time interest into visits or bookings.

We also want to enhance the app’s multimodal and multi-source capabilities to make the product more effective, explainable, trustworthy, and transparent. In the future, Mapify AI will be enriched with more diverse information through:

  • multimodal input such as voice and image,
  • stronger multi-source grounding and verification,
  • richer and more diverse information signals,
  • and more transparent ranking explanations.

Longer term, we see Mapify AI becoming a real-time city companion: a product that helps users not only discover what exists, but confidently decide what to do next, here and now.

Built With

Share this project:

Updates