MCP Mogno (mogno-mcp)

Previously published as @seiva-ai/mcp-server (≤ 0.3.0, Fly.io era). That package is deprecated — install mogno-mcp.

MCP server that lets coding agents in IDEs (Claude Code, Codex, Antigravity, Cursor) operate the Mogno platform (formerly Seiva) — everything the workspace UI does: create, edit, build, publish, roll back and delete apps; run and manage tools, agents, skills, schedules and workflow graphs; MCP servers, Context knowledge, Storage, DataPacks, data sources, subspaces, credentials, members, the HITL approval queue, usage and a synchronous agent chat; push/pull local checkouts; and migrate external projects.

The server announces itself as mogno; the npm package name and the seiva_* tool prefix are kept for compatibility (the Management API, platform prompts and the coverage gate refer to tools by those names). The canonical host is https://cloud.mogno.ai — the old platform.seiva.ai (Fly.io) host is gone. Env vars: MOGNO_URL / MOGNO_API_KEY (the historical SEIVA_URL / SEIVA_API_KEY still work).

There are three entrypoints in this package. tools_manifest.json is the enforced catalog for the default workspace client; the partnership-admin surface is intentionally separate because it has different authority. Pick one per IDE session:

| Entrypoint | When to use | API key type | Extra tools | |---|---|---|---| | client.js | Default for IDE agents. Day-to-day app/tool development from your IDE on a single workspace. | Workspace-scoped (seiva_... from /api-keys) | Local checkout (seiva_app_*, seiva_tool_*) wrapping the seiva CLI | | index.js | Legacy compatibility entrypoint for inspecting multiple workspaces. Partnership keys are read-only on workspace resources. | Partnership-scoped | Workspace switching and workspace creation; use admin.js for partnership writes | | admin.js | Partnership catalog management (publishing partnership tools/agents/skills/apps, gating workspace permissions). | Partnership-scoped | Partnership CRUD (seiva_publish_*, seiva_archive_*, partnership-level audit) |

For 95% of users, client.js is the right answer — it's the bin exposed as mogno-mcp (aliases mogno-mcp-server, seiva-mcp-server) and what npx -y mogno-mcp runs. Use a workspace-scoped key with it for mutations; a partnership key cannot be used to bypass one workspace's boundary or mutate that workspace's resources.

Setup (canonical IDE flow)

1. Register the MCP server in your IDE config. @seiva-ai/cli is pulled automatically as a dependency, so no global install needed — npx handles it. Paste your real API key from /api-keys and the canonical host:

   {
     "mcpServers": {
       "mogno": {
         "command": "npx",
         "args": ["-y", "mogno-mcp"],
         "env": {
           "MOGNO_URL": "https://cloud.mogno.ai",
           "MOGNO_API_KEY": "seiva_YOUR_API_KEY"
         }
       }
     }
   }

   Drop into .mcp.json at the project root (project scope) or register via claude mcp add-json --scope user (Claude Code user scope). VS Code (.vscode/mcp.json) needs top-level servers and "type": "stdio" per entry; Codex uses TOML in ~/.codex/config.toml. The full per-IDE guide is on /api-keys in the platform UI.

2. Restart the IDE. First call to a seiva_* tool warms npx's cache (a few seconds); subsequent calls are instant.

3. Optional — install the CLI for direct use (clone/push/pull/build of apps and tools from a shell, not from your IDE agent):

   npm install -g @seiva-ai/cli
   seiva login   # prompts for URL + API key; writes ~/.seiva/config.json (chmod 0600)

   The MCP server does not require seiva login — credentials come from the env block above. The CLI's config file is only consulted as a fallback when neither env var is set.

Tool catalog

The full set of tools (with HTTP method/path and category) is documented in tools_manifest.json. Highlights by category:

• Apps lifecycle: seiva_create_app, seiva_duplicate_app (the seed-app pattern for a family of apps), seiva_list_apps, seiva_get_app, seiva_get_project_context, seiva_build_app, seiva_test_app, seiva_publish_app
• App admin (Manage App via API, 2026-09): seiva_update_app (name, description, icon, color, category), seiva_list_categories, seiva_set_app_permissions (visibility, users, agents and primary_agent_id), seiva_enable_app_resource / seiva_disable_app_resource (tool, Edge Function, workflow, MCP server or credential → app), seiva_enable_collection_ai_query / seiva_disable_collection_ai_query
• Cross-app data: seiva_list_data_access, seiva_grant_data_access, seiva_revoke_data_access — an app's collections opened to a reader app; the grant lives on the app being read
• Files: seiva_list_files, seiva_read_file, seiva_write_file, seiva_edit_file_diff (prefer this for edits), seiva_write_files (batch), seiva_delete_file
• Runtime debugging: seiva_get_app_runtime_errors, seiva_get_build_logs, seiva_get_app_usage
• DataPacks: seiva_list_available_datapacks, seiva_describe_datapack_table, seiva_request_datapack_grant
• Cross-app: seiva_list_app_agents, seiva_request_external_dependency, seiva_upload_app_asset
• EditLock (multi-agent coordination): seiva_app_lock with action: acquire | renew | release | status
• HITL approvals (polling): seiva_list_pending_approvals
• Credentials: seiva_list_credentials, seiva_create_credential
• Agents / Skills / Tools / Schedules: full CRUD per category; seiva_schedule_action (fire | pause | resume) and seiva_list_schedules with stats: true
• Tool execution: seiva_execute_tool — run any workspace tool (custom, builtin, or partnership) by name with arbitrary input, deterministically (no agent/LLM). Registered in client.js only — the backend requires a workspace-scoped key. Approval-gated tools fail with requires_approval instead of executing
• Collections data: seiva_query_data, seiva_list_records, seiva_count_records, seiva_get_record, seiva_create_record, seiva_create_records (batch, 5000 per call — use it for seeds), seiva_update_record, seiva_delete_record
• DataPack grants: seiva_list_app_data_grants, seiva_grant_app_data, seiva_revoke_app_data
• Local checkout (CLI bridge): seiva_app_checkout (status | pull | push | build) and seiva_tool_checkout (status | pull | push)
• Migration (client-only): seiva_analyze_external_project, seiva_generate_migration_plan, seiva_import_project_files, seiva_import_env_vars
• Logs: seiva_get_logs, seiva_get_session_logs

Whole-workspace surface (2026-09-22 — seiva-mcp/tools/*.js, one module per platform area)

• Workspace / whoami: seiva_get_workspace (workspace, the key's user + role, feature flags), seiva_update_workspace (name, timezone), seiva_get_usage, seiva_chat (synchronous conversation with a workspace agent)
• App lifecycle: seiva_delete_app, seiva_list_app_versions, seiva_rollback_app, seiva_unpublish_app, seiva_list_app_collections; categories seiva_create_category / seiva_update_category / seiva_delete_category
• Workflows (a schedule's graph + runs): seiva_list_workflows, seiva_get_workflow, seiva_set_workflow_graph, seiva_validate_workflow_graph, seiva_regenerate_workflow, seiva_run_workflow (sync | test | async), seiva_list_workflow_executions, seiva_get_workflow_execution, seiva_get_workflow_catalog
• MCP servers: seiva_list_mcp_servers, seiva_get_mcp_server, seiva_create_mcp_server, seiva_import_mcp_servers_json, seiva_update_mcp_server, seiva_delete_mcp_server, seiva_mcp_server_action (sync | test), seiva_list_mcp_server_tools, seiva_toggle_mcp_server_tool, seiva_list_builtin_mcp_servers, seiva_enable_builtin_mcp_server
• Context (knowledge blocks): seiva_list_context_blocks, seiva_get_context_block, seiva_create_context_block, seiva_update_context_block, seiva_archive_context_block, seiva_context_block_action (pause | resume | enable_ai | disable_ai), seiva_list_context_sources, seiva_add_context_source (text, markdown or base64 file), seiva_remove_context_source, seiva_reindex_context_source
• Platform docs: seiva_list_docs, seiva_read_doc
• Storage: seiva_list_storage_files, seiva_upload_storage_file, seiva_get_storage_file, seiva_read_storage_file, seiva_move_storage_file, seiva_delete_storage_file
• DataPacks (workspace level): seiva_list_datapacks, seiva_get_datapack, seiva_describe_datapack, seiva_list_datapack_rows (read-only)
• HITL approvals (whole workspace): seiva_list_approvals, seiva_get_approval, seiva_decide_approval (agent/tool cards, DataPack grants, external deps); seiva_list_pending_approvals stays the per-app view
• Credentials: seiva_get_credential, seiva_update_credential, seiva_delete_credential (values never returned)
• Members: seiva_invite_member, seiva_remove_member
• Subspaces: seiva_list_subspaces, seiva_get_subspace, seiva_create_subspace, seiva_update_subspace, seiva_subspace_action (pause | activate | archive), seiva_list_subspace_members, seiva_subspace_member (add | remove), seiva_list_subspace_apps, seiva_subspace_app_access (grant | revoke)
• Data sources: seiva_list_datasource_servers, seiva_list_datasources, seiva_get_datasource, seiva_create_datasource, seiva_update_datasource, seiva_delete_datasource, seiva_check_datasource_health, seiva_query_datasource (single read-only SELECT)
• Marketplace (read): seiva_list_marketplace_bundles, seiva_get_marketplace_bundle, seiva_list_subspace_offers

Still UI-only (no route — the tools will not exist, do not guess paths)

Create an app with its own Data Model, DataPack row writes and pack activation, pairing a Data Source server (its secret is shown once), API-key management, applying a marketplace bundle to a subspace, approvals that require step-up authentication (the API answers 428), and changing a schedule's status through update (use seiva_schedule_action).

Running from this checkout

The npm package lags the repo (npm view mogno-mcp version vs package.json). Inside the monorepo point the IDE at the local entrypoint instead of npx:

{ "mcpServers": { "mogno": { "command": "node", "args": ["seiva-mcp/client.js"], "env": { "MOGNO_URL": "https://cloud.mogno.ai", "MOGNO_API_KEY": "seiva_..." } } } }

.mcp.json is gitignored (it carries the key); .mcp.json.example is the template. The sibling seiva-cli/ is resolved automatically for the checkout tools.

Migration flow (importing an external project)

When the user says "bring this Lovable / v0 / Next.js project into Seiva", run the migration tools in this order:

1. seiva_analyze_external_project { source_path }
       → JSON: framework, deps, backend SDKs, env vars, assets, incompatibilities
2. seiva_generate_migration_plan { source_path, target_app_id? }
       → markdown plan, show to user, get confirmation
3. seiva_create_app { name, data_scope, ... }            # if target doesn't exist
4. seiva_import_env_vars { env_vars: [{ name, value }] } # before importing files
5. seiva_import_project_files { target_app_id, source_path, dry_run: true }
       → review what will land before committing
6. seiva_import_project_files { target_app_id, source_path }
       → batch upload, aborts on security-audit HIGH violation
7. seiva_request_external_dependency { host, kind, purpose }  # for each fetched host
8. seiva_build_app + iterate using classifier.agent_prompt

Load the framework-by-framework cheatsheet, SDK mapping (Supabase → DataPacks, Firebase → workspace users, etc.), and the "things that NEVER survive the import" list via seiva_get_instructions when starting a migration — the prompt lives on the platform and is delivered through that tool.

Orientation (how the agent learns what it can/can't do)

The server ships an instructions field at MCP init (you'll see it in the session header) that mirrors the in-platform App Builder agent's system prompt: the session protocol plus EditLock / build-loop / HITL etiquette. The full guidance lives on the platform — load it on demand:

1. seiva_get_instructions("ide_agent_guide") first — capability map, hard limits, and a table of which doc to load when.
2. seiva_get_instructions("guardrails") before writing any app code — the closed library list and security rules.
3. seiva_list_instructions to discover more. Category core has the App Builder split (app_builder_core / app_builder_discovery / app_builder_editing — never the ~168KB legacy app_builder); category recipes has per-feature recipes (recipe_forms, recipe_charts, recipe_email, …) — load a recipe before coding that feature.

This is the same lazy-loading pattern the in-platform builder (Monica/Matt) uses: a small always-on core, with depth fetched on demand.

Headless behaviour (no LiveView, no presence)

When the IDE agent operates without the platform's web editor open, three things differ from the in-browser experience:

• Build errors: drive the auto-fix loop yourself with the classifier.agent_prompt returned in 422 responses.
• HITL approvals: poll seiva_list_pending_approvals (60-120s) — there's no modal to wait on.
• EditLock: acquire explicitly before editing in a multi-agent session (seiva_app_lock with action: "acquire" + heartbeats with action: "renew").

Related packages

• @seiva-ai/cli — seiva command (clone/status/pull/push/build/publish + tool variants). The local checkout MCP tools shell out to this CLI. Pulled automatically as a dependency.
• @seiva-ai/support-mcp-server — separate read-only MCP for platform admins (Sentry, Cloud Run, Oban). Different auth.

License

MIT — see LICENSE.