OpenSearchCon India 2026

We migrated ~1,500 OpenSearch nodes across 7 clusters in 5 regions from Intel to AWS Graviton 4, upgrading from OpenSearch 2.13 to 3.4 and JVM 17 to 21 along the way. We saw 2x indexing throughput and ~30% cost savings. We want to share the benchmarking data, compare migration strategies (inline upgrade, snapshot-restore, and why CCS didn't work), and push more teams toward Graviton.

A practical guide to evaluating and executing a Graviton migration at scale — covering instance type benchmarking (i4i/i4g/i7i/i8g), migration strategy trade-offs (inline upgrade is fast but risky, snapshot-restore is safe but needs parallel infrastructure, CCS doesn't work across major versions), production validation steps, and the real performance and cost numbers from 1,500 nodes in production.

Large-scale Graviton migration data for OpenSearch is scarce. By sharing production numbers from 7 clusters across 5 regions — including what didn't work — we want to de-risk Graviton adoption for the community. The 2x throughput and 30% cost reduction we're seeing should motivate more teams to make the move, and our migration playbook gives them a concrete path to follow.

When a search cluster slows down, the first question is: what's running right now? Until recently, OpenSearch had no answer. Top N Queries shows what was slow after the fact, but by then the root cause may have disappeared.

In this talk, I'll walk through Live Queries, a feature I built for the Query Insights plugin that gives operators real-time visibility into every in-flight and recently completed search request across the cluster.

I'll cover:
- Why "what's running now?" was unanswerable and how operators struggled with manual correlation of node stats and thread dumps
- The end-to-end architecture: REST handler → transport fan-out → TaskGroup collection → LiveQueryRecord assembly with per-shard task details (CPU, memory, running time)
- The lock-free Finished Queries Cache: ConcurrentLinkedDeque with CAS-based lazy activation achieving zero hot-path overhead
- Correlating live and finished queries via nodeId:taskId keys linked to Top N records
- Evolution from OpenSearch 3.0 (inflight API) through 3.1 (cancellation tracking) to 3.3 (WLM group filtering)
- Live demo and future roadmap: comprehensive latency breakdown (RFC #20693) and OpenTelemetry integration

Running OpenSearch in production at scale is very different from what tutorials or books show. When you manage many clusters, you start seeing issues you didn’t know existed, like shard and disk imbalance, uneven traffic distribution, and unstable cluster states. These problems can degrade search performance and even cause incidents.

In this session, we will share real challenges we faced while operating large OpenSearch clusters and the practical solutions we used to stabilize them. We will explore how shard distribution can silently create problems, why some nodes end up using much more disk than others, and how clusters behave under heavy indexing and query load.

This talk focuses on the operational side of running OpenSearch in production. We’ll discuss strategies for better shard allocation, preventing disk imbalance, controlling indexing pressure, and keeping clusters stable under load.

Attendees will leave with practical techniques they can apply to run OpenSearch clusters reliably at large scale and improve stability and performance in real-world environments.

Traditional keyword search is no longer sufficient for modern SRE workflows because infrastructure error messages are often too generic to be actionable. This session explores a technical shift in observability: moving from standard indexing to high-dimensional vector embeddings for terminal traces and post-mortems using OpenSearch.

We will deep-dive into a privacy-first AI architecture, demonstrating how to integrate OpenSearch’s vector engine with local, private models (such as Llama) to ensure sensitive production logs never leave your VPC.

You will learn the mechanics of building a Retrieval-Augmented Generation (RAG) pipeline designed specifically for infrastructure telemetry. The session includes a live demo where a local agent "recalls" the exact historical fix for a messy, real-time stack trace, providing a direct link to the relevant PR or configuration change from the past.

Ever wondered what really happens after you hit “Search”? This talk takes you on a fast, funny, and surprisingly eye‑opening journey through the secret life of a query inside OpenSearch. We’ll follow it as it squeezes through analyzers, hops across shards, meets vectors, dodges caches, and races toward the perfect answer, all in milliseconds. Along the way, you’ll discover why some queries feel instant, why others take a coffee break, and how tiny architectural choices can totally change the search experience. Whether you're new to OpenSearch or a seasoned engineer, you’ll walk away with a delightful mental model of how search really works and how to make it faster, smarter, and a whole lot more magical.

Most teams have a dirty secret: they're running Elasticsearch versions they can't afford to upgrade and can't afford to stay on. The migration feels impossible due to data loss risk, query regression, extended downtime, and no rollback. So they wait. And wait. This talk ends the waiting. We walk through the OpenSearch Migration Assistant end-to-end: a fully open-source toolkit that handles metadata migration, historical backfill via Reindex-from-Snapshot, and live traffic capture + replay so your users never feel the move. We'll cover all three migration scenarios, the trickiest mapping transformation pitfalls (dense_vector → knn_vector, anyone?), and live comparative response diffing before the final cutover. Migrate smarter, not harder.

Search finds. Discovery reveals. At Shutterstock, serving one of the world's largest licensed creative content libraries at 2000+ requests per second, the difference is everything.
Generative Discovery changes the contract entirely. It treats every interaction as a signal of intent, builds context across modalities, and applies cognition to surface what users did not know to ask for.
This talk introduces a production architecture built around three principles:
Intent: multimodal signals including text, image, and behavioral context unified into rich intent representations driving OpenSearch k-NN and hybrid retrieval.
Context: session aware, editorially grounded RAG pipelines using OpenSearch as a dynamic retrieval backbone at scale.
Cognition: generative agents that think, orchestrate multi step retrieval, and resolve ambiguous intent, treating OpenSearch as an intelligent reasoning substrate rather than a passive index.
You will learn from real production decisions, evolving thinking, and lessons still being learned on the frontier of Generative Discovery.

As data volumes and AI-driven workloads grow, operating large-scale search and observability platforms comes with rising infrastructure costs and energy consumption. GreenOps, an approach that combines operational efficiency, cost management, and environmental responsibility, is emerging as a practical way for engineering teams to run cloud systems more sustainably.

This session explores how GreenOps principles apply when operating OpenSearch for search and observability workloads. We will examine strategies to optimise cluster sizing, storage, and indexing patterns to reduce unnecessary compute usage while maintaining performance and reliability. The talk will also cover ways teams can use observability data to identify inefficient workloads, control infrastructure costs, and reduce the overall carbon footprint of their systems.

Attendees will gain practical insights into running more efficient OpenSearch deployments while aligning operational decisions with broader sustainability and cost-optimization goals.

This OpenSearchCon talk covers setting up and enabling agents for private environments, from initial configuration to solving common challenges. We faced numerous issues connecting OpenSearch Agents to our private LLM. Through trial and error, we succeeded by setting certificates in the JDK keystore, enabling private MCPs, and more. We identified gaps in OpenSearch and addressed them via pull requests, including creating a blueprint for Ollama and adding an option to disable certificate validation for LLM connectors.

In this session, we'll share our journey, discuss use cases, and provide a live demo using the latest OpenSearch features, including the brand new Agentic UI. You'll leave with practical insights to configure and optimize OpenSearch Agents for private LLMs, solutions to common integration issues, and the knowledge to deploy customized, fully private search experiences.

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.

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.