Para as alternativas Skill, curl e git-clone, além de sistemas PEP 668 e configuração de ocultação de segredos, consulte o [guia de instalação completo](https://github.com/prismorsec/prismor/blob/main/docs/installation.md).

---

## Capacidades<a name="capabilities" />

![Arquitetura do Prismor](https://assets.kitploit.com/production/public/readmes/13903/0e84c7211b3275de581182b7f69c44d8224142323b43220dd1234eee17616757.png)

- 🛡️ [Prismor](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md) cobre o motor de políticas, logs de sessão, auditoria de segurança e referência da CLI
- 📦 [Supply Chain](https://github.com/prismorsec/prismor/blob/main/docs/supply-chain.md) cobre a aplicação no momento da instalação, correspondência de IOC e pontuação de risco
- 🛜 [Isolamento de Rede](https://github.com/prismorsec/prismor/blob/main/docs/network-isolation.md) cobre controle de egresso orientado por políticas, detecção de IP bruto e bloqueio de túneis
- 🔍 [Scanner de Skills](https://github.com/prismorsec/prismor/blob/main/docs/skill-scanner.md) cobre a varredura de risco de servidores MCP e skills nos agentes suportados
- 🚦 [Guardrails MCP](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md#custom-guardrails-for-mcp-tools) permitem bloquear um servidor ou ferramenta MCP específico, ou exigir aprovação humana antes que o agente o chame, com uma regra de política que você mesmo escreve
- 🛰️ [Gateway MCP](https://github.com/prismorsec/prismor/blob/main/docs/mcp-gateway.md) é um único conector MCP que fica à frente de todos os outros servidores MCP que você usa — cada `tools/call` é avaliado por política antes de ser encaminhado e cada resposta é escaneada quanto a injeção antes que o modelo a veja, de modo que um resultado de ferramenta envenenado nunca se torna contexto. `prismor mcp-gateway install` move um `.mcp.json` existente para trás dele
- 🛤️ [Proxy LLM](https://github.com/prismorsec/prismor/blob/main/docs/llm-proxy.md) governa um agente que o Prismor não consegue interceptar, através da única coisa que todo agente tem: seu tráfego de modelo. Aponte-o para `prismor proxy` com `ANTHROPIC_BASE_URL`, `OPENAI_BASE_URL`, ou o `HttpOptions(base_url=...)` do Google Gen AI SDK e nada mais no agente muda. Cada chamada de ferramenta que o modelo *propõe* — `tool_use` do Anthropic, `tool_calls` do OpenAI, `functionCall` do Gemini — é remodelada no mesmo evento que um hook `Bash` produz e julgada pela mesma regra, com chamadas em streaming retidas até que possam ser julgadas
- [Hooks de Inferência do Claude](https://github.com/prismorsec/prismor/blob/main/docs/inference-hook.md) faz do Prismor o servidor de segurança de IA por trás do Claude Enterprise: a Anthropic envia cada prompt governado do claude.ai, Claude Code e Cowork para `prismor inference-hook serve`, que executa sua política no transcript e responde permitir/negar antes que o modelo seja executado — requisições assinadas (Standard Webhooks), fail-closed, modo shadow, nada para instalar nos dispositivos dos usuários. `prismor inference-hook test` envia frames de amostra assinados para verificar a fiação
- 🏷️ [Tags de Ferramentas](https://github.com/prismorsec/prismor/blob/main/docs/tool-tags.md) classificam ferramentas por capacidade (read, write, network, exec) para que uma regra possa dizer "nada que leia dados privados pode também alcançar a rede" em vez de nomear cada ferramenta uma a uma — ferramentas MCP se autodeclaram via `_meta`, e `prismor tags` lista, testa e faz lint das expressões de regras
- 🔐 [Sweep e Cloak](https://github.com/prismorsec/prismor/blob/main/docs/sweep-and-cloak.md) cobre a prevenção de segredos nas fronteiras das ferramentas, configuração prática, melhores práticas, modelo de ameaças e limpeza de segredos vazados
- 🦞 [Integração com OpenClaw](https://github.com/prismorsec/prismor/blob/main/docs/openclaw.md) cobre hooks de runtime, varredura de injeção de prompt e configuração de escopo de projeto ou usuário para OpenClaw
- 🤖 [Ocultação no Hermes Agent](https://github.com/prismorsec/prismor/blob/main/docs/hermes.md) cobre a ocultação de segredos específica do Hermes com autodescoberta de entry-point do pip, instalação no sistema de arquivos e guarda de colagem pre_gateway_dispatch
- ☁️ [VMs de Agentes Hospedados](https://github.com/prismorsec/prismor/blob/main/docs/cloud-agents.md) governa agentes que rodam em uma máquina na qual você nunca faz login (Claude Code na web, agentes em nuvem do Cursor, agente de codificação do Copilot, OpenHands Cloud, Codex cloud, Replicas): o script de configuração da plataforma instala o binário, e `install-hooks --portable` escreve uma configuração de hook que é segura para commitar
- 🧠 [Guarda Semântica](https://github.com/prismorsec/prismor/blob/main/docs/semantic-guard.md): camada híbrida opcional que adiciona uma verificação de intenção assistida por LLM para tentativas de injeção de prompt parafraseadas que as regras de regex não conseguem capturar
- 🪤 [Canary](https://github.com/prismorsec/prismor/blob/main/docs/canary.md) planta arquivos de credenciais honeytoken que disparam um achado CRITICAL no momento em que um agente os lê, capturando comportamento de reconhecimento
- 🪪 [IAM](https://github.com/prismorsec/prismor/blob/main/docs/iam.md) dá a cada agente uma identidade nomeada e um perfil de permissão de privilégio mínimo quando vários agentes compartilham um workspace
- 🧩 [Agentes de Framework](https://github.com/prismorsec/prismor/blob/main/docs/frameworks-overview.md) protege agentes em produção (OpenAI Agents SDK, LangChain/LangGraph em Python e JS, CrewAI, browser-use, Pydantic AI, AutoGen Core, Agno, Semantic Kernel, Google ADK, BeeAI, Claude Agent SDK, Vercel AI SDK, Mastra) com uma única chamada — envolva cada requisição em `use_subject("user:alice")` e um agente multi-tenant ganha atribuição por usuário, perfis IAM por usuário e suspensão por usuário
- 🎯 [Agente com Escopo](https://github.com/prismorsec/prismor/blob/main/docs/scoped-agent.md) sintetiza regras mínimas e específicas da tarefa por sessão, de modo que um pivô injetado fora da tarefa seja bloqueado
- 🧬 [Aprendizado](https://github.com/prismorsec/prismor/blob/main/docs/learning.md) minera o histórico de sessões para propor novas regras, sinalizar falsos positivos e detectar evasão
- ⚖️ [Política em Camadas e Isenções](https://github.com/prismorsec/prismor/blob/main/docs/policy-layers-and-exemptions.md) cobre observe/enforce por regra, o piso não sobrescrevível e isenções concedidas por administrador e com prazo limitado entre as camadas de organização / projeto / repositório
- 🔐 [Seleção explícita de enforce e a janela de desbloqueio](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md#choosing-what-blocks) — a configuração de enforce começa sem nada bloqueando e você escolhe o conjunto; `prismor allow` cria exceções estreitas, e `prismor unlock` abre uma janela protegida por senha e com prazo limitado na qual um agente pode editar políticas (nunca as regras de autoproteção que guardam o próprio Prismor)
- 📡 [Telemetria ao Vivo](https://github.com/prismorsec/prismor/blob/main/docs/live-telemetry.md) cobre o link opcional de plano de controle empresarial — registro de dispositivos, política remota assinada e telemetria redigida transmitida para um dashboard de organização auto-hospedado
- 🔌 [Destinos de Telemetria](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-sinks.md) encaminham cada achado para o que você já executa — um coletor OpenTelemetry (logs OTLP/HTTP), Splunk HEC, Datadog, syslog, um webhook ou um arquivo local em JSON/CEF/OCSF — despachado antes da decisão de bloqueio e nunca capaz de travar uma chamada de ferramenta
- 📊 [Dashboard](https://github.com/prismorsec/prismor/blob/main/docs/dashboard.md) cobre os dashboards de terminal e web local, além de forense de sessão, com `prismor tokens` detalhando para onde o contexto e o gasto de tokens de uma sessão realmente foram
- 🩺 [Saúde e Recuperação](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md) — `prismor doctor` verifica a saúde de cada subsistema (hooks, assinatura de política, registro, destino de telemetria, estado da cadeia), e `prismor pause` / `pause-hard` suspende *apenas a aplicação* para um humano durante um incidente, enquanto o registro em modo observe continua rodando
- 🧾 [Trilha de Auditoria Assinada](https://github.com/prismorsec/prismor/blob/main/docs/audit-trail.md) encadeia por hash e assina com Ed25519 cada ação do agente localmente, de modo que `prismor trail verify` prova que o histórico não foi editado, excluído ou reescrito
- 🔖 [Recibos de Telemetria Assinados](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-receipts.md) é o esquema de transmissão para os registros que um dispositivo reporta — bytes canônicos, as duas camadas de integridade e um verificador de referência sem dependências, para que um SIEM ou um auditor possa verificar um recibo sem o Prismor
- 📑 [Pacote de Atestação](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md) empacota postura, inventário de agentes, descoberta de host, cobertura de controle de frameworks (OWASP LLM/Agentic, NIST AI RMF, EU AI Act) e a âncora da trilha em um único arquivo assinado com Ed25519 que um auditor reverifica com `prismor attest verify`
- 🔦 [Descoberta de Host](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md#host-discovery) varre a máquina com `prismor discover` e sinaliza qualquer agente de IA rodando sem hooks do Prismor (shadow AI)
- ⏪ [Ingestão de Transcript](https://github.com/prismorsec/prismor/blob/main/docs/transcript-ingest.md) reconstrói o que seus agentes fizeram *antes* de o Prismor ser instalado — `prismor ingest --discover` reproduz transcripts de sessão em disco através do motor de políticas ao vivo, de modo que o dashboard é populado no primeiro dia e você pode ver exatamente o que teria sido bloqueado ao mudar uma regra para enforce, além de `--coverage` para sessões que rodaram sem monitoramento
- 🗺️ [Revisão de Arquitetura de IA Agêntica](https://github.com/prismorsec/prismor/blob/main/docs/agentic-architecture-review.md) é uma checklist de tempo de design para sistemas multiagente/que usam ferramentas — escopo de permissão, integridade de memória, confiança entre agentes, posicionamento de supervisão humana — cada item mapeado para um ID de controle real e, onde existe, a regra do Prismor que o respalda
- 🐳 [Docker e Contêineres](https://github.com/prismorsec/prismor/blob/main/docs/docker.md) cobre endurecimento de contêineres, pré-requisitos e limitações conhecidas

Mapa completo de comandos em todas as capacidades: [Referência da CLI](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

Essas capacidades mapeiam para o [OWASP Top 10 para Aplicações LLM](https://genai.owasp.org/llm-top-10/) - cobrindo injeção de prompt (LLM01), divulgação de informações sensíveis (LLM02), supply chain (LLM03), tratamento inadequado de saída (LLM05) e agência excessiva (LLM06).

---

## Cenários e Casos de Uso<a name="scenarios-and-use-cases" />

Fluxos de trabalho reais com os comandos e configurações que os fazem funcionar — integração de uma equipe em modo observe, atribuição IAM por usuário para pipelines multiagente e de frameworks, descoberta de shadow AI, aprovação step-up para operações de alto risco e geração de um pacote de atestação assinado para uma auditoria de conformidade. Consulte [USE_CASES.md](https://github.com/prismorsec/prismor/blob/main/USE_CASES.md).

---

## Configuração<a name="configuration" />

### Referência de Comandos

Mapa completo de comandos: [docs/cli-reference.md](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

### Modos de Governança

`prismor setup` pede que você escolha uma postura em vez de configurar seis eixos de política manualmente. Cada uma compila em `.prismor/policy.yaml` — aplicação, egresso, acesso a ferramentas, regras de tags, sandbox e limite de dados em conjunto.

![Modos de governança do Prismor](https://raw.githubusercontent.com/prismorsec/prismor/main/assets/prismor-modes.png)

| Modo | Para | Cobertura | Atrito |
|---|---|---|---|
| `dev-safe` | Trabalho em funcionalidades em código que você não leu | 31% | 9% |
| `trusted-workspace` | Repositórios internos confiáveis, trabalho local com Docker | 34% | 9% |
| `regulated-airgap` | PII/PHI, SOC 2, EU AI Act — sem rede, sem shell | 100% | 90% |```bash
prismor mode list                            # compare the three
prismor mode explain dev-safe                # the trade, including what it does NOT stop
prismor mode apply dev-safe                  # compile it into this workspace
prismor mode apply regulated-airgap --observe   # what it would block, blocking nothing

### Um único motor de políticas, todas as superfícies de aplicação

A Etapa 1 tem mais de uma porta, e isso é intencional: nenhum ponto único de interposição cobre todos os agentes. Os hooks são os mais abrangentes, mas nem todo host os oferece; o MCP é o único lugar onde alguns agentes podem ser interceptados; agentes de frameworks de produção rodam onde não há host para conectar hooks.

Assim, cada superfície normaliza o que viu em um único evento canônico e pede ao mesmo avaliador um veredito. Uma regra escrita uma vez cobre a mesma ação independentemente de como ela chega.

| superfície | o que ela governa | recusar | reescrever entrada | redigir saída |
|---|---|:--:|:--:|:--:|
| Hooks de agentes de código | toda a superfície de ferramentas de um agente | sim | Claude/Qwen | não |
| Gateway MCP | todo servidor MCP atrás de um conector | sim | sim | sim |
| Built-ins espelhados | o próprio Bash/Read/Write do agente, via MCP | sim | sim | sim |
| Adaptadores de SDK de frameworks | agentes in-process (13 frameworks) | sim | não | não |
| `prismor eval-server` | chamadores não-Python, proxies externos | sim | sim | sim |
| Canal de hook de inferência | webhook de turno de transcrição hospedado | sim | não | não |

"Redigir saída" é a razão pela qual o espelho existe: um hook de pré-ação só pode *recusar* a leitura de um arquivo, enquanto uma superfície que carrega a resposta pode retornar o arquivo com a credencial mascarada.

Isso é verificado em vez de apenas afirmado — `tests/test_surface_conformance.py` reproduz uma ação através do normalizador de cada superfície e falha se elas discordarem quanto ao veredito ou à regra.

Veja [o contrato de decisão](https://github.com/prismorsec/prismor/blob/main/docs/decision-contract.md) para o formato do evento e o vocabulário de veredito, e [superfícies de governança](https://github.com/prismorsec/prismor/blob/main/docs/governance-surfaces.md) para qual superfície usar por agente.

---

## Capacidades Selecionadas, Detalhadas<a name="selected-capabilities-walked-through" />

Três módulos de [Capacidades](#capabilities), com configuração, saída e resultados.

### Defesa Híbrida Semântica contra Injeção de Prompt<a name="hybrid-semantic-prompt-injection-defense" />

Regras de regex capturam formatos de injeção conhecidos. A guarda semântica adiciona uma camada ciente de intenção: uma pré-triagem heurística lida com casos claros em <1 ms, e entradas incertas escalam para um juiz LLM que detém o veredito de qualquer forma — ele confirma ataques parafraseados que a regex só viu pela metade e libera texto benigno que disparou um sinal de reivindicação de autoridade. Testado em mais de 800 casos — **+30% de recall** sem falsos positivos adicionais, incluindo injeções parafraseadas e em arquivo que contornam a regex.

![Semantic Guard Results](https://assets.kitploit.com/production/public/readmes/13903/a32297d3549c5ff60690c8dca14490f1d53a17a253d912bcb2187414dea3d018.png)

O juiz roda em um login que você já tem — nenhuma chave de API é necessária. `prismor setup` pergunta na etapa **LLM judge**; via script:```bash
prismor setup --non-interactive --judge claude   # Claude Code CLI, your Claude login
prismor setup --non-interactive --judge codex    # Codex CLI, your ChatGPT login
prismor setup --non-interactive --judge api --judge-model gpt-4o-mini   # any litellm model + key

# Iniciar o servidor
mcp-server --port 8080

# Conectar a um servidor remoto
mcp-client --server http://localhost:8080

# Executar com arquivo de configuração
mcp-server --config config.yaml

# Ativar saída detalhada
mcp-server --verbose

# Formato de saída JSON
mcp-client --output json

# Clonar o repositório
git clone https://github.com/example/mcp-server.git
cd mcp-server

# Criar ambiente virtual
python -m venv venv
source venv/bin/activate  # No Windows: venv\Scripts\activate

# Instalar dependências
pip install -r requirements.txt

# Instalar dependências de desenvolvimento
pip install -r requirements-dev.txt

# Executar todos os testes
pytest

# Executar com cobertura
pytest --cov=mcp_server

# Executar testes específicos
pytest tests/test_server.py

# Executar com saída detalhada
pytest -v

# Executar flake8
flake8 mcp_server

# Executar pylint
pylint mcp_server

# Executar black
black mcp_server

# Executar isort
isort mcp_server

# Compilar pacote
python -m build

# Compilar wheel
python setup.py bdist_wheel

# Compilar código-fonte
python setup.py sdist

# Compilar imagem Docker
docker build -t mcp-server:latest .

# Executar contêiner
docker run -p 8080:8080 mcp-server:latest

# Executar com variáveis de ambiente
docker run -p 8080:8080 -e MCP_TOKEN=secret mcp-server:latest

# Executar com volume
docker run -p 8080:8080 -v $(pwd)/config:/app/config mcp-server:latest

version: '3.8'

services:
  mcp-server:
    build: .
    ports:
      - "8080:8080"
    environment:
      - MCP_TOKEN=secret
      - MCP_DEBUG=false
    volumes:
      - ./config:/app/config
    restart: unless-stopped

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-server
  template:
    metadata:
      labels:
        app: mcp-server
    spec:
      containers:
      - name: mcp-server
        image: mcp-server:latest
        ports:
        - containerPort: 8080
        env:
        - name: MCP_TOKEN
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: token
``````yaml
# .prismor/policy.yaml
settings:
  semantic_guard:
    provider: codex   # api | claude | codex
    model: ""         # "" = that CLI's default model

./tool -u https://example.com

./tool -u https://example.com -H "Authorization: Bearer token" --cookies "session=abc123"

./tool -l targets.txt --threads 20 --rate-limit 50

./tool -u https://example.com --format json --output results.json

./tool -u https://example.com --proxy http://127.0.0.1:8080 --insecure

# config.yaml
timeout: 15
threads: 20
rate_limit: 100
user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
follow_redirects: true
insecure: false
output_format: json

./tool --config /path/to/custom-config.yaml -u https://example.com

[VULNERABLE] https://example.com/path1
[SAFE] https://example.com/path2
[ERROR] https://example.com/path3 - Connection timeout

{
  "results": [
    {
      "url": "https://example.com/path1",
      "status": "vulnerable",
      "details": {
        "type": "SQL Injection",
        "parameter": "id",
        "payload": "' OR '1'='1"
      }
    },
    {
      "url": "https://example.com/path2",
      "status": "safe",
      "details": null
    }
  ],
  "summary": {
    "total": 2,
    "vulnerable": 1,
    "safe": 1,
    "errors": 0
  }
}

url,status,type,parameter,payload
https://example.com/path1,vulnerable,SQL Injection,id,' OR '1'='1
https://example.com/path2,safe,,,

./tool -u https://example.com --timeout 30

./tool -u https://example.com --insecure

./tool -u https://example.com --rate-limit 5 --threads 2

./tool -l large-targets.txt --threads 5

./tool -u https://example.com --verbose --debug

Veredictos: `< 30` permitir · `30–59` alertar · `≥ 60` bloquear. A correspondência de IOC sempre bloqueia. Crie aliases para os seus gerenciadores de pacotes para controlar automaticamente cada instalação.

`prismor supplychain harden` grava configurações de lockdown em `.npmrc` / `.yarnrc.yml` / `pip.conf` / `.cargo/config.toml` para que o gerenciador de pacotes as aplique mesmo quando o alias é contornado (CI, plugins de IDE).```bash
prismor supplychain harden           # apply to current directory
prismor supplychain harden --dry-run

`--scope` tem como padrão `project`. **Os escopos project e user editam arquivos diferentes** — executar apenas `--scope user` *não* afeta os hooks locais de um workspace, e vice-versa:

| Agent | Escopo project | Escopo user |
|---|---|---|
| Claude Code | `<workspace>/.claude/settings.json` | `~/.claude/settings.json` |
| Cursor | `<workspace>/.cursor/hooks.json` | `~/.cursor/hooks.json` |
| Windsurf | `<workspace>/.windsurf/hooks.json` | `~/.codeium/windsurf/hooks.json` |
| OpenClaw | `<workspace>/.openclaw/plugins.json` | `~/.openclaw/config.json` |
| Hermes | `<workspace>/.hermes/plugins.json` | `~/.hermes/config.json` |
| Codex | `<workspace>/.codex/hooks.json` | `~/.codex/hooks.json` |
| Copilot | `<workspace>/.github/copilot/hooks.json` | `~/.copilot/hooks.json` |
| Grok Build | `<workspace>/.grok/hooks/prismor.json` | `~/.grok/hooks/prismor.json` |
| Kiro CLI | `<workspace>/.kiro/agents/kiro_default.json` | `~/.kiro/agents/kiro_default.json` |
| Crush | `<workspace>/crush.json` | `~/.config/crush/crush.json` |
| OpenHands | `<workspace>/.openhands/hooks.json` | `~/.openhands/hooks.json` |
| Qwen Code | `<workspace>/.qwen/settings.json` | `~/.qwen/settings.json` |
| Continue CLI | `<workspace>/.continue/settings.json` | `~/.continue/settings.json` |
| Goose | `<workspace>/.agents/plugins/prismor/hooks/hooks.json` | `~/.agents/plugins/prismor/hooks/hooks.json` |

Se você executar apenas um escopo, os hooks do outro (se instalados) continuarão sendo acionados. Execute ambos se quiser o Prismor completamente fora do cenário para um agente.

Uma sessão em execução já carregou sua configuração de hooks — desinstalar no meio da sessão não terá efeito até que você inicie uma nova sessão.

Se `prismor uninstall-hooks` reportar sucesso mas os hooks ainda estiverem sendo acionados, você provavelmente está executando uma instalação obsoleta — por exemplo, uma cópia instalada via `pipx` que é um snapshot desatualizado de um checkout de desenvolvimento. Verifique `which immunity` e, se ele resolver para um venv do `pipx`, reinstale a partir do código-fonte atual (`pipx install --force <path-or-package>`) antes de executar novamente a desinstalação. Como último recurso, edite manualmente o arquivo de configuração de hooks.

### 2. Desativação suave: modo de observação + dry-run

Mantenha os hooks instalados, mas impeça que eles bloqueiem:```bash
prismor install-hooks --agent all --scope project --mode observe
PRISMOR_LOCAL_DRY_RUN=1   # set in your shell/session env