We recently shared the story of how we organized Scalingo’s first fully remote hackathon, along with the challenges we faced and the lessons we learned. Now it’s time to dive into what really came out of it: the projects our teams built. We’re starting with the winner of our internal hackathon, the Scalingo Companion.

AI Hackathon: Meet the team

The idea behind the Scalingo Companion came from a challenge our users sometimes face: figuring out what’s causing unexpected application behavior. While our support team is always there to help troubleshoot issues, Pierre, Étienne, and Mathéo wondered whether there could be another way. Their answer was the Scalingo Companion, an AI-powered chatbot designed to help users diagnose and resolve problems with their applications. But before we dive into the project itself, let’s take a step back.

For the hackathon, participants were free to form teams however they liked. Étienne explained how theirs came together:

"Before the hackathon, I reached out to Pierre because we're on the same team, but we don't often work on the same topics. Then we asked Mathéo to join us because he's on a different team, so we basically never get to work together."

As we mentioned in our previous article, one of the main goals of the hackathon was to encourage collaboration between colleagues who don't usually cross paths in their day-to-day work. At Scalingo, Étienne is an R&D Engineer in the Infrastructure Services Team (IST), Pierre is a Senior Software Engineer in the same team, and Mathéo is an Infrastructure Engineer in the Infrastructure Engineering Team (IET).

For Étienne and Mathéo, this was their first hackathon experience, while Pierre had already taken part in similar events in the game development space, as well as the Hacking Industry Camp organized by Alsace Digitale to tackle industrial challenges. The team was also stepping into unfamiliar technical territory: artificial intelligence, and more specifically Retrieval-Augmented Generation (RAG) and the Model Context Protocol (MCP).

Understanding RAG & MCP before building

Before they could start building, the team first had to understand the technology they wanted to work with. While they already used AI tools in their daily work, none of them had explored everything these technologies could do. That learning opportunity was one of the reasons they signed up for the hackathon in the first place.

"The first challenge was understanding the topic of AI itself. That's exactly why the three of us wanted to take part."

They therefore dedicated the first half-day of the hackathon to research. Understanding the ins and outs of MCP and RAG—two increasingly important building blocks of modern AI systems—was essential before they could decide what they wanted to build.

Once they had spent some time reading documentation and experimenting with the concepts, they felt confident enough to start developing the Scalingo Companion.

An architecture built around two MCP servers and a RAG

To build the Scalingo Companion, the team developed two MCP servers, a RAG, and an application through which users could interact with the assistant.

The RAG serves as the project's knowledge base, integrating both Scalingo's documentation and internal developer documentation. The team vectorized the documentation paragraph by paragraph before indexing it in OpenSearch®.

As for the two MCP servers, one is responsible for interacting with the Scalingo API, while the other acts as a bridge to the knowledge base.

To build the project, the team relied on several technologies. They used Go and Python as programming languages, while OpenSearch® was chosen as the database for the RAG component, with everything hosted on Scalingo.

OpenSearch® proved to be the ideal tool for the project. Within just a few minutes, the team had ingested the documentation and was able to perform vector searches. Its ease of use allowed them to spend more time developing the rest of the project.

An assistant dedicated to your application

The idea behind the project was simple: to create a chatbot capable of understanding the context of an application deployed on Scalingo and helping identify issues as well as potential improvements. To take things one step further and allow certain issues to be resolved directly, the Scalingo Companion was also designed to perform scaling operations on the application.

The application takes the form of a traditional chatbot that users can interact with by asking questions. When a user submits a request, it is sent to a large language model (LLM), which can query both the Scalingo MCP and the Knowledge Base MCP. The Scalingo Companion can use the Knowledge Base MCP to find answers in the documentation stored in the OpenSearch database. It can also go further by using the Scalingo MCP to retrieve information about the application—such as metrics, logs, memory issues, and resource consumption—or act directly on the application through the Scalingo API.

This allows the assistant to provide personalized responses based on data from the user's own application, rather than generic information. The team demonstrated this capability during their final presentation.

To showcase the project, they created an application deliberately filled with issues, causing excessive memory usage and generating numerous errors. They then asked the Scalingo Companion to diagnose the problem. After analysing the application, it was able to correlate an incoming request with a sudden increase in memory usage. It identified the specific HTTP endpoint responsible for the memory leak and suggested scaling the application up to a larger container size to keep it online while the underlying issue could be addressed.

The scaling operation is performed directly from within the assistant, which confirms once the operation has been completed. To further validate the Companion's diagnosis, the team opened the application's dashboard and showed that the application logs matched those reported by the assistant.

The team then pushed the project even further by asking the Scalingo Companion to analyse the application's source code, which was provided directly to it, and identify anything that appeared abnormal. Although the assistant had not specifically been designed for this type of task, it handled it remarkably well, highlighting suspicious variables and parameters as well as excessive memory allocations.

Looking back on the project

For Étienne, Pierre, and Mathéo, the hackathon was a very positive experience:

"We're happy we had the opportunity to work together and learn about a field we didn't know at all. It was enjoyable and motivating to spend a few days away from our usual projects, working with different people."

While the development process wasn't without its challenges—they notably had to switch LLM providers after discovering that their initial choice didn't support MCP servers—the team was ultimately pleased with the outcome of the project:

"We're happy that we were able to deliver a working project by the end. We managed to do everything we set out to do, and we didn't have to make too many compromises."

Although they have no plans to continue working on or further refining the project, they appreciated the opportunity to explore a topic they hadn't yet had the chance to work with in their day-to-day roles.

Build and host your own AI projects on Scalingo

If you're looking to build an AI project and host it on Scalingo, we have plenty of tutorials and resources to help you get started:

• Building a RAG with OpenSearch® (article)

• Building a Recommendation Engine with pgvector (article)

• Build your own RAG in 12 minutes with OpenSearch® and Scalingo (video)

Ready to get started? Sign up today and enjoy 30 days free, or get in touch with our team to learn more.