Skip to main content
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: 
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. 
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. 
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
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)
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
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. 
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
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
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. 
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: 
{
  "tools": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  }
}

​
Tool Schema

Tools are defined with JSON Schema: 
{
  "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: 
# Enable as built-in extension
goose session --with-builtin memory

# Configure permanently
goose configure

​
Stdio Transport

MCP servers communicate over stdin/stdout: 
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: 
{
  "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

Build docs developers (and LLMs) love

Get started for freeTalk to us