Project Info

Winner

Chroma: Best AI application using Chroma

Artki.tech

Inspiration

The spark came during a late-night furniture shopping session. We watched a friend spend hours on Pinterest creating mood boards, then struggle to find matching furniture on multiple websites. Despite having great taste, they couldn't translate their vision into reality. We realized this was a universal problem: the gap between inspiration and implementation in interior design. Nearly 98% of design enthusiasts are dissatisfied with their home decor, yet over $25 billion is spent on interior design each year in the U.S. While AI had revolutionized many creative fields, interior design remained fragmented across inspiration platforms, furniture retailers, and 3D planning tools. Our breakthrough insight: what if we could learn someone's aesthetic preferences the same way Spotify learns musical taste - not through questionnaires, but through choices? Museum artworks became our "songs" - universally recognized pieces that reveal deep aesthetic preferences through simple A/B comparisons. What It Does Artki.tech is an AI-powered interior design platform that creates personalized 3D room visualizations with real, purchasable furniture based on your unique taste profile. Here's the complete flow: Floorplan Analysis: Users upload their room's floorplan, which gets transformed into a 3D room reconstruction using Claude-generated Three.js code. Floorplan Analysis: Users upload their room's floorplan, which gets transformed into a 3D room reconstruction using Claude-generated Three.js code. Taste Discovery: Users compare 12 pairs of museum artworks (Monet vs. Picasso, Van Gogh vs. Warhol). Each choice updates a 512-dimensional taste vector using CLIP embeddings, learning aesthetic preferences without questionnaires. Taste Discovery: Users compare 12 pairs of museum artworks (Monet vs. Picasso, Van Gogh vs. Warhol). Each choice updates a 512-dimensional taste vector using CLIP embeddings, learning aesthetic preferences without questionnaires. Real Product Discovery: Our system scrapes Amazon to find actual furniture products matching your taste profile, ensuring everything you see can be purchased. Real Product Discovery: Our system scrapes Amazon to find actual furniture products matching your taste profile, ensuring everything you see can be purchased. AI-Powered 3D Pipeline: Amazon products are enhanced with OpenAI-generated images Images are converted to 3D models using Claude's Three.js generation Models are rendered in your reconstructed room AI-Powered 3D Pipeline: Amazon products are enhanced with OpenAI-generated images Images are converted to 3D models using Claude's Three.js generation Models are rendered in your reconstructed room Interactive Visualization: Real-time Three.js rendering shows actual purchasable furniture in your specific room layout. Users can rotate, zoom, and rearrange items to perfect their design. Interactive Visualization: Real-time Three.js rendering shows actual purchasable furniture in your specific room layout. Users can rotate, zoom, and rearrange items to perfect their design. Smart Recommendations: ChromaDB's vector search finds semantically similar products based on visual features, style tags, and your evolving preferences. Smart Recommendations: ChromaDB's vector search finds semantically similar products based on visual features, style tags, and your evolving preferences. Architecture Overview Frontend: Next.js 16 + React 19 + TypeScript + Three.js + React Three Fiber Backend: FastAPI + Python 3.11 AI/ML: Claude 4.5 Sonnet + CLIP embeddings + OpenAI API + NeRF Database: ChromaDB Cloud for vectors 3D: Three.js + React Three Fiber + NeRF reconstruction Data Source: Amazon product scraping for real furniture Development Process & Technical Evolution Initial Approach: NeRF Neural Radiance Fields We started by training NeRF (Neural Radiance Fields) models to create photorealistic 3D reconstructions of rooms from just a few photos Built a Flask API server (api_server.py) to handle NeRF training with user-uploaded images Successfully generated 3D room reconstructions from 10+ photos per room Pivot Decision: While NeRF worked, the output had low fidelity and training took 8-10 minutes per room Day 1: Foundation & Pivot Set up Next.js frontend and FastAPI backend Integrated Three.js for 3D visualization Key Pivot: Switched from NeRF to Claude API for faster, higher-quality 3D generation Claude generates Three.js code directly, which we render with React Three Fiber Reduced generation time from 30 minutes to 3 seconds Day 2: AI Integration & Product Pipeline Implemented CLIP embeddings for artwork analysis Built taste vector algorithm for preference learning Amazon Integration: Created web scraping system to find real products matching user preferences Image-to-3D Pipeline: Scrape Amazon for furniture matching user taste Use OpenAI API to generate product images Convert images to 3D models using Claude Render models in Three.js scene Scrape Amazon for furniture matching user taste Use OpenAI API to generate product images Convert images to 3D models using Claude Render models in Three.js scene Day 3: Complete System Integration Connected floorplan upload to room reconstruction Integrated user preference embeddings with product search Built complete pipeline: Floorplan → Room Reconstruction → Preference Analysis → Amazon Scraping → Image Generation → 3D Conversion → Final Visualization Polished UI/UX with TailwindCSS Complete Technical Pipeline Room Reconstruction: User uploads floorplan → Claude generates Three.js room geometry from floorplan specifications Room Reconstruction: User uploads floorplan → Claude generates Three.js room geometry from floorplan specifications Taste Learning: CLIP encodes museum artworks into 512-dimensional vectors. User choices update their vector: user_vec = user_vec + win_vec - 0.5 * lose_vec Taste Learning: CLIP encodes museum artworks into 512-dimensional vectors. User choices update their vector: user_vec = user_vec + win_vec - 0.5 * lose_vec Product Discovery: Scrape Amazon for furniture matching taste vector Extract product metadata (price, dimensions, materials) Generate embeddings for semantic search Product Discovery: Scrape Amazon for furniture matching taste vector Extract product metadata (price, dimensions, materials) Generate embeddings for semantic search 3D Model Generation: OpenAI API transforms product descriptions into detailed images Images fed to Claude for Three.js code generation Real-time rendering of actual products as 3D models 3D Model Generation: OpenAI API transforms product descriptions into detailed images Images fed to Claude for Three.js code generation Real-time rendering of actual products as 3D models Final Visualization: Combine room reconstruction with generated furniture models in interactive 3D scene Final Visualization: Combine room reconstruction with generated furniture models in interactive 3D scene Challenges We Ran Into 1. NeRF Training Performance Problem: NeRF neural radiance field training took 15-30 minutes per room with low-fidelity output. Solution: Pivoted to Claude API for instant Three.js code generation, reducing time from 30 minutes to 3 seconds while improving quality. 2. Amazon Product Integration Problem: Connecting abstract taste preferences to real, purchasable products. Solution: Built web scraper for Amazon products, then used embeddings to match products to user taste vectors. 3. Image-to-3D Conversion Pipeline Problem: No direct way to convert Amazon product images to 3D models. Solution: Created multi-step pipeline: Amazon data → OpenAI image enhancement → Claude 3D code generation → Three.js rendering. 4. 3D Model Loading Issues Problem: GLTF files referenced external textures, causing 404 errors. Solution: Converted to self-contained GLB format with embedded textures. 5. Embedding Performance Problem: Generating CLIP embeddings for scraped products took 30+ seconds. Solution: Pre-computed embeddings stored in ChromaDB, reducing search to <100ms. 6. AI Code Generation Reliability Problem: Claude sometimes generated invalid Three.js code for complex furniture. Solution: Implemented robust error handling with fallback hand-crafted generators for common furniture types. 7. Floorplan to 3D Reconstruction Problem: Converting 2D floorplan images to accurate 3D room geometry. Solution: Used Claude to interpret floorplan and generate proportional Three.js room structures. Accomplishments That We're Proud Of Successfully Pivoted from NeRF: Started with neural radiance fields, recognized limitations, and pivoted to a better solution within 24 hours Successfully Pivoted from NeRF: Started with neural radiance fields, recognized limitations, and pivoted to a better solution within 24 hours End-to-End Pipeline: Built complete pipeline from floorplan upload to 3D room with real Amazon products - a truly functional prototype End-to-End Pipeline: Built complete pipeline from floorplan upload to 3D room with real Amazon products - a truly functional prototype Multi-AI Orchestration: Successfully integrated 5 different AI systems (Claude, CLIP, OpenAI, ChromaDB, NeRF) into one seamless experience Multi-AI Orchestration: Successfully integrated 5 different AI systems (Claude, CLIP, OpenAI, ChromaDB, NeRF) into one seamless experience Real Product Integration: Connected abstract preferences to actual purchasable Amazon products, solving a real-world problem Real Product Integration: Connected abstract preferences to actual purchasable Amazon products, solving a real-world problem Real-time 3D Generation: Reduced 3D generation from 30 minutes (NeRF) to 3 seconds (Claude) while improving quality Real-time 3D Generation: Reduced 3D generation from 30 minutes (NeRF) to 3 seconds (Claude) while improving quality Lightning-Fast Search: <100ms semantic search across scraped products with 512-dimensional vectors Lightning-Fast Search: <100ms semantic search across scraped products with 512-dimensional vectors Production-Ready Architecture: Built scalable, well-documented codebase that could be deployed tomorrow Production-Ready Architecture: Built scalable, well-documented codebase that could be deployed tomorrow What We Learned Technical Insights Multi-modal AI is powerful: Combining visual (CLIP) and language (Claude) AI creates emergent capabilities Vector databases are game-changers: ChromaDB enabled instant personalized search Prompt engineering matters: Structured prompts improved Claude's code generation by 70% Fallbacks are essential: Every AI component needs a reliable backup Product Insights Users want simplicity: 12 comparisons hit the sweet spot between accuracy and user patience Visual choices reveal preferences: People make faster, more confident decisions with images than questionnaires 3D visualization sells: Seeing furniture in context dramatically improves user confidence Team Insights API integration complexity: Coordinating multiple external APIs requires careful error handling Performance optimization is iterative: Each bottleneck revealed led to architectural improvements What's Next for Artki.tech Immediate Goals (Next Month) Real Furniture Integration: Partner with IKEA, Wayfair, West Elm for actual purchasable items Mobile AR Preview: Use ARKit/ARCore for in-room visualization Expand Catalog: 500+ furniture items with real product links Business Model Freemium: Free taste profiling + 3 room designs Pro Subscription: Unlimited designs, high-res exports, AR preview Affiliate Revenue: Commission from furniture purchases Enterprise API: White-label solution for furniture retailers

Interior Design 3D Furniture Search

AI-powered interior design assistant that uses semantic search to find and place 3D furniture models based on user preferences and natural language queries.

🏗️ Architecture

Tech Stack

Frontend: Next.js 16 + React 19 + Three.js (3D rendering)
Backend: FastAPI + Python 3.10+
ML/AI:
- CLIP (OpenAI) for image/text embeddings
- Claude 3.5 Sonnet (Anthropic) for natural language query enhancement
Vector DB: ChromaDB Cloud for semantic search
3D Models: GLTF/OBJ formats

How It Works

User Preference Collection: Users complete a style quiz (A/B testing with artwork images)
Taste Embedding: CLIP generates a 512-dimensional taste vector stored in ChromaDB
Natural Language Queries: Users describe furniture they want ("I need a cozy modern wooden coffee table")
Query Enhancement (Claude): AI parses the query to extract:
- Category (furniture/lighting/painting)
- Subcategory (sofa/table/lamp)
- Style tags (modern, scandinavian, etc.)
- Materials (wood, metal, glass)
- Colors and dimensions
Hybrid Search: Combines user preference vector (60%) + enhanced text query embedding (40%)
3D Rendering: Loads and places selected furniture models in the 3D room scene

📁 Project Structure

.
├── artspace-interior/artspace-ui/          # Frontend (Next.js)
│   ├── app/
│   │   ├── components/
│   │   │   ├── 3DViewer.tsx               # Three.js 3D scene
│   │   │   ├── FloorplanUploader.tsx       # Upload room floorplan
│   │   │   ├── StyleQuiz.tsx               # User taste preferences
│   │   │   └── StudioChatPanel.tsx         # Chat interface for queries
│   │   └── page.tsx                        # Main app flow
│   └── lib/
│       ├── furniture-api.ts                # API client for furniture search
│       └── nerf-api.ts                     # NeRF 3D reconstruction
│
└── taste-fingerprint/                      # Backend (Python)
    ├── apps/serve/
    │   ├── main.py                         # FastAPI server
    │   ├── services/
    │   │   ├── embeddings.py               # CLIP embedding utilities
    │   │   └── furniture.py                # Furniture search service
    │   └── scripts/
    │       └── embed_furniture.py          # Populate ChromaDB with furniture
    │
    └── packages/catalog/
        ├── furniture.json                  # Curated furniture catalog (22 items)
        └── artworks.json                   # Artwork catalog for taste quiz

🚀 Setup Instructions

1. Clone and Navigate

cd /path/to/interior-design

2. Backend Setup (taste-fingerprint)

cd taste-fingerprint/apps/serve

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Create .env file with your own credentials
cat > .env << 'EOF'
CHROMA_API_KEY=<your_chroma_api_key>
CHROMA_TENANT=<your_chroma_tenant_id>
CHROMA_DATABASE=taste-fingerprint
ANTHROPIC_API_KEY=<your_anthropic_api_key>
SKETCHFAB_TOKEN=<your_sketchfab_token>
CORS_ALLOW_ORIGINS=http://localhost:3000,http://localhost:3001
EOF

# Embed furniture catalog into ChromaDB
python scripts/embed_furniture.py

# Start the API server
uvicorn main:app --reload --port 8000

The API will be available at http://localhost:8000

3. Frontend Setup (artspace-ui)

cd ../../artspace-interior/artspace-ui

# Install dependencies
npm install

# Create .env.local file
cat > .env.local << 'EOF'
NEXT_PUBLIC_API_BASE=http://localhost:8000
NEXT_PUBLIC_FURNITURE_API_URL=http://localhost:8000
NEXT_PUBLIC_NERF_API_URL=http://localhost:5000
EOF

# Start the development server
npm run dev

The app will be available at http://localhost:3000

🎯 Usage Flow

1. Upload Floorplan

User uploads a room floorplan image
System processes it to create 3D room geometry

2. Style Preferences

User completes a style quiz (9 questions)
System generates taste vector using CLIP embeddings
Vector stored in ChromaDB under user_id

3. Search Furniture

User enters natural language query: "modern wooden coffee table"
System searches furniture catalog using hybrid approach:
- User taste vector (60 weight)
- Text query embedding (40% weight)
Returns ranked results with similarity scores

4. 3D Visualization

Selected furniture loaded into Three.js scene
User can view, rotate, and explore the furnished room

🔌 API Endpoints

Furniture Search

POST /api/furniture/search

{
  "user_id": "user_123",
  "text_query": "I need a cozy modern wooden coffee table for my living room",
  "category": "furniture",
  "limit": 10,
  "use_claude": true
}

Claude Enhancement Example: Input: "I need a cozy modern wooden coffee table" Claude extracts:

{
  "enhanced_text": "modern scandinavian oak coffee table",
  "category": "furniture",
  "subcategory": "table",
  "style_tags": ["modern", "scandinavian", "cozy"],
  "materials": ["wood", "oak"],
  "colors": ["natural"]
}

Response:

{
  "items": [
    {
      "id": "furn_table_coffee_002",
      "name": "Round Wooden Coffee Table",
      "category": "furniture",
      "subcategory": "table",
      "styleTags": ["scandinavian", "natural", "organic"],
      "colors": ["oak", "natural", "wood"],
      "dimensions": { "width": 36, "depth": 36, "height": 16, "unit": "inches" },
      "description": "Round coffee table with solid oak top and splayed legs",
      "image_url": "/furniture/table_coffee_002.jpg",
      "model_url": "/models/furniture/table_coffee_002.glb",
      "model_format": "gltf",
      "similarity_score": 0.8234
    }
  ],
  "count": 1,
  "query": {
    "user_id": "user_123",
    "text_query": "modern wooden coffee table",
    "category": "furniture"
  }
}

Get Furniture by ID

GET /api/furniture/{furniture_id}

User Taste Update

POST /taste/update

{
  "user_id": "user_123",
  "win_id": "art_botticelli_john",
  "lose_id": "art_caravaggio_denial"
}

📊 Furniture Catalog

The catalog contains 22 curated 3D furniture items:

Furniture (14 items): Sofas, chairs, tables, bookshelves, rugs, plants, cushions
Lighting (5 items): Floor lamps, table lamps, pendants, chandeliers
Paintings (4 items): Abstract, botanical, landscape artwork

Each item includes:

Name, description, dimensions
Style tags (modern, mid-century, scandinavian, etc.)
Color palette
Image URL (for embedding)
3D model URL (GLTF format)

Adding More Items

Add new entries to packages/catalog/furniture.json
Add corresponding images to apps/web/public/furniture/
Add 3D models to apps/web/public/models/
Re-run the embedding script:

cd taste-fingerprint/apps/serve
python scripts/embed_furniture.py

🧪 Testing

Test Backend API

# Health check
curl http://localhost:8000/health

# Search furniture
curl -X POST http://localhost:8000/api/furniture/search \
  -H "Content-Type: application/json" \
  -d '{
    "text_query": "modern sofa",
    "category": "furniture",
    "limit": 5
  }'

Test Frontend

Navigate to http://localhost:3000
Upload a floorplan image
Complete the style quiz
View the 3D room with furniture

🔧 Troubleshooting

ChromaDB Connection Issues

Verify API key, tenant, and database name in .env
Check network connectivity to ChromaDB Cloud

Embedding Script Fails

Ensure furniture images exist in apps/web/public/furniture/
Check image paths in furniture.json match actual files
Verify CLIP model downloads successfully

3D Models Not Loading

Check model URLs in furniture.json are correct
Verify GLTF files are valid (test with online viewer)
Check browser console for Three.js errors

CORS Errors

Verify CORS_ALLOW_ORIGINS in backend .env includes frontend URL
Check NEXT_PUBLIC_API_BASE in frontend .env.local

📝 Next Steps

Short Term

Add actual 3D model files (.glb) to /public/models/
Add furniture product images to /public/furniture/
Test end-to-end flow with real models
Implement furniture placement logic in 3DViewer

Medium Term

Expand furniture catalog to 50-100 items
Add price filtering and shopping cart
Implement "Save Design" functionality
Add furniture swapping/alternatives UI

Long Term

Integrate with real 3D furniture retailers (Wayfair, IKEA APIs)
Auto-generate room layouts based on floorplan
AR preview mode (mobile)
Multi-room support

📚 Key Technologies

CLIP: Connects text and images in same embedding space
Claude 3.5 Sonnet: Advanced AI for natural language understanding
ChromaDB: Open-source vector database
Three.js: JavaScript 3D library
FastAPI: Modern Python web framework
Next.js: React framework with SSR

🎯 Key Features

1. Claude-Enhanced Query Understanding

Instead of simple keyword matching, Claude AI parses natural language:

"I want something cozy" → extracts style: bohemian, warm colors
"modern wooden table" → furniture + table + modern + wood materials
"floor lamp under 6 feet" → lighting + floor lamp + dimension constraints

2. Hybrid Semantic Search

Combines user taste preferences (from style quiz)
With specific item requests (from chat queries)
Weights: 60% user taste + 40% text query

3. Smart Caching

All searches cached in ChromaDB
Instant results for repeated queries
No repeated API calls

👥 Team

Built for CalHacks 12.0 by the Interior Design Team

📄 License

MIT

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FastAPIIn code
HTMLIn code
Hugging FaceIn code
JavaScriptIn code
Next.jsIn code
OpenAIIn code
PythonIn code
PyTorchIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
FlaskClaimed
VercelClaimed

13 of 15 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

459 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

5 Verified6 Code-supported

ChromaDB vector search for smart furniture recommendationsVerified
ChromaDB's vector search finds semantically similar products based on visual features, style tags, and evolving preferences
Claimed on Devposthigh confidence
- taste-fingerprint/apps/serve/services/furniture.py:20 — FurnitureSearchService performs hybrid semantic search against a ChromaDB 'furnitures' collection using CLIP text embeddings and user preference vectors
- taste-fingerprint/apps/serve/main.py:1115 — _query_products_by_vector queries the ChromaDB 'products' collection by cosine similarity against the user's taste vector
Claude-based product/query enhancement and recommendation scoringVerified
Claude parses natural language queries and scores candidate products for recommendations
Claimed on readmehigh confidence
- taste-fingerprint/apps/serve/services/query_enhancer.py:1 — Module dedicated to enhancing furniture search queries via Claude, imported by services/furniture.py
- taste-fingerprint/apps/serve/main.py:1141 — _build_claude_payload builds a scoring prompt combining taste vector and candidates, sent to Claude via recommend_products and merged with cosine similarity in _merge_scores
Floorplan upload and Claude-generated 3D room reconstructionVerified
Users upload a floorplan which is transformed into a 3D room reconstruction using Claude-generated Three.js code
Claimed on Devposthigh confidence
- artspace-interior/artspace-ui/app/components/FloorplanUploader.tsx:1 — Upload UI component for floorplan images, wired into app/page.tsx
- taste-fingerprint/apps/serve/services/complete_room_generator.py:14 — CompleteRoomGenerator sends the uploaded image to Claude Vision (claude-sonnet-4-5) and returns generated Three.js scene code
- taste-fingerprint/apps/serve/main.py:1023 — /api/generate-complete-room endpoint invokes CompleteRoomGenerator with the uploaded image_data
Interactive Three.js/React Three Fiber 3D visualization with rotate/zoom/rearrangeVerified
Real-time Three.js rendering shows purchasable furniture in the room; users can rotate, zoom, and rearrange items
Claimed on Devposthigh confidence
- artspace-interior/artspace-ui/app/components/3DViewer.tsx:1 — Three.js/React Three Fiber scene component for rendering room and furniture
- artspace-interior/artspace-ui/app/components/Claude3DViewer.tsx:1 — Viewer component dedicated to rendering Claude-generated Three.js code
Taste discovery via 12 artwork A/B comparisons updating a 512-D CLIP taste vectorVerified
Users compare 12 pairs of museum artworks; each choice updates a 512-dimensional taste vector using CLIP embeddings
Claimed on Devposthigh confidence
- artspace-interior/artspace-ui/app/components/TasteFingerprint.tsx:35 — TARGET_COMPARISONS = 12, pairs artworks and posts win/lose choices to the backend
- taste-fingerprint/apps/serve/main.py:768 — /taste/update endpoint computes user_vec = user_vec + win_vec - 0.5*lose_vec matching the described formula, normalized and upserted to ChromaDB
- taste-fingerprint/apps/serve/services/embeddings.py:36 — embed_image/embed_text use openai/clip-vit-base-patch32 (CLIP) producing 512-D vectors
AI-powered image-to-3D pipeline (OpenAI image generation to Claude Three.js conversion)Code-supported
Amazon products are enhanced with OpenAI-generated images, then converted to 3D models using Claude's Three.js generation and rendered in the room
Claimed on Devpostmedium confidence
- taste-fingerprint/apps/serve/main.py:999 — /api/image-to-3d endpoint infers furniture attributes from a description/image_url and calls Claude3DGenerator to produce Three.js code
- taste-fingerprint/apps/serve/services/claude_3d_generator.py:18 — Claude3DGenerator.generate_furniture_code calls Claude Sonnet 4.5 to generate Three.js furniture code, with a static fallback if the API key is absent
- taste-fingerprint/apps/serve/main.py:713 — /render/room calls openai_client.images.edit to generate a photorealistic room render, but this augments the whole room image rather than converting individual product images into standalone 3D models as the claim describes
Amazon product scraping for real, purchasable furnitureCode-supported
System scrapes Amazon to find actual furniture products matching the user's taste profile
Claimed on Devpostlow confidence
- taste-fingerprint/packages/catalog/products_clean.json:12 — Product entries contain amazon.com buy_url, m.media-amazon.com image_url, and scraped_at timestamps, indicating scraped Amazon data
- taste-fingerprint/apps/serve/scripts/clean_products.py:1 — Docstring says it cleans 'the messy scrape stored in packages/catalog/products.json', but this script only transforms already-scraped data; no live scraper (requests/BeautifulSoup/Selenium hitting amazon.com) was found anywhere in the repo
Curated 22-item furniture/lighting/art catalogCode-supported
The catalog contains 22 curated 3D furniture items across furniture, lighting, and paintings categories
Claimed on readmelow confidence
- taste-fingerprint/packages/catalog/furniture.json — Catalog file exists as described in README's project structure; exact item count of 22 was not independently tallied
Hybrid furniture search: 60% user taste vector + 40% text query embedding weightingCode-supported
Hybrid Search combines user preference vector (60%) with enhanced text query embedding (40%)
Claimed on readmelow confidence
- taste-fingerprint/apps/serve/services/furniture.py:48 — search() method blends user_id vector and text_query but the exact 60/40 weighting constants were not located in the excerpt read; broader read of the file needed to confirm the precise ratio
NeRF-based room reconstruction (early prototype)Code-supported
Initial approach trained NeRF (Neural Radiance Fields) models via a Flask API server (api_server.py) for photorealistic 3D room reconstruction from photos, later pivoted away from
Claimed on Devpostmedium confidence
- artspace-interior/artspace-ui/api_server.py:1 — Flask REST API server for NeRF training/upload endpoints exists exactly as described, matching the claimed 'pivot' narrative (present but described as superseded by the Claude pipeline)
- artspace-interior/artspace-ui/lib/nerf-api.ts:1 — Frontend client for the NeRF API also exists
Style quiz (9-question) taste preference UICode-supported
Users complete a style quiz (9 questions) to generate a taste vector, per README's 'How It Works' section
Claimed on readmemedium confidence
- artspace-interior/artspace-ui/app/components/StyleQuiz.tsx:18 — StyleQuiz component exists with grouped style options (modern-minimal, scandinavian, industrial, etc.) but this is a separate preset-style picker, distinct from and possibly not the same flow as the 12-artwork-pair TasteFingerprint component actually wired into page.tsx

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.