Skip to main content
Memvid files have configurable storage capacity. By default, new files are created with 1 GB capacity, enough for most use cases. When you need more, upgrade your plan and sync tickets to increase capacity.

​
Default Capacity

When you create a new memory, you get generous defaults: 
memvid create knowledge.mv2

✓ Created memory at knowledge.mv2
  Capacity: 50 MB (52428800 bytes)
  Size: 70 KB
  Indexes: lexical | vector
Next steps:
  memvid put knowledge.mv2 --input <file>     # Add content
  memvid find knowledge.mv2 --query <text>    # Search
  memvid stats knowledge.mv2                  # View stats

​
Plans

PlanTotal CapacityMemoriesPer-Memory LimitPrice
Free50 MB150 MBFree
Starter25 GB55 GB$9.99/mo
Pro125 GB1025 GB$49.99/mo
EnterpriseUnlimitedUnlimitedUnlimitedContact us

​
Checking Capacity

​
CLI

memvid stats knowledge.mv2

Memory: knowledge.mv2

Documents:         1,250
Active Frames:     1,248
Size:              7.8 MB
Capacity:          50 MB
Utilization:       15.6%

Indexes:
  Lexical:         Yes
  Vector:          Yes
  Time:            Yes

​
Python SDK

from memvid_sdk import use

mem = use('basic', 'knowledge.mv2', read_only=True)
stats = mem.stats()

print(f"Size: {stats['size_bytes'] / 1e9:.2f} GB")
print(f"Capacity: {stats['capacity_bytes'] / 1e9:.2f} GB")
print(f"Utilization: {stats['storage_utilisation_percent']:.1f}%")

# Check current ticket info
ticket = mem.current_ticket()
print(f"Plan: {ticket['issuer']}")
print(f"Capacity: {ticket['capacity_bytes'] / 1e9:.2f} GB")

​
Node.js SDK

import { use } from '@memvid/sdk';

const mem = await use('basic', 'knowledge.mv2', { readOnly: true });
const stats = await mem.stats();

console.log(`Size: ${(stats.size_bytes / 1e9).toFixed(2)} GB`);
console.log(`Capacity: ${(stats.capacity_bytes / 1e9).toFixed(2)} GB`);
console.log(`Utilization: ${stats.storage_utilisation_percent.toFixed(1)}%`);

​
Upgrading Capacity

To increase your memory’s capacity, you need to:
  1. Get a Memvid API key from app.memvid.com
  2. Create a memory in the dashboard and get its Memory ID
  3. Sync tickets to your local file

​
Step 1: Get Your Credentials

  1. Sign up at app.memvid.com
  2. Create a new memory in the dashboard
  3. Copy your API Key and Memory ID

​
Step 2: Sync Tickets

from memvid_sdk import use
import os

# Configuration
API_KEY = os.environ.get("MEMVID_API_KEY")
MEMORY_ID = os.environ.get("MEMVID_MEMORY_ID")
API_URL = "https://api.memvid.com"  # or your custom endpoint

# Open your memory
mem = use('basic', 'knowledge.mv2')

# Check current binding
binding = mem.get_memory_binding()
if binding:
    print(f"Already bound to: {binding['memory_id']}")
else:
    print("Not currently bound")

# Sync tickets from the API
result = mem.sync_tickets(
    memory_id=MEMORY_ID,
    api_key=API_KEY,
    api_url=API_URL
)

print(f"Memory ID: {result['memory_id']}")
print(f"Issuer: {result['issuer']}")
print(f"New Capacity: {result['capacity_bytes'] / 1e9:.2f} GB")

# Verify new capacity
capacity = mem.get_capacity()
print(f"Current capacity: {capacity / 1e9:.2f} GB")

mem.close()

​
Environment Variables

VariableDescription
MEMVID_API_KEYYour API key from app.memvid.com
MEMVID_MEMORY_IDMemory ID from the dashboard
MEMVID_API_URLAPI endpoint (default: https://api.memvid.com)

​
Capacity Exceeded Errors

When you exceed capacity, you’ll see error MV001: 
Error: CapacityExceeded (MV001)
File capacity: 52428800 bytes (50 MB)
Current usage: 49000000 bytes (49 MB)
Requested: 5000000 bytes (5 MB)

​
Solutions

  1. Delete unused frames: 
    memvid delete knowledge.mv2 --frame-id 42 --yes
  2. Vacuum to reclaim space: 
    memvid doctor knowledge.mv2 --vacuum
  3. Upgrade your plan and sync tickets

​
Handling Capacity in Code

from memvid_sdk import use, CapacityExceededError

def safe_ingest(mem, documents):
    """Ingest documents with capacity handling."""
    stats = mem.stats()
    available = stats['capacity_bytes'] - stats['size_bytes']

    for doc in documents:
        estimated_size = len(doc['text'].encode('utf-8'))

        if estimated_size > available:
            print(f"Skipping {doc['title']}: insufficient capacity")
            continue

        try:
            mem.put(text=doc['text'], title=doc['title'])
            available -= estimated_size
        except CapacityExceededError:
            print(f"Capacity exceeded at {doc['title']}")
            break

    mem.seal()

​
WAL Size by Capacity

The Write-Ahead Log scales with capacity:
File CapacityWAL SizeCheckpoint Threshold
< 100 MB1 MB768 KB (75%)
< 1 GB4 MB3 MB (75%)
< 10 GB16 MB12 MB (75%)
≥ 10 GB64 MB48 MB (75%)

​
Storage Optimization

​
Vector Compression

Enable 16x compression for embeddings: 
memvid put knowledge.mv2 --input docs/ --vector-compression

mem.put_many(docs, enable_embedding=True, vector_compression=True)

​
Vacuum After Deletions

Reclaim space from deleted frames: 
# Check before
memvid stats knowledge.mv2

# Vacuum
memvid doctor knowledge.mv2 --vacuum

# Check after
memvid stats knowledge.mv2

​
Best Practices

​
Capacity Planning

  1. Start free: 50 MB handles most personal projects
  2. Monitor usage: Check storage_utilisation_percent regularly
  3. Upgrade before 80%: Leave headroom for growth
  4. Use compression: Enable vector compression for large collections

​
Multi-Memory Strategy

For large organizations: 
project-docs.mv2      → 10 GB (documentation)
chat-history.mv2      → 25 GB (conversations)
media-archive.mv2     → 50 GB (images, audio)

​
Next Steps

Memory Architecture

Understand file structure

Troubleshooting

Solve capacity issues