Goose App Maker MCP
Enables creation and management of web application styles through custom CSS files stored in app directories
Supports web application functionality through custom JavaScript code, including integration with Goose API via a helper script
Provides package distribution capabilities, with instructions for building and publishing the MCP server to PyPI
Mentioned as a possible app type in the manifest.json structure, allowing creation of React-based web applications
Used for version management in the project configuration via pyproject.toml
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Goose App Maker MCP create a weather dashboard app that shows temperature and forecast"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Goose App Maker
This MCP (Model Context Protocol) sever allows users to create, manage, and serve web applications through Goose, that make use of Goose for api calls, data access, and more.
Install
click here to install in goose πͺΏ πͺΏπͺΏπͺΏπͺΏπͺΏπͺΏπͺΏπͺΏπͺΏ
Features
Create new web applications from basic instructions
Store apps in
~/.config/goose/app-maker-appsdirectory (each app in its own subdirectory)Serve web applications locally on demand
Open web applications in the default browser (and chromeless if possible)
Lists all available web applications
make apps that can themselves use goose as a generic backend
Related MCP server: mcp-toolkit
Examples
Load data via goose (re-using its extensions)
goose keeps track of your apps:
Make apps on demand
Show rich tabular or list data as well
Usage from source
eg in goose:
# Run directly from source
uv --directory $PWD run python main.pyIMPORTANT: this MCP is required to be run in the goose desktop app at the moment (as it accesses goose-server/goosed)
Building and publishing
Optional: Build in a clean environment using uv
uv venv .venv
source .venv/bin/activate
uv pip install build
python -m buildPublishing
Update version in
pyproject.toml:
[project]
version = "x.y.z" # Update thisBuild the package:
# Clean previous builds
rm -rf dist/*
python -m buildPublish to PyPI:
# Install twine if needed
uv pip install twine
# Upload to PyPI
python -m twine upload dist/*How it works
This MCP serves up apps, but also allows them to talk to goose via goosed and their own session:
Overview
The system implements a non-blocking, asynchronous request-response pattern that allows web applications to send requests to Goose and receive responses without blocking the main thread. This is achieved through a combination of:
A blocking endpoint on the server side
Asynchronous JavaScript on the client side
A response storage mechanism with thread synchronization
Web App Structure
Web apps are made (or downloaded) on request, based on resources/templates.
Each web app is stored in its own directory under ~/.config/goose/app-maker-apps with the following structure:
app-name/
βββ goose-app-manifest.json # App metadata
βββ index.html # Main HTML file
βββ style.css # CSS styles
βββ script.js # JavaScript code
βββ goose_api.js # allows the apps to access goose(d) for deeper backend functionality
βββ ... # Other app files
The goose-app-manifest.json file contains metadata about the app, including:
name: Display name of the app
type: Type of app (e.g., "static", "react", etc.)
description: Brief description of the app
created: Timestamp when the app was created
files: List of files in the app
1. Client-Side Request Flow
When a client wants to get a response from Goose:
βββββββββββ βββββββββββββββββββ βββββββββββββββββ ββββββββββββββββ
β User ββββββΆβ gooseRequestX() ββββββΆβ Goose API ββββββΆβ waitForResp- β
β Request β β (text/list/ β β (/reply) β β onse endpoint β
βββββββββββ β table) β βββββββββββββββββ ββββββββββββββββ
βββββββββββββββββββ β
β² β
β β
ββββββββββββββββββββββββββββββββββββββββββββββ
ResponseThe user initiates a request (e.g., clicking "Get List Response")
The client calls one of the request functions (
gooseRequestText,gooseRequestList, orgooseRequestTable)The function generates a unique
responseIdand sends a request to Goose with instructions to callapp_responsewith this IDThe function then calls
waitForResponse(responseId)which polls the/wait_for_response/{responseId}endpointThis endpoint blocks until the response is available or a timeout occurs
When the response is available, it's returned to the client and displayed
2. Server-Side Processing
On the server side:
βββββββββββββββ βββββββββββββββ βββββββββββββββββ
β HTTP Server ββββββΆβ app_responseββββββΆβ response_locksβ
β (blocking β β (stores β β (notifies β
β endpoint) βββββββ response) βββββββ waiters) β
βββββββββββββββ βββββββββββββββ βββββββββββββββββThe
/wait_for_response/{responseId}endpoint uses condition variables to block until a response is availableWhen Goose processes the request, it calls the
app_responsefunction with the response data and theresponseIdThe
app_responsefunction stores the response in theapp_responsesdictionary and notifies any waiting threads using the condition variableThe blocked HTTP request is then unblocked and returns the response to the client
3. Thread Synchronization
The system uses Python's threading.Condition for thread synchronization:
When a client requests a response that isn't available yet, a condition variable is created for that
responseIdThe HTTP handler thread waits on this condition with a timeout (30 seconds)
When the response becomes available, the condition is notified
If the timeout expires before the response is available, an error is returned
Key Components
Client-Side Functions
gooseRequestText(query): Requests a text responsegooseRequestList(query): Requests a list responsegooseRequestTable(query, columns): Requests a table response with specified columnswaitForResponse(responseId): Waits for a response with the given ID
Server-Side Functions
app_response(response_id, string_data, list_data, table_data): Stores a response and notifies waitersHTTP handler with
/wait_for_response/{responseId}endpoint: Blocks until response is available
Available Tools
9 toolsapp_createB
Create a new web application directory and copy starter files.
The starter files are for you to replace with actual content, you don't have to use them as is.
the goose_api.js file is a utility you will want to keep in case you need to do api calls as part of your app via goose.
Args:
app_name: Name of the application (will be used as directory name)
description: Brief description of the application (default: "")
Returns:
A dictionary containing the result of the operation
After this, consider how you want to change the app to meet the functionality, look at the examples in resources dir if you like.
Or, you can replace the content with existing html/css/js files you have (just make sure to leave the goose_api.js file in the app dir)
Use the app_error tool once it is opened and user has interacted (or has started) to check for errors you can correct the first time, this is important to know it works.Inputs: app_name (required), description. Returns: result
app_deleteC
Delete an existing web application.
Args:
app_name: Name of the application to delete
Returns:
A dictionary containing the result of the operation
Inputs: app_name (required). Returns: result
app_errorA
Report an error from the app or retrieve the list of errors.
This is useful while developing or debugging the app as it allows errors (or any messages) to be reported and monitored
Args:
error_message: Optional error message to report. If None, returns the list of errors.
clear: Optional, If True, clears the list of errors
Returns:
A string containing the list of errors if error_message is None,
otherwise a confirmation message.
Inputs: error_message, clear. Returns: result
app_listB
List all available web applications.
Returns:
A dictionary containing the list of available apps and their details
Inputs: no named parameters. Returns: result
app_openA
Open an app in the default web browser. If the app is not currently being served,
it will be served first.
Can only open one app at a time.
Args:
app_name: Name of the application to open
Returns:
A dictionary containing the result of the operation
Inputs: app_name (required). Returns: result
app_refreshA
Refresh the currently open app in Chrome.
Only works on macOS with Google Chrome.
Returns:
A dictionary containing the result of the operation
Inputs: no named parameters. Returns: result
app_responseA
Use this to return a response to the app that has been requested.
Provide only one of string_data, list_data, or table_data.
Args:
string_data: Optional string response
list_data: Optional list of strings response
table_data: Optional table response with columns and rows
Format: {"columns": ["col1", "col2", ...], "rows": [["row1col1", "row1col2", ...], ...]}
Returns:
True if the response was stored successfully, False otherwise
Inputs: string_data, list_data, table_data. Returns: result
app_serveA
Serve an existing web application on a local HTTP server.
The server will automatically find an available port.
Can only serve one app at a time
Args:
app_name: Name of the application to serve
Returns:
A dictionary containing the result of the operation
Inputs: app_name (required). Returns: result
app_stop_serverB
Stop the currently running HTTP server.
Returns:
A dictionary containing the result of the operation
Inputs: no named parameters. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogβ¦
TDQS
Scored across 9 tools
Most tools have distinct purposes, but there is some potential confusion between app_open and app_serve, as both involve launching an app, and app_error's dual functionality for reporting and retrieving errors could be ambiguous. However, the descriptions clarify their specific roles, making them generally distinguishable.
All tool names follow a consistent 'app_' prefix with a descriptive action in snake_case, such as app_create, app_delete, and app_list. This pattern is maintained throughout all nine tools, making them predictable and easy to understand.
With 9 tools, the count is well-scoped for managing web applications, covering creation, deletion, listing, serving, opening, error handling, refreshing, responding, and stopping the server. Each tool serves a clear purpose without redundancy, fitting the domain appropriately.
The toolset provides comprehensive coverage for basic app lifecycle management, including CRUD operations and runtime interactions. A minor gap exists in the lack of an update tool for modifying existing apps, but agents can work around this by recreating apps or using other tools like app_response for content changes.
Maintenance
Related MCP Connectors
Manage game servers, configurations, players, and groups through the GameServerApp MCP server.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
A MCP server built for developers enabling Git based project management with project and personalβ¦
Build, deploy, and host full-stack web apps from any MCP client. DB, auth, storage, cron included.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server that enables web searches using a SearxNG instance, allowing MCP-compatible applications like Goose to perform internet searches.1GPL 3.0
- AlicenseAqualityDmaintenanceA general-purpose MCP server providing web search, persistent memory storage, and secure code execution capabilities. It enables AI agents to search the web, store and retrieve data, and run Python/JavaScript code in sandboxed environments.8MIT
- FlicenseCqualityDmaintenanceMCP server that enables deployment and management of MCP servers through a simple configuration-based interface.1-
- AlicenseNot gradedqualityBmaintenanceA full-featured MCP server for local development with filesystem, shell, editor, session persistence, and security features.2MIT