### Example: Starting Build MCP Extension Tutorial

Source: https://goose-docs.ai/docs/mcp/tutorial-mcp

An example interaction showing how to start the 'build-mcp-extension' tutorial. Goose prompts for SDK preference and extension type.

```text
I'd like to learn how to build an extension for goose
```

```text
I'll help you learn about building extensions! The "build-mcp-extension" tutorial would be perfect for this. Let me load it and guide you through it.

─── load_tutorial | tutorial ──────────────────────────
name: build-mcp-extension

Before we dive into building your extension, I need to understand a few things to better guide you:

1. Which SDK would you prefer to use? We have three options:
   - Python (beginner-friendly, great for prototyping)
   - TypeScript (great for web-based tools)
   - Kotlin (robust, type-safe, good for complex applications)

2. What type of extension would you like to build? For example:
   - A tool that performs specific actions
   - A resource that provides data to the LLM
   - Or do you have a specific idea in mind?

Let me know your preferences, and I'll help you get started with the appropriate setup and implementation!

For reference, here's what we'll cover:
1. Setting up your development environment
2. Creating the basic MCP server
3. Implementing your specific functionality
4. Testing and debugging

Which SDK would you like to use to get started?
```

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

### Clone and Set Up Dev.to MCP Server

Source: https://goose-docs.ai/docs/mcp/dev.to-mcp

Clone the Dev.to MCP server repository, install dependencies, and build the project. This is a one-time setup before starting the server.

```bash
git clone https://github.com/nickytonline/dev-to-mcp.git
cd dev-to-mcp
npm install
npm run build # one-time setup
```

```bash
npm start
```

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

### Install MLflow and Start Server

Source: https://goose-docs.ai/docs/tutorials/mlflow

Install the MLflow library and launch the MLflow tracking server. The UI will be accessible at http://localhost:5000.

```bash
pip install mlflow
mlflow server --port 5000
```

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

### Example Allowlist Configuration

Source: https://goose-docs.ai/docs/guides/allowlist

An example allowlist specifying the Slack, GitHub, and Jira extensions that are permitted for installation.

```yaml
extensions:
  - id: slack
    command: uvx mcp_slack
  - id: github
    command: uvx mcp_github
  - id: jira
    command: uvx mcp_jira
```

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

### Start Specific Tutorial by Name

Source: https://goose-docs.ai/docs/mcp/tutorial-mcp

Directly request a tutorial by its name, for example, the 'first-game' tutorial.

```text
( O)> Can you walk me through the first-game tutorial?
```

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

### Example Skill with Supporting Files (SKILL.md)

Source: https://goose-docs.ai/docs/guides/context-engineering/using-skills

The SKILL.md content for an API setup skill, referencing supporting files.

```markdown
---
name: api-setup
description: Set up API integration with configuration and helper scripts
---

# API Setup

This skill helps you set up a new API integration with our standard configuration.

## Steps

1. Run `setup.sh <api-name>` to create the integration directory
2. Copy `templates/config.template.json` to your integration directory
3. Update the config with your API credentials
4. Test the connection

## Configuration

The config template includes:
- `api_key`: Your API key (get from the provider's dashboard)
- `endpoint`: API endpoint URL
- `timeout`: Request timeout in seconds (default: 30)

## Verification

After setup, verify:
- [ ] Config file is valid JSON
- [ ] API key is set and not a placeholder
- [ ] Test connection succeeds

```

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

### Test Docker Setup and Verify API

Source: https://goose-docs.ai/docs/tutorials/plan-feature-devcontainer-setup

Use these commands to start your Docker environment, list running containers, and test API accessibility.

```bash
# Test Docker setup locally
docker-compose up -d
docker ps

# Verify API accessibility
curl http://localhost:8888/api/products

# Test database connection
docker exec -it mysql mysql -u user -p api_db
```

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

### Example Global .goosehints File

Source: https://goose-docs.ai/docs/guides/context-engineering/using-goosehints

This example demonstrates how to configure global hints for Goose. It includes instructions on project setup, coding standards, and workflow preferences. Use '@' syntax to include file content immediately or plain references for optional files.

```plaintext
Always use TypeScript for new Next.js projects.

@coding-standards.md  # Contains our coding standards
docs/contributing.md  # Contains our pull request process

Follow the [Google Style Guide](https://google.github.io/styleguide/pyguide.html) for Python code.

Run unit tests before committing any changes.

Prefer functional programming patterns where applicable.
```

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

### Example goose Output for Containerized Development

Source: https://goose-docs.ai/docs/mcp/container-use-mcp

This output demonstrates the steps goose takes to create an isolated container environment for development, including setup commands and dependency installation.

```text
I'll help you create a container environment to add SQLite functionality to your to-do list application on a separate Git branch. Let me start by creating the environment and examining your current code structure.
─── environment_create | containeruse ──────────────────────────
environment_source: ./examples/todo-list
explanation: ...
title: ...

Now let me set up the environment with the necessary tools and then proceed with the SQLite feature development:
─── environment_config | containeruse ──────────────────────────
config:
    base_image: python:3.11-slim
    setup_commands:
        -
            [REDACTED: 63 chars]
        -
            pip install pytest pytest-cov

environment_id: thankful-whale
environment_source: ./examples/todo-list
explanation: ...

Let me install pytest after the environment is running:

---


Great! I've created a container environment for safely adding SQLite functionality to your to-do list app. Let me first explore the current code structure and then create a new Git branch.

---


Now I'll create the SQLite-based storage implementation. First, let me create a new version of the TaskManager with SQLite support:

---


## ✅ SQLite Feature Successfully Added!

I've successfully created a container environment and added SQLite functionality to your to-do list application! Here's what was accomplished:

```

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

### Install Fetch MCP Server via CLI

Source: https://goose-docs.ai/docs/mcp/fetch-mcp

Use this command to install the Fetch MCP Server using uvx. Ensure uv is installed on your system.

```sh
uvx mcp-server-fetch
```

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

### Install Square Local MCP Server via CLI

Source: https://goose-docs.ai/docs/mcp/square-mcp

Run this command to start the local Square MCP server on your machine. Ensure you have Node.js installed and configured environment variables.

```sh
npx square-mcp-server start
```

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

### Install Dependencies

Source: https://goose-docs.ai/docs/tutorials/subagents

Navigate to your project directory and install all necessary dependencies using npm.

```bash
cd your-project-folder
npm install
```

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

### Install Neon Local MCP Server via Goose CLI

Source: https://goose-docs.ai/docs/mcp/neon-mcp

Run this command to start the local Neon MCP server using npx. Replace `<YOUR_NEON_API_KEY>` with your actual Neon API key.

```bash
npx -y @neondatabase/mcp-server-neon start <YOUR_NEON_API_KEY>
```

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

### Start Session with Built-in Extension

Source: https://goose-docs.ai/docs/getting-started/using-extensions

Enable a built-in extension for the current session using the `--with-builtin` flag. This does not permanently install the extension.

```bash
goose session --with-builtin "{extension_id}"
```

```bash
goose session --with-builtin "developer,computercontroller"
```

```bash
goose session --with-builtin developer --with-builtin computercontroller
```

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

### Recipe File with Parameters

Source: https://goose-docs.ai/docs/guides/recipes/session-recipes

Example of a recipe file demonstrating the use of parameters. Parameters are defined in the `parameters` section and referenced within the recipe content using `{{ variable_name }}` syntax. Ensure values starting with template syntax are quoted.

```yaml
version: 1.0.0
title: "{{ project_name }} Code Review" # Wrap the value in quotes if it starts with template syntax to avoid YAML parsing errors
description: Automated code review for {{ project_name }} with {{ language }} focus
instructions: You are a code reviewer specialized in {{ language }} development.
prompt: |
   Apply the following standards:
   - Complexity threshold: {{ complexity_threshold }}
   - Required test coverage: {{ test_coverage }}%
   - Style guide: {{ style_guide }}
activities:
- "Review {{ language }} code for complexity"
- "Check test coverage against {{ test_coverage }}% requirement"
- "Verify {{ style_guide }} compliance"
settings:                     
  goose_provider: "anthropic"   
  goose_model: "claude-3-7-sonnet-latest"          
  temperature: 0.7 
parameters:
- key: project_name
  input_type: string
  requirement: required # could be required, optional or user_prompt
  description: name of the project
- key: language
  input_type: string
```

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

### Install Beads MCP with Packaging Dependency

Source: https://goose-docs.ai/docs/mcp/beads-mcp

If the extension fails to start due to a missing 'packaging' module, use this command to install it. This is a fix for versions prior to 0.49.1.

```sh
uv tool install beads-mcp --with packaging
```

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

### Configure LLM Provider via Goose CLI

Source: https://goose-docs.ai/docs/getting-started/installation

This example shows the interactive command-line flow for configuring an LLM provider using the Goose CLI. It covers selecting authentication methods and confirming successful setup.

```bash
┌   goose-configure
│
◇ How would you like to set up your provider?
│ Tetrate Agent Router Service Login
│
Opening browser for Tetrate Agent Router Service authentication...
[goose opens the browser and prints details]

Authentication complete!

Configuring Tetrate Agent Router Service...
✓ Tetrate Agent Router Service configuration complete
✓ Models configured successfully

Testing configuration...
✓ Configuration test passed!
✓ Developer extension enabled!
└ Tetrate Agent Router Service setup complete! You can now use goose.
```

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

### Install Amp CLI

Source: https://goose-docs.ai/docs/guides/acp-providers

Installs the Amp CLI tool. Ensure Node.js and npm are installed first.

```bash
curl -fsSL https://ampcode.com/install.sh | bash
```

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

### Deployment Workflow Skill Example

Source: https://goose-docs.ai/docs/guides/context-engineering/using-skills

A SKILL.md example for a production deployment skill, outlining pre-deployment steps.

```markdown
---
name: production-deploy
description: Safe deployment procedure for production environment
---

# Production Deployment

## Pre-deployment
1. Ensure all tests pass
2. Get approval from at least 2 reviewers
3. Notify #deployments channel


```

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

### Install goose TUI Client

Source: https://goose-docs.ai/docs/guides/acp-clients

Navigate to the `ui/text` directory and run `npm install` to install the necessary dependencies for the goose TUI client.

```bash
cd ui/text
npm install
```

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

### Install YouTube Transcript Extension via CLI

Source: https://goose-docs.ai/docs/mcp/youtube-transcript-mcp

Use this command to install the YouTube Transcript extension using uvx. Ensure you have uv installed.

```sh
uvx --from git+https://github.com/jkawamoto/mcp-youtube-transcript mcp-youtube-transcript
```

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

### Install Beads MCP Extension via CLI

Source: https://goose-docs.ai/docs/mcp/beads-mcp

Use the `uvx` command to quickly install the Beads MCP extension. Ensure `uv` is installed on your system.

```sh
uvx beads-mcp
```

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

### Install Linux MCP Server via uvx

Source: https://goose-docs.ai/docs/mcp/linux-mcp-server-mcp

Use the `uvx` command to install the Linux MCP Server extension. Ensure `uv` is installed on your system.

```sh
# Using uv (recommended)
uvx linux-mcp-server
```

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

### Install DataHub MCP Server via Goose CLI

Source: https://goose-docs.ai/docs/mcp/datahub-mcp

Use the `uvx` command to install the DataHub MCP Server extension. Ensure you have uv installed.

```sh
uvx mcp-server-datahub@latest
```

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

### Install Context7 MCP Server via CLI

Source: https://goose-docs.ai/docs/mcp/context7-mcp

Use this command to quickly install the Context7 MCP server extension using Node Package Execute (npx). Ensure Node.js is installed.

```sh
npx -y @upstash/context7-mcp
```

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

### Install Exa MCP Server via Goose CLI

Source: https://goose-docs.ai/docs/mcp/exa-mcp

Use this command to install the Exa MCP Server directly from the command line. Ensure Node.js is installed.

```sh
npx -y exa-mcp-server
```

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

### Example Skill with Supporting Files (setup.sh)

Source: https://goose-docs.ai/docs/guides/context-engineering/using-skills

A bash script used as a supporting file for the api-setup skill to create directories and copy templates.

```bash
#!/bin/bash
API_NAME=$1
mkdir -p "integrations/$API_NAME"
cp templates/config.template.json "integrations/$API_NAME/config.json"
echo "Created integration directory for $API_NAME"
echo "Edit integrations/$API_NAME/config.json with your credentials"

```

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

### Set up Environment Variables

Source: https://goose-docs.ai/docs/mcp/filesystem-mcp

Copy the example environment file and fill in secure values. This is a prerequisite for running the project securely.

```bash
# For each project
cp .env.example .env
# Fill in secure values in .env files
```

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

### Goose Prompt for OpenAI Whisper Analysis

Source: https://goose-docs.ai/docs/mcp/gitmcp-mcp

This prompt instructs Goose AI to use the Git MCP extension to analyze the 'openai/whisper' GitHub repository. It specifies the desired information, including model functionality, setup, and code examples, formatted as a Markdown guide.

```text
Can you help me understand how the OpenAI Whisper speech-to-text model works?

Use the GitHub repository `openai/whisper` to find accurate information.

Please:
- Summarize what the model does and its key features
- Show an example of how to run it from the command line
- Explain what files or models are needed to get started
- Include any useful code snippets or setup instructions you find in the repo

Give me the response in a Markdown guide format.
```

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

### Install Spraay MCP Server

Source: https://goose-docs.ai/docs/tutorials/spraay-mcp

Clone the Spraay MCP Server repository, install dependencies, and build the project.

```bash
git clone https://github.com/plagtech/spraay-x402-mcp.git
cd spraay-x402-mcp
npm install
npm run build
```

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

### Resume Specific Session Example (Goose CLI)

Source: https://goose-docs.ai/docs/guides/sessions/session-management

Example of resuming a session named 'react-migration' using the Goose CLI.

```bash
goose session -r --name react-migration
```

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

### Start Tutorial by Asking Goose

Source: https://goose-docs.ai/docs/mcp/tutorial-mcp

Initiate a tutorial by asking goose about a topic of interest. Goose will suggest relevant tutorials, such as 'build-mcp-extension'.

```text
( O)> I'd like to learn how to build an extension for goose
```

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

### Goose Prompt Example

Source: https://goose-docs.ai/docs/experimental/vs-code-extension

Example of a prompt to Goose AI within the VS Code extension to update a contributing guide.

```plaintext
Update the contributing guide at /goose/CONTRIBUTING.md with instructions on how to start docusaurus dev server
```

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

### Initialize Node.js Project and Install MCP SDK

Source: https://goose-docs.ai/docs/tutorials/building-mcp-apps

Set up a new Node.js project and install the necessary MCP SDK package. Ensure your package.json is configured to use ES modules.

```bash
mkdir mcp-app-demo
cd mcp-app-demo
npm init -y
```

```bash
npm install @modelcontextprotocol/sdk
```

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

### Get Swap Quote with Spraay

Source: https://goose-docs.ai/docs/tutorials/spraay-mcp

Example query to get a swap quote for 100 USDC to WETH on Base using the spraay_swap_quote tool.

```text
Get me a swap quote for 100 USDC to WETH on Base
```

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

### Start Session with Extensions

Source: https://goose-docs.ai/docs/guides/goose-cli-commands

Starts a session with additional extensions enabled, such as built-in developer tools or remote HTTP extensions.

```bash
goose session --with-extension "npx -y @modelcontextprotocol/server-memory"
```

```bash
goose session --with-builtin developer
```

```bash
goose session --with-streamable-http-extension "http://localhost:8080/mcp"
```

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

### Example goose Prompt for YouTube Transcript

Source: https://goose-docs.ai/docs/mcp/youtube-transcript-mcp

This is an example of how to prompt goose to get a YouTube video transcript. Provide the full YouTube URL.

```text
Get me the transcript for this YouTube video: https://www.youtube.com/watch?v=dQw4w9WgXcQ
```

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

### Preview Recipe Details

Source: https://goose-docs.ai/docs/guides/recipes/session-recipes

Use the `explain` command to view recipe details before execution.

```sh
goose explain --recipe code-review
```

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

### Run goose TUI Client (Auto-launch)

Source: https://goose-docs.ai/docs/guides/acp-clients

Execute `npm start` in the TUI client directory to launch the goose TUI. This command will automatically start the goose ACP server if it's installed.

```bash
npm start
```

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

### Initialize Node.js Project and Install Remotion Dependencies

Source: https://goose-docs.ai/docs/tutorials/remotion-video-creation

Commands to create a new project directory, initialize npm, and install Remotion and related packages.

```bash
mkdir -p git-terminal-video && cd git-terminal-video && npm init -y
```

```bash
npm install remotion @remotion/cli react react-dom typescript @types/react
```

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

### Initialize MCP Wiki Project

Source: https://goose-docs.ai/docs/tutorials/custom-extensions

Sets up a new Python project for an MCP server using uv. Creates necessary directories and files for the server structure.

```bash
uv init --lib mcp-wiki
cd mcp-wiki

mkdir -p src/mcp_wiki
touch src/mcp_wiki/server.py
touch src/mcp_wiki/__main__.py
```

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

### Start Goose Session with Ollama Tool Shim

Source: https://goose-docs.ai/docs/experimental/ollama

Start a new Goose session with the Ollama tool shim enabled and a custom interpreter model. This example uses `llama3.2` as the interpreter model.

```bash
GOOSE_TOOLSHIM=1 GOOSE_TOOLSHIM_OLLAMA_MODEL=llama3.2 cargo run --bin goose session
```

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

### Create MCP Server with Tool and Resource Handlers

Source: https://goose-docs.ai/docs/tutorials/building-mcp-apps

Set up the main server file for your MCP App. This includes defining capabilities, handling tool calls to display the app, and serving the HTML resource.

```javascript
#!/usr/bin/env node

import {
  Server,
  StdioServerTransport,
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

import { readFileSync } from "fs";
import { join } from "path";
import { dirname } from "path";
import { fileURLToPath } from "url";

// Load HTML from file
const __dirname = dirname(fileURLToPath(import.meta.url));
const APP_HTML = readFileSync(join(__dirname, "index.html"), "utf-8");

// Create the MCP server
const server = new Server(
  {
    name: "mcp-app-demo",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
      resources: {},
    },
  }
);

// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "show_demo_app",
        description: "Shows an interactive demo MCP App UI in the chat",
        inputSchema: {
          type: "object",
          properties: {},
          required: [],
        },
      },
    ],
  };
});

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name } = request.params;

  if (name === "show_demo_app") {
    return {
      content: [
        {
          type: "text",
          text: "The demo app is now displayed!",
        },
      ],
      // This metadata tells goose to render the MCP App
      _meta: {
        ui: {
          resourceUri: "ui://mcp-app-demo/main",
        },
      },
    };
  }

  throw new Error(`Unknown tool: ${name}`);
});

// List available resources
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "ui://mcp-app-demo/main",
        name: "MCP App Demo",
        description: "An interactive demo",
        mimeType: "text/html;profile=mcp-app",
      },
    ],
  };
});

// Read resource content - returns the HTML
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params;

  if (uri === "ui://mcp-app-demo/main") {
    return {
      contents: [
        {
          uri: "ui://mcp-app-demo/main",
          mimeType: "text/html;profile=mcp-app",
          text: APP_HTML,
          _meta: {
            ui: {
              csp: {
                connectDomains: [],
                resourceDomains: [],
                frameDomains: [],
                baseUriDomains: [],
              },
              prefersBorder: true,
            },
          },
        },
      ],
    };
  }

  throw new Error(`Resource not found: ${uri}`);
});

// Start the server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP App Demo server running on stdio");
}

main().catch(console.error);

```

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

### Set up MCP Project Environment

Source: https://goose-docs.ai/docs/tutorials/custom-extensions

Run this command to synchronize your project dependencies. Ensure Node.js and npm are installed.

```bash
uv sync
```

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

### Run MCP Server in Development Mode

Source: https://goose-docs.ai/docs/tutorials/custom-extensions

Start your MCP server for development. MCP Inspector should open automatically. You may be prompted to install `@modelcontextprotocol/inspector`.

```bash
mcp dev src/mcp_wiki/server.py
```

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

### Generate Configuration File Template Example

Source: https://goose-docs.ai/docs/guides/recipes/recipe-reference

An example recipe that uses template syntax to generate a configuration file with placeholder variables, demonstrating parameter substitution and escaping.

```yaml
version: "1.0.0"
title: "Generate Config Template"
description: "Generate a template with placeholder values"
parameters:
  - key: app_name
    input_type: string
    requirement: required
    description: "Application name"

prompt: |
  Create a config.yaml file for {{ app_name }} with these placeholder variables:
  - {{'{{API_KEY}}'}} for the API key
  - {{'{{DATABASE_URL}}'}} for the database connection
  - {{'{{PORT}}'}} for the server port
```

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

### Start Session with Mixed Extension Types

Source: https://goose-docs.ai/docs/guides/goose-cli-commands

Demonstrates starting a session with a combination of different extension types, including local stdio, remote HTTP, and built-in extensions.

```bash
goose session \
  --with-extension "echo hello" \
  --with-streamable-http-extension "http://localhost:8080/mcp" \
  --with-builtin "developer"
```

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

### Dockerfile for API Server Build

Source: https://goose-docs.ai/docs/tutorials/plan-feature-devcontainer-setup

Example Dockerfile for building an API server, potentially a PHP application. It specifies the base image and installs the pdo_mysql extension.

```dockerfile
FROM php:8.1-apache
RUN docker-php-ext-install pdo_mysql
```

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

### Initialize Benchmark Configuration

Source: https://goose-docs.ai/docs/tutorials/benchmarking

Create a basic JSON configuration file for benchmarking. The `cat` command displays the generated file content.

```bash
goose bench init-config -n bench-config.json
cat bench-config.json
```

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

### Troubleshoot Extension Command Errors

Source: https://goose-docs.ai/docs/troubleshooting/known-issues

If an extension fails to start due to a missing command, ensure the necessary package runner (like Node.js for npx commands) is installed and configured correctly.

```bash
Failed to start extension `{extension name}`: Could not run extension command (`{extension command}`): No such file or directory (os error 2)
Please check extension configuration for {extension name}.
```

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

### Update LLM Provider via Goose CLI

Source: https://goose-docs.ai/docs/getting-started/installation

This example illustrates the interactive CLI process for updating your LLM provider and model. It guides you through selecting configuration options and entering new API keys.

```bash
goose configure
```

```bash
┌   goose-configure
│
◇ What would you like to configure?
│ Configure Providers
│
◇ Which model provider should we use?
│ Google Gemini
│
◇ Provider Google Gemini requires GOOGLE_API_KEY, please enter a value
│▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
│
◇ Enter a model from that provider:
│ gemini-2.0-flash-exp
│
◇  Hello there! You're all set to use me, so please ask away!
│
└  Configuration saved successfully
```

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

### Example Skill with Supporting Files (config.template.json)

Source: https://goose-docs.ai/docs/guides/context-engineering/using-skills

A JSON template file used by the api-setup skill for new API integration configurations.

```json
{
  "api_key": "YOUR_API_KEY_HERE",
  "endpoint": "https://api.example.com/v1",
  "timeout": 30,
  "retry_attempts": 3
}

```

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

### Install Repomix MCP Server via Goose Desktop

Source: https://goose-docs.ai/docs/mcp/repomix-mcp

Launch the installer for the Repomix extension through Goose Desktop. This provides a user-friendly way to add repository packing and analysis capabilities.

```html
[Launch the installer](goose://extension?cmd=npx&arg=-y&arg=repomix&arg=--mcp&id=repomix&name=Repomix&description=Pack%20repositories%20into%20AI-friendly%20formats%20for%20goose)
```

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

### Devcontainer Configuration for Java and Docker

Source: https://goose-docs.ai/docs/tutorials/plan-feature-devcontainer-setup

Configure your Codespace environment with this devcontainer.json file. It specifies the Java 17 image, enables Docker-in-Docker, sets up a post-creation command to start Docker Compose, and installs essential VS Code extensions.

```json
{
  "name": "API Testing Environment",
  "image": "mcr.microsoft.com/devcontainers/java:17",
  "features": {
    "docker-in-docker": "latest"
  },
  "postCreateCommand": "docker-compose up -d",
  "customizations": {
    "vscode": {
      "extensions": [
        "vscjava.vscode-java-pack",
        "ms-azuretools.vscode-docker"
      ]
    }
  }
}
```

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

### Goose CLI Theme Management Examples

Source: https://goose-docs.ai/docs/guides/goose-cli-commands

Examples demonstrating how to manage the Goose CLI syntax highlighting theme using environment variables and slash commands.

```bash
# Set ANSI theme for the session via environment variable
export GOOSE_CLI_THEME=ansi
goose session --name use-custom-theme
```

```bash
# Toggle theme during a session
/t
```

```bash
# Set the light theme during a session
/t light
```

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

### Build Backend Tasks with Beads

Source: https://goose-docs.ai/docs/mcp/beads-mcp

Initiate backend tasks by first completing 'Storage Setup', then proceed to build and complete 'Add Expense', 'Calculate Total', and 'Delete Expense' sequentially. This ensures data persistence and core functionalities are implemented.

```bash
Check beads for the expense tracker project.

Build the "Storage Setup" task and mark it complete.

Then build "Add Expense", "Calculate Total", and "Delete Expense", marking each complete as you go.
```

```bash
Check beads for the expense tracker project.

Build the "Storage Setup" task and mark it complete.

Then build "Add Expense", "Calculate Total", and "Delete Expense", marking each complete as you go.
```

```bash
path: storage.js
command: write

```

```bash
issue_id: ultimate-beads-test-6gs
reason: Implemented localStorage helpers: getExpenses, saveExpenses, clearExpenses, generateId

```

```bash
Now let me build "Add Expense":

```

```bash
path: addExpense.js
command: write

```

```bash
issue_id: ultimate-beads-test-5x5
reason: Implemented addExpense() function

```

```bash
Now "Calculate Total":

```

```bash
path: calculateTotal.js
command: write

```

```bash
issue_id: ultimate-beads-test-29u
reason: Implemented calculateTotal() and calculateTotalByCategory()

```

```bash
And finally "Delete Expense":

```

```bash
path: deleteExpense.js
command: write

```

```bash
issue_id: ultimate-beads-test-ae4
reason: Implemented deleteExpense() and deleteExpensesByCategory()

```

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

### goose Output for Multitasking Example

Source: https://goose-docs.ai/docs/mcp/computer-controller-mcp

The output details goose's execution of the multitasking prompt, showing the steps taken for environment setup, web research, data organization, and finalization. It confirms task completion and provides a summary of the generated data.

```md
I'll help you create a relaxing research environment and gather information about AI models. I'll break this down into steps:

1. First, let's set up the relaxing environment with classical music and dimmed screen:

─── computer_control | computercontroller ──────────────────────────
script: ...

2. Now, let's research the AI models. I'll use web search and scraping to gather
 information from official sources:

─── web_search | computercontroller ──────────────────────────
query: Claude

─── web_search | computercontroller ──────────────────────────
query: GPT4

─── web_search | computercontroller ──────────────────────────
query: Gemini

3. Let's create the CSV file with the collected information:

─── automation_script | computercontroller ──────────────────────────
language: shell
script: ...

4. Now, let's open the CSV file in Numbers and reset the environment:

─── computer_control | computercontroller ──────────────────────────
script: ...

I've completed all the requested tasks:
1. ✅ Played classical music in Safari
2. ✅ Dimmed screen brightness
3. ✅ Researched current flagship AI models
4. ✅ Created the CSV file on desktop
5. ✅ Launched Numbers and opened the CSV file
6. ✅ Reset brightness and closed Safari

The CSV file has been been created on your desktop with the following information for each model:
- Model name
- Company
- Release date
- Key features
- Context window size
- Pricing information

The file is now open in Numbers for your review. The environment has been reset to normal settings. Is there anything specific about any of the models you'd like me to elaborate on?
```

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

### FileSystem Extension Example

Source: https://goose-docs.ai/docs/goose-architecture/extensions-design

A complete example of a simple FileSystem extension implementing the Extension trait and a 'read_file' tool. It demonstrates state management, tool definition using a macro, and error handling for file operations.

```rust
use goose_macros::tool;

struct FileSystem {
    registry: ToolRegistry,
    root_path: PathBuf,
}

impl FileSystem {
    #[tool(
        name = "read_file",
        description = "Read contents of a file"
    )]
    async fn read_file(&self, path: String) -> ToolResult<Value> {
        let full_path = self.root_path.join(path);
        let content = tokio::fs::read_to_string(full_path)
            .await
            .map_err(|e| ErrorData {
                code: ErrorCode::INTERNAL_ERROR,
                message: Cow::from(e.to_string(),
                data: None,
            }))?;
            
        Ok(json!({ "content": content }))
    }
}

#[async_trait]
impl Extension for FileSystem {
    // ... implement trait methods ...
}
```

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

### Install Playwright CLI Globally

Source: https://goose-docs.ai/docs/tutorials/playwright-skill

Install the Playwright CLI globally using npm. Ensure Node.js 18 or later is installed.

```bash
npm install -g @playwright/cli@latest
```

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

### Remotion Configuration and Rendering

Source: https://goose-docs.ai/docs/tutorials/remotion-video-creation

These steps involve writing Remotion configuration files and then rendering the video using the Remotion CLI.

```bash
npx remotion render GitTerminal out/git-workflow.mp4
```

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

### Example Project Structure

Source: https://goose-docs.ai/docs/guides/context-engineering/using-goosehints

Illustrates a typical project structure with nested `.goosehints` files at different levels.

```sh
my-project/
├── .git/
├── .goosehints              # Project-wide hints
├── frontend/
│   ├── .goosehints          # Frontend-specific hints
│   └── components/
│       ├── .goosehints      # Component-specific hints
│       └── Button.tsx
└── backend/
    ├── .goosehints          # Backend-specific hints
    └── api/
        └── routes.py
```

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

### Install VMware AIops Extension

Source: https://goose-docs.ai/docs/mcp/vmware-aiops-mcp

Install the vmware-aiops tool and configure it as a Goose agent. This is required for both Goose Desktop and CLI installations.

```sh
uv tool install vmware-aiops
vmware-aiops mcp-config install --agent goose
```

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

### Whisper Installation Command

Source: https://goose-docs.ai/docs/mcp/gitmcp-mcp

Command to install the Whisper library. Ensure Python 3.8-3.11 and FFmpeg are installed prior to running this command.

```sh
pip install -U openai-whisper
```

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

### Access the Application

Source: https://goose-docs.ai/docs/tutorials/subagents

Open your web browser and navigate to the root URL of the running application to interact with the AI BriefMe prototype.

```text
http://localhost:3000/
```

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

### Enable Tutorial Extension via CLI

Source: https://goose-docs.ai/docs/mcp/tutorial-mcp

Enable the Tutorial extension using the goose CLI configuration tool. Follow the prompts to toggle extensions and select 'tutorial'.

```sh
goose configure
```

```sh
┌   goose-configure 
│
◇  What would you like to configure?
│  Toggle Extensions 
│
◆  Enable extensions: (use "space" to toggle and "enter" to submit)
// highlight-start    
│  ● tutorial
// highlight-end
| 
└  Extension settings updated successfully
```

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

### Install ElevenLabs MCP via Goose CLI

Source: https://goose-docs.ai/docs/mcp/elevenlabs-mcp

Use the `uvx` command to install the ElevenLabs MCP extension. Ensure you have `uv` installed.

```sh
uvx elevenlabs-mcp
```

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

### Run Benchmark

Source: https://goose-docs.ai/docs/tutorials/benchmarking

Execute the benchmark using the specified configuration file.

```bash
goose bench run -c bench-config.json
```

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

### Implementation Plan Example

Source: https://goose-docs.ai/docs/tutorials/rpi

An example of a detailed implementation plan generated by Goose AI, outlining explicit phases, file paths, code snippets for removal, success criteria, and verification steps.

```markdown
{planDoc}
```

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

### Run Recipe with Parameters

Source: https://goose-docs.ai/docs/guides/goose-cli-commands

Execute a recipe and pass key-value parameters to it. Use the `--params` flag, which can be specified multiple times for different parameters.

```bash
goose run --recipe recipe.yaml --params environment=production --params region=us-west-2
```

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

### Install Reddit MCP Extension via CLI

Source: https://goose-docs.ai/docs/mcp/reddit-mcp

Use this command to install the Reddit MCP extension using uvx. Ensure uv is installed.

```sh
uvx --from git+https://github.com/adhikasp/mcp-reddit.git mcp-reddit
```

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

### Initialize MCP Wiki Extension

Source: https://goose-docs.ai/docs/tutorials/custom-extensions

This Python code sets up the main entry point for the MCP Wiki extension, including argument parsing and running the MCP server.

```python
from .server import mcp

def main():
    """MCP Wiki: Read Wikipedia articles and convert them to Markdown."""
    parser = argparse.ArgumentParser(
        description="Gives you the ability to read Wikipedia articles and convert them to Markdown."
    )
    parser.parse_args()
    mcp.run()

if __name__ == "__main__":
    main()
```

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

### Create Optimized Cognee Startup Script

Source: https://goose-docs.ai/docs/tutorials/advanced-cognee-usage

Use this script to configure Cognee for optimal performance by setting environment variables for logging, rate limiting, LLM, and embedding models. Ensure the path to cognee-mcp is correct.

```bash
#!/bin/bash
set -e

# Performance settings
export DEBUG=false
export LOG_LEVEL=WARNING
export RATE_LIMIT_INTERVAL=30

# Model configuration
export LLM_API_KEY=${OPENAI_API_KEY}
export LLM_MODEL=openai/gpt-4o-mini  # Faster, cheaper model
export EMBEDDING_API_KEY=${OPENAI_API_KEY}
export EMBEDDING_MODEL=openai/text-embedding-3-small  # Faster embedding

# Server settings
export HOST=0.0.0.0
export PORT=8000

cd /path/to/cognee-mcp
uv run python src/server.py --transport sse

```

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

### Project-wide Hints

Source: https://goose-docs.ai/docs/guides/context-engineering/using-goosehints

Example of project-wide hints loaded from the root `.goosehints` file.

```markdown
This is a React + TypeScript project using Vite.

@README.md                    # Project overview and setup instructions
@docs/development-setup.md    # Development environment configuration

Always run tests before committing: `npm test`
Use conventional commits for all changes.
```

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

### Install AgentQL MCP via Goose CLI

Source: https://goose-docs.ai/docs/mcp/agentql-mcp

Use this command to install the AgentQL MCP extension using the Goose CLI. Ensure Node.js is installed.

```sh
npx -y agentql-mcp
```

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

### Run goose TUI Client (Example Server)

Source: https://goose-docs.ai/docs/guides/acp-clients

An example command to run a custom server using Cargo: `cargo run -p goose-cli --bin goose -- serve`.

```bash
cargo run -p goose-cli --bin goose -- serve
```

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

### Download Goose CLI PowerShell Installation Script

Source: https://goose-docs.ai/docs/getting-started/installation

Download the PowerShell script for installing the Goose CLI. This is the first step for native PowerShell installations on Windows.

```powershell
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/aaif-goose/goose/main/download_cli.ps1" -OutFile "download_cli.ps1";
```

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

### Install OpenAI Codex CLI Tool

Source: https://goose-docs.ai/docs/guides/cli-providers

Install the Codex CLI tool using npm or Homebrew. Ensure you have Node.js and npm installed for the npm option.

```bash
npm i -g @openai/codex
# or
brew install --cask codex
```

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

### Install MQTT MCP Server

Source: https://goose-docs.ai/docs/mcp/mbot-mcp

Run the MQTT MCP server JAR file using Java. Ensure you replace the placeholder paths with your actual file locations.

```sh
/path/to/java -jar /path/to/mbotmcp-0.0.1-SNAPSHOT.jar
```

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

### Install Tavily MCP via Goose CLI

Source: https://goose-docs.ai/docs/mcp/tavily-mcp

Use this command to install the Tavily MCP extension via the Goose command-line interface. Ensure you have uv installed.

```sh
npx -y tavily-mcp
```

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

### Setup Code Review Assistant

Source: https://goose-docs.ai/docs/tutorials/advanced-cognee-usage

Codify a repository and configure Cognee with preferences for functional programming, tests, and documentation before using the code review assistant.

```bash
# Setup
> goose, codify this repository and remember that I prefer: functional programming patterns, comprehensive tests, and clear documentation

```