Skip to content
MCP server

Gomo Sounds

Plan, generate and choose game sound effects, music and voice lines by chat

Pricing
Freemium
Platforms
Web, API
Runs
Remotely
Version
0.23.1
Listing updated
3 days ago

About Gomo Sounds

Gomo Sounds is a freemium MCP server for design and media. It runs as a hosted remote server, so there is nothing to install locally.

Gomo Sounds organizes game audio around the game itself. Each sound is something that happens in the game, such as Move, Land or Click, and each has several generated versions; you pick which versions ship and the game chooses among them at random. The thing that makes the sound, a beetle warrior or a river stone, appears as a labelled card with its image.

Over MCP an assistant can list your games, search sounds by name, event or description, generate more versions with or without a changed prompt, pick the best ones, and create folders and sounds. game_progress reports how much of a game already has a sound and lists missing events, so the assistant can offer to fill the gaps.

It runs on the website, so nothing is installed. Claude uses an account sign-in; Claude Code, Cursor and VS Code use an access key created under Integrations.

Install

Run in a terminal

claude mcp add --transport http gomo-sounds https://gomosounds.com/mcp

Add to Settings → Connectors → Add custom connector

https://gomosounds.com/mcp
Install in CursorOpens Cursor, which asks you to confirm. Or add it by hand:

Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "gomo-sounds": {
      "url": "https://gomosounds.com/mcp"
    }
  }
}
Install in VS CodeOpens VS Code, which asks you to confirm. Or add it by hand:

Add to .vscode/mcp.json

{
  "servers": {
    "gomo-sounds": {
      "type": "http",
      "url": "https://gomosounds.com/mcp"
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "gomo-sounds": {
      "serverUrl": "https://gomosounds.com/mcp"
    }
  }
}

Add to your client's MCP settings (most use this shape)

{
  "mcpServers": {
    "gomo-sounds": {
      "type": "http",
      "url": "https://gomosounds.com/mcp"
    }
  }
}

Tools this server provides (37)

Read directly from the server.

create_game
Creates a game in the account. It's the FIRST step: without a game there are no folders or entities. A new project ALWAYS gets a new game: never reuse an existing game because its name matches the project. If the account has a game with the same or a similar name, the call is refused with the list: ask the user whether to use that game or create a new one (suggest a different name when it is the s
game_progress
How much of the game already has a chosen sound (what goes into the game), in % and per tab (Ambience, Sound effects, Interface), and EVERY missing event, with its id. Call it at the end of any setup or bulk generation and whenever the user asks what's missing. Below 100%: show what's missing and the cost to complete it, and ask whether to generate.
sounds_for_folder
Creates the event event_name on EACH entity in a folder (and subfolders) and generates each one's sound, with its own prompt: {entity} and {description} in the prompt become each entity's name and description. WITHOUT max_credits it only plans: returns the entities, the total cost and the balance, without spending anything. Show the user and, with their OK, call again with max_credits equal to the
find_sounds
Searches entities (units, mobs, buildings, screens) by name, game, event or prompt, ignoring accents/case, and returns EVERYTHING about each one: image, events (Attack, Death...), each generated variation with id, prompt used, duration, cost, date, whether it's the chosen one, the audio URL and the editor link (editUrl), plus the page of the entity and of each event on the site (url). Also finds f
get_entity
Reads one entity (a thing of the game that makes noise) with everything about its sounds: its image, its events and every generated variation of each event (prompt, duration, chosen or not, audio link). Also returns the site pages to give the user: the entity (url: opens it, with its sound cards), each event (url: the player to listen, choose, trim and combine) and each variation's editor (editUrl
list_games
The account's games and projects (kind: game or project; a project is the same thing for anything that is not a game) with how much is in each (entities, events and generated sounds; a game can have every sound in folder events and no entity), the credit balance and the prices: account.creditsPerSecond for sounds, account.music.creditsPerMinute per quality level for tracks (cost = seconds × that ÷
get_game
Reads one game: its settings (engine, description, visibility, sound direction), its entities (the things that make noise, like the player or an enemy) with how many of their events already have a chosen sound, and the inbox (scenes the engine plugin sent that are not placed yet). Returns the site link (url) of the game and of each entity. Read-only, costs nothing. Use it after list_games to see w
generate_sounds
Generates sound variations for an event (spends credits: refused until the user approved the cost in the conversation, see approve_spending). Without prompt/duration/loop, uses the event's. LOOP OR ONE-SHOT, decided from what the sound is in the game: a LOOP is anything that lasts while something keeps happening and the game plays on repeat: ambience and weather, music, engines and machines, fire
generate_music
Generates ONE version of a track for an event of the Music tab (spends credits: refused until the user approved the cost in the conversation, see approve_spending). Without prompt/duration/loop, uses the event's. The prompt goes to the music model exactly as written (nothing is rewritten or added behind it), so write it in English as comma-separated tags: genre, mood, instruments, tempo, productio
derive_music
Makes a NEW version of a track from an existing version (spends credits: refused until the user approved the cost, see approve_spending). origin=repaint regenerates only the section [start, end] seconds (at least 3 s) and keeps the rest; origin=extend adds `seconds` of new music after the end, in the same mood (the final length must fit the user's plan); origin=cover makes a similar track from thi
create_tracks
Creates several tracks at once in the game's Music folder (created with the first track) or in one of its subfolders: free, nothing is generated. Each track has a name (what it is in the game: Main theme, Forest, Boss fight), a prompt (how it sounds, sent to the model as is: English comma-separated tags such as genre, mood, instruments, tempo), a duration, loop AND the same form as generate_music,
job_status
Where the user's generations are: pass the jobIds from generate_music/derive_music with wait=false (or omit job_ids to list every unfinished one of the account). Each job is waiting (its turn in the account's queue: the account generates one track at a time and the rest follow on their own), queued (with the engine), running, done (with the new versions; if the event had no chosen version, the new
list_voices
The voice library for character lines (voice sounds): each voice with its id, name, who it is (person: homem = man, mulher = woman, menino = boy, menina = girl), style (personagem = character, narracao = narrator), a description in the user's language, the registers it has (coloquial = loose, the default; conversa = conversational; formal = read) and sample links per register and language. Also th
create_voice
Creates ONE voice sound (a character line) in a game, in its Voices folder ("Vozes" in Portuguese games), created with the first line. Free: nothing is generated yet. name = what the game calls it (e.g. "Victory line", "Groovy"); text = exactly what the character says, as written (up to maxChars of list_voices; split longer speeches into several lines). Pick the voice, register and emotion from li
generate_voice
Generates versions (1 to 4) of a voice line created with create_voice, with its text, voice, register and emotion (spends credits: refused until the user approved the cost in the conversation, see approve_spending). A line costs its estimated seconds (characters / charsPerSecond of list_voices, at least 1 s) × creditsPerSecond × versions. Voice versions are NEVER chosen automatically, not even the
choose_sound
Edits the event's LIST of sounds the game picks from at random. Pass generation_ids to set the whole list at once (2-3 is a good amount for variety); or generation_id with mode: 'add' adds one, 'remove' removes one, 'only' replaces the list with one, null empties it. After choosing, the UNCHOSEN variations of this event are DELETED to keep the account clean (favorites, edited sounds and sounds use
share_sound
Makes several events of the same game play the sound of one variation's event (e.g. the same 'Building' sound on all buildings), instead of generating one sound per event. Live link: changing the sound on the original changes it everywhere; the variation joins the original's list if it wasn't there yet. The sounds the target events had are removed from their lists, so ask the user first if they al
create_entity
Creates an entity in a game: a THING that exists in the game and makes noise (unit, enemy, building, object, block, character, button or screen). NEVER an action or moment: 'Undo', 'Snap', 'Level complete', 'Jump' are EVENTS of something (of Interface, of Blocks, of the Character), not entities. Inside a folder, it inherits the folder's events. On the site it is a folder with its image and name, h
create_event
Adds an event to an entity OR to a folder. The event name is WHAT happens (Move, Attack, Die, Land, Click, Undo, Level complete), never 'Sound' or 'Som'. A folder event applies to all entities inside it (e.g. 'Select' once for all units); an entity can have its own with the same name, which wins. Game actions with no owner (Undo, Victory, Level complete) go as events of the Interface folder. Ambie
delete_sound
Deletes a sound (event) or a track for good, with its versions, like the Delete button on its page: the game stops playing it. Versions that are favorites or also chosen in another sound stay there. While it has a generation queued or running, it is refused: wait for it (job_status). ONLY when the user asked, in this conversation, to delete THIS sound (say its name and game before); never to tidy
list_folders
Reads the folder tree of one game, one line per folder (path and id), with each folder's events: name, id, ✓ when a sound is chosen, duration and loop, and for a Music track the settings saved in its form (mode, quality, genre, bpm, key, beats per bar, sung or instrumental). Entities inside a folder inherit its events. Read-only, costs nothing. Use it to find a folder_id or parent_id before create
set_sound_direction
Sets the style rules every generation follows, so the game's sounds match (materials, what to avoid, duration, mixing). With game_id it applies to the whole game; with folder_id, to everything inside the folder (added to the game's). Empty text clears it. The text replaces what was there and guides only the next generations: existing sounds stay as they are. Spends no credits. Use it when the user
create_folder
Creates a folder (free name) in a game, to GROUP several entities (Enemies, Items) or, in Ambience and Interface, sounds by place or screen. Never a folder for a single thing like the player: that is an entity (create_entity). It goes at the root of a tab (section) or inside another folder (parent_id), and can already take entities (entity_ids), which then inherit its events. Every tab takes subfo
move_entities
Moves entities of one game into a folder (folder_id), or out of their folder (empty folder_id: back to Sound effects). In the new folder they inherit its events and stop inheriting the old folder's; their own events and sounds stay. Spends no credits, and moving again to the same folder changes nothing. Use it to reorganize after create_entity or place_scenes; find folder ids with list_folders and
set_game_visibility
Changes who can see a game. public: anyone can open it and it shows up in the site's Explore gallery. private: only the owner sees it; needs a paid plan, and on the free plan the call fails with a message to show the user. Doesn't touch the sounds or spend credits, and calling it again with the same value changes nothing. Only call it when the user asks to lock or open the game.
save_sound
Only when the user asked for the file or chose to bring the sounds only through the conversation; never to put files into their project before that. Link to download an audio file FROM YOUR ACCOUNT (audio URL from find_sounds/get_entity): show it to the user, who opens it in the browser (it works without logging in, for 24 hours). Explore sounds belong to other accounts and do NOT come out through
export_game
For the user to download all the chosen sounds at once (other engines, or when they ask). Link to the .zip with the game's CHOSEN sounds and the manifest.json (neutral format for any engine): show it to the user, who opens it in any browser (it works for 24 hours). In Godot, the plugin installs it directly. An event with more than one sound (e.g. 3 sword hits) must be played by picking one of its
get_manifest
For engine plugins, and for you when the user chose to bring the sounds only through the conversation (save each sound to its suggested path, next to its scene; never before that choice): the game's CHOSEN sounds in the neutral manifest format (gomo-sounds/manifest@1), each with a download link valid for 24 hours and the suggested path in the project. To hand the user a ready .zip, use export_game
sync_scenes
For engine plugins: sends the project's scenes (up to 20 per call) to the game's Inbox, matching by the engine id (externalId, e.g. res://units/spider.tscn). A scene that is already an entity only gets its image refreshed; a new one waits in the Inbox until the user places it in a tab on the site. Sending again never duplicates. Plugin flow, in order: sync_scenes (the plugin sends its scenes), gam
mark_installed
For engine plugins: tells the site the chosen sounds were installed in the project now, so the site can show which changes already reached the game. Plugin flow, in order: sync_scenes (the plugin sends its scenes), game_scenes (see what arrived), place_scenes (turn them into entities), mark_installed (the plugin reports the install).
godot_plugin
The kit to put the Gomo Sounds plugin into the user's Godot project, with the rules to do it without breaking anything, AND the version check: call it only when the user chose the plugin (it is optional: the conversation alone also works) or asks for it, and ALWAYS before telling the user to Sync or to Install sounds. Returns the current version, the versions the plugin of this account has reporte
game_scenes
What the engine plugin synced into the game: when the last sync was, the scenes waiting in the Inbox (not in any tab yet; each has a suggested tab from its project path) and the scenes that are already entities, with their folder. Call it after the user clicks Sync in the plugin, to confirm it worked, and before creating entities by hand for a Godot game: a synced scene must not be created twice.
place_scenes
Turns scenes waiting in the game's Inbox (sent by the engine plugin; see game_scenes) into entities in a tab, exactly like dragging them on the site. section auto (default) puts each scene by its project path: ui/ or menus/ to Interface, maps/ or levels/ to Ambience, the rest in Sound effects inside a folder named after the project folder (res://units/x.tscn goes to Units). Or choose the tab (ambi
suggest_game_setup
Call it only after the USER picked "maximum refinement" and answered or confirmed the six fields. Make each field rich and concrete (the look and palette, every character and what it is made of, the mood, reference games), read from the project when you can, and review the result before showing it (see the QUALITY BAR in the instructions). The same assistant as the site's "I want maximum refinemen
accept_terms
Accepts the current Terms of Use and Privacy Policy for the account, like the button on the site. Call it ONLY after a tool answered terms_required, you asked the user that exact question with the links and the user explicitly said yes in this conversation. Never call it on your own or because the user asked for something else. Then retry what you were doing.
approve_spending
Records that the USER approved spending credits: valid until that total is spent, for up to 6 hours (a whole batch of tracks fits in one yes); generate_sounds, generate_voice, generate_music and sounds_for_folder refuse without it. Call it ONLY after you showed the user the whole plan with the total cost ("Posso gerar <plan> por <total> créditos? Você tem <balance>.") and the user explicitly said
gomo_guide
The full rules of Gomo Sounds: how games, folders, entities and events work, loop and duration, cost and the yes before spending, the two doors of a new game, the quality bar, Godot (plugin or only the conversation), links and downloads. Call it FIRST in every conversation, before any other tool, and follow it.

What it does

Game-structured library
Sounds are grouped by game, entity and event, each with versions.
Chat generation
Generate new versions with the original or an edited description.
Choose what ships
Mark which versions go to the game.
Progress report
See percent of events covered and every missing event.
Rich search
Find sounds by name, game, event or description.
Folders
Create and move folders, including music and ambience events.

Good for

  • Fill every missing event in a game with sound effects
  • Ask for the sounds of a dragon and review each version
  • Generate more versions of a button click
  • Organise music and interface sounds into folders

Pricing

Freemium

MCP on every plan including free; generating sounds uses credits

Prices change. Check gomosounds.com before you buy.

Gomo Sounds FAQ

Does it need an install?

No. The MCP endpoint at gomosounds.com/mcp runs on the website.

Is it free?

MCP works on every plan including free; generating sounds uses credits, as on the site.

How do I authenticate?

Sign in with your account in Claude, or send an access key as a Bearer header in Claude Code, Cursor or VS Code.

How do I test it?

Ask the assistant to list your games; it should call list_games.

Is Gomo Sounds free?

Gomo Sounds has a free plan, with paid plans for more usage or features.

How do I add Gomo Sounds to Claude Code?

Run this command in your terminal: claude mcp add --transport http gomo-sounds https://gomosounds.com/mcp

What are the best alternatives to Gomo Sounds?

The closest alternatives to Gomo Sounds are HyperFrames by HeyGen, ffmpeg-skill, AvatarSay — Fictional Character & Talking Video MCP, ChartAnt and VfxSmith.

Alternatives to Gomo Sounds

  1. Hosted MCP connector for creating and rendering videos from HTML through AI chat

    • Remote
    • Freemium
    • 85.3K GitHub stars
    • Design and media
  2. ffmpeg-skill

    MCP server

    Local FFmpeg video and audio editing tools for coding agents over MCP

    Runs locally
    • Open source
    • 6.9K GitHub stars
    • Design and media
  3. ChartAnt

    MCP server

    Remote MCP server returning charts, maps and dashboards as hosted PNG links

    • 51 tools
    • Remote
    • Freemium
    • Design and media
  4. VfxSmith

    MCP server

    Search, generate, refine and export pixel art game effects from Claude Code or Codex

    Not checked yet
    • Remote
    • Freemium
    • Design and media
  5. CalderFlow

    MCP server

    Turn notes or specs into editable flowcharts, timelines and funnels from an AI assistant

    • 10 tools
    • Remote
    • Free
    • Design and media