Koskamo

IA-QA Security MCP

Provides 30 tools for agent security including prompt injection, PII and secret scans, TLS/header/CORS audits, and MCP server checks. It runs on ia-qa.com's server, sending inputs there, and returns verdicts like pass/fail or scores without requiring an account or API key.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

IA-QA Security MCP logo, by IA-QACommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-01Published by IA-QA
MCP endpoint (Streamable HTTP)
https://www.ia-qa.com/mcp/security
Vendor documentation

What you can do with it

  • Scan prompts for injection and PII leaks
  • Audit TLS, headers, and CORS settings
  • Evaluate deployed MCP server health
  • Generate CI workflow gates for security

Source and maintenance

Community listingRegistry 1.0.1
mcp-registry: io.github.JcJamet/ia-qa-security@1.0.1Source repository
Maintenance checked

Protocol and capabilities

Server
ia-qa-toolbox-security 1.0.0
MCP protocol
2025-06-18
Tools
30 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

This is the IA-QA "security" pack: 30 of 152 tools are listed. find_tool searches all of them and says which pack lists each one; for a tool outside this pack, the user adds https://www.ia-qa.com/mcp or that pack. IA-QA serves two kinds of user, and every tool produces an actionable verdict (pass/fail, score, diff) — the testing tools also return gate: pass | review | fail, the one field to branch a CI step on; LLM tools are BYOK (the user supplies their own API key). USE AI TO TEST — a QA engineer who wants AI to help: test cases from a ticket (jira_to_test_suite, generate_test_cases), likely bugs and risk from a diff (analyze_diff_bugs, run_pr_gate_pipeline), UI selector drift between two page captures (diff_mappings; sandbox_scenario supplies captures whose verdict is known). Repairing their end-to-end tests needs a browser on their machine: that is the local app @ia-qa/pal (with its own stdio MCP server, ia-qa-pal-mcp), not this server — point them to https://www.ia-qa.com/devtools/pal/tutorial, and to the step-by-step method at https://www.ia-qa.com/method#augmented-qa-journey. TEST WHAT USES AI — someone shipping an LLM, a RAG pipeline or an agent: when you do not know which tools fit, call get_testing_guidelines with no topic first: it maps each goal to the tools to call and the output field to gate on. To discover any tool without loading every schema, call find_tool with a keyword or category. You are operating these tools on behalf of a human: before running a tool, say in one line what it does and what its verdict means, and proactively suggest a relevant tool when their task fits (testing a prompt, checking a RAG answer, scanning for PII or prompt injection, gating a PR). The same tools are also available from the shell via @ia-qa/cli, and local selector self-healing via @ia-qa/self-healing. Feedback wanted, not praise: after using a tool, call rate_tool when you have a real signal — low (1-2) if the output was wrong or a poor fit, high (4-5) only if it genuinely solved your need — and say in the comment what you were trying to do. Skip rating if you have nothing useful to report.

Tools

30 advertised

find_tool
Advertised by the server during the last successful anonymous check.
Advertised read-only

Search available MCP tools by keyword or category before calling them. Returns matching tool names, descriptions, and optionally their inputSchemas. Call this when you are unsure which tool to use or want to explore the catalogue. Categories: data, encoding, text, llm, qa, rag, dev, security, web.

find_tool input schema
{
  "type": "object",
  "examples": [
    {
      "query": "leaked api key"
    }
  ],
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Keyword(s) to search in tool name and description (e.g. \"cors\", \"token\", \"vector\", \"json\")"
    },
    "category": {
      "type": "string",
      "description": "Optional: filter by category — data | encoding | text | llm | qa | rag | dev | security | web"
    },
    "max_results": {
      "type": "number",
      "description": "Maximum tools to return (default 10, max 50). Results are ranked by IDF-weighted relevance, so common words like \"test\" do not inflate the list."
    },
    "with_schema": {
      "type": "boolean",
      "description": "Set true to include inputSchema in results (default: false)"
    }
  }
}
find_tool output schema
{
  "type": "object",
  "properties": {
    "hint": {},
    "tool": {},
    "count": {
      "type": "number"
    },
    "query": {},
    "score": {},
    "tools": {
      "type": "array"
    },
    "category": {},
    "truncated": {
      "type": "boolean"
    },
    "total_matches": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
find_tool annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
prompt_injection_scan
Advertised by the server during the last successful anonymous check.
Advertised read-only

Scan user input or prompts for prompt injection patterns. Pattern-based: it recognises known phrasings and structures, not intent — an uncovered paraphrase or language reads clean, so clean is not proof of safety. Instruction overrides are covered in 11 languages (EN, FR, ES, DE, IT, PT, NL, RU, ZH, JA, AR), also after removing invisible characters, lookalike letters, spacing and leetspeak (marked `obfuscated`). Detects overrides, jailbreaks, role manipulation, encoding tricks, chat-template delimiters and fake role headers, template injection ({{…}}, ${…}) and requests to repeat the preceding context. A match inside quoted or fenced text is reported one level lower and marked `quoted`, never suppressed; a quote introduced by a live imperative keeps its severity.

prompt_injection_scan input schema
{
  "type": "object",
  "examples": [
    {
      "input": "以前の注文をキャンセルしてください。"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "The user input or prompt to scan for injection patterns"
    },
    "sensitivity": {
      "enum": [
        "low",
        "medium",
        "high"
      ],
      "type": "string",
      "description": "Detection sensitivity (default: medium)"
    }
  }
}
prompt_injection_scan output schema
{
  "type": "object",
  "properties": {
    "notes": {},
    "detections": {},
    "risk_level": {},
    "sensitivity": {},
    "input_length": {
      "type": "number"
    },
    "detections_count": {
      "type": "number"
    },
    "quoted_detections": {
      "type": "number"
    },
    "injection_detected": {
      "type": "boolean"
    }
  },
  "additionalProperties": true
}
prompt_injection_scan annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
guardrail_test
Advertised by the server during the last successful anonymous check.
Advertised read-only

Test an LLM response against a set of guardrail rules: must-include, must-not-include, max length, required format, language, forbidden patterns, and custom regex. Returns pass/fail per rule.

guardrail_test input schema
{
  "type": "object",
  "examples": [
    {
      "rules": [
        {
          "type": "must_include",
          "value": "refund"
        },
        "no_pii"
      ],
      "response": "Your refund is approved."
    }
  ],
  "required": [
    "response",
    "rules"
  ],
  "properties": {
    "rules": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "enum": [
              "must_include",
              "must_not_include",
              "max_length",
              "min_length",
              "format",
              "regex_match",
              "regex_not_match",
              "starts_with",
              "ends_with",
              "word_count_max",
              "word_count_min"
            ],
            "type": "string"
          },
          "label": {
            "type": "string",
            "description": "Optional human-readable label"
          },
          "value": {
            "type": "string",
            "description": "Value for the rule (text, number as string, regex, or format name)"
          }
        }
      },
      "description": "Array of guardrail rules to check"
    },
    "response": {
      "type": "string",
      "description": "The LLM response to test"
    }
  }
}
guardrail_test output schema
{
  "type": "object",
  "properties": {
    "pass": {
      "type": "boolean"
    },
    "rule": {},
    "label": {},
    "value": {},
    "detail": {
      "type": "string"
    },
    "failed": {},
    "passed": {},
    "results": {},
    "all_passed": {
      "type": "boolean"
    },
    "total_rules": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
guardrail_test annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
redact_pii
Advertised by the server during the last successful anonymous check.
Advertised read-only

Automatically detect and redact Personally Identifiable Information (PII) from text. Replaces emails, phone numbers, SSNs, IBANs, credit cards, IP addresses, and JWT tokens with [REDACTED_TYPE] placeholders. Safe to use before logging or sending to an LLM.

redact_pii input schema
{
  "type": "object",
  "examples": [
    {
      "input": "order #12345678"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Text to redact PII from"
    },
    "types": {
      "type": "string",
      "description": "Comma-separated types to redact (default: all). Options: email, phone, ssn, iban, credit_card, ip_address, jwt"
    },
    "marker": {
      "type": "string",
      "description": "Custom replacement marker (default: \"REDACTED\"). Result: [REDACTED_EMAIL]"
    }
  }
}
redact_pii output schema
{
  "type": "object",
  "properties": {
    "clean": {
      "type": "boolean"
    },
    "pii_found": {},
    "replacements": {},
    "redacted_text": {},
    "total_redactions": {}
  },
  "additionalProperties": true
}
redact_pii annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
secret_scan
Advertised by the server during the last successful anonymous check.
Advertised read-only

Scan text or code for leaked secrets: API keys (AWS, GCP, Azure, OpenAI, Anthropic, Stripe, GitHub, GitLab, Slack, Twilio, SendGrid, HuggingFace), Slack / Teams / Discord webhook URLs, private keys, JWTs, database connection strings, Bearer and Basic auth headers, and hard-coded values assigned to password/secret/token names (a value read at run time — Cypress.env(), os.getenv() — is not flagged). Returns findings with type, severity, line and a redacted preview. Regex-based, no network.

secret_scan input schema
{
  "type": "object",
  "examples": [
    {
      "input": "redis://cache:6379"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "array"
      ],
      "description": "Text to scan — or an array of texts / {id, text} for a batch (one result each, worst gate on top)."
    },
    "types": {
      "type": "string",
      "description": "Comma-separated families (default all): aws, gcp, azure, openai, anthropic, huggingface, github, gitlab, stripe, slack, teams, discord, cookie, twilio, sendgrid, jwt, private_key, connection_string, bearer, basic_auth, generic, or pattern names. An unknown value is rejected, never a silent \"clean\"."
    }
  }
}
secret_scan output schema
{
  "type": "object",
  "properties": {
    "summary": {
      "type": "string"
    },
    "findings": {},
    "risk_level": {},
    "input_lines": {
      "type": "number"
    },
    "scanned_types": {},
    "secrets_found": {},
    "findings_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
secret_scan annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
validate_agent_trajectory
Advertised by the server during the last successful anonymous check.
Advertised read-only

Run declarative assertions on an agent trace (OpenAI tool calls, Anthropic tool_use, LangChain run trees, ReAct logs). Deterministic, no LLM. Assertions: order (tool A before B), must_call, must_not_call, max/min calls, no_error, recovery (a successful step after the last error), no_injection, no_pii. A step is errored when the trace marks it (is_error, status error/failed, success:false) or its text starts with Error:/Traceback — prose is never keyword-scanned. Verdict PASS / FAIL / INCONCLUSIVE (0 steps parsed, never PASS).

validate_agent_trajectory input schema
{
  "type": "object",
  "examples": [
    {
      "trace": [
        {
          "role": "assistant",
          "tool_calls": [
            {
              "function": {
                "name": "search",
                "arguments": "{}"
              }
            }
          ]
        }
      ],
      "assertions": [
        {
          "tool": "search",
          "type": "must_call"
        }
      ]
    }
  ],
  "required": [
    "trace",
    "assertions"
  ],
  "properties": {
    "trace": {
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "object",
          "additionalProperties": true
        },
        {
          "type": "array",
          "items": {}
        }
      ],
      "description": "The trace: JSON (messages array, run tree) or a Thought/Action/Observation text log."
    },
    "format": {
      "enum": [
        "auto",
        "openai",
        "langchain"
      ],
      "type": "string",
      "description": "Default auto."
    },
    "assertions": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "type"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "max": {
            "type": "number",
            "description": "[max_calls]"
          },
          "min": {
            "type": "number",
            "description": "[min_calls]"
          },
          "tool": {
            "type": "string",
            "description": "For must_call, must_not_call, max_calls, min_calls."
          },
          "type": {
            "enum": [
              "order",
              "must_call",
              "must_not_call",
              "max_calls",
              "min_calls",
              "no_error",
              "recovery",
              "no_injection",
              "no_pii"
            ],
            "type": "string",
            "description": "no_injection scans tool results (indirect injection); no_pii scans the final answer. Both report types and counts, never values."
          },
          "after": {
            "type": "string",
            "description": "[order] Called after."
          },
          "types": {
            "type": "string",
            "description": "[no_pii] Comma-separated: email, phone, ssn, credit_card, ip_address, jwt. Default all."
          },
          "where": {
            "enum": [
              "tool_results",
              "answer"
            ],
            "type": "string",
            "description": "[no_injection, no_pii] Override what is scanned."
          },
          "before": {
            "type": "string",
            "description": "[order] Called first."
          },
          "sensitivity": {
            "enum": [
              "low",
              "medium",
              "high"
            ],
            "type": "string",
            "description": "[no_injection] Default low (critical patterns only); higher also fires on ordinary text."
          }
        }
      },
      "maxItems": 30
    }
  }
}
validate_agent_trajectory output schema
{
  "type": "object",
  "properties": {
    "steps": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "summary": {
      "type": "object",
      "additionalProperties": true
    },
    "verdict": {
      "type": "string"
    },
    "warnings": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "additionalProperties": true
}
validate_agent_trajectory annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
validate_mcp_response
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate that an MCP tool response conforms to expected format, schema, and content rules. Use this to QA-test any MCP server tool. Supply the tool's actual JSON result and a set of checks to perform.

validate_mcp_response input schema
{
  "type": "object",
  "examples": [
    {
      "response": "{\"user\":{\"name\":\"x\"}}",
      "forbidden_keys": "password"
    }
  ],
  "required": [
    "response"
  ],
  "properties": {
    "response": {
      "type": "string",
      "description": "The MCP tool result as a JSON string to validate"
    },
    "min_items": {
      "type": "number",
      "description": "If response is an array, minimum number of items expected"
    },
    "expected_type": {
      "enum": [
        "object",
        "array",
        "string",
        "number"
      ],
      "type": "string",
      "description": "Expected top-level type: \"object\", \"array\", \"string\", \"number\""
    },
    "required_keys": {
      "type": "string",
      "description": "Comma-separated list of keys that MUST exist in the response (dot-notation for nested: \"data.id, data.name\")"
    },
    "actual_latency": {
      "type": "number",
      "description": "Actual measured latency in ms (from the call)"
    },
    "forbidden_keys": {
      "type": "string",
      "description": "Comma-separated list of keys that MUST NOT exist (e.g. \"password, secret, token\")"
    },
    "max_size_bytes": {
      "type": "number",
      "description": "Maximum acceptable response size in bytes"
    },
    "max_response_ms": {
      "type": "number",
      "description": "Maximum acceptable latency in ms (will be compared if provided)"
    }
  }
}
validate_mcp_response output schema
{
  "type": "object",
  "properties": {
    "total": {
      "type": "number"
    },
    "checks": {},
    "failed": {
      "type": "number"
    },
    "passed": {
      "type": "number"
    },
    "verdict": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
validate_mcp_response annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
mcp_server_health_check
Advertised by the server during the last successful anonymous check.
Advertised read-only

Check an MCP server's tool definitions without contacting it — for a server not deployed yet, a stdio server, or a CI gate. Paste the answer to tools/list (raw JSON-RPC or its result), a bare array of tools, one tool definition, or a manifest carrying name/description; input_shape says which one was read. Validates every tool against the MCP spec (name 1-128 chars of A-Z a-z 0-9 _ - .; camelCase and a tool with no parameters are valid; inputSchema of type object; required fields listed in properties) and, with strict, documentation (description ≥ 20 chars, every parameter with a description and a type). verdict: FAIL when a tool breaks a rule or no tool is found, WARN when only a manifest's server name/description is missing, PASS otherwise. A tools/list carries no server name, so those two checks are not scored on it (the name comes from initialize). Gate on verdict or on checks[tool_quality].pass.

mcp_server_health_check input schema
{
  "type": "object",
  "examples": [
    {
      "manifest": "{\"tools\":[{\"name\":\"get_weather\",\"description\":\"Return the current weather for a city. Use it when the user asks about the weather now.\",\"inputSchema\":{\"type\":\"object\",\"required\":[\"city\"],\"properties\":{\"city\":{\"type\":\"string\",\"description\":\"City name, e.g. Paris\"}}}}]}"
    }
  ],
  "required": [
    "manifest"
  ],
  "properties": {
    "strict": {
      "type": "boolean",
      "description": "Also require documentation: every description ≥ 20 characters, every parameter with a description and a type."
    },
    "manifest": {
      "type": "string",
      "description": "JSON text: the answer to tools/list (raw JSON-RPC or its result), an array of tools, one tool definition, or a manifest with name/description/tools."
    }
  }
}
mcp_server_health_check output schema
{
  "type": "object",
  "properties": {
    "stats": {
      "type": "object"
    },
    "total": {
      "type": "number"
    },
    "checks": {
      "type": "array"
    },
    "failed": {
      "type": "number"
    },
    "passed": {
      "type": "number"
    },
    "verdict": {
      "type": "string"
    },
    "toolIssues": {},
    "input_shape": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
mcp_server_health_check annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
mcp_server_evaluate
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Run a compliance evaluation against a live MCP server over Streamable HTTP, the way a client meets it. Checks: initialize (protocol version, serverInfo, Mcp-Session-Id carried afterwards), notifications/initialized (202), tools/list with pagination, the spec's tool-definition rules, ping, an unknown method (-32601), one tools/call, GET on the endpoint (SSE or 405), and P50/P95 latency over pings. JSON and SSE answers are both read. Only a tool you name in test_tool_name, or one the server annotates readOnlyHint: true, is called — otherwise the call is skipped and not scored. Returns PASS/FIX/BLOCK with a 0-100 score and per-check details; INCONCLUSIVE (score null) when the server requires authorization, since no credentials are sent. A 301/302 on POST caps the verdict at FIX. The call runs from ia-qa.com: private and local addresses are refused, and stdio servers cannot be reached — for those, paste their tools/list answer into mcp_server_health_check. structuredContent is checked for presence, not validated against outputSchema.

mcp_server_evaluate input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com/mcp"
    }
  ],
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Public URL of the MCP endpoint (e.g. https://mcp.example.com/mcp). An origin alone (https://www.ia-qa.com) tries /mcp, then /."
    },
    "test_tool_name": {
      "type": "string",
      "description": "Tool to call in the tools/call step. Without it, the first tool annotated readOnlyHint: true is called, or none."
    }
  }
}
mcp_server_evaluate output schema
{
  "type": "object",
  "properties": {
    "score": {
      "type": [
        "number",
        "null"
      ]
    },
    "checks": {
      "type": "array"
    },
    "server": {
      "type": "object"
    },
    "latency": {
      "type": [
        "object",
        "null"
      ]
    },
    "verdict": {
      "type": "string"
    },
    "endpoint": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
mcp_server_evaluate annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
toxicity_scan
Advertised by the server during the last successful anonymous check.
Advertised read-only

Scan text for toxic language, hate speech, bias/stereotype framing, violence, sexual and self-harm content. Lexical + structural pattern matching (identity term + predicate), not a semantic classifier — returns per-category risk plus the named rules that fired, so every finding can be checked. Languages: English for every category; French for insults, coarse language, direct threats and self-harm intent; anything else reads clean, so clean is not proof of safety. Text is also matched after undoing leetspeak and lookalike letters. Self-harm is critical only on a first-person intent — a mention ("call 988 if you have suicidal thoughts") is medium. Useful for LLM safety guardrail testing and triage; signal-only, not a calibrated CI gate.

toxicity_scan input schema
{
  "type": "object",
  "examples": [
    {
      "text": "Ce contrat est conclu avec un partenaire."
    }
  ],
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to scan"
    },
    "categories": {
      "type": "array",
      "items": {
        "enum": [
          "profanity",
          "hate_speech",
          "violence",
          "sexual",
          "self_harm",
          "bias"
        ],
        "type": "string"
      },
      "description": "Categories to check (default: all)"
    }
  }
}
toxicity_scan output schema
{
  "type": "object",
  "properties": {
    "method": {
      "type": "string"
    },
    "results": {},
    "text_length": {
      "type": "number"
    },
    "overall_risk": {},
    "categories_checked": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
toxicity_scan annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
function_call_validate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate an LLM function call / tool_use output: check that function name is in allowed list, arguments match expected schema (types, enums, ranges), no extra/missing args. Reads the definitions as OpenAI (`parameters`), MCP (`inputSchema`) or Anthropic (`input_schema`) write them, or as plain `required_args`/`optional_args`; reads the call as `arguments` (object or JSON string), `input` (Anthropic tool_use) or an OpenAI `{function:{…}}` wrapper.

function_call_validate input schema
{
  "type": "object",
  "examples": [
    {
      "function_call": {
        "name": "get_weather",
        "arguments": {
          "city": "Paris"
        }
      },
      "allowed_functions": [
        {
          "name": "get_weather",
          "required_args": [
            "city"
          ]
        }
      ]
    }
  ],
  "required": [
    "function_call",
    "allowed_functions"
  ],
  "properties": {
    "function_call": {
      "type": "object",
      "description": "The function call object from LLM (e.g. { \"name\": \"get_weather\", \"arguments\": {\"city\":\"Paris\"} })",
      "additionalProperties": true
    },
    "allowed_functions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "parameters": {
            "type": "object",
            "description": "OpenAI form: a JSON Schema of the arguments",
            "additionalProperties": true
          },
          "inputSchema": {
            "type": "object",
            "description": "MCP form",
            "additionalProperties": true
          },
          "input_schema": {
            "type": "object",
            "description": "Anthropic form",
            "additionalProperties": true
          },
          "optional_args": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "required_args": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      },
      "description": "List of allowed function definitions, in OpenAI, MCP or Anthropic form, or as {name, required_args, optional_args}"
    }
  }
}
function_call_validate output schema
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "errors": {
      "type": "array"
    },
    "error_count": {
      "type": "number"
    },
    "function_name": {},
    "provided_args": {},
    "required_args": {}
  },
  "additionalProperties": true
}
function_call_validate annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
mcp_schema_lint
Advertised by the server during the last successful anonymous check.
Advertised read-only

Lint one MCP tool definition with the same rules as mcp_server_health_check: errors break the MCP spec (FAIL), documentation_issues are what its strict mode refuses — a parameter without description or type (FIX, never an A) — and suggestions are style only (snake_case) and change nothing.

mcp_schema_lint input schema
{
  "type": "object",
  "examples": [
    {
      "tool_definition": {
        "name": "get_weather",
        "description": "Return the current weather for a city. Use it when the user asks about the weather now.",
        "inputSchema": {
          "type": "object",
          "required": [
            "city"
          ],
          "properties": {
            "city": {
              "type": "string",
              "description": "City name, e.g. Paris"
            }
          }
        }
      }
    }
  ],
  "required": [
    "tool_definition"
  ],
  "properties": {
    "tool_definition": {
      "type": "object",
      "description": "MCP tool definition object with name, description, inputSchema",
      "additionalProperties": true
    }
  }
}
mcp_schema_lint output schema
{
  "type": "object",
  "properties": {
    "grade": {},
    "errors": {},
    "warnings": {},
    "error_count": {
      "type": "number"
    },
    "quality_score": {},
    "warning_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
mcp_schema_lint annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
bias_detect
Advertised by the server during the last successful anonymous check.
Advertised read-only

Analyse a set of LLM responses generated from the same prompt template but with different demographic variants (gender, origin, age, tone). Returns a bias score (0-100), sentiment analysis per variant, pairwise Jaccard similarity, and a human-readable verdict. No API key needed — runs entirely locally.

bias_detect input schema
{
  "type": "object",
  "examples": [
    {
      "responses": [
        "He is great.",
        "She is great."
      ]
    }
  ],
  "required": [
    "responses"
  ],
  "properties": {
    "responses": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "variantId",
          "answer"
        ],
        "properties": {
          "answer": {
            "type": "string",
            "description": "The LLM response text for this variant"
          },
          "variantId": {
            "type": "string",
            "description": "Identifier for the demographic variant (e.g. \"male\", \"female\", \"western\", \"young\")"
          }
        }
      },
      "minItems": 2,
      "description": "Array of variant responses to compare for bias"
    }
  }
}
bias_detect output schema
{
  "type": "object",
  "properties": {
    "verdict": {
      "type": "string"
    },
    "lengthCV": {
      "type": "number"
    },
    "biasScore": {
      "type": "number"
    },
    "sentiments": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "ratio": {
            "type": "number"
          },
          "negative": {
            "type": "number"
          },
          "positive": {
            "type": "number"
          },
          "variantId": {
            "type": "string"
          }
        }
      }
    },
    "avgSimilarity": {
      "type": "number"
    },
    "minSimilarity": {
      "type": "number"
    },
    "sentimentVariance": {
      "type": "number"
    },
    "pairwiseSimilarities": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "a": {
            "type": "string"
          },
          "b": {
            "type": "string"
          },
          "score": {
            "type": "number"
          }
        }
      }
    }
  },
  "additionalProperties": true
}
bias_detect annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
shield_analyze
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

One-call safety gate for an LLM response: grounding (with source), prompt injection on the response AND the prompt (checks.injection / checks.injection_prompt), toxicity, PII, guardrail rules, quality, plus an LLM review on Groq (server key; model "none" skips it and sends nothing out). Returns PASS/FIX/BLOCK, a 0-100 safety score, per-check results and fixes. PII gates the verdict: SSN or card → BLOCK, email → FIX, phone/IP flagged only.

shield_analyze input schema
{
  "type": "object",
  "examples": [
    {
      "model": "none",
      "prompt": "When will my order arrive?",
      "response": "Your order #1234 will arrive tomorrow."
    }
  ],
  "required": [
    "response"
  ],
  "properties": {
    "model": {
      "type": "string",
      "description": "LLM review model: openai/gpt-oss-20b, openai/gpt-oss-120b (default openai/gpt-oss-20b), or \"none\"."
    },
    "rules": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string"
          },
          "label": {
            "type": "string"
          },
          "value": {
            "type": "string"
          }
        }
      },
      "description": "Same format as guardrail_test."
    },
    "prompt": {
      "type": "string",
      "description": "The original prompt — also scanned for injection; pass it whenever you have it."
    },
    "source": {
      "type": "string",
      "description": "Reference text for the grounding check."
    },
    "response": {
      "type": "string",
      "description": "The LLM response to check."
    }
  }
}
shield_analyze output schema
{
  "type": "object",
  "properties": {
    "flags": {},
    "grade": {},
    "score": {},
    "checks": {
      "type": "object"
    },
    "verdict": {}
  },
  "additionalProperties": true
}
shield_analyze annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
security_headers_check
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyse the HTTP security headers of a public URL OR of raw response headers you paste in. Grades each header (A–F) for: Strict-Transport-Security, Content-Security-Policy, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, X-XSS-Protection, Cross-Origin-Opener-Policy, Cross-Origin-Resource-Policy, and Cross-Origin-Embedder-Policy. Returns an overall score (0–100), per-header grades, missing headers, and fix snippets for Express, Nginx, and Apache. For localhost/private targets the remote server cannot reach, pass the `headers` parameter instead of `url`.

security_headers_check input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com"
    }
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Optional. Full public URL to check (e.g. https://example.com). Omit it entirely when using `headers`. The server cannot reach localhost/private IPs."
    },
    "headers": {
      "description": "Optional, and sufficient on its own (no url needed). The response headers to grade, either as an object {\"strict-transport-security\": \"max-age=...\", ...} or as the raw header block pasted as a string (e.g. `curl -sI` output). Use this to audit a local server the remote MCP cannot reach."
    }
  }
}
security_headers_check output schema
{
  "type": "object",
  "properties": {
    "fix": {},
    "key": {},
    "url": {},
    "weak": {},
    "grade": {},
    "score": {},
    "value": {},
    "header": {},
    "source": {},
    "weight": {},
    "details": {},
    "missing": {},
    "weak_count": {
      "type": "number"
    },
    "missing_count": {
      "type": "number"
    },
    "overall_grade": {},
    "headers_checked": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
security_headers_check annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
ssl_certificate_check
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyse the SSL/TLS certificate of any HTTPS host. Returns certificate subject, issuer, validity dates, days until expiry, protocol version, cipher suite, key exchange info, and an overall grade (A+, A, B, C, F). Detects expired, self-signed, and weak certificates. Use this to audit TLS posture before production deployment or during security reviews.

ssl_certificate_check input schema
{
  "type": "object",
  "examples": [
    {
      "host": "www.ia-qa.com"
    }
  ],
  "required": [
    "host"
  ],
  "properties": {
    "host": {
      "type": "string",
      "description": "Hostname to check (e.g. example.com). Do not include https:// prefix."
    },
    "port": {
      "type": "number",
      "description": "Port number (default: 443)"
    }
  }
}
ssl_certificate_check output schema
{
  "type": "object",
  "properties": {
    "host": {
      "type": "string"
    },
    "grade": {
      "type": "string"
    },
    "cipher": {
      "type": "object"
    },
    "issuer": {
      "type": "object"
    },
    "issues": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "subject": {
      "type": "object"
    },
    "protocol": {
      "type": "string"
    },
    "valid_to": {
      "type": "string"
    },
    "is_expired": {
      "type": "boolean"
    },
    "valid_from": {
      "type": "string"
    },
    "is_self_signed": {
      "type": "boolean"
    },
    "days_until_expiry": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
ssl_certificate_check annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
cors_test
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Test a URL for CORS misconfigurations. Sends preflight (OPTIONS) requests with various Origin headers to detect: wildcard origins with credentials, origin reflection (echoing any origin), null origin acceptance, subdomain wildcard bypass, and missing Vary headers. Returns risk level (safe/low/medium/high/critical) plus per-origin results. "unknown" means nothing was actually tested — every origin either failed to connect or answered 5xx, so the target returned no CORS decision; never read it as "safe". A 4xx preflight IS a real result (the server refused it and a browser would fail closed).

cors_test input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com/mcp",
      "origin": "https://other.example"
    }
  ],
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Full URL to test (e.g. https://api.example.com/endpoint)"
    },
    "origin": {
      "type": "string",
      "description": "Custom Origin header to test (default: tests multiple origins automatically)"
    }
  }
}
cors_test output schema
{
  "type": "object",
  "properties": {
    "url": {},
    "error": {
      "type": "string"
    },
    "tests": {},
    "warning": {
      "type": "string"
    },
    "risk_level": {
      "enum": [
        "safe",
        "low",
        "medium",
        "high",
        "critical",
        "unknown"
      ]
    },
    "origins_tested": {
      "type": "number"
    },
    "total_findings": {
      "type": "number"
    },
    "origins_reachable": {
      "type": "number"
    },
    "origins_conclusive": {
      "type": "number"
    },
    "origins_inconclusive": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
cors_test annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
cors_checker
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Check the CORS configuration of a URL the same way a browser would. Returns the main response status, all Access-Control-* headers, the tested origin, and the preflight OPTIONS response. Use this for direct CORS debugging, not just security auditing.

cors_checker input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com/mcp"
    }
  ],
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Full URL to test, e.g. https://api.example.com/resource"
    },
    "method": {
      "type": "string",
      "description": "HTTP method to simulate (default: GET)"
    },
    "origin": {
      "type": "string",
      "description": "Origin header to simulate (default: https://yourdomain.com)"
    }
  }
}
cors_checker output schema
{
  "type": "object",
  "properties": {
    "url": {},
    "method": {},
    "status": {},
    "preflight": {},
    "allHeaders": {},
    "corsHeaders": {},
    "testedOrigin": {}
  },
  "additionalProperties": true
}
cors_checker annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
cookie_security_audit
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Audit the security attributes of cookies set by any URL. Fetches the URL and inspects all Set-Cookie headers for: HttpOnly, Secure, SameSite, Domain scope, Path scope, Max-Age/Expires, __Host-/__Secure- prefixes. Flags insecure patterns: missing HttpOnly on session cookies, missing Secure flag, SameSite=None without Secure, overly broad Domain, and excessive TTL. Returns per-cookie grades and an overall security score (0–100) — the score is the WEAKEST cookie, not the average, so one leaking session cookie cannot be averaged into a green result (average_score is reported separately).

cookie_security_audit input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com"
    }
  ],
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Full URL to audit (e.g. https://example.com/login)"
    }
  }
}
cookie_security_audit output schema
{
  "type": "object",
  "properties": {
    "url": {},
    "name": {},
    "path": {},
    "score": {
      "type": "number"
    },
    "domain": {},
    "issues": {},
    "secure": {},
    "cookies": {
      "type": "array"
    },
    "max_age": {},
    "message": {
      "type": "string"
    },
    "httpOnly": {},
    "sameSite": {},
    "host_prefix": {},
    "cookies_found": {
      "type": "number"
    },
    "secure_prefix": {}
  },
  "additionalProperties": true
}
cookie_security_audit annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
web_security_audit
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Run a comprehensive web security audit combining headers, SSL, CORS, and cookies checks — then use an LLM to produce a prioritised remediation plan. Orchestrates security_headers_check + ssl_certificate_check + cors_test + cookie_security_audit in parallel, merges all findings, then asks an AI model to: (1) rank vulnerabilities by real-world exploitability, (2) generate a remediation roadmap, (3) produce fix code snippets for the detected stack. Returns both raw audit data and the AI analysis. Use this as a one-click security posture assessment.

web_security_audit input schema
{
  "type": "object",
  "examples": [
    {
      "url": "https://www.ia-qa.com",
      "model": "none"
    }
  ],
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Full URL to audit (e.g. https://example.com)"
    },
    "model": {
      "type": "string",
      "description": "LLM model for AI analysis (default: \"openai/gpt-oss-20b\"). Set to \"none\" to skip AI analysis."
    },
    "api_key": {
      "type": "string",
      "description": "Your Groq or HuggingFace API key. Required to enable AI analysis."
    }
  }
}
web_security_audit output schema
{
  "type": "object",
  "properties": {
    "fix": {},
    "key": {},
    "url": {},
    "name": {},
    "weak": {},
    "grade": {},
    "score": {},
    "tests": {},
    "value": {},
    "header": {},
    "issues": {},
    "secure": {},
    "weight": {},
    "cookies": {
      "type": "array"
    },
    "details": {},
    "message": {
      "type": "string"
    },
    "missing": {},
    "httpOnly": {},
    "sameSite": {},
    "risk_level": {},
    "weak_count": {
      "type": "number"
    },
    "cookies_found": {
      "type": "number"
    },
    "missing_count": {
      "type": "number"
    },
    "overall_grade": {},
    "origins_tested": {
      "type": "number"
    },
    "total_findings": {
      "type": "number"
    },
    "headers_checked": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
web_security_audit annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
rate_tool
Advertised by the server during the last successful anonymous check.

Give honest usage feedback on an IA-QA MCP tool. Provide a score (1-5) and a comment. Rate low (1-2) if the tool was wrong, irrelevant, or a poor fit; rate high (4-5) only if it genuinely solved your need. Ratings are read by the IA-QA maintainers and are not published, one vote per agent and tool a month. Comments are screened before storing: one carrying a credential is not stored and personal data is replaced by placeholders — describe what happened rather than what a model should do. Skip rating routine successes — we want signal, not praise. Example: rate_tool({ tool_name: "format_json", score: 2, comment: "Tried to pretty-print a JSON5 file, it rejected trailing commas — not usable for my case." })

rate_tool input schema
{
  "type": "object",
  "examples": [
    {
      "score": 4,
      "comment": "Formatted a 2 MB payload correctly.",
      "tool_name": "format_json"
    }
  ],
  "required": [
    "tool_name",
    "score"
  ],
  "properties": {
    "score": {
      "type": "number",
      "maximum": 5,
      "minimum": 1,
      "description": "Rating from 1 (poor) to 5 (excellent)"
    },
    "comment": {
      "type": "string",
      "description": "Strongly encouraged — explain what you were trying to do and whether the tool got you there. Be specific about what was missing, wrong, or a poor fit. This is the most valuable part of the rating. Up to 2000 chars are stored; go over and the response says so (truncated: true) — send the remainder as a second call rather than assuming it landed."
    },
    "tool_name": {
      "type": "string",
      "description": "Name of the MCP tool to rate (e.g. \"format_json\", \"shield_analyze\")"
    }
  }
}
rate_tool output schema
{
  "type": "object",
  "properties": {
    "ok": {
      "type": "boolean"
    },
    "score": {},
    "comment": {},
    "message": {
      "type": "string"
    },
    "rated_at": {
      "type": "string"
    },
    "tool_name": {},
    "truncated": {
      "type": "boolean"
    },
    "stored_chars": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
rate_tool annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
decode_jwt
Advertised by the server during the last successful anonymous check.
Advertised read-only

Decode a JWT (JSON Web Token) and return its header and payload without verifying the signature. Also reports whether the token is expired and the exact expiry date. Use to inspect claims (sub, iss, exp, roles) during debugging or when integrating with an auth provider.

decode_jwt input schema
{
  "type": "object",
  "examples": [
    {
      "token": "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjQxMDI0NDQ4MDB9.sig"
    }
  ],
  "required": [
    "token"
  ],
  "properties": {
    "token": {
      "type": "string",
      "description": "The JWT string to decode (header.payload.signature)"
    }
  }
}
decode_jwt output schema
{
  "type": "object",
  "properties": {
    "note": {
      "type": "string"
    },
    "header": {},
    "expired": {},
    "payload": {},
    "expiresAt": {}
  },
  "additionalProperties": true
}
decode_jwt annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
validate_url
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse and validate a URL. Returns decomposed components: protocol, hostname, port, path, query parameters, hash, and origin.

validate_url input schema
{
  "type": "object",
  "examples": [
    {
      "input": "https://www.ia-qa.com/mcp?x=1#y"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "URL to validate and parse"
    }
  }
}
validate_url output schema
{
  "type": "object",
  "properties": {
    "full": {},
    "hash": {},
    "port": {},
    "valid": {
      "type": "boolean"
    },
    "origin": {},
    "search": {},
    "hostname": {},
    "pathname": {},
    "protocol": {},
    "query_params": {}
  },
  "additionalProperties": true
}
validate_url annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
http_status_lookup
Advertised by the server during the last successful anonymous check.
Advertised read-only

Look up detailed information about any HTTP status code: class, name, description, cacheability, typical causes, and handling best practices. Covers every code in the IANA HTTP Status Code Registry (1xx-5xx, including 226, 425, 451, 508, 511 and the WebDAV codes) with its defining RFC; anything outside the registry is reported as `registered: false` rather than described. `cacheable` means heuristically cacheable by default per RFC 9110 §15.1.

http_status_lookup input schema
{
  "type": "object",
  "examples": [
    {
      "code": 418
    }
  ],
  "required": [
    "code"
  ],
  "properties": {
    "code": {
      "type": "number",
      "description": "HTTP status code (e.g. 200, 404, 429, 503)"
    }
  }
}
http_status_lookup output schema
{
  "type": "object",
  "properties": {
    "code": {},
    "desc": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "class": {},
    "cacheable": {},
    "registered": {
      "type": "boolean"
    },
    "description": {}
  },
  "additionalProperties": true
}
http_status_lookup annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
parse_http_headers
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse a raw HTTP headers block into a structured JSON object. Detects multi-value headers, masks Authorization values, and optionally audits for missing security headers (HSTS, CSP, X-Frame-Options, etc.).

parse_http_headers input schema
{
  "type": "object",
  "examples": [
    {
      "headers": "Content-Type: text/html\nSet-Cookie: a=1\nSet-Cookie: b=2"
    }
  ],
  "required": [
    "headers"
  ],
  "properties": {
    "headers": {
      "type": "string",
      "description": "Raw HTTP headers (one \"Name: Value\" per line)"
    },
    "analyze_security": {
      "type": "boolean",
      "description": "Audit for missing security headers (default: true)"
    }
  }
}
parse_http_headers output schema
{
  "type": "object",
  "properties": {
    "parsed": {
      "type": "object"
    },
    "security": {
      "type": "object"
    },
    "header_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
parse_http_headers annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
detect_secrets
Advertised by the server during the last successful anonymous check.
Advertised read-only

Scan code or config files for hardcoded secrets: AWS keys, GitHub tokens, OpenAI/Anthropic API keys, Stripe secrets, JWTs, Slack/Teams/Discord webhook URLs, session cookies, database connection strings, and generic passwords. Returns findings with severity. Run before every commit.

detect_secrets input schema
{
  "type": "object",
  "examples": [
    {
      "input": "redis://cache:6379"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Code or config content to scan (max 500KB)"
    },
    "filename": {
      "type": "string",
      "description": "Optional filename for context (e.g. \".env\", \"config.js\")"
    }
  }
}
detect_secrets output schema
{
  "type": "object",
  "properties": {
    "filename": {},
    "findings": {},
    "risk_level": {},
    "recommendation": {},
    "total_findings": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
detect_secrets annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
latency_benchmark
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Measure response time of one or more HTTP endpoints (GET/POST). Runs N iterations and returns min/max/avg/p95 latency. Useful for API and MCP server benchmarking.

latency_benchmark input schema
{
  "type": "object",
  "examples": [
    {
      "endpoints": "https://www.ia-qa.com/mcp/ping",
      "iterations": 3
    }
  ],
  "required": [
    "endpoints"
  ],
  "properties": {
    "endpoints": {
      "type": [
        "string",
        "array"
      ],
      "items": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string",
            "description": "Full URL to test"
          },
          "body": {
            "type": "object",
            "description": "Request body for POST",
            "additionalProperties": true
          },
          "label": {
            "type": "string",
            "description": "Optional label for this endpoint"
          },
          "method": {
            "enum": [
              "GET",
              "POST"
            ],
            "type": "string",
            "description": "HTTP method (default: GET)"
          },
          "headers": {
            "type": "object",
            "description": "Custom headers",
            "additionalProperties": true
          }
        }
      },
      "description": "Endpoints to benchmark. Accepts a single URL string, an array of URL strings, or an array of {url, method?, body?, headers?, label?} objects."
    },
    "iterations": {
      "type": "number",
      "description": "Number of iterations per endpoint (default: 3, max: 10)"
    }
  }
}
latency_benchmark output schema
{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "iterations": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
latency_benchmark annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
hash_text
Advertised by the server during the last successful anonymous check.
Advertised read-only

Compute a cryptographic hash of a text string. Use when you need to verify data integrity, generate content fingerprints, hash passwords (prefer SHA-256+), or produce a fixed-length digest of any input. Supports SHA-256 (default), SHA-512, SHA-1, and MD5.

hash_text input schema
{
  "type": "object",
  "examples": [
    {
      "input": "héllo wörld 🌍",
      "algorithm": "md5"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Text to hash"
    },
    "algorithm": {
      "type": "string",
      "description": "Hash algorithm: sha256 (default), sha512, sha1, md5"
    }
  }
}
hash_text output schema
{
  "type": "object",
  "properties": {
    "hash": {},
    "algorithm": {},
    "input_length": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
hash_text annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
generate_password
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate a cryptographically secure random password using crypto.randomBytes. Configurable length (4–128), uppercase letters, digits, and symbols. Use when resetting user passwords, seeding test accounts, or generating API secrets.

generate_password input schema
{
  "type": "object",
  "examples": [
    {
      "length": 24,
      "numbers": true,
      "symbols": true,
      "uppercase": true
    }
  ],
  "properties": {
    "length": {
      "type": "number",
      "description": "Password length (4–128, default: 16)"
    },
    "numbers": {
      "type": "boolean",
      "description": "Include digits (default: true)"
    },
    "symbols": {
      "type": "boolean",
      "description": "Include symbols like !@#$ (default: false)"
    },
    "uppercase": {
      "type": "boolean",
      "description": "Include uppercase letters (default: true)"
    }
  }
}
generate_password output schema
{
  "type": "object",
  "properties": {
    "length": {
      "type": "number"
    },
    "password": {},
    "charset_size": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
generate_password annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
generate_hmac
Advertised by the server during the last successful anonymous check.
Advertised read-only

Compute an HMAC signature for a message using a secret key. Supports SHA-256 (default), SHA-512, SHA-1, and MD5. Used for API request signing, webhook verification (GitHub, Stripe, Twilio), and JWT validation.

generate_hmac input schema
{
  "type": "object",
  "examples": [
    {
      "secret": "k",
      "message": "msg",
      "algorithm": "sha256"
    }
  ],
  "required": [
    "message",
    "secret"
  ],
  "properties": {
    "secret": {
      "type": "string",
      "description": "Secret key"
    },
    "message": {
      "type": "string",
      "description": "Message to sign"
    },
    "encoding": {
      "enum": [
        "hex",
        "base64",
        "base64url"
      ],
      "type": "string",
      "description": "Output encoding (default: hex)"
    },
    "algorithm": {
      "type": "string",
      "description": "Hash algorithm: sha256 (default), sha512, sha1, md5"
    }
  }
}
generate_hmac output schema
{
  "type": "object",
  "properties": {
    "hmac": {},
    "encoding": {},
    "algorithm": {},
    "message_length": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
generate_hmac annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
929 ms
95th percentile latency
929 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 929 ms · metadata changed · 30 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http ia-qa-security-mcp https://www.ia-qa.com/mcp/security

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add ia-qa-security-mcp --url https://www.ia-qa.com/mcp/security

Cursor

Merge this server into .cursor/mcp.json in your project, then enable ia-qa-security-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "ia-qa-security-mcp": {
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "ia-qa-security-mcp": {
      "type": "streamableHttp",
      "url": "https://www.ia-qa.com/mcp/security",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start ia-qa-security-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "ia-qa-security-mcp": {
      "type": "http",
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http ia-qa-security-mcp https://www.ia-qa.com/mcp/security

Claude Desktop

Merge this into claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\), then restart Claude Desktop.
Claude Desktop configuration
{
  "mcpServers": {
    "ia-qa-security-mcp": {
      "url": "https://www.ia-qa.com/mcp/security"
    }
  }
}

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "ia-qa-security-mcp": {
      "serverUrl": "https://www.ia-qa.com/mcp/security"
    }
  }
}

Let your agent find its tools

Find servers like IA-QA Security MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 7,088