Gwirian MCP Server: Use Your Test Scenarios From Cursor and Other AI Tools

Gwirian now includes an MCP (Model Context Protocol) server. That means AI assistants—like the one in Cursor—can work directly with your Gwirian workspace: list projects, create or update features and scenarios, and log scenario executions, all from the same place you write code or docs.

This post explains what the Gwirian MCP server does, what you can do with it, and how to install and use it (with Cursor as an example).

What is MCP?

The Model Context Protocol is an open protocol that lets AI applications talk to external tools and data sources in a standard way. When you connect an MCP server to a client (e.g. Cursor), the AI can call that server’s “tools” (list projects, create a feature, etc.) on your behalf. Gwirian implements this as an HTTP-based MCP server that uses your existing workspace and API token.

What the Gwirian MCP Server Can Do

All operations are scoped to the workspace tied to your API token. Within that workspace you get:

Projects (read-only)

• List projects — List all projects you can access in the workspace.
• Get project — Get one project’s details, including execution info and team members.

Features (full CRUD)

• List features — List features for a project, with optional search.
• Get feature — Get a feature’s details and execution info.
• Create feature — Create a feature (title, description, optional tags).
• Update feature — Update a feature’s title, description, or tags.
• Delete feature — Delete a feature.

Scenarios (full CRUD)

• List scenarios — List scenarios for a feature.
• Get scenario — Get a scenario’s details and executions.
• Create scenario — Create a scenario (e.g. title, optional Given/When/Then).
• Update scenario — Update a scenario.
• Delete scenario — Delete a scenario.

Scenario executions (full CRUD)

• List scenario executions — List executions for a scenario (optional filter by status).
• Get scenario execution — Get one execution’s details.
• Create scenario execution — Record a new execution (e.g. status: passed/failed/pending, optional notes).
• Update scenario execution — Update an execution’s status or notes.
• Delete scenario execution — Delete an execution.

So you can, for example, have the AI create a feature, add scenarios, and then record runs—all via MCP, without leaving your editor.

Prerequisites

1. A Gwirian account and workspace
   Use the hosted app or your self-hosted instance.

2. An API token for the workspace

   • Log in to Gwirian and open your workspace.
   • Go to workspace settings or the workspace members page.
   • Generate an API token for the workspace (if you don’t have one).
   • Copy the token; you’ll need it in the client config.

API tokens are workspace-scoped: each workspace has its own token, and the token defines which workspace the MCP tools use. To use multiple workspaces, configure separate MCP entries (or clients) with different tokens.

How to Install and Use It (Cursor Example)

You add the Gwirian MCP server as an MCP server in your client. Here we use Cursor.

1. Open Cursor MCP settings

• Open Cursor Settings.
• Go to Features → Model Context Protocol.
• Add a new server or edit your MCP config file (often ~/.cursor/mcp.json).

2. Add the Gwirian server

Use the URL of your Gwirian instance and your API token.

Hosted app (production):

{
  "mcpServers": {
    "gwirian": {
      "url": "https://app.gwirian.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN_HERE"
      }
    }
  }
}

Self-hosted or local:

{
  "mcpServers": {
    "gwirian": {
      "url": "https://your-gwirian-domain.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN_HERE"
      }
    }
  }
}

For local development, use your Rails server URL, for example: "url": "http://localhost:3000/mcp".

Replace YOUR_API_TOKEN_HERE with the token you copied from Gwirian. The client will send it in the Authorization: Bearer ... header on every request.

3. Use the tools from Cursor

Once the server is connected, you can ask the AI to:

• “List my Gwirian projects.”
• “Create a feature in project X called ‘Login flow’ with description ‘…’.”
• “List scenarios for feature Y.”
• “Record a scenario execution for scenario Z as passed with note ‘Run on staging’.”

The assistant will call the corresponding MCP tools (e.g. list_projects, create_feature, list_scenarios, create_scenario_execution) in your workspace.

Authentication in Short

• The server expects a Bearer token in the Authorization header.
• The token must be a valid workspace API token from Gwirian.
• All MCP tools run in the workspace associated with that token.

Testing the Connection

If your client supports it, you can trigger a tool list or an “initialize” request to see that the server responds. From the command line you can test with curl (replace YOUR_API_TOKEN with your real token):

# List available tools
curl -X POST https://app.gwirian.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'

A successful response includes the list of tools (e.g. list_projects, get_feature, create_scenario, …). If you get an auth error, double-check the token and that it’s sent as Authorization: Bearer <token>.

Summary

• Gwirian provides an MCP server so AI tools can work with your test scenarios and executions.
• You get read-only access to projects and full CRUD for features, scenarios, and scenario executions in the workspace linked to your API token.
• Installation is done by adding the server URL and your workspace API token to your MCP client (e.g. Cursor’s MCP settings).
• Use the same token for the hosted app (https://app.gwirian.com/mcp) or your own instance; the AI will then operate in that workspace.

If you use Cursor or another MCP-compatible client, try adding the Gwirian server and ask the AI to list your projects or create a feature—you’ll see your Gwirian workspace and the MCP tools in action.