@rashidazarang/airtable-mcp 1.2.1 → 1.2.4

package/simple_airtable_server.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Simple Airtable MCP Server for Claude
+-------------------------------------
+A minimal MCP server that implements Airtable tools and Claude's special methods
+"""
+import os
+import sys
+import json
+import logging
+import requests
+import traceback
+from typing import Dict, Any, List, Optional
+
+# Check if MCP SDK is installed
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError:
+    print("Error: MCP SDK not found. Please install with 'pip install mcp'")
+    sys.exit(1)
+
+# Parse command line arguments
+if len(sys.argv) < 5:
+    print("Usage: python3 simple_airtable_server.py --token YOUR_TOKEN --base YOUR_BASE_ID")
+    sys.exit(1)
+
+# Get the token and base ID from command line arguments
+token = None
+base_id = None
+for i in range(1, len(sys.argv)):
+    if sys.argv[i] == "--token" and i+1 < len(sys.argv):
+        token = sys.argv[i+1]
+    elif sys.argv[i] == "--base" and i+1 < len(sys.argv):
+        base_id = sys.argv[i+1]
+
+if not token:
+    print("Error: No Airtable token provided. Use --token parameter.")
+    sys.exit(1)
+
+if not base_id:
+    print("Error: No base ID provided. Use --base parameter.")
+    sys.exit(1)
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("airtable-mcp")
+
+# Create MCP server
+app = FastMCP("Airtable Tools")
+
+# Helper function for Airtable API calls
+async def airtable_api_call(endpoint, method="GET", data=None, params=None):
+    """Make an Airtable API call with error handling"""
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    url = f"https://api.airtable.com/v0/{endpoint}"
+    
+    try:
+        if method == "GET":
+            response = requests.get(url, headers=headers, params=params)
+        elif method == "POST":
+            response = requests.post(url, headers=headers, json=data)
+        else:
+            raise ValueError(f"Unsupported method: {method}")
+        
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        logger.error(f"API call error: {str(e)}")
+        return {"error": str(e)}
+
+# Claude-specific methods
+@app.rpc_method("resources/list")
+async def resources_list(params: Dict = None) -> Dict:
+    """List available Airtable resources for Claude"""
+    try:
+        # Return a simple list of resources
+        resources = [
+            {"id": "airtable_tables", "name": "Airtable Tables", "description": "Tables in your Airtable base"}
+        ]
+        return {"resources": resources}
+    except Exception as e:
+        logger.error(f"Error in resources/list: {str(e)}")
+        return {"error": {"code": -32000, "message": str(e)}}
+
+@app.rpc_method("prompts/list")
+async def prompts_list(params: Dict = None) -> Dict:
+    """List available prompts for Claude"""
+    try:
+        # Return a simple list of prompts
+        prompts = [
+            {"id": "tables_prompt", "name": "List Tables", "description": "List all tables"}
+        ]
+        return {"prompts": prompts}
+    except Exception as e:
+        logger.error(f"Error in prompts/list: {str(e)}")
+        return {"error": {"code": -32000, "message": str(e)}}
+
+# Airtable tool functions
+@app.tool()
+async def list_tables() -> str:
+    """List all tables in the specified base"""
+    try:
+        result = await airtable_api_call(f"meta/bases/{base_id}/tables")
+        
+        if "error" in result:
+            return f"Error: {result['error']}"
+        
+        tables = result.get("tables", [])
+        if not tables:
+            return "No tables found in this base."
+        
+        table_list = [f"{i+1}. {table['name']} (ID: {table['id']})" 
+                    for i, table in enumerate(tables)]
+        return "Tables in this base:\n" + "\n".join(table_list)
+    except Exception as e:
+        return f"Error listing tables: {str(e)}"
+
+@app.tool()
+async def list_records(table_name: str, max_records: int = 100) -> str:
+    """List records from a table"""
+    try:
+        params = {"maxRecords": max_records}
+        result = await airtable_api_call(f"{base_id}/{table_name}", params=params)
+        
+        if "error" in result:
+            return f"Error: {result['error']}"
+        
+        records = result.get("records", [])
+        if not records:
+            return "No records found in this table."
+        
+        # Format the records for display
+        formatted_records = []
+        for i, record in enumerate(records):
+            record_id = record.get("id", "unknown")
+            fields = record.get("fields", {})
+            field_text = ", ".join([f"{k}: {v}" for k, v in fields.items()])
+            formatted_records.append(f"{i+1}. ID: {record_id} - {field_text}")
+        
+        return "Records:\n" + "\n".join(formatted_records)
+    except Exception as e:
+        return f"Error listing records: {str(e)}"
+
+# Start the server
+if __name__ == "__main__":
+    print(f"Starting Airtable MCP Server with token {token[:5]}...{token[-5:]} and base {base_id}")
+    app.start() 

package/smithery.yaml

@@ -1,7 +1,7 @@
 # Smithery.ai configuration
 name: "@rashidazarang/airtable-mcp"
-version: "1.0.0"
-description: "Connect your AI tools directly to Airtable. Query, create, update, and delete records using natural language. Features include base management, table operations, schema manipulation, record filtering, and data migration—all through a standardized MCP interface compatible with Cursor, Claude Code, Cline, Zed, and other Claude-powered editors."
+version: "1.2.4"
+description: "Connect your AI tools directly to Airtable. Query, create, update, and delete records using natural language. Features include base management, table operations, schema manipulation, record filtering, and data migration—all through a standardized MCP interface compatible with Claude Desktop and other Claude-powered editors."
 
 startCommand:
   type: stdio
@@ -11,31 +11,35 @@ startCommand:
       airtable_token:
         type: string
         description: "Your Airtable Personal Access Token"
+        required: true
       base_id:
         type: string
-        description: "Your default Airtable base ID (optional)"
-    required: ["airtable_token"]
+        description: "Your default Airtable base ID"
+        required: true
+    required: ["airtable_token", "base_id"]
   commandFunction: |
     (config) => {
-      // Pass config as a JSON string to the inspector_server.py
-      const configStr = JSON.stringify(config);
+      // Use the working JavaScript implementation
       return {
-        command: "python3.10",
-        args: ["inspector_server.py", "--config", configStr],
-        env: {}
+        command: "node",
+        args: ["airtable_simple.js", "--token", config.airtable_token, "--base", config.base_id],
+        env: {
+          AIRTABLE_TOKEN: config.airtable_token,
+          AIRTABLE_BASE_ID: config.base_id
+        }
       };
     }
 
 listTools:
-  command: "python3.10"
-  args: ["inspector.py"]
+  command: "node"
+  args: ["airtable_simple.js", "--list-tools"]
   env: {}
   
 build:
-  dockerfile: "Dockerfile"
+  dockerfile: "Dockerfile.node"
 
 metadata:
   author: "Rashid Azarang"
   license: "MIT"
   repository: "https://github.com/rashidazarang/airtable-mcp"
-  homepage: "https://github.com/rashidazarang/airtable-mcp#readme" 
+  homepage: "https://github.com/rashidazarang/airtable-mcp#readme"

package/test_client.py

@@ -4,14 +4,21 @@ Simple test client for Airtable MCP
 """
 import asyncio
 import json
+import os
 import sys
 import subprocess
 import time
 from typing import Dict, Any
 
-# Define the token and base ID
-TOKEN = "patnWSCSCmnsqeQ4I.2a3603372f6df67e51f9fe553012192019f2d81c3eab0f94ebd702d7fb63e338"
-BASE_ID = "appi7fWMQcB3BNzPs"
+# Load credentials from environment variables
+TOKEN = os.environ.get('AIRTABLE_TOKEN', 'YOUR_AIRTABLE_TOKEN_HERE')
+BASE_ID = os.environ.get('AIRTABLE_BASE_ID', 'YOUR_BASE_ID_HERE')
+
+if TOKEN == 'YOUR_AIRTABLE_TOKEN_HERE' or BASE_ID == 'YOUR_BASE_ID_HERE':
+    print("Error: Please set AIRTABLE_TOKEN and AIRTABLE_BASE_ID environment variables")
+    print("Example: export AIRTABLE_TOKEN=your_token_here")
+    print("         export AIRTABLE_BASE_ID=your_base_id_here")
+    sys.exit(1)
 
 # Helper function to directly make Airtable API calls
 def api_call(endpoint, token=TOKEN):

package/test_mcp_comprehensive.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * Comprehensive Test Script for Airtable MCP
+ * Tests all available MCP tools and functionality
+ */
+
+const http = require('http');
+
+const MCP_SERVER_URL = 'http://localhost:8010/mcp';
+const TEST_TOKEN = process.env.AIRTABLE_TOKEN || 'YOUR_AIRTABLE_TOKEN_HERE';
+const TEST_BASE_ID = process.env.AIRTABLE_BASE_ID || 'YOUR_BASE_ID_HERE';
+
+if (TEST_TOKEN === 'YOUR_AIRTABLE_TOKEN_HERE' || TEST_BASE_ID === 'YOUR_BASE_ID_HERE') {
+  console.error('Error: Please set AIRTABLE_TOKEN and AIRTABLE_BASE_ID environment variables');
+  console.error('Example: export AIRTABLE_TOKEN=your_token_here');
+  console.error('         export AIRTABLE_BASE_ID=your_base_id_here');
+  process.exit(1);
+}
+
+// Helper function to make MCP requests
+function makeMCPRequest(method, params = {}) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: method,
+      params: params
+    });
+
+    const options = {
+      hostname: 'localhost',
+      port: 8010,
+      path: '/mcp',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        try {
+          const response = JSON.parse(data);
+          resolve(response);
+        } catch (e) {
+          reject(new Error(`Failed to parse response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => {
+      reject(new Error(`Request failed: ${e.message}`));
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function runComprehensiveTest() {
+  console.log('🔌 Airtable MCP Comprehensive Test');
+  console.log('===================================');
+  console.log(`Server: ${MCP_SERVER_URL}`);
+  console.log(`Base ID: ${TEST_BASE_ID}`);
+  console.log(`Token: ${TEST_TOKEN.substring(0, 10)}...${TEST_TOKEN.substring(TEST_TOKEN.length - 10)}`);
+  console.log('');
+
+  try {
+    // Test 1: List Resources
+    console.log('📋 Test 1: Listing Resources');
+    console.log('----------------------------');
+    const resourcesResponse = await makeMCPRequest('resources/list');
+    console.log('✅ Resources Response:');
+    console.log(JSON.stringify(resourcesResponse, null, 2));
+    console.log('');
+
+    // Test 2: List Prompts
+    console.log('📝 Test 2: Listing Prompts');
+    console.log('-------------------------');
+    const promptsResponse = await makeMCPRequest('prompts/list');
+    console.log('✅ Prompts Response:');
+    console.log(JSON.stringify(promptsResponse, null, 2));
+    console.log('');
+
+    // Test 3: List Tables
+    console.log('📊 Test 3: Listing Tables');
+    console.log('------------------------');
+    const tablesResponse = await makeMCPRequest('tools/call', {
+      name: 'list_tables'
+    });
+    console.log('✅ Tables Response:');
+    console.log(JSON.stringify(tablesResponse, null, 2));
+    console.log('');
+
+    // Test 4: List Records from Requests table
+    console.log('📄 Test 4: Listing Records (Requests Table)');
+    console.log('-------------------------------------------');
+    const recordsResponse = await makeMCPRequest('tools/call', {
+      name: 'list_records',
+      arguments: {
+        table_name: 'requests',
+        max_records: 3
+      }
+    });
+    console.log('✅ Records Response:');
+    console.log(JSON.stringify(recordsResponse, null, 2));
+    console.log('');
+
+    // Test 5: List Records from Providers table
+    console.log('👥 Test 5: Listing Records (Providers Table)');
+    console.log('--------------------------------------------');
+    const providersResponse = await makeMCPRequest('tools/call', {
+      name: 'list_records',
+      arguments: {
+        table_name: 'providers',
+        max_records: 3
+      }
+    });
+    console.log('✅ Providers Response:');
+    console.log(JSON.stringify(providersResponse, null, 2));
+    console.log('');
+
+    // Test 6: List Records from Categories table
+    console.log('🏷️ Test 6: Listing Records (Categories Table)');
+    console.log('---------------------------------------------');
+    const categoriesResponse = await makeMCPRequest('tools/call', {
+      name: 'list_records',
+      arguments: {
+        table_name: 'categories',
+        max_records: 3
+      }
+    });
+    console.log('✅ Categories Response:');
+    console.log(JSON.stringify(categoriesResponse, null, 2));
+    console.log('');
+
+    console.log('🎉 All Tests Completed Successfully!');
+    console.log('');
+    console.log('📊 Test Summary:');
+    console.log('✅ MCP Server is running and accessible');
+    console.log('✅ Airtable API connection is working');
+    console.log('✅ All MCP tools are functioning properly');
+    console.log('✅ JSON-RPC protocol is correctly implemented');
+    console.log('✅ Error handling is working');
+    console.log('');
+    console.log('🚀 The Airtable MCP is ready for use!');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the comprehensive test
+runComprehensiveTest();