TL;DR

• Docker etend Compose pour supporter des services IA natifs : modeles, agents, serveurs MCP. Meme fichier docker-compose.yml, meme workflow.
• Docker Model Runner permet de faire tourner des LLM localement avec une API compatible OpenAI. Plus besoin d'Ollama separement.
• Le MCP Gateway connecte les agents IA a tes services Docker existants (bases de donnees, APIs, fichiers) via le protocole MCP.
• Docker Hub heberge desormais des modeles IA et des MCP servers open-source. Un docker pull pour un modele, comme pour une image.
• Les partenariats avec CrewAI, LangGraph et Vercel AI SDK montrent que Docker vise l'orchestration multi-agents en production.

L'IA arrive dans ton docker-compose.yml

Si tu utilises Docker au quotidien, tu connais le pattern : tu decris tes services dans un docker-compose.yml, tu lances docker compose up, et tout tourne. Frontend, backend, base de donnees, cache Redis, reverse proxy -- tout est orchestre dans un seul fichier.

En juillet 2025, Docker etend ce modele aux agents IA. Le meme fichier, le meme workflow, les memes commandes. Sauf que maintenant, un "service" peut etre un modele de langage, un agent autonome, ou un serveur MCP.

C'est un changement subtil mais profond. Jusqu'ici, integrer de l'IA dans une stack Docker signifiait lancer Ollama a cote, gerer des volumes de modeles separement, et bricoler des bridges reseau. Docker unifie tout ca.

Docker Model Runner : les LLM en local, natif

Docker Model Runner est un runtime de modeles integre directement dans Docker Desktop. Il permet de faire tourner des LLM localement avec une API compatible OpenAI.

# docker-compose.yml avec un modèle IA
services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db
      - model

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: myapp
      POSTGRES_PASSWORD: secret

  model:
    provider: model
    options:
      model: ai/llama3.2:8B-Q4_K_M

Le bloc provider: model est la nouveaute. Docker reconnait que ce n'est pas un conteneur classique mais un service de modele. Il gere automatiquement :

• Le telechargement et le cache du modele
• L'allocation GPU/CPU
• L'API compatible OpenAI sur un endpoint interne
• La gestion memoire et le dechargement automatique

Ton application peut ensuite appeler le modele comme elle appellerait une API OpenAI, sauf que tout tourne en local :

import openai

# L'URL interne Docker, comme pour n'importe quel service
client = openai.OpenAI(
    base_url="http://model:8080/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="ai/llama3.2:8B-Q4_K_M",
    messages=[{"role": "user", "content": "Résume ce document..."}]
)

Le modele est un service Docker comme un autre. Il demarre avec docker compose up, s'arrete avec docker compose down, et ses logs sont visibles dans docker compose logs model. Pas de process separe, pas de configuration supplementaire.

Le MCP Gateway : connecter les agents a tes services

Le Model Context Protocol (MCP) est un standard ouvert qui permet aux LLM d'interagir avec des outils externes. Docker MCP Gateway est un proxy qui connecte les agents IA a tes services Docker existants.

Concretement, au lieu de donner a ton agent un acces direct a ta base de donnees (mauvaise idee), tu passes par le MCP Gateway qui :

• Expose tes services comme des outils MCP typages
• Gere les permissions (quel agent a acces a quoi)
• Logge toutes les interactions
• Valide les requetes avant de les transmettre

services:
  app:
    build: .
    ports:
      - "3000:3000"

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: myapp
      POSTGRES_PASSWORD: secret

  mcp-gateway:
    image: docker/mcp-gateway:latest
    environment:
      MCP_SERVICES: db,app
    volumes:
      - ./mcp-config.yaml:/etc/mcp/config.yaml

  agent:
    provider: model
    options:
      model: ai/llama3.2:8B-Q4_K_M
    depends_on:
      - mcp-gateway

Le fichier de configuration MCP definit ce que l'agent peut faire :

# mcp-config.yaml
tools:
  - name: query_database
    description: "Exécuter une requête SQL en lecture seule"
    service: db
    permissions:
      - SELECT
    max_rows: 100

  - name: get_api_status
    description: "Vérifier le statut de l'API"
    service: app
    endpoint: /health
    method: GET

L'agent ne voit pas la base de donnees directement. Il voit un outil query_database avec des permissions definies. C'est le meme pattern que les roles en base de donnees, applique aux agents IA.

Docker Hub : un registry pour les modeles

Docker Hub heberge desormais des modeles IA et des MCP servers. La syntaxe est la meme que pour les images Docker :

# Tirer un modèle
docker model pull ai/llama3.2:8B-Q4_K_M

# Lister les modèles locaux
docker model list

# Lancer un modèle interactivement
docker model run ai/llama3.2:8B-Q4_K_M

# Tirer un MCP server
docker pull docker/mcp-postgres:latest
docker pull docker/mcp-filesystem:latest

L'interet : la meme experience utilisateur. Tu ne te demandes pas comment installer un modele, ou le stocker, comment gerer les versions. Tu fais docker pull, comme pour n'importe quelle image.

Docker a aussi open-source un catalogue de MCP servers pre-packages pour les services courants : PostgreSQL, MySQL, Redis, Elasticsearch, le systeme de fichiers. Chacun expose les operations standard comme des outils MCP.

Docker Offload : quand le local ne suffit pas

Un LLM 8B tourne confortablement sur un MacBook M1 avec 16 Go de RAM. Un modele 70B, beaucoup moins. Docker Offload permet de router les inferences vers le cloud de maniere transparente.

services:
  model:
    provider: model
    options:
      model: ai/llama3.2:70B-Q4_K_M
      offload: auto  # Local si possible, cloud sinon

Le mode auto detecte les capacites de la machine. Si le modele tient en memoire, il tourne localement. Sinon, Docker route vers un service cloud compatible. Ton code applicatif ne change pas -- l'URL du service reste la meme.

C'est particulierement utile pour le dev : tu developpes avec un petit modele en local (rapide, gratuit), tu testes avec un gros modele en offload (plus lent, payant), et tu deploies en production avec le modele de ton choix.

Multi-agents : les partenariats

Docker ne construit pas un framework d'agents -- il fournit l'infrastructure. Les partenariats annonces sont strategiques :

CrewAI. Un framework Python pour orchestrer des equipes d'agents. Chaque agent a un role, des outils, et un objectif. Docker Compose orchestre les agents comme des services, avec le MCP Gateway pour les connecter aux donnees.

LangGraph. Le framework de LangChain pour les agents stateful. LangGraph gere les graphes de decisions, Docker gere le runtime et les connexions aux services.

Vercel AI SDK. L'integration permet de deployer des agents IA dans des apps Next.js avec Docker comme backend. L'agent tourne dans un conteneur, le frontend sur Vercel, et le MCP Gateway connecte les deux.

Le message est clair : Docker ne veut pas etre un framework d'IA. Docker veut etre le runtime d'IA. Exactement comme Docker est devenu le runtime de facto pour les microservices.

Un exemple complet : agent de support client

Voici a quoi ressemble une stack complete avec un agent IA :

# docker-compose.yml
services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - api

  api:
    build: ./api
    environment:
      DATABASE_URL: postgres://postgres:secret@db:5432/support
      MODEL_URL: http://model:8080/v1
    depends_on:
      - db
      - model

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: support
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data

  model:
    provider: model
    options:
      model: ai/llama3.2:8B-Q4_K_M

  mcp-gateway:
    image: docker/mcp-gateway:latest
    volumes:
      - ./mcp-config.yaml:/etc/mcp/config.yaml
    depends_on:
      - db

  mcp-postgres:
    image: docker/mcp-postgres:latest
    environment:
      POSTGRES_URL: postgres://postgres:secret@db:5432/support

volumes:
  pgdata:

Un docker compose up et tu as : un frontend, une API, une base de donnees, un modele IA, et un MCP Gateway qui connecte l'agent a la base de donnees. Le tout isole, reproductible, et versionne.

C'est le meme pattern que les microservices. Et c'est exactement le point.

Ce que ca change pour les devs

Si tu fais du DevOps ou du backend, voici les implications :

1. L'IA devient un service infrastructure. Comme la base de donnees ou le cache, le modele IA est un service que tu orchestres. Pas un appel API externe, un composant de ta stack.

2. Le MCP Gateway est un pattern a surveiller. Plutot que de donner un acces direct aux agents, passe par une couche de permissions. C'est la bonne pratique de securite qui va s'imposer.

3. Le local-first pour le dev. Avec Docker Model Runner, tu peux developper avec de l'IA sans couts API, sans connexion internet, sans envoyer tes donnees a un tiers.

4. Le multi-agents va se normaliser. Si orchestrer un agent est aussi simple qu'ajouter un service dans un Compose, on va en voir beaucoup plus en production.

Docker fait ce que Docker a toujours fait : prendre quelque chose de complique (les conteneurs hier, les agents IA aujourd'hui) et le rendre accessible a n'importe quel dev avec un fichier YAML et une ligne de commande.

Ressources

• Docker Blog - AI in Docker Compose -- annonce officielle et documentation
• Docker Model Runner -- documentation du runtime de modeles
• Docker MCP Catalog -- catalogue des MCP servers pre-packages
• Model Context Protocol -- specification du protocole MCP
• CrewAI + Docker -- integration multi-agents avec Docker Compose
• LangGraph -- framework d'agents stateful compatible Docker