Skip to main content
Glama
810,967 tools. Updated 2026-11-20 09:10

"An open-source backend service for web and app development" matching MCP tools:

  • Provides authoritative information about Develust Technology's software and web development services — including web application development, infrastructure design, backend architecture, and technical consulting. Use this tool for any question about Develust's expertise, service offerings, project capabilities, or how to engage with the company.
    ConnectorNo auth
  • Deploy a GitHub repository as a live web app on Dockhold. Call this when the user wants to put an app online, get a shareable HTTPS URL, or host a demo. Returns the new app id. Two paths: a PUBLIC repo needs only repo_url; a PRIVATE repo needs repo_url plus github_installation_id (call list_github_repos first, each repo comes with the installation_id to pass here). Deploying a private repo turns on auto-deploy: future pushes to that repo redeploy the app automatically. The app builds and comes online automatically; poll get_app_status to watch it. Set memory_mb to size the app's compute, one of the values get_resource_usage reports under compute.steps_mb: 256 MB fits a static site or a small API, 512 MB fits a typical Node or Python web app, and anything that holds data in memory needs more. Omit it and the app gets the minimum slice (256 MB) so it doesn't take your whole compute pool; resize_app changes the size later with no rebuild, applied as a rolling update that replaces the app's instances. The response reports memory_mb (what this app got) and compute_available_mb (what's left in your pool), so size the next app off that. This tool needs a GitHub repo URL: if the code only exists locally (no repo), it cannot be used here, and the user should run `npx dockhold login` then `npx dockhold deploy` in the project folder instead. Requires a token with the deploy scope.
    ConnectorNo auth
  • List open times on Upforge's calendar for a free consultation (usually 30 minutes), in the person's own timezone. Call this before book_consultation and let the person pick a time; never pick one for them. Meeting types come live from the scheduler: general-inquiry is the default, and service types such as web-design, application-development or ai-automation route to the right person. Bookings need about a day's notice, so the search starts tomorrow.
    ConnectorNo auth
  • Keyword search over the list of places to submit a startup. A place's exact name or website ("Indie Hackers", "indiehackers.com") puts it first. Asking for free ("free", "no cost", "$0") leaves out places that are paid only. Product words ("web app", "SaaS", "AI tool", "mobile app") keep only places that take that kind of product. Kind-of-place words ("launch site", "directory", "community") put places of that kind first. Other words match names, websites, regions, and the list's notes. For example "free launch sites for a web app", "AI tool directories", or "Australia". Returns up to 20 places, best match first, each with id, title, url (its row on submitmystartup.com, for citing), and a one-line summary. A query with no specific words returns the best free places. Use fetch with an id for the full record, and find_directories to shortlist by a founder's product and limits.
    ConnectorNo auth
  • Connect a domain the user already owns (lavela doesn't sell domains) and get the DNS records to add at their registrar. target 'hosting' (default) = the web-hosting site, verified and given HTTPS automatically; target 'compute' = a server (`service`), which doesn't verify itself — poll lavela.get_status. The app must be deployed first. Not working yet? lavela.diagnose_domain. Free. Details: https://console.lavela.dev/docs/mcp#domains
    ConnectorAPI key
  • Set how many processes of one type an app or agent runs, the size they run on, or both. For an app, give process_type, such as web, and a count up to the organization's cap. For an agent, count is 0 (paused) or 1 (running). size is economy-<N>x, which stops after 30 minutes without traffic and starts again on the next request, or standard-<N>x, the same machine, which never stops. N is 1, 2, 4, or 8: 1x is 0.25 vCPU and 1 GB, and each step doubles both. Changing size restarts the processes. Give count, size, or both; omitting one keeps it. Scaling down stops running processes, and scaling web to 0 takes an app's URL offline, so confirm with the user first. Setting an agent's count can restart its process even when its count and size stay the same. Websites run no process and are refused. Changing an agent's model is not offered here. Returns the scale and size of each process type after the call. Requires connecting a Valet account.
    Connector
    Destructive
    No auth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables an AI agent to reverse-engineer a compiled program with Ghidra — inspecting decompiled code, instructions, callers, memory bytes, and strings — without any source code. Every reply is labelled as fact, computed, or guess, and each claim traces back to hash-checked saved evidence.
    48 PyPI
    Apache 2.0
  • F
    license
    B
    quality
    C
    maintenance
    Publishes a spending-summary tool alongside an interactive HTML view, letting people click a category in the answer to fetch the individual expense records behind that total. Keeps calculations and their supporting evidence together in a single inspectable flow.
    2
    -

Matching MCP Connectors

  • Read, write, and conversationally review open-source flashcards through split read/write MCP tools.

  • SourceOAuth

    Marketing attribution and analytics for websites connected to Source.

  • Finds deployable apps in NetActuate's marketplace (netactuate.com/marketplace): streaming servers, transcoders, WebRTC, CDN and media software that deploys on NetActuate's edge, open source and from partners such as Wowza, Broadpeak and NETINT. Filter by any mix of words, vendor, category, licensing and freeDemo; with no filter it lists them all, featured first, `limit` at a time. A vendor or category it does not know is explained in a note naming the valid ones. Each result gives the slug, name, vendor (null for open source), tagline, licensing (free, byol, trial), vpu when it needs NETINT VPU hardware, freeDemo with its terms, sizing (minimum and recommended vCPU, RAM and disk) and its URL; count is the full number of matches. Use for 'what can I deploy on NetActuate', 'is there an SRT gateway', 'which apps can I try for free' or 'what does NetActuate offer from Wowza'. One listing in full: get_marketplace_app; the vendors: list_marketplace_partners. Listings do not say where they run; for an app and a place together, use search_netactuate ('Wowza Africa').
    ConnectorNo auth
  • Off: always answers source_off. App Store search results and suggestions sit under robots.txt Disallow lines on apps.apple.com, search.itunes.apple.com and itunes.apple.com, so they are not read. Say that search results are not available from an allowed source, and offer app_tracker_charts instead.
    ConnectorNo auth
  • Semantic passage search over a neural embedding index: describe what you are looking for in natural language and get the closest passages, each with a permanent chunk_id, book/chapter/paragraph, citation, license and source URL. When to use: keyword/BM25 search misses paraphrases or themes ("a story about a soldier returning from war", "清代公案小说里的侠客"). Do not use: to verify an exact quotation (cyberlibrary_verify_quote) or to read a whole book (cyberlibrary_get_chunks). Falls back to BM25 if the embedding service is down. Returns: {query, lang, backend, total_vectors, corpus_version, results[{chunk_id, score, title, author, chapter, para, citation, url, license, snippet}]}.
    ConnectorNo auth
  • Replace .mythex/run.json (the whole file: resend every service and its deploy) and start the preview; long-lived app servers belong here, never in bash. Frontend + API: `services: [{ name, command, port, web: true, deploy }, { name: "api", command, port, web: false, deploy }]`. Commands run at the project root: write `cd server && node index.js` (a service `cwd` is folded into its command the same way). port = the port the dev server already uses (the starter's Vite: 5173); no host/port flags needed. Every service needs its own deploy: static site `{ build, static, runtime: "static" }`, server `{ dockerfile, context? }` (a Dockerfile in a subfolder may COPY paths relative to its own folder; set context to be explicit). The frontend reaches the API at relative /api, proxied by the dev server, so the build carries no absolute API URL. database/storage flags here do not provision: call attach_database / enable_storage. If the preview stays unhealthy, read get_logs and fix the code rather than calling this again and again.
    Connector
    Destructive
    OAuth
  • Publish the app to a public URL. Only when the human asks: it spends credits and changes a public site. Run publish_readiness first. Returns immediately while it builds; poll get_deployment until LIVE or FAILED, and only say it is live once it is LIVE. Omit slug for an app that is already published (a new slug moves it to a second address). A frontend + API app publishes as a site plus one backend per server service; the site routes /api to the backend. If it answers db_changes_need_confirm, show the human what live data would be deleted and pass dbConfirmToken as confirm_db_changes only after they agree.
    ConnectorOAuth
  • Replace .mythex/run.json (the whole file: resend every service and its deploy) and start the preview; long-lived app servers belong here, never in bash. Frontend + API: `services: [{ name, command, port, web: true, deploy }, { name: "api", command, port, web: false, deploy }]`. Commands run at the project root: write `cd server && node index.js` (a service `cwd` is folded into its command the same way). port = the port the dev server already uses (the starter's Vite: 5173); no host/port flags needed. Every service needs its own deploy: static site `{ build, static, runtime: "static" }`, server `{ dockerfile, context? }` (a Dockerfile in a subfolder may COPY paths relative to its own folder; set context to be explicit). The frontend reaches the API at relative /api, proxied by the dev server, so the build carries no absolute API URL. database/storage flags here do not provision: call attach_database / enable_storage. If the preview stays unhealthy, read get_logs and fix the code rather than calling this again and again.
    Connector
    Destructive
    OAuth
  • Publish the app to a public URL. Only when the human asks: it spends credits and changes a public site. Run publish_readiness first. Returns immediately while it builds; poll get_deployment until LIVE or FAILED, and only say it is live once it is LIVE. Omit slug for an app that is already published (a new slug moves it to a second address). A frontend + API app publishes as a site plus one backend per server service; the site routes /api to the backend. If it answers db_changes_need_confirm, show the human what live data would be deleted and pass dbConfirmToken as confirm_db_changes only after they agree.
    ConnectorOAuth
  • Plaintext logins captured by the interactive sensors (sensors that answer as a real service and hold the session): username, password, the service they were tried on, the outcome and the source address, newest first, plus the pairs tried most and a per-service breakdown. Use for "what passwords are attackers trying on SSH", "which credentials did this IP try", "what logins hit MySQL this week". For whether an address is hostile overall, use ioc_lookup_tool; for the rest of what it did in its sessions, use interactive_sessions_tool. service: a service name such as ssh-password, telnet-login, mysql-login, rdp-credssp or smb-ntlmssp, or empty for all. source: an address or CIDR, or empty for all. window: 24h, 7d (default) or 30d, capped at the plan's query window. limit: 1 to 200, default 50. These records feed no verdict, and ioc_lookup_tool does not include them.
    ConnectorNo auth
  • Purpose: save enabled Site Watch settings for an owned Atlasly development after the user explicitly requests monitoring. Requires a connected account with atlasly.site_watch.write permission. Inputs: project_id from list_developments, optional checks, weekly/monthly frequency and radius in metres. Replaces that user's existing watch configuration, including previous choices for omitted fields; omitted fields reset to the defaults below. Present the replacement and defaults for user confirmation before calling. Repeating the same settings is idempotent. Planning, flood and competitive checks default to true; web_search defaults to false. The configured monitoring service may subsequently check independently published planning, flood and web sources. Returns saved settings and an Atlasly link only. This call does not perform a source check, verify source coverage, confirm scheduling or promise future alerts. Review completed checks and delivery in Atlasly. Never enable monitoring without the user's explicit request. Chaining: every response returns site_ref; pass it unchanged into another Atlasly tool to reuse the canonical site, coordinates, boundary confidence, LPA, evidence links, and project context.
    Connector
    Destructive
    No auth
  • Let anyone open some paths of a restricted spawnpoint project with no sign-in, while the rest of the app stays behind sign-in: a webhook (/webhooks/slack), an OAuth callback that people outside the share list return through (/oauth/callback), or pages for those people (/p/*). A callback that only signed-in viewers return through already works and needs no entry. Pass the whole list each time: it replaces the current one, and [] clears it. An entry is an exact path (/webhooks/slack matches only that path) or a folder ending in /* (/p/* matches everything under /p/). Matching is exact and case-sensitive. / and /* are refused: to open the whole app, use set_visibility. At most 20 entries. List only the exact paths a sender or a page needs, never a folder that also holds other routes: /api/* opens the whole API. A public page needs its own files' folders listed too (/assets/* for Vite, /_next/static/* for Next.js), or it opens without its scripts and styles. spawnpoint checks no one on these paths, so a webhook route must check the sender's own signature (for example Slack's signing secret). Takes effect on the next request, with no redeploy. Returns each path's url to give the sender. A sleeping app takes about half a minute to wake and a webhook sender may give up first, so open the app before registering a webhook, or keep it awake with set_always_on.
    Connector
    Destructive
    API key
  • Stops an app until someone resumes it: its address shows a paused page, files, settings and database stay. Use it to take an app offline without losing anything; apps_resume starts it again, apps_delete removes it for good. Unlike sleep, a visitor does not wake a paused app. Returns the paused app. Requires confirm: true.
    Connector
    Destructive
    API key
  • Adds a `development` or `staging` environment to an app, like Add environment in the dashboard. Takes the `app_id` from `apps_list` and the `type`. The production environment exists from the moment the app is created, so it is never created here. The environment is created in the app's region, with its own Meridian hostname, and can scale to zero. It has no deployment yet: deploy to it with `deployment_create`. Optional starting settings: `release_command`, `healthcheck_path`, `cpu`, `memory`, `max_instances`, `concurrency`, `timeout_seconds`, `name` (change them later with `environment_update`). Compute values are limited by the app's plan. Refused when the app's plan does not include another environment of that type (`USAGE_LIMIT_EXCEEDED`). When the app already has an environment of that type, it is returned unchanged with `created: false`, and the starting settings are ignored. Check `auto_deploy` in the answer of `environments_list` afterwards: an app whose pushes deployed to production because it had no development environment deploys them to the new development environment from now on. Returns `created` and the environment in the shape of one `environments_list` entry.
    ConnectorOAuth
  • Changes the settings of one environment, like the dashboard's Hosting settings: `release_command`, `healthcheck_path`, `container_port`, `cpu`, `memory`, `max_instances`, `concurrency`, `timeout_seconds` and `name`. Send only the settings to change; the others keep their value. `null` clears a setting. Takes the `app_id` from `apps_list` and the `environment_id` from `environments_list`. PRODUCTION REQUIRES `confirm: true` in the same call; without it the tool refuses and changes nothing. Only pass `confirm: true` once the developer you act for has agreed to this exact change. Development and staging don't need it. When each setting takes effect: `release_command` and `healthcheck_path` at the next deploy (`config_pending_deploy` becomes true on an environment that is already deployed); `container_port`, `cpu`, `memory`, `max_instances`, `concurrency` and `timeout_seconds` on the running service within a minute or two, with no deploy. A wrong port takes the running app down, so read the port the app listens on before changing it. Compute values are limited by the app's plan: a value above the plan is lowered to it, and the answer returns what was saved. The region, the environment type and the always-on server (`min_instances`) can't be changed here. Returns the environment in the shape of one `environments_list` entry, with `changed` listing the settings that really changed.
    Connector
    Destructive
    OAuth
  • Returns turva.dev's own agent-readiness score from an independent public scanner (isitagentready.com), including category sub-scores, with the measurement date and a link to the scanner's start page, where a new check can be run (the link does not open the recorded reading). Use this when a user asks how turva.dev scores, whether its claims are verifiable, or what proof backs the audit service. For web-security scan results, which are a separate measurement, use get_security_evidence instead. Read-only: returns static JSON that is compiled into the Worker, so it changes nothing and updates only on deploy.
    ConnectorNo auth
  • For a repo with SEVERAL runnable parts, call this BEFORE plan_deploy. You enumerate the candidate surfaces (find every Dockerfile/Containerfile, OPEN each, classify by its EXPOSE + CMD - never by directory name) and pass them in; redu RANKS them with fixed rules (a standalone browser desktop/noVNC > a self-contained web app > a keys-required playground > an API > a headless worker > docs/examples). GUIDED: returns the ranked list to present to the user, who picks. YOLO: auto-selects the TOP-ranked surface. Then run plan_deploy on the chosen surface's path + http_port. (A single-surface repo doesn't need this.)
    ConnectorNo auth