Back to Browse

GenHTTP MCP Server

by MDA2AV
Developer ToolsLow Risk9.9MCP RegistryRemote
Free

Server data from the Official MCP Registry

Write, deploy and host small C# web services and sites at a public address.

About

Write, deploy and host small C# web services and sites at a public address.

Remote endpoints: streamable-http: https://genhttp.dev/mcp

Security Report

9.9
Low Risk9.9Low Risk

Valid MCP server (1 strong, 0 medium validity signals). No known CVEs in dependencies. Imported from the Official MCP Registry. 1 finding(s) downgraded by scanner intelligence.

Endpoint verified · Open access · 1 issue found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Found in Source Code

Found by scanning the linked source code. This listing connects to a hosted endpoint, so none of this runs on your machine: it describes what the server software does where it is hosted.

HTTP Network Access

Connects to external APIs or services over the internet.

How to Connect

Remote Plugin

No local installation needed. Your AI client connects to the remote endpoint directly.

Add this to your MCP configuration to connect:

{
  "mcpServers": {
    "dev-genhttp-lambda": {
      "url": "https://genhttp.dev/mcp"
    }
  }
}

Documentation

View on GitHub

From the project's GitHub README.

GenHTTP Lambda

Cloud: genhttp.dev Community: community.genhttp.run Docker Hub: genhttp/lambda

A self-hosted platform for the apps your coding agent builds.

Coding agents such as Claude Code, Codex and Cursor can write a small web app in minutes. Deploying it usually takes far longer: a container, a port, a reverse proxy entry, a database and backups, repeated for every new app. GenHTTP Lambda gives these apps a single home on your own server. Once your agent is connected, every app it builds is online at its own address within seconds, with a database, a version history and rollback. You operate one container.

docker run -d -p 8080:8080 -v lambda-data:/data -e LAMBDA_ADMIN_TOKEN=secure-password genhttp/lambda

Then open http://localhost:8080.

The front page of a GenHTTP Lambda server

Why GenHTTP Lambda

  • A single container. No database server, Redis, message queue or Kubernetes is required. The server, all apps and their data run in one container and are stored in one volume, so a backup is a copy of that volume.
  • Hundreds of apps per installation. All apps run in the same process, each at its own address, without a separate container, port, proxy entry or database server. genhttp.dev, which runs the same code, hosts more than a hundred apps this way.
  • Deployment is handled by your agent. Any agent that supports MCP can create an app, write and check its code, test a change on a copy, publish it and read its logs, without you having to open a terminal.
  • You stay in control. Every app has an editor that shows what changed and why, restores any earlier version in one click, and gives you access to its records, its visitors and its code.

Use cases

GenHTTP Lambda is designed for small internal tools that often go unhosted because deploying them takes more effort than writing them:

  • In a company, the tools that replace a shared spreadsheet: an inventory of devices and licenses, a vacation or on-call planner, a tracker for orders, approvals or support requests, a form that collects requests and lists them for whoever handles them. Each gets a database instead of a file on a shared drive, a version history, and an address the whole team opens.
  • At home, the pieces around your home automation: a dashboard for your sensors, a webhook receiver that records what your devices report, a small API for your scripts and automations, a page that shows the household the heating schedule or the meter readings.

A request such as "Build a shared task list for the team" produces an app that is online. A follow-up such as "Give every task the day it is due" is tested in a draft before it goes live.

Screenshots

What every app gets

  • An address below /lambda/ on your server or at a subdomain of its own, and a custom domain once the app is moved to production in the panel.
  • Data that is independent of versions: a database for records, a folder for saved files, and secrets for the API keys and passwords of the services it uses. Secret values are entered in the editor; the agent only ever sees their names.
  • Drafts and versions: a change is tested in a draft with a copy of the data and then published, and earlier versions remain available for rollback.
  • Git: every app is a repository. Pushing a commit to main saves a version, and pushing a branch starts a draft.
  • Analytics and logs: page views, referrers and countries once enabled, and the app's output for each request.
  • No lock-in: any app can be downloaded as a standard .NET project and run anywhere else. Nothing ties it to this server.

Under the hood, every app is a small C# program, a GenHTTP handler, which the server compiles and starts within seconds. Writing one by hand is optional:

return Inline.Create()
             .Get(() => "Hello from my app!");

Running it

docker run -d --name lambda -p 8080:8080 -v lambda-data:/data \
  -e LAMBDA_PUBLIC_URL=https://lambda.example.com \
  -e LAMBDA_ADMIN_TOKEN=a-long-password \
  genhttp/lambda
  • One container, one port, one volume. No other services are required: the platform's data and every app's database are SQLite files in /data. If you would rather keep the databases in PostgreSQL, see PostgreSQL.
  • LAMBDA_PUBLIC_URL is the address at which you and your agents reach the server, and the apps' addresses are derived from it. If it is not set, the server answers at any host name and the addresses use http://localhost:8080.
  • LAMBDA_ADMIN_TOKEN is the password for the administration panel at /admin. If it is not set, the panel is disabled.
  • Images are published for amd64 and arm64.

The sample in samples/community provides the same setup with Docker Compose and can optionally include the build agent:

cd samples/community
cp .env.example .env     # the panel's password is secure-password - change it
docker compose up -d

Configuration

VariableDescription
LAMBDA_PUBLIC_URLThe address at which people and agents reach the installation, such as https://lambda.example.com - a host name or an IPv4 address. The apps' addresses are derived from it, and once it is set the server answers only at that name and at localhost. If it is not set, the server answers at any name and the addresses use http://localhost:8080.
LAMBDA_ADMIN_TOKENThe password for the administration panel at /admin. If it is not set, the panel is disabled.
LAMBDA_HOSTING_URLA domain for the apps, such as https://apps.example.com. Each app then answers at its own subdomain (https://my-app.apps.example.com/) instead of below /lambda/. Requires a wildcard DNS record and a wildcard certificate.
LAMBDA_CONTACTAn email address the pages offer for questions, such as requests to move an app to production.
LAMBDA_ABUSE_CONTACTAn email address the pages offer for reporting a harmful app.
LAMBDA_AGENT_URL, LAMBDA_AGENT_TOKENThe address of the build agent and the secret shared with it (see below).
LAMBDA_USAGE_REPORTSSet to false to stop sending the daily usage report (see Telemetry).
LAMBDA_DATABASE, LAMBDA_POSTGRES_CONNECTIONKeep the databases in PostgreSQL instead of SQLite files (see PostgreSQL).

Further settings, covering limits, logging, TLS and analytics, are described in the reference.

Name and logo

The installation presents itself as GenHTTP Lambda until you give it a name and a logo of your own: in the administration panel, under Configuration → Branding. They replace GenHTTP Lambda's in the header of every page, in page titles and link previews, and as the browser tab icon; without a logo, the first letter of the name is shown. Apps built on the installation name it in the "Made with" line at the foot of their pages, and so do the pages that say what an app was built with. The logo may be a PNG, JPEG, GIF, WebP or SVG image of up to 512 KB; a square mark works best. Changes apply to the next page that is opened, without a restart. An agent that you give the admin token can do the same through the REST API (PUT /api/v1/admin/branding) or the MCP tool customize_installation. The links to the project's source code and community remain.

PostgreSQL

Instead of SQLite files in the volume, the installation can keep the platform's records, its analytics and every app's database in one PostgreSQL database - each app in a schema of its own, reached under a database role that can access nothing else:

docker run -d --name lambda -p 8080:8080 -v lambda-data:/data \
  -e LAMBDA_DATABASE=postgresql \
  -e LAMBDA_POSTGRES_CONNECTION="Host=db;Database=lambda;Username=lambda;Password=..." \
  genhttp/lambda

samples/community has a Compose overlay that runs PostgreSQL beside the server. Choose the database before you create apps: data is not moved from one to the other. The apps themselves need no change, since their code does not depend on the database. docs/postgresql.md covers the privileges the user needs, connections, and what differs from SQLite.

HTTPS

The image serves plain HTTP on port 8080. Place it behind your existing reverse proxy, such as Caddy, nginx or Traefik, with a single entry for the whole server, and set LAMBDA_PUBLIC_URL to the https:// address. The server can also serve TLS itself; the reference describes how.

Data and backups

The installation stores all of its data in the volume at /data: its database, every version of every app, the apps' records and files, their git history, the logo and the showcase's pictures, and secrets.key, the key the apps' secrets are encrypted with. Back up the entire volume, including secrets.key. Without that file, the stored secrets cannot be decrypted. With PostgreSQL, back up the database as well.

Updating

docker pull genhttp/lambda
docker compose up -d     # or: docker rm -f lambda, then run it again

The database is migrated when the server starts. Apps and their data are left unchanged.

Connecting an agent

The Publish page (/ship) explains how to connect each agent. For Claude Code, a single command is sufficient:

claude mcp add --transport http genhttp http://localhost:8080/mcp

Other agents can add a remote MCP server at http://localhost:8080/mcp (the value of LAMBDA_PUBLIC_URL followed by /mcp).

You can then describe what you need, for example "Build a guestbook, with a page where I approve the entries." The agent creates the app, publishes it and returns its address and its editor link. Store the editor link safely: it grants full control over the app and cannot be recovered.

Agents that can make HTTP requests or use git can work that way instead: the REST API is documented at /api/v1/scalar/, and each app's git address is shown in its editor.

Rules for agents

Every agent, the build agent included, starts by reading the platform's guide (the MCP tool platform_guide). You can add a section of your own to it, with how apps are built on your installation - the architecture you prefer, the language apps are written in, the colours of your organisation, data they must not keep: in the administration panel, under Platform → Guide, which also shows the guide as agents read it, or through the REST API (PUT /api/v1/admin/guide). Your section comes last, after the platform's own: agents follow it wherever the guide leaves them the choice, and it cannot change what the platform requires or enforces, such as its limits or the rules about connecting to other servers. It is limited to 6 KB, since agents read the whole guide with every call. Agents working in a git clone read its AGENTS.md instead, which does not include your section.

Building apps from a description: the build agent (optional)

With the build agent enabled, the Create a website page (/build) is a workspace in the style of a chat: people describe the app they want, and an agent on your server writes it and publishes it. The app then appears in a list beside the conversation, where they can keep asking the agent about it - how many people visited, what was entered, whether something fails - or for changes and settings, each a message. No coding agent of their own is required. The list is kept in the browser that built the apps; other apps are added with their editor link. Each message counts against the daily limit set in the panel's Limits section, and the panel's Settings can turn off building new apps, asking about existing ones, or both.

The build agent is optional and is the only part of the setup that runs outside the main container. It requires:

  • a Claude subscription, with a token created by claude setup-token;
  • Docker on the same machine: for every build, the agent starts a short-lived container that can reach only this server and Anthropic.

In samples/community/.env, set CLAUDE_CODE_OAUTH_TOKEN, a random LAMBDA_AGENT_TOKEN (openssl rand -hex 32), LAMBDA_AGENT_URL=http://agent:8401 and DOCKER_GID (getent group docker | cut -d: -f3), then start it:

docker compose --profile agent up -d

Security and operations

  • Apps share the platform's address. Below /lambda/, an app runs on the same origin as the editor and the administration panel, so its pages could read what those store in your browser - including the editor links that the /build workspace remembers. The editor does not send its address to apps, and the panel keeps its password for the current tab only, but this setup is intended for apps built by you and your team. To host apps for people you do not know, give the installation a separate domain for them (LAMBDA_HOSTING_URL); each app is then a site of its own.
  • Apps run inside the server process. This is what makes hosting hundreds of them inexpensive. Their code is checked for prohibited operations before it runs, but it shares the server's process: this is not a sandbox. Only run code you would be prepared to run yourself.
  • Connecting to other servers requires approval. An app's code may connect to other servers, for example to call an API, open a socket or send email, only once you have allowed it in the panel's Connectivity section, where its owner's request is listed together with its purpose. Apps in production may connect without approval, unless you decline it; this default is set per tier under Limits. Without this rule, anybody could route their traffic through your server with an app that fetches whatever address it is given. Pages that fetch from other sites in the browser need no approval, and agents are instructed to use that approach wherever possible.
  • Unused apps are taken offline. A new app starts in the sandbox: by default, one that is neither visited nor changed for 30 days is taken offline, and removed 90 days after that. Moving an app to production in the panel (All lambdas, the app's page, Manage, Tier) keeps it online, with more room and a custom domain, and has it compiled as the server starts, so its first visitor after a restart does not wait for that. On an installation run for a team rather than for strangers, set New lambdas start in to Production under Limits; how long sandbox apps last is set there as well. Every app is then compiled in the background after each restart, one after another.

Telemetry

The community edition sends a usage report once a day to https://telemetry.genhttp.run: the version, the machine, which options are enabled and counts over the apps, never anything about an individual app or person. Set LAMBDA_USAGE_REPORTS=false to disable it. docs/telemetry.md lists what a report contains.

For developers

GenHTTP Lambda is a set of components (the platform's services, the REST API, the MCP endpoint, the runner that serves the apps, the editor, the administration panel and the published sources) which a host composes in the same way as any other GenHTTP application:

var site = Layout.Create()
                 .Add(PlatformRoutes.Api, RestApi.Create(platform))
                 .Add(PlatformRoutes.Mcp, McpServer.Create(platform))
                 .Add(PlatformRoutes.Editor, Editor.Create(platform))
                 .Add(PlatformRoutes.Admin, AdminPanel.Create(platform))
                 .Add(SourcePages.Create(platform))
                 .Add(LandingPage.Create(platform));

return await LambdaServer.Create(platform)
                         .Settings(settings)
                         .Handler(Runner.Create(platform).Site(site))
                         .RunAsync();

This is src/GenHTTP.Lambda.Community/Program.cs; genhttp.dev runs src/GenHTTP.Lambda.Cloud alongside it. Building and running from source requires the .NET 11 SDK and Node 22:

npm install && npm run build                              # the frontends
dotnet run --project src/GenHTTP.Lambda.Community -c Release
  • docs/reference.md - routes, the API, configuration, operations and architecture.
  • CLAUDE.md - the design decisions behind the project and the rules for changing it.

License

MIT.

Reviews

No reviews yet

Be the first to review this server!