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
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.
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 GitHubFrom the project's GitHub README.
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.

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
mainsaves 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_URLis 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 usehttp://localhost:8080.LAMBDA_ADMIN_TOKENis 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
| Variable | Description |
|---|---|
LAMBDA_PUBLIC_URL | The 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_TOKEN | The password for the administration panel at /admin. If it is not set, the panel is disabled. |
LAMBDA_HOSTING_URL | A 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_CONTACT | An email address the pages offer for questions, such as requests to move an app to production. |
LAMBDA_ABUSE_CONTACT | An email address the pages offer for reporting a harmful app. |
LAMBDA_AGENT_URL, LAMBDA_AGENT_TOKEN | The address of the build agent and the secret shared with it (see below). |
LAMBDA_USAGE_REPORTS | Set to false to stop sending the daily usage report (see Telemetry). |
LAMBDA_DATABASE, LAMBDA_POSTGRES_CONNECTION | Keep 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/buildworkspace 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!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Git
Freeby Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
