Capacity & Plans

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

Plan	Total Capacity	Memories	Per-Memory Limit	Price
Free	50 MB	1	50 MB	Free
Starter	25 GB	5	5 GB	$9.99/mo
Pro	125 GB	10	25 GB	$49.99/mo
Enterprise	Unlimited	Unlimited	Unlimited	Contact 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:

Get a Memvid API key from memvid.com/dashboard
Create a memory in the dashboard and get its Memory ID
Sync tickets to your local file

Step 1: Get Your Credentials

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

Step 2: Sync Tickets

Python SDK
CLI

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()

# Set environment variables
export MEMVID_API_KEY="your-api-key"
export MEMVID_MEMORY_ID="your-memory-id"
export MEMVID_API_URL="https://api.memvid.com"

# Sync tickets
memvid tickets sync knowledge.mv2

# Verify
memvid stats knowledge.mv2

Environment Variables

Variable	Description
`MEMVID_API_KEY`	Your API key from memvid.com/dashboard
`MEMVID_MEMORY_ID`	Memory ID from the dashboard
`MEMVID_API_URL`	API 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

Delete unused frames:

memvid delete knowledge.mv2 --frame-id 42 --yes

Vacuum to reclaim space:
memvid doctor knowledge.mv2 --vacuum
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 Capacity	WAL Size	Checkpoint Threshold
< 100 MB	1 MB	768 KB (75%)
< 1 GB	4 MB	3 MB (75%)
< 10 GB	16 MB	12 MB (75%)
≥ 10 GB	64 MB	48 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

Start free: 50 MB handles most personal projects
Monitor usage: Check storage_utilisation_percent regularly
Upgrade before 80%: Leave headroom for growth
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)

​Default Capacity

​Plans

​Checking Capacity

​CLI

​Python SDK

​Node.js SDK

​Upgrading Capacity

​Step 1: Get Your Credentials

​Step 2: Sync Tickets

​Environment Variables

​Capacity Exceeded Errors

​Solutions

​Handling Capacity in Code

​WAL Size by Capacity

​Storage Optimization

​Vector Compression

​Vacuum After Deletions

​Best Practices

​Capacity Planning

​Multi-Memory Strategy

​Next Steps

Memory Architecture

Troubleshooting