魔术助手

What you can build

• Full-stack business apps — CRM systems, admin panels, booking systems, internal tools; database, secure API and frontend generated from natural language
• Database-driven AI agents — agents that query and update your database and invoke your endpoints, behind your own role-based access control
• AI chatbots and expert systems — crawl a website, get an embeddable chatbot grounded in your own content
• Secure APIs over legacy databases — point it at an existing MySQL, PostgreSQL, SQL Server or MariaDB schema and get a CRUD API in seconds
• Wrappers around third-party APIs — paste an OpenAPI or Swagger URL and get typed, documented endpoints wrapping Stripe, GitHub, Slack or anything else publishing a spec
• MCP tool servers — expose your endpoints to Claude, Cursor, Codex, Qoder or any MCP client
• Background jobs and automation — scheduled tasks written in Hyperlambda, or generated from a plain English description
• Static sites and SPAs — your cloudlet serves files directly, next to the APIs powering them

Getting started

Deploy to DigitalOcean (recommended)

One droplet running the full stack, with persistent volumes for your data, configuration and modules. Create your droplet — edit the single DOMAIN= line in .do/cloud-init.yaml and paste it into the User Data field. HTTPS is automatic through Caddy and Let's Encrypt. Full guide: DigitalOcean deployment guide

Docker Compose (self-hosted)

The one-liner at the top of this README is the fastest route. If you'd rather keep the file around:

<details> <summary>Full <code>docker-compose.yml</code></summary>

version: "3.8"

services:
  backend:
    image: servergardens/magic-backend:latest
    platform: linux/amd64
    container_name: magic_backend
    restart: unless-stopped

    ports:
      - "4444:4444"

    volumes:
      - magic_files_etc:/magic/files/etc
      - magic_files_data:/magic/files/data
      - magic_files_config:/magic/files/config
      - magic_files_modules:/magic/files/modules

  frontend:
    image: servergardens/magic-frontend:latest
    container_name: magic_frontend
    restart: unless-stopped

    depends_on:
      - backend

    ports:
      - "5555:80"

volumes:
  magic_files_etc:
  magic_files_data:
  magic_files_config:
  magic_files_modules:

</details>

Run docker compose up, visit localhost:5555, log in with root / root, and configure the system. More installation options here.

Building and testing

```bash

Run the backend — builds and starts the API on http://localhost:5000

cd backend dotnet run

Type-check and build the dashboard

cd frontend && npm install && npm run build ```

Import any API

Point the Import API tab at any OpenAPI or Swagger URL — OpenAPI 3.x or Swagger 2.0, JSON or YAML — and Magic generates Hyperlambda endpoints wrapping whichever operations you tick. Query parameters and form fields become named, typed arguments carrying the specification's own types, defaults, enums and descriptions, and required ones get validators, so a missing argument is refused before the upstream API is ever contacted.

Because Magic publishes an endpoint's file comment as its MCP tool description and each argument's comment as that argument's description, an imported API arrives at your agent as a set of self-describing tools. Slack's chat.postMessage becomes fifteen individually typed, individually described arguments — not one of them written by hand.

The upstream credential is never written into the generated files. It is read from your configuration at the moment the endpoint is invoked, so the files stay safe to commit, and you declare which of your roles are allowed to invoke the wrapper.

Backend — starts the API on http://localhost:5000

cd backend dotnet run

Bring your own OpenAI API key

Magic uses OpenAI by default — create a key here. If you'd rather not use OpenAI, there are Ollama and HuggingFace plugins that override the inference functions, and chatbots can use BM25 keyword retrieval instead of embeddings — full-text search over your training data, running entirely inside SQLite, needing no OpenAI key and no vectorisation. Semantic and hybrid retrieval still use OpenAI's embeddings API. And if you drive Magic through the MCP server, you don't need an OpenAI key at all.

Python, terminal, and C# integration

Generate and execute Python on the fly and let the LLM use it as a tool, use Bash and the underlying terminal, and create Hyperlambda keywords in C#. Persisted Python scripts can be referenced later as tools, permanently widening your agents' capabilities.

Notice — you must be logged in as root to generate and execute Python or terminal scripts, or create C# extensions. Magic's security model eliminates entire classes of holes, but it is not a magic pill; don't expose endpoints that let third parties execute arbitrary code.

Git integration

Magic was built for software developers from day one, so Git is integrated as part of the platform. Create a project, vibe code your tools and even your GitHub workflows, then commit and push.

Run a plugin's unit tests (each plugin's tests live in its *.tests project)

cd plugins/<plugin>/<plugin>.tests dotnet test

How it compares

FAQ

Is it really free? Yes — MIT licensed, self-hostable, no feature gates. The hosted Hyperlambda code generator is currently free to use; future pricing is expected at $49 per 1,000 requests, and there is no payment wall today.

Do I need an OpenAI API key? For AI code generation and semantic (embeddings) retrieval, yes. If you drive Magic over MCP from Claude or Codex, no. Ollama and HuggingFace plugins can replace inference, and chatbots configured for BM25 keyword retrieval search your training data with SQLite full-text search — no OpenAI involved.

Can I run it completely on my own hardware? Yes. Everything — database, API, frontend, scheduler, chatbots — runs in your own containers, on your own machine.

How is this different from Lovable or Bolt? They generate a frontend and hand the backend to a third-party service. Magic generates and runs the whole backend, needs no deployment step before you can test, and is yours to self-host under MIT.

What database does it use? SQLite out of the box, with full support for MySQL, PostgreSQL, MariaDB and SQL Server. No connectors required.

Do I have to learn Hyperlambda? No. The generator writes it from plain English, and the dashboard's prompt bars cover most workflows. Reading Hyperlambda is much easier than writing it.

What happens if AINIRO disappears? Everything you've generated keeps running — it's MIT-licensed code on your hardware. You'd only lose the ability to generate new code with the hosted generator.

Is AI-generated code safe to execute? That's the point of the security model: Hyperlambda is sandboxed and its vocabulary can be whitelisted per role, so generated code can only invoke functions you explicitly allowed.