Getting Started with AI Guard Developer Portal

Welcome to AI Guard Developer Portal

AI Guard Developer Portal is a comprehensive platform for integrating AI guardrails, compliance checking, and LLM security into your applications. This guide will help you get started quickly.

Overview

The AI Guard Developer Portal provides:

• AI Guardrails: Input/output validation and content filtering
• LLM Connection Management: Configure and manage multiple AI model endpoints
• API Key Management: Secure API keys with built-in guardrails
• Privacy Guard: PII detection and redaction
• Citadel: Advanced prompt injection protection
• Compliance Checking: Industry-specific compliance validation
• Real-time Monitoring: Track usage, costs, and performance

Quick Start (5 Minutes)

Step 1: Log In

1. Navigate to developer.isms-cloud.com
2. Enter your credentials
3. Or click "Sign in with SSO" if using sso.platformaxion.com

First Time Login?

• Contact your administrator for account creation
• You'll receive an email with login credentials
• Change your password on first login

Step 2: Configure Your First LLM Connection

1. Go to Settings > LLM Connections
2. Click "Add New Connection"
3. Fill in the details:

For Azure OpenAI:

LLM Name: My Azure GPT-4
Provider: Azure OpenAI
Endpoint URL: https://your-resource.openai.azure.com/
API Key: your-azure-api-key
Model Name: gpt-4

For OpenAI:

LLM Name: OpenAI GPT-4
Provider: OpenAI
Endpoint URL: https://api.openai.com/v1/chat/completions
API Key: sk-...
Model Name: gpt-4-turbo

For GitHub Models:

LLM Name: GitHub GPT-4
Provider: GitHub Models
Endpoint URL: https://models.inference.ai.azure.com/chat/completions
API Key: your-github-token
Model Name: gpt-4o

4. Click "Test Connection" to verify
5. Click "Save"

Step 3: Create Your First API Key

1. Go to API Keys section
2. Click "Create New API Key"
3. Configure:

Key Name: My First API Key
LLM Connection: [Select from dropdown]
Enable Privacy Guard: ✓ (recommended)
Enable Input Guardrails: ✓ (recommended)
Enable Output Guardrails: ✓ (recommended)

4. Click "Generate API Key"
5. Important: Copy and save your API key immediately
   • Format: devkey_xxxxxxxxxxxxxxxxxx
   • You won't see it again!
   • Store securely (password manager, env vars)

Step 4: Test Your API Key

1. Go to API Playground
2. Select your API key from dropdown
3. Enter a test prompt:

What is artificial intelligence?

4. Click "Send Request"
5. View the response and guardrail results

Success! You're now ready to integrate AI Guard into your applications.

Understanding the Dashboard

After logging in, you'll see the main dashboard with:

Key Metrics

• Total API Calls: Lifetime request count
• Tokens Used: Total token consumption
• Cost: Estimated costs (if configured)
• Active Keys: Number of active API keys

Recent Activity

• Latest API requests
• Guardrail violations
• System alerts

Quick Actions

• Create API Key
• View API Logs
• Test in Playground
• View Documentation

Core Concepts

1. LLM Connections

What: Configuration for connecting to AI models Why: Centralize model endpoint management Example: Azure OpenAI, OpenAI, Anthropic, GitHub Models

2. API Keys

What: Secure credentials for API access Why: Control access and apply guardrails per key Format: devkey_[hash] Features:

• Per-key guardrail configuration
• Usage tracking
• Rate limiting
• Cost monitoring

3. Guardrails

What: Security and compliance validation rules Types:

• Input Guardrails: Validate user prompts
• Output Guardrails: Filter model responses
• Persona Guardrails: Enforce AI behavior/personality
• Agent Guardrails: Control agent actions

4. Privacy Guard

What: PII detection and redaction Detects:

• Email addresses
• Phone numbers
• SSN, credit cards
• Addresses
• Custom patterns

5. Citadel

What: Prompt injection protection Protects Against:

• Jailbreak attempts
• Prompt leaking
• Instruction override
• Malicious prompts

Making Your First API Call

Using cURL

curl -X POST https://developer.isms-cloud.com/public/api/dev_guard.php \
  -H "Content-Type: application/json" \
  -H "X-API-Key: devkey_your_api_key_here" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "What is machine learning?"
      }
    ],
    "max_tokens": 500
  }'

Using Python

import requests
import json

url = "https://developer.isms-cloud.com/public/api/dev_guard.php"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "devkey_your_api_key_here"
}

payload = {
    "messages": [
        {
            "role": "user",
            "content": "Explain neural networks"
        }
    ],
    "max_tokens": 500
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()

if data.get("success"):
    print("Response:", data["response"]["content"])
    print("\nGuardrail Results:")
    print(f"  Input: {data['guardrails']['input']['result']}")
    print(f"  Output: {data['guardrails']['output']['result']}")
else:
    print("Error:", data.get("error"))

Using Node.js

const axios = require('axios');

const url = 'https://developer.isms-cloud.com/public/api/dev_guard.php';
const apiKey = 'devkey_your_api_key_here';

const payload = {
  messages: [
    {
      role: 'user',
      content: 'What is deep learning?'
    }
  ],
  max_tokens: 500
};

axios.post(url, payload, {
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': apiKey
  }
})
.then(response => {
  const data = response.data;
  if (data.success) {
    console.log('Response:', data.response.content);
    console.log('\nGuardrail Results:');
    console.log('  Input:', data.guardrails.input.result);
    console.log('  Output:', data.guardrails.output.result);
  } else {
    console.error('Error:', data.error);
  }
})
.catch(error => {
  console.error('Request failed:', error.message);
});

Response Format

{
  "success": true,
  "response": {
    "role": "assistant",
    "content": "Machine learning is..."
  },
  "guardrails": {
    "input": {
      "result": "pass",
      "score": 0.95,
      "violations": []
    },
    "output": {
      "result": "pass",
      "score": 0.98,
      "violations": []
    },
    "privacy": {
      "pii_detected": false,
      "redactions": []
    }
  },
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 145,
    "total_tokens": 157
  },
  "model": "gpt-4",
  "cost": 0.0047
}

Next Steps

Learn More Features

1. Create Custom Guardrails: Define your own validation rules
2. Set Up Compliance: Configure industry-specific compliance checks
3. Monitor Usage: Track API calls and costs
4. Integrate Citadel: Add advanced prompt injection protection
5. Use Templates: Leverage pre-built guardrail templates

Best Practices

• ✓ Enable Privacy Guard for all production keys
• ✓ Use input AND output guardrails
• ✓ Test guardrails in playground before deployment
• ✓ Monitor API logs regularly
• ✓ Set rate limits on API keys
• ✓ Rotate API keys periodically
• ✓ Use different keys for dev/staging/production

Common Use Cases

Customer Support Chatbot:

• Enable Privacy Guard (protect customer PII)
• Input guardrail: Block inappropriate questions
• Output guardrail: Ensure helpful, professional responses
• Persona guardrail: Maintain brand voice

Document Q&A:

• Enable Citadel (prevent prompt injection)
• Input guardrail: Validate question format
• Output guardrail: Ensure factual responses
• Compliance: GDPR/HIPAA if needed

Code Assistant:

• Input guardrail: Validate code requests
• Output guardrail: Block insecure code patterns
• Citadel: Prevent jailbreak attempts

Getting Help

Documentation

• API Reference: Full API endpoint documentation
• Guardrail Library: Pre-built guardrail templates
• Integration Guides: Platform-specific guides
• Video Tutorials: Step-by-step walkthroughs

Support

• In-App Help: Click "?" icon in top menu
• Knowledge Base: support.platformaxion.com
• Email Support: support@guardaxion.com
• Status Page: Check system status

Community

• Share guardrail templates
• Best practices discussions
• Feature requests
• Bug reports

Security Notes

⚠️ Never commit API keys to version control

• Use environment variables
• Use secrets management (AWS Secrets Manager, Azure Key Vault)
• Rotate keys if exposed

⚠️ API Key Security

• Keys are shown only once at creation
• Store in secure location immediately
• Delete compromised keys immediately
• Use separate keys per environment

⚠️ Rate Limiting

• Default: 100 requests/minute per key
• Adjustable in API key settings
• Monitor usage to avoid limits

Troubleshooting

API Key Not Working

• Verify key starts with devkey_
• Check key is active in dashboard
• Ensure key hasn't been deleted
• Verify correct header: X-API-Key

Connection Timeout

• Check LLM endpoint URL is correct
• Verify API key for LLM is valid
• Test connection in Settings > LLM Connections
• Check network/firewall settings

Guardrail Blocking Valid Content

• Review guardrail configuration
• Adjust sensitivity scores
• Check violation details in API response
• Use playground to test and tune

High Costs

• Review token usage in logs
• Set max_tokens limits
• Use cheaper models for simple tasks
• Implement caching where possible
• Enable rate limiting

What's Next?

Now that you're set up, explore these guides:

1. API Key Management: Advanced key configuration
2. Custom Guardrails: Create your own validation rules
3. Privacy Guard Setup: Configure PII detection
4. Citadel Integration: Advanced security features
5. Monitoring & Analytics: Track usage and performance
6. Compliance Configuration: Industry-specific requirements
7. Template Library: Pre-built solutions

Ready to build secure AI applications! 🚀