मैं Supabase Edge Functions के साथ ChatGPT ऐप कैसे बनाऊँ? चरण-दर-चरण मार्गदर्शिका

मैं Supabase Edge Functions के साथ ChatGPT ऐप कैसे बनाऊँ? चरण-दर-चरण मार्गदर्शिका

अगर आपके ब्राउज़र को ChatGPT-शैली के ऐप को चलाने के लिए आपकी OpenAI API कुंजी जानने की कभी ज़रूरत ही न पड़े तो? मैं Supabase Edge Functions के साथ ChatGPT ऐप कैसे बनाऊँ? सुरक्षित न्यूनतम आर्किटेक्चर सीधा है: ब्राउज़र एक प्रॉम्प्ट Supabase Edge Function को भेजता है, फ़ंक्शन सर्वर-साइड प्रदाता कुंजी पढ़ता है, प्रॉम्प्ट को OpenAI-संगत मॉडल को भेजता है और असिस्टेंट का उत्तर लौटाता है। जैसे-जैसे प्रोडक्शन की आवश्यकताएँ बढ़ती हैं, Supabase Auth, डेटाबेस में स्थायित्व, रेट लिमिटिंग और स्ट्रीमिंग जोड़ी जा सकती है।

यह तरीका महत्वपूर्ण है क्योंकि यह यूज़र इंटरफ़ेस को मॉडल प्रदाता से अलग करता है। केवल-फ्रंटएंड इंटीग्रेशन में JavaScript, ब्राउज़र स्टोरेज या नेटवर्क अनुरोधों के माध्यम से कोई सीक्रेट गलती से उजागर हो सकता है; Edge Function उस क्रेडेंशियल को सर्वर पर रखता है और आपको इनपुट को मान्य करने, यूज़र्स को प्रमाणित करने, कोटा लागू करने और अपस्ट्रीम विफलताओं को संभालने के लिए एक नियंत्रित स्थान देता है। Supabase के आधिकारिक दस्तावेज़ Edge Functions को सर्वर-साइड TypeScript फ़ंक्शंस के रूप में वर्णित करते हैं, जिन्हें यूज़र्स के निकट चलने के लिए बनाया गया है। इससे वे अलग एप्लिकेशन सर्वर तैनात किए बिना AI अनुरोधों के लिए एक व्यावहारिक बैकएंड लेयर बन जाती हैं।

इस मार्गदर्शिका में, आप पहले सबसे छोटा कार्यशील संस्करण बनाएँगे और फिर इसे सुरक्षित रूप से विस्तारित करेंगे:

• Supabase प्रोजेक्ट और Edge Function बनाएँ।
• मॉडल-प्रदाता API कुंजी को सर्वर-साइड सीक्रेट के रूप में कॉन्फ़िगर करें।
• CORS हैंडलिंग, JSON पार्सिंग, पेलोड वैलिडेशन और अपस्ट्रीम त्रुटि हैंडलिंग जोड़ें।
• क्रेडेंशियल उजागर किए बिना ब्राउज़र JavaScript या TypeScript से फ़ंक्शन को इनवोक करें।
• Supabase Auth जोड़ें और क्लाइंट द्वारा भेजी गई यूज़र ID पर भरोसा करने के बजाय यूज़र के एक्सेस टोकन को मान्य करें।
• स्वामित्व जाँच और Row Level Security के साथ बातचीत और संदेश स्टोर करें।
• वैकल्पिक स्ट्रीमिंग, रेट लिमिटिंग, दुरुपयोग नियंत्रण और संरचित ऑब्ज़र्वेबिलिटी जोड़ें।
• फ़ंक्शन तैनात करें और सामान्य 401, 403, CORS, विकृत-अनुरोध, टाइमआउट और मॉडल-प्रदाता त्रुटियों की समस्या हल करें।

यह मार्गदर्शिका स्थिर अवधारणाओं को संस्करण-संवेदनशील कमांड और API से भी अलग करेगी, इसलिए प्रोडक्शन में उपयोग से पहले तैनाती संबंधी निर्देशों को वर्तमान Supabase और OpenAI दस्तावेज़ों के अनुसार जाँचना चाहिए। एक संक्षिप्त संदर्भ तालिका अनुमानित कोटा या पुराने मॉडल मूल्य-निर्धारण को तथ्य के रूप में प्रस्तुत करने के बजाय सत्यापित सीमाओं या स्टेटस कोड की पहचान करेगी।

यही सर्वर-साइड पैटर्न टेक्स्ट चैट से आगे भी लागू होता है। CallMissed जैसे प्लेटफ़ॉर्म इस प्रकार के AI इंफ्रास्ट्रक्चर को व्यापक ग्राहक सहभागिता पर लागू करते हैं, जिसमें भारत की 22 भाषाओं में WhatsApp, वॉइस, ईमेल और Indic-भाषा अनुभव शामिल हैं। हालाँकि, एक केंद्रित ChatGPT ऐप के लिए Supabase Edge Functions एक स्पष्ट आधार प्रदान करती हैं: सीक्रेट की सुरक्षा करें, हर अनुरोध को मान्य करें, हर यूज़र को प्रमाणित करें और स्थायित्व तथा स्केलिंग को आकस्मिक होने के बजाय जानबूझकर निर्धारित करें।

मैं Supabase Edge Functions के साथ ChatGPT ऐप कैसे बनाऊँ? ब्राउज़र-से-Edge-Function-से-मॉडल प्रवाह का उपयोग करें, प्रदाता कुंजी को सर्वर-साइड रखें और प्रोडक्शन के लिए Auth, स्थायित्व तथा रेट लिमिट जोड़ें।

Supabase Edge Functions के साथ ChatGPT ऐप बनाने का सुरक्षित तरीका है कि ब्राउज़र से प्रॉम्प्ट को Edge Function पर भेजा जाए, उस सर्वर-साइड फ़ंक्शन के भीतर मॉडल-प्रदाता कुंजी पढ़ी जाए, मॉडल को कॉल किया जाए और उत्तर लौटाया जाए। स्थानीय परीक्षण के लिए इस अनऑथेंटिकेटेड प्रवाह से शुरुआत करें, फिर प्रोडक्शन से पहले Supabase Auth, डेटाबेस में स्थायित्व, रेट लिमिट और प्रतिबंधित CORS जोड़ें।

प्रोजेक्ट आर्किटेक्चर कैसा होना चाहिए?

इस अनुरोध पथ का उपयोग करें:

1. ब्राउज़र { "prompt": "..." } को chat पर भेजता है।
2. Supabase Edge Function अनुरोध को मान्य करता है।
3. फ़ंक्शन सर्वर-साइड सीक्रेट्स से OPENAI_API_KEY पढ़ता है।
4. फ़ंक्शन OpenAI-संगत चैट-कम्प्लीशंस एंडपॉइंट को कॉल करता है।
5. ब्राउज़र को केवल असिस्टेंट का उत्तर मिलता है—प्रदाता कुंजी नहीं।

Supabase Edge Functions को सर्वर-साइड TypeScript फ़ंक्शंस के रूप में दस्तावेज़ित करता है, जो यूज़र्स के निकट चलती हैं। निम्न कमांड संस्करण-संवेदनशील हैं; तैनाती से पहले वर्तमान Supabase CLI सिंटैक्स की पुष्टि करें।

npx supabase login
npx supabase init
npx supabase functions new chat
npx supabase functions serve chat --env-file .env.local
npx supabase secrets set OPENAI_API_KEY="your-key"
npx supabase functions deploy chat

स्थानीय रूप से .env.local बनाएँ, इसे .gitignore में जोड़ें और कुंजी को फ्रंटएंड कोड, ब्राउज़र स्टोरेज या किसी सार्वजनिक एनवायरनमेंट वेरिएबल में कभी न रखें।

मैं पहला Edge Function कैसे लिखूँ?

supabase/functions/chat/index.ts को इस न्यूनतम अनऑथेंटिकेटेड स्टार्टर से बदलें:

const cors = {
  "Access-Control-Allow-Origin": "http://localhost:5173",
  "Access-Control-Allow-Headers": "authorization, x-client-info, apikey, content-type",
  "Content-Type": "application/json",
};

Deno.serve(async (req) => {
  if (req.method === "OPTIONS") return new Response("ok", { headers: cors });
  if (req.method !== "POST")
    return new Response(JSON.stringify({ error: "POST required" }),
      { status: 405, headers: cors });

  try {
    const body = await req.json();
    const prompt = body?.prompt;

    if (typeof prompt !== "string" || prompt.trim().length === 0 ||
        prompt.length > 4000) {
      return new Response(JSON.stringify({ error: "Invalid prompt" }),
        { status: 400, headers: cors });
    }

    const upstream = await fetch("https://api.openai.com/v1/chat/completions", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${Deno.env.get("OPENAI_API_KEY")}`,
      },
      body: JSON.stringify({
        model: "gpt-4o-mini",
        messages: [{ role: "user", content: prompt.trim() }],
      }),
    });

    if (!upstream.ok) {
      return new Response(JSON.stringify({ error: "Model request failed" }),
        { status: 502, headers: cors });
    }

    const data = await upstream.json();
    return new Response(JSON.stringify({
      response: data.choices?.[0]?.message?.content ?? "",
    }), { headers: cors });
  } catch {
    return new Response(JSON.stringify({ error: "Malformed JSON or server error" }),
      { status: 400, headers: cors });
  }
});

किसी अन्य OpenAI-संगत प्रदाता—या CallMissed के मल्टी-मॉडल API जैसे गेटवे—के लिए सर्वर-साइड सीमा को बनाए रखते हुए एंडपॉइंट, कुंजी और मॉडल बदलें।

ब्राउज़र फ़ंक्शन को कैसे कॉल करता है?

const { data, error } = await supabase.functions.invoke("chat", {
  body: { prompt: inputValue },
});

if (error) throw new Error(error.message);
output.textContent = data.response;

फ़ंक्शन अमान्य इनपुट के लिए 400, असमर्थित विधि के लिए 405 और अपस्ट्रीम मॉडल अनुरोध विफल होने पर 502 लौटाता है। ये अर्थ Internet Engineering Task Force के RFC 9110 द्वारा परिभाषित HTTP सेमांटिक्स के अनुरूप हैं।

इस स्टार्टर में जानबूझकर कोई यूज़र पहचान नहीं है। प्रोडक्शन संस्करण को फ़ंक्शन के भीतर Supabase Auth एक्सेस टोकन को मान्य करना चाहिए, डेटाबेस क्वेरी में स्वामित्व लागू करना चाहिए और मॉडल अनुरोध स्वीकार करने से पहले प्रति-यूज़र रेट लिमिट लागू करनी चाहिए।

ऐप बनाने से पहले मुझे किन चीज़ों की आवश्यकता है और मुझे किन सेटअप मानों की पुष्टि करनी चाहिए? (तालिका)

कोड लिखने से पहले अपने Supabase प्रोजेक्ट, स्थानीय CLI, फ़ंक्शन नाम, environment variables, और model endpoint की पुष्टि करें। ब्राउज़र को केवल Supabase URL और सार्वजनिक client key मिलनी चाहिए; model-provider key को Edge Function secret के रूप में सुरक्षित रखना आवश्यक है।

मुझे पहले किन setup values की पुष्टि करनी चाहिए?

एक समान naming scheme का उपयोग करें, ताकि frontend, Edge Function और deployment environment में आपस में असंगति न हो। निम्नलिखित values व्यावहारिक defaults हैं; इन्हें चलाने से पहले version-sensitive commands की पुष्टि वर्तमान Supabase documentation से करें।

Supabase Edge Functions को server-side TypeScript functions के रूप में document करता है, इसलिए provider API key Supabase के secret store में होनी चाहिए, न कि Git में commit की गई .env files में। विकास के लिए स्थानीय .env file का उपयोग किया जा सकता है, लेकिन उसे .gitignore में जोड़ें और deployment के लिए वर्तमान Supabase CLI secret command का उपयोग करें।

मुझे क्या install और create करना होगा?

निम्नलिखित तैयार रखें:

• एक Supabase account और project।
• Node.js और वर्तमान Supabase CLI।
• एक frontend application, जैसे Vite, Next.js, या plain browser JavaScript।
• Model provider की एक API key।
• Private repository या उचित secret scanning के साथ Git।
• वैकल्पिक: Supabase Auth, यदि प्रत्येक conversation किसी signed-in user से संबंधित होनी चाहिए।

इनके समान commands से project initialize करें और function create करें:

supabase login
supabase init
supabase link --project-ref YOUR_PROJECT_REF
supabase functions new chat
supabase functions serve chat --env-file .env.local

ये CLI commands version-sensitive हैं। यदि installed CLI unknown option की सूचना दे, तो किसी blog post से पुरानी command copy करने के बजाय वर्तमान Supabase CLI reference देखें।

Source control से बाहर एक स्थानीय environment file बनाएं:

OPENAI_API_KEY=replace-with-a-local-development-key
MODEL_NAME=replace-with-a-supported-model
ALLOWED_ORIGIN=http://localhost:5173

Production के लिए equivalent values को hosted Edge Function secrets के रूप में set करें, फिर deploy करें:

supabase secrets set OPENAI_API_KEY=... MODEL_NAME=... ALLOWED_ORIGIN=https://app.example.com
supabase functions deploy chat

OPENAI_API_KEY को Vite के VITE_ prefix, React environment imports, browser storage या client-side network payloads के माध्यम से expose न करें। ब्राउज़र को केवल user का message—और, authentication enabled होने पर, उसका Supabase access token—chat function को भेजना चाहिए। CallMissed जैसे OpenAI-compatible gateway का उपयोग करने वाली teams के लिए deployment से पहले gateway base URL और model identifier, दोनों की पुष्टि करें; एक endpoint secrets को client में ले जाए बिना provider switching को सरल बना सकता है।

मैं Supabase project कैसे create करूँ, CLI install करूँ, secrets configure करूँ और local development शुरू करूँ?

एक Supabase project create करें, Supabase CLI install और link करें, एक Edge Function generate करें, और model-provider key को server-side secret के रूप में store करें। Local development के दौरान ब्राउज़र अंततः function को call करेगा, जबकि function Deno.env.get() के माध्यम से OPENAI_API_KEY पढ़ेगा; key frontend code, localStorage या public .env file में कभी दिखाई नहीं देनी चाहिए।

मैं Supabase project कैसे create और link करूँ?

1. Supabase Dashboard खोलें, New project चुनें, कोई organization चुनें, मजबूत database password set करें और अपने users के निकट region चुनें।
2. अपने operating system के package manager का उपयोग करके Supabase CLI install करें। Installation commands releases के बीच बदल सकती हैं, इसलिए वर्तमान command की पुष्टि Supabase CLI documentation में करें।
3. Authenticate करें और local project initialize करें:

supabase login
supabase init
supabase link --project-ref YOUR_PROJECT_REF

YOUR_PROJECT_REF Supabase Dashboard URL या project settings में दिखने वाला project identifier है। supabase init command configuration, migrations और Edge Functions के लिए स्थानीय supabase/ directory बनाती है।

मैं ChatGPT app के लिए Edge Function कैसे create करूँ?

chat नाम का function generate करें:

supabase functions new chat

TypeScript entry point आमतौर पर यह होता है:

supabase/functions/chat/index.ts

Supabase Edge Functions को server-side TypeScript functions के रूप में describe करता है, जो users के निकट run होती हैं। इस architecture में function browser और OpenAI-compatible model provider के बीच security boundary है। CallMissed जैसे gateways एक OpenAI-compatible endpoint के माध्यम से कई models तक access प्रदान कर सकते हैं, इसलिए function provider-specific details को server पर रख सकता है।

Function के भीतर secret पढ़ें:

const openaiApiKey = Deno.env.get("OPENAI_API_KEY");

if (!openaiApiKey) {
  throw new Error("OPENAI_API_KEY is not configured");
}

Secret के अनुपस्थित होने पर unauthenticated upstream request भेजने के बजाय function को स्पष्ट रूप से fail होना चाहिए।

मैं API secrets को सुरक्षित रूप से कैसे configure करूँ?

Source control से बाहर एक स्थानीय file बनाएं:

OPENAI_API_KEY=your_server_side_provider_key

उस file के साथ function serve करें:

supabase functions serve chat --env-file .env.local

Linked project के लिए production secret को Supabase Edge Functions secrets documentation में documented वर्तमान syntax का उपयोग करके set करें। सामान्यतः उपयोग की जाने वाली command है:

supabase secrets set OPENAI_API_KEY=your_server_side_provider_key

.gitignore से स्थानीय files को सुरक्षित रखें:

.env*
!.env.example

.env.example में केवल variable name होना चाहिए:

OPENAI_API_KEY=

Local smoke test में मुझे क्या verify करना चाहिए?

जब application को database या authentication services की आवश्यकता हो, तब local stack शुरू करें:

supabase start
supabase functions serve chat --env-file .env.local

फिर function का सीधे परीक्षण करें:

curl -i -X POST http://127.0.0.1:54321/functions/v1/chat \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Hello"}'

message के बजाय prompt का उपयोग करें, क्योंकि minimal function contract में prompt field अपेक्षित है। सफल response यह verify करता है कि function शुरू होता है, अपना configured secret पढ़ता है, JSON body parse करता है, prompt को upstream model को भेजता है और response लौटाता है। यह frontend rendering या browser CORS behavior को verify नहीं करता।

यदि test 500 लौटाता है, तो पहले पुष्टि करें कि .env.local में अपेक्षित variable name मौजूद है और file बदलने के बाद function restart किया गया है।

मैं minimal secure Edge Function कैसे लिखूँ और उसे frontend से कैसे call करूँ?

न्यूनतम सुरक्षित आर्किटेक्चर ब्राउज़र → Supabase Edge Function → OpenAI-compatible model है: ब्राउज़र एक प्रॉम्प्ट भेजता है, Edge Function सर्वर-साइड सीक्रेट्स से प्रोवाइडर कुंजी पढ़ता है, मॉडल को कॉल करता है और JSON लौटाता है। ब्राउज़र के सामने प्रोवाइडर कुंजी उजागर किए बिना Supabase Auth, डेटाबेस में स्थायित्व और रेट लिमिटिंग बाद में जोड़ी जा सकती है।

मैं Edge Function कैसे बनाऊँ और कॉन्फ़िगर करूँ?

Supabase CLI कमांड रिलीज़ के बीच बदल सकते हैं, इसलिए प्रोडक्शन डिप्लॉयमेंट से पहले Supabase के दस्तावेज़ में वर्तमान सिंटैक्स की पुष्टि करें:

supabase login
supabase link --project-ref YOUR_PROJECT_REF
supabase functions new chat
supabase secrets set OPENAI_API_KEY="sk-your-server-side-key"
supabase secrets set OPENAI_MODEL="gpt-4o-mini"
supabase functions serve chat --env-file .env.local
supabase functions deploy chat

OPENAI_API_KEY को कभी भी फ्रंटएंड एनवायरनमेंट वेरिएबल्स, कमिट की गई फ़ाइलों, ब्राउज़र स्टोरेज या HTML में न रखें। CallMissed जैसे प्लेटफ़ॉर्म OpenAI-compatible gateway भी प्रदान करते हैं, जिससे ब्राउज़र इंटीग्रेशन को फिर से लिखे बिना अपस्ट्रीम एंडपॉइंट और मॉडल कॉन्फ़िगरेशन बदले जा सकते हैं।

न्यूनतम सुरक्षित Edge Function क्या है?

यह उदाहरण जानबूझकर केवल स्थानीय या प्रारंभिक परीक्षण के लिए अनऑथेंटिकेटेड अनुरोधों की अनुमति देता है। लॉन्च से पहले Supabase access token आवश्यक करें, उसे सर्वर-साइड पर वैलिडेट करें और प्रति-उपयोगकर्ता रेट लिमिट जोड़ें।

// supabase/functions/chat/index.ts
const origin = Deno.env.get("ALLOWED_ORIGIN") ?? "http://localhost:5173";
const apiKey = Deno.env.get("OPENAI_API_KEY");
const model = Deno.env.get("OPENAI_MODEL") ?? "gpt-4o-mini";

const cors = {
  "Access-Control-Allow-Origin": origin,
  "Access-Control-Allow-Methods": "POST, OPTIONS",
  "Access-Control-Allow-Headers":
    "authorization, x-client-info, apikey, content-type",
  "Content-Type": "application/json",
};

const reply = (body: unknown, status = 200) =>
  new Response(JSON.stringify(body), { status, headers: cors });

Deno.serve(async (req) => {
  try {
    if (req.method === "OPTIONS") return new Response("ok", { headers: cors });
    if (req.method !== "POST") return reply({ error: "Method not allowed" }, 405);
    if (!apiKey) return reply({ error: "Server key is not configured" }, 500);

    let body: { prompt?: unknown };
    try {
      body = await req.json();
    } catch {
      return reply({ error: "Request body must be valid JSON" }, 400);
    }

    if (
      typeof body.prompt !== "string" ||
      body.prompt.trim().length === 0 ||
      body.prompt.length > 8_000
    ) {
      return reply({ error: "prompt must be 1–8,000 characters" }, 400);
    }

    let upstream: Response;
    try {
      upstream = await fetch("https://api.openai.com/v1/chat/completions", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${apiKey}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          model,
          messages: [{ role: "user", content: body.prompt.trim() }],
        }),
      });
    } catch (error) {
      console.error("Upstream network failure:", error);
      return reply({ error: "Model service is temporarily unavailable" }, 502);
    }

    if (!upstream.ok) {
      console.error("Model provider status:", upstream.status);
      return reply({ error: "Model request failed" }, 502);
    }

    let result: any;
    try {
      result = await upstream.json();
    } catch {
      return reply({ error: "Model returned invalid JSON" }, 502);
    }

    const content = result.choices?.[0]?.message?.content;
    return typeof content === "string"
      ? reply({ message: content })
      : reply({ error: "Model returned an unexpected response" }, 502);
  } catch (error) {
    console.error("Unhandled function error:", error);
    return reply({ error: "Internal server error" }, 500);
  }
});

8,000-वर्ण की सीमा एक एप्लिकेशन वैलिडेशन विकल्प है, यह किसी कथित प्रोवाइडर सीमा का दावा नहीं है। प्रोडक्शन में ALLOWED_ORIGIN को सटीक फ्रंटएंड डोमेन पर सेट करें, पेलोड आकार और संदेश भूमिकाओं को वैलिडेट करें और प्रॉम्प्ट, टोकन या सीक्रेट को कभी लॉग न करें।

फ्रंटएंड फ़ंक्शन को कैसे कॉल करता है?

<input id="prompt" />
<button id="send">Send</button>
<pre id="answer"></pre>

<script type="module">
  const promptInput = document.querySelector("#prompt");
  const answer = document.querySelector("#answer");

  document.querySelector("#send").addEventListener("click", async () => {
    answer.textContent = "Loading...";

    const response = await fetch(
      "https://YOUR_PROJECT_REF.supabase.co/functions/v1/chat",
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ prompt: promptInput.value }),
      }
    );

    const data = await response.json().catch(() => ({}));

    if (!response.ok) {
      throw new Error(data.error ?? `Request failed: ${response.status}`);
    }

    answer.textContent = data.message;
  });
</script>

ऑथेंटिकेटेड ऐप के लिए Authorization: Bearer ${session.access_token} जोड़ें और क्लाइंट द्वारा भेजी गई user ID पर भरोसा करने के बजाय उस टोकन को फ़ंक्शन के अंदर वैलिडेट करें।

प्रोडक्शन के लिए ऑथेंटिकेशन, स्थायित्व, स्ट्रीमिंग, रेट लिमिटिंग और ऑब्ज़र्वेबिलिटी कैसे जोड़ूँ? (तालिका)

प्रोडक्शन नियंत्रण इस क्रम में जोड़ें: कॉलर को ऑथेंटिकेट करें, Row Level Security (RLS) के अंतर्गत डेटा को स्थायी रूप से सहेजें, वैकल्पिक रूप से मॉडल आउटपुट को स्ट्रीम करें, सर्वर-साइड कोटा लागू करें और संशोधित टेलीमेट्री उत्सर्जित करें। Edge Function को Supabase access token वैलिडेट करना चाहिए, वैलिडेट की गई user ID से स्वामित्व निर्धारित करना चाहिए, सर्वर-साइड सीक्रेट के साथ मॉडल प्रोवाइडर को कॉल करना चाहिए और ब्राउज़र द्वारा भेजे गए user_id पर कभी भरोसा नहीं करना चाहिए।

डिप्लॉय करने से पहले मुझे क्या जोड़ना चाहिए?

RFC 6585 HTTP 429 को परिभाषित करता है, जबकि RFC 9110 सामान्य HTTP सेमांटिक्स, जैसे 400, 401 और 403 जैसी स्थितियों, को परिभाषित करता है। विकृत इनपुट के लिए 400, अमान्य ऑथेंटिकेशन के लिए 401 और ऑथेंटिकेटेड लेकिन अनधिकृत एक्सेस के लिए 403 लौटाएँ।

मैं RLS-संरक्षित चैट स्कीमा कैसे बनाऊँ?

यह SQL Supabase SQL Editor में चलाएँ। messages नीति अपनी पैरेंट conversation के माध्यम से स्वामित्व की जाँच करती है:

create table public.conversations (
  id uuid primary key default gen_random_uuid(),
  owner_id uuid not null references auth.users(id) on delete cascade,
  title text,
  created_at timestamptz not null default now()
);

create table public.messages (
  id bigint generated always as identity primary key,
  conversation_id uuid not null references public.conversations(id) on delete cascade,
  role text not null check (role in ('system', 'user', 'assistant')),
  content text not null,
  created_at timestamptz not null default now()
);

alter table public.conversations enable row level security;
alter table public.messages enable row level security;

create policy "owners manage conversations"
on public.conversations for all
using (owner_id = auth.uid())
with check (owner_id = auth.uid());

create policy "owners manage messages"
on public.messages for all
using (exists (
  select 1 from public.conversations c
  where c.id = conversation_id and c.owner_id = auth.uid()
))
with check (exists (
  select 1 from public.conversations c
  where c.id = conversation_id and c.owner_id = auth.uid()
));

मैं पहचान का सत्यापन और संदेशों को स्थायी रूप से कैसे संग्रहीत करूँ?

किसी अपरिभाषित ग्लोबल पर निर्भर रहने के बजाय Supabase क्लाइंट को आरंभ करें। यह पैटर्न कॉल करने वाले के JWT का उपयोग करता है, इसलिए Postgres RLS लागू होता है:

import { createClient } from "npm:@supabase/supabase-js@2";

const authHeader = req.headers.get("Authorization");
if (!authHeader?.startsWith("Bearer ")) {
  return Response.json({ error: "Authentication required" }, { status: 401 });
}

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_ANON_KEY")!,
  { global: { headers: { Authorization: authHeader } } }
);

const { data: { user }, error } = await supabase.auth.getUser();
if (error || !user) {
  return Response.json({ error: "Invalid access token" }, { status: 401 });
}

const { data: conversation, error: insertError } =
  await supabase.from("conversations")
    .insert({ owner_id: user.id, title: "New chat" })
    .select("id").single();

await supabase.from("messages").insert({
  conversation_id: conversation.id,
  role: "user",
  content: validatedMessage
});

Supabase Auth का दस्तावेज़ीकरण Auth सेवा के माध्यम से टोकन का सत्यापन करने की अनुशंसा करता है। checkQuota जैसे हेल्पर को ट्रांज़ैक्शनल स्टोर या बाहरी सेवा के साथ लागू किया जाना चाहिए; जब तक उसका सेटअप दिखाया न गया हो, इसे स्यूडोकोड मानें। स्ट्रीमिंग के लिए, प्रदाता की स्ट्रीम को उसके दस्तावेज़ित Content-Type के साथ लौटाएँ, एक correlation ID जोड़ें, और पूरे प्रॉम्प्ट या सीक्रेट रिकॉर्ड किए बिना समय और स्थिति लॉग करें।

कौन-सी सामान्य गलतियाँ सुरक्षा बग, CORS विफलताएँ, प्रमाणीकरण त्रुटियाँ या अविश्वसनीय ChatGPT प्रतिक्रियाएँ उत्पन्न करती हैं? (तालिका)

Supabase Edge Function को भेजे गए प्रत्येक ब्राउज़र अनुरोध को अविश्वसनीय मानें: मॉडल-प्रदाता की कुंजी कभी उजागर न करें, क्लाइंट द्वारा भेजी गई उपयोगकर्ता ID पर कभी भरोसा न करें, और कभी यह न मानें कि सफल HTTP अनुरोध में मान्य मॉडल प्रतिक्रिया शामिल है। अधिकांश विफलताएँ सीक्रेट, CORS, प्रमाणीकरण, पेलोड सत्यापन और अपस्ट्रीम त्रुटि प्रबंधन से जुड़ी कुछ रोकी जा सकने वाली सामान्य गलतियों के कारण होती हैं।

परिनियोजन से पहले आपको किन गलतियों की जाँच करनी चाहिए?

आप इन विफलताओं का व्यवस्थित रूप से निदान कैसे करते हैं?

ब्राउज़र के Network पैनल और Supabase Edge Function लॉग का एक साथ उपयोग करें:

1. यदि प्रतिक्रिया प्राप्त करने से पहले ब्राउज़र विफल हो जाता है, तो OPTIONS प्रीफ़्लाइट अनुरोध, अनुमत origin, अनुमत हेडर और यह जाँचें कि फ़ंक्शन त्रुटियों के साथ-साथ सफल प्रतिक्रियाओं पर भी CORS हेडर लौटाता है या नहीं।
2. यदि प्रतिक्रिया 401 है, तो पुष्टि करें कि फ्रंटएंड Authorization: Bearer <access_token> भेजता है और फ़ंक्शन केवल यह जाँचने के बजाय टोकन का सत्यापन करता है कि हेडर मौजूद है।
3. यदि प्रतिक्रिया 403 है, तो डेटाबेस स्वामित्व नियमों, Row Level Security नीतियों और बातचीत के लिए किसी भी सर्वर-साइड प्राधिकरण जाँच का निरीक्षण करें।
4. यदि प्रतिक्रिया 400 है, तो विकास के दौरान केवल सुरक्षित सत्यापन विवरण प्रिंट करें और सत्यापित करें कि क्लाइंट अपेक्षित messages संरचना के साथ मान्य JSON भेजता है।
5. यदि प्रतिक्रिया 429, 500, 502 या 504 है, तो अनुरोध ID और अपस्ट्रीम स्थिति फ़ील्ड का उपयोग करके अपने फ़ंक्शन की विफलता को मॉडल प्रदाता की विफलता से अलग करें।

CORS पर MDN Web Docs का मार्गदर्शन और HTTP स्थिति कोड के लिए IETF RFC 9110 की परिभाषाएँ मानकों का आधार प्रदान करती हैं; परिनियोजन से पहले रनटाइम-विशिष्ट व्यवहार के लिए Supabase के वर्तमान Edge Functions और Auth दस्तावेज़ीकरण की जाँच की जानी चाहिए। एक विश्वसनीय ChatGPT ऐप इन विफलताओं को छिपाता नहीं है—यह सीक्रेट या उपयोगकर्ता डेटा लीक किए बिना उन्हें पूर्वानुमेय, न्यूनतम प्रतिक्रियाओं में बदल देता है।

CORS, 401, विकृत JSON, अपस्ट्रीम त्रुटियाँ, टाइमआउट और स्ट्रीमिंग पार्सर समस्याएँ कैसे ठीक करें?

सामान्य समस्या-निवारण प्रश्न

प्रश्न: Supabase Edge Functions वाले ChatGPT ऐप में CORS त्रुटियाँ कैसे ठीक करूँ?

उत्तर: प्रमाणीकरण या JSON पार्सिंग से पहले OPTIONS प्रीफ़्लाइट अनुरोधों को संभालें, और सफल तथा त्रुटि प्रतिक्रियाओं दोनों पर Access-Control-Allow-Origin, Access-Control-Allow-Headers और Access-Control-Allow-Methods हेडर लौटाएँ। विकास के दौरान सटीक फ्रंटएंड origin का उपयोग करें; उत्पादन में wildcard को allowlist से बदलें, क्योंकि Supabase Edge Functions सर्वर-साइड TypeScript endpoints हैं, जैसा कि Supabase द्वारा दस्तावेज़ित है।

प्रश्न: Supabase Edge Functions वाले मेरे ChatGPT ऐप में 401 Unauthorized त्रुटि क्यों आती है?

उत्तर: 401 का आमतौर पर अर्थ है कि ब्राउज़र ने वैध Supabase Auth access token नहीं भेजा, token की अवधि समाप्त हो गई है, या फ़ंक्शन क्लाइंट से provider API key की गलत अपेक्षा कर रहा है। Authorization: Bearer <supabase-access-token> भेजें, फिर क्लाइंट द्वारा भेजी गई user ID पर भरोसा करने के बजाय फ़ंक्शन के अंदर Supabase Auth से उस token को मान्य करें; frontend code में model-provider key कभी उजागर न करें।

प्रश्न: मैं malformed JSON या “Unexpected end of JSON input” त्रुटियों को कैसे ठीक करूँ?

उत्तर: पुष्टि करें कि क्लाइंट Content-Type: application/json और वैध serialized body भेजता है, जैसे JSON.stringify({ messages }), और यह सत्यापित करें कि फ़ंक्शन await request.json() को केवल एक बार कॉल करता है। खाली request bodies, trailing commas, गलत property names और non-JSON error responses की जाँच करें; secrets या पूरे user prompts को लॉग करने के बजाय request ID और validation result लॉग करें।

प्रश्न: Supabase Edge Function से आने वाली upstream OpenAI या model-provider त्रुटियों का निवारण कैसे करूँ?

उत्तर: पहले सर्वर पर provider response का status और body देखें, फिर credentials या अस्पष्ट HTML को browser पर forward करने के बजाय { "error": "upstream_model_error", "requestId": "..." } जैसा स्थिर JSON error shape लौटाएँ। Provider से मिलने वाला 401 या 403 आमतौर पर अनुपस्थित, अमान्य या अनधिकृत server secret को दर्शाता है, जबकि 429 throttling को दर्शाता है; application code बदलने से पहले configured secret, model name, account permissions और provider documentation की जाँच करें।

प्रश्न: ChatGPT response generate करते समय मेरा Supabase Edge Function timeout क्यों हो जाता है?

उत्तर: Timeout आमतौर पर अत्यधिक conversation history, धीमे upstream model, बहुत लंबे समय तक चलने वाले retries या streaming से perceived latency कम होने के बावजूद पूर्ण response की प्रतीक्षा करने के कारण होते हैं। Input size और history सीमित करें, platform request limit से कम explicit upstream AbortController timeout सेट करें, unbounded retries से बचें और स्पष्ट retryable error लौटाएँ; Supabase की documentation में वर्तमान Edge Function limits की पुष्टि करें, क्योंकि runtime quotas version और plan पर निर्भर होती हैं।

प्रश्न: Supabase Edge Functions वाले ChatGPT ऐप में streaming parser की समस्याएँ कैसे ठीक करूँ?

उत्तर: सुनिश्चित करें कि फ़ंक्शन और क्लाइंट एक ही protocol पर सहमत हों: Server-Sent Events में आमतौर पर Content-Type: text/event-stream का उपयोग होता है, जबकि newline-delimited JSON में प्रत्येक पंक्ति पर एक पूर्ण JSON object होता है। क्लाइंट को partial network chunks को buffer करना चाहिए, केवल पूर्ण delimiters पर split करना चाहिए, जहाँ लागू हो वहाँ SSE data: prefix हटाना चाहिए, provider के terminal event को संभालना चाहिए और streaming अक्षम होने पर सामान्य JSON response पर वापस आना चाहिए; production से पहले disconnects और malformed chunks का परीक्षण करें।

Deployment से पहले मुझे क्या सत्यापित करना चाहिए, और Supabase ChatGPT ऐप के साथ आगे कहाँ जा सकता हूँ?

Deployment से पहले production-जैसे environment में secret management, authentication, input validation, database ownership, CORS, error handling, observability और वर्तमान provider API behavior सत्यापित करें। पहली release के बाद आप Supabase ChatGPT ऐप को streaming, persistent conversation history, retrieval-augmented generation, tool calling, analytics और multichannel interfaces के साथ विस्तारित कर सकते हैं।

अपने Supabase ChatGPT ऐप को deploy करने से पहले मुझे क्या सत्यापित करना चाहिए?

इस release checklist का उपयोग करें:

1. Credentials की सुरक्षा करें: पुष्टि करें कि OpenAI या compatible-provider key केवल Supabase server-side secrets में मौजूद है। लीक हुई keys के लिए frontend bundle, Git history, logs और network requests खोजें। Supabase documentation project secrets को Edge Functions के लिए उपलब्ध runtime environment variables के रूप में वर्णित करती है; provider credentials को browser-exposed .env variables में न रखें।
2. Users को authenticate करें: Private features के लिए Supabase Auth access token आवश्यक करें। Edge Function को Supabase Auth के साथ token सत्यापित करना चाहिए और verified token से user identity प्राप्त करनी चाहिए, बजाय JSON में भेजे गए user_id पर भरोसा करने के।
3. Requests को validate करें: अधिकतम body size लागू करें, non-empty prompt आवश्यक करें, message roles को validate करें, unexpected fields अस्वीकार करें और malformed JSON को नियंत्रित 400 response के साथ संभालें।
4. Database isolation जाँचें: Conversation और message tables पर Row Level Security सक्षम करें। दो अलग-अलग users के साथ परीक्षण करके पुष्टि करें कि User A, User B के records को select, update या delete नहीं कर सकता।
5. Browser access सीमित करें: जहाँ संभव हो wildcard CORS को अपने production origin से बदलें। पुष्टि करें कि preflight OPTIONS requests और authenticated requests दोनों सफल होते हैं।
6. Failures का परीक्षण करें: Missing secrets, expired tokens, provider 401 या 429 responses, timeouts, empty model output और invalid streaming chunks का अनुकरण करें।
7. Logs की समीक्षा करें: Supabase Edge Functions logs में request IDs, latency, status और सुरक्षित error categories दर्ज होनी चाहिए—API keys, access tokens, full prompts या personal data नहीं।

Release से तुरंत पहले Supabase की Edge Functions documentation, Supabase Auth documentation और OpenAI API documentation की जाँच करनी चाहिए, क्योंकि CLI commands, runtime behavior, model names, limits और response formats बदल सकते हैं।

मुझे आगे कौन-से सुधार बनाने चाहिए?

User value और operational risk के अनुसार सुधारों को प्राथमिकता दें:

• Streaming responses: Edge Function से provider का समर्थित event stream लौटाएँ और browser में chunks को क्रमिक रूप से consume करें। Model provider की official documentation में वर्तमान streaming format सत्यापित करें; यह न मानें कि प्रत्येक OpenAI-compatible provider समान event names या termination markers का उपयोग करता है।
• Conversation history: Authenticated user के लिए foreign key के साथ conversations और messages store करें, फिर केवल Row Level Security द्वारा अनुमत records load करें।
• Rate limiting और budgets: Per-user और per-IP request limits, maximum prompt lengths, concurrency controls और daily spending alerts लागू करें। Provider-side limits और pricing version-sensitive होते हैं, इसलिए उन्हें copied examples के बजाय वर्तमान billing documentation के आधार पर configure करें।
• Grounded answers: Document ingestion, embeddings, retrieval और citations जोड़ें, ताकि assistant आपकी approved knowledge base से उत्तर दे।
• Tool calling: Server को order lookup या appointment booking जैसे सावधानीपूर्वक allow-listed functions invoke करने दें। प्रत्येक tool argument को validate करें और किसी भी state-changing action से पहले authorization आवश्यक करें।
• Multichannel delivery: यही authenticated, server-side orchestration pattern web chat, WhatsApp, email और voice को support कर सकता है। CallMissed जैसे platforms WhatsApp Business calling तथा 22 भारतीय भाषाओं में voice और chat experiences के माध्यम से AI communication का विस्तार करते हैं, जो यह दर्शाता है कि focused chat backend किस प्रकार व्यापक customer engagement में विकसित हो सकता है।

Reliable deployment अंतिम लक्ष्य नहीं है: यह working demo और maintainable AI product के बीच की सीमा है। Edge Function को thin रखें, secrets को server-side रखें, प्रत्येक user और request को सत्यापित करें और runtime या API upgrade करते समय आधिकारिक Supabase तथा model-provider documentation को फिर से जाँचें।

निष्कर्ष

Supabase Edge Functions वाला सुरक्षित ChatGPT ऐप एक सिद्धांत से शुरू होता है: browser prompts को Edge Function पर भेजता है, जबकि function model-provider API key को server-side रखता है और response लौटाता है। इस minimal flow से आप authentication, persistence, validation, rate limiting, streaming और observability को सोच-समझकर जोड़कर production-ready foundation बना सकते हैं।

मुख्य बातें हैं:

• क्रेडेंशियल सुरक्षित रखें: ब्राउज़र कोड, स्टोरेज या नेटवर्क अनुरोधों में OpenAI या संगत मॉडल API कुंजी कभी उजागर न करें; इसे सर्वर-साइड सीक्रेट के रूप में संग्रहीत करें।
• हर अनुरोध को मान्य करें: CORS, JSON पार्सिंग, पेलोड आकार, संदेश भूमिकाओं, अपस्ट्रीम विफलताओं और गैर-2xx प्रतिक्रियाओं को प्रोडक्शन घटनाओं में बदलने से पहले संभालें।
• डेटा को प्रमाणित और अलग रखें: एक्सेस टोकन को मान्य करने के लिए Supabase Auth का उपयोग करें, फिर सर्वर-साइड जाँचों और Row Level Security के साथ वार्तालाप के स्वामित्व को लागू करें।
• सावधानीपूर्वक स्केल करें: वर्तमान Supabase और मॉडल-प्रदाता दस्तावेज़ों की पुष्टि करने के बाद ही स्ट्रीमिंग, कोटा, दुरुपयोग नियंत्रण, संरचित लॉगिंग और डिप्लॉयमेंट जाँचें जोड़ें।

इस आर्किटेक्चर का अगला चरण अधिक सक्षम मॉडलों, कम विलंबता वाले इन्फरेंस, विकसित हो रही स्ट्रीमिंग APIs और गोपनीयता तथा लागत नियंत्रण की अधिक कड़ी आवश्यकताओं से आकार लेगा। CallMissed जैसे प्लेटफ़ॉर्म दिखाते हैं कि यही AI-इन्फ्रास्ट्रक्चर पैटर्न 22 भारतीय भाषाओं में वॉइस एजेंट और बहुभाषी चैटबॉट तक विस्तृत हो रहा है।

अपने सीक्रेट सुरक्षित रखने और डेटा सीमाओं को स्पष्ट रूप से परिभाषित करने के बाद, आप अगला AI अनुभव किस आधार पर बनाएँगे?

संबंधित लेख

• Supabase Edge Functions के साथ ChatGPT ऐप कैसे बनाएं? 2026 गाइड
• छोटे व्यवसाय के लिए 24/7 AI ग्राहक सेवा: साझा मेमोरी के साथ वॉइस, WhatsApp और ईमेल स्टैक बनाएं
• छोटे व्यवसाय के लिए CallMissed: 24/7 AI संचार वर्कफ़्लो बनाएं