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.