MCP server for analyzing documents using Azure Content Understanding service. Handles document upload, analysis, and result retrieval from Azure Blob Storage.
Static source inference · medium confidence · detected: Logging
Deprecated protocol patterns detected
Summary
This server has critical gaps in definition quality. Three tools are present, but parameter descriptions are entirely missing for the Analyze tool, schema format is inferred from Semantic Kernel reflection rather than explicit, and descriptions are inconsistent in detail. The tool definitions rely on Semantic Kernel's KernelPluginFactory to auto-generate schemas from C# attributes (line in McpServerBuilderExtensions.cs: McpServerTool.Create(function.AsAIFunction())), which means schemas are not directly visible in the MCP layer, they are inferred from runtime reflection. This violates the principle of explicit, verifiable tool registration. GetAllowedFolders has no visible description. The Analyze tool description lacks detail about prerequisites, error conditions, or what constitutes success. No parameter descriptions are present for analyzerId or fullFilePath in the source. Overall, this server falls well below the baseline for A/B tier servers.
Tools (3)
Analyzewriteauth38/100
Submits a document to Azure Content Understanding to extract content from.
GetAllowedFoldersread only25/100
Gets a list of fully qualified folder paths that this tool has access to.
GetAnalyzersread onlyauth37/100
Retreives a list of analyzers for Content Understanding.
Schema definitions are inferred from Semantic Kernel runtime reflection, not explicitly declared in MCP layer. KernelPluginFactory.CreateFromType<T>() and McpServerTool.Create(function.AsAIFunction()) generate schemas dynamically, making them invisible to static analysis and not verifiable in source code.
Analyze tool parameters (analyzerId, fullFilePath) lack descriptions in source code. The rubric requires every parameter to have a description explaining what it controls. LLMs cannot infer whether analyzerId is a UUID, an integer ID, or a human-readable name.
Migrate from Semantic Kernel's reflection-based tool registration to explicit MCP tool definitions with visible input schemas. Either (a) add direct McpServerBuilder.AddTool() calls with explicit InputSchema parameters in Program.cs, or (b) decorate the plugin classes with attributes that explicitly define schema in a verifiable way visible at static analysis time.
Add a description to GetAllowedFolders: e.g., 'Returns a list of folder paths this server is configured to access. Use before calling Analyze to ensure the document path is within an allowed directory.'
Add parameter descriptions to Analyze: 'analyzerId' → 'The ID of the analyzer to use for document analysis. Retrieve available analyzers via GetAnalyzers.'; 'fullFilePath' → 'The full file path to the document to analyze. Must be within an allowed folder (use GetAllowedFolders to see the list).'
Fix the typo in GetAnalyzers: change 'Retreives' to 'Retrieves'.
Expand GetAnalyzers description: 'Retrieves the list of available analyzers for the Azure Content Understanding service. Call this first to see which analyzer IDs can be passed to Analyze. Returns analyzer names and descriptions to help choose the right one.'
Add explicit output schema documentation for each tool. For example, GetAnalyzers should document: 'Returns an array of analyzer objects with fields: analyzerId (string), name (string), description (string).' For Analyze: 'Returns an object with fields: status (string, one of: pending, processing, completed, failed), resultSummary (string), extractedText (string), metadata (object).'
Spec posture evidence
Inferred effective spec: <=2025-11-25.
Relies on Logging (deprecated) - log to stderr or use OpenTelemetry
Score history
Overall score trend
↑ 15 points across a rubric change (v1 → v2)
32/100
Scored
Grade
Overall
Spec posture
Rubric
2026-09-22
F
32
<=2025-11-25
v2
2026-03-09
F
17
-
v1
GetAnalyzers description is extremely brief ('Retreives a list of analyzers for Content Understanding') and contains a typo ('Retreives' should be 'Retrieves'). Descriptions should be 10 - 1024 chars and explain WHAT, WHEN, and any prerequisites. This one is 61 chars but lacks context.
Output schemas are not documented. The AnalyzeDocument.cs file is truncated and does not show return type documentation. Users cannot know what fields to expect in responses, making LLM downstream planning difficult.
Tool definitions are tied to Semantic Kernel reflection-based registration. This means schemas are generated at runtime and not directly visible in the codebase. Per hard scoring rules: 'If you cannot see the actual tool definition in the source (only inferred): cap that tool's overall at 50.' All three tools are defined via Semantic Kernel plugins, making them inferred rather than explicit.
No enum constraints documented for analyzerId parameter in Analyze. If only certain analyzer IDs are valid, they should be declared as an enum to prevent hallucinated invalid IDs from the LLM.
No error handling guidance. None of the tool descriptions include recovery hints (e.g., 'If analyzer not found, call GetAnalyzers first').
GetAnalyzersAnalyzeGetAllowedFolders
Enhance Analyze description to explicitly state side effects: 'Submits a document to Azure Content Understanding for analysis. Uploads the file to blob storage, waits for processing to complete, and cleans up the blob when done. This is a stateful operation that cannot be safely retried without risk of duplicate processing.'
Declare valid analyzerId values as an enum in the schema (if the set is known). If dynamic, add a description hint: 'Valid values can be obtained from GetAnalyzers.'
Add error handling guidance to Analyze: 'If the analyzer is not found, call GetAnalyzers to see available options. If the file path is not found, verify it exists and is within an allowed folder (use GetAllowedFolders).'
Consider adding a timeout parameter to Analyze with documented defaults: 'timeoutSeconds (optional, default 300): How long to wait for analysis to complete before timing out. Useful for very large documents.'
Document that Analyze is idempotent only if called with the same document, clarify whether re-analyzing the same file produces the same result or if it's a fresh operation.