DEV Community: Jonathan VUILLEMIN

Build robust and observable MCP servers to supercharge your LLMs with Go

Jonathan VUILLEMIN — Fri, 09 May 2025 05:10:52 +0000

MCP opens a lot of new capabilities for LLMs by offering them the possibility to trigger backend code. And Go is a very solid choice to create MCP servers, due to its resilience and scalability.

Yokai released its new MCP server module: you can easily create MCP tools, resources and prompts, while the framework handles the SSE/stdio exposition, with built-in o11y (automatic logs, traces and metrics).

Yokai comes with a MCP server demo application to see it in action, you can try it with your favorite MCP compatible AI application (Cursor, Claude desktop, ...) or simply via the provided MCP inspector.

If you want to know more about this, you can go to the Yokai MCP server module documentation where you'll find getting started instructions, technical documentation and the demo.

Some Go demo applications with Yokai

Jonathan VUILLEMIN — Mon, 28 Oct 2024 11:06:19 +0000

We're actively working on Yokai, a simple Go framework coming with an opinionated but modular list of dependencies (like echo, viper, zerolog, grpc, ...), depending of the type of application you'd like to build.

It's strongly focused on observability, providing logs, traces and metrics instrumentation for all its components, and on testability.

Today we share the showroom repository with 3 demo applications, to help understanding how this works and what it brings:

a gRPC demo with both unary and streaming RPCs
an HTTP demo with a rest crud against a MySQL
a worker demo subscribing to pub/sub

All 3 come with a docker compose stack to easily play with them (with air live reload), and to see the o11y signals in action (Jaeger included).

Feel free to check this out, and to reach if this is of interest for you.

It's under MIT license.

How we're trying to make our PHP devs efficient also with Golang

Jonathan VUILLEMIN — Wed, 26 Jun 2024 05:14:26 +0000

For the quick background presentation (👋), I'm a backend / platform engineer, I work in a company with a monolithic PHP (Laravel) main application.

We're in the journey to split it in smaller services or to move some recurring logic as sidecars. And for this, we noticed that the best choice was not always PHP, but sometimes Golang was more appropriate for our use cases.

The main problems we faced:

Since our company devs are mostly all PHP devs, we needed a way to ramp them up on Golang.
We also needed to avoid to have too much differences in the Go code produced by different teams, and their code to have the same conventions when it comes to our platform compatibility (same way to log, same way to handle env vars / config, same way to handle traces / metrics, etc...)

We (platform team) worked and iterated on some Go app skeletons, pre-configuring some libs, applying some shared conventions, and with time it became consequent enough that we considered to open source it.

So I present to you Yokai 🚀
It's a simple, modular and observable Go framework for backend applications.

It comes with a bunch of features (that we needed on our own production projects): HTTP server, gRPC server, workers, database instrumentation, etc ... while always keeping a strong focus on observability (logs, traces, metrics). Everything is in the docs if you want to know more about it.

So, if you're coming from a PHP framework background (like Symfony, Laravel) and want to start exploring Go, this offers you something close to what you're used to: dependency injection, observability, easy ways to test, etc ... but for Go :)

Feel free to take a look (docs & demo apps), to comment, and happy coding 👍

Check Yokai on GitHub.

Yokai - new SQL module

Jonathan VUILLEMIN — Mon, 13 May 2024 15:52:35 +0000

Yokai, until today, came only with an ORM module (based on GORM), cause it has been the fastest way to provide DB access while having a good observability (logs, traces) by using GORM hooks.

We've been working on and just released an SQL module:

based on database/sql
with out of the box observability (SQL logs and traces)
with a migrations mechanism (based on Goose)
with a seeding mechanism (for testing)
with a hooking mechanism (to extend logic around SQL operations)

Since it's decorating database/sql, you can use tools like SQLC with it.

The documentation is here: https://ankorstore.github.io/yokai/modules/fxsql/

Hoping this may help 👍

Yokai - a simple, modular and observable Go framework for backend applications.

Jonathan VUILLEMIN — Sat, 20 Apr 2024 22:33:03 +0000

Building backend applications with Go is amazing.

But to build production-grade applications, you need to put in place a bunch of efforts and boilerplate code, introducing complexity not even related to the logic of your application (like dependencies wiring, configuration management, observability instrumentation, etc.).

To solve this, Yokai was created with the following goals in mind:

Simple: it is easy to use, configure and test, enabling you to iterate fast and deliver quickly maintainable applications.
Modular: it can be extended with the available Yokai modules, or with your own, to build evolvable applications.
Observable: it comes with built-in logging, tracing and metrics instrumentation, to build reliable applications.

In other words, Yokai lets you focus on your application logic, while taking care of the rest.

Don't hesitate to visit the Yokai repository to find the technical documentation, starting guides and demo applications!