Medialyst MCP

Medialyst exposes a remote MCP server for agents that need to search news, create media lists, inspect media-list tables, update rows and columns, and create share links.

The site docs are for setup. The MCP server is the source of truth for agents while they work.

Get An API Key

1. In Medialyst, open Settings → Developers. The _ segment resolves to your current organization.
2. Click Create API Key.
3. Give the key a clear name, then choose the smallest set of scopes that covers the agent workflow.
4. Copy the key immediately. Medialyst only shows the raw key once.
5. Store the key in your agent client's secret storage or an environment variable such as MEDIALYST_API_KEY.

Endpoint And Auth

Use the production MCP endpoint:

https://medialyst.ai/api/mcp

The server uses MCP Streamable HTTP. Every client must send your Medialyst API key as a bearer token:

Authorization: Bearer <YOUR_API_KEY>

OAuth is not required for v1.

Required Scopes

Use the smallest key that covers the workflow:

Connect Your Agent

Use one of the client snippets below. Replace <YOUR_API_KEY> with the key you copied, or export MEDIALYST_API_KEY when the snippet uses an environment variable.

Claude Code

Claude Code can connect to remote HTTP MCP servers directly:

export MEDIALYST_API_KEY="<YOUR_API_KEY>"

claude mcp add --transport http --scope user medialyst https://medialyst.ai/api/mcp \
  --header "Authorization: Bearer $MEDIALYST_API_KEY"

Verify in Claude Code:

/mcp

Codex

Add this to ~/.codex/config.toml:

[mcp_servers.medialyst]
url = "https://medialyst.ai/api/mcp"
bearer_token_env_var = "MEDIALYST_API_KEY"

Then export the key before starting Codex:

export MEDIALYST_API_KEY="<YOUR_API_KEY>"
codex mcp list

You can also verify from inside Codex:

/mcp

OpenClaw

Register Medialyst in OpenClaw's MCP registry:

openclaw mcp set medialyst '{"url":"https://medialyst.ai/api/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer <YOUR_API_KEY>"}}'

Verify the saved config:

openclaw mcp show medialyst --json

Hermes

Add this to ~/.hermes/config.yaml:

mcp_servers:
  medialyst:
    url: "https://medialyst.ai/api/mcp"
    headers:
      Authorization: "Bearer <YOUR_API_KEY>"

Restart Hermes, or reload MCP from an active Hermes session:

/reload-mcp

Cursor

Cursor can use the global MCP config file at ~/.cursor/mcp.json. Add:

{
  "mcpServers": {
    "medialyst": {
      "url": "https://medialyst.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MEDIALYST_API_KEY}"
      }
    }
  }
}

Then start Cursor from a shell where the key is exported:

export MEDIALYST_API_KEY="<YOUR_API_KEY>"
cursor .

You can also open Cursor Settings → MCP, choose Add new global MCP server, and paste the same JSON into the config editor.

Claude Cowork / Claude Desktop

For Claude Desktop-style local MCP configuration, add Medialyst through a stdio bridge in claude_desktop_config.json:

{
  "mcpServers": {
    "medialyst": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://medialyst.ai/api/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

Restart Claude Desktop after saving the file.

Other MCP-Compatible Agents

Use the Streamable HTTP endpoint and bearer header directly:

MCP URL: https://medialyst.ai/api/mcp
Transport: Streamable HTTP
Header: Authorization: Bearer <YOUR_API_KEY>

If your client only supports stdio servers, bridge to the remote endpoint with mcp-remote:

{
  "mcpServers": {
    "medialyst": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://medialyst.ai/api/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

Runtime Docs Tools

Agents should not rely on stale copied schemas. After connecting, they should ask the MCP server how to use the current contract.

Recommended first calls:

{
  "topic": "getting_started",
  "detail": "short"
}

Then, before a mutation:

{
  "tool_name": "apply_table_action",
  "detail": "full"
}

Use include_schema: true only when examples are not enough. Some table-action schemas are large.

Tool Surface

Agent Operating Model

Media lists are workflow tables. The table is the deliverable.

Good agents follow this pattern:

1. Call get_usage_guide.
2. Search or list existing media lists.
3. Create or select a list.
4. Inspect the table before edits.
5. Use returned IDs from tool responses.
6. Preview template-bearing columns before applying them.
7. Apply one focused table action at a time.
8. Verify with get_media_list or inspect_table.
9. Share only when the user asks for a public link.

Token-Efficient Reads

The MCP server is summary-first. Agents should start with compact/default reads, then ask for detail only when they need it.

Compact cell previews drop repeated envelope fields such as workflowType, searchText, sortValue, version, and hasFullValue. Enrichment-health compact mode returns each blocker row-id set once under blockedRowSets so dependent columns can reference a rowSetId instead of repeating the same rows.

Example Workflow

Ask your agent:

Search recent AI infrastructure coverage, create a media list from the best articles, add a Notes column, and share the list.

Expected sequence:

1. get_usage_guide
2. search_news
3. create_media_list
4. inspect_table
5. get_tool_reference for apply_table_action
6. apply_table_action with create_column
7. apply_table_action with patch_cells if notes are known
8. create_share_link after the user asks to share

Troubleshooting

Agent Skill

For open-source agents, use a small bootstrap skill that tells the agent how to connect and when to call the runtime docs tools. Keep detailed schemas on the server.

Install the Medialyst MCP agent skill.