Skip to main content

Use Yamify MCP with Claude, Cursor, and Lovable

Yamify screenshot

AI tools using Yamify MCP interact with the same workspaces and apps visible in the Yamify dashboard.

Yamify MCP gives AI tools a structured way to work with your Yamify account. Instead of asking an agent to click through the dashboard, you let it call explicit Yamify tools.

What Yamify MCP can do​

Today, Yamify MCP supports these core actions:

  • yamify.list_workspaces
  • yamify.list_apps
  • yamify.deploy_inference_api

That means an AI tool can:

  • Discover what workspaces you already have
  • Inspect what apps are live in each workspace
  • Create a new inference endpoint inside an existing Yam

Why this matters​

This turns Yamify into a control plane for AI builders.

You can use one assistant to:

  • inspect your live automations
  • find the right workspace
  • create a model endpoint
  • wire that endpoint into another app or workflow

Best uses by tool​

Claude​

Claude is strongest when you want planning plus tool-driven execution.

Use Claude with Yamify MCP to:

  • audit active workspaces before shipping a feature
  • list existing apps for a client account
  • create an inference endpoint for a new workflow
  • document deployment state in plain English

Example workflow

  1. Ask Claude to list your Yamify workspaces.
  2. Ask it which workspace already contains the client automation stack.
  3. Ask it to create a new inference API in that workspace.
  4. Ask it to generate the frontend or n8n integration code that calls the endpoint.

Cursor​

Cursor is strongest when the agent is already inside the codebase.

Use Cursor with Yamify MCP to:

  • provision infrastructure while editing app code
  • pull app inventory during implementation
  • create a model endpoint and immediately wire it into the current repo

Example workflow

  1. Open your product repo in Cursor.
  2. Ask Cursor to provision a Yamify inference endpoint for support-chat.
  3. Ask Cursor to add a server action or API route that calls the endpoint.
  4. Ask Cursor to generate a smoke test against the Yamify-hosted endpoint.

Lovable​

Lovable is strongest when you want fast UI generation.

Use Lovable with Yamify-backed endpoints to:

  • build internal AI tools quickly
  • create simple SaaS frontends on top of Yamify-hosted models
  • ship demos without operating backend model infrastructure manually

Best pattern

Use Yamify MCP or Yamify’s inference API as the backend control and model layer, while Lovable handles the frontend experience.

High-value workflows​

1. AI support console​

  • Use MCP to create an inference endpoint
  • Use Lovable or Cursor to build the UI
  • Use n8n to push tickets or summaries into downstream systems

2. Sales copilot for agencies​

  • Use MCP to inspect active workspaces
  • Use Inference API to classify leads
  • Use OpenClaw or n8n for follow-up automation

3. Client operations dashboard​

  • Use MCP to query deployed apps
  • Build a frontend that shows live deployment inventory
  • Add team invites so client stakeholders can view the same workspace

Safe usage rules​

  • Keep prompts focused on workspace-level actions, not raw infrastructure assumptions
  • Store provider keys only in approved app inputs or secret flows
  • Prefer listing workspaces and apps before taking any provisioning action
  • Use inference endpoints for runtime traffic, not MCP

What Yamify MCP is not​

Yamify MCP is not a replacement for your app runtime API.

Use it for:

  • control-plane actions
  • discovery
  • provisioning

Do not use it for:

  • end-user chat traffic
  • long-running streaming UX in your product
  • bulk unbounded cluster operations

Suggested prompt ideas​

You can give an AI tool prompts like:

  • “List my Yamify workspaces and tell me which one already has OpenClaw installed.”
  • “Create a Yamify inference endpoint called sales-brain in my agency-prod workspace.”
  • “Inspect my deployed apps and generate a summary of what each client workspace is running.”
  • “Create a Yamify-hosted inference endpoint and then write the Next.js route that calls it.”

Next step​

Continue with Deploy and Call a Yamify Inference API if you want to build on top of a live model endpoint.