# Brancher votre modèle

Un modèle atteint le Hub par un client MCP. Cette page donne l'entrée de configuration de Claude Code et d'opencode, chacune essayée dans le client lui-même, et la réponse que chaque client a reçue de `get_state` sur `hub`. Elle s'adresse aux ingénieurs qui ont déjà installé le Hub.

*Une étincelle dont les rayons sont des lignes des entrées de configuration données sur cette page.*


## Avant l'entrée

Le Hub est installé, `libremodular-mcp init` a été lancé et Inkscape est activé, comme dans le [démarrage rapide](https://libremodular.davalan.fr/fr/quickstart/index.md). Un client exécute le Hub comme une commande avec l'argument `serve`, et le Hub a besoin de la variable `XDG_RUNTIME_DIR`, qu'une session de bureau définit.

Les entrées ci-dessous portent `/usr/bin/libremodular-mcp`, le chemin du paquet. Les essais ont exécuté le Hub compilé depuis les sources : leur `command` était le chemin absolu de `target/release/libremodular-mcp` dans le clone ; le reste de chaque entrée est tel qu'il est écrit ici.

## Avec Claude Code

Claude Code lit les serveurs d'un projet dans `.mcp.json`, à la racine du projet. Placez-y cette entrée :

```json
{
  "mcpServers": {
    "libremodular": {
      "command": "/usr/bin/libremodular-mcp",
      "args": ["serve"]
    }
  }
}
```

La commande `claude mcp add --scope project libremodular -- /usr/bin/libremodular-mcp serve` écrit la même entrée, avec `"type": "stdio"` et `"env": {}` en plus. Claude Code liste les deux outils du Hub sous les noms `mcp__libremodular__get_state` et `mcp__libremodular__execute_script`.

Le modèle était Claude Haiku 5.5, lancé par `claude -p` avec cette entrée et cette demande :

```text
Call the get_state tool of the libremodular MCP server with target_app set to "hub", then copy its JSON answer as it is.
```


Claude Code a appelé `mcp__libremodular__get_state` avec `{"target_app": "hub"}`, et la réponse du Hub lui est parvenue sous cette forme :

**Réponse du Hub**

```json
{
  "app": "hub",
  "app_version": "0.1.0",
  "bridge_version": null,
  "captured_at": "2026-10-28T14:50:40.403Z",
  "connected": true,
  "content_origin": "hub",
  "screenshot": null,
  "state": {
    "modules": [
      {
        "app_version": "1.4",
        "bridge_version": null,
        "connected": true,
        "mode": "cli",
        "name": "inkscape"
      }
    ]
  },
  "warnings": []
}
```


La réponse liste Inkscape, la seule application activée, comme connectée en mode `cli`.

## Avec opencode

opencode lit `opencode.json` dans le dossier du projet. La commande `opencode mcp add libremodular -- /usr/bin/libremodular-mcp serve`, lancée dans ce dossier, écrit ce fichier :

```json
{
  "mcp": {
    "servers": {
      "libremodular": {
        "type": "local",
        "command": [
          "/usr/bin/libremodular-mcp",
          "serve"
        ]
      }
    }
  }
}
```

opencode ne donne pas à son modèle un outil par outil MCP : le modèle écrit du JavaScript pour son outil `execute`, et les outils du Hub s'atteignent par `tools['libremodular']`. Le modèle était Llama 3.1 8B, servi en local par Ollama et lancé par `opencode run --standalone --auto --model ollama/llama3.1:8b-instruct-q5_K_M` avec cette demande :

```text
Use your execute tool to call the get_state tool of the libremodular MCP server with target_app set to "hub", then copy its JSON answer as it is.
```


Le modèle a écrit cet appel :

**Script écrit**

```javascript
tools['libremodular'].get_state({target_app: "hub"})
```


et opencode a rendu la réponse du Hub :

**Réponse du Hub**

```json
{
  "app": "hub",
  "app_version": "0.1.0",
  "bridge_version": null,
  "captured_at": "2026-10-28T14:51:18.715Z",
  "connected": true,
  "content_origin": "hub",
  "screenshot": null,
  "state": {
    "modules": [
      {
        "app_version": "1.4",
        "bridge_version": null,
        "connected": true,
        "mode": "cli",
        "name": "inkscape"
      }
    ]
  },
  "warnings": []
}
```


> **Limite**
>
> Un seul modèle a répondu, une fois la demande formulée avec l'outil `execute`. Une demande qui ne le nommait pas n'a pas rapporté la réponse du Hub ; `qwen2.5-coder:14b`, local aussi, a écrit l'appel sous forme de texte et n'a rien exécuté ; les modèles gratuits hébergés d'opencode avaient atteint leur limite d'usage. `opencode mcp list` n'affiche aucun serveur alors que `opencode run` atteint le Hub : la réponse de `get_state` est la vérification.


## Donner son guide au modèle

Le [guide du modèle](https://github.com/RonanDavalan/LibreModular-MCP/blob/main/docs/GUIDE_LLM.md) tient en six étapes. La première est l'appel fait plus haut : `get_state` sur `hub`, qui liste les applications que le modèle peut utiliser et dit lesquelles sont connectées. Un client qui permet de joindre un fichier prend le guide en pièce jointe.

## Autres clients

> **Limite**
>
> Aucun autre client MCP n'a été essayé. Le fichier où placer l'entrée, et le nom de ses clés, dépendent de votre client.