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

# MCP Servers

> Built-in Model Context Protocol server implementations

Goose includes several built-in MCP (Model Context Protocol) servers that can be run standalone or used as extensions.

## Running MCP Servers

MCP servers can be executed directly:

```bash theme={null}
goose mcp <server-name>
```

Available servers:

* `autovisualiser` - Data visualization and UI generation
* `computercontroller` - Web scraping and automation
* `memory` - Persistent memory storage
* `tutorial` - Interactive tutorials

## Server Details

### AutoVisualiser

Generate data visualizations and UI components.

```bash theme={null}
goose mcp autovisualiser
```

**Capabilities:**

* Chart generation (bar, line, pie, scatter)
* Interactive dashboards
* Data visualization from JSON/CSV
* UI component generation

**Use Cases:**

* Creating charts from data
* Building interactive reports
* Visualizing API responses

### ComputerController

Web scraping, file caching, and system automation.

```bash theme={null}
goose mcp computercontroller
```

**Tools:**

#### web\_scrape

Fetch and parse web content.

**Parameters:**

* `url` (string, required) - The URL to fetch
* `save_as` (string) - Format: `text`, `json`, or `binary`

```yaml theme={null}
tool: web_scrape
parameters:
  url: "https://api.example.com/data"
  save_as: json
```

**Features:**

* HTML to text conversion
* JSON API responses
* Binary file downloads
* Content caching

#### cache

Manage cached web content.

**Parameters:**

* `command` (string, required) - Operation: `list`, `view`, `delete`, `clear`
* `filename` (string) - File to operate on (for view/delete)

```yaml theme={null}
tool: cache
parameters:
  command: list
```

Operations:

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

#### automation\_script

Execute automation scripts.

**Parameters:**

* `language` (string, required) - Script type: `shell`, `batch`, `ruby`, `powershell`
* `script` (string, required) - Script content to execute
* `save_output` (boolean) - Save output to file

```yaml theme={null}
tool: automation_script
parameters:
  language: shell
  script: |
    #!/bin/bash
    echo "Processing data..."
    curl -s https://api.example.com/data | jq '.results'
  save_output: true
```

**Platform Support:**

* **Linux/macOS:** Shell, Ruby, PowerShell
* **Windows:** Batch, PowerShell, Ruby

#### Document Tools

Extract text from documents:

**read\_pdf**

* Extract text from PDF files
* Parameters: `file_path` (string)

**read\_docx**

* Extract text from Word documents
* Parameters: `file_path` (string)

**read\_xlsx**

* Extract data from Excel spreadsheets
* Parameters: `file_path` (string), `sheet_name` (optional)

### Memory

Persistent memory storage across sessions.

```bash theme={null}
goose mcp memory
```

**Tools:**

#### remember\_memory

Store information with categories and tags.

**Parameters:**

* `category` (string, required) - Memory category
* `data` (string, required) - Information to store
* `tags` (array) - Optional tags for filtering
* `is_global` (boolean, required) - Global or project-local storage

```yaml theme={null}
tool: remember_memory
parameters:
  category: "user_preferences"
  data: "User prefers TypeScript for new projects"
  tags: ["coding", "preferences"]
  is_global: true
```

#### retrieve\_memories

Retrieve stored memories.

**Parameters:**

* `category` (string, required) - Category to retrieve (use "\*" for all)
* `is_global` (boolean, required) - Global or project-local storage

```yaml theme={null}
tool: retrieve_memories
parameters:
  category: "user_preferences"
  is_global: true
```

#### remove\_memory\_category

Delete entire memory categories.

**Parameters:**

* `category` (string, required) - Category to remove (use "\*" for all)
* `is_global` (boolean, required) - Global or project-local storage

#### remove\_specific\_memory

Delete specific memory by content.

**Parameters:**

* `category` (string, required) - Category containing memory
* `memory_content` (string, required) - Exact content to remove
* `is_global` (boolean, required) - Global or project-local storage

**Storage Locations:**

* Global: `~/.config/goose/memory/global/`
* Local: `<project>/.goose/memory/`

### Tutorial

Interactive tutorials and guides.

```bash theme={null}
goose mcp tutorial
```

**Capabilities:**

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

## Protocol Details

### Communication

All MCP servers use stdio transport:

* **Input:** JSON-RPC requests on stdin
* **Output:** JSON-RPC responses on stdout
* **Errors:** Logged to stderr

### Server Capabilities

Each server announces capabilities:

```json theme={null}
{
  "tools": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  }
}
```

### Tool Schema

Tools are defined with JSON Schema:

```json theme={null}
{
  "name": "web_scrape",
  "description": "Fetch content from a URL",
  "inputSchema": {
    "type": "object",
    "properties": {
      "url": {
        "type": "string",
        "description": "The URL to fetch"
      }
    },
    "required": ["url"]
  }
}
```

## Integration with Goose

### As Extensions

MCP servers can be used as extensions:

```bash theme={null}
# Enable as built-in extension
goose session --with-builtin memory

# Configure permanently
goose configure
```

### Stdio Transport

MCP servers communicate over stdin/stdout:

```rust theme={null}
use rmcp::{transport::stdio, ServiceExt};

pub async fn serve<S>(server: S) -> Result<()>
where
    S: rmcp::ServerHandler,
{
    let service = server.serve(stdio()).await?;
    service.waiting().await?;
    Ok(())
}
```

### Error Handling

Servers return standardized errors:

```json theme={null}
{
  "code": -32602,
  "message": "Invalid params",
  "data": {
    "details": "URL parameter is required"
  }
}
```

Error codes:

* `-32700` - Parse error
* `-32600` - Invalid request
* `-32601` - Method not found
* `-32602` - Invalid params
* `-32603` - Internal error

## See Also

* [Extensions Overview](/api/extensions/overview) - Extension system concepts
* [Built-in Extensions](/api/extensions/builtin) - Using extensions in Goose
* [Session Command](/api/cli/session) - Starting sessions with extensions