The TaskLite connector in ChatGPT, Gemini, Cursor, Codex, VS Code, Windsurf and Claude

Claude Desktop and claude.ai

1. Settings, Connectors, find TaskLite in the directory (or "Add custom connector" with the URL https://mcp.tasklite.net/mcp).
2. Connect, sign in to TaskLite (or sign up on the spot), approve.
3. In a chat, open the + menu, Connectors, and make sure TaskLite is toggled on for that conversation.

Claude Code

Hosted, with OAuth in the browser on first use:

claude mcp add --transport http tasklite https://mcp.tasklite.net/mcp

Or with a personal API key (TaskLite app, Settings, Integrations, API keys), which is what CI and scripts use:

claude mcp add --transport http tasklite https://mcp.tasklite.net/mcp \
  --header "Authorization: Bearer tl_your_key"

Or the local package over stdio:

npm install -g @tasklite/mcp
claude mcp add tasklite -- tasklite-mcp

Verify with /mcp: tasklite should appear with its tools listed. The exact count is on /docs, which is generated from the published package.

Cursor

Cursor reads MCP servers from .cursor/mcp.json in the project or ~/.cursor/mcp.json globally. Streamable HTTP with a key:

{
  "mcpServers": {
    "tasklite": {
      "url": "https://mcp.tasklite.net/mcp",
      "headers": { "Authorization": "Bearer tl_your_key" }
    }
  }
}

Or stdio through the package:

{
  "mcpServers": {
    "tasklite": {
      "command": "tasklite-mcp",
      "env": { "TASKLITE_API_KEY": "tl_your_key" }
    }
  }
}

Restart Cursor; the tools appear under MCP in the agent panel.

OpenAI Codex

Codex CLI takes MCP servers in ~/.codex/config.toml:

[mcp_servers.tasklite]
command = "tasklite-mcp"
env = { TASKLITE_API_KEY = "tl_your_key" }

Streamable HTTP is supported in recent Codex versions with a url key and http_headers; if your version rejects it, the stdio form above always works.

ChatGPT

ChatGPT connects to remote MCP servers through Settings, Connectors (turn on developer mode first under Settings, Apps and connectors, Advanced). Add https://mcp.tasklite.net/mcp, sign in with TaskLite in the OAuth window, then enable the connector inside a chat.

The server implements the search and fetch tools ChatGPT requires, so TaskLite works in regular chat and in deep research: search finds projects, boards and items across your organization, fetch returns one of them in full. The write tools are available too; ChatGPT asks you to confirm before each write.

OpenAI Responses API and Agents SDK

The Responses API can call a remote MCP server directly with the mcp tool. It does not run an OAuth flow, so pass a personal API key in authorization:

{
  "model": "gpt-5",
  "input": "List my projects and how many boards each one has",
  "tools": [
    {
      "type": "mcp",
      "server_label": "tasklite",
      "server_url": "https://mcp.tasklite.net/mcp",
      "authorization": "Bearer tl_your_key",
      "require_approval": "never"
    }
  ]
}

Restrict what the model may call with allowed_tools, for example ["search", "fetch", "query_items"] for a read-only agent. In the Agents SDK the same server is a MCPServerStreamableHttp:

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="tasklite",
    params={
        "url": "https://mcp.tasklite.net/mcp",
        "headers": {"Authorization": "Bearer tl_your_key"},
    },
) as tasklite:
    agent = Agent(name="ops", instructions="Use TaskLite for all data.", mcp_servers=[tasklite])
    result = await Runner.run(agent, "Which orders are overdue?")

Gemini CLI

Gemini CLI reads MCP servers from ~/.gemini/settings.json (or .gemini/settings.json in a project). Remote servers use httpUrl. With OAuth discovery the CLI finds the TaskLite authorization server on its own and opens the browser once:

{
  "mcpServers": {
    "tasklite": {
      "httpUrl": "https://mcp.tasklite.net/mcp",
      "authProviderType": "dynamic_discovery",
      "oauth": { "enabled": true }
    }
  }
}

Or with a key, which is what scripts and shared machines use:

{
  "mcpServers": {
    "tasklite": {
      "httpUrl": "https://mcp.tasklite.net/mcp",
      "headers": { "Authorization": "Bearer tl_your_key" }
    }
  }
}

Check with /mcp inside Gemini CLI; tasklite should show as connected with its tools listed.

Gemini API

The google-genai SDK accepts an MCP client session as a tool, so a Gemini model can call TaskLite without any glue code:

from google import genai
from google.genai import types
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    "https://mcp.tasklite.net/mcp",
    headers={"Authorization": "Bearer tl_your_key"},
) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        client = genai.Client()
        response = await client.aio.models.generate_content(
            model="gemini-2.5-pro",
            contents="Create a board for supplier invoices with the right column types",
            config=types.GenerateContentConfig(tools=[session]),
        )
        print(response.text)

VS Code and GitHub Copilot

VS Code reads .vscode/mcp.json in the workspace (or add the server from the Command Palette, MCP: Add Server). It runs the OAuth sign-in itself:

{
  "servers": {
    "tasklite": {
      "type": "http",
      "url": "https://mcp.tasklite.net/mcp"
    }
  }
}

Windsurf

Windsurf takes remote servers in ~/.codeium/windsurf/mcp_config.json with a serverUrl key:

{
  "mcpServers": {
    "tasklite": {
      "serverUrl": "https://mcp.tasklite.net/mcp",
      "headers": { "Authorization": "Bearer tl_your_key" }
    }
  }
}

Any other MCP client

Anything that runs a stdio server can run tasklite-mcp with TASKLITE_API_KEY in the environment. Anything that supports Streamable HTTP can use the hosted URL with a bearer header. The server also publishes /.well-known/oauth-protected-resource, so clients that implement OAuth discovery can connect with no key at all.

Keys versus OAuth