Runnable examples

{
  "name": "semicola-typescript-starter",
  "private": true,
  "type": "module",
  "scripts": { "start": "tsx src/main.ts" },
  "dependencies": { "@modelcontextprotocol/sdk": "^1.29.0" },
  "devDependencies": { "tsx": "^4.20.6", "typescript": "^5.9.0", "@types/node": "^22.0.0" }
}

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

export const SEMICOLA_MCP_URL = process.env.SEMICOLA_MCP_URL ?? 'https://api.semicola.com/mcp/v3';
export const TIMEOUT_MS = 15_000;

/** Connects with an API key or OAuth access token and makes one read-only call. */
export async function connectAndVerify(token: string, endpoint = SEMICOLA_MCP_URL) {
  const signal = AbortSignal.timeout(TIMEOUT_MS);
  const client = new Client({ name: 'semicola-typescript-starter', version: '1.0.0' });
  const transport = new StreamableHTTPClientTransport(new URL(endpoint), {
    requestInit: { headers: { Authorization: `Bearer ${token}` } },
  });
  try {
    await client.connect(transport, { signal, timeout: TIMEOUT_MS });
    const { tools } = await client.listTools({}, { signal, timeout: TIMEOUT_MS });
    const result = await client.callTool({ name: 'get_status', arguments: {} }, undefined, {
      signal,
      timeout: TIMEOUT_MS,
    });
    if (result.isError || result.structuredContent === undefined) {
      throw new Error('get_status failed: check the token and the account it belongs to.');
    }
    return { toolCount: tools.length, status: result.structuredContent };
  } finally {
    await client.close();
  }
}

const token = process.env.SEMICOLA_API_KEY;
if (!token) throw new Error('Set SEMICOLA_API_KEY before running.');
console.log(JSON.stringify(await connectAndVerify(token), null, 2));

mcp>=1.26,<2
anyio>=4.5,<5

"""Verify a Semicola account through the v3 MCP endpoint."""

import asyncio
import json
import os

import anyio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

SEMICOLA_MCP_URL = os.environ.get("SEMICOLA_MCP_URL", "https://api.semicola.com/mcp/v3")
TIMEOUT_SECONDS = 15


async def connect_and_verify(token: str, endpoint: str = SEMICOLA_MCP_URL):
    headers = {"Authorization": f"Bearer {token}"}
    async with streamablehttp_client(endpoint, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("get_status", {})
            if result.isError or result.structuredContent is None:
                raise RuntimeError("get_status failed: check the token and its account.")
            return result.structuredContent


async def main() -> None:
    token = os.environ.get("SEMICOLA_API_KEY")
    if not token:
        raise RuntimeError("Set SEMICOLA_API_KEY before running.")
    with anyio.fail_after(TIMEOUT_SECONDS):
        status = await connect_and_verify(token)
    print(json.dumps(status, indent=2))


if __name__ == "__main__":
    asyncio.run(main())