Advanced usage

from memvai import Memv

client = Memv()

# Get raw response with headers
response = client.spaces.with_raw_response().list()

# Access headers
print(response.headers.get('X-Request-ID'))
print(response.headers.get('X-RateLimit-Remaining'))

# Parse the response
spaces = response.parse()
print(spaces.spaces)

import Memv from 'memvai';

const client = new Memv();

// Get raw response
const response = await client.spaces.list().asResponse();
console.log(response.headers.get('X-Request-ID'));

// Get both parsed data and raw response
const { data, response: raw } = await client.spaces.list().withResponse();
console.log(raw.headers.get('X-RateLimit-Remaining'));
console.log(data.spaces);

import asyncio
from memvai import AsyncMemv

async def main():
    client = AsyncMemv()

    # Execute multiple requests in parallel
    spaces_task = client.spaces.list()
    stats_task = client.spaces.get_stats()

    spaces, stats = await asyncio.gather(spaces_task, stats_task)

    print(f"Spaces: {len(spaces.spaces)}")
    print(f"Total memories: {stats.total_memories}")

asyncio.run(main())

import Memv from 'memvai';

const client = new Memv();

// Execute multiple requests in parallel
const [spaces, stats] = await Promise.all([
  client.spaces.list(),
  client.spaces.getStats(),
]);

console.log(`Spaces: ${spaces.spaces.length}`);
console.log(`Total memories: ${stats.total_memories}`);

async def upload_files_parallel(space_id: str, file_paths: list[str]):
    """Upload multiple files concurrently."""
    client = AsyncMemv()

    async def upload_file(file_path: str):
        with open(file_path, 'rb') as f:
            return await client.upload.batch.create(
                space_id=space_id,
                files=[f]
            )

    # Upload all files concurrently
    tasks = [upload_file(path) for path in file_paths]
    results = await asyncio.gather(*tasks)

    return [r.batch_id for r in results]

# Usage
files = ["doc1.pdf", "doc2.pdf", "doc3.pdf"]
batch_ids = asyncio.run(upload_files_parallel("space_abc123", files))

async function uploadFilesParallel(
  spaceId: string,
  filePaths: string[]
): Promise<string[]> {
  const uploadPromises = filePaths.map(async filePath => {
    const file = fs.createReadStream(filePath);
    const response = await client.upload.batch.create({
      space_id: spaceId,
      files: [file],
    });
    return response.batch_id;
  });

  return await Promise.all(uploadPromises);
}

// Usage
const files = ['doc1.pdf', 'doc2.pdf', 'doc3.pdf'];
const batchIds = await uploadFilesParallel('space_abc123', files);

import logging
from memvai import Memv

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

client = Memv()

# Logging is automatic with MEMV_LOG environment variable

import Memv from 'memvai';
import pino from 'pino';

const logger = pino();

const client = new Memv({
  logger: logger.child({ name: 'Memv' }),
  logLevel: 'debug',
});