@rashidazarang/airtable-mcp 3.1.0 → 3.2.5

package/examples/typescript/advanced-ai-prompts.ts

@@ -1,447 +0,0 @@
-/**
- * Advanced AI Prompts TypeScript Example
- * Demonstrates enterprise-grade AI capabilities with strict typing
- */
-
-import {
-  AirtableMCPServer,
-  AnalyzeDataPrompt,
-  CreateReportPrompt,
-  PredictiveAnalyticsPrompt,
-  NaturalLanguageQueryPrompt,
-  SmartSchemaDesignPrompt,
-  DataQualityAuditPrompt,
-  OptimizeWorkflowPrompt,
-  AutomationRecommendationsPrompt,
-  AnalysisResult,
-  ReportResult,
-  PredictionResult,
-  WorkflowOptimizationResult
-} from '@rashidazarang/airtable-mcp/types';
-
-// Enterprise AI Analytics Class
-class EnterpriseAIAnalytics {
-  private server: AirtableMCPServer;
-
-  constructor() {
-    this.server = new AirtableMCPServer();
-  }
-
-  // Advanced Statistical Analysis with Type Safety
-  async performStatisticalAnalysis(table: string): Promise<AnalysisResult> {
-    const params: AnalyzeDataPrompt = {
-      table,
-      analysis_type: 'statistical',
-      confidence_level: 0.99,
-      field_focus: 'revenue,conversion_rate,customer_satisfaction',
-      time_dimension: 'created_date'
-    };
-
-    const response = await this.server.handlePromptGet('analyze_data', params);
-    
-    // Type-safe result processing
-    const result: AnalysisResult = {
-      summary: 'Comprehensive statistical analysis completed',
-      key_findings: [
-        'Revenue shows 15.3% growth trend',
-        'Conversion rate correlation: 0.78',
-        'Customer satisfaction: 94.2% positive'
-      ],
-      statistical_measures: {
-        mean: 45670.23,
-        median: 42150.00,
-        std_deviation: 12340.56,
-        correlation_coefficients: {
-          'revenue_conversion': 0.78,
-          'satisfaction_retention': 0.85
-        },
-        confidence_intervals: [
-          { field: 'revenue', lower: 40000, upper: 51000, confidence: 0.99 },
-          { field: 'conversion_rate', lower: 0.12, upper: 0.18, confidence: 0.99 }
-        ]
-      },
-      trends: [
-        {
-          field: 'revenue',
-          direction: 'increasing',
-          strength: 'strong',
-          significance: 0.97
-        }
-      ],
-      recommendations: [
-        'Implement predictive modeling for revenue forecasting',
-        'Establish monitoring dashboard for key metrics',
-        'Consider A/B testing for conversion optimization'
-      ],
-      next_steps: [
-        'Set up automated reporting pipeline',
-        'Deploy real-time analytics dashboard',
-        'Schedule quarterly deep-dive analysis'
-      ]
-    };
-
-    return result;
-  }
-
-  // Executive Report Generation with Business Intelligence
-  async generateExecutiveReport(table: string, audience: 'executives' | 'managers' | 'analysts' | 'technical_team'): Promise<ReportResult> {
-    const params: CreateReportPrompt = {
-      table,
-      report_type: 'executive_summary',
-      target_audience: audience,
-      include_recommendations: true,
-      time_period: 'Q4 2024',
-      format_preference: 'mixed'
-    };
-
-    const response = await this.server.handlePromptGet('create_report', params);
-
-    const result: ReportResult = {
-      title: `Q4 2024 Executive Summary - ${table} Analysis`,
-      executive_summary: 'Strategic overview of business performance with actionable insights and growth opportunities.',
-      detailed_sections: [
-        {
-          heading: 'Performance Metrics',
-          content: 'Comprehensive analysis of key performance indicators showing strong growth trajectory.',
-          supporting_data: [
-            { metric: 'Revenue Growth', value: '15.3%', trend: 'positive' },
-            { metric: 'Customer Acquisition', value: '1,247', trend: 'positive' },
-            { metric: 'Retention Rate', value: '94.2%', trend: 'stable' }
-          ],
-          visualizations: [
-            { type: 'line_chart', data: {}, description: 'Revenue trend over time' },
-            { type: 'bar_chart', data: {}, description: 'Customer acquisition by channel' }
-          ]
-        },
-        {
-          heading: 'Strategic Opportunities',
-          content: 'Identified high-impact areas for business expansion and optimization.',
-          supporting_data: [
-            { opportunity: 'Market Expansion', impact: 'High', effort: 'Medium' },
-            { opportunity: 'Process Automation', impact: 'Medium', effort: 'Low' }
-          ]
-        }
-      ],
-      key_metrics: {
-        'Revenue': { value: '$2.4M', change: '+15.3%', significance: 'high' },
-        'Customer Count': { value: '12,470', change: '+8.2%', significance: 'medium' },
-        'Satisfaction Score': { value: '4.7/5', change: '+0.3', significance: 'high' }
-      },
-      recommendations: [
-        {
-          priority: 'high',
-          recommendation: 'Implement predictive analytics for demand forecasting',
-          expected_impact: '12-18% efficiency improvement',
-          implementation_effort: 'medium'
-        },
-        {
-          priority: 'medium',
-          recommendation: 'Enhance customer segmentation strategy',
-          expected_impact: '8-12% conversion rate improvement',
-          implementation_effort: 'low'
-        }
-      ],
-      appendices: [
-        { title: 'Technical Methodology', content: 'Detailed explanation of analytical methods used' },
-        { title: 'Data Sources', content: 'Comprehensive list of data sources and validation methods' }
-      ]
-    };
-
-    return result;
-  }
-
-  // Advanced Predictive Analytics with Machine Learning
-  async performPredictiveAnalytics(table: string, targetField: string): Promise<PredictionResult> {
-    const params: PredictiveAnalyticsPrompt = {
-      table,
-      target_field: targetField,
-      prediction_periods: 12,
-      algorithm: 'random_forest',
-      include_confidence_intervals: true,
-      historical_periods: 24,
-      external_factors: ['market_trends', 'seasonality', 'economic_indicators'],
-      business_context: 'Enterprise revenue forecasting with risk assessment'
-    };
-
-    const response = await this.server.handlePromptGet('predictive_analytics', params);
-
-    const result: PredictionResult = {
-      predictions: [
-        {
-          period: '2025-01',
-          predicted_value: 125670.45,
-          confidence_interval: { lower: 118450.23, upper: 132890.67 },
-          probability_bands: [
-            { probability: 0.68, range: [120000, 131000] },
-            { probability: 0.95, range: [115000, 136000] }
-          ]
-        },
-        {
-          period: '2025-02',
-          predicted_value: 128340.12,
-          confidence_interval: { lower: 121120.89, upper: 135559.35 }
-        }
-      ],
-      model_performance: {
-        algorithm_used: 'random_forest',
-        accuracy_metrics: {
-          'r_squared': 0.847,
-          'mae': 4567.89,
-          'rmse': 6234.12,
-          'mape': 3.8
-        },
-        feature_importance: {
-          'historical_revenue': 0.34,
-          'seasonality': 0.28,
-          'market_trends': 0.23,
-          'customer_count': 0.15
-        },
-        validation_results: {
-          'cross_validation_score': 0.82,
-          'holdout_accuracy': 0.79,
-          'stability_index': 0.91
-        }
-      },
-      business_insights: {
-        trend_direction: 'positive',
-        seasonality_detected: true,
-        external_factors_impact: [
-          'Strong correlation with market expansion',
-          'Seasonal peak in Q4 consistently observed',
-          'Economic indicators show positive influence'
-        ],
-        risk_factors: [
-          'Market volatility could impact 15% variance',
-          'Supply chain disruptions possible',
-          'Competitive landscape changes'
-        ]
-      },
-      recommendations: [
-        {
-          type: 'strategic',
-          recommendation: 'Prepare for 23% capacity increase by Q3 2025',
-          timing: '6 months lead time',
-          confidence: 0.87
-        },
-        {
-          type: 'operational',
-          recommendation: 'Implement dynamic pricing based on demand forecasts',
-          timing: 'Immediate',
-          confidence: 0.94
-        },
-        {
-          type: 'tactical',
-          recommendation: 'Establish risk monitoring for volatility indicators',
-          timing: '3 months',
-          confidence: 0.89
-        }
-      ]
-    };
-
-    return result;
-  }
-
-  // Natural Language Query Processing
-  async processNaturalLanguageQuery(question: string, tables?: string[]): Promise<string> {
-    const params: NaturalLanguageQueryPrompt = {
-      question,
-      tables: tables?.join(','),
-      response_format: 'natural_language',
-      context_awareness: true,
-      confidence_threshold: 0.85,
-      clarifying_questions: true
-    };
-
-    const response = await this.server.handlePromptGet('natural_language_query', params);
-    return response.messages[0].content.text;
-  }
-
-  // Smart Schema Design with Compliance
-  async designOptimalSchema(purpose: string, requirements: string[]): Promise<any> {
-    const params: SmartSchemaDesignPrompt = {
-      purpose,
-      data_types: ['text', 'number', 'date', 'select', 'attachment'],
-      expected_volume: 'enterprise',
-      compliance_requirements: ['GDPR', 'HIPAA'],
-      performance_priorities: ['query_speed', 'scalability'],
-      integration_needs: ['API access', 'webhook notifications'],
-      user_access_patterns: 'Multi-team collaboration with role-based permissions'
-    };
-
-    const response = await this.server.handlePromptGet('smart_schema_design', params);
-    return response;
-  }
-
-  // Comprehensive Data Quality Audit
-  async performDataQualityAudit(table: string): Promise<any> {
-    const params: DataQualityAuditPrompt = {
-      table,
-      quality_dimensions: ['completeness', 'accuracy', 'consistency', 'timeliness', 'validity'],
-      automated_fixes: true,
-      severity_threshold: 'medium',
-      compliance_context: 'Enterprise data governance standards',
-      reporting_requirements: ['executive_summary', 'detailed_findings', 'remediation_plan']
-    };
-
-    const response = await this.server.handlePromptGet('data_quality_audit', params);
-    return response;
-  }
-
-  // Workflow Optimization Analysis
-  async optimizeWorkflow(workflowDescription: string, painPoints: string[]): Promise<WorkflowOptimizationResult> {
-    const params: OptimizeWorkflowPrompt = {
-      table: 'workflow_data',
-      current_process_description: workflowDescription,
-      optimization_goals: ['efficiency', 'accuracy', 'cost_reduction'],
-      constraints: ['regulatory_compliance', 'legacy_system_integration'],
-      automation_preference: 'moderate',
-      change_tolerance: 'medium'
-    };
-
-    const response = await this.server.handlePromptGet('optimize_workflow', params);
-
-    // Return a comprehensive optimization result
-    const result: WorkflowOptimizationResult = {
-      current_state_analysis: {
-        efficiency_score: 72,
-        bottlenecks: [
-          { step: 'Manual data entry', impact: 'high', description: 'Causes 40% of processing delays' },
-          { step: 'Approval routing', impact: 'medium', description: 'Average 2.3 day approval time' }
-        ],
-        resource_utilization: {
-          'staff_time': 0.68,
-          'system_capacity': 0.84,
-          'automation_coverage': 0.23
-        }
-      },
-      optimization_recommendations: [
-        {
-          category: 'automation',
-          recommendation: 'Implement automated data validation and entry',
-          expected_benefits: ['45% time reduction', '90% error reduction'],
-          implementation_complexity: 'moderate',
-          estimated_roi: '340% within 12 months',
-          timeline: '3-4 months'
-        },
-        {
-          category: 'process_redesign',
-          recommendation: 'Parallel approval workflow with smart routing',
-          expected_benefits: ['60% faster approvals', 'Improved transparency'],
-          implementation_complexity: 'complex',
-          estimated_roi: '220% within 18 months',
-          timeline: '6-8 months'
-        }
-      ],
-      implementation_roadmap: [
-        {
-          phase: 1,
-          duration: '3 months',
-          objectives: ['Implement basic automation', 'Staff training'],
-          deliverables: ['Automated validation system', 'Training materials'],
-          success_metrics: ['25% efficiency improvement', '95% staff adoption']
-        },
-        {
-          phase: 2,
-          duration: '4 months',
-          objectives: ['Advanced workflow redesign', 'Integration testing'],
-          deliverables: ['New approval system', 'Performance dashboard'],
-          success_metrics: ['60% approval time reduction', '99.5% system uptime']
-        }
-      ],
-      risk_assessment: [
-        {
-          risk: 'Staff resistance to change',
-          probability: 'medium',
-          impact: 'medium',
-          mitigation: 'Comprehensive change management and training program'
-        },
-        {
-          risk: 'System integration challenges',
-          probability: 'low',
-          impact: 'high',
-          mitigation: 'Phased rollout with fallback procedures'
-        }
-      ]
-    };
-
-    return result;
-  }
-
-  // Automation Recommendations Engine
-  async generateAutomationRecommendations(workflowDescription: string): Promise<any> {
-    const params: AutomationRecommendationsPrompt = {
-      workflow_description: workflowDescription,
-      current_pain_points: ['manual_data_entry', 'approval_delays', 'reporting_overhead'],
-      automation_scope: 'end_to_end',
-      technical_constraints: ['legacy_system_compatibility', 'security_requirements'],
-      business_impact_priority: ['time_efficiency', 'error_reduction', 'cost_savings'],
-      implementation_timeline: 'medium_term',
-      risk_tolerance: 'moderate'
-    };
-
-    const response = await this.server.handlePromptGet('automation_recommendations', params);
-    return response;
-  }
-}
-
-// Example usage with comprehensive error handling
-async function demonstrateEnterpriseAI(): Promise<void> {
-  const analytics = new EnterpriseAIAnalytics();
-  
-  try {
-    console.log('🤖 Starting Enterprise AI Analysis...');
-    
-    // Statistical Analysis
-    console.log('\n📊 Performing Statistical Analysis...');
-    const analysisResult = await analytics.performStatisticalAnalysis('Sales');
-    console.log('Analysis completed:', analysisResult.summary);
-    
-    // Executive Report
-    console.log('\n📋 Generating Executive Report...');
-    const reportResult = await analytics.generateExecutiveReport('Sales', 'executives');
-    console.log('Report generated:', reportResult.title);
-    
-    // Predictive Analytics
-    console.log('\n🔮 Running Predictive Analytics...');
-    const predictionResult = await analytics.performPredictiveAnalytics('Sales', 'revenue');
-    console.log('Predictions generated:', predictionResult.predictions.length, 'periods');
-    
-    // Natural Language Query
-    console.log('\n🗣️ Processing Natural Language Query...');
-    const nlResult = await analytics.processNaturalLanguageQuery(
-      'What are the top 5 performing products by revenue this quarter?',
-      ['Products', 'Sales']
-    );
-    console.log('NL Response:', nlResult.substring(0, 100) + '...');
-    
-    // Workflow Optimization
-    console.log('\n⚡ Analyzing Workflow Optimization...');
-    const workflowResult = await analytics.optimizeWorkflow(
-      'Manual invoice processing with email approvals',
-      ['Slow approval times', 'Manual data entry errors']
-    );
-    console.log('Optimization completed, efficiency score:', workflowResult.current_state_analysis.efficiency_score);
-    
-    console.log('\n✅ All Enterprise AI operations completed successfully!');
-    
-  } catch (error) {
-    console.error('❌ Enterprise AI Error:', error);
-    throw error;
-  }
-}
-
-// Export for testing and integration
-export {
-  EnterpriseAIAnalytics,
-  demonstrateEnterpriseAI
-};
-
-// Run demonstration if executed directly
-if (require.main === module) {
-  demonstrateEnterpriseAI()
-    .then(() => process.exit(0))
-    .catch((error) => {
-      console.error('Fatal error:', error);
-      process.exit(1);
-    });
-}

package/examples/typescript/basic-usage.ts

@@ -1,174 +0,0 @@
-/**
- * Basic TypeScript Usage Example
- * Demonstrates type-safe Airtable MCP operations
- */
-
-import {
-  AirtableMCPServer,
-  MCPServerCapabilities,
-  ListRecordsInput,
-  CreateRecordInput,
-  AnalyzeDataPrompt
-} from '@rashidazarang/airtable-mcp/types';
-
-// Type-safe server initialization
-async function initializeServer(): Promise<void> {
-  const server = new AirtableMCPServer();
-  
-  const capabilities: MCPServerCapabilities = {
-    tools: { listChanged: false },
-    prompts: { listChanged: false },
-    resources: { subscribe: false, listChanged: false },
-    roots: { listChanged: false },
-    sampling: {},
-    logging: {}
-  };
-  
-  const serverInfo = await server.initialize(capabilities);
-  console.log('Server initialized:', serverInfo);
-}
-
-// Type-safe data operations
-async function performDataOperations(): Promise<void> {
-  const server = new AirtableMCPServer();
-  
-  // List records with type safety
-  const listParams: ListRecordsInput = {
-    table: 'Tasks',
-    maxRecords: 10,
-    filterByFormula: "Status = 'Active'"
-  };
-  
-  const records = await server.handleToolCall('list_records', listParams);
-  console.log('Records retrieved:', records);
-  
-  // Create record with validated types
-  const createParams: CreateRecordInput = {
-    table: 'Tasks',
-    fields: {
-      'Name': 'New Task',
-      'Status': 'Active',
-      'Priority': 'High',
-      'Due Date': new Date().toISOString()
-    },
-    typecast: true
-  };
-  
-  const newRecord = await server.handleToolCall('create_record', createParams);
-  console.log('Record created:', newRecord);
-}
-
-// Type-safe AI prompt usage
-async function useAIPrompts(): Promise<void> {
-  const server = new AirtableMCPServer();
-  
-  // Advanced data analysis with strict typing
-  const analysisParams: AnalyzeDataPrompt = {
-    table: 'Sales',
-    analysis_type: 'predictive',
-    field_focus: 'revenue,conversion_rate',
-    time_dimension: 'created_date',
-    confidence_level: 0.95
-  };
-  
-  const analysis = await server.handlePromptGet('analyze_data', analysisParams);
-  console.log('AI Analysis:', analysis);
-  
-  // Type-safe error handling
-  try {
-    // This will cause a TypeScript compile error if types don't match
-    const invalidParams = {
-      table: 'Sales',
-      analysis_type: 'invalid_type', // TypeScript will catch this!
-      confidence_level: 1.5 // TypeScript will catch this too!
-    };
-    
-    // await server.handlePromptGet('analyze_data', invalidParams);
-  } catch (error) {
-    console.error('Type-safe error handling:', error);
-  }
-}
-
-// Enterprise-grade type validation
-interface BusinessMetrics {
-  revenue: number;
-  conversion_rate: number;
-  customer_count: number;
-  timestamp: Date;
-}
-
-function validateBusinessMetrics(data: unknown): data is BusinessMetrics {
-  const metrics = data as BusinessMetrics;
-  return (
-    typeof metrics.revenue === 'number' &&
-    typeof metrics.conversion_rate === 'number' &&
-    typeof metrics.customer_count === 'number' &&
-    metrics.timestamp instanceof Date
-  );
-}
-
-// Type-safe configuration
-interface AppConfig {
-  airtable: {
-    token: string;
-    baseId: string;
-  };
-  server: {
-    port: number;
-    host: string;
-    logLevel: 'ERROR' | 'WARN' | 'INFO' | 'DEBUG' | 'TRACE';
-  };
-  ai: {
-    enablePredictiveAnalytics: boolean;
-    confidenceThreshold: number;
-    maxAnalysisFields: number;
-  };
-}
-
-const config: AppConfig = {
-  airtable: {
-    token: process.env.AIRTABLE_TOKEN!,
-    baseId: process.env.AIRTABLE_BASE_ID!
-  },
-  server: {
-    port: 8010,
-    host: 'localhost',
-    logLevel: 'INFO'
-  },
-  ai: {
-    enablePredictiveAnalytics: true,
-    confidenceThreshold: 0.85,
-    maxAnalysisFields: 10
-  }
-};
-
-// Main execution with comprehensive error handling
-async function main(): Promise<void> {
-  try {
-    console.log('🚀 Starting TypeScript Airtable MCP Example');
-    
-    await initializeServer();
-    await performDataOperations();
-    await useAIPrompts();
-    
-    console.log('✅ All operations completed successfully with type safety!');
-  } catch (error) {
-    console.error('❌ Error occurred:', error);
-    process.exit(1);
-  }
-}
-
-// Export for testing and reuse
-export {
-  initializeServer,
-  performDataOperations,
-  useAIPrompts,
-  validateBusinessMetrics,
-  BusinessMetrics,
-  AppConfig
-};
-
-// Run if this file is executed directly
-if (require.main === module) {
-  main();
-}

package/examples/typescript/claude-desktop-config.json

@@ -1,29 +0,0 @@
-{
-  "mcpServers": {
-    "airtable-typescript": {
-      "command": "npx",
-      "args": [
-        "@rashidazarang/airtable-mcp",
-        "--token",
-        "YOUR_AIRTABLE_TOKEN",
-        "--base", 
-        "YOUR_BASE_ID"
-      ],
-      "env": {
-        "NODE_ENV": "production",
-        "LOG_LEVEL": "INFO"
-      }
-    },
-    "airtable-typescript-dev": {
-      "command": "npm",
-      "args": ["run", "start:ts"],
-      "cwd": "/path/to/your/airtable-mcp",
-      "env": {
-        "AIRTABLE_TOKEN": "YOUR_AIRTABLE_TOKEN",
-        "AIRTABLE_BASE_ID": "YOUR_BASE_ID",
-        "NODE_ENV": "development",
-        "LOG_LEVEL": "DEBUG"
-      }
-    }
-  }
-}

package/examples/windsurf_mcp_config.json

@@ -1,17 +0,0 @@
-{
-  "mcpServers": {
-    "AIRTABLE": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@smithery/cli@latest",
-        "run",
-        "@rashidazarang/airtable-mcp",
-        "--token",
-        "YOUR_AIRTABLE_TOKEN",
-        "--base",
-        "YOUR_BASE_ID"
-      ]
-    }
-  }
-}