Batch Processing

# ❌ Inefficient: Individual requests
embeddings = []
for text in texts:
    response = client.embed(model="voyage-3", input=text)
    embeddings.append(response.embeddings[0])

# ✅ Efficient: Single batch request
response = client.embed(model="voyage-3", input=texts)
embeddings = response.embeddings

def process_in_batches(texts, batch_size=50):
    results = []

    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        response = client.embed(model="voyage-3", input=batch)
        results.extend(response.embeddings)

    return results

# Usage
all_embeddings = process_in_batches(large_text_list, batch_size=50)

import asyncio

async def process_large_dataset(texts, batch_size=50):
    client = catsu.Client()

    # Split into batches
    batches = [
        texts[i:i + batch_size]
        for i in range(0, len(texts), batch_size)
    ]

    # Process all batches in parallel
    responses = await asyncio.gather(*[
        client.aembed(model="voyage-3", input=batch)
        for batch in batches
    ])

    # Combine results
    all_embeddings = []
    for response in responses:
        all_embeddings.extend(response.embeddings)

    return all_embeddings

# Process 1000 texts in batches of 50, in parallel
embeddings = asyncio.run(process_large_dataset(texts, batch_size=50))

import time

texts = ["Sample text"] * 100

# Method 1: Individual requests
start = time.time()
for text in texts:
    response = client.embed(model="voyage-3", input=text)
individual_time = time.time() - start

# Method 2: Batch request
start = time.time()
response = client.embed(model="voyage-3", input=texts)
batch_time = time.time() - start

print(f"Individual: {individual_time:.2f}s")
print(f"Batch: {batch_time:.2f}s")
print(f"Speedup: {individual_time / batch_time:.1f}x")