Au-delà du prompt, comment le protocole MCP augmente nos interactions avec les LLMs

Maintenant, armez vous de votre IDE préféré et commençons l'implémentation de notre serveur.

Pour des raisons de simplicité, nous écrirons notre code dans le fichier main.py. Voici le fichier final avec l'explication bloc par bloc du code :

import os
import yaml
import asyncio
import httpx
from fastmcp import FastMCP
# On commence par charger et parser la spécification OpenAPI de Firefly III.
with open("./firefly-iii-openapi.yaml", "r") as f:
openapi_spec = yaml.safe_load(f)
# On créé un client HTTP async authentifié pour communiquer avec notre instance de Firefly III.
client = httpx.AsyncClient(base_url=os.environ["FIREFLY_III_URL"], headers={"Authorization": "Bearer " + os.environ["FIREFLY_III_ACCESS_TOKEN"]})
# C'est la que la magie opère avec FastMCP. On instancie un serveur MCP en passant directement la spécification OpenAPI chargée plus haut et en utilisant notre client httpx.
mcp = FastMCP.from_openapi(name="Firefly III MCP server", openapi_spec=openapi_spec, client=client)
# On peut définir nos prompts ici pour guider l'usage du serveur MCP. C'est utile quand on a beaucoup de tools
@mcp.prompt

def get_account_balance_prompt(account_name: str) -> str:

"""

Generates a prompt to get the current balance of a specified account.

"""

return f"What is the current balance of the account named '{account_name}'?"

@mcp.prompt

def summarize_spending_by_category_prompt(start_date: str, end_date: str) -> str:

"""

Generates a prompt to summarize spending by category within a date range (YYYY-MM-DD).

"""

return f"Please provide a summary of my spending by category from {start_date} to {end_date}."
# On définit la fonction principale pour lancer le serveur en asynchrone
async def main():
await mcp.run_async(transport="streamable-http")

# On run le serveur

if __name__ == "__main__":

asyncio.run(main())

Nous allons ensuite lancer le serveur en développement pour l'inspecter (ouvrez l'url avec le token):

fastmcp dev main.py
# output

[07/08/25 12:39:45] INFO Created FastMCP OpenAPI server with 219 routes openapi.py:782

Starting MCP inspector...

⚙️ Proxy server listening on 127.0.0.1:6277

🔑 Session token: <redacted>

Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth

🔗 Open inspector with token pre-filled:

http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=<redacted>

Notons le nombre "élevé" de tools créés. Le but d'un MCP n'est pas de juste de transposer une API avec tous ses endpoints disponibles (sur un nombre élevé de tools, cela peut rapidement créer des problèmes d'identification du contexte).

Les MCPs s'illustrent en contextualisant l'usage des tools avec les prompts et les autres fonctionnalités du protocole. C'est pourquoi la définition des prompts au sein de votre MCP est aussi importante que la définition des tools disponibles. Dans le cadre de l'implémentation d'un serveur MCP de production à grande échelle, posez-vous la question de quels endpoints sont vraiment utiles et est ce que je vais gagner de la valeur dans mes processus métiers.

En cliquant sur l'URL, nous accédons au MCP Inspector, l'outil de test du protocole, plutôt pratique pour voir comment se comporte notre serveur.

Pour nous connecter, remplissez les 2 variables d'environnements que nous avons défini dans le .env.

Si tout est bon, nous devrions voir le statut connected.

Maintenant, partez explorer l'inspecteur pour tester vos tools, prompts, resources, etc...

Déploiement

Nous avons mis en place un serveur local, mais si nous somme plusieurs à devoir utiliser celui ci, l'idéal est de le mettre en ligne pour que les personnes qui doivent l'utiliser y ait accès.

Nous allons créer un container léger avec l'aide de Docker pour "packager" notre serveur

Commençons par créer un Dockerfile très simple :

FROM python:3.12.9-slim-bookworm

ENV PYTHONBUFFERED=1

ENV UV_LINK_MODE=copy

WORKDIR /app

# The installer requires curl (and certificates) to download the release archive

RUN apt-get update && apt-get install -y --no-install-recommends curl ca-certificates

# Download the latest installer

ADD https://astral.sh/uv/install.sh /uv-installer.sh

# Run the installer then remove it

RUN sh /uv-installer.sh && rm /uv-installer.sh

# Ensure the installed binary is on the `PATH`

ENV PATH="/root/.local/bin/:$PATH"

# Copy the project into the image

COPY . ./

RUN --mount=type=cache,target=/root/.cache/uv \

uv sync

CMD ["uv", "run", "main.py"]

On build l'image :

docker build -t mcp-firefly .

Si l'optimisation des images est un sujet qui vous intéresse, allez voir la documentation d'uv pour optimiser l'installation des dépendances dans une image docker :

https://docs.astral.sh/uv/guides/integration/docker/

Une fois l'image construite, vous pouvez la pousser sur votre registre d'images Docker.

Vous pouvez ensuite configurer votre client MCP avec cette configuration (la configuration peut légèrement différer selon votre client/hôte MCP) :

"mcpServers": {
"firefly": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"-e",
"FIREFLY_III_URL",
"-e",
"FIREFLY_III_ACCESS_TOKEN",

// utiliser l'URL de votre registre d'images

"<registry>/mcp-firefly"

],

env: {

"FIREFLY_III_URL": "<your-firefly-url>",

"FIREFLY_III_ACCESS_TOKEN": "<your-secret-token>"

}

}

}

Voila, nous avons un serveur fonctionnel prêt à l'emploi. À vous d'aller creuser vos cas d'usages pour en tirer parti de la puissance qu'offre le protocole MCP