find_implementation_requirements
Extract detailed implementation requirements for 3GPP features, including mandatory/optional requirements, dependencies, and testing guidance to support telecommunications standards development.
Instructions
Extract detailed implementation requirements for specific 3GPP features, including mandatory/optional requirements, dependencies, and implementation guidance.
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| complexity_level | No | Implementation complexity level (default: intermediate) | intermediate |
| domain | No | Specific domain context (e.g., "charging", "security", "mobility", "radio") | |
| feature | Yes | The feature or functionality to analyze (e.g., "CHF implementation", "5G handover", "SUCI privacy protection") | |
| format | No | Response format - agent_ready provides structured JSON for AI agents | agent_ready |
| include_dependencies | No | Include dependency analysis and prerequisite requirements (default: true) | |
| include_testing_guidance | No | Include testing and validation guidance (default: true) |
Implementation Reference
- The execute method implements the core logic of the find_implementation_requirements tool. It calls the APIManager to fetch requirements and formats the response based on the requested format (agent_ready, summary, or detailed).async execute(args: FindImplementationRequirementsArgs) { try { const context = { domain: args.domain, complexity_level: args.complexity_level || 'intermediate' }; const requirements = await this.apiManager.findImplementationRequirements(args.feature, context); const format = args.format || 'agent_ready'; switch (format) { case 'agent_ready': return { content: [ { type: 'text', text: JSON.stringify(this.formatForAgent(requirements, args), null, 2) } ] }; case 'summary': return { content: [ { type: 'text', text: this.formatSummary(requirements, args) } ] }; case 'detailed': default: return { content: [ { type: 'text', text: this.formatDetailed(requirements, args) } ] }; } } catch (error) { return { content: [ { type: 'text', text: `Error finding implementation requirements: ${error instanceof Error ? error.message : 'Unknown error'}` } ], isError: true }; } }
- The getDefinition method provides the tool schema including name, description, and detailed inputSchema with properties, enums, defaults, and required fields.getDefinition() { return { name: 'find_implementation_requirements', description: 'Extract detailed implementation requirements for specific 3GPP features, including mandatory/optional requirements, dependencies, and implementation guidance.', inputSchema: { type: 'object', properties: { feature: { type: 'string', description: 'The feature or functionality to analyze (e.g., "CHF implementation", "5G handover", "SUCI privacy protection")' }, domain: { type: 'string', description: 'Specific domain context (e.g., "charging", "security", "mobility", "radio")' }, complexity_level: { type: 'string', enum: ['basic', 'intermediate', 'advanced'], description: 'Implementation complexity level (default: intermediate)', default: 'intermediate' }, include_dependencies: { type: 'boolean', description: 'Include dependency analysis and prerequisite requirements (default: true)', default: true }, include_testing_guidance: { type: 'boolean', description: 'Include testing and validation guidance (default: true)', default: true }, format: { type: 'string', enum: ['detailed', 'summary', 'agent_ready'], description: 'Response format - agent_ready provides structured JSON for AI agents', default: 'agent_ready' } }, required: ['feature'] } }; }
- TypeScript interface defining the input arguments for the tool.export interface FindImplementationRequirementsArgs { feature: string; domain?: string; complexity_level?: 'basic' | 'intermediate' | 'advanced'; include_dependencies?: boolean; include_testing_guidance?: boolean; format?: 'detailed' | 'summary' | 'agent_ready'; }
- src/index.ts:110-111 (registration)Registration in the MCP server's CallToolRequestSchema handler: dispatches calls to this tool name to the requirementsTool.execute method.case 'find_implementation_requirements': return await this.requirementsTool.execute(args as unknown as FindImplementationRequirementsArgs);
- src/index.ts:81-81 (registration)Instantiation of the FindImplementationRequirementsTool instance used by the server.this.requirementsTool = new FindImplementationRequirementsTool(this.apiManager);
- src/api/api-manager.ts:163-202 (helper)APIManager method called by the tool to fetch raw implementation requirements data from TSpec-LLM and 3GPP API.async findImplementationRequirements(feature: string, context?: { domain?: string; complexity_level?: 'basic' | 'intermediate' | 'advanced'; }): Promise<{ requirements: any[]; related_specifications: SpecificationMetadata[]; implementation_guidance: string[]; }> { try { const searchQuery = `${feature} implementation requirements ${context?.domain || ''}`; // Search TSpec-LLM for implementation details const tspecResults = await this.tspecClient.searchSpecifications({ query: searchQuery, max_results: 10 }); // Extract requirements from content const requirements = this.extractRequirements(tspecResults); // Find related specifications const relatedSpecs = await this.tgppClient.searchSpecifications(feature); // Generate implementation guidance const implementationGuidance = this.generateImplementationGuidance( feature, tspecResults, context ); return { requirements, related_specifications: relatedSpecs, implementation_guidance: implementationGuidance }; } catch (error) { throw new Error(`Failed to find implementation requirements: ${error instanceof Error ? error.message : 'Unknown error'}`); } }