MVP working - audio analysis pipeline with Whisper, MFCC diarization, Groq insights

.gitignore

@@ -0,0 +1,21 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+.env
+
+# Database
+*.db
+
+# Node
+node_modules/
+dist/
+
+# Conda/pip
+venv/
+
+# Mac
+.DS_Store
+
+# Temporary audio files
+/tmp/behavioral_mirror/

backend/db/database.py

@@ -0,0 +1,24 @@
+from sqlalchemy import create_engine, Column, String, Text, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///./behavioral_mirror.db"
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL,
+    connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class Session(Base):
+    __tablename__ = "sessions"
+
+    id = Column(String, primary_key=True)
+    user_id = Column(String, index=True)
+    context = Column(String)
+    signals_json = Column(Text)
+    insights_json = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)

backend/environment.yml

@@ -0,0 +1,263 @@
+name: behavioral-mirror
+channels:
+  - conda-forge
+  - defaults
+  - https://repo.anaconda.com/pkgs/main
+  - https://repo.anaconda.com/pkgs/r
+dependencies:
+  - aom=3.9.1=h7bae524_0
+  - bzip2=1.0.8=h80987f9_6
+  - ca-certificates=2026.4.22=hbd8a1cb_0
+  - cairo=1.18.4=he0f2337_1
+  - dav1d=1.2.1=hb547adb_0
+  - dbus=1.16.2=h3ff7a7c_1
+  - ffmpeg=8.1.1=gpl_h246f3d5_101
+  - font-ttf-dejavu-sans-mono=2.37=hab24e00_0
+  - font-ttf-inconsolata=3.000=h77eed37_0
+  - font-ttf-source-code-pro=2.038=h77eed37_0
+  - font-ttf-ubuntu=0.83=h77eed37_3
+  - fontconfig=2.17.1=h2b252f5_0
+  - fonts-conda-ecosystem=1=0
+  - fonts-conda-forge=1=hc364b38_1
+  - fribidi=1.0.16=hc919400_0
+  - gdk-pixbuf=2.44.6=h4e57454_0
+  - glslang=16.3.0=h7cb4797_0
+  - gmp=6.3.0=h7bae524_2
+  - graphite2=1.3.14=hec049ff_2
+  - harfbuzz=14.2.0=h3103d1b_0
+  - icu=78.3=hef89b57_0
+  - lame=3.100=h1a8c8d9_1003
+  - lcms2=2.19.1=hdfa7624_0
+  - lerc=4.1.0=h1eee2c3_0
+  - libabseil=20260107.1=cxx17_h2062a1b_0
+  - libass=0.17.4=hcbd7ca7_0
+  - libbrotlicommon=1.2.0=hc919400_1
+  - libbrotlidec=1.2.0=hc919400_1
+  - libbrotlienc=1.2.0=hc919400_1
+  - libcxx=22.1.2=hf894667_0
+  - libdeflate=1.25=hc11a715_0
+  - libdovi=3.3.2=h78f8ca3_4
+  - libexpat=2.8.0=h50f4ffc_0
+  - libffi=3.5.2=hcf2aa1b_0
+  - libfreetype=2.14.3=hce30654_0
+  - libfreetype6=2.14.3=hdfa99f5_0
+  - libglib=2.88.1=ha08bb59_2
+  - libhwloc=2.13.0=default_ha97f43a_1000
+  - libhwy=1.4.0=ha332bbd_0
+  - libiconv=1.18=h23cfdf5_2
+  - libintl=0.25.1=h493aca8_0
+  - libjpeg-turbo=3.1.4.1=h84a0fba_0
+  - libjxl=0.11.2=h934fa54_1
+  - liblzma=5.8.3=h8088a28_0
+  - liblzma-devel=5.8.3=h8088a28_0
+  - libogg=1.3.5=h48c0fde_1
+  - libopenvino=2026.0.0=h3e6d54f_1
+  - libopenvino-arm-cpu-plugin=2026.0.0=h3e6d54f_1
+  - libopenvino-auto-batch-plugin=2026.0.0=h2406d2e_1
+  - libopenvino-auto-plugin=2026.0.0=h2406d2e_1
+  - libopenvino-hetero-plugin=2026.0.0=h85cbfa6_1
+  - libopenvino-ir-frontend=2026.0.0=h85cbfa6_1
+  - libopenvino-onnx-frontend=2026.0.0=h41365f2_1
+  - libopenvino-paddle-frontend=2026.0.0=h41365f2_1
+  - libopenvino-pytorch-frontend=2026.0.0=hf6b4638_1
+  - libopenvino-tensorflow-frontend=2026.0.0=hc295da0_1
+  - libopenvino-tensorflow-lite-frontend=2026.0.0=hf6b4638_1
+  - libopus=1.6.1=h1a92334_0
+  - libplacebo=7.360.1=h176d363_0
+  - libpng=1.6.58=h132b30e_0
+  - libprotobuf=6.33.5=h4a5acfd_0
+  - librsvg=2.62.1=he8aa2a2_0
+  - libsqlite=3.53.1=h1b79a29_0
+  - libtiff=4.7.1=h4030677_1
+  - libusb=1.0.29=hbc156a2_0
+  - libvorbis=1.3.7=h81086ad_2
+  - libvpx=1.15.2=ha759d40_0
+  - libvulkan-loader=1.4.341.0=h3feff0a_0
+  - libwebp-base=1.6.0=h07db88b_0
+  - libxml2=2.15.3=h5654f7c_0
+  - libxml2-16=2.15.3=h5ef1a60_0
+  - libzlib=1.3.2=h8088a28_2
+  - ncurses=6.5=hee39554_0
+  - openh264=2.6.0=hb5b2745_0
+  - openssl=3.6.2=hd24854e_0
+  - pango=1.56.4=hf80efc4_1
+  - pcre2=10.47=h30297fc_0
+  - pip=26.0.1=pyhc872135_1
+  - pixman=0.46.4=h81086ad_1
+  - pugixml=1.15=hd3d436d_0
+  - python=3.10.20=h1b19095_0_cpython
+  - readline=8.3=h0b18652_0
+  - sdl2=2.32.56=h248ca61_0
+  - sdl3=3.4.8=h6fa9c73_0
+  - shaderc=2026.2=hf31e910_0
+  - snappy=1.2.2=hada39a4_1
+  - spirv-tools=2026.1=h4ddebb9_0
+  - sqlite=3.51.2=h67002bf_0
+  - svt-av1=4.0.1=h0cb729a_0
+  - tbb=2023.0.0=he0260a5_2
+  - tk=8.6.15=hcd8a7d5_0
+  - wheel=0.46.3=py310hca03da5_0
+  - x264=1!164.3095=h57fd34a_2
+  - x265=3.5=hbc6ce65_3
+  - xz=5.8.3=hd0f0c4f_0
+  - xz-gpl-tools=5.8.3=hd0f0c4f_0
+  - xz-tools=5.8.3=h8088a28_0
+  - zlib=1.3.2=h8088a28_2
+  - zstd=1.5.7=hbf9d68e_6
+  - pip:
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.13.5
+      - aiosignal==1.4.0
+      - alembic==1.18.4
+      - annotated-doc==0.0.4
+      - annotated-types==0.7.0
+      - anthropic==0.102.0
+      - antlr4-python3-runtime==4.9.3
+      - anyio==4.13.0
+      - asteroid-filterbanks==0.4.0
+      - async-timeout==5.0.1
+      - attrs==26.1.0
+      - audioread==3.1.0
+      - av==17.0.1
+      - certifi==2026.4.22
+      - cffi==2.0.0
+      - charset-normalizer==3.4.7
+      - click==8.3.3
+      - coloredlogs==15.0.1
+      - colorlog==6.10.1
+      - contourpy==1.3.2
+      - ctranslate2==4.7.1
+      - cycler==0.12.1
+      - decorator==5.2.1
+      - distro==1.9.0
+      - docstring-parser==0.18.0
+      - einops==0.8.2
+      - exceptiongroup==1.3.1
+      - fastapi==0.136.1
+      - faster-whisper==1.2.1
+      - filelock==3.29.0
+      - flatbuffers==25.12.19
+      - fonttools==4.63.0
+      - frozenlist==1.8.0
+      - fsspec==2026.4.0
+      - googleapis-common-protos==1.75.0
+      - groq==1.2.0
+      - grpcio==1.80.0
+      - h11==0.16.0
+      - hf-xet==1.5.0
+      - httpcore==1.0.9
+      - httpx==0.28.1
+      - huggingface-hub==0.36.2
+      - humanfriendly==10.0
+      - hyperpyyaml==1.2.3
+      - idna==3.15
+      - importlib-metadata==8.7.1
+      - jinja2==3.1.6
+      - jiter==0.14.0
+      - joblib==1.5.3
+      - julius==0.2.7
+      - kiwisolver==1.5.0
+      - lazy-loader==0.5
+      - librosa==0.11.0
+      - lightning==2.6.1
+      - lightning-utilities==0.15.3
+      - llvmlite==0.47.0
+      - mako==1.3.12
+      - markdown-it-py==4.2.0
+      - markupsafe==3.0.3
+      - matplotlib==3.10.9
+      - mdurl==0.1.2
+      - more-itertools==11.0.2
+      - mpmath==1.3.0
+      - msgpack==1.1.2
+      - multidict==6.7.1
+      - networkx==3.4.2
+      - nltk==3.9.4
+      - numba==0.65.1
+      - numpy==1.26.4
+      - omegaconf==2.3.0
+      - onnxruntime==1.23.2
+      - openai-whisper==20250625
+      - opentelemetry-api==1.41.1
+      - opentelemetry-exporter-otlp==1.41.1
+      - opentelemetry-exporter-otlp-proto-common==1.41.1
+      - opentelemetry-exporter-otlp-proto-grpc==1.41.1
+      - opentelemetry-exporter-otlp-proto-http==1.41.1
+      - opentelemetry-proto==1.41.1
+      - opentelemetry-sdk==1.41.1
+      - opentelemetry-semantic-conventions==0.62b1
+      - optuna==4.8.0
+      - packaging==26.2
+      - pandas==2.3.3
+      - pillow==12.2.0
+      - platformdirs==4.9.6
+      - pooch==1.9.0
+      - primepy==1.3
+      - propcache==0.5.2
+      - protobuf==6.33.6
+      - pyannote-audio==3.1.1
+      - pyannote-core==6.0.1
+      - pyannote-database==6.1.1
+      - pyannote-metrics==4.1
+      - pyannote-pipeline==4.0.0
+      - pyannoteai-sdk==0.4.0
+      - pycparser==3.0
+      - pydantic==2.13.4
+      - pydantic-core==2.46.4
+      - pydub==0.25.1
+      - pygments==2.20.0
+      - pyparsing==3.3.2
+      - python-dateutil==2.9.0.post0
+      - python-dotenv==1.2.2
+      - python-multipart==0.0.28
+      - pytorch-lightning==2.6.1
+      - pytorch-metric-learning==2.9.0
+      - pytz==2026.2
+      - pyyaml==6.0.3
+      - regex==2026.5.9
+      - requests==2.34.2
+      - resemblyzer==0.1.4
+      - rich==15.0.0
+      - ruamel-yaml==0.18.17
+      - ruamel-yaml-clib==0.2.15
+      - safetensors==0.7.0
+      - scikit-learn==1.7.2
+      - scipy==1.15.3
+      - semver==3.0.4
+      - sentencepiece==0.2.1
+      - setuptools==82.0.1
+      - shellingham==1.5.4
+      - six==1.17.0
+      - sniffio==1.3.1
+      - sortedcontainers==2.4.0
+      - soundfile==0.13.1
+      - soxr==1.1.0
+      - speechbrain==1.1.0
+      - sqlalchemy==2.0.49
+      - starlette==1.0.0
+      - sympy==1.13.1
+      - tensorboardx==2.6.5
+      - threadpoolctl==3.6.0
+      - tiktoken==0.13.0
+      - tokenizers==0.22.2
+      - tomli==2.4.1
+      - torch==2.5.1
+      - torch-audiomentations==0.12.0
+      - torch-pitch-shift==1.2.5
+      - torchaudio==2.8.0
+      - torchcodec==0.7.0
+      - torchmetrics==1.9.0
+      - torchvision==0.23.0
+      - tqdm==4.67.3
+      - transformers==4.57.6
+      - typer==0.25.1
+      - typing==3.7.4.3
+      - typing-extensions==4.15.0
+      - typing-inspection==0.4.2
+      - tzdata==2026.2
+      - urllib3==2.7.0
+      - uvicorn==0.47.0
+      - webrtcvad==2.0.10
+      - yarl==1.23.0
+      - zipp==3.23.1
+prefix: /opt/anaconda3/envs/behavioral-mirror

backend/main.py

@@ -0,0 +1,161 @@
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import os, shutil, uuid, json
+from dotenv import load_dotenv
+import numpy as np
+
+load_dotenv()
+
+from pipeline.transcriber import Transcriber
+from pipeline.diarizer import Diarizer
+from pipeline.signal_extractor import SignalExtractor
+from pipeline.insight_generator import InsightGenerator
+from db.database import SessionLocal, Session, Base, engine
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+
+UPLOAD_DIR = "/tmp/behavioral_mirror"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+print("Loading models... this may take a minute on first run.")
+transcriber = Transcriber(model_size="base")
+diarizer = Diarizer(hf_token=os.getenv("HF_TOKEN"))
+insight_gen = InsightGenerator(api_key=os.getenv("GROQ_API_KEY"))
+print("All models loaded. Server ready.")
+
+
+@app.get("/")
+def root():
+    return {"status": "Behavioral Mirror API is running"}
+
+
+@app.post("/api/analyze")
+async def analyze_session(
+    audio: UploadFile = File(...),
+    context: str = Form("casual"),
+    user_speaker: str = Form("SPEAKER_00"),
+    num_speakers: int = Form(2),
+    user_id: str = Form("default_user")
+):
+    session_id = str(uuid.uuid4())
+    audio_path = f"{UPLOAD_DIR}/{session_id}.wav"
+
+    # Save uploaded file temporarily
+    temp_path = f"{UPLOAD_DIR}/{session_id}_temp"
+    with open(temp_path, "wb") as f:
+        shutil.copyfileobj(audio.file, f)
+
+    # Convert to proper WAV format using ffmpeg
+    import subprocess
+    result_conv = subprocess.run([
+        "ffmpeg", "-i", temp_path,
+        "-ar", "16000",
+        "-ac", "1",
+        "-y", audio_path
+    ], capture_output=True)
+    os.remove(temp_path)
+
+    try:
+        # Step 1: Transcribe
+        print(f"[{session_id}] Transcribing...")
+        transcript = transcriber.transcribe(audio_path)
+
+        # Step 2: Diarize
+        print(f"[{session_id}] Diarizing...")
+        diarization = diarizer.diarize(audio_path, num_speakers=num_speakers)
+
+        # Step 3: Merge
+        print(f"[{session_id}] Merging transcript and speakers...")
+        merged = diarizer.merge_transcript_with_speakers(
+            transcript["segments"],
+            diarization
+        )
+
+        # Step 4: Extract signals
+        print(f"[{session_id}] Extracting signals...")
+        extractor = SignalExtractor(audio_path, merged, user_speaker)
+        signals = extractor.extract_all()
+
+        # Step 5: Get baseline
+        db = SessionLocal()
+        baseline = get_user_baseline(db, user_id)
+
+        # Step 6: Generate insights
+        print(f"[{session_id}] Generating insights...")
+        insights = insight_gen.generate(signals, context, baseline)
+
+        # Step 7: Save session
+        save_session(db, session_id, user_id, signals, insights, context)
+        db.close()
+
+        # Delete audio immediately after processing
+        os.remove(audio_path)
+        print(f"[{session_id}] Done.")
+
+        return {
+            "session_id": session_id,
+            "signals": signals,
+            "insights": insights
+        }
+
+    except Exception as e:
+        if os.path.exists(audio_path):
+            os.remove(audio_path)
+        print(f"Error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/sessions/{user_id}")
+def get_sessions(user_id: str):
+    db = SessionLocal()
+    sessions = db.query(Session).filter(
+        Session.user_id == user_id
+    ).order_by(Session.created_at.desc()).all()
+    db.close()
+
+    return [
+        {
+            "session_id": s.id,
+            "context": s.context,
+            "created_at": s.created_at.isoformat(),
+            "insights": json.loads(s.insights_json),
+            "signals": json.loads(s.signals_json)
+        }
+        for s in sessions
+    ]
+
+
+def get_user_baseline(db, user_id: str):
+    sessions = db.query(Session).filter(Session.user_id == user_id).all()
+    if len(sessions) < 3:
+        return None
+
+    all_signals = [json.loads(s.signals_json) for s in sessions[-10:]]
+
+    return {
+        "avg_speech_rate_wpm": float(np.mean([s["speech_rate"]["overall_wpm"] for s in all_signals])),
+        "avg_talk_ratio": float(np.mean([s["talk_ratio"]["user_ratio"] for s in all_signals])),
+        "avg_filler_rate": float(np.mean([s["filler_words"]["rate_per_100_words"] for s in all_signals])),
+        "avg_response_latency_s": float(np.mean([s["pauses"]["response_latency"]["mean_s"] for s in all_signals]))
+    }
+
+
+def save_session(db, session_id, user_id, signals, insights, context):
+    session = Session(
+        id=session_id,
+        user_id=user_id,
+        context=context,
+        signals_json=json.dumps(signals),
+        insights_json=json.dumps(insights)
+    )
+    db.add(session)
+    db.commit()

backend/pipeline/diarizer.py

@@ -0,0 +1,77 @@
+import numpy as np
+import librosa
+from sklearn.cluster import KMeans
+
+class Diarizer:
+    def __init__(self, hf_token: str = None):
+        print("Diarizer ready (librosa-based).")
+
+    def diarize(self, audio_path: str, num_speakers: int = 2) -> list:
+        print(f"Diarizing: {audio_path}")
+
+        audio, sr = librosa.load(audio_path, sr=16000, mono=True)
+
+        # Split into 1-second windows with 0.5s hop
+        window = sr          # 1 second
+        hop = sr // 2        # 0.5 second
+
+        embeddings = []
+        timestamps = []
+
+        for start in range(0, len(audio) - window, hop):
+            chunk = audio[start:start + window]
+
+            # Extract simple features: MFCCs
+            mfcc = librosa.feature.mfcc(y=chunk, sr=sr, n_mfcc=13)
+            embedding = np.concatenate([mfcc.mean(axis=1), mfcc.std(axis=1)])
+            embeddings.append(embedding)
+            timestamps.append({
+                "start": round(start / sr, 3),
+                "end": round((start + window) / sr, 3)
+            })
+
+        if len(embeddings) < num_speakers:
+            # Not enough audio — assign everything to speaker 0
+            return [{"speaker": "SPEAKER_00", "start": 0.0,
+                     "end": round(len(audio) / sr, 3)}]
+
+        # Cluster into num_speakers groups
+        kmeans = KMeans(n_clusters=num_speakers, random_state=0, n_init=10)
+        labels = kmeans.fit_predict(np.array(embeddings))
+
+        # Build segment list
+        raw_segments = []
+        for ts, label in zip(timestamps, labels):
+            raw_segments.append({
+                "speaker": f"SPEAKER_0{label}",
+                "start": ts["start"],
+                "end": ts["end"]
+            })
+
+        # Merge consecutive same-speaker segments
+        merged = []
+        for seg in raw_segments:
+            if (merged and
+                merged[-1]["speaker"] == seg["speaker"] and
+                seg["start"] - merged[-1]["end"] < 1.0):
+                merged[-1]["end"] = seg["end"]
+            else:
+                merged.append(dict(seg))
+
+        return merged
+
+    def merge_transcript_with_speakers(
+        self,
+        transcript_segments: list,
+        diarization_segments: list
+    ) -> list:
+        merged = []
+        for t_seg in transcript_segments:
+            t_mid = (t_seg["start"] + t_seg["end"]) / 2
+            assigned_speaker = "SPEAKER_00"
+            for d_seg in diarization_segments:
+                if d_seg["start"] <= t_mid <= d_seg["end"]:
+                    assigned_speaker = d_seg["speaker"]
+                    break
+            merged.append({**t_seg, "speaker": assigned_speaker})
+        return merged

backend/pipeline/insight_generator.py

@@ -0,0 +1,117 @@
+import json
+from groq import Groq
+
+class InsightGenerator:
+    def __init__(self, api_key: str):
+        self.client = Groq(api_key=api_key)
+
+    def generate(self, signals: dict, context: str, user_baseline: dict = None) -> dict:
+        structured_input = self._prepare_input(signals, context, user_baseline)
+        prompt = self._build_prompt(structured_input)
+
+        response = self.client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,
+            max_tokens=1500
+        )
+
+        raw_output = response.choices[0].message.content
+        return self._parse_output(raw_output)
+
+    def _prepare_input(self, signals: dict, context: str, baseline: dict) -> dict:
+        prepared = {
+            "context": context,
+            "session_duration_minutes": round(signals["session_duration_s"] / 60, 1),
+            "talk_ratio_user": signals["talk_ratio"]["user_ratio"],
+            "speech_rate_wpm": signals["speech_rate"]["overall_wpm"],
+            "speech_rate_variability": signals["speech_rate"]["variability"],
+            "avg_response_latency_s": signals["pauses"]["response_latency"]["mean_s"],
+            "within_turn_pause_count": signals["pauses"]["within_turn_pauses"]["count"],
+            "user_interrupted_other": signals["interruptions"]["user_interrupted_other"],
+            "user_was_interrupted": signals["interruptions"]["user_was_interrupted"],
+            "filler_rate_per_100_words": signals["filler_words"]["rate_per_100_words"],
+            "top_filler_words": list(signals["filler_words"]["breakdown"].keys())[:3],
+            "pitch_std_hz": signals["pitch_features"].get("std_hz"),
+            "other_engagement_trend": signals["engagement_proxy"].get("other_speaker_turn_length_trend")
+        }
+
+        if baseline:
+            def pct_delta(current, base):
+                if not base or base == 0:
+                    return None
+                return round((current - base) / base * 100, 1)
+
+            prepared["baseline_comparison"] = {
+                "speech_rate_delta_pct": pct_delta(
+                    prepared["speech_rate_wpm"],
+                    baseline.get("avg_speech_rate_wpm")
+                ),
+                "filler_rate_delta_pct": pct_delta(
+                    prepared["filler_rate_per_100_words"],
+                    baseline.get("avg_filler_rate")
+                ),
+                "response_latency_delta_pct": pct_delta(
+                    prepared["avg_response_latency_s"],
+                    baseline.get("avg_response_latency_s")
+                ),
+                "talk_ratio_delta": round(
+                    prepared["talk_ratio_user"] - baseline.get("avg_talk_ratio", 0.5), 3
+                )
+            }
+
+        return prepared
+
+    def _build_prompt(self, data: dict) -> str:
+        return f"""You are a behavioral communication analyst. Generate reflective, non-judgmental observations about conversational behavior patterns.
+
+STRICT RULES:
+1. Never diagnose or make personality claims
+2. Always use probabilistic language: "may suggest", "could indicate", "appeared to", "was observed"
+3. Never say things like "you are nervous", "you are dominant", "you lack confidence"
+4. Observations must be grounded in the specific signals provided
+5. Generate exactly 3 observations
+6. Output must be valid JSON only — no extra text, no markdown, no code fences
+
+SESSION DATA:
+{json.dumps(data, indent=2)}
+
+Output this exact JSON structure:
+{{
+  "summary_sentence": "One sentence describing the overall conversational pattern.",
+  "observations": [
+    {{
+      "signal": "talk_ratio",
+      "observation": "Behavioral observation in non-judgmental language.",
+      "resonance_prompt": "A gentle reflective question for the user."
+    }},
+    {{
+      "signal": "speech_rate",
+      "observation": "Behavioral observation in non-judgmental language.",
+      "resonance_prompt": "A gentle reflective question for the user."
+    }},
+    {{
+      "signal": "pauses",
+      "observation": "Behavioral observation in non-judgmental language.",
+      "resonance_prompt": "A gentle reflective question for the user."
+    }}
+  ],
+  "notable_pattern": "One sentence about the most notable pattern, or null.",
+  "data_confidence": "high"
+}}"""
+
+    def _parse_output(self, raw: str) -> dict:
+        try:
+            clean = raw.strip()
+            if "```" in clean:
+                clean = clean.split("```")[1]
+                if clean.startswith("json"):
+                    clean = clean[4:]
+            return json.loads(clean.strip())
+        except Exception:
+            return {
+                "summary_sentence": "Session analyzed successfully.",
+                "observations": [],
+                "notable_pattern": None,
+                "data_confidence": "low"
+            }

backend/pipeline/signal_extractor.py

@@ -0,0 +1,244 @@
+import librosa
+import numpy as np
+import re
+
+class SignalExtractor:
+
+    FILLER_WORDS = ["um", "uh", "like", "you know", "basically",
+                "literally", "actually", "so", "right", "i mean",
+                "matlab", "yaani", "bas", "toh", "na", "aur",
+                "waise", "dekh", "yaar", "arre", "haan"]
+
+    def __init__(self, audio_path: str, merged_segments: list, user_speaker_id: str):
+        self.audio_path = audio_path
+        self.segments = merged_segments
+        self.user_speaker = user_speaker_id
+        self.other_speaker = None
+
+        speakers = set(s["speaker"] for s in merged_segments if s["speaker"] != "UNKNOWN")
+        others = speakers - {user_speaker_id}
+        if others:
+            self.other_speaker = list(others)[0]
+
+        self.audio, self.sr = librosa.load(audio_path, sr=16000)
+
+    def extract_all(self) -> dict:
+        user_segs = [s for s in self.segments if s["speaker"] == self.user_speaker]
+        other_segs = [s for s in self.segments if s["speaker"] == self.other_speaker] if self.other_speaker else []
+
+        return {
+            "session_duration_s": self._get_session_duration(),
+            "talk_ratio": self._compute_talk_ratio(user_segs, other_segs),
+            "speech_rate": self._compute_speech_rate(user_segs),
+            "pauses": self._compute_pauses(user_segs, other_segs),
+            "interruptions": self._compute_interruptions(user_segs, other_segs),
+            "filler_words": self._compute_filler_words(user_segs),
+            "turn_dynamics": self._compute_turn_dynamics(user_segs, other_segs),
+            "pitch_features": self._compute_pitch_features(user_segs),
+            "engagement_proxy": self._compute_engagement_proxy(other_segs),
+            "timeline": self._build_timeline(user_segs)
+        }
+
+    def _get_session_duration(self) -> float:
+        if not self.segments:
+            return 0.0
+        return round(self.segments[-1]["end"], 2)
+
+    def _compute_talk_ratio(self, user_segs, other_segs) -> dict:
+        user_time = sum(s["end"] - s["start"] for s in user_segs)
+        other_time = sum(s["end"] - s["start"] for s in other_segs)
+        total = user_time + other_time
+
+        return {
+            "user_speaking_time_s": round(user_time, 2),
+            "other_speaking_time_s": round(other_time, 2),
+            "user_ratio": round(user_time / total, 3) if total > 0 else 0.5
+        }
+
+    def _compute_speech_rate(self, user_segs) -> dict:
+        if not user_segs:
+            return {"overall_wpm": 0, "segments": [], "variability": 0}
+
+        segment_rates = []
+        for seg in user_segs:
+            duration_min = (seg["end"] - seg["start"]) / 60
+            if duration_min < 0.05:
+                continue
+            words = seg.get("words", [])
+            wpm = round(len(words) / duration_min, 1) if duration_min > 0 else 0
+            segment_rates.append({
+                "start": seg["start"],
+                "end": seg["end"],
+                "wpm": wpm
+            })
+
+        all_words = sum(len(s.get("words", [])) for s in user_segs)
+        total_time_min = sum(s["end"] - s["start"] for s in user_segs) / 60
+
+        return {
+            "overall_wpm": round(all_words / total_time_min, 1) if total_time_min > 0 else 0,
+            "segments": segment_rates,
+            "variability": round(float(np.std([s["wpm"] for s in segment_rates])), 1) if segment_rates else 0
+        }
+
+    def _compute_pauses(self, user_segs, other_segs) -> dict:
+        within_turn_pauses = []
+        response_latencies = []
+
+        for seg in user_segs:
+            words = seg.get("words", [])
+            for i in range(1, len(words)):
+                gap = words[i].get("start", 0) - words[i-1].get("end", 0)
+                if 0.15 < gap < 3.0:
+                    within_turn_pauses.append(gap)
+
+        other_ends = [s["end"] for s in other_segs]
+        user_starts = [s["start"] for s in user_segs]
+
+        for u_start in user_starts:
+            preceding = [t for t in other_ends if t < u_start and u_start - t < 5.0]
+            if preceding:
+                latency = u_start - max(preceding)
+                if latency > 0.1:
+                    response_latencies.append(latency)
+
+        return {
+            "within_turn_pauses": {
+                "count": len(within_turn_pauses),
+                "mean_duration_s": round(float(np.mean(within_turn_pauses)), 3) if within_turn_pauses else 0,
+                "total_pause_time_s": round(sum(within_turn_pauses), 2)
+            },
+            "response_latency": {
+                "mean_s": round(float(np.mean(response_latencies)), 3) if response_latencies else 0,
+                "max_s": round(float(max(response_latencies)), 3) if response_latencies else 0
+            }
+        }
+
+    def _compute_interruptions(self, user_segs, other_segs) -> dict:
+        user_interrupts_other = 0
+        other_interrupts_user = 0
+
+        for u in user_segs:
+            for o in other_segs:
+                if o["start"] < u["start"] < o["end"]:
+                    if o["end"] - u["start"] > 0.3:
+                        user_interrupts_other += 1
+
+        for o in other_segs:
+            for u in user_segs:
+                if u["start"] < o["start"] < u["end"]:
+                    if u["end"] - o["start"] > 0.3:
+                        other_interrupts_user += 1
+
+        return {
+            "user_interrupted_other": user_interrupts_other,
+            "user_was_interrupted": other_interrupts_user
+        }
+
+    def _compute_filler_words(self, user_segs) -> dict:
+        all_text = " ".join(s.get("text", "").lower() for s in user_segs)
+        all_words_count = sum(len(s.get("words", [])) for s in user_segs)
+
+        filler_counts = {}
+        total_fillers = 0
+        for filler in self.FILLER_WORDS:
+            count = len(re.findall(r'\b' + filler + r'\b', all_text))
+            if count > 0:
+                filler_counts[filler] = count
+                total_fillers += count
+
+        return {
+            "total_count": total_fillers,
+            "rate_per_100_words": round((total_fillers / all_words_count * 100), 2) if all_words_count > 0 else 0,
+            "breakdown": filler_counts
+        }
+
+    def _compute_turn_dynamics(self, user_segs, other_segs) -> dict:
+        user_turn_lengths = [s["end"] - s["start"] for s in user_segs]
+        other_turn_lengths = [s["end"] - s["start"] for s in other_segs]
+
+        return {
+            "total_turns": len(user_segs) + len(other_segs),
+            "user_turns": len(user_segs),
+            "other_turns": len(other_segs),
+            "avg_user_turn_length_s": round(float(np.mean(user_turn_lengths)), 2) if user_turn_lengths else 0,
+            "avg_other_turn_length_s": round(float(np.mean(other_turn_lengths)), 2) if other_turn_lengths else 0
+        }
+
+    def _compute_pitch_features(self, user_segs) -> dict:
+        pitches = []
+
+        for seg in user_segs:
+            start_sample = int(seg["start"] * self.sr)
+            end_sample = int(seg["end"] * self.sr)
+            segment_audio = self.audio[start_sample:end_sample]
+
+            if len(segment_audio) < self.sr * 0.5:
+                continue
+
+            f0, voiced_flag, _ = librosa.pyin(
+                segment_audio,
+                fmin=librosa.note_to_hz('C2'),
+                fmax=librosa.note_to_hz('C7'),
+                sr=self.sr
+            )
+
+            voiced_f0 = f0[voiced_flag & ~np.isnan(f0)]
+            if len(voiced_f0) > 0:
+                pitches.extend(voiced_f0.tolist())
+
+        if not pitches:
+            return {"mean_hz": None, "std_hz": None, "range_hz": None}
+
+        return {
+            "mean_hz": round(float(np.mean(pitches)), 2),
+            "std_hz": round(float(np.std(pitches)), 2),
+            "range_hz": round(float(np.max(pitches) - np.min(pitches)), 2)
+        }
+
+    def _compute_engagement_proxy(self, other_segs) -> dict:
+        if len(other_segs) < 4:
+            return {"trend": "insufficient_data", "interpretation_note": "probabilistic proxy only"}
+
+        first_half = other_segs[:len(other_segs)//2]
+        second_half = other_segs[len(other_segs)//2:]
+
+        first_avg = float(np.mean([s["end"] - s["start"] for s in first_half]))
+        second_avg = float(np.mean([s["end"] - s["start"] for s in second_half]))
+
+        delta = (second_avg - first_avg) / first_avg if first_avg > 0 else 0
+
+        return {
+            "other_speaker_turn_length_trend": round(delta, 3),
+            "interpretation_note": "probabilistic proxy only"
+        }
+
+    def _build_timeline(self, user_segs) -> list:
+        if not self.segments:
+            return []
+
+        duration = self.segments[-1]["end"]
+        window_size = 60
+        windows = []
+
+        for window_start in range(0, int(duration), window_size):
+            window_end = window_start + window_size
+            window_segs = [s for s in user_segs
+                          if s["start"] >= window_start and s["end"] <= window_end]
+
+            if not window_segs:
+                continue
+
+            words_in_window = sum(len(s.get("words", [])) for s in window_segs)
+            speaking_time = sum(s["end"] - s["start"] for s in window_segs)
+            wpm = round(words_in_window / (speaking_time / 60), 1) if speaking_time > 0 else 0
+
+            windows.append({
+                "window_start_s": window_start,
+                "window_end_s": min(window_end, duration),
+                "speech_rate_wpm": wpm,
+                "speaking_time_s": round(speaking_time, 1),
+                "turn_count": len(window_segs)
+            })
+
+        return windows

backend/pipeline/transcriber.py

@@ -0,0 +1,109 @@
+import whisper
+import subprocess
+import os
+
+class Transcriber:
+    def __init__(self, model_size="base"):
+        print(f"Loading Whisper model: {model_size}")
+        self.model = whisper.load_model(model_size)
+        print("Whisper model loaded.")
+
+    def convert_to_wav(self, audio_path: str) -> str:
+        """Convert any audio format to WAV using ffmpeg."""
+        wav_path = audio_path.replace(".m4a", ".wav").replace(".mp3", ".wav").replace(".mp4", ".wav")
+        if wav_path == audio_path:
+            wav_path = audio_path + ".wav"
+
+        subprocess.run([
+            "ffmpeg", "-i", audio_path,
+            "-ar", "16000",
+            "-ac", "1",
+            "-y", wav_path
+        ], capture_output=True)
+
+        return wav_path
+
+    def transcribe(self, audio_path: str) -> dict:
+        print(f"Transcribing: {audio_path}")
+
+        # Convert to WAV if needed
+        if not audio_path.endswith(".wav"):
+            print("Converting to WAV...")
+            wav_path = self.convert_to_wav(audio_path)
+        else:
+            wav_path = audio_path
+
+        result = self.model.transcribe(
+            wav_path,
+            word_timestamps=True,
+            verbose=False
+        )
+
+        # Clean up converted file
+        if wav_path != audio_path and os.path.exists(wav_path):
+            os.remove(wav_path)
+
+        segments = []
+        for seg in result["segments"]:
+            words = []
+            for w in seg.get("words", []):
+                words.append({
+                    "word": w["word"].strip(),
+                    "start": round(w["start"], 3),
+                    "end": round(w["end"], 3),
+                    "score": round(w.get("probability", 0), 3)
+                })
+
+            segments.append({
+                "start": round(seg["start"], 3),
+                "end": round(seg["end"], 3),
+                "text": seg["text"].strip(),
+                "words": words
+            })
+
+        return {
+            "segments": segments,
+            "language": result.get("language", "en")
+        }
+
+
+
+# import whisper
+# import json
+
+# class Transcriber:
+#     def __init__(self, model_size="base"):
+#         print(f"Loading Whisper model: {model_size}")
+#         self.model = whisper.load_model(model_size)
+#         print("Whisper model loaded.")
+
+#     def transcribe(self, audio_path: str) -> dict:
+#         print(f"Transcribing: {audio_path}")
+#         result = self.model.transcribe(
+#             audio_path,
+#             word_timestamps=True,
+#             verbose=False
+#         )
+
+#         segments = []
+#         for seg in result["segments"]:
+#             words = []
+#             for w in seg.get("words", []):
+#                 words.append({
+#                     "word": w["word"].strip(),
+#                     "start": round(w["start"], 3),
+#                     "end": round(w["end"], 3),
+#                     "score": round(w.get("probability", 0), 3)
+#                 })
+
+#             segments.append({
+#                 "start": round(seg["start"], 3),
+#                 "end": round(seg["end"], 3),
+#                 "text": seg["text"].strip(),
+#                 "words": words
+#             })
+
+#         return {
+#             "segments": segments,
+#             "language": result.get("language", "en")
+#         }

backend/requirements.txt

@@ -0,0 +1,14 @@
+fastapi
+uvicorn
+python-multipart
+anthropic
+sqlalchemy
+pydantic
+python-dotenv
+pydub
+librosa
+numpy
+scipy
+openai-whisper
+pyannote.audio
+whisperx

backend/requirements_frozen.txt

@@ -0,0 +1,154 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.5
+aiosignal==1.4.0
+alembic==1.18.4
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anthropic==0.102.0
+antlr4-python3-runtime==4.9.3
+anyio==4.13.0
+asteroid-filterbanks==0.4.0
+async-timeout==5.0.1
+attrs==26.1.0
+audioread==3.1.0
+av==17.0.1
+certifi==2026.4.22
+cffi==2.0.0
+charset-normalizer==3.4.7
+click==8.3.3
+coloredlogs==15.0.1
+colorlog==6.10.1
+contourpy==1.3.2
+ctranslate2==4.7.1
+cycler==0.12.1
+decorator==5.2.1
+distro==1.9.0
+docstring_parser==0.18.0
+einops==0.8.2
+exceptiongroup==1.3.1
+fastapi==0.136.1
+faster-whisper==1.2.1
+filelock==3.29.0
+flatbuffers==25.12.19
+fonttools==4.63.0
+frozenlist==1.8.0
+fsspec==2026.4.0
+googleapis-common-protos==1.75.0
+groq==1.2.0
+grpcio==1.80.0
+h11==0.16.0
+hf-xet==1.5.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==0.36.2
+humanfriendly==10.0
+HyperPyYAML==1.2.3
+idna==3.15
+importlib_metadata==8.7.1
+Jinja2==3.1.6
+jiter==0.14.0
+joblib==1.5.3
+julius==0.2.7
+kiwisolver==1.5.0
+lazy-loader==0.5
+librosa==0.11.0
+lightning==2.6.1
+lightning-utilities==0.15.3
+llvmlite==0.47.0
+Mako==1.3.12
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+matplotlib==3.10.9
+mdurl==0.1.2
+more-itertools==11.0.2
+mpmath==1.3.0
+msgpack==1.1.2
+multidict==6.7.1
+networkx==3.4.2
+nltk==3.9.4
+numba==0.65.1
+numpy==1.26.4
+omegaconf==2.3.0
+onnxruntime==1.23.2
+openai-whisper==20250625
+opentelemetry-api==1.41.1
+opentelemetry-exporter-otlp==1.41.1
+opentelemetry-exporter-otlp-proto-common==1.41.1
+opentelemetry-exporter-otlp-proto-grpc==1.41.1
+opentelemetry-exporter-otlp-proto-http==1.41.1
+opentelemetry-proto==1.41.1
+opentelemetry-sdk==1.41.1
+opentelemetry-semantic-conventions==0.62b1
+optuna==4.8.0
+packaging==26.2
+pandas==2.3.3
+pillow==12.2.0
+platformdirs==4.9.6
+pooch==1.9.0
+primePy==1.3
+propcache==0.5.2
+protobuf==6.33.6
+pyannote-core==6.0.1
+pyannote-database==6.1.1
+pyannote-metrics==4.1
+pyannote-pipeline==4.0.0
+pyannote.audio==3.1.1
+pyannoteai-sdk==0.4.0
+pycparser==3.0
+pydantic==2.13.4
+pydantic_core==2.46.4
+pydub==0.25.1
+Pygments==2.20.0
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-multipart==0.0.28
+pytorch-lightning==2.6.1
+pytorch-metric-learning==2.9.0
+pytz==2026.2
+PyYAML==6.0.3
+regex==2026.5.9
+requests==2.34.2
+Resemblyzer==0.1.4
+rich==15.0.0
+ruamel.yaml==0.18.17
+ruamel.yaml.clib==0.2.15
+safetensors==0.7.0
+scikit-learn==1.7.2
+scipy==1.15.3
+semver==3.0.4
+sentencepiece==0.2.1
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+sortedcontainers==2.4.0
+soundfile==0.13.1
+soxr==1.1.0
+speechbrain==1.1.0
+SQLAlchemy==2.0.49
+starlette==1.0.0
+sympy==1.13.1
+tensorboardX==2.6.5
+threadpoolctl==3.6.0
+tiktoken==0.13.0
+tokenizers==0.22.2
+tomli==2.4.1
+torch==2.5.1
+torch-audiomentations==0.12.0
+torch_pitch_shift==1.2.5
+torchaudio==2.8.0
+torchcodec==0.7.0
+torchmetrics==1.9.0
+torchvision==0.23.0
+tqdm==4.67.3
+transformers==4.57.6
+typer==0.25.1
+typing==3.7.4.3
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2026.2
+urllib3==2.7.0
+uvicorn==0.47.0
+webrtcvad==2.0.10
+yarl==1.23.0
+zipp==3.23.1

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,21 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: { ecmaFeatures: { jsx: true } },
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "axios": "^1.16.1",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "recharts": "^3.8.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^10.3.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.6.0",
+    "vite": "^8.0.12"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,44 @@
+import { useState } from "react"
+import UploadView from "./components/UploadView"
+import ResultsView from "./components/ResultsView"
+import HistoryView from "./components/HistoryView"
+
+export default function App() {
+  const [view, setView] = useState("upload")
+  const [results, setResults] = useState(null)
+
+  return (
+    <div style={{ maxWidth: 780, margin: "0 auto", padding: 24, fontFamily: "system-ui" }}>
+      <div style={{ marginBottom: 28 }}>
+        <h1 style={{ fontSize: 22, fontWeight: 700, margin: 0 }}>🪞 Behavioral Mirror</h1>
+        <p style={{ color: "#666", marginTop: 4, fontSize: 14, margin: 0 }}>
+          Reflective insights from your conversations
+        </p>
+      </div>
+
+      <nav style={{ display: "flex", gap: 20, marginBottom: 32,
+        borderBottom: "1px solid #eee", paddingBottom: 12 }}>
+        {["upload", "history"].map(v => (
+          <button key={v} onClick={() => setView(v)}
+            style={{ background: "none", border: "none", cursor: "pointer",
+              fontWeight: view === v ? 600 : 400, fontSize: 14,
+              color: view === v ? "#111" : "#888",
+              borderBottom: view === v ? "2px solid #111" : "2px solid transparent",
+              paddingBottom: 4, textTransform: "capitalize" }}>
+            {v}
+          </button>
+        ))}
+      </nav>
+
+      {view === "upload" && (
+        <UploadView onResults={(r) => { setResults(r); setView("results") }} />
+      )}
+      {view === "results" && results && (
+        <ResultsView results={results} onBack={() => setView("upload")} />
+      )}
+      {view === "history" && (
+        <HistoryView onSelect={(r) => { setResults(r); setView("results") }} />
+      )}
+    </div>
+  )
+}

frontend/src/components/HistoryView.jsx

@@ -0,0 +1,90 @@
+import { useState, useEffect } from "react"
+import axios from "axios"
+
+export default function HistoryView({ onSelect }) {
+  const [sessions, setSessions] = useState([])
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    axios.get("http://localhost:8000/api/sessions/default_user")
+      .then(res => setSessions(res.data))
+      .catch(err => console.error(err))
+      .finally(() => setLoading(false))
+  }, [])
+
+  if (loading) return (
+    <div style={{ textAlign: "center", padding: 48, color: "#888" }}>
+      Loading sessions...
+    </div>
+  )
+
+  if (sessions.length === 0) return (
+    <div style={{ textAlign: "center", padding: 48 }}>
+      <div style={{ fontSize: 36, marginBottom: 12 }}>📭</div>
+      <p style={{ color: "#888", fontSize: 14 }}>No sessions yet.</p>
+      <p style={{ color: "#aaa", fontSize: 13 }}>
+        Upload your first conversation to get started.
+      </p>
+    </div>
+  )
+
+  return (
+    <div>
+      <p style={{ fontSize: 13, color: "#888", marginBottom: 16 }}>
+        {sessions.length} session{sessions.length > 1 ? "s" : ""} recorded
+      </p>
+
+      <div style={{ display: "flex", flexDirection: "column", gap: 10 }}>
+        {sessions.map(s => (
+          <div key={s.session_id}
+            onClick={() => onSelect({ signals: s.signals, insights: s.insights })}
+            style={{ border: "1px solid #eee", borderRadius: 10, padding: 16,
+              background: "white", cursor: "pointer",
+              transition: "border-color 0.2s" }}
+            onMouseEnter={e => e.currentTarget.style.borderColor = "#111"}
+            onMouseLeave={e => e.currentTarget.style.borderColor = "#eee"}>
+
+            <div style={{ display: "flex", justifyContent: "space-between",
+              alignItems: "center", marginBottom: 8 }}>
+              <span style={{ fontSize: 13, fontWeight: 600,
+                textTransform: "capitalize", color: "#333" }}>
+                {s.context.replace(/_/g, " ")}
+              </span>
+              <span style={{ fontSize: 11, color: "#aaa" }}>
+                {new Date(s.created_at).toLocaleDateString("en-IN", {
+                  day: "numeric", month: "short", year: "numeric"
+                })}
+              </span>
+            </div>
+
+            <p style={{ margin: "0 0 10px", fontSize: 13,
+              color: "#555", lineHeight: 1.5 }}>
+              {s.insights.summary_sentence}
+            </p>
+
+            <div style={{ display: "flex", gap: 16 }}>
+              {[
+                { label: "Talk ratio", value: `${Math.round(s.signals.talk_ratio.user_ratio * 100)}%` },
+                { label: "Speech rate", value: `${s.signals.speech_rate.overall_wpm} wpm` },
+                { label: "Duration", value: `${Math.round(s.signals.session_duration_s / 60)}m` },
+              ].map(({ label, value }) => (
+                <div key={label}>
+                  <span style={{ fontSize: 11, color: "#aaa" }}>{label}: </span>
+                  <span style={{ fontSize: 11, fontWeight: 600, color: "#555" }}>{value}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        ))}
+      </div>
+
+      {sessions.length >= 3 && (
+        <div style={{ marginTop: 20, padding: 14, background: "#f0fdf4",
+          border: "1px solid #86efac", borderRadius: 10, fontSize: 13, color: "#166534" }}>
+          ✨ You have {sessions.length} sessions — baseline comparisons are now active.
+          Future insights will compare against your personal patterns.
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/components/ResultsView.jsx

@@ -0,0 +1,173 @@
+import { useState } from "react"
+import { LineChart, Line, XAxis, YAxis, Tooltip, ResponsiveContainer } from "recharts"
+
+export default function ResultsView({ results, onBack }) {
+  const { signals, insights } = results
+
+  const formatTime = (s) => {
+    const m = Math.floor(s / 60)
+    const sec = Math.round(s % 60)
+    return `${m}:${sec.toString().padStart(2, "0")}`
+  }
+
+  const talkPct = Math.round(signals.talk_ratio.user_ratio * 100)
+  const duration = Math.round(signals.session_duration_s / 60)
+
+  return (
+    <div>
+      <button onClick={onBack}
+        style={{ background: "none", border: "none", cursor: "pointer",
+          color: "#666", fontSize: 13, marginBottom: 20, padding: 0 }}>
+        ← Back
+      </button>
+
+      {/* Summary */}
+      <div style={{ background: "#f8f9fa", borderRadius: 12,
+        padding: 20, marginBottom: 24, borderLeft: "4px solid #111" }}>
+        <p style={{ fontSize: 15, lineHeight: 1.7, margin: 0, color: "#333" }}>
+          {insights.summary_sentence}
+        </p>
+      </div>
+
+      {/* Key metrics */}
+      <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr 1fr 1fr",
+        gap: 10, marginBottom: 28 }}>
+        {[
+          { label: "Duration", value: `${duration}m`, sub: "total" },
+          { label: "You spoke", value: `${talkPct}%`, sub: "of the time" },
+          { label: "Speech rate", value: `${signals.speech_rate.overall_wpm}`, sub: "words/min" },
+          { label: "Filler words", value: `${signals.filler_words.rate_per_100_words}`, sub: "per 100 words" },
+        ].map(({ label, value, sub }) => (
+          <div key={label} style={{ textAlign: "center", padding: "14px 8px",
+            border: "1px solid #eee", borderRadius: 10, background: "white" }}>
+            <div style={{ fontSize: 11, color: "#888", marginBottom: 4 }}>{label}</div>
+            <div style={{ fontSize: 22, fontWeight: 700 }}>{value}</div>
+            <div style={{ fontSize: 11, color: "#888" }}>{sub}</div>
+          </div>
+        ))}
+      </div>
+
+      {/* Speech rate timeline */}
+      {signals.timeline?.length > 1 && (
+        <div style={{ marginBottom: 28 }}>
+          <h3 style={{ fontSize: 14, fontWeight: 600, marginBottom: 12, color: "#333" }}>
+            Speech Rate Over Time
+          </h3>
+          <div style={{ background: "white", border: "1px solid #eee",
+            borderRadius: 10, padding: 16 }}>
+            <ResponsiveContainer width="100%" height={150}>
+              <LineChart data={signals.timeline}>
+                <XAxis dataKey="window_start_s"
+                  tickFormatter={formatTime} fontSize={11} />
+                <YAxis domain={["auto", "auto"]} fontSize={11} width={35} />
+                <Tooltip
+                  labelFormatter={v => `At ${formatTime(v)}`}
+                  formatter={v => [`${Math.round(v)} wpm`, "Speech rate"]} />
+                <Line type="monotone" dataKey="speech_rate_wpm"
+                  stroke="#111" strokeWidth={2} dot={false} />
+              </LineChart>
+            </ResponsiveContainer>
+          </div>
+        </div>
+      )}
+
+      {/* Interruptions & turns */}
+      <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr",
+        gap: 10, marginBottom: 28 }}>
+        <div style={{ padding: 16, border: "1px solid #eee",
+          borderRadius: 10, background: "white" }}>
+          <div style={{ fontSize: 12, color: "#888", marginBottom: 8 }}>Interruptions</div>
+          <div style={{ fontSize: 13 }}>
+            You interrupted: <strong>{signals.interruptions.user_interrupted_other}x</strong>
+          </div>
+          <div style={{ fontSize: 13, marginTop: 4 }}>
+            You were interrupted: <strong>{signals.interruptions.user_was_interrupted}x</strong>
+          </div>
+        </div>
+        <div style={{ padding: 16, border: "1px solid #eee",
+          borderRadius: 10, background: "white" }}>
+          <div style={{ fontSize: 12, color: "#888", marginBottom: 8 }}>Turn Dynamics</div>
+          <div style={{ fontSize: 13 }}>
+            Your turns: <strong>{signals.turn_dynamics.user_turns}</strong>
+          </div>
+          <div style={{ fontSize: 13, marginTop: 4 }}>
+            Avg length: <strong>{signals.turn_dynamics.avg_user_turn_length_s}s</strong>
+          </div>
+        </div>
+      </div>
+
+      {/* Observations */}
+      <h3 style={{ fontSize: 14, fontWeight: 600, marginBottom: 12 }}>
+        Behavioral Observations
+      </h3>
+      <div style={{ display: "flex", flexDirection: "column", gap: 12, marginBottom: 24 }}>
+        {insights.observations?.map((obs, i) => (
+          <ObservationCard key={i} obs={obs} />
+        ))}
+      </div>
+
+      {/* Notable pattern */}
+      {insights.notable_pattern && (
+        <div style={{ background: "#fffbeb", border: "1px solid #fde68a",
+          borderRadius: 10, padding: 16, marginBottom: 24 }}>
+          <div style={{ fontSize: 12, fontWeight: 600, color: "#92400e", marginBottom: 4 }}>
+            Notable Pattern
+          </div>
+          <p style={{ margin: 0, fontSize: 14, color: "#78350f" }}>
+            {insights.notable_pattern}
+          </p>
+        </div>
+      )}
+
+      {/* Disclaimer */}
+      <div style={{ fontSize: 11, color: "#999", padding: 14,
+        background: "#fafafa", borderRadius: 8, lineHeight: 1.7 }}>
+        <strong>Note:</strong> These observations are probabilistic patterns from audio signals,
+        not validated psychological assessments. Use them as prompts for self-reflection only.
+      </div>
+    </div>
+  )
+}
+
+function ObservationCard({ obs }) {
+  const [resonance, setResonance] = useState(null)
+
+  return (
+    <div style={{ border: "1px solid #eee", borderRadius: 10,
+      padding: 16, background: "white" }}>
+      <div style={{ fontSize: 11, color: "#888", fontWeight: 600,
+        textTransform: "uppercase", letterSpacing: 0.5, marginBottom: 8 }}>
+        {obs.signal.replace(/_/g, " ")}
+      </div>
+      <p style={{ margin: "0 0 10px", fontSize: 14, lineHeight: 1.6, color: "#222" }}>
+        {obs.observation}
+      </p>
+      <p style={{ margin: "0 0 14px", fontSize: 13, color: "#555",
+        fontStyle: "italic", lineHeight: 1.5 }}>
+        💭 {obs.resonance_prompt}
+      </p>
+
+      {resonance === null ? (
+        <div>
+          <div style={{ fontSize: 12, color: "#666", marginBottom: 8 }}>
+            Does this resonate?
+          </div>
+          <div style={{ display: "flex", gap: 8 }}>
+            {["Yes", "Somewhat", "No"].map(label => (
+              <button key={label} onClick={() => setResonance(label)}
+                style={{ padding: "5px 14px", border: "1px solid #ddd",
+                  borderRadius: 20, background: "white", cursor: "pointer",
+                  fontSize: 12, color: "#333" }}>
+                {label}
+              </button>
+            ))}
+          </div>
+        </div>
+      ) : (
+        <div style={{ fontSize: 12, color: "#888" }}>
+          ✓ Noted — thanks for the feedback.
+        </div>
+      )}
+    </div>
+  )
+}

frontend/src/components/UploadView.jsx

@@ -0,0 +1,159 @@
+import { useState } from "react"
+import axios from "axios"
+
+const CONTEXTS = [
+  { value: "casual", label: "Casual Conversation" },
+  { value: "job_interview", label: "Job Interview" },
+  { value: "disagreement", label: "Disagreement / Conflict" },
+  { value: "presentation", label: "Presentation / Pitch" },
+  { value: "meeting", label: "Meeting" },
+]
+
+const STAGES = [
+  "Transcribing audio...",
+  "Identifying speakers...",
+  "Extracting behavioral signals...",
+  "Generating reflective insights..."
+]
+
+export default function UploadView({ onResults }) {
+  const [file, setFile] = useState(null)
+  const [context, setContext] = useState("casual")
+  const [numSpeakers, setNumSpeakers] = useState(2)
+  const [loading, setLoading] = useState(false)
+  const [stageIndex, setStageIndex] = useState(0)
+  const [error, setError] = useState("")
+
+  const handleSubmit = async () => {
+    if (!file) return
+    setLoading(true)
+    setError("")
+    setStageIndex(0)
+
+    const interval = setInterval(() => {
+      setStageIndex(prev => Math.min(prev + 1, STAGES.length - 1))
+    }, 15000)
+
+    try {
+      const form = new FormData()
+      form.append("audio", file)
+      form.append("context", context)
+      form.append("num_speakers", numSpeakers)
+      form.append("user_id", "default_user")
+
+      const { data } = await axios.post(
+        "http://localhost:8000/api/analyze",
+        form,
+        { headers: { "Content-Type": "multipart/form-data" }, timeout: 300000 }
+      )
+
+      clearInterval(interval)
+      onResults(data)
+    } catch (e) {
+      clearInterval(interval)
+      setError(e.response?.data?.detail || "Something went wrong. Check the backend terminal.")
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  if (loading) return (
+    <div style={{ textAlign: "center", padding: 64 }}>
+      <div style={{ fontSize: 40, marginBottom: 16 }}>⏳</div>
+      <p style={{ fontWeight: 500, fontSize: 16 }}>{STAGES[stageIndex]}</p>
+      <p style={{ fontSize: 13, color: "#999", marginTop: 8 }}>
+        This takes 1–3 minutes depending on audio length
+      </p>
+      <div style={{ marginTop: 24, background: "#f0f0f0", borderRadius: 8,
+        height: 4, overflow: "hidden" }}>
+        <div style={{ background: "#111", height: "100%", borderRadius: 8,
+          width: `${((stageIndex + 1) / STAGES.length) * 100}%`,
+          transition: "width 0.5s ease" }} />
+      </div>
+    </div>
+  )
+
+  return (
+    <div>
+      {/* File upload area */}
+      <div
+        onClick={() => document.getElementById("file-input").click()}
+        style={{ border: "2px dashed #ddd", borderRadius: 12, padding: 40,
+          textAlign: "center", marginBottom: 20, cursor: "pointer",
+          background: file ? "#f0fdf4" : "#fafafa",
+          borderColor: file ? "#86efac" : "#ddd",
+          transition: "all 0.2s" }}>
+        <input id="file-input" type="file" accept="*/*"
+          style={{ display: "none" }}
+          onChange={e => setFile(e.target.files[0])} />
+        {file ? (
+          <>
+            <div style={{ fontSize: 32 }}>✅</div>
+            <p style={{ fontWeight: 600, marginTop: 8 }}>{file.name}</p>
+            <p style={{ fontSize: 12, color: "#666" }}>
+              {(file.size / 1024 / 1024).toFixed(1)} MB · Click to change
+            </p>
+          </>
+        ) : (
+          <>
+            <div style={{ fontSize: 36 }}>🎙️</div>
+            <p style={{ fontWeight: 500, marginTop: 8 }}>Upload audio or video</p>
+            <p style={{ fontSize: 12, color: "#999" }}>MP3, WAV, MP4, M4A · Max 100MB</p>
+          </>
+        )}
+      </div>
+
+      {/* Context selector */}
+      <div style={{ marginBottom: 14 }}>
+        <label style={{ display: "block", fontSize: 13,
+          fontWeight: 500, marginBottom: 6, color: "#333" }}>
+          What kind of conversation was this?
+        </label>
+        <select value={context} onChange={e => setContext(e.target.value)}
+          style={{ width: "100%", padding: "10px 12px", borderRadius: 8,
+            border: "1px solid #ddd", fontSize: 14, background: "white" }}>
+          {CONTEXTS.map(c => (
+            <option key={c.value} value={c.value}>{c.label}</option>
+          ))}
+        </select>
+      </div>
+
+      {/* Speakers selector */}
+      <div style={{ marginBottom: 24 }}>
+        <label style={{ display: "block", fontSize: 13,
+          fontWeight: 500, marginBottom: 6, color: "#333" }}>
+          Number of speakers
+        </label>
+        <select value={numSpeakers} onChange={e => setNumSpeakers(Number(e.target.value))}
+          style={{ width: "100%", padding: "10px 12px", borderRadius: 8,
+            border: "1px solid #ddd", fontSize: 14, background: "white" }}>
+          <option value={2}>2 speakers</option>
+          <option value={3}>3 speakers</option>
+          <option value={4}>4 speakers</option>
+        </select>
+      </div>
+
+      {/* Error */}
+      {error && (
+        <div style={{ background: "#fef2f2", border: "1px solid #fca5a5",
+          borderRadius: 8, padding: 12, marginBottom: 16,
+          fontSize: 13, color: "#991b1b" }}>
+          ⚠️ {error}
+        </div>
+      )}
+
+      {/* Submit */}
+      <button onClick={handleSubmit} disabled={!file}
+        style={{ width: "100%", padding: "13px 24px",
+          background: file ? "#111" : "#ccc", color: "white",
+          border: "none", borderRadius: 8, fontSize: 15,
+          cursor: file ? "pointer" : "not-allowed", fontWeight: 500 }}>
+        Analyze Conversation
+      </button>
+
+      <p style={{ fontSize: 11, color: "#999", textAlign: "center", marginTop: 10 }}>
+        🔒 Audio is deleted immediately after analysis. Only behavioral signals are stored.
+      </p>
+    </div>
+  )
+}

frontend/src/index.css

@@ -0,0 +1,125 @@
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  background: #f5f5f5;
+  color: #111;
+  -webkit-font-smoothing: antialiased;
+}
+
+
+
+/* :root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 1126px;
+  max-width: 100%;
+  margin: 0 auto;
+  text-align: center;
+  border-inline: 1px solid var(--border);
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+} */

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})