### Install Image-to-Video Guide Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/video/p-video/SKILL.md

Installs a skill that provides a guide for image-to-video generation.

```bash
npx skills add inference-sh/skills@image-to-video
```

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

### Quick Start: Open a Page

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/agent-browser/SKILL.md

Log in to the belt CLI and open a web page to get interactive elements. Use --session new to start a new browser session.

```bash
belt login

# Open a page and get interactive elements
belt app run agent-browser --function open --input '{"url": "https://example.com"}' --session new
```

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

### Quick Start: Run Pruna P-Video

Source: https://github.com/inference-sh/skills/blob/main/tools/video/p-video/SKILL.md

A basic example to quickly start generating a video using the P-Video model with a text prompt.

```bash
belt app run pruna/p-video --input '{"prompt": "drone shot flying over a forest at sunset"}'
```

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

### Workflow Example: Image Generation

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/running-apps.md

A step-by-step example for generating images, including getting app details, generating a sample input, editing the input file, and running the app.

```bash
# 1. Get app details
belt app get falai/flux-dev-lora
```

```bash
# 2. Generate sample input
belt app sample falai/flux-dev-lora --save input.json
```

```json
# 3. Edit input.json
# {
#   "prompt": "a cat astronaut floating in space",
#   "num_images": 1,
#   "image_size": "landscape_16_9"
# }
```

```bash
# 4. Run
belt app run falai/flux-dev-lora --input input.json
```

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

### Generate Tutorial/Explainer Dialogue

Source: https://github.com/inference-sh/skills/blob/main/tools/audio/elevenlabs-dialogue/SKILL.md

Generate dialogue for a tutorial or explainer, detailing a step-by-step process. This example shows a conversation guiding through a setup process.

```bash
belt app run elevenlabs/text-to-dialogue --input '{
  "segments": [
    {"text": "Can you walk me through the setup process?", "voice": "jessica"},
    {"text": "Sure. Step one, install the CLI. It takes about thirty seconds.", "voice": "daniel"},
    {"text": "And then what?", "voice": "jessica"},
    {"text": "Step two, run the login command. It opens your browser for authentication.", "voice": "daniel"},
    {"text": "That sounds simple enough.", "voice": "jessica"},
    {"text": "It is. Step three, you are ready to run your first app.", "voice": "daniel"}
  ]
}'
```

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

### Run an AI App with Python SDK

Source: https://github.com/inference-sh/skills/blob/main/sdk/python-sdk/SKILL.md

Quick start example demonstrating how to initialize the client and run an AI app with input. The result of the AI app is printed to the console.

```python
from inferencesh import inference

client = inference(api_key="inf_your_key")

# Run an AI app
result = client.run({
    "app": "infsh/flux-1-dev",
    "input": {"prompt": "A sunset over mountains"}
})
print(result["output"])
```

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

### Add Video Prompting Guide Skill

Source: https://github.com/inference-sh/skills/blob/main/guides/video/storyboard-creation/SKILL.md

Use this command to add the video prompting guide skill to your project. Ensure you have the 'skills' CLI installed.

```bash
npx skills add inference-sh/skills@video-prompting-guide
```

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

### Product Demo Prompt Example

Source: https://github.com/inference-sh/skills/blob/main/guides/prompting/video-prompting-guide/SKILL.md

Use this example to generate prompts for product demonstrations. It includes keywords for camera movement, lighting, and style.

```bash
belt app run google/veo-3-1-fast --input '{ "prompt": "Smooth tracking shot around a sleek smartphone on a white pedestal, soft studio lighting, product photography style, reflections on surface, 4K, shallow depth of field" }'
```

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

### Initialize a New App

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/cli.md

Creates a new application project. Use non-interactive mode for Python (default) or Node.js, or run interactively for guided setup.

```bash
# Create
belt app init my-app              # Non-interactive (Python default)
belt app init my-app --lang node  # Non-interactive (Node.js)
belt app init                     # Interactive
```

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

### Install All Skills with npx

Source: https://github.com/inference-sh/skills/blob/main/README.md

Install all available inference.sh skills using the npx command. This is a convenient way to get the entire suite of tools.

```bash
npx skills add inference-sh/skills
```

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

### Setup Parameters with Defaults

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/node-app-logic.md

Illustrates how to define setup parameters using Zod, including default values and descriptions, which are used to configure the application during initialization.

```javascript
export const AppSetup = z.object({
  modelId: z.string().default("gpt2").describe("Model to load"),
  precision: z.string().default("fp16").describe("Model precision"),
});

export class App {
  async setup(config) {
    // config is validated against AppSetup — defaults filled in
    this.model = await loadModel(config.modelId);
  }
}
```

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

### Install a Skill by Name and Version

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/related-skill/SKILL.md

Installs a specific skill, including its version, from the inference.sh registry. Ensure the skill name and version are correct.

```bash
# Install a skill
npx skills add inference-sh/skills@ai-image-generation
```

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

### Install Agent Component and SDK

Source: https://github.com/inference-sh/skills/blob/main/ui/agent-ui/SKILL.md

Install the agent component using npx and add the SDK for the proxy route.

```bash
# Install the agent component
npx shadcn@latest add https://ui.inference.sh/r/agent.json

# Add the SDK for the proxy route
npm install @inferencesh/sdk
```

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

### Workflow Example: Video Generation

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/running-apps.md

An example workflow for video generation, demonstrating how to generate sample input, edit the prompt, and run the video generation app.

```bash
# 1. Generate sample
belt app sample google/veo-3-1-fast --save input.json
```

```json
# 2. Edit prompt
# {
#   "prompt": "A drone shot flying over a forest at sunset"
# }
```

```bash
# 3. Run
belt app run google/veo-3-1-fast --input input.json
```

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

### Basic Client Setup with Proxy

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/references/react-integration.md

Initialize the inference.sh client, pointing to your proxy URL. This setup avoids exposing your API key in the browser.

```typescript
import { inference } from '@inferencesh/sdk';

// Create client with proxy (no API key in browser)
const client = inference({ proxyUrl: '/api/inference/proxy' });
```

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

### Install Python SDK

Source: https://github.com/inference-sh/skills/blob/main/sdk/python-sdk/SKILL.md

Install the inference.sh Python SDK using pip. For async support, install with the `async` extra.

```bash
pip install inferencesh
```

```bash
pip install inferencesh[async]
```

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

### Add Video Prompting Skill

Source: https://github.com/inference-sh/skills/blob/main/guides/prompting/prompt-engineering/SKILL.md

Use this command to add the video prompting guide skill to your project. Ensure you have the CLI installed.

```bash
# Video prompting guide
npx skills add inference-sh/skills@video-prompting-guide
```

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

### Install and Run Google Veo CLI

Source: https://github.com/inference-sh/skills/blob/main/tools/video/google-veo/SKILL.md

Installs the belt CLI skill and runs a basic text-to-video generation with the Veo 3.1 Fast model.

```bash
belt login

belt app run google/veo-3-1-fast --input '{"prompt": "drone shot over a mountain lake"}'
```

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

### Install and Login to Belt CLI

Source: https://github.com/inference-sh/skills/blob/main/guides/video/storyboard-creation/SKILL.md

Install the belt CLI skill and log in to your inference.sh account before generating storyboards.

```bash
npx skills add belt-sh/cli
```

```bash
belt login
```

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

### Install and Run Video Prompting CLI

Source: https://github.com/inference-sh/skills/blob/main/guides/prompting/video-prompting-guide/SKILL.md

Installs the belt CLI skill for interacting with inference.sh. Then, it demonstrates how to log in and run a video generation prompt for the google/veo-3-1-fast model.

```bash
npx skills add belt-sh/cli
```

```bash
belt login

# Well-structured video prompt
belt app run google/veo-3-1-fast --input '{ "prompt": "Cinematic tracking shot of a red sports car driving through Tokyo at night, neon lights reflecting on wet streets, rain falling, 4K, shallow depth of field" }'
```

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

### Install the Full Platform Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/related-skill/SKILL.md

Installs a comprehensive skill that includes all 250+ applications available on inference.sh. Use this for maximum capability access.

```bash
# Install the full platform skill with all 250+ apps
npx skills add inference-sh/skills@infsh-cli
```

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

### Workflow Example: Text-to-Speech

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/running-apps.md

A quick example for text-to-speech generation using an inline input. This demonstrates a simple and direct way to use the TTS app.

```bash
# Quick inline run
belt app run infsh/kokoro-tts --input '{"text": "Hello, this is a test."}'
```

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

### Install @inferencesh/sdk

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/SKILL.md

Install the SDK package using npm, yarn, or pnpm. Node.js 18.0.0+ or a modern browser with fetch is required.

```bash
npm install @inferencesh/sdk
```

```bash
yarn add @inferencesh/sdk
```

```bash
pnpm add @inferencesh/sdk
```

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

### Build an App Tool with Setup and Input Defaults

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/references/tool-builder.md

Configure an app tool with hidden setup parameters and default input values. This allows for more advanced customization of the app's behavior.

```typescript
import { appTool, string } from '@inferencesh/sdk';

// App tool with setup and defaults
const translate = appTool('translate', 'infsh/translator@latest')
  .describe('Translate text between languages')
  .param('text', string('Text to translate'))
  .param('targetLang', string('Target language code'))
  .setup({
    model: 'advanced',
    preserveFormatting: true
  })
  .input({
    sourceLang: 'auto'
  })
  .build();
```

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

### Install Chat Components with shadcn-ui

Source: https://github.com/inference-sh/skills/blob/main/ui/chat-ui/SKILL.md

Use this command to install the chat components using the shadcn-ui CLI. This command fetches the chat component configuration from the specified URL.

```bash
npx shadcn@latest add https://ui.inference.sh/r/chat.json
```

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

### Install Pruna P-Image Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/image/gpt-image/SKILL.md

Install the Pruna P-Image skill, known for being fast and economical.

```bash
npx skills add inference-sh/skills@p-image
```

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

### Changelog Page Structure Example

Source: https://github.com/inference-sh/skills/blob/main/guides/product/product-changelog/SKILL.md

A markdown example demonstrating how to structure a changelog page, including dates, categories, and feature descriptions.

```markdown
# Changelog

## February 8, 2026

### New
- **Bulk Export for Reports** — Export up to 10,000 rows at once. [Learn more →](link)
- **Dark Mode** — Toggle dark mode from Settings > Appearance.

### Improved
- **Dashboard Loading** — Dashboards now load 3x faster on large datasets.
- **Search** — Search results now include archived items.

### Fixed
- Fixed an issue where exported CSV files had missing column headers.
- Fixed a bug where the date picker showed incorrect timezone.

---

## February 1, 2026

### New
- **API Webhooks** — Get notified when events happen in your account.

### Fixed
- Fixed an issue where email notifications were delayed by up to 2 hours.
```

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

### Install CLI via curl

Source: https://github.com/inference-sh/skills/blob/main/cli-install.md

Use this command to download and execute the installation script directly from inference.sh. This method is suitable for most users on Linux and macOS.

```sh
curl -fsSL cli.inference.sh | sh
```

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

### Generate Tutorial/How-To OG Image

Source: https://github.com/inference-sh/skills/blob/main/guides/design/og-image-design/SKILL.md

Use this template to create an Open Graph image for a tutorial or how-to guide. It includes a distinct 'TUTORIAL' badge and a clear title for the guide.

```bash
belt app run infsh/html-to-image --input '{ "html": "<div style=\"width:1200px;height:630px;background:linear-gradient(to right,#1a1a2e,#16213e);display:flex;align-items:center;padding:60px;font-family:system-ui;color:white"><div><div style=\"display:inline-block;background:#e74c3c;color:white;padding:8px 16px;border-radius:4px;font-size:16px;font-weight:bold;margin-bottom:16px\">TUTORIAL</div><h1 style=\"font-size:48px;margin:0;line-height:1.2\">Build a REST API in 10 Minutes with Node.js</h1><p style=\"font-size:20px;opacity:0.7;margin-top:16px\">Step-by-step guide with code examples</p></div></div>" }'
```

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

### Install Agent UI Skill

Source: https://github.com/inference-sh/skills/blob/main/ui/tools-ui/SKILL.md

Install the full agent UI skill, which is recommended for a complete agent component experience.

```bash
npx skills add inference-sh/skills@agent-ui
```

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

### Manual Install inference.sh CLI

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/SKILL.md

Provides steps for manually downloading, verifying, and installing the inference.sh CLI if piping to sh is not preferred. Includes checksum verification.

```bash
# Download the binary and checksums
curl -LO https://dist.inference.sh/cli/checksums.txt
curl -LO $(curl -fsSL https://dist.inference.sh/cli/manifest.json | grep -o '"url":"[^"]*"' | grep $(uname -s | tr A-Z a-z)-$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') | head -1 | cut -d'"' -f4)
# Verify checksum
sha256sum -c checksums.txt --ignore-missing
# Extract and install
tar -xzf inferencesh-cli-*.tar.gz
mv inferencesh-cli-* ~/.local/bin/inferencesh
```

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

### Define Setup Parameters for Re-initialization

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/python-app-logic.md

Defines setup parameters that, when changed, trigger the re-initialization of the application. This is useful for dynamically loading models or configurations.

```python
class AppSetup(BaseAppInput):
    model_id: str = Field(default="gpt2", description="Model to load")
    precision: str = Field(default="fp16", description="Model precision")

class App(BaseApp):
    async def setup(self, config: AppSetup):
        from transformers import AutoModel
        self.model = AutoModel.from_pretrained(config.model_id)
```

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

### Build an App Tool with Setup and Input Defaults

Source: https://github.com/inference-sh/skills/blob/main/sdk/python-sdk/references/tool-builder.md

Configure an app tool with hidden setup parameters and default input values. The `.setup()` method takes a configuration dictionary, and `.input()` sets default inputs.

```python
# App tool with setup and defaults
translate = (
    app_tool("translate", "infsh/translator@latest")
    .describe("Translate text between languages")
    .param("text", string("Text to translate"))
    .param("target_lang", string("Target language code"))
    .setup({
        "model": "advanced",
        "preserve_formatting": True
    })
    .input({
        "source_lang": "auto"
    })
    .build()
)
```

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

### Example Prompts for Product Photography

Source: https://github.com/inference-sh/skills/blob/main/guides/photo/ai-product-photography/SKILL.md

Illustrative examples of prompts that follow the formula, demonstrating how to combine different elements to achieve specific aesthetic styles for product images.

```text
"Wireless earbuds on white marble surface, soft studio lighting, Apple advertising style, 8K, sharp focus"

"Sneakers floating on gradient background, dramatic rim lighting, Nike campaign aesthetic, commercial photography"

"Skincare bottle with water droplets, spa setting with stones, natural lighting, luxury beauty brand style"
```

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

### Express Proxy Middleware Setup

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/references/server-proxy.md

Set up Express.js to use the Inference API proxy middleware. This example shows basic setup and integration with custom authentication middleware.

```typescript
import express from 'express';
import { createProxyMiddleware } from '@inferencesh/sdk/proxy/express';

const app = express();

// Basic setup
app.use('/api/inference/proxy', createProxyMiddleware({
  apiKey: process.env.INFERENCE_API_KEY!
}));

// With auth middleware
app.use('/api/inference/proxy',
  requireAuth,
  createProxyMiddleware({
    apiKey: process.env.INFERENCE_API_KEY!
  })
);

app.listen(3000);
```

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

### Generate Product Demonstration Video

Source: https://github.com/inference-sh/skills/blob/main/guides/video/explainer-video-guide/SKILL.md

Use this command to generate a product demonstration video. Specify the desired scene and context in the prompt.

```bash
belt app run google/veo-3-1-fast --input '{
  "prompt": "Clean product demonstration video, hands typing on a laptop showing a dashboard interface, bright modern office, soft natural lighting, professional"
}'
```

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

### Install Media Generation Skills

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/related-skill/SKILL.md

Installs a group of skills related to media generation, including image, video, and music. Use these to add creative capabilities to your AI.

```bash
npx skills add inference-sh/skills@ai-image-generation
npx skills add inference-sh/skills@ai-video-generation
npx skills add inference-sh/skills@ai-music-generation
```

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

### Manual Skill Installation

Source: https://github.com/inference-sh/skills/blob/main/README.md

Manually install inference.sh skills by copying the tool, UI, and SDK directories to the Claude skills directory. This method is useful for local development or custom setups.

```bash
cp -r tools/* ui/* sdk/* guides/* ~/.claude/skills/
```

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

### Install Content Creator Skills

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/related-skill/SKILL.md

Installs a set of skills for content creation, including image generation, video generation, and text-to-speech. Suitable for multimedia content production workflows.

```bash
npx skills add inference-sh/skills@ai-image-generation
npx skills add inference-sh/skills@ai-video-generation
npx skills add inference-sh/skills@text-to-speech
```

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

### Sample Workflow for Qwen-Image-2-Pro Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/image/qwen-image-2-pro/SKILL.md

Command-line interface commands to generate a sample input file, edit it, and then run the Qwen-Image-2-Pro skill.

```bash
# 1. Generate sample input to see all options
belt app sample alibaba/qwen-image-2-pro --save input.json

# 2. Edit the prompt
# 3. Run
belt app run alibaba/qwen-image-2-pro --input input.json
```

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

### Food Content Prompt Example

Source: https://github.com/inference-sh/skills/blob/main/guides/prompting/video-prompting-guide/SKILL.md

Use this example for food content prompts, featuring slow motion, appetizing visuals, and commercial quality keywords. It also shows how to enable audio generation.

```bash
belt app run bytedance/seedance-2-0 --input '{ "prompt": "Close-up of chocolate sauce being drizzled over ice cream, slow motion, steam rising, soft lighting, food photography style, appetizing, commercial quality", "generate_audio": true }'
```

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

### Exa Answer Example

Source: https://github.com/inference-sh/skills/blob/main/tools/llm/web-search/SKILL.md

Get direct factual answers to questions using the Exa Answer app.

```bash
belt app run exa/answer --input {
  "question": "What is the population of Tokyo?"
}
```

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

### Run FLUX Dev LoRA Model

Source: https://github.com/inference-sh/skills/blob/main/tools/image/flux-image/SKILL.md

Executes the falai/flux-dev-lora app to generate an image from a text prompt. This is a quick start example.

```bash
belt app run falai/flux-dev-lora --input '{"prompt": "a futuristic city at night"}'
```

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

### Full Tool Lifecycle Display Example

Source: https://github.com/inference-sh/skills/blob/main/ui/tools-ui/SKILL.md

A comprehensive example demonstrating how to conditionally render ToolCall, ToolResult, or ToolApproval components based on the tool's status and whether it has a result.

```tsx
import { ToolCall, ToolResult, ToolApproval } from "@/registry/blocks/tools"

function ToolDisplay({ tool }) {
  if (tool.status === 'approval') {
    return (
      <ToolApproval
        name={tool.name}
        args={tool.args}
        onApprove={tool.approve}
        onDeny={tool.deny}
      />
    )
  }

  if (tool.result) {
    return (
      <ToolResult
        name={tool.name}
        result={tool.result}
        status={tool.status}
      />
    )
  }

  return (
    <ToolCall
      name={tool.name}
      args={tool.args}
      status={tool.status}
    />
  )
}
```

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

### Veo Sample Workflow

Source: https://github.com/inference-sh/skills/blob/main/tools/video/google-veo/SKILL.md

Demonstrates a sample workflow for generating video input files and running them with the Veo CLI. First, generate a sample input JSON, then edit it, and finally run the generation.

```bash
# 1. Generate sample input to see all options
belt app sample google/veo-3-1-fast --save input.json

# 2. Edit the prompt
# 3. Run
belt app run google/veo-3-1-fast --input input.json
```

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

### Tavily Search Assistant Example

Source: https://github.com/inference-sh/skills/blob/main/tools/llm/web-search/SKILL.md

Use the Tavily Search Assistant to get AI-powered answers with sources and images for a given query.

```bash
belt app run tavily/search-assistant --input {
  "query": "What are the best practices for building AI agents?"
}
```

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

### Generate Tutorial/How-To Video

Source: https://github.com/inference-sh/skills/blob/main/guides/social/ai-social-media-content/SKILL.md

This command is for creating tutorial-style videos, such as craft demonstrations. Ensure the prompt clearly describes the actions and desired aesthetic.

```bash
belt app run google/veo-3-1 --input '{
  "prompt": "Hands demonstrating a craft tutorial, overhead shot, clean workspace, step-by-step motion, warm lighting, vertical format"
}'
```

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

### Basic Text-to-Speech with Kokoro TTS

Source: https://github.com/inference-sh/skills/blob/main/tools/audio/text-to-speech/SKILL.md

A simple example of using the Kokoro TTS model to convert text to speech. This is a good starting point for general-purpose TTS.

```bash
belt app run infsh/kokoro-tts --input '{"text": "Welcome to our tutorial."}'
```

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

### inf.yml Configuration Example

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/SKILL.md

A comprehensive example of an inf.yml file, demonstrating how to configure skill name, description, category, kernel, default function, resources (GPU, RAM), environment variables, secrets, and integrations.

```yaml
name: my-app
description: What my app does
category: image
kernel: python-3.11     # or node-22

# For multi-function apps (default: run)
# default_function: generate

resources:
  gpu:
    count: 1
    vram: 24    # 24GB (auto-converted)
    type: any
  ram: 32       # 32GB

env:
  MODEL_NAME: gpt-4

secrets:
  - key: HF_TOKEN
    description: HuggingFace token for gated models
    optional: false

integrations:
  - key: google.sheets
    description: Access to Google Sheets
    optional: true
```

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

### Add Inference Skills CLI

Source: https://github.com/inference-sh/skills/blob/main/tools/image/ai-image-generation/SKILL.md

Install specific inference skills using the 'npx skills add' command. This example shows how to add the full platform skill.

```bash
# Full platform skill (all 250+ apps)
npx skills add inference-sh/skills@infsh-cli

# Pruna P-Image (fast & economical)
npx skills add inference-sh/skills@p-image

# GPT-Image-2 (OpenAI)
npx skills add inference-sh/skills@gpt-image

# FLUX-specific skill
npx skills add inference-sh/skills@flux-image

# Upscaling & enhancement
npx skills add inference-sh/skills@image-upscaling

# Background removal
npx skills add inference-sh/skills@background-removal

# Video generation
npx skills add inference-sh/skills@ai-video-generation

# AI avatars from images
npx skills add inference-sh/skills@ai-avatar-video
```

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

### Run Python Code with Pandas Version

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/python-executor/SKILL.md

Execute Python code using the belt CLI to run the Python executor app. This example specifically prints the installed Pandas version.

```bash
belt login

# Run Python code
belt app run infsh/python-executor --input '{ "code": "import pandas as pd\nprint(pd.__version__)" }'
```

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

### Belt CLI App Management Commands

Source: https://github.com/inference-sh/skills/blob/main/tools/infsh-cli/SKILL.md

Manage your installed applications using `belt app` commands. This includes listing apps, getting app details, and generating sample input configurations.

```bash
# List your apps
belt app list
```

```bash
# Get app details
belt app get google/veo-3-1-fast
```

```bash
# Generate sample input
belt app sample google/veo-3-1-fast --save input.json
```

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

### Extract Cookies Using JavaScript

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/agent-browser/references/authentication.md

This snippet shows how to extract cookies from a browser session using JavaScript. The first example gets the document.cookie, while the second attempts to stringify resource performance entries.

```bash
# Get cookies via JavaScript
RESULT=$(belt app run agent-browser --function execute --session $SESSION --input '{
  "code": "document.cookie"
}')
COOKIES=$(echo $RESULT | jq -r '.result')
echo "Cookies: $COOKIES"

# Get all cookies including httpOnly (more complete)
RESULT=$(belt app run agent-browser --function execute --session $SESSION --input '{
  "code": "JSON.stringify(performance.getEntriesByType(\"resource\").map(r => r.name))"
}')
```

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

### Product Demo Pipeline

Source: https://github.com/inference-sh/skills/blob/main/guides/content/ai-content-pipeline/SKILL.md

Generates a product showcase video by creating a product image, animating it, upscaling the video, and adding background music.

```bash
# 1. Generate product image
belt app run falai/flux-dev --input '{
  "prompt": "Sleek wireless earbuds on white surface, studio lighting, product photography"
}' > product.json

# 2. Animate product reveal
belt app run falai/wan-2-5 --input '{
  "image_url": "<product-url>",
  "prompt": "slow 360 rotation, smooth motion"
}' > product_video.json

# 3. Upscale video quality
belt app run falai/topaz-video-upscaler --input '{
  "video_url": "<product-video-url>"
}' > upscaled.json

# 4. Add background music
belt app run infsh/media-merger --input '{
  "video_url": "<upscaled-url>",
  "audio_url": "https://your-music.mp3",
  "audio_volume": 0.3
}'
```

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

### Complete Inference SH Agent Setup and Tool Handling

Source: https://github.com/inference-sh/skills/blob/main/sdk/python-sdk/references/tool-builder.md

Demonstrates the full setup of an Inference SH agent, including defining custom tools (calculator, image generation, Slack notification), configuring internal tools (web search, code execution), and implementing a comprehensive tool call handler that manages calculations and approvals.

```python
from inferencesh import (
    inference, tool, app_tool, webhook_tool,
    string, number, integer, boolean, enum_of,
    array, obj, optional, internal_tools
)

client = inference(api_key="inf_...")

# Calculator tool
calculator = (
    tool("calculate")
    .display("Calculator")
    .describe("Perform mathematical calculations")
    .param("expression", string("Math expression to evaluate"))
    .build()
)

# Image generation tool
image_gen = (
    app_tool("generate_image", "infsh/flux-schnell@latest")
    .describe("Generate an image from text")
    .param("prompt", string("Image description"))
    .param("style", enum_of(["realistic", "artistic", "cartoon"], "Image style"))
    .setup({"quality": "high"})
    .input({"steps": 20})
    .require_approval()
    .build()
)

# Slack notification tool
slack = (
    webhook_tool("notify", "https://hooks.slack.com/...")
    .describe("Send Slack notification")
    .param("message", string("Message to send"))
    .build()
)

# Built-in tools
internals = (
    internal_tools()
    .web_search(True)
    .code_execution(True)
    .build()
)

# Create agent with all tools
agent = client.agent({
    "core_app": {"ref": "infsh/claude-sonnet-4@latest"},
    "system_prompt": "You are a helpful assistant with various capabilities.",
    "tools": [calculator, image_gen, slack],
    "internal_tools": internals,
    "temperature": 0.7
})

# Handle tool calls
def handle_tool(call):
    if call.name == "calculate":
        try:
            result = eval(call.args["expression"])
            agent.submit_tool_result(call.id, {"result": result})
        except Exception as e:
            agent.submit_tool_result(call.id, {"error": str(e)})
    elif call.requires_approval:
        approved = input(f"Allow {call.name}? (y/n): ").lower() == 'y'
        if approved:
            # Let the app/webhook tool execute
            pass
        else:
            agent.submit_tool_result(call.id, {"error": "Denied"})

response = agent.send_message(
    "Calculate 15% tip on $85, then notify Slack",
    on_tool_call=handle_tool
)
```

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

### Build an Express API for Session Management

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/references/sessions.md

This Express.js example demonstrates how to manage user sessions for browser automation tasks. It stores session IDs in memory, keyed by user ID, and handles session start, actions, and expiry.

```typescript
import express from 'express';
import { inference } from '@inferencesh/sdk';

const app = express();
const client = inference({ apiKey: process.env.INFERENCE_API_KEY });

// Store sessions per user
const userSessions: Map<string, string> = new Map();

app.post('/api/browser/start', async (req, res) => {
  const userId = req.user.id;

  const result = await client.run({
    app: 'browser-automation',
    input: { action: 'start', url: req.body.url },
    session: 'new',
    session_timeout: 300
  });

  userSessions.set(userId, result.session_id);
  res.json({ sessionId: result.session_id });
});

app.post('/api/browser/action', async (req, res) => {
  const userId = req.user.id;
  const sessionId = userSessions.get(userId);

  if (!sessionId) {
    return res.status(400).json({ error: 'No active session' });
  }

  try {
    const result = await client.run({
      app: 'browser-automation',
      input: req.body,
      session: sessionId
    });
    res.json(result.output);
  } catch (e: any) {
    if (e.message?.includes('session')) {
      userSessions.delete(userId);
      res.status(400).json({ error: 'Session expired' });
    } else {
      throw e;
    }
  }
});

app.post('/api/browser/end', (req, res) => {
  const userId = req.user.id;
  userSessions.delete(userId);
  res.json({ ok: true });
});
```

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

### Full Example: Typed Client, Tools, and Agent

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/references/typescript.md

Demonstrates a complete integration with the Inference SDK, including typed clients, defining and building tools, configuring an agent, and handling tool calls and responses with type safety.

```typescript
import {
  inference,
  tool,
  appTool,
  string,
  enumOf,
  type InferenceClient,
  type AgentTool,
  type TaskDTO,
  type ToolCall
} from '@inferencesh/sdk';

// Typed client
const client: InferenceClient = inference({
  apiKey: process.env.INFERENCE_API_KEY!
});

// Typed tools
const tools: AgentTool[] = [
  tool('search')
    .describe('Search for information')
    .param('query', string('Search query'))
    .build(),

  appTool('generate', 'infsh/flux-schnell@latest')
    .describe('Generate image')
    .param('prompt', string('Description'))
    .param('style', enumOf(['realistic', 'artistic'], 'Style'))
    .build()
];

// Typed agent
const agent = client.agent({
  core_app: { ref: 'infsh/claude-sonnet-4@latest' },
  system_prompt: 'You are helpful.',
  tools
});

// Typed handler
async function handleToolCall(call: ToolCall): Promise<void> {
  console.log(`Tool: ${call.name}, Args:`, call.args);
}

// Typed response handling
const response = await agent.sendMessage('Hello', {
  onToolCall: handleToolCall
});

console.log(response.text);
```

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

### Generate Bar Chart with Python

Source: https://github.com/inference-sh/skills/blob/main/guides/design/data-visualization/SKILL.md

Generate a bar chart using Python's Matplotlib library executed via the belt CLI. This example creates a monthly revenue growth chart and saves it as 'revenue.png'. Ensure Matplotlib is installed in your Python environment.

```bash
belt app run infsh/python-executor --input '{ "code": "import matplotlib.pyplot as plt\nimport matplotlib\nmatplotlib.use(\"Agg\")\n\nmonths = [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\"]\nrevenue = [42, 48, 55, 61, 72, 89]\n\nfig, ax = plt.subplots(figsize=(10, 6))\nax.bar(months, revenue, color=\"#3b82f6\", width=0.6)\nax.set_ylabel(\"Revenue ($K)\")\nax.set_title(\"Monthly Revenue Growth\", fontweight=\"bold\")\nfor i, v in enumerate(revenue):\n    ax.text(i, v + 1, f\"${v}K\", ha=\"center\", fontweight=\"bold\")\nplt.tight_layout()\nplt.savefig(\"revenue.png\", dpi=150)\nprint(\"Saved\")" }'
```

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

### Install Inference CLI

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/cli.md

Installs the Inference CLI tool. After installation, you can log in and check your current user.

```bash
curl -fsSL https://cli.inference.sh | sh
belt login
belt me  # Check current user
```

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

### Install inference.sh CLI

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/SKILL.md

Installs the inference.sh CLI using a curl script. This is the recommended and simplest installation method.

```bash
curl -fsSL https://cli.inference.sh | sh
belt login
```

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

### List Installed Skills

Source: https://github.com/inference-sh/skills/blob/main/tools/utilities/related-skill/SKILL.md

Displays a list of all skills currently installed in your environment. Helps in managing your installed skill set.

```bash
# List installed skills
npx skills list
```

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

### List Your Apps

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/app-discovery.md

Lists all applications available in your local environment. Use the --search flag to filter by name or the -l flag for detailed output.

```bash
belt app list
```

```bash
belt app list --search "flux"
```

```bash
belt app search "flux"
```

```bash
belt app list -l  # detailed
```

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

### Install Claude Code Plugin

Source: https://github.com/inference-sh/skills/blob/main/README.md

Install all inference.sh skills as a Claude Code plugin. This command installs the plugin from the default marketplace.

```bash
/plugin install inference-sh
```

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

### Initialize and Deploy App

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/cli-reference.md

Commands for developing and deploying applications. Initialize a new app interactively or with a name, test it locally with input, and deploy it. A dry-run option validates without deploying.

```bash
belt app init
```

```bash
belt app init <name>
```

```bash
belt app test --input <file>
```

```bash
belt app deploy
```

```bash
belt app deploy --dry-run
```

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

### Install Seedance 2.0 Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/video/happyhorse/SKILL.md

Installs the Seedance 2.0 skill.

```bash
npx skills add inference-sh/skills@seedance
```

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

### Query Optimization Examples

Source: https://github.com/inference-sh/skills/blob/main/tools/llm/ai-rag-pipeline/SKILL.md

Demonstrates the difference between vague and specific search queries for better AI performance. Use specific and contextual queries.

```bash
# Bad: Too vague
"AI news"
```

```bash
# Good: Specific and contextual
"latest developments in large language models January 2024"
```

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

### Install Node.js v20+ with fnm or nvm

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/cli.md

Installs Node.js version 22 using either fnm or nvm, required for Node.js applications. Ensure you have one of these version managers installed.

```bash
# macOS / Linux (via fnm)
curl -fsSL https://fnm.vercel.app/install | bash
fnm install 22
```

```bash
# Or via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
nvm install 22
```

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

### Generate Sample Input File

Source: https://github.com/inference-sh/skills/blob/main/tools/agent-tools/references/running-apps.md

Create a template input file for an application to understand its required parameters. Use the `--save` flag to write the sample to a file.

```bash
belt app sample falai/flux-dev-lora
```

```bash
belt app sample falai/flux-dev-lora --save input.json
```

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

### Install Image Upscaling Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/image/flux-image/SKILL.md

Installs a dedicated skill for image upscaling functionalities.

```bash
# Upscaling
npx skills add inference-sh/skills@image-upscaling
```

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

### Example Character Description

Source: https://github.com/inference-sh/skills/blob/main/guides/design/character-design-sheet/SKILL.md

An example of a fully fleshed-out character description based on the template.

```text
young woman in her mid-twenties with short asymmetric auburn red hair
swept to the right side, bright emerald green eyes, light warm skin
with a small beauty mark below her left eye, wearing a fitted navy
blue bomber jacket with silver zipper over a white crew-neck t-shirt,
dark slate slim jeans, and bright red canvas sneakers, small silver
stud earrings
```

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

### Build a Client Tool

Source: https://github.com/inference-sh/skills/blob/main/sdk/javascript-sdk/SKILL.md

Create a client-side tool that can be invoked directly from your code. This example defines a 'greet' tool that requires user approval.

```typescript
const greet = tool('greet')
  .display('Greet User')
  .describe('Greets a user by name')
  .param('name', string('Name to greet'))
  .requireApproval()
  .build();
```

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

### Effective Headline Examples

Source: https://github.com/inference-sh/skills/blob/main/guides/design/landing-page-design/SKILL.md

Examples of headlines that clearly communicate value and avoid common pitfalls.

```text
✅ "Turn customer feedback into product features, automatically"
```

```text
✅ "The spreadsheet that thinks like a database"
```

```text
✅ "Find and fix bugs before your users do"
```

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

### Install Chat UI Skill

Source: https://github.com/inference-sh/skills/blob/main/ui/tools-ui/SKILL.md

Install the chat UI skill, which provides chat interface components.

```bash
npx skills add inference-sh/skills@chat-ui
```

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

### Generate Tutorial Thumbnail

Source: https://github.com/inference-sh/skills/blob/main/guides/design/youtube-thumbnail-design/SKILL.md

Use this command to generate a thumbnail for tutorial content, featuring an organized workspace with a laptop and code editor.

```bash
belt app run falai/flux-dev-lora --input '{
  "prompt": "overhead flat lay of organized workspace with laptop showing code editor, colorful sticky notes, coffee cup, clean bright background, professional setup, tutorial style composition, warm lighting",
  "width": 1280,
  "height": 720
}'
```

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

### Editable Install for Local Packages

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/references/python-patterns.md

Specifies local packages for editable installs in requirements.txt to manage dependencies.

```txt
-e ./local_package_directory

```

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

### Install Related Skills

Source: https://github.com/inference-sh/skills/blob/main/ui/agent-ui/SKILL.md

Commands to install related skills for chat UI, widgets, and tool lifecycle UI.

```bash
# Chat UI building blocks
npx skills add inference-sh/skills@chat-ui

# Declarative widgets from JSON
npx skills add inference-sh/skills@widgets-ui

# Tool lifecycle UI
npx skills add inference-sh/skills@tools-ui
```

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

### System Packages

Source: https://github.com/inference-sh/skills/blob/main/sdk/building-apps/SKILL.md

Lists system packages that need to be installed via apt for the skill to function correctly.

```text
ffmpeg
libgl1-mesa-glx
```

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

### Build a Basic Client Tool

Source: https://github.com/inference-sh/skills/blob/main/sdk/python-sdk/references/tool-builder.md

Create a simple client tool using the `tool` builder. This tool executes directly within your Python code. Use `.describe()` for a description and `.param()` to add parameters.

```python
from inferencesh import tool, string, integer

# Basic tool
greet = (
    tool("greet")
    .describe("Greets a user")
    .param("name", string("Name to greet"))
    .build()
)
```

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

### Install AI Image Generation Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/image/flux-image/SKILL.md

Installs a skill that provides access to all AI image generation models.

```bash
# All image generation models
npx skills add inference-sh/skills@ai-image-generation
```

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

### Install Pruna P-Image Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/image/flux-image/SKILL.md

Installs the Pruna P-Image skill, which offers fast and economical image generation.

```bash
# Pruna P-Image (fast & economical)
npx skills add inference-sh/skills@p-image
```

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

### Install ElevenLabs Multi-Speaker Dialogue Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/audio/elevenlabs-tts/SKILL.md

Installs the ElevenLabs multi-speaker dialogue skill for advanced voice applications.

```bash
npx skills add inference-sh/skills@elevenlabs-dialogue
```

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

### Generate Device Mockup Scene

Source: https://github.com/inference-sh/skills/blob/main/guides/design/app-store-screenshots/SKILL.md

Generate a device mockup scene using the belt CLI. This example shows how to create a mockup for an iPhone 15 Pro with a specific app interface prompt and dimensions.

```bash
belt app run falai/flux-dev-lora --input '{
  "prompt": "iPhone 15 Pro showing a clean modern app interface with analytics dashboard, floating at slight angle, soft gradient background, professional product photography, subtle shadow, marketing mockup style",
  "width": 1024,
  "height": 1536
}'
```

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

### Add AI Podcast Creation Skill

Source: https://github.com/inference-sh/skills/blob/main/tools/audio/dialogue-audio/SKILL.md

Install the AI podcast creation skill.

```bash
npx skills add inference-sh/skills@ai-podcast-creation
```

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

### Install the belt CLI Skill

Source: https://github.com/inference-sh/skills/blob/main/guides/content/content-repurposing/SKILL.md

Installs the belt CLI skill, which is required for using inference.sh CLI commands.

```bash
npx skills add belt-sh/cli
```

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

### Image-to-Video with Start and End Frames

Source: https://github.com/inference-sh/skills/blob/main/tools/video/seedance/SKILL.md

Controls the start and end frames of a video generated from an image and prompt, with audio.

```bash
belt app run bytedance/seedance-2-0 --input '{
  "image": "https://start-frame.jpg",
  "end_image": "https://end-frame.jpg",
  "prompt": "smooth transition between scenes",
  "generate_audio": true
}'
```

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

### Exa Search Example

Source: https://github.com/inference-sh/skills/blob/main/tools/llm/web-search/SKILL.md

Perform a smart web search using the Exa Search app to find highly relevant links with context.

```bash
belt app run exa/search --input {
  "query": "machine learning frameworks comparison"
}
```

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

### Install Widgets UI Skill

Source: https://github.com/inference-sh/skills/blob/main/ui/tools-ui/SKILL.md

Install the widgets UI skill, which includes various widgets for displaying tool results.

```bash
npx skills add inference-sh/skills@widgets-ui
```

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

### Run App with Input JSON

Source: https://github.com/inference-sh/skills/blob/main/tools/image/nano-banana-2/SKILL.md

Run the app using a pre-configured input JSON file.

```bash
belt app run google/gemini-3-1-flash-image-preview --input input.json
```