import asyncio
from antarys import Client


async def main():
    # Initialize client
    client = Client(host="http://localhost:8080")

    # Create collection
    await client.create_collection(
        name="my_vectors",
        dimensions=1536,
        enable_hnsw=True
    )

    vectors = client.vector_operations("my_vectors")

    # Upsert vectors
    await vectors.upsert([
        {
            "id": "doc1",
            "values": [0.1] * 1536,
            "metadata": {"category": "AI", "source": "research"}
        },
        {
            "id": "doc2",
            "values": [0.2] * 1536,
            "metadata": {"category": "ML", "source": "tutorial"}
        }
    ])

    # Query similar vectors
    results = await vectors.query(
        vector=[0.15] * 1536,
        top_k=5,
        include_metadata=True,
        filter={"category": "AI"}
    )

    for match in results["matches"]:
        print(f"ID: {match['id']}, Score: {match['score']:.4f}")

    await client.close()


asyncio.run(main())

# Create collection with HNSW indexing
await client.create_collection(
    name="documents",
    dimensions=1536,
    enable_hnsw=True,
    shards=16,
    m=16,
    ef_construction=200
)

# List all collections
collections = await client.list_collections()

# Get collection details
info = await client.describe_collection("documents")

# Delete collection
await client.delete_collection("documents")

# Simple embedding
embedding = await client.embed("Hello, World!")

# Batch embeddings
embeddings = await client.embed([
    "First document",
    "Second document",
    "Third document"
])

# Query-optimized embeddings
query_emb = await client.embed_query("What is artificial intelligence?")

# Document embeddings with progress
doc_embs = await client.embed_documents(
    documents=["Doc 1", "Doc 2", "Doc 3"],
    show_progress=True
)

# Text similarity comparison
score = await client.text_similarity(
    "machine learning",
    "artificial intelligence"
)

vectors = client.vector_operations("my_collection")

# Single vector upsert
await vectors.upsert([
    {
        "id": "vec1",
        "values": [0.1, 0.2, 0.3],
        "metadata": {"type": "document", "timestamp": 1234567890}
    }
])

# Batch upsert for large-scale operations
batch = []
for i in range(10000):
    batch.append({
        "id": f"vector_{i}",
        "values": [random.random() for _ in range(1536)],
        "metadata": {"category": f"cat_{i % 5}"}
    })

await vectors.upsert_batch(
    batch,
    batch_size=5000,
    parallel_workers=8,
    show_progress=True
)

# Semantic search with filters
results = await vectors.query(
    vector=[0.1] * 1536,
    top_k=10,
    include_metadata=True,
    filter={"category": "research"},
    threshold=0.7,
    use_ann=True
)

# Batch queries
query_vectors = [[0.1] * 1536, [0.2] * 1536, [0.3] * 1536]
batch_results = await vectors.batch_query(
    vectors=query_vectors,
    top_k=5,
    include_metadata=True
)

# Get specific vector
vector_data = await vectors.get_vector("vec1")

# Count vectors
count = await vectors.count_vectors()

# Delete by IDs
await vectors.delete(["vec1", "vec2", "vec3"])

client = Client(
    host="http://localhost:8080",

    # Connection pooling
    connection_pool_size=100,

    # HTTP/2 and compression
    use_http2=True,
    compression=True,

    # Client-side caching
    cache_size=1000,
    cache_ttl=300,

    # Threading
    thread_pool_size=16,

    # Reliability
    retry_attempts=5,
    timeout=120
)

client = Client(
    connection_pool_size=20,
    cache_size=500,
    thread_pool_size=4
)

# Batch operations
batch_size = 1000
parallel_workers = 2

client = Client(
    connection_pool_size=50,
    cache_size=2000,
    thread_pool_size=8
)

# Batch operations
batch_size = 3000
parallel_workers = 4

client = Client(
    connection_pool_size=100,
    cache_size=5000,
    thread_pool_size=16
)

# Batch operations
batch_size = 5000
parallel_workers = 8

# Collection creation
await client.create_collection(
    name="optimized",
    dimensions=1536,
    enable_hnsw=True,
    m=16,  # Connectivity (16-64 for high recall)
    ef_construction=200,  # Construction quality (200-800)
    shards=32  # Parallel processing
)

# Query-time tuning
results = await vectors.query(
    vector=query_vector,
    ef_search=200,  # Search quality (100-800)
    use_ann=True  # Enable HNSW acceleration
)

# Validate vector dimensions
is_valid = await vectors.validate_vector_dimensions([0.1] * 1536)

# Get collection dimensions
dims = await vectors.get_collection_dimensions()

# Get cache statistics
stats = vectors.get_cache_stats()
print(f"Cache hit rate: {stats['hit_rate']:.2%}")

# Clear caches
await client.clear_cache()
await vectors.clear_cache()

# Check server health
health = await client.health()

# Get server information
info = await client.info()

# Collection statistics
collection_info = await client.describe_collection("vectors")
print(f"Vector count: {collection_info.get('vector_count', 0)}")

from antarys.types import VectorRecord, SearchResult, SearchParams

# Type-safe vector record
record: VectorRecord = {
    "id": "example",
    "values": [0.1, 0.2, 0.3],
    "metadata": {"key": "value"}
}

# Type-safe search parameters
params = SearchParams(
    vector=[0.1] * 1536,
    top_k=10,
    include_metadata=True,
    threshold=0.8
)