Cloudflare

https://github.com/cloudflare/cloudflare-docs
Admin
Cloudflare Docs is an open-source documentation project that allows community feedback and...
Tokens:7,970,814
Snippets:60,581
Trust Score:9.3
Update:2 hours ago
Show doc for...
Tokens:
Raw
### Install dependencies and start development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/style-guide/contributions.mdx

Installs the required package dependencies and starts the local documentation development server with hot reloading.

```bash
pnpm install
pnpm run dev
```

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

### Install the Flagship Go SDK with go get

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/flagship/sdk/go.mdx

Install the Go SDK package using go get before configuring the provider.

```sh
go get github.com/cloudflare/flagship/sdks/go
```

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

### Install dependencies and run dev server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/getting-started/quick-start.mdx

Navigate into the newly created project folder, install dependencies, and start the local development server.

```sh
cd agents-starter
npm install
npm run dev
```

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

### Install chat agent dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/examples/chat-agent.mdx

Run from inside the chat-agent directory to install the agents, AI chat, AI SDK provider, and zod packages.

```sh
cd chat-agent
npm install agents @cloudflare/ai-chat ai @ai-sdk/provider zod
```

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

### Install agents, ai, and @ai-sdk/provider dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-memory/get-started.mdx

Installs the dependencies used by this guide. Run this from inside the memory-agent project directory.

```sh
npm install agents ai @ai-sdk/provider
```

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

### Install the Droid CLI

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/droid.mdx

Installs the Droid CLI via the install script. For Windows, Homebrew, or npm, refer to the Droid quickstart guide.

```bash
curl -fsSL https://app.factory.ai/cli | sh
```

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

### Install Vite globally and start development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/quickstart.mdx

Use this alternative command when running the project from the ready-made template.

```bash
npm i -g vite && npm run dev
```

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

### Generate types and start the dev server with wrangler types and npm run dev

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/examples/chat-agent.mdx

Run these commands to generate types and launch the local dev server before testing the chat agent. Use the listed prompts to exercise server-side tools, client-side tools, and the approval UI.

```sh
npx wrangler types
npm run dev
```

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

### Example response with ssl.settings

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/cloudflare-for-saas/performance/early-hints-for-saas.mdx

This is an example response from the GET request. It shows the ssl.settings object with early_hints set to "off". Copy the complete object to modify it.

```json
{
  "ssl": {
    "settings": {
      "ciphers": [
        "ECDHE-ECDSA-AES128-GCM-SHA256",
        "ECDHE-RSA-AES128-GCM-SHA256"
      ],
      "early_hints": "off",
      "http2": "on",
      "min_tls_version": "1.2",
      "tls_1_3": "on"
    }
  }
}
```

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

### Install AWS SDK and fetch R2 object in Go

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/r2/examples/authenticate-r2-auth-tokens.mdx

Install the aws-sdk-go-v2 packages using go get, then run the script with go run main.go. Replace <YOUR_BUCKET_NAME> and objectKey with your bucket name and existing file key.

```sh
go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/credentials
go get github.com/aws/aws-sdk-go-v2/service/s3
```

```go
   	package main

    import (
  	  "context"
  	  "fmt"
  	  "io"
  	  "log"
  	  "github.com/aws/aws-sdk-go-v2/aws"
  	  "github.com/aws/aws-sdk-go-v2/config"
  	  "github.com/aws/aws-sdk-go-v2/service/s3"
    )

    func main() {
	    cfg, err := config.LoadDefaultConfig(context.TODO())
	    if err != nil {
		    log.Fatalf("Unable to load SDK config, %v", err)
	    }

	    // Create an S3 client
	    client := s3.NewFromConfig(cfg)

	    // Specify the object key
	    bucket := "<YOUR_BUCKET_NAME>"
	    objectKey := "pfp.jpg"

	    // Fetch the object
	    output, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
		    Bucket: aws.String(bucket),
		    Key:    aws.String(objectKey),
	    })
	    if err != nil {
		    log.Fatalf("Unable to fetch object, %v", err)
	    }
	    defer output.Body.Close()

	    fmt.Println("Successfully fetched the object")

	    // Process the object content as needed
	    // For example, to save the file:
	    // file, err := os.Create("ingested_0001.parquet")
	    // if err != nil {
	    // 	log.Fatalf("Unable to create file, %v", err)
	    // }
	    // defer file.Close()
	    // _, err = io.Copy(file, output.Body)
	    // if err != nil {
	    // 	log.Fatalf("Unable to write file, %v", err)
	    // }

	    // Or to read the content:
	    content, err := io.ReadAll(output.Body)
	    if err != nil {
		    log.Fatalf("Unable to read object content, %v", err)
	    }
	    fmt.Printf("Object content length: %d bytes\n", len(content))
    }
```

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

### Custom recording app URL example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/recording-guide/create-record-app-using-sdks.mdx

Example URL provided to the Start Recording API. RealtimeKit appends authToken and config query parameters to this URL.

```txt
https://example.com/my-custom-recorder
```

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

### Run the Dynamic Workers Starter locally

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/dynamic-workers/examples/dynamic-workers-starter.mdx

Install dependencies and start the local development server. Use these commands to run the starter template on your machine.

```sh
npm install
npm run dev
```

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

### Start the local MCP server with npm start

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/model-context-protocol/guides/remote-mcp-server.mdx

Run from the project directory to launch the local development server. Check the output for the local port; in this example the MCP endpoint is http://localhost:8788/mcp.

```sh
npm start
```

```sh
⎔ Starting local server...
[wrangler:info] Ready on http://localhost:8788
```

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

### Run the quickstart script

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-search/get-started/python.mdx

Executes quickstart.py to run the instance creation, upload, and search sequence.

```sh
python quickstart.py
```

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

### Install Claude Code CLI with install script

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/claude-code.mdx

Installs the Claude Code CLI via the official install script. For Windows, Homebrew, WinGet, or npm, refer to the Claude Code setup guide.

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

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

### Install and start HTTPD on EC2

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ssl/origin-configuration/authenticated-origin-pull/aws-alb-integration.mdx

Installs the HTTPD daemon using yum and starts the service on an Amazon Linux EC2 instance. Run this during target instance setup before configuring the ALB target group.

```bash
sudo yum install -y httpd
sudo systemctl start httpd
```

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

### Navigate to the project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/tutorials/postgres.mdx

Switch into the newly created `postgres-tutorial` directory after scaffolding the Worker application.

```sh
cd postgres-tutorial
```

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

### Install the Codex CLI with npm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/codex.mdx

Installs the Codex CLI globally. macOS and Linux are fully supported; use WSL2 on Windows. For Homebrew or other install methods, see the Codex CLI setup guide.

```bash
npm install -g @openai/codex
```

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

### Initialize a new Sphinx project with sphinx-quickstart

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-a-sphinx-site.mdx

Runs sphinx-quickstart inside the active virtual environment and answers prompts for directory setup, project name, author, release, and language.

```sh
sphinx-quickstart
```

```sh output
Separate source and build directories (y/n) [n]: Y
Project name: <Your project name>
Author name(s): <You Author Name>
Project release []: <You can accept default here or provide a version>
Project language [en]: <You can accept en here or provide a regional language code>
```

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

### Install Think agent dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/harnesses/think/getting-started.mdx

Install runtime and development dependencies required for the Think agent, including @cloudflare/think, @cloudflare/computer, and React.

```sh
npm install @cloudflare/think @cloudflare/computer @cloudflare/ai-chat agents ai zod @ai-sdk/provider react react-dom
npm install -D wrangler @cloudflare/vite-plugin @cloudflare/workers-types @vitejs/plugin-react @tailwindcss/vite tailwindcss typescript vite
```

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

### Prepare the Pocket Radio repository checkout

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/sfu/examples/embedded-devices.mdx

Clone the realtime-examples repository, navigate to the esp32-radio directory, execute the setup script, and copy the example credentials configuration file.

```sh
git clone https://github.com/cloudflare/realtime-examples.git
cd realtime-examples/esp32-radio
make setup
cp .credential.env.example .credential.env
```

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

### Create and initialize project with uv and dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-catalog/get-started.mdx

Sets up a project directory, initializes a uv environment creating .venv and pyproject.toml, and adds marimo, pyiceberg, pyarrow, and pandas.

```bash
mkdir r2-data-catalog-notebook

```

```bash
cd r2-data-catalog-notebook

```

```text
uv init

```

```py
uv add marimo pyiceberg pyarrow pandas

```

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

### Index sample document via /setup endpoint

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-search/agent-sdks/ai-sdk.mdx

Triggers document indexing at the /setup route. The first indexing run may take a minute or two before returning a completed status and key.

```sh
curl http://localhost:8787/setup
```

```json
{ "key": "caching.md", "status": "completed" }
```

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

### Move into the Worker project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/workers.mdx

Change into the artifacts-worker directory created by C3 before continuing with the guide.

```sh
cd artifacts-worker
```

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

### Repo metadata JSON response

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/rest-api.mdx

Example response from the repo metadata endpoint. Returns repo metadata only; to get a new repo token, use POST /tokens.

```json
{
	"result": {
		"id": "repo_123",
		"name": "starter-repo",
		"description": null,
		"default_branch": "main",
		"created_at": "<ISO_TIMESTAMP>",
		"updated_at": "<ISO_TIMESTAMP>",
		"last_push_at": null,
		"source": null,
		"read_only": false,
		"remote": "https://<ACCOUNT_ID>.artifacts.cloudflare.net/git/default/starter-repo.git"
	},
	"success": true,
	"errors": [],
	"messages": []
}
```

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

### Run the voice agent app with npm run dev

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/examples/voice-agent.mdx

Start the development server, then open the app in your browser, select Start Call, and speak. The transcript appears in real time and the agent's response plays through your speakers.

```sh
npm run dev
```

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

### Update ChatAgent with chat, scheduleIngest, and runIngest in src/server.ts

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-memory/get-started.mdx

Update ChatAgent with the chat method, scheduling helpers, and runIngest. Keep the Session setup from step 4 where the comment indicates.

```typescript
export class ChatAgent extends Agent<Env, ChatAgentState> {
	initialState: ChatAgentState = { cursor: 0, nextIngestAt: null };

	// Keep the `session = Session.create(this)` setup from step 4 here.

	async chat(message: string): Promise<string> {
		const userMessage: UIMessage = {
			id: `user-${crypto.randomUUID()}`,
			role: "user",
			parts: [{ type: "text", text: message }],
		};
		await this.session.appendMessage(userMessage);

		await this.scheduleIngest();

		const ai = createAI({ binding: this.env.AI });
		const result = await generateText({
			model: ai("@cf/zai-org/glm-4.7-flash"),
			system: await this.session.freezeSystemPrompt(),
			messages: await convertToModelMessages(
				(await this.session.getHistory()) as UIMessage[],
			),
			tools: await this.session.tools(),
			stopWhen: stepCountIs(5),
		});

		const assistantMessage: UIMessage = {
			id: `assistant-${crypto.randomUUID()}`,
			role: "assistant",
			parts: [{ type: "text", text: result.text }],
		};
		await this.session.appendMessage(assistantMessage);

		return result.text;
	}

	async ingestScheduledMemory() {
		await this.runIngest();
	}

	private async scheduleIngest() {
		await this.cancelPendingIngest();
		await this.schedule(
			MEMORY_INGEST_DELAY_SECONDS,
			"ingestScheduledMemory",
			{},
		);
		this.setState({
			...this.state,
			nextIngestAt: Date.now() + MEMORY_INGEST_DELAY_SECONDS * 1000,
		});
	}

	private async cancelPendingIngest() {
		const pending = await this.listSchedules();
		for (const schedule of pending) {
			if (schedule.callback === "ingestScheduledMemory") {
				await this.cancelSchedule(schedule.id);
			}
		}
	}

	private async runIngest(): Promise<{ ingested: number }> {
		const history = (await this.session.getHistory()) as UIMessage[];
		const messages = history
			.slice(this.state.cursor)
			.filter(
				(message) => message.role === "user" || message.role === "assistant",
			)
			.map((message) => ({
				role: message.role,
				content: message.parts
					.map((part) => (part.type === "text" ? part.text : ""))
					.filter(Boolean)
					.join("\n\n"),
			}))
			.filter((message) => message.content);

		if (messages.length === 0) {
			this.setState({ ...this.state, nextIngestAt: null });
			return { ingested: 0 };
		}

		const profile = await this.env.MEMORY.getProfile(MEMORY_PROFILE_NAME);
		await profile.ingest(messages, { sessionId: this.name });

		this.setState({
			...this.state,
			cursor: history.length,
			nextIngestAt: null,
		});

		return { ingested: messages.length };
	}
}
```

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

### Create a new project using eleventy-base-blog

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-an-eleventy-site.mdx

Clones the `eleventy-base-blog` starter repository into a local directory, navigates into it, and installs project dependencies.

```sh
git clone https://github.com/11ty/eleventy-base-blog.git my-blog-name
cd my-blog-name
npm install
```

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

### Export environment variables for Artifacts REST API

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/rest-api.mdx

Set these environment variables before making API calls. Use a unique repo name each time you run the guide.

```sh
export ARTIFACTS_NAMESPACE="default"
export ARTIFACTS_REPO="starter-repo"
export ACCOUNT_ID="<YOUR_ACCOUNT_ID>"
export CLOUDFLARE_API_TOKEN="<YOUR_API_TOKEN>"
export ARTIFACTS_BASE_URL="https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/artifacts/namespaces/$ARTIFACTS_NAMESPACE"
```

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

### meeting.self.setupTracks(options)

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/core/api-reference/RTKSelf.md

Sets up the local media tracks.

```APIDOC
## meeting.self.setupTracks(options)

### Description
Sets up the local media tracks.

### Parameters
| Param | Type | Description |
| --- | --- | --- |
| options | Object | The audio and video options. |
| [options.video] | boolean | If true, the video stream is fetched. |
| [options.audio] | boolean | If true, the audio stream is fetched. |
| [options.forceReset] | boolean | If true, force resets tracks before re-acquiring. |

### Kind
Instance method of RTKSelf
```

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

### setUp(theme:)

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/ui-kit/api-reference/ios/app-theme.mdx

Applies a custom theme that conforms to AppThemeProtocol to the shared AppTheme instance.

```APIDOC
## setUp(theme:)

### Description
Applies a custom theme conforming to `AppThemeProtocol` to the shared AppTheme instance. This overrides the default appearance objects with those provided by the custom theme.

### Method
Instance method

### Endpoint
`AppTheme.shared.setUp(theme:)`

### Parameters
- **theme** (AppThemeProtocol) - Required - An object conforming to `AppThemeProtocol` that defines custom appearance properties.

### Response
- **Void** - This method does not return a value.

### Example
```swift
import RealtimeKitUI

class CustomTheme: AppThemeProtocol {
    // Implement required appearance properties
}

let customTheme = CustomTheme()
AppTheme.shared.setUp(theme: customTheme)
```
```

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

### Create an Artifacts repo and export variables with jq

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/workers.mdx

Send a POST request to your local Worker and use jq to extract the remote URL and token into shell variables. Requires jq to be installed.

```bash
RESPONSE=$(curl --silent http://localhost:8787/repos \
  --header "Content-Type: application/json" \
  --data '{"name":"starter-repo"}')

export ARTIFACTS_REMOTE=$(printf '%s' "$RESPONSE" | jq -r '.remote')
export ARTIFACTS_TOKEN=$(printf '%s' "$RESPONSE" | jq -r '.token')
```

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

### Create a repo with curl and extract remote and token using jq

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/rest-api.mdx

Use this jq-based approach to create a repo and automatically extract the remote Git URL and short-lived token from the response into shell variables. Requires jq to be installed.

```bash
CREATE_RESPONSE=$(curl --silent --request POST "$ARTIFACTS_BASE_URL/repos" \
  --header "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
  --header "Content-Type: application/json" \
  --data "{\"name\":\"$ARTIFACTS_REPO\"}")

export ARTIFACTS_REMOTE=$(printf '%s' "$CREATE_RESPONSE" | jq -r '.result.remote')
export ARTIFACTS_TOKEN=$(printf '%s' "$CREATE_RESPONSE" | jq -r '.result.token')
```

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

### Run a preparation command on startup with onStart() and output()

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/containers/guides/execute-commands.mdx

Use the onStart() lifecycle hook to execute commands when a Container starts. process.output() buffers standard output and standard error as separate ArrayBuffer instances.

```typescript
import { Container } from "@cloudflare/containers";

export class MyContainer extends Container {
	override async onStart() {
		const process = await this.ctx.container.exec([
			"node",
			"scripts/prepare.js",
		]);
		const output = await process.output();
		const decoder = new TextDecoder();

	if (output.exitCode !== 0) {
		throw new Error(
			`Container preparation failed: ${decoder.decode(output.stderr)}`,
		);
	}

	console.log(decoder.decode(output.stdout));
    }

}
```

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

### Install the Cloudflare SDK

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/workers-for-platforms/reference/platform-examples.mdx

Install the official Cloudflare npm package before using the TypeScript SDK examples.

```sh
npm install cloudflare
```

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

### Navigate into the new project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/demos/chatgpt-app.mdx

Run after creating the my-chess-app project to move into its directory before installing dependencies.

```sh
cd my-chess-app
```

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

### Test D1 Worker Binding APIs in index.js

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/d1/worker-api/index.mdx

Routes incoming requests based on the URL pathname to test various D1 Worker Binding API methods such as run, raw, first, batch, exec, and withSession. Replaces the contents of index.js following the initial Get started setup.

```js
// D1 API Playground - Test each D1 Worker Binding API method
// Change the URL pathname to test different methods (e.g., /RUN, /RAW, /FIRST)
export default {
	async fetch(request, env) {
	  const { pathname } = new URL(request.url);

		// Sample data for testing
		const companyName1 = `Bs Beverages`;
		const companyName2 = `Around the Horn`;

		// Prepare reusable statements
		const stmt = env.DB.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);
		const stmtMulti = env.DB.prepare(`SELECT * FROM Customers; SELECT * FROM Customers WHERE CompanyName = ?`);
		const session = env.DB.withSession("first-primary")
		const sessionStmt = session.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);

      // Test D1PreparedStatement::run - returns full D1Result object
      if (pathname === `/RUN`){
    	const returnValue = await stmt.bind(companyName1).run();
    	return Response.json(returnValue);

      // Test D1PreparedStatement::raw - returns array of arrays
    } else if (pathname === `/RAW`){
    	const returnValue = await stmt.bind(companyName1).raw();
    	return Response.json(returnValue);

      // Test D1PreparedStatement::first - returns first row only
    } else if (pathname === `/FIRST`){
    	const returnValue = await stmt.bind(companyName1).first();
    	return Response.json(returnValue);

      // Test D1Database::batch - execute multiple statements
    } else if (pathname === `/BATCH`) {
    	const batchResult = await env.DB.batch([
    		stmt.bind(companyName1),
    		stmt.bind(companyName2)
    	]);
    	return Response.json(batchResult);

      // Test D1Database::exec - execute raw SQL without parameters
    } else if (pathname === `/EXEC`){
    	const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
    	return Response.json(returnValue);

      // Test D1 Sessions API with read replication
    } else if (pathname === `/WITHSESSION`){
    	const returnValue = await sessionStmt.bind(companyName1).run();
    	console.log("You're now using D1 Sessions!")
    	return Response.json(returnValue);
    }

      // Default response with instructions
      return new Response(
    	`Welcome to the D1 API Playground!
    	\nChange the URL to test the various methods inside your index.js file.`,
      );
    },

};
```

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

### Initialize a new Hexo project

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-a-hexo-site.mdx

Run `hexo init` to scaffold a new Hexo project and navigate into the project directory.

```sh
hexo init my-hexo-site
cd my-hexo-site
```

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

### Clone and install privacypass-ts repository

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/privacy-pass/getting-started.mdx

Clone the repository and install dependencies before running the local Privacy Pass examples.

```sh
git clone https://github.com/cloudflare/privacypass-ts.git
cd privacypass-ts
npm ci
```

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

### Stop the server with DELETE and restart with GET

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/commands/run-a-server-in-the-background.mdx

Send a DELETE request to stop the server, then a GET request to start it again. The DELETE request responds with 202; the next request starts the server and prints the same response.

```sh
curl https://<YOUR_WORKER>.<YOUR_SUBDOMAIN>.workers.dev/server --request DELETE
curl https://<YOUR_WORKER>.<YOUR_SUBDOMAIN>.workers.dev/server
```

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

### Start local development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/framework-guides/web-apps/more-web-frameworks/analog.mdx

Runs the local development server to preview the Analog application locally.

```npm
npm run dev
```

```pnpm
pnpm run dev
```

```yarn
yarn run dev
```

```bun
bun run dev
```

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

### Install Apache and create test HTML page

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/networks/connectors/cloudflare-tunnel/deployment-guides/azure.mdx

Updates apt package repositories, installs the Apache HTTP server, and writes a sample test landing page to verify web server connectivity.

```bash
apt update

apt -y install apache2

cat <<EOF > /var/www/html/index.html
<html><body><h1>Hello Cloudflare!</h1>
<p>This page was created for a Cloudflare demo.</p>
</body></html>
EOF
```

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

### Create an Artifacts repo in a Worker fetch handler

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/workers.mdx

Replace src/index.ts with this Worker that creates an Artifacts repo on POST /repos and returns the remote URL and initial write token. This example omits authentication; in production, authorize the caller before creating repos or returning write tokens.

```ts
export default {
	async fetch(request, env) {
		const url = new URL(request.url);

		if (request.method === "POST" && url.pathname === "/repos") {
			// Read the repo name from the request body so the route is reusable.
			const body = await request.json().catch(() => ({}));

			const repoName = body.name ?? "starter-repo";

			// Create the repo and return the remote URL plus initial write token.
			const created = await env.ARTIFACTS.create(repoName);

			return Response.json({
				name: created.name,
				remote: created.remote,
				token: created.token,
			});
		}

		return new Response("Use POST /repos to create an Artifacts repo.", {
			status: 405,
			headers: { Allow: "POST" },
		});
	},
};
```

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

### Start local development with wrangler dev

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/workers.mdx

Run this command to start local development for your Worker. Open a second terminal afterward to send requests to the Worker.

```bash
npx wrangler dev
```

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

### Start development server with npm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/durable-objects/tutorials/build-a-seat-booking-app.mdx

Run the local development server to serve the application frontend at http://localhost:8787.

```bash
npm run dev
```

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

### Launch interactive setup wizard with Wrangler CLI

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-pipelines/sinks/manage-sinks.mdx

Use the interactive setup wizard to configure a stream, sink, and pipeline together.

```bash
<PackageManagers type="exec" pkg="wrangler" args={"basin pipelines setup"} />
```

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

### Install cloudflared service to run at login

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/locally-managed/as-a-service/macos.mdx

Installs Cloudflare Tunnel as a launch agent that starts whenever you log in, using the configuration in ~/.cloudflared/.

```sh
cloudflared service install
```

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

### Install and Run cloudflared on macOS

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/setup/replace-vpn/device-to-network.mdx

Installs the cloudflared connector via Homebrew and starts the service using the provided tunnel token on macOS.

```sh
brew install cloudflared && sudo cloudflared service install <YOUR_TUNNEL_TOKEN>
```

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

### RealtimeKitClient.initMedia([options], [skipAwaits], [cachedUserDetails])

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/core/api-reference/RealtimeKitClient.md

Static method to initialize media devices and settings. Accepts optional parameters for configuration, skipping awaits, and cached user details.

```APIDOC
## RealtimeKitClient.initMedia([options], [skipAwaits], [cachedUserDetails])

### Description
Static method to initialize media devices and settings. Accepts optional parameters for configuration, skipping awaits, and cached user details.

### Method
Static method

### Parameters
- **options** (object) - Optional - Media initialization options.
- **skipAwaits** (boolean) - Optional - Whether to skip awaiting certain operations.
- **cachedUserDetails** (object) - Optional - Cached user details to use during initialization.

### Returns
A Promise that resolves when media initialization is complete.
```

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

### Initialize partition using lunacm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ssl/keyless-ssl/hardware-security-modules/ibm-cloud-hsm.mdx

Run lunacm from your virtual server and initialize the assigned partition with a label and domain password.

```txt
vm$ lunacm
LunaCM v7.1.0-379. Copyright (c) 2006-2017 SafeNet.

    Available HSMs:

    Slot Id ->              0
    Label ->
    Serial Number ->        XXXXXXXXXXXXX
    Model ->                LunaSA 7.0.0
    Firmware Version ->     7.0.1
    Configuration ->        Luna User Partition With SO (PW) Signing With Cloning Mode
    Slot Description ->     Net Token Slot


    Current Slot Id: 0

lunacm:>partition init -label KeylessSSL -domain cloudflare

  Enter password for Partition SO: ********

  Re-enter password for Partition SO: ********

  You are about to initialize the partition.
  All contents of the partition will be destroyed.

  Are you sure you wish to continue?

  Type 'proceed' to continue, or 'quit' to quit now ->proceed

Command Result : No Error
```

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

### Set up environment variables

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/hyperdrive/examples/connect-to-postgres/postgres-drivers-and-libraries/prisma-orm.mdx

Add your database connection string to the .env file created by Prisma.

```txt
DATABASE_URL="postgres://user:password@host:port/database"
```

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

### Start local development with Wrangler

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-memory/get-started.mdx

Run the local development server for the Agent Memory app using Wrangler.

```bash
npx wrangler dev
```

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

### Create installation script file

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/tutorials/deploy-client-headless-linux.mdx

Sets file creation permissions and opens a new shell script in Vim.

```sh
umask 077
vim install_warp.sh
```

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

### Complete Android video view example in Kotlin

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/core/local-participant.mdx

Full activity example showing self-preview video view setup, lifecycle handling, and resource cleanup.

```kotlin
import android.os.Bundle
import android.widget.FrameLayout
import androidx.appcompat.app.AppCompatActivity
import io.dyte.core.VideoView

class MainActivity : AppCompatActivity() {
    private lateinit var videoView: VideoView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Get the self-preview video view
        videoView = meeting.localUser.getSelfPreview()

        // Add to your layout
        val container = findViewById<FrameLayout>(R.id.video_container)
        container.addView(videoView)

        // Start rendering
        videoView.renderVideo()
    }

    override fun onPause() {
        super.onPause()
        // Stop rendering when activity is paused
        videoView.stopVideoRender()
    }

    override fun onResume() {
        super.onResume()
        // Resume rendering when activity is resumed
        videoView.renderVideo()
    }

    override fun onDestroy() {
        super.onDestroy()
        // Clean up resources
        videoView.release()
    }
}
```

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

### env.BROWSER.launch()

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/browser-run/reference/browser-binding-api.mdx

Performs session acquisition and connection capability setup in a single call.

```APIDOC
### env.BROWSER.launch()

#### Description
Performs the acquire and connection-capability steps in one call when separating acquisition from connection is not needed.

#### Return Value
Returns a `Promise<Connection>` resolving to an object containing:
- `sessionId` (string) - The Browser Run session ID.
- `webSocket` (Fetcher) - A session-pinned `Fetcher` used to open a CDP connection.
- `targets` (Array, optional) - The target list if returned.

#### Example
```ts
const session = await env.BROWSER.launch();
const response = await session.webSocket.fetch(
  "https://browser-binding.invalid",
  { headers: { Upgrade: "websocket" } }
);
```
```

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

### Install cloudflared service to run at boot

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/locally-managed/as-a-service/macos.mdx

Installs Cloudflare Tunnel as a launch daemon requiring root privileges, starting on system boot and using configuration in /etc/cloudflared.

```sh
sudo cloudflared service install
```

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

### Start Local Development Server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/r2/tutorials/summarize-pdf.mdx

Run the development server locally to preview the front-end application.

```sh
npm run dev
```

```txt output
 ⛅️ wrangler 3.80.2
-------------------

⎔ Starting local server...
[wrangler:inf] Ready on http://localhost:8787
╭───────────────────────────╮
│  [b] open a browser       │
│  [d] open devtools        │
│  [l] turn off local mode  │
│  [c] clear console        │
│  [x] to exit              │
╰───────────────────────────╯
```

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

### Install Cloudflare root certificate in Alpine-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Alpine-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	alpine-app:
		image: alpine:3.18
 		volumes:
 			- certs/certificate.pem:/usr/local/share/ca-certificates/certificate.pem
 		entrypoint: /bin/sh -c "apk add --no-cache ca-certificates && update-ca-certificates && app start"
```

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

### Start development server with npm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/sdk/get-started.mdx

Starts the local development server. The first run builds the Docker container (taking 2-3 minutes), while subsequent runs use cached builds.

```sh
npm run dev
# If you expect to have multiple sandbox instances, you can increase `max_instances`.
```

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

### Install Cloudflare root certificate in Debian-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Debian-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	debian-app:
		image: debian:12
 		volumes:
 			- certs/certificate.pem:/usr/local/share/ca-certificates/certificate.crt
 		entrypoint: /bin/sh -c "apt-get update && apt-get install -y ca-certificates && update-ca-certificates && app start"
```

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

### Start Prometheus with configuration file

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/metrics/grafana-tutorial.mdx

Run the Prometheus server binary with the specified prometheus.yml configuration file.

```sh
./prometheus --config.file="prometheus.yml"
```

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

### Get a Workflow instance by ID with get

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workflows/build/workers-api.mdx

get(id) returns a WorkflowInstance and throws an exception if the ID does not exist or is invalid, so wrap the call in try/catch. The example returns the instance ID and its status as JSON.

```typescript
// Fetch an existing Workflow instance by ID:
try {
	let instance = await env.MY_WORKFLOW.get(id);
	return Response.json({
		id: instance.id,
		details: await instance.status(),
	});
} catch (e: any) {
	// Handle errors
	// .get will throw an exception if the ID doesn't exist or is invalid.
	const msg = `failed to get instance ${id}: ${e.message}`;
	console.error(msg);
	return Response.json({ error: msg }, { status: 400 });
}
```

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

### Navigate to project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/tutorials/create-finetuned-chatgpt-ai-models-with-r2.mdx

Switch into the newly initialized project directory created by the C3 CLI.

```sh
cd finetune-chatgpt-model
```

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

### Example JRE path for Android Studio

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

This is an example of the JRE path shown in Android Studio's About dialog. Use it to set the JAVA_HOME environment variable for certificate installation.

```txt
/Applications/Android Studio.app/Contents/jbr/Contents/Home
```

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

### Create a project with cf init

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cf/get-started/first-worker.mdx

Scaffolds a new project directory, installs dependencies, and generates types for bindings.

```sh
cf init my-worker
```

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

### List tokens for a repo — curl example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/api/rest-api.mdx

Send a GET request to list tokens for a repo. The example uses state=all, per_page=30, and page=1.

```bash
curl "$ARTIFACTS_BASE_URL/repos/$ARTIFACTS_REPO/tokens?state=all&per_page=30&page=1" \
  --header "Authorization: Bearer $CLOUDFLARE_API_TOKEN"
```

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

### List application instances with tabular output

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/workers/wrangler-commands/containers.mdx

Shows an example command to list container instances for an application along with the resulting tabular output.

```sh
wrangler containers instances 12345678-abcd-1234-abcd-123456789abc
```

```sh output
INSTANCE                              NAME        STATE          LOCATION  VERSION  CREATED
a1b2c3d4-e5f6-7890-abcd-ef1234567890  worker-12   running        sfo06     3        2025-06-01T12:00:00Z
b2c3d4e5-f6a7-8901-bcde-f12345678901  worker-47   provisioning   iad01     2        2025-06-01T13:00:00Z
```

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

### Start server and wait for readiness in Durable Object

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/previews/index.mdx

Use this method to start the container and wait until the server responds. It sends GET / requests until any HTTP response arrives, for up to 30 seconds, because start() returns before the server listens.

```typescript
export class MyContainer extends DurableObject<Env> {
	// ...

	// Skip the check after the first response
	private ready = false;

	private async startServer(): Promise<Container> {
		const container = this.ctx.container;

		if (!container) {
			throw new Error("No container is configured");
		}

		if (!container.running) {
			container.start({
				image: "cloudflare/debian-trixie",
				entrypoint: ["node", "--eval", server],
				enableInternet: false,
			});
			await container.setInactivityTimeout(INACTIVITY_TIMEOUT_MS);
			this.ready = false;
		}

		// `start()` returns before the server listens. Send `GET /` until any
		// HTTP response arrives, for up to 30 seconds
		const deadline = Date.now() + 30_000;

		while (!this.ready && Date.now() < deadline) {
			try {
				const response = await container
					.getTcpPort(port)
					.fetch("http://container/", { signal: AbortSignal.timeout(1_000) });
				await response.body?.cancel();
				this.ready = true;
			} catch {
				await scheduler.wait(500);
			}
		}

		return container;
	}
}
```

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

### Check Node.js version for the cf proxy setup

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/cloud-workload-security/troubleshooting/index.mdx

Run in the client terminal to confirm Node.js 24.5 or later, which the documented cf setup requires. Set NODE_USE_ENV_PROXY=1 before starting the client.

```sh
node --version
```

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

### Create sample index.html file

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/kv/examples/workers-kv-to-serve-assets.mdx

Create a static asset file named index.html to store in Workers KV.

```html
Hello World!

```

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

### Call intercept() in container setup after start

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/reference/directory-backups.mdx

Call intercept() in the setup that runs after you start the container, and again when a restarted Durable Object finds the container running. Do not call intercept() while a backup or restore can be running. A container that registered the catch-all first keeps sending backup traffic to it; restart the container to use intercept().

```typescript
#setup: Promise<void> | null = null;

// Call before each use of the container.
#ensureRunning(container: Container): Promise<void> {
	// Set up each new container, and a running container
	// after this Durable Object restarts.
	if (this.#setup === null || !container.running) {
		this.#setup = this.#setUp(container).catch((error) => {
			this.#setup = null;
			throw error;
		});
	}
	return this.#setup;
}

async #setUp(container: Container): Promise<void> {
	if (!container.running) {
		container.start({
			image: container.images.sandbox,
			enableInternet: false,
		});
	}
	await this.#backups.intercept();
	await container.interceptAllOutboundHttp(
		this.ctx.exports.Outbound({ props: {} }),
	);
}
```

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

### Initialize RealtimeKit with breakout rooms support in Web Components

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/ui-kit/breakout-rooms.mdx

Use this HTML example to initialize the SDK and update the meeting object reference when the meetingChanged event fires.

```html
<script type="module">
	import RealtimeKitClient from "https://cdn.jsdelivr.net/npm/@cloudflare/realtimekit@latest/dist/index.es.js";

	let meeting = await RealtimeKitClient.init({
		authToken: "<participant_auth_token>",
	});

	// Add event handler for breakout rooms
	meeting.connectedMeetings.on("meetingChanged", (newMeeting) => {
		meeting = newMeeting;
		document.querySelector("rtk-meeting").meeting = meeting;
	});
</script>
```

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

### Complete Wrangler Configuration Example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/queues/tutorials/handle-rate-limits/index.mdx

Complete Wrangler configuration file example with project metadata, nodejs compatibility, and queue bindings configured for rate limits.

```jsonc
{
	"$schema": "./node_modules/wrangler/config-schema.json",
	"name": "resend-rate-limit-queue",
	"main": "src/index.ts",
	"upload_source_maps": true,
	"compatibility_date": "$today",
	"compatibility_flags": [
		"nodejs_compat"
		],
	"queues": {
		"producers": [
			{
				"binding": "EMAIL_QUEUE",
				"queue": "rate-limit-queue"
			}
		],
		"consumers": [
			{
				"queue": "rate-limit-queue",
				"max_batch_size": 2,
				"max_batch_timeout": 10,
				"max_retries": 3
			}
		]
	}
}
```

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

### Install Cloudflare root certificate in Red Hat-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Red Hat-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	redhat-app:
		image: registry.access.redhat.com/ubi9/ubi:latest
 		volumes:
 			- certs/certificate.pem:/etc/pki/ca-trust/source/anchors/certificate.pem
 		entrypoint: /bin/sh -c "dnf install -y ca-certificates && update-ca-trust extract && app start"
```

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

### rtk-participant-setup with Properties

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/ui-kit/api-reference/angular/rtk-participant-setup.mdx

Example showing rtk-participant-setup with isPreview, nameTagPosition, and participant properties bound.

```html
<!-- component.html -->
<rtk-participant-setup
 [isPreview]="true"
 [nameTagPosition]="| 'bottom-left'
    | 'bottom-right'
    | 'bottom-center'
    | 'top-left'
    | 'top-right'
    | 'top-center'"
 [participant]="participant">
</rtk-participant-setup>
```

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

### intercept

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/reference/directory-backups.mdx

Routes backup traffic from the container to DirectoryBackupGateway, which refuses every request until a backup or restore starts. This method does not start the container. It should be called in the setup that runs after starting the container and again when a restarted Durable Object finds the container running.

```APIDOC
## intercept

### Description
Routes backup traffic from the container to `DirectoryBackupGateway`, which refuses every request until a backup or restore starts. `intercept()` does not start the container.

### Method
`intercept`

### Endpoint
`intercept(): Promise<void>`

### Parameters
None.

### Response
#### Success Response
- **void** - No return value.

### Errors
- If the Durable Object also calls `interceptAllOutboundHttp()`, call `intercept()` before it. Otherwise the catch-all receives the backup traffic from the container, and `backup()` and `restore()` fail with `BACKUP_TRANSFER`.
- Do not call `intercept()` while a backup or restore can be running. It replaces the access of the running operation, and the operation fails.
- A container that registered the catch-all first keeps sending backup traffic to it. Restart the container to use `intercept()`.
```

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

### Run Docker Compose container

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Run this command to start the container with the certificate installed at runtime.

```sh
docker-compose up
```

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

### Start Trino Docker container with R2 catalog

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-catalog/config-examples/trino.mdx

Prepares the catalog directory, copies the configuration file, and starts a Trino Docker container mounting the catalog volume.

```bash
# Create a local directory for the catalog configuration
mkdir -p trino-catalog

# Place your r2.properties file in the catalog directory
cp r2.properties trino-catalog/

# Run Trino with the catalog configuration
docker run -d \
  --name trino-r2 \
  -p 8080:8080 \
  -v $(pwd)/trino-catalog:/etc/trino/catalog \
  trinodb/trino:latest
```

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

### Deploy static assets directory with interactive setup

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/changelog/workers/2025-09-09-interactive-wrangler-assets.mdx

Deploys a static site directory using the simplified command syntax, initiating interactive prompts for project setup.

```bash
wrangler deploy dist
# Interactive prompts handle the rest as shown in the example flow below
```

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

### Get repo metadata with curl

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/artifacts/get-started/rest-api.mdx

Fetch repo metadata to recover the remote URL later. Requires the Authorization header with a Cloudflare API token.

```bash
curl "$ARTIFACTS_BASE_URL/repos/$ARTIFACTS_REPO" \
  --header "Authorization: Bearer $CLOUDFLARE_API_TOKEN"
```

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

### Apply a custom theme with setUp(theme:)

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/humans/ui-kit/api-reference/ios/app-theme.mdx

Defines a custom theme conforming to AppThemeProtocol and applies it via AppTheme.shared.setUp(theme:).

```swift
import RealtimeKitUI

class CustomTheme: AppThemeProtocol {
    // Implement required appearance properties
}

let customTheme = CustomTheme()
AppTheme.shared.setUp(theme: customTheme)
```

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

### Example folder structure for multitenant data

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/changelog/ai-search/2025-04-23-autorag-metadata-filtering.mdx

Organize content into per-tenant folders to allow scoped search queries across specific customer datasets.

```bash
customer-a/logs/
customer-a/contracts/
customer-b/contracts/
```

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

### Navigate to the project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-gateway/integrations/aig-workers-ai-binding.mdx

Change into the newly created hello-ai project directory after running the create-cloudflare CLI tool.

```bash
cd hello-ai
```

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

### Ask your agent to install cf and update AGENTS.md

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cf/agents.mdx

Prompt you can give your agent to perform the cf setup for you, including installing the CLI and adding the cf preference line to your user-level AGENTS.md or CLAUDE.md file.

```txt
Install the Cloudflare CLI with `npm install -g cf`. Then add this line to my
user-level AGENTS.md or CLAUDE.md file: "When interacting with Cloudflare, use
the cf CLI unless the project has a Wrangler configuration file."
```

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

### Navigate to the project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/tutorials/build-a-jamstack-app.mdx

Change into the newly created `todos` project directory after initializing the project.

```sh
cd todos
```

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

### Get session tools and merge with custom tools

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/runtime/lifecycle/sessions.mdx

Call `session.tools()` to get tools generated from your context block provider types, then spread them alongside your own tools before passing to your LLM.

```typescript
const tools = await session.tools();
const allTools = { ...tools, ...myTools };
```

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

### Use startsWith function in queries

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/analytics/analytics-engine/sql-reference/string-functions.mdx

Query examples checking if a string or dataset column starts with a specified prefix.

```sql
SELECT startsWith('prefix ...', 'prefix') AS b;
SELECT startsWith(blob1, 'prefix') AS b FROM your_dataset;
```
Tokens:
Raw