Connect Any AI Agent to Your GEO Data: Cursor, Windsurf, Hermes & Open-Source Stacks

Summary

Because Refine's MCP server is a standard remote Streamable HTTP server with bearer-token auth, it works with any MCP client: IDE agents like Cursor and Windsurf, open-weight models like Nous Research's Hermes running behind an MCP client library, framework agents built with LangChain or the MCP SDKs, and legacy stdio-only clients through the mcp-remote bridge. This guide gives the config for each path.

One Protocol, Every Agent

MCP won because it decoupled tools from assistants. Refine ships one server; the ecosystem ships hundreds of clients. That includes the big names — but also the agent you are building yourself, on whatever model you choose. Your GEO data should be available to all of them, because the best agent for the job changes: the IDE agent while you fix your site, an autonomous scheduled agent for weekly reporting, a self-hosted open-weight model when data must stay on your infrastructure.

Cursor and Windsurf

Both IDE agents take a JSON config. For Cursor, add this to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global); Windsurf uses the same shape in its MCP settings:

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

Why put GEO data in an IDE agent? Because the fixes are often code: llms.txt, schema markup, extractable headings, content pages. An agent that can see which prompts you lose and edit the site that should win them closes the loop in one place.

Open-Weight Models: Hermes, Llama, Qwen

Open-weight models with strong function calling — Nous Research's Hermes line is the reference example — make excellent GEO agents when you need full control: self-hosted inference, no data leaving your infrastructure, custom fine-tunes. The model itself does not speak MCP; your client code does, then exposes the tools to the model as function-calling schemas. With the official Python MCP SDK:

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).

The loop is the same regardless of model: list the Refine tools, hand their schemas to the model, execute whatever it calls, feed results back. Hermes-class models handle the fifteen Refine tools comfortably — the schemas are small and the workflows are shallow (read, decide, write).

Framework Agents: LangChain and Friends

Agent frameworks ship MCP adapters that do the schema conversion for you. With langchain-mcp-adapters, the Refine server becomes a set of LangChain tools in a few lines, usable with any chat model the framework supports — hosted or 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.

The Universal Fallback: mcp-remote

Some clients only speak stdio — they launch a local process and cannot reach remote HTTP servers directly. The mcp-remote package bridges the gap: the client runs it locally, and it proxies everything to the Refine endpoint with your auth header attached.

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

Choosing Where Your GEO Agent Should Live

• Chat assistant (Claude, ChatGPT) — best for ad-hoc analysis and content review by humans in the loop.
• IDE agent (Cursor, Windsurf) — best when the remediation is code and content on your own site.
• Autonomous agent (Agents SDK, LangChain, self-hosted Hermes) — best for scheduled reporting, monitoring loops and bulk content pipelines.
• Mix freely: keys are per-brand, you can hold up to 20, and giving each agent its own key keeps rotation and revocation clean.