Multiple LLMs in One Telegram Chat: Combining Groq and Google AI

A developer from Habr built a playful Telegram bot in which several LLMs work in a single chat at the same time, each pretending to be a corporate employee. The idea started as a joke for a gathering with friends, but it quickly turned into an interesting technical case on integrating multiple models using only free APIs.

How to cram different models into one chat

The original concept was simple and fun: create a chat where several neural networks "work" at once, believing they are real corporate employees. Each model gets its own role and backstory, and the user can switch between them at any moment, asking the same question to different LLMs. This is not just parallel testing: it is an attempt to make the networks learn and stick to their personas within a single dialogue.

Where to get an API without paying

The first practical task was mundane but critical: find a stack of tools with decent free limits. The developer researched the options and settled on three main ones:

• Groq — for Llama, with record inference speed
• Google AI Studio — for Gemma and Gemini, with decent free tiers
• Plain HTTP requests to connect the components

At the initial stage the code turned out relatively simple: pick a model based on the user's command, route the request to the right API, and insert the reply into the shared chat context. There was minimal logic; the difficulty lay in managing state and context for each model at the same time.

When a model forgets who it is

A funny but stubborn problem soon appeared: when switching between models, one of them would not give up its turn and simply pretended to be another, completely losing its own identity. The developer fixed most of the problem with a carefully designed system prompt that explicitly "reminds" each model who it is supposed to be in this dialogue.

However, the glitch could not be eliminated completely. The models still sometimes get confused about their roles, especially in long multi-turn dialogues. According to the developer, this is a fundamental limitation of LLMs themselves: they generate text well and imitate style, but often lose the context of their identity when attention shifts.

What this means

The case shows that a multi-model interface can be built even on free APIs, provided you put work into the architecture and prompting. Fully reliable management of context and identity is not yet achievable, but for experiments, prototyping and learning, it is more than enough.