quickerspot-mcp
Provides access to the ElevenLabs V3 voice engine for generating and managing commercial voice-over audio, including voice selection and TTS production.
mcp-name: io.github.raphaelInacio/quickerspot-mcp
Servidor MCP QuickerSpot
Servidor oficial Model Context Protocol (MCP) para a plataforma QuickerSpot — Automação de vinhetas, rádio indoor e sonorização comercial com IA.
Conecte seus Assistentes de IA (Cursor IDE, Claude Desktop, Antigravity, Hermes Agent, OpenClaw) diretamente ao motor de voz ElevenLabs V3, gerador de roteiros por IA e mixer de rádio indoor do QuickerSpot.
🚀 Como Usar em 2 Passos
1. Obter sua API Key
Acesse o painel do QuickerSpot em quickerspot.com/settings e crie uma nova API Key (ex: qs_live_...).
2. Configurar o mcp.json
Adicione a definição do servidor no seu arquivo mcp.json (ou claude_desktop_config.json):
{
"mcpServers": {
"quickerspot": {
"command": "uvx",
"args": ["quickerspot-mcp"],
"env": {
"QUICKERSPOT_API_KEY": "qs_live_SUA_CHAVE_AQUI"
}
}
}
}O quickerspot-mcp conecta-se automaticamente ao backend de produção do QuickerSpot. Se você estiver desenvolvendo localmente, pode adicionar "QUICKERSPOT_API_URL": "http://localhost:8000" no bloco env.
Related MCP server: ElevenLabs MCP Server
🛠️ Ferramentas MCP Disponíveis (tools)
list_voices()— Retorna o catálogo de vozes comerciais disponíveis (Camila, Helena, Marcos, Carlos, Ricardo).create_campaign(name, data, voice_tone, free_text)— Cria uma nova campanha comercial e gera o roteiro síncrono via IA.approve_script(campaign_id, script)— Aprova o roteiro e dispara a produção de áudio TTS + mixagem em background.get_campaign_status(campaign_id)— Consulta o status (PENDING,PROCESSING,COMPLETED), roteiro e URLs de download dos MP3s.list_campaigns()— Lista todas as campanhas ativas da sua conta.create_recado(text, voice_id)— Gera áudio instantâneo de recado/aviso para loja com vinheta (fast-lane sem fluxo HITL).
💻 Execução com Python Local (Opcional)
Se preferir rodar localmente com Python:
{
"mcpServers": {
"quickerspot": {
"command": "python",
"args": ["-m", "quickerspot_mcp.server"],
"env": {
"QUICKERSPOT_API_KEY": "qs_live_SUA_CHAVE_AQUI"
}
}
}
}Available Tools
6 toolsapprove_scriptA
Aprova (ou edita) o roteiro de uma campanha e dispara a produção de áudio (TTS e mixagem) em background.
Parâmetros:
campaign_id: ID da campanha a ser aprovada.
script: Texto do roteiro final editado (opcional). Se não informado, utiliza o roteiro gerado pela IA.
action: Ação a realizar ("approve" para aprovar e gerar áudio, ou "regenerate" para solicitar novo roteiro). Default: "approve".
Retorna uma confirmação de que o processamento foi iniciado em background (Status 202 Accepted).
Use get_campaign_status após alguns segundos para verificar a conclusão da produção.
| Name | Required | Description | Default |
|---|---|---|---|
| action | No | approve | |
| script | No | ||
| campaign_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by revealing that processing runs in background, that the API returns 202 Accepted, and that completion should be checked via another endpoint. Minor gaps include no mention of idempotency or failure behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, well-structured, and front-loaded with the core purpose. The parameter list and return behavior are presented efficiently without redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three parameters, no annotations, and a clear async workflow, the description covers the essential context: what the tool does, what each parameter means, what the response is, and how to follow up. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description fully compensates by explaining each parameter: campaign_id identifies the target, script is optional with fallback to the AI-generated script, and action defines the two possible behaviors with its default value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the main action ('Aprova (ou edita) o roteiro de uma campanha') and the follow-up effect ('dispara a produção de áudio'), making the tool's purpose specific and easily distinguishable from sibling tools like create_campaign and get_campaign_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool, explains the difference between 'approve' and 'regenerate', and explicitly directs the agent to use get_campaign_status afterward. It does not mention exclusions, but the workflow guidance is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_campaignA
Cria uma nova campanha comercial no QuickerSpot e gera o roteiro em formato texto via IA.
Esta operação é síncrona para a geração do roteiro (leva de 5 a 15 segundos). Após a criação, o estado da campanha fica como PENDING aguardando aprovação do roteiro.
Parâmetros:
name: Nome identificador da campanha (ex: "Ofertas de Fim de Semana").
data: Lista opcional de produtos com preços, ex: [{"product": "Detergente 500ml", "price": "R$ 2,99"}].
voice_tone: Tom de voz desejado (ex: "Friendly", "Enthusiastic", "Professional", "Urgent"). Default: "Friendly".
slogan: Slogan comercial da loja ou marca (opcional).
free_text: Instrução ou texto livre em formato plain text para a IA gerar o comercial (opcional se enviar data).
voice_id: ID da voz selecionada (consulte via
list_voices) (opcional).background_music: Trilha sonora de fundo (opcional).
audio_style: Estilo do áudio ("standard" | "dramatic") (opcional).
production_mode: Modo de produção ("standard" | "ai_production") (opcional).
Retorna um JSON com os dados da campanha criada, o ID da campanha (campaign_id ou id) e os roteiros gerados.
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | ||
| name | Yes | ||
| slogan | No | ||
| voice_id | No | ||
| free_text | No | ||
| voice_tone | No | Friendly | |
| audio_style | No | standard | |
| production_mode | No | standard | |
| background_music | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It usefully discloses that the script generation is synchronous and takes 5 to 15 seconds, that the campaign starts as PENDING, and that the result is JSON with campaign data, ID, and generated scripts. It does not mention failure modes or authorization requirements, but the key operational behaviors are transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well organized: a concise purpose statement, key behavioral notes, a labeled parameter list, and a return-value summary. Each bullet earns its place and provides concrete examples without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 9-parameter creation tool with zero schema descriptions and no annotations, the description is remarkably complete. It covers what the tool does, how long it takes, resulting state, every parameter's meaning, defaults, and the response shape. Little is left for the agent to guess.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully explain the parameters. It does: every parameter is listed with a human-readable meaning, examples, defaults, and allowed values for audio_style and production_mode. It also clarifies relationship hints like free_text being optional when data is sent, adding real semantic value beyond the bare JSON schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Cria uma nova campanha comercial no QuickerSpot e gera o roteiro em formato texto via IA.' This clearly distinguishes it from read-only siblings like list_campaigns and get_campaign_status, and from create_recado, by defining the exact object and outcome.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives practical context by noting that voice selection should be done via list_voices and that the campaign starts in PENDING state waiting for script approval, which implies subsequent use of approve_script. It does not explicitly name alternatives or say when not to use the tool, but the usage context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_recadoA
Gera um áudio instantâneo de recado curto (fast-lane TTS sem fluxo de aprovação HITL).
Ideal para anúncios rápidos de loja, avisos de estacionamento, chamadas de clientes ou recados operacionais. O áudio gerado já inclui vinheta/chime sonora no início.
Parâmetros:
text: Texto do recado a ser sintetizado (máximo 300 caracteres).
voice_id: ID da voz (opcional).
Retorna um JSON contendo os detalhes do áudio e a URL direta para download/reprodução do MP3.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| voice_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations to lean on, the description discloses meaningful behavioral traits: the audio is generated instantly, bypasses HITL approval, includes a vinheta/chime at the start, and returns a JSON payload with a direct MP3 download/reproduction URL. It does not discuss broader side effects, permissions, or rate limits, but the core behavior is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured: main function, use cases, behavioral note, parameters, and return format each appear once without filler. Every sentence contributes to tool selection or correct invocation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter generator with an output schema, this is nearly complete: it covers purpose, when to use it, parameter semantics, output behavior, and the distinctive chime trait. The main missing context is that valid voice IDs likely come from the sibling list_voices tool, and there is no explicit statement about what happens when text exceeds 300 characters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description compensates by explaining that text is the message to be synthesized and by adding the critical 300-character maximum. Voice_id is described as the optional voice ID, though it could be improved by pointing to the sibling list_voices tool for valid values and explaining default voice behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Gera um áudio instantâneo de recado curto' and immediately clarifies it is a fast-lane TTS flow without HITL approval. This clearly differentiates it from the approval-oriented sibling flow and from create_campaign, so an agent can identify when to select this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit use-case context such as quick store announcements, parking notices, customer calls, and operational messages. It also notes the no-approval fast lane, which strongly implies when this tool is appropriate. However, it does not explicitly name sibling alternatives or state when not to use it, so it falls just short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_campaign_statusA
Consulta o status atual, roteiros e links para os arquivos de áudio de uma campanha específica.
Utilize esta ferramenta para verificar se o áudio de uma campanha já terminou de ser produzido.
Status possíveis:
PENDING: Aguardando aprovação do roteiro.
PROCESSING: Áudio sendo gerado e mixado em background.
COMPLETED: Áudio gerado com sucesso. As URLs dos arquivos MP3 estão disponíveis no campo
audios.FAILED: Ocorreu uma falha durante o processamento.
Parâmetros:
campaign_id: ID da campanha a ser consultada.
| Name | Required | Description | Default |
|---|---|---|---|
| campaign_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden and does it well: it explains that PROCESSING is asynchronous, COMPLETED exposes MP3 URLs in the `audios` field, and FAILED indicates an error. It stops short of describing every possible edge case, such as error response behavior, but covers the essential behavior for correct use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, then provides a compact structured list of statuses, and closes with the parameter definition. Every sentence earns its place with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a single simple parameter and an output schema, so the description does not need to explain return formats. It covers what the tool returns at a high level, the possible statuses, and the meaning of the required parameter, making it fully sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by defining `campaign_id` as the ID of the campaign to be consulted. This is minimal but sufficient for a single, self-explanatory parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Consulta o status atual, roteiros e links para os arquivos de áudio') and clearly scopes it to a single campaign. It also enumerates the possible status values, making the tool's purpose unmistakable and distinct from sibling tools like create_campaign or list_campaigns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this tool to check whether a campaign's audio has finished being produced. It does not name alternatives or state when not to use it, but the use case is clear enough for an agent to select it among the listed siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_campaignsA
Lista todas as campanhas comerciais pertencentes ao usuário vinculado à API Key M2M.
Retorna uma lista em JSON com o histórico de campanhas, incluindo status e URLs de áudio.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the return format (a JSON list) and key fields (status, audio URLs), but it does not mention pagination, ordering, error behavior, or authentication details beyond the API Key reference.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with no filler. The action and scope are front-loaded, and the return-value information is stated in the second sentence without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool with an output schema, the description is complete enough: it states what is listed, for whom, and what the response contains. No additional information is necessary for an agent to select and invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline is 4; there is nothing for the description to add about parameter meanings. The description appropriately clarifies that data is scoped to the API Key's user, which is implicit context rather than a parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Lista todas as campanhas comerciais' (list all commercial campaigns), and clearly scopes it to the user linked to the M2M API Key. This distinguishes it from siblings like list_voices (different resource), create_campaign (creation), and get_campaign_status (single status lookup).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the use case clear: retrieve the full history of commercial campaigns for the authenticated user, with statuses and audio URLs. However, it does not explicitly name alternatives or state when not to use this tool, such as when only a single campaign's status is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_voicesA
Lista todas as vozes comerciais disponíveis no QuickerSpot para narração e vinhetas.
Utilize esta ferramenta antes de criar uma campanha ou recado para escolher o timbre de voz mais apropriado para o seu produto/anúncio.
Retorna um JSON contendo uma lista de objetos com id, elevenlabs_id e name.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the behavioral disclosure burden. It makes clear this is a read-only listing operation ('Lista') and discloses the return shape: 'Retorna um JSON contendo uma lista de objetos com id, elevenlabs_id e name.' It does not discuss auth, rate limits, or edge cases, but for a simple list operation this is reasonably transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, each earning its place: what the tool lists, when to use it, and what it returns. It is front-loaded with the primary purpose and contains no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool takes no parameters, has an output schema available, and is a straightforward listing operation, the description is complete. It provides the usage context, the type of content, and the return format, which is enough for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds contextual meaning about how the returned voices are used (for narration and jingles) even though no parameter documentation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Lista todas as vozes comerciais disponíveis no QuickerSpot para narração e vinhetas.' It clearly identifies what is listed and the intended content domain, and it is easily distinguishable from sibling tools like list_campaigns and create_campaign.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells the agent when to use the tool: 'Utilize esta ferramenta antes de criar uma campanha ou recado para escolher o timbre de voz mais apropriado.' It provides clear context but does not explicitly name alternatives or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.5- First observed
approve_script - First observed
create_campaign - First observed
create_recado - First observed
get_campaign_status - First observed
list_campaigns - First observed
list_voices
TDQS
Each tool targets a distinct workflow stage: listing campaigns, creating a campaign, approving scripts, checking status, and direct TTS recados. The two creation tools (create_campaign vs create_recado) could be confused at a glance, but their descriptions clearly separate the full campaign workflow from instant short audio.
All tool names follow a consistent verb_noun snake_case pattern: list_, create_, approve_, get_. The use of 'recado' is a localized noun, but it is still consistent with the naming convention and does not create structural inconsistency.
With 6 tools, the server is well-scoped for campaign management and quick audio generation. Each tool covers a necessary step in the workflow without redundancy or bloat.
The core lifecycle is covered: list voices, create campaign, approve script, check status, and generate instant recados. Minor gaps exist, such as no delete/cancel operation for campaigns and no listing/history of generated recados, but agents can complete primary workflows without dead ends.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
The OpenRouter MCP server plugs OpenRouter into the AI tools you already use. Once connected, your assistant can pull live OpenRouter data (models, prices, your credits, rankings, and docs) and send quick test messages, all without leaving your editor.
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Related MCP Servers
- AlicenseAqualityDmaintenanceA simple MCP server for interacting with OpenAI assistants. This server allows other tools (like Claude Desktop) to create and interact with OpenAI assistants through the Model Context Protocol.939MIT

ElevenLabs MCP Serverofficial
AlicenseAqualityFmaintenanceAn official Model Context Protocol (MCP) server that enables AI clients to interact with ElevenLabs' Text to Speech and audio processing APIs, allowing for speech generation, voice cloning, audio transcription, and other audio-related tasks.271,536MIT- AlicenseAqualityDmaintenanceOfficial AllVoiceLab Model Context Protocol (MCP) server, supporting interaction with powerful text-to-speech and video translation APIs.1259MIT
- FlicenseAqualityDmaintenanceA Model Context Protocol server that enables AI assistants like Claude Desktop to interact with Spotify's music streaming service, supporting playback control, playlist management, music search, and user profile access.412-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/raphaelInacio/quickerspot-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server