eduardweb.
OpenAI & ClaudeAvansat#typescript#postgresql#openai#ai-agents#function-calling

Function calling cu OpenAI: cum am legat un LLM la Postgres fără să risc dezastre

De Vlad Stancu, 18 oct. 2026 · 31 vizualizări · 3 like-uri

Postat 18 oct. 2026
typescript
async function runAgent(userPrompt: string, history: ChatCompletionMessageParam[] = []) {
  const messages: ChatCompletionMessageParam[] = [
    { role: 'system', content: 'Ești un asistent intern. Folosește uneltele disponibile pentru date.' },
    ...history,
    { role: 'user', content: userPrompt }
  ];

  while (true) {
    const response = await openai.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools: dbToolDefinitions,
      tool_choice: 'auto',
    });

    const choice = response.choices[0].message;
    messages.push(choice);

    if (!choice.tool_calls || choice.tool_calls.length === 0) {
      return choice.content; // Răspunsul final generat pentru utilizator
    }

    for (const toolCall of choice.tool_calls) {
      const handler = toolRegistry[toolCall.function.name];
      const args = JSON.parse(toolCall.function.arguments);
      
      const result = handler 
        ? await handler(args).catch(err => ({ error: err.message }))
        : { error: 'Unknown tool' };

      messages.push({
        role: 'tool',
        tool_call_id: toolCall.id,
        content: JSON.stringify(result)
      });
    }
  }
}

Toată lumea vrea să pună un LLM peste baza de date a companiei și să întrebe „care au fost vânzările pe Q3”. Problema e că majoritatea sar direct la text-to-SQL fără protecție, iar la primul prompt mai ciudat te trezești cu un SELECT * pe o tabelă de 4 milioane de rânduri care-ți blochează baza. Am trecut prin asta acum vreo 6 luni pe un proiect cu 60k comenzi lunare, unde echipa de suport pierdea ore întregi căutând manual statusuri de retur.

După ce ne-am fript cu timeout-uri și halucinații pe tabele relaționale complexe, am aruncat la gunoi promptul care genera SQL brut și am trecut pe function calling strict. Iată pattern-ul care a supraviețuit în producție.

Problema cu text-to-SQL direct

Dacă îi dai modelului schema completă a bazei în system prompt, pierzi instantaneu două lucruri: bani și latență. La o schemă cu 40 de tabele, consumi vreo 3.000 de tokeni doar ca să-i explici structura la fiecare request. În plus, GPT-4o o să presupună adesea relații care nu există în realitate sau o să uite să pună un LIMIT obligatoriu.

Soluția mai curată e să-i expui un set restrâns de unelte (tools). Modelul nu are voie să inventeze query-uri, ci doar să aleagă dintr-un catalog de funcții predefinite, cu parametri validați prin JSON Schema. În loc de „generează SQL pentru utilizatorul X”, el apelează getUserOrders({ userId, limit, status }).

Bucla de execuție (Agent Loop)

Când implementezi function calling, OpenAI nu rulează codul pentru tine. Modelul doar îți semnalează: „Vreau să apelezi funcția X cu argumentele Y”. Responsabilitatea ta e să prinzi răspunsul, să rulezi funcția în backend, să atașezi rezultatul în istoricul conversației cu rolul tool și să apelezi din nou API-ul.

Am văzut mulți devi care scriu if/else pentru fiecare tool direct în controller. Devine un coșmar la mai mult de trei funcții. O abordare mult mai sănătoasă e un dispatcher decuplat: un map simplu de funcții asincrone unde fiecare funcție are acces doar la o conexiune de DB read-only.

Trade-off-uri reale

Pattern-ul ăsta nu e un glonț de argint, ci o alegere conștientă:

  1. Siguranță vs. Flexibilitate: Dacă un manager vrea un raport ad-hoc pe care nu l-ai mapat într-un tool, agentul va zice sincer că nu poate. Pentru mine e un plus masiv, nu un bug. Prefer să aud suportul zicând „nu știe asta” decât să am un lock pe Postgres în mijlocul zilei.
  2. Latență adăugată: Fiecare pas de tool execution adaugă cel puțin încă un roundtrip HTTP către OpenAI. Un răspuns simplu ia 600ms; dacă agentul decide să apeleze două unelte secvențial, te duci lejer la 2.5 - 3 secunde. E ok pentru dashboard-uri interne, e groaznic pentru un live chat public.
  3. Gestionarea erorilor: Dacă funcția ta crapă (de exemplu, timeout în DB), nu arunca 500 înapoi în UI. Trimite eroarea înapoi în LLM ca răspuns de tip tool: JSON.stringify({ error: 'DB_TIMEOUT' }). Modelul e surprinzător de bun în a-i explica utilizatorului uman că baza de date e ocupată și ar trebui să revină.

Voi cum abordați agregările mari pe date interne? Ați lăsat LLM-ul să ruleze direct pe un read-replica sau mergeți exclusiv pe API-uri pre-parametrizate?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

Doar membrii comunității pot lăsa comentarii.