Your First Data Model

Overview

This tutorial walks you through creating your first data model in SDCStudio using the React SPA interface. You'll learn the complete workflow from configuring Settings and uploading ontologies to generating published schemas.

Time to Complete: 15-20 minutes

What You'll Learn

How to configure Settings and upload ontologies
How to navigate the React SPA interface
How to upload and process data files
How AI analyzes and enhances your data with ontologies
How to review and customize model components
How to publish and generate multiple output formats

Prerequisites

An active SDCStudio account at https://sdcstudio.axius-sdc.com
A sample CSV file (or use our example below)
(Optional but recommended) Project/domain specific ontologies in Turtle (.ttl) format

Step 0: Configure Settings First! (Critical)

Before creating your first model, configure your Settings. This is the most important step for getting high-quality AI suggestions.

Access Settings

Sign In to SDCStudio
Click the Settings icon (gear/cog) in the top navigation bar
You'll see a modal or page with tabs: Profile, Ontologies, Preferences

Upload Your Ontologies

Why This Matters: - The AI uses your ontologies to understand your domain - Better semantic suggestions and component creation - Consistency with your organization's data vocabulary - Improved validation and relationship detection

Important Note: - Standard ontologies (FHIR, SNOMED, NIEM, schema.org, etc.) are already built into SDCStudio - You only need to upload your organization's custom/local domain ontologies - Upload vocabularies specific to your business, project, or industry that aren't in standard collections

Upload Process:

Click the "Ontologies" tab
Click "Upload Ontology" button
Select your Turtle (.ttl) file:
Your organization's custom vocabulary
Project-specific data dictionary
Industry-specific terminology not in standard ontologies
Fill in metadata:
Name: "Company Product Catalog" or "Internal Data Dictionary"
Description: "Custom vocabulary for our product classification"
Namespace: Your organization's namespace URI
Click "Save"
Repeat for multiple custom ontologies

What to Upload: - ✅ Your organization's data dictionary in Turtle format - ✅ Custom business vocabularies specific to your domain - ✅ Project-specific terminology not covered by standard ontologies - ❌ Standard ontologies (FHIR, NIEM, etc.) - already included

Configure Your Profile

Click the "Profile" tab
Update:
Display name
Email notifications
Organization info
Save changes

Now you're ready! Your uploaded ontologies will enhance all AI processing.

Step 1: Create Your First Project

Projects organize all your related work in one place.

Navigate and Create

Click "Projects" in the main navigation (left sidebar or top menu)
Click "Create New Project" button (usually top-right)
Fill in the form:
Name: Customer Management
Description: Tutorial: Learning SDCStudio with customer data
Domain (optional): Select Business/E-commerce
Click "Create"

You'll be redirected to your project dashboard.

Step 2: Prepare Your Data

For this tutorial, create a file called customers.csv:

customer_id,first_name,last_name,email,phone,signup_date,status,total_purchases,last_purchase_amount
1001,Jane,Smith,jane.smith@email.com,+1-555-0101,2024-01-15,active,5,129.99
1002,John,Doe,john.doe@email.com,+1-555-0102,2024-02-20,active,3,89.50
1003,Maria,Garcia,maria.garcia@email.com,+1-555-0103,2024-03-10,inactive,0,0.00
1004,James,Wilson,james.wilson@email.com,+1-555-0104,2024-04-05,active,12,249.99
1005,Lisa,Anderson,lisa.anderson@email.com,+1-555-0105,2024-05-12,active,7,179.50

This Data Includes: - Identifiers: Customer IDs - Text: Names, email addresses - Phone Numbers: With country code pattern - Dates: ISO date format - Categories: Status (active/inactive) - Counts: Purchase counts - Decimals: Currency amounts

Step 3: Upload Your Data

Upload Process

In Your Project, click the "Data Sources" tab
Click "Upload Data" button
Select File: Choose your customers.csv
Confirm: Click "Upload" or "Open"

You'll see your file appear in the Data Sources list with status badge UPLOADING.

Interface Updates

Watch the React interface update automatically: - Status badge changes color and text - Progress indicators may appear - No manual refresh needed - it's real-time!

Step 4: Watch the Two-Stage AI Processing

SDCStudio's intelligence works in two phases. The React interface shows real-time status updates.

Phase 1: Structural Parsing (30 seconds - 2 minutes)

Status Flow: UPLOADING → PARSING → PARSED

What's Happening Behind the Scenes:

The system is: - Detecting file format (CSV) - Identifying columns: - customer_id, first_name, last_name, email, phone - signup_date, status, total_purchases, last_purchase_amount - Inferring data types: - customer_id: Integer → XdCount - first_name, last_name: Text → XdString - email: Text with pattern → XdString (with email validation) - phone: Text with pattern → XdString (with phone pattern) - signup_date: Date → XdTemporal - status: Category text → XdString (with enumeration) - total_purchases: Integer count → XdCount - last_purchase_amount: Decimal → XdFloat (with currency unit)

You can keep working - the interface updates automatically!

Phase 2: AI Enhancement (1-5 minutes)

Status Flow: AGENT_PROCESSING → COMPLETED

What's Happening:

The AI is now using your uploaded ontologies to:

Semantic Analysis:
Understanding: "customer_id is a unique identifier"
Understanding: "email is contact information"
Understanding: "status represents account state"
Pattern Recognition:
Email pattern: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
Phone pattern: Country code + area code + number
Status values: Only "active" or "inactive"
Ontology Matching (YOUR ONTOLOGIES AT WORK!):
Matching "email" to schema.org email property
Matching "phone" to telecom/contact patterns
Applying domain-specific validation from your ontologies
Validation Rules:
Email: Required, pattern validation, max length 320
Phone: Optional, pattern validation
Status: Must be "active" or "inactive"
Purchases: Non-negative integer
Amount: Positive decimal with currency unit
Relationship Detection:
Grouping all fields into a "Customer" cluster
Identifying contact information as a logical group
Recognizing purchase-related fields as related data

The React interface shows progress - watch the status badge!

Step 5: Review Your Generated Data Model

Once status shows COMPLETED with a green badge:

Navigate to Your Model

Click the "Data Models" tab in your project
You'll see: customers data model (auto-created)
Click on the model name to open details

Explore the Model Structure

The React interface shows a structured view:

Data Model Level

Name: customers
Status: DRAFT (ready to edit and publish)
Components: 9 components created
Created By: AI processing (with your ontology input!)

Cluster Level

Cluster Name: customers_cluster
Purpose: Groups all customer-related fields
Components: Contains all 9 fields

Component Level

Click on individual components to see AI-generated details:

customer_id Component:

Type: XdCount (non-negative integer)
Label: "Customer ID"
Description: "Unique identifier for customer records"
Validation:
  - Required: Yes
  - Min Value: 1
  - Pattern: Positive integer

email Component:

Type: XdString (text)
Label: "Email Address"
Description: "Customer contact email"
Validation:
  - Required: Yes
  - Pattern: Email format validation
  - Max Length: 320 characters
  - Case: Lowercase recommended

phone Component:

Type: XdString (text)
Label: "Phone Number"
Description: "Customer contact phone with country code"
Validation:
  - Required: No
  - Pattern: +[country]-[area]-[number]
  - Format: International format

signup_date Component:

Type: XdTemporal (date/time)
Label: "Signup Date"
Description: "Date customer registered"
Format: ISO 8601 date (YYYY-MM-DD)
Validation:
  - Required: Yes
  - Valid date range

status Component:

Type: XdString (text)
Label: "Account Status"
Description: "Current status of customer account"
Validation:
  - Required: Yes
  - Enumeration: ["active", "inactive"]
  - Default: "active"

last_purchase_amount Component:

Type: XdFloat (decimal number)
Label: "Last Purchase Amount"
Description: "Value of most recent purchase"
Validation:
  - Required: No
  - Min Value: 0.00
  - Units: USD (currency)
  - Precision: 2 decimal places

Notice the Quality!

The AI used your ontologies to: - Choose appropriate data types - Add meaningful descriptions - Create sensible validation rules - Detect patterns automatically - Group related fields logically

Step 6: Customize Your Model (Optional but Recommended)

Refine the AI's work to match your exact requirements.

Edit a Component

In the component list, click "Edit" button on "status"
Review AI suggestions
Modify if needed:
Add more enumeration values if you have other statuses
Add documentation about state transitions
Set default value
Click "Save"

Add Custom Validation

Edit the "email" component
Add or modify:
Pattern: Keep AI's email regex or customize
Add: unique=true if emails must be unique
Add: Business rule documentation
Save changes

Enhance Descriptions

Edit any component
Add business context:
"This field is used by the billing system"
"Validated against customer database daily"
"Required for GDPR compliance"
Save

Your changes teach the AI! Future models in this project will benefit from your corrections.

Step 7: Publish Your Model

Publishing makes your model immutable and enables output generation.

Publish Process

In the Data Model details, click "Publish" button (may be in toolbar)
Review the summary:
Component count
Validation rules
Missing required fields (if any)
Fix any issues if validation fails
Click "Confirm Publish"

Status changes to PUBLISHED with a green badge.

What Happened: - Model locked for editing (create new version to modify) - Output generation enabled - XSD schema can now be created - Applications can be generated

Step 8: Generate Multiple Outputs

Now you can create various output formats from your published model.

Available Output Formats

The React interface provides a "Generate" dropdown or buttons for:

1. XSD Schema (XML Schema Definition)

Purpose: XML validation schema
Use: Data validation, integration, XML tools
Includes: All types, constraints, documentation

2. XML Instance (Example Document)

Purpose: Sample XML conforming to your schema
Use: Testing, documentation, examples
Includes: All fields with sample data

3. JSON Schema (JSON validation)

Purpose: JSON validation and documentation
Use: REST APIs, web apps, validation
Includes: Types, constraints, descriptions

4. JSON-LD (Linked Data schema)

Purpose: Semantic web integration
Use: Knowledge graphs, semantic search
Includes: RDF mappings, ontology links

5. HTML Documentation

Purpose: Human-readable documentation
Use: Team reference, stakeholder review
Includes: All fields, descriptions, diagrams

6. RDF Triples (Semantic data)

Purpose: Triple store integration
Use: Semantic databases, SPARQL queries
Includes: Subject-predicate-object statements

7. SHACL (Shape constraints)

Purpose: RDF validation rules
Use: Semantic validation, data quality
Includes: All validation constraints as shapes

8. GQL (Graph Query Language)

Purpose: Property graph database queries
Use: Neo4j, graph databases
Includes: CREATE statements for nodes/edges

How to Generate

Click "Generate" dropdown in your model toolbar
Select output type (e.g., "XSD Schema")
Configure options if presented:
Include documentation? (usually Yes)
Sample data? (for XML instance)
Validation strict/lenient?
Click "Generate"
Download automatically or from link

Try Multiple Formats! Each serves different use cases.

Step 9: Generate an Application (Advanced Optional)

SDCStudio can generate complete Django applications from your model.

AppGen Process

In model details, look for "Generate Application" button
Click to start AppGen wizard
Configure:
App Name: customer-management
App Type: Django project with models, forms, views
Features: Select CRUD operations, API endpoints
Click "Generate"
Download ZIP file with complete application
Extract and run: bash unzip customer-management.zip cd customer-management docker-compose up --build

Generated App Includes: - Django models matching your components - Web forms with validation - CRUD views (Create, Read, Update, Delete) - Admin interface - Docker configuration - XML instance generation

See: App Generation Guide for full details

What You've Accomplished!

Congratulations! You've completed the full SDCStudio workflow:

✅ Configured Settings with ontology uploads (THE FOUNDATION!) ✅ Navigated the React SPA interface confidently ✅ Created a project to organize your work ✅ Uploaded a CSV file with customer data ✅ Watched AI analyze your data in two phases using your ontologies ✅ Reviewed AI-generated components with semantic enrichment ✅ Customized components with your business rules ✅ Published your data model ✅ Generated multiple output formats (XSD, XML, JSON, etc.) ✅ (Optional) Generated a complete web application

Key Takeaways

🎯 Settings and Ontologies are Critical

Upload ontologies first - they drive AI quality
Update ontologies as your domain evolves
More ontologies = better semantic understanding

🔄 The Two-Stage Pipeline

Phase 1 (Fast): Structure parsing
Phase 2 (Smart): AI enhancement with ontologies
Real-time updates in React interface

📊 AI + Human Collaboration

AI does heavy lifting with ontology guidance
You refine and add business context
System learns from your corrections

🚀 Multiple Output Formats

One model → many formats
XSD for validation
JSON for APIs
RDF for semantic web
Applications for end users

Next Steps

Enhance Your Skills

Data Modeling Guide
Advanced component types
Complex structures and relationships
Best practices for model design
Semantic Enhancement Guide
Finding and preparing ontologies
Creating custom vocabularies
Ontology best practices
Generating Outputs Guide
Deep dive into each output format
Customization options
Integration strategies

Try Different Scenarios

Healthcare Data: Patient records with FHIR ontology
Financial Data: Transactions with accounting vocabulary
IoT Data: Sensor readings with units and quantified types
Document Metadata: Content with Dublin Core ontology

Build Your Component Library

Create reusable components across projects
Establish organization standards
Share components with your team
Version control your models

Troubleshooting

File Won't Upload

Check file size (< 10MB recommended)
Verify CSV format (headers in first row)
Ensure UTF-8 encoding
Check file permissions

Processing Stuck

Wait 60 seconds for auto-refresh
Click "Refresh" if available
Check status badge color
Look for error messages

Agent Processing Failed

Status: AGENT_ERROR
Action: Click "Retry" button
Check: Error log for details
Try: Simplifying data structure
Contact: support@axius-sdc.com if persists

Can't Publish Model

Check all components are valid
Ensure required fields are set
Review validation errors in UI
Fix any duplicate component names

Generation Fails

Verify model is published
Check for missing validation rules
Ensure no circular references
Review error messages in UI

Getting Help

Documentation: User Guides - Comprehensive feature docs
Troubleshooting: Troubleshooting Guide - Common issues
Support Email: support@axius-sdc.com
Community: Join discussions with other users

Success Indicators

You're ready for advanced features when you can:

✅ Configure Settings and manage ontologies ✅ Navigate the React SPA without hesitation ✅ Upload data and understand processing stages ✅ Review and customize AI-generated components ✅ Publish models and generate multiple outputs ✅ Troubleshoot common issues independently ✅ Explain how ontologies improve AI quality

Ready to explore advanced features? Check out the Data Modeling Guide for complex structures, or Semantic Enhancement to master ontology integration.