> ## 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.

# Memvid vs Vector Databases

> An honest comparison of Memvid with Pinecone, ChromaDB, and other vector databases

You're probably here because you've used vector databases before and wondering how Memvid is different. Here's an honest comparison.

<Note>
  **TL;DR**: Memvid uses **Smart Frames**, a superset of vector databases. You get lexical search, semantic search, temporal queries, and entity extraction in one file.
</Note>

***

## The 30-Second Comparison

|                         | Pinecone                    | ChromaDB             | Memvid                                                  |
| ----------------------- | --------------------------- | -------------------- | ------------------------------------------------------- |
| **Setup time**          | 7.4s (API provisioning)     | 2 min                | **145ms**                                               |
| **Search latency**      | 267ms (network + embedding) | \~500ms              | **24ms** ⚡                                              |
| **Embeddings required** | Yes, always                 | Yes, always          | Optional                                                |
| **Works offline**       | No                          | Yes                  | **Yes**                                                 |
| **File count**          | Cloud-managed               | Multiple files       | **1 file**                                              |
| **Infrastructure**      | Managed cloud               | Self-hosted or cloud | **None**                                                |
| **Pricing**             | \$70/mo+                    | Free / paid cloud    | **Free**                                                |
| **Search modes**        | Vector only                 | Vector only          | **Smart Frames (Lexical + Vector + Temporal + Entity)** |
| **Time-travel queries** | No                          | No                   | **Yes**                                                 |
| **Entity extraction**   | No                          | No                   | **Yes (built-in)**                                      |

<Info>
  **Search is 11x faster** because Memvid doesn't require network round-trips to embedding APIs or cloud vector databases. Your data, your machine, instant results.
</Info>

***

## Real-World Benchmark

We ran a head-to-head benchmark with 1,000 documents using native SDKs. Here's what we measured:

### Performance Results (1,000 Documents)

| Metric        | Memvid   | Pinecone | LanceDB | Winner              |
| ------------- | -------- | -------- | ------- | ------------------- |
| **Setup**     | 145ms    | 7.4s     | 158ms   | **Memvid (51x)**    |
| **Ingestion** | 1.6m     | 3.3m     | 6.1s    | LanceDB             |
| **Search**    | **24ms** | 267ms    | 506ms   | **Memvid (11-21x)** |
| **Storage**   | 4.9 MB   | Cloud    | Cloud   | **Memvid**          |

### Search Latency Breakdown

| System     | Avg Search |  vs Memvid |
| ---------- | ---------: | ---------: |
| **Memvid** |   **24ms** |          - |
| Pinecone   |      267ms | 11x slower |
| LanceDB    |      506ms | 21x slower |

**Why is Memvid search so fast?** No network calls. Vector databases require:

1. Network round-trip to embedding API (to embed your query)
2. Network round-trip to vector database (to search)
3. Query embedding computation time

Memvid runs entirely on your machine using **Smart Frames**, pre-indexed with Tantivy full-text search, temporal indexes, and entity graphs. Your query goes straight to the index.

### Why Ingestion Takes Longer (And Why That's OK)

Memvid's ingestion is slower than pure vector databases because it does **more work**:

* **Auto-tagging**: Automatic topic detection for every document
* **Date extraction**: Temporal entity recognition for timeline queries
* **Triplet extraction**: Subject-Predicate-Object knowledge graph building
* **Full-text indexing**: Tantivy BM25 for instant lexical search
* **Timeline indexing**: Temporal index for time-travel queries

These features enable richer queries and memory extraction. Ingestion is a **one-time cost**. Search latency is what matters for production use.

### Projected at Scale (10,000 Documents)

| Metric        | Memvid     | Pinecone | LanceDB |
| ------------- | ---------- | -------- | ------- |
| **Setup**     | \~145ms    | \~7.4s   | \~158ms |
| **Ingestion** | \~16m      | \~33m    | \~1m    |
| **Search**    | **\~24ms** | \~267ms  | \~506ms |

*Search latency remains constant regardless of dataset size thanks to efficient indexing.*

### Search Accuracy Comparison

Memvid uses **Smart Frames**, not just keyword search. Each frame is enriched with auto-tagging, temporal indexing, entity extraction, and optional embeddings.

| Query Type                                | Memvid (Smart Frames)       | Vector DBs                | Winner     |
| ----------------------------------------- | --------------------------- | ------------------------- | ---------- |
| **Exact match** `"handleAuthentication"`  | ✅ 100% precision            | ❌ Returns "login", "auth" | **Memvid** |
| **Error codes** `"ERROR_CODE_404"`        | ✅ Exact match               | ❌ Semantic confusion      | **Memvid** |
| **Temporal** `"meetings last week"`       | ✅ Timeline index            | ❌ No temporal awareness   | **Memvid** |
| **Entity state** `"Alice's current role"` | ✅ Knowledge graph           | ❌ No entity tracking      | **Memvid** |
| **Names** `"John Smith contract"`         | ✅ Exact + entity extraction | ❌ Names get fuzzy         | **Memvid** |
| **Semantic** `"reduce costs"`             | ✅ Hybrid mode               | ✅ Finds "cut expenses"    | **Tie**    |
| **Conceptual** `"happy moments"`          | ✅ Hybrid mode               | ✅ Finds "joyful"          | **Tie**    |

**Smart Frames give you the best of all worlds:**

```python theme={null}
# Exact lexical search (instant)
results = mem.find("handleAuthentication", k=5)

# Temporal queries (unique to Memvid)
results = mem.timeline("2024-01-01", "2024-01-31")

# Entity state (knowledge graph)
alice = mem.state("Alice")  # {employer: "Anthropic", role: "Engineer"}

# Semantic search (when you need it)
results = mem.find("cost reduction strategies", mode="vec")

# Hybrid search (best of both)
results = mem.find("budget optimization", mode="auto")
```

**The reality**: Vector databases only do one thing: semantic similarity. Memvid does **lexical + semantic + temporal + entity extraction** in a single file.

<Tip>
  **The takeaway**: If you're building something that needs fast, reliable search, and you're tired of paying for API calls and managing cloud infrastructure, Memvid gets you there with a single file.
</Tip>

***

## The Fundamental Difference

Traditional vector databases assume you need embeddings for everything:

```mermaid theme={null}
flowchart LR
    subgraph Traditional[Traditional Vector DB]
        A[Your Data] --> B[Embedding API]
        B --> C[Vector Store]
        C --> D[Search]
    end
```

**Problems with this approach:**

* Can't search until embeddings are computed
* API calls cost money and add latency
* Embedding model updates break your index
* "Error 404" doesn't match "error 404" (semantic ≠ exact)
* No temporal awareness: can't query "last week's meetings"
* No entity tracking: can't ask "what's Alice's current role?"

Memvid uses **Smart Frames**:

```mermaid theme={null}
flowchart LR
    subgraph Memvid[Memvid Smart Frames]
        E[Your Data] --> F[Smart Frame]
        F --> G[Lexical Index]
        F --> H[Timeline Index]
        F --> I[Entity Graph]
        F --> J[Vector Index]
        G & H & I & J --> K[Search]
    end
```

**Instant search + rich capabilities.** Your data is searchable the moment you add it, with temporal queries, entity extraction, and optional semantic search.

***

## Setup Comparison

### Pinecone

```python theme={null}
# 1. Sign up at pinecone.io
# 2. Create a project
# 3. Get API key
# 4. Install SDK
pip install pinecone-client

# 5. Initialize
import pinecone
pinecone.init(api_key="your-api-key", environment="us-west1-gcp")

# 6. Create index (wait for provisioning...)
pinecone.create_index("my-index", dimension=1536, metric="cosine")

# 7. Wait for index to be ready
import time
while not pinecone.describe_index("my-index").status["ready"]:
    time.sleep(1)

# 8. Connect to index
index = pinecone.Index("my-index")

# 9. Now you need to embed your data before inserting...
```

**Measured setup time: 7.4 seconds** (plus embedding time for each document)

### ChromaDB

```python theme={null}
# 1. Install
pip install chromadb

# 2. Initialize
import chromadb
client = chromadb.Client()

# 3. Create collection
collection = client.create_collection("my-collection")

# 4. Add documents (ChromaDB embeds automatically, but still takes time)
collection.add(
    documents=["doc1", "doc2", "doc3"],
    ids=["id1", "id2", "id3"]
)
# This step embeds all documents - can take minutes for large datasets
```

**Time to first search: 2-5 minutes** (embedding time)

### Memvid

```bash theme={null}
npm install -g memvid-cli
memvid create knowledge.mv2
echo "Your document content" | memvid put knowledge.mv2
memvid find knowledge.mv2 --query "document"
```

```python theme={null}
from memvid_sdk import create

mem = create('knowledge.mv2')
mem.put(title="Doc", label="docs", metadata={}, text="Your document content")
results = mem.find("document", k=5)
```

**Measured setup time: 145ms.** Search in milliseconds.

***

## Search Quality Comparison

### Smart Frames: Best of All Worlds

Memvid's Smart Frames combine multiple search capabilities that vector databases can't match:

| Capability              | Vector DBs        | Memvid Smart Frames   |
| ----------------------- | ----------------- | --------------------- |
| **Exact match**         | ❌ Fuzzy by design | ✅ 100% precision      |
| **Semantic similarity** | ✅ Core feature    | ✅ Optional embeddings |
| **Temporal queries**    | ❌ Not supported   | ✅ Timeline index      |
| **Entity tracking**     | ❌ Not supported   | ✅ Knowledge graph     |
| **Hybrid search**       | ❌ Pick one mode   | ✅ Auto-selects best   |

**Code search example:**

```bash theme={null}
# Finding a specific function (exact match)
memvid find codebase.mv2 --query "handleWebSocketConnection"
# → Returns exact matches instantly

# With vector search, you might get:
# - "processNetworkRequest" (semantically similar, wrong function)
# - "WebSocket" documentation (not the function)
# - "connectionHandler" (close but not exact)
```

### Memvid Handles Semantic Too

When you need conceptual queries, add embeddings:

```bash theme={null}
# Enable semantic search
memvid doctor knowledge.mv2 --rebuild-vec-index

# Semantic mode
memvid find knowledge.mv2 --query "cost reduction strategies" --mode vec

# Hybrid mode (auto-selects best approach)
memvid find knowledge.mv2 --query "budget optimization" --mode auto
```

| Query             | Lexical Mode      | Semantic Mode        | Hybrid Mode    |
| ----------------- | ----------------- | -------------------- | -------------- |
| `"reduce costs"`  | Exact phrase only | Finds "cut expenses" | ✅ Best of both |
| `"handleAuth"`    | ✅ Exact match     | Fuzzy results        | ✅ Exact match  |
| `"happy moments"` | Literal only      | Finds "joyful"       | ✅ Best of both |

***

## Infrastructure Comparison

### Pinecone Architecture (Serverless, 2025)

```mermaid theme={null}
flowchart TB
    subgraph App[Your Application]
        A[App Code]
    end
    subgraph Cloud[Pinecone Cloud]
        B[API Gateway]
        C[Multi-tenant Compute]
        D[Blob Storage]
        E[Freshness Layer]
    end
    A -->|HTTPS| B
    B --> C
    C --> D
    C --> E
```

**Requires:**

* Internet connection
* API key management
* Vendor lock-in
* Usage-based billing

### ChromaDB Architecture

```mermaid theme={null}
flowchart TB
    subgraph App[Your Application]
        A[App Code]
    end
    subgraph Server[ChromaDB Server]
        B[SQLite DB]
        C[Vector Index]
        D[Parquet Files]
    end
    A --> Server
    B -.-> E[metadata.db]
    C -.-> F[index.bin]
    D -.-> G[data.parquet]
```

**Requires:**

* Multiple files to manage
* Server process running
* Careful backup strategy

### Memvid Architecture

```mermaid theme={null}
flowchart TB
    subgraph App[Your Application]
        A[App Code]
    end
    A --> B[knowledge.mv2]
```

**That's it.** One file. Copy it, sync it, git commit it.

```bash theme={null}
# Share your entire knowledge base
cp knowledge.mv2 /team/shared/

# Version control it
git add knowledge.mv2 && git commit -m "Updated docs"

# Backup
cp knowledge.mv2 knowledge.mv2.backup
```

***

## Cost Comparison

### Pinecone Pricing (as of 2025)

| Tier       | Monthly Cost | Vectors   | Queries   |
| ---------- | ------------ | --------- | --------- |
| Free       | \$0          | 100K      | Limited   |
| Standard   | \$70+        | 1M+       | Unlimited |
| Enterprise | Custom       | Unlimited | Unlimited |

**Plus:** Embedding API costs (\$0.0001+ per 1K tokens)

### ChromaDB Pricing

| Deployment   | Cost                       |
| ------------ | -------------------------- |
| Self-hosted  | Free (your infrastructure) |
| Chroma Cloud | \$30+/mo                   |

**Plus:** Embedding API costs (unless using local models)

### Memvid Pricing

| Tier                | Cost                   |
| ------------------- | ---------------------- |
| Open source         | **Free forever**       |
| Memvid Cloud (sync) | Free tier + paid plans |

Embeddings are optional.

### Real Cost Example: 1M Documents

|                    | Pinecone        | ChromaDB             | Memvid  |
| ------------------ | --------------- | -------------------- | ------- |
| Storage            | \$70/mo         | \$30/mo or self-host | **\$0** |
| Embedding (OpenAI) | \~\$50 one-time | \~\$50 one-time      | **\$0** |
| Monthly API calls  | Included        | Included             | **\$0** |
| **Year 1 Total**   | **\$890+**      | **\$410+**           | **\$0** |

<Info>
  **Zero API calls means zero cost.** In our benchmark with 1,000 documents, Pinecone and LanceDB made 1,005 API calls each (1,000 for document embeddings + 5 for query embeddings). Memvid made **zero** because it doesn't need embeddings to search.
</Info>

***

## Feature Comparison

### What Memvid Has That Vector DBs Don't

<CardGroup cols={2}>
  <Card title="Time-Travel Queries" icon="clock">
    Query your data as it existed at any point in time:

    ```python theme={null}
    # What did we know last week?
    results = mem.find("budget", as_of_frame=1000)
    ```
  </Card>

  <Card title="Entity Extraction" icon="brain">
    Built-in entity extraction and relationship graphs:

    ```python theme={null}
    alice = mem.state("Alice")
    # {employer: "Anthropic", role: "Engineer"}
    ```
  </Card>

  <Card title="Single-File Portability" icon="file">
    Everything in one `.mv2` file:

    ```bash theme={null}
    scp knowledge.mv2 user@server:/data/
    ```
  </Card>

  <Card title="Crash Recovery" icon="shield">
    Embedded WAL ensures zero data loss:

    ```bash theme={null}
    # Power failure? No problem.
    memvid verify knowledge.mv2
    # ✓ File integrity verified
    ```
  </Card>
</CardGroup>

### What Vector DBs Have That Memvid Approaches Differently

| Feature                 | Vector DBs     | Memvid                                    |
| ----------------------- | -------------- | ----------------------------------------- |
| **Semantic search**     | Core feature   | ✅ Hybrid mode (add when needed)           |
| **Distributed scaling** | Built-in       | Single-file (use sharding for huge scale) |
| **Managed hosting**     | Yes (Pinecone) | Memvid Cloud (optional)                   |
| **Real-time sync**      | Some           | Coming soon                               |

<Note>
  **Smart Frames = superset of vector databases.** Memvid does everything vector DBs do (semantic search), plus lexical search, temporal queries, and entity extraction, all in one file.
</Note>

***

## When to Use What

### Use Pinecone When:

* You need managed infrastructure
* You're building a semantic-search-first application
* You have budget for cloud services
* You need global distribution

### Use ChromaDB When:

* You want open source with optional cloud
* You're prototyping and need quick setup
* You're comfortable managing multiple files
* Your use case is purely semantic search

### Use Memvid When:

* **You need fast search**: 24ms vs 267-506ms (11-21x faster than vector DBs)
* **You want to search immediately** without embedding delays
* **You need exact matches** (code, logs, error messages, names)
* **You want one portable file** for your entire knowledge base (4.9 MB for 1,000 docs)
* **You're building offline-first** applications
* **You want time-travel queries** (point-in-time retrieval)
* **You need entity extraction** built-in (auto-tagging, date extraction, triplets)
* **You want to avoid vendor lock-in** and API dependencies
* **You care about cost** (\$0 forever is hard to beat)

***

## Migration Guide

### From Pinecone to Memvid

```python theme={null}
import pinecone
from memvid_sdk import create

# Export from Pinecone
pinecone.init(api_key="...")
index = pinecone.Index("my-index")

# Create Memvid memory
mem = create("knowledge.mv2")

# Fetch and migrate (you'll need your original documents)
# Pinecone doesn't store original text, only vectors
# This is why Memvid stores everything in one place
```

### From ChromaDB to Memvid

```python theme={null}
import chromadb
from memvid_sdk import create

# Export from ChromaDB
client = chromadb.Client()
collection = client.get_collection("my-collection")
results = collection.get(include=["documents", "metadatas"])

# Create Memvid memory
mem = create("knowledge.mv2")

# Migrate documents
for doc, meta in zip(results["documents"], results["metadatas"]):
    mem.put(
        title=meta.get("title", "Untitled"),
        label="migrated",
        metadata=meta,
        text=doc
    )

mem.seal()
```

***

## Try It Yourself

The best comparison is your own experience:

```bash theme={null}
# Install (10 seconds)
npm install -g memvid-cli

# Create and search (10 more seconds)
memvid create test.mv2
echo "The quick brown fox jumps over the lazy dog" | memvid put test.mv2
memvid find test.mv2 --query "quick fox"

# That's it. Just search.
```

***

## Still Have Questions?

<CardGroup cols={2}>
  <Card title="5-Minute Quickstart" icon="rocket" href="/quickstart/five-minute-guide">
    Get hands-on with Memvid
  </Card>

  <Card title="The Memvid Approach" icon="lightbulb" href="/introduction/the-memvid-approach">
    Why we built it this way
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/2mynS7fcK7">
    Ask questions, get help
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/memvid/memvid">
    Star the repo, contribute
  </Card>
</CardGroup>