# Tool Argument Completeness Checker MCP for AI Agents AI Agent Connect > Tool Argument Completeness Checker prevents your agents from making broken tool calls by verifying that every required parameter is present and valid. It scans raw text to catch missing fields or hallucinated values in your automation pipelines, ensuring your agentic workflows don't fail during execution. ## Overview - **Category:** developer-tools - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_Sh49pxTulCI60lpzZ6L6JqIUNUHe1MBWDnt97cIU/ai-agent-connect - **Tags:** llm, validation, schema, debugging, extraction ## Description You know that feeling when an agent tries to run a command, but it just misses something? It forgets the ID or invents a status that doesn't even exist in your database. These tiny mistakes break your entire automation pipeline and leave you digging through logs at 2 AM. This MCP acts as a safety gate between what your agent proposes and what actually executes. It looks at the raw text, pulls out the arguments, and checks them against your requirements. If something is missing or if the agent makes up an invalid option, you get an immediate alert. You can plug this into any compatible client through Vinkius to add a much-needed validation step to your workflows. It essentially turns 'I think I did this' into 'I know this is correct.' ## Tools ### tool_extract_raw_matches Low-level scan for argument-value pairs ### tool_get_argument_coverage Provides a high-level summary of tool adherence ### tool_validate_extraction null ## Prompt Examples **Prompt:** ``` Is this action ready to run: 'Update order 50 with status=shipped'? ``` **Response:** ``` The report shows **100% coverage**. Both `order_id` and `status` were found and are valid. ``` **Prompt:** ``` Check this call: 'Create user name=Alice'. (Required: email) ``` **Response:** ``` Warning: **50% completeness**. The required field `email` is missing from the text. ``` **Prompt:** ``` Verify if this value is okay: 'Set priority=urgent' where valid are [low, high]. ``` **Response:** ``` Error detected. The value `urgent` is not in the allowed list of **[low, high]**. ``` ## Capabilities ### Catch missing parameters Identify exactly which required fields were left out of an agent's proposed action. ### Detect hallucinated values Flag when an agent invents an enum value that does not exist in your allowed list. ### Calculate argument coverage Get a percentage score representing how complete the proposed tool call is. ### Flag null fields Spot instances where required data was provided as a null or empty value. ### Validate argument strings Verify that extracted text matches the expected format for your specific parameters. ## Use Cases ### Broken API calls An agent tries to update a record but forgets the ID. The checker flags it before the request ever hits your server. ### Invalid status updates Your agent suggests a 'processing' status that doesn't exist in your system. This tool catches the hallucination immediately. ### Incomplete user creation A workflow attempts to create a user without a required email field. You get an alert before any database errors occur. ## Benefits - Eliminate runtime errors caused by missing arguments in your automation. - Reduce hallucinations by checking enum values against a source of truth. - Get instant feedback on the reliability of your agent's proposed actions. - Automate the validation step within your existing developer workflows. - Ensure high-integrity data passing between your LLM and external services. ## How It Works The bottom line is you stop executing broken commands. 1. Feed the raw action text from your agent into the MCP. 2. The tool extracts arguments and compares them against your required schema and valid enums. 3. You receive a detailed report highlighting any missing or invalid data points. ## Frequently Asked Questions **How can I stop my AI agents from making mistakes?** You can use the Tool Argument Completeness Checker to validate arguments before they are executed. This prevents broken calls from ever reaching your backend. **Can this tool detect when an agent makes up a status?** Yes. By comparing extracted text against your provided list of valid enums, the Tool Argument Completeness Checker flags any hallucinated values immediately. **Will this work with Claude or Cursor?** Yes, it works with any MCP-compatible client like Claude, Cursor, or Windsurf. It acts as a validation layer for whatever agent you are using. **Does the Tool Argument Completeness Checker handle missing fields?** Absolutely. It identifies exactly which required parameters were left out of the proposed action text so you can fix them before execution. **Is this useful for complex automation pipelines?** It is essential for complex workflows where accuracy is critical. It ensures that every tool call contains the necessary data to succeed without errors. **How does the tool detect hallucinated values?** The `check_argument_completeness` tool compares any extracted argument values against a provided JSON object of valid enums. If an extracted value is not present in the allowed set, it is flagged as a hallucination. **What input format is required for arguments?** You must provide `requiredArgsJson` as a JSON array of strings and `validEnumsJson` as a JSON object mapping argument names to arrays of allowed values. **Can it handle complex action text?** Yes, the tool uses regex and keyword indexing to parse unstructured text, making it capable of extracting values from natural language descriptions of tool calls. **How does the tool detect hallucinations?** It compares the extracted argument values against a provided list of valid enums using `tool_validate_extraction`. If a value is found that isn't in the list, it is flagged as a hallucination. **What is the difference between a missing argument and a hallucination?** A missing argument is a required field that was not mentioned in the text at all. A hallucination is a field that was mentioned, but with an invalid value that does not match the allowed set. **Can I use this to scan raw text for any potential values?** Yes, you can use `tool_extract_raw_matches` to perform a low-level scan of text using specific keywords as anchors to find potential argument-value pairs.