# How to Vibe Code Your Own Animam.ai (and Stop Paying for It) > Your website answers at 2 a.m., you get the lead by 8 - Site: https://animam.ai - Category: AI Agent Infrastructure & Chatbot SaaS - Verdict: **Solid side project** (68/100 vibecodeable) - Estimated effort: 3-4 weekends of focused development ## Verdict You can build a solid personal multi-tenant AI chatbot and MCP server platform in a few weekends, but building the production-grade URL scrapers, agency fleet propagation tree, and secure server-side action hooks requires real engineering discipline. The core loop—scraping a URL, storing chunks in a vector database, running a streaming chat widget, and executing deterministic quote calculations—is a satisfying full-stack challenge. However, wiring up a Model Context Protocol (MCP) server that conforms to specification over Streamable HTTP, managing multi-tenant parent-child schema inheritance for agencies, and building robust SSRF protection for verified actions will test your debugging patience with AI coding agents. ### What you can't replicate - The official WordPress plugin ecosystem traction - Established agency customer trust and brand presence in the French market ## What it does Multi-tenant AI agent infrastructure and embeddable chatbot platform that turns public website content into a qualified lead capture, calendar booking, and server-side quote agent. ### Core features - Automated URL scraping and markdown chunking corpus ingestion - Embeddable iframe/script widget with real-time SSE chat streaming - Server-side deterministic quote calculator (model picks arguments, code executes math) - Model Context Protocol (MCP) Streamable HTTP server for AI agent fleet management - Multi-tenant bot fleet sync with cascade propagation and local override detection - Verified backend action webhooks with DNS validation and secret encryption at rest - WordPress plugin for content synchronization and widget injection - Voice telephony workflow integration via Vapi ## The business ### Pricing - Starter: €29 / mo - Builder: €49 / mo - Pro: €79 / mo - Agency: €199 / mo - Enterprise: Custom Founded 2026. Team size: 1. ## The hard parts - Building a robust URL scraper that extracts clean product/pricing context without breaking on heavy JavaScript SPAs - Implementing a secure MCP Streamable HTTP server endpoint that safely manages transient demo keys and tenant contexts - Enforcing strict server-side calculation guardrails so the LLM never computes financial totals directly - Managing multi-tenant fleet propagation where child overrides automatically detach from parent templates - Validating outgoing verified action URLs securely to prevent Server-Side Request Forgery (SSRF) against internal networks ## How to vibe code Animam.ai ### Prerequisites - Node.js (free): Required runtime for Next.js 16 and backend TypeScript services - GitHub (free): Source control and seamless deployment integration - Anthropic API Key (Pay-as-you-go (~$10-20/mo)): Provides Claude model access for agent responses and tool calling ### Recommended AI tools - Claude Code: Best-in-class multi-file terminal agent for scaffolding complex full-stack apps and MCP servers - Cursor: Ideal for iterative UI work on the chat widget, dashboard components, and inline diff reviews ### Stack - Frontend: Next.js with Tailwind CSS and React - Backend: Next.js App Router API Routes & Streamable HTTP MCP Handlers - Database: Turso (SQLite at the edge with vector support via libSQL) - Auth: better-auth - Payments: Polar - Other: Firecrawl for robust URL scraping and markdown extraction, Zod for strict schema validation on server-side quote and action parameters ### Hosting - Cloudflare (Hosting the Next.js frontend, API endpoints, and Turso edge database access for $0-5/mo): $5/mo ### Build guide 1. **Project Scaffolding & Database Schema** — Initialize a Next.js 16 project with Tailwind CSS and configure Turso with libSQL for relational tables and vector embeddings. ``` Scaffold a new Next.js 16 application using App Router, TypeScript, and Tailwind CSS. Set up Drizzle ORM connected to a Turso libSQL database. Create database migrations and schema definitions for: `tenants` (id, slug, name, url, settings), `corpus_entries` (id, tenant_id, content, embedding vector), `conversations` (id, tenant_id, visitor_email, status, summary), and `messages` (id, conversation_id, role, content, tool_executions). Ensure all tables include proper foreign keys, indexing on tenant slugs, and timestamp fields. Add a seed script with mock tenant data to verify local connectivity. ``` 2. **URL Scraping & Corpus Ingestion Pipeline** — Build an ingestion engine that accepts a public URL, scrapes its content using Firecrawl, chunks the text, generates vector embeddings, and stores them in the corpus. ``` Implement a backend service in `lib/ingest.ts` that takes a target URL and a tenant ID. Integrate Firecrawl API (or a robust fetch-and-turndown fallback) to scrape public web pages, extract clean markdown, chunk the text into 500-character segments, generate vector embeddings using Anthropic or local lightweight models, and insert them into the `corpus_entries` table. Expose a POST `/api/tenants/[slug]/corpus` endpoint that triggers this ingestion pipeline and returns the count of ingested corpus entries. ``` 3. **Chatbot Core Loop & Server-Side Quote Engine** — Implement the conversational chat endpoint with RAG retrieval over the corpus and strict server-side arithmetic guards for quote calculation. ``` Build the chat execution engine at POST `/api/tenants/[slug]/chat`. The endpoint must receive a visitor message, perform a vector similarity search against `corpus_entries` to retrieve relevant context, and prompt Claude Haiku with system instructions defining the bot's persona. Implement tool-calling for quotes where the LLM only outputs quote parameters (e.g., item quantities, tier selections), while a deterministic backend math function in `lib/pricing.ts` executes the arithmetic against the tenant's price grid. Return a structured JSON envelope containing the message, toolExecutions array, and token usage statistics. ``` 4. **Embeddable Widget & Frontend Chat UI** — Create a lightweight, embeddable chat widget script and React component that can be dropped onto any external website via a single script tag. ``` Create an embeddable chat widget component in React that communicates with the chat API via Server-Sent Events or streaming JSON responses. Build an entry point script bundle (`public/widget.js`) that injects a floating chat bubble iframe into host websites, passing the tenant slug via data attributes. Style the widget with a clean, responsive Tailwind UI supporting dark/light mode, lead capture forms (email/name), meeting booking widgets, and Stripe payment link rendering inside the conversation flow. ``` 5. **Model Context Protocol (MCP) Server Endpoint** — Expose a public Model Context Protocol (MCP) Streamable HTTP server endpoint so AI coding assistants can programmatically query and manage agents. ``` Implement an MCP Streamable HTTP server endpoint at `/api/mcp` supporting tools: `try_on_site(url)`, `chat_with_demo(slug, message)`, `get_plans()`, `create_corpus(slug, content)`, and `list_conversations(slug)`. Ensure the endpoint adheres strictly to the Model Context Protocol specification over HTTP without requiring initial authentication for public demo actions, while returning structured JSON-RPC responses that AI agents like Claude or Cursor can execute autonomously. ``` 6. **Fleet Management & Verified Actions Webhooks** — Add multi-tenant fleet propagation for agencies and secure backend webhooks with SSRF guards for verified actions. ``` Implement agency fleet management features allowing parent accounts to define tools and propagate them across child tenant bots with cascade reporting (created, updated, skipped, detached). Build the verified action webhook dispatcher in `lib/actions.ts`: before posting visitor data and verified emails to a tenant's registered endpoint, perform rigorous URL validation (resolving DNS, rejecting private IP ranges and internal network loops) and encrypt stored secrets at rest using AES-256. ``` ### Cost vs paying **Starting costs (one-time):** - Domain name registration: $12 one-time - Anthropic API starting credits: $20 one-time - Total: ~$32 one-time **Ongoing costs (monthly):** - Cloudflare Workers / Turso database: $5/mo - Anthropic API usage: ~$10-15/mo - Total: ~$15-20/mo - Paying for the SaaS instead: €49/mo (Builder Tier) - Build time: 25-35 hours - AI tool credits: $20 (Claude Pro) - Break-even: For personal use or learning, immediate; to replace a commercial SaaS subscription, 2-3 months. ## Sources - [Animam.ai Home Page](https://animam.ai/) - [Animam.ai Pricing Page](https://animam.ai/_pricing.md) - [Animam.ai About Page](https://animam.ai/_about.md) - [Animam.ai Enterprise Page](https://animam.ai/_enterprise.md)