Connecter n’importe quel agent IA à vos données GEOCursor, Windsurf, Hermes et les stacks open source

Résumé

Parce que le serveur MCP de Refine est un serveur distant standard en Streamable HTTP avec authentification par jeton bearer, il fonctionne avec n’importe quel client MCP : les agents d’IDE comme Cursor et Windsurf, les modèles à poids ouverts comme Hermes de Nous Research derrière une bibliothèque cliente MCP, les agents construits avec LangChain ou les SDK MCP, et les anciens clients limités à stdio via la passerelle mcp-remote. Ce guide donne la configuration de chacune de ces voies.

Un protocole, tous les agents

MCP s’est imposé parce qu’il a découplé les outils des assistants. Refine publie un serveur ; l’écosystème publie des centaines de clients. Cela inclut les grands noms, mais aussi l’agent que vous construisez vous-même, sur le modèle de votre choix. Vos données GEO devraient être accessibles à tous, car le meilleur agent pour la tâche change : l’agent de l’IDE pendant que vous corrigez votre site, un agent autonome planifié pour le reporting hebdomadaire, un modèle à poids ouverts auto-hébergé quand les données doivent rester sur votre infrastructure.

Cursor et Windsurf

Les deux agents d’IDE prennent une configuration JSON. Pour Cursor, ajoutez ceci dans .cursor/mcp.json (projet) ou ~/.cursor/mcp.json (global) ; Windsurf utilise la même forme dans ses réglages MCP :

{
  "mcpServers": {
    "refine": {
      "url": "https://app.refine-app.com/api/mcp/mcp",
      "headers": {
        "Authorization": "Bearer rfn_live_your_key"
      }
    }
  }
}

Pourquoi mettre des données GEO dans un agent d’IDE ? Parce que les corrections sont souvent du code : llms.txt, balisage schema, titres faciles à extraire, pages de contenu. Un agent qui voit les prompts que vous perdez et peut modifier le site qui devrait les gagner ferme la boucle en un seul endroit.

Les modèles à poids ouverts : Hermes, Llama, Qwen

Les modèles à poids ouverts dotés d’un bon appel de fonctions, la gamme Hermes de Nous Research en est l’exemple de référence, font d’excellents agents GEO quand vous avez besoin d’un contrôle total : inférence auto-hébergée, aucune donnée qui quitte votre infrastructure, fine-tuning sur mesure. Le modèle lui-même ne parle pas MCP : c’est votre code client qui le fait, puis expose les outils au modèle sous forme de schémas d’appel de fonctions. Avec le SDK MCP officiel en Python :

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    "https://app.refine-app.com/api/mcp/mcp",
    headers={"Authorization": "Bearer rfn_live_your_key"},
) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await session.list_tools()
        # Convert tools to your model's function-calling format,
        # run Hermes (or Llama, Qwen...) in a tool-use loop,
        # and execute calls with session.call_tool(name, args).

La boucle est la même quel que soit le modèle : lister les outils Refine, transmettre leurs schémas au modèle, exécuter ce qu’il appelle, lui renvoyer les résultats. Les modèles de la classe d’Hermes gèrent sans difficulté les quinze outils de Refine : les schémas sont courts et les tâches peu profondes (lire, décider, écrire).

Les agents de frameworks : LangChain et consorts

Les frameworks d’agents proposent des adaptateurs MCP qui font la conversion de schémas pour vous. Avec langchain-mcp-adapters, le serveur Refine devient un ensemble d’outils LangChain en quelques lignes, utilisables avec n’importe quel modèle de chat pris en charge par le framework, hébergé ou local :

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "refine": {
        "transport": "streamable_http",
        "url": "https://app.refine-app.com/api/mcp/mcp",
        "headers": {"Authorization": "Bearer rfn_live_your_key"},
    }
})
tools = await client.get_tools()
# Pass tools to any LangChain / LangGraph agent.

La solution universelle : mcp-remote

Certains clients ne parlent que stdio : ils lancent un processus local et ne peuvent pas joindre directement des serveurs HTTP distants. Le paquet mcp-remote fait le pont : le client le lance en local, et il relaie tout vers l’endpoint de Refine en ajoutant votre en-tête d’authentification.

{
  "mcpServers": {
    "refine": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://app.refine-app.com/api/mcp/mcp",
        "--header", "Authorization: Bearer rfn_live_your_key"
      ]
    }
  }
}

Choisir où doit vivre votre agent GEO

• Un assistant de chat (Claude, ChatGPT) : idéal pour l’analyse ponctuelle et la relecture de contenus par des humains.
• Un agent d’IDE (Cursor, Windsurf) : idéal quand la correction passe par le code et les contenus de votre propre site.
• Un agent autonome (Agents SDK, LangChain, Hermes auto-hébergé) : idéal pour le reporting planifié, les boucles de surveillance et la production de contenus en volume.
• Combinez librement : les clés sont par marque, vous pouvez en avoir jusqu’à 20, et donner sa propre clé à chaque agent simplifie la rotation et la révocation.