TL;DR
Lovable is een door AI aangestuurd ontwikkelplatform dat instructies in natuurlijke taal omzet in bewerkbare webapplicatiecode. Het helpt founders, designers, productteams en developers bij het bouwen van interfaces, het koppelen van backend-services en het publiceren van applicaties via een iteratief gesprek. Deze gids legt de mogelijkheden, de projectarchitectuur en een praktische CometAPI-integratie voor een schrijf-assistent uit. De integratie voegt model-inferentie toe aan de applicatie die je bouwt; het biedt geen manier om Lovable’s eigen coding agent te vervangen. Lezers dienen basiskennis te hebben van HTTP-requests en JavaScript, en toegang te hebben tot een Lovable-project en een CometAPI-account voordat ze de implementatiestappen volgen.
Key Takeaways
- Door AI aangestuurde ontwikkeling: Genereer en verfijn applicaties met prompts in natuurlijke taal.
- Full‑stack mogelijkheden: Bouw frontend‑ervaringen met backendfuncties, databases, authenticatie en hosting.
- Moderne architectuur: Nieuwe Lovable-projecten gebruiken sinds mei 2026 React‑based TanStack Start en SSR.
- CometAPI-compatibiliteit: Voeg externe model-inferentie toe via een beveiligde backend-functie.
- Beste use cases: MVP’s, AI‑assistants, interne tools, content‑apps en klantportalen.
What Is Lovable and How Does It Work?
Lovable (lovable.dev) is een door AI aangestuurd platform voor het bouwen van production‑grade full‑stack webapplicaties met natuurlijke taal. De officiële website en het productoverzicht zijn de startpunten om het platform te verkennen.
Je beschrijft wat je wilt in een chatinterface, en het genereert een werkende app met:
- Frontend (meestal React, TypeScript, Tailwind CSS)
- Backend, database, authenticatie en opslag (via de ingebouwde Lovable Cloud, dat is managed Supabase)
- Integraties, deployment en bewerkbare code die jij bezit
Het ondersteunt de volledige productlevenscyclus—van prototyping tot deployment—en kan code synchroniseren naar GitHub, GitLab of Bitbucket. Het richt zich op founders, productmanagers, niet‑developers en teams die snel willen bewegen en toch code‑eigendom willen behouden. Het vindt zijn oorsprong in het open‑source GPT Engineer‑project (opgericht in Stockholm in 2023 door Anton Osika en Fabian Hedin) en is gerebrand/gecommercialiseerd als Lovable.
How Lovable Turns Prompts Into Applications
- Beschrijf applicatiegebruikers, pagina’s, features en business rules.
- Genereer de eerste app en bekijk de preview.
- Koppel de database, sign‑in, betalingen of externe API’s.
- Test gedrag en verfijn code, design en workflows.
- Publiceer of blijf de geëxporteerde applicatiecode onderhouden.
Lovable’s engineering‑artikel van 1 juni 2026 beschrijft de overstap naar React‑based TanStack Start en server‑side rendering voor nieuwe projecten vanaf 13 mei 2026. Bestaande React + Vite‑projecten behouden hun eerdere architectuur; controleer het daadwerkelijke project voordat je een server‑functie of Edge Function‑implementatie kiest.
Lovable Technical Specifications
| Specification | Lovable |
|---|---|
| Category | Door AI aangestuurde webapplicatiebouwer |
| Primary interaction | Prompting in natuurlijke taal |
| Framework for new projects | React en TanStack Start |
| Rendering | Server‑side rendering voor nieuwe projecten |
| Earlier architecture | React + Vite |
| Backend | Lovable Cloud en ondersteunde integraties |
| Authentication and database | Ondersteund |
| External APIs | Connectors en custom API‑requests |
| AI integration | Lovable AI en externe model‑API’s |
| Code access | Gegenereerde code en GitHub‑workflows |
| Collaboration | Workspace‑ en projectfeatures |
| Deployment | Ingebouwd en ondersteunde externe opties |
Lovable is een applicatieontwikkelplatform, geen foundation model. Daarom beschrijven parameters, context windows, token‑throughput en MMLU‑scores niet Lovable zelf. Deze horen bij de specifieke AI‑modellen die betrokken zijn bij ontwikkeling of inferentie.
Can You Configure CometAPI in Lovable?
Ja—binnen applicaties die met Lovable zijn gegenereerd. CometAPI kan model‑requests afhandelen vanuit een beveiligde backend‑functie. Dat is iets anders dan het veranderen van de LLM die Lovable’s eigen coding agent aanstuurt.
Je kunt CometAPI integreren in applicaties die met Lovable zijn gebouwd, mits de gekozen modellen en interfaces worden ondersteund.
Dit betekent niet dat je direct het development‑proxymodel kunt vervangen dat door Lovable zelf wordt gebruikt.
Als je wilt bepalen welke modellen jouw applicatie aanroept, configureer dan model‑routing binnen je eigen server‑side code.
| Integration | Compatibility | Explanation |
|---|---|---|
| AI features in a generated app | Yes | Beveiligde server‑side API‑requests |
| Chatbot or writing assistant | Yes | Ondersteunde CometAPI‑chatmodellen aanroepen |
| Multi-model app | Yes | Model‑ID’s configureren in backend‑routing |
| Replace Lovable internal coding model | Not established as a standard setting | Selectie van intern agentmodel staat hier los van |
| Backend service through CometAPI | Yes | Custom HTTP of server‑functie‑integratie |
| Lovable workspace management API | Separate | Beheert platformresources, geen model‑inferentie |
Lovable’s uitleg over interne model‑orchestratie beschrijft hoe de development agent routes verwerkt. De onderstaande CometAPI‑integratie betreft applicatie‑inferentie; dit artikel beweert niet dat er een gedocumenteerde CometAPI‑instelling is voor die interne agent.
How the Lovable and CometAPI Architecture Works
Lovable ondersteunt dit op twee hoofdmanieren voor de apps die je bouwt:
- Secrets (aanbevolen voor direct gebruik)
- Sla je CometAPI‑sleutel op als projectsecret (bijv.
COMETAPI_KEYofOPENAI_API_KEY). Vraag Lovable in de projectchat om de API te integreren via een beveiligde Edge Function. De sleutel blijft server‑side en wordt nooit blootgesteld in de browser. - Custom connector
- Maak een custom connector in de workspace Connectors‑catalogus. Configureer de basis‑URL (
https://api.cometapi.com/v1), authenticatie (Bearer‑token of custom header) en voeg vervolgens een verbinding toe door je CometAPI‑sleutel te plakken. Requests gaan via de connector‑gateway van Lovable, waardoor credentials versleuteld blijven en buiten je code.
Notities:
- De ingebouwde AI‑features van apps gebruiken Lovable’s eigen managed keys en verbruiken workspace‑credits. Je kunt die niet vervangen door een CometAPI‑ (of andere provider‑) sleutel.
- Voor externe AI‑calls binnen jouw app (chatbots, generatie, enz.) werken de secrets‑ of custom‑connector‑aanpak en worden kosten gefactureerd aan je CometAPI‑account in plaats van aan Lovable‑credits.
- Er is volgens de meest recente documentatie geen bewijs van native/vooraf gebouwde CometAPI‑ondersteuning in Lovable’s connectorcatalogus; je stelt het in als een generieke OpenAI‑compatibele of custom API‑integratie.
Kortom: Lovable is een sterk “vibe‑coding”/prompt‑to‑full‑stack app‑builder, en ja—je kunt een CometAPI‑sleutel veilig configureren en gebruiken voor AI‑features binnen de apps die je ermee maakt.

De browser stuurt input naar een applicatie‑backend. De backend leest een secret, roept CometAPI aan en retourneert het resultaat. Plaats nooit private API‑sleutels in React‑componenten of andere client‑side code.
How to Build an AI Writing Assistant With Lovable and CometAPI
Het volgende voorbeeld bouwt SmartWrite, een AI‑schrijfassistent met een tekstinvoer, toonselectie en een server‑side CometAPI‑request. Kies het TanStack boundary‑patroon voor een nieuwer project of het volledige Supabase Edge Function‑entry point voor een ouder project. Kies één backend‑implementatie die bij je project past, configureer de secrets en bevestig een ondersteund chatmodel in je CometAPI‑account. Voer vóór publicatie het voorbeeld uit met je eigen projectsecrets en een chatmodel dat beschikbaar is voor je account.
Step 1: Create a Lovable Project
Open https://lovable.dev/ en gebruik deze development‑prompt:
Build a responsive AI writing assistant named SmartWrite.
Include a dashboard, a large prompt box, a tone selector
(Professional / Friendly / Concise), a Generate button,
and an output panel with Copy and Clear controls.
Use a clean responsive design with loading states and errors.
Implement AI generation only through a secure server function.
Never expose API credentials to the frontend.
Do not ship mock AI responses.
Step 2: Configure the CometAPI Credential
Genereer een sleutel in je CometAPI‑account en verifieer een chat‑model‑ID die in dat account beschikbaar is. Deze tutorial gebruikt een directe backend‑integratie, met COMETAPI_API_KEY en COMETAPI_MODEL als server‑side configuratie. Volg het mechanisme voor secret‑toegang dat door de backend in je gegenereerde project wordt ondersteund.
Configuration example: Where to Store and Use CometAPI Credentials
Om CometAPI veilig te koppelen, vraag je Lovable om een server‑side integratie te maken en vraag je de API‑sleutel via het beveiligde invoerformulier op. Je kunt projectsecrets ook beheren onder More → Settings → Secrets. Voor een externe Supabase‑backend configureer je secrets in Supabase. Zie de officiële Lovable Secrets‑gids.
Volg deze vier vereisten:
- Sla API‑sleutels alleen op de server op en lees ze daar. Voeg
COMETAPI_API_KEYtoe via de beveiligde Secrets‑interface van het project. Lees deze uitsluitend uit server‑side secrets of runtime‑bindings. Neem de sleutel nooit op in frontend‑code, browser‑toegankelijke environment variables, chatberichten of screenshots. - Houd API‑configuratie buiten frontend‑requests. Configureer
COMETAPI_MODELop de server met een geverifieerde CometAPI‑model‑ID. De frontend mag alleenpromptentonesturen. Valideer requests tegen deze toegestane velden en weiger onverwachte properties, waaronderconfig,apiKeyenmodel. Sta nooit toe dat clients willekeurige API‑sleutels aanleveren of server‑side modelconfiguratie overschrijven. - Gebruik de juiste secret‑toegangsmethode voor de runtime. De implementatie moet overeenkomen met de daadwerkelijke backend‑omgeving van het project. Worker‑based deployments gebruiken geïnjecteerde bindings, terwijl Supabase Edge Functions toegang hebben tot secrets via
Deno.env. Ga er niet van uit datprocess.env,Deno.enven Worker‑bindings inwisselbaar zijn. Verifieer hoe secrets worden geïnjecteerd voordat je de API‑handler implementeert. - Verifieer geheimbescherming na publicatie. Inspecteer de productie‑JavaScriptbundle, de Network‑panel van de browser DevTools en de applicatielogs. Bevestig dat API‑sleutels nooit voorkomen in client‑side assets, request payloads, responses, URL’s of logs. Verifieer ook dat CometAPI‑requests op de server worden uitgevoerd en dat ongeautoriseerde configuratie‑overschrijvingen worden geweigerd.

Een opgeslagen secret betekent niet automatisch dat de integratie veilig of functioneel is. De integratie is pas klaar wanneer server‑side API‑calls werken, client‑requests beschermde instellingen niet kunnen overschrijven en productiecontroles bevestigen dat credentials privé blijven.
Gebruik het volgende architectuurdiagram om de grens tussen frontend en backend en de locatie van beschermde credentials te identificeren. Het diagram is conceptueel en geen screenshot van de instellingeninterface van Lovable.
Prompt to give Lovable
Connect SmartWrite directly to CometAPI through an authenticated backend function. Ask me for COMETAPI_API_KEY in a secure secret form and use COMETAPI_MODEL for the exact model ID I provide. Send POST requests to https://api.cometapi.com/v1/chat/completions from the server only. Accept prompt and tone, validate them, enforce per-user limits, and return only the generated text to the frontend. Use the backend runtime already present in this project. Do not put credentials in chat, frontend code, or browser requests. Do not generate mock success results. Explain how to test the integration and show sanitized errors when it fails.
Lovable ondersteunt ook beheerde custom connectors. De instructies hier gebruiken bewust het pad voor directe integratie zoals gedocumenteerd in de API‑integratiegids, zodat ze aansluiten op de onderstaande server‑side helper.
Step 3: Test the CometAPI Chat Endpoint
Vanaf een vertrouwde Bash‑terminal stel je lokaal COMETAPI_API_KEY en COMETAPI_MODEL in en test je vervolgens POST https://api.cometapi.com/v1/chat/completions. De officiële CometAPI‑requestgids documenteert de basis‑URL, Bearer‑authenticatie en het chatrespons‑formaat. Selecteer een model dat deze endpoint ondersteunt; compatibiliteit garandeert niet elke providerfeature of parameter.
# Set COMETAPI_API_KEY securely in this terminal before running.
# Replace the model value with a chat model verified in your account.
export COMETAPI_MODEL="YOUR_VERIFIED_CHAT_MODEL_ID"
: "${COMETAPI_API_KEY:?Set COMETAPI_API_KEY first}"
curl --fail-with-body --max-time 45 \
https://api.cometapi.com/v1/chat/completions \
-H "Authorization: Bearer $COMETAPI_API_KEY" \
-H "Content-Type: application/json" \
--data "$(printf '{"model":"%s","messages":[{"role":"user","content":"Write a customer welcome email."}],"stream":false}' "$COMETAPI_MODEL")"
Controlepunt: een succesvolle response bevat choices[0].message.content. Als authenticatie faalt of het model niet beschikbaar is, los dat op voordat je de gebruikersinterface koppelt. Plak geen volledige credentials of private prompts in diagnostische screenshots.
Step 4: Connect CometAPI Through a Secure Backend
Lovable ondersteunt twee backendarchitecturen:
- Nieuwe projecten (TanStack Start): Gebruik
createServerFnom API‑requests op de server af te handelen. - Oudere React + Vite‑projecten: Gebruik Supabase Edge Functions voor server‑side API‑calls.
Kies de implementatie die past bij de architectuur van je project.
Option A: TanStack Start (New Projects)
Maak src/server/writing.functions.ts:
import { createServerFn } from "@tanstack/react-start";
export const generateWriting = createServerFn({ method: "POST" })
.handler(async ({ data }: { data: { prompt: string } }) => {
const { env } = await import("cloudflare:workers");
const res = await fetch(
"https://api.cometapi.com/v1/chat/completions",
{
method: "POST",
headers: {
Authorization: `Bearer ${env.COMETAPI_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: env.COMETAPI_MODEL,
messages: [{ role: "user", content: data.prompt }],
}),
}
);
if (!res.ok) throw new Error("Generation failed.");
const result = await res.json();
return { text: result.choices[0].message.content };
});
Sla COMETAPI_API_KEY en COMETAPI_MODEL op als server‑side Worker‑bindings. Als je deployment een andere adapter gebruikt, gebruik dan het ondersteunde secret‑toegangsmechanisme daarvan.
Option B: React + Vite (Older Projects)
Maak supabase/functions/generate-writing/index.ts:
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";
serve(async (req) => {
try {
const { prompt } = await req.json();
if (typeof prompt !== "string" || !prompt.trim()) {
return Response.json({ error: "Invalid prompt" }, { status: 400 });
}
const res = await fetch(
"https://api.cometapi.com/v1/chat/completions",
{
method: "POST",
headers: {
Authorization: `Bearer ${Deno.env.get("COMETAPI_API_KEY")}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: Deno.env.get("COMETAPI_MODEL"),
messages: [{ role: "user", content: prompt }],
}),
}
);
if (!res.ok) throw new Error("CometAPI request failed.");
const result = await res.json();
return Response.json({ text: result.choices[0].message.content });
} catch {
return Response.json({ error: "Generation failed." }, { status: 500 });
}
});
Voeg COMETAPI_API_KEY en COMETAPI_MODEL toe aan Supabase‑projectsecrets en deploy vervolgens de functie.
In beide benaderingen blijven API‑credentials op de server. Productieapplicaties moeten ook authenticatie, invoervalidatie en limieten per gebruiker implementeren.
Step 5: Connect the Lovable Interface
TanStack Start client
import { generate } from "./server/writing.functions";
const { text } = await generate({ data: { prompt, tone } });
// Render text as text content, not as trusted HTML.
React + Vite client
// Use the existing, signed-in Supabase client generated for your project.
const { data, error } = await supabase.functions.invoke("generate-writing", {
body: { prompt, tone },
});
if (error) throw new Error("Generation failed. Please try again.");
const text = data.text;
Gebruik de client die bij je gekozen tak past. TanStack gebruikt zijn gegenereerde RPC‑endpoint; Supabase gebruikt de gedeployde generate‑writing‑functie. Geen van beide vereist het bedenken van een aparte /api/generate‑route. De browser kan zijn applicatiesessietoken meesturen voor authenticatie, maar mag nooit de private CometAPI‑credential of een config‑object meesturen. Toon loading‑, fout‑ en retry‑states in de interface.
Step 6: Test and Publish the Application
Test na publicatie de live‑URL in plaats van uitsluitend te vertrouwen op de editorpreview. Gebruik een private testcredential en houd screenshots en bewijs vrij van geheime waarden. Rond deze controles af vóór bredere toegang:
- Inspecteer de gebuilde browser‑JavaScript, sourcemaps en publieke configuratie op de private CometAPI‑sleutel. Zoek lokaal zonder de sleutel af te drukken in gedeelde terminaloutput of op te slaan in rapporten. Een variabelenaam alleen is geen bewijs van een gelekte waarde.
- Inspecteer browser‑Network‑requests, inclusief payloads, headers en foutresponses. Het request mag alleen de toegestane schrijfinvoer en applicatie‑authenticatiedata bevatten; de private CometAPI Authorization‑header hoort alleen op de server‑naar‑provider‑request.
- Bekijk function‑logs, applicatielogs, monitoringtraces en foutmeldingen. Log geen sleutels, bearer‑tokens, configuratie‑objecten of volledige upstream‑foutbodies. Als een sleutel is blootgesteld, trek deze in en vervang hem, en verwijder de blootstelling voordat je opnieuw test.
- Probeer requests in uitgelogde en verlopen sessies; beide moeten worden geweigerd vóór een provider‑call. Stuur apiKey, config of model als extra veld en verifieer de weigering. Test lege en te grote prompts, een ongeldige toon, providerstoringen en je gedeployde gebruikersquota.
- Bevestig dat een geldig ingelogd request tekst oplevert met je geselecteerde model. Noteer de deploymentversie en geanonimiseerde pass/fail‑resultaten; de voorbeelden bewijzen niet dat jouw eigen deployment deze checks heeft doorstaan.
What Can You Build With Lovable and CometAPI?
| Project | CometAPI role | Possible features |
|---|---|---|
| AI writing assistant | Draft and rewrite content | Toonselectie, templates, editor |
| Document summarizer | Summarize extracted text | Uploads, document Q&A, key points |
| Customer support desk | Classify and draft responses | Tickettriage, voorgestelde antwoorden |
| Business analytics assistant | Explain business data | KPI‑dashboards, inzichten in natuurlijke taal |
- Normale prompts leveren leesbare modelresponses op.
- Lege en te grote prompts worden veilig geweigerd.
- API‑credentials verschijnen nooit in het browsernetwork‑paneel.
- Modelstoringen geven niet‑gevoelige foutmeldingen terug.
- Geauthenticeerde gebruikers hebben requestlimieten en activiteitsmonitoring.
- De layout werkt correct op desktop en mobiel.
Dit zijn voorgestelde projectpatronen, geen claims over afgeronde of onafhankelijk gebenchmarkte deployments.
FAQ
How should a multi-tenant app prevent one customer’s records from appearing in another customer’s AI response?
Leid tenant‑ en gebruikersidentiteit af uit de geverifieerde serversessie en scope elke databaselookup voordat je modelcontext samenstelt. Vertrouw nooit op een tenant‑ID die door de browser wordt aangeleverd of op een promptinstructie om toegang af te dwingen. Voeg waar ondersteund row‑level database‑policies toe en verifieer ze met twee testaccounts. Test record‑ID’s, zoekresultaten, geëxporteerde bestanden en gespreksgeschiedenis op tenant‑overschrijdende toegang.
When is retrieval-augmented generation preferable to putting documents directly into every prompt?
Gebruik retrieval wanneer de documentencollectie te groot is om elke keer mee te sturen, vaak verandert of bron‑traceerbaarheid vereist is. Parse en indexeer de documenten, haal een kleine relevante set op en voeg bronidentificatoren aan het antwoord toe. Retrieval vereist nog steeds evaluatie: een vloeiend antwoord kan een irrelevante passage citeren. Houd toegangsfilters in de retrievalquery en test vragen waarvan de antwoorden ontbreken. Voor een klein, stabiel document kan directe context een eenvoudigere start zijn.
How can streaming be added without displaying broken or misleading responses?
Behandel streaming als een aparte transportfeature, niet als een one‑liner ter vervanging van stream: false. Bevestig het streamingformaat van het geselecteerde model, laat de backend events doorgeven en behandel partiële chunks, annulering, time‑outs en verbindingsverlies in de UI. Markeer een onderbroken response als onvolledig en laat de gebruiker bewust opnieuw proberen. Toon gestreamde tekst niet als vertrouwde HTML. Test op het gepubliceerde hostingpad omdat tussenlagen een stream kunnen bufferen die lokaal werkte.
What should a fallback policy check before switching to another model?
Definieer welke fouten een retry of fallback rechtvaardigen en controleer vervolgens of het alternatief dezelfde endpoint, instructies, tool‑schema en outputformaat ondersteunt. Houd retries begrensd en vermijd het stilzwijgend wisselen van modellen voor workflows die consistent gedrag vereisen. Evalueer de fallback op representatieve prompts, inclusief weigeringen en gevallen met misvormde output. Als modeloutput een externe actie triggert, bescherm die actie met een aparte bevestiging of idempotency‑regel zodat een herhaalde generatie de actie niet kan dupliceren.
What evidence should a team keep before promoting an AI feature from a pilot to regular use?
Bewaar een versiebeheerde evaluatieset met verwachte gedragingen, model‑ en promptconfiguratie, geredacteerde requestmetadata en registraties van mislukte gevallen. Definieer acceptatiecriteria voor feitelijke nauwkeurigheid, responsvorm, latentie en toegangsgrenzen; vergelijk resultaten na model‑ of promptwijzigingen. Bepaal voor gevoelige input wat verzonden en bewaard kan worden voordat je de feature inschakelt. Dit zijn voorgestelde engineering‑controls, geen claims dat Lovable of CometAPI een bepaald regulatoir resultaat garandeert.
Conclusion: Is Lovable Worth Using?
Lovable maakt het eenvoudiger om ideeën te vertalen naar functionerende webapplicaties. De full‑stack tooling en externe integraties zijn vooral nuttig om productconcepten snel te valideren. CometAPI voegt een flexibele route toe voor model‑inferentie in chat, schrijven, analytics en andere door AI aangestuurde workflows.
Begin met een kleine, beveiligde applicatie, test de CometAPI‑koppeling, beoordeel de gegenereerde code en breid uit nadat de kernervaring betrouwbaar blijkt.



