Databricks App Templates

The Agentic Support Console is an end-to-end AI-powered support application built on the Databricks platform. It demonstrates a complete data lifecycle including:

• OLTP: Lakebase (Postgres) for operational data.
• CDC: Lakehouse Sync to move data from Lakebase to the Lakehouse.
• Medallion Architecture: Lakeflow Declarative Pipelines moving data from Bronze (history) to Silver (current state) to Gold (analytics/context).
• AI Agent: A Lakeflow Job that calls an LLM via AI Gateway, writing responses back to Delta tables.
• Reverse Sync: Syncing Gold Delta tables back to Lakebase via Sync Tables.
• Frontend: A Databricks App using AppKit (Express + React 19) with Genie analytics integration.

The Advanced Responses API Agent is a stateful conversational agent template designed for Databricks Apps. It implements the OpenAI Responses API interface, making it compatible with the OpenAI Python SDK.

Key capabilities include:

• Stateful Sessions: Uses Databricks Lakebase to provide short-term memory (conversation history) via AsyncDatabricksSession.
• Long-Running Background Execution: Decouples agent execution from HTTP connection limits (which are ~120s on Databricks Apps) using a background=true flag. This allows for tasks lasting up to 1 hour by default.
• Resumable Streaming: Supports cursor-based resumption using starting_after=N to allow clients to reconnect and skip already-received events.
• API Access: While it includes a built-in chat UI, it exposes an API endpoint for integration into external websites or mobile apps.

The Databricks Agent Chat Template is a full-stack chat application designed to interact with Databricks Agent serving endpoints and Agent Bricks. It is built using ExpressJS, React, and the Vercel AI SDK.

Key capabilities include:

• Databricks Integration: Direct connection to agent serving endpoints.
• Authentication: Uses Databricks authentication to identify users and secure conversations.
• Persistent History (Optional): Uses Databricks Lakebase (Postgres) to store and retrieve chat history.
• User Feedback (Optional): Collects thumbs up/down feedback, which is stored as MLflow assessments on underlying traces.

The appkit-all-in-one template is a Databricks App powered by AppKit. It provides a full-stack foundation using React, TypeScript, and Tailwind CSS.

It comes with several enabled plugins:

• Analytics: Executes SQL queries against Databricks SQL Warehouses.
• Lakebase: Provides a fully managed Postgres database for transactional (OLTP) workloads on Databricks.
• Genie: Integrates the AI/BI Genie conversational interface for natural language data queries.
• Server: An Express HTTP server that handles static file serving and Vite dev mode.

Inventory Intelligence is an end-to-end retail inventory management application built on Databricks. It utilizes a multi-layered architecture to manage data from an OLTP source to a consumer-facing app:

1. OLTP (Lakebase Postgres): The source of truth for retail data.
2. Lakehouse Sync (CDC): Replicates data from Lakebase to the Bronze layer in Unity Catalog.
3. Lakeflow Declarative Pipelines: Processes Bronze data into Silver (SCD Type 1) and Gold (aggregated/business-ready) layers.
4. Lakeflow Jobs: A pluggable demand forecast model that populates replenishment recommendations.
5. Sync Tables (Reverse ETL): Syncs Gold layer Delta tables back to Lakebase for application use.
6. Databricks App: A user interface (built with AppKit) providing Dashboards, Stores, Replenishment, and Genie analytics.

The deployment process uses a mix of Databricks Asset Bundles (DAB) and direct CLI commands depending on the resource type:

The agent supports two types of memory to maintain context and user preferences:

Short-term Memory (Conversation History)

Uses AsyncCheckpointSaver to preserve history within a single session. To maintain context across multiple requests in the same conversation, pass a thread_id in the custom_inputs field.

Long-term Memory (User Facts)

Uses AsyncDatabricksStore to persist information across different sessions. The agent provides three tools: get_user_memory, save_user_memory, and delete_user_memory. To scope these memories to a specific user, pass a user_id in custom_inputs. If user_id is omitted, memory tools are disabled.

{
  "input": [{ "role": "user", "content": "Remember I prefer Python" }],
  "custom_inputs": { "thread_id": "<thread-id>", "user_id": "alice@example.com" }
}

The project is organized into client, server, and shared directories:

• client/: React frontend (contains src/ and public/)
• server/: Express backend (contains server.ts and routes/)
• shared/: Shared TypeScript types used by both client and server
• databricks.yml: Databricks Asset Bundle configuration
• app.yaml: App configuration
• .env.example: Template for environment variables

To bypass the ~120s HTTP timeout enforced by Databricks Apps, this template uses the background=true flag to run agent tasks asynchronously.

Workflow:

1. Initiation: A POST request with background=true returns a response_id immediately.
2. Execution: The agent runs in the background, managed by LongRunningAgentServer (from databricks-ai-bridge).
3. Retrieval/Polling: Clients can poll for results or stream them using the GET /responses/{id} endpoint.
4. Resumption: If a connection is lost, clients can use the starting_after=N parameter to resume streaming from a specific cursor.
5. Persistence: Stream events are persisted to Lakebase PostgreSQL to support this resumption.

The project is organized into a client-server architecture:

• client/: React frontend (source in src/, static assets in public/).
• server/: Express backend (entry point at server.ts, routes in routes/).
• shared/: Shared TypeScript types used by both client and server.
• config/: Configuration files, including SQL queries in queries/.
• databricks.yml: Databricks Asset Bundle configuration.
• app.yaml: Application configuration.
• .env.example: Template for environment variables.

The application operates in two modes based on the presence of database environment variables.

Persistent Mode

Requirement: POSTGRES_URL or (PGUSER, PGPASSWORD, PGDATABASE, PGHOST) must be configured.

• Conversations are saved to Postgres/Lakebase.
• Users can access history via the sidebar.
• History persists across sessions.

Ephemeral Mode

Requirement: No database environment variables are set.

• Conversations are stored in memory and lost on page refresh or server restart.
• The sidebar shows "No chat history available".
• An "Ephemeral" indicator appears in the header.