OpenSearchCon India 2026

Bakerʼs Basket
Butter Croissant
(Contains Wheat, Milk)

Blueberry muffins
(Contains Wheat, Milk, Soy)

Strawberry Danish
(Contains Wheat, Milk)

Juices
Watermelon Juice (VE)
Banana Milkshake (GF)
(Contains Milk)

Fruits (VE, GF)
Watermelon, pineapple, papaya, dragon fruit

Yoghurt (GF)
Strawberry yoghurt, Passion fruit yoghurt
(Contains Milk)

From the Hot Kitchen
Medu vada with coconut and tomato chutney (VE)
(Contains Mustard)

Drumstick and lentil curry ~ sambhar (VE, GF)
(Contains Mustard)

Paneer paratha
North Indian stuffed flat bread with mildly spiced paneer, griddle fried and served with curd and pickle
(Contains Wheat, Milk)

Hash brown patties with ketchup
(Contains Wheat)

Butter & Fruit Preserve
(Contains Milk)

Moong dal halwa (GF)
(Contains Milk, Nuts (Pistachio, Cashew, Almond))

OpenSearch Dashboards plugins are often used to add individual features, but how far can the plugin model go? In this talk we share how we took the dashboards-observability plugin skeleton and evolved it into a full observability platform supporting tracing, RUM, profiling, synthetics, model observability, alerting, AI-powered RCA, and pipeline monitors — all within a single plugin.

We’ll walk through the architectural patterns behind this evolution, including domain-based state management, lazy-loaded modules, custom clients, and config-driven feature toggling. We’ll also discuss integrating rich visualizations such as trace timelines, dependency graphs, and flamegraphs into the Dashboards plugin shell, extending the query grammar for syntax highlighting, and organizing server routes with a middleware layer to proxy multiple backends.

Attendees will leave with practical patterns for building complex applications on OpenSearch Dashboards and a deeper understanding of how the plugin architecture can evolve from simple extensions into an extensible application platform for full solutions.

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.

We want to show that a fully open-source log management stack (OpenSearch + Data Prepper + OpenSearch Dashboards) can run at ~400TB-per-day scale with few extensions. We hope to get feedback from others running ODD at scale, exchange patterns for plugin development and operations, and encourage more teams to adopt and contribute to the ODD ecosystem.

It details a massive ODD deployment utilizing ~1,500 OpenSearch nodes to handle 6 GB/s data volume. Key takeaways are Extensibility (Pluggable data prepper), Cost Efficiency (S3 remote snapshots as cold storage), and Open Source Commitment (using official OpenSearch ecosystem). Attendees will grasp ODD scaling and extension potential.

It showcases how the ODD stack manages high-throughput pipelines and multi-datasource UIs, reducing reliance on proprietary vendors. It presents extension patterns using Data Prepper and OSD plugins for custom observability (RUM, synthetics, traces, profiles, alerts). This promotes open source observability through a reusable reference architecture and operational patterns, encouraging OpenSearch ecosystem adoption and contribution.

Your users search for “comfortable shoes for standing all day” and get shoe polish. 30% of searches return zero results even when products exist. This is keyword hell, costing you customers daily.

This session reveals how we transformed Adobe Commerce search using OpenSearch’s vector search capabilities. Learn the complete technical journey, including text embeddings, k-NN similarity, and hybrid search that combines keyword precision with semantic understanding.

We’ll cover the architecture, including vector indexing with FAISS and Lucene, ingest pipelines for automatic embedding generation, and query-time optimization.

Honest challenges included computational costs, embedding model selection through sentence-transformers comparisons, dimension tradeoffs between 384 and 768, cold start problems, and explainability to stakeholders.

You’ll get actionable knowledge such as exact OpenSearch configurations, PPL queries for semantic search, hybrid scoring strategies, open-source model recommendations, and cost optimization for Indian startups, with $30 per month infrastructure compared to $200 or more for managed vector databases.

Modern AI assistants and knowledge systems rely heavily on high-quality retrieval to provide accurate and contextual responses. While large language models generate answers, it is the underlying search infrastructure that retrieves relevant information and grounds AI outputs in real data.
In this session, we explore how modern AI applications use search infrastructure as the backbone of their intelligence layer. We will examine the architectural patterns that combine OpenSearch with embeddings, vector search, and hybrid retrieval to power knowledge assistants, enterprise search systems, and AI copilots.
The talk will walk through the evolution of search infrastructurfrom traditional keyword-based search to semantic retrieval and retrieval-augmented generation (RAG). We will discuss key design considerations such as document chunking strategies, embedding pipelines, hybrid ranking approaches, and relevance tuning required to build reliable AI systems.

Attendees will also learn how it enables scalable retrieval pipelines that support real-time indexing, vector similarity search, and metadata filtering—capabilities that are essential for powering AI-driven knowledge systems at scale.

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.

Description
Join us to explore the latest performance improvements in OpenSearch, highlighting the integration of Lucene’s bulk collection API and enhancements to the gRPC Search API. This session will dive into how bulk collection optimizes aggregation execution, delivering measurable gains across analytical workloads by batching operations and reducing computational overhead. We will also cover the expanded features of the gRPC Search API in OpenSearch 3.4, which now supports new query types, improved bulk requests, and multiple document formats. To make these concepts clear and practical, we will showcase live demos illustrating performance boosts in aggregation workloads and expanded query handling through gRPC. Attendees will gain a clear understanding of how these advancements significantly enhance efficiency and broaden query capabilities in real‑world use cases. Key takeaways include understanding Lucene’s bulk collection benefits, learning about new gRPC query types, and discovering improvements in bulk request handling and document format support.

Fruits (VE, GF)
Watermelon, grapes, kiwi, dragon fruit, papaya

Sabudana kichidi with mint chutney (VE, GF)

Venn Pongal with curry leaves and vegetables, savoury rice porridge (GF)
(Contains Milk (Cashew))

Aloo bonda fritters with chutney (VE)
(Contains Mustard)

Strawberry Danish
(Contains Milk, Wheat)

Banana Tea Cake
(Contains Milk, Wheat)

Modern Kubernetes platforms generate massive volumes of logs, yet most teams still rely on keyword searches and dashboards to debug production issues. This slows down incident response and hides valuable operational knowledge inside unstructured data.

In this talk, we’ll demonstrate how to build an AI-assisted observability pipeline using Fluent Bit, OpenSearch, and Retrieval-Augmented Generation (RAG) to transform raw logs into queryable, contextual insights. We’ll walk through a cloud-native architecture that streams logs from Kubernetes workloads, enriches and indexes them in OpenSearch, and uses RAG to answer operational questions in real time.

Attendees will see how this approach helps SREs and platform teams reduce MTTR, improve root-cause analysis, and move from reactive troubleshooting to proactive observability—using open-source, CNCF-aligned tooling.

This session explores how to build a comprehensive code security platform using OpenSearch's powerful analytics capabilities enhanced with AI agentic workflows. I'll demonstrate how to implement a system that continuously monitors, analyzes, and remediates security vulnerabilities across your codebase. Attendees will learn how to leverage OpenSearch for storing and analyzing code security telemetry, while implementing agentic AI workflows that autonomously identify patterns, prioritize vulnerabilities, and suggest remediation strategies.

Key topics include:
• Configuring OpenSearch for efficient storage and querying of code security data
• Implementing vector search to identify similar vulnerability patterns across repositories
• Building AI agents that autonomously scan, analyze, and classify security issues
• Creating agentic workflows that coordinate specialized security analysis tasks
• Developing automated remediation suggestions using LLM-powered agents
• Visualizing security insights through OpenSearch Dashboards

This session provides a practical blueprint for security teams looking to scale their code security.

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 AI agents generate massive operational telemetry: prompts, tool executions, policy decisions, and execution outcomes. Without strong indexing and analytics, debugging and governing these systems becomes extremely difficult.

This talk presents a practical architecture for operating autonomous systems at scale using OpenSearch as the observability and decision-intelligence backbone.

We explore an AgentOps architecture where OpenSearch indexes agent traces, policy decisions, incident telemetry, and execution evidence to enable real-time debugging, safety enforcement, and auditability.

Topics covered include building searchable “decision traces” for AI agents, designing observability pipelines for autonomous systems, using OpenSearch for policy audits and incident forensics, and scaling analytics for multi-agent operations.

Attendees will learn concrete patterns for using search and analytics infrastructure to make AI-driven systems observable, debuggable, and governable in production.

Large Language Models (LLMs) power some of today’s most advanced AI applications-from chatbots to intelligent copilots-yet monitoring their complex behavior remains a major challenge. This session demonstrates how OpenTelemetry’s auto-instrumentation capabilities, combined with OpenSearch’s powerful analytics, provide end-to-end observability for LLM-based systems.

You’ll learn how to automatically collect rich telemetry data-traces, metrics, and logs-from your LLM applications with minimal manual effort using OpenTelemetry and libraries like OpenLIT. See how this data flows into OpenSearch, enabling real-time analysis, anomaly detection, and performance monitoring tailored specifically for AI workloads.

By the end of this talk, you will get the tools and best practices to build scalable, AI-driven observability pipelines that keep your LLM applications reliable and performant.

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.

Salads
‘Kerala style’ tempered chickpea salad, grated coconut (VE)
(Contains Mustard)

Salad of griddled American corn, fresh scallions, cherry tomatoes, olive tapenade (VE)

Yam mamuang, raw mango salad with chiffonade vegetables, coriander
(Contains Sesame)

Sev Papdi chaat
(Contains Wheat)

Main Course
Roast garlic & paprika-spiced grouper, broccoli amandine, citrus burnt butter essence (NV)
(Contains Fish, Milk, Mustard, Nut (Almond))

Eggplant, okra, peppers and young corn in hoisin chili sauce (VE)
(Contains Celery, Soy, Sesame, Wheat)

Mee goreng rice noodles with vegetables tossed in wok (VE, GF)
(Contains Celery)

Dhaniya murgh (NV)
Chicken morsels with fresh coriander leaves, cracked black pepper and fresh green chillies
(Contains Milk, Nut (Cashew))

Subz Panchmela (VE, GF)
Vegetables tossed with coriander-flavoured spicy masala and curry
(Contains Milk)

Nivik, stew of chickpeas, spinach and chard, tomato puree
(Contains Milk)

Kaddu ka dalcha (VE, GF)
Yellow lentils and red pumpkin tempered with cumin, garlic and chilli
(Contains Mustard)

Thai yellow curry with vegetables and Jasmine rice (VE)
(Contains Soy, Wheat, Celery, Sulphite)

Chadhanchi pulao (VE, GF)
Basmati rice and kala chana cooked with Indian spices

Steamed Rice(VE, GF)

Accompaniments
Assorted Indian breads
(Contains Wheat, Milk)

Kachumbar raita (GF)
(Contains Milk)

Papad, Pickle and chutney (Contains Mustard, Milk) GLUTEN FREE

Desserts
Khajur barfi, Indian sweet cakes made with dates, silver warq
(Contains Milk, Nuts (Pistachio, Cashew, Almond))

Orange & dark chocolate pudding
(Contains Milk, Wheat, Soy)

Thai black rice and sweetened coconut milk
(Contains Sulphite)