Codex/login trim username

.env.template

@@ -146,6 +146,17 @@ ESTIMATE_TIME_FOR_QUEUE_RUNS="false"
 LLM_SERVICE_API_URL="http://127.0.0.1:7001"
 LLM_SERVICE_API_KEY="<api key>"
 LLM_SERVICE_API_VER="" # can be empty or v1
+OPENAI_API_KEY=""
+
+####################################################################################################
+# AI DASHBOARD CHAT VECTOR STORE
+####################################################################################################
+
+AI_DASHBOARD_CHAT_CHROMA_COLLECTION_PREFIX=org_
+AI_DASHBOARD_CHAT_CHROMA_EMBEDDING_MODEL=text-embedding-3-small
+AI_DASHBOARD_CHAT_CHROMA_HOST=localhost
+AI_DASHBOARD_CHAT_CHROMA_PORT=8003
+AI_DASHBOARD_CHAT_CHROMA_SSL=False
 
 ####################################################################################################
 # MONITORING & LOGGING
@@ -183,4 +194,4 @@ LOGS_MOUNT=
 
 SCHEMA_CHANGE_DETECTION_INTER_ORG_DELAY=60
 SCHEMA_CHANGE_DETECTION_SCHEDULE_HOUR=18
-SCHEMA_CHANGE_DETECTION_SCHEDULE_MINUTE=30
+SCHEMA_CHANGE_DETECTION_SCHEDULE_MINUTE=30

Docker/docker-compose.dev.yml

@@ -102,6 +102,15 @@ services:
   celery_worker:
     image: dalgo_backend:0.1
     command: celery
+    depends_on:
+      backend:
+        condition: service_started
+      redis_server:
+        condition: service_started
+      initdb:
+        condition: service_completed_successfully
+    networks:
+      - dalgo-network
     environment:
       - REDIS_HOST=${REDIS_HOST}
       - REDIS_PORT=${REDIS_PORT}
@@ -112,15 +121,6 @@ services:
       - DBPASSWORD=${DBPASSWORD}
       - DBADMINUSER=${DBADMINUSER}
       - DBADMINPASSWORD=${DBADMINPASSWORD}
-    depends_on:
-      backend:
-        condition: service_started
-      redis_server:
-        condition: service_started
-      initdb:
-        condition: service_completed_successfully
-    networks:
-      - dalgo-network
   celery_beat:
     image: dalgo_backend:0.1
     command: beat
@@ -165,4 +165,4 @@ volumes:
 
 networks:
   dalgo-network:
-    driver: bridge
+    driver: bridge

Docker/docker-compose.yml

@@ -8,6 +8,7 @@ services:
       - redis_data:/data
     networks:
       - dalgo-network 
+
   backend:
     image: dalgo_backend:latest
     command: backend

README.md

@@ -139,7 +139,25 @@ PREFECT_PROXY_API_URL=
 ### Step 6: Create secrets directory
 -   Set `DEV_SECRETS_DIR` in `.env` unless you want to use Amazon's Secrets Manager
 
-### Step 7: Install DBT
+### Step 7: Install Chroma for dashboard chat
+
+Dashboard chat retrieval uses a local Chroma server in development. One simple way to run it is:
+
+```bash
+docker run --rm \
+  -p 8003:8000 \
+  -v "$PWD/.local/chroma-data:/data" \
+  chromadb/chroma:0.5.23
+```
+
+Then point the backend env to it:
+
+```bash
+AI_DASHBOARD_CHAT_CHROMA_HOST=localhost
+AI_DASHBOARD_CHAT_CHROMA_PORT=8003
+```
+
+### Step 8: Install DBT
 
 The platform now supports multiple DBT versions using `uv` and `pyproject.toml` for better dependency management.
 
@@ -178,11 +196,11 @@ $DBT_VENV/
 
 Organizations use either `venv` or `venv-1.9.8` in their `dbt_venv` database field.
 
-### Step 8: Add SIGNUPCODE and FRONTEND_URL
+### Step 9: Add SIGNUPCODE and FRONTEND_URL
 
 -   The `SIGNUPCODE` in `.env` is for signing up using the frontend. If you are running the frontend, set its URL in `FRONTEND_URL`
 
-### Step 9: Start Backend
+### Step 10: Start Backend
 
 ```
 DJANGOSECRET=
@@ -199,11 +217,11 @@ DJANGOSECRET=
 
 -   Start the server `uvicorn ddpui.asgi:application --port <PORT_TO_LISTEN_ON>`
 
-### Step 10: Create first org and user
+### Step 11: Create first org and user
 -   Run `python manage.py createorganduser <Org Name> <Email address> --role super-admin`
 -   The above command creates a user with super admin role. If we don't provide any role, the default role is of account manager.
 
-### Step11: Running celery
+### Step 12: Running celery
 
 We use two separate Celery workers for better task isolation:
 

ddpui/api/dashboard_native_api.py

@@ -16,9 +16,16 @@
     DashboardLock,
     DashboardFilterType,
 )
+from ddpui.models.dashboard_chat import (
+    DashboardAIContext,
+    DashboardChatMessage,
+    DashboardChatMessageRole,
+)
+from ddpui.models.org_preferences import OrgPreferences
 from ddpui.models.org_user import OrgUser
 from ddpui.auth import has_permission
 from ddpui.utils.custom_logger import CustomLogger
+from ddpui.utils.feature_flags import get_all_feature_flags_for_org
 from ddpui.services.dashboard_service import (
     DashboardService,
     DashboardData,
@@ -35,6 +42,7 @@
     DashboardCreate,
     DashboardUpdate,
     DashboardResponse,
+    DashboardExportResponse,
     DashboardFilterResponse,
     FilterCreate,
     FilterUpdate,
@@ -46,13 +54,60 @@
     DashboardShareStatus,
     LandingPageResponse,
     LandingPageResolveResponse,
+    DashboardAIContextResponse,
+    DashboardChatBootstrapResponse,
+    DashboardChatMessageFeedbackRequest,
+    DashboardChatMessageFeedbackResponse,
+    UpdateDashboardAIContextSchema,
 )
+from ddpui.core.dashboard_chat.suggested_prompts import build_dashboard_suggested_prompts
 
 logger = CustomLogger("ddpui")
 
 dashboard_native_router = Router()
 
 
+def _get_or_create_dashboard_ai_context(dashboard: Dashboard):
+    context, _ = DashboardAIContext.objects.get_or_create(dashboard=dashboard)
+    return context
+
+
+def _serialize_dashboard_ai_context(dashboard: Dashboard, context: DashboardAIContext):
+    org_dbt = dashboard.org.dbt
+    return DashboardAIContextResponse(
+        dashboard_id=dashboard.id,
+        dashboard_title=dashboard.title,
+        dashboard_context_markdown=context.markdown,
+        dashboard_context_updated_by=context.updated_by.user.email if context.updated_by else None,
+        dashboard_context_updated_at=context.updated_at,
+        ai_context_refreshed_at=org_dbt.vector_last_ingested_at if org_dbt else None,
+    )
+
+
+def _serialize_dashboard_chat_bootstrap(dashboard: Dashboard) -> DashboardChatBootstrapResponse:
+    dashboard_export = DashboardService.export_dashboard_context_for_dashboard(dashboard, dashboard.org)
+
+    return DashboardChatBootstrapResponse(
+        dashboard_id=dashboard.id,
+        suggested_prompts=build_dashboard_suggested_prompts(
+            dashboard_export=dashboard_export,
+        ),
+    )
+
+
+def _ensure_dashboard_chat_feature_enabled(org) -> None:
+    """Hide dashboard chat settings endpoints unless the feature flag is enabled."""
+    if not get_all_feature_flags_for_org(org).get("AI_DASHBOARD_CHAT", False):
+        raise HttpError(404, "Chat with dashboards is not enabled for this organization")
+
+
+def _ensure_dashboard_chat_consent_enabled(org) -> None:
+    """Require consent before writing dashboard-specific AI context."""
+    org_preferences = OrgPreferences.objects.filter(org=org).first()
+    if org_preferences is None or not org_preferences.ai_data_sharing_enabled:
+        raise HttpError(409, "Enable AI data sharing before updating dashboard AI context")
+
+
 # Endpoints
 @dashboard_native_router.get("/", response=List[DashboardResponse])
 @has_permission(["can_view_dashboards"])
@@ -89,6 +144,133 @@ def get_dashboard(request, dashboard_id: int):
     return DashboardResponse(**DashboardService.get_dashboard_response(dashboard))
 
 
+@dashboard_native_router.get("/{dashboard_id}/export/", response=DashboardExportResponse)
+@has_permission(["can_view_dashboards"])
+def export_dashboard(request, dashboard_id: int):
+    """Export dashboard JSON along with the chart configs it references."""
+    orguser: OrgUser = request.orguser
+
+    try:
+        return DashboardService.export_dashboard_context(dashboard_id, orguser.org)
+    except DashboardNotFoundError as err:
+        raise HttpError(404, "Dashboard not found") from err
+
+
+@dashboard_native_router.get(
+    "/{dashboard_id}/ai-context/",
+    response=DashboardAIContextResponse,
+)
+@has_permission(["can_manage_org_settings"])
+def get_dashboard_ai_context(request, dashboard_id: int):
+    """Load dashboard-level AI context settings for settings management."""
+    orguser: OrgUser = request.orguser
+    _ensure_dashboard_chat_feature_enabled(orguser.org)
+
+    try:
+        dashboard = DashboardService.get_dashboard(dashboard_id, orguser.org)
+    except DashboardNotFoundError as err:
+        raise HttpError(404, "Dashboard not found") from err
+
+    context = _get_or_create_dashboard_ai_context(dashboard)
+
+    return _serialize_dashboard_ai_context(dashboard, context)
+
+
+@dashboard_native_router.get(
+    "/{dashboard_id}/chat-bootstrap/",
+    response=DashboardChatBootstrapResponse,
+)
+@has_permission(["can_view_dashboards"])
+def get_dashboard_chat_bootstrap(request, dashboard_id: int):
+    """Return deterministic UI bootstrap data for dashboard chat."""
+    orguser: OrgUser = request.orguser
+    _ensure_dashboard_chat_feature_enabled(orguser.org)
+
+    try:
+        dashboard = DashboardService.get_dashboard(dashboard_id, orguser.org)
+    except DashboardNotFoundError as err:
+        raise HttpError(404, "Dashboard not found") from err
+
+    return _serialize_dashboard_chat_bootstrap(dashboard)
+
+
+@dashboard_native_router.post(
+    "/{dashboard_id}/chat/messages/{message_id}/feedback/",
+    response=DashboardChatMessageFeedbackResponse,
+)
+@has_permission(["can_view_dashboards"])
+@transaction.atomic
+def set_dashboard_chat_message_feedback(
+    request,
+    dashboard_id: int,
+    message_id: int,
+    payload: DashboardChatMessageFeedbackRequest,
+):
+    """Persist one locked thumbs-up/thumbs-down selection for an assistant answer."""
+    orguser: OrgUser = request.orguser
+    _ensure_dashboard_chat_feature_enabled(orguser.org)
+
+    message = (
+        DashboardChatMessage.objects.select_related("session")
+        .filter(
+            id=message_id,
+            session__org=orguser.org,
+            session__orguser=orguser,
+            session__dashboard_id=dashboard_id,
+            role=DashboardChatMessageRole.ASSISTANT.value,
+        )
+        .first()
+    )
+    if message is None:
+        raise HttpError(404, "Assistant message not found")
+
+    if message.feedback is not None:
+        if message.feedback == payload.feedback:
+            return DashboardChatMessageFeedbackResponse(
+                message_id=message.id,
+                feedback=message.feedback,
+            )
+        raise HttpError(409, "Feedback has already been recorded for this message")
+
+    message.feedback = payload.feedback
+    message.save(update_fields=["feedback"])
+
+    return DashboardChatMessageFeedbackResponse(
+        message_id=message.id,
+        feedback=message.feedback,
+    )
+
+
+@dashboard_native_router.put(
+    "/{dashboard_id}/ai-context/",
+    response=DashboardAIContextResponse,
+)
+@has_permission(["can_manage_org_settings"])
+@transaction.atomic
+def update_dashboard_ai_context(
+    request,
+    dashboard_id: int,
+    payload: UpdateDashboardAIContextSchema,
+):
+    """Update dashboard-level AI context markdown for settings management."""
+    orguser: OrgUser = request.orguser
+    _ensure_dashboard_chat_feature_enabled(orguser.org)
+    _ensure_dashboard_chat_consent_enabled(orguser.org)
+
+    try:
+        dashboard = DashboardService.get_dashboard(dashboard_id, orguser.org)
+    except DashboardNotFoundError as err:
+        raise HttpError(404, "Dashboard not found") from err
+
+    context = _get_or_create_dashboard_ai_context(dashboard)
+    context.markdown = payload.dashboard_context_markdown
+    context.updated_by = orguser
+    context.updated_at = timezone.now()
+    context.save()
+
+    return _serialize_dashboard_ai_context(dashboard, context)
+
+
 @dashboard_native_router.post("/", response=DashboardResponse)
 @has_permission(["can_create_dashboards"])
 def create_dashboard(request, payload: DashboardCreate):