AI Agent Template MCP Server
An MCP server that enhances AI agents' coding capabilities by providing zero hallucinations, improved code quality, security-first approach, high test coverage, and efficient context management.
README Documentation
MCP Context Manager
The definitive MCP (Model Context Protocol) server for perfect AI-assisted development. This server transforms AI agents into expert developers that write flawless, secure, and well-tested code with zero hallucinations.
npm: https://www.npmjs.com/package/mcp-context-manager
GitHub: https://github.com/bswa006/mcp-context-manager
๐ Overview
This MCP server is the missing piece for AI-assisted development, providing:
- ๐ง Zero Hallucinations: Context7 integration + multi-layer verification
- ๐ 53% Better Code Quality: Enforced patterns + automated validation
- ๐ก๏ธ Security-First: Real-time vulnerability scanning
- ๐งช 80%+ Test Coverage: Intelligent test generation
- โก 30% Less Tokens: Efficient context management
- ๐ฏ Perfect Pattern Matching: Code indistinguishable from senior developers
๐ What's New in v2.0.0
Complete UX Enhancement Suite
- Deep Codebase Analysis: Comprehensive pattern detection and architecture understanding
- Conversation Starters: Help AI understand your project instantly
- Token Optimization: 3-tier context system saving 70-95% tokens
- IDE Integrations: Auto-loading configs for Cursor, VS Code, and IntelliJ
- Persistence Automation: Git hooks, cron jobs, and monitoring
- Team Workflows: Onboarding, maintenance, and quality checklists
- One-Command Setup: Complete workflow from analysis to automation
๐ Key Features
1. Agent Memory System
- Persistent Learning: Agents remember patterns, mistakes, and successes
- Context Awareness: Real-time tracking of current development session
- Performance Metrics: Continuous improvement through measurement
2. Hallucination Prevention
- API Verification: Every import and method checked before use
- Context7 Integration: Real-time documentation for latest APIs
- Pattern Validation: Ensures code matches existing conventions
3. Intelligent Code Generation
- Pattern Detection: Analyzes codebase to match style
- Security Scanning: Catches vulnerabilities before they happen
- Test Generation: Automatically creates tests for 80%+ coverage
4. Workflow Automation
- Guided Workflows: Step-by-step guidance for common tasks
- Proactive Prompts: AI guides itself through best practices
- Performance Tracking: Metrics for continuous improvement
๐ Quick Start
Option 1: Use the Published npm Package (Recommended)
# Install globally
npm install -g mcp-context-manager
# Or use directly with npx
npx mcp-context-manager
Then add to your Claude Desktop config:
{
"mcpServers": {
"context-manager": {
"command": "npx",
"args": ["mcp-context-manager"]
}
}
}
Note: After updating Claude Desktop config, restart Claude Desktop completely for changes to take effect.
If you still see "0 tools enabled", try this alternative configuration:
{
"mcpServers": {
"context-manager": {
"command": "node",
"args": ["/path/to/global/node_modules/mcp-context-manager/dist/cli.js"]
}
}
}
To find the global node_modules path, run: npm root -g
Option 2: Clone and Build Locally
# Clone the repository
git clone https://github.com/bswa006/mcp-context-manager
cd mcp-context-manager
# Install dependencies
npm install
# Build the server
npm run build
Configuration
Claude Desktop
Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"context-manager": {
"command": "node",
"args": ["/path/to/ai-agent-template-mcp/dist/server.js"]
}
}
}
Cursor
Add to your Cursor settings:
{
"mcp.servers": {
"context-manager": {
"command": "node",
"args": ["/path/to/ai-agent-template-mcp/dist/server.js"]
}
}
}
Available Resources (AI Agent Self-Guidance)
Core Resources
template://ai-constraints- CRITICAL rules AI must follow when generating codetemplate://current-patterns- REQUIRED patterns to match in new codetemplate://hallucination-prevention- Common AI mistakes and prevention guidetemplate://naming-conventions- MANDATORY naming patterns to followtemplate://security-requirements- CRITICAL security rules (non-negotiable)template://api-signatures- Valid API methods to prevent hallucinationstemplate://error-handling- REQUIRED error handling patterns
Agent Intelligence Resources
template://agent-memory- Persistent memory of patterns and learningstemplate://agent-context- Real-time context for current sessiontemplate://pattern-library- Comprehensive code patterns for all scenariostemplate://workflow-templates- Step-by-step guides for common taskstemplate://test-patterns- Testing strategies for 80%+ coverage
๐ Complete Tool Reference
Here's a comprehensive list of all 15 tools available in the MCP server:
Core Validation Tools
| Tool | Purpose | Key Features |
|---|---|---|
| check_before_suggesting | Prevent hallucinations | Verifies imports, methods, and patterns exist before AI suggests code |
| validate_generated_code | Validate AI output | Checks generated code against project patterns and conventions |
| get_pattern_for_task | Pattern guidance | Provides exact patterns to follow for components, hooks, services, etc. |
| check_security_compliance | Security validation | Scans code for vulnerabilities and security issues |
| detect_existing_patterns | Pattern detection | Analyzes existing codebase to match coding style |
Workspace & Project Tools
| Tool | Purpose | Key Features |
|---|---|---|
| initialize_agent_workspace | Project setup | Creates PROJECT-TEMPLATE.md, CODEBASE-CONTEXT.md, and context files |
| analyze_codebase_deeply | Deep analysis | Comprehensive pattern detection, architecture understanding |
| complete_setup_workflow | One-command setup | Runs all setup tools in sequence for complete configuration |
Testing & Performance Tools
| Tool | Purpose | Key Features |
|---|---|---|
| generate_tests_for_coverage | Test generation | Creates tests to achieve 80%+ coverage with edge cases |
| track_agent_performance | Metrics tracking | Monitors token usage, validation scores, and improvements |
UX Enhancement Tools (v2.0.0)
| Tool | Purpose | Key Features |
|---|---|---|
| create_conversation_starters | AI context helper | Quick tasks, recent work, project overview for faster AI understanding |
| create_token_optimizer | Token savings | 3-tier context system (minimal/standard/comprehensive) with ROI tracking |
| create_ide_configs | IDE integration | Auto-loading configs for Cursor, VS Code, IntelliJ |
| setup_persistence_automation | Auto-updates | Git hooks, cron jobs, monitoring, validation scripts |
| create_maintenance_workflows | Team collaboration | Onboarding guides, checklists, metrics dashboards, training materials |
Available Tools (AI Self-Validation)
1. check_before_suggesting ๐
CRITICAL: AI must use this before suggesting any code to prevent hallucinations.
{
imports: string[]; // List of imports to verify
methods: string[]; // List of methods/APIs to verify
patterns?: string[]; // Code patterns to verify
}
2. validate_generated_code โ
AI must validate all generated code against project patterns.
{
code: string; // Generated code to validate
context: string; // What the code is supposed to do
targetFile?: string; // Where this code will be placed
}
3. get_pattern_for_task ๐
Get the exact pattern to follow for a specific task.
{
taskType: 'component' | 'hook' | 'service' | 'api' | 'test' | 'error-handling';
requirements?: string[]; // Specific requirements
}
4. check_security_compliance ๐
Verify code meets security requirements before suggesting.
{
code: string; // Code to check
sensitiveOperations?: string[]; // List of sensitive ops
}
5. detect_existing_patterns ๐
Analyze existing code to match patterns when generating new code.
{
directory: string; // Directory to analyze
fileType: string; // Type of files to analyze
}
6. initialize_agent_workspace ๐
Initialize complete AI agent workspace with templates and context.
{
projectPath: string; // Path to project
projectName: string; // Name of project
techStack?: { // Optional tech stack
language?: string;
framework?: string;
uiLibrary?: string;
testFramework?: string;
};
}
7. generate_tests_for_coverage ๐งช
Generate intelligent tests to achieve 80%+ coverage.
{
targetFile: string; // File to test
testFramework?: string; // jest, vitest, mocha
coverageTarget?: number; // Default: 80
includeEdgeCases?: boolean; // Include edge cases
includeAccessibility?: boolean; // Include a11y tests
}
8. track_agent_performance ๐
Track and analyze AI agent performance metrics.
{
featureName: string; // Feature completed
timestamp: string; // ISO timestamp
metrics: {
tokensUsed: number;
timeElapsed: number;
validationScore: number;
securityScore: number;
testCoverage: number;
// ... more metrics
};
}
9. analyze_codebase_deeply ๐ฌ
Perform comprehensive analysis of codebase to understand patterns and architecture.
{
projectPath: string; // Path to analyze
maxDepth?: number; // Max directory depth (default: 5)
excludePatterns?: string[]; // Patterns to exclude
}
10. create_conversation_starters ๐ฌ
Create conversation starters to help AI understand project context quickly.
{
projectPath: string; // Project path
analysisId?: string; // Analysis ID from analyze_codebase_deeply
includeQuickTasks?: boolean; // Include common quick tasks
includeCurrentWork?: boolean; // Include recent git commits
tokenLimit?: number; // Maximum tokens for the file
customTasks?: string[]; // Custom quick tasks to include
}
11. create_token_optimizer ๐
Create tiered context files for token optimization with ROI tracking.
{
projectPath: string; // Project path
analysisId?: string; // Analysis ID
tiers?: ('minimal' | 'standard' | 'comprehensive')[];
trackUsage?: boolean; // Enable token usage tracking
generateMetrics?: boolean; // Generate ROI metrics report
}
12. create_ide_configs ๐ ๏ธ
Create IDE-specific configurations for Cursor, VS Code, and IntelliJ.
{
projectPath: string; // Project path
analysisId?: string; // Analysis ID
ide: 'cursor' | 'vscode' | 'intellij' | 'all';
autoLoadContext?: boolean; // Enable automatic context loading
customRules?: string[]; // Custom rules to add
includeDebugConfigs?: boolean; // Include debugging configurations
}
13. setup_persistence_automation ๐
Set up automated context updates with monitoring and validation.
{
projectPath: string; // Project path
analysisId?: string; // Analysis ID
updateSchedule: 'daily' | 'weekly' | 'on-change' | 'manual';
gitHooks?: boolean; // Install git hooks for validation
monitoring?: boolean; // Enable context monitoring
notifications?: { // Notification settings
email?: string;
slack?: string;
};
}
14. create_maintenance_workflows ๐
Create team workflows for maintaining AI context quality over time.
{
projectPath: string; // Project path
analysisId?: string; // Analysis ID
teamSize: number; // Number of developers
updateFrequency: 'daily' | 'weekly' | 'biweekly' | 'monthly';
includeChecklists?: boolean; // Include review checklists
includeMetrics?: boolean; // Include metrics dashboard
includeTraining?: boolean; // Include training materials
}
15. complete_setup_workflow ๐
Complete MCP setup workflow: analyze codebase, create all context files, and configure automation.
{
projectPath: string; // Project path
projectName: string; // Project name
teamSize?: number; // Team size
updateSchedule?: 'daily' | 'weekly' | 'on-change' | 'manual';
ide?: 'cursor' | 'vscode' | 'intellij' | 'all';
includeAll?: boolean; // Include all optional features
}
Available Prompts (AI Self-Guidance)
1. before_generating_code ๐
AI MUST use this prompt before generating any code.
2. validate_my_suggestion ๐
AI should validate its own code before presenting to user.
3. check_patterns ๐
AI checks if it is following project patterns correctly.
4. prevent_hallucination ๐ง
AI verifies all imports and methods exist before using them.
5. security_self_check ๐
AI checks its own code for security issues.
6. workflow_guidance ๐
Get specific workflow guidance based on task context.
7. performance_check ๐
Track agent performance after completing features.
๐ Workflows
Quick Start with Complete Setup
The fastest way to get started is using the complete_setup_workflow tool:
// In your AI chat:
Use the complete_setup_workflow tool with these parameters:
{
"projectPath": "/path/to/your/project",
"projectName": "My Awesome Project",
"teamSize": 5,
"updateSchedule": "weekly",
"ide": "all"
}
This will:
- ๐ Analyze your entire codebase deeply
- ๐ Create all context files (PROJECT-TEMPLATE.md, CODEBASE-CONTEXT.md)
- ๐ฌ Generate conversation starters for quick AI onboarding
- ๐ Create token-optimized context tiers (saving 70-95% tokens)
- ๐ ๏ธ Generate IDE configs for Cursor, VS Code, and IntelliJ
- ๐ Set up automated updates with git hooks and cron jobs
- ๐ Create team workflows and documentation
After completion:
- Review generated files in
agent-context/directory - Commit all files to version control
- Open in your IDE - context auto-loads!
- Your AI will now understand your project perfectly
New Feature Development
- Initialize workspace with
initialize_agent_workspace - Detect patterns with
detect_existing_patterns - Verify APIs with
check_before_suggesting - Get pattern with
get_pattern_for_task - Generate code following patterns
- Validate with
validate_generated_code - Security check with
check_security_compliance - Generate tests with
generate_tests_for_coverage - Track metrics with
track_agent_performance
Bug Fixing
- Analyze error and affected files
- Check patterns in affected area
- Verify fix approach
- Apply minimal changes
- Validate and test
- Track performance
Code Refactoring
- Analyze current implementation
- Detect existing patterns
- Plan incremental changes
- Validate each change
- Ensure tests pass
- Track improvements
๐ Performance Metrics
The MCP server tracks:
- Token Usage: Average reduction of 30% vs baseline
- Code Quality: Validation scores > 80%
- Security: Zero vulnerabilities in generated code
- Test Coverage: Consistently achieving 80%+
- Development Speed: 2-3x faster with fewer iterations
๐ฏ Best Practices
For AI Agents
- Always verify before suggesting: Use
check_before_suggestingfirst - Follow the workflow: Don't skip validation steps
- Track everything: Use performance metrics for improvement
- Learn from mistakes: Agent memory persists learnings
For Developers
- Initialize workspace: Start projects with proper templates
- Keep context updated: Maintain CODEBASE-CONTEXT.md
- Review agent memory: Check what patterns work best
- Monitor metrics: Use performance data to optimize
Development
# Run in development mode
npm run dev
# Type check
npm run type-check
# Lint
npm run lint
# Build for production
npm run build
Architecture
ai-agent-template-mcp/
โโโ src/
โ โโโ server.ts # Main server entry point
โ โโโ resources/ # Resource handlers
โ โ โโโ index.ts # Resource definitions
โ โ โโโ extractors.ts # Pattern extractors
โ โโโ tools/ # Tool implementations
โ โ โโโ validators/ # Hallucination prevention
โ โ โโโ analyzers/ # Pattern detection
โ โ โโโ patterns/ # Pattern providers
โ โ โโโ workspace/ # Workspace initialization
โ โ โโโ testing/ # Test generation
โ โ โโโ performance/ # Metrics tracking
โ โโโ prompts/ # Workflow guidance
โโโ AGENT-CODING-TEMPLATE.md # Master template
โโโ AGENT-CONTEXT.md # Session tracking
โโโ AGENT-MEMORY.md # Persistent memory
โโโ .context7.yaml # API verification
How It Works
When an AI agent with this MCP server generates code:
-
Pre-Generation Phase:
- AI loads project constraints and patterns
- Detects existing patterns in the codebase
- Verifies all imports and methods exist
- Gets the correct pattern template
-
Generation Phase:
- AI follows the exact patterns from the codebase
- Applies security requirements automatically
- Handles all required states (loading/error/empty)
-
Validation Phase:
- AI validates its own code (must score > 80%)
- Checks for security vulnerabilities
- Ensures pattern compliance
- Only presents code that passes all checks
๐ Results
Based on the AI Agent Template methodology:
Code Quality Improvements
- 53% better test coverage compared to baseline
- 67% fewer bugs in production
- 89% reduction in security vulnerabilities
- Zero hallucinations with verification system
Development Efficiency
- 30% fewer tokens used per feature
- 2-3x faster feature completion
- 60% less time reviewing AI code
- 45% reduction in back-and-forth iterations
Pattern Compliance
- 100% pattern match with existing codebase
- Consistent naming across all generated code
- Proper error handling in every component
- Security best practices automatically applied
๐ฎ Future Enhancements
- Visual Studio Code extension
- GitHub Actions integration
- Multi-language support
- Team pattern sharing
- Advanced analytics dashboard
- Custom pattern training
๐ค Contributing
Contributions are welcome! Please read our contributing guidelines and submit PRs.
๐ License
MIT
Making AI agents write better code than humans since 2024