Skip to content

AI first · Open source soon

The backend your agentbuilds with you.

Connect Claude Code, Cursor or any MCP client and it creates collections, policies, functions and storage for you. Auth, data, realtime and vector search, on MongoDB.

Free plan: 1 project, 512 MB storage, 100,000 function runs a month. No card.

Or run it locally, no account needed

$npx -y @groveback/cli@latest dev --seed --persist
app.groveback.com
The Groveback dashboard: an orders collection with nine documents, and the sidebar with every backend section

AI first

Your agent is the admin

Groveback was designed to be driven by an agent from the first commit. Every admin operation in the API is a tool your agent can call, with the same permissions and the same audit trail.

  • 114 MCP tools

    Collections, policies, functions, storage, users, roles, RAG and webhooks. One API key, one command to connect.

  • Safe by design

    The key is scoped to one project, the data plane stays closed until a policy opens it, and read only mode skips every tool that writes.

  • It checks its own work

    Function tests, integration tests and knowledge base evals run as tools, so the agent proves a change before you ship it.

  • Config as code

    grove pull writes the whole project into your repo; grove push --dry-run shows the diff before anything changes.

agent · groveback_shop

# Connect it once

$ claude mcp add groveback_shop -e GROVEBACK_URL=https://api.groveback.com -e GROVEBACK_API_KEY=gb_sk_… -- npx -y @groveback/mcp@latest

› Build an orders backend. Customers only see their own orders, and notify me on each new one.

  • create_collection orders
  • set_collection_schema orders · customer, total, status, ownerId
  • set_collection_policy orders · list: ownerId = $auth.uid
  • create_function notify-on-order · post insert
  • run_function_tests notify-on-order · 3 passed

✓ Done. orders is closed by default and each customer only reads their own; notify-on-order runs after every insert.

$ grove pull # the project lands in your repo as code

Your data stays in MongoDB. Everything around it is already built, and every request still passes your policies.

One project, six building blocks

Scroll through what you get

  1. 01 · Auth

    Users, sessions and MFA

    Email and password, OAuth providers, TOTP with backup codes, email verification and password reset. Your users live in your database.

    const grove = createClient({ baseUrl, projectId: 'shop' });
    
    await grove.auth.register('ada@shop.dev', 'hunter22', 'Ada');
    const user = await grove.auth.login('ada@shop.dev', 'hunter22');
    // MFA on? login resolves { mfaRequired: true }
    await grove.auth.verifyMfa('481207');
  2. 02 · Data API

    A data API that is closed by default

    Every collection gets REST and GraphQL. Nothing is readable until you write a policy, and the policy becomes part of the Mongo query, so indexes still apply.

    // policies/orders.json — $and'ed into every query
    {
      "list":   { "filter": { "ownerId": "$auth.uid" } },
      "create": { "validate": "document.total > 0" },
      "update": { "immutableFields": ["ownerId"] }
    }
    
    const mine = await grove.collection('orders').find({ limit: 20 });
  3. 03 · Storage

    Files with signed URLs

    Buckets, folders and signed links, on S3 compatible storage. Public or private per bucket.

    await grove.storage.upload('avatars', 'ada.png', file, 'image/png');
    
    const { url } = await grove.storage.signUrl('avatars', 'ada.png', 3600);
  4. 04 · Functions

    Functions in a sandbox

    Database triggers, cron jobs and custom HTTP endpoints. They run in an isolated worker with no secrets and reach your data only through the same policies.

    // functions/normalize-email.ts — a pre hook, sandboxed
    export default async (event, ctx) => {
      if (!event.document.email?.includes('@')) {
        return { abort: true, reason: 'email is invalid' };
      }
      return { document: { ...event.document, email: event.document.email.toLowerCase() } };
    };
  5. 05 · Realtime

    Changes, live

    Subscribe to a collection and get inserts, updates and deletes as they happen. Each event is filtered by the subscriber’s read policy.

    const orders = grove.collection('orders');
    
    const stop = orders.subscribe('*', (event) => {
      console.log(event.type, event.document);
    });
  6. 06 · Vector

    Search by meaning

    Embed text on write and search by similarity, with the same filters and permissions as any other read. Knowledge bases for RAG come built in.

    const hits = await grove.collection('products').search({
      text: 'waterproof hiking boots',
      limit: 8,
    });
    // ranked closest first, filtered by the same read policy

Watch it work

Nine tutorials, under a minute each

From an empty project to an agent building the backend. The videos are in Spanish.

Watch the playlist on YouTube

How it works

From empty to deployed in three steps

  1. 1

    Create a project

    In the dashboard, or locally with one command. Each project gets its own database.

  2. 2

    Model and protect

    Define collections with a JSON schema and write a policy per operation. Preview what a user would see before you ship.

  3. 3

    Call it from your app

    Use the SDK, REST or GraphQL. Generate a typed client from your schema with grove gen.

Built for teams that ship

The parts you would build anyway

  • Your own MongoDB

    Point a project at your Atlas cluster. System data stays apart from yours.

  • Environments

    Dev and production per project, with config you can promote between them.

  • Local emulator

    The whole backend in memory for development, with seed data that persists.

  • A CLI for humans and agents

    grove dev, seed, pull, push and gen: everything an agent needs to run locally and ship config.

  • API keys and roles

    Scoped keys for servers, member roles for your team, end user roles for your app.

  • Config as code

    Export the whole project as a bundle you commit, and import it anywhere.

Questions

Will Groveback be open source?

Yes, that is the plan. We will publish the code once we are sure it runs well, is secure and is ready for the community to build on. Until then you can start on the free plan or run it locally with the CLI.

Do I need my own MongoDB?

No. Projects run on our cluster by default. You can link your own cluster when you create a project, and environments can share it under a different database.

What does the free plan include?

One project with two environments, 512 MB of storage, 100,000 function runs a month and 10,000 vectors. No credit card.

How is access controlled?

Every collection is closed until it has a policy. A policy is a Mongo filter plus optional CEL validation per operation, added to every query on the server.

What can my AI agent do with it?

Almost everything you can do in the dashboard. The MCP server has 114 tools: collections, schemas, policies, functions with tests and rollback, storage, users, roles, knowledge bases and webhooks. Start it in read only mode if you only want the agent to look.

Can I run it on my laptop?

Yes. The CLI starts the whole backend in memory with a dashboard link, no account or config file needed.

Build the app. Your agent builds the backend.

Start on the free plan, connect your agent, or run it locally right now.

Or run it locally, no account needed

$npx -y @groveback/cli@latest dev --seed --persist