Resonate

https://docs.resonatehq.io
Admin
Resonate is an agent-native durable execution engine, implementing a distributed async/await...
Tokens:162,239
Snippets:1,916
Trust Score:6.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Clone and Setup Python Example

Source: https://docs.resonatehq.io/get-started/examples/multi-agent-orchestration

Clone the Python example repository, install dependencies, and configure the OpenAI API key.

```shell
git clone https://github.com/resonatehq-examples/example-multi-agent-orchestration-py
cd example-multi-agent-orchestration-py
uv sync
cp .env.example .env  # add your OPENAI_API_KEY
```

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

### Python Schedule Example Setup

Source: https://docs.resonatehq.io/get-started/examples/schedule

Clone the Python example repository and install its dependencies using uv. This prepares the environment for running the Python schedule and worker.

```shell
git clone https://github.com/resonatehq-examples/example-schedule-py
cd example-schedule-py
uv sync
```

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

### TypeScript Schedule Example Setup

Source: https://docs.resonatehq.io/get-started/examples/schedule

Clone the TypeScript example repository, install dependencies, and prepare for running the schedule and worker.

```shell
git clone https://github.com/resonatehq-examples/example-schedule-ts
cd example-schedule-ts
npm install
```

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

### Clone and install example project

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-cloud-run-workers

Steps to clone the example project and install its dependencies locally.

```shell
git clone https://github.com/resonatehq-examples/example-countdown-gcp-ts
cd example-countdown-gcp-ts
npm install
```

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

### Python Load Balancing Setup

Source: https://docs.resonatehq.io/get-started/examples/load-balancing

Clone the Python example repository, install dependencies, and start the Resonate server and workers.

```shell
git clone https://github.com/resonatehq-examples/example-load-balancing-py
cd example-load-balancing-py
uv sync
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
uv run python worker.py
```

```shell
for i in 1 2 3 4 5 6; do uv run python invoke.py; done
```

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

### Clone and Install TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-lambda-workers

Clone the TypeScript example repository, navigate into it, and install dependencies.

```shell
git clone https://github.com/resonatehq-examples/example-aws-lambda-ts
cd example-aws-lambda-ts
npm install
```

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

### Clone and Install Python Example

Source: https://docs.resonatehq.io/get-started/examples/recursive-factorial

Clone the Python recursive factorial example repository and install its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-recursive-factorial-py
cd example-recursive-factorial-py
uv sync
```

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

### Clone and Install TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/multi-agent-orchestration

Clone the TypeScript example repository and install its dependencies.

```shell
git clone https://github.com/resonatehq-examples/example-multi-agent-orchestration-ts
cd example-multi-agent-orchestration-ts
bun install
```

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

### Rust Load Balancing Setup

Source: https://docs.resonatehq.io/get-started/examples/load-balancing

Clone the Rust example repository, build the project, and start the Resonate server and workers.

```shell
git clone https://github.com/resonatehq-examples/example-load-balancing-rs
cd example-load-balancing-rs
cargo build
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
cargo run --bin worker
```

```shell
for i in 1 2 3 4 5 6; do cargo run --bin client; done
```

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

### TypeScript Load Balancing Setup

Source: https://docs.resonatehq.io/get-started/examples/load-balancing

Clone the TypeScript example repository, install dependencies, and start the Resonate server and workers.

```shell
git clone https://github.com/resonatehq-examples/example-load-balancing-ts
cd example-load-balancing-ts
npm install
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
npx tsx worker.ts
```

```shell
for i in 1 2 3 4 5 6; do npx tsx client.ts; done
```

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

### Clone and Install Python Example

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-lambda-workers

Clone the Python example repository, navigate into it, and synchronize dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-lambda-workers-py
cd example-lambda-workers-py
uv sync
```

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

### Clone and Install Python Example

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Clone the repository and install dependencies for the Python async HTTP API example using uv.

```shell
git clone https://github.com/resonatehq-examples/example-async-http-api-py
cd example-async-http-api-py
uv sync
```

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

### Clone and Install Python Example Dependencies

Source: https://docs.resonatehq.io/get-started/examples/async-agent-tools

Clone the Python example repository and install its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-async-tools-mcp-server-py
cd example-async-tools-mcp-server-py
uv sync
```

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

### Run Human-in-the-Loop Example with Python

Source: https://docs.resonatehq.io/get-started/examples/human-in-the-loop

Clone the repository, install dependencies using uv, and start the Resonate Server, gateway, and worker in separate terminals. Then, start a workflow using curl. Visit the callback URL printed by the worker to unblock the workflow.

```shell
git clone https://github.com/resonatehq-examples/example-human-in-the-loop-py
cd example-human-in-the-loop-py
uv sync
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
uv run gateway
```

```shell
uv run worker
```

```shell
curl -X POST http://localhost:5001/start-workflow \
  -H "Content-Type: application/json" \
  -d '{"workflow_id": "hitl-001"}'
```

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

### Clone and Install Python Example

Source: https://docs.resonatehq.io/get-started/examples/durable-sleep

Clone the Python example repository and synchronize its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-durable-sleep-py
cd example-durable-sleep-py
uv sync
```

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

### Rust Schedule Example Setup

Source: https://docs.resonatehq.io/get-started/examples/schedule

Clone the Rust example repository and build the project. This prepares the environment for running the Rust schedule and worker.

```shell
git clone https://github.com/resonatehq-examples/example-schedule-rs
cd example-schedule-rs
cargo build
```

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

### Clone and Install TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/recursive-factorial

Clone the TypeScript recursive factorial example repository, install its Node.js dependencies, and prepare for execution.

```shell
git clone https://github.com/resonatehq-examples/example-recursive-factorial-ts
cd example-recursive-factorial-ts
npm install
```

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

### Clone and Install Python Fan-Out Fan-In Example

Source: https://docs.resonatehq.io/get-started/examples/fan-out-fan-in

Clone the Python fan-out fan-in example repository and install its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-fan-out-fan-in-py
cd example-fan-out-fan-in-py
uv sync
```

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

### Clone and Install TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/durable-sleep

Clone the TypeScript example repository and install its dependencies using npm.

```shell
git clone https://github.com/resonatehq-examples/example-durable-sleep-ts
cd example-durable-sleep-ts
npm install
```

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

### Go Load Balancing Setup

Source: https://docs.resonatehq.io/get-started/examples/load-balancing

Clone the Go example repository, download dependencies, and run the combined worker and client process.

```shell
git clone https://github.com/resonatehq-examples/example-load-balancing-go
cd example-load-balancing-go
go mod download
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
go run . -url=http://localhost:8001 -workers=3 -tasks=6
```

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

### Clone and Install TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Clone the repository and install dependencies for the TypeScript async HTTP API example.

```shell
git clone https://github.com/resonatehq-examples/example-async-http-api-ts
cd example-async-http-api-ts
bun install
```

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

### Clone and Install TypeScript Fan-Out Fan-In Example

Source: https://docs.resonatehq.io/get-started/examples/fan-out-fan-in

Clone the TypeScript fan-out fan-in example repository and install its dependencies using bun.

```shell
git clone https://github.com/resonatehq-examples/example-fan-out-fan-in-ts
cd example-fan-out-fan-in-ts
bun install
```

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

### Run Human-in-the-Loop Example with TypeScript

Source: https://docs.resonatehq.io/get-started/examples/human-in-the-loop

Clone the repository, install dependencies using Bun, and start the Resonate Server, gateway, and worker in separate terminals. Then, start a workflow using curl. Visit the callback URL printed by the worker to unblock the workflow.

```shell
git clone https://github.com/resonatehq-examples/example-human-in-the-loop-ts
cd example-human-in-the-loop-ts
bun install
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
bun run gateway.ts
```

```shell
bun run worker.ts
```

```shell
curl -X POST http://localhost:5001/start-workflow \
  -H "Content-Type: application/json" \
  -d '{"workflow_id": "hitl-001"}'
```

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

### Clone and Run Hello World in TypeScript

Source: https://docs.resonatehq.io/get-started/examples/hello-world

Clone the TypeScript example repository, install dependencies, and run the workflow locally using npx.

```shell
git clone https://github.com/resonatehq-examples/example-hello-world-ts
cd example-hello-world-ts
npm install
```

```shell
npx tsx index.ts
```

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

### Clone and Install Python Webhook Handler

Source: https://docs.resonatehq.io/get-started/examples/webhook-handler

Clone the Python example repository and install its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-webhook-handler-py
cd example-webhook-handler-py
uv sync
```

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

### Start Resonate Server locally

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-cloud-run-workers

Installs and starts the Resonate Server in development mode using Homebrew.

```shell
brew install resonatehq/tap/resonate
resonate dev
```

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

### Clone TypeScript Example

Source: https://docs.resonatehq.io/get-started/examples/async-rpc

Clone the TypeScript example repository and install its dependencies using bun.

```shell
git clone https://github.com/resonatehq-examples/example-async-rpc-ts
cd example-async-rpc-ts
bun install
```

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

### Start Grafana Server

Source: https://docs.resonatehq.io/deploy/metrics

Command to start the Grafana server. Ensure Grafana is downloaded and installed before running.

```bash
./grafana server
```

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

### Run Rust Gateway

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the gateway process for the Rust example.

```shell
cargo run --bin gateway
```

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

### Clone and Run Hello World in Rust

Source: https://docs.resonatehq.io/get-started/examples/hello-world

Clone the Rust example repository, build the project, start the Resonate server, and run the worker. The workflow is invoked separately.

```shell
git clone https://github.com/resonatehq-examples/example-hello-world-rs
cd example-hello-world-rs
cargo build
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
cargo run
```

```shell
resonate invoke greet-1 --func greet --arg '"World"'
```

```shell
resonate tree greet-1
```

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

### Run Python Gateway

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the gateway process for the Python example using uv.

```shell
uv run uvicorn main:app --host 127.0.0.1 --port 5001
```

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

### Clone and Run Hello World in Python

Source: https://docs.resonatehq.io/get-started/examples/hello-world

Clone the Python example repository, install dependencies, and run the workflow. This requires the Resonate server to be running in a separate terminal.

```shell
git clone https://github.com/resonatehq-examples/example-hello-world-py
cd example-hello-world-py
uv sync
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
uv run main.py
```

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

### Clone and Install TypeScript Webhook Handler

Source: https://docs.resonatehq.io/get-started/examples/webhook-handler

Clone the TypeScript example repository and install its dependencies using Bun.

```shell
git clone https://github.com/resonatehq-examples/example-webhook-handler-ts
cd example-webhook-handler-ts
bun install
```

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

### Resonate Server Log Output Example

Source: https://docs.resonatehq.io/deploy/run-server

Example log output when the Resonate Server starts, showing the port and backend configuration.

```text
INFO resonate: Resonate Server starting port=8001
INFO resonate: Using SQLite backend path="resonate.db"
INFO resonate: Auth disabled — all requests accepted
```

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

### Clone and Install Python Money Transfer App

Source: https://docs.resonatehq.io/get-started/examples/money-transfer

Clone the Python money transfer example repository and install its dependencies using uv.

```shell
git clone https://github.com/resonatehq-examples/example-money-transfer-py
cd example-money-transfer-py
uv sync
```

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

### Run TypeScript Gateway

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the gateway process for the TypeScript example.

```shell
bun run gateway
```

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

### Clone and Build Rust Example

Source: https://docs.resonatehq.io/get-started/examples/async-agent-tools

Clone the Rust example repository and build the project.

```shell
git clone https://github.com/resonatehq-examples/example-mcp-tools-rs
cd example-mcp-tools-rs
cargo build
```

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

### Clone and Run Kafka Worker (Python)

Source: https://docs.resonatehq.io/get-started/examples/kafka-worker

Clone the Python example repository using uv, install dependencies, and run the Kafka worker and producer.

```shell
git clone https://github.com/resonatehq-examples/example-kafka-worker-py
cd example-kafka-worker-py
uv sync
```

```shell
cd redpanda && docker compose up
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
uv run python -m record_deletor.delete
```

```shell
uv run python -m record_producer.produce -n 10
```

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

### Run Rust Worker

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the worker process for the Rust example.

```shell
cargo run --bin worker
```

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

### Run Python Worker

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the worker process for the Python example using uv.

```shell
uv run python worker.py
```

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

### Clone and Install TypeScript Money Transfer App

Source: https://docs.resonatehq.io/get-started/examples/money-transfer

Clone the TypeScript money transfer example repository, install dependencies, and set up the environment variables.

```shell
git clone https://github.com/resonatehq-examples/example-money-transfer-application-ts
cd example-money-transfer-application-ts
npm install
cp .env.example .env
```

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

### Clone and Run Kafka Worker (TypeScript)

Source: https://docs.resonatehq.io/get-started/examples/kafka-worker

Clone the TypeScript example repository, install dependencies, and run the Kafka worker and producer.

```shell
git clone https://github.com/resonatehq-examples/example-kafka-worker-ts
cd example-kafka-worker-ts
bun install
```

```shell
docker compose up
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
bun run consumer
```

```shell
bun run producer -- -n 10
```

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

### Clone and Build Rust Example

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Clone the repository and build the Rust async HTTP API example.

```shell
git clone https://github.com/resonatehq-examples/example-async-http-api-rs
cd example-async-http-api-rs
cargo build
```

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

### Run Local Lambda + API Gateway Simulator (TypeScript)

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-lambda-workers

Start the local simulator for API Gateway and Lambda functions in the TypeScript example.

```shell
npm run local
```

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

### Resonate Go Example

Source: https://docs.resonatehq.io/evaluate/coming-from/dbos

An example of using Resonate in Go, including creating a Resonate client, registering a function, and running it. Note the use of `resonate.New` and `greetFn.Run`.

```go
func greet(_ *resonate.Context, args GreetArgs) (string, error) {
    return fmt.Sprintf("hello, %s!", args.Name), nil
}

func main() {
    r, _ := resonate.New(resonate.Config{URL: "http://localhost:8001"})
    defer r.Stop()

    greetFn, _ := resonate.Register(r, "greet", greet)
    h, _ := greetFn.Run(ctx, id, GreetArgs{Name: "world"})
    out, _ := h.Result(ctx)
    fmt.Println(out)
}
```

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

### Install Resonate Go SDK

Source: https://docs.resonatehq.io/develop/go

Add the Resonate Go SDK to your project using go get. Use `@latest` for the most recent development version or pin to a specific commit for stability.

```shell
go get github.com/resonatehq/resonate-sdk-go@latest
```

```shell
go get github.com/resonatehq/resonate-sdk-go@<commit-sha>
```

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

### Run Human-in-the-Loop Example with Rust

Source: https://docs.resonatehq.io/get-started/examples/human-in-the-loop

Clone the repository, build the project using cargo, and start the Resonate Server, gateway, and worker in separate terminals. Then, start a workflow using curl. Visit the 'CLICK TO RESOLVE' URL printed by the worker to unblock the workflow.

```shell
git clone https://github.com/resonatehq-examples/example-human-in-the-loop-rs
cd example-human-in-the-loop-rs
cargo build
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
cargo run --bin gateway
```

```shell
cargo run --bin worker
```

```shell
curl -X POST http://localhost:5001/start-workflow \
  -H "Content-Type: application/json" \
  -d '{"workflow_id": "hitl-001"}'
```

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

### Clone and Build Rust Example

Source: https://docs.resonatehq.io/get-started/examples/recursive-factorial

Clone the Rust recursive factorial example repository and build the project using Cargo.

```shell
git clone https://github.com/resonatehq-examples/example-recursive-factorial-rs
cd example-recursive-factorial-rs
cargo build
```

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

### Clone and Run Kafka Worker (Rust)

Source: https://docs.resonatehq.io/get-started/examples/kafka-worker

Clone the Rust example repository, build the project, and run the Kafka worker and producer. Ensure cmake is installed if rdkafka has build issues.

```shell
git clone https://github.com/resonatehq-examples/example-kafka-worker-rs
cd example-kafka-worker-rs
cargo build
```

```shell
docker compose up
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
cargo run --bin consumer
```

```shell
cargo run --bin producer -- -n 10
```

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

### Install Resonate Server with Homebrew

Source: https://docs.resonatehq.io/deploy/run-server

Install the latest Resonate Server version using Homebrew.

```shell
brew install resonatehq/tap/resonate
```

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

### Clone and Build Rust Fan-Out Fan-In Example

Source: https://docs.resonatehq.io/get-started/examples/fan-out-fan-in

Clone the Rust fan-out fan-in example repository and build the project using Cargo.

```shell
git clone https://github.com/resonatehq-examples/example-fan-out-fan-in-rs
cd example-fan-out-fan-in-rs
cargo build
```

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

### Enable and Start Systemd Service

Source: https://docs.resonatehq.io/deploy/deployment-patterns

Commands to enable the Resonate systemd service to start on boot and to manually start the service.

```bash
sudo systemctl enable resonate
sudo systemctl start resonate
```

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

### Install Resonate Binary

Source: https://docs.resonatehq.io/get-started/claude-code

Installs the Resonate binary using Homebrew and verifies the installation by checking the version. Expect version 0.9.7 or newer.

```shell
brew install resonatehq/tap/resonate
resonate --version   # expect 0.9.7 or newer
```

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

### Start Python Services and Gateway

Source: https://docs.resonatehq.io/get-started/examples/async-rpc

Run each of the nine services and the gateway using uv.

```shell
uv run python src/service_a.py
uv run python src/service_b.py
# ...service_c through service_i, one terminal each
```

```shell
uv run python src/gateway.py
```

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

### Clone and Download Go Modules

Source: https://docs.resonatehq.io/get-started/examples/recursive-factorial

Clone the Go recursive factorial example repository and download its module dependencies.

```shell
git clone https://github.com/resonatehq-examples/example-recursive-factorial-go
cd example-recursive-factorial-go
go mod download
```

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

### Start Resonate Server with Different Storage Options

Source: https://docs.resonatehq.io/reference/cli

Use `resonate serve` to start the server. Configure storage using `--storage-type` and the corresponding URL flag. Defaults to SQLite if no options are provided.

```shell
resonate serve
```

```shell
resonate serve \
  --storage-type postgres \
  --storage-postgres-url "postgres://<USER>:<PASSWORD>@localhost:5432/resonate"
```

```shell
resonate serve \
  --storage-type mysql \
  --storage-mysql-url "mysql://<USER>:<PASSWORD>@localhost:3306/resonate"
```

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

### Run TypeScript Worker

Source: https://docs.resonatehq.io/get-started/examples/async-http-api-endpoints

Start the worker process for the TypeScript example.

```shell
bun run worker
```

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

### Start TypeScript Services and Gateway

Source: https://docs.resonatehq.io/get-started/examples/async-rpc

Run each of the nine services and the gateway using bun.

```shell
bun run a
bun run b
# ...c through i, one terminal each
```

```shell
bun run gateway
```

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

### Start Resonate Development Server

Source: https://docs.resonatehq.io/reference/cli

Starts the Resonate server with an in-memory SQLite database. This is ideal for local development, running examples, or CI jobs that do not require data persistence.

```shell
resonate dev
# Resonate Server listening on 0.0.0.0:8001
```

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

### Clone and Download Go Modules for Fan-Out Fan-In

Source: https://docs.resonatehq.io/get-started/examples/fan-out-fan-in

Clone the Go fan-out fan-in example repository and download its module dependencies.

```shell
git clone https://github.com/resonatehq-examples/example-fan-out-fan-in-go
cd example-fan-out-fan-in-go
go mod download
```

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

### Temporal Go Workflow and Activity

Source: https://docs.resonatehq.io/evaluate/coming-from/temporal

A Go example using the Temporal SDK, illustrating a workflow executing an activity. Requires `temporalio/sdk-go`.

```go
import (
	"context"
	"time"
	"go.temporal.io/sdk/workflow"
)

func Workflow(ctx workflow.Context, name string) (string, error) {
    ao := workflow.ActivityOptions{StartToCloseTimeout: 10 * time.Second}
    ctx = workflow.WithActivityOptions(ctx, ao)

    var result string
    err := workflow.ExecuteActivity(ctx, Activity, name).Get(ctx, &result)
    return result, err
}

func Activity(ctx context.Context, name string) (string, error) {
    return "Hello " + name + "!", nil
}
```

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

### Initialize Resonate with Default Configuration

Source: https://docs.resonatehq.io/develop/rust

Initializes a Resonate instance using default configuration settings. This is the simplest way to get started.

```rust
use resonate::prelude::*;

let resonate = Resonate::new(ResonateConfig::default());
```

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

### Initialize Go Module and Get Resonate SDK

Source: https://docs.resonatehq.io/get-started/quickstart

Initialize a Go module and fetch the Resonate SDK for Go. Requires Go 1.22 or later.

```shell
go mod init countdown
go get github.com/resonatehq/resonate-sdk-go@latest
```

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

### Local Development Setup (Python)

Source: https://docs.resonatehq.io/evaluate/coming-from/temporal

Initialize the Resonate SDK for local development without a separate server. This is useful for quick iteration and testing.

```python
from resonate import Resonate

resonate = Resonate.local()

#...
```

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

### Docker Compose Logging Configuration

Source: https://docs.resonatehq.io/deploy/logging

Configure logging for the Resonate server within a Docker Compose setup. This example sets the log driver to 'json-file' with size and file limits.

```yaml
services:
  resonate-server:
    image: resonatehqio/resonate:v0.9.8
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
```

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

### Initialize Go SDK with Environment Variable

Source: https://docs.resonatehq.io/develop/go

Initializes the Resonate Go SDK, automatically picking up the RESONATE_URL from the environment if no explicit configuration is provided.

```go
r, err := resonate.New(resonate.Config{}) // picks up RESONATE_URL
```

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

### DBOS TypeScript Local Development with Postgres

Source: https://docs.resonatehq.io/evaluate/coming-from/dbos

Configure DBOS in TypeScript. This example shows setting the system database URL, which defaults to Postgres. Ensure the DBOS CLI is available to start a local Postgres instance if needed.

```typescript
DBOS.setConfig({
  name: "dbos-node-starter",
  systemDatabaseUrl: process.env.DBOS_SYSTEM_DATABASE_URL,
  // ...
});
await DBOS.launch(/* { conductorKey } */);
```

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

### Run Deep Research Agent Locally with TypeScript

Source: https://docs.resonatehq.io/get-started/examples/deep-research-agent

Clone the TypeScript example repository, install dependencies, set your OpenAI API key, and run the agent. The agent prints a recursive trace as it decomposes the topic. You can test resilience by killing and restarting the worker.

```shell
git clone https://github.com/resonatehq-examples/example-openai-deep-research-agent-ts
cd example-openai-deep-research-agent-ts
npm install
export OPENAI_API_KEY=sk-...
```

```shell
brew install resonatehq/tap/resonate
resonate dev
```

```shell
npx tsx src/index.ts
```

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

### DBOS Go Local Development with Postgres

Source: https://docs.resonatehq.io/evaluate/coming-from/dbos

Configure DBOS in Go. This example sets up the DBOS context, defaulting to Postgres. It retrieves the database URL from the environment, allowing for flexible configuration.

```go
dbosCtx, err = dbos.NewDBOSContext(context.Background(), dbos.Config{
	DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
	AppName:     "dbos-toolbox",
	// ...
})
```

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

### Kafka Worker Implementation in TypeScript

Source: https://docs.resonatehq.io/develop/typescript

This example demonstrates how to consume messages from Kafka and dispatch them as Resonate workflows. It uses `kafkajs` for Kafka integration and assumes a `resonate.beginRun` function is available for starting workflows. Ensure that the `messageId` used is stable and uniquely identifies the logical message to enable deduplication of duplicate deliveries.

```typescript
import { Kafka } from "kafkajs";
import { resonate } from "./workflow";

const kafka = new Kafka({ brokers: ["localhost:9092"] });
const consumer = kafka.consumer({ groupId: "workers" });

await consumer.connect();
await consumer.subscribe({ topic: "records_to_process", fromBeginning: true });

await consumer.run({
  eachMessage: async ({ topic, partition, message }) => {
    // topic-partition-offset uniquely identifies the message even when no key is set
    const messageId = `${topic}-${partition}-${message.offset}`;
    // messageId is the durable promise id — duplicate invocations dedupe.
    await resonate.beginRun(messageId, "workflow", messageId, message.offset);
  },
});
```

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

### Python Hello World Workflow

Source: https://docs.resonatehq.io/get-started/examples/hello-world

Register and run a workflow with a Resonate Server using the Python SDK. This example requires a running Resonate server.

```python
from __future__ import annotations

import asyncio
import os
import time
from typing import TYPE_CHECKING

from resonate.resonate import Resonate

if TYPE_CHECKING:
    from resonate.context import Context


async def bar(ctx: Context, greetee: str) -> str:
    return f"Hello {greetee} from bar!"


async def baz(ctx: Context, greetee: str) -> str:
    return f"Hello {greetee} from baz!"


async def foo(ctx: Context, greetee: str) -> str:
    # Each ctx.run is a checkpoint — its return value is durably stored.
    bar_greeting = await ctx.run(bar, greetee=greetee)
    baz_greeting = await ctx.run(baz, greetee=greetee)
    return f"Hello {greetee} from foo! {bar_greeting} {baz_greeting}"


async def main() -> None:
    url = os.environ.get("RESONATE_URL", "http://localhost:8001")
    r = Resonate(url=url)
    r.register(foo)
    try:
        handle = r.run(f"greeting-{time.time_ns()}", foo, "World")
        result = await handle.result()
        print(result)
    finally:
        await r.stop()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Start Docker Compose Stack

Source: https://docs.resonatehq.io/deploy/deployment-patterns

Command to start the Docker Compose services in detached mode.

```bash
docker-compose up -d

```

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

### DBOS Go Workflow Queue and Run

Source: https://docs.resonatehq.io/evaluate/coming-from/dbos

Sets up a workflow queue and then runs 10 tasks concurrently using `dbos.RunWorkflow` with `dbos.WithQueue`. Results are collected using `handle.GetResult()`.

```go
queue := dbos.NewWorkflowQueue(ctx, "queue")
// ...
handles := make([]dbos.WorkflowHandle[int], 10)
for i := range 10 {                                      // fan-out
    handle, err := dbos.RunWorkflow(ctx, task, i, dbos.WithQueue(queue.Name))
    if err != nil {
        panic(fmt.Sprintf("failed to enqueue step %d: %v", i, err))
    }
    handles[i] = handle
}
results := make([]int, 10)
for i, handle := range handles {                         // fan-in
    result, err := handle.GetResult()
    if err != nil {
        panic(fmt.Sprintf("failed to get result for step %d: %v", i, err))
    }
    results[i] = result
}
```

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

### Install OpenTelemetry Package

Source: https://docs.resonatehq.io/deploy/tracing

Install the necessary OpenTelemetry package for Resonate integration using npm.

```bash
npm install @resonatehq/opentelemetry
```

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

### Start TypeScript Money Transfer Server

Source: https://docs.resonatehq.io/get-started/examples/money-transfer

Start the Node.js server for the TypeScript money transfer application.

```shell
npm start
```

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

### DBOS Workflow with Compensation Logic

Source: https://docs.resonatehq.io/evaluate/coming-from/dbos

Illustrates a DBOS workflow that includes steps for reserving inventory and updating order status. It demonstrates how to implement compensation logic using `dbos.RunAsStep` when a payment fails or is not received within the expected timeframe.

```go
func checkoutWorkflow(ctx dbos.DBOSContext, _ string) (string, error) {
    // ... reserve inventory, await payment ...
    payment_status, err := dbos.Recv[string](ctx, PAYMENT_STATUS, 60*time.Second)
    if err != nil || payment_status != "paid" {
        dbos.RunAsStep(ctx, func(stepCtx context.Context) (string, error) {
            return undoReserveInventory(stepCtx)        // compensation
        })
        dbos.RunAsStep(ctx, func(stepCtx context.Context) (string, error) {
            return updateOrderStatus(stepCtx, UpdateOrderStatusInput{OrderID: orderID, OrderStatus: CANCELLED})
        })
    } else {
        // ... mark paid, dispatch ...
    }
    return "", nil
}
```

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

### Start Cloud Function in local dev mode

Source: https://docs.resonatehq.io/get-started/examples/durable-serverless-cloud-run-workers

Starts the local development server for the Cloud Function.

```shell
npm run dev
```

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

### Start Production Server with PostgreSQL

Source: https://docs.resonatehq.io/get-started/cli-guide

Use `resonate serve` with `--storage-type postgres` and `--storage-postgres-url` to start a Resonate server using PostgreSQL for persistent storage. Ensure you replace placeholders with your actual database credentials.

```shell
resonate serve \
  --storage-type postgres \
  --storage-postgres-url "postgres://<USER>:<PASSWORD>@localhost:5432/resonate"
```

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

### Install Cloudflare Workers Shim

Source: https://docs.resonatehq.io/deploy/serverless-workers

Install the Cloudflare Workers worker shim package using npm.

```shell
npm install @resonatehq/cloudflare
```

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

### Starting Prometheus Server

Source: https://docs.resonatehq.io/deploy/metrics

Run the Prometheus server with the specified configuration file. It's recommended to run on a different port than Resonate.

```bash
# Run on port 9091 to avoid conflict with Resonate (which uses 9090)
./prometheus --config.file=prometheus.yml --web.listen-address=:9091
```
Tokens:
Raw