Delete a Model

Via Vi SDK:

import vi

client = vi.Client(
    secret_key="your-secret-key",
    organization_id="your-organization-id"
)

# Download model before deletion
print("Creating backup...")
downloaded = client.get_model(
    run_id="your-run-id",
    save_path="./backups/model-name-backup"
)

print(f"✓ Model backed up to {downloaded.model_path}")
print("Safe to delete from platform if needed")

Via Web Interface:

1. Go to Models tab
2. Click ⋮ menu on the model
3. Select Export Model
4. Follow export instructions
5. Save to secure backup location
6. Verify backup integrity before deleting

Questions to answer before deletion:

1. Is this model deployed?

   • Check your deployment configurations
   • Review production inference endpoints
   • Verify no active API integrations

2. Who uses this model?

   • Ask team members if they're using it
   • Check shared documentation and wikis
   • Review project planning documents

3. Are there automated dependencies?

   • Check CI/CD pipelines
   • Review scheduled inference jobs
   • Verify monitoring and alerting systems

4. Is this the only copy?

   • Confirm you have local downloads if needed
   • Check if model is backed up elsewhere
   • Verify training can be reproduced if necessary

Planning phase

• Identify why this model needs deletion
• Confirm model is superseded or no longer needed
• Check if anyone on team uses this model
• Review deployment status

Backup phase

• Download model if any future use is possible
• Save model to secure backup location
• Document model version and performance metrics
• Verify backup integrity

Dependency check phase

• Check production deployments
• Review development environments
• Verify no automated workflows use this model
• Confirm no monitoring/alerting references this model

Update phase

• Update deployments to use replacement model
• Update documentation and wikis
• Notify team members of change
• Test replacement model thoroughly

Execution phase

• Navigate to Models tab
• Select Delete Model option
• Type model name to confirm
• Click Delete button

Post-deletion phase

• Verify deletion completed
• Monitor for any related errors
• Update project documentation
• Archive backup if created

For models deployed to production, follow this enhanced protocol:

1. Preparation (1-2 days before)

• Document current model:

  • Version and performance metrics
  • Deployment locations
  • Known issues or limitations

• Train replacement model:

  • Ensure new model meets requirements
  • Evaluate thoroughly
  • Test in staging environment

2. Staging deployment (1 day before)

• Deploy replacement to staging:
  • Download new model
  • Deploy to staging infrastructure
  • Run integration tests
  • Monitor performance

3. Production cutover (deletion day)

• Low-traffic window recommended:

  • Schedule during off-peak hours
  • Have rollback plan ready
  • Team on standby for issues

• Execute cutover:

  • Deploy new model to production
  • Monitor error rates and performance
  • Verify inference works correctly
  • Wait 24-48 hours before deletion

4. Deletion (2 days after cutover)

• Verify old model not in use:

  • Check logs for any remaining requests
  • Confirm monitoring shows no traffic
  • Verify team members updated

• Delete old model:

  • Follow standard deletion process
  • Document deletion in changelog
  • Keep backup for 30 days

5. Post-deletion monitoring (1 week)

• Watch for issues:
  • Monitor error logs
  • Check performance metrics
  • Review user reports
  • Address any problems quickly

No. Model deletion is permanent and cannot be undone. Once deleted, all model weights, adapters, configurations, and metadata are immediately and permanently removed from the platform.

Best practice: Always download your model before deletion if there's any chance you might need it in the future.

If you deleted by mistake:

• Check if you have local downloads
• Look for team member copies
• If you have the original training dataset and configuration, you can retrain
• Contact support for Enterprise plans (may have additional options)

They will fail immediately. Any inference requests to a deleted model will return errors:

• SDK calls fail — ViModel() initialization throws ModelNotFoundError
• API requests fail — HTTP 404 responses for model not found
• Downloaded models still work — If you previously downloaded the model, local copies continue functioning

Before deleting:

1. Update all applications to use a different model
2. Test updated applications thoroughly
3. Deploy updates to production
4. Monitor for 24-48 hours
5. Only then delete the old model

Yes. Deleting a model immediately frees up storage space in your organization:

• Full models — 1-20 GB per model (depending on architecture)
• LoRA adapters — 50-500 MB per adapter
• Configurations — Minimal space (< 1 MB)

The freed storage becomes available for new training runs right away.

Check your storage usage in Organization > Resource Usage.

The platform will allow deletion, but you should not delete a model that's actively being used.

Recommended approach:

1. Check if model is deployed or in use
2. Update all services to use different model
3. Monitor for 24-48 hours to ensure no traffic to old model
4. Only then delete the model

If you must delete urgently:

• Have replacement model ready and tested
• Update all services simultaneously
• Monitor closely for errors
• Have rollback plan ready

The platform doesn't prevent deletion of in-use models because it can't track all external deployments. It's your responsibility to manage dependencies safely.

No. The training run that produced this model remains in your Runs section with full history:

• Training metrics — Loss curves, accuracy, mAP, etc.
• Training logs — Complete training output
• Evaluation results — Performance assessments
• Configuration — Dataset, hyperparameters, system prompt

What you lose:

• Ability to download the model
• Ability to run inference
• Model weights and adapters
• Model key (checkpoint identifier)

The run serves as a historical record even after model deletion.

Currently, models must be deleted one at a time through the web interface. Each deletion requires typing the model name as a safety measure.

For bulk deletions:

• Delete models individually through UI (safest)
• Use Vi SDK with extra caution (not recommended without additional safety checks)

If you need to delete many models:

import vi

client = vi.Client(
    secret_key="your-secret-key",
    organization_id="your-organization-id"
)

# List models to delete (be VERY careful)
models_to_delete = [
    {"run_id": "run_1", "name": "Old Model v1"},
    {"run_id": "run_2", "name": "Test Model A"},
]

# Manual confirmation for each
for model in models_to_delete:
    print(f"\nModel: {model['name']}")
    print(f"Run ID: {model['run_id']}")
    confirm = input(f"Type '{model['name']}' to confirm deletion: ")

    if confirm == model['name']:
        # Note: Vi SDK may not support direct model deletion
        # This is a conceptual example - use web interface
        print(f"Would delete {model['name']}")
    else:
        print("Skipped")

⚠️ Warning: Bulk deletion is dangerous. Always:

• Backup models before bulk operations
• Verify each model before deletion
• Start with test models to verify process
• Have recovery plan ready

Unfortunately, deletion is permanent:

• No recovery through the interface
• No undo or trash bin functionality
• Cannot restore from platform backups

Your only options:

1. Restore from local backup:

   • If you previously downloaded the model
   • Upload weights to your infrastructure
   • Resume inference from local copy

2. Retrain from scratch:

   • Use the same dataset
   • Use the same workflow configuration
   • Reference run history for exact settings
   • May not produce identical results due to randomness

3. Contact support:

   • Enterprise plans may have additional options
   • Contact support immediately
   • Provide run ID and timing of deletion
   • No guarantees of recovery

Prevention is key:

• Always double-check model name before confirming
• Download critical models before deletion
• Use descriptive names to avoid confusion
• Implement peer review for production model deletions