@solvers-hub/llm-json 0.1.6 → 0.1.7

package/examples/schema-validation-example.ts

@@ -0,0 +1,140 @@
+import LlmJson from '../src/index';
+
+/**
+ * Example demonstrating how to use schema validation with the LLM-JSON library.
+ */
+function runSchemaValidationExample() {
+  console.log('Schema Validation Example');
+  console.log('=========================\n');
+
+  // Define some schemas for validation
+  const schemas = [
+    {
+      name: 'person',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+          email: { type: 'string' }
+        },
+        required: ['name', 'age']
+      }
+    },
+    {
+      name: 'product',
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          name: { type: 'string' },
+          price: { type: 'number' }
+        },
+        required: ['id', 'name', 'price']
+      }
+    }
+  ];
+
+  // Create an instance with auto-correction and schemas
+  const llmJson = new LlmJson({
+    attemptCorrection: true,
+    schemas
+  });
+
+  // Example 1: Valid JSON matching a schema
+  console.log('Example 1: Valid JSON matching a schema');
+  console.log('----------------------------------------');
+
+  const input1 = `Here's some customer information:
+  
+  {
+    "name": "John Doe",
+    "age": 32,
+    "email": "john.doe@example.com"
+  }
+  
+  Please process this customer data.`;
+
+  const result1 = llmJson.extract(input1);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result1.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result1.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 2: Valid JSON but doesn't match any schema
+  console.log('Example 2: Valid JSON but doesn\'t match any schema');
+  console.log('--------------------------------------------------');
+
+  const input2 = `Here's some location data:
+  
+  {
+    "latitude": 37.7749,
+    "longitude": -122.4194,
+    "city": "San Francisco"
+  }`;
+
+  const result2 = llmJson.extract(input2);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result2.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result2.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 3: Multiple JSON objects with some matching schemas
+  console.log('Example 3: Multiple JSON objects with some matching schemas');
+  console.log('--------------------------------------------------------');
+
+  const input3 = `Here are two different objects:
+  
+  First, a person:
+  {
+    "name": "Jane Smith",
+    "age": 28
+  }
+  
+  And a product:
+  {
+    "id": "prod-123",
+    "name": "Laptop",
+    "price": 999.99
+  }
+  
+  And something that doesn't match our schemas:
+  {
+    "title": "Meeting Notes",
+    "date": "2023-05-15"
+  }`;
+
+  const result3 = llmJson.extract(input3);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result3.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result3.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 4: Malformed JSON that gets corrected and validated
+  console.log('Example 4: Malformed JSON that gets corrected and validated');
+  console.log('----------------------------------------------------------');
+
+  const input4 = `This JSON has errors but should be fixed:
+  
+  {
+    name: "Alex Johnson",
+    age: 42,
+    email: "alex@example.com"
+  }`;
+
+  const result4 = llmJson.extract(input4);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result4.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result4.validatedJson, null, 2));
+}
+
+// Run the example
+runSchemaValidationExample(); 

package/examples/schema-validation-examples.ts

@@ -0,0 +1,248 @@
+import LlmJson from '../src/index';
+
+/**
+ * Comprehensive examples of schema validation with LLM-JSON
+ */
+function runSchemaValidationExamples() {
+    // Example 1: Basic schema with required and optional fields
+    
+    const input1 = `Here's a user profile:
+    {
+        "name": "John Doe",
+        "age": 30,
+        "email": "john@example.com",
+        "location": "New York"
+    }`;
+
+    const userSchema = {
+        name: 'user',
+        schema: {
+            type: 'object',
+            required: ['name', 'email'],  // These fields must be present
+            properties: {
+                name: { type: 'string' },
+                email: { type: 'string', format: 'email' },
+                age: { type: 'number' },  // Optional field
+                location: { type: 'string' }  // Optional field
+            }
+        }
+    };
+
+    // Example 2: Complex schema with nested objects and arrays
+
+    const input2 = `Here's a product catalog:
+    {
+        "product": {
+            "id": "123",
+            "name": "Smartphone",
+            "price": 599.99,
+            "specifications": {
+                "brand": "TechCo",
+                "model": "X100",
+                "features": ["5G", "Wireless Charging", "Dual Camera"]
+            },
+            "inventory": {
+                "inStock": true,
+                "quantity": 50,
+                "locations": [
+                    {
+                        "store": "Main Store",
+                        "quantity": 30
+                    },
+                    {
+                        "store": "Branch Store",
+                        "quantity": 20
+                    }
+                ]
+            }
+        }
+    }`;
+
+    const productSchema = {
+        name: 'product',
+        schema: {
+            type: 'object',
+            required: ['product'],
+            properties: {
+                product: {
+                    type: 'object',
+                    required: ['id', 'name', 'price', 'specifications', 'inventory'],
+                    properties: {
+                        id: { type: 'string' },
+                        name: { type: 'string' },
+                        price: { type: 'number', minimum: 0 },
+                        specifications: {
+                            type: 'object',
+                            required: ['brand', 'model', 'features'],
+                            properties: {
+                                brand: { type: 'string' },
+                                model: { type: 'string' },
+                                features: {
+                                    type: 'array',
+                                    items: { type: 'string' }
+                                }
+                            }
+                        },
+                        inventory: {
+                            type: 'object',
+                            required: ['inStock', 'quantity', 'locations'],
+                            properties: {
+                                inStock: { type: 'boolean' },
+                                quantity: { type: 'integer', minimum: 0 },
+                                locations: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        required: ['store', 'quantity'],
+                                        properties: {
+                                            store: { type: 'string' },
+                                            quantity: { type: 'integer', minimum: 0 }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    // Example 3: Multiple schemas for different types of data
+
+    const input3 = `Here are different types of records:
+    {
+        "employee": {
+            "id": "E123",
+            "name": "Jane Smith",
+            "department": "Engineering",
+            "skills": ["JavaScript", "TypeScript", "React"],
+            "contact": {
+                "email": "jane@company.com",
+                "phone": "+1-234-567-8900"
+            }
+        }
+    }
+
+    {
+        "project": {
+            "id": "P789",
+            "name": "Website Redesign",
+            "status": "in-progress",
+            "deadline": "2024-12-31",
+            "teamSize": 5,
+            "budget": 50000
+        }
+    }`;
+
+    const employeeSchema = {
+        name: 'employee',
+        schema: {
+            type: 'object',
+            required: ['employee'],
+            properties: {
+                employee: {
+                    type: 'object',
+                    required: ['id', 'name', 'department', 'skills', 'contact'],
+                    properties: {
+                        id: { type: 'string', pattern: '^E\\d+$' },  // Must start with E followed by numbers
+                        name: { type: 'string' },
+                        department: { type: 'string' },
+                        skills: { 
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 1  // Must have at least one skill
+                        },
+                        contact: {
+                            type: 'object',
+                            required: ['email'],
+                            properties: {
+                                email: { type: 'string', format: 'email' },
+                                phone: { type: 'string' }  // Optional
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    const projectSchema = {
+        name: 'project',
+        schema: {
+            type: 'object',
+            required: ['project'],
+            properties: {
+                project: {
+                    type: 'object',
+                    required: ['id', 'name', 'status', 'deadline', 'teamSize'],
+                    properties: {
+                        id: { type: 'string', pattern: '^P\\d+$' },  // Must start with P followed by numbers
+                        name: { type: 'string' },
+                        status: { 
+                            type: 'string',
+                            enum: ['not-started', 'in-progress', 'completed']  // Only these values allowed
+                        },
+                        deadline: { 
+                            type: 'string',
+                            format: 'date'  // Must be a valid date string
+                        },
+                        teamSize: { 
+                            type: 'integer',
+                            minimum: 1,
+                            maximum: 20  // Team size constraints
+                        },
+                        budget: {
+                            type: 'number',
+                            minimum: 0  // Optional but must be positive
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    // Create LlmJson instances with different schema combinations
+    const llmJson1 = new LlmJson({ attemptCorrection: true, schemas: [userSchema] });
+    const llmJson2 = new LlmJson({ attemptCorrection: true, schemas: [productSchema] });
+    const llmJson3 = new LlmJson({ attemptCorrection: true, schemas: [employeeSchema, projectSchema] });
+
+    // Run the examples
+    const result1 = llmJson1.extract(input1);
+    console.log('User Schema Validation Result:');
+    result1.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result1.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result1.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+
+    const result2 = llmJson2.extract(input2);
+    console.log('\nProduct Schema Validation Result:');
+    result2.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result2.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result2.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+
+    const result3 = llmJson3.extract(input3);
+    console.log('\nMultiple Schemas Validation Result:');
+    result3.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result3.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result3.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+}
+
+runSchemaValidationExamples();

package/package.json

@@ -1,53 +1,53 @@
-{
-    "name": "@solvers-hub/llm-json",
-    "version": "0.1.6",
-    "description": "A TypeScript SDK to extract and correct JSON from LLM outputs",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "author": "Solvers Hub",
-    "license": "MIT",
-    "scripts": {
-        "build": "tsc",
-        "test": "jest",
-        "test:coverage": "jest --coverage",
-        "lint": "eslint src/**/*.ts",
-        "prepublishOnly": "npm run build && npm run docs",
-        "example": "ts-node examples/example.ts",
-        "example:schema": "ts-node examples/schema-validation-example.ts",
-        "build:example": "tsc && node dist/examples/example.js",
-        "docs": "typedoc --out docs src",
-        "docs:md": "typedoc --out docs-md --plugin typedoc-plugin-markdown src"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/solvers-hub/llm-json.git"
-    },
-    "bugs": {
-        "url": "https://github.com/solvers-hub/llm-json/issues"
-    },
-    "homepage": "https://github.com/solvers-hub/llm-json#readme",
-    "keywords": [
-        "llm",
-        "json",
-        "extractor",
-        "parser"
-    ],
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
-        "jest": "^29.5.0",
-        "ts-jest": "^29.1.0",
-        "ts-node": "^10.9.1",
-        "typedoc": "^0.25.12",
-        "typedoc-plugin-markdown": "^3.17.1",
-        "typescript": "^5.0.4"
-    },
-    "dependencies": {
-        "ajv": "^8.17.1"
-    },
-    "files": [
-        "dist/**/*",
-        "docs/**/*",
-        "docs-md/**/*"
-    ]
+{
+    "name": "@solvers-hub/llm-json",
+    "version": "0.1.7",
+    "description": "A TypeScript SDK to extract and correct JSON from LLM outputs",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "Solvers Hub",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "test:coverage": "jest --coverage",
+        "lint": "eslint src/**/*.ts",
+        "prepublishOnly": "npm run build && npm run docs",
+        "example:run": "ts-node",
+        "docs": "typedoc --out docs src",
+        "docs:md": "typedoc --out docs-md --plugin typedoc-plugin-markdown src"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/solvers-hub/llm-json.git"
+    },
+    "bugs": {
+        "url": "https://github.com/solvers-hub/llm-json/issues"
+    },
+    "homepage": "https://github.com/solvers-hub/llm-json#readme",
+    "keywords": [
+        "llm",
+        "json",
+        "extractor",
+        "parser"
+    ],
+    "devDependencies": {
+        "@types/jest": "^29.5.0",
+        "@types/node": "^18.15.11",
+        "jest": "^29.5.0",
+        "ts-jest": "^29.1.0",
+        "ts-node": "^10.9.1",
+        "typedoc": "^0.25.12",
+        "typedoc-plugin-markdown": "^3.17.1",
+        "typescript": "^5.0.4"
+    },
+    "dependencies": {
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1"
+    },
+    "files": [
+        "dist/**/*",
+        "docs/**/*",
+        "docs-md/**/*",
+        "examples/**/*"
+    ]
 }