Chaining Mcp Server — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited Chaining Mcp Server (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
A refined and unified Model Context Protocol (MCP) server that combines intelligent tool chaining, route optimization, sequential thinking, time management, development guidance, monitoring, analytics, security, and compliance capabilities. This server discovers available MCP servers on your system, analyzes their tools, validates tool chains, and provides a complete enterprise-grade toolkit for complex task execution with real awesome-copilot MCP server integration.
~/.cursor/mcp.json and other configuration locations.gitignore and build systemThe chaining MCP server now includes a comprehensive collection of 42 prebuilt prompts and 11 resource sets designed to help models effectively use the available toolsets for development, debugging, orchestration, monitoring, analytics, security, and compliance workflows. The collection now includes extensive tool-chaining resources with ready-made chains for common development scenarios, plus enterprise-grade monitoring and security resources.
The prompts are organized into specialized categories including MCP ecosystem exploration, cross-server orchestration, time-sensitive operations, intelligent routing, collaborative development, and advanced tool chaining.
Tool Chaining Resources:
Enterprise Resources:
Prebuilt prompts provide structured guidance for specific development tasks:
Each prompt includes:
Resource sets are curated collections of prompts, workflows, templates, and examples for specific scenarios:
Each resource set contains:
#### Tool Chain Validation
// Validate a tool chain for correctness and security
const validation = await mcpClient.callTool('validate_tool_chain', {
toolChain: [
{
serverName: 'filesystem-mcp',
toolName: 'read_file',
parameters: { path: 'config.json' }
},
{
serverName: 'filesystem-mcp',
toolName: 'search_replace',
parameters: { path: 'config.json', old_string: '"debug": false', new_string: '"debug": true' },
dependsOn: ['read_file']
}
],
checkCircularDependencies: true,
checkToolAvailability: true,
checkParameterCompatibility: true
});
console.log(validation);#### Performance Analysis
// Analyze tool chain performance and get optimization suggestions
const analysis = await mcpClient.callTool('analyze_tool_chain_performance', {
toolChain: [
{
serverName: 'filesystem-mcp',
toolName: 'list_dir',
parameters: { path: 'src' }
},
{
serverName: 'grep-mcp',
toolName: 'grep',
parameters: { pattern: 'TODO|FIXME', path: 'src' },
dependsOn: ['list_dir']
}
],
includeExecutionMetrics: true,
includeComplexityAnalysis: true,
includeOptimizationSuggestions: true
});
console.log(analysis);#### Monitoring & Analytics Prompts
// Use the system health monitoring prompt
const healthPrompt = await mcpClient.callTool('get_prompt', {
id: 'system-health-monitoring'
});
// Use the performance bottleneck analysis prompt
const perfPrompt = await mcpClient.callTool('get_prompt', {
id: 'performance-bottleneck-analysis'
});#### Security & Compliance Prompts
// Use the security vulnerability assessment prompt
const securityPrompt = await mcpClient.callTool('get_prompt', {
id: 'security-vulnerability-assessment'
});
// Use the compliance audit workflow prompt
const compliancePrompt = await mcpClient.callTool('get_prompt', {
id: 'compliance-audit-workflow'
});These prebuilt prompts and resource sets help models:
npm install npm run buildConfiguration
Add the chaining MCP server to your MCP client configuration:
{
"mcpServers": {
"chaining": {
"command": "node",
"args": ["/path/to/chaining-mcp-server/dist/index.js"],
"env": {
"SEQUENTIAL_THINKING_AVAILABLE": "true",
"AWESOME_COPILOT_ENABLED": "true",
"RELIABILITY_MONITORING_ENABLED": "true",
"GITHUB_TOKEN": "your_github_token_here"
}
}
}
}Note: Replace /path/to/chaining-mcp-server with your actual path to the chaining-mcp-server directory.
Important: Set GITHUB_TOKEN to a valid GitHub Personal Access Token to use awesome-copilot tools. Get a token from https://github.com/settings/tokens.
#### 1. list_mcp_servers
Lists all discovered MCP servers on the system.
Input: None
Output: JSON object containing server information including name, command, args, environment variables, and capabilities.
#### 2. analyze_tools
Analyzes available tools from discovered MCP servers.
Input:
serverName (optional): Filter by specific server namecategory (optional): Filter by tool categoryOutput: JSON object containing tool analysis, grouped by server and category.
#### 3. generate_route_suggestions
Generates optimal route suggestions for a given task.
Input:
task (required): The task or problem to solvecriteria (optional): Optimization criteria objectCriteria Options:
prioritizeSpeed: Optimize for speedprioritizeSimplicity: Optimize for simplicityprioritizeReliability: Optimize for reliabilitymaxComplexity: Maximum complexity level (1-10)maxDuration: Maximum duration in millisecondsrequiredCapabilities: Array of required capabilitiesexcludedTools: Array of tools to excludeOutput: JSON object containing suggested routes with tools, estimated duration, complexity, confidence, and reasoning.
#### 4. analyze_with_sequential_thinking
Analyzes complex workflows using sequential thinking.
Input:
problem (required): The problem to analyzecriteria (optional): Optimization criteriamaxThoughts (optional): Maximum number of thoughts (1-20, default: 10)Output: JSON object containing sequential thinking analysis, thoughts, and suggestions.
#### 5. get_tool_chain_analysis
Gets comprehensive analysis of available tools and suggested routes.
Input:
input (required): Input description for analysiscriteria (optional): Optimization criteriaOutput: JSON object containing comprehensive analysis including total tools, average complexity, and route recommendations.
#### 6. search_instructions
Searches custom instructions based on keywords in their descriptions.
Input:
keywords (required): Keywords to search for in instruction descriptionsOutput: JSON object with matching instructions and their metadata. Requires GITHUB_TOKEN environment variable to be configured.
#### 7. load_instruction
Loads a custom instruction from the repository.
Input:
mode (required): Instruction mode (instructions, prompts, chatmodes)filename (required): Filename of the instruction to loadOutput: JSON object containing the instruction content and metadata. Requires GITHUB_TOKEN environment variable to be configured.
#### 8. sequentialthinking
A detailed tool for dynamic and reflective problem-solving through thoughts.
Input:
thought (required): Your current thinking stepnextThoughtNeeded (required): Whether another thought step is neededthoughtNumber (required): Current thought numbertotalThoughts (required): Estimated total thoughts neededisRevision (optional): Whether this revises previous thinkingrevisesThought (optional): Which thought is being reconsideredbranchFromThought (optional): Branching point thought numberbranchId (optional): Branch identifierneedsMoreThoughts (optional): If more thoughts are neededOutput: JSON object with thought processing results and metadata.
#### 9. brainstorming
Generate creative ideas and solutions for problems using different brainstorming approaches.
Input:
topic (required): The topic or problem to brainstorm aboutcontext (optional): Additional context or background informationapproach (optional): The brainstorming approach ('creative', 'analytical', 'practical', 'innovative') - defaults to 'creative'ideaCount (optional): Number of ideas to generate (3-20) - defaults to 10includeEvaluation (optional): Whether to include evaluation and prioritization - defaults to trueconstraints (optional): Array of constraints or requirements to considerOutput: JSON object containing generated ideas with feasibility, innovation, and effort metrics, plus evaluation and recommendations.
Approaches:
creative: Generate innovative and unconventional ideasanalytical: Data-driven and logical solution generationpractical: Realistic and implementable solutionsinnovative: Cutting-edge approaches combining multiple perspectives#### 10. workflow_orchestrator
Execute complex multi-server workflows across the MCP ecosystem with dependency management and error handling.
Input:
workflowId (required): Unique identifier for the workflowname (required): Human-readable name for the workflowdescription (optional): Description of what this workflow doessteps (required): Array of workflow steps to executeid: Unique identifier for this stepserverName: Name of the MCP server to execute ontoolName: Name of the tool to executeparameters: Parameters to pass to the tooldependsOn (optional): IDs of steps that must complete before this stepoutputMapping (optional): Map outputs from this step to input parameters for dependent stepsretryOnFailure (optional): Whether to retry this step on failuremaxRetries (optional): Maximum number of retriesfailFast (optional): Whether to stop execution on first failuretimeout (optional): Maximum execution time in millisecondsvariables (optional): Global variables available to all stepsOutput: JSON object containing workflow execution results, step-by-step status, execution time, and aggregated results.
Key Features:
#### 11. get_current_time
Get current time in a specific timezone.
Input:
timezone (required): IANA timezone name (e.g., 'America/New_York', 'Europe/London')Output: JSON object with timezone, datetime, day of week, and DST status.
#### 12. convert_time
Convert time between timezones.
Input:
source_timezone (required): Source IANA timezone nametime (required): Time to convert in 24-hour format (HH:MM)target_timezone (required): Target IANA timezone nameOutput: JSON object with source and target times, plus time difference.
#### 13. get_prompt
Get a specific prebuilt prompt by ID.
Input:
id (required): The ID of the prompt to retrieveOutput: JSON object containing the complete prompt with its content and metadata.
#### 14. search_prompts
Search for prompts by keywords, category, or tags.
Input:
query (required): Search query to match against prompt names, descriptions, categories, or tagscategory (optional): Filter by category (development, debugging, etc.)complexity (optional): Filter by complexity level (low, medium, high)Output: JSON object with matching prompts and their metadata.
#### 15. get_resource_set
Get a specific resource set by ID.
Input:
id (required): The ID of the resource set to retrieveOutput: JSON object containing the complete resource set with all its resources.
#### 16. search_resource_sets
Search for resource sets by keywords, category, or tags.
Input:
query (required): Search query to match against resource set names, descriptions, categories, or tagscategory (optional): Filter by category (development, debugging, etc.)complexity (optional): Filter by complexity level (low, medium, high)Output: JSON object with matching resource sets and their metadata.
#### 17. validate_tool_chain
Validate tool chains for correctness, dependencies, and potential issues. Checks for circular dependencies, tool availability, and parameter compatibility.
Input:
toolChain (required): Array of tool chain steps with server name, tool name, parameters, and dependenciescheckCircularDependencies (optional): Whether to check for circular dependencies (default: true)checkToolAvailability (optional): Whether to verify tools exist on their servers (default: true)checkParameterCompatibility (optional): Whether to check parameter compatibility (default: true)Output: JSON object with validation results including errors, warnings, and overall validity status.
#### 18. analyze_tool_chain_performance
Analyze performance metrics and efficiency of tool chains. Provides execution time estimates, complexity analysis, and optimization suggestions.
Input:
toolChain (required): Array of tool chain steps to analyzeincludeExecutionMetrics (optional): Whether to include execution time estimates (default: true)includeComplexityAnalysis (optional): Whether to analyze complexity metrics (default: true)includeOptimizationSuggestions (optional): Whether to provide optimization suggestions (default: true)Output: JSON object with performance metrics, complexity analysis, and optimization recommendations.
chaining://serversReturns a JSON list of all discovered MCP servers.
chaining://toolsReturns a JSON list of all available tools from discovered servers.
chaining://analysisReturns a JSON summary of the current analysis state.
chaining://promptsReturns a JSON collection of all available prebuilt prompts for common development tasks.
chaining://resourcesReturns a JSON collection of curated resource sets for different development scenarios.
chaining://prompts/overviewReturns a JSON overview of available prompts by category and complexity level.
chaining://awesome-copilot/collectionsReturns a JSON collection of all available awesome-copilot collections with their metadata.
chaining://awesome-copilot/instructionsReturns a JSON collection of all available awesome-copilot instructions with their metadata.
chaining://awesome-copilot/statusReturns a JSON object with the current status of awesome-copilot integration.
chaining://sequential/stateReturns a JSON object with the current state of sequential thinking sessions, including thought history and active session status.
chaining://workflows/statusReturns a JSON object with the status of active and completed workflow orchestrations, including execution progress and results.
chaining://tool-chainsReturns a JSON collection of comprehensive tool chaining resources including prompts and resource sets specifically designed for complex development workflows and orchestration patterns.
chaining://tool-chains/overviewReturns a JSON overview of available tool chaining resources organized by category and complexity level, providing insights into the tool chaining capabilities.
// List all discovered MCP servers
const servers = await mcpClient.callTool('list_mcp_servers', {});
console.log(servers);// Analyze tools by category
const analysis = await mcpClient.callTool('analyze_tools', {
category: 'filesystem'
});
console.log(analysis);// Generate route suggestions for a task
const routes = await mcpClient.callTool('generate_route_suggestions', {
task: 'Read a file and search for specific content',
criteria: {
prioritizeSpeed: true,
maxComplexity: 5
}
});
console.log(routes);// Analyze complex workflow with sequential thinking
const analysis = await mcpClient.callTool('analyze_with_sequential_thinking', {
problem: 'Design a complex data processing pipeline',
criteria: {
prioritizeReliability: true,
maxDuration: 10000
},
maxThoughts: 15
});
console.log(analysis);// Search for development instructions
const instructions = await mcpClient.callTool('search_instructions', {
keywords: 'mcp server'
});
// Load a specific instruction
const instruction = await mcpClient.callTool('load_instruction', {
mode: 'instructions',
filename: 'typescript-mcp-server.instructions.md'
});
// Note: These tools require GITHUB_TOKEN environment variable to be configured
// Get a token from https://github.com/settings/tokens and set it in your environment// Use sequential thinking for complex problem solving
const thought1 = await mcpClient.callTool('sequentialthinking', {
thought: 'I need to analyze this complex problem step by step',
nextThoughtNeeded: true,
thoughtNumber: 1,
totalThoughts: 5
});
const thought2 = await mcpClient.callTool('sequentialthinking', {
thought: 'Let me break down the problem into smaller components',
nextThoughtNeeded: true,
thoughtNumber: 2,
totalThoughts: 5
});// Generate creative ideas for a product feature
const creativeIdeas = await mcpClient.callTool('brainstorming', {
topic: 'user onboarding experience',
approach: 'creative',
ideaCount: 8,
constraints: ['must be mobile-friendly', 'budget under $50k']
});
// Generate practical solutions for a technical problem
const practicalSolutions = await mcpClient.callTool('brainstorming', {
topic: 'database performance optimization',
context: 'high-traffic e-commerce platform',
approach: 'practical',
ideaCount: 6,
includeEvaluation: true
});
// Generate analytical approaches for data analysis
const analyticalIdeas = await mcpClient.callTool('brainstorming', {
topic: 'customer churn prediction',
approach: 'analytical',
constraints: ['must use existing data', 'prediction accuracy > 85%']
});// Execute a multi-server research workflow
const researchWorkflow = await mcpClient.callTool('workflow_orchestrator', {
workflowId: 'research-workflow-001',
name: 'AI Technology Research Pipeline',
description: 'Comprehensive research on AI technologies using multiple MCP servers',
steps: [
{
id: 'search-trends',
serverName: 'google-search-mcp',
toolName: 'search_trends',
parameters: {
topics: ['artificial intelligence', 'machine learning'],
timeframe: '6M',
includePredictions: true
}
},
{
id: 'academic-research',
serverName: 'google-search-mcp',
toolName: 'academic_search',
parameters: {
query: 'artificial intelligence trends 2024',
maxResults: 5
},
dependsOn: ['search-trends']
},
{
id: 'content-analysis',
serverName: 'google-search-mcp',
toolName: 'content_summarizer',
parameters: {
urls: ['output://academic-research.results'], // Using output mapping
maxLength: 500
},
dependsOn: ['academic-research'],
outputMapping: {
'urls': 'academic-research.results.urls' // Map output to input
}
}
],
failFast: false,
timeout: 300000 // 5 minutes
});
// Check workflow status
const workflowStatus = await mcpClient.readResource('chaining://workflows/status');
console.log('Active workflows:', workflowStatus);// Get current time in different timezones
const nyTime = await mcpClient.callTool('get_current_time', {
timezone: 'America/New_York'
});
const londonTime = await mcpClient.callTool('get_current_time', {
timezone: 'Europe/London'
});
// Convert time between timezones
const conversion = await mcpClient.callTool('convert_time', {
source_timezone: 'America/New_York',
time: '14:30',
target_timezone: 'Asia/Tokyo'
});// Get a specific prebuilt prompt
const prompt = await mcpClient.callTool('get_prompt', {
id: 'analyze-project-structure'
});
console.log(prompt);
// Search for prompts by keyword
const searchResults = await mcpClient.callTool('search_prompts', {
query: 'debugging',
category: 'development',
complexity: 'medium'
});
console.log(searchResults);
// Get a resource set
const resourceSet = await mcpClient.callTool('get_resource_set', {
id: 'development-starter-kit'
});
console.log(resourceSet);
// Search for resource sets
const resourceSearch = await mcpClient.callTool('search_resource_sets', {
query: 'performance',
complexity: 'high'
});
console.log(resourceSearch);// Get all available prompts
const allPrompts = await mcpClient.readResource('chaining://prompts');
console.log(allPrompts);
// Get all resource sets
const allResources = await mcpClient.readResource('chaining://resources');
console.log(allResources);
// Get prompts overview
const overview = await mcpClient.readResource('chaining://prompts/overview');
console.log(overview);
// Get awesome-copilot collections
const collections = await mcpClient.readResource('chaining://awesome-copilot/collections');
console.log(collections);
// Get awesome-copilot instructions
const instructions = await mcpClient.readResource('chaining://awesome-copilot/instructions');
console.log(instructions);
// Get awesome-copilot integration status
const status = await mcpClient.readResource('chaining://awesome-copilot/status');
console.log(status);
// Get sequential thinking state
const sequentialState = await mcpClient.readResource('chaining://sequential/state');
console.log(sequentialState);
// Get comprehensive tool chaining resources
const toolChains = await mcpClient.readResource('chaining://tool-chains');
console.log('Available tool chains:', toolChains);
// Get tool chaining overview
const toolChainsOverview = await mcpClient.readResource('chaining://tool-chains/overview');
console.log('Tool chaining overview:', toolChainsOverview);SEQUENTIAL_THINKING_AVAILABLE: Set to 'true' to enable sequential thinking integrationMCP_SERVERS: JSON string containing additional MCP server configurationsDISABLE_THOUGHT_LOGGING: Set to 'true' to disable sequential thinking thought loggingAWESOME_COPILOT_ENABLED: Set to 'false' to disable awesome-copilot integrationGITHUB_TOKEN: GitHub Personal Access Token required for awesome-copilot tools (get from https://github.com/settings/tokens)src/
├── index.ts # Main entry point
├── server.ts # Clean orchestrator (220 lines, fully modularized)
├── types.ts # Type definitions and Zod schemas
├── core/
│ ├── discovery.ts # Server discovery logic
│ └── optimizer.ts # Route optimization algorithms
├── managers/
│ ├── brainstorming-manager.ts # Brainstorming functionality
│ ├── sequential-thinking-manager.ts # Sequential thinking processing
│ ├── workflow-orchestrator.ts # Workflow orchestration
│ ├── reliability-manager.ts # System reliability management
│ ├── time-manager.ts # Time and timezone management
│ └── memory-manager.ts # Memory and knowledge management
├── integrations/
│ ├── awesome-copilot-integration.ts # Awesome Copilot integration
│ └── sequential-integration.ts # Sequential thinking integration
├── prompts/
│ ├── prompt-definitions.ts # Prompt and resource set data definitions
│ ├── prompt-handlers.ts # Dynamic prompt generation and validation logic
│ └── prompt-registry.ts # Registry for managing prompts and resource sets (40 prompts, 12 resource sets)
├── config/
│ ├── config-loader.ts # Configuration loading utilities
│ └── discovery-config.ts # Discovery configuration
├── utils/
│ └── schema-utils.ts # Schema utility functions
├── handlers/
│ └── request-handlers.ts # Central tool execution dispatcher
├── tools/
│ ├── tool-registry.ts # Tool definitions and listing (18 tools)
│ ├── core-chaining-tools.ts # Core chaining tool schemas (6 tools)
│ ├── awesome-copilot-tools.ts # Awesome Copilot tool schemas (2 tools)
│ ├── sequential-thinking-tools.ts # Sequential thinking tool schemas (2 tools)
│ ├── time-management-tools.ts # Time management tool schemas (2 tools)
│ ├── prompt-resource-tools.ts # Prompt/resource tool schemas (4 tools)
│ └── validation-analysis-tools.ts # Validation/analysis tool schemas (2 tools)
└── resources/
├── resource-registry.ts # Resource definitions and handlers
├── resource-definitions.ts # Static resource metadata (13 resources)
└── resource-handlers.ts # Dynamic resource content generationnpm run build # Build TypeScript to JavaScript
npm run dev # Watch mode for development
npm run clean # Clean dist directory#### Local Testing
node dist/index.jsThis server is designed to work seamlessly with other MCP servers in your ecosystem:
When the sequential thinking MCP server is available, the chaining server can:
The server integrates with the official awesome-copilot MCP server to provide:
The chaining server complements Project-Guardian by:
MIT License - see LICENSE file for details.
For issues and questions, please create an issue in the repository.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.