What does it feel like to attend OpenSearchCon for the very first time?
When I walked in, I was nervous. I’ve been working in infrastructure and observability, but this was my first real step into the OpenSearch world after months of spinning up clusters and using it. Would I sound clueless in a crowd of OpenSearch experts? How much would I learn and contribute? I was excited to find out.
Connecting the dots: Graphs and vectors
What I loved about OpenSearchCon was its range—from introductory sessions to deep dives. The first talk I walked into was by Sam Herman of DataStax, who presented the story behind JVector.
I’d always understood that vectors are how we represent data, and that vector search relies on graphs, but I hadn’t connected the dots that graph construction itself is optimized so vectors and their neighbors stay close together. During this phase, connected nodes are arranged so that if one vector is accessed, its neighbors are nearby—read sequentially from disk. This minimizes random I/O and makes searches faster. That insight—that the structure of the graph directly shapes performance, both for search and for indexing—crystallized something fundamental for me. It was the first time I saw how OpenSearch vector search design weaves together data representation, retrieval logic, and system-level efficiency.
Snapshots: Inspiration for my daily work
The snapshot talk resonated deeply because it connects directly to my daily work—setting up repositories, verifying cross-cluster backups, tuning performance, and planning for long-term durability.
It broke down why snapshots are expensive: egress, data priority, inefficiencies at scale, and how newer designs like Snapshot v2 change the game. Hearing about timestamp-based referencing and coordination-free mechanisms made me realize how much more there is to explore—shallow snapshots for reduced storage, searchable snapshots for faster recovery, and APIs I haven’t even yet used.
It gave me a sense of direction: once my current setup is complete, these are the paths to explore further.
Operators: Turning architecture into automation
The Operator talks were another highlight. A few years ago, customers passed on OpenSearch because there was no Operator. Now we not only have one, but we also have a growing set of mature deployment architectures. I use ArgoCD, the OpenSearch Operator, and Prometheus/VictoriaMetrics daily to keep clusters healthy and consistent.
Seeing Eliatra’s workflow wiring the Operator with ArgoCD, Alertmanager, and Grafana showed how everything can flow together into one automatable system. Even if we don’t adopt every approach, these talks reminded me that sharing everyday insights—even small ones—can spark new ideas. That’s the energy that keeps a technical community alive.
Other highlights included:
- The new Prometheus exporter plugin for OpenSearch 3.0, making 3.0 bulletproof with the Prometheus-based monitoring.
- Talks on tracing, which make bottlenecks visible at the service level in Kubernetes.
- Best practices for building closed-loop observability.
Scaling vector workloads: Math as a bridge to understanding
One of the most fascinating (and admittedly challenging) sessions for me was on scaling vector workloads. Jon Handler peeled back every layer, from indexing to vector metadata, showing how math ties it all together. It really did feel like being in a calculus class—but in the best way.
The simple formula for per-document index size—vector dimensions × bytes per dimension × 2—helped me understand why we often store two copies of vector data: one for the ANN structure, and one for the source.
The talk then introduced derived source, a clever way to halve that footprint by reconstructing the source from the index when needed. It’s a small mathematical insight with a big impact—proof that precision and scalability are inseparable.
That single equation stitched so many loose ends together for me. For someone new to OpenSearch, it’s easy to learn things conceptually without grasping what’s actually happening underneath. This talk gave me that missing bridge—the behind-the-scenes look into how components and math make search systems work. It reminded me of why math and systems design are two sides of the same coin—both rooted in logic, both essential for innovation.
Agentic RAG and the beauty of tools that think
I couldn’t stop talking about how much I like retrieval-augmented generation (RAG). I first learned about it at another conference, long before I touched OpenSearch, and I was amazed at how it could revolutionize the large language model (LLM) interpretation of huge documents like a Sherlock Holmes novel or a Shakespeare play.
Then came Pietro Mele and Lucian Precup of Adelean’s talk, which blew me away: Agentic RAG. Traditional RAG lets LLMs retrieve and summarize documents. Agentic RAG, though, gives them agency—the tools and autonomy to decide what they need in order to improve themselves. Instead of just making the LLM a librarian who fetches documents, agentic RAG turns it into a building manager with tools—able to decide whether it needs a wrench or a hammer and to use them with confidence.
The new Model Context Protocol (MCP) interface, now interoperable with OpenSearch 3.0, reduces the need to juggle multiple interfaces and brings everything through one clean entry point. What impressed me most was the spirit of it—pairing conceptual clarity with execution by explaining how to register agents, architect the flow, and translate decisions into action.
I admired that balance between vision and practicality—qualities seen in many OpenSearchCon presentations.
Belonging in the hive: Where learning meets accessibility
OpenSearchCon was also impressively organized. Every talk, recording, slide, and speaker profile was available online, perfectly tagged and searchable.
The level of accessibility provided by a structured conference website turned the conference into a continuous learning space and not just a three-day event. Instead of getting lost, you can dive back into the content any time, rewatch talks, and chew on the concepts at your own pace.
And then there was the community. Hallway conversations were as valuable as the talks, full of shared ideas and new connections. Lunch was elegantly plated, and I picked up more swag than I should probably admit.
This was my first glimpse of OpenSearch as a living, breathing ecosystem—like eating honey for years and finally seeing how the hive works from the inside. I carried back not just new knowledge but also a deeper sense of belonging to this ecosystem and the people building it.
References
Scaling: Capacity Planning, and Scaling/Optimization for Vector Workloads – Jon Handler, Amazon Web Services
Agentic RAG: Building Next-gen Search With OpenSearch – Pietro Mele & Lucian Precup, Adelean
Tracing: Kubernetes Under the Magnifying Glass: Observability With OpenSearch – Arnab Chatterjee
