@172ai/containers-mcp-server 1.0.27 → 1.2.0

package/dist/server.d.ts

@@ -16,6 +16,10 @@ declare class ContainerMCPServer {
      * Set up container management tools
      */
     private setupContainerTools;
+    /**
+     * Get container development workflow prompts
+     */
+    private getContainerWorkflowPrompts;
     /**
      * Get all available tools
      */
@@ -68,6 +72,22 @@ declare class ContainerMCPServer {
     private handleGetExecutionHistory;
     private handleGetCostEstimate;
     private handleGetExtensionCostEstimate;
+    /**
+     * Get container development workflow content
+     */
+    private getContainerDevelopmentWorkflowContent;
+    /**
+     * Get container debugging workflow content
+     */
+    private getContainerDebuggingWorkflowContent;
+    /**
+     * Get container deployment workflow content
+     */
+    private getContainerDeploymentWorkflowContent;
+    /**
+     * Get container best practices content
+     */
+    private getContainerBestPracticesContent;
     /**
      * Start the MCP server
      */

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":";AAuBA;;;;;GAKG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,MAAM,CAAS;;IAcvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuG3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAspBnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;YAoBZ,oBAAoB;YAmBpB,kBAAkB;YAoBlB,qBAAqB;YAerB,qBAAqB;YAcrB,qBAAqB;YAYrB,mBAAmB;YAcnB,oBAAoB;YAepB,oBAAoB;YAmBpB,gBAAgB;YAmBhB,kBAAkB;YAclB,wBAAwB;YAkBxB,oBAAoB;YAiBpB,gBAAgB;YAgBhB,gBAAgB;YAgBhB,gBAAgB;YAYhB,sBAAsB;YAmBtB,mBAAmB;YAmBnB,wBAAwB;YAkBxB,oBAAoB;YAmBpB,mBAAmB;YAcnB,wBAAwB;YAuBxB,oBAAoB;YAwBpB,0BAA0B;YAmB1B,sBAAsB;YAiBtB,qBAAqB;YAcrB,yBAAyB;YAuBzB,qBAAqB;YAyBrB,8BAA8B;IAwB5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyB7B;AAID,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":";AAwBA;;;;;GAKG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,MAAM,CAAS;;IAcvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyH3B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkFnC;;OAEG;IACH,OAAO,CAAC,WAAW;IAspBnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;YAoBZ,oBAAoB;YAmBpB,kBAAkB;YAoBlB,qBAAqB;YAerB,qBAAqB;YAcrB,qBAAqB;YAYrB,mBAAmB;YAcnB,oBAAoB;YAepB,oBAAoB;YAmBpB,gBAAgB;YAmBhB,kBAAkB;YAclB,wBAAwB;YAkBxB,oBAAoB;YAiBpB,gBAAgB;YAgBhB,gBAAgB;YAgBhB,gBAAgB;YAYhB,sBAAsB;YAmBtB,mBAAmB;YAmBnB,wBAAwB;YAkBxB,oBAAoB;YAmBpB,mBAAmB;YAcnB,wBAAwB;YAuBxB,oBAAoB;YAwBpB,0BAA0B;YAmB1B,sBAAsB;YAiBtB,qBAAqB;YAcrB,yBAAyB;YAuBzB,qBAAqB;YAyBrB,8BAA8B;IAwB5C;;OAEG;IACH,OAAO,CAAC,sCAAsC;IA0F9C;;OAEG;IACH,OAAO,CAAC,oCAAoC;IAgG5C;;OAEG;IACH,OAAO,CAAC,qCAAqC;IA8H7C;;OAEG;IACH,OAAO,CAAC,gCAAgC;IAqLxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyB7B;AAID,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/server.js

@@ -57,9 +57,25 @@ class ContainerMCPServer {
         // Handle prompts/list requests
         this.server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => {
             return {
-                prompts: [],
+                prompts: this.getContainerWorkflowPrompts(),
             };
         });
+        // Handle prompts/get requests
+        this.server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case 'container_development_workflow':
+                    return this.getContainerDevelopmentWorkflowContent(args);
+                case 'container_debugging_workflow':
+                    return this.getContainerDebuggingWorkflowContent(args);
+                case 'container_deployment_workflow':
+                    return this.getContainerDeploymentWorkflowContent(args);
+                case 'container_best_practices':
+                    return this.getContainerBestPracticesContent();
+                default:
+                    throw errorHandler_js_1.ErrorHandler.createValidationError(`Unknown prompt: ${name}`);
+            }
+        });
         // Handle resources/list requests
         this.server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
             return {
@@ -145,6 +161,90 @@ class ContainerMCPServer {
             }
         });
     }
+    /**
+     * Get container development workflow prompts
+     */
+    getContainerWorkflowPrompts() {
+        return [
+            {
+                name: "container_development_workflow",
+                title: "Complete Container Development Workflow",
+                description: "Step-by-step guide for creating, building, and deploying containers from customer requirements",
+                arguments: [
+                    {
+                        name: "customer_request",
+                        description: "The customer's requirements for the container application",
+                        required: true
+                    },
+                    {
+                        name: "application_type",
+                        description: "Type of application (web app, API service, worker, CLI tool, etc.)",
+                        required: false
+                    },
+                    {
+                        name: "programming_language",
+                        description: "Preferred programming language (if any)",
+                        required: false
+                    },
+                    {
+                        name: "framework",
+                        description: "Preferred framework or technology stack (if any)",
+                        required: false
+                    }
+                ]
+            },
+            {
+                name: "container_debugging_workflow",
+                title: "Container Build & Runtime Debugging",
+                description: "Troubleshooting guide for container build failures and runtime errors",
+                arguments: [
+                    {
+                        name: "container_id",
+                        description: "ID of the container experiencing issues",
+                        required: true
+                    },
+                    {
+                        name: "error_type",
+                        description: "Type of error (build_failure, runtime_error, deployment_error)",
+                        required: true
+                    },
+                    {
+                        name: "error_message",
+                        description: "The specific error message or log output",
+                        required: false
+                    }
+                ]
+            },
+            {
+                name: "container_deployment_workflow",
+                title: "Container Deployment & Monitoring",
+                description: "Best practices for deploying containers and monitoring their execution",
+                arguments: [
+                    {
+                        name: "container_id",
+                        description: "ID of the container to deploy",
+                        required: true
+                    },
+                    {
+                        name: "deployment_environment",
+                        description: "Target deployment environment (development, staging, production)",
+                        required: false
+                    },
+                    {
+                        name: "resource_requirements",
+                        description: "Expected CPU, memory, and duration requirements",
+                        required: false
+                    }
+                ]
+            },
+            {
+                name: "container_best_practices",
+                title: "Container Development Best Practices",
+                description: "Guidelines and recommendations for creating high-quality, secure containers",
+                arguments: []
+            }
+        ];
+    }
     /**
      * Get all available tools
      */
@@ -1305,6 +1405,504 @@ class ContainerMCPServer {
             ],
         };
     }
+    /**
+     * Get container development workflow content
+     */
+    getContainerDevelopmentWorkflowContent(args) {
+        const { customer_request, application_type, programming_language, framework } = args;
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `I need to create a container application. Here are the requirements:
+
+**Customer Request:** ${customer_request}
+${application_type ? `**Application Type:** ${application_type}\n` : ''}${programming_language ? `**Programming Language:** ${programming_language}\n` : ''}${framework ? `**Framework/Stack:** ${framework}\n` : ''}
+
+Please follow this comprehensive workflow to create, build, and deploy the container:
+
+## Phase 1: Code Development & Local Files
+1. **Analyze Requirements**: Break down the customer request into specific features and technical requirements
+2. **Create Application Architecture**: Design the application structure and identify needed components
+3. **Write Application Code**: Create all necessary code files locally
+4. **Create Dockerfile**: Write an optimized, multi-stage Dockerfile following best practices
+5. **Prepare Supporting Files**: Create configuration files, requirements files, and documentation
+
+## Phase 2: Container Creation & Setup
+6. **Create Container**: Use \`create_container\` tool with:
+   - Descriptive name based on the application purpose
+   - Short description (1-2 sentences)
+   - Long description in Markdown with features, usage, and deployment notes
+   - Relevant tags for discoverability
+   - Appropriate capabilities based on application needs
+   - Set private/public visibility as appropriate
+
+7. **Upload Application Files**: Use \`upload_file\` tool to add all code files:
+   - Upload Dockerfile first
+   - Upload application code in logical order (main files first)
+   - Upload configuration and support files
+   - Verify uploads with \`list_container_files\`
+
+8. **Configure Environment Variables**: Add environment variables one-by-one using \`update_container\`:
+   - Database connections
+   - API keys and secrets (use placeholders)
+   - Configuration settings
+   - Port numbers and service endpoints
+
+## Phase 3: Build Process
+9. **Initiate Build**: Use \`build_container\` tool to start the container build
+10. **Monitor Build Progress**: Check build status every 15 seconds using \`get_build_status\`
+11. **Handle Build Errors**: If build fails:
+    - Get detailed error logs with \`get_build_logs\`
+    - Analyze error messages and identify issues
+    - Update problematic files using \`update_file\`
+    - Delete and re-upload fixed files if needed
+    - Restart build process
+    - Repeat until build succeeds
+
+## Phase 4: Deployment & Testing
+12. **Start Container Execution**: Use \`start_execution\` with appropriate duration and resource settings
+13. **Monitor Execution**: Check execution status and logs using \`get_execution_status\` and \`get_execution_logs\`
+14. **Handle Runtime Errors**: If execution fails:
+    - Analyze execution logs for runtime issues
+    - Update code files to fix runtime problems
+    - Rebuild the container (repeat Phase 3)
+    - Restart execution
+    - Test functionality through the provided access URL
+
+## Phase 5: Validation & Documentation
+15. **Functional Testing**: Verify all features work as expected
+16. **Performance Testing**: Check resource usage and performance
+17. **Security Review**: Ensure no secrets are exposed and security best practices are followed
+18. **Update Documentation**: Enhance container description with deployment notes and usage examples
+
+## Best Practices to Follow:
+- Use multi-stage builds to minimize image size
+- Set proper file permissions and use non-root users when possible
+- Include health checks in the Dockerfile
+- Use environment variables for configuration
+- Add comprehensive error handling and logging
+- Include proper documentation and examples
+- Tag containers appropriately for discoverability
+- Set resource limits based on application needs
+- Use secrets management for sensitive data
+- Include monitoring and observability features
+
+Start with Phase 1 and work through each step systematically. Let me know if you encounter any issues or need clarification on any step.`
+                    }
+                }
+            ]
+        };
+    }
+    /**
+     * Get container debugging workflow content
+     */
+    getContainerDebuggingWorkflowContent(args) {
+        const { container_id, error_type, error_message } = args;
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `Help me debug container issues for container ${container_id}.
+
+**Error Type:** ${error_type}
+${error_message ? `**Error Message:** ${error_message}\n` : ''}
+
+Please follow this systematic debugging workflow:
+
+## Step 1: Gather Information
+1. **Get Container Details**: Use \`get_container\` to understand the current configuration
+2. **Check Build Status**: Use \`get_build_status\` to see the latest build information
+3. **Review Build Logs**: Use \`get_build_logs\` to analyze build output and errors
+4. **Check Execution Status**: Use \`get_execution_status\` if the container was deployed
+5. **Review Execution Logs**: Use \`get_execution_logs\` to see runtime error details
+
+## Step 2: Identify Root Cause
+Based on the error type, focus on specific areas:
+
+### Build Failures:
+- **Dockerfile Issues**: Syntax errors, invalid instructions, missing dependencies
+- **Code Compilation**: Language-specific build errors, missing packages
+- **File Permissions**: Incorrect file access or execution permissions
+- **Resource Limits**: Build process running out of memory or disk space
+- **Network Issues**: Package downloads or external service access failures
+
+### Runtime Errors:
+- **Configuration Issues**: Missing or incorrect environment variables
+- **Dependency Problems**: Missing runtime libraries or incorrect versions
+- **Port Conflicts**: Application trying to bind to unavailable ports
+- **Permission Issues**: Application lacking required file or network permissions
+- **Resource Constraints**: Insufficient CPU, memory, or disk space
+
+### Deployment Errors:
+- **Image Issues**: Corrupted or incomplete container image
+- **Network Problems**: Service discovery or external connectivity issues
+- **Health Check Failures**: Application not responding to health check endpoints
+- **Resource Allocation**: Insufficient cluster resources or quota limits
+
+## Step 3: Fix Identified Issues
+1. **Update Code Files**: Use \`update_file\` to fix code issues
+2. **Modify Dockerfile**: Update container configuration and build instructions  
+3. **Adjust Environment Variables**: Add or modify required environment settings
+4. **Update Dependencies**: Fix package versions or add missing dependencies
+5. **Improve Error Handling**: Add better logging and error management to code
+
+## Step 4: Test Fixes
+1. **Rebuild Container**: Use \`build_container\` to create new image with fixes
+2. **Monitor Build**: Check \`get_build_status\` every 15 seconds until completion
+3. **Verify Build Success**: Ensure build completes without errors
+4. **Test Deployment**: Use \`start_execution\` to deploy updated container
+5. **Validate Functionality**: Test all features to ensure issues are resolved
+
+## Step 5: Prevent Future Issues
+1. **Improve Documentation**: Update container description with troubleshooting notes
+2. **Add Health Checks**: Include comprehensive health monitoring
+3. **Enhance Logging**: Improve application logging for better debugging
+4. **Set Appropriate Resources**: Configure proper CPU, memory, and timeout settings
+5. **Add Monitoring**: Include metrics and alerting for proactive issue detection
+
+## Common Issue Patterns:
+
+### "Permission Denied" Errors:
+- Switch to non-root user in Dockerfile
+- Set proper file permissions (chmod)
+- Check if application needs specific capabilities
+
+### "Cannot Connect" Errors:
+- Verify correct port configuration
+- Check firewall and network policies  
+- Ensure services are listening on correct interfaces
+
+### "Out of Memory" Errors:
+- Increase memory limits in execution settings
+- Optimize application memory usage
+- Use memory-efficient algorithms and data structures
+
+### "Build Timeout" Errors:
+- Optimize Dockerfile for faster builds
+- Use build caches and multi-stage builds
+- Check for infinite loops or hanging processes
+
+Start debugging systematically and let me know what you discover in each step.`
+                    }
+                }
+            ]
+        };
+    }
+    /**
+     * Get container deployment workflow content
+     */
+    getContainerDeploymentWorkflowContent(args) {
+        const { container_id, deployment_environment, resource_requirements } = args;
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `Let's deploy container ${container_id} following deployment best practices.
+
+${deployment_environment ? `**Target Environment:** ${deployment_environment}\n` : ''}${resource_requirements ? `**Resource Requirements:** ${resource_requirements}\n` : ''}
+
+Follow this comprehensive deployment workflow:
+
+## Phase 1: Pre-Deployment Validation
+1. **Verify Container Status**: Use \`get_container\` to review configuration
+2. **Check Build Status**: Ensure latest build completed successfully with \`get_build_status\`
+3. **Review Build Logs**: Verify no warnings or issues in \`get_build_logs\`
+4. **Validate Configuration**: Check environment variables and settings are appropriate
+5. **Security Audit**: Ensure no secrets are hardcoded and proper security practices
+
+## Phase 2: Resource Planning
+6. **Get Cost Estimate**: Use \`get_cost_estimate\` with expected resource settings:
+   - **Development**: CPU: 1, Memory: 1Gi, Duration: 1-3 days
+   - **Testing/Staging**: CPU: 1-2, Memory: 2-4Gi, Duration: 3-7 days  
+   - **Production**: CPU: 2-4, Memory: 4-8Gi, Duration: 7-30 days
+
+7. **Plan Duration**: Set appropriate runtime duration based on:
+   - Development/testing: 1-3 days for quick iterations
+   - Staging/demo: 3-7 days for extended testing
+   - Production: 7-30 days for stable operations
+
+## Phase 3: Deployment Execution
+8. **Configure Environment Variables**: Set deployment-specific variables:
+   - Database URLs and connection strings
+   - API endpoints and service URLs
+   - Feature flags and configuration toggles
+   - Monitoring and logging endpoints
+
+9. **Start Execution**: Use \`start_execution\` with:
+   - Appropriate duration for environment
+   - Proper resource allocation (CPU/Memory)
+   - Environment-specific variable overrides
+
+10. **Monitor Startup**: Track deployment progress:
+    - Check \`get_execution_status\` every 30 seconds initially
+    - Monitor \`get_execution_progress\` for detailed startup phases
+    - Review \`get_execution_logs\` for startup messages and errors
+
+## Phase 4: Post-Deployment Validation
+11. **Health Checks**: Verify application is responding:
+    - Test primary endpoints using the access URL
+    - Verify database connections and external services
+    - Check application metrics and performance indicators
+
+12. **Functional Testing**: Validate core features:
+    - Test all major user workflows
+    - Verify API endpoints and data processing
+    - Check integration with external systems
+
+13. **Performance Testing**: Monitor resource usage:
+    - Check CPU and memory utilization
+    - Monitor response times and throughput
+    - Verify application handles expected load
+
+## Phase 5: Monitoring & Maintenance
+14. **Set Up Monitoring**: Track key metrics:
+    - Application health and availability
+    - Resource utilization trends
+    - Error rates and performance metrics
+    - User activity and business metrics
+
+15. **Plan Maintenance**: Schedule ongoing tasks:
+    - Regular health checks and status monitoring
+    - Log review and analysis
+    - Performance optimization opportunities
+    - Security updates and patches
+
+## Environment-Specific Considerations:
+
+### Development Environment:
+- Use minimal resources (1 CPU, 1Gi RAM)
+- Enable debug logging and detailed error messages
+- Allow rapid iteration with shorter durations
+- Include development tools and debugging capabilities
+
+### Staging Environment:
+- Mirror production resources but at smaller scale
+- Enable comprehensive logging and monitoring
+- Use production-like data volumes and load patterns
+- Test deployment procedures and rollback scenarios
+
+### Production Environment:
+- Use appropriate resource allocation for expected load
+- Enable comprehensive monitoring and alerting
+- Implement proper backup and disaster recovery
+- Follow security hardening and compliance requirements
+
+## Troubleshooting Deployment Issues:
+
+### Slow Startup:
+- Check resource allocation (CPU/Memory)
+- Review startup logs for bottlenecks
+- Optimize initialization procedures
+- Consider increasing startup timeout
+
+### Connection Failures:
+- Verify network configuration and firewall rules
+- Check service discovery and DNS resolution
+- Validate external service endpoints
+- Test connectivity from deployment environment
+
+### Resource Constraints:
+- Monitor actual vs. allocated resources
+- Check for memory leaks or CPU spikes
+- Consider scaling up resource allocation
+- Optimize application resource usage
+
+Start the deployment process and monitor each phase carefully. Let me know if you encounter any issues during deployment.`
+                    }
+                }
+            ]
+        };
+    }
+    /**
+     * Get container best practices content
+     */
+    getContainerBestPracticesContent() {
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `Here are comprehensive best practices for container development with the 172.ai platform:
+
+## Dockerfile Best Practices
+
+### 1. Multi-Stage Builds
+\`\`\`dockerfile
+# Use multi-stage builds to reduce final image size
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+FROM node:18-alpine AS runtime
+WORKDIR /app
+COPY --from=builder /app/node_modules ./node_modules
+COPY . .
+EXPOSE 3000
+CMD ["node", "index.js"]
+\`\`\`
+
+### 2. Security Hardening
+\`\`\`dockerfile
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nextjs -u 1001
+
+# Set proper file permissions
+COPY --chown=nextjs:nodejs . .
+USER nextjs
+
+# Use specific base image versions
+FROM node:18.17.0-alpine
+\`\`\`
+
+### 3. Layer Optimization
+\`\`\`dockerfile
+# Combine RUN commands to reduce layers
+RUN apt-get update && apt-get install -y \\
+    git \\
+    curl \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy dependency files first for better caching
+COPY package*.json ./
+RUN npm install
+COPY . .
+\`\`\`
+
+## Container Configuration Best Practices
+
+### 1. Environment Variables
+- Use environment variables for all configuration
+- Provide sensible defaults where possible
+- Document all required and optional variables
+- Use secrets management for sensitive data
+
+### 2. Health Checks
+\`\`\`dockerfile
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD curl -f http://localhost:3000/health || exit 1
+\`\`\`
+
+### 3. Resource Limits
+- Set appropriate CPU and memory limits
+- Consider application startup time for duration planning
+- Monitor actual resource usage vs. allocated
+
+## Development Workflow Best Practices
+
+### 1. Code Organization
+- Keep application code modular and well-structured
+- Include comprehensive error handling and logging
+- Use configuration files for environment-specific settings
+- Include proper documentation and README files
+
+### 2. File Management
+- Upload files in logical order (dependencies first)
+- Use clear, descriptive file names
+- Organize files in proper directory structure
+- Remove unnecessary files to reduce image size
+
+### 3. Build Process
+- Monitor builds closely (check every 15 seconds)
+- Review build logs for warnings and optimization opportunities
+- Fix build issues incrementally
+- Use build arguments for customization
+
+## Deployment Best Practices
+
+### 1. Environment Management
+- Use separate configurations for dev/staging/production
+- Test in staging environments before production deployment
+- Implement proper rollback procedures
+- Monitor deployments closely during startup
+
+### 2. Resource Planning
+- Start with conservative resource allocation
+- Monitor actual usage and adjust as needed
+- Plan duration based on environment and use case
+- Consider cost implications of resource choices
+
+### 3. Monitoring & Observability
+- Include comprehensive logging in applications
+- Implement health check endpoints
+- Monitor key performance and business metrics
+- Set up alerting for critical issues
+
+## Security Best Practices
+
+### 1. Image Security
+- Use official base images from trusted sources
+- Keep base images updated with security patches
+- Scan images for known vulnerabilities
+- Remove unnecessary packages and tools
+
+### 2. Runtime Security
+- Run containers with non-root users
+- Limit container capabilities and privileges
+- Use read-only filesystems where possible
+- Implement proper network segmentation
+
+### 3. Secrets Management
+- Never hardcode secrets in images or configuration
+- Use environment variables for runtime secrets
+- Implement proper secret rotation procedures
+- Audit access to sensitive configuration
+
+## Performance Optimization
+
+### 1. Application Performance
+- Implement efficient algorithms and data structures
+- Use appropriate caching strategies
+- Optimize database queries and external API calls
+- Monitor and profile application performance
+
+### 2. Container Performance
+- Minimize image size through multi-stage builds
+- Use appropriate base images for your runtime
+- Optimize startup time and resource utilization
+- Implement graceful shutdown procedures
+
+### 3. Resource Efficiency
+- Right-size resource allocations based on actual usage
+- Use horizontal scaling when appropriate
+- Implement efficient data processing patterns
+- Monitor and optimize memory usage
+
+## Testing & Quality Assurance
+
+### 1. Container Testing
+- Test containers in environments similar to production
+- Validate all environment variable combinations
+- Test startup, shutdown, and restart procedures
+- Verify health checks and monitoring endpoints
+
+### 2. Integration Testing
+- Test integration with external services and APIs
+- Validate data processing and business logic
+- Test error handling and recovery procedures
+- Verify security controls and access restrictions
+
+### 3. Performance Testing
+- Load test applications under expected traffic
+- Test resource utilization under various conditions
+- Validate scaling behavior and limits
+- Test recovery from failure scenarios
+
+Follow these best practices to create robust, secure, and efficient containerized applications on the 172.ai platform.`
+                    }
+                }
+            ]
+        };
+    }
     /**
      * Start the MCP server
      */