eduardweb.
OpenAI & ClaudeAvansat#typescript#openai#sql#function-calling#agent

Function Calling cu OpenAI: cum interoghezi baza de date fără să-ți expui schema întreagă

De Ioan Manole, 24 oct. 2026 · 34 vizualizări · 2 like-uri

Postat 24 oct. 2026
typescript
import OpenAI from 'openai';

const openai = new OpenAI();

// Definim schema strictă pentru tool
const tools: OpenAI.ChatCompletionTool[] = [{
  type: 'function',
  function: {
    name: 'getOrderStats',
    description: 'Află statistici agregate despre comenzi',
    parameters: {
      type: 'object',
      properties: {
        startDate: { type: 'string', description: 'ISO date' },
        status: { type: 'string', enum: ['completed', 'cancelled', 'pending'] }
      },
      required: ['startDate', 'status'],
      additionalProperties: false
    }
  }
}];

// Loop-ul simplificat de dispatch
async function queryAgent(userPrompt: string, tenantId: string) {
  const messages: OpenAI.ChatCompletionMessageParam[] = [
    { role: 'system', content: 'Răspunde exclusiv pe baza uneltelor disponibile.' },
    { role: 'user', content: userPrompt }
  ];

  const res = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages,
    tools
  });

  const toolCall = res.choices[0].message.tool_calls?.[0];
  if (toolCall && toolCall.function.name === 'getOrderStats') {
    const args = JSON.parse(toolCall.function.arguments);
    
    // Security check: tenantId vine DIN CONTEXT, nu din LLM
    const data = await db.orders.aggregate({ tenantId, ...args });

    messages.push(res.choices[0].message);
    messages.push({
      role: 'tool',
      tool_call_id: toolCall.id,
      content: JSON.stringify(data)
    });

    const finalRes = await openai.chat.completions.create({ model: 'gpt-4o-mini', messages });
    return finalRes.choices[0].message.content;
  }

  return res.choices[0].message.content;
}

Toată lumea vrea să pună un LLM peste baza de date internă și să spună conducerii că au făcut sistem de BI conversațional. În practică, dacă lași modelul să genereze SQL arbitrar pe o conexiune directă, mai devreme sau mai târziu o să crape ceva grav sau o să-ți blocheze baza cu un full scan idiot pe 4 milioane de rânduri.

Am implementat pattern-ul ăsta acum vreo șase luni pentru o platformă B2B cu vreo 80k comenzi active. După ce am testat mai multe variante, singura abordare care a supraviețuit în producție fără panică de security a fost trecerea de la „modelul generează SQL liber” la „modelul alege o funcție strictă cu parametri validați prin Zod”.

De ce pică abordarea cu raw SQL

Prima tentație e să-i dai în system prompt definiția tabelelor (DDL) și să-i ceri SELECT-uri. Pare flexibil. M-am prins repede că flexibilitatea asta te omoară: modelul inventează clauze JOIN inexistente dacă schema devine puțin mai stufoasă, uită de indecși și generează query-uri de 12 secunde pe tabele agregate.

Pe lângă asta, oricât îl rogi frumos în prompt să facă doar SELECT, e suficient un prompt injection mai subtil din partea unui user malițios ca să te trezești cu lock-uri pe tabele sau date leakuite dincolo de tenant-ul curent.

Pattern-ul: unelte atomice, parametri rigizi

Soluția sănătoasă e să tratezi baza de date ca pe un set de query-uri predefinite sau un query-builder restrâns. În loc să lași modelul să scrie interogarea, îi dai un tool de tipul get_monthly_revenue sau search_orders cu parametri clari: startDate, endDate, status, limit.

Fluxul funcționează simplu în trei pași:

  1. Utilizatorul pune o întrebare în limbaj natural („Câte comenzi am avut anulate săptămâna trecută?”).
  2. Modelul decide că are nevoie de tool-ul search_orders și îți returnează un JSON cu argumentele respective.
  3. Aplicația ta backend interceptează acel call, injectează obligatoriu tenant_id-ul din sesiune (pe care modelul NU are voie să-l controleze), rulează query-ul optimizat și trimite rezultatul înapoi în conversație.

Trade-off-uri reale: latență și flexibilitate

Nu e totul lapte și miere. Cel mai mare minus e latența. Pentru un singur răspuns faci două apeluri către OpenAI: primul ca să decidă ce tool apelează, al doilea ca să transforme datele brute din DB într-un rezumat lizibil. La un model standard GPT-4o, asta înseamnă că latența totală sare de la 800ms la undeva pe la 2.2 - 2.8 secunde per interogare.

Al doilea compromis ține de flexibilitate: dacă utilizatorul întreabă ceva complet atipic, pentru care nu ai definit o funcție specifică, agentul va zice sincer că nu are acces la acele date. Pentru mine, ăsta a fost un mare plus, nu un bug — prefer ca sistemul să refuze elegant decât să-mi inventeze cifre într-un raport financiar trimis către acționari.

Voi cum ați rezolvat problema permisiunilor per utilizator când ați expus baze de date către LLM-uri?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

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