### Example Setup Script for MicroVM Customization

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/dbos-cloud/application-management.md

This bash script demonstrates how to install system packages, such as 'traceroute', within the microVM before your application starts. This requires a DBOS Pro subscription.

```bash
#!/bin/bash

# Install the traceroute package for use in your application
apt install traceroute
```

--------------------------------

### Install DBOS and Initialize Example App

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/quickstart.md

Installs the DBOS library and FastAPI, then initializes a starter application. This is a prerequisite for running DBOS applications.

```shell
pip install dbos 'fastapi[standard]'
dbos init --template dbos-app-starter
```

--------------------------------

### Start Local Development Server

Source: https://github.com/dbos-inc/dbos-docs/blob/main/README.md

Install dependencies and launch the local development server for the documentation site.

```bash
npm install
npm run start
```

--------------------------------

### Configure Application Runtime and Setup Script

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/dbos-cloud/application-management.md

Specify the command to start your application and an optional setup script for customizing the microVM environment in `dbos-config.yaml`. The setup script requires a DBOS Pro subscription.

```yaml
runtimeConfig:
    # Script DBOS Cloud runs to customize your application runtime.
    # Requires a DBOS Pro subscription.
    setup:
        - "./build.sh"
    # Command DBOS Cloud executes to start your application.
    start: <your-start-command>
```

--------------------------------

### Start Workflow Example (Registered Workflow)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/methods.md

Demonstrates how to start a previously registered workflow using its handle and providing input arguments.

```typescript
async function example(input: number) {
    // Call steps
}
const exampleWorkflow = DBOS.registerWorkflow(example);

const input = 10;
const handle = await DBOS.startWorkflow(exampleWorkflow)(input);
```

--------------------------------

### Install DBOS CLI and Start Postgres

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/integrating-dbos.md

Install the DBOS Go CLI and start a Postgres database in a Docker container using these commands.

```shell
go install github.com/dbos/dbos-transact-golang/cmd/dbos@latest
dbos postgres start
```

--------------------------------

### Start Workflow Example (Decorator)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/methods.md

Shows how to start a workflow defined using the @DBOS.workflow() decorator, referencing the class and static method.

```typescript
export class Example {
  @DBOS.workflow()
  static async exampleWorkflow(input: number) {
    // Call steps
  }
}

const input = 10;
const handle = await DBOS.startWorkflow(Example).exampleWorkflow(input);
```

--------------------------------

### Example Workflow Execution

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/prompting.md

Demonstrates how to run a workflow, retrieve its handle, and then get its result. Includes error handling for both running the workflow and getting the result.

```go
func workflow(ctx dbos.DBOSContext, input string) (string, error) {
    return "success", nil
}

func example(input string) error {
    handle, err := dbos.RunWorkflow(dbosContext, workflow, input)
    if err != nil {
        return err
    }
    result, err := handle.GetResult()
    if err != nil {
        return err
    }
    fmt.Println("Workflow result:", result)
    return nil
}
```

--------------------------------

### Temporal Workflow Starting

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of starting a Temporal workflow using the Python client. Requires connection to a Temporal server.

```python
client = await Client.connect("localhost:7233")
handle = await client.start_workflow(
    OrderWorkflow.run,
    order,
    id="order-123",
    task_queue="orders",
)
result = await handle.result()
```

--------------------------------

### Install DBOS Transact Go Library

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/integrating-dbos.md

Use 'go get' to add the DBOS Transact Go library to your project dependencies.

```shell
go get github.com/dbos/dbos-transact-golang
```

--------------------------------

### Start Node.js Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/quickstart.md

After setting up the database, start your Node.js application using this command. Visit http://localhost:3000/ to test its functionality.

```bash
npm run start
```

--------------------------------

### Queue Registration Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/prompting.md

Example of registering a DBOS queue with a specific name.

```python
DBOS.register_queue("example_queue")
```

--------------------------------

### Start the Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/examples/checkout-tutorial.md

This command starts the DBOS and Fastify server. Once running, the application can be accessed at http://localhost:3000.

```shell
npm run start
```

--------------------------------

### Launch DBOS and FastAPI Server

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/examples/widget-store.md

This snippet shows how to launch the DBOS runtime and start the FastAPI server using uvicorn. Ensure DBOS is installed and configured before running.

```python
import uvicorn
from dbos import DBOS

if __name__ == "__main__":
    DBOS.launch()
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

--------------------------------

### Start DBOS Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/cli.md

Starts your DBOS application by executing the `start` command defined in `dbos-config.yaml`.

```APIDOC
## npx dbos start

### Description
Start your DBOS application by executing the `start` command defined in [`dbos-config.yaml`](./configuration.md).
For example:
```yaml
runtimeConfig:
  start:
    - "node dist/main.js"
```
DBOS Cloud executes this command to start your app.

### Method
CLI Command

### Endpoint
N/A

### Parameters
N/A
```

--------------------------------

### Start DBOS Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/reference/cli.md

Execute the `dbos start` command to initiate your DBOS application. This command runs the 'start' script defined in your `dbos-config.yaml` file, which is used by DBOS Cloud to launch your application.

```yaml
runtimeConfig:
  start:
    - "fastapi run"
```

--------------------------------

### Initialize and Launch DBOS App with Koa

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/upgrading.md

This TypeScript code demonstrates the setup for a DBOS application using Koa. It includes setting application configuration, launching the DBOS runtime, registering Koa with DBOS, and starting the server. The port is now managed via environment variables.

```typescript
// Note that port is no longer set in the runtime,
//   and should come from the environment and default to 3000
const PORT = parseInt(process.env.NODE_PORT ?? '3000');

async function main() {
  DBOS.setConfig({
    "name": "alert-center", // Setting app name is required
  });

  await DBOS.launch();
  DBOS.logRegisteredEndpoints();

  const app = new Koa();
  const appRouter = new Router();
  dkoa.registerWithApp(app, appRouter);

  app.listen(PORT, () => {
    console.log(`Server running at http://localhost:${PORT}`);
  });
}

main().then(()=>{}).catch(console.error);
```

--------------------------------

### Build and Start DBOS App

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/programming-guide.md

Build the TypeScript project and start the DBOS application.

```shell
npm run build
npm run start
```

--------------------------------

### Install Databricks SDK

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/lakebase.md

Install the required Python SDK for programmatic OAuth token generation.

```shell
pip install databricks-sdk
```

--------------------------------

### Initialize Go Project and Install DBOS

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/programming-guide.md

Initialize a new Go module and install the DBOS Go SDK. This is the first step in setting up your DBOS Go application.

```shell
go mod init dbos-starter
go get github.com/dbos-inc/dbos-transact-golang/dbos
```

--------------------------------

### Run Workflow on Specific Instance Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/prompting.md

Example of running a workflow method on a specific instance using the WithRunInstance option.

```go
handle, err := dbos.RunWorkflow(ctx, slack.Send, input, dbos.WithRunInstance(slack))
```

--------------------------------

### Example DBOS Client Initialization

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/reference/client.md

Demonstrates how to initialize a DBOS Client using environment variables for the database URL. Ensure the DBOS_SYSTEM_DATABASE_URL environment variable is set.

```go
config := dbos.ClientConfig{
    DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
}
client, err := dbos.NewClient(context.Background(), config)
if err != nil {
    log.Fatal(err)
}
defer client.Shutdown(5 * time.Second)
```

--------------------------------

### Initialize Go Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/quickstart.md

Install the DBOS Go CLI and initialize a starter application. This requires Go 1.23.0 or higher. After initialization, navigate into the application directory.

```shell
go install github.com/dbos-inc/dbos-transact-golang/cmd/dbos@latest
dbos init
cd dbos-toolbox
```

--------------------------------

### Example: Creating a Schedule

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/reference/client.md

Illustrates how to create a new schedule by providing a `ClientScheduleInput` with schedule name, target workflow, cron expression, and context.

```go
err := client.CreateSchedule(dbos.ClientScheduleInput{
    ScheduleName: "my-schedule",
    WorkflowName: "myPeriodicTask",
    Schedule:     "*/5 * * * *",
    Context:      "my context",
})
```

--------------------------------

### Start Workflow with No Timeout

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/reference/methods.md

Example of starting a child workflow and explicitly disabling its timeout using `Timeout.none()`, detaching it from the parent's timeout settings.

```java
dbos.startWorkflow(() -> proxy.longRunningChild(),
    new StartWorkflowOptions().withTimeout(Timeout.none()));
```

--------------------------------

### DBOS Python Workflow Starting (In-App)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of starting a DBOS workflow directly within the application using Python. Uses `SetWorkflowID` for idempotency.

```python
# Starting a workflow from in your application
with SetWorkflowID("order-123"):
    handle = DBOS.start_workflow(order_workflow, order)
result = handle.get_result()
```

--------------------------------

### Download and Set Up DBOS Java Starter App

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/quickstart.md

Clone the DBOS demo applications repository and navigate to the Java starter directory. Ensure you have Java 17 or higher installed.

```shell
git clone https://github.com/dbos-inc/dbos-demo-apps.git
cd dbos-demo-apps/java/dbos-starter
```

--------------------------------

### Start Workflow with a Specific ID

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/prompting.md

Starts a workflow and assigns it a globally unique ID, which also serves as an idempotency key. Ensure the Example interface and ExampleImpl class are defined.

```java
class ExampleImpl implements Example {
    @Workflow
    public String exampleWorkflow() {
        System.out.println("Running workflow with ID: " + DBOS.workflowId());
        // ...
        return "success";
    }
}

public void example(DBOS dbos, Example proxy) throws Exception {
    String myID = "unique-workflow-id-123";
    WorkflowHandle<String, Exception> handle = dbos.startWorkflow(
        () -> proxy.exampleWorkflow(),
        new StartWorkflowOptions().withWorkflowId(myID)
    );
    String result = handle.getResult();
    System.out.println("Result: " + result);
}
```

--------------------------------

### Instantiate and Launch DBOS with a Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/reference/dbos-class.md

This example shows how to configure DBOS with a name and system database URL, instantiate the DBOS class, launch it, and then execute a simple workflow consisting of two steps. Ensure the DBOS_SYSTEM_DATABASE_URL environment variable is set.

```python
import os
from dbos import DBOS, DBOSConfig

@DBOS.step()
def step_one():
    print("Step one completed!")

@DBOS.step()
def step_two():
    print("Step two completed!")

@DBOS.workflow()
def dbos_workflow():
    step_one()
    step_two()

# Configure and launch DBOS, then run a workflow.
if __name__ == "__main__":
    config: DBOSConfig = {
        "name": "dbos-starter",
        "system_database_url": os.environ.get("DBOS_SYSTEM_DATABASE_URL"),
    }
    DBOS(config=config)
    DBOS.launch()
    dbos_workflow()
```

--------------------------------

### Install DBOS and OpenAI Agents Integration

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/ai/ai-quickstart.md

Install the DBOS library and the durable OpenAI agents integration package. This setup is required for running OpenAI agents with DBOS durability.

```shell
pip install dbos dbos-openai-agents
```

--------------------------------

### Initialize DBOS Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/reference/cli.md

Use `dbos init` to set up a new DBOS application in your local directory. You can specify an application name and choose from various templates like 'dbos-toolbox', 'dbos-app-starter', 'dbos-cron-starter', or 'dbos-db-starter'. The `--config` flag allows adding only the `dbos-config.yaml` file to an existing project.

```bash
dbos init <application-name> -t <template>
```

```bash
dbos init --config
```

--------------------------------

### Example DBOS Client Initialization

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/prompting.md

Demonstrates how to create and initialize a DBOS client using a configuration that specifies the system database URL from an environment variable. Ensures the client's connection pool is released upon shutdown.

```go
config := dbos.ClientConfig{
    DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
}
client, err := dbos.NewClient(context.Background(), config)
if err != nil {
    log.Fatal(err)
}
def client.Shutdown(5 * time.Second)
```

--------------------------------

### Get Debouncer Instance

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/reference/methods.md

Obtain an immutable Debouncer builder instance. This is the starting point for configuring debouncer behavior.

```java
Debouncer<R> debouncer()
```

--------------------------------

### Set up Google Cloud Project and Enable APIs

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-cloud-run.md

Configure your Google Cloud project, enable necessary APIs, and authenticate the gcloud CLI.

```bash
gcloud auth login
gcloud projects create [YOUR_PROJECT_ID]
gcloud config set project [YOUR_PROJECT_ID]

gcloud beta billing projects link [YOUR_PROJECT_ID] \
  --billing-account=[YOUR_BILLING_ACCOUNT_ID]

gcloud services enable \
  run.googleapis.com \
  sqladmin.googleapis.com \
  compute.googleapis.com \
  servicenetworking.googleapis.com \
  secretmanager.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com
```

--------------------------------

### Start DBOS Workflow via HTTP GET (Service Mode)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-cloud-run.md

Initiates a DBOS workflow with ID '1' by sending an HTTP GET request to the deployed Cloud Run service URL. This is used for testing the service in 'service' deployment mode.

```bash
curl -X GET https://my-app-XXXXXXXXXX.us-central1.run.app/workflow/1
```

--------------------------------

### Run DBOS Go Starter Locally

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-cloud-run.md

Starts a local DBOS application container with specified environment variables for database connection and conductor API key. Use this for local development and testing before deploying to the cloud.

```bash
docker run --rm -p 8080:8080 \
  -e DB_USER=postgres \
  -e DB_PASSWORD="your_local_db_password" \
  -e DB_NAME=myappdb \
  -e INSTANCE_UNIX_SOCKET=host.docker.internal \
  -e DBOS_CONDUCTOR_KEY="your_conductor_api_key" \
  dbos-go-starter-image
```

--------------------------------

### Start a Background Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/prompting.md

Initiates a workflow to run in the background. Returns a handle to monitor and retrieve results. Ensure the Example interface and ExampleImpl class are defined.

```java
class ExampleImpl implements Example {
    @Workflow
    public String backgroundTask(String input) {
        // ...
        return output;
    }
}

public void runWorkflowExample(DBOS dbos, Example proxy) throws Exception {
    // Start the background task
    WorkflowHandle<String, Exception> handle = dbos.startWorkflow(
        () -> proxy.backgroundTask("input"),
        new StartWorkflowOptions()
    );
    // Wait for the background task to complete and retrieve its result
    String result = handle.getResult();
    System.out.println("Workflow result: " + result);
}
```

--------------------------------

### Initialize and Launch DBOS App

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/examples/widget-store.md

Sets up the DBOS context, registers workflows, and launches the application. Ensure DBOS_SYSTEM_DATABASE_URL and DBOS_CONDUCTOR_API_KEY environment variables are set.

```go
func main() {
    logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
        Level: slog.LevelDebug,
    }))

    dbURL := os.Getenv("DBOS_SYSTEM_DATABASE_URL")
    if dbURL == "" {
        logger.Error("DBOS_SYSTEM_DATABASE_URL required")
        os.Exit(1)
    }

    dbosContext, err := dbos.NewDBOSContext(context.Background(), dbos.Config{
        AppName:         "widget-store",
        DatabaseURL:     os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
        AdminServer:     true,
        Logger:          logger,
        ConductorAPIKey: os.Getenv("DBOS_CONDUCTOR_API_KEY"),
    })
    if err != nil {
        logger.Error("DBOS initialization failed", "error", err)
        os.Exit(1)
    }
    dbos.RegisterWorkflow(dbosContext, checkoutWorkflow)
    dbos.RegisterWorkflow(dbosContext, dispatchOrderWorkflow)

    err = dbos.Launch(dbosContext)
    if err != nil {
        logger.Error("DBOS service start failed", "error", err)
        os.Exit(1)
    }
    defer dbos.Shutdown(dbosContext, 10 * time.Second)

    db, err = pgxpool.New(context.Background(), dbURL)
    if err != nil {
        logger.Error("database connection failed", "error", err)
        os.Exit(1)
    }
    defer db.Close()

    r := gin.Default()

    // Serve HTML
    r.StaticFile("/", "./html/app.html")

    // HTTP endpoints
    r.GET("/product", func(c *gin.Context) { getProduct(c, db, logger) })
    r.GET("/orders", func(c *gin.Context) { getOrders(c, db, logger) })
    r.GET("/order/:id", func(c *gin.Context) { getOrder(c, db, logger) })
    r.POST("/restock", func(c *gin.Context) { restock(c, db, logger) })
    r.POST("/checkout/:idempotency_key", func(c *gin.Context) { checkoutEndpoint(c, dbosContext, logger) })
    r.POST("/payment_webhook/:payment_id/:payment_status", func(c *gin.Context) { paymentEndpoint(c, dbosContext, logger) })
    r.POST("/crash_application", func(c *gin.Context) { crashApplication(c, logger) })

    if err := r.Run(":8080"); err != nil {
        logger.Error("HTTP server start failed", "error", err)
        os.Exit(1)
    }
}
```

--------------------------------

### Execute DBOS Child Workflow (Go)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of executing a child workflow from a parent workflow in DBOS using Go. Demonstrates starting a child workflow in the background.

```go
func ParentWorkflow(ctx dbos.DBOSContext, input string) (string, error) {
    // Start child workflow in background
    handle, err := dbos.RunWorkflow(ctx, ChildWorkflow, data)
    if err != nil {
        return "", err
    }
    result, err := handle.GetResult()
    return result, err
}
```

--------------------------------

### Initialize DBOS Node Starter Project

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/programming-guide.md

Initialize a new DBOS project using the node starter template and install dependencies.

```shell
npx @dbos-inc/create@latest -t dbos-node-starter
cd dbos-node-starter
```

--------------------------------

### Execute DBOS Child Workflow (TypeScript)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of executing a child workflow from a parent workflow in DBOS using TypeScript. Supports direct calls and background starts.

```typescript
async function parentWorkflow() {
    // Call directly (runs inline)
    const result = await childWorkflowFn(data);

    // Or start in background
    const handle = await DBOS.startWorkflow(childWorkflowFn)(data);
    const result2 = await handle.getResult();
}
const parentWorkflowFn = DBOS.registerWorkflow(parentWorkflow);
```

--------------------------------

### Execute DBOS Child Workflow (Python)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of executing a child workflow from a parent workflow in DBOS using Python. Supports direct calls and background starts.

```python
@DBOS.workflow()
def parent_workflow():
    # Call directly (runs inline)
    result = child_workflow(data)

    # Or start in background
    handle = DBOS.start_workflow(child_workflow, data)
    result = handle.get_result()
```

--------------------------------

### Execute DBOS Child Workflow (Java)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/explanations/migrating-from-temporal.md

Example of executing a child workflow from a parent workflow in DBOS using Java. Shows direct calls and background starts with WorkflowHandle.

```java
@Workflow(name = "parentWorkflow")
public String parentWorkflow() {
    // Call directly (runs inline)
    String result = proxy.childWorkflow(data);

    // Or start in background
    WorkflowHandle<String, Exception> handle = DBOS.startWorkflow(
        () -> proxy.childWorkflow(data),
        new StartWorkflowOptions()
    );
    return handle.getResult();
}
```

--------------------------------

### Example: Producing and Consuming DBOS Streams

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/prompting.md

Demonstrates a workflow writing multiple values to a stream and closing it, followed by examples of both blocking and asynchronous reading of stream data.

```go
func producerWorkflow(ctx dbos.DBOSContext, _ string) (string, error) {
    err := dbos.WriteStream(ctx, "progress", "step 1 complete")
    if err != nil {
        return "", err
    }
    err = dbos.WriteStream(ctx, "progress", "step 2 complete")
    if err != nil {
        return "", err
    }
    err = dbos.CloseStream(ctx, "progress")
    if err != nil {
        return "", err
    }
    return "done", nil
}

// Blocking read
values, closed, err := dbos.ReadStream[string](ctx, workflowID, "progress")

// Async read: process values as they arrive
ch, err := dbos.ReadStreamAsync[string](ctx, workflowID, "progress")
if err != nil {
    return err
}
for streamValue := range ch {
    if streamValue.Err != nil {
        return streamValue.Err
    }
    if streamValue.Closed {
        break
    }
    fmt.Printf("Received: %s\n", streamValue.Value)
}
```

--------------------------------

### DBOS.scheduled Decorator Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/workflows-steps.md

Use the @DBOS.scheduled decorator to run a workflow on a crontab schedule. The workflow function must accept scheduled and start times. Ensure the crontab string is valid.

```typescript
import { DBOS } from '@dbos-inc/dbos-sdk';

class SchedulerConfig {
  crontab: string;
  mode?: SchedulerMode = SchedulerMode.ExactlyOncePerIntervalWhenActive;
  queueName?: string;
}

class ScheduledExample{
  @DBOS.workflow()
  @DBOS.scheduled({crontab: '*/30 * * * * *'})
  static async scheduledWorkflow(schedTime: Date, startTime: Date) {
    DBOS.logger.info(`I am a workflow scheduled to run every 30 seconds`);
  }
}
```

--------------------------------

### Configure and Launch DBOS (Python)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/ai/ai-quickstart.md

Initialize DBOS with configuration, including the system database URL, and launch the DBOS runtime. For production, set DBOS_SYSTEM_DATABASE_URL to a Postgres connection string.

```python
import os
from dbos import DBOS, DBOSConfig

config: DBOSConfig = {
    "name": "my-app",
    "system_database_url": os.environ.get("DBOS_SYSTEM_DATABASE_URL"),
}
DBOS(config=config)
DBOS.launch()
```

--------------------------------

### Registering and Running a DBOS Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/prompting.md

Demonstrates how to define, register, and run a simple DBOS workflow with two steps. Workflow registration must occur before launching the DBOS context.

```go
type Workflow[P any, R any] func(ctx DBOSContext, input P) (R, error)

func stepOne(ctx context.Context) (string, error) {
    fmt.Println("Step one completed")
    return "success", nil
}

func stepTwo(ctx context.Context) (string, error) {
    fmt.Println("Step two completed")
    return "success", nil
}

func workflow(ctx dbos.DBOSContext, _ string) (string, error) {
    _, err := dbos.RunAsStep(ctx, stepOne)
    if err != nil {
        return "failure", err
    }
    _, err = dbos.RunAsStep(ctx, stepTwo)
    if err != nil {
        return "failure", err
    }
    return "success", err
}

func main() {
    ... // Create the DBOS context
    dbos.RegisterWorkflow(dbosContext, workflow)
    ... // Launch DBOS after registering all workflows
}
```

--------------------------------

### Running a Workflow and Getting its Result

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/tutorials/workflow-tutorial.md

Call a registered workflow using RunWorkflow, which starts it in the background. A workflow handle is returned, allowing you to retrieve the workflow's result or check for errors.

```Go
func runWorkflowExample(dbosContext dbos.DBOSContext, input string) error {
    handle, err := dbos.RunWorkflow(dbosContext, workflow, input)
    if err != nil {
        return err
    }
    result, err := handle.GetResult()
    if err != nil {
        return err
    }
    fmt.Println("Workflow result:", result)
    return nil
}
```

--------------------------------

### Initialize DBOS with Configuration

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/reference/configuration.md

Instantiate the DBOS client by passing a DBOSConfig object. Ensure the 'name' and 'system_database_url' are provided. The system database URL can be set via an environment variable.

```python
import os
from dbos import DBOS, DBOSConfig

config: DBOSConfig = {
    "name": "dbos-example",
    "system_database_url": os.environ["DBOS_SYSTEM_DATABASE_URL"],
}
DBOS(config=config)
```

--------------------------------

### Handle Non-Deterministic Operations Using Steps

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/tutorials/workflow-tutorial.md

Perform non-deterministic operations within separate functions and call them as steps from the workflow to ensure determinism. This example shows how to get a random choice using a step.

```Go
func generateChoice(ctx context.Context) (int, error) {
    return rand.Intn(2), nil
}

func exampleWorkflow(ctx dbos.DBOSContext, input string) (string, error) {
    randomChoice, err := dbos.RunAsStep(ctx, generateChoice)
    if err != nil {
        return "", err
    }
    if randomChoice == 0 {
        return dbos.RunAsStep(ctx, stepOne)
    } else {
        return dbos.RunAsStep(ctx, stepTwo)
    }
}
```

--------------------------------

### Get Event in Handler for Checkout Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/tutorials/workflow-communication.md

A handler retrieves a payment ID event emitted by the checkout workflow. It starts the workflow in the background and then waits for the event, returning it or indicating failure if the event is not received within the timeout.

```java
app.post("/checkout/{idempotency_key}", ctx -> {
    String idempotencyKey = ctx.pathParam("idempotency_key");

    // Idempotently start the checkout workflow in the background.
    WorkflowHandle<Void, RuntimeException> handle = dbos.startWorkflow(
        () -> checkoutProxy.checkoutWorkflow(),
        new StartWorkflowOptions().withWorkflowId(idempotencyKey)
    );

    // Wait for the checkout workflow to send a payment ID, then return it.
    Optional<String> paymentId = dbos.<String>getEvent(handle.workflowId(), PAYMENT_ID, Duration.ofSeconds(60));
    if (paymentId.isEmpty()) {
        ctx.status(404);
        ctx.result("Checkout failed to start");
    } else {
        ctx.result(paymentId.get());
    }
});
```

--------------------------------

### DBOS Scaling Workflow Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-cloud-run.md

A Go scheduled workflow that checks queue depth and resizes a Cloud Run worker pool accordingly. It reads queue length, gets current instance count, computes desired instances, and updates the pool if necessary.

```go
func ScalingWorkflow(ctx dbos.DBOSContext, input dbos.ScheduledWorkflowInput) (any, error) {
    // 1. Read queue length by listing all enqueued/pending workflows
    workflows, err := dbos.ListWorkflows(ctx, dbos.WithQueuesOnly(), dbos.WithQueueName(taskQueue.Name))
    if err != nil {
        return "", fmt.Errorf("failed to list workflows: %w", err)
    }
    qlen := len(workflows)

    // 2. Get current instance count from the Cloud Run Admin API
    currentInstances, err := dbos.RunAsStep(ctx, func(stepCtx context.Context) (int, error) {
        return getWorkerPoolInstances(stepCtx)
    })
    if err != nil {
        return "", fmt.Errorf("failed to get current instances: %w", err)
    }

    // 3. Compute desired instances: ceil(queue_depth / worker_concurrency)
    desiredInstances := int(math.Ceil(float64(qlen) / float64(WORKER_CONCURRENCY)))
    if desiredInstances < 1 {
        desiredInstances = 1
    }

    // 4. Resize the pool if needed
    if desiredInstances != currentInstances {
        _, err := dbos.RunAsStep(ctx, func(stepCtx context.Context) (string, error) {
            return setWorkerPoolInstances(stepCtx, desiredInstances)
        })
        if err != nil {
            return "", fmt.Errorf("failed to set instances: %w", err)
        }
    }

    return fmt.Sprintf("qlen=%d, instances=%d", qlen, desiredInstances), nil
}
```

--------------------------------

### Clone and Navigate Demo Apps Repository

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/examples/checkout-tutorial.md

These shell commands clone the dbos-demo-apps repository and navigate into the widget-store directory, preparing the project for local setup.

```shell
git clone https://github.com/dbos-inc/dbos-demo-apps.git
cd typescript/widget-store
```

--------------------------------

### Start Database and Run Agent

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/examples/hacker-news-agent.md

Commands to initialize the local Postgres database and execute the agent with a specific research topic.

```shell
npx dbos postgres start
```

```shell
npx agent "artificial intelligence"
```

```shell
npx agent "rust"
npx agent "postgres"
npx agent "kubernetes"
```

```shell
npx agent "artificial intelligence" --workflow-id <id>
```

--------------------------------

### Configure and Launch DBOS Worker in Vercel Function

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/vercel.md

Configure and launch the DBOS worker within a Vercel Function. This sets up the worker to poll for and execute workflows from a registered queue. It includes a GET handler to start the worker and wait for workflows to complete within a timeout.

```typescript
// Configure and launch DBOS. It will automatically dequeue and execute workflows.
DBOS.setConfig({
  name: 'dbos-vercel-integration',
  systemDatabaseUrl: process.env.DBOS_SYSTEM_DATABASE_URL,
  runAdminServer: false,
});
await DBOS.launch();
await DBOS.registerQueue('exampleQueue');

// After the worker Vercel function is launched,
// it waits for either all enqueued workflows
// to complete or for a timeout to be reached
async function waitForQueuedWorkflowsToComplete(timeoutMs: number): Promise<void> {
  const startTime = Date.now();
  const intervalMs = 1000;
  while (true) {
    if (Date.now() - startTime >= timeoutMs) {
      throw new Error(`Timeout reached after ${timeoutMs}ms - queued workflows still exist`);
    }
    const queuedWorkflows = await DBOS.listQueuedWorkflows({queueName: 'exampleQueue'});
    if (queuedWorkflows.length === 0) {
      console.log('All queued workflows completed');
      return;
    }
    console.log(`${queuedWorkflows.length} workflows still queued, waiting...`);
    await new Promise<void>((resolve) => setTimeout(resolve, intervalMs));
  }
}

export async function GET(request: Request) {
  waitUntil(waitForQueuedWorkflowsToComplete(300000));
  return new Response(`Starting DBOS worker! Request URL: ${request.url}`);
}
```

--------------------------------

### Create and Use a Partitioned Queue

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/tutorials/queue-tutorial.md

Demonstrates creating a partitioned queue with a global concurrency limit and enqueuing tasks partitioned by user ID. Partition keys are required for partitioned queues.

```go
partitionedQueue := dbos.NewWorkflowQueue(dbosContext, "user-tasks",
    dbos.WithPartitionQueue(),
    dbos.WithGlobalConcurrency(1),
)

type Task struct {
    TaskID string
    Data   string
}

func processTask(ctx dbos.DBOSContext, task Task) (string, error) {
    // Process the task...
    return fmt.Sprintf("Processed task %s", task.TaskID), nil
}

func onUserTaskSubmission(dbosContext dbos.DBOSContext, userID string, task Task) error {
    // Partition the task queue by user ID. As the queue has a
    // maximum concurrency of 1, this means that at most one
    // task can run at once per user (but tasks from different
    // users can run concurrently).
    handle, err := dbos.RunWorkflow(dbosContext, processTask, task,
        dbos.WithQueue("user-tasks"),
        dbos.WithQueuePartitionKey(userID),
    )
    if err != nil {
        return fmt.Errorf("failed to enqueue task: %w", err)
    }

    result, err := handle.GetResult()
    if err != nil {
        return fmt.Errorf("task failed: %w", err)
    }

    fmt.Printf("Task completed: %s\n", result)
    return nil
}
```

--------------------------------

### Initialize New Java Project with Gradle

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/programming-guide.md

Use this command to create a new Java project and accept the default Gradle settings.

```shell
mkdir myapp && cd myapp
gradle init
```

--------------------------------

### Enqueueing Workflows Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/queues.md

Shows how to enqueue workflows using `DBOS.startWorkflow` with a specified queue name.

```APIDOC
## Enqueueing Workflows

Workflows are enqueued by providing a `queueName` argument to [`DBOS.startWorkflow`](./methods.md#dbosstartworkflow).
This enqueues a function for processing and returns a [handle](./methods.md#workflow-handles) to it.
Through arguments to `DBOS.startWorkflow`, you can optionally provide a custom priority or deduplication ID to an enqueued workflow.

The `DBOS.startWorkflow` method durably enqueues your function; after it returns, your function is guaranteed to eventually execute even if your app is interrupted.

**Example syntax:**

```typescript
import { DBOS } from "@dbos-inc/dbos-sdk";

async function taskFunction(task) {
    // ...
}
const taskWorkflow = DBOS.registerWorkflow(taskFunction, {"name": "taskWorkflow"});

async function queueFunction(tasks) {
  await DBOS.registerQueue("example_queue");
  const handles = []

  // Enqueue each task so all tasks are processed concurrently.
  for (const task of tasks) {
    handles.push(await DBOS.startWorkflow(taskWorkflow, { queueName: "example_queue" })(task))
  }

  // Wait for each task to complete and retrieve its result.
  // Return the results of all tasks.
  const results = []
  for (const h of handles) {
    results.push(await h.getResult())
  }
  return results
}
const queueWorkflow = DBOS.registerWorkflow(queueFunction, {"name": "taskWorkflow"})
```

**Example syntax using decorated workflows:**

```javascript
import { DBOS } from "@dbos-inc/dbos-sdk";

class Tasks {
  @DBOS.workflow()
  static async processTask(task) {
    // ...
  }

  @DBOS.workflow()
  static async processTasks(tasks) {
    await DBOS.registerQueue("example_queue");
    const handles = []

    // Enqueue each task so all tasks are processed concurrently.
    for (const task of tasks) {
      handles.push(await DBOS.startWorkflow(Tasks, { queueName: "example_queue" }).processTask(task));
    }

    // Wait for each task to complete and retrieve its result.
    // Return the results of all tasks.
    const results = [];
    for (const h of handles) {
      results.push(await h.getResult());
    }
    return results;
  }
}
```
```

--------------------------------

### Install Node.js with NVM on macOS/Linux

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/partials/_install_node.mdx

Installs Node.js version 22 using NVM. Ensure NVM is installed and sourced before running these commands.

```bash
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm

nvm install 22
nvm use 22
```

--------------------------------

### Create and Configure a Queue

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/prompting.md

Example of creating a new queue instance with a specific name and setting its worker concurrency. Queues must be registered before launching DBOS.

```java
Queue queue = new Queue("example-queue")
  .withWorkerConcurrency(1);
```

--------------------------------

### Install DBOS MCP with uv

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/mcp.md

Use this command to install the DBOS MCP package using uv. Ensure uv is installed first.

```bash
claude mcp add dbos-conductor -- uvx dbos-mcp
```

--------------------------------

### Start Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/reference/workflows-steps.md

Starts a workflow in the background and returns a handle. The workflow is guaranteed to run to completion even if the application is interrupted after it is durably started. Optionally enqueue it on a DBOS queue.

```java
interface Example {
    public void workflow();
}

class ExampleImpl implements Example {
    @Workflow
    public void workflow() {
        return;
    }
}

DBOS dbos = new DBOS(config);
Example proxy = dbos.registerProxy(Example.class, new ExampleImpl());
dbos.launch();
dbos.startWorkflow(() -> proxy.workflow(), new StartWorkflowOptions());
```

--------------------------------

### Enqueue Workflow Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/reference/client.md

Example demonstrating how to enqueue a workflow with specific input, timeout, and priority options. It shows how to obtain a workflow handle and retrieve its result.

```go
type ProcessInput struct {
    TaskID string
    Data   string
}

type ProcessOutput struct {
    Result string
    Status string
}

handle, err := dbos.Enqueue[ProcessInput, ProcessOutput](
    client, 
    "process_queue",
    "ProcessWorkflow",
    ProcessInput{TaskID: "task-123", Data: "data"},
    dbos.WithEnqueueTimeout(30 * time.Minute),
    dbos.WithEnqueuePriority(5),
)
if err != nil {
    log.Fatal(err)
}

result, err := handle.GetResult()
if err != nil {
    log.Printf("Workflow failed: %v", err)
} else {
    log.Printf("Result: %+v", result)
}
```

--------------------------------

### Set up PostgreSQL with Docker

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/prompting.md

Run a PostgreSQL database instance using Docker. Ensure the password is set to 'dbos' and the port is exposed.

```shell
docker run -d \
  --name dbos-postgres \
  -e POSTGRES_PASSWORD=dbos \
  -p 5432:5432 \
  postgres:17
```

--------------------------------

### Install llama-agents-dbos package

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/llamaindex.md

Install the required package using pip or uv.

```shell
pip install llama-agents-dbos
```

```shell
uv add llama-agents-dbos
```

--------------------------------

### Install CockroachDB Python Drivers

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/cockroachdb.md

Install the required PostgreSQL-compatible drivers for Python.

```bash
pip install psycopg2-binary sqlalchemy-cockroachdb
```

--------------------------------

### Instance Method Workflow Setup

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/workflows-steps.md

Classes with workflow methods must inherit from ConfiguredInstance and call its constructor with a unique instance name. Instances must be created before DBOS.launch().

```typescript
abstract class ConfiguredInstance {
  constructor(name: string)  
}
```

```typescript
class MyClass extends ConfiguredInstance {
  cfg: MyConfig;
  constructor(name: string, config: MyConfig) {
    super(name);
    this.cfg = cfg;
  }

  @DBOS.workflow()
  async testWorkflow(p: string): Promise<void> {
    // ... Operations that use this.cfg
  }
}

const myClassInstance = new MyClass('instanceA');
```

--------------------------------

### Example: Creating a Scheduled Workflow

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/golang/reference/methods.md

Demonstrates how to use the CreateSchedule function with various options, including context, automatic backfill, and schedule details.

```go
err := dbos.CreateSchedule(ctx, myPeriodicTask, dbos.CreateScheduleRequest{
    ScheduleName: "my-schedule",
    Schedule:     "*/5 * * * *",
},
    dbos.WithScheduleContext("my context"),
    dbos.WithAutomaticBackfill(true),
)
```

--------------------------------

### Stream Reader Example

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/prompting.md

Example of reading values from a DBOS stream and printing them.

```python
for value in DBOS.read_stream(workflow_id, example_key):
    print(f"Received: {value}")
```

--------------------------------

### Initialize Database and Roles

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-kubernetes.md

Runs a temporary pod to create the application database and restricted user role.

```bash
kubectl run pg-setup --restart=Never \
  --namespace dbos \
  --image=postgres:16 \
  --env="PGPASSWORD=$POSTGRES_PASSWORD" \
  --command -- bash -c "
    psql -h $RDS_ENDPOINT -U postgres -c 'CREATE DATABASE dbos_app;'
    psql -h $RDS_ENDPOINT -U postgres -c \"CREATE ROLE dbos_app_role WITH LOGIN PASSWORD '$APP_ROLE_PASSWORD';\"
  "
# Wait for the pod to finish, then clean up
sleep 15 && kubectl logs pg-setup -n dbos && kubectl delete pod pg-setup -n dbos
```

--------------------------------

### Example DBOS Configuration File

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/reference/configuration.md

A sample `dbos-config.yaml` file demonstrating default parameters for a Node.js application.

```yaml
name: my-app
language: node
system_database_url: ${DBOS_SYSTEM_DATABASE_URL}
runtimeConfig:
  start:
    - node dist/main.js
```

--------------------------------

### Install SQS Receiver

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/tutorials/externalmessages.md

Install the SQS event receiver library using npm.

```shell
npm i @dbos-inc/sqs-receive
```

--------------------------------

### Configure DBOS Application

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/dbos-cloud/deploying-to-cloud.md

Set up the DBOSConfig with application name, database URL, and enable the AdminServer. Ensure the DatabaseURL points to the DBOS_SYSTEM_DATABASE_URL environment variable.

```go
dbos.Config{
    AppName:     "dbos-starter",
    DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
    AdminServer: true,
}
```

--------------------------------

### Install KafkaJS Receiver

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/typescript/tutorials/externalmessages.md

Install the KafkaJS event receiver library using npm.

```shell
npm i @dbos-inc/kafkajs-receive
```

--------------------------------

### Using DBOS with Try-with-Resources (v0.8+)

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/upgrading.md

Shows how to use the `DBOS` instance with a try-with-resources statement for automatic resource management, including proxy registration and launching.

```java
var dbosConfig = DBOSConfig.defaultsFromEnv("my-app");
try (var dbos = new DBOS(dbosConfig)) {
  Example proxy = dbos.registerProxy(Example.class, new ExampleImpl(dbos));
  dbos.launch();
  proxy.workflow();
}
```

--------------------------------

### Clone and Navigate Demo Apps Repository

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/java/examples/widget-store.md

Instructions to clone the dbos-demo-apps repository and navigate to the widget-store Java directory.

```shell
git clone https://github.com/dbos-inc/dbos-demo-apps.git
cd java/widget-store
```

--------------------------------

### Install Confluent Kafka

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/python/tutorials/kafka-integration.md

Install the Confluent Kafka client library for your Python application.

```bash
pip install confluent-kafka
```

--------------------------------

### Sample Dockerfile for Multi-stage Build

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/hosting-with-cloud-run.md

A multi-stage Dockerfile that uses a Go build environment and a distroless runtime image for a smaller, more secure final image.

```dockerfile
# --- Build Stage ---
FROM golang:1.24 as builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download && go mod tidy
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

# --- Run Stage ---
FROM gcr.io/distroless/static-debian12
COPY --from=builder /app/main /
EXPOSE 8080
CMD ["/main"]
```

--------------------------------

### Install TypeScript OpenTelemetry Dependencies

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/production/dbos-cloud/deploying-to-cloud.md

Installs the required OpenTelemetry package for TypeScript applications.

```shell
npm i @dbos-inc/otel@latest
```

--------------------------------

### Install Pydantic AI with DBOS

Source: https://github.com/dbos-inc/dbos-docs/blob/main/docs/integrations/pydantic-ai.md

Install the required dependencies using pip or uv.

```shell
pip install pydantic-ai[dbos]
```

```shell
uv add pydantic-ai[dbos]
```

```shell
pip install pydantic-ai-slim[dbos]
```

```shell
uv add pydantic-ai-slim[dbos]
```