开源MCP工具

Build apps with AI

Tell any AI what you want. The generator pipeline walks you through a prompt-driven workflow: describe your idea, copy prompts into your AI chat, paste responses back. The system validates each component and registers it on your node. The result is a full 5-layer stack (extension, data cortex, feature cortex, app-domain cortex, app) that you can package and share as an installable template.

For simple one-off apps, just copy the prompt from the portal landing page, paste it into any AI chat, and you get a working HTML app that uses AIMEAT memory. No registration needed.

Getting Started

Docker — one compose file per backend (run from the aimeat/ directory)

docker compose up # MongoDB (default) docker compose -f docker-compose.postgres.yml up --build # PostgreSQL docker compose -f docker-compose.sqlite.yml up --build # SQLite (no external DB) ```

Server runs on port 40050. Quick test: paste this into any AI chat:

Fetch http://localhost:40050/llms.txt and tell me what this system does.

If the AI reads the docs and explains the protocol, everything works. Admin dashboard URL is shown in the startup log.

Example: Jewelz game (6 minutes)

If your AI can make HTTP calls (Claude Code, Cursor, Copilot), point it at your node's llms.txt and describe what you want:

http://localhost:40050/llms.txt - Build me a match-3 jewels game.
This node has capabilities at /v1/capabilities - check what's available
(like the aimeat-charts cortex for score visualization).
Use the standard AIMEAT app template with login bar and save high scores to memory.

The AI reads the API docs, checks available capabilities, and builds the app:

<img src="assets/screenshots/gen_jewels_game_app1.png" alt="Claude Code building Jewelz game from a single prompt" width="600" />

The result is a match-3 game with AIMEAT login, persistent high scores saved to memory, and a Chart.js score history panel. Runs directly on your node:

<img src="assets/screenshots/gen_jewels_game_app2.png" alt="Jewelz game running on AIMEAT" width="600" />

If your AI chat can't make HTTP calls (ChatGPT, Gemini, free-tier Claude), go to your node's "Try it" page at /v1/classic and copy the app generation prompt from there. The AI will ask you questions (what kind of app, name, style), you answer, and it produces an HTML file. Paste it into the App Catalogue, iterate to improve it, and publish. You can also connect agents to the same app if they use the same memory keys.

Example: Rick and Morty app with server-side extension (under 10 minutes)

Here's what the full flow looks like, from zero to a published app with a server-side API extension:

1. Copy the "Generate Extension" prompt from your profile's Extensions tab. Paste it into any AI chat along with what you want (e.g. "create extension from https://rickandmortyapi.com/"). The AI designs the extension, actions, and scheduled jobs:

<img src="assets/screenshots/gen-extensions-rickmorty1.png" alt="AI designs the extension architecture" width="600" />

2. The AI produces all the files: manifest, 8 action scripts, install command. It validates the YAML, checks sandbox compatibility, and gives you a one-line install:

<img src="assets/screenshots/gen-extensions-rickmorty2.png" alt="AI generates extension files with install command" width="600" />

3. After installing, the extension appears in your profile with all its actions, config, and API endpoint ready to use:

<img src="assets/screenshots/gen-extensions-rickmorty3.png" alt="Extension code review in profile" width="400" /> <img src="assets/screenshots/gen-extensions-rickmorty4.png" alt="Installed extension with actions and API endpoint" width="600" />

4. Now build the app. Point the AI to http://localhost:40050/llms.txt and ask it to make a Rick and Morty app using the existing capabilities at /v1/capabilities. Paste the result into the App Catalogue (Add App > Paste):

<img src="assets/screenshots/gen-extensions-rickmorty5.png" alt="Pasting the app HTML into App Catalogue" width="400" />

5. The app is saved locally. Right-click to publish it to the server so others can use it too:

<img src="assets/screenshots/gen-extensions-rickmorty6.png" alt="App context menu with Publish option" width="300" /> <img src="assets/screenshots/gen-extensions-rickmorty7.png" alt="Publish dialog" width="400" />

That's it. A server-side extension with 8 API actions, a scheduled data refresh job, and a browser app that uses it, all created by copy-pasting prompts into an AI chat.

Note: If you add your AIMEAT node as an MCP server in Claude Code, VS Code, or Cursor, the AI can install extensions and publish apps directly through MCP tools without using the UI at all.

Example: Band Jam, a real-time multiplayer music app

Not everything has to be simple. This is a real-time peer-to-peer music collaboration app built through conversation with Claude. Multiple people join a room, pick instruments, and play together over WebSockets. It has a ProTracker-style pattern editor, live jam mode, note recording, and a note river visualization showing what everyone is playing.

The first prompt produced a working 971-line single HTML file. Then iterating over multiple rounds added features: virtual keyboard for mobile, multi-track recording, reconnect handling, per-track volume control, and 9-track tabbed editing.

<details> <summary>Click to see the AI conversation that built it (4 screenshots)</summary>

<p> <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam1.jpeg" alt="Initial prompt and architecture" width="48%" /> <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam2.jpeg" alt="Feature iteration with honest limitations" width="48%" /> </p> <p> <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam4.jpeg" alt="Multi-track refactor with 9 tracks" width="48%" /> <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam5.jpeg" alt="Final version with per-track controls" width="48%" /> </p>

</details>

Two users jamming together on desktop (top: piano, bottom: drums). Notes sync in real-time across all connected browsers:

<img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam6.jpeg" alt="Two browsers jamming together" width="600" />

Works on mobile too. Virtual drum pads with multi-touch support:

<img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam8_mobile.jpeg" alt="Mobile drum pad interface" width="300" />

All of this runs on AIMEAT's built-in WebSocket realtime layer. The app is a single HTML file, no build step, no external dependencies beyond what the node provides.

Example: 3D world with live AI agents

This one combines everything. A Three.js 3D world where you place and edit objects, with AI agents connected to the same world through AIMEAT's shared memory and chat. The agent (Hermes/OpenClaw, connected via Telegram) sees what's in the world, responds to requests in the world chat, and builds content alongside you in real-time.

<img src="assets/screenshots/gen_3dword_app_with_agent_creating_content_also_by_chatting_with_agent.jpg" alt="3D world with AI agent creating content through chat" width="700" />

On the left: Telegram chat with the agent. The user asks it to build things ("build a house", "add windows"), and it does, updating the 3D world through shared memory. On the right: the world chat panel showing both the user and the agent (maailmat-builder#happyadmin@aimeat-finland-001-genesis) communicating. The agent updates its presence automatically, reads the current world state so it knows what's already there, and creates new objects based on conversation.

The app prompts the agent with the current world state so it can make informed decisions about what to build and where. You edit the world manually (drag objects, place shapes from the toolbar) while the agent builds alongside you. Everything syncs through AIMEAT memory.

Quick start with npx

Requires Node.js 24+. Runs without cloning the repo:

```bash

the CLI stores the token, downloads the runtime-specific skill bundle,

Reference Implementation

The aimeat/ directory contains a full reference implementation in TypeScript (Express 5.2, Node 24). It implements the entire RFC and adds production features: GHII human identities, TOTP 2FA, V8 extensions, package marketplace, push notifications, WebRTC, and a comprehensive admin UI.

Three storage backends: SQLite (personal nodes, local dev; can run :memory: for true in-RAM speed), MongoDB (production), and PostgreSQL (production). MongoDB and PostgreSQL share one Prisma-backed code path, so behaviour is identical across both. The legacy in-memory backend is deprecated -- SQLite :memory: covers the same fast-iteration role using the actual production code path.

See the Implementation Guide v3.0 for full details.

Applications and packages

On top of the protocol sits the application layer. Apps are self-contained HTML files built by AI and stored on your node. Server extensions run in a sandboxed environment, processing data and calling external APIs. Cortex manifests provide shared UI components (charts, forms, layouts) that any app can use. Packages bundle all of these together into installable units that others can browse and install from the template gallery.

and prints a paste-ready Hello Integration instruction for your agent

```

For MCP-capable runtimes (Claude Desktop, MCP-aware IDEs), run aimeat connect serve afterwards to attach the AIMEAT toolset over stdio. For CLI-only runtimes that cannot do stdio, every MCP tool is also reachable via aimeat connect call <tool-name> --json '<input>'.

Multi-agent connector. A single aimeat connect serve process can serve multiple agents at once. Add more agents with aimeat connect add --agent <name> --url ... --owner ...; list them with aimeat connect list; remove with aimeat connect remove <name>. In multi-agent mode, MCP tools accept an optional agent_name parameter; when omitted, the agent marked primary: true in its per-agent config is used. This is the path for connecting one interactive agent (Claude Code) plus several task-runner agents (e.g. CrewAI crews) from one connector process -- see docs/integrations/crewai.md for the task-runner pattern.

Agent modes. Every agent declares a mode at registration: autonomous (continuous), interactive (chat/IDE, default), task-runner (triggered, runs one task, exits), coordinator (orchestrates others), or workstation (a node-visiting agent that lives in the user's own environment -- VSCode, Claude Desktop -- and uses MCP directly). Mode picks the Hello Integration flow: task-runner agents get a reduced 7-step onboarding (no command surface, but the test-task pair is kept as a smoke test), and workstation agents get the narrowest 4-step flow (auth + platform + capabilities + directives) because they are not node-resident -- no runtime config, slash commands, telemetry, or task queue. The others run the full 13 steps. Combine modes with owner-managed tags (crew:*, source:*, role:*, project:*) for filtering and grouping in the profile UI. Details: docs/coding-guidelines/agent-tags.md.

2. Copy the prompt from your profile. If you do not want to install a CLI, your profile -> Agents tab still produces a paste-ready prompt with the device-auth flow baked in -- give it to any AI agent, the agent calls one endpoint, you approve, and it is connected with its own identity and scoped permissions.

Claude Pro, ChatGPT Plus, and other MCP-capable AIs connect directly as MCP clients. OpenClaw, Hermes, Claude Code, and Cursor all work. Three scope presets (readonly, standard, full) control what each agent can access.

Built-in components

Seven bundled cortexes ship out of the box: charts (Chart.js wrapper), forms (inputs, selects, validation), layouts (8 responsive patterns including dashboard grid and fibonacci), navigation (tabs, sidebar, breadcrumbs), dialogs (modals, toasts, alerts), viewers (carousel, grid, DataTable, timeline), and canvas (drawing with export). All are MIT-licensed, zero external dependencies, and available to any app under the AIMEAT.* namespace.

Packages and templates

Bundle apps + extensions + cortex + translations + CSM into one installable unit. Publish to the template gallery and others can browse and install it on their node.

A digital signage package ships as the example template: a complete building display system with an admin panel, kiosk display app, three layout modes (fullscreen, header, full), light/dark themes, and an AI chat prompt that lets non-technical users create custom display views by describing what they want. Install with pnpm seed:examples (requires the server running and AIMEAT_ADMIN_PASSWORD set in .env).

Example: Comicland, an AI comic community (full app, built from VS Code)

Comicland is a community for AI-generated comics built end-to-end from VS Code with Claude Code talking directly to a live AIMEAT node. No CI, no separate deploy step -- each iteration is aimeat_app_publish over MCP and the new version is live on the node within seconds. The whole 5-layer AIMEAT stack (extension, cortex, app) was scaffolded by AI, then evolved through dozens of feature passes in the same workflow.

<p align="center"> <img src="assets/screenshots/comic-land-series-view.png" alt="Comicland series detail with episodes, follow, tip, and owner-only publish/unpublish controls" width="48%" /> <img src="assets/screenshots/comic-land-creation-pipeline.png" alt="Comicland creation pipeline: AI interview -> script JSON -> per-page image prompts -> overlay editor -> publish" width="48%" /> </p>

What's in there: a prompt-driven creation pipeline (AI interview produces a script, the app generates per-page Nano-Banana-style image prompts with character/environment references, the user pastes the resulting images back); a 3-step episode wizard with page or panel images; a drag-and-drop speech-bubble overlay editor with language-keyed translations; multi-tenant reading where any logged-in user can read another author's published series from their own GHII namespace; characters and environments with multiple reference images and a chosen showcase; follow/tip/comment social actions; per-series public/private toggle and per-episode draft/published toggle so authors can prepare quietly and roll out when ready; full FI/EN i18n. All of it stored in AIMEAT memory + storage with proper public/private visibility, no Comicland-specific backend code beyond one sandboxed extension with eleven router-actions.

The same loop works for any sufficiently rich app: open a folder, point Claude Code at the node, and iterate. The MCP tools (aimeat_app_publish, aimeat_extension_install, aimeat_cortex_install, aimeat_memory_*, aimeat_storage_*) cover the entire publish/install/inspect cycle.