DSL-Leitfaden¶

Andere Sprachen¶

Meistern Sie die Symbi DSL fuer den Aufbau richtlinienbewusster, sicherer KI-Agenten.

Inhaltsverzeichnis¶

Ueberblick¶

Die Symbi DSL ist eine domaenenspezifische Sprache, die fuer die Erstellung autonomer, richtlinienbewusster Agenten entwickelt wurde. Sie kombiniert traditionelle Programmierstrukturen mit erweiterten Sicherheitsfeatures, kryptographischen Operationen und deklarativen Richtliniendefinitionen.

Hauptmerkmale¶

Sicherheitsorientiertes Design: Eingebaute Richtliniendurchsetzung und Audit-Funktionen
Deklarative Richtlinien: Sicherheitsanforderungen als Code ausdruecken
Kryptographische Operationen: Native Unterstuetzung fuer Verschluesselung, Signierung und Beweise
Inter-Agent-Kommunikation: Eingebaute Messaging- und Kollaborationsmuster
Typsicherheit: Starke Typisierung mit sicherheitsbewussten Typannotationen

Sprachsyntax¶

Grundstruktur¶

Jedes Symbi-Programm besteht aus optionalen Metadaten und Agentendefinitionen:

metadata {
    version: "1.0.0"
    author: "developer"
    description: "Example agent"
}

agent process_data(input: DataSet) -> Result {
    // Agent implementation
}

Geplantes Feature -- Import-Syntax ist fuer ein zukuenftiges Release geplant.
import data_processing as dp;
import security_utils;

Kommentare¶

// Single-line comment
# Hash-style comment (also supported)

/*
 * Multi-line comment
 * Supports markdown formatting
 */

Metadatenbloecke¶

Metadaten stellen wesentliche Informationen ueber Ihren Agenten bereit:

metadata {
    version: "1.2.0"
    author: "ThirdKey Security Team"
    description: "Healthcare data analysis agent with HIPAA compliance"
    license: "Proprietary"
    tags: ["healthcare", "hipaa", "analysis"]
    min_runtime_version: "1.0.0"
    dependencies: ["medical_nlp", "privacy_tools"]
}

Metadatenfelder¶

Feld	Typ	Erforderlich	Beschreibung
`version`	String	Ja	Semantische Version des Agenten
`author`	String	Ja	Agent-Autor oder Organisation
`description`	String	Ja	Kurze Beschreibung der Agent-Funktionalitaet
`license`	String	Nein	Lizenzidentifikator
`tags`	Array[String]	Nein	Klassifizierungs-Tags
`min_runtime_version`	String	Nein	Minimal erforderliche Runtime-Version
`dependencies`	Array[String]	Nein	Externe Abhaengigkeiten

Agentendefinitionen¶

Grundlegende Agentenstruktur¶

agent agent_name(param1: Type1, param2: Type2) -> ReturnType {
    capabilities: [capability1, capability2]

    policy policy_name {
        // Policy rules
    }

    with configuration_options {
        // Agent implementation
    }
}

Agentenparameter¶

Unterstuetzung fuer verschiedene Parametertypen:

agent complex_agent(
    // Basic types
    name: String,
    age: int,
    active: bool,

    // Optional parameters
    email: Optional<String>,

    // Complex types
    data: Array<Record>,
    config: Map<String, Value>,

    // Security-aware types
    sensitive_data: EncryptedData<PersonalInfo>,
    credentials: SecureString
) -> ProcessingResult {
    // Implementation
}

Faehigkeitsdeklaration¶

Deklarieren Sie, was Ihr Agent kann:

agent data_processor(input: DataSet) -> Analysis {
    capabilities: [
        data_analysis,          // Core data processing
        statistical_modeling,   // Advanced analytics
        report_generation,      // Output formatting
        audit_logging           // Compliance tracking
    ]

    // Implementation
}

Richtliniendefinitionen¶

Richtlinien definieren Sicherheits- und Compliance-Regeln, die zur Laufzeit durchgesetzt werden.

Richtlinienstruktur¶

policy policy_name {
    allow: action_list if condition
    deny: action_list if condition
    require: requirement_list
    audit: audit_specification
}

Zugriffskontrollrichtlinien¶

policy medical_data_access {
    allow: ["read", "analyze"] if user.role == "doctor"
    allow: ["read"] if user.role == "nurse"
    deny: ["export", "print"] if data.contains_pii == true
    require: [
        user.clearance >= "medical_professional",
        session.mfa_verified == true,
        audit_trail = true
    ]
}

Datenklassifizierungsrichtlinien¶

policy data_classification {
    allow: process(data) if data.anonymized == true
    deny: store(data) if data.classification == "restricted"
    audit: all_operations with digital_signature
}

Komplexe Richtlinienlogik¶

policy dynamic_access_control {
    allow: read(resource) if (
        user.department == resource.owner_department ||
        user.role == "administrator" ||
        (user.role == "auditor" && current_time.business_hours)
    )

    deny: write(resource) if (
        resource.locked == true ||
        user.last_training < 30d ||
        system.maintenance_mode == true
    )

    require: approval("supervisor") for operations on sensitive_data
}

Typsystem¶

Primitive Typen¶

// Basic types
let name: String = "Alice";
let count: int = 42;
let rate: float = 3.14;
let active: bool = true;

Sammlungstypen¶

// Arrays
let numbers: Array<int> = [1, 2, 3, 4, 5];
let names: Array<String> = ["Alice", "Bob", "Charlie"];

// Maps
let config: Map<String, String> = {
    "host": "localhost",
    "port": "8080",
    "ssl": "true"
};

// Sets
let unique_ids: Set<String> = {"id1", "id2", "id3"};

Sicherheitsbewusste Typen¶

// Encrypted types
let secret: EncryptedString = encrypt("sensitive_data", key);
let secure_number: Encrypted<int> = encrypt(42, key);

// Private data with differential privacy
let private_data: PrivateData<float> = PrivateData::new(value, epsilon=1.0);

// Verifiable results with zero-knowledge proofs
let verified_result: VerifiableResult<Analysis> = VerifiableResult {
    value: analysis,
    proof: generate_proof(analysis),
    signature: sign(analysis)
};

Benutzerdefinierte Typen¶

// Type aliases
type UserId = String;
type EncryptedPersonalInfo = EncryptedData<PersonalInfo>;

Geplantes Feature -- struct- und enum-Definitionen sind fuer ein zukuenftiges Release geplant. Derzeit werden nur type-Aliase unterstuetzt.

// Struct definitions (geplant)
struct PersonalInfo {
    name: String,
    email: EncryptedString,
    phone: Optional<String>,
    birth_date: Date
}

// Enum definitions (geplant)
enum SecurityLevel {
    Public,
    Internal,
    Confidential,
    Restricted
}

Ausfuehrungskontext¶

Konfigurieren Sie die Ausfuehrung Ihres Agenten mit der with-Klausel:

Speicherverwaltung¶

agent persistent_agent(data: DataSet) -> Result {
    with memory = "persistent", storage = "encrypted" {
        // Agent state persists across sessions
        store_knowledge(data);
        return process_with_history(data);
    }
}

agent ephemeral_agent(query: String) -> Answer {
    with memory = "ephemeral", cleanup = "immediate" {
        // Agent state is discarded after execution
        return quick_answer(query);
    }
}

Datenschutzeinstellungen¶

agent privacy_preserving_agent(sensitive_data: PersonalInfo) -> Statistics {
    with privacy = "differential", epsilon = 1.0 {
        // Add differential privacy noise
        let noisy_stats = compute_statistics(sensitive_data);
        return add_privacy_noise(noisy_stats, epsilon);
    }
}

Sicherheitskonfiguration¶

agent high_security_agent(classified_data: ClassifiedInfo) -> Report {
    with
        security = "maximum",
        sandbox = "firecracker",
        encryption = "homomorphic",
        requires = "top_secret_clearance"
    {
        // High-security processing
        return process_classified(classified_data);
    }
}

Eingebaute Funktionen¶

Datenverarbeitung¶

// Validation functions
if (validate_input(data)) {
    // Process valid data
}

// Data transformation
let cleaned_data = sanitize(raw_data);
let normalized = normalize(cleaned_data);

Kryptographische Operationen¶

// Encryption/Decryption
let encrypted = encrypt(plaintext, public_key);
let decrypted = decrypt(ciphertext, private_key);

// Digital signatures
let signature = sign(message, private_key);
let valid = verify(message, signature, public_key);

// Zero-knowledge proofs
let proof = prove(statement);
let verified = verify_proof(proof, public_statement);

Audit und Protokollierung¶

// Audit logging
audit_log("operation_started", {
    "operation": "data_processing",
    "user": user.id,
    "timestamp": now()
});

// Security events
security_event("policy_violation", {
    "policy": "data_access",
    "user": user.id,
    "resource": resource.id
});

Inter-Agent-Kommunikation¶

Direktes Messaging¶

agent coordinator(task: Task) -> Result {
    with communication = "secure" {
        // Send task to specialized agent
        let result = agent security_analyzer.analyze(task);

        if (result.safe) {
            let processed = agent data_processor.process(task);
            return processed;
        } else {
            return reject("Security check failed");
        }
    }
}

agent event_publisher(event: Event) -> Confirmation {
    with communication = "broadcast" {
        // Broadcast event to all subscribers
        broadcast(EventNotification {
            type: event.type,
            data: event.data,
            timestamp: now()
        });

        return Confirmation { sent: true };
    }
}

agent event_subscriber() -> Void {
    with communication = "subscribe" {
        // Subscribe to specific events
        let events = subscribe(EventNotification);

        for event in events {
            process_event(event);
        }
    }
}

Sichere Kommunikation¶

agent secure_collaborator(request: SecureRequest) -> SecureResponse {
    with
        communication = "encrypted",
        authentication = "mutual_tls"
    {
        // Establish secure channel
        let channel = establish_secure_channel(request.source);

        // Send encrypted response
        let response = process_request(request);
        return encrypt_response(response, channel.key);
    }
}

Fehlerbehandlung¶

Try-Catch-Bloecke¶

agent robust_processor(data: DataSet) -> Result {
    try {
        let validated = validate_data(data);
        let processed = process_data(validated);
        return Ok(processed);
    } catch (ValidationError e) {
        audit_log("validation_failed", e.details);
        return Error("Invalid input data");
    } catch (ProcessingError e) {
        audit_log("processing_failed", e.details);
        return Error("Processing failed");
    }
}

Fehlerwiederherstellung¶

agent fault_tolerant_agent(input: Input) -> Result {
    let max_retries = 3;
    let retry_count = 0;

    while (retry_count < max_retries) {
        try {
            return process_with_fallback(input);
        } catch (TransientError e) {
            retry_count += 1;
            sleep(exponential_backoff(retry_count));
        } catch (PermanentError e) {
            return Error(e.message);
        }
    }

    return Error("Max retries exceeded");
}

Erweiterte Features¶

Bedingte Kompilierung¶

Geplantes Feature -- Bedingte Kompilierung ist fuer ein zukuenftiges Release geplant.

agent development_agent(data: DataSet) -> Result {
    capabilities: [development, testing]

    #if debug {
        debug_log("Processing data: " + data.summary);
    }

    #if feature.enhanced_security {
        policy strict_security {
            require: multi_factor_authentication
            audit: all_operations with timestamps
        }
    }

    // Implementation
}

Makros und Codegenerierung¶

Geplantes Feature -- Makrodefinitionen sind fuer ein zukuenftiges Release geplant.

// Define reusable policy template
macro secure_data_policy($classification: String) {
    policy secure_access {
        allow: read(data) if user.clearance >= $classification
        deny: export(data) if data.contains_pii
        audit: all_operations with signature
    }
}

agent classified_processor(data: ClassifiedData) -> Report {
    // Use the macro
    secure_data_policy!("secret");

    // Implementation
}

Integration mit externen Systemen¶

agent api_integrator(request: APIRequest) -> APIResponse {
    capabilities: [api_access, data_transformation]

    policy api_access {
        allow: call(external_api) if api.rate_limit_ok
        require: valid_api_key
        audit: all_api_calls with response_codes
    }

    with
        timeout = 30.seconds,
        retry_policy = "exponential_backoff"
    {
        let response = call_external_api(request);
        return transform_response(response);
    }
}

Best Practices¶

Sicherheitsleitlinien¶

Definieren Sie immer Richtlinien fuer Datenzugriff und Operationen
Verwenden Sie verschluesselte Typen fuer sensible Daten
Implementieren Sie Audit-Protokollierung fuer Compliance
Validieren Sie alle Eingaben vor der Verarbeitung
Verwenden Sie das Prinzip der minimalen Berechtigung in Richtliniendefinitionen

Leistungsoptimierung¶

Verwenden Sie fluechtigen Speicher fuer kurzlebige Agenten
Buendeln Sie Operationen wenn moeglich
Implementieren Sie ordnungsgemaesse Fehlerbehandlung mit Wiederholungen
Ueberwachen Sie die Ressourcennutzung im Ausfuehrungskontext
Verwenden Sie geeignete Datentypen fuer Ihren Anwendungsfall

Code-Organisation¶

Gruppieren Sie verwandte Richtlinien im selben Block
Verwenden Sie beschreibende Faehigkeitsnamen
Dokumentieren Sie komplexe Richtlinienlogik mit Kommentaren
Trennen Sie Anliegen in verschiedene Agenten
Verwenden Sie gemeinsame Muster wieder mit gemeinsamen Richtliniendefinitionen

Beispiele¶

Gesundheitsdaten-Prozessor¶

metadata {
    version: "2.1.0"
    author: "Medical AI Team"
    description: "HIPAA-compliant patient data analyzer"
    tags: ["healthcare", "hipaa", "privacy"]
}

agent medical_analyzer(patient_data: EncryptedPatientRecord) -> MedicalInsights {
    capabilities: [
        medical_analysis,
        privacy_preservation,
        audit_logging,
        report_generation
    ]

    policy hipaa_compliance {
        allow: analyze(data) if user.medical_license.valid
        deny: export(data) if data.contains_identifiers
        require: [
            user.hipaa_training.completed,
            session.secure_connection,
            audit_trail = true
        ]
    }

    with
        memory = "encrypted",
        privacy = "differential",
        security = "high",
        requires = "medical_clearance"
    {
        try {
            let decrypted = decrypt(patient_data, medical_key);
            let anonymized = anonymize_data(decrypted);
            let insights = analyze_medical_data(anonymized);

            audit_log("analysis_completed", {
                "patient_id_hash": hash(decrypted.id),
                "insights_generated": insights.count,
                "timestamp": now()
            });

            return insights;
        } catch (DecryptionError e) {
            security_event("decryption_failed", e.details);
            return Error("Unable to process patient data");
        }
    }
}

Finanz-Transaktionsmonitor¶

agent fraud_detector(transaction: Transaction) -> FraudAssessment {
    capabilities: [fraud_detection, risk_analysis, real_time_processing]

    policy financial_compliance {
        allow: analyze(transaction) if user.role == "fraud_analyst"
        deny: store(transaction.details) if transaction.amount > 10000
        require: [
            user.financial_license.valid,
            system.compliance_mode.active,
            real_time_monitoring = true
        ]
        audit: all_decisions with reasoning
    }

    with
        memory = "ephemeral",
        timeout = 500.milliseconds,
        priority = "high"
    {
        let risk_score = calculate_risk(transaction);
        let historical_pattern = analyze_pattern(transaction.account_id);

        if (risk_score > 0.8 || historical_pattern.suspicious) {
            alert_fraud_team(transaction, risk_score);
            return FraudAssessment {
                risk_level: "high",
                recommended_action: "block_transaction",
                confidence: risk_score
            };
        }

        return FraudAssessment {
            risk_level: "low",
            recommended_action: "approve",
            confidence: 1.0 - risk_score
        };
    }
}

Naechste Schritte¶

DSL-Spezifikation - Vollstaendige Sprachspezifikationsreferenz
Runtime-Architektur - Verstehen Sie, wie Agenten ausgefuehrt werden
Sicherheitsmodell - Lernen Sie ueber die Sicherheitsimplementierung
API-Referenz - Vollstaendige Funktions- und Typenreferenz
Beispiele - Weitere vollstaendige Beispiele

Bereit, Ihren ersten Agenten zu erstellen? Schauen Sie sich unseren Startleitfaden an oder erkunden Sie die Runtime-Beispiele.