LiquidMetal AI Developer Mode: show me a minimal manifest and the exact CLI command to deploy it (raindrop build create)

Quick Answer: In LiquidMetal AI Developer Mode, you can deploy a minimal Raindrop app with a tiny manifest that defines a single service, then run one CLI command to ship it. Define your app in raindrop.manifest.ts, then go from manifest to a production backend in seconds with raindrop build create.

Why This Matters

If you’re building AI agents or RAG workflows, the hard part usually isn’t the model—it’s getting a reliable backend into production. Developer Mode exists so you can describe your stack once, let Raindrop handle the infrastructure, and still keep full control of the code. A minimal manifest and a single raindrop build create call means you can move from “idea” to “production API” without standing up servers, databases, auth, or glue code.

Key Benefits:

• Production-ready from day one: Even a minimal manifest gives you a fully versioned, observable, globally scalable API instead of a local demo script.
• No infrastructure glue work: You define a service; Raindrop wires up deployment, routing, and smart primitives so you’re not stitching together serverless, auth, and storage.
• Fast iteration with safety: Every build is versioned, so you can experiment, roll forward, or roll back manifests and code with confidence.

Core Concepts & Key Points

Concept	Definition	Why it's important
Developer Mode	The Raindrop workflow where you define your app with a manifest and TypeScript implementation.	Gives developers precise control over services and smart primitives while outsourcing infra, auth, and deployment.
Raindrop Manifest	A TypeScript “blueprint” file (e.g., raindrop.manifest.ts) that declares your application, services, and required components.	Treats your entire backend as code: versioned, repeatable, and easy to deploy or roll back.
raindrop build create	Core CLI command that reads your manifest and creates a complete, versioned build on Raindrop.	Compresses “provision + wiring + deploy” into one step and ensures code, data, and smart primitives share a single version lineage.

How It Works (Step-by-Step)

At a high level, Developer Mode looks like this:

1. Install the Raindrop CLI.
2. Create a minimal manifest defining a single service.
3. Implement your service handler in TypeScript.
4. Run raindrop build create to build and deploy your app.

Below is the minimal, production-ready path.

---

1. Install the Raindrop CLI

First, install the Raindrop CLI globally:

npm install -g @liquidmetal-ai/raindrop

Sign up at liquidmetal.ai to get your organization ID and API credentials. You’ll use these for authentication and manifest configuration.

---

2. Create a Minimal Raindrop Manifest

In Developer Mode, the manifest is your single source of truth. For a minimal app, you only need:

• One application definition
• One HTTP service
• Basic auth configuration (if needed)

Create raindrop.manifest.ts in your project root with something like this:

// raindrop.manifest.ts
import { defineApp } from "@liquidmetal-ai/raindrop";

export default defineApp({
  name: "minimal-developer-mode-app",

  services: {
    api: {
      type: "service",
      runtime: "nodejs18", // or nodejs20 depending on your setup
      entry: "src/handler.ts",
      http: {
        path: "/",
        method: "POST",
      },
      auth: {
        // Minimal public endpoint; tighten this for production
        type: "public",
      },
    },
  },
});

What this gives you:

• A named application (minimal-developer-mode-app) that will be fully versioned.
• One service (api) with a POST endpoint at /.
• Raindrop-managed infrastructure, routing, and scaling—no additional config.

---

3. Implement the Service in TypeScript

Next, add the TypeScript handler referenced by entry: "src/handler.ts".

Create src/handler.ts:

// src/handler.ts
import type { RaindropRequest, RaindropResponse } from "@liquidmetal-ai/raindrop";

export async function handler(req: RaindropRequest): Promise<RaindropResponse> {
  const body = (await req.json().catch(() => ({}))) as { name?: string };

  const name = body.name ?? "world";

  return {
    statusCode: 200,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      message: `Hello, ${name}!`,
      source: "minimal-developer-mode-app",
    }),
  };
}

This is intentionally minimal:

• One function, one route, one response.
• Ready to be extended with SmartMemory, SmartBuckets, SmartSQL, or SmartInference later without changing the deployment story.

---

4. The Exact CLI Command to Deploy: raindrop build create

With your manifest and handler in place, you can now create and deploy a production build in one step:

raindrop build create

Behind that single command, Raindrop will:

• Parse your manifest and resolve all services.
• Package your TypeScript implementation.
• Create a new, versioned build for your app (code + config + smart primitives).
• Deploy it onto Raindrop’s globally scalable runtime.

Depending on your environment or CI setup, you may also see or use a two-step pattern for more explicit control:

# Generate resources from the manifest (blueprint → concrete resources)
raindrop build generate

# Deploy the generated build to Raindrop
raindrop build deploy

But if you just want the shortest path from manifest to a running endpoint, raindrop build create is the command to reach for: it encapsulates the build, test, and deploy pipeline so you don’t have to orchestrate those steps manually.

---

5. Query Your Deployed Service

Once deployed, Raindrop exposes your service on an organization-specific FQDN. It will look like:

https://agent.<YOUR_ORG_ID>.lmapp.run/

Replace <YOUR_ORG_ID> with the ID shown in your LiquidMetal AI dashboard.

Test the endpoint:

curl -X POST "https://agent.<YOUR_ORG_ID>.lmapp.run/" \
  -H "Content-Type: application/json" \
  -d '{"name": "Raindrop"}'

You should see:

{
  "message": "Hello, Raindrop!",
  "source": "minimal-developer-mode-app"
}

From here, you can immediately start layering in:

• SmartMemory for persistent agent sessions
• SmartBuckets for RAG-ready storage
• SmartSQL for natural-language analytics
• SmartInference for unified access to 60+ models

All without changing how you deploy: update manifest + code → raindrop build create.

Common Mistakes to Avoid

• Over-specifying infrastructure in the manifest:
  Don’t try to re-create your entire cloud layout in the manifest. Keep it declarative and high level—services, smart primitives, auth. Raindrop handles scaling, routing, and wiring.

• Skipping version-awareness in your workflow:
  Every raindrop build create produces a new version. Make a habit of tracking build IDs and linking them to commits. That’s what enables safe rollback/rollforward and reproducible behavior when debugging AI decisions.

Real-World Example

In my own migrations from home-grown RAG backends to Raindrop, the first pass is always a minimal manifest just like the one above. I start with a single service that proxies requests to an existing agent, deploy with raindrop build create, and confirm that:

• The endpoint is reachable on agent.<ORG_ID>.lmapp.run.
• Logs and traces show each AI decision.
• Versioning ties the deployed behavior back to a specific manifest + code state.

Once that baseline is in production, I replace the old glue stack piece by piece—moving vector storage to SmartBuckets, user state into SmartMemory, and analytics onto SmartSQL. The manifest grows incrementally, but the deployment command stays the same.

Pro Tip: Treat your initial minimal manifest as a “production shim.” Get it deployed with raindrop build create, wire your clients to the new FQDN, then iterate behind that stable URL—Raindrop’s versioning lets you swap implementations without breaking consumers.

Summary

Developer Mode gives you a direct, code-first path to production on LiquidMetal AI: define a tiny manifest, implement a single handler, and run raindrop build create to ship a fully versioned, observable, and scalable backend. From that minimal starting point, you can incrementally adopt SmartMemory, SmartBuckets, SmartSQL, and SmartInference without changing your deployment muscle memory. The combination of declarative manifests and a single build command is what turns “agent prototype” into “production API” in minutes, not weeks.

Next Step

Get Started