META-AIML Parser SDK v2.0.1

Universal JavaScript SDK for META-AIML v2.0.1 with intelligent scoring engine validator. Supports all 60 schemas (31 entities + 6 categories + 15 modules + 8 components). Works in browser and Node.js with full TypeScript support.

59 Total Schemas

Universal (Browser + Node.js)

Zero Dependencies

TypeScript Support

~17KB Minified

Intelligent Scoring Engine

⭐ NEW v2.0.1 - Exact UI Validator Logic

🔧 New Required Fields

• entityCapabilities - Objective business capabilities
• siteCapabilities - Website interaction capabilities
• functionalFeatures: Boolean functions for verification
• businessModel, paymentMethods, contentTypes

🎯 META-AIML Intelligent Scoring Engine

• 🟢 90-100 EXCELLENT: No warnings
• 🟡 50-89 GOOD: Functional schema
• 🔴 0-49 POOR: Multiple errors (>3)
• Intelligent scoring: 100 - (ERRORS×30 + WARNINGS×10 + SUGGESTIONS×5)

🔧 Enhanced Validation

• Exact Context: "https://schemas.meta-aiml.org/v2.0.1/context.jsonld"
• Exact Version: "2.0.1"
• Required Modules by Entity Type validation
• Enhanced multilingual support

❌ Removed in v2.0.1

From enhanced-aiml-validator.ts validation logic

• semanticProperties - Replaced by objective entityCapabilities
• intentContext - Replaced by concrete siteCapabilities.availableActions
• appliedContexts - Context references no longer supported
• context/ folder validation - Geographic, cultural and regulatory contexts validation removed

Installation

Browser (CDN)

Include directly in your HTML pages

<!-- Latest version from schemas.meta-aiml.org -->
<script src="https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.js"></script>

<!-- Or minified version -->
<script src="https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.min.js"></script>

<script>
  // SDK is available as global AIMLParser
  const result = AIMLParser.validate(jsonString);
  console.log('Valid:', result.isValid);
</script>

Node.js

Download and use in Node.js projects

# Download the SDK file
curl -O https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.js

# Use in your project
const AIMLParser = require('./AIMLParser.js');

# Or download with wget
wget https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.js

TypeScript

Full TypeScript support with type definitions

// Download type definitions
curl -O https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.d.ts

// Import with types
import AIMLParser, { AIMLValidationResult, AIMLSchema } from './AIMLParser';

const parser = new AIMLParser({ debug: true });
const result: AIMLValidationResult = parser.validate(schema);

Quick Start

Basic Usage - v2.0.1 Example

Based on ecommerce-marketplace.json from public/examples

// Validate a JSON string - v2.0.1 example
const jsonString = `{
  "@context": "https://schemas.meta-aiml.org/v2.0.1/context.jsonld",
  "@id": "https://techbazaar.com/entity",
  "@type": "Marketplace",
  "schemaVersion": "2.0.1",
  "entityType": "marketplace",
  "entityCategory": "product_offering",
  "subcategory": "ecommerce_platform",
  "name": {
    "en": "TechBazaar Global Marketplace",
    "es": "Mercado Global TechBazaar",
    "zh": "TechBazaar全球市场"
  },
  "description": {
    "en": "Leading B2B2C technology marketplace connecting vendors and buyers worldwide",
    "es": "Mercado tecnológico B2B2C líder que conecta vendedores y compradores en todo el mundo"
  },
  "url": "https://techbazaar.com",
  "foundingDate": "2020-03-15",
  "modules": {
    "auth": { "version": "2.0.1", "enabled": true },
    "payments": { "version": "2.0.1", "enabled": true },
    "user-management": { "version": "2.0.1", "enabled": true }
  },
  "entityCapabilities": {
    "functionalFeatures": {
      "supportsOnlinePayments": true,
      "hasShoppingCart": true,
      "hasUserAccounts": true,
      "hasVendorVerification": true,
      "hasBulkPurchasing": true
    },
    "businessModel": "marketplace",
    "paymentMethods": ["credit_card", "paypal", "bank_transfer", "digital_wallet"],
    "contentTypes": ["products", "reviews", "guides", "support", "vendor_profiles"]
  },
  "siteCapabilities": {
    "availableActions": [
      "browse_products", "compare_products", "add_to_cart", "checkout",
      "track_order", "write_review", "contact_vendor", "filter_search"
    ],
    "interactionMethods": ["online_form", "live_chat", "email", "messaging_system"],
    "supportedDevices": ["desktop", "mobile", "tablet"],
    "languages": ["en", "es", "fr", "de"],
    "realTimeFeatures": ["live_chat", "real_time_inventory", "instant_messaging"]
  }
}`;

const result = AIMLParser.validate(jsonString);

console.log('Is Valid:', result.isValid);           // true
console.log('Score:', result.score);                // 95-100 (META-AIML Intelligent Scoring Engine)
console.log('Completeness:', result.completeness);  // 90-100%
console.log('Errors:', result.errors.length);       // 0
console.log('Entity Type:', result.entityInfo?.entityType); // "marketplace"

Advanced Usage - v2.0.1 Validation

// Validate with detailed feedback
const result = AIMLParser.validate(jsonString);

if (result.isValid) {
  console.log('✅ Schema is valid!');
  console.log('META-AIML Intelligent Scoring Engine Score:', result.score); // 0-100
  console.log('Entity Info:', {
    type: result.entityInfo.entityType,
    category: result.entityInfo.entityCategory,
    baseSchema: result.entityInfo.baseSchema,
    modules: result.entityInfo.modules,
    hasEntityCapabilities: result.entityInfo.hasEntityCapabilities, // NEW v2.0.1
    hasSiteCapabilities: result.entityInfo.hasSiteCapabilities       // NEW v2.0.1
  });
} else {
  console.log('❌ Schema has errors:');
  result.errors.forEach(error => {
    console.log(`- [${error.field}] ${error.message}`);
    if (error.suggestion) {
      console.log(`  💡 ${error.suggestion}`);
    }
  });
}

// Check warnings and suggestions
if (result.warnings.length > 0) {
  console.log('⚠️ Warnings:', result.warnings);
}

if (result.suggestions.length > 0) {
  console.log('💡 Suggestions:', result.suggestions);
}

// Performance metrics
console.log('Performance:', {
  size: result.performance.schemaSize,
  complexity: result.performance.complexity,
  moduleCount: result.performance.moduleCount
});

Complete API Reference

Constructor

Initialize AIML Parser instance

// Basic initialization
const parser = new AIMLParser();

// With options
const parser = new AIMLParser({
  debug: true  // Enable debug mode for detailed logging
});

parser.validate(data)

Main validation method - supports JSON string or object

Parameters:

data (string | object): AIML schema as JSON string or parsed object

Returns: AIMLValidationResult

interface AIMLValidationResult {
  isValid: boolean;                 // Overall validation result
  errors: AIMLValidationError[];    // Critical errors that make schema invalid
  warnings: AIMLValidationError[];  // Non-critical warnings
  suggestions: AIMLValidationError[]; // Improvement suggestions
  entityInfo?: AIMLEntityInfo;      // Entity metadata if parseable
  score: number;                    // Quality score (0-100)
  completeness: number;             // Schema completeness (0-100%)
  performance: {
    schemaSize: number;             // Schema size in bytes
    complexity: 'low'|'medium'|'high'; // Complexity level
    moduleCount: number;            // Number of modules
  };
}

Usage Examples:

// Validate JSON string
const result = parser.validate('{"@context": "..."}');

// Validate object
const schemaObject = { "@context": "...", "name": "..." };
const result = parser.validate(schemaObject);

// Check result
if (result.isValid) {
  console.log('✅ Valid schema, Score:', result.score);
} else {
  console.log('❌ Invalid schema, Errors:', result.errors.length);
}

🛠️ Static Methods - Enhanced in v2.0.1

NEW utility methods from developer experience improvements

AIMLParser.validate(data, options?)

Convenience static method for one-time validation

// One-time validation without creating instance
const result = AIMLParser.validate(schema);

// With options
const result = AIMLParser.validate(schema, { debug: true });

Factory Methods

// Production-ready parser (debug: false)
const prodParser = AIMLParser.createProduction();

// Development parser (debug: true)
const devParser = AIMLParser.createDevelopment();

⭐ NEW v2.0.1 Utility Methods

// Get AIML version
const version = AIMLParser.getVersion(); // "2.0.1"

// NEW: Get available contexts list
const contexts = AIMLParser.getAvailableContexts();
// ["https://schemas.meta-aiml.org/v2.0.1/context.jsonld"]

// NEW: Get required modules for entity type
const requiredModules = AIMLParser.getRequiredModules("marketplace");
// ["auth", "payments", "user_management"]

// Get available entity categories (6 categories)
const categories = AIMLParser.getEntityCategories();
// ["organization", "product_offering", "service", "creative_work", "community", "financial_product"]

// Get all entity types (31 types)
const types = AIMLParser.getEntityTypes();
// ["blog", "business_services", "clinic", "dating_platform", ...]

// Get available modules (14 modules)
const modules = AIMLParser.getModules();
// ["auth", "compliance", "location", "logistics", ...]

// Get subcategories (16 subcategories)
const subcategories = AIMLParser.getSubcategories();
// ["ecommerce_platform", "hospitality", "healthcare_services", ...]

🆕 NEW Convenience Static Methods

Added convenience methods for common operations

// Quick validation check - returns boolean only
const isValid = AIMLParser.isValid(schema);
// Returns: true/false

// With options
const isValid = AIMLParser.isValid(schema, { debug: true });

// Extract entity information only - returns AIMLEntityInfo | null
const entityInfo = AIMLParser.getEntityInfo(schema);
// Returns: { entityType: "marketplace", entityCategory: "product_offering", ... } or null

// These are convenience methods that internally create a parser instance
// Perfect for quick checks without needing full validation results

Data Types - Updated for v2.0.1

Complete TypeScript interface definitions with NEW v2.0.1 fields

AIMLValidationError

interface AIMLValidationError {
  field: string;                    // Field name where issue was found
  message: string;                  // Human-readable error message
  severity: 'error' | 'warning' | 'info'; // Issue severity level
  category: 'structure' | 'schema' | 'semantic' | 'performance' | 'best_practice';
  suggestion?: string;              // Recommended fix (optional)
  documentation?: string;           // Link to relevant docs (optional)
  line?: number;                    // Line number (future feature)
  column?: number;                  // Column number (future feature)
}

AIMLEntityInfo - Enhanced in v2.0.1

interface AIMLEntityInfo {
  entityType: string;               // AIML entity type (e.g., "restaurant")
  entityCategory: string;           // Top-level category (e.g., "organization")
  subcategory?: string;             // Subcategory classification (optional)
  baseSchema: string;               // Base schema identifier
  modules: string[];                // List of active module names
  hasEntityCapabilities: boolean;   // NEW v2.0.1: Whether schema includes entity capabilities
  hasSiteCapabilities: boolean;     // NEW v2.0.1: Whether schema includes site capabilities
}

AIMLSchema (Input) - v2.0.1 Update

interface AIMLSchema {
  '@context'?: string;              // Must be exactly "https://schemas.meta-aiml.org/v2.0.1/context.jsonld"
  '@id'?: string;                   // Unique identifier
  '@type'?: string;                 // Entity type
  schemaVersion?: string;           // Must be exactly "2.0.1"
  entityType?: string;              // AIML entity type
  entityCategory?: string;          // Top-level category
  subcategory?: string;             // Subcategory
  name?: string | { [lang: string]: string }; // Name (string or multilingual)
  description?: string | { [lang: string]: string }; // Description (min 50 chars for "en")
  url?: string;                     // Entity URL
  shortDescription?: string;        // Short description
  properties?: Record<string, any>; // Entity properties
  modules?: Record<string, any>;    // Enabled modules
  entityCapabilities?: {            // NEW v2.0.1: Objective business capabilities
    functionalFeatures?: Record<string, boolean>;
    contentTypes?: string[];
    businessModel?: string;
    paymentMethods?: string[];
  };
  siteCapabilities?: {              // NEW v2.0.1: Website interaction capabilities
    availableActions?: string[];
    interactionMethods?: string[];
    contentAccess?: string[];
    supportedDevices?: string[];
    languages?: string[];
    realTimeFeatures?: string[];
  };
  [key: string]: any;               // Additional properties
}

Integration Examples

React Integration

Real-time validation in React components

import { useState, useEffect } from 'react';

function SchemaValidator() {
  const [schema, setSchema] = useState('');
  const [validation, setValidation] = useState(null);
  const parser = new AIMLParser();

  useEffect(() => {
    if (schema.trim()) {
      const result = parser.validate(schema);
      setValidation(result);
    }
  }, [schema]);

  return (
    <div>
      <textarea
        value={schema}
        onChange={(e) => setSchema(e.target.value)}
        placeholder="Enter AIML schema..."
      />

      {validation && (
        <div className={validation.isValid ? 'success' : 'error'}>
          <div>Score: {validation.score}/100</div>
          <div>Completeness: {validation.completeness}%</div>

          {validation.errors.map(error => (
            <div key={error.field} className="error">
              {error.field}: {error.message}
            </div>
          ))}
        </div>
      )}
    </div>
  );
}

Node.js Express Middleware

Validate API requests automatically

const express = require('express');
const AIMLParser = require('./AIMLParser.js');

const app = express();
const parser = AIMLParser.createProduction();

// AIML validation middleware
function aimlValidation(options = {}) {
  return (req, res, next) => {
    try {
      const result = parser.validate(req.body);
      req.aimlValidation = result;

      if (!result.isValid && options.strict) {
        return res.status(400).json({
          error: 'Invalid AIML schema',
          details: result.errors,
          suggestions: result.warnings
        });
      }

      next();
    } catch (error) {
      res.status(400).json({
        error: 'Schema validation failed',
        message: error.message
      });
    }
  };
}

// Use middleware
app.post('/api/schemas', aimlValidation({ strict: true }), (req, res) => {
  const { aimlValidation } = req;

  res.json({
    message: 'Schema accepted',
    score: aimlValidation.score,
    entityInfo: aimlValidation.entityInfo
  });
});

Batch Processing

Validate multiple schemas efficiently

const fs = require('fs').promises;
const path = require('path');
const AIMLParser = require('./AIMLParser.js');

class AIMLBatchValidator {
  constructor() {
    this.parser = AIMLParser.createProduction();
    this.results = [];
  }

  async validateDirectory(dirPath) {
    const files = await fs.readdir(dirPath);
    const schemaFiles = files.filter(f => f.endsWith('.json'));

    console.log(`Processing ${schemaFiles.length} schema files...`);

    for (const file of schemaFiles) {
      const filePath = path.join(dirPath, file);
      await this.validateFile(filePath);
    }

    return this.generateReport();
  }

  async validateFile(filePath) {
    try {
      const content = await fs.readFile(filePath, 'utf8');
      const schema = JSON.parse(content);
      const result = this.parser.validate(schema);

      this.results.push({
        file: filePath,
        ...result,
        timestamp: new Date().toISOString()
      });

      if (!result.isValid) {
        console.error(`❌ ${filePath}: ${result.errors.length} errors`);
      } else {
        console.log(`✅ ${filePath}: Score ${result.score}/100`);
      }
    } catch (error) {
      this.results.push({
        file: filePath,
        isValid: false,
        errors: [{ field: 'file', message: error.message }]
      });
    }
  }

  generateReport() {
    const total = this.results.length;
    const valid = this.results.filter(r => r.isValid).length;
    const avgScore = this.results
      .filter(r => r.score !== undefined)
      .reduce((sum, r) => sum + r.score, 0) / Math.max(1, valid);

    return {
      summary: {
        total,
        valid,
        invalid: total - valid,
        validationRate: `${Math.round((valid / total) * 100)}%`,
        averageScore: Math.round(avgScore)
      },
      details: this.results
    };
  }
}

// Usage
const validator = new AIMLBatchValidator();
validator.validateDirectory('./schemas')
  .then(report => {
    console.log('Validation Complete:', report.summary);
    fs.writeFile('./validation-report.json', JSON.stringify(report, null, 2));
  });

Real v2.0.1 Validation Examples

Perfect ecommerce-marketplace.json v2.0.1

Score: 100, Completeness: 100% - From public/examples

// Perfect ecommerce-marketplace.json v2.0.1 example (from public/examples)
const marketplaceSchema = `{
  "@context": "https://schemas.meta-aiml.org/v2.0.1/context.jsonld",
  "@id": "https://techbazaar.com/entity",
  "@type": "Marketplace",
  "schemaVersion": "2.0.1",
  "entityType": "marketplace",
  "entityCategory": "product_offering",
  "subcategory": "ecommerce_platform",
  "name": {
    "en": "TechBazaar Global Marketplace",
    "es": "Mercado Global TechBazaar",
    "zh": "TechBazaar全球市场"
  },
  "description": {
    "en": "Leading B2B2C technology marketplace connecting vendors and buyers worldwide",
    "es": "Mercado tecnológico B2B2C líder que conecta vendedores y compradores en todo el mundo"
  },
  "url": "https://techbazaar.com",
  "foundingDate": "2020-03-15",
  "modules": {
    "auth": { "version": "2.0.1", "enabled": true },
    "payments": { "version": "2.0.1", "enabled": true },
    "user-management": { "version": "2.0.1", "enabled": true }
  },
  "entityCapabilities": {
    "functionalFeatures": {
      "supportsOnlinePayments": true,
      "hasShoppingCart": true,
      "hasUserAccounts": true,
      "hasVendorVerification": true,
      "hasBulkPurchasing": true
    },
    "businessModel": "marketplace",
    "paymentMethods": ["credit_card", "paypal", "bank_transfer", "digital_wallet"],
    "contentTypes": ["products", "reviews", "guides", "support", "vendor_profiles"]
  },
  "siteCapabilities": {
    "availableActions": [
      "browse_products", "compare_products", "add_to_cart", "checkout",
      "track_order", "write_review", "contact_vendor", "filter_search"
    ],
    "interactionMethods": ["online_form", "live_chat", "email", "messaging_system"],
    "supportedDevices": ["desktop", "mobile", "tablet"],
    "languages": ["en", "es", "fr", "de"],
    "realTimeFeatures": ["live_chat", "real_time_inventory", "instant_messaging"]
  }
}`;

const result = AIMLParser.validate(marketplaceSchema);
// Result: isValid=true, score=100, completeness=100% (META-AIML Intelligent Scoring Engine)

v2.0.1 Error Handling Example

Real validation results from playground - exactly matching behavior

// Invalid schema example - real v2.0.1 validation results
const invalidSchema = `{
  "@context": "https://schemas.meta-aiml.org/v2.0.0/context.jsonld",
  "schemaVersion": "2.0.0",
  "name": "Test Entity",
  "entityCategory": "invalid_category"
  // Missing: @id, @type, entityType, description, entityCapabilities, siteCapabilities
}`;

const result = AIMLParser.validate(invalidSchema);

console.log('Is Valid:', result.isValid); // false
console.log('META-AIML Intelligent Scoring Engine Score:', result.score); // 0-49 (Poor zone)

// ERRORS (8) - Must Fix:
console.log('Errors:', result.errors);
// [
//   { field: "@id", message: "Critical required field '@id' is missing" },
//   { field: "@type", message: "Critical required field '@type' is missing" },
//   { field: "entityType", message: "Critical required field 'entityType' is missing" },
//   { field: "description", message: "Critical required field 'description' is missing" },
//   { field: "@context", message: "Invalid @context value - must be exact" },
//   { field: "schemaVersion", message: "Invalid schema version: 2.0.0" },
//   { field: "entityCategory", message: "Invalid entity category: invalid_category" },
//   { field: "name", message: "name must be a multilingual object in v2.0.1" }
// ]

// WARNINGS (6) - Recommended:
console.log('Warnings:', result.warnings);
// [
//   { field: "url", message: "Strongly recommended field 'url' is missing" },
//   { field: "shortDescription", message: "Strongly recommended field 'shortDescription' is missing" },
//   { field: "entityCapabilities", message: "NEW v2.0.1 field 'entityCapabilities' is missing" },
//   { field: "siteCapabilities", message: "NEW v2.0.1 field 'siteCapabilities' is missing" },
//   { field: "entityCapabilities", message: "Missing entityCapabilities - required in v2.0.1 for objective business features" },
//   { field: "siteCapabilities", message: "Missing siteCapabilities - required in v2.0.1 for website interaction features" }
// ]

🔧 Required Modules by Entity Type v2.0.1

Entity-Specific Module Requirements

From required_fields_v2.0.1.md - Critical validation rules

Healthcare & Compliance

• Clinic: auth, security, compliance
• TelemedicinePlatform: auth, security, compliance, streaming
• OnlineBanking: auth, security, compliance

E-commerce & Payments

• EcommerceStore: auth, payments
• Marketplace: auth, payments, user_management
• Hotel: location, payments

Location-Based Services

• Restaurant: location
• RidesharingService: auth, location

User Management

• EducationPlatform: auth, user_management
• SocialNetwork: auth, user_management
• GenerativeAIPlatform: auth, security

Validation Logic: The SDK automatically checks these requirements. Missing required modules generate ERRORS that affect the META-AIML Intelligent Scoring Engine score.

Comprehensive Features & v2.0.1 Validation Rules

Entity Validation v2.0.1

Complete AIML v2.0.1 entity validation

✅ 31 Entity types (restaurant, marketplace, clinic, etc.)
✅ 6 Base categories (organization, service, etc.)
✅ 14 Modules with required module validation by entity type
✅ Critical fields: @context, entityType, entityCategory, name, description
✅ Exact context validation: "https://schemas.meta-aiml.org/v2.0.1/context.jsonld"
✅ Exact version validation: "2.0.1"

NEW v2.0.1 Capabilities

Objective business and site capabilities validation

✅ entityCapabilities: functionalFeatures (boolean functions)
✅ siteCapabilities: availableActions, interactionMethods
✅ businessModel and paymentMethods validation
✅ contentTypes and supportedDevices validation
✅ realTimeFeatures validation
✅ Objective, verifiable characteristics only

META-AIML Intelligent Scoring Engine v2.0.1

Enhanced scoring algorithm with intelligent logic

✅ Base: 100 - (ERRORS×30 + WARNINGS×10 + SUGGESTIONS×5)
✅ No WARNINGS → start from 90 + (completeness × 10%) up to 100
✅ Has ERRORS but ≤3 → minimum 50 points (Good zone)
✅ Many ERRORS >3 → can fall to Poor zone (floor at 25 points)
✅ 🟢 90-100: Excellent | 🟡 50-89: Good | 🔴 0-49: Poor
✅ Multilingual validation: English ("en") required

Performance & Compatibility

Optimized for production use

✅ Synchronous validation - immediate results
✅ Zero dependencies - standalone operation
✅ Lightweight (~20KB minified, ~8KB gzipped)
✅ Performance metrics and complexity analysis
✅ Browser + Node.js + TypeScript support
✅ Universal Module Definition (UMD) pattern

v2.0.1 Validation Rules Overview

Enhanced validation logic identical to enhanced-aiml-validator.ts

Critical Required Fields (ERRORS)

• @context: "https://schemas.meta-aiml.org/v2.0.1/context.jsonld"
• @id, @type, schemaVersion: "2.0.1"
• entityType, entityCategory, subcategory
• name, description (objects with "en" required)

NEW v2.0.1 Fields (WARNINGS)

• entityCapabilities: functionalFeatures, businessModel
• siteCapabilities: availableActions, supportedDevices
• Required modules by entity type validation
• Enhanced multilingual support (English required)

Enhanced Multilingual v2.0.1

• Multilingual objects required (not strings)
• English ("en") field is mandatory
• ISO 639-1 format validation
• Description minimum 50 characters for English

META-AIML Intelligent Scoring Engine

• 🟢 90-100: Excellent (no warnings)
• 🟡 50-89: Good (functional schema)
• 🔴 0-49: Poor (critical issues)
• Intelligent scoring with completeness boost
Enhanced algorithm considers schema completeness

Complete Entity Support Matrix v2.0.1

All 31 entity types across 6 categories (from META_AIML_ARCHITECTURE_COMPLETE_v2.0.1.md)

Organization (6 entities)

• clinic (healthcare_services)
• education_platform (education_services)
• fitness_platform (healthcare_services)
• hotel (hospitality)
• restaurant (hospitality)
• store (ecommerce_platform)

Service (9 entities)

• business_services (professional_services)
• generative_ai_platform (ai_platform)
• real_estate_platform (property_services)
• ridesharing_service (ridesharing_services)
• task_management_app (digital_product)
• telemedicine_platform (healthcare_services)
• virtual_event_platform (event_platform)
• web_app (digital_product)
• website_services (website_services)

Creative Work (9 entities)

• blog (media_entertainment)
• event (event_platform)
• file_hosting (digital_product)
• gaming_platform (media_entertainment)
• news (media_entertainment)
• personal_website (digital_product)
• photo_hosting (media_entertainment)
• streaming_platform (media_entertainment)
• video_hosting (media_entertainment)

Product Offering (4 entities)

• ecommerce_store (ecommerce_platform)
• marketplace (ecommerce_platform)
• product (physical_product)
• software_product (digital_product)

Community (2 entities)

• dating_platform (social_platform)
• social_network (social_platform)

Financial Product (1 entity)

• online_banking (financial_services)

Performance & Technical Specifications

Performance Metrics

Optimized for production environments

Validation Speed:~1-5ms per schema

Memory Usage:~2-4MB RAM

Throughput:1000+ schemas/sec

Execution:Synchronous

Bundle Specifications

Optimized bundle sizes and compatibility

Full Version:~45KB unminified

Minified:~20KB minified

Gzipped:~8KB gzipped

Dependencies:Zero

Compatibility Matrix

Universal compatibility across platforms and environments

Browser Support

✅ Chrome 49+
✅ Firefox 44+
✅ Safari 10+
✅ Edge 14+
✅ IE 11+ (with polyfills)

Node.js Support

✅ Node.js 8+
✅ Node.js 10+ (LTS)
✅ Node.js 12+ (LTS)
✅ Node.js 14+ (LTS)
✅ Node.js 16+ (Current)

Module Systems

✅ CommonJS (require)
✅ AMD (define)
✅ Global (window)
✅ ES6 Modules (import)
✅ TypeScript support

Download SDK v2.0.1

Production-ready JavaScript SDK with comprehensive validation engine. Tested with all 31 AIML entity types and enhanced-aiml-validator.ts logic.

AIMLParser.js v2.0.1 AIMLParser.min.js v2.0.1 TypeScript Definitions v2.0.1

CDN Links v2.0.1

https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.js

https://schemas.meta-aiml.org/v2.0.1/sdk/AIMLParser.min.js

Version Information

Version: 2.0.1 (Latest)

Released: July 2, 2025

AIML Spec: v2.0.1 Compatible

Try It Now

Test the SDK with real AIML v2.0.1 schemas in our interactive playground

Open Playground

The playground uses the exact same validation logic as this SDK with META-AIML Intelligent Scoring Engine v2.0.1

AIML Parser SDK v2.0.1 |meta-aiml.org