mcp-observatory
Testes de segurança nativos de CI para servidores MCP. Simulação de ataques, detecção de desvios de esquema e pontuação de saúde antes que agentes dependam deles.
Documentação
MCP Observatory
Mais selos
Proteja os servidores MCP que você está construindo. MCP Observatory é a ferramenta de segurança nativa para CI voltada a equipes que publicam servidores MCP personalizados. Teste durante o desenvolvimento, detecte desvios de esquema, simule ataques e gere evidências de conformidade — antes que agentes dependam dos seus servidores.
Também disponível em Chinês simplificado.
Imposição em tempo de execução: Use mcp-seatbelt para bloquear chamadas de ferramentas MCP perigosas em tempo de execução com base nos resultados da varredura do observatory.
Comece
Guia de configuração passo a passo · macOS, Windows, Linux · Node.js 20+ e npm (instale o Node.js LTS).
1. Execute sua primeira varredura
Abra o Terminal ou o PowerShell na pasta do seu projeto e cole:
npx -y @kryptosai/mcp-observatory@latest
Isso baixa o Observatory e verifica seu primeiro servidor MCP configurado. Sem servidor configurado, ele usa um exemplo incluído. Para testar apenas esse exemplo, execute npx -y @kryptosai/mcp-observatory@latest demo --example.
2. Leia o resultado
O terminal mostra o alvo, a nota, os achados e o caminho do recibo salvo. Verificações com falha são achados para revisar, não uma solicitação de pagamento. Se a conexão falhou, corrija o comando de inicialização ou as credenciais e execute novamente. Uma nota de demonstração descreve o exemplo, não o seu próprio servidor.
3. Salve um snapshot hospedado gratuitamente (opcional)
Na mesma pasta do projeto, execute:
npx -y @kryptosai/mcp-observatory@latest cloud upload
Abra o link de verificação impresso no terminal, confirme o código, conecte-se com o GitHub e retorne ao terminal. Aguarde Upload concluído e abra o link do painel. Não é necessária configuração de conta separada ou método de pagamento. O plano gratuito inclui um alvo, o snapshot mais recente, retenção de sete dias e dez uploads por mês.
Varreduras locais e CI local permanecem gratuitas. Individual Pro custa US$ 29/mês quando você precisa de 10 alvos, histórico de 90 dias, ingestão de CI hospedada ou varreduras HTTP hospedadas.
MCP Observatory usa telemetria de produto ciente de jurisdição após exibir o aviso de coleta. Revise os campos exatos com telemetry preview, verifique a política atual com telemetry status ou interrompa a coleta a qualquer momento com telemetry disable, MCP_OBSERVATORY_TELEMETRY=0 ou DO_NOT_TRACK=1. Consulte o aviso completo de privacidade e telemetria.
npx -y @kryptosai/mcp-observatory@latest test npx -y @modelcontextprotocol/server-everything
- uses: KryptosAI/mcp-observatory/action@v1
Se este repositório for um pacote MCP, isso testa npx -y <package.json name>. Caso contrário, defina command:.
Ou gere um fluxo de trabalho completo: npx -y @kryptosai/mcp-observatory@latest setup-ci --all --command "npx -y my-mcp-server" --sarif
Instalação: npx -y @kryptosai/mcp-observatory@latest · brew tap kryptosai/mcp-observatory https://github.com/KryptosAI/mcp-observatory && brew install mcp-observatory · docker pull ghcr.io/kryptosai/mcp-observatory:latest · curl -fsSL https://raw.githubusercontent.com/KryptosAI/mcp-observatory/main/scripts/install.sh | sh
docker run --rm ghcr.io/kryptosai/mcp-observatory:latest demo
docker run --rm ghcr.io/kryptosai/mcp-observatory:latest test npx -y @modelcontextprotocol/server-everything
Escanear um servidor no host requer rede e, para arquivos locais, uma montagem de volume (-v "$PWD:$PWD" -w "$PWD").
Agentes: npx -y @kryptosai/mcp-observatory@latest serve
Conexão padrão negada: npx -y @kryptosai/mcp-observatory@latest protect reescreve toda configuração de cliente descoberta (Cursor, Claude, VS Code, .mcp.json, …). Desfazer: protect --undo. Servidores HTTP/SSE são deixados intactos.
Negação padrão em tempo de execução: npx -y @kryptosai/mcp-observatory@latest enforce --start-proxy escreve uma política Seatbelt a partir da varredura e inicia o proxy. A varredura local permanece gratuita.
Prova: Índice de Segurança. Envie um snapshot hospedado gratuitamente com cloud upload; Individual Pro custa US$ 29/mês quando você precisa de histórico retido e ingestão de CI hospedada.
Aprenda com o uso em produção
Conecte chamadas reais de ferramentas à intenção do usuário com o SDK e CLI de aprendizado de uso: evidências de invocação anonimizadas, relatórios opt-in de "perguntado / esperado / obtido", trechos selecionados de conversas, sinalizadores de insatisfação com um clique, agrupamento de intenções em solicitações capturadas e exportação de casos de regressão. Execute mcp-observatory usage review --dir private-usage para inspecionar evidências vinculadas em uma tela de navegador somente loopback. Os logs do servidor não podem revelar conversas não compartilhadas; sinais observados de execução e sinais inferidos de falha permanecem separados. A coleta é local e requer integração explícita.
Por que MCP Observatory
Servidores MCP estão se tornando dependências de produção. Se os agentes dependem deles, as equipes precisam de uma maneira de detectar ferramentas quebradas, esquemas inseguros, desvios de esquema, respostas lentas e armadilhas de segurança antes que essas falhas cheguem aos usuários.
Observatory oferece a mantenedores e equipes:
- Configuração de CI em um comando com
setup-ci --all - Auditorias mapeadas por perfil com
audit --profile nsa-mcp - Recibos MCP que empacotam alvo, evidência, veredito, ação e comandos de reprodução
- Grafos de risco MCP que agrupam servidores por limite de capacidade, estado do recibo, postura de CI e ação recomendada
- Recibos de ação que dizem
allow,gate,rerun,quarantineouescalate - Comentários em PRs do GitHub para achados de compatibilidade, desvio e segurança
- SARIF do GitHub Code Scanning para achados MCP normalizados
- Selos de pontuação de saúde para sinais públicos de confiança
- Fluxos de trabalho de gravação/reprodução/verificação para testes de regressão
- Modo de servidor MCP para que agentes possam inspecionar outros servidores MCP diretamente
- Caminho de suporte de produção para histórico hospedado de um usuário, ingestão de CI e remediação pronta para proprietário com Release Gate
Consulte GitHub Code Scanning para servidores MCP, Recibos MCP, Solução de problemas, Metodologia de segurança, Índice de segurança de servidores MCP, Colaboradores do MCP Observatory, contrato de cliente hospedado, limite do repositório, limite do open core e suporte comercial.
Autoavaliação
Escanearmos a nós mesmos com mcp-observatory a cada lançamento. Veja os resultados →
Para Equipes de Segurança e Plataforma
Servidores MCP estão se tornando parte da cadeia de suprimentos de software de IA. Os agentes precisam de ferramentas confiáveis, testáveis e auditáveis antes que essas ferramentas se tornem dependências em fluxos de trabalho críticos.
Esteja você publicando um servidor MCP ou gerenciando uma frota, MCP Observatory oferece pontuação de segurança nativa para CI, simulação de ataques, detecção de desvios de esquema, relatórios SARIF/HTML/Markdown e GitHub Code Scanning — desde o seu primeiro comando npx até a implantação em produção. O desenvolvimento local permanece gratuito; equipes com uma decisão de aprovação de produção em curto prazo podem usar o Piloto de Release Gate MCP de escopo fixo.
Suporte de Produção
O uso local de OSS permanece gratuito sob MIT. Equipes que executam MCP em produção podem usar o Piloto de Release Gate MCP para evidências em modo seguro, configuração de SARIF/Code Scanning, implantação de CI, relatórios privados e notas de remediação prontas para proprietário. A oferta pública fixa de entrada é $15,000 para 1-3 servidores MCP críticos em dez dias úteis; trabalhos mais amplos são escopados após a decisão de lançamento.
O repositório de código aberto é o mecanismo de evidência portátil. Autenticação hospedada, retenção, fluxos de trabalho organizacionais, coordenação de frota e inteligência privada permanecem fora do pacote OSS; consulte o limite do repositório.
Execute npx @kryptosai/mcp-observatory cloud, abra uma solicitação de piloto no seletor de issues ou consulte COMMERCIAL.md. Consulte também privacidade, atribuição de campanha e termos para uso em produção.
Como Ele Se Compara
| Recurso | mcp-observatory | Snyk agent-scan | Cisco mcp-scanner | agent-shield |
|---|---|---|---|---|
| Nativo para MCP | ✓ | ✓ | ✓ | ✓ |
| Simulação de ataques | ✓ | ✗ | ✗ | ✗ |
| Detecção de desvios de esquema | ✓ | ✗ | ✗ | ✗ |
| Gravação/reprodução/verificação | ✓ | ✗ | ✗ | ✗ |
| Pontuação de saúde (0-100) | ✓ | ✗ | ✗ | ✗ |
| Saída SARIF | ✓ | ✓ | ✓ | ✓ |
| Nativo para CI/CD (setup-ci) | ✓ | ✓ | ✓ | ✓ |
| Índice público de segurança | ✓ | ✗ | ✗ | ✗ |
| Imposição em tempo de execução via mcp-seatbelt | ✓ | ✗ | ✗ | ✗ |
Início Rápido
Execute uma primeira verificação. Sem argumentos, inicia demo (seus servidores ou a demonstração local empacotada):
npx @kryptosai/mcp-observatory
Aprofunde-se — também invoque ferramentas seguras para verificar se elas realmente executam:
npx @kryptosai/mcp-observatory scan deep
Teste um servidor específico:
npx @kryptosai/mcp-observatory test npx -y @modelcontextprotocol/server-everything
Adicione-o ao Claude Code como um servidor MCP:
claude mcp add mcp-observatory -- npx -y @kryptosai/mcp-observatory serve
Ou adicione-o manualmente à sua configuração:
{
"mcpServers": {
"mcp-observatory": {
"command": "npx",
"args": ["-y", "@kryptosai/mcp-observatory", "serve"]
}
}
}
Comandos
| Comando | O que faz |
|---|---|
scan | Descobre servidores automaticamente, verifica-os e executa simulação segura de prontidão para ataques por padrão |
scan deep | Escaneia, executa simulação segura de ataques e também invoca ferramentas seguras para verificar se elas executam |
test <cmd> / test --target <file> | Testa um servidor e emite um recibo de ação por comando ou configuração de alvo |
record <cmd> | Grava uma sessão de servidor em um arquivo cassete para reprodução offline |
replay <cassette> | Reproduz um cassete offline — sem necessidade de servidor ativo |
verify <cassette> <cmd> | Verifica se um servidor ativo ainda corresponde a um cassete gravado |
diff <base> <head> | Compara dois artefatos de execução para regressões e desvios de esquema |
watch <config> | Observa um servidor em busca de mudanças e alerta sobre regressões |
suggest | Detecta sua stack e recomenda servidores MCP do registro |
serve | Inicia como um servidor MCP para agentes de IA |
lock | Captura esquemas de servidores MCP em um arquivo de bloqueio |
lock verify | Verifica se servidores ativos correspondem ao arquivo de bloqueio |
history | Mostra tendências de pontuação de saúde para seus servidores MCP |
setup-ci / init-ci | Cria uma GitHub Action e um trecho de selo para verificações de compatibilidade/segurança MCP |
setup-ci --sarif | Gera um fluxo de trabalho que envia achados normalizados para o GitHub Code Scanning |
setup-ci --doctor | Inspeciona se o repositório tem um kit completo de adoção de CI |
telemetry status|enable|disable|identify|preview | Inspeciona ou controla a telemetria do produto e fornece deliberadamente um e-mail de contato |
risk-graph --input <path> | Mescla recibos e artefatos de execução em grafos de risco MCP em JSON, Markdown e HTML |
--no-attack-sim | Opta por não participar da simulação segura de ataques padrão em scan ou test |
ci-report | Gera relatório de CI para criação de issues no GitHub |
enterprise-report | Gera um relatório estático de produção/segurança a partir de artefatos de execução |
score <cmd> | Pontua a saúde de um servidor MCP (0-100) |
badge <cmd> | Gera um selo SVG de pontuação de saúde para README |
cloud | Mostra o snapshot hospedado gratuito, Individual Pro e opções do Piloto de Release Gate |
Execute sem argumentos para iniciar demo. Use --menu para o catálogo interativo.
O Que Ele Faz
Verifica capacidades — conecta-se a um servidor e verifica se ferramentas, prompts e recursos respondem corretamente.
Invoca ferramentas — vai além da listagem. Chama de fato ferramentas seguras (sem parâmetros obrigatórios / readOnlyHint) e relata quais funcionam e quais falham.
npx @kryptosai/mcp-observatory scan deep
Detecta desvios de esquema — compara duas execuções e destaca campos adicionados/removidos, mudanças de tipo e mudanças de parâmetros que quebram.
npx @kryptosai/mcp-observatory diff run-a.json run-b.json
Recomenda servidores — escaneia seu projeto em busca de linguagens, frameworks, bancos de dados e provedores de nuvem, e então cruza com o registro MCP para sugerir servidores que você está perdendo.
npx @kryptosai/mcp-observatory suggest
Ou pergunte ao seu agente "quais servidores MCP devo adicionar?" ao executar no modo de servidor MCP.
Varredura de segurança — analisa esquemas de ferramentas em busca de padrões perigosos: superfícies de injeção de shell, acesso amplo a arquivos, falta de autenticação e vazamento de credenciais em respostas.
npx @kryptosai/mcp-observatory test --security npx -y my-mcp-server
Gravar / reproduzir / verificar — capture uma sessão ao vivo, reproduza-a offline no CI e verifique se nada mudou. Como VCR para MCP.
# Record a session
npx @kryptosai/mcp-observatory record npx -y @modelcontextprotocol/server-everything
# Replay offline (no server needed)
npx @kryptosai/mcp-observatory replay .mcp-observatory/cassettes/latest.cassette.json
# Verify the live server still matches
npx @kryptosai/mcp-observatory verify cassette.json npx -y @modelcontextprotocol/server-everything
Monitore regressões — executa verificações em intervalos e alerta quando algo muda.
npx @kryptosai/mcp-observatory watch target.json
Locais de verificação
Quando você executa scan, ele procura por configurações MCP em:
~/.claude.json(Claude Code)~/Library/Application Support/Claude/claude_desktop_config.json(Claude Desktop, macOS)%APPDATA%/Claude/claude_desktop_config.json(Claude Desktop, Windows).claude.jsone.mcp.json(diretório atual)
Arquitetura
┌─────────────────────────┐
│ MCP Observatory CLI │
│ npx @kryptosai/mcp- │
│ observatory scan │
└───────────┬─────────────┘
│
┌───────────▼─────────────┐
│ Config Discovery │
│ (Claude, Cursor, etc.) │
└───────────┬─────────────┘
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌──────────────┐ ┌──────────────────┐
│ Security Scan │ │ Attack Sim │ │ Schema Drift │
│ (shell, creds) │ │ (tool poison)│ │ (version diff) │
└────────┬────────┘ └──────┬───────┘ └────────┬─────────┘
│ │ │
└─────────────────┼───────────────────┘
▼
┌─────────────────────┐
│ Health Score │
│ (0-100 + verdict) │
└──────────┬──────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ SARIF │ │ Markdown │ │ CI Gateway │
│ (Code Scan) │ │ Report │ │ (setup-ci) │
└──────────────┘ └──────────────┘ └──────────────┘
CI / GitHub Action
Adicione o Observatory ao pipeline de CI do seu servidor MCP:
npx @kryptosai/mcp-observatory setup-ci --all --command "npx -y my-mcp-server" --sarif --schedule weekly
Confira o kit de adoção:
npx @kryptosai/mcp-observatory setup-ci --doctor
Verificações bem-sucedidas de test, run e de alvo único scan também oferecem converter o resultado aprovado em um kit de adoção de CI. Essa conversão automática habilita SARIF/Code Scanning e verificações semanais agendadas por padrão; passe --no-ci-sarif quando quiser apenas um workflow conservador sem upload de Code Scanning.
Ou crie o workflow manualmente:
# .github/workflows/observatory.yml
name: MCP Server Check
on: [pull_request]
permissions:
contents: read
jobs:
observatory:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: KryptosAI/mcp-observatory/action@v1
with:
command: npx -y my-mcp-server
deep: true
security: true
comment-on-pr: false
set-status: false
GitLab CI
Executa a mesma verificação test em merge requests e em main, publicando o SARIF como um relatório SAST do GitLab para que os achados apareçam no widget de segurança do merge request. Isso corresponde ao que setup-ci --ci-provider gitlab-ci gera.
# .gitlab-ci.yml
mcp-observatory:
image: node:22
rules:
- if: $CI_PIPELINE_SOURCE == 'merge_request_event'
- if: $CI_COMMIT_BRANCH == 'main'
script:
- npx @kryptosai/mcp-observatory test npx -y my-mcp-server --deep --security --sarif mcp-observatory.sarif
artifacts:
reports:
sast: mcp-observatory.sarif
Ou deixe o CLI escrever para você:
npx @kryptosai/mcp-observatory setup-ci --ci-provider gitlab-ci --command "npx -y my-mcp-server"
Entradas da action:
| Entrada | Descrição | Padrão |
|---|---|---|
command | Comando do servidor a testar | (opcional; omita para verificar servidores descobertos) |
target | Caminho para o JSON de configuração do alvo | |
targets | Caminho para o arquivo de configuração MCP para verificação de matriz multi-servidor | |
deep | Também invocar ferramentas seguras | false |
security | Executar análise de segurança | false |
fail-on-regression | Falhar a action em problemas | true |
fail-on-baseline-drift | Falhar a action quando a verificação de baseline detectar desvio | true |
comment-on-pr | Publicar relatório como comentário no PR. Requer pull-requests: write. | true |
set-status | Definir uma verificação de status do commit (verde/vermelho) no SHA do HEAD. Requer statuses: write. | true |
github-token | Token para comentários em PRs e status de commits | ${{ github.token }} |
A action pode comentar em PRs e definir status de commits quando o workflow concede permissões de escrita. setup-ci gera workflows somente leitura e amigáveis a terceiros por padrão e permite que mantenedores optem por comentários/status depois. init-ci permanece disponível como um alias compatível com versões anteriores. Veja action/README.md para todas as opções.
Equipes de produção com uma decisão de aprovação MCP de curto prazo podem usar o MCP Release Gate Pilot de escopo fixo: uma decisão de aprovar, bloquear ou adiar para 1–3 servidores em dez dias úteis. Veja COMMERCIAL.md ou solicite uma decisão em mcp-observatory.com/release-gate-pilot.
Selos de evidência para MCP Observatory
Mantenedores de servidores MCP podem adicionar um sinal público de compatibilidade/segurança ao seu README:
[](https://github.com/KryptosAI/mcp-observatory)
Ou gere um selo de pontuação a partir de uma verificação ao vivo:
npx @kryptosai/mcp-observatory badge npx -y my-mcp-server --output docs/mcp-health.svg
Veja o loop de distribuição de evidências para o template da GitHub Action, corpo do PR do mantenedor e playbook de implantação de selos. Um selo é um sinal público de evidência, não uma certificação ou endosso.
Gere um relatório de produção/segurança pronto para piloto a partir de artefatos de execução local:
npx @kryptosai/mcp-observatory enterprise-report \
--account "Your Company" \
--format html \
--output observatory-enterprise-report.html
Para atribuição interna mais clara de conta no CI, defina:
MCP_OBSERVATORY_ORG=your-company.com
Para associar deliberadamente um e-mail de contato e um slug opcional de canal de contato à telemetria analítica privada, execute mcp-observatory telemetry identify --email <address> [--channel <slug>]. Definir uma organização ou identificar um contato não autoriza divulgação.
Testando integrações Feishu/Lark? Veja o guia MCP Feishu/Lark.
Arquivos de bloqueio
$ npx @kryptosai/mcp-observatory lock # Snapshot all server schemas
$ npx @kryptosai/mcp-observatory lock verify # Verify no drift since last lock
Arquivos de bloqueio são o package-lock para ferramentas de IA: faça commit do contrato MCP e torne qualquer desvio de ferramenta, schema, prompt ou recurso visível no CI. Veja arquivos de bloqueio MCP.
Rastreamento de tendências
$ npx @kryptosai/mcp-observatory history # Show health trends over time
Verificações noturnas
$ npx @kryptosai/mcp-observatory ci-report # Generate regression report for CI
Modo Servidor MCP
Nenhuma outra ferramenta de teste é em si um servidor MCP. Adicione o Observatory como um servidor e seu agente de IA pode testar, diagnosticar e monitorar seus outros servidores MCP de forma autônoma.
claude mcp add mcp-observatory -- npx -y @kryptosai/mcp-observatory serve
Seu agente recebe 10 ferramentas:
| Ferramenta | Quando usar |
|---|---|
scan | Verificar se todos os seus servidores MCP configurados estão saudáveis |
check_server | Testar um servidor específico antes de instalar ou após atualizar |
score_server | Obter uma pontuação de saúde rápida e uma nota para um servidor |
record | Capturar um baseline de um servidor funcional para comparação futura |
replay | Testar contra uma sessão gravada — sem necessidade de servidor ao vivo |
verify | Confirmar que uma atualização de servidor não quebrou nada |
watch | Verificar um servidor e ver o que mudou desde a última verificação |
diff_runs | Encontrar regressões entre dois resultados de verificação |
get_last_run | Recuperar resultados de verificação anteriores para um servidor |
suggest_servers | Descobrir servidores MCP que correspondem à stack do seu projeto |
Uma ferramenta de IA que verifica outras ferramentas de IA. É uma ferramenta que testa ferramentas que servem ferramentas.
Segurança
O servidor MCP roda dentro de hosts de IA onde um LLM escolhe quais ferramentas chamar. Para prevenir ataques de injeção de prompt:
- Allowlist de comandos: Apenas
npx,node,python,python3,uvx,docker,deno,bunsão permitidos como executáveis base. O CLI não tem restrições. - Validação de caminho: Ferramentas de leitura de arquivos são restritas aos diretórios runs/cassettes.
- Sem execução arbitrária: Use o CLI para comandos sem restrições.
CLI vs MCP: Diferenças Intencionais
| Recurso | CLI | Servidor MCP | Por quê |
|---|---|---|---|
watch | Loop de polling | Verificação única + diff | Request/response não suporta long-polling |
| Menu interativo | Navegação com setas | Não disponível | MCP não tem UI interativa |
| Saída colorida | Flag --no-color | Sempre texto simples | MCP retorna conteúdo estruturado |
report | Renderiza artefatos salvos | Não disponível | Agentes leem artefatos diretamente |
serve | Inicia servidor MCP | N/A | É o servidor MCP |
run | Lê arquivos de configuração de alvo | Parâmetros inline | Ferramentas MCP aceitam parâmetros diretamente |
get_last_run | Não disponível (use ls + diff) | Disponível | Conveniência para agentes |
Compatibilidade
Funciona com qualquer servidor MCP que use transportes padrão:
| Transporte | Exemplos | Adaptador |
|---|---|---|
| stdio (maioria dos servidores) | filesystem, memory, context7, brave-search, sentry, notion, stripe | local-process |
| HTTP/SSE (remoto) | Cloudflare, Exa, Tavily | http |
| Docker | Todas as imagens @modelcontextprotocol/server-* | local-process via docker run -i |
Servidores que precisam de chaves de API funcionam via env na configuração do alvo. Servidores Python funcionam via uvx. Veja a matriz de compatibilidade completa para servidores testados e problemas conhecidos.
Arquivos de configuração de alvo
Para mais controle (variáveis de ambiente, metadados, timeout personalizado):
{
"targetId": "filesystem-server",
"adapter": "local-process",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
"timeoutMs": 15000,
"skipInvoke": false
}
npx @kryptosai/mcp-observatory run --target ./target.json
Alvos HTTP / SSE
{
"targetId": "my-remote-server",
"adapter": "http",
"url": "https://mcp.example.com/mcp",
"authToken": "${MCP_SERVER_TOKEN}",
"headers": {
"X-Api-Key": "$MCP_SERVER_API_KEY"
},
"timeoutMs": 15000
}
Configurações de alvo suportam referências ${VAR}, $VAR e env:VAR em valores authToken, headers e de processo local env.
Como se Compara
| Recurso | Observatory | mcp-recorder | MCPBench | mcp-jest |
|---|---|---|---|---|
| Auto-descoberta de servidores | ✅ | — | — | — |
| Verificar capacidades | ✅ | — | ✅ | ✅ |
| Invocar ferramentas | ✅ | — | — | ✅ |
| Detecção de desvio de schema | ✅ | — | — | — |
| Gravar / reproduzir | ✅ | ✅ | — | — |
| Verificar contra cassette | ✅ | — | — | — |
| Diffs de snapshot de resposta | ✅ | — | — | — |
| Benchmarking / latência | — | — | ✅ | — |
| Integração Jest | — | — | — | ✅ |
| Funciona como servidor MCP | ✅ | — | — | — |
Cada ferramenta tem pontos fortes. O Observatory foca em detecção de regressões e workflows amigáveis a CI. O mcp-recorder é ótimo como proxy transparente. O MCPBench é a escolha para benchmarking de desempenho. O mcp-jest é ideal se você já está em um workflow Jest.
Trabalhos Anteriores
O padrão gravar/reproduzir/verificar é inspirado em:
- VCR (Ruby) — pioneiro em gravação/reprodução HTTP baseada em cassettes
- Polly.js (Netflix) — gravação de interações HTTP para JavaScript
- mcp-recorder — proxy de gravação de tráfego específico para MCP
- MCPBench — benchmarking de servidores MCP
- mcp-jest — testes estilo Jest para servidores MCP
Limitações
- Servidores que exigem OAuth interativo (ex.: Google Drive) precisam de pré-autenticação antes que o Observatory possa conectar
- Transportes WebSocket personalizados (ex.: BrowserTools MCP) não são suportados
- Alguns servidores expiram ou fecham antes do init — veja problemas conhecidos e compatibilidade
Funciona com mcp-seatbelt
Verifique antes de confiar. Depois execute npx -y @kryptosai/mcp-observatory@latest enforce --start-proxy — o Observatory escreve uma política mcp-seatbelt de negação por padrão e inicia o proxy. O Observatory valida; o seatbelt aplica.
Funciona com agent-obs
Proteja seus servidores com o Observatory. Rastreie seus agentes com agent-obs — um rastreador de execução de agentes de código aberto que registra cada chamada de ferramenta, calcula notas de sessão A-F e mostra exatamente onde seus agentes gastam tempo, queimam tokens e encontram erros. O Observatory diz se um servidor é seguro. O agent-obs diz o que seu agente fez com ele. Gratuito, local-first, npm install -g agent-obs.
Contribuidores ✨
Agradecemos a essas pessoas incríveis que contribuíram:
- leemeo3 — 3 alvos do Safety Index (Git, Chrome DevTools, Filesystem MCP)
- albatrossflyon-coder — GitHub MCP Safety Index (#201)
- tanishxdev — Avisos de depreciação do CLI legado (#187)
- sansynx — Validação de formato do CLI (#182)
Veja todos os contribuidores →
Contribuindo
Aceitamos contribuidores! Este projeto segue um Código de Conduta do Contributor Covenant. A forma mais rápida de se envolver:
git clone https://github.com/KryptosAI/mcp-observatory.git && cd mcp-observatory && npm install && npm test
A primeira contribuição mais comum é adicionar um servidor MCP ao Safety Index (10-15 minutos). Veja CONTRIBUTING.md para diretrizes completas, padrões de código e a escada de reconhecimento de contribuidores.
Se o Observatory salvou você de um deploy quebrado, considere dar uma estrela. Isso ajuda outras pessoas a encontrar o projeto.