Installer LibreChat

Installer LibreChat à côté de Linkr et le relier au serveur MCP : la configuration selon que Linkr et LibreChat tournent sous Docker ou non, le modèle, la demande de confirmation et la clé de chaque utilisateur.

En résumé

LibreChat est le client de conversation que nous recommandons pour faire travailler un agent sur Linkr : open source, multi-utilisateur, et capable d’utiliser un modèle hébergé dans l’établissement. Il s’installe à côté de Linkr et se relie à son serveur MCP par un fichier, librechat.yaml. L’adresse à y inscrire dépend de la façon dont les deux tournent — sous Docker ou non — : cette page donne la configuration de chaque cas.

Client Backend

Pourquoi LibreChat

Linkr n’héberge pas de conversation : un agent tourne dans un client externe, qui tient la conversation, choisit le modèle et demande votre accord avant d’agir, et qui agit sur Linkr par le serveur MCP. Tout client compatible MCP convient. Nous recommandons LibreChat pour un usage en établissement :

Open source et auto-hébergé — il tourne sur vos machines, et peut n’utiliser que des modèles locaux : rien ne sort de l’établissement.
Multi-utilisateur — chacun s’y connecte avec son compte, et donne à Linkr sa propre clé API : l’agent agit en son nom, avec ses droits, jamais davantage.
Une demande de confirmation réglable — l’administrateur décide quels outils s’exécutent d’emblée et lesquels attendent votre accord.

LibreChat s’utilise dans un onglet à côté de Linkr. Chaque modification faite par l’agent apparaît dans Linkr sous vos yeux, dans la cloche des Notifications.

Il faut une installation avec backend

Le serveur MCP agit sur Linkr par son API : il ne fonctionne qu’avec une installation Docker ou manuelle, pas en mode client-only. Le détail est dans Modes de déploiement.

Choisir sa configuration

Une seule chose change d’un cas à l’autre : l’adresse par laquelle LibreChat joint le serveur MCP de Linkr. Repérez votre cas, puis choisissez l’onglet correspondant à chaque étape — ils restent synchronisés sur toute la page.

Linkr	LibreChat	Adresse du serveur MCP
Docker	Docker, même machine	`http://linkr-mcp:3940/mcp`
Installation manuelle	Docker, même machine	`http://host.docker.internal:3940/mcp`
Docker ou installation manuelle	Sans Docker, même machine	`http://127.0.0.1:3940/mcp`
Sur un serveur	Sur une autre machine	une adresse en `https://`, voir plus bas

Pourquoi trois adresses : à l’intérieur d’un conteneur Docker, 127.0.0.1 désigne le conteneur lui-même, pas votre machine. Deux conteneurs se joignent par un réseau Docker commun ; un conteneur joint votre machine par le nom host.docker.internal.

Installation

Démarrer Linkr et son serveur MCP

Linkr doit tourner avant LibreChat, avec son serveur MCP — sur le port 3940.

Le fichier docker-compose.hub.yml lance le serveur MCP avec le reste de Linkr, comme un service mcp. Pour que LibreChat le joigne, les deux doivent partager un réseau Docker. Créez-le une fois :

docker network create linkr-agents

Puis, dans docker-compose.hub.yml, rattachez le service mcp à ce réseau sous le nom linkr-mcp, et déclarez le réseau à la fin du fichier :

  mcp:
    # … lignes existantes inchangées : image, ports, environment …
    networks:
      default:
      linkr-agents:
        aliases: [linkr-mcp]

networks:
  linkr-agents:
    external: true

La ligne default: garde le service sur le réseau de Linkr, par lequel il joint l’API. Relancez Linkr : docker compose -f docker-compose.hub.yml up -d.

npm run dev:all lance le serveur MCP avec le reste de Linkr. Par défaut, il n’écoute que sur 127.0.0.1 — l’intérieur de votre machine —, qu’un conteneur ne peut pas joindre. Ouvrez-le en ajoutant cette ligne dans packages/linkr-mcp/.env (créez le fichier s’il n’existe pas) :

LINKR_MCP_HOST=0.0.0.0

Relancez npm run dev:all.

Le port 3940 devient joignable depuis votre réseau

Avec 0.0.0.0, le serveur MCP accepte aussi les connexions des autres machines, et les clés API y circulent en clair. Réservez ce réglage à un poste de travail derrière un pare-feu, jamais à une machine exposée.

Rien à changer côté Linkr : avec Docker comme avec l’installation manuelle, le serveur MCP écoute sur http://127.0.0.1:3940/mcp, que LibreChat joint directement puisqu’il tourne sur la même machine.

Installer LibreChat

Il faut Git et Docker. Dans un dossier à part, hors de celui de Linkr :

git clone https://github.com/LibreChat-AI/LibreChat.git
cd LibreChat
cp .env.example .env
cp librechat.example.yaml librechat.yaml

Le fichier .env règle LibreChat lui-même ; librechat.yaml recevra la configuration de Linkr à l’étape suivante.

Il faut Git et Docker. Dans un dossier à part, hors de celui de Linkr :

git clone https://github.com/LibreChat-AI/LibreChat.git
cd LibreChat
cp .env.example .env
cp librechat.example.yaml librechat.yaml

Le fichier .env règle LibreChat lui-même ; librechat.yaml recevra la configuration de Linkr à l’étape suivante.

Il faut Git, Node.js 24 et une base MongoDB, que LibreChat utilise pour ses comptes et ses conversations. Le guide d’installation sans Docker de LibreChat détaille l’installation de MongoDB. Ensuite :

git clone https://github.com/LibreChat-AI/LibreChat.git
cd LibreChat
cp .env.example .env
cp librechat.example.yaml librechat.yaml
npm run reinstall

Dans .env, renseignez MONGO_URI avec l’adresse de votre base MongoDB.

Le port 3000 est déjà celui de Linkr

L’installation Docker de LibreChat lance aussi un panneau d’administration, publié par défaut sur le port 3000 — celui de Linkr. Dans le fichier .env de LibreChat, décommentez la ligne ADMIN_PANEL_PORT et donnez-lui un autre port, par exemple ADMIN_PANEL_PORT=3090. Ce panneau demande aussi une valeur pour ADMIN_PANEL_SESSION_SECRET, que openssl rand -hex 32 génère.

Déclarer Linkr dans librechat.yaml

Ouvrez librechat.yaml et ajoutez-y les deux blocs suivants, au premier niveau du fichier. S’ils existent déjà, complétez-les plutôt que de les dupliquer.

mcpSettings:
  allowedAddresses:
    - "linkr-mcp:3940"

mcpServers:
  linkr:
    type: streamable-http
    url: http://linkr-mcp:3940/mcp
    headers:
      Authorization: "Bearer {{LINKR_API_KEY}}"
    customUserVars:
      LINKR_API_KEY:
        title: "Clé API Linkr"
        description: "Dans Linkr : Paramètres utilisateur → Clés API"
        sensitive: true
    requiresOAuth: false
    serverInstructions: true
    timeout: 300000

mcpSettings:
  allowedAddresses:
    - "host.docker.internal:3940"

mcpServers:
  linkr:
    type: streamable-http
    url: http://host.docker.internal:3940/mcp
    headers:
      Authorization: "Bearer {{LINKR_API_KEY}}"
    customUserVars:
      LINKR_API_KEY:
        title: "Clé API Linkr"
        description: "Dans Linkr : Paramètres utilisateur → Clés API"
        sensitive: true
    requiresOAuth: false
    serverInstructions: true
    timeout: 300000

mcpSettings:
  allowedAddresses:
    - "127.0.0.1:3940"

mcpServers:
  linkr:
    type: streamable-http
    url: http://127.0.0.1:3940/mcp
    headers:
      Authorization: "Bearer {{LINKR_API_KEY}}"
    customUserVars:
      LINKR_API_KEY:
        title: "Clé API Linkr"
        description: "Dans Linkr : Paramètres utilisateur → Clés API"
        sensitive: true
    requiresOAuth: false
    serverInstructions: true
    timeout: 300000

Ce que fait chaque ligne :

allowedAddresses — LibreChat refuse par défaut de contacter une adresse privée, une protection contre les requêtes détournées vers le réseau interne. Cette ligne autorise le serveur MCP de Linkr, et lui seul.
{{LINKR_API_KEY}} et customUserVars — la clé n’est pas écrite dans le fichier : LibreChat la demande à chaque utilisateur, et l’envoie à Linkr avec chacune de ses requêtes. sensitive la masque à la saisie.
requiresOAuth: false — au démarrage, avant qu’aucune clé n’ait été saisie, Linkr répond « non autorisé ». Sans cette ligne, LibreChat en conclut à tort que le serveur attend une connexion OAuth.
serverInstructions — transmet au modèle la présentation que Linkr fait de ses outils.
timeout — cinq minutes, en millisecondes : une cohorte ou un script peut prendre du temps sur un gros entrepôt.

allowedAddresses, pas allowedDomains

LibreChat connaît aussi mcpSettings.allowedDomains. Cette clé fonctionne, mais elle transforme la liste en liste exclusive : tout serveur MCP qui n’y figure pas est alors bloqué. allowedAddresses ouvre l’accès au seul serveur de Linkr sans toucher au reste.

Choisir un modèle

LibreChat a besoin d’au moins un modèle de langage. Pour des données de santé, nous recommandons très fortement un modèle hébergé dans l’établissement — la page Agents explique pourquoi. Avec Ollama sur la même machine, ajoutez dans librechat.yaml :

endpoints:
  allowedAddresses:
    - "host.docker.internal:11434"
  custom:
    - name: "Ollama"
      apiKey: "ollama"
      baseURL: "http://host.docker.internal:11434/v1/"
      models:
        default: ["gpt-oss:20b"]
        fetch: true
      titleConvo: false
      modelDisplayLabel: "Ollama"

endpoints:
  allowedAddresses:
    - "host.docker.internal:11434"
  custom:
    - name: "Ollama"
      apiKey: "ollama"
      baseURL: "http://host.docker.internal:11434/v1/"
      models:
        default: ["gpt-oss:20b"]
        fetch: true
      titleConvo: false
      modelDisplayLabel: "Ollama"

endpoints:
  allowedAddresses:
    - "127.0.0.1:11434"
  custom:
    - name: "Ollama"
      apiKey: "ollama"
      baseURL: "http://127.0.0.1:11434/v1/"
      models:
        default: ["gpt-oss:20b"]
        fetch: true
      titleConvo: false
      modelDisplayLabel: "Ollama"

fetch: true affiche tous les modèles installés dans Ollama ; default est celui proposé en premier. Le modèle doit savoir appeler des outils — c’est le cas de gpt-oss, de Qwen ou de Mistral, pas de tous. Un serveur vLLM ou tout autre service compatible OpenAI se déclare de la même façon, avec son adresse. La documentation de LibreChat liste les autres fournisseurs.

Un modèle distant voit ce que l'agent lit

Linkr ne filtre pas ce que ses outils renvoient au modèle : résultats de requêtes, noms de concepts, contenu de scripts. Avec un modèle accessible chez un fournisseur externe, limitez-vous à des données ouvertes ou synthétiques — MIMIC-IV Demo, un vocabulaire ATHENA —, jamais à des données de patients réelles.

Régler la demande de confirmation

Par défaut, LibreChat exécute les outils sans rien demander. Pour qu’il attende votre accord avant toute modification, ajoutez sous endpoints, à côté de custom :

endpoints:
  agents:
    recursionLimit: 60
    toolApproval:
      enabled: true
      mode: default
      allow:
        - "get_*_mcp_linkr"
        - "list_*_mcp_linkr"
        - "describe_*_mcp_linkr"
        - "search_*_mcp_linkr"
        - "read_*_mcp_linkr"
        - "preview_*_mcp_linkr"
        - "run_sql_mcp_linkr"
        - "find_linkr_tools_mcp_linkr"
        - "run_linkr_read_tool_mcp_linkr"

LibreChat nomme chaque outil <outil>_mcp_<serveur>. Les outils de la liste allow ne font que lire — lister les projets, décrire une base, chercher un concept, lancer une requête en lecture seule — et s’exécutent sans question. Tous les autres — créer une cohorte, ajouter un widget, exécuter du code — attendent votre accord, que LibreChat demande dans la conversation.

Les outils les moins courants passent par trois outils d’accès : run_linkr_read_tool, run_linkr_write_tool et run_linkr_delete_tool, un par type d’action. Seul le premier figure dans allow : une modification ou une suppression demande toujours votre accord, même par cette voie.

recursionLimit fixe le nombre d’étapes qu’un agent peut enchaîner pour une seule réponse ; la valeur par défaut, 25, est vite atteinte quand une tâche demande plusieurs dizaines d’appels d’outils.

Démarrer LibreChat

Créez dans le dossier de LibreChat un fichier docker-compose.override.yml, que Docker lit en plus du fichier de LibreChat. Il monte librechat.yaml dans le conteneur et le rattache au réseau de Linkr :

services:
  api:
    volumes:
      - type: bind
        source: ./librechat.yaml
        target: /app/librechat.yaml
    networks:
      - default
      - linkr-agents

networks:
  linkr-agents:
    external: true

Puis lancez LibreChat :

docker compose up -d

Créez dans le dossier de LibreChat un fichier docker-compose.override.yml, que Docker lit en plus du fichier de LibreChat. Il monte librechat.yaml dans le conteneur :

services:
  api:
    volumes:
      - type: bind
        source: ./librechat.yaml
        target: /app/librechat.yaml

Puis lancez LibreChat :

docker compose up -d

LibreChat lit librechat.yaml à la racine de son dossier. Lancez-le :

npm run backend

Ouvrez http://localhost:3080 et créez un compte : le premier compte créé devient administrateur de LibreChat. Après toute modification de librechat.yaml, redémarrez LibreChat — docker compose restart api sous Docker — pour qu’il la prenne en compte.

Donner sa clé API

Chaque utilisateur fait cette étape une fois, avec son propre compte :

Dans Linkr, créez une clé : menu de votre compte → Paramètres utilisateur → onglet Clés API → Nouvelle clé API. Copiez-la tout de suite, elle n’est affichée qu’une fois. Le détail est dans Serveur MCP.
Dans LibreChat, ouvrez le menu Serveurs MCP, sous la zone de saisie, et cliquez sur l’icône de réglage à côté de linkr : la fenêtre Configurer les variables pour linkr s’ouvre. Collez-y la clé et enregistrez.

C'est branché

Sélectionnez linkr dans le menu Serveurs MCP et demandez : « Quels projets Linkr puis-je ouvrir ? ». L’agent appelle l’outil qui liste vos projets et vous répond. Demandez ensuite une modification — « crée une cohorte des patients de plus de 65 ans dans ce projet » — : LibreChat vous demande votre accord, puis la cohorte apparaît dans Linkr et dans sa cloche des Notifications.

Linkr et LibreChat sur deux machines

Dans un établissement, LibreChat tourne souvent sur son propre serveur, à côté d’autres outils. Le serveur MCP de Linkr n’écoute alors que sur sa machine — c’est voulu : les clés API y circulent en HTTP simple, donc en clair.

Pour l’ouvrir à LibreChat, placez devant lui un terminateur TLS — le reverse proxy de l’établissement, nginx, Caddy… — qui le publie en https://, par exemple https://linkr-mcp.mon-chu.fr/mcp. Dans librechat.yaml, inscrivez cette adresse dans url. Si ce nom correspond à une adresse du réseau interne, ajoutez-le aussi dans allowedAddresses, avec son port : "linkr-mcp.mon-chu.fr:443".

Le reste de la configuration est inchangé. L’Installation en production décrit le déploiement de Linkr sur un serveur.

Dépannage

LibreChat affiche « Connection attempt to the provided MCP server failed ». Vérifiez dans l’ordre : que Linkr et son serveur MCP tournent ; que l’adresse de url correspond à votre cas, dans le tableau plus haut ; que la même adresse, avec son port, figure dans mcpSettings.allowedAddresses ; et que LibreChat a été redémarré depuis.

LibreChat propose une connexion OAuth au lieu de demander la clé. La ligne requiresOAuth: false manque sous linkr. Ajoutez-la, puis redémarrez LibreChat.

Les outils échouent sur « non autorisé ». La clé saisie est expirée, révoquée, ou a été mal copiée. Créez-en une nouvelle dans Linkr et saisissez-la de nouveau dans Configurer les variables pour linkr.

Linkr ne répond plus sur le port 3000 depuis l’installation de LibreChat. C’est le panneau d’administration de LibreChat qui l’occupe. Changez ADMIN_PANEL_PORT dans le .env de LibreChat, voir l’étape « Installer LibreChat ».

Sous Docker, network linkr-agents declared as external, but could not be found. Le réseau commun n’existe pas encore : docker network create linkr-agents, puis relancez.

Le modèle n’appelle jamais les outils. Vérifiez que linkr est bien sélectionné dans le menu Serveurs MCP de la conversation, et que le modèle choisi sait appeler des outils. Un petit modèle peut aussi s’y perdre : essayez la même demande avec un modèle plus grand.

Après une mise à jour de Linkr, de nouveaux outils n’apparaissent pas. LibreChat garde la liste des outils obtenue à la connexion. Réinitialisez le serveur linkr dans LibreChat ; si vous utilisez un agent LibreChat, cochez aussi les nouveaux outils dans sa configuration.

Pour aller plus loin

Agents — ce qu’un agent peut faire dans Linkr, et comment vous gardez la main.
Serveur MCP — les clés API, les réglages du serveur, et OpenCode comme autre client.
Skills — installer dans LibreChat le skill d’alignement de concepts.
Documentation de LibreChat — toutes les options de mcpServers.