• 

  architecture

• 

• 

• 

• 

• 

• 

Stylewise — Check Your Closet Before You Check Out

An Alexa+-inspired, voice-first AI shopping companion that knows what you own, helps you style it, and recommends what to buy only when you actually need it.

What if the smartest shopping assistant sometimes told you not to shop?

Stylewise brings your wardrobe, your occasions, and your shopping decisions into one conversation.

---

Inspiration

Four wedding events. One limited budget. A wardrobe full of clothes. And somehow, still nothing to wear.

Imagine being invited to your friend's big fat Indian wedding.

Not just one event, but four:

Haldi. Mehendi. Sangeet. Wedding.

You start browsing Amazon for outfits. A beautiful kurta catches your eye. Then a lehenga. Then a dupatta that might match something you already own.

Before long, your shopping cart is growing, your budget is shrinking, and you still aren't sure what you'll actually wear.

But what if you already own most of what you need?

Maybe the ivory kurta you bought last year works for the mehendi. Maybe your festive trousers can be styled differently for the sangeet. Maybe all you're missing is one complementary dupatta.

Most shopping assistants start with what you could buy. We wanted to start with what you already own.

That idea became Stylewise, a conversational AI shopping companion that connects your existing wardrobe with intelligent purchase recommendations.

Our goal isn't to discourage shopping. It's to make every purchase more intentional, useful, and compatible with the clothes you already have.

Because the best purchase isn't necessarily another outfit. Sometimes it's the one missing piece that makes several existing outfits possible. And sometimes, it's no purchase at all.

---

What It Does

Stylewise helps users answer three fundamental questions:

1. What do I already own?
2. What can I wear or combine from my existing wardrobe?
3. What should I buy, if anything, to complete my outfits within my budget?

Rather than simply recommending products from a catalogue, Stylewise considers existing garments, ownership uncertainty, occasion requirements, clothing compatibility, personal preferences, and spending limits.

1. Meet Nisha — Your Conversational AI Stylist

Meet Nisha, our AI-powered styling companion.

Imagine asking:

You: "Nisha, I have a mehendi and sangeet coming up. My budget is SGD 60. What should I wear?"

Instead of immediately recommending two new outfits, Nisha checks your wardrobe, identifies suitable combinations, and evaluates what you might actually need to purchase.

Perhaps you already own an ivory kurta, festive trousers, and a maroon dupatta.

Nisha might recommend reusing those pieces and purchasing one complementary gold dupatta for SGD 20, instead of spending your entire budget on a new outfit.

But the conversation doesn't stop there.

You: "Actually, I prefer burgundy. And no synthetic fabrics."

Nisha updates the planning constraints.

You: "What if I don't buy anything?"

Nisha evaluates a zero-purchase alternative.

You: "Wait, I still have my evening silk dupatta!"

That single correction changes the available wardrobe and can change the entire recommendation.

Suddenly, the best shopping plan might cost SGD 0.

This is what we wanted to build: a shopping assistant that preserves conversational context, responds to corrections, and reasons about whether a purchase is necessary.

Users can also ask:

• "Do I already own something that works?"
• "What goes with my ivory kurta?"
• "Can I style this for another occasion?"
• "Which purchase would be the most useful?"
• "What if I don't buy anything?"

Stylewise preserves relevant context across follow-up requests, so users don't have to restart their shopping decisions every time.

2. A Digital Wardrobe Reconstructed From Purchase History

Before Nisha can recommend what to wear, Stylewise needs to understand what the user owns.

Our prototype reconstructs a digital wardrobe from purchase records and uploaded clothing information.

But we discovered an important problem:

Purchase history is not the same as your current wardrobe.

You might have returned an item, gifted it, donated it, or simply forgotten whether you still have it.

So Stylewise explicitly represents ownership uncertainty:

• Confirmed owned: Available for outfit planning.
• Needs confirmation: The user must verify whether the garment is still owned.
• Returned: Excluded from available wardrobe pieces.

Instead of silently assuming that every historical purchase is available, Nisha can ask the user to confirm uncertain items.

This makes the recommendation more trustworthy and gives users control over their wardrobe information.

We wanted Nisha to know when she doesn't know.

3. Three Shopping Strategies — Not Just Three Products

Traditional shopping assistants usually recommend products.

Stylewise first recommends a strategy.

For each occasion-planning request, our planner evaluates three possible approaches:

Strategy	What it means
Wear what you own	Build suitable outfits entirely from confirmed wardrobe pieces.
Fill a small gap	Buy a complementary item that makes existing pieces work together.
Buy a new outfit	Consider a complete purchase when existing combinations cannot satisfy the requirements.

The planner evaluates:

• Garment compatibility.
• Confirmed ownership and availability.
• Occasion suitability.
• User preferences and restrictions.
• Budget constraints.
• Total purchase costs.
• Alternative combinations.

For example, instead of recommending an entirely new sangeet outfit, Stylewise might suggest purchasing a complementary gold dupatta for SGD 20 to complete an outfit using garments already owned.

Users can inspect the recommendation, compare alternatives, and explore what happens if they decide not to purchase anything.

Buying nothing is a valid, first-class recommendation — not a failed shopping search.

This is one of the most important decisions we made while designing Stylewise.

We didn't want an assistant that always finds a reason to sell something.

We wanted one that recognizes when the user already has enough.

4. What Goes With What — A Wardrobe That Understands Compatibility

A digital wardrobe shouldn't be just a list of clothing items.

Stylewise also helps users explore how garments relate to one another.

Users can ask:

"Nisha, what goes with my ivory kurta?"

Our What Goes With What view visualizes compatible garment relationships, helping users discover combinations they might not have considered.

This makes Stylewise useful even when the user isn't planning a purchase.

Instead of viewing clothes as isolated products, users can explore how existing pieces work together.

5. A Visual, Explainable Shopping Workspace

The conversational assistant is supported by an interactive visual companion.

Our prototype includes:

• Ask Nisha: Conversational styling, preferences, follow-up questions, and voice interaction.
• Your Wardrobe: Explore reconstructed garments, purchase information, and ownership states.
• Outfit Plan: Review outfit feasibility, costs, and shopping alternatives.
• What Goes With What: Visualize compatible garment combinations.
• Outfit Builder: Assemble, validate, and save looks.
• Inspiration: Compare reference images against existing wardrobe pieces.

We also expose tool activity and planning details so users can inspect how recommendations were produced.

Instead of simply saying "Buy this," Stylewise helps explain what the user already owns, what works together, what is missing, and why a particular purchase makes sense.

6. Voice-First, Not Voice-Only — Designed for Alexa+

Our vision is simple:

"Alexa, ask Nisha what I should wear to my friend's wedding."

Stylewise is designed as a conversational shopping capability for an Alexa+-style experience.

Voice provides a natural way to describe occasions, preferences, budgets, and wardrobe questions.

But fashion is inherently visual.

That's why we designed the experience around two complementary modes:

• Voice-first interaction: Ask questions naturally and receive concise recommendations.
• Visual companion: Inspect garments, outfit combinations, costs, and purchase alternatives.

On a voice-only device, Nisha could summarize the recommended outfit and any required purchase.

On a screen-enabled device, the same recommendation could be accompanied by visual outfit options, wardrobe relationships, and budget details.

For the hackathon, we implemented a working web-based conversational and visual simulation, alongside a self-hosted MCP server designed around the Alexa+ MCP integration model.

The current prototype is not a published production Alexa+ add-on. The MCP capability is implemented and tested; direct production Alexa+ integration remains a future step subject to platform access.

7. Voice-Powered Conversations

Stylewise supports voice input so users can describe their needs naturally instead of typing detailed shopping queries.

Our demo uses:

• Whisper: Browser-based speech transcription.
• Expressive voice service: A separate authenticated Mac-based service for spoken responses.
• Browser fallback: Alternative speech output when the expressive voice service is unavailable.

We tuned spoken responses to remain concise while keeping detailed reasoning, costs, and ownership conditions visible in the interface.

Voice makes the experience natural. The visual companion makes the recommendation inspectable.

---

How We Built It

Stylewise combines generative AI, deterministic planning, Model Context Protocol (MCP), voice interaction, and serverless AWS infrastructure.

Our core architectural principle is:

The LLM interprets the request. The planner verifies the recommendation.

1. Frontend and Cloud Infrastructure

The visual companion is built with:

• Next.js
• React
• TypeScript
• AWS Amplify Hosting

The backend uses:

• Python
• FastAPI
• AWS Lambda
• Mangum

We use Amazon Cognito for authentication and MongoDB Atlas for application and wardrobe data.

AWS Secrets Manager stores the database connection credential, while Amazon CloudWatch provides sanitized diagnostics and deployment troubleshooting.

2. Amazon Bedrock — Natural-Language Understanding

We use Amazon Bedrock Nova Lite for conversational interpretation, tool selection, and garment-image understanding.

The model helps interpret requests such as:

"I need something festive for two functions, preferably burgundy, under SGD 60, and nothing synthetic."

It identifies relevant information such as:

• Occasion requirements.
• Spending limits.
• Style preferences.
• Fabric restrictions.
• Wardrobe questions.
• Conversational follow-up context.

However, we deliberately avoid letting the language model independently decide every shopping fact.

3. Deterministic Planning and Verification

Our shared deterministic planner checks:

• Ownership: Is the garment confirmed available?
• Compatibility: Do the selected garments work together?
• Occasion coverage: Does the plan address the requested events?
• Preferences: Does the recommendation respect stated constraints?
• Budget: Is the total purchase cost within the user's limit?
• Alternatives: Is there a lower-cost or zero-purchase strategy?

This separation matters because a language model can produce a convincing recommendation without necessarily verifying its underlying assumptions.

For example, the model should not be able to:

• Invent a product price.
• Treat an uncertain garment as confirmed owned.
• Introduce an unstated preference.
• Claim an outfit is within budget without checking the total cost.

The planning layer verifies these constraints before presenting recommendations.

We use generative AI to understand the user, and deterministic logic to validate the shopping decision.

4. Model Context Protocol (MCP)

We implemented a self-hosted MCP server using:

• MCP Python SDK / FastMCP
• Streamable HTTP
• MCP specification version 2025-11-25

The server exposes structured capabilities for:

• Wardrobe retrieval.
• Catalogue information.
• Garment compatibility relationships.
• Occasion and purchase planning.

The web application and MCP interface share the same underlying deterministic planner.

This means our shopping intelligence is not tied to one frontend.

Alexa+ is the intended conversational environment. Stylewise is the shopping capability. MCP is the integration path. The web application is our visual prototype and simulation.

The current web chat uses REST, while the separately implemented MCP server exposes the same core planning services through structured tools.

5. Voice Experience

Voice input uses browser-based Whisper transcription.

For expressive speech output, the demo uses a separate authenticated Mac-based voice service, with a browser fallback when the service is unavailable.

One important design decision was to avoid reading lengthy planning explanations aloud.

Nisha should communicate the essential recommendation concisely, while the visual interface presents detailed costs, outfit combinations, and ownership conditions.

6. Testing and Verification

We built regression tests around backend behavior and planning reliability.

Our latest local verification passed:

• 85 backend tests
• Successful production frontend build

We focused particularly on ownership handling, budget validation, recommendation consistency, and conversational planning behavior.

---

Challenges We Faced

1. Preventing Confident but Incorrect AI Recommendations

One of our biggest challenges was ensuring the conversational assistant didn't introduce unstated preferences, assume ownership, or present unsupported shopping recommendations.

During early testing, the model sometimes attempted to add an unstated fabric exclusion or mark an uncertain item as owned.

These errors can directly change a shopping recommendation.

We addressed them by separating language understanding from deterministic decision-making, adding validation guards, and building regression tests.

A convincing AI explanation is not proof that the underlying recommendation is correct.

2. Making Purchase History Trustworthy

Purchase history is not the same as a current wardrobe.

An item may have been returned, discarded, gifted, or otherwise become unavailable.

We introduced explicit ownership states and confirmation workflows so uncertain garments are not silently treated as available.

This also made the conversational experience more meaningful: a user can correct Nisha, and that correction can change the recommended purchase.

3. Making "Buy Nothing" a Real Recommendation

Most shopping systems are optimized to recommend something.

We wanted Stylewise to evaluate whether a purchase was necessary in the first place.

That meant making reuse, gap-filling, and buying new comparable planning strategies, rather than defaulting to a product suggestion.

Our goal is to improve the usefulness of a purchase, not maximize the number of purchases.

4. Deploying MCP on Serverless Infrastructure

Running our MCP server through AWS Lambda and Mangum introduced lifecycle and routing challenges.

We encountered repeated-invocation issues related to Streamable HTTP session management.

We worked through the ASGI integration and normalized the MCP endpoint path to support more reliable requests.

5. Building a Natural Voice Experience

Voice interaction involved more than connecting speech recognition and synthesis.

We worked through:

• Microphone capture.
• Transcription accuracy.
• Browser audio permissions.
• Latency.
• Voice consistency.
• Overly verbose spoken responses.
• Fallback behavior.

We improved the experience by shortening spoken answers while preserving important details on screen.

---

Accomplishments We're Proud Of

We're proud that Stylewise goes beyond a conversational shopping concept.

We built an end-to-end prototype with a deployed web experience, authenticated backend, reusable MCP interface, deterministic planner, and voice interaction.

Our key accomplishments include:

• A shopping assistant that can recommend SGD 0: Buying nothing is a deliberate outcome, not a failed search.
• Wardrobe reconstruction with ownership uncertainty: Purchase history is not blindly treated as proof of current ownership.
• Three comparable shopping strategies: Reuse existing garments, fill a small gap, or buy a new outfit.
• A visual compatibility experience: Users can explore which garments work together.
• A self-hosted MCP server: Shopping-planning capabilities are exposed through structured tools.
• A shared planning engine: REST and MCP use the same deterministic decision logic.
• An AWS-hosted application: Built with Amazon Bedrock, Lambda, Amplify, Cognito, Secrets Manager, and CloudWatch.
• 85 passing backend tests: Constraint validation and reliability were important engineering requirements.

But our favourite part is a much smaller interaction.

A user says:

"Actually, I still own that dupatta."

And Nisha can reconsider the plan and potentially respond:

"Then you might not need to buy anything at all."

That captures exactly what we wanted Stylewise to do.

---

What We Learned

Building Stylewise reinforced that a useful AI shopping assistant needs more than fluent conversation.

It needs reliable state, explicit uncertainty, verifiable calculations, and tools that produce inspectable results.

Through this project, we gained practical experience with:

• Building conversational applications using Amazon Bedrock.
• Combining LLM reasoning with deterministic planning.
• Developing and deploying a self-hosted MCP server.
• Building authenticated, serverless AWS applications.
• Reconstructing wardrobe information from purchase records.
• Designing explainable, budget-aware recommendation workflows.
• Integrating voice interaction into a real web application.
• Testing AI-assisted workflows for reliability.

We also learned five important product lessons:

1. Personalization needs reliable state. An assistant cannot make useful wardrobe recommendations without knowing what is available and what remains uncertain.

2. LLMs and deterministic systems are complementary. Language models understand natural requests; planning logic checks constraints.

3. Explainability matters. Users should understand why a purchase is recommended and what alternatives exist.

4. Voice-first doesn't mean voice-only. Conversation is a natural entry point, but fashion decisions benefit from visual exploration.

5. The best shopping recommendation isn't always another product. Sometimes it's an outfit you can already create. Sometimes it's one missing piece. And sometimes buying something new genuinely makes sense.

The value is in knowing the difference.

---

What's Next

We see Stylewise evolving into a more deeply integrated personal shopping companion.

1. Deeper Alexa+ Integration

Our next goal is to connect the existing MCP capabilities to Alexa+ through the appropriate developer integration path when access becomes available.

We envision Nisha helping users through natural conversation across voice-only and screen-enabled experiences.

2. Consent-Based Retailer Integrations

Connect authorized purchase history and product information from supported retailers, with explicit user permission.

This could make wardrobe reconstruction easier while retaining ownership confirmation for uncertain items.

3. Better Garment Understanding

Improve:

• Clothing attribute extraction.
• Fabric and style understanding.
• Visual garment matching.
• Fit confidence.
• Compatibility reasoning.

4. Smarter, More Meaningful Recommendations

We want Stylewise to evaluate not just whether a product looks good, but how much value it adds to the user's existing wardrobe.

For example:

• How many new combinations could this item unlock?
• Does it solve a genuine occasion gap?
• Does it complement existing garments?
• Is it worth the cost?
• Is there a better option that requires no purchase?

5. Production-Ready Voice and Shopping Workflows

Move expressive voice capabilities to permanently hosted infrastructure and expand supported retailer catalogue and purchase integrations.

---

Prototype Scope and Transparency

Stylewise is a working hackathon prototype with clearly defined boundaries.

• Purchase history: The demonstration uses synthetic purchase records.
• Catalogue and prices: Product data and prices are synthetic, not live retailer offers.
• Wardrobe input: The prototype supports uploaded clothing information.
• Checkout: Purchase flows are simulated.
• Alexa+: The web application demonstrates an Alexa+-style conversational shopping workflow; it is not a published production Alexa+ add-on.
• MCP: The self-hosted MCP server is implemented and tested independently of production Alexa+ connectivity.
• Email receipts: Any email-receipt import preview is a labeled simulation rather than access to a real user's inbox.

These boundaries allow us to demonstrate the architecture and shopping experience without implying access to real customer purchase records or live retailer checkout systems.

---

Product Feedback

Amazon Bedrock — Nova Lite

What we used it for: Tool selection and conversational interpretation for multi-turn wardrobe planning; vision tagging for garment and inspiration-image workflows.

What worked well: The Converse API and typed tool schemas made it straightforward to connect natural-language requests to our planner. Nova Lite was responsive enough for a demo and handled request framing well.

What needs work: In early live turns, the model sometimes attempted to add an unstated fabric exclusion or mark an item as owned, and could expose reasoning-style text. We added deterministic validation after tool selection. Stronger first-class controls for allowed mutations and reasoning suppression would reduce application-side guard code.

Onboarding: Bedrock setup was clear once model access and regional availability were understood. Model availability by region could be easier to see before implementation.

Would we use it again? Yes. It works well when paired with a deterministic decision engine instead of being asked to decide product facts.

AWS Lambda

What we used it for: The FastAPI API, authenticated MCP server, planner routes, and Alexa-format request handler via a Function URL.

What worked well: Lambda gave us an inexpensive deployment path for a compact Python service and let REST, MCP, and Alexa-format handling share one deployment.

What needs work: Streamable HTTP session lifecycle behavior under the ASGI adapter was not obvious. A clearer Lambda-specific MCP example would have saved debugging time.

Onboarding: Fast to start from a ZIP deployment and Function URL.

Would we use it again? Yes, for this request-response workload.

AWS Amplify Hosting

What we used it for: Hosting the static Next.js visual companion.

What worked well: Manual static deployment was fast and the hosted web app integrated cleanly with Cognito redirect URLs.

What needs work: Clearer guidance for static exports with current Next.js versions would help; we deliberately avoided SSR.

Onboarding: Straightforward after the static build configuration was chosen.

Would we use it again? Yes, for a static web companion.

Amazon Cognito

What we used it for: Hosted sign-in, OAuth authorization code with PKCE, and access-token verification for REST and MCP requests.

What worked well: It gave us a real identity boundary and short-lived token flow without placing credentials in the frontend.

What needs work: Debugging access-token versus ID-token use in a browser can be confusing. A more prominent token-use diagnostic would help.

Onboarding: The hosted UI and redirect configuration were manageable, though exact callback URLs require care.

Would we use it again? Yes.

AWS Secrets Manager

What we used it for: Retrieving the MongoDB Atlas URI at Lambda runtime.

What worked well: The database credential never enters the repository or browser bundle.

What needs work: A more concise serverless example for one secret and least-privilege policy would help first-time builders.

Onboarding: Clear once the Lambda runtime role had the required read permission.

Would we use it again? Yes.

Amazon CloudWatch

What we used it for: Sanitized request diagnostics and deployment troubleshooting.

What worked well: It gave us a single place to check Lambda health without logging access tokens or request bodies.

What needs work: A faster path from a Function URL error to the relevant log stream would help during a short hackathon.

Onboarding: Familiar and reliable.

Would we use it again? Yes.

MCP Python SDK / Streamable HTTP

What we used it for: A self-hosted MCP server implementing specification 2025-11-25, with authenticated wardrobe, catalogue, graph, and planning tools.

What worked well: FastMCP made typed tools and Streamable HTTP practical for a small Python service.

What needs work: Session-manager lifecycle expectations under Lambda/ASGI need clearer documentation.

Onboarding: Quick locally; deployment edge cases needed careful testing.

Would we use it again? Yes.

Alexa+ Developer Tooling

What we used it for: We evaluated the MCP Toolkit and add-on documentation while designing the integration path.

What worked well: The open MCP direction provides a credible way for a self-hosted capability to fit Alexa+.

What needs work: The toolkit is currently limited to select partners, with no self-serve hackathon access available to our team. The documentation could surface eligibility requirements earlier and make local inspection accessible without partner onboarding.

Onboarding: Direct toolkit onboarding was unavailable, so we implemented our self-hosted MCP capability and demonstrated the experience through a web simulation.

Would we use it again? Yes, when onboarding becomes available.

---

The Bigger Idea

We started with a familiar problem:

Four wedding functions. One budget. And a wardrobe that somehow still feels incomplete.

But Stylewise isn't only about wedding outfits.

It's about changing the question we ask before buying something.

Instead of just:

"What should I buy?"

We want people to ask:

"What do I already have, what can I do with it, and is there anything genuinely worth adding?"

We believe the next generation of shopping assistants should understand what users already own, not just what retailers want to sell.

And sometimes, after checking the wardrobe, comparing the alternatives, and doing the math, Nisha's best recommendation might simply be:

"You already have the perfect outfit."

---

Stylewise

Check Your Closet Before You Check Out.

Shop smarter. Reuse what you own. Buy what actually makes sense.

#Stylewise #AlexaPlus #AmazonBedrock #AWS #GenerativeAI #VoiceAI #ModelContextProtocol #AIShopping #SustainableFashion #Hackathon

Built With

• alexa
• amazon-bedrock
• amazon-cognito
• amazon-nova
• aws-amplify
• aws-lambda
• conversational-ai
• fastapi
• generative-ai
• mcp
• model-context-protocol
• mongodb-atlas
• nextjs
• python
• react
• recommendation-systems
• serverless
• typescript
• voice-ai
• whisper