Koskamo

IA-QA MCP Data

A community-hosted MCP server providing 36 data utilities for AI agents, including JSON/YAML/CSV parsing, schema validation, encoding, and text/time manipulation tools. It operates as a free, no-key service where calls run on ia-qa.com's server.

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 MCP Data 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/data
Vendor documentation

What you can do with it

  • Validate JSON, YAML, or CSV data structures against schemas
  • Parse and manipulate text and time formats
  • Encode and decode data formats
  • Find specific tools using keyword search

Source and maintenance

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

Protocol and capabilities

Server
ia-qa-toolbox-data 1.0.0
MCP protocol
2025-06-18
Tools
36 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 "data" pack: 36 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

36 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
}
diff_text
Advertised by the server during the last successful anonymous check.
Advertised read-only

Compute a unified line-by-line diff between two text strings (LCS algorithm). Returns added/removed/unchanged line counts and formatted diff hunks with configurable context lines (0–20). Use to compare versions of prompts, configs, code snippets, or any text where you need to see exactly what changed.

diff_text input schema
{
  "type": "object",
  "examples": [
    {
      "a": "a\nb\nc",
      "b": "a\nB\nc"
    }
  ],
  "required": [
    "a",
    "b"
  ],
  "properties": {
    "a": {
      "type": "string",
      "description": "Original (before) text"
    },
    "b": {
      "type": "string",
      "description": "Modified (after) text"
    },
    "context": {
      "type": "number",
      "description": "Context lines around each change (0–20, default: 3)"
    }
  }
}
diff_text output schema
{
  "type": "object",
  "properties": {
    "diff": {
      "type": "string"
    },
    "added": {
      "type": "number"
    },
    "removed": {
      "type": "number"
    },
    "unchanged": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
diff_text annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "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
}
validate_email
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate an email address against RFC 5322 syntax before storing it, sending a transactional email, or adding it to a mailing list. Returns { valid, email } — use this to avoid bounces and malformed data.

validate_email input schema
{
  "type": "object",
  "examples": [
    {
      "email": "john.doe@example.com"
    }
  ],
  "required": [
    "email"
  ],
  "properties": {
    "email": {
      "type": "string",
      "description": "Email address to validate"
    }
  }
}
validate_email output schema
{
  "type": "object",
  "properties": {
    "email": {},
    "valid": {
      "type": "boolean"
    },
    "reason": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
validate_email annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "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
}
timestamp_convert
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert between Unix timestamps (seconds or milliseconds) and ISO-8601 / UTC date strings. Auto-detects epoch vs. millisecond format. Omit input to get the current time. Returns iso, unix_s, unix_ms, utc, date, and time fields.

timestamp_convert input schema
{
  "type": "object",
  "examples": [
    {
      "input": 0
    }
  ],
  "properties": {
    "input": {
      "description": "Unix timestamp (number, seconds or ms) or ISO date string. Omit to get the current time."
    }
  }
}
timestamp_convert output schema
{
  "type": "object",
  "properties": {
    "iso": {
      "type": "string"
    },
    "utc": {
      "type": "string"
    },
    "date": {
      "type": "string"
    },
    "time": {
      "type": "string"
    },
    "unix_s": {
      "type": "number"
    },
    "unix_ms": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
timestamp_convert annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
cron_parse
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse a cron expression into a human-readable schedule description. Supports standard 5-field cron (minute hour day month weekday).

cron_parse input schema
{
  "type": "object",
  "examples": [
    {
      "expression": "*/5 * * * *"
    }
  ],
  "required": [
    "expression"
  ],
  "properties": {
    "expression": {
      "type": "string",
      "description": "Cron expression (e.g., \"0 9 * * 1-5\", \"*/15 * * * *\")"
    }
  }
}
cron_parse output schema
{
  "type": "object",
  "properties": {
    "fields": {
      "type": "object"
    },
    "expression": {},
    "human_readable": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
cron_parse annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
count_code_lines
Advertised by the server during the last successful anonymous check.
Advertised read-only

Count lines of code: total, code lines, comment lines, blank lines, and comment density. Supports JS/TS, Python, Java/C/C++, Ruby, Go, Shell, HTML/XML, and CSS.

count_code_lines input schema
{
  "type": "object",
  "examples": [
    {
      "input": "// c\nconst a = 1; // x\n\n/* b\n c */\nlet b;",
      "language": "javascript"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Source code to analyze"
    },
    "language": {
      "type": "string",
      "description": "Language hint: \"js\", \"ts\", \"py\", \"java\", \"c\", \"rb\", \"go\", \"sh\", \"html\", \"css\" (auto-detect if omitted)"
    }
  }
}
count_code_lines output schema
{
  "type": "object",
  "properties": {
    "language": {},
    "code_lines": {},
    "blank_lines": {},
    "total_lines": {},
    "comment_lines": {},
    "comment_density": {},
    "code_to_comment_ratio": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
count_code_lines annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
lint_commit_message
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate a git commit message against the Conventional Commits spec (feat, fix, docs, style, refactor, test, chore, ci, perf, build). Returns compliance score, breaking change detection, and actionable suggestions.

lint_commit_message input schema
{
  "type": "object",
  "examples": [
    {
      "message": "feat!: drop node 18"
    }
  ],
  "required": [
    "message"
  ],
  "properties": {
    "strict": {
      "type": "boolean",
      "description": "Enforce strict rules: max 72-char subject, imperative mood check (default: false)"
    },
    "message": {
      "type": "string",
      "description": "Git commit message to validate"
    }
  }
}
lint_commit_message output schema
{
  "type": "object",
  "properties": {
    "type": {},
    "scope": {},
    "score": {
      "type": "number"
    },
    "valid": {
      "type": "boolean"
    },
    "checks": {},
    "subject": {},
    "has_body": {
      "type": "boolean"
    },
    "is_breaking_change": {
      "type": "boolean"
    }
  },
  "additionalProperties": true
}
lint_commit_message annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
env_parse
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse a .env file content into a JSON object. Handles quoted values (single and double), inline comments, export prefix, and escaped sequences (\n, \t inside double quotes). Returns all key-value pairs. Use in CI/CD pipelines, agent config loaders, or when processing dotenv files programmatically.

env_parse input schema
{
  "type": "object",
  "examples": [
    {
      "input": "PORT=3000"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": ".env file content to parse (e.g. the output of `cat .env`)"
    }
  }
}
env_parse output schema
{
  "type": "object",
  "properties": {
    "vars": {},
    "count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
env_parse annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
openapi_validate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate the structure of an OpenAPI 3.x specification (JSON or YAML). Checks required top-level fields (openapi, info.title, info.version, paths), validates each operation (responses, operationId uniqueness), detects undeclared $ref components, and flags missing 2xx responses. Returns a PASS/FAIL verdict, a 0–100 compliance score, and a list of errors and warnings with JSON-pointer locations. Use before publishing an API spec or generating SDK code.

openapi_validate input schema
{
  "type": "object",
  "examples": [
    {
      "input": {
        "info": {
          "title": "t",
          "version": "1"
        },
        "paths": {
          "/a": {
            "get": {
              "responses": {
                "200": {
                  "description": "ok"
                }
              },
              "operationId": "getA"
            }
          }
        },
        "openapi": "3.0.3"
      }
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The OpenAPI 3.x spec — a JSON string, a YAML string, or the already-parsed spec object."
    }
  }
}
openapi_validate output schema
{
  "type": "object",
  "properties": {
    "score": {
      "type": "number"
    },
    "stats": {
      "type": "object"
    },
    "errors": {},
    "verdict": {},
    "warnings": {}
  },
  "additionalProperties": true
}
openapi_validate annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
generate_slug
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert any string into a URL-friendly slug: lowercase, ASCII-normalized (é→e), special characters removed, spaces replaced with hyphens. Use for generating SEO-friendly URL paths, file names, or identifier keys from user-provided titles or labels.

generate_slug input schema
{
  "type": "object",
  "examples": [
    {
      "input": "Héllo Wörld 2026"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "String to slugify"
    },
    "separator": {
      "type": "string",
      "description": "Separator character (default: \"-\")"
    }
  }
}
generate_slug output schema
{
  "type": "object",
  "properties": {
    "slug": {}
  },
  "additionalProperties": true
}
generate_slug annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
format_json
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate and pretty-print a string that is ALREADY valid JSON. Strict by design — it is a validity gate: valid JSON comes back formatted, anything else is rejected with the exact parse error. It never repairs, completes, or guesses. NOT for: plain text or prose (will fail), JSON embedded in markdown/prose (use extract_json_from_text first), JS objects (JSON.stringify them first), YAML (use yaml_to_json).

format_json input schema
{
  "type": "object",
  "examples": [
    {
      "input": "{\"a\":1,\"b\":{\"a\":2}}"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "A raw JSON string, e.g. '{\"key\":\"value\"}'. Must already parse as JSON — plain text or truncated JSON is rejected, not repaired."
    },
    "indent": {
      "type": "number",
      "description": "Indent size (default: 2)"
    }
  }
}
format_json output schema
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "formatted": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
format_json annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
parse_csv
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse a CSV string into a JSON array of objects (or raw arrays). Full RFC 4180: quoted fields may contain the delimiter, embedded newlines (the Excel/Sheets multi-line cell), and doubled quotes. Custom delimiters supported. An unterminated quote is rejected with its position rather than parsed into corrupted rows. Use when processing spreadsheet exports, data imports, or structured text pipelines where the source is CSV. Supports up to 200 KB.

parse_csv input schema
{
  "type": "object",
  "examples": [
    {
      "input": "a;b\n1;2",
      "delimiter": ";"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "CSV content to parse"
    },
    "header": {
      "type": "boolean",
      "description": "Treat the first row as headers (default: true)"
    },
    "delimiter": {
      "type": "string",
      "description": "Field delimiter character (default: \",\")"
    }
  }
}
parse_csv output schema
{
  "type": "object",
  "properties": {
    "rows": {
      "type": "array"
    },
    "columns": {
      "type": "number"
    },
    "headers": {
      "type": "array"
    },
    "row_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
parse_csv annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
extract_json_path
Advertised by the server during the last successful anonymous check.
Advertised read-only

Extract a value from a JSON string using dot-notation path (e.g., "user.address.city", "items.0.name", "meta.tags"). Supports array index access via numeric path segments.

extract_json_path input schema
{
  "type": "object",
  "examples": [
    {
      "path": "a.b.0.c",
      "input": {
        "a": {
          "b": [
            {
              "c": 1
            },
            {
              "c": 2
            }
          ]
        }
      }
    }
  ],
  "required": [
    "input",
    "path"
  ],
  "properties": {
    "path": {
      "type": "string",
      "description": "Dot-notation path, e.g. \"user.address.city\" or \"items.0.name\""
    },
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON to traverse — a JSON string, or the object/array itself."
    }
  }
}
extract_json_path output schema
{
  "type": "object",
  "properties": {
    "path": {},
    "type": {},
    "value": {}
  },
  "additionalProperties": true
}
extract_json_path annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
json_schema_validate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Validate a JSON value against a JSON Schema (draft-07 subset). Supports type, required, properties, items, enum, const, pattern, format (email/uri/date/date-time/uuid), minimum/maximum, minLength/maxLength, minItems/maxItems, uniqueItems, additionalProperties, anyOf, allOf, oneOf, not, and local $ref (#/definitions/…, #/$defs/…). A schema using a keyword outside that list (patternProperties, if/then, dependencies, a remote $ref…) is never reported valid: the keyword is named in `unevaluated_keywords`. Returns all validation errors with dot-notation paths.

json_schema_validate input schema
{
  "type": "object",
  "examples": [
    {
      "value": {
        "p": {
          "n": "five"
        }
      },
      "schema": {
        "type": "object",
        "$defs": {
          "P": {
            "type": "object",
            "properties": {
              "n": {
                "type": "string"
              }
            }
          }
        },
        "properties": {
          "p": {
            "$ref": "#/$defs/P"
          }
        }
      }
    }
  ],
  "required": [
    "value",
    "schema"
  ],
  "properties": {
    "value": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON value to validate — a JSON string, or the value itself."
    },
    "schema": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON Schema — a JSON string, or the schema object itself."
    }
  }
}
json_schema_validate output schema
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "errors": {
      "type": "array"
    },
    "error_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
json_schema_validate annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
flatten_json
Advertised by the server during the last successful anonymous check.
Advertised read-only

Flatten a nested JSON object to single-level dot-notation keys (e.g. {"a":{"b":1}} → {"a.b":1}), or unflatten dot-notation keys back to a nested object. Supports custom separators.

flatten_json input schema
{
  "type": "object",
  "examples": [
    {
      "input": {
        "a": {
          "b": 1,
          "c": [
            1,
            2
          ]
        }
      }
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "mode": {
      "type": "string",
      "description": "\"flatten\" (default) or \"unflatten\""
    },
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON to flatten or unflatten — a JSON string, or the object itself."
    },
    "separator": {
      "type": "string",
      "description": "Key separator (default: \".\")"
    }
  }
}
flatten_json output schema
{
  "type": "object",
  "properties": {
    "result": {},
    "key_count": {
      "type": "number"
    },
    "max_depth": {
      "type": "array"
    }
  },
  "additionalProperties": true
}
flatten_json annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
xml_to_json
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert an XML string to a JSON object. Supports attributes, nested elements, arrays, CDATA, and namespaces. Options: parse numbers, parse booleans, ignore attributes.

xml_to_json input schema
{
  "type": "object",
  "examples": [
    {
      "input": "<r a=\"1\"><i>x</i><i>y</i></r>"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "XML string to convert"
    },
    "attr_prefix": {
      "type": "string",
      "description": "Prefix for attribute keys (default: \"@_\")"
    },
    "ignore_attrs": {
      "type": "boolean",
      "description": "Ignore XML attributes (default: false)"
    },
    "parse_values": {
      "type": "boolean",
      "description": "Auto-parse numbers and booleans (default: true)"
    }
  }
}
xml_to_json output schema
{
  "type": "object",
  "properties": {
    "result": {},
    "key_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
xml_to_json annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
mock_from_schema
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate realistic mock data from a JSON Schema. Supports all common types (string, number, integer, boolean, array, object, null), format hints (email, date, date-time, uri, uuid), enum, const, and nested schemas. Perfect for testing MCP tools with realistic data.

mock_from_schema input schema
{
  "type": "object",
  "examples": [
    {
      "count": 20,
      "schema": {
        "type": "object",
        "required": [
          "id",
          "email"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "maximum": 9,
            "minimum": 5
          },
          "tag": {
            "enum": [
              "a",
              "b"
            ]
          },
          "email": {
            "type": "string",
            "format": "email"
          }
        }
      }
    }
  ],
  "required": [
    "schema"
  ],
  "properties": {
    "seed": {
      "type": "string",
      "description": "Optional seed string for deterministic output (uses first char codes)"
    },
    "count": {
      "type": "number",
      "description": "Number of mock objects to generate (default: 1, max: 20)"
    },
    "schema": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON Schema to generate from — a JSON string, or the schema object itself."
    }
  }
}
mock_from_schema output schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "number"
    },
    "results": {}
  },
  "additionalProperties": true
}
mock_from_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
json_to_csv
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert a JSON array of objects to CSV format. Automatically detects columns from all object keys. Handles quoting and escaping per RFC 4180.

json_to_csv input schema
{
  "type": "object",
  "examples": [
    {
      "input": [
        {
          "a": 1
        },
        {
          "b": 2
        }
      ]
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The array of objects to convert — a JSON string, or the array itself."
    },
    "headers": {
      "type": "boolean",
      "description": "Include header row (default: true)"
    },
    "delimiter": {
      "type": "string",
      "description": "Column delimiter (default: \",\")"
    }
  }
}
json_to_csv output schema
{
  "type": "object",
  "properties": {
    "csv": {
      "type": "string"
    },
    "rows": {
      "type": "number"
    },
    "columns": {
      "type": "number"
    },
    "column_names": {}
  },
  "additionalProperties": true
}
json_to_csv annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
json_diff
Advertised by the server during the last successful anonymous check.
Advertised read-only

Compute a deep structural diff between two JSON values. Returns added, removed, and changed keys with dot-notation paths. Like git diff but for JSON objects — perfect for API response regression testing. Arrays are not compared blindly by position: the same elements in a different order collapse to a single "reordered" change, and an array of records sharing a stable identity field (id, uuid, key, name…) is matched by that field, so paths read [id=42] and a moved record is not reported as N rewrites.

json_diff input schema
{
  "type": "object",
  "examples": [
    {
      "after": {
        "a": 1,
        "b": 2
      },
      "before": {
        "a": 1,
        "b": 2
      }
    }
  ],
  "required": [
    "before",
    "after"
  ],
  "properties": {
    "after": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The modified JSON (after) — a JSON string, or the value itself."
    },
    "before": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The original JSON (before) — a JSON string, or the value itself."
    },
    "max_depth": {
      "type": "number",
      "description": "Max nesting depth to recurse (default: 10)"
    }
  }
}
json_diff output schema
{
  "type": "object",
  "properties": {
    "added": {
      "type": "boolean"
    },
    "changes": {
      "type": "array"
    },
    "removed": {
      "type": "boolean"
    },
    "modified": {
      "type": "boolean"
    },
    "identical": {
      "type": "boolean"
    },
    "total_changes": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
json_diff annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
json_to_yaml
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert a JSON object to clean, human-readable YAML. Handles nested objects, arrays, multiline strings, and special characters. No external dependencies.

json_to_yaml input schema
{
  "type": "object",
  "examples": [
    {
      "input": {
        "a": "x: y",
        "c": null,
        "d": "yes",
        "e": "0123"
      }
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The JSON to convert to YAML — a JSON string, or the value itself."
    },
    "indent": {
      "type": "number",
      "description": "Indentation size in spaces (default: 2)"
    }
  }
}
json_to_yaml output schema
{
  "type": "object",
  "properties": {
    "yaml": {},
    "lines": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
json_to_yaml annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
yaml_to_json
Advertised by the server during the last successful anonymous check.
Advertised read-only

Parse a YAML string and return the equivalent JSON value. The reverse of json_to_yaml. Supports nested objects, arrays, anchors, aliases, multi-document streams, and all scalar types. Use when processing config files, CI/CD pipeline definitions, or OpenAPI specs authored in YAML.

yaml_to_json input schema
{
  "type": "object",
  "examples": [
    {
      "input": "a: 1\nb: [x, y]"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "YAML string to parse"
    },
    "multi": {
      "type": "boolean",
      "description": "If true, parse all documents in a multi-document stream and return an array (default: false)"
    }
  }
}
yaml_to_json output schema
{
  "type": "object",
  "properties": {
    "json": {},
    "count": {
      "type": "number"
    },
    "documents": {}
  },
  "additionalProperties": true
}
yaml_to_json annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
json_schema_generate
Advertised by the server during the last successful anonymous check.
Advertised read-only

Infer a JSON Schema (draft-07) from a sample JSON value. Detects types, required fields, array item shapes, nested objects, and common string formats (email, uri, date, date-time, uuid). Returns a ready-to-use schema compatible with json_schema_validate. Use when you have a sample API response or LLM output and want to auto-generate a validation schema for CI/CD testing.

json_schema_generate input schema
{
  "type": "object",
  "examples": [
    {
      "input": {
        "a": [
          1
        ],
        "b": true,
        "f": 1.5,
        "n": 1,
        "o": {
          "k": null
        },
        "s": "x"
      }
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "object",
        "array"
      ],
      "description": "The sample JSON value to infer the schema from — a JSON string, or the value itself."
    },
    "samples": {
      "type": [
        "array",
        "string"
      ],
      "description": "More samples of the same shape, merged with input: a field seen as null and as a date becomes [\"string\",\"null\"]; one missing somewhere is not required."
    },
    "required_all": {
      "type": "boolean",
      "description": "Mark fields present in every observed object as required (default: true)"
    }
  }
}
json_schema_generate output schema
{
  "type": "object",
  "properties": {
    "schema": {
      "type": "object"
    },
    "warnings": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "additionalProperties": true
}
json_schema_generate annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
text_stats
Advertised by the server during the last successful anonymous check.
Advertised read-only

Compute comprehensive statistics for any text: character count (with and without spaces), word count, line count, sentence count, paragraph count, and estimated reading time in minutes. Sentence counting is abbreviation-aware — titles (Mr., Dr.), acronyms (U.S., i.e., p.m.), initials, decimals, URLs and emails do not end a sentence, and a text with no terminal punctuation still counts as one. Use for validating form field lengths, evaluating LLM output verbosity, or content auditing.

text_stats input schema
{
  "type": "object",
  "examples": [
    {
      "input": "One two three.\nFour five!\n\nSix?"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "The text to analyse"
    }
  }
}
text_stats output schema
{
  "type": "object",
  "properties": {
    "chars": {},
    "lines": {},
    "words": {},
    "sentences": {},
    "paragraphs": {},
    "chars_no_space": {},
    "reading_time_minutes": {}
  },
  "additionalProperties": true
}
text_stats annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
regex_test
Advertised by the server during the last successful anonymous check.
Advertised read-only

Test a regular expression pattern against an input string and return all matches with their index positions and named capture groups. Use for validating user inputs, extracting structured data from text, or debugging regex patterns. Supports flags g, i, m, s, u, y. The match runs in an isolated thread with a 500 ms budget: a pattern that blows up (catastrophic backtracking, e.g. "(a+)+$") comes back as redos_detected:true — a real ReDoS verdict on your pattern — instead of hanging.

regex_test input schema
{
  "type": "object",
  "examples": [
    {
      "flags": "g",
      "input": "a 12-34 b 5-6",
      "pattern": "\\d+-\\d+"
    }
  ],
  "required": [
    "pattern",
    "input"
  ],
  "properties": {
    "flags": {
      "type": "string",
      "description": "Regex flags: g (global), i (case-insensitive), m (multiline), s (dotAll) — default: \"\""
    },
    "input": {
      "type": "string",
      "description": "The string to test against (max 50 KB)"
    },
    "pattern": {
      "type": "string",
      "description": "Regular expression pattern (without delimiters)"
    }
  }
}
regex_test output schema
{
  "type": "object",
  "properties": {
    "note": {},
    "flags": {},
    "matched": {},
    "matches": {},
    "pattern": {},
    "verdict": {},
    "elapsed_ms": {
      "type": "number"
    },
    "match_count": {
      "type": "number"
    },
    "redos_detected": {
      "type": "boolean"
    }
  },
  "additionalProperties": true
}
regex_test annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
lorem_ipsum
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate Lorem Ipsum placeholder text for UI mockups, design prototypes, or test data population. Configurable paragraphs (1–10), sentences per paragraph (1–20), and approximate words per sentence (3–30).

lorem_ipsum input schema
{
  "type": "object",
  "examples": [
    {
      "paragraphs": 3,
      "sentences_per_paragraph": 2
    }
  ],
  "properties": {
    "paragraphs": {
      "type": "number",
      "description": "Number of paragraphs to generate (1–10, default: 1)"
    },
    "words_per_sentence": {
      "type": "number",
      "description": "Approximate words per sentence (3–30, default: 10)"
    },
    "sentences_per_paragraph": {
      "type": "number",
      "description": "Sentences per paragraph (1–20, default: 5)"
    }
  }
}
lorem_ipsum output schema
{
  "type": "object",
  "properties": {
    "paragraphs": {},
    "paragraph_count": {
      "type": "number"
    }
  },
  "additionalProperties": true
}
lorem_ipsum annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
case_convert
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert a string between naming conventions: camelCase, PascalCase, snake_case, kebab-case, UPPER_SNAKE_CASE, dot.case, Title Case. Essential for code generation and refactoring.

case_convert input schema
{
  "type": "object",
  "examples": [
    {
      "to": "snake",
      "input": "helloWorld fooBar"
    }
  ],
  "required": [
    "input",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "Target case: \"camel\", \"pascal\", \"snake\", \"kebab\", \"upper_snake\", \"dot\", \"title\""
    },
    "input": {
      "type": "string",
      "description": "String to convert (e.g., \"myVariableName\", \"my-css-class\")"
    }
  }
}
case_convert output schema
{
  "type": "object",
  "properties": {
    "result": {},
    "from_words": {},
    "target_case": {}
  },
  "additionalProperties": true
}
case_convert annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
generate_uuid
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate one or more cryptographically random UUID v4 identifiers. Use this when you need unique IDs for test fixtures, database records, session tokens, or any scenario requiring a guaranteed-unique string. Returns up to 100 UUIDs in one call.

generate_uuid input schema
{
  "type": "object",
  "examples": [
    {
      "count": 5
    }
  ],
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of UUIDs to generate (1–100, default: 1)"
    }
  }
}
generate_uuid output schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "number"
    },
    "uuids": {}
  },
  "additionalProperties": true
}
generate_uuid annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "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
}
base64_encode
Advertised by the server during the last successful anonymous check.
Advertised read-only

Encode a UTF-8 string to Base64. Use when you need to embed binary data, multi-line text, or special characters safely inside JSON fields, HTTP headers, or data URIs.

base64_encode input schema
{
  "type": "object",
  "examples": [
    {
      "input": "héllo 🌍"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Text to encode"
    }
  }
}
base64_encode output schema
{
  "type": "object",
  "properties": {
    "encoded": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
base64_encode annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
base64_decode
Advertised by the server during the last successful anonymous check.
Advertised read-only

Decode a Base64 string back to UTF-8 text. Use for inspecting Base64-encoded API responses, JWT payload claims, config file values, or attachment data.

base64_decode input schema
{
  "type": "object",
  "examples": [
    {
      "input": "aMOpbGxvIPCfjI0="
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Base64 string to decode"
    }
  }
}
base64_decode output schema
{
  "type": "object",
  "properties": {
    "decoded": {}
  },
  "additionalProperties": true
}
base64_decode annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
url_encode
Advertised by the server during the last successful anonymous check.
Advertised read-only

Percent-encode a string for safe use in URLs. Call this before programmatically building query strings, path segments, or form-encoded bodies to prevent injection and malformed URLs.

url_encode input schema
{
  "type": "object",
  "examples": [
    {
      "input": "a b&c=d/é"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "mode": {
      "type": "string",
      "description": "\"component\" (default) or \"full\" for encodeURI behavior"
    },
    "input": {
      "type": "string",
      "description": "String to URL-encode"
    }
  }
}
url_encode output schema
{
  "type": "object",
  "properties": {
    "encoded": {}
  },
  "additionalProperties": true
}
url_encode annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
url_decode
Advertised by the server during the last successful anonymous check.
Advertised read-only

Decode a percent-encoded URL string back to plain text. Use when parsing query parameters from raw URLs or when displaying encoded values to users.

url_decode input schema
{
  "type": "object",
  "examples": [
    {
      "input": "a%20b%26c"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "URL-encoded string to decode"
    }
  }
}
url_decode output schema
{
  "type": "object",
  "properties": {
    "decoded": {}
  },
  "additionalProperties": true
}
url_decode annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
color_convert
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert a color between HEX, RGB, and HSL formats. Use when translating design tokens between CSS notations, verifying color accessibility, or normalizing color values from user input. Accepts #rrggbb, #rgb, rgb(r,g,b), or hsl(h,s%,l%).

color_convert input schema
{
  "type": "object",
  "examples": [
    {
      "input": "rgb(18, 52, 86)"
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Color value to convert, e.g. \"#ff6b6b\", \"rgb(255,107,107)\", \"hsl(0,100%,71%)\""
    }
  }
}
color_convert output schema
{
  "type": "object",
  "properties": {
    "b": {},
    "g": {},
    "r": {},
    "hex": {},
    "hsl": {
      "type": "string"
    },
    "rgb": {
      "type": "string"
    },
    "input": {}
  },
  "additionalProperties": true
}
color_convert annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
number_base_convert
Advertised by the server during the last successful anonymous check.
Advertised read-only

Convert numbers between bases: decimal, binary, octal, hexadecimal, or any base 2–36. Auto-detects 0x, 0b, 0o prefixes.

number_base_convert input schema
{
  "type": "object",
  "examples": [
    {
      "input": "ff",
      "to_base": 10,
      "from_base": 16
    }
  ],
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "Number to convert (e.g., \"255\", \"0xFF\", \"0b1010\", \"0o77\")"
    },
    "to_base": {
      "type": "number",
      "description": "Target base 2–36 (omit to get all common bases)"
    },
    "from_base": {
      "type": "number",
      "description": "Source base 2–36 (auto-detects prefix if omitted)"
    }
  }
}
number_base_convert output schema
{
  "type": "object",
  "properties": {
    "octal": {
      "type": "string"
    },
    "binary": {
      "type": "string"
    },
    "result": {
      "type": "string"
    },
    "decimal": {},
    "to_base": {},
    "from_base": {},
    "hexadecimal": {
      "type": "string"
    }
  },
  "additionalProperties": true
}
number_base_convert 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
776 ms
95th percentile latency
776 ms

Maintenance history

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

  • · probe · passed · 776 ms · metadata changed · 36 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-mcp-data https://www.ia-qa.com/mcp/data

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-mcp-data --url https://www.ia-qa.com/mcp/data

Cursor

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

Cline

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

VS Code

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

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-mcp-data https://www.ia-qa.com/mcp/data

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-mcp-data": {
      "url": "https://www.ia-qa.com/mcp/data"
    }
  }
}

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-mcp-data": {
      "serverUrl": "https://www.ia-qa.com/mcp/data"
    }
  }
}

Let your agent find its tools

Find servers like IA-QA MCP Data 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 6,905