Building E-Commerce AI Agents with Antarys

How UVTR Infortech Solutions built conversational commerce experiences using Antarys as their vector storage layer.

Company Overview

UVTR Infortech Solutions (uvtrbd.com) builds conversational AI for e-commerce businesses Globally. Their E-Commerce AI Agents platform enables shoppers to discover products, get personalized recommendations, and complete purchases directly through Messenger and Instagram.

The Challenge

UVTR needed a vector database to power their AI agents with several key requirements:

• Fast retrieval for real-time conversations where customers expect instant responses
• Self-hosting capability to keep customer data in their own infrastructure
• Simple integration for generating and storing product embeddings
• Cost-effective solution that wouldn't require expensive cloud database services

Traditional cloud-based vector databases posed challenges with pricing at scale and data residency requirements for their customers.

Why Antarys

UVTR chose Antarys as their vector storage layer for three primary reasons:

Use Cases

Product Discovery

Customers chat with the agent using natural language like "cute notebooks for school under 300 taka" or "pastel stationery for college." The agent:

1. Converts the customer's message into a vector embedding
2. Searches the product catalog stored in Antarys
3. Returns relevant products matching the semantic meaning

from antarys import Client

# Initialize Antarys
client = Client(host="http://localhost:8080")
await client.create_collection("products", dimensions=1536)

vectors = client.vector_operations("products")

# Store product embeddings
await vectors.upsert([{
    "id": product_id,
    "values": product_embedding,
    "metadata": {
        "name": "Unicorn Spiral Notebook",
        "price": 250,
        "category": "notebooks",
        "colors": ["pink", "purple", "pastel"]
    }
}])

# Search products
results = await vectors.query(
    vector=customer_query_embedding,
    top_k=10,
    include_metadata=True,
    filter={"price": {"$lt": 300}}
)

Personalized Recommendations

The agent remembers each customer's preferences across conversations:

• Color preferences (pastels, bright colors, monochrome)
• Price sensitivity and typical budget range
• Favorite brands and product categories
• Past purchases and browsing history

# Create customer preference collection
await client.create_collection("customers", dimensions=1536)
customer_vectors = client.vector_operations("customers")

# Store customer preference vector
await customer_vectors.upsert([{
    "id": customer_id,
    "values": preference_embedding,
    "metadata": {
        "favorite_colors": ["pastel_pink", "lavender"],
        "price_range": [200, 500],
        "last_purchase": "2025-01-15"
    }
}])

# Get customer preferences
customer_data = await customer_vectors.get_vector(customer_id)

# Find matching products
recommendations = await vectors.query(
    vector=customer_data['values'],
    top_k=20,
    filter={"in_stock": True}
)

Bundle Recommendations

The agent suggests complementary products that make sense together:

• Notebook + matching gel pens
• Planner + sticky notes + washi tape
• Art supplies bundle

# Find complementary products
await client.create_collection("bundles", dimensions=1536)
bundle_vectors = client.vector_operations("bundles")

# When customer adds item to cart
cart_item = await vectors.get_vector(item_id)

# Find frequently bought together
complements = await bundle_vectors.query(
    vector=cart_item['values'],
    top_k=5
)

Inventory Intelligence

The agent aggregates demand signals from conversations to help merchants make better inventory decisions:

• Track what customers are asking for (even if out of stock)
• Identify trending products early
• Spot seasonal demand patterns
• Suggest reorder quantities based on conversation volume

# Log demand signals
await client.create_collection("demand_signals", dimensions=1536)
demand_vectors = client.vector_operations("demand_signals")

# Store each product query
await demand_vectors.upsert([{
    "id": query_id,
    "values": query_embedding,
    "metadata": {
        "product_requested": product_name,
        "timestamp": current_time,
        "resulted_in_purchase": False
    }
}])

# Analyze trends weekly
trending = await demand_vectors.query(
    vector=category_embedding,
    top_k=1000,
    filter={"timestamp": {"$gte": last_week}}
)

Architecture

UVTR's architecture is straightforward:

Performance Impact

Response Speed

Fast vector retrieval ensures conversations feel natural and responsive. Multiple searches happen per interaction:

• Understanding customer intent (1 search)
• Finding relevant products (1-2 searches)
• Retrieving customer preferences (1 search)
• Identifying bundle opportunities (1 search)

With traditional databases, these sequential searches could introduce noticeable lag. Antarys' performance keeps the conversation flowing smoothly.

Cost Structure

Self-hosting Antarys eliminated recurring cloud database fees:

• No per-query pricing
• No data egress charges
• No scaling surprises
• Predictable infrastructure costs

Simplified Operations

One system handles both embedding generation and storage:

# Single workflow for new products
product_text = f"{product.name} {product.description} {product.category}"
embedding = generate_embedding(product_text)

# Store directly in Antarys
await vectors.upsert([{
    "id": product.id,
    "values": embedding,
    "metadata": product.to_dict()
}])

No separate vectorization service. No complex data pipelines. Just generate and store.

Results

Since implementing Antarys:

• +25% conversion rate from chat interactions
• +45% repeat purchases from returning customers
• +30% inventory turnover improvement
• Sub-second response times for product recommendations

Looking Forward

UVTR plans to expand their agent capabilities:

Voice Commerce: Add voice search using Antarys' multimodal support for audio embeddings

Visual Search: Let customers upload photos to find similar products using image embeddings

Multi-Merchant: Scale to multiple stores, each with isolated vector collections for data privacy

Technical Setup

Installation

Antarys runs with a single command:

# Download and run Antarys
./antarys --port=8080

Python Client

from antarys import Client

# Connect to Antarys
client = Client(host="http://localhost:8080")

# Create collections for different data types
await client.create_collection("products", dimensions=1536)
await client.create_collection("customers", dimensions=1536)
await client.create_collection("bundles", dimensions=1536)

# Get collection interface
vectors = client.vector_operations("products")

# Insert vectors
await vectors.upsert(vector_data)

# Search vectors
results = await vectors.query(
    vector=query_embedding,
    top_k=10,
    include_metadata=True
)

Node.js Integration

UVTR also uses the Node.js SDK for their real-time agent controllers:

import { createClient } from 'antarys';

const client = createClient('http://localhost:8080');
const vectors = client.vectorOperations('products');

// Fast product search
const results = await vectors.query({
    vector: queryEmbedding,
    topK: 10,
    includeMetadata: true
});

Why Vector Databases for AI Agents

Traditional keyword search doesn't work well for conversational AI because customers use natural language, not exact product names. Vector databases enable semantic understanding:

Customer says: "something pink and cute for my daughter's school"

Vector search understands:

• "pink" → pastel colors, light shades
• "cute" → playful designs, friendly patterns
• "daughter's school" → age-appropriate, educational context

Returns: Notebooks with unicorns, pastel planners, kawaii stationery sets

This semantic understanding is why UVTR chose a vector database as the foundation for their AI agents. Antarys made it practical to deploy and maintain.

Conclusion

UVTR Infortech Solutions found Antarys to be a good fit for building e-commerce AI agents that need:

• Fast vector retrieval for conversational experiences
• Self-hosting capabilities for data privacy
• Simple integration for embedding workflows
• Cost-effective operations at scale

For teams building AI agents that require vector storage for memory and personalization, Antarys provides the essential infrastructure without unnecessary complexity.

Learn more: Antarys Documentation | UVTR Infortech Solutions