Query Usage & Limits

# Show current plan and usage
memvid plan show

Plan: starter
Status: active

Usage (this period):
  Queries: 12,847 / 50,000 (25.7%)
  Storage: 10.5 GB / 25 GB (42.0%)

Billing period:
  Started: 2024-12-01
  Resets: 2025-01-01 (in 15 days)

Dashboard: https://memvid.com/dashboard/plan

memvid plan show --json

{
  "plan": "starter",
  "status": "active",
  "queries": {
    "used": 12847,
    "limit": 25000,
    "remaining": 12153,
    "percent": 51.39
  },
  "storage": {
    "used_bytes": 2254857830,
    "limit_bytes": 5368709120,
    "percent": 42.0
  },
  "period": {
    "start": "2024-12-01T00:00:00Z",
    "end": "2025-01-01T00:00:00Z",
    "days_remaining": 15
  }
}

memvid find memory.mv2 --query "search term"

Error: Monthly query quota exceeded (MV023)

Used: 25,000 / 25,000
Resets: 2025-01-01 (in 3 days)

Options:
  1. Wait for quota reset
  2. Upgrade plan: https://memvid.com/dashboard/plan

from memvid import use, QuotaExceededError, MemvidError

mem = use('basic', 'memory.mv2')

try:
    results = mem.find("search query")
except QuotaExceededError as e:
    print(f"Quota exceeded!")
    print(f"Used: {e.used} / {e.limit}")
    print(f"Resets: {e.reset_date}")
    print(f"Upgrade at: {e.upgrade_url}")
except MemvidError as e:
    print(f"Other error: {e}")

import { use, QuotaExceededError, MemvidError } from '@anthropics/memvid'

const mem = await use('basic', 'memory.mv2')

try {
  const results = await mem.find("search query")
} catch (e) {
  if (e instanceof QuotaExceededError) {
    console.log(`Quota exceeded!`)
    console.log(`Used: ${e.used} / ${e.limit}`)
    console.log(`Resets: ${e.resetDate}`)
    console.log(`Upgrade at: ${e.upgradeUrl}`)
  } else if (e instanceof MemvidError) {
    console.log(`Other error: ${e.message}`)
  }
}

X-RateLimit-Limit: 300
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1704067260

import time
from memvid import use, RateLimitError

mem = use('basic', 'memory.mv2')

def search_with_retry(query, max_retries=3):
    for attempt in range(max_retries):
        try:
            return mem.find(query)
        except RateLimitError as e:
            if attempt < max_retries - 1:
                wait_time = e.retry_after or (2 ** attempt)
                print(f"Rate limited. Waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise

# Inefficient: 10 queries
for term in search_terms:
    results = mem.find(term)

# Better: Build compound queries when logical
results = mem.find(" OR ".join(search_terms))

from functools import lru_cache

@lru_cache(maxsize=100)
def cached_search(query):
    return mem.find(query)

# Fetching 100 results when you only need 5
memvid find memory.mv2 --query "term" --top-k 100  # Wasteful

# Better: Request what you need
memvid find memory.mv2 --query "term" --top-k 5

# Search entire memory
memvid find memory.mv2 --query "report"  # Broad

# Better: Scope to relevant documents
memvid find memory.mv2 --query "report" --scope "finance/" --start 2024-01-01

from memvid import get_usage

usage = get_usage()
if usage['queries']['remaining'] < 100:
    print(f"Warning: Only {usage['queries']['remaining']} queries left")
    print(f"Resets: {usage['period']['end']}")

class QueryTracker:
    def __init__(self, mem, warning_threshold=0.8):
        self.mem = mem
        self.warning_threshold = warning_threshold

    def find(self, query, **kwargs):
        usage = get_usage()
        percent_used = usage['queries']['used'] / usage['queries']['limit']

        if percent_used >= self.warning_threshold:
            print(f"Warning: {percent_used*100:.1f}% of quota used")

        return self.mem.find(query, **kwargs)

# Unset API key to disable tracking
memvid config unset api_key

# Queries work but aren't tracked
memvid find memory.mv2 --query "test"

# Refresh plan information
memvid plan sync

# Clear cached ticket and re-fetch
memvid plan clear
memvid plan sync