FreeInd MCP server

MCP (Model Context Protocol) is the integration standard used by Claude, Cursor, VS Code, OpenCode, and other agents. Instead of writing glue code, your agent discovers the tools below and calls them directly. The server is a thin client over the public REST API, so every tool obeys the same scopes, credits, plan limits, and rate limits as a raw API call.

Typical flows an agent can complete end to end:

• “Make a 16:9 hero image of a red fox in snow, then give me the file.”
• “Suggest the best models for a cinematic product shot, then generate three options.”
• “Turn this brief into an 8-slide deck and export it.”
• “Write and render a 5-minute two-host podcast about our launch.”
• “Run our product-hero workflow for this new subject.”

Authenticate with a FreeInd API key, exactly like the REST API. The key is passed through to the API on every call, so the agent can only do what the key allows.

Authorization: Bearer fi_live_...

# Generate at https://free.ind.in/dashboard/api-keys
# Recommended scopes: generations.read, generations.write, assets.read, usage.read, wallet.read
# Add workflows.read + workflows.write for list_workflows / run_workflow.

Generation tools also need workspaceId and userId so the server can verify the caller is an active member of that workspace before spending credits. Find both under Dashboard → Settings, or call GET /v1/me while signed in to copy your user id.

Claude Code

claude mcp add --transport http freeind https://free.ind.in/mcp/generation \
  --header "Authorization: Bearer fi_live_..."

Claude Desktop

Claude Desktop does not speak remote HTTP directly; bridge it with mcp-remote. Add this to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows), then restart the app.

{
  "mcpServers": {
    "freeind": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://free.ind.in/mcp/generation",
        "--header",
        "Authorization: Bearer fi_live_..."
      ]
    }
  }
}

Cursor

{
  "mcpServers": {
    "freeind": {
      "url": "https://free.ind.in/mcp/generation",
      "headers": {
        "Authorization": "Bearer fi_live_..."
      }
    }
  }
}

VS Code

{
  "servers": {
    "freeind": {
      "type": "http",
      "url": "https://free.ind.in/mcp/generation",
      "headers": {
        "Authorization": "Bearer fi_live_..."
      }
    }
  }
}

OpenCode

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "freeind": {
      "type": "remote",
      "url": "https://free.ind.in/mcp/generation",
      "headers": {
        "Authorization": "Bearer fi_live_..."
      },
      "enabled": true
    }
  }
}

Any MCP SDK

Point the client at the URL and pass the bearer header. The transport is Streamable HTTP; the server opens a session on initialize and returns an Mcp-Session-Id header to send on follow-up requests. A minimal handshake:

curl -sS https://free.ind.in/mcp/generation \
  -H "Authorization: Bearer fi_live_..." \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{
    "protocolVersion":"2025-06-18",
    "capabilities":{},
    "clientInfo":{"name":"curl","version":"1.0"}
  }}'

The generation server exposes 19 tools. Every generation tool takes workspaceId and userId in addition to the arguments below.

The full input schemas are discoverable through MCP itself (tools/list) so agents fill arguments correctly without a separate spec.

The server deliberately enforces model choice: an agent must call suggest_models and let the user pick before create_generation will accept a model. This prevents surprise spending on a premium model.

User: Make a moody product shot of a black espresso machine.

Agent → suggest_models({ brief: "moody product shot, black espresso machine", workspaceId, userId })
Server → 3 models with credit prices and why each fits.

User picks "GPT Image 1".

Agent → create_generation({ modelId, params: {
  mode: "text_to_image",
  prompt: "black espresso machine, dark moody studio, hard rim light, steam",
  aspectRatio: "4:3"
}, workspaceId, userId })
Server → { generationId, status: "queued", estimated: 40 credits }

Agent → wait_for_generation({ generationId })
Server → { status: "succeeded" }

Agent → get_generation_outputs({ generationId })
Server → image URLs the agent can show or download.

The same server can run over stdio from this repository. Set a key in the environment and point your client at the built entry point:

# Run the server locally over stdio (development / self-hosting)
FREEIND_API_URL=https://free.ind.in \
FREEIND_API_KEY=fi_live_... \
  node apps/mcp-generation/dist/index.cjs

{
  "mcpServers": {
    "freeind": {
      "command": "node",
      "args": ["apps/mcp-generation/dist/index.cjs"],
      "env": {
        "FREEIND_API_URL": "https://free.ind.in",
        "FREEIND_API_KEY": "fi_live_..."
      }
    }
  }
}

HTTP runs with npm --prefix apps/mcp-generation run start:http on port 4006 at /mcp.

• 401 api_key_required — the client did not send the bearer header. Some clients need the header on every request, not only during setup.
• user_not_in_workspace — userId is not an active member of workspaceId. Copy both from the same workspace.
• model_selection_required — call suggest_models and pass one of the returned ids.
• insufficient_credits — top up credits or the pay-as-you-go wallet, or use paymentMode: "direct" for a one-time checkout.
• rate_limited — per-key quotas are the same as the REST API. Back off and retry.
• 403 on free.flow tools — add workflows.read / workflows.write to the API key.

Need raw HTTP instead? The API reference documents every endpoint the MCP tools call, plus the Postman collection.