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

# Getting Started

> Everything you need to start building with Memvid

Welcome to Memvid, the portable AI memory system that puts you in control. This guide covers everything you need to start building intelligent applications.

***

## What Makes Memvid Different

### Single-File Architecture

Every `.mv2` file is completely self-contained:

* **Your data**: Documents, text, images, audio, videos
* **Embeddings**: Vector representations for semantic search
* **Indices**: BM25 lexical index and vector index
* **Time index**: Temporal ordering for timeline queries
* **Write-ahead log**: Crash-safe transaction logging

Share a memory by sharing a file. It works anywhere: local disk, USB drive, cloud storage, or Git repository.

### Hybrid Search Engine

Memvid combines the best of two search paradigms:

```bash theme={null}
# Hybrid search (recommended)
memvid find knowledge.mv2 --query "user authentication" --mode auto

# Lexical search - exact keyword matching
memvid find knowledge.mv2 --query "authentication" --mode lex

# Semantic search - conceptual understanding
memvid find knowledge.mv2 --query "how do users log in" --mode sem
```

### Lightning Performance

Built in Rust from the ground up for maximum performance:

| Operation         | Time          |
| ----------------- | ------------- |
| Search (50K docs) | \< 20ms       |
| Bulk ingestion    | 150+ docs/sec |
| Frame append      | \< 0.1ms      |

## Quick Start

### 1. Install the CLI

```bash theme={null}
npm install -g memvid-cli
```

### 2. Create Your First Memory

```bash theme={null}
# Create a new memory file (1 GB capacity by default)
memvid create my-knowledge.mv2

# Ingest documents with vector compression
memvid put my-knowledge.mv2 --input ./documents/ --vector-compression

# Search your knowledge
memvid find my-knowledge.mv2 --query "your search query"
```

### 3. Build Your Application

<Tabs>
  <Tab title="Node.js">
    ```typescript theme={null}
        import { use } from '@memvid/sdk';

        // Open your memory
        const mem = await use('basic', 'my-knowledge.mv2', { readOnly: true });

        // Search
        const results = await mem.find('machine learning', { k: 10 });
        results.hits.forEach(hit => {
          console.log(`${hit.score.toFixed(2)}: ${hit.title}`);
        });

        // Ask questions
        const answer = await mem.ask('What are the key concepts?');
        console.log(answer.answer);
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
        from memvid_sdk import use

        # Open your memory
        mem = use('basic', 'my-knowledge.mv2', read_only=True)

        # Search
        results = mem.find('machine learning', k=10)
        for hit in results.get('hits', []):
            print(f"{hit['score']:.2f}: {hit['title']}")

        # Ask questions with AI synthesis
        answer = mem.ask('What are the key concepts?')
        print(answer.get('answer'))

        # Always close when done
        mem.close()
    ```
  </Tab>

  <Tab title="LangChain">
    ```python theme={null}
    from memvid_sdk import use
    from langchain_openai import ChatOpenAI
    from langchain.chains import RetrievalQA

    # Open with LangChain adapter
    mem = use('langchain', 'my-knowledge.mv2', read_only=True)
    retriever = mem.as_retriever(k=5)

    # Create QA chain
    qa = RetrievalQA.from_chain_type(
        llm=ChatOpenAI(model="gpt-4o"),
        retriever=retriever
    )

    result = qa.run("What are the main concepts?")
    print(result)
    ```
  </Tab>
</Tabs>

***

## Key Features in v2

* **Frame Architecture**: Video-inspired append-only storage for crash safety and time-travel queries
* **Time Index Track**: Query documents by temporal order
* **Embedded WAL**: Crash-safe transactions with automatic recovery
* **Parallel Ingestion**: Multi-threaded document processing
* **Framework Adapters**: Native integrations for LangChain, LlamaIndex, AutoGen, and more

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Quickstart Guide" icon="rocket" href="/quickstart/cli-to-dashboard">
    Build a complete workflow with the CLI
  </Card>

  <Card title="Frame Architecture" icon="film" href="/introduction/frames">
    Understand the video-inspired storage model
  </Card>

  <Card title="CLI Reference" icon="terminal" href="/cli/create-and-put">
    Complete reference for all CLI commands
  </Card>

  <Card title="Python SDK" icon="python" href="/python-sdk/overview">
    Full SDK documentation with examples
  </Card>
</CardGroup>

***

## Getting Help

* **[FAQ](/faq/general)**: Answers to common questions
* **[Troubleshooting](/troubleshooting/cli)**: Solutions to common issues
* **[GitHub Issues](https://github.com/memvid/memvid/issues)**: Report bugs and request features

We're excited to see what you build with Memvid!