MySpec

Plataforma de desenvolvimento orientado a especificações. Permite que Cursor, Claude Code e outros clientes MCP leiam e escrevam projetos MySpec e pacotes de especificação (constituição, requisitos, solução, tarefas). 31 ferramentas. Requer uma conta MySpec; plano gratuito disponível.

Ver em myspec.devExperimente este MCPPatrocinado

Servidor MCP hospedado

npx add-mcp 'https://mcp.myspec.dev/mcp'

Instala no Claude Code, Codex, Cursor e outros

Documentação

INTEGRATION PROTOCOL · MCP · v0.4

Servidor MCP

@myspec/mcp-server - specs no seu agente de IA de codificação

Um servidor Model Context Protocol que expõe seus projetos MySpec, arquivos de spec, anexos, sessões de spec e pacotes de artefatos para Cursor, Claude Code, Claude Desktop e qualquer cliente MCP - via stdio com OAuth, ou via HTTPS com um token de API.

Instale com npx ou como um plugin do Claude Code. 31 ferramentas. Sem CLI separado para aprender.

Três formas de conectar

Servidor stdio (padrão)

Seu editor de IA é o cliente MCP; npx -y @myspec/mcp-server é o servidor na sua máquina. Faça login uma vez com login, ou insira um token de API. Pode baixar arquivos para o disco.

Servidor HTTP (hospedado)

https://mcp.myspec.dev/mcp - um endpoint HTTP Streamable sem estado para clientes sem sistema de arquivos: plataformas de agentes hospedados, clientes de navegador, conectores, runners de CI. Requer um Personal Access Token no cabeçalho Authorization - não há login via navegador. Mesmas 31 ferramentas, conteúdo movido inline. Guia completo ↓

reverso (opt-in)

Execute reverse --root <dir> e os papéis se invertem: sua máquina serve uma visão somente leitura de um diretório para o agente cloud MySpec, permitindo que fluxos de trabalho brownfield leiam seu código existente antes de propor uma alteração.

Configure seu cliente

Adicione MySpec ao seu .mcp.json (Claude Code, Cursor), ao claude_desktop_config.json do Claude Desktop, ou à configuração equivalente do cliente MCP:

{
  "mcpServers": {
    "myspec": {
      "command": "npx",
      "args": ["-y", "@myspec/mcp-server"]
    }
  }
}

Usuários do Claude Code podem registrá-lo para todo o usuário em um único comando:

$ claude mcp add --scope user myspec -- npx -y @myspec/mcp-server

Quer a versão em desenvolvimento? Use a dist-tag @next (@myspec/mcp-server@next) - uma pré-lançamento publicada a cada merge. Prefira o pacote sem tag para uso diário.

Alternativa · Plugin do Claude Code

Claude Code: instale o plugin oficial em vez disso

O plugin myspec-mcp registra este mesmo servidor para você - sem configuração para escrever, sem segredos nele - e adiciona habilidades de Desenvolvimento Orientado a Spec para implementar, analisar e escrever pacotes de spec MySpec. Execute dentro do Claude Code, reinicie, e então faça login com npx -y @myspec/mcp-server login:

/plugin marketplace add myspecs/claude-plugins
/plugin install myspec-mcp@myspec

Use um método, não ambos: se o plugin estiver instalado, remova qualquer entrada myspec de .mcp.json ou claude mcp add (claude mcp remove myspec), ou o Claude Code carregará dois conjuntos de ferramentas MySpec.

Início rápido do plugin: instalar, entrar, primeiros prompts →

Configurações não assistidas: tokens de API

login precisa de um navegador. Para um servidor, um contêiner, um job de CI ou uma máquina compartilhada - e sempre para o servidor HTTP - crie um Personal Access Token (PAT, mostrado no webapp como um API token, valor msp_pat_…): menu do avatar → API tokens → Create token. Escolha a organização em que ele atua, acesso somente leitura ou leitura/escrita, e uma expiração - 30, 90, 180 ou 365 dias (90 por padrão; não existe nunca expira). O token é mostrado uma única vez.

{
  "mcpServers": {
    "myspec": {
      "command": "npx",
      "args": ["-y", "@myspec/mcp-server"],
      "env": { "MYSPEC_API_TOKEN": "msp_pat_…" }
    }
  }
}

ou em um único comando:

$ claude mcp add --scope user myspec --env MYSPEC_API_TOKEN=msp_pat_… -- npx -y @myspec/mcp-server

Sem login, sem arquivos: o token é trocado por um token de acesso de curta duração a cada execução e nunca é gravado em disco. Desative a variável e a credencial desaparece.
Precedência: MYSPEC_API_TOKEN > apiToken em ~/.myspec/oauth_creds.json > o token de atualização salvo por login. Quem vencer é usado exclusivamente - um token rejeitado falha a execução em vez de silenciosamente cair para outra identidade.
A organização e o modo de acesso de um token são fixados na criação; sua expiração pode ser estendida sem alterar o valor, até uma vida total máxima de dois anos a partir da criação - além disso, crie um novo.
Você pode manter 25 tokens ativos e criar 10 por hora. A revogação é permanente: um token revogado nunca pode ser reativado ou atualizado, apenas substituído.

Ferramentas da plataforma

31 ferramentas em cada servidor, em seis grupos. Nomes e formatos de argumentos são idênticos entre os servidores stdio e HTTP - as únicas diferenças são as linhas na tabela de comparação abaixo - então um prompt que funciona no Cursor funciona também em um agente hospedado.

Projetos

7 ferramentas

list_projects
get_project
create_project
update_project
archive_project
unarchive_project
delete_project

delete_project só funciona em um projeto arquivado - arquivar é a etapa de confirmação.

Arquivos de spec

6 ferramentas

list_spec_file
get_spec_file
read_spec_file
download_spec_file
upload_spec_file
update_spec_file

Leituras retornam content_version; gravações se tornam novas revisões. download_spec_file é exclusivo do stdio e salva em .specs/.

Lixeira

2 ferramentas

move_spec_file_to_trash
restore_spec_file_from_trash

Nada é destruído por acidente: arquivos na lixeira permanecem restauráveis indefinidamente (liste-os com list_spec_file trashed=true).

Anexos

4 ferramentas

list_attachments
get_attachment
read_attachment
upload_attachment

PDF, DOCX, XLSX, imagens e qualquer arquivo de texto UTF-8 de até 10 MiB. Texto é paginado por linha; imagens voltam inline.

Sessões de spec

6 ferramentas

list_spec_sessions
get_spec_session
rename_spec_session
archive_spec_session
unarchive_spec_session
delete_spec_session

Apenas metadados e resumos da sessão - a transcrição do chat nunca é retornada. Excluir exige arquivar primeiro.

Artefatos

6 ferramentas

list_artifacts
get_artifact
read_artifact_file
create_artifact
write_artifact_revision
rollback_artifact

Novo - disponível apenas via MCP por enquanto: pacotes de múltiplos arquivos (um mockup HTML é index.html + styles.css + app.js) versionados como um único snapshot. Ainda não há interface de navegador para artefatos. rollback_artifact acrescenta uma revisão em vez de reescrever o histórico, como git revert.

Downloads salvos em .specs/

download_spec_file espelha o caminho remoto sob uma pasta .specs/ com prefixo de ponto no diretório de trabalho do servidor - convencionalmente ignorada pelo git, então uma cópia baixada nunca aparece como ruído não rastreado ao lado do seu próprio specs/. Passe um destination_path absoluto para salvar em qualquer outro lugar.

download_spec_file(file_id)                       # -> .specs/<bundle>/requirements.md
download_spec_file(file_id, destination_path="/tmp/req.md")   # explicit path, honored as given

Edições concorrentes nunca são sobrescritas silenciosamente

Várias pessoas e sessões de IA podem trabalhar no mesmo projeto. get_spec_file e read_spec_file retornam um content_version; passe-o para update_spec_file como expected_version e uma gravação que competiu com o salvamento de outra pessoa é rejeitada com uma mensagem nomeando quem a alterou - releia, mescle e atualize novamente. O servidor HTTP torna expected_version obrigatório.

read_spec_file(file_id)            -> { content, content_version: 42 }
update_spec_file(file_id, content, expected_version: 42)
# someone saved in between? -> rejected, nothing overwritten; re-read, merge, retry

MCP SERVER HTTP · mcp.myspec.dev

O servidor HTTP para agentes hospedados

@myspec/mcp-server-http é o irmão do servidor stdio, implantado como um Cloudflare Worker sem estado em https://mcp.myspec.dev/mcp. Ele existe para clientes MCP que conectam via HTTPS e não têm sistema de arquivos - plataformas de agentes hospedados, clientes baseados em navegador, conectores estilo ChatGPT ou Claude, runners de CI. Mesmos 31 nomes de ferramentas, mesma plataforma por baixo; tudo que precisava de disco local (login OAuth, arquivos de credenciais, downloads, a ponte reversa) está deliberadamente ausente, e o conteúdo é movido inline, paginado.

OBRIGATÓRIO · PERSONAL ACCESS TOKEN NO CABEÇALHO DA REQUISIÇÃO

Toda requisição a mcp.myspec.dev deve carregar um Personal Access Token MySpec. Não há login via navegador neste servidor - uma requisição sem o cabeçalho é rejeitada com HTTP 401 antes mesmo de ser analisada.

Authorization: Bearer msp_pat_…

01 · CRIAR No webapp MySpec: menu do avatar → API tokens → Create token. Escolha a organização, somente leitura ou leitura/escrita, e uma expiração (30 / 90 / 180 / 365 dias, 90 por padrão). O valor (msp_pat_…) é mostrado uma única vez.
02 · CONFIGURAR Coloque-o nos cabeçalhos de requisição do seu cliente como Authorization: Bearer <token> - a flag --header, o bloco headers de mcp.json, ou a opção de cabeçalhos personalizados do seu SDK (trechos abaixo).
03 · VERIFICAR Uma chamada tools/list responde 200 quando o token é aceito e 401 quando está ausente, revogado, expirado ou pertence a outro ambiente.

curl -sS -o /dev/null -w '%{http_code}\n' https://mcp.myspec.dev/mcp \
  -H "Authorization: Bearer msp_pat_…" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
# 200 → token accepted · 401 → missing, revoked, expired, or a token from the other environment

Trate o token como uma senha: ele concede o nível de acesso e a organização com que foi criado enquanto for válido. Armazene-o em um gerenciador de segredos ou em uma variável de ambiente, nunca em um arquivo de configuração versionado.

Endpoints

Rota	Autenticação	Propósito
POST /mcp	Personal Access Token (obrigatório)	Streamable HTTP sem estado - uma mensagem JSON-RPC por requisição (`initialize`, `tools/list`, `tools/call`). Sem stream SSE, sem sessões; um cabeçalho `Mcp-Session-Id` é ignorado. Outros verbos respondem 405.
GET /health	Nenhuma	Sonda de disponibilidade reportando `service`, `version`, `environment`; faz zero chamadas upstream.

Produção: mcp.myspec.dev. Staging: mcp.myspecs.dev. Tokens são específicos do ambiente - um token de produção não funciona contra staging e vice-versa.

Autenticação: apenas Personal Access Token

Toda requisição carrega Authorization: Bearer msp_pat_… - o mesmo Personal Access Token descrito acima (webapp → menu do avatar → API tokens). Nenhum outro tipo de credencial é aceito. O Worker o troca por um token de plataforma de curta duração em cada requisição; não há fluxo OAuth, sem login, e nada armazenado em nenhum dos lados. Um token ausente ou rejeitado é um HTTP 401 em nível de transporte com WWW-Authenticate: Bearer antes mesmo do corpo JSON-RPC ser analisado, e o corpo nomeia o motivo: MALFORMED_TOKEN (não é um valor msp_pat_), TOKEN_INVALID (desconhecido, expirado, revogado ou desabilitado), ou ORG_ACCESS_LOST (seu dono não está mais na organização). Um 502 carregando EXCHANGE_UNAVAILABLE ou EXCHANGE_MALFORMED significa que a troca do token em si falhou, não o seu token.

Um token somente leitura ainda vê todas as 31 ferramentas listadas - 14 somente leitura, 17 de mutação; chamar uma de mutação retorna um erro de ferramenta acionável "este token de API é somente leitura" em vez de uma falha de transporte.
Um token é limitado a uma organização na criação - as ferramentas operam apenas nos projetos dessa organização.
Tokens trocados são armazenados em cache na memória do isolate por no máximo 60 segundos, então um token revogado no webapp pode continuar funcionando por até um minuto. Trate essa janela como a exposição ao rotacionar.

Conecte um cliente

Em cada trecho, substitua msp_pat_… pelo seu próprio Personal Access Token - é a única credencial que o servidor aceita.

Claude Code - registre o servidor remoto com seu cabeçalho:

$ claude mcp add --transport http myspec https://mcp.myspec.dev/mcp --header "Authorization: Bearer msp_pat_…"

Cursor, Windsurf, VS Code e qualquer cliente que aceite um servidor MCP remoto com cabeçalhos personalizados - estilo mcp.json:

{
  "mcpServers": {
    "myspec": {
      "url": "https://mcp.myspec.dev/mcp",
      "headers": { "Authorization": "Bearer msp_pat_…" }
    }
  }
}

SDKs de agentes hospedados, conectores e CI - a ida e volta JSON-RPC bruta que qualquer cliente HTTP pode fazer:

# 1. handshake
curl -sS https://mcp.myspec.dev/mcp \
  -H "Authorization: Bearer msp_pat_…" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"curl","version":"0"}}}'

# 2. list the tools (optionally narrowed with X-MCP-Tools)
curl -sS https://mcp.myspec.dev/mcp \
  -H "Authorization: Bearer msp_pat_…" \
  -H "Content-Type: application/json" \
  -H "X-MCP-Tools: list_projects,read_spec_file" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# 3. call one
curl -sS https://mcp.myspec.dev/mcp \
  -H "Authorization: Bearer msp_pat_…" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"list_projects","arguments":{"limit":5}}}'

$ curl -sS https://mcp.myspec.dev/health # {"service":"…","version":"…","environment":"production"}

Clientes que só suportam servidores remotos baseados em OAuth (algumas interfaces de conectores de consumo) não conseguem anexar um cabeçalho bearer estático; use o servidor stdio nesses casos, ou um proxy que injete o cabeçalho.

O que difere do servidor stdio

	stdio (`npx @myspec/mcp-server`)	HTTP (`mcp.myspec.dev`)
Autenticação	OAuth `login` ou token de API	Personal Access Token obrigatório em cada cabeçalho de requisição
Transporte	stdio, processo de longa duração	Streamable HTTP sem estado, uma mensagem JSON-RPC por POST
Arquivos grandes	`read_spec_file` pagina por linha, arquivos acima de 8 MiB são recusados; `download_spec_file` salva arquivos binários ou grandes (até 50 MiB) em `.specs/`	Mesma paginação e mesmo limite de 8 MiB; sem downloads — visualize arquivos maiores ou binários no webapp
Listagem de lixeira	`list_spec_file trashed=true`	`list_spec_file trashed=true` — o antigo `list_trashed_spec_files` está obsoleto, mantido apenas para compatibilidade reversa
Corpo do arquivo de spec	`content` inline ou `local_file_path` lido do disco	`content` apenas inline
Anexos em	`upload_attachment` aceita um `file_path` local	`upload_attachment` aceita `content_base64`
Edições concorrentes	`expected_version` opcional	`expected_version` obrigatório em `update_spec_file`
URLs de download / cache em disco	URLs assinadas, cache `~/.myspec`	Nenhum — o conteúdo é sempre inline
Acesso ao código local	`reverse --root`	Não disponível (sem máquina para expor)

read_spec_file(file_id, offset=1, limit=2000)
-> { content, start_line, end_line, read_lines, total_lines, truncated, next_offset, content_version }
update_spec_file(file_id, content, expected_version)   # expected_version is REQUIRED here

Reduza a superfície de ferramentas com X-MCP-Tools

Um cabeçalho de requisição opcional que lista as ferramentas que um cliente deve ver, separadas por vírgula e sensível a maiúsculas/minúsculas: X-MCP-Tools: list_projects,list_spec_file,read_spec_file. O servidor é construído por requisição exatamente a partir dessa interseção — nomes desconhecidos são descartados, e uma lista que resulta em nada gera um conjunto de ferramentas vazio em vez do conjunto completo, então um conector que pediu acesso somente leitura nunca recebe um gravador. Aplicado tanto em tools/list quanto em tools/call.

Limites

O quê	Limite	Observações
read_spec_file / read_attachment (texto)	2.000 linhas por chamada (padrão e máximo), 1 MiB por resposta	Pagine com offset (baseado em 1) e next_offset em vez de baixar.
Tamanho do arquivo read_spec_file	Arquivos acima de 8 MiB são recusados	O arquivo inteiro é materializado no Worker antes da paginação.
upload_attachment	10 MiB decodificados (≈ 13,4 MiB em base64) via content_base64	Corresponde ao limite de anexos da plataforma; PDF, DOCX, XLSX, imagens, texto UTF-8.
read_attachment (imagens)	png / jpeg / gif / webp retornados inteiros, até 10 MiB	Outros tipos binários são direcionados ao webapp.
list_spec_sessions	20 por página	O contexto da sessão é analisado no servidor; pagine em vez de buscar tudo.
get_spec_session include_context	1 MiB	Verifique context_size_bytes e context_keys primeiro.
read_artifact_file	2.000 linhas por chamada, 1 MiB por resposta; arquivos acima de 8 MiB são recusados	Mesma paginação do read_spec_file. Arquivos de artefato binários (imagens, fontes) não são legíveis aqui — get_artifact lista o tamanho e o checksum deles.
create_artifact / write_artifact_revision	50 arquivos por pacote, 2 MiB por arquivo, 10 MiB por revisão	Uma revisão é um snapshot imutável; as 50 mais recentes são mantidas, as mais antigas são removidas.
Cabeçalho X-MCP-Tools	4.096 bytes / 64 nomes	Listas mais longas retornam HTTP 400.
Lotes JSON-RPC	Rejeitados com -32600	Uma mensagem por POST; sem SSE, sem sessões.
Revogação de token	Até 60 s	Tokens trocados são armazenados em cache na memória do isolate por no máximo 60 s.

Notas de segurança

O Worker não mantém estado persistente — sem banco de dados, KV ou armazenamento de objetos; nada seu é armazenado entre requisições.
Logs estruturados ocultam o cabeçalho Authorization e qualquer substring msp_pat_.
Gravações são atribuídas ao ator de IA, então um humano editando o mesmo arquivo de spec no webapp vence qualquer corrida; excluir um projeto ou sessão ainda exige arquivá-lo primeiro.
Prefira um token somente leitura para conectores que só precisam ler specs e defina uma expiração — ela pode ser estendida depois sem alterar o valor, até dois anos a partir da criação.

Acesso a arquivos locais para trabalho brownfield (somente leitura)

Os fluxos de trabalho MySpec brownfield e OpenSpec recusam propor uma alteração até lerem arquivos reais do seu repositório. Há duas maneiras de deixar o arquiteto na nuvem ver seu código:

Opção 1 — Montar uma pasta no navegador

Clique em Montar pasta no painel Local Workspace de uma sessão de chat. Usa a File System Access API, então funciona em Chrome e navegadores baseados em Chromium (Edge 86+), não no Firefox ou Safari.

Opção 2 — modo reverso

Qualquer navegador, qualquer SO: o CLI conecta-se via WebSocket e serve um diretório. Apenas uma conexão reversa por usuário está ativa; uma mais nova substitui a antiga.

$ npx -y @myspec/mcp-server reverse --root./my-project

local_fs_list_dir — lista entradas de diretório sob a raiz concedida
local_fs_read_file — lê um arquivo sob a raiz concedida
local_fs_grep — busca um padrão sob a raiz concedida
local_pack_codebase / local_pack_codebase_read_page — empacota o código em um pacote de texto paginado que o agente lê de uma vez (sua primeira ação preferida)

Todo caminho é restrito ao diretório que você passa com --root, arquivos binários são rejeitados e arquivos secretos (chaves SSH, credenciais estilo .env) são sempre excluídos — isso é exposição somente leitura, não um mecanismo de sincronização. A URL WebSocket do agente é descoberta da sua conta após o login; --agent-url ou MYSPEC_AI_AGENT_WS_URL a substitui.

Autenticação em resumo

	`login` (OAuth)	Token de API
Precisa de navegador	Sim (ou `--paste`)	Não
Credencial rotaciona	Sim, a cada atualização	Não
Escopo	O que a sessão alcançar (organização fixada)	Uma organização, fixada na criação
Acesso	Completo	Somente leitura ou leitura/gravação, fixado na criação
Funciona com servidor HTTP	Não	Sim — e é a única opção lá

O estado local fica em ~/.myspec/: settings.json (qual servidor de autenticação você usou, além das URLs de serviço descobertas) e oauth_creds.json (tokens, modo 0600 — o servidor recusa um arquivo legível por grupo ou outros). logout encerra a sessão e deixa settings.json intacto; se o arquivo contém um apiToken configurado, ele é reescrito apenas com esse token; caso contrário, é removido.

Variáveis de ambiente

MYSPEC_API_TOKEN — token de API de longa duração (msp_pat_…) para uso não assistido; tem precedência sobre credenciais salvas e nunca é gravado em disco
MYSPEC_USER_AUTH_URL — servidor de autenticação para troca (padrão https://auth.myspec.dev); defina-o para um token de não produção para que um 401 seja lido como a incompatibilidade de ambiente que é
MYSPEC_DOWNLOAD_ROOT — raiz de cache em disco usada por read_spec_file (padrão ~/.myspec); ferramentas nunca gravam fora dela
MYSPEC_AI_AGENT_WS_URL — URL WebSocket do agente de IA para reverse; pula a descoberta

Convenções de arquivos de spec

Caminhos de spec são relativos, enraizados em specs/ ou openspec/, e aninham no máximo três níveis de diretório. O tipo de arquivo é derivado do nome — constitution, requirements, solution, tasks, proposal e um openspec-spec genérico para todo o resto (spec.md e plan.md do Spec Kit, deltas do OpenSpec e design.md). Pacotes mais antigos nomeavam o arquivo de solução como design.md; faça a correspondência por file_type, não pelo nome do arquivo.

Leia o guia de campo para cada tipo de arquivo de spec →

Perguntas frequentes

O que posso fazer com o servidor MCP MySpec?

Depois de conectado ao Claude Desktop, Claude Code ou Cursor, seu editor de IA pode listar e gerenciar seus projetos MySpec; ler, baixar, enviar e atualizar arquivos de spec como revisões versionadas; ler anexos; inspecionar ou organizar sessões de spec; e versionar pacotes de artefatos com vários arquivos — sem alternar para o navegador para copiar conteúdo de um lado para o outro.

Posso enviar arquivos de spec locais existentes para um projeto MySpec?

Sim. Aponte seu editor de IA para um arquivo local e peça para enviá-lo — upload_spec_file aceita um caminho local diretamente no servidor stdio (local_file_path; o servidor HTTP recebe o corpo inline como content), então um requirements.md, um spec.md do Spec Kit ou uma alteração do OpenSpec já no seu repositório pode ser trazida para um projeto sem copiar e colar. Use update_spec_file da mesma forma para salvar uma nova revisão.

Ele pode ver meu código local, não apenas arquivos de spec?

Sim, se você optar por isso. Executar npx -y @myspec/mcp-server reverse --root ./my-project expõe uma visão somente leitura desse diretório ao agente de IA na nuvem, para que ele possa listar arquivos, lê-los, pesquisar neles ou empacotar todo o código em um pacote para contexto — exatamente o que os fluxos de trabalho brownfield precisam antes de redigir uma proposta. No Chrome, você pode montar uma pasta pela página de chat.

Meu agente roda na nuvem e não tem disco. Ele ainda pode usar MySpec?

Sim — aponte-o para https://mcp.myspec.dev/mcp e configure um Personal Access Token nos cabeçalhos de requisição (Authorization: Bearer msp_pat_…); o servidor HTTP não tem login por navegador e rejeita requisições não autenticadas. Ele recebe os mesmos nomes de ferramentas, com conteúdo de arquivo retornado inline e paginado em vez de baixado. Veja o guia do servidor HTTP.

Preciso instalar um CLI separado primeiro?

Não. npx -y @myspec/mcp-server executa o servidor diretamente — não há nada para instalar globalmente e nenhum outro CLI é necessário.

Existe um plugin para Claude Code?

Sim. Execute /plugin marketplace add myspecs/claude-plugins e /plugin install myspec-mcp@myspec dentro do Claude Code. O plugin registra este servidor para você e adiciona habilidades que implementam, analisam e escrevem pacotes de spec MySpec; um segundo plugin, myspec-factory, executa um pacote inteiro com sessões de worker paralelas. Veja o início rápido do plugin Claude Code.

O servidor MCP substitui o app.myspec.dev?

Não. O servidor MCP dá ao seu editor de IA acesso a specs que já existem — ele não executa a entrevista do Architect nem os fluxos de geração. Para criar um novo pacote, você ainda começa em app.myspec.dev; o servidor MCP é como você então puxa esses specs para seu editor, mantém-nos atualizados e alimenta contexto local.