The announcement was made during the Franco-German summit “Summit on European Digital Sovereignty – Shaping Europe’s digital future. Together.” Both companies see this collaboration as a key lever to make artificial intelligence more accessible and truly sovereign in Europe.

They note that despite growing interest in AI, industrial adoption is still significantly hindered by computing costs. SpiNNcloud’s current systems already reduce certain costs by up to 17x. The next architecture, SpiNNext, is expected to push efficiency gains even further, with potential savings of up to 80x. A breakthrough that could reshape the dynamics of AI industrialization on the continent.

A Franco-German cooperation for a sovereign AI infrastructure

The two partners see their collaboration as a structuring component of a Franco-German  initiative dedicated to AI infrastructures. They emphasize that sustainable competition with global giants will only be possible by strengthening cooperation among European players. Their ambition goes beyond their own partnership: they aim to involve other innovative SMEs across the continent to form a network of expertise capable of delivering essential digital building blocks without external dependency.

Clever Cloud operates a European cloud platform for hosting, automation, databases, and orchestration. All technology is developed in-house and operated in Europe. The company employs around one hundred people and serves customers in more than 120 countries. 
SpiNNcloud, for its part, develops computing architectures inspired by the human brain, designed for high-performance computing and artificial intelligence applications. Its systems currently rely on the SpiNNaker2 architecture, while SpiNNext is already under development.

The cooperation has entered an operational phase. The first SpiNNcloud systems are being integrated into Clever Cloud’s infrastructure, and technical tests are underway. Two workstreams are being developed: leveraging the performance of the systems for intensive computing, and a shared “Token as a Service” layer, enabling companies to use AI services -language models or other algorithms - based on actual consumption, with significantly reduced costs and energy usage. The teams have aligned their roadmap around integration, security, and operations.

By relying on European technologies-both hardware and software-the two companies aim to contribute to the emergence of a truly independent AI infrastructure. Following the summit, they plan to continue discussions with French, German, and European authorities to share insights on infrastructures, energy efficiency, and digital sovereignty. The event held between President Emmanuel Macron and Chancellor Friedrich Merz also provided a platform for extensive exchanges with the attending delegations.

Quentin Adam, CEO of Clever Cloud, States: “We want a Europe that develops its own technologies and takes control of its digital future. With SpiNNcloud, we demonstrate that European industry not only has the expertise but also the determination to address the major challenges of AI: costs, energy consumption, sovereignty. This collaboration shows that a cooperating Europe can design high-performance, efficient, and truly independent infrastructures.”

Hector Gonzalez, CEO of SpiNNcloud, adds: “With Clever Cloud, we found an ideal partner to bring the unique energy efficiency of our brain-inspired systems to industrial use cases. This Franco-German cooperation proves that Europe has the technological building blocks needed to build competitive and sovereign solutions.”

About SpiNNcloud

SpiNNcloud is reinventing AI infrastructure through a brain-inspired computing architecture designed to drastically reduce energy consumption while maintaining high performance. Its event-based approach, in which computations occur only when needed, opens up new margins of efficiency. The company provides complete systems to research centers and enterprises worldwide.

Want to learn more about this project?

Feel free to contact us.

Contact us

MCP (Model Context Protocol) servers are that guide—directing LLMs to the right information, whether through broad, flexible access (generic) or targeted, optimized interactions (domain-specific). But how do you decide which approach is best for your use case?

Understanding MCP server designs

MCP (Model Context Protocol) servers are specialized interfaces that allow Large Language Models (LLMs) to connect with external data sources, services, or tools. They transform natural language instructions into actionable queries, providing LLMs with structured, efficient access to information.

MCP servers can be categorized into two main types:

• Generic MCP Servers: Highly flexible, adaptable to any database or tool, but requiring LLMs to understand and navigate complex schemas.
• Domain-Specific MCP Servers: Purpose-built for a specific domain, offering predefined tools that simplify interactions.

Generic MCP servers: a flexible starting point

Generic MCP servers are versatile, one-size-fits-all solutions. They connect LLMs to any database or tool without prior knowledge of their structure. This flexibility makes them quick to deploy, but it also means that LLMs must navigate and understand complex schemas on their own.

What makes an MCP server generic?

• Universal Querying: Accepts raw queries (like SQL) from the LLM, making it compatible with any database.
• Schema Agnostic: No predefined knowledge of database structure.
• Minimal Configuration: Quick to set up without extensive preparation.

Example: PostgreSQL MCP server with single query tool

A practical example of this approach is the @modelcontextprotocol/server-postgres. This MCP server connects LLMs to PostgreSQL databases with a single, flexible endpoint:

• Endpoint: POST /query - Accepts raw SQL queries directly from the LLM.
• Functionality: Allows LLMs to query any PostgreSQL database without knowing its schema in advance.

Pros and cons of generic MCP servers

✅ Advantages

• Fast and easy setup.
• Compatible with any database.
• No need to update for schema changes.

❌ Drawbacks

• High cognitive load for LLMs.
• Less efficient, requiring multiple queries.
• Security risks (SQL injection).

Domain-specific MCP servers: a tailored, efficient alternative

Domain-specific MCP servers are precision tools, purpose-built for a specific domain. They offer predefined tools that make interactions clear and efficient.

What makes an MCP server domain-specific?

• Predefined Tools: Provides intuitive commands like getMonsterByName or listMonstersByType.
• Schema Awareness: Knows the database structure and can optimize queries.
• Guided Interactions: LLMs use clear, named tools without exploring schema.

Example: custom PostgreSQL MCP server for RAGmonsters

A practical example is the Custom PostgreSQL MCP Server for RAGmonsters. It offers targeted tools:

• getMonsterByName: Fetches detailed information about a monster.
• listMonstersByType: Lists monsters of a given type.

Pros and cons of domain-specific MCP servers

✅ Advantages

• Easy, intuitive interactions for LLMs.
• Optimized for specific use cases.
• Secure (no raw SQL).

❌ Drawbacks

• Initial setup time.
• Less flexible to schema changes.
• Comparing the Two Approaches

Conclusion: choosing the right MCP server

To find out more and discover a concrete implementation of these concepts, discover how to create your MCP server with Otoroshi. It details how Otoroshi with LLM allows you to quickly create MCP servers and clients, expose functions via SSE, WebSockets or HTTP, and simplify integration with ready-to-use MCP connectors.

Whether you need a flexible, exploratory tool or a precise, optimized solution, understanding the difference between generic and domain-specific MCP servers will help you build smarter, more efficient LLM-powered applications. Choose a generic server for quick setup and adaptability, or a domain-specific server for secure, streamlined performance. Ready to start? Explore our PostgreSQL MCP Server or Custom RAGmonsters MCP Server to see both approaches in action.

Animé par Horacio Gonzalez - @LostInBrittany
Épisode enregistré le 2 octobre 2024 à Marrakech

Les invités

00:00:16 : Sébastien BLANC (@sebi2706) Staff Developer Advocate @ Aiven

00:11:19 : Badr El HAOURI (@badrelhouari) Chairman @ Devoxx Morocco

00:22:06 : Eléa PETTON (@EleaPetton) Machine Learning Engineer @ OVH Cloud

00:29:43 : Raphaël SEMETEYS (@RaphaelSemeteys) Architecte, DevRel, expert open source @ Wordline

00:38:40 : Yassine BENABBAS (@yostane) Teacher, and Software Development Community Advocate at Worldline @ Wordline 

00:45:00 : Natalie GODEC (@ouvessvit) Senior Cloud Architect @ Zencore

Liens vers les talks

Coming soon...

If AI has been in the news recently, it's mainly through large language models (LLMs), which require substantial computing power for training or inference. Thus, it's common to see developers using them via turnkey APIs, as we did in a previous article. But this is changing thanks to more open and efficient models and tools, which you can easily deploy on Clever Cloud.

Indeed, while our platform was designed for a variety of uses, we always paid particular attention to its flexibility and the freedom it gave our customers. This means they can easily exploit it to address new markets, with minimum effort spent on adaptation.

To confirm this, we recently tried to deploy open source AI models such as those derived from LLaMA and Mistral. Their particularity is that they exist in lightweight versions, which don't necessarily require a GPU to run. As a result, they can be hosted as simple Clever Cloud applications, as long as they have been allocated enough memory.

Let's ollama (with a web UI) !

To do it, we've chosen to use ollama, an MIT-licensed project that lets you download models from a registry, or even your own. It works as a server that communicates via an API, and is very easy to host on our infrastructures.

• Create a Clever Cloud account (and get 20 euros in credits)

To get started, you’ll need a Clever Cloud account. You can create the application and follow the next steps using our web interface, the Console, but also through our open source CLI: Clever Tools. That’s what we’ll describe below.

We’ll assume that your machine is running git and a recent version of Node.js. If you haven’t yet installed Clever Tools on your system, type (with system administrator rights, or sudo if necessary):

npm i -g clever-tools
clever login

Once logged in, you can check that everything has gone smoothly with the following command:

clever profile

Next, we create a Clever Cloud application using Node.js. It will install ollama to download and run our models, adding a web interface (chatbot-ollama, also under MIT license) that will allow us to query the server from any browser, run from a computer or a simple smartphone.

This solution also offers local storage of chats in the browser. It therefore requires no database, but offers an import/export function. You can also choose between different models, set some of their parameters, configure system instructions, various prompts, and so on.

mkdir myollama && cd myollama
git init
curl -L https://github.com/ivanfioravanti/chatbot-ollama/archive/refs/heads/main.tar.gz | tar -xz --strip-components=1

clever create -t node myollama && clever scale --flavor L
clever env set CC_POST_BUILD_HOOK "npx next telemetry disable && npm run build"
clever env set CC_PRE_BUILD_HOOK "./ollama_setup.sh"
clever env set CC_PRE_RUN_HOOK "./ollama_start.sh"

echo "orca-mini" > models.list
echo "mistral" >> models.list
echo "codellama" >> models.list

The code above creates the application. We add a file containing the list of models we wish to fetch during startup. We've chosen an L instance, the minimum size for loading such models into memory. We also declare several environment variables for running scripts to install ollama, start the server and disable telemetry for the Next.js framework used to build the web interface after the dependencies have been installed.

Now add some scripts

Our application is almost ready. We still have to create two executable files:

touch ollama_setup.sh && chmod +x ollama_setup.sh
touch ollama_start.sh && chmod +x ollama_start.sh

ollama_setup.sh download the ollama binary and the models from our list. Open it with your favorite editor and insert the following content:

#!/bin/bash

# We define the folder (in $PATH), where the ollama binary will be placed
BIN_DIR=${HOME}/.local/bin
mkdir -p ${BIN_DIR} 

ollama_start() {
    echo "Downloading and launching ollama..."
    curl -Ls https://ollama.ai/download/ollama-linux-amd64 -o ${BIN_DIR}/ollama
    chmod +x ${BIN_DIR}/ollama
    ollama serve &> /dev/null &
    echo -e "Finished: \033[32m✔\033[0m\n"
}

get_models() {
    MODELS_FILE="models.list"
    MODELS_DEFAULT="orca-mini"

    # We check if the models file exists
    if [ ! -f ${MODELS_FILE} ]; then
        echo "File ${MODELS_FILE} not found, ${MODELS_DEFAULT} used by default."
        echo ${MODELS_DEFAULT} > ${MODELS_FILE}
    fi

    # Loop through each line and pull model
    while IFS= read -r line; do
        echo "Pulling ${line} model..."
        ollama pull "${line}" > /dev/null 2>&1
        echo -e "Finished: \033[32m✔\033[0m\n"

    done < ${MODELS_FILE}
}

# We start ollama, and wait for it to respond
ollama_start
if [ $? -ne 0 ]; then
    echo -e "\nError during ollama setup."
    exit 1
fi

count=0
MAX_TIME=10

while ! pgrep -x "ollama" > /dev/null; do
    if [ ${count} -lt ${MAX_TIME} ]; then
        sleep 1
        count=$((count+1))
    else
        echo "Application 'ollama' did not launch within 10 seconds."
        exit 1
    fi
done

get_models
if [ $? -ne 0 ]; then
    echo -e "\nError during models downloading."
    exit 1
fi

This code may seem a little long, but that's mainly because we've made it modular, logging only successful steps and any errors.

ollama_start.sh detects whether the ollama server is already present before starting the web interface. If it isn't, we launch it in the background (we'll see why below).

Open it with your favorite editor and insert the following content:

if ! pgrep -f "ollama" > /dev/null; then
    # If 'ollama' is not running, start it in the background
    ollama serve &
    echo "Application 'ollama' started."
else
    # If 'ollama' is already running
    echo "'ollama' application is already running."
fi

Once these two files have been created, we can deploy the application:

git add . && git commit -m "Init application"
clever deploy
clever domain

You'll then see the domain to access it (which you can customize).

Cache and quick (re)start

Using Clever Cloud not only means deploying such an application easily, with logs and monitoring, and being able to instantly change its horizontal and/or vertical scaling. It also means being able to turn it into an image ready for a fast redeployment.

In fact, every application we host is stored as an archive just before dependencies are installed. This means it can be stopped and restarted in this form, so we don't have to re-download the models every time. To do this, simply specify the folders to be added to the archive:

clever env set CC_OVERRIDE_BUILDCACHE "/:../.ollama/:../.local/bin/"
clever restart --without-cache --follow

The application will restart, but this time it will take the built web interface, ollama and models from its cache, as the CC_PRE_BUILD_HOOK and CC_PRE_BUILD_HOOK steps are not executed. This is one of the reasons why we need to make sure that we start the ollama server with CC_PRE_RUN_HOOK, but check that this hasn't already been done in a deployment where it is used to download models before running them.

Once this step is complete, you can stop the application and restart it whenever you like - it'll be much faster from now on. And you'll only be charged for the time you use it, by the second. If you wish to modify the list of models to use, do so in the dedicated file. A git push will be enough to rebuild the new cache.

# Stop/Restart the application
clever stop
clever restart

# After a modification in models.list, git push to recreate the cache
git add models.list && git commit -m "New models" 
clever deploy

You'll find the files you need for this project in this GitHub repository, with the environment variables ready to import (clever env import < .env).

And if you want to push things further, deploy other models and tools for your applications that require more power and/or GPUs, let us know!

Animé par Jean-Baptiste KAISER - @ArendSyl
avec la participation de :
- Guillaume ASSIER : @GuillaumeAssier
- Eloi DEMOLIS : @Wonshtrum
- Sylvain WALLEZ : @bluxte

Épisode enregistré le 7 novembre 2023

👋 Venez discuter avec nous sur @clever_cloudFR pour nous dire ce que vous avez pensé de ce nouvel épisode.

➡️ Pour découvrir ou réécouter d’anciens épisodes c’est par ici !

Chapitrage et liens

00:01:24 Executive Order sur l’IA https://bsky.app/profile/dashishka.bsky.social/post/3kd25ppdlek2l
https://www.whitehouse.gov/briefing-room/presidential-actions/2023/10/30/executive-order-on-the-safe-secure-and-trustworthy-development-and-use-of-artificial-intelligence/

00:07:03 Platforme d’entrainement d’IA en pleine mer https://www.numerama.com/tech/1547042-pour-echapper-aux-regulations-sur-lia-une-entreprise-veut-creer-un-etat-en-pleine-mer.html

00:12:01 Adoption de WebGPU (and “Rust is the defacto standard for graphics in Rust”) https://www.youtube.com/watch?v=CklvTsKogTg

00:22:15 Alternant chez Orange le jour, dev de malwares la nuit
https://www.zdnet.fr/actualites/alternant-chez-orange-cyberdefense-le-jour-developpeur-de-programmes-malveillants-la-nuit-39962084.htm

00:28:43 React serveur
https://twitter.com/manekinekko/status/1717957681359495449

00:36:27 ChatGPT Builder
https://openai.com/blog/introducing-gpts
https://twitter.com/heyBarsee/status/1721792544814588141

00:46:50 Text to 3D generative AI
https://research.nvidia.com/labs/dir/magic3d/

00:51:28 #sanglicam
https://twitter.com/hashtag/sanglicam?f=live

00:56:42 Musique de fin
Eloi (6-10) : OOGIE BOOGIE'S SONG | The Nightmare Before Christmas | VoicePlay A Cappella Cover : https://www.youtube.com/watch?v=EbxkOntz2SA

Animé par Quentin ADAM

avec la participation de :

• Sun Tan - @_sunix
• Horacio Gonzalez - @lostinbritany
• Sebastien Blanc - @sebi2706

👋 Venez discuter avec nous sur @clever_cloudFR pour nous dire ce que vous avez pensé de ce nouvel épisode.

➡️ Pour découvrir ou réécouter d’anciens épisodes c’est par ici !

Timecode et liens

00:00:16 - Présentation des participants
00:03:38 - Devoxx Belgique
00:13:01 - IA everywhere, Java et le binaire
00:39:12 - Broadcom et vmware
00:43:45 - MISTRAL 7B premier modèle ouvert d'AI
https://www.usine-digitale.fr/article/la-start-up-francaise-mistral-ai-devoile-mistral-7b-son-grand-modele-de-langage-open-source.N2176022

OVHcloud s’équipe en GPU nouvelle génération : https://www.lemagit.fr/actualites/366553735/VDI-rasterisation-IA-OVHcloud-sequipe-en-GPU-nouvelle-generation

00:51:15 - L’iA et le numérique comme tremplin politique :
https://www.wired.com/story/what-openai-really-wants/

01:10:59 - Musique de fin : Music Thylacine - Vivaldi (and 74 musicians) (Official Video) https://www.youtube.com/watch?v=3zyVu8xn60I

• No hidden cost starting from 0.42 euros an hour
• Billed by the minute
• Datacenter located in Europe to comply with GDPR
• up to 4 GeForce GTX1070 on the same machine
• Fully automated setup with CUDA, Tensorflow, Keras and more

0.42 euros an hour […] with 8 CPU, 1 GPU (Nvidia GeForce GTX1070), 6GB of Ram and 250GB of storage space