Sometimes the tasks in projects look very simple.… Until you start making them.
We had a project with an already implemented search on OpenSearch. Everything was working: indexes, filters, custom query logic — even its own "mini-ORM" above the search, through which the frontend sent complex queries.
And at some point, a decision came.: "Let's just replace OpenSearch with TypeSense."
Spoiler alert: it's never "easy".
The most important limitation is that the frontend should not notice any changes.
In other words, the API remains the same, the query structure remains the same, and the search behavior remains the same. And inside there is a completely different engine.
I needed to take queries tailored for OpenSearch, transform them, send them to TypeSense and return the result in the same format. In fact, it's about writing a full—fledged adapter between two different worlds.
Waiting: "Well, there's a client to change and fix a couple of requests."
Reality:
The problem is that these aren't just different APIs—they're different search philosophies.
For example: OpenSearch has a flexible DSL that allows you to build queries of almost any complexity. TypeSense focuses on simplicity and speed, with a deliberately limited syntax. And simply "converting JSON" doesn't work — you need to rethink the query logic entirely.
In fact, query generation, filtering, aggregations and their analogues had to be redone in TypeSense, working with indexes and auxiliary utilities. And all this while maintaining a 1:1 behavior, without the right to regress, because the front should not have felt the difference.
Classic of the genre: the time for the task was greatly underestimated at the planning stage. And that's where the fun begins.
Without an AI assistant, I would not have completed this task on time. Seriously.
The AI in this case played several roles at once:
Moreover, you can ask "dumb" questions, ask to explain concepts, compare approaches and generate code — and he does not get tired, does not get annoyed and responds instantly.
I literally disassembled a piece of OpenSearch logic, asked how to implement it in TypeSense, received an adapter, tested it, found discrepancies, returned with clarified questions - and repeated. And so on dozens of times, iteration after iteration, until the behavior matched.
Important insight
Previously, the new technology meant: "we need a specialist with experience in this particular stack," but now the formula has changed: "we need time and well—formulated questions." AI greatly reduces the threshold of entry into an unfamiliar area.
If you spice it up with a good hint and clearly indicate who to beat, it really helps. And most importantly: there are already two of you.
1. Replacing the search engine is not replacing the client, it is replacing the architecture.
2. Different search engines are different philosophies, not just different syntax.
3. The most difficult thing is to keep the 1:1 behavior unchanged on the consumer side.
4. AI is not a toy, but a real working tool that is already changing the way we solve complex problems.
If you encounter a new technology, there is no need to panic and you do not need to urgently look for a "senior with 10 years of experience in this particular stack." It is enough to understand the basic principles, use AI as a partner, and methodically move iteration after iteration.
Yes, but it will require writing a full-fledged adapter between the two engines. The frontend will send requests in the usual format, and the adapter will transform them to the TypeSense syntax and return the response in the same structure.
