Quick Start Template

Copy this to your project and customize for your needs.

Python Quick Start

from orionai import OrionAI, ValidationResult

# Initialize OrionAI with your config
orion = OrionAI("path/to/CaseyProtocol.json")

# Example: Validate AI-generated content
def validate_ai_output(ai_text, system_name="MyAI"):
    """
    Validate any AI-generated text before using it
    
    Args:
        ai_text: The text generated by your AI system
        system_name: Name of your AI system for tracking
        
    Returns:
        Sanitized text if approved, None if rejected
    """
    report = orion.monitor_ai_decision(
        ai_system=system_name,
        decision=ai_text,
        context="Your application context here"
    )
    
    # Handle different validation results
    if report.result == ValidationResult.APPROVED:
        return report.sanitized_decision
    
    elif report.result == ValidationResult.SANITIZED:
        print(f"[!] PII removed from output")
        return report.sanitized_decision
    
    elif report.result == ValidationResult.QUARANTINED:
        print(f"[!] Output quarantined: {report.triggered_rules}")
        # Log for review, return safe fallback
        return None
    
    else:  # REJECTED
        print(f"[X] Output rejected: {report.triggered_rules}")
        return None


# Example usage in your application
user_input = "What should I do?"
ai_response = your_ai_model.generate(user_input)

# Validate before showing to user
safe_response = validate_ai_output(ai_response, "ChatBot")

if safe_response:
    display_to_user(safe_response)
else:
    display_to_user("I'm sorry, I can't help with that.")

C++ Quick Start (Unreal Engine 5)

// YourGameMode.h
#include "OrionAI.h"

UCLASS()
class AYourGameMode : public AGameModeBase
{
    GENERATED_BODY()

protected:
    virtual void BeginPlay() override;
    
    UFUNCTION(BlueprintCallable)
    FString ValidateAIText(const FString& AIText, const FString& SystemName);
};

// YourGameMode.cpp
void AYourGameMode::BeginPlay()
{
    Super::BeginPlay();
    
    // Initialize OrionAI once at game startup
    UOrionAI::Initialize(TEXT("Config/CaseyProtocol.json"));
}

FString AYourGameMode::ValidateAIText(const FString& AIText, const FString& SystemName)
{
    // Validate AI-generated content (NPC dialogue, chat, etc.)
    FOrionValidationReport Report = UOrionAI::MonitorAIDecision(
        SystemName,
        AIText,
        TEXT("Game content")
    );
    
    // Handle validation results
    switch (Report.Result)
    {
        case EOrionValidationResult::Approved:
        case EOrionValidationResult::Sanitized:
            return Report.SanitizedDecision;
            
        case EOrionValidationResult::Quarantined:
            UE_LOG(LogTemp, Warning, TEXT("AI output quarantined"));
            return TEXT(""); // Return safe fallback
            
        case EOrionValidationResult::Rejected:
            UE_LOG(LogTemp, Error, TEXT("AI output rejected"));
            return TEXT(""); // Return safe fallback
    }
    
    return TEXT("");
}

Note: C++ implementation is Unreal Engine 5 specific. For industry-agnostic C++ (coming soon), see roadmap below.

REST API Template (Future Dashboard)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from orionai import OrionAI, ValidationResult

app = FastAPI(title="OrionAI Validation Service")
orion = OrionAI("Config/CaseyProtocol.json")

class ValidationRequest(BaseModel):
    system: str
    decision: str
    context: str = ""

class ValidationResponse(BaseModel):
    result: str
    sanitized_decision: str
    triggered_rules: list
    suspicion_score: float

@app.post("/validate", response_model=ValidationResponse)
async def validate(request: ValidationRequest):
    """Validate AI output via REST API"""
    
    report = orion.monitor_ai_decision(
        ai_system=request.system,
        decision=request.decision,
        context=request.context
    )
    
    return ValidationResponse(
        result=report.result.value,
        sanitized_decision=report.sanitized_decision,
        triggered_rules=report.triggered_rules,
        suspicion_score=report.suspicion_score
    )

@app.get("/health")
async def health():
    """Health check endpoint"""
    return {"status": "operational", "service": "OrionAI"}

# Run with: uvicorn quickstart:app --reload

Environment Setup

# .env file template
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
GITHUB_API_TOKEN=ghp_your_github_token_here
GITHUB_REPO=your-org/your-repo
JIRA_API_TOKEN=your_jira_api_token
JIRA_URL=https://your-domain.atlassian.net
JIRA_PROJECT=YOURPROJECT

# Ring Intel ML (optional)
RING_INTEL_ENABLED=true
RING_INTEL_CONFIDENCE=0.85

Customization Checklist

Support

See Docs/INTEGRATION.md for detailed integration guides for each platform.

FilesExpand file tree

QUICKSTART.md

Latest commit

History