Iris

oficial

Servidor de avaliação e observabilidade de agentes nativo do MCP com registro de rastreamento, avaliação de qualidade de saída, rastreamento de custos, 12 regras de avaliação integradas, painel em tempo real e detecção de PII

O que você pode fazer com Iris MCP?

  • Registrar e pontuar uma execução — Peça ao seu assistente para registrar uma execução de agente no Iris e avaliar a saída; depois, veja o veredito e as pontuações no painel.
  • Verificar regras de segurança e custo — Execute as 28 regras determinísticas integradas para PII, injeção de prompt, indicadores de alucinação e limites de custo, sem nenhuma chamada a LLM.
  • Inspecionar e editar regras — Liste as regras integradas e revise-as ou altere-as, já que todas podem ser inspecionadas e editadas.
  • Adicionar uma regra personalizada — Carregue regras que você escreveu como código por meio de eval.plugins em config.json, fixadas pelo hash do arquivo.
  • Comparar execuções — Abra duas execuções com as mesmas perguntas lado a lado, com um intervalo, na visualização Runs do painel.
  • Bloquear a CI com base nos vereditos — Execute ingest com --evaluate --fail-on any para fazer um job falhar diante de qualquer veredito que não seja aprovação.

Documentação

Iris — pare de lançar agentes no achismo

CI OpenSSF Scorecard OpenSSF Best Practices npm version License: MIT Install in Cursor Install in VS Code

Envie uma execução do agente para Iris e peça uma avaliação da qualidade, segurança e custo — na sua máquina, sem SDK nem conta. A maioria dos projetos de agentes verifica a qualidade executando alguns prompts lembrados e avaliando o resultado a olho. Iris substitui isso por números que você pode auditar: as execuções do seu agente são armazenadas em um banco de dados SQLite no seu disco, 28 regras integradas as avaliam de forma determinística — PII, injeção de prompt, indicadores de alucinação, limites de custo e as próprias chamadas de ferramentas do agente — gratuitamente, sem chamadas a LLM; e um avaliador opcional de LLM, com um limite rígido de custo por avaliação, cuida das questões semânticas. Todas as regras podem ser inspecionadas e editadas, porque um avaliador que você não pode auditar é só achismo com um número. Licença MIT, sem telemetria. Nada sai da sua máquina, a menos que você ative uma destas opções: um endpoint OpenTelemetry (IRIS_OTEL_ENDPOINT), que exporta rastros para o coletor que você indicar; o avaliador de LLM com sua própria chave, que envia o texto avaliado ao provedor e cuja verificação de citações busca as páginas citadas por uma saída; ou um webhook, que envia IDs, a avaliação e os nomes das regras, nunca o texto, para o endereço que você definir.

Requer Node.js 22.13 ou posterior. Confira com node --version.

The demo: Failures, a failure opened, two runs compared

O banco de dados de demonstração, registrado por scripts/demo-media.mts; o código-fonte está em demo.mp4. Uma imagem: dashboard-overview.png.

Uma falha na tela em 60 segundos

Sem configurar o agente, sem configuração — um comando:

npx @iris-eval/mcp-server --demo

Isso cria um banco de dados de demonstração — cinco agentes pequenos, duas semanas de execuções, todas as avaliações geradas pelo próprio mecanismo — e disponibiliza o painel em http://localhost:6920 (seu navegador abre automaticamente na primeira execução). O painel abre em Falhas: o que falhou, começando pelo pior e mais recente, com cada cartão indicando a regra e suas evidências. Vale a pena clicar: um vazamento de PII detectado pelas regras de segurança, uma instrução oculta em uma publicação de fórum que o sumarizador seguiu, um número que nunca apareceu no documento de origem, duas execuções com as mesmas doze perguntas comparadas com um intervalo (Execuções), uma regra personalizada implantada e outra pausada com seus registros de auditoria, e uma pontuação reprovada pelo avaliador de LLM com sua justificativa.

Os dados de demonstração ficam em um banco de dados próprio (demo.db no diretório pessoal do Iris — ~/.iris no macOS/Linux, %USERPROFILE%\.iris no Windows) e nunca se misturam aos seus rastros reais. Remova tudo com um comando:

npx @iris-eval/mcp-server --demo-clear

Conecte seu próprio agente

Primeiro, confirme que a instalação funciona nesta máquina — ela funciona offline e não abre nada seu:

npx @iris-eval/mcp-server --self-test   # exit 0 = healthy

Depois, adicione Iris ao seu cliente MCP. Um comando grava no arquivo de configuração do próprio cliente, preserva todos os outros servidores e fixa a versão executada:

npx -y @iris-eval/mcp-server install claude-code

Os clientes: claude-code, claude-desktop, cursor, windsurf, continue, vscode, cline, zed, codex, gemini. install --list mostra os clientes encontrados nesta máquina, qual Iris cada um executa e qual arquivo lê; install <client> --uninstall remove Iris novamente. Todos os clientes compartilham um banco de dados; portanto, após uma atualização, migre todos de uma vez com install --upgrade (Atualização). Reinicie o cliente para carregá-lo.

Claude Desktop: um clique. Cada versão a partir da 0.20.0 inclui iris-eval.mcpb, um MCP Bundle: baixe a versão mais recente, abra-a e o Claude Desktop exibirá uma janela de instalação. Nada nela é obrigatório — uma chave da Anthropic ou da OpenAI para o avaliador de LLM é opcional, e o painel é uma opção que vem desativada. O bundle contém o pacote npm e suas dependências, então não é preciso instalar mais nada: o Claude Desktop o executa com a versão do Node que acompanha o aplicativo, desde que seja 22.13 ou mais recente (o Claude Desktop 1.1.6679 inclui a versão 24.13), e Iris armazena os rastros usando o SQLite integrado ao Node, no mesmo ~/.iris usado por todas as outras instalações. As notas da versão explicam como verificar a assinatura e a atestação da compilação.

Ele funciona em qualquer cliente MCP, e cada cliente mencionado tem uma linha indicando como é verificado. Verificado em todas as execuções de CI: Claude Code, Gemini CLI — o cliente real inicia Iris a partir da configuração gravada pelo instalador e informa que se conectou (claude mcp list, gemini mcp list), no Linux, macOS e Windows; os hooks do plugin de captura do Claude Code também são executados pelos scripts reais. Configurado com base na documentação MCP de cada cliente — o instalador grava o arquivo documentado por cada cliente, no caminho documentado e no formato próprio de cada um (um bloco mcpServers, o servers do VS Code, o context_servers do Zed, TOML do Codex), preservando comentários e todos os outros servidores; testes unitários verificam cada caminho e cada gravador de formato com base nessa documentação: Claude Desktop, Cursor, Devin Desktop (Windsurf), Continue, VS Code, Cline, Zed, OpenAI Codex CLI. Cada linha inclui sua fonte e a data em que foi consultada: https://iris-eval.com/clients. Para fazer manualmente, use um bloco, incluindo o painel:

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

Seu cliente lista as doze ferramentas do Iris ao se conectar, e o painel fica disponível em http://localhost:6920. Agora envie isto ao seu agente:

Registre essa última tarefa no Iris e avalie o resultado.

O rastro aparece no painel com suas pontuações. Prefere o servidor MCP sem interface? Remova --dashboard dos argumentos — você pode abrir o mesmo painel a qualquer momento com npx @iris-eval/mcp-server --dashboard.

Uma coisa importante para saber desde o início: as ferramentas MCP são chamadas quando o modelo decide chamá-las. Iris não intercepta seu agente; portanto, os rastros são registrados quando seu agente pede que sejam registrados — porque você pediu isso ou porque seu código chama as ferramentas diretamente. Peça ao agente para “registrar isso no Iris e avaliar” e ele fará isso. Se quiser capturar sem depender da decisão do modelo, POST /api/v1/traces faz exatamente isso — seu código envia o rastro por HTTP simples, sem modelo no processo (consulte docs/http-ingest.md). A CLI e os hooks de host no roteiro serão clientes leves do mesmo endpoint.

Captura por HTTP (sem modelo no processo)

O endpoint de ingestão fica na porta do painel — 6920 por padrão, não na porta de transporte MCP — e só existe enquanto o painel está em execução. Passe --dashboard (ou defina IRIS_DASHBOARD=true); --transport http sozinho não inicia o painel, e uma solicitação à porta de transporte retorna 404. Com o painel ativo, qualquer coisa capaz de enviar uma solicitação HTTP pode registrar um rastro — e, opcionalmente, executar as avaliações determinísticas na mesma solicitação. GET /api/v1/capabilities na mesma porta informa o que este servidor pode avaliar, o que cada regra exige, o estado do avaliador e as etapas para ativá-lo, além dos limites — o mesmo objeto servido pelo recurso MCP iris://capabilities — para que um cliente HTTP tenha o contexto recebido por um cliente MCP durante a inicialização:

curl -s -X POST "http://127.0.0.1:6920/api/v1/traces" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_name": "support-bot",
    "input": "What is the refund policy?",
    "output": "Refunds are available within 30 days of purchase.",
    "evaluate": true,
    "eval_type": "safety"
  }'

Retorna 201 com o trace_id armazenado e o resultado da avaliação (no modo --demo, o endpoint recusa gravações com 403, para que os dados de demonstração nunca se misturem aos seus). O endpoint aceita o mesmo corpo que a ferramenta log_trace e usa a mesma pilha de middleware do restante do painel: vinculação a loopback e proteção contra rebind de DNS por padrão, além de autenticação Bearer quando configurada. Dois fatos simples sobre ele: aceita gravações sem autenticação, a menos que Iris seja iniciado com --api-key (ou IRIS_API_KEY) — a vinculação a loopback é o que o mantém restrito à sua máquina por padrão; portanto, defina uma chave antes de vincular a um endereço fora do loopback; e o que ele armazena é literal — input e output são gravados em iris.db exatamente como enviados, incluindo qualquer texto que no_pii venha a sinalizar. Contrato completo, referência dos campos e semântica dos erros: docs/http-ingest.md.

Capture cada turno do Claude Code (opcional)

/plugin marketplace add iris-eval/mcp-server
/plugin install iris-eval-capture@iris-eval

Um segundo plugin, instalado separadamente: seus hooks registram o prompt de cada turno, as chamadas de ferramentas (inclusive as que falharam, com o erro recebido pelo agente) e a resposta final, usando o prompt como chave; assim, as chamadas de um turno interrompido e as de um subagente em segundo plano também são enviadas para iris-eval ingest, sem bloquear, com os trechos críticos ocultados no texto armazenado para avaliação — uma captura que não depende de o modelo decidir chamar uma ferramenta. Um turno encerrado com erro de API é armazenado sem ser avaliado; se o modelo também tiver registrado o turno, os dois rastros são mantidos e o do plugin recebe o nome do modelo. Ele nunca imprime nada, nunca bloqueia e nunca envia nada para lugar algum. Instalar apenas iris-eval não altera o fluxo do seu turno. Limites e remoção: claude-plugin-capture/README.md.

Python

pip install iris-eval
from iris_eval import IrisClient
iris = IrisClient()                       # IRIS_URL, or the running dashboard's runtime.json
iris.evaluate_output("…", input="…", agent_name="support-bot")["verdict"]   # {"state": "pass", "basis": "clean", "by": []}

Um cliente leve sobre a API HTTP do servidor 0.16.0 e posteriores, com versão independente — iris_eval.__version__ e a página do PyPI mostram seu número, que não é o do servidor: log_trace(), evaluate_output(), get_traces(), get_trace(), health(), capabilities(), síncrono e assíncrono, respostas tipadas, a própria mensagem do servidor em caso de recusa — e um plugin do pytest: uma fixture iris e assert_iris(output, expect="pass") que verifica o estado da avaliação. packages/python/README.md.

Registre cada chamada à OpenAI e à Anthropic

from iris_eval import wrap_openai
client = wrap_openai(OpenAI(), agent_name="support-bot")   # every call: a GenAI span to POST /v1/traces, scored
import { wrapOpenAI } from '@iris-eval/sdk';
const openai = wrapOpenAI(new OpenAI(), { agentName: 'support-bot' });

Envolva o cliente do provedor uma única vez e cada chamada ao modelo se tornará um span GenAI do OpenTelemetry enviado à porta OTLP, armazenado com sua entrada, saída, uso de tokens e chamadas de ferramentas, e avaliado: uma captura que não depende de o modelo chamar uma ferramenta. wrap_openai / wrap_anthropic no cliente Python; wrapOpenAI, wrapAnthropic e irisMiddleware para o Vercel AI SDK em @iris-eval/sdk. Ambos ainda não foram publicados (a próxima versão iris-eval no PyPI; @iris-eval/sdk é compilado a partir do código-fonte até seu primeiro lançamento no npm). Streams, os auxiliares de stream dos SDKs e chamadas de ferramentas são compatíveis; o cliente original não é alterado, e uma falha do Iris nunca interrompe uma chamada — packages/sdk/README.md, packages/python/README.md.

Avalie cada execução do LangChain e do LangGraph

from iris_eval.langchain import IrisCallbackHandler
graph.invoke(inputs, config={"callbacks": [IrisCallbackHandler(agent_name="support-bot")]})

Cada execução de nível superior se torna um rastro (a execução, suas chamadas de modelo, suas chamadas de ferramentas e seus nós do grafo como spans GenAI), com entrada, saída, chamadas de ferramentas, uso de tokens e uma avaliação. Python no cliente (pip install iris-eval, 0.2.0 e posteriores), JavaScript como @iris-eval/langchain (neste repositório, ainda não publicado no npm). Ambos são comprovados no CI com um aplicativo LangGraph real e um modelo com script; a exportação OpenTelemetry do próprio LangSmith é comprovada da mesma forma — docs/otel-recipes.md.

Uma barreira de CI, sem precisar de servidor

npx -y @iris-eval/mcp-server ingest --file traces.ndjson --evaluate --fail-on any

any falha o job para toda avaliação que não seja aprovada: uma falha e uma avaliação que não foi verificada. Em vez disso, indique uma única base (--fail-on detector_veto) para falhar somente nela.

Ou use a GitHub Action (0.16.0), que falha o job para as avaliações indicadas, grava o comprovante no resumo do job e o publica como um único comentário na solicitação de pull, atualizado no mesmo lugar: uses: iris-eval/mcp-server/.github/actions/gate@v0.21.0 com traces: traces.ndjson — docs/ci-gate.md. Uma quarta porta (0.15.0): POST /v1/traces na porta do dashboard recebe o JSON ou protobuf OTLP/HTTP que sua instrumentação OpenTelemetry já emite (o exporter do SDK Python fala apenas protobuf, então esta também é a porta do Python), e cada trace OTLP se torna um trace Iris com seus spans — docs/otel-integration.md; uma receita por framework (Pydantic AI, Google ADK, LangGraph via LangSmith, CrewAI, OpenAI Agents SDK em Python e JavaScript, LlamaIndex, AutoGen, Microsoft Agent Framework, Semantic Kernel, Vercel AI SDK e Mastra), cada uma comprovada por um fixture, em docs/otel-recipes.md. ingest lê um trace JSON (ou NDJSON, um por linha) de stdin ou de um arquivo, armazena-o, avalia-o exatamente segundo as regras executadas por evaluate_output, imprime uma linha JSON por trace com o veredito e sua justificativa, e sai com código 1 quando um veredito corresponde a --fail-on. --dataset <id|label> restringe esse gate às chaves de caso de um dataset (POST /api/v1/datasets promove as chaves de caso de uma execução para um), para que um job falhe apenas nos casos que você escolheu. A receita completa, os códigos de saída e as oito justificativas estão em docs/ci-gate.md.

Escreva uma regra como código

eval.plugins em config.json carrega regras que você escreveu — um módulo ES cuja exportação padrão é { name, kind, mechanism, version, needs, evaluate(ctx) } — fixadas pelo sha256 do arquivo, para que um arquivo alterado desde que foi fixado impeça a inicialização em vez de ser executado. Um plugin carregado é acionado como um recurso integrado e aparece em list_rules em plugins. O contrato, a receita do hash e o que um plugin pode retornar: docs/plugins.md.

Use o mecanismo no seu próprio processo

O mecanismo de avaliação pode ser importado — sem servidor, sem banco de dados, sem modelo:

import { EvalEngine, defaultConfig } from '@iris-eval/mcp-server/engine';

const engine = new EvalEngine(defaultConfig.eval.defaultThreshold, defaultConfig.eval.ruleThresholds, defaultConfig.eval);
const result = await engine.evaluateAll({ output: answer, input: prompt, toolCalls, costUsd });
result.verdict.state;       // 'pass' | 'fail' | 'unknown', with result.verdict.basis and result.interpretations

O mesmo mecanismo, as mesmas regras e o mesmo composer executados pelo servidor; builtInRules(), createCustomRule(), compose() e os leitores de precisão publicada são exportados junto com ele.

Um cliente tipado para a rota HTTP

import { createClient } from '@iris-eval/mcp-server/client';

const iris = createClient({ baseUrl: 'http://127.0.0.1:6920', apiKey: process.env.IRIS_API_KEY });
const { trace_id, evaluation } = await iris.logTrace({ agent_name: 'support-bot', input, output, tool_calls, evaluate: true });
evaluation?.verdict?.state;  // the same object evaluate_output returns

Um corpo em todas as portas: é o que log_trace e iris-eval ingest aceitam. Uma recusa lança IrisClientError com a própria mensagem e o status do servidor. Ambos os subcaminhos são verificados a partir de um tarball empacotado em cada build.

Verifique sua instalação

npx @iris-eval/mcp-server --self-test   # offline diagnostic; exit 0 = healthy, 1 = a check failed
npx @iris-eval/mcp-server --version     # prints the bare version, e.g. 1.2.3

--self-test primeiro cria seu diretório inicial do Iris, caso não exista, e verifica se ele permite gravação (código de saída 1, indicando o caminho, caso não permita); informa onde está o índice de pesquisa do seu banco de dados (completo, quantos traces uma compilação em segundo plano já indexou ou sem FTS5 neste SQLite); lê o esquema do seu banco de dados (código de saída 1, com a correção, quando esta versão ou um cliente MCP fixado em uma versão mais antiga não consegue abri-lo); depois executa suas verificações — ida e volta do armazenamento, um SSN inserido e uma injeção inserida detectados pelas regras de segurança, inicialização do dashboard, proteção contra DNS rebinding — dentro de um diretório temporário isolado. Seu banco de dados real é apenas lido, nunca alterado. Tudo o que o Iris grava fica em um diretório, seu diretório inicial do Iris: ~/.iris por padrão (%USERPROFILE%\.iris no Windows), ou onde quer que IRIS_HOME aponte. É lá que ficam iris.db, config.json, custom-rules.json, audit.log, preferences.json e os arquivos de demonstração; aponte IRIS_HOME para um diretório temporário para experimentar o Iris sem tocar nos seus dados reais.

Configuração por ferramenta
ClienteStatusO que isso significaLeitura
Claude Codeverificadoum teste executa o cliente real em cada execução de CI2026-09-25
Claude Desktopdeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Cursordeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Devin Desktop (Windsurf)declaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Continuedeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
VS Codedeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Clinedeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Zeddeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
OpenAI Codex CLIdeclaradoconfigurado com base na documentação MCP do próprio cliente; o caminho e o formato do instalador são testados por unidade2026-09-25
Gemini CLIverificadoum teste executa o cliente real em cada execução de CI2026-09-25

Cada linha informa o que foi verificado: iris-eval.com/clients. Nenhum cliente é chamado de compatível sem uma linha.

npx -y @iris-eval/mcp-server install <client> grava cada um desses itens para você. Manualmente, por cliente:

Claude Desktop

Edite seu arquivo de configuração MCP:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Adicione a configuração JSON acima e reinicie o Claude Desktop.

Claude Code

claude mcp add --transport stdio iris-eval -- npx -y @iris-eval/mcp-server

Depois reinicie a sessão (/clear ou inicie-a novamente) para carregar as ferramentas.

Observação para Windows: Não use o wrapper cmd /c — ele causa problemas na análise de caminhos. O comando npx funciona diretamente.

Cursor

Adicione a configuração JSON acima a ~/.cursor/mcp.json (todos os projetos) ou a .cursor/mcp.json em um workspace, com "type": "stdio" na entrada iris-eval — a documentação do Cursor indica que é obrigatório.

Devin Desktop (Windsurf)

Adicione a configuração JSON acima a mcp_config.json: ~/.config/devin/mcp_config.json no macOS e Linux, %APPDATA%\devin\mcp_config.json no Windows.

Continue

Salve a configuração JSON acima como um arquivo próprio na pasta mcpServers do Continue: ~/.continue/mcpServers/iris-eval.json (todos os workspaces) ou .continue/mcpServers/iris-eval.json em um deles.

VS Code (MCP nativo)

Adicione a .vscode/mcp.json no seu workspace (observação: o VS Code usa servers, não mcpServers):

{
  "servers": {
    "iris-eval": {
      "command": "npx",
      "args": ["-y", "@iris-eval/mcp-server"]
    }
  }
}

Cline

Abra o painel MCP Servers do Cline → Configure MCP Servers e adicione a configuração JSON mcpServers acima a cline_mcp_settings.json (~/.cline/data/settings/cline_mcp_settings.json, compartilhada pelo Cline no VS Code, JetBrains e CLI).

Zed

Adicione à configuração do Zed settings.json:

{
  "context_servers": {
    "iris-eval": {
      "command": "npx",
      "args": ["-y", "@iris-eval/mcp-server"],
      "env": {}
    }
  }
}

OpenAI Codex CLI

Adicione a ~/.codex/config.toml:

[mcp_servers.iris-eval]
command = "npx"
args = ["-y", "@iris-eval/mcp-server"]

Gemini CLI

Adicione a configuração JSON mcpServers acima a ~/.gemini/settings.json. O Gemini CLI se conecta a servidores MCP apenas em pastas nas quais confia: se gemini mcp list mostrar iris-eval como Disabled, execute /permissions nessa pasta.

Qualquer outro cliente compatível com MCP

O Iris é um servidor MCP padrão de stdio — um único comando npx @iris-eval/mcp-server, sem SDK, sem alterações no código. Se seu cliente é compatível com MCP, é compatível com o Iris. Os formatos de configuração dos clientes mudam; em caso de dúvida, consulte a documentação MCP do seu cliente e aponte-o para esse comando.

Outros métodos de instalação

# Global install (recommended for persistent data and faster startup)
npm install -g @iris-eval/mcp-server
iris-eval --dashboard

# Docker — two servers, two ports: 3000 = MCP HTTP transport,
# 6920 = dashboard (which also serves the POST /api/v1/traces ingest endpoint).
# The image binds 0.0.0.0 inside the container, so a key is required (see Production).
# The volume is the Iris home: the database, deployed rules and audit log persist in it.
docker run -p 3000:3000 -p 6920:6920 -v iris-data:/data \
  -e IRIS_API_KEY="$(openssl rand -hex 32)" ghcr.io/iris-eval/mcp-server

Dica: A instalação global (npm install -g) armazena traces persistentemente em ~/.iris/iris.db. Com npx, os traces persistem no mesmo local, mas a inicialização é mais lenta devido à resolução de pacotes.

A imagem do contêiner e os diretórios MCP que listam o Iris:

Docker Glama Score PulseMCP mcp.so

O que você recebe

Registro de tracesÁrvores hierárquicas de spans com latência por chamada de ferramenta, uso de tokens e custo em USD. Armazenadas em SQLite, consultáveis instantaneamente.
Avaliação de saída28 regras integradas em 4 categorias: completude, relevância, segurança e custo. Detecção de PII (21 padrões: SSN, cartão de crédito, telefone, e-mail, IBAN, data de nascimento, MRN, IP, chave de API, passaporte, além de tokens da AWS/Slack/SendGrid/GitHub/Google/npm/DigitalOcean, credenciais dentro de URLs, atribuições com nomes de segredos, blocos de chave privada PEM e frases-semente; data de nascimento, número de prontuário médico, passaporte e frase-semente só são acionados junto ao respectivo rótulo, por design), injeção de prompt (38 padrões, frase + estrutura), detecção de saída fictícia, detecção de alucinações (25 sinais de fabricação/contradição fundamentados no contexto — passe input para fundamentá-los no material de origem do agente) e seis regras de trajetória que leem o que o agente FEZ: uma chamada de ferramenta com falha não reconhecida, uma chamada repetida (por chamada, por sequência repetida ou por alvo quando você enviar tools), uma chamada cujos argumentos são rejeitados pelo próprio esquema JSON da ferramenta e que o agente não tentou novamente, um arquivo, diretório ou URL citado na resposta que não aparece em nada que o agente leu, uma instrução recebida dentro de um RESULTADO DE FERRAMENTA e obedecida por uma chamada posterior, e uma tarefa que exigiu mais chamadas de ferramenta do que o limite de etapas. Mais duas comparam uma execução com execuções anteriores do mesmo caso pelo mesmo agente, sem que ninguém precise escrever a expectativa: uma ação que nenhuma execução anterior realizou e uma etapa que todas as execuções anteriores realizaram, mas esta não. Uma trajetória pode chegar como tool_calls ou como spans TOOL do OpenTelemetry. Adicione regras personalizadas com esquemas Zod.
LLM como avaliadorPontuação semântica opcional via Anthropic ou OpenAI — use sua própria chave de API. Sete modelos. Com IRIS_RELEVANCE_JUDGE_MODEL definido, answers_the_ask consulta o avaliador relevance e reprova uma resposta fora do tópico; sem ele, a regra analisa lexicalmente a solicitação e dá recomendações. Limite rígido de custo por avaliação (IRIS_LLM_JUDGE_MAX_COST_USD_PER_EVAL, padrão $0.25), com preços por avaliação informados no resultado.
Visibilidade de custosCusto agregado de todos os agentes em qualquer intervalo de tempo. Defina limites de orçamento. Receba alertas quando os agentes gastarem demais. Um trace que envia contagens de tokens e um modelo, mas nenhum custo (a maioria dos traces de OpenTelemetry e frameworks), é precificado pelo preço de tabela do modelo e marcado como estimado em todos os lugares onde aparece; pricing.models em config.json define preços para modelos que não estão na tabela integrada — docs/cost.md.
Dashboard webInterface em modo escuro e em tempo real que mostra primeiro as falhas, começando pelas piores e mais recentes — visualização de traces com pesquisa de texto completo em todo o texto dos traces, resultados de avaliação, detalhamento de custos e uma paleta de comandos (⌘K) que pesquisa suas próprias regras, traces e avaliações.
Local primeiroTudo fica em SQLite no seu disco. O servidor auto-hospedado não exige conta nem cadastro e não envia telemetria. As conexões HTTP de saída ocorrem apenas quando você opta por elas: sua própria chave de avaliador LLM, busca de citações, um exporter OTel que você configura ou um webhook que você define.

O que vem a seguir: o mapa de recursos — todas as perguntas que podem ser feitas ao Iris sobre cada assunto, com o que ele tem e o que lhe falta — e as três frentes.

Medido, não alegado

Toda regra integrada tem precisão, revocação e F1 publicados, com intervalos de confiança de 95%, medidos em um corpus rotulado que está neste repositório (proof/corpus/) e pode ser regenerado com um único comando — npm run proof — offline, sem chave e sem modelo no processo. Esses números são de dois tipos diferentes, e a página nunca os soma: algumas regras são medidas em relação a rótulos atribuídos por um modelo que leu a própria falha, o que mede a detecção; as demais são verificadas em relação à própria definição documentada, aplicada de forma independente, o que mostra que o código implementa a fórmula, mas não diz nada sobre se a fórmula detecta a falha. proof/RESULTS.md e a página de comprovação identificam cada regra. A CI repete a medição em cada pull request e falha se os números registrados diferirem dos resultados produzidos pelo código, portanto uma regra não pode mudar sem que seus números também mudem. Os números estão em iris-eval.com/proof e em proof/RESULTS.md; como o corpus foi criado, o que ele não é e como interpretar um intervalo estão em docs/proof.md. O corpus é sintético e rotulado por modelo — ainda falta uma rotulagem cega feita por humanos, e a página informa isso; node proof/blind-sample.mjs extrai a amostra reproduzível que resolverá essa questão.

Ferramentas MCP

Iris registra doze ferramentas que qualquer agente compatível com MCP pode invocar — ciclo de vida de rastreamentos e regras, comparação entre execuções, avaliação por LLM como juiz e verificação semântica de citações:

  • log_trace — Registra uma execução de agente com spans, chamadas de ferramentas, uso de tokens e custo; passe evaluate: true para avaliá-la na mesma chamada
  • evaluate_output — Avalia a qualidade da saída com base em regras de completude, relevância, segurança e custo (heurística, determinística, gratuita)
  • get_traces — Consulta rastreamentos armazenados com suporte a filtros, paginação e intervalos de tempo, e encontra a execução em que o agente disse algo com q: pesquisa de texto completo em valores de entrada, saída, chamadas de ferramentas e metadados, com classificação por relevância e palavras correspondentes destacadas
  • list_rules — Lista as regras de avaliação personalizadas implantadas (somente leitura)
  • deploy_rule — Registra uma nova regra de avaliação personalizada para que seja executada em cada evaluate_output dessa categoria
  • delete_rule — Remove uma regra personalizada implantada (destrutiva, idempotente)
  • delete_trace — Remove um único rastreamento armazenado pelo ID (destrutiva, limitada ao tenant)
  • evaluate_with_llm_judge — Avaliação semântica por LLM (Anthropic ou OpenAI). Sete modelos: accuracy, helpfulness, safety, correctness, faithfulness, task_completed, relevance. Com limite de custo e preços por avaliação divulgados. Use sua própria chave de API (IRIS_ANTHROPIC_API_KEY ou IRIS_OPENAI_API_KEY) — Iris não faz proxy nem retransmite chamadas de LLM.
  • verify_citations — Extrai citações da saída (numeradas, autor-ano, URLs, DOIs), busca as fontes por meio de um resolvedor protegido contra SSRF e com lista de domínios permitidos, e usa um LLM como juiz para verificar se cada fonte realmente dá suporte à afirmação citada. HTTP de saída opcional. Mesmo requisito de BYOK que evaluate_with_llm_judge.
  • compare_runs — Uma alteração piorou o agente? Compara duas execuções de avaliações armazenadas: um teste exato pareado quando as execuções compartilham chaves de caso, um intervalo da diferença caso contrário, um honesto "não é possível determinar" com o número de casos necessários, ou "equivalente dentro de uma margem". Cada regra tem seu próprio teste unilateral, corrigido em conjunto (Benjamini–Hochberg), para que vinte regras não possam fabricar uma regressão
  • compare_traces — Com que confiabilidade o agente responde à mesma pergunta? Taxas de aprovação por caso com intervalos, começando pelos casos instáveis, e uma taxa geral que leva as repetições em conta
  • evaluate_runs — Reavalia cada rastreamento de uma execução com as regras atuais e cria uma nova execução, para que uma alteração nas regras nunca seja interpretada como uma alteração no agente

Ativar o juiz de LLM (opcional; as regras determinísticas nunca precisam dele)

  1. Obtenha uma chave de API da Anthropic ou da OpenAI.
  2. Coloque-a no ambiente do processo que executa Iris, não apenas no seu shell. Claude Code, Claude Desktop, Cursor e a maioria dos clientes MCP: o bloco "env" da entrada iris-eval na sua configuração MCP — "iris-eval": { "command": "npx", "args": ["-y", "@iris-eval/mcp-server"], "env": { "IRIS_ANTHROPIC_API_KEY": "sk-ant-..." } } (IRIS_OPENAI_API_KEY para uma chave da OpenAI). Docker: -e IRIS_ANTHROPIC_API_KEY=... no comando de execução. HTTP ou CI: exporte a variável antes de iniciar iris-eval.
  3. Reinicie a sessão MCP. Um processo em execução nunca vê uma variável definida depois que ele foi iniciado.
  4. Confirme de dentro do seu cliente: leia iris://capabilities — judge.enabled deve ser true. Uma chave exportada no seu shell não é passada ao processo iniciado pelo cliente, a menos que a configuração a liste. Em uma máquina, npx @iris-eval/mcp-server --self-test imprime a linha do juiz para esse shell, e GET /api/v1/health informa judge.enabled em um dashboard em execução.
  5. Limite de gastos: cada chamada tem um limite de IRIS_LLM_JUDGE_MAX_COST_USD_PER_EVAL (padrão de 0.25 USD) e é recusada antes de qualquer gasto se o pior caso ultrapassar esse limite. Todas as chamadas do juiz feitas por Iris com sua chave usam um único orçamento diário, IRIS_LLM_JUDGE_DAILY_BUDGET_USD (padrão de 1 USD por dia UTC); depois de atingir o limite, nenhuma chamada é feita até a meia-noite UTC. Iris chama o provedor diretamente com sua chave e nunca faz proxy dela.
  6. Opcional: defina IRIS_RELEVANCE_JUDGE_MODEL como um ID de modelo com preço (por exemplo, claude-haiku-4-5) para que answers_the_ask peça ao juiz que verifique se cada resposta atende ao que foi solicitado e reprove as que forem irrelevantes. Isso corresponde a uma chamada do juiz por avaliação que contenha uma entrada, usando sua chave e sujeita ao limite acima; a chave, por si só, nunca ativa esse recurso. Cada chamada envia essa entrada e a saída ao provedor do modelo, substituindo antes os dados pessoais e as credenciais marcados com as flags no_pii (IRIS_RELEVANCE_JUDGE_REDACT=off envia esses dados sem alterações). As chamadas usam esse orçamento diário e são limitadas a IRIS_RELEVANCE_JUDGE_MAX_CALLS_PER_REQUEST por solicitação (padrão de 20); ao atingir qualquer um dos limites, answers_the_ask analisa a solicitação lexicalmente e explica o motivo.

Quando IRIS_OTEL_ENDPOINT está configurado, as chamadas de log_trace também emitem uma exportação OTLP/HTTP JSON de melhor esforço para qualquer coletor OpenTelemetry (Jaeger, Grafana Tempo, Datadog OTLP, Honeycomb etc.). Consulte docs/otel-integration.md.

Como passed é decidido

evaluate_output retorna tanto um score quanto uma flag passed — eles respondem a perguntas diferentes:

  • score (0..1) é a média ponderada das regras executadas — um gradiente de qualidade.
  • passed é o veredito de liberar ou não, e a pontuação nunca é considerada para isso. Um compositor analisa cada regra conforme o tipo de afirmação que ela faz: uma política configurada por você funciona como bloqueio; um detector crítico veta; uma verificação crítica solicitada que não conseguiu responder torna o veredito desconhecido (passed: false), em vez de aprovado; todos os demais detectores se combinam em uma probabilidade de que a saída seja ruim, ponderada pela razão de perda informada em eval.falsePassCost (padrão 1, portanto o limite é 0.5). verdict.basis identifica a camada que decidiu e verdict.by identifica as regras; verdict.also lista todas as camadas posteriores que também teriam decidido; interpretations[] explica por que uma regra reprovada não decidiu e qual configuração mudaria isso, além de identificar qualquer questão que não foi avaliada e a entrada que permitiria avaliá-la.

Violações de segurança genuínas reprovam a avaliação. Por padrão, no_pii, no_injection_patterns e no_blocklist_words são regras críticas: se uma delas reprovar, a avaliação informa passed: false, independentemente da pontuação das outras regras, e a resposta identifica as responsáveis em critical_failures. Um SSN vazado não pode ser compensado pela média. Quais regras integradas são críticas é uma configuração de implantação (eval.criticalRules / eval.nonCriticalRules), assim como quais detectores apenas informam resultados (eval.advisoryRules); o resultado de cada regra inclui a flag efetiva critical e criticalSource, e list_rules informa a lista de regras aplicada por este servidor. Regras personalizadas implantadas com severity: "high" ou "critical" reprovam da mesma forma; as severidades low/medium afetam apenas a pontuação. Um limite importante, descrito da mesma forma em todas as interfaces: uma regra crítica ignorada (contexto ausente, definição inválida ou regex interrompida ao atingir o limite do sandbox) não avaliou a saída e não veta — todas essas regras são identificadas em critical_skipped. Um bloqueio que precisa falhar de forma segura trata um critical_skipped não vazio como desconhecido, não como aprovado, e pode tratar qualquer caso ignorado de budgetExceeded em rule_results da mesma forma.

Para bloqueios de CI: se você omitir eval_type, todos os conjuntos de regras serão executados — completude, relevância, segurança, custo e quaisquer regras personalizadas — e a resposta informa eval_type: "all" com um note indicando que o padrão foi executado, além de um mapa categories por conjunto. Cada linha inclui state: o veredito, interpretado para as regras daquele conjunto, para que uma linha nunca indique aprovação quando as regras que reprovaram a avaliação foram ignoradas. Um conjunto sem nada para avaliar (custo sem cost_usd, relevância sem input) informa state: "unknown" e passed: null nesse caso — não avaliado, não reprovado — e nunca conta para o veredito. A resposta sempre repete o eval_type executado, para que seu bloqueio possa verificar a cobertura; use passed para o veredito e especifique um conjunto apenas quando quiser uma execução mais restrita.

Criar uma regra personalizada

Há duas maneiras de adicionar uma regra. As regras inline acompanham uma única chamada de evaluate_output (custom_rules, até 10 por chamada); elas são executadas junto com o conjunto eval_type escolhido ou sozinhas com eval_type: "custom". As regras implantadas são registradas uma vez com deploy_rule, persistem em custom-rules.json na pasta inicial do Iris e são executadas em cada evaluate_output futuro de seu evalType. A definição tem o mesmo formato nos dois casos:

CampoObrigatórioDescrição
namesim1–80 caracteres; aparece como ruleName nos resultados
typesimum entre regex_match · regex_no_match · min_length · max_length · contains_keywords · excludes_keywords · json_schema · cost_threshold
configsimas chaves desse tipo: pattern (+ flags opcional) para os dois tipos de regex · min_length / max_length (uma contagem de caracteres) · keywords (+ threshold opcional, 0–1, padrão 1 = todos devem aparecer) para os dois tipos de palavra-chave · {} para json_schema · max_cost em USD para cost_threshold
weightnãopeso na pontuação; padrão 1

deploy_rule envolve a definição com name, um description opcional, evalType (completeness · relevance · safety · cost · custom) e severity. A severidade indica o que significa uma reprovação: low/medium apenas reduzem a pontuação; high/critical reprovam a avaliação — passed: false, com a regra identificada em critical_failures — independentemente da pontuação ponderada. Uma regra ignorada (uma regra cost_threshold sem cost_usd ou uma regex interrompida ao atingir o limite de 100 ms do sandbox) não avaliou a saída e é listada em critical_skipped. Implante uma regra crítica que proíba nomes de host internos em qualquer coisa que o agente diga:

{
  "name": "no_internal_hostnames",
  "description": "Output must not mention internal hostnames.",
  "evalType": "safety",
  "severity": "critical",
  "definition": {
    "name": "no_internal_hostnames",
    "type": "regex_no_match",
    "config": { "pattern": "\\b[a-z0-9-]+\\.internal\\.example\\b", "flags": "i" }
  }
}

A resposta contém a regra persistida — guarde o id para delete_rule:

{ "rule": { "id": "rule-588823d0", "name": "no_internal_hostnames", "evalType": "safety", "severity": "critical", "enabled": true, "version": 1, "definition": { "…": "…" } } }

A partir do próximo evaluate_output com eval_type: "safety", uma saída que menciona db-primary.internal.example volta passed: false com critical_failures: ["no_internal_hostnames"] — embora todas as cinco regras de segurança integradas tenham sido aprovadas e a pontuação ponderada seja 0.895. Os padrões Regex precisam passar por uma verificação de ReDoS no momento da implantação e sempre ser executados em um worker isolado, com um prazo rígido de 100 ms. list_rules mostra o que está implantado; o criador de regras do painel monta o mesmo formato a partir de uma falha em que você clicou. Referência completa, pontuação por tipo e exemplos práticos: docs/custom-rules.md.

Esquemas completos das ferramentas e configuração: iris-eval.com

Hospedado por você e gratuito

O Iris é executado na sua máquina ou na sua própria infraestrutura. O núcleo de código aberto é gratuito e licenciado sob a licença MIT, sem limites de uso e sem necessidade de conta. Armazenamento hospedado, histórico compartilhado da equipe e alertas estão em consideração, não em desenvolvimento; se forem úteis para você, fale conosco em hello@iris-eval.com.

Dois compromissos permanecem: nada que seja gratuito hoje passará a ser pago, e nenhuma certificação de conformidade será reivindicada antes de ser obtida.

Exemplos

Comunidade

Configuração e segurança

Argumentos da CLI

FlagPadrãoDescrição
--transportstdioTipo de transporte: stdio ou http
--port3000Porta do transporte HTTP
--db-path~/.iris/iris.dbCaminho do banco de dados SQLite
--config~/.iris/config.jsonCaminho do arquivo de configuração
--api-key—Chave de API para autenticação HTTP (transporte e painel, incluindo POST /api/v1/traces)
--dashboardfalseAtiva o painel web. Também é a única forma de iniciar o endpoint de ingestão POST /api/v1/traces — ele nunca é iniciado implicitamente com --transport http
--dashboard-port6920Porta do painel
--dashboard-host127.0.0.1Endereço de vinculação do painel. Por padrão, usa loopback — o painel não exige autenticação, a menos que --api-key esteja definido; portanto, vinculá-lo além do loopback expõe todo o seu histórico de rastros
--demofalseCria um banco de dados de demonstração (separado dos seus rastros reais) e disponibiliza o painel usando-o
--demo-clearfalseExclui o banco de dados de demonstração e encerra
--self-testfalseExecuta o diagnóstico de instalação offline em um diretório temporário isolado e encerra (0 = saudável, 1 = uma verificação falhou). Também lê o banco de dados configurado em modo somente leitura e falha quando esta versão ou um cliente MCP fixado não consegue abri-lo
--purgefalseExclui todos os rastros, spans e avaliações armazenados no banco de dados configurado, compacta o arquivo e trunca o log de gravação antecipada para que o texto excluído não permaneça no disco e, em seguida, encerra. As regras implantadas, o log de auditoria e as preferências são mantidos. A ação não pode ser desfeita. Pare primeiro qualquer servidor Iris em execução — o arquivo é compactado no próprio local. Recusa-se a combinar com --demo, --demo-clear ou --self-test
--version—Imprime a versão sem formatação (por exemplo, 1.2.3) em stdout e encerra com código 0. Não lê nada do diretório pessoal do Iris

Três comandos recebem seus próprios argumentos e encerram: iris-eval ingest carrega rastros de um arquivo ou de stdin (Um bloqueio de CI, sem necessidade de servidor), iris-eval export traces|evaluations --format csv|jsonl grava o conteúdo armazenado, filtrado como as listas do painel, em stdout ou --out (docs/api-reference.md), e iris-eval install <client> grava o Iris na configuração de um cliente MCP — --uninstall o remove, --list mostra os clientes encontrados nesta máquina e qual Iris cada um executa, --upgrade atualiza todos os clientes que executam o Iris para esta versão (Conecte seu próprio agente, Atualização). Nenhum deles inicia um servidor.

config.json é validado quando o Iris inicia. Uma chave que o Iris não reconhece — um erro de digitação como eval.critcalRules, uma chave de outra ferramenta — ou um valor do tipo errado impede a inicialização, com uma frase que identifica a chave completa, a chave que provavelmente era a pretendida ou o tipo esperado. Nada no arquivo é ignorado silenciosamente.

Variáveis de ambiente

Cada variável é documentada por --help. Quando ambos estão definidos, as flags da CLI têm precedência sobre as variáveis de ambiente.

VariávelDescrição
IRIS_TRANSPORTTipo de transporte (stdio ou http)
IRIS_HOSTEndereço de vinculação do transporte HTTP (padrão 127.0.0.1)
IRIS_PORTPorta do transporte HTTP (1-65535, padrão 3000)
IRIS_HOMEDiretório para todos os arquivos por usuário: config.json, iris.db, custom-rules.json, audit.log, preferences.json (padrão ~/.iris)
IRIS_DB_PATHCaminho do banco de dados SQLite (substitui IRIS_HOME somente para o banco de dados)
IRIS_SQLITE_DRIVERQual driver SQLite armazena o banco de dados: native (better-sqlite3, o padrão) ou node (o node:sqlite integrado ao Node, Node 22.13+). Se não definido: nativo; quando o módulo nativo não puder ser carregado (ou for uma compilação que encerraria o processo nesta versão do Node), Iris avisa uma vez e usa o integrado
IRIS_SEARCH_BUDGET_MSPor quanto tempo uma busca de rastros (q) pode ler antes de responder com as correspondências encontradas até então e search.complete: false, em milissegundos (50 a 60000, padrão 1000). Uma busca mantém outras solicitações aguardando enquanto lê, então esse também é o tempo máximo que pode fazê-las esperar. Também storage.searchBudgetMs em config.json
IRIS_SEARCH_INDEXon (o padrão) ou off. off não mantém um índice de texto completo dos rastros: uma gravação armazena o rastro e nada mais, e uma busca de rastros (q) lê os próprios rastros dentro de IRIS_SEARCH_BUDGET_MS, do mais recente para o mais antigo; portanto, em um armazenamento grande, pode responder com parte das correspondências (search.complete: false). Desativá-lo apaga o índice mantido pelo banco de dados; ativá-lo novamente cria um novo em segundo plano. Também storage.searchIndex em config.json
IRIS_LOG_LEVELNível de log: debug, info, warn, error
IRIS_DASHBOARDtrue/1/yes/on ativa o painel web; false/0/no/off o desativa (também substitui dashboard.enabled em config.json)
IRIS_DASHBOARD_PORTPorta do painel (1-65535, padrão 6920)
IRIS_WEBHOOK_URLDestinatário do webhook disparado em um momento — mesclado sobre notify.webhook em config.json (docs/webhooks.md)
IRIS_WEBHOOK_SECRETChave de assinatura do webhook (qualquer string, ou whsec_ + base64); o formato iris se recusa a executar sem uma
IRIS_DASHBOARD_HOSTEndereço de vinculação do painel (padrão 127.0.0.1)
IRIS_API_KEYChave de API para autenticação HTTP. Obrigatória para vincular o transporte HTTP ou o painel além do loopback (0.0.0.0, um endereço de LAN, um contêiner): sem ela, o servidor se recusa a iniciar
IRIS_API_KEY_FILECaminho para um arquivo cujo conteúdo, após remover espaços em branco nas extremidades, é a chave de API — o padrão de arquivo secreto montado pelo Docker e Kubernetes, para que a chave nunca fique em um bloco de ambiente. Defina esta opção ou IRIS_API_KEY, não ambas
IRIS_ALLOW_UNAUTHENTICATEDDefina como 1 para executar intencionalmente uma vinculação não loopback sem chave (suspende a recusa; nesse caso, a rede é seu limite de segurança)
IRIS_ALLOWED_ORIGINSLista de permissões de origens separadas por vírgulas. Painel: cabeçalhos CORS (aceita curingas, por exemplo, http://localhost:*). Transporte HTTP: lista de permissões Origin com correspondência exata para proteção contra rebind de DNS (curingas ignorados; as próprias origens de loopback do servidor são sempre permitidas)
IRIS_MAX_INPUT_ELEMENTSNúmero máximo de elementos de array e chaves de objeto que uma entrada pode conter antes de ser validada (um número inteiro, padrão 100000): os argumentos de uma chamada de ferramenta em todos os transportes e o corpo de uma solicitação na porta do painel (os corpos JSON da API e POST /v1/traces, JSON ou protobuf). Uma chamada de ferramenta que exceder o limite recebe um resultado de erro; um corpo, 413. O padrão aceita todas as entradas JSON legítimas medidas, inclusive uma que preencha toda a solicitação de 1 MB. Um corpo protobuf em POST /v1/traces tem seu próprio limite, um elemento a cada 5 bytes de security.requestSizeLimit (209,716 em 1 MB) ou esta configuração, se for maior; assim, um lote do exportador dentro do limite de tamanho da solicitação não é recusado por sua densidade (o corpo real de exportador mais denso medido contém um elemento a cada 7.5 bytes); aumentar requestSizeLimit para lotes maiores de um coletor também aumenta esse limite. Também security.maxInputElements em config.json
IRIS_MAX_TOOL_INPUT_ELEMENTSO nome de IRIS_MAX_INPUT_ELEMENTS antes da versão 0.21.0, lido quando o novo nome não está definido (e security.maxToolInputElements em config.json, da mesma forma)
IRIS_NO_AUTO_LAUNCHDefina como 1 para desativar a abertura automática do painel na primeira execução
IRIS_ANTHROPIC_API_KEYObrigatório para evaluate_with_llm_judge + verify_citations com provider=anthropic
IRIS_OPENAI_API_KEYObrigatório para evaluate_with_llm_judge + verify_citations com provider=openai
IRIS_LLM_JUDGE_MAX_COST_USD_PER_EVALLimite máximo de custo por chamada do avaliador LLM (padrão 0.25). max_cost_usd pode reduzi-lo para uma chamada, nunca aumentá-lo
IRIS_RELEVANCE_JUDGE_MODELID de um modelo de avaliador com preço definido (por exemplo, claude-haiku-4-5). Quando definido, com a chave desse provedor, answers_the_ask consulta esse avaliador LLM em cada avaliação que contenha uma entrada e aplica o resultado de relevância — uma chamada ao avaliador por avaliação, dentro do limite de custo acima e dos dois limites abaixo. A entrada e a saída de cada avaliação desse tipo são enviadas ao provedor desse modelo (Anthropic ou OpenAI) usando sua chave, após a substituição dos dados pessoais e credenciais sinalizados por no_pii. Se não definido (o padrão), answers_the_ask analisa a solicitação lexicalmente e fornece recomendações, sem enviar nada (docs/llm-as-judge.md)
IRIS_LLM_JUDGE_DAILY_BUDGET_USDQuanto todas as chamadas do avaliador podem gastar juntas por dia UTC, por locatário (padrão 1): o avaliador de relevância, evaluate_with_llm_judge e verify_citations compartilham esse limite. Ele é mantido no banco de dados, portanto uma reinicialização não o redefine. Uma chamada só é feita se seu custo máximo couber no saldo restante; depois disso, answers_the_ask analisa a solicitação lexicalmente (judge.withheld: "daily_budget") e as ferramentas do avaliador respondem IRIS_BUDGET_EXCEEDED (uma citação, daily_budget_reached). 0 interrompe todas as chamadas
IRIS_RELEVANCE_JUDGE_DAILY_BUDGET_USDO nome de IRIS_LLM_JUDGE_DAILY_BUDGET_USD antes da versão 0.21.0, quando limitava apenas o avaliador de relevância. Lido quando o novo nome não está definido; nesse caso, limita todas as chamadas do avaliador. O servidor informa isso na inicialização
IRIS_RELEVANCE_JUDGE_MAX_CALLS_PER_REQUESTNúmero de chamadas do avaliador de relevância que uma solicitação pode fazer (padrão 20): um lote OTLP ou uma reavaliação de evaluate_runs avalia seus primeiros 20 rastros e analisa o restante lexicalmente, com judge.withheld: "request_cap"
IRIS_RELEVANCE_JUDGE_REDACTon (padrão): os sinalizadores no_pii de cada span (dados pessoais e credenciais) na entrada e na saída são substituídos por um marcador [REDACTED:<kind>#<n>] antes de serem enviados ao avaliador de relevância. off os envia sem alterações
IRIS_CITATION_ALLOW_FETCHDefina como 1 para permitir HTTP de saída em verify_citations (desativado por padrão). Um argumento de ferramenta pode desativá-lo para uma chamada, nunca ativá-lo
IRIS_CITATION_DOMAINSLista de permissões de nomes de host separados por vírgulas para verify_citations (correspondência por sufixo). Um argumento de ferramenta pode restringi-la, nunca adicionar itens
IRIS_CITATION_MAX_COST_USD_TOTALValor máximo que uma chamada verify_citations pode gastar em chamadas ao avaliador (padrão 1). max_cost_usd_total pode reduzi-lo para uma chamada, nunca aumentá-lo
IRIS_OTEL_ENDPOINTAtiva a exportação de rastros OTLP/HTTP JSON com melhor esforço para esta URL do coletor
IRIS_OTEL_SERVICE_NAMEAtributo de recurso service.name para exportação OTel (padrão iris-eval)
IRIS_OTEL_HEADERSCabeçalhos k=v separados por vírgulas para exportação OTel (por exemplo, authorization=Bearer abc)
IRIS_OTEL_TIMEOUT_MSTempo limite por exportação (padrão 15000)
RATE_LIMIT_SALTSomente o site — adiciona um salt ao hash do endereço usado pelo limite de taxa do playground iris-eval.com; o servidor nunca o lê

Segurança

Ao usar o transporte HTTP, Iris inclui:

  • Autenticação por chave de API com comparação resistente a ataques de temporização (Bearer para clientes de API; login no painel pelo navegador via ?key=)
  • CORS restrito a localhost por padrão
  • Limitação de taxa por endereço de cliente e minuto: 600 solicitações à API do painel (security.rateLimit.api) e 20 ao endpoint MCP (security.rateLimit.mcp), ambos definidos em config.json; uma solicitação MCP acima do limite recebe um erro JSON-RPC que identifica a chave
  • Cabeçalhos de segurança Helmet
  • Validação de entrada Zod em todas as rotas
  • Expressão regular segura contra ReDoS para regras de avaliação personalizadas
  • Um limite de tamanho de solicitação de 1 MB em cada transporte (security.requestSizeLimit): HTTP responde 413; stdio responde com um erro JSON-RPC e mantém a sessão aberta
  • Um limite de 100,000 elementos de array e chaves de objeto em uma entrada, contabilizados antes da validação (security.maxInputElements): os argumentos de uma chamada de ferramenta em qualquer transporte recebem um resultado de erro se excederem o limite; o corpo de uma solicitação do painel ou OTLP recebe um 413
  • Erros de validação retornam no máximo 20 problemas e o total (issueCount), para que a resposta permaneça pequena, por mais incorreta que seja a solicitação
# Production deployment
iris-eval --transport http --port 3000 --api-key "$(openssl rand -hex 32)" --dashboard

Com uma chave definida, os clientes de API — clientes MCP, SDKs de captura, POST /api/v1/traces — enviam Authorization: Bearer <key>. Para abrir o painel em um navegador, acrescente a chave uma vez a qualquer URL do painel, http://localhost:6920/?key=<api key>: Iris a troca por um cookie de sessão HttpOnly, SameSite=Lax e redireciona para a mesma página, removendo a chave da barra de endereço. Uma página aberta sem sessão exibe um formulário de login que faz a mesma troca. A chave nunca é armazenada no navegador, e as sessões existem apenas no processo do servidor (no máximo 256 sessões ativas por vez; se todas estiverem ativas, o login é recusado em vez de remover uma delas).

Produção

Várias chaves e rotação sem interrupção. security.apiKeys em config.json comporta qualquer número de chaves adicionais, cada uma com um id e exatamente um de keyFile (um arquivo cujo conteúdo, após remover espaços em branco nas extremidades, é a chave) ou keyHash (o sha256 hexadecimal da chave, para que o arquivo de configuração não contenha segredos — printf %s "$KEY" | openssl dgst -sha256), além de um expiresAt opcional (ISO 8601) após o qual ela deixa de corresponder naquele instante. Para fazer a rotação: adicione a nova chave, migre seus clientes e remova a chave antiga. As chaves em config.json e nos arquivos de chave entram em vigor sem reinicialização (0.20.0): a cada solicitação, o servidor verifica se config.json ou algum arquivo de chave indicado por ele foi alterado e, se sim, relê as chaves antes de responder. Remover uma chave de security.apiKeys ou excluir seu arquivo de chave a revoga na próxima solicitação: essa solicitação é recusada e todas as sessões de navegador abertas com ela são encerradas. Um config.json que não possa ser lido (por exemplo, por estar parcialmente gravado) falha de forma segura; até que seja corrigido, somente uma chave de IRIS_API_KEY ou --api-key é aceita. A própria chave em IRIS_API_KEY ou --api-key, e a ativação da autenticação, ainda só mudam após uma reinicialização. Cada chave autentica até ser removida ou expirar, tanto pelo caminho Bearer quanto pelo login no navegador; o log de inicialização identifica os IDs. security.rateLimit.mcpKeyBy: "apiKey" contabiliza o limite por minuto do endpoint MCP por chave, em vez de por endereço de cliente, para que vários agentes no mesmo endereço tenham cada um seu próprio limite por minuto.

Vários clientes. --transport http atende qualquer número de clientes MCP em um endereço: cada initialize abre sua própria sessão usando o mesmo mecanismo e armazenamento, até 256 sessões simultâneas. Com stdio, cada cliente inicia seu próprio processo de servidor, e esses processos compartilham o diretório inicial do Iris: uma regra implantada, desativada ou excluída por um deles se aplica a todos os outros em até 20 ms; um rótulo escrito por um deles é lido pelos demais imediatamente; e, se dois deles alterarem regras ao mesmo tempo, nenhuma alteração será perdida. O Iris se recusa a iniciar quando o transporte HTTP ou o painel está vinculado além do loopback — 0.0.0.0, um endereço LAN, um contêiner — sem uma chave de API, e informa isso em uma frase que menciona IRIS_API_KEY. Isso inclui um docker run simples da imagem, que vincula 0.0.0.0 dentro do contêiner, pois o loopback não pode ser alcançado por uma porta publicada. O loopback sem chave continua funcionando (com um aviso no transporte HTTP): nesse caso, o limite da máquina controla a exposição.

# The image: pass a key
docker run -p 3000:3000 -p 6920:6920 -v iris-data:/data \
  -e IRIS_API_KEY="$(openssl rand -hex 32)" ghcr.io/iris-eval/mcp-server

# Compose: the file requires the variable and refuses before the container starts
IRIS_API_KEY="$(openssl rand -hex 32)" docker compose up

# A network you have already fenced some other way: run open, on purpose
IRIS_ALLOW_UNAUTHENTICATED=1 iris-eval --transport http --dashboard

Aberto por design, em um servidor com chave: GET /health no transporte e GET /api/v1/health no painel respondem sem chave e fora de todos os limites de taxa, em um único formato: status, versão, tempo de atividade, o driver SQLite, checks para armazenamento, o arquivo de regras implantadas e as migrações (aplicadas em relação às conhecidas), o estado do índice de pesquisa (search: pronto ou o progresso da compilação como proporção dos rastros), e se há uma chave de juiz — nunca a chave, nunca um rastro, nunca a contagem deles. status é ok somente quando todas as verificações estão; caso contrário, é degraded com HTTP 503, que o próprio HEALTHCHECK da imagem Docker consulta. Todo o resto exige Authorization: Bearer <key> ou uma sessão do navegador. A retenção é executada em todos os servidores: rastros e avaliações mais antigos que retention.days (padrão 30) são excluídos na inicialização, depois que o servidor começa a responder, e a cada retention.sweepIntervalHours, em etapas curtas que nunca fazem uma solicitação esperar muito; --self-test exibe a política desta instalação, e iris://capabilities / GET /api/v1/capabilities a transportam como retention.

Um webhook é disparado por um evento (0.16.0): notify.webhook em config.json (ou IRIS_WEBHOOK_URL e IRIS_WEBHOOK_SECRET) identifica um destinatário, e o Iris envia uma mensagem assinada quando um veredito falha, uma detecção crítica veta, um custo é um valor atípico, a taxa de falha de uma regra muda ou um caso recebe respostas diferentes pela primeira vez — IDs, o veredito, as regras e os números, nunca o texto do agente. Assinada simultaneamente no formato Standard Webhooks e no formato GitHub, com novas tentativas e espera progressiva, intervalo de resfriamento por agente e regra, sem nunca interferir na avaliação; corpos para Slack e Discord integrados. docs/webhooks.md.

Seus dados no disco

Tudo o que o Iris armazena fica no diretório inicial do Iris (~/.iris, ou IRIS_HOME). iris.db mantém o input e o output de cada rastro literalmente — incluindo qualquer texto que no_pii venha a sinalizar; a detecção não remove dados, a menos que você peça: storage.redact: "critical_spans" em config.json armazena a saída de cada avaliação com os trechos sinalizados por um detector crítico substituídos por [REDACTED:<pattern>] (desativado por padrão; os deslocamentos das evidências ainda indexam o texto visto pelo chamador). storage.synchronous define quando uma gravação chega ao disco: normal (o padrão) sincroniza o log de gravação antecipada em cada ponto de verificação, portanto, uma falha do Iris não causa perda de dados nem corrompe o arquivo, mas uma queda de energia ou falha do sistema operacional pode desfazer as gravações desde a última sincronização; full sincroniza cada confirmação e as preserva em ambos os casos, com cerca de 1,5 ms a mais por gravação. Na inicialização e, depois disso, a cada retention.sweepIntervalHours (padrão 24; 0 desativa o temporizador), rastros e avaliações mais antigos que retention.days (padrão 30; 0 desativa; definido em config.json) são excluídos e o log de gravação antecipada passa por um ponto de verificação. Um item é mantido além do período: a execução de referência fixada, com suas avaliações, pois é contra ela que todas as execuções posteriores são comparadas. Cada limpeza que mantém parte desses dados informa isso no log, com a execução e as contagens; desafixe a execução e a próxima limpeza a excluirá. Casos e rótulos de conjuntos de dados não são rastros nem avaliações e não são removidos. Excluir um rastro — por meio de delete_trace ou da limpeza — apaga o texto de todas as avaliações vinculadas a ele (a saída, o texto esperado e as mensagens das regras) e registra erased_at; o veredito, as pontuações e os deslocamentos das evidências permanecem. Cada exclusão verifica o log de gravação antecipada antes de retornar, para que o texto excluído não continue legível em iris.db ou iris.db-wal (se uma pesquisa estiver lendo o arquivo naquele momento, ou outro processo estiver lendo ou gravando nele, a exclusão retorna sem esperar e o texto sai do arquivo assim que a operação termina). Para remover tudo agora, pare o servidor e execute --purge: ele exclui todos os rastros, trechos e avaliações armazenados, compacta o banco de dados e trunca o log de gravação antecipada para remover o texto do disco, preservando as regras implantadas, o log de auditoria e as preferências. Antes de uma versão aplicar uma migração a um iris.db existente, ela copia o arquivo para o mesmo diretório (iris.db.<from>-to-<to>.<time>.bak, somente para o proprietário; as três versões mais recentes são mantidas; Rebaixamento): a cópia preserva os rastros como estavam, portanto, a limpeza de retenção exclui os que forem mais antigos que retention.days, e --purge os exclui todos. O servidor faz a cópia e as migrações depois de responder ao cliente, em uma thread própria: chamadas de ferramentas, leituras de recursos e solicitações HTTP que chegarem nesse meio-tempo aguardam, por no máximo 30 s cada, e depois são recusadas com uma frase que informa o que o servidor está fazendo (IRIS_STORAGE_ERROR, pode ser repetido; HTTP 503 com Retry-After). O status de integridade responde durante todo o processo e informa o que a atualização está fazendo. A partir da versão 0.19.0, com 100.000 rastros, cada um representando um loop de agente, a cópia e as migrações levaram cerca de 6 s. iris-eval ingest, --purge e --self-test ainda atualizam antes de fazer qualquer outra coisa.

O Iris não criptografa os dados em repouso. iris.db e seus arquivos de log de gravação antecipada são criados somente para o proprietário (modo 600), e o diretório inicial do Iris é criado no modo 700 (no Windows, as ACLs dos arquivos se aplicam). O banco de dados não armazena chaves de provedores de LLM: IRIS_ANTHROPIC_API_KEY e IRIS_OPENAI_API_KEY são lidas do ambiente e nunca gravadas no disco. Ele armazena entradas e saídas de rastros literalmente, portanto, coloque o diretório inicial do Iris em um disco ou volume criptografado (FileVault, BitLocker, LUKS ou um volume de nuvem criptografado para a montagem /data da imagem Docker).

Uma exportação — o botão Exportar nas páginas Rastros e Avaliações do painel, GET /api/v1/traces/export e /api/v1/evaluations/export, ou iris-eval export — inclui o texto armazenado tal como está, igual ao que o painel exibe: entrada e saída do rastro literalmente, saída da avaliação com storage.redact aplicado. Trate um arquivo exportado como o banco de dados de onde ele veio.

Solução de problemas

Primeiro passo: execute o autoteste

npx @iris-eval/mcp-server --self-test

Ele verifica o armazenamento, as avaliações determinísticas e o painel em um diretório temporário isolado e exibe um veredito para cada etapa — a saída de falha identifica a etapa com problema. O código de saída 0 significa que a instalação está saudável.

O Iris não inicia / ERR_MODULE_NOT_FOUND

Talvez você tenha uma versão antiga em cache. Limpe o cache do npx e tente novamente:

npx --yes @iris-eval/mcp-server@latest

Ou instale globalmente para evitar problemas de cache:

npm install -g @iris-eval/mcp-server@latest

npm install --ignore-scripts interrompeu a vinculação do SQLite

O Iris armazena rastros com better-sqlite3, um módulo nativo que baixa ou compila sua vinculação em um script de instalação. Se esse script foi ignorado — --ignore-scripts na linha de comando, ignore-scripts=true em um .npmrc (comum em máquinas corporativas) ou um espelho de registro que remove o postinstall — a inicialização falha com uma longa mensagem "Could not locate the bindings file" que lista uma dúzia de caminhos tentados. Recompile esse módulo:

npm rebuild better-sqlite3
# for a global install:
npm rebuild -g better-sqlite3

As ferramentas não aparecem no Claude Code

As ferramentas MCP só são carregadas no início da sessão. Depois de adicionar iris-eval, reinicie a sessão com /clear ou reabra o terminal.

Verificação da versão

npx @iris-eval/mcp-server --version

A primeira linha do log de inicialização também informa a versão (Starting Iris MCP server vX.Y.Z), e --self-test a exibe no resumo. Em uma instalação global, npm ls -g @iris-eval/mcp-server mostra a versão instalada.

Atualização

Todos os clientes MCP em uma máquina compartilham um banco de dados, ~/.iris/iris.db, e install fixa cada cliente à versão que gravou sua configuração. Quando uma versão altera o esquema do banco de dados, o primeiro processo dessa versão a abrir o arquivo o atualiza; a partir daí, um cliente ainda fixado a uma versão mais antiga se recusa a iniciar. Portanto, atualize todos os clientes de uma só vez, antes ou logo depois de atualizar:

npx -y @iris-eval/mcp-server@latest install --upgrade

Ele encontra todos os arquivos de configuração de clientes nesta máquina que executam o Iris e atualiza cada versão fixada para essa versão (preservando tudo o que você adicionou à entrada, como --dashboard ou um bloco env), não altera uma versão fixada a uma versão mais recente nem uma entrada que execute algo diferente do pacote npm e lista o que fez. Reinicie os clientes indicados. install --list mostra qual versão do Iris cada cliente executa.

Duas instalações ficam fora desses arquivos: a extensão do Claude Desktop (iris-eval.mcpb) é atualizada quando você abre um pacote mais recente, e os plugins do Claude Code com claude plugin marketplace update iris-eval e depois claude plugin update iris-eval@iris-eval (e claude plugin update iris-eval-capture@iris-eval para o plugin de captura).

Atualização da versão 0.19.x para 0.20.0. A versão 0.20.0 adiciona o índice de pesquisa e outros itens ao banco de dados (migrações 015 e posteriores). Depois que qualquer processo da versão 0.20.0 abrir ~/.iris/iris.db (a extensão do Claude Desktop, npx iris-eval ou npx @iris-eval/mcp-server sem versão), um cliente fixado à versão 0.19.x para com This database was migrated by a newer Iris (…) — migration(s) 015-trace-search, … are unknown to v0.19.0. Upgrade Iris, …. Essa mensagem vem da versão 0.19.x e não pode ser alterada; a solução é executar o comando acima. Antes da atualização, a versão 0.20.0 copia o arquivo para o mesmo diretório, portanto, também é possível voltar atrás (abaixo).

Uma inicialização que atualiza o banco de dados imprime no stderr o que foi feito: a cópia criada, quais versões mais antigas não podem mais abrir o arquivo e qualquer cliente nesta máquina fixado a uma delas, junto com o comando. --self-test lê o banco de dados sem alterá-lo e informa o mesmo antes de você iniciar qualquer coisa.

Em uma instalação global, npm update -g @iris-eval/mcp-server e depois iris-eval install --upgrade.

Rebaixamento

Uma versão que atualiza o banco de dados primeiro cria uma cópia ao lado dele: iris.db.<from>-to-<to>.<time>.bak no diretório inicial do Iris (<from> é a versão que alterou o esquema do arquivo pela última vez; <to>, a que o atualizou; a linha de inicialização exibe o caminho exato). Para voltar atrás:

  1. Pare todos os clientes MCP e qualquer outro processo do Iris que use o banco de dados.
  2. Preserve o arquivo atualizado, caso volte a usá-lo: renomeie iris.db para iris.db.upgraded e exclua iris.db-wal e iris.db-shm, se existirem.
  3. Copie o backup para iris.db: cp ~/.iris/iris.db.0.19.0-to-0.20.0.<time>.bak ~/.iris/iris.db.
  4. Fixe cada cliente novamente à versão mais antiga: npx -y @iris-eval/mcp-server@0.19.0 install <client> para cada um (install --upgrade nunca reverte a versão de um cliente).

Os rastros armazenados após a atualização estão em iris.db.upgraded, não no backup. Se nenhuma cópia foi criada (a linha de inicialização informa o motivo, por exemplo, disco cheio), a versão mais antiga não pode abrir o arquivo atualizado, e a solução é install --upgrade.

O driver de armazenamento

A instalação ainda é concluída em uma plataforma sem um better-sqlite3 pré-compilado. better-sqlite3 é uma dependência opcional: quando o npm não consegue baixar um binário pré-compilado para sua versão do Node e sua plataforma, nem compilá-lo (a compilação exige Python e uma cadeia de ferramentas C++ — as ferramentas de compilação C++ do Visual Studio no Windows), o npm exibe o erro de compilação, ignora o módulo e conclui a instalação. O Iris então usa o SQLite integrado ao Node e informa isso: a inicialização exibe uma linha no stderr indicando o motivo, e --self-test mostra driver node: better-sqlite3 is not installed …. Para voltar a usar o driver nativo, instale-o em um ambiente com um binário pré-compilado ou uma cadeia de ferramentas (npm install better-sqlite3 no projeto; para uma instalação global, instale o Iris novamente com npm install -g @iris-eval/mcp-server quando houver uma cadeia de ferramentas disponível). A CI instala o servidor empacotado com a compilação nativa forçada a falhar em cada alteração e exige que a instalação seja concluída e que o autoteste armazene e leia um rastro usando o driver integrado. Iris mantém tudo em um único arquivo SQLite, aberto por better-sqlite3 — um complemento nativo baixado ou compilado para o seu Node e a sua plataforma. Quando esse módulo não pode ser carregado, Iris recorre ao SQLite integrado do Node (node:sqlite, Node 22.13 ou posterior) com um aviso no stderr, para que a ausência de um pré-build resulte em uma inicialização mais lenta, não em uma inicialização impossível. Iris faz o mesmo, antes de carregá-lo, com um better-sqlite3 compilado na sua máquina usando os cabeçalhos do Node 24.19 ou posterior e executado no Node 24.19 a 24.21: nessas versões, esse binário aborta todo o processo na primeira vez que libera uma instrução (Assertion failed: (env) != nullptr, nodejs/node#65446). O Node 24.22.0 inclui a correção, e Iris carrega o binário nessa versão. npm rebuild better-sqlite3 substitui-o pelo binário pré-compilado, que é seguro em todas as versões. IRIS_SQLITE_DRIVER=node escolhe o integrado intencionalmente; native proíbe o fallback. O integrado é aberto com o carregamento de extensões desativado e trusted_schema desativado; o Node imprime sua própria linha ExperimentalWarning: SQLite is an experimental feature no stderr ao carregá-lo, e Iris não a suprime. --self-test e GET /health identificam o driver em uso; todos os números na página de comprovação foram medidos com o driver nativo, e a suíte de testes é executada com ambos no CI.

Versão do Node.js

Iris requer Node.js 22.13 ou posterior. O Node 20 chegou ao fim da vida útil em 2026-04-30 e não é compatível; o Node 18 chegou ao fim da vida útil em abril de 2025.

O requisito mínimo é 22.13, e não 22.0, porque 22.13.0 é a primeira versão que inclui node:sqlite. Isso faz dela a primeira versão em que toda instalação compatível do Iris tem um segundo driver de armazenamento: quando o complemento nativo better-sqlite3 não pode ser carregado, Iris recorre ao SQLite integrado do Node em vez de falhar ao iniciar. Antes da 22.13 — e durante toda a vida útil do Node 20 — havia apenas um driver, e a ausência de um pré-build impedia a inicialização.

node --version  # Must be v22.13.0 or newer

Windows: cmd /c não é necessário

O /doctor do Claude Code pode sugerir envolver o npx com cmd /c. Isso não é necessário e causa problemas de análise de caminhos. Use npx diretamente:

# Correct
claude mcp add --transport stdio iris-eval -- npx -y @iris-eval/mcp-server

# Wrong (causes /c to be parsed as a path)
claude mcp add --transport stdio iris-eval -- cmd /c "npx -y @iris-eval/mcp-server"

Se Iris for útil para você, considere estrelar o repositório — isso ajuda outras pessoas a encontrá-lo.

Star on GitHub

Licenciado sob MIT.