> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/block/goose/llms.txt
> Use this file to discover all available pages before exploring further.

# Extensions Overview

> Understanding Goose's extension system for adding custom capabilities

Goose's extension system allows you to add custom tools and capabilities to your AI agent through the Model Context Protocol (MCP). Extensions can be built-in, command-line (stdio), or remote (HTTP).

## Extension Types

### Built-in Extensions

Built-in extensions are bundled with Goose and provide core functionality:

* **developer** - Code editing and shell access
* **autovisualiser** - Data visualization and UI generation
* **computercontroller** - Web scraping, file caching, and automation
* **memory** - Persistent memory storage and retrieval
* **tutorial** - Interactive tutorials and guides

### Stdio Extensions

Stdio extensions run as local command-line processes that communicate over stdin/stdout using the MCP protocol.

```bash theme={null}
goose session --with-extension "npx -y @block/gdrive"
```

### Streamable HTTP Extensions

Remote extensions communicate over HTTP using MCP Streamable HTTP protocol.

```bash theme={null}
goose session --with-streamable-http-extension "http://localhost:8000/messages"
```

## Configuration

Extensions are configured in your `~/.config/goose/config.yaml` file:

```yaml theme={null}
extensions:
  developer:
    enabled: true
    config:
      type: platform
      name: developer
      description: Code editing and shell access

  my-custom-tool:
    enabled: true
    config:
      type: stdio
      name: my-custom-tool
      cmd: npx
      args: ["-y", "@my/tool"]
      description: My custom tool
      timeout: 120
```

## Using Extensions

### In CLI Sessions

Enable extensions for a session:

```bash theme={null}
# Use built-in extension
goose session --with-builtin developer

# Use multiple extensions
goose session --with-builtin developer,memory

# Use stdio extension
goose session --with-extension "npx -y @block/gdrive"

# Use without profile defaults
goose session --no-profile --with-builtin developer
```

### In Configuration

Add extensions interactively:

```bash theme={null}
goose configure
# Select: Add Extension
```

Toggle enabled extensions:

```bash theme={null}
goose configure
# Select: Toggle Extensions
```

## Extension Discovery

Goose discovers extension tools automatically through the MCP protocol. Each extension exposes:

* **Tools** - Functions the AI can call
* **Resources** - Data the extension can provide
* **Prompts** - Pre-defined instruction templates

The AI agent can see and use all tools from enabled extensions.

## Environment Variables

Extensions can use environment variables for configuration:

```yaml theme={null}
extensions:
  gdrive:
    enabled: true
    config:
      type: stdio
      name: gdrive
      cmd: npx
      args: ["-y", "@block/gdrive"]
      env_keys:
        - GOOGLE_API_KEY
      description: Google Drive integration
```

Secrets are stored securely in your system keyring.

## Timeouts

Set custom timeouts for long-running operations:

```bash theme={null}
# Set timeout in CLI
goose session --with-streamable-http-extension "http://localhost:8000 timeout=300"
```

In config:

```yaml theme={null}
config:
  timeout: 300  # seconds
```

Default timeout is 120 seconds.

## Container Support

Run extensions inside Docker containers:

```bash theme={null}
goose session --container my-container-id --with-builtin developer
```

The extension must be available inside the container. For built-in extensions, Goose must be installed in the container.

## See Also

* [MCP Servers](/api/extensions/mcp-servers) - Built-in MCP server implementations
* [Built-in Extensions](/api/extensions/builtin) - Detailed built-in extension reference
* [Configure Command](/api/cli/configure) - Managing extensions via CLI