OpenSearchCon India 2026

Operating OpenSearch at large scale with multi-tenant, hierarchical data introduces serious sharding challenges. Queries can fan out to hundreds of shards, hot shards reduce throughput, and rebalancing large clusters becomes operationally difficult.

This session introduces HSplit, a production-proven intelligent sharding system designed for OpenSearch deployments managing millions of folders, billions of documents, and petabytes of data. HSplit analyzes hierarchical structure, access-control patterns, and usage behavior to automatically determine optimal partition boundaries.

We’ll show how HSplit reduced per-query shard fanout from 200+ shards to single digits (95% reduction) and improved P95 latency from 2–5 seconds to 100–300 ms (10× faster) while maintaining stable performance as data grows. The session covers access-aware partitioning, composite scoring strategies, constraint-driven splitting, and stateless routing that supports thousands of queries per second.

Attendees will gain practical strategies, architectural patterns, and decision frameworks for designing efficient sharding strategies for large-scale, multi-tenant OpenSearch environments.

Open source observability has moved beyond dashboards and “logs vs metrics vs traces.” Today, teams are converging on unified telemetry pipelines that support reliability and security use cases—without locking into a single tool. In this session, we’ll map the evolving landscape of open source tools for analytics, observability, and security, and show how modern stacks are built around standardized instrumentation (OpenTelemetry), scalable backends (Prometheus ecosystem, Grafana/Loki/Tempo, OpenSearch/Elastic alternatives), and policy-driven operations in Kubernetes.

We’ll cover the biggest shifts shaping the ecosystem: tool sprawl → composable platforms, manual triage → automated correlation, and rising data costs → smarter sampling and routing. You’ll leave with a practical reference architecture for collecting, enriching, routing, storing, and querying telemetry—plus guidance on selecting components based on scale, compliance, and budget.

Building billion-scale vector indexes on OpenSearch has traditionally meant days of CPU-intensive processing. OpenSearch 3.0 changes this with GPU-accelerated index building using CAGRA and auto-optimize for automated hyperparameter tuning.

This session shares hands-on lessons building billion-scale vector indexes on OpenSearch 3.0. We cover the end-to-end journey: selecting embedding models, choosing between HNSW and IVF algorithms, leveraging GPU-accelerated builds for up to 9x faster indexing, and using auto-optimize to balance recall, latency, and cost without manual tuning of ef_construction and M parameters.

We dive into production realities including quantization strategies (scalar, product, binary) to reduce memory footprint, disk-optimized vector search for cost-sensitive workloads, and hybrid search combining vector similarity with BM25 keyword matching. We cover operational patterns for zero-downtime index rebuilds and monitoring vector search performance.

Attendees leave with a decision framework for vector index configuration, benchmarks across deployment sizes, and guidance on when GPU acceleration pays off versus CPU-only approaches.

AI agents powered by LLMs such as Claude are inherently stateless and rely on external systems to maintain persistent memory. While these models can reason, plan, and call tools, they cannot retain knowledge across sessions on their own, forcing users to repeat information and limiting context-aware interactions.

In this session, we explore how to build context-aware AI agents with persistent memory using OpenSearch. Attendees will learn how OpenSearch’s agentic memory enables agents to store conversations, extract knowledge, learn user preferences, and retrieve relevant context over time.

Through practical examples, we demonstrate semantic knowledge extraction, preference learning, and session summarisation, showing how models like Claude can leverage stored context for personalised, intelligent responses. By the end, participants will understand how to design scalable memory architectures that transform stateless LLM agents into context-aware systems that continuously learn from interactions.

Modern observability tools mostly index log lines, metrics, and traces as isolated events. But production incidents rarely happen because of a single event. They happen because of patterns of behavior across services.

In this session, I’ll explore a different approach: indexing system execution paths instead of raw logs.

Rather than storing individual log lines, request traces are converted into behavioral documents that represent how a request actually moved through the system. This makes it possible to search for things like unusual request flows, repeated failure paths, or rare service interactions.

We’ll walk through:
=> Transforming distributed traces into searchable execution paths
=> Designing an index structure for behavioral search
=> Querying for patterns like repeated timeout paths or rare service flows
=> How OpenSearch scoring can highlight abnormal request behavior

A small demo will simulate a microservice environment and show how OpenSearch can surface failure patterns by searching system behavior instead of individual log lines.