use memvid_core::{Memvid, PutOptions, SearchRequest};

fn main() -> memvid_core::Result<()> {
    // 创建新的记忆文件
    let mut mem = Memvid::create("knowledge.mv2")?;

    // 添加文档（带元数据）
    let opts = PutOptions::builder()
        .title("会议记录")
        .uri("mv2://meetings/2024-01-15")
        .tag("project", "alpha")
        .build();
    mem.put_bytes_with_options(b"Q4 planning discussion...", opts)?;
    mem.commit()?;

    // 搜索
    let response = mem.search(SearchRequest {
        query: "planning".into(),
        top_k: 10,
        snippet_chars: 200,
        ..Default::default()
    })?;

    for hit in response.hits {
        println!("{}: {}", hit.title.unwrap_or_default(), hit.text);
    }

    Ok(())
}

from memvid import Memvid, PutOptions, SearchRequest

# 创建记忆文件
mem = Memvid.create("knowledge.mv2")

# 添加文档
opts = PutOptions.builder() \
    .title("会议记录") \
    .uri("mv2://meetings/2024-01-15") \
    .tag("project", "alpha") \
    .build()
mem.put_bytes_with_options(b"Q4 planning discussion...", opts)
mem.commit()

# 搜索
response = mem.search(
    query="planning",
    top_k=10,
    snippet_chars=200
)
for hit in response.hits:
    print(f"{hit.title}: {hit.text}")

import { create, PutOptions, SearchRequest } from '@memvid/sdk';

async function main() {
  // 创建记忆文件
  const mem = await create('knowledge.mv2');

  // 添加文档
  const opts = new PutOptions()
    .setTitle('会议记录')
    .setUri('mv2://meetings/2024-01-15')
    .addTag('project', 'alpha');
  await mem.put({
    title: '会议记录',
    label: 'meeting',
    text: 'Q4 planning discussion...',
  });

  // 搜索
  const results = await mem.find('planning', { k: 10 });
  console.log(results.hits);

  // 密封文件
  await mem.seal();
}

main();

# 创建记忆文件
memvid-cli create knowledge.mv2

# 添加文档
memvid-cli put knowledge.mv2 \
  --title "会议记录" \
  --content "Q4 planning discussion..." \
  --tag project=alpha

# 搜索
memvid-cli find knowledge.mv2 --query "planning" --top-k 5

# 时间旅行查询
memvid-cli find knowledge.mv2 --query "planning" --as-of-frame 100

# 查看文件状态
memvid-cli inspect knowledge.mv2 --stats

# 压缩文件
memvid-cli compact knowledge.mv2

# 加密文件
memvid-cli lock knowledge.mv2 --out knowledge.mv2e

// 追加新记忆
mem.put_bytes_with_options(b"new information", opts)?;

// 创建分支
let branch = mem.branch("experiment-branch")?;
branch.put_bytes(b"experimental data")?;

// 回退到主分支

# 回溯到特定时间点（通过帧号）
results = mem.find('config', as_of_frame=100)

# 回溯到特定时间点（通过时间戳）
results = mem.find('budget', as_of_ts=1704067200)

# 查看历史时间线
results = mem.find('config', as_of_frame=50)

// Rust 时间旅行
let past_mem = mem.at_timestamp(1705276800)?;

for frame in past_mem.frames() {
    println!("{:?}", frame);
}

let branched = past_mem.branch("what-if-scenario")?;

# CLI 时间旅行
memvid find knowledge.mv2 --query "config" --as-of-frame 100
memvid find knowledge.mv2 --query "config" --as-of-ts 1704067200
memvid timeline knowledge.mv2 --as-of-frame 50

// 子毫秒级本地记忆访问
let response = mem.search(SearchRequest {
    query: "project planning".into(),
    top_k: 5,
    ..Default::default()
})?;
println!("P50 latency: {}ms", response.latency_p50);

import { create } from '@memvid/sdk';

const mem = await create('knowledge.mv2');
await mem.put({ title: 'Team Info', label: 'notes', text: 'Alice works at Anthropic...' });

// 查询实体状态
const alice = await mem.state('Alice');
// { slots: { employer: 'Anthropic', role: 'Senior Engineer' } }

# Cargo.toml 示例
[dependencies]
memvid-core = { version = "2.0", features = ["lex", "vec", "temporal_track", "encryption"] }

// 音频转录
use memvid_core::{WhisperConfig, WhisperTranscriber};

let config = WhisperConfig::default();
let transcriber = WhisperTranscriber::new(&config)?;
let result = transcriber.transcribe_file("audio.mp3")?;
println!("{}", result.text);

// 图片搜索（需要 clip feature）
cargo run --example clip_visual_search --features clip

// 本地嵌入
use memvid_core::text_embed::{LocalTextEmbedder, TextEmbedConfig};

let config = TextEmbedConfig::default();
let embedder = LocalTextEmbedder::new(config)?;
let embedding = embedder.embed_text("hello world")?;

# 加密 PHI 数据
memvid lock phi-data.mv2 --out phi-data.mv2e

# 记录访问日志
echo "$(date): Decrypting phi-data for user $USER" >> audit.log
memvid unlock phi-data.mv2e --out phi-data.mv2

# 重新加密
memvid lock phi-data.mv2 --out phi-data.mv2e
echo "$(date): Re-encrypted phi-data" >> audit.log

// 批量摄入（并行）
let opts = PutOptions::builder()
    .title("Bulk document")
    .parallel(true)  // 启用并行摄入
    .build();

// 大文档分块（建议 500-1000 字符/块）
for chunk in document.chunks(1000) {
    mem.put_bytes(chunk, &opts)?;
}

// 精确搜索（使用 BM25）
let response = mem.search(SearchRequest {
    query: "exact phrase".into(),
    top_k: 10,
    snippet_chars: 200,
    use_bm25: true,      // BM25 精确匹配
    use_vector: false,   // 关闭向量搜索
    ..Default::default()
})?;

// 向量 + BM25 混合搜索
let response = mem.search(SearchRequest {
    query: "concept".into(),
    top_k: 10,
    hybrid: true,        // 混合搜索
    ..Default::default()
})?;

// 压缩旧记忆
mem.compact()?;

// 设置过期时间
let opts = PutOptions::builder()
    .expires_at(1706236800)  // Unix timestamp
    .build();

// 清理过期数据
mem.cleanup()?;

use std::fs;
use chrono::Local;

fn backup_memory(mem: &Memvid) -> Result<String, Box<dyn Error>> {
    let timestamp = Local::now().format("%Y%m%d_%H%M%S");
    let backup_path = format!("knowledge_{}.mv2", timestamp);
    fs::copy(mem.path(), &backup_path)?;
    println!("备份已保存: {}", backup_path);
    Ok(backup_path)
}

name: Backup Memory
on:
  schedule:
    - cron: '0 0 * * *'  # 每日凌晨

jobs:
  backup:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Memvid
        run: curl -fsSL https://get.memvid.com | sh
      - name: Decrypt, update, re-encrypt
        env:
          MEMVID_PASSWORD: ${{ secrets.MEMVID_PASSWORD }}
        run: |
          echo "$MEMVID_PASSWORD" | memvid unlock memory.mv2e --password-stdin --out memory.mv2
          memvid put memory.mv2 --input ./new-data/
          echo "$MEMVID_PASSWORD" | memvid lock memory.mv2 --password-stdin --out memory.mv2e
      - name: Upload encrypted backup
        uses: actions/upload-artifact@v4
        with:
          name: encrypted-memory
          path: memory.mv2e

use memvid_core::Memvid;

// 创建新记忆
let mem = Memvid::create("knowledge.mv2")?;

// 打开已有记忆
let mem = Memvid::open("knowledge.mv2")?;

// 打开加密记忆
let mem = Memvid::open_encrypted("secure.mv2e", "password")?;

// 创建加密记忆
let mem = Memvid::create_encrypted("secure.mv2e", "password")?;

use memvid_core::{PutOptions, PutOptionsBuilder};

// 基本写入
mem.put_bytes(b"content")?;

// 带选项写入
let opts = PutOptionsBuilder::default()
    .title("Title")
    .uri("mv2://resource/id")
    .tag("key", "value")
    .expires_at(timestamp)
    .build();
mem.put_bytes_with_options(b"content", opts)?;

// 提交更改
mem.commit()?;

use memvid_core::{SearchRequest, SearchOptions};

// 基本搜索
let response = mem.search("query")?;

// 高级搜索
let request = SearchRequest {
    query: "query".into(),
    top_k: 10,
    snippet_chars: 200,
    use_bm25: true,
    use_vector: true,
    hybrid: true,
    as_of_frame: None,
    as_of_ts: None,
    ..Default::default()
};
let response = mem.search(request)?;

// 遍历结果
for hit in response.hits {
    println!("{}: {}", hit.title.unwrap_or_default(), hit.text);
}

// 按时间戳回溯
let past = mem.at_timestamp(1704067200)?;

// 按帧号回溯
let past = mem.at_frame(100)?;

// 创建分支
let branch = past.branch("experiment")?;

from memvid import Memvid, PutOptions

# 创建
mem = Memvid.create("knowledge.mv2")

# 写入
opts = PutOptions.builder().title("Title").build()
mem.put_bytes_with_options(b"content", opts)
mem.commit()

# 搜索
results = mem.find("query", k=10)

# 时间旅行
results = mem.find("query", as_of_frame=100)
results = mem.find("query", as_of_ts=1704067200)

import { create, use, PutOptions } from '@memvid/sdk';

// 创建
const mem = await create('knowledge.mv2');

// 写入
await mem.put({
  title: 'Title',
  label: 'tag',
  text: 'content'
});

// 搜索
const results = await mem.find('query', { k: 10 });

// 使用已有记忆
const existing = await use('alias', 'knowledge.mv2', { mode: 'auto' });

# 检查 .mv2 文件大小
ls -lh knowledge.mv2

# 检查磁盘空间
df -h /path/to/directory

# 监控进程内存使用情况
ps aux | grep memvid

# 检查文件 WAL 使用情况
memvid-cli inspect knowledge.mv2 --stats

// 尝试恢复损坏的文件
let mem = Memvid::recover("knowledge.mv2")?;

match mem {
    Ok(recovered) => println!("恢复成功，共恢复 {} 条记录", recovered.len()),
    Err(e) => eprintln!("恢复失败: {:?}", e),
}

# CLI 恢复命令
memvid-cli recover knowledge.mv2 --output recovered.mv2

use memvid_core::{Memvid, PutOptions, SearchRequest, Error};

fn robust_search(mem: &Memvid, query: &str) -> Result<Vec<SearchHit>, Error> {
    let response = mem.search(SearchRequest {
        query: query.into(),
        top_k: 10,
        ..Default::default()
    })?;

    if response.hits.is_empty() {
        eprintln!("警告：未找到匹配结果，请尝试 broader 查询");
        return Ok(Vec::new());
    }

    Ok(response.hits)
}

fn safe_commit(mem: &mut Memvid) -> Result<(), Error> {
    match mem.commit() {
        Ok(_) => println!("提交成功"),
        Err(e) => {
            eprintln!("提交失败: {:?}", e);
            return Err(e);
        }
    }
    Ok(())
}

# 加密敏感数据
memvid lock phi-data.mv2 --out phi-data.mv2e

# 解密使用
memvid unlock phi-data.mv2e --out phi-data.mv2

// Rust 加密示例
let mem = Memvid::create_encrypted("secure.mv2e", "password")?;
let mem = Memvid::open_encrypted("secure.mv2e", "password")?;

from memvid import Memvid, PutOptions

# 从 JSONL 文件批量导入
mem = Memvid.create("imported.mv2")
with open("data.jsonl", "r") as f:
    for line in f:
        item = json.loads(line)
        mem.put_bytes(
            item["content"].encode(),
            PutOptions.builder().title(item["title"]).build()
        )
mem.commit()
print(f"成功导入记录")

use std::fs;
use chrono::Local;

fn backup_memory(mem: &Memvid) -> Result<String, Box<dyn Error>> {
    let timestamp = Local::now().format("%Y%m%d_%H%M%S");
    let backup_path = format!("knowledge_{}.mv2", timestamp);
    fs::copy(mem.path(), &backup_path)?;
    println!("备份已保存: {}", backup_path);
    Ok(backup_path)
}

# CLI
npm install -g memvid-cli

# Node.js
npm install @memvid/sdk

# Python
pip install memvid-sdk

# Rust
cargo add memvid-core