> For the complete documentation index, see [llms.txt](https://docs.flora.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.flora.ai/mcp/install/other-clients.md).

# Install FLORA MCP in other clients

Connect FLORA MCP from Windsurf, Gemini CLI, Copilot Studio, Hermes Agent, OpenClaw, or any client that supports remote MCP servers.

[FLORA MCP](https://flora.ai/mcp) is a standard remote MCP server, so any client that supports Streamable HTTP with OAuth can connect. This page covers Windsurf, Gemini CLI, Copilot Studio, Hermes Agent and OpenClaw, then gives the settings for any other client.

| Setting        | Value                                                                                                              |
| -------------- | ------------------------------------------------------------------------------------------------------------------ |
| Server URL     | `https://agents.flora.ai/mcp`                                                                                      |
| Transport      | Streamable HTTP (remote server, nothing to install)                                                                |
| Sign-in        | OAuth with your FLORA account. Headless clients can send a FLORA API key as `Authorization: Bearer <key>` instead. |
| Server name    | `flora`                                                                                                            |
| Check it works | Ask your agent: "List my FLORA workspaces. Don't generate anything."                                               |

| Client                       | Jump to                           |
| ---------------------------- | --------------------------------- |
| Windsurf (now Devin Desktop) | [Windsurf](#windsurf)             |
| Gemini CLI                   | [Gemini CLI](#gemini-cli)         |
| Microsoft Copilot Studio     | [Copilot Studio](#copilot-studio) |
| Hermes Agent                 | [Hermes](#hermes)                 |
| OpenClaw                     | [OpenClaw](#openclaw)             |
| Anything else                | [Any MCP client](#any-mcp-client) |

## Windsurf

Windsurf is now Devin Desktop. Its default agent and the Devin CLI read MCP servers from `~/.config/devin/mcp_config.json` (macOS and Linux), so one command adds FLORA:

```bash
devin mcp add -s user flora https://agents.flora.ai/mcp
devin mcp login flora
```

`devin mcp login flora` opens FLORA's sign-in page. Tokens are stored locally and refreshed. To edit the file by hand instead, add:

```json
{
  "mcpServers": {
    "flora": {
      "url": "https://agents.flora.ai/mcp",
      "transport": "http"
    }
  }
}
```

The legacy Cascade agent reads the same file and also accepts `serverUrl` in place of `url`. Refresh servers from the **⋯** (Actions) menu in the Cascade panel after editing.

**Verify:** `devin mcp list` shows `flora`. Then ask the agent "List my FLORA workspaces. Don't generate anything."

**Gotchas:** on a team plan, an admin can turn MCP off or allow only listed servers; ask them to allow `https://agents.flora.ai/mcp`. Use `-s project` to write `.devin/mcp_config.json` in a repo instead.

**Remove:** `devin mcp remove flora`.

## Gemini CLI

Gemini CLI connects to Streamable HTTP servers through `httpUrl` and handles OAuth itself: it sees FLORA's `401`, finds the sign-in endpoints, registers, and opens your browser.

```bash
gemini mcp add --transport http flora https://agents.flora.ai/mcp
```

This writes to the project's `.gemini/settings.json`. Add `--scope user` to write to `~/.gemini/settings.json` instead. The entry looks like this:

```json
{
  "mcpServers": {
    "flora": {
      "httpUrl": "https://agents.flora.ai/mcp"
    }
  }
}
```

**Sign in:** in a Gemini CLI session, run `/mcp auth flora`. Your browser opens FLORA's sign-in page. Tokens are stored in `~/.gemini/mcp-oauth-tokens.json` and refreshed automatically.

**Verify:** run `/mcp` to see `flora` and its tools, then ask "List my FLORA workspaces. Don't generate anything."

**Gotchas:** use `httpUrl`, not `url` (`url` means the older SSE transport). Browser sign-in needs a local browser; on SSH or in a container, use an API key with `--header "Authorization: Bearer $FLORA_API_KEY"` instead.

**Remove:** `gemini mcp remove flora`, and delete FLORA's entry from `~/.gemini/mcp-oauth-tokens.json` if you want the token gone too.

## Copilot Studio

Microsoft Copilot Studio adds FLORA as a tool on an agent, using its MCP onboarding wizard.

1. Open your agent's **Tools** page.
2. Select **Add a tool**, then **New tool**, then **Model Context Protocol**.
3. Fill in **Server name** (`FLORA`), **Server description** (for example, "Generates images, video and 3D on FLORA canvases and runs FLORA Techniques"), and **Server URL** (`https://agents.flora.ai/mcp`).
4. For authentication, select **OAuth 2.0**, then **Dynamic discovery**. FLORA supports dynamic client registration, so there's nothing else to fill in.
5. Select **Create**, then **Next**.
6. In **Add tool**, select **Create a new connection**, sign in with your FLORA account, then select **Add to agent**.

**Verify:** in the agent's test pane, ask "List my FLORA workspaces. Don't generate anything."

**Gotchas:** Copilot Studio supports Streamable HTTP only, which FLORA uses. If your environment has a Power Platform data policy for connectors, it also governs the FLORA tool.

**Remove:** remove the FLORA tool from the agent's **Tools** page.

## Hermes

Hermes Agent (Nous Research) connects to remote HTTP servers with OAuth natively. Add FLORA under `mcp_servers` in `~/.hermes/config.yaml`:

```yaml
mcp_servers:
  flora:
    url: "https://agents.flora.ai/mcp"
    auth: oauth
```

Or add it from the shell: `hermes mcp add flora --url https://agents.flora.ai/mcp --auth oauth`.

**Sign in:** run `hermes mcp login flora`, or reload with `/reload-mcp` in a session. Hermes prints an authorize URL, opens your browser when it can, and waits for the callback. Tokens are cached in `~/.hermes/mcp-tokens/flora.json`.

**Verify:** `hermes mcp list` shows `flora`, and `hermes mcp test flora` checks the connection. Then ask "List my FLORA workspaces. Don't generate anything."

**Gotchas:** `auth: oauth` is required. Without it, Hermes doesn't start FLORA's sign-in and the connection fails with `401`. Older guides route Hermes through `mcp-remote`; that still works, but you no longer need it.

**Remove:** `hermes mcp remove flora`, or delete the entry and run `/reload-mcp`. Delete `~/.hermes/mcp-tokens/flora.json` to clear the token.

## OpenClaw

OpenClaw supports remote HTTP servers with OAuth natively. Register FLORA with `openclaw mcp set`, which writes to `mcp.servers` in `~/.openclaw/openclaw.json`:

```bash
openclaw mcp set flora '{"url":"https://agents.flora.ai/mcp","transport":"streamable-http","auth":"oauth"}'
```

**Sign in:** run `openclaw mcp login flora` on the machine that runs OpenClaw, and finish FLORA's sign-in in the browser.

**Verify:** `openclaw mcp list` shows `flora`, and `openclaw mcp doctor flora --probe` checks the live connection. Then ask "List my FLORA workspaces. Don't generate anything."

**Gotchas:** keep `"transport":"streamable-http"`. Without a transport, OpenClaw falls back to the older SSE transport and the connection fails. While `auth` is `oauth`, OpenClaw ignores any static `Authorization` header on that server; to use an API key instead, drop `auth` and set the header.

**Remove:** `openclaw mcp logout flora`, then `openclaw mcp unset flora`.

## Any MCP client

Use these settings in any client that supports remote MCP servers:

| Field     | Value                                                                                                                                       |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| Name      | `flora` (any name works; `flora` keeps docs and skills consistent)                                                                          |
| Transport | Streamable HTTP (often `http` or `streamable-http`; not SSE)                                                                                |
| URL       | `https://agents.flora.ai/mcp`, with no trailing slash                                                                                       |
| Auth      | OAuth 2.1 with PKCE and dynamic client registration. Leave client ID and secret empty. Or a FLORA API key as `Authorization: Bearer <key>`. |

Most clients take one of these JSON shapes. Try the first; add `"type"` if your client asks for a transport:

```json
{
  "mcpServers": {
    "flora": {
      "url": "https://agents.flora.ai/mcp"
    }
  }
}
```

```json
{
  "mcpServers": {
    "flora": {
      "type": "http",
      "url": "https://agents.flora.ai/mcp"
    }
  }
}
```

### Clients without remote server support: mcp-remote

If your client only runs local (stdio) servers, bridge to FLORA with [`mcp-remote`](https://www.npmjs.com/package/mcp-remote). It runs on your machine, speaks stdio to the client and HTTP to FLORA, and handles the browser sign-in. It needs Node.js 18 or later.

```json
{
  "mcpServers": {
    "flora": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://agents.flora.ai/mcp"]
    }
  }
}
```

To try it from a terminal first:

```bash
npx -y mcp-remote https://agents.flora.ai/mcp
```

`mcp-remote` stores sign-in tokens in `~/.mcp-auth` (or the folder `MCP_REMOTE_CONFIG_DIR` points to). If sign-in keeps failing, delete that folder and restart your client:

```bash
rm -rf ~/.mcp-auth
```

To send a FLORA API key instead of signing in, pass it as a header. Some clients mangle spaces inside `args`, so keep the space in the environment variable:

```json
{
  "mcpServers": {
    "flora": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://agents.flora.ai/mcp", "--header", "Authorization:${FLORA_AUTH_HEADER}"],
      "env": {
        "FLORA_AUTH_HEADER": "Bearer ak_XXXX"
      }
    }
  }
}
```

### Check the server from a terminal

A request without a token should return `401` with a `WWW-Authenticate` header. That's the normal answer, and it means the server is up:

```bash
curl -i -X POST https://agents.flora.ai/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{}'
```

```http
HTTP/2 401
www-authenticate: Bearer realm="OAuth", error="invalid_token", error_description="Missing or invalid access token", resource_metadata="https://agents.flora.ai/.well-known/oauth-protected-resource/mcp"
```

A `404` means the path is wrong; check for a trailing slash. Building a client? The OAuth endpoints are listed in [Authentication](/mcp/authentication.md#how-sign-in-works).

### Verify

Ask your agent:

> List my FLORA workspaces. Don't generate anything.

If it lists your workspaces, you're connected. If not, see [Troubleshooting](/mcp/troubleshooting.md).

## Next

* [Quickstart](/mcp/quickstart.md): your first image, with a cost quote first.
* [Authentication](/mcp/authentication.md): OAuth, API keys and disconnecting.
* [Tools reference](/mcp/tools.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.flora.ai/mcp/install/other-clients.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
