Skip to main content
Glama
741,183 tools. Updated 2026-11-04 01:59

"MCP servers with SSE endpoints" matching MCP tools:

  • Business-day date math. Three modes inferred from params: add (start+days -> the date N business days away, negative days = before), diff (start+end -> count of business days between, inclusive of both endpoints), is (date -> is it a business day). Optional weekend (default sat,sun) and holidays (comma list of YYYY-MM-DD you supply). No signup, no API key. Pure UTC date-only math; no time-of-day/DST/timezone.
    ConnectorNo auth
  • Full-text search across every UploadKit docs page (88+ pages — getting-started, core-concepts, SDK reference, API reference, dashboard, guides). Ranks matches by keyword frequency in title, description, and body. When to use: any question about UploadKit behaviour, configuration, or integration that the component tools do not answer — middleware, onUploadComplete callbacks, REST API endpoints, webhooks, presigned URLs, CSS theming variables, type-safety setup, migration from UploadThing, rate limits, etc. Returns: JSON { query, count, indexGeneratedAt, matches: [{ path, url, title, description, snippet, score }] }. Sorted by score descending. Read-only. Bundled index (no network call) — results reflect docs at build time.
    ConnectorNo auth
  • Returns the tier, label, masked owner email, creation date, last-used timestamp, today's request count, and daily request limit for the API key used in this request. Useful for agents that need to monitor their own quota consumption. Use this tool when: - You want to check how many requests your key has used today. - You need to know your current tier or daily limit. - You want to confirm that your API key is active. Do NOT use this tool when: - You want to manage multiple keys — this endpoint only reflects the calling key. - You need tracker data — use the tracker endpoints instead. Inputs: - No body or query parameters. Auth is from the `Authorization: Bearer` header. Returns: - `tier`: free, supporter, pro, or enterprise. - `requests_today`: integer count from KV (best-effort; resets at UTC midnight). - `limit_per_day`: null for enterprise (unlimited). - `last_used`: ISO 8601 timestamp, may be null if never used. Cost: - Free. Does not count against the daily request limit. Latency: - Typical: <150ms, p99: <400ms.
    ConnectorNo auth
  • Returns the current status of a task created by an `?async=true` intel request. Poll this endpoint until `status` is one of: `complete`, `failed`, `cancelled`, `expired`. On `complete`, the `result` field contains the same payload the sync endpoint would have returned. On `failed`, `error.message` explains the failure. Use this tool when: - You submitted an intel probe with `?async=true` and need to retrieve the result. - You want to check whether a background task finished without opening an SSE stream. Do NOT use this tool when: - You want real-time event streaming — use `stream_task` instead. - You have no task_id — submit a probe with `?async=true` first. Inputs: - `task_id` (path, required): 26-char ULID returned in the 202 response. Returns: - `status`: `pending` | `running` | `complete` | `failed` | `cancelled` | `expired`. - `result`: populated when status is `complete`. Null otherwise. - `error`: populated when status is `failed`. Null otherwise. - `expires_at`: tasks expire 1 hour after creation. Cost: - Free. Does not count against rate limits. Latency: - Typical: <100ms.
    ConnectorNo auth
  • Retrieve reference documentation for the Zaira Guide API and MCP server on demand. Topics: - getting_started — how to connect via MCP or REST, first queries - endpoints — full REST endpoint reference with parameters - mcp_tools — MCP tool reference with when-to-use guidance and a routing matrix - schema — the tool entry schema - errors — error taxonomy for REST (RFC 9457) and MCP (JSON-RPC) Call with no topic to get an index of available topics. Returns: the requested topic as a Markdown-KV block. With no topic, returns an index listing all available topics with short descriptions; call again with the relevant topic for the full content. Examples (topic selection): - "How do I call the REST API?" → {topic: "getting_started"} - "What parameters does /tools accept?" → {topic: "endpoints"} - "What fields are in a tool entry?" → {topic: "schema"} - "What error shapes do I handle, and what are the recovery steps?" → {topic: "errors"} - "Which MCP tool fits my task?" → {topic: "mcp_tools"} Edge cases: - No topic argument is valid — you get the index. This is the deferred-loading path; don't load every topic at once. - Topic must match the enum exactly (lowercase, underscore). "getting-started" with a hyphen is rejected as an unknown parameter. Risk: read-only, closed-world, idempotent — no state change possible.
    ConnectorNo auth
  • Free and instant: remaining monthly budget, credit balance, when the budget resets, and which endpoints stay free. Check this before a paid call if you are unsure the budget covers it.
    ConnectorNo auth

Matching MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    Integrates the LINE Messaging API with AI agents via the Model Context Protocol, supporting both stdio and SSE transport protocols. It allows agents to send messages, manage rich menus, and retrieve user profile information for LINE Official Accounts.
    10
    3,398 npm
    Apache 2.0

Matching MCP Connectors

  • Pay-per-call tools for autonomous agents, settled in USDC on Base via x402.

  • x402 paid API tools for AI agents on Base: EU/global registries, crypto, wallet & agent trust.

  • Start a cloud cost / FinOps scan of a linked account and return a job_id. Use this when the user wants to find idle, unused or underutilized cloud resources, review cloud spend, or estimate savings. The provider comes from the connection, and **AWS is the only provider supported today** (see `list_connections`). Other clouds will appear on this same tool as connections for them become linkable; nothing else about the call changes. READ-ONLY against your cloud: it reads resource metadata and monitoring metrics and reports; it never changes, stops or deletes anything. (It does create a scan job here and consume that account's scan quota, which is why this tool is not marked read-only.) On AWS it covers EC2 instances, EBS volumes and snapshots, RDS instances, Elastic IPs, NAT Gateways, load balancers, VPCs and VPC endpoints, site-to-site VPN and Transit Gateway attachments, Client VPN endpoints, Secrets Manager secrets, CloudFront distributions and WAF web ACLs. Resource kinds outside that list are not inspected, so a clean scan is not a claim that the whole bill is optimized. `connection_id` picks which linked AWS account to scan (see `list_connections`). Omit it to run against sample data — useful for showing the user what the output looks like before any account is linked. The scan runs asynchronously: poll `get_job(job_id)` roughly every 10 seconds until status is COMPLETED (typically 1-3 minutes), then call `list_cost_findings(job_id)`. Do NOT start another scan while one is running — each scan consumes the account's monthly quota. Pass `idempotency_key` (any unique string you choose) if you may retry on a network error: a retry with the same key returns the original job instead of starting a second scan.
    ConnectorNo auth
  • The RELATIONS between the platform's teaching objects — which Academy module teaches which concept, which study covers which module, what a concept relates to. THIS IS THE ONLY TOOL ON THIS SERVER THAT SERVES EDGES; the others serve rows. Ask it what connects to what, not what exists. SCOPE, AND IT IS NARROWER THAN 'the knowledge graph': it carries four node types — `concept`, `module`, `study`, `vendor` — and every edge whose BOTH endpoints are one of them. The whole graph holds twelve node types; the eight it does not carry are each either served by their own tool or named as not served at all, and `_meta.excluded_node_types` says which per type (consultant data is served at NO tier), so a missing type is a documented boundary and never a silent gap. Call it with `node_id` (e.g. `module:M178`, `concept:C001`, `study:ai-impact-2026-EN`) to walk one node's neighbourhood; with `node_type` and/or `query` to find a node id first. `edge_type` and `direction` narrow a walk. Read `_meta.available_edge_types` — computed from the served projection on every call — before assuming an edge type exists.
    ConnectorNo auth
  • Escape hatch for DPF capabilities that don't have a dedicated tool yet. ALWAYS prefer a dedicated tool when one exists — get_status, list_data, submit_query, delete_data_spec, onboard_data_source, update_data_spec, run_data_job, manage_connection, manage_trigger, setup_scheduled_pull, list_my_workspaces, create_workspace — and reach for this only when none of those fit (e.g. "how many credits do I have?" -> path "/auth/billing", action "get-balance"; a brand-new action added to the API since this server's tools were last updated). Every DPF endpoint is POST <path> with a JSON body of { action, ...fields }, authenticated with your OAuth session automatically. Pass workspaceId explicitly for workspace-scoped actions (data-specs, connections, job-triggers, and under "/workspaces": get-workspace, list-queries, list-bytes-accessed, list-storage, list-processed-files, list-trigger-runs) — omit it entirely for account-level actions that reject one (under "/workspaces": create, get-workspaces, grant-permission, revoke-permission, update/delete-workspace; under "/auth/billing": get-balance only — billing mutations such as purchase-credits, modify-subscription, manage-payment, and create-customer are NOT available via MCP; direct the user to https://dpf-it.com/workspace.html#credits for all credit and subscription management). If unsure of an action's exact fields, read the "dpf-openapi-spec" resource (dpf://openapi/spec.yaml) rather than guessing. Exception: the raw Iceberg REST proxy under "/iceberg/v1/..." (e.g. to read or set a table's "dpf.primary-keys" property via a commit-table request) does not use the action convention at all — give action any placeholder string (it's ignored) and put the real Iceberg REST commit body, e.g. {"requirements":[],"updates":[{"action":"set-properties","updates":{"dpf.primary-keys":"col_a,col_b"}}]}, in params. This tool only issues POST, so Iceberg's GET-based reads (loadTable, listTables) aren't reachable this way. Returns the raw response data (or, for endpoints like the Iceberg proxy with no {success, data} envelope, the whole response body).
    Connector
    Destructive
    OAuth
  • List all schemas of an API specification. Optionally include usage counts showing how many endpoints reference each schema. Set scope to 'project' to look across every spec in the project instead — that returns the groups of structurally identical schemas (candidates for the shared library) plus counts, not the full list, and specId is then ignored. Every entry carries the rowVersion update_schema needs, so a batch of updates does not need a get_schema per schema first. Use this to browse schemas or find a schema id; for one schema with its full definition use get_schema. Requires project context.
    ConnectorAPI key
  • FREE search for paid API endpoints (x402) by task. Pass either a natural-language query (the planner will split it) or pre-split queries[]. Returns a structured plan with up to `maxRoutesPerQuery` candidates per sub-query. No auth. Limits: burst 200/10s, total 1000/15min per IP; free probes 10/h per IP, 20/h per agent. IMPORTANT: Do not fetch `route.url` directly. To execute the preferred route, call `call_endpoint({ routeId, arguments })` - `routeId` from `plan[].routes[].routeId`, `arguments` keys = `parameters[].name` of that route.
    ConnectorNo auth
  • Chamados de suporte do PRÓPRIO user pelo Claude (qualquer logado; identidade SEMPRE do sessionToken). Escopo TRAVADO no dono: você só vê e mexe nos SEUS tickets, nunca nos de outra pessoa (os endpoints de suporte já vazaram PII uma vez e foram fechados; aqui a régua é a mesma). Sub-actions: 'create' (abre chamado; subject obrigatório, message=primeira mensagem opcional, whatsapp opcional; devolve ticketId), 'list' (seus chamados: subject/status open|closed/escalado/data), 'get' (1 chamado seu por ticketId + histórico de mensagens), 'reply' (responde num chamado seu, entra como mensagem do user; reabre se estava fechado). Fechar/escalar/deletar ficam no lado do suporte, fora do MCP.
    ConnectorOAuth
  • List Central Command x402 catalog endpoints (names, prices, parameters, tiers). Purpose: discover which cc.* tools exist and what they cost before calling them. Behavior: READ-ONLY. Does not place orders or charge per-endpoint fees by itself (catalog fetch). Auth: optional X-Api-Key (same catalog is public); payment not required for listing. Cost: free to list. Individual endpoint calls are billed separately when invoked. Rate limit: gateway default. Returns: JSON envelope { ok, endpoint, status, data: { endpoints: [...] } }. Guidelines: Call this first. Then invoke cc.<slug> with required params. Admin-only tools are omitted.
    ConnectorNo auth
  • List the endpoints under one line, identified by `lineKey`; returns `{lineKey, endpoints: []}` with no paging. Each entry reports `id`, `name`, `path`, `httpMethod`, `strict`, `mock`, and `targetCount` — not the endpoint's full body, which get_endpoint returns. Errors when `lineKey` is missing or doesn't match a line in the project.
    ConnectorNo auth
  • Pay for a paid sermon or bundle per-call in USDC on Base using the x402 protocol. This is the only TOOL here that buys SoapBox faith content: the prepaid marketplace-credit tools were retired on 2026-07-15 and their endpoints now answer HTTP 410. (A person can instead buy on the item's web_url in a browser.) No SoapBox account or API key is required — the payment IS the credential (https://github.com/coinbase/x402). SoapBox is the Merchant of Record: the church keeps 70% of net and SoapBox takes 30%. This is a content SALE, never a donation — donations go 100% to the church via give_to_church. Works for a single sermon (sermon_id) or a whole series (bundle_id). Two-step, exactly per spec: (1) call with just the sermon_id (or bundle_id) and NO payment to get back the HTTP-402 payment requirements — the USDC amount, asset, network ('base'), and SoapBox's payTo receive address. (2) Send EXACTLY maxAmountRequired USDC on Base to payTo — any other amount is refused after it has been sent, so don't round it or add to it, and re-run step 1 if time has passed, since the price can change. Sign the 402's onchainPayment.message (your tx hash in lower case, and the item) with the wallet that paid, then call again with x_payment set to base64 of {"txHash":"0x...","signature":"0x..."} — SoapBox checks the on-chain transfer came from the signing wallet, records the sale (church keeps 70%), and returns the transcript. The signature is required: tx hashes are public, and it stops anyone else spending your payment. Idempotent per tx hash. Gasless EIP-3009 'exact' payments via an x402 facilitator are also accepted in the same x_payment field.
    ConnectorNo auth
  • Start here. Returns the AdCritter platform overview - what AdCritter is, the entity hierarchy (organization > advertiser > campaign > ad), the happy path for getting ads running, and how to navigate the other MCP tools. Applications built from this guidance are REST API clients that call /v1/ endpoints, not MCP tool callers. Before writing code, call adcritter_get_api_reference(entity, action) for each entity and action you plan to use - tool descriptions and parameter names describe conceptual behavior only, and do not match actual API routes, field names, query parameters, or response shapes.
    ConnectorNo auth
  • Enumerate every ACC and BIM 360 project the authenticated APS app can see by walking all accessible hubs and their project lists. When to use: The agent needs to discover project IDs before calling any other tool (e.g. the user says 'show me my projects' or 'find issues in the Tower project' and no project_id is known yet). Also useful to confirm hub membership for a project. When NOT to use: Do not call this repeatedly in a loop — cache the result; if the user already supplied a project_id starting with 'b.', skip discovery. APS scopes: data:read account:read. No write scope needed. Rate limits: APS default ~50 req/min per app per endpoint; BIM 360 hubs endpoints are pageable (limit 200). This tool fans out 1 hubs call + N project calls (one per hub) so call it sparingly on tenants with many hubs. Errors: 401 (APS token expired — refresh and retry once); 403 (app not provisioned in the BIM 360/ACC account — ask user to have an account admin add the APS client_id); 404 (rare, indicates hub deleted mid-call); 429 (rate limit — back off 60s); 5xx (ACC upstream — retry with jitter). Side effects: None. Read-only and idempotent.
    ConnectorNo auth
  • Opens a persistent SSE connection that emits events as the task progresses. The stream closes automatically when the task reaches a terminal state or after ~90 seconds (timeout). Heartbeat comments are sent every ~15 seconds to keep the connection alive through proxies. Event types: - `status` — emitted when status changes (pending → running → complete/failed) - `result` — emitted on `complete` with the full result payload - `error` — emitted on `failed`, `cancelled`, or `expired` with error info - SSE comment (`: heartbeat`) — keepalive, no data Use this tool when: - You want real-time progress without polling. - You are in an environment that supports SSE (EventSource API). Do NOT use this tool when: - You want a simple one-shot status check — use `get_task` instead. - Your HTTP client doesn't support streaming responses. Inputs: - `task_id` (path, required): 26-char ULID. Returns: - SSE stream (`text/event-stream`). Each event is `event: <type>\\ndata: <json>\\n\\n`. Cost: - Free. Counts as one request against rate limits when the stream opens. Latency: - First event: <200ms. Stream duration: up to 90s.
    ConnectorNo auth
  • Long-poll: blocks until the next edit lands on this board, then returns. WHEN TO CALL THIS: if your MCP client does NOT surface `notifications/resources/updated` events from `resources/subscribe` back to the model (most chat clients do not — they receive the SSE event but don't inject it into your context), this tool is how you 'wait for the human' inside a single turn. Typical flow: you draw / write what you were asked to, then instead of ending your turn you call `wait_for_update(board_id)`. When the human adds, moves, or erases something, the call returns and you refresh with `get_preview` / `get_board` and continue the collaboration. Great for turn-based interactions (games like tic-tac-toe, brainstorming where you respond to each sticky the user drops, sketch-and-feedback loops, etc.). If your client DOES deliver resource notifications natively, prefer `resources/subscribe` — it's cheaper and has no timeout ceiling. BEHAVIOUR: resolves ~3 s after the edit burst settles (same debounce as the push notifications — this is intentional so drags and long strokes collapse into one wake-up). Returns `{ updated: true, timedOut: false }` on a real edit, or `{ updated: false, timedOut: true }` if nothing happened within `timeout_ms`. On timeout, just call it again to keep waiting; chaining calls is cheap. `timeout_ms` is clamped to [1000, 55000]; default 25000 (leaves headroom under typical 60 s proxy timeouts).
    ConnectorNo auth
  • Discovery meta-tool. Lists ALL available Nordic Data API data endpoints (HTTP method, path, short description) by reading the backend's live OpenAPI spec at runtime — far beyond the curated high-level tools. Use this to discover capabilities the dedicated tools do not cover, then call get_endpoint_schema for parameter details and call_endpoint to execute one. Only read-only operations are listed (GET/HEAD plus the POST screening queries); admin and state-changing endpoints are never returned. Supports an optional `search` keyword filter. The catalog has 230+ endpoints.
    ConnectorNo auth
  • Poll everything new for you since a timestamp, in one call. The preferred polling primitive for agents: rolls new public posts, new public comments, and your notifications into a single request with a server-issued ``next_since`` watermark. Poll on a cadence of **30–60 seconds**; back off when the counts come back zero. The watermark trails the server clock by 10 seconds, so a write still committing when you read lands in the next call: pass ``next_since`` back verbatim, never your own clock. Each requested stream returns ``{truncated, items}``. ``truncated`` flips true when that stream hit its 100-item cap — a long-offline agent should then fall back to the full paginated tools/endpoints (``colony_search_posts``, ``colony_get_post_comments``, ``colony_get_notifications``). Comments carry ``parent_id`` so you can rebuild threading. Requires authentication.
    ConnectorNo auth