admin login

frontend/src/App.tsx

@@ -9,8 +9,10 @@ import ExplorePage from './pages/ExplorePage';
 import HelpPage from './pages/HelpPage';
 import MapDetailPage from './pages/MapDetailsPage';
 import DemoPage from './pages/DemoPage';
-import DevPage from './pages/DevPage';
+
+import AdminPage from './pages/AdminPage/AdminPage';
 import { FilterProvider } from './contexts/FilterContext';
+import { AdminProvider } from './contexts/AdminContext';
 
 const router = createHashRouter([
   {
@@ -22,7 +24,8 @@ const router = createHashRouter([
       { path: '/explore',   element: <ExplorePage /> },
       { path: '/help',      element: <HelpPage /> },
       { path: '/demo',      element: <DemoPage /> },
-      { path: '/dev',       element: <DevPage /> },
+      
+      { path: '/admin',     element: <AdminPage /> },
       { path: '/map/:mapId', element: <MapDetailPage /> },
     ],
   },
@@ -95,9 +98,11 @@ function Application() {
   return (
     <AlertContext.Provider value={alertContextValue}>
       <LanguageContext.Provider value={languageContextValue}>
-        <FilterProvider>
-          <RouterProvider router={router} />
-        </FilterProvider>
+        <AdminProvider>
+          <FilterProvider>
+            <RouterProvider router={router} />
+          </FilterProvider>
+        </AdminProvider>
       </LanguageContext.Provider>
     </AlertContext.Provider>
   );

frontend/src/components/HeaderNav.tsx

@@ -8,6 +8,7 @@ import {
   GoMainIcon,
   SettingsIcon,
 } from "@ifrc-go/icons";
+import { useAdmin } from "../contexts/AdminContext";
 
 declare global {
   interface Window {
@@ -19,12 +20,12 @@ const navItems = [
   { to: "/upload",    label: "Upload",    Icon: UploadCloudLineIcon },
   { to: "/explore",   label: "Explore",   Icon: SearchLineIcon },
   { to: "/analytics", label: "Analytics", Icon: AnalysisIcon },
-  { to: "/dev",       label: "Dev",       Icon: SettingsIcon },
 ];
 
 export default function HeaderNav() {
   const location = useLocation();
   const navigate = useNavigate();
+  const { isAuthenticated } = useAdmin();
 
   return (
     <nav className="border-b border-gray-200 bg-white shadow-sm sticky top-0 z-50 backdrop-blur-sm bg-white/95">
@@ -72,18 +73,18 @@ export default function HeaderNav() {
                         ? 'shadow-lg shadow-ifrcRed/20 transform scale-105' 
                         : 'hover:bg-white hover:shadow-md hover:scale-105'
                     }`}
-                                      onClick={() => {
-                    if (location.pathname === "/upload") {
-                      if (window.confirmNavigationIfNeeded) {
-                        window.confirmNavigationIfNeeded(to);
-                        return;
+                    onClick={() => {
+                      if (location.pathname === "/upload") {
+                        if (window.confirmNavigationIfNeeded) {
+                          window.confirmNavigationIfNeeded(to);
+                          return;
+                        }
+                        if (!confirm("You have unsaved changes. Are you sure you want to leave?")) {
+                          return;
+                        }
                       }
-                      if (!confirm("You have unsaved changes. Are you sure you want to leave?")) {
-                        return;
-                      }
-                    }
-                    navigate(to);
-                  }}
+                      navigate(to);
+                    }}
                   >
                     <Icon className={`w-4 h-4 transition-transform duration-200 ${
                       isActive ? 'scale-110' : 'group-hover:scale-110'
@@ -99,31 +100,66 @@ export default function HeaderNav() {
           })}
         </nav>
 
-        <Button
-          name="help"
-          variant={location.pathname === '/help' ? "primary" : "tertiary"}
-          size={1}
-          className={`transition-all duration-200 ${
-            location.pathname === '/help'
-              ? 'shadow-lg shadow-ifrcRed/20 transform scale-105'
-              : 'hover:bg-blue-50 hover:text-blue-600 hover:shadow-md hover:scale-105'
-          }`}
-          onClick={() => {
-            if (location.pathname === "/upload") {
-              if (window.confirmNavigationIfNeeded) {
-                window.confirmNavigationIfNeeded('/help');
-                return;
-              }
-              if (!confirm("You have unsaved changes. Are you sure you want to leave?")) {
-                return;
+        <div className="flex items-center space-x-2">
+          <Button
+            name="help"
+            variant={location.pathname === '/help' ? "primary" : "tertiary"}
+            size={1}
+            className={`transition-all duration-200 ${
+              location.pathname === '/help'
+                ? 'shadow-lg shadow-ifrcRed/20 transform scale-105' 
+                : 'hover:bg-blue-50 hover:text-blue-600 hover:shadow-md hover:scale-105'
+            }`}
+            onClick={() => {
+              if (location.pathname === "/upload") {
+                if (window.confirmNavigationIfNeeded) {
+                  window.confirmNavigationIfNeeded('/help');
+                  return;
+                }
+                if (!confirm("You have unsaved changes. Are you sure you want to leave?")) {
+                  return;
+                }
               }
-            }
-            navigate('/help');
-          }}
-        >
-          <QuestionLineIcon className="w-4 h-4" />
-          <span className="inline ml-2 font-semibold">Help & Support</span>
-        </Button>
+              navigate('/help');
+            }}
+          >
+            <QuestionLineIcon className="w-4 h-4" />
+            <span className="inline ml-2 font-semibold">Help & Support</span>
+          </Button>
+
+          <div className="relative">
+            <Container withInternalPadding className="p-2">
+              <Button
+                name="dev"
+                variant={location.pathname === '/admin' ? "primary" : "tertiary"}
+                size={1}
+                className={`transition-all duration-200 ${
+                  location.pathname === '/admin'
+                    ? 'shadow-lg shadow-purple-500/20 transform scale-105'
+                    : 'hover:bg-purple-50 hover:text-purple-600 hover:shadow-md hover:scale-105'
+                }`}
+                onClick={() => {
+                  if (location.pathname === "/upload") {
+                    if (window.confirmNavigationIfNeeded) {
+                      window.confirmNavigationIfNeeded('/admin');
+                      return;
+                    }
+                    if (!confirm("You have unsaved changes. Are you sure you want to leave?")) {
+                      return;
+                    }
+                  }
+                  navigate('/admin');
+                }}
+              >
+                <SettingsIcon className="w-4 h-4" />
+                <span className="inline ml-2 font-semibold">Dev</span>
+              </Button>
+            </Container>
+            {location.pathname === '/admin' && (
+              <div className="absolute -bottom-2 left-1/2 transform -translate-x-1/2 w-8 h-1 bg-purple-500 rounded-full animate-pulse"></div>
+            )}
+          </div>
+        </div>
       </PageContainer>
     </nav>
   );

frontend/src/contexts/AdminContext.tsx

@@ -0,0 +1,110 @@
+import React, { createContext, useContext, useState, useEffect } from 'react';
+import type { ReactNode } from 'react';
+
+interface AdminContextType {
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  login: (password: string) => Promise<boolean>;
+  logout: () => void;
+  verifyToken: () => Promise<void>;
+}
+
+const AdminContext = createContext<AdminContextType | undefined>(undefined);
+
+export const useAdmin = () => {
+  const context = useContext(AdminContext);
+  if (context === undefined) {
+    throw new Error('useAdmin must be used within an AdminProvider');
+  }
+  return context;
+};
+
+interface AdminProviderProps {
+  children: ReactNode;
+}
+
+export const AdminProvider: React.FC<AdminProviderProps> = ({ children }) => {
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const verifyToken = async () => {
+    const adminToken = localStorage.getItem('adminToken');
+    if (!adminToken) {
+      setIsAuthenticated(false);
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const response = await fetch('/api/admin/verify', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${adminToken}`
+        }
+      });
+
+      if (response.ok) {
+        setIsAuthenticated(true);
+      } else {
+        // Token is invalid, remove it
+        localStorage.removeItem('adminToken');
+        setIsAuthenticated(false);
+      }
+    } catch (error) {
+      console.error('Error verifying admin token:', error);
+      localStorage.removeItem('adminToken');
+      setIsAuthenticated(false);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const login = async (password: string): Promise<boolean> => {
+    try {
+      const response = await fetch('/api/admin/login', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ password })
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        localStorage.setItem('adminToken', data.access_token);
+        setIsAuthenticated(true);
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      console.error('Login error:', error);
+      return false;
+    }
+  };
+
+  const logout = () => {
+    localStorage.removeItem('adminToken');
+    setIsAuthenticated(false);
+  };
+
+  // Check authentication status on mount
+  useEffect(() => {
+    verifyToken();
+  }, []);
+
+  const value: AdminContextType = {
+    isAuthenticated,
+    isLoading,
+    login,
+    logout,
+    verifyToken
+  };
+
+  return (
+    <AdminContext.Provider value={value}>
+      {children}
+    </AdminContext.Provider>
+  );
+};

frontend/src/pages/{DevPage.tsx → AdminPage/AdminPage.tsx}

@@ -1,11 +1,17 @@
-import { useState, useEffect } from 'react';
-import {
-  PageContainer, Heading, Button, Container,
-} from '@ifrc-go/ui';
+import React, { useState, useEffect } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useAdmin } from '../../contexts/AdminContext';
+import { PageContainer, Heading, Button, Container, TextInput } from '@ifrc-go/ui';
 
 const SELECTED_MODEL_KEY = 'selectedVlmModel';
 
-export default function DevPage() {
+export default function AdminPage() {
+  const navigate = useNavigate();
+  const { isAuthenticated, isLoading, login, logout } = useAdmin();
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+  const [isLoggingIn, setIsLoggingIn] = useState(false);
+  
   const [availableModels, setAvailableModels] = useState<Array<{
     m_code: string;
     label: string;
@@ -15,8 +21,10 @@ export default function DevPage() {
   const [selectedModel, setSelectedModel] = useState<string>('');
 
   useEffect(() => {
-    fetchModels();
-  }, []);
+    if (isAuthenticated) {
+      fetchModels();
+    }
+  }, [isAuthenticated]);
 
   const fetchModels = () => {
     fetch('/api/models')
@@ -26,7 +34,10 @@ export default function DevPage() {
         
         const persistedModel = localStorage.getItem(SELECTED_MODEL_KEY);
         if (modelsData.models && modelsData.models.length > 0) {
-          if (persistedModel && modelsData.models.find((m: { m_code: string; is_available: boolean }) => m.m_code === persistedModel && m.is_available)) {
+          if (persistedModel === 'random') {
+            // Keep random selection
+            setSelectedModel('random');
+          } else if (persistedModel && modelsData.models.find((m: { m_code: string; is_available: boolean }) => m.m_code === persistedModel && m.is_available)) {
             setSelectedModel(persistedModel);
           } else {
             const firstAvailableModel = modelsData.models.find((m: { is_available: boolean }) => m.is_available) || modelsData.models[0];
@@ -36,7 +47,7 @@ export default function DevPage() {
         }
       })
       .catch(() => {
-
+        // Handle error silently
       });
   };
 
@@ -71,13 +82,117 @@ export default function DevPage() {
 
   const handleModelChange = (modelCode: string) => {
     setSelectedModel(modelCode);
-    localStorage.setItem(SELECTED_MODEL_KEY, modelCode);
+    if (modelCode === 'random') {
+      // For random selection, we'll select a random available model when needed
+      localStorage.setItem(SELECTED_MODEL_KEY, 'random');
+    } else {
+      localStorage.setItem(SELECTED_MODEL_KEY, modelCode);
+    }
+  };
+
+  const handleLogin = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!password.trim()) {
+      setError('Please enter a password');
+      return;
+    }
+
+    setIsLoggingIn(true);
+    setError('');
+
+    try {
+      const success = await login(password);
+      if (!success) {
+        setError('Invalid password');
+      }
+    } catch (err) {
+      setError('Login failed. Please try again.');
+    } finally {
+      setIsLoggingIn(false);
+    }
+  };
+
+  const handleLogout = () => {
+    logout();
+    setPassword('');
+    setError('');
   };
 
+  if (isLoading) {
+    return (
+      <PageContainer>
+        <div className="flex items-center justify-center min-h-[400px]">
+          <div className="text-center">
+            <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-ifrcRed mx-auto mb-4"></div>
+            <p className="text-gray-600">Loading...</p>
+          </div>
+        </div>
+      </PageContainer>
+    );
+  }
+
+  if (!isAuthenticated) {
+    return (
+      <PageContainer>
+        <div className="mx-auto max-w-md px-4 sm:px-6 lg:px-8 py-6 sm:py-10">
+          <div className="text-center mb-8">
+            <Heading level={1}>Admin Login</Heading>
+          </div>
+
+          <form onSubmit={handleLogin} className="space-y-6">
+            <div>
+              <label htmlFor="password" className="block text-sm font-medium text-gray-700 mb-2">
+                Password
+              </label>
+              <TextInput
+                id="password"
+                name="password"
+                type="password"
+                value={password}
+                onChange={(value) => setPassword(value || '')}
+                placeholder="Enter admin password"
+                required
+                className="w-full"
+              />
+            </div>
+
+            {error && (
+              <div className="bg-ifrcRed/10 border border-ifrcRed/20 rounded-md p-3">
+                <p className="text-sm text-ifrcRed font-medium">{error}</p>
+              </div>
+            )}
+
+            <div className="flex justify-center">
+              <Container withInternalPadding className="p-2">
+                <Button
+                  name="login"
+                  type="submit"
+                  variant="primary"
+                  size={2}
+                  disabled={isLoggingIn}
+                >
+                  {isLoggingIn ? 'Logging in...' : 'Login'}
+                </Button>
+              </Container>
+            </div>
+          </form>
+        </div>
+      </PageContainer>
+    );
+  }
+
   return (
     <PageContainer>
       <div className="mx-auto max-w-screen-lg px-4 sm:px-6 lg:px-8 py-6 sm:py-10">
-        <Heading level={1}>Development & Testing</Heading>
+        <div className="flex justify-end mb-8">
+          <Button
+            name="logout"
+            variant="secondary"
+            onClick={handleLogout}
+          >
+            Logout
+          </Button>
+        </div>
         
         <div className="mt-8 space-y-8">
           {/* Model Selection Section */}
@@ -99,6 +214,7 @@ export default function DevPage() {
                   onChange={(e) => handleModelChange(e.target.value)}
                   className="border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-ifrcRed focus:border-transparent min-w-[200px]"
                 >
+                  <option value="random">Random</option>
                   {availableModels
                     .filter(model => model.is_available)
                     .map(model => (
@@ -109,12 +225,13 @@ export default function DevPage() {
                 </select>
                 {selectedModel && (
                   <span className="text-xs text-green-600 bg-green-50 px-2 py-1 rounded">
-                    ✓ Active for caption generation
+                    {selectedModel === 'random' 
+                      ? '✓ Random model selection active' 
+                      : '✓ Active for caption generation'
+                    }
                   </span>
                 )}
               </div>
-              
-
             </div>
           </Container>
 
@@ -146,16 +263,16 @@ export default function DevPage() {
                         <td className="px-4 py-2 text-sm font-mono">{model.m_code}</td>
                         <td className="px-4 py-2 text-sm">{model.label}</td>
                         <td className="px-4 py-2 text-sm">{model.model_type}</td>
-                                                 <td className="px-4 py-2 text-sm">
-                           <Button
-                             name={`toggle-${model.m_code}`}
-                             variant={model.is_available ? "primary" : "secondary"}
-                             size={1}
-                             onClick={() => toggleModelAvailability(model.m_code, model.is_available)}
-                           >
-                             {model.is_available ? 'Enabled' : 'Disabled'}
-                           </Button>
-                         </td>
+                        <td className="px-4 py-2 text-sm">
+                          <Button
+                            name={`toggle-${model.m_code}`}
+                            variant={model.is_available ? "primary" : "secondary"}
+                            size={1}
+                            onClick={() => toggleModelAvailability(model.m_code, model.is_available)}
+                          >
+                            {model.is_available ? 'Enabled' : 'Disabled'}
+                          </Button>
+                        </td>
                       </tr>
                     ))}
                   </tbody>
@@ -164,65 +281,125 @@ export default function DevPage() {
             </div>
           </Container>
 
-          {/* API Testing Section */}
-          <Container
-            heading="API Testing"
-            headingLevel={2}
-            withHeaderBorder
-            withInternalPadding
-          >
-            <div className="space-y-4">
-              <p className="text-gray-700">
-                Test API endpoints and model functionality.
-              </p>
-              
-              <div className="flex flex-wrap gap-4">
-                <Button
-                  name="test-models-api"
-                  variant="secondary"
-                  onClick={() => {
-                    fetch('/api/models')
-                      .then(r => r.json())
-                      .then(() => {
-                        alert('Models API response received successfully');
-                      })
-                      .catch(() => {
-                        alert('Models API error occurred');
-                      });
-                  }}
-                >
-                  Test Models API
-                </Button>
-                
-                <Button
-                  name="test-selected-model"
-                  variant="secondary"
-                  disabled={!selectedModel}
-                  onClick={() => {
-                    if (!selectedModel) return;
-                    fetch(`/api/models/${selectedModel}/test`)
-                      .then(r => r.json())
-                      .then(() => {
-                        alert('Model test completed successfully');
-                      })
-                      .catch(() => {
-                        alert('Model test failed');
-                      });
-                  }}
-                >
-                  Test Selected Model
-                </Button>
+                           {/* API Testing Section */}
+                 <Container
+                   heading="API Testing"
+                   headingLevel={2}
+                   withHeaderBorder
+                   withInternalPadding
+                 >
+                   <div className="space-y-4">
+                     <p className="text-gray-700">
+                       Test API endpoints and model functionality.
+                     </p>
+                     
+                     <div className="flex flex-wrap gap-4">
+                       <Button
+                         name="test-models-api"
+                         variant="secondary"
+                         onClick={() => {
+                           fetch('/api/models')
+                             .then(r => r.json())
+                             .then(() => {
+                               alert('Models API response received successfully');
+                             })
+                             .catch(() => {
+                               alert('Models API error occurred');
+                             });
+                         }}
+                       >
+                         Test Models API
+                       </Button>
+                       
+                       <Button
+                         name="test-selected-model"
+                         variant="secondary"
+                         disabled={!selectedModel}
+                         onClick={() => {
+                           if (!selectedModel) return;
+                           fetch(`/api/models/${selectedModel}/test`)
+                             .then(r => r.json())
+                             .then(() => {
+                               alert('Model test completed successfully');
+                             })
+                             .catch(() => {
+                               alert('Model test failed');
+                             });
+                         }}
+                       >
+                         Test Selected Model
+                       </Button>
+       
+                       <Button
+                         name="refresh-models"
+                         variant="secondary"
+                         onClick={fetchModels}
+                       >
+                         Refresh Models
+                       </Button>
+                     </div>
+                   </div>
+                 </Container>
 
-                <Button
-                  name="refresh-models"
-                  variant="secondary"
-                  onClick={fetchModels}
-                >
-                  Refresh Models
-                </Button>
-              </div>
-            </div>
-          </Container>
+                 {/* Schema Validation Section */}
+                 <Container
+                   heading="Schema Validation"
+                   headingLevel={2}
+                   withHeaderBorder
+                   withInternalPadding
+                 >
+                   <div className="space-y-4">
+                     <p className="text-gray-700">
+                       Monitor and test JSON schema validation for VLM responses.
+                     </p>
+                     
+                     <div className="flex flex-wrap gap-4">
+                       <Button
+                         name="view-schemas"
+                         variant="secondary"
+                         onClick={() => {
+                           fetch('/api/schemas', {
+                             headers: {
+                               'Authorization': `Bearer ${localStorage.getItem('adminToken')}`
+                             }
+                           })
+                             .then(r => r.json())
+                             .then(data => {
+                               console.log('Schemas:', data);
+                               alert(`Found ${data.length} schemas. Check console for details.`);
+                             })
+                             .catch(() => {
+                               alert('Failed to fetch schemas');
+                             });
+                         }}
+                       >
+                         View Schemas
+                       </Button>
+                       
+                       <Button
+                         name="validation-stats"
+                         variant="secondary"
+                         onClick={() => {
+                           fetch('/api/schemas/validation-stats', {
+                             headers: {
+                               'Authorization': `Bearer ${localStorage.getItem('adminToken')}`
+                             }
+                           })
+                             .then(r => r.json())
+                             .then(data => {
+                               console.log('Validation Stats:', data);
+                               alert(`Validation: ${data.validation_passed} passed, ${data.validation_failed} failed. Check console for details.`);
+                             })
+                             .catch(() => {
+                               alert('Failed to fetch validation stats');
+                             });
+                         }}
+                       >
+                         Validation Stats
+                       </Button>
+                     </div>
+                   </div>
+                 </Container>
         </div>
       </div>
     </PageContainer>

frontend/src/pages/UploadPage/UploadPage.tsx

@@ -342,7 +342,7 @@ export default function UploadPage() {
 
     const modelName = localStorage.getItem(SELECTED_MODEL_KEY);
     if (modelName) {
-    fd.append('model_name', modelName);
+      fd.append('model_name', modelName);
     }
 
     try {
@@ -365,7 +365,7 @@ export default function UploadPage() {
           body: new URLSearchParams({
             title: title || 'Generated Caption',
             prompt: imageType === 'drone_image' ? 'DEFAULT_DRONE_IMAGE' : 'DEFAULT_CRISIS_MAP',
-            ...(modelName      && { model_name: modelName })
+            ...(modelName && { model_name: modelName })
           })
         },
       );
@@ -449,11 +449,11 @@ export default function UploadPage() {
       const capRes = await fetch(`/api/images/${newId}/caption`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-          title: 'Generated Caption',
-          prompt: imageType === 'drone_image' ? 'DEFAULT_DRONE_IMAGE' : 'DEFAULT_CRISIS_MAP',
-          ...(modelName && { model_name: modelName }),
-        }),
+                  body: new URLSearchParams({
+            title: 'Generated Caption',
+            prompt: imageType === 'drone_image' ? 'DEFAULT_DRONE_IMAGE' : 'DEFAULT_CRISIS_MAP',
+            ...(modelName && { model_name: modelName }),
+          }),
       });
       const capJson = await readJsonSafely(capRes);
       if (!capRes.ok) throw new Error((capJson.error as string) || 'Caption failed');

py_backend/ADMIN_SETUP.md

@@ -0,0 +1,108 @@
+# Admin Authentication Setup
+
+This document explains how to set up admin authentication for the PromptAid Vision application.
+
+## Environment Variables
+
+Add these environment variables to your `.env` file or Hugging Face Space secrets:
+
+### Required Variables
+
+```bash
+# Admin password for authentication
+ADMIN_PASSWORD=your-secure-admin-password-here
+
+# JWT secret key for token signing (use a strong, random key)
+JWT_SECRET_KEY=your-secure-jwt-secret-key-here
+```
+
+### Optional Variables
+
+```bash
+# Database connection
+DATABASE_URL=postgresql://username:password@localhost:5432/database_name
+
+# Storage configuration
+STORAGE_PROVIDER=local
+STORAGE_DIR=./uploads
+```
+
+## How It Works
+
+### 1. Admin Login
+- Users click "Admin Login" in the header navigation
+- They enter the admin password
+- If correct, they receive a JWT token valid for 24 hours
+
+### 2. Authentication Flow
+- Frontend stores the JWT token in localStorage
+- Token is sent with each admin API request in Authorization header
+- Backend verifies token validity and role
+
+### 3. Security Features
+- JWT tokens expire after 24 hours
+- Tokens are verified on each admin request
+- Password is stored in environment variables (not in code)
+
+## API Endpoints
+
+### POST `/api/admin/login`
+- **Purpose**: Authenticate admin user
+- **Body**: `{"password": "admin_password"}`
+- **Response**: `{"token": "jwt_token", "expires_at": "timestamp"}`
+
+### POST `/api/admin/verify`
+- **Purpose**: Verify admin token
+- **Headers**: `Authorization: Bearer <token>`
+- **Response**: `{"valid": true/false, "message": "..."}`
+
+### GET `/api/admin/status`
+- **Purpose**: Get admin status (protected endpoint)
+- **Headers**: `Authorization: Bearer <token>`
+- **Response**: `{"status": "authenticated", "role": "admin", "timestamp": "..."}`
+
+## Development vs Production
+
+### Development
+- Default password: `admin123`
+- Default JWT secret: `your-secret-key-change-in-production`
+- **⚠️ Change these in production!**
+
+### Production
+- Use strong, random passwords
+- Use secure JWT secret keys
+- Store secrets in environment variables or Hugging Face Space secrets
+- Consider implementing password hashing for additional security
+
+## Future Enhancements
+
+- User-specific accounts and permissions
+- Role-based access control
+- Password hashing with bcrypt
+- Session management
+- Audit logging
+- Two-factor authentication
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Invalid admin password"**
+   - Check that `ADMIN_PASSWORD` environment variable is set correctly
+   - Ensure no extra spaces or characters
+
+2. **"Token is invalid or expired"**
+   - Token may have expired (24-hour limit)
+   - Try logging in again
+   - Check `JWT_SECRET_KEY` is consistent
+
+3. **"Method Not Allowed"**
+   - Ensure admin router is properly included in main.py
+   - Check API endpoint URLs are correct
+
+### Debug Steps
+
+1. Verify environment variables are loaded
+2. Check backend logs for authentication errors
+3. Verify JWT token format in browser localStorage
+4. Test API endpoints directly with tools like curl or Postman

py_backend/alembic/versions/{0002_drone_pose_fields_and_schema.py → 0002_drone_fields.py}

@@ -10,7 +10,7 @@ import json
 
 # Alembic identifiers
 revision = "0002_drone_fields"
-down_revision = "0001_initial_schema_and_seed"
+down_revision = "b8fc40bfe3c7"
 branch_labels = None
 depends_on = None
 

py_backend/alembic/versions/0003_fix_json_schemas.py

@@ -0,0 +1,175 @@
+"""Fix JSON schemas to match validation requirements
+
+Revision ID: 0003_fix_json_schemas
+Revises: 0002_drone_pose_fields_and_schema
+Create Date: 2025-01-20 10:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import json
+
+# revision identifiers, used by Alembic.
+revision = '0003_fix_json_schemas'
+down_revision = '0002_drone_fields'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    """Fix the JSON schemas to match validation requirements"""
+    
+    # Fix the default crisis map schema
+    crisis_schema = {
+        "type": "object",
+        "properties": {
+            "analysis": {"type": "string"},
+            "metadata": {
+                "type": "object",
+                "properties": {
+                    "title": {"type": "string"},
+                    "source": {"type": "string"},
+                    "type": {"type": "string"},
+                    "countries": {"type": "array", "items": {"type": "string"}},
+                    "epsg": {"type": "string"}
+                },
+                "required": ["title", "source", "type", "countries", "epsg"]
+            }
+        },
+        "required": ["analysis", "metadata"]
+    }
+    
+    op.execute(
+        sa.text(
+            """
+            UPDATE json_schemas 
+            SET schema = CAST(:schema AS JSONB)
+            WHERE schema_id = '[email protected]'
+            """
+        ).bindparams(
+            schema=json.dumps(crisis_schema, separators=(",", ":"))
+        )
+    )
+    
+    # Fix the drone schema (the current one is mostly correct, but let's ensure it's perfect)
+    drone_schema = {
+        "type": "object",
+        "properties": {
+            "analysis": {"type": "string"},
+            "metadata": {
+                "type": "object",
+                "properties": {
+                    "title": {"type": ["string", "null"]},
+                    "source": {"type": ["string", "null"]},
+                    "type": {"type": ["string", "null"]},
+                    "countries": {"type": ["array", "null"], "items": {"type": "string"}},
+                    "epsg": {"type": ["string", "null"]},
+                    "center_lat": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                    "center_lon": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "amsl_m": {"type": ["number", "null"]},
+                    "agl_m": {"type": ["number", "null"]},
+                    "heading_deg": {"type": ["number", "null"], "minimum": 0, "maximum": 360},
+                    "yaw_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "pitch_deg": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                    "roll_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "rtk_fix": {"type": ["boolean", "null"]},
+                    "std_h_m": {"type": ["number", "null"], "minimum": 0},
+                    "std_v_m": {"type": ["number", "null"], "minimum": 0}
+                }
+            }
+        },
+        "required": ["analysis", "metadata"]
+    }
+    
+    op.execute(
+        sa.text(
+            """
+            UPDATE json_schemas 
+            SET schema = CAST(:schema AS JSONB)
+            WHERE schema_id = '[email protected]'
+            """
+        ).bindparams(
+            schema=json.dumps(drone_schema, separators=(",", ":"))
+        )
+    )
+    
+    print("✓ Updated JSON schemas to match validation requirements")
+
+
+def downgrade():
+    """Revert to previous schema versions"""
+    
+    # Revert crisis map schema to original
+    original_crisis_schema = {
+        "type": "object",
+        "properties": {
+            "analysis": {"type": "string"},
+            "metadata": {
+                "type": "object",
+                "properties": {
+                    "title": {"type": "string"},
+                    "source": {"type": "string"},
+                    "type": {"type": "string"},
+                    "countries": {"type": "array", "items": {"type": "string"}},
+                    "epsg": {"type": "string"}
+                }
+            }
+        },
+        "required": ["analysis", "metadata"]
+    }
+    
+    op.execute(
+        sa.text(
+            """
+            UPDATE json_schemas 
+            SET schema = CAST(:schema AS JSONB)
+            WHERE schema_id = '[email protected]'
+            """
+        ).bindparams(
+            schema=json.dumps(original_crisis_schema, separators=(",", ":"))
+        )
+    )
+    
+    # Revert drone schema to original
+    original_drone_schema = {
+        "type": "object",
+        "properties": {
+            "analysis": {"type": "string"},
+            "metadata": {
+                "type": "object",
+                "properties": {
+                    "title": {"type": ["string", "null"]},
+                    "source": {"type": ["string", "null"]},
+                    "type": {"type": ["string", "null"]},
+                    "countries": {"type": ["array", "null"], "items": {"type": "string"}},
+                    "epsg": {"type": ["string", "null"]},
+                    "center_lat": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                    "center_lon": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "amsl_m": {"type": ["number", "null"]},
+                    "agl_m": {"type": ["number", "null"]},
+                    "heading_deg": {"type": ["number", "null"], "minimum": 0, "maximum": 360},
+                    "yaw_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "pitch_deg": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                    "roll_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                    "rtk_fix": {"type": ["boolean", "null"]},
+                    "std_h_m": {"type": ["number", "null"], "minimum": 0},
+                    "std_v_m": {"type": ["number", "null"], "minimum": 0}
+                }
+            }
+        },
+        "required": ["analysis", "metadata"]
+    }
+    
+    op.execute(
+        sa.text(
+            """
+            UPDATE json_schemas 
+            SET schema = CAST(:schema AS JSONB)
+            WHERE schema_id = '[email protected]'
+            """
+        ).bindparams(
+            schema=json.dumps(original_drone_schema, separators=(",", ":"))
+        )
+    )
+    
+    print("✓ Reverted JSON schemas to previous versions")

py_backend/alembic/versions/b8fc40bfe3c7_initial_schema_seed.py

@@ -9,7 +9,7 @@ import sqlalchemy as sa
 from sqlalchemy.dialects import postgresql
 import pycountry
 
-revision = '0001_initial_schema_and_seed'
+revision = 'b8fc40bfe3c7'
 down_revision = None
 branch_labels = None
 depends_on = None

py_backend/app/crud.py

@@ -211,3 +211,15 @@ def get_models(db: Session):
 def get_model(db: Session, m_code: str):
     """Get a specific model by code"""
     return db.get(models.Models, m_code)
+
+def get_all_schemas(db: Session):
+    """Get all JSON schemas"""
+    return db.query(models.JSONSchema).all()
+
+def get_schema(db: Session, schema_id: str):
+    """Get a specific JSON schema by ID"""
+    return db.query(models.JSONSchema).filter(models.JSONSchema.schema_id == schema_id).first()
+
+def get_recent_images_with_validation(db: Session, limit: int = 100):
+    """Get recent images with validation info"""
+    return db.query(models.Images).order_by(models.Images.created_at.desc()).limit(limit).all()

py_backend/app/main.py

@@ -7,10 +7,15 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, JSONResponse, HTMLResponse
 
+from dotenv import load_dotenv
+load_dotenv()
+
 from app.config import settings
 from app.routers import upload, caption, metadata, models
 from app.routers.images import router as images_router
 from app.routers.prompts import router as prompts_router
+from app.routers.admin import router as admin_router
+from app.routers.schemas import router as schemas_router
 
 app = FastAPI(title="PromptAid Vision")
 
@@ -29,6 +34,8 @@ app.include_router(models.router,      prefix="/api",            tags=["models"]
 app.include_router(upload.router,      prefix="/api/images",     tags=["images"])
 app.include_router(images_router,      prefix="/api/contribute", tags=["contribute"])
 app.include_router(prompts_router,     prefix="/api/prompts",    tags=["prompts"])
+app.include_router(admin_router,       prefix="/api/admin",      tags=["admin"])
+app.include_router(schemas_router,     prefix="/api",            tags=["schemas"])
 
 @app.get("/health", include_in_schema=False, response_class=JSONResponse)
 async def health():

py_backend/app/routers/admin.py

@@ -0,0 +1,132 @@
+import os
+import jwt
+import hashlib
+from datetime import datetime, timedelta
+from fastapi import APIRouter, HTTPException, Depends, Header
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from ..database import SessionLocal
+from ..config import settings
+
+router = APIRouter()
+security = HTTPBearer()
+
+# Models
+class AdminLoginRequest(BaseModel):
+    password: str
+
+class AdminLoginResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    expires_at: str
+
+class AdminVerifyResponse(BaseModel):
+    valid: bool
+    message: str
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def get_admin_password():
+    """Get admin password from environment variable"""
+    password = os.getenv('ADMIN_PASSWORD')
+    if not password:
+        raise HTTPException(
+            status_code=500,
+            detail="ADMIN_PASSWORD environment variable not set"
+        )
+    return password
+
+def create_admin_token():
+    """Create a JWT token for admin authentication"""
+    # In production, use a proper secret key
+    secret_key = os.getenv('JWT_SECRET_KEY', 'your-secret-key-change-in-production')
+    
+    payload = {
+        'role': 'admin',
+        'exp': datetime.utcnow() + timedelta(hours=24),  # 24 hour expiry
+        'iat': datetime.utcnow()
+    }
+    
+    token = jwt.encode(payload, secret_key, algorithm='HS256')
+    return token
+
+def verify_admin_token(token: str):
+    """Verify the admin JWT token"""
+    try:
+        secret_key = os.getenv('JWT_SECRET_KEY', 'your-secret-key-change-in-production')
+        payload = jwt.decode(token, secret_key, algorithms=['HS256'])
+        
+        if payload.get('role') != 'admin':
+            return False
+        
+        # Check if token is expired
+        exp = payload.get('exp')
+        if exp and datetime.utcnow() > datetime.fromtimestamp(exp):
+            return False
+            
+        return True
+    except jwt.ExpiredSignatureError:
+        return False
+    except jwt.InvalidTokenError:
+        return False
+
+@router.post("/login", response_model=AdminLoginResponse)
+async def admin_login(request: AdminLoginRequest):
+    """Admin login endpoint"""
+    admin_password = get_admin_password()
+    
+    # Hash the provided password and compare with stored hash
+    # For now, using simple comparison (in production, use proper hashing)
+    if request.password == admin_password:
+        token = create_admin_token()
+        expires_at = datetime.utcnow() + timedelta(hours=24)
+        
+        return AdminLoginResponse(
+            access_token=token,
+            expires_at=expires_at.isoformat()
+        )
+    else:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid admin password"
+        )
+
+@router.post("/verify", response_model=AdminVerifyResponse)
+async def verify_admin(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify admin token endpoint"""
+    token = credentials.credentials
+    
+    if verify_admin_token(token):
+        return AdminVerifyResponse(
+            valid=True,
+            message="Token is valid"
+        )
+    else:
+        return AdminVerifyResponse(
+            valid=False,
+            message="Token is invalid or expired"
+        )
+
+@router.get("/status")
+async def admin_status(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Get admin status (protected endpoint)"""
+    token = credentials.credentials
+    
+    if not verify_admin_token(token):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid or expired token"
+        )
+    
+    return {
+        "status": "authenticated",
+        "role": "admin",
+        "timestamp": datetime.utcnow().isoformat()
+    }

py_backend/app/routers/caption.py

@@ -3,6 +3,7 @@ from sqlalchemy.orm import Session
 from typing import List
 from .. import crud, database, schemas, storage
 from ..services.vlm_service import vlm_manager
+from ..services.schema_validator import schema_validator
 from ..config import settings
 
 from ..services.stub_vlm_service import StubVLMService
@@ -132,11 +133,34 @@ async def create_caption(
             prompt=prompt_text,
             metadata_instructions=metadata_instructions,
             model_name=model_name,
+            db_session=db,
         )
-        text = result.get("caption", "")
-        used_model = model_name or "STUB_MODEL"
+        
+        # Get the raw response for validation
         raw = result.get("raw_response", {})
-        metadata = result.get("metadata", {})
+        
+        # Validate and clean the data using schema validation
+        image_type = img.image_type
+        print(f"DEBUG: Validating data for image type: {image_type}")
+        print(f"DEBUG: Raw data structure: {list(raw.keys()) if isinstance(raw, dict) else 'Not a dict'}")
+        
+        cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
+        
+        if is_valid:
+            print(f"✓ Schema validation passed for {image_type}")
+            text = cleaned_data.get("analysis", "")
+            metadata = cleaned_data.get("metadata", {})
+        else:
+            print(f"⚠ Schema validation failed for {image_type}: {validation_error}")
+            # Use fallback but log the validation error
+            text = result.get("caption", "This is a fallback caption due to schema validation error.")
+            metadata = result.get("metadata", {})
+            raw["validation_error"] = validation_error
+            raw["validation_failed"] = True
+        
+        # Use the actual model that was used, not the requested model_name
+        used_model = result.get("model", model_name) or "STUB_MODEL"
+        
     except Exception as e:
         print(f"VLM error, using fallback: {e}")
         text = "This is a fallback caption due to VLM service error."

py_backend/app/routers/models.py

@@ -29,7 +29,17 @@ def get_available_models(db: Session = Depends(get_db)):
                 "config": model.config
             })
         
-        return {"models": models_info}
+        # Add debug info about registered services
+        registered_services = list(vlm_manager.services.keys())
+        
+        return {
+            "models": models_info,
+            "debug": {
+                "registered_services": registered_services,
+                "total_services": len(registered_services),
+                "available_db_models": [m.m_code for m in db_models if m.is_available]
+            }
+        }
     except Exception as e:
         raise HTTPException(500, f"Failed to get models: {str(e)}")
 

py_backend/app/routers/schemas.py

@@ -0,0 +1,179 @@
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+from typing import List, Dict, Any
+from .. import crud, database, schemas
+from ..services.schema_validator import schema_validator
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from ..routers.admin import verify_admin_token
+
+router = APIRouter()
+security = HTTPBearer()
+
+def get_db():
+    db = database.SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def verify_admin_access(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify admin token for schema endpoints"""
+    token = credentials.credentials
+    
+    if not verify_admin_token(token):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid or expired admin token"
+        )
+    
+    return token
+
+@router.get("/schemas", response_model=List[Dict[str, Any]])
+async def get_schemas(
+    db: Session = Depends(get_db),
+    token: str = Depends(verify_admin_access)
+):
+    """Get all JSON schemas (admin only)"""
+    try:
+        # Get schemas from database
+        db_schemas = crud.get_all_schemas(db)
+        
+        schemas_list = []
+        for schema in db_schemas:
+            schemas_list.append({
+                "schema_id": schema.schema_id,
+                "title": schema.title,
+                "version": schema.version,
+                "created_at": schema.created_at.isoformat() if schema.created_at else None,
+                "schema": schema.schema
+            })
+        
+        return schemas_list
+    except Exception as e:
+        raise HTTPException(500, f"Failed to get schemas: {str(e)}")
+
+@router.get("/schemas/{schema_id}", response_model=Dict[str, Any])
+async def get_schema(
+    schema_id: str,
+    db: Session = Depends(get_db),
+    token: str = Depends(verify_admin_access)
+):
+    """Get a specific JSON schema (admin only)"""
+    try:
+        schema = crud.get_schema(db, schema_id)
+        if not schema:
+            raise HTTPException(404, f"Schema {schema_id} not found")
+        
+        return {
+            "schema_id": schema.schema_id,
+            "title": schema.title,
+            "version": schema.version,
+            "created_at": schema.created_at.isoformat() if schema.created_at else None,
+            "schema": schema.schema
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Failed to get schema: {str(e)}")
+
+@router.post("/schemas/validate")
+async def validate_data_against_schema(
+    data: Dict[str, Any],
+    schema_id: str,
+    db: Session = Depends(get_db),
+    token: str = Depends(verify_admin_access)
+):
+    """Validate JSON data against a specific schema (admin only)"""
+    try:
+        # Get the schema from database
+        schema = crud.get_schema(db, schema_id)
+        if not schema:
+            raise HTTPException(404, f"Schema {schema_id} not found")
+        
+        # Validate the data
+        is_valid, error_msg = schema_validator.validate_against_schema(
+            data, schema.schema, schema_id
+        )
+        
+        return {
+            "is_valid": is_valid,
+            "error_message": error_msg,
+            "schema_id": schema_id,
+            "data": data
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Validation failed: {str(e)}")
+
+@router.post("/schemas/test-validation")
+async def test_schema_validation(
+    image_type: str,
+    data: Dict[str, Any],
+    token: str = Depends(verify_admin_access)
+):
+    """Test data validation against image type schemas (admin only)"""
+    try:
+        # Validate data against the appropriate schema for the image type
+        cleaned_data, is_valid, error_msg = schema_validator.clean_and_validate_data(
+            data, image_type
+        )
+        
+        return {
+            "is_valid": is_valid,
+            "error_message": error_msg,
+            "image_type": image_type,
+            "original_data": data,
+            "cleaned_data": cleaned_data if is_valid else None
+        }
+    except Exception as e:
+        raise HTTPException(500, f"Test validation failed: {str(e)}")
+
+@router.get("/schemas/validation-stats")
+async def get_validation_stats(
+    db: Session = Depends(get_db),
+    token: str = Depends(verify_admin_access)
+):
+    """Get validation statistics (admin only)"""
+    try:
+        # Get recent images with validation info
+        recent_images = crud.get_recent_images_with_validation(db, limit=100)
+        
+        stats = {
+            "total_images": len(recent_images),
+            "validation_passed": 0,
+            "validation_failed": 0,
+            "validation_errors": [],
+            "by_image_type": {
+                "crisis_map": {"total": 0, "passed": 0, "failed": 0},
+                "drone_image": {"total": 0, "passed": 0, "failed": 0}
+            }
+        }
+        
+        for img in recent_images:
+            if hasattr(img, 'raw_json') and img.raw_json:
+                image_type = img.image_type
+                if image_type in stats["by_image_type"]:
+                    stats["by_image_type"][image_type]["total"] += 1
+                
+                # Check if validation failed
+                if img.raw_json.get("validation_failed"):
+                    stats["validation_failed"] += 1
+                    if image_type in stats["by_image_type"]:
+                        stats["by_image_type"][image_type]["failed"] += 1
+                    
+                    error = img.raw_json.get("validation_error", "Unknown error")
+                    stats["validation_errors"].append({
+                        "image_id": str(img.image_id),
+                        "image_type": image_type,
+                        "error": error,
+                        "created_at": img.created_at.isoformat() if img.created_at else None
+                    })
+                else:
+                    stats["validation_passed"] += 1
+                    if image_type in stats["by_image_type"]:
+                        stats["by_image_type"][image_type]["passed"] += 1
+        
+        return stats
+    except Exception as e:
+        raise HTTPException(500, f"Failed to get validation stats: {str(e)}")

py_backend/app/services/huggingface_service.py

@@ -152,6 +152,6 @@ class InstructBLIPService(HuggingFaceService):
     """InstructBLIP model service using Hugging Face"""
     
     def __init__(self, api_key: str):
-        super().__init__(api_key, "microsoft/git-base")
+        super().__init__(api_key, "Salesforce/instructblip-vicuna-7b")
         self.model_name = "INSTRUCTBLIP_VICUNA_7B"
         self.model_type = ModelType.CUSTOM 

py_backend/app/services/schema_validator.py

@@ -0,0 +1,217 @@
+import json
+from typing import Dict, Any, Optional, Tuple
+from jsonschema import validate, ValidationError
+from jsonschema.validators import Draft7Validator
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SchemaValidator:
+    """Service for validating JSON data against stored schemas"""
+    
+    def __init__(self):
+        self.validators = {}
+    
+    def validate_against_schema(self, data: Dict[str, Any], schema: Dict[str, Any], schema_id: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validate JSON data against a schema
+        
+        Args:
+            data: The JSON data to validate
+            schema: The JSON schema to validate against
+            schema_id: Identifier for the schema (for logging)
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            # Use Draft7Validator for better error messages
+            validator = Draft7Validator(schema)
+            errors = list(validator.iter_errors(data))
+            
+            if errors:
+                error_messages = []
+                for error in errors:
+                    path = " -> ".join(str(p) for p in error.path) if error.path else "root"
+                    error_messages.append(f"{path}: {error.message}")
+                
+                error_msg = f"Schema validation failed for {schema_id}: {'; '.join(error_messages)}"
+                logger.warning(error_msg)
+                return False, error_msg
+            
+            logger.info(f"Schema validation passed for {schema_id}")
+            return True, None
+            
+        except Exception as e:
+            error_msg = f"Schema validation error for {schema_id}: {str(e)}"
+            logger.error(error_msg)
+            return False, error_msg
+    
+    def validate_crisis_map_data(self, data: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+        """
+        Validate crisis map data against the default schema
+        """
+        # Define the expected crisis map schema
+        crisis_schema = {
+            "type": "object",
+            "properties": {
+                "analysis": {"type": "string"},
+                "metadata": {
+                    "type": "object",
+                    "properties": {
+                        "title": {"type": "string"},
+                        "source": {"type": "string"},
+                        "type": {"type": "string"},
+                        "countries": {"type": "array", "items": {"type": "string"}},
+                        "epsg": {"type": "string"}
+                    },
+                    "required": ["title", "source", "type", "countries", "epsg"]
+                }
+            },
+            "required": ["analysis", "metadata"]
+        }
+        
+        return self.validate_against_schema(data, crisis_schema, "crisis_map")
+    
+    def validate_drone_data(self, data: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+        """
+        Validate drone data against the drone schema
+        """
+        # Define the expected drone schema
+        drone_schema = {
+            "type": "object",
+            "properties": {
+                "analysis": {"type": "string"},
+                "metadata": {
+                    "type": "object",
+                    "properties": {
+                        "title": {"type": ["string", "null"]},
+                        "source": {"type": ["string", "null"]},
+                        "type": {"type": ["string", "null"]},
+                        "countries": {"type": ["array", "null"], "items": {"type": "string"}},
+                        "epsg": {"type": ["string", "null"]},
+                        "center_lat": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                        "center_lon": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                        "amsl_m": {"type": ["number", "null"]},
+                        "agl_m": {"type": ["number", "null"]},
+                        "heading_deg": {"type": ["number", "null"], "minimum": 0, "maximum": 360},
+                        "yaw_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                        "pitch_deg": {"type": ["number", "null"], "minimum": -90, "maximum": 90},
+                        "roll_deg": {"type": ["number", "null"], "minimum": -180, "maximum": 180},
+                        "rtk_fix": {"type": ["boolean", "null"]},
+                        "std_h_m": {"type": ["number", "null"], "minimum": 0},
+                        "std_v_m": {"type": ["number", "null"], "minimum": 0}
+                    }
+                }
+            },
+            "required": ["analysis", "metadata"]
+        }
+        
+        return self.validate_against_schema(data, drone_schema, "drone")
+    
+    def validate_data_by_type(self, data: Dict[str, Any], image_type: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validate data based on image type
+        
+        Args:
+            data: The JSON data to validate
+            image_type: Either 'crisis_map' or 'drone_image'
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if image_type == 'drone_image':
+            return self.validate_drone_data(data)
+        elif image_type == 'crisis_map':
+            return self.validate_crisis_map_data(data)
+        else:
+            return False, f"Unknown image type: {image_type}"
+    
+    def clean_and_validate_data(self, raw_data: Dict[str, Any], image_type: str) -> Tuple[Dict[str, Any], bool, Optional[str]]:
+        """
+        Clean and validate data, returning cleaned data, validation status, and any errors
+        
+        Args:
+            raw_data: Raw data from VLM
+            image_type: Type of image being processed
+            
+        Returns:
+            Tuple of (cleaned_data, is_valid, error_message)
+        """
+        try:
+            # Extract the main content (handle different VLM response formats)
+            if "content" in raw_data:
+                # Some VLM models wrap content in a "content" field
+                content = raw_data["content"]
+                if isinstance(content, str):
+                    # Try to parse JSON from string content
+                    try:
+                        parsed_content = json.loads(content)
+                        data = parsed_content
+                    except json.JSONDecodeError:
+                        # If it's not JSON, treat as analysis
+                        data = {"analysis": content, "metadata": {}}
+                else:
+                    data = content
+            else:
+                data = raw_data
+            
+            # Validate the data
+            is_valid, error_msg = self.validate_data_by_type(data, image_type)
+            
+            if is_valid:
+                # Clean the data (remove any extra fields, normalize)
+                cleaned_data = self._clean_data(data, image_type)
+                return cleaned_data, True, None
+            else:
+                return data, False, error_msg
+                
+        except Exception as e:
+            error_msg = f"Data processing error: {str(e)}"
+            logger.error(error_msg)
+            return raw_data, False, error_msg
+    
+    def _clean_data(self, data: Dict[str, Any], image_type: str) -> Dict[str, Any]:
+        """
+        Clean and normalize the data structure
+        """
+        cleaned = {
+            "analysis": data.get("analysis", ""),
+            "metadata": {}
+        }
+        
+        metadata = data.get("metadata", {})
+        
+        # Clean metadata based on image type
+        if image_type == 'crisis_map':
+            cleaned["metadata"] = {
+                "title": metadata.get("title", ""),
+                "source": metadata.get("source", "OTHER"),
+                "type": metadata.get("type", "OTHER"),
+                "countries": metadata.get("countries", []),
+                "epsg": metadata.get("epsg", "OTHER")
+            }
+        elif image_type == 'drone_image':
+            cleaned["metadata"] = {
+                "title": metadata.get("title"),
+                "source": metadata.get("source"),
+                "type": metadata.get("type"),
+                "countries": metadata.get("countries"),
+                "epsg": metadata.get("epsg"),
+                "center_lat": metadata.get("center_lat"),
+                "center_lon": metadata.get("center_lon"),
+                "amsl_m": metadata.get("amsl_m"),
+                "agl_m": metadata.get("agl_m"),
+                "heading_deg": metadata.get("heading_deg"),
+                "yaw_deg": metadata.get("yaw_deg"),
+                "pitch_deg": metadata.get("pitch_deg"),
+                "roll_deg": metadata.get("roll_deg"),
+                "rtk_fix": metadata.get("rtk_fix"),
+                "std_h_m": metadata.get("std_h_m"),
+                "std_v_m": metadata.get("std_v_m")
+            }
+        
+        return cleaned
+
+# Global instance
+schema_validator = SchemaValidator()

py_backend/app/services/vlm_service.py

@@ -62,18 +62,65 @@ class VLMServiceManager:
         """Get list of available model names"""
         return list(self.services.keys())
     
-    async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "", model_name: str | None = None) -> dict:
+    async def generate_caption(self, image_bytes: bytes, prompt: str, metadata_instructions: str = "", model_name: str | None = None, db_session = None) -> dict:
         """Generate caption using the specified model or fallback to available service."""
         
         service = None
-        if model_name:
+        if model_name and model_name != "random":
             service = self.services.get(model_name)
             if not service:
                 print(f"Model '{model_name}' not found, using fallback")
         
         if not service and self.services:
-            service = next(iter(self.services.values()))
-            print(f"Using fallback service: {service.model_name}")
+            # If random is selected or no specific model, choose a random available service
+            if db_session:
+                # Check database availability for random selection
+                try:
+                    from .. import crud
+                    available_models = crud.get_models(db_session)
+                    available_model_codes = [m.m_code for m in available_models if m.is_available]
+                    
+                    print(f"DEBUG: Available models in database: {available_model_codes}")
+                    print(f"DEBUG: Registered services: {list(self.services.keys())}")
+                    
+                    # Filter services to only those marked as available in database
+                    available_services = [s for s in self.services.values() if s.model_name in available_model_codes]
+                    
+                    print(f"DEBUG: Available services after filtering: {[s.model_name for s in available_services]}")
+                    
+                    if available_services:
+                        import random
+                        import time
+                        # Use current time as seed for better randomness
+                        random.seed(int(time.time() * 1000000) % 1000000)
+                        
+                        # Shuffle the list first for better randomization
+                        shuffled_services = available_services.copy()
+                        random.shuffle(shuffled_services)
+                        
+                        service = shuffled_services[0]
+                        print(f"Randomly selected service: {service.model_name} (from {len(available_services)} available)")
+                        print(f"DEBUG: All available services were: {[s.model_name for s in available_services]}")
+                        print(f"DEBUG: Shuffled order: {[s.model_name for s in shuffled_services]}")
+                    else:
+                        # Fallback to any service
+                        service = next(iter(self.services.values()))
+                        print(f"Using fallback service: {service.model_name}")
+                except Exception as e:
+                    print(f"Error checking database availability: {e}, using fallback")
+                    service = next(iter(self.services.values()))
+                    print(f"Using fallback service: {service.model_name}")
+            else:
+                # No database session, use service property
+                available_services = [s for s in self.services.values() if s.is_available]
+                if available_services:
+                    import random
+                    service = random.choice(available_services)
+                    print(f"Randomly selected service: {service.model_name}")
+                else:
+                    # Fallback to any service
+                    service = next(iter(self.services.values()))
+                    print(f"Using fallback service: {service.model_name}")
         
         if not service:
             raise ValueError("No VLM services available")

py_backend/browser_test.js

@@ -0,0 +1,58 @@
+// Test schema endpoints in browser console
+// Copy and paste this into your browser's developer console
+
+async function testSchemaEndpoints() {
+    console.log("🧪 Testing Schema Endpoints...");
+    
+    // Get the admin token from localStorage
+    const token = localStorage.getItem('adminToken');
+    
+    if (!token) {
+        console.log("❌ No admin token found. Please login first.");
+        return;
+    }
+    
+    console.log("✅ Admin token found:", token.substring(0, 20) + "...");
+    
+    const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json'
+    };
+    
+    try {
+        // Test get schemas
+        console.log("\n1. Testing GET /api/schemas...");
+        const schemasResponse = await fetch('/api/schemas', { headers });
+        console.log("Response status:", schemasResponse.status);
+        
+        if (schemasResponse.ok) {
+            const schemas = await schemasResponse.json();
+            console.log("✅ Schemas found:", schemas.length);
+            schemas.forEach(schema => {
+                console.log(`   - ${schema.schema_id}: ${schema.title}`);
+            });
+        } else {
+            const errorText = await schemasResponse.text();
+            console.log("❌ Error:", errorText);
+        }
+        
+        // Test validation stats
+        console.log("\n2. Testing GET /api/schemas/validation-stats...");
+        const statsResponse = await fetch('/api/schemas/validation-stats', { headers });
+        console.log("Response status:", statsResponse.status);
+        
+        if (statsResponse.ok) {
+            const stats = await statsResponse.json();
+            console.log("✅ Validation stats:", stats);
+        } else {
+            const errorText = await statsResponse.text();
+            console.log("❌ Error:", errorText);
+        }
+        
+    } catch (error) {
+        console.log("❌ Network error:", error);
+    }
+}
+
+// Run the test
+testSchemaEndpoints();

py_backend/requirements.txt

@@ -20,3 +20,5 @@ requests
 pycountry>=22.3.5
 pycountry-convert>=0.7.2
 python-multipart
+PyJWT
+jsonschema

py_backend/test_admin_endpoints.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Test admin endpoints and schema validation
+"""
+
+import requests
+import json
+import os
+
+# Update this to your backend URL
+BASE_URL = "http://localhost:8000"  # Change if different
+
+def test_admin_login():
+    """Test admin login"""
+    print("🧪 Testing Admin Login...")
+    
+    # You'll need to set your admin password here or in environment
+    password = os.getenv("ADMIN_PASSWORD", "your_password_here")
+    
+    try:
+        response = requests.post(f"{BASE_URL}/api/admin/login", 
+                               json={"password": password})
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ Admin login successful")
+            print(f"   Token type: {data.get('token_type', 'N/A')}")
+            print(f"   Expires at: {data.get('expires_at', 'N/A')}")
+            return data.get('access_token')
+        else:
+            print(f"❌ Admin login failed: {response.status_code}")
+            print(f"   Response: {response.text}")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Admin login error: {e}")
+        return None
+
+def test_schema_endpoints(token):
+    """Test schema endpoints with token"""
+    if not token:
+        print("❌ No token available, skipping schema tests")
+        return
+    
+    print("\n🧪 Testing Schema Endpoints...")
+    
+    headers = {"Authorization": f"Bearer {token}"}
+    
+    # Test get schemas
+    try:
+        response = requests.get(f"{BASE_URL}/api/schemas", headers=headers)
+        if response.status_code == 200:
+            schemas = response.json()
+            print(f"✅ Get schemas successful: found {len(schemas)} schemas")
+            for schema in schemas:
+                print(f"   - {schema['schema_id']}: {schema['title']}")
+        else:
+            print(f"❌ Get schemas failed: {response.status_code}")
+            print(f"   Response: {response.text}")
+    except Exception as e:
+        print(f"❌ Get schemas error: {e}")
+    
+    # Test validation stats
+    try:
+        response = requests.get(f"{BASE_URL}/api/schemas/validation-stats", headers=headers)
+        if response.status_code == 200:
+            stats = response.json()
+            print(f"✅ Validation stats successful:")
+            print(f"   Total images: {stats.get('total_images', 0)}")
+            print(f"   Validation passed: {stats.get('validation_passed', 0)}")
+            print(f"   Validation failed: {stats.get('validation_failed', 0)}")
+        else:
+            print(f"❌ Validation stats failed: {response.status_code}")
+            print(f"   Response: {response.text}")
+    except Exception as e:
+        print(f"❌ Validation stats error: {e}")
+
+def main():
+    print("🚀 Testing Admin and Schema Endpoints")
+    print("=" * 50)
+    
+    # Test admin login
+    token = test_admin_login()
+    
+    # Test schema endpoints
+    test_schema_endpoints(token)
+    
+    print(f"\n📋 Instructions:")
+    print(f"1. Make sure your backend is running")
+    print(f"2. Set ADMIN_PASSWORD environment variable or update the password in this script")
+    print(f"3. Update BASE_URL if your backend is not on localhost:8000")
+
+if __name__ == "__main__":
+    main()

py_backend/test_schema_integration.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test script for schema validation integration
+"""
+
+import requests
+import json
+import sys
+import os
+
+BASE_URL = "http://localhost:8000"
+
+def test_schema_endpoints():
+    """Test admin schema management endpoints"""
+    print("🧪 Testing Schema Management Endpoints...")
+    
+    # First, login to get admin token
+    login_data = {"password": os.getenv("ADMIN_PASSWORD", "your_password_here")}
+    
+    try:
+        login_response = requests.post(f"{BASE_URL}/api/admin/login", json=login_data)
+        if login_response.status_code != 200:
+            print(f"❌ Admin login failed: {login_response.status_code}")
+            print("Please set ADMIN_PASSWORD environment variable or update the password in the script")
+            return False
+        
+        token = login_response.json().get("access_token")
+        headers = {"Authorization": f"Bearer {token}"}
+        
+        # Test getting all schemas
+        schemas_response = requests.get(f"{BASE_URL}/api/schemas", headers=headers)
+        if schemas_response.status_code == 200:
+            schemas = schemas_response.json()
+            print(f"✅ Found {len(schemas)} schemas in database:")
+            for schema in schemas:
+                print(f"   - {schema['schema_id']}: {schema['title']}")
+        else:
+            print(f"❌ Failed to fetch schemas: {schemas_response.status_code}")
+            return False
+        
+        # Test validation stats
+        stats_response = requests.get(f"{BASE_URL}/api/schemas/validation-stats", headers=headers)
+        if stats_response.status_code == 200:
+            stats = stats_response.json()
+            print(f"✅ Validation stats: {stats['validation_passed']} passed, {stats['validation_failed']} failed")
+        else:
+            print(f"❌ Failed to fetch validation stats: {stats_response.status_code}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Schema endpoint test failed: {e}")
+        return False
+
+def test_schema_validation():
+    """Test schema validation directly"""
+    print("\n🧪 Testing Schema Validation Logic...")
+    
+    # Test crisis map validation
+    crisis_data = {
+        "analysis": "A major earthquake occurred in Panama with magnitude 6.6",
+        "metadata": {
+            "title": "Panama Earthquake July 2025",
+            "source": "WFP",
+            "type": "EARTHQUAKE",
+            "countries": ["PA"],
+            "epsg": "32617"
+        }
+    }
+    
+    try:
+        from app.services.schema_validator import schema_validator
+        
+        # Test crisis map validation
+        is_valid, error = schema_validator.validate_crisis_map_data(crisis_data)
+        if is_valid:
+            print("✅ Crisis map validation: PASSED")
+        else:
+            print(f"❌ Crisis map validation: FAILED - {error}")
+        
+        # Test drone validation
+        drone_data = {
+            "analysis": "Drone image shows damaged infrastructure after earthquake",
+            "metadata": {
+                "title": "Damaged Infrastructure",
+                "source": "WFP",
+                "type": "EARTHQUAKE",
+                "countries": ["PA"],
+                "epsg": "4326",
+                "center_lat": 8.5,
+                "center_lon": -80.0,
+                "amsl_m": 100.0,
+                "agl_m": 50.0,
+                "heading_deg": 180.0,
+                "yaw_deg": 0.0,
+                "pitch_deg": 0.0,
+                "roll_deg": 0.0,
+                "rtk_fix": True,
+                "std_h_m": 0.5,
+                "std_v_m": 0.3
+            }
+        }
+        
+        is_valid, error = schema_validator.validate_drone_data(drone_data)
+        if is_valid:
+            print("✅ Drone validation: PASSED")
+        else:
+            print(f"❌ Drone validation: FAILED - {error}")
+        
+        # Test invalid data
+        invalid_data = {
+            "analysis": "Test analysis",
+            "metadata": {
+                "center_lat": 95.0,  # Invalid: > 90
+                "center_lon": 200.0,  # Invalid: > 180
+            }
+        }
+        
+        is_valid, error = schema_validator.validate_drone_data(invalid_data)
+        if not is_valid:
+            print("✅ Invalid data rejection: PASSED")
+            print(f"   Expected error: {error}")
+        else:
+            print("❌ Invalid data rejection: FAILED - Should have rejected invalid coordinates")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Schema validation test failed: {e}")
+        return False
+
+def test_models_api():
+    """Test models API to see debug info"""
+    print("\n🧪 Testing Models API (Debug Info)...")
+    
+    try:
+        response = requests.get(f"{BASE_URL}/api/models")
+        if response.status_code == 200:
+            data = response.json()
+            models = data.get("models", [])
+            debug = data.get("debug", {})
+            
+            print(f"✅ Found {len(models)} models:")
+            for model in models[:3]:  # Show first 3
+                print(f"   - {model['m_code']}: {model['label']} ({'Available' if model['is_available'] else 'Disabled'})")
+            
+            if debug:
+                print(f"✅ Debug info:")
+                print(f"   - Registered services: {debug.get('registered_services', [])}")
+                print(f"   - Total services: {debug.get('total_services', 0)}")
+                print(f"   - Available DB models: {debug.get('available_db_models', [])}")
+            
+            return True
+        else:
+            print(f"❌ Models API failed: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Models API test failed: {e}")
+        return False
+
+def test_caption_generation():
+    """Test caption generation with a sample image to see if validation works"""
+    print("\n🧪 Testing Caption Generation with Schema Validation...")
+    
+    # This would require an actual image upload, which is complex
+    # For now, we'll just check if the endpoint exists
+    try:
+        # Test if caption endpoint exists (should return 404 for non-existent image)
+        response = requests.post(f"{BASE_URL}/api/images/test-id/caption", 
+                               data={"title": "Test", "prompt": "DEFAULT_CRISIS_MAP"})
+        
+        # We expect 404 since the image doesn't exist, but that means the endpoint works
+        if response.status_code == 404:
+            print("✅ Caption generation endpoint: ACCESSIBLE")
+            print("   (404 expected for non-existent image)")
+            return True
+        else:
+            print(f"✅ Caption generation endpoint: ACCESSIBLE (status: {response.status_code})")
+            return True
+            
+    except Exception as e:
+        print(f"❌ Caption generation test failed: {e}")
+        return False
+
+def main():
+    print("🚀 Starting Schema Validation Integration Tests")
+    print("=" * 60)
+    
+    tests = [
+        ("Schema Validation Logic", test_schema_validation),
+        ("Models API", test_models_api),
+        ("Caption Generation Endpoint", test_caption_generation),
+        ("Admin Schema Endpoints", test_schema_endpoints),
+    ]
+    
+    results = []
+    for test_name, test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"❌ {test_name}: EXCEPTION - {e}")
+            results.append((test_name, False))
+    
+    print("\n" + "=" * 60)
+    print("📊 Test Results Summary:")
+    
+    passed = 0
+    for test_name, result in results:
+        status = "✅ PASSED" if result else "❌ FAILED"
+        print(f"   {test_name}: {status}")
+        if result:
+            passed += 1
+    
+    print(f"\n🎯 Overall: {passed}/{len(results)} tests passed")
+    
+    if passed == len(results):
+        print("\n🎉 All tests passed! Schema validation is working correctly.")
+        print("\nNext steps:")
+        print("1. Try uploading an image through the frontend")
+        print("2. Check the admin panel for schema validation stats")
+        print("3. Look at the backend logs for validation debug messages")
+    else:
+        print("\n⚠️  Some tests failed. Check the error messages above.")
+        print("Common issues:")
+        print("- ADMIN_PASSWORD not set correctly")
+        print("- Backend not running on localhost:8000")
+        print("- Database connection issues")
+
+if __name__ == "__main__":
+    main()

py_backend/test_schema_validation.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Test script for schema validation
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from app.services.schema_validator import schema_validator
+
+def test_crisis_map_validation():
+    """Test crisis map data validation"""
+    print("Testing Crisis Map Validation...")
+    
+    # Valid crisis map data
+    valid_data = {
+        "analysis": "A major earthquake occurred in Panama with magnitude 6.6",
+        "metadata": {
+            "title": "Panama Earthquake July 2025",
+            "source": "WFP",
+            "type": "EARTHQUAKE",
+            "countries": ["PA"],
+            "epsg": "32617"
+        }
+    }
+    
+    is_valid, error = schema_validator.validate_crisis_map_data(valid_data)
+    print(f"✓ Valid data: {is_valid}, Error: {error}")
+    
+    # Invalid crisis map data (missing required fields)
+    invalid_data = {
+        "analysis": "A major earthquake occurred in Panama",
+        "metadata": {
+            "title": "Panama Earthquake",
+            # Missing source, type, countries, epsg
+        }
+    }
+    
+    is_valid, error = schema_validator.validate_crisis_map_data(invalid_data)
+    print(f"✗ Invalid data: {is_valid}, Error: {error}")
+    
+    # Test data cleaning
+    cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(valid_data, "crisis_map")
+    print(f"✓ Cleaned data: {is_valid}, Error: {error}")
+    if is_valid:
+        print(f"  Cleaned metadata: {cleaned_data['metadata']}")
+
+def test_drone_validation():
+    """Test drone data validation"""
+    print("\nTesting Drone Validation...")
+    
+    # Valid drone data
+    valid_data = {
+        "analysis": "Drone image shows damaged infrastructure after earthquake",
+        "metadata": {
+            "title": "Damaged Infrastructure",
+            "source": "WFP",
+            "type": "EARTHQUAKE",
+            "countries": ["PA"],
+            "epsg": "4326",
+            "center_lat": 8.5,
+            "center_lon": -80.0,
+            "amsl_m": 100.0,
+            "agl_m": 50.0,
+            "heading_deg": 180.0,
+            "yaw_deg": 0.0,
+            "pitch_deg": 0.0,
+            "roll_deg": 0.0,
+            "rtk_fix": True,
+            "std_h_m": 0.5,
+            "std_v_m": 0.3
+        }
+    }
+    
+    is_valid, error = schema_validator.validate_drone_data(valid_data)
+    print(f"✓ Valid drone data: {is_valid}, Error: {error}")
+    
+    # Invalid drone data (invalid coordinate values)
+    invalid_data = {
+        "analysis": "Drone image shows damaged infrastructure",
+        "metadata": {
+            "title": "Damaged Infrastructure",
+            "center_lat": 95.0,  # Invalid: > 90
+            "center_lon": 200.0,  # Invalid: > 180
+            "heading_deg": 400.0,  # Invalid: > 360
+        }
+    }
+    
+    is_valid, error = schema_validator.validate_drone_data(invalid_data)
+    print(f"✗ Invalid drone data: {is_valid}, Error: {error}")
+    
+    # Test data cleaning
+    cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(valid_data, "drone_image")
+    print(f"✓ Cleaned drone data: {is_valid}, Error: {error}")
+    if is_valid:
+        print(f"  Cleaned metadata keys: {list(cleaned_data['metadata'].keys())}")
+
+def test_vlm_response_format():
+    """Test handling of different VLM response formats"""
+    print("\nTesting VLM Response Format Handling...")
+    
+    # Test content-wrapped format
+    content_wrapped = {
+        "content": {
+            "analysis": "Test analysis",
+            "metadata": {
+                "title": "Test Title",
+                "source": "WFP",
+                "type": "EARTHQUAKE",
+                "countries": ["PA"],
+                "epsg": "4326"
+            }
+        }
+    }
+    
+    cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(content_wrapped, "crisis_map")
+    print(f"✓ Content-wrapped format: {is_valid}, Error: {error}")
+    
+    # Test string content format
+    string_content = {
+        "content": '{"analysis": "Test", "metadata": {"title": "Test", "source": "WFP", "type": "EARTHQUAKE", "countries": ["PA"], "epsg": "4326"}}'
+    }
+    
+    cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(string_content, "crisis_map")
+    print(f"✓ String content format: {is_valid}, Error: {error}")
+
+if __name__ == "__main__":
+    print("Schema Validation Test Suite")
+    print("=" * 40)
+    
+    try:
+        test_crisis_map_validation()
+        test_drone_validation()
+        test_vlm_response_format()
+        print("\n✅ All tests completed!")
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()

py_backend/test_simple_validation.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Simple test to verify schema validation is working in your running backend
+"""
+
+def test_validation_system():
+    """Test the validation system directly"""
+    print("🧪 Testing Schema Validation System...")
+    
+    try:
+        # Import the validator
+        from app.services.schema_validator import schema_validator
+        
+        print("\n1. Testing Crisis Map Validation:")
+        crisis_data = {
+            "analysis": "A major earthquake occurred in Panama with magnitude 6.6",
+            "metadata": {
+                "title": "Panama Earthquake July 2025",
+                "source": "WFP",
+                "type": "EARTHQUAKE",
+                "countries": ["PA"],
+                "epsg": "32617"
+            }
+        }
+        
+        cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(crisis_data, "crisis_map")
+        print(f"   ✅ Valid crisis map data: {is_valid}")
+        if is_valid:
+            print(f"   📋 Cleaned metadata keys: {list(cleaned_data['metadata'].keys())}")
+        
+        print("\n2. Testing Drone Validation:")
+        drone_data = {
+            "analysis": "Drone shows damaged building",
+            "metadata": {
+                "title": "Damaged Building",
+                "center_lat": 8.5,
+                "center_lon": -80.0,
+                "amsl_m": 100.0,
+                "heading_deg": 180.0
+            }
+        }
+        
+        cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(drone_data, "drone_image")
+        print(f"   ✅ Valid drone data: {is_valid}")
+        if is_valid:
+            print(f"   📋 Cleaned metadata has {len([k for k, v in cleaned_data['metadata'].items() if v is not None])} non-null fields")
+        
+        print("\n3. Testing Invalid Data Rejection:")
+        invalid_data = {
+            "analysis": "Test",
+            "metadata": {
+                "center_lat": 95.0,  # Invalid: > 90
+                "center_lon": 200.0,  # Invalid: > 180
+                "heading_deg": 400.0  # Invalid: > 360
+            }
+        }
+        
+        cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(invalid_data, "drone_image")
+        print(f"   ✅ Invalid data correctly rejected: {not is_valid}")
+        if not is_valid:
+            print(f"   📝 Error message: {error[:100]}...")
+        
+        print("\n4. Testing VLM Response Format Handling:")
+        wrapped_data = {
+            "content": {
+                "analysis": "Test analysis",
+                "metadata": {
+                    "title": "Test Title",
+                    "source": "WFP",
+                    "type": "EARTHQUAKE",
+                    "countries": ["PA"],
+                    "epsg": "4326"
+                }
+            }
+        }
+        
+        cleaned_data, is_valid, error = schema_validator.clean_and_validate_data(wrapped_data, "crisis_map")
+        print(f"   ✅ Content-wrapped format handled: {is_valid}")
+        
+        print("\n🎉 Schema validation system is working correctly!")
+        print("\n📋 What this means:")
+        print("   • VLM responses will be validated against schemas")
+        print("   • Invalid data will be caught and logged")
+        print("   • Clean, structured data will be stored")
+        print("   • Different schemas for crisis maps vs drone images")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_database_schemas():
+    """Test database schema access"""
+    print("\n🧪 Testing Database Schema Access...")
+    
+    try:
+        from app import crud, database
+        from app.models import JSONSchema
+        
+        # Create a database session
+        db = database.SessionLocal()
+        
+        # Get schemas from database
+        schemas = crud.get_all_schemas(db)
+        print(f"   ✅ Found {len(schemas)} schemas in database:")
+        
+        for schema in schemas:
+            print(f"      - {schema.schema_id}: {schema.title}")
+        
+        # Test specific schema retrieval
+        crisis_schema = crud.get_schema(db, "[email protected]")
+        drone_schema = crud.get_schema(db, "[email protected]")
+        
+        if crisis_schema:
+            print(f"   ✅ Crisis schema found: {crisis_schema.title}")
+        if drone_schema:
+            print(f"   ✅ Drone schema found: {drone_schema.title}")
+        
+        db.close()
+        return True
+        
+    except Exception as e:
+        print(f"❌ Database schema test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🚀 Testing Schema Validation Integration")
+    print("=" * 50)
+    
+    success1 = test_validation_system()
+    success2 = test_database_schemas()
+    
+    if success1 and success2:
+        print(f"\n✅ All tests passed! Your schema validation is ready to use.")
+        print(f"\n🔧 To see it in action:")
+        print(f"   1. Upload an image through your frontend")
+        print(f"   2. Check backend logs for validation messages")
+        print(f"   3. Use admin panel to view validation stats")
+    else:
+        print(f"\n❌ Some tests failed. Check the errors above.")