> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memvid.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Capacity & Plans

> Storage tiers, capacity management, and upgrading your memories

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:

```bash theme={null}
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

```bash theme={null}
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

```python theme={null}
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

```typescript theme={null}
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 [memvid.com/dashboard](https://memvid.com/dashboard)
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 [memvid.com/dashboard](https://memvid.com/dashboard)
2. Create a new memory in the dashboard
3. Copy your **API Key** and **Memory ID**

### Step 2: Sync Tickets

<Tabs>
  <Tab title="Python SDK">
    ```python theme={null}
    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()
    ```
  </Tab>

  <Tab title="CLI">
    ```bash theme={null}
    # 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
    ```
  </Tab>
</Tabs>

### Environment Variables

| Variable           | Description                                                            |
| ------------------ | ---------------------------------------------------------------------- |
| `MEMVID_API_KEY`   | Your API key from [memvid.com/dashboard](https://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

1. **Delete unused frames**:

   ```bash theme={null}
   memvid delete knowledge.mv2 --frame-id 42 --yes
   ```
2. **Vacuum to reclaim space**:

   ```bash theme={null}
   memvid doctor knowledge.mv2 --vacuum
   ```
3. **Upgrade your plan** and sync tickets

***

## Handling Capacity in Code

```python theme={null}
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:

```bash theme={null}
memvid put knowledge.mv2 --input docs/ --vector-compression
```

```python theme={null}
mem.put_many(docs, enable_embedding=True, vector_compression=True)
```

### Vacuum After Deletions

Reclaim space from deleted frames:

```bash theme={null}
# 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

<CardGroup cols={2}>
  <Card title="Memory Architecture" icon="database" href="/concepts/memory-architecture">
    Understand file structure
  </Card>

  <Card title="Troubleshooting" icon="wrench" href="/troubleshooting/cli">
    Solve capacity issues
  </Card>
</CardGroup>