> ## 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.

# Built-in Extensions

> Reference for Goose's bundled extension capabilities

Goose includes several built-in extensions that provide core capabilities. These extensions are ready to use without installation.

## Available Extensions

### developer

Code editing, file operations, and shell access.

**Enable:**

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

**Capabilities:**

* Read, write, and edit files
* Execute shell commands
* Navigate file systems
* Search code
* Run tests and builds

**Platform Extension:**
This is a platform-level extension with OS-specific implementations.

**Configuration:**

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

### autovisualiser

Data visualization and UI generation tools.

**Enable:**

```bash theme={null}
goose session --with-builtin autovisualiser
```

**Capabilities:**

* Generate charts (bar, line, pie, scatter)
* Create interactive dashboards
* Visualize data from JSON/CSV
* Build UI components

**Use Cases:**

* Data analysis visualization
* Report generation
* Interactive data exploration
* Dashboard creation

**Configuration:**

```yaml theme={null}
extensions:
  autovisualiser:
    enabled: true
    config:
      type: builtin
      name: autovisualiser
      description: Data visualisation and UI generation tools
      timeout: 120
      bundled: true
```

### computercontroller

Web scraping, file caching, and system automation.

**Enable:**

```bash theme={null}
goose session --with-builtin computercontroller
```

**Tools:**

#### web\_scrape

Fetch and parse web content.

**Example:**

```bash theme={null}
# In a Goose session:
"Scrape the latest news from https://example.com/news"
```

**Parameters:**

* `url` - URL to fetch
* `save_as` - Format: `text`, `json`, or `binary`

**Features:**

* HTML to text conversion
* JSON API responses
* Binary downloads
* Automatic caching

#### cache

Manage cached web content.

**Operations:**

* `list` - Show cached files
* `view` - Display file content
* `delete` - Remove specific file
* `clear` - Delete all cached files

**Example:**

```bash theme={null}
"Show me what's in the cache"
"Clear the web scraping cache"
```

#### automation\_script

Execute automation scripts in various languages.

**Supported Languages:**

* Shell/Bash (Linux/macOS)
* Batch (Windows)
* PowerShell (all platforms)
* Ruby (if installed)

**Example:**

```bash theme={null}
"Run a shell script to process the log files"
"Execute this PowerShell command to check disk space"
```

#### Document Readers

**read\_pdf** - Extract text from PDF files
**read\_docx** - Extract text from Word documents\
**read\_xlsx** - Extract data from Excel spreadsheets

**Example:**

```bash theme={null}
"Extract the text from report.pdf"
"Read the data from spreadsheet.xlsx"
```

**Configuration:**

```yaml theme={null}
extensions:
  computercontroller:
    enabled: true
    config:
      type: builtin
      name: computercontroller
      description: Controls for webscraping, file caching, and automations
      timeout: 120
      bundled: true
```

### memory

Persistent memory storage across sessions.

**Enable:**

```bash theme={null}
goose session --with-builtin memory
```

**Capabilities:**

* Store categorized information
* Tag-based retrieval
* Global and project-local storage
* Persistent across sessions

**Storage Types:**

**Global Memory:**
Stored in `~/.config/goose/memory/global/`\
Available across all projects.

**Local Memory:**
Stored in `<project>/.goose/memory/`\
Project-specific information.

**Operations:**

#### Store Memory

```bash theme={null}
"Remember that I prefer TypeScript for new projects"
"Save this API endpoint to memory: https://api.example.com"
```

**Parameters:**

* `category` - Organization category
* `data` - Information to store
* `tags` - Optional tags
* `is_global` - Global or local storage

#### Retrieve Memory

```bash theme={null}
"What do you remember about my coding preferences?"
"Retrieve all API endpoints from memory"
```

**Parameters:**

* `category` - Category to retrieve ("\*" for all)
* `is_global` - Global or local storage

#### Remove Memory

```bash theme={null}
"Delete the user_preferences category from memory"
"Remove that old API endpoint from memory"
```

**When to Use:**

* User preferences and habits
* Project configuration details
* Recurring workflow patterns
* API keys and endpoints
* Team conventions

**Configuration:**

```yaml theme={null}
extensions:
  memory:
    enabled: true
    config:
      type: builtin
      name: memory
      description: Tools to save and retrieve durable memories
      timeout: 120
      bundled: true
```

### tutorial

Interactive tutorials and learning guides.

**Enable:**

```bash theme={null}
goose session --with-builtin tutorial
```

**Capabilities:**

* Step-by-step guides
* Interactive examples
* Best practices
* Learning resources

**Use Cases:**

* Learning Goose features
* Understanding extension development
* Exploring MCP protocol
* Recipe creation guidance

**Configuration:**

```yaml theme={null}
extensions:
  tutorial:
    enabled: true
    config:
      type: builtin
      name: tutorial
      description: Access interactive tutorials and guides
      timeout: 120
      bundled: true
```

## Using Built-in Extensions

### Command Line

**Single Extension:**

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

**Multiple Extensions:**

```bash theme={null}
goose session --with-builtin developer,memory,computercontroller
```

**With Other Options:**

```bash theme={null}
goose run --recipe analyze.yaml --with-builtin developer,memory
```

### Configuration File

Add to `~/.config/goose/config.yaml`:

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

  memory:
    enabled: true
    config:
      type: builtin
      name: memory
      description: Persistent memory storage
      timeout: 120
      bundled: true
```

### Interactive Configuration

```bash theme={null}
goose configure
# Select: Add Extension
# Choose: Built-in Extension
# Select desired extension
```

## Extension Registry

Built-in extensions are registered at startup:

```rust theme={null}
use goose::builtin_extension::register_builtin_extensions;
use goose_mcp::BUILTIN_EXTENSIONS;

register_builtin_extensions(BUILTIN_EXTENSIONS.clone());
```

Registry maps extension names to spawn functions:

```rust theme={null}
pub static BUILTIN_EXTENSIONS: Lazy<HashMap<&'static str, SpawnServerFn>> = 
    Lazy::new(|| {
        HashMap::from([
            builtin!(autovisualiser, AutoVisualiserRouter),
            builtin!(computercontroller, ComputerControllerServer),
            builtin!(memory, MemoryServer),
            builtin!(tutorial, TutorialServer),
        ])
    });
```

## Container Support

Run extensions inside Docker containers:

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

**Requirements:**

* Extension must exist in container
* For built-in extensions, Goose must be installed in container
* Container must be running

## Disabling Profile Extensions

Skip default profile extensions:

```bash theme={null}
goose session --no-profile --with-builtin developer
```

This uses only the specified extensions, ignoring your profile defaults.

## Timeout Configuration

Set custom timeouts for long operations:

```yaml theme={null}
config:
  type: builtin
  name: computercontroller
  timeout: 300  # 5 minutes
```

Default timeout is 120 seconds.

## Platform Extensions

The `developer` extension is a platform extension with OS-specific implementations:

* **Linux:** Native file operations and shell
* **macOS:** Native file operations and Terminal integration
* **Windows:** Native file operations and PowerShell/CMD

## See Also

* [Extensions Overview](/api/extensions/overview) - Extension system concepts
* [MCP Servers](/api/extensions/mcp-servers) - MCP server implementation details
* [Configure Command](/api/cli/configure) - Managing extensions
* [Session Command](/api/cli/session) - Using extensions in sessions