Quick Start Guide

{
  "simulation_id": "sim_abc123def456",
  "status": "queued",
  "created_at": "2024-01-15T10:30:00Z",
  "estimated_completion_time": "2024-01-15T10:35:00Z",
  "prompt": "Create a busy downtown intersection with pedestrians crossing, cars waiting at traffic lights, and a food truck on the corner"
}

curl -X POST "https://api.vects.ai/risk-assessment/" \
  -H "Authorization: Api-Key YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "routePoints": [
      {"lat": 37.7749, "lng": -122.4194},
      {"lat": 37.7849, "lng": -122.4094}
    ]
  }'

{
  "riskPoints": [
    {
      "lat": 37.7749,
      "lng": -122.4194,
      "weight": 0.2,
      "riskLevel": "low"
    },
    {
      "lat": 37.7849,
      "lng": -122.4094,
      "weight": 0.7,
      "riskLevel": "high"
    }
  ],
  "summary": {
    "overallRisk": "medium",
    "averageRisk": 0.45
  }
}

const ws = new WebSocket('ws://api.vects.ai:8001/ws/marl_state');

ws.onopen = function() {
  console.log('Connected to MARL WebSocket');
  
  // Request initial agents
  ws.send(JSON.stringify({
    type: 'request_initial_agents',
    payload: {
      focus_latitude: 37.7749,
      focus_longitude: -122.4194
    }
  }));
};

ws.onmessage = function(event) {
  const message = JSON.parse(event.data);
  
  switch(message.type) {
    case 'add_agent':
      console.log('New agent:', message.payload.id);
      // Add agent to your 3D scene
      break;
    case 'initial_population_complete':
      console.log(`Loaded ${message.payload.count} agents`);
      break;
  }
};

const emergencySimulation = {
  prompt: "Simulate a building evacuation during a fire emergency with multiple exit routes and emergency responders",
  scenario_type: "emergency_response",
  settings: {
    max_agents: 300,
    simulation_duration: 600,
    environment_type: "indoor"
  }
};

const urbanPlanningSimulation = {
  prompt: "Model pedestrian and vehicle traffic around a new subway station entrance during rush hour",
  scenario_type: "urban_planning",
  settings: {
    max_agents: 800,
    simulation_duration: 3600,
    environment_type: "mixed"
  }
};

const securitySimulation = {
  prompt: "Analyze crowd flow and security coverage at a large outdoor event with multiple entry points",
  scenario_type: "security_assessment",
  settings: {
    max_agents: 1000,
    simulation_duration: 7200,
    environment_type: "outdoor"
  }
};

import React, { useState, useEffect } from 'react';

function StructSimulation() {
  const [simulation, setSimulation] = useState(null);
  const [status, setStatus] = useState('idle');

  const createSimulation = async () => {
    setStatus('creating');
    
    const response = await fetch('https://api.vects.ai/api/v1/simulations/', {
      method: 'POST',
      headers: {
        'Authorization': `Api-Key ${process.env.REACT_APP_Struct_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt: "Create a busy city intersection with traffic and pedestrians"
      })
    });
    
    const sim = await response.json();
    setSimulation(sim);
    setStatus('processing');
    
    // Poll for completion
    pollStatus(sim.simulation_id);
  };

  const pollStatus = async (simulationId) => {
    const response = await fetch(`https://api.vects.ai/api/v1/simulations/${simulationId}/status/`);
    const statusData = await response.json();
    
    if (statusData.status === 'completed') {
      setStatus('completed');
    } else {
      setTimeout(() => pollStatus(simulationId), 5000);
    }
  };

  return (
    <div>
      <h1>Struct Simulation</h1>
      <button onClick={createSimulation} disabled={status !== 'idle'}>
        Create Simulation
      </button>
      <p>Status: {status}</p>
      {simulation && <p>ID: {simulation.simulation_id}</p>}
    </div>
  );
}

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;

public class StructIntegration : MonoBehaviour 
{
    private string apiKey = "YOUR_API_KEY";
    private string baseUrl = "https://api.vects.ai/api/v1";
    
    public void CreateSimulation() 
    {
        StartCoroutine(CreateSimulationCoroutine());
    }
    
    IEnumerator CreateSimulationCoroutine() 
    {
        string json = JsonUtility.ToJson(new {
            prompt = "Create a busy intersection with cars and pedestrians"
        });
        
        using (UnityWebRequest request = UnityWebRequest.Post($"{baseUrl}/simulations/", json, "application/json")) 
        {
            request.SetRequestHeader("Authorization", $"Api-Key {apiKey}");
            
            yield return request.SendWebRequest();
            
            if (request.result == UnityWebRequest.Result.Success) 
            {
                var response = JsonUtility.FromJson<SimulationResponse>(request.downloadHandler.text);
                Debug.Log($"Simulation created: {response.simulation_id}");
                
                StartCoroutine(PollStatus(response.simulation_id));
            }
        }
    }
}