DanLevy.net

IT

Smetti di Chiedere agli LLM di Fare Matematica

Sono scarsi. Ecco come risolvere.

Sai cosa c’è di strano nei modelli linguistici? Possono spiegare la meccanica quantistica, scrivere poesie e fare il debug del tuo TypeScript… ma chiedi loro di moltiplicare 18472 per 9347 e c’è una buona probabilità che ti rispondano con sicurezza sbagliando di migliaia.

Una volta mi lasciava perplesso, finché non ho capito cosa stiamo effettivamente chiedendo loro di fare. Stiamo chiedendo a un motore di riconoscimento di pattern di fare il calcolatore. È come chiedere a un ginnasta di tenere la tua contabilità perché conosce il concetto di “equilibrio”.

Il fatto è che gli LLM non calcolano nulla. Quando chiedi a GPT o Claude quanto fa 2 + 2, non stanno sommando. Stanno prevedendo che “4” è il token più probabile dopo “2 + 2 =”. Nella maggior parte dei casi funziona benissimo, perché questi pattern esistono nei loro dati di addestramento. Ma spingiti oltre l’aritmetica semplice verso calcoli multi-step o qualsiasi cosa con numeri che non erano comuni nell’addestramento, e stai essenzialmente lanciando i dadi.

Mi ci sono sbattuto la testa di recente mentre revisionavo del codice che usava un modello di alto livello per calcolare rate di mutui. Il modello ha risposto con totale sicurezza. Sbagliava anche di 400 dollari al mese. È il tipo di errore che conta.

Anche man mano che i modelli migliorano nel ragionamento (si dice che GPT-5 mostri miglioramenti), stanno pur sempre facendo un sofisticato riconoscimento di pattern, non calcolo simbolico. Per il lavoro creativo e le attività di linguaggio naturale, questa natura probabilistica è esattamente ciò che li rende magici. Per la matematica? Non proprio.

Cosa Risolve Davvero il Problema?

La risposta non è aspettare modelli più intelligenti. È dare al modello lo strumento giusto per il lavoro.

Pensa a come risolveresti questo problema se stessi costruendo un sistema non-AI. Non scriveresti logica matematica custom, useresti una libreria. Lo stesso principio si applica qui, solo che ora stiamo insegnando all’LLM quando e come usare quella libreria.

Le tool call nei moderni SDK AI ci permettono di fornire al modello funzioni strutturate che può invocare. Invece di costringere l’LLM a fingere di sapere la matematica, gli diamo qualcosa che la sa davvero: un motore di matematica simbolica.

Ho usato AI SDK v5 e v6 per questo, insieme a CortexJS Compute Engine. L’SDK gestisce orchestrazione e routing degli strumenti, mentre CortexJS gestisce qualsiasi cosa, dall’aritmetica di base fino al calcolo infinitesimale. È una separazione dei compiti sorprendentemente pulita.

Terminal window
bun add ai @ai-sdk/anthropic @cortex-js/compute-engine zod

Costruire lo Strumento Matematico

L’implementazione è più diretta di quanto potresti pensare. Quello che stiamo costruendo è un ponte tra la comprensione del linguaggio naturale dell’LLM e il calcolo matematico effettivo.

import { generateText, stepCountIs, tool } from 'ai';
import { ComputeEngine } from '@cortex-js/compute-engine';
import { z } from 'zod';


// Initialize the engine once
const ce = new ComputeEngine();


const mathTool = tool({
  description: 'Evaluate mathematical expressions and solve equations with guaranteed accuracy. MUST be used for all mathematical operations to verify correctness - do not attempt mental math. Supports arithmetic, algebra, calculus, and complex operations. Can process multiple expressions at once.',
  parameters: z.object({
    expressions: z.array(z.string()).describe(
      'Array of mathematical expressions in LaTeX or plain notation, e.g. ["2 + 2", "\\frac{x^2 + 1}{x - 1}", "\\int x^2 dx"]'
    ),
  }),
  execute: async ({ expressions }) => {
    // Process all expressions in parallel (or detailed batch)
    return expressions.map(expression => {
      try {
        const result = ce.parse(expression).evaluate();
        return {
          expression,
          result: result.toString(),
          latex: result.latex,
        };
      } catch (error) {
        return {
          expression,
          error: (error as Error).message
        };
      }
    });
  },
});

Qualche cosa da notare:

La descrizione fa il grosso del lavoro. Quel linguaggio “MUST be used” può sembrare aggressivo, ma nella mia esperienza, essere espliciti con il modello su quando usare uno strumento è la differenza tra funzionare a volte e funzionare in modo affidabile. Consideralo prompt engineering a livello di strumento.

L’elaborazione batch tramite un array expressions conta più di quanto potresti pensare. Ogni chiamata al modello ha latenza. Se stai risolvendo un sistema di equazioni o facendo matematica multi-step, elaborarli singolarmente crea una terribile esperienza utente. Il batch significa un solo round-trip per risolvere dieci problemi.

Usare un motore simbolico invece di un semplice eval() (per favore non usare eval()) ci dà una vera comprensione matematica. Il motore analizza l’intento, gestisce la formattazione LaTeX e può lavorare con derivate e integrali. Non stiamo solo facendo calcoli, stiamo facendo matematica.

La gestione degli errori è limitata a ogni espressione. Se un calcolo fallisce, restituiamo quell’errore ma continuiamo con il resto. Questo permette al modello di vedere cosa ha funzionato e cosa no, potenzialmente auto-correggendosi nel passaggio successivo.

Metterlo al Lavoro

Proviamo con qualcosa che tipicamente farebbe allucinare un modello grezzo:

import { anthropic } from '@ai-sdk/anthropic';


const { text } = await generateText({
  model: anthropic('claude-sonnet-4-5'),
  prompt: 'Calculate 18472 × 9347, divide by 127, then take the square root of the result.',
  tools: { mathTool },
  stopWhen: stepCountIs(5), // Allow up to five model/tool steps
});


console.log(text);

Il modello vede la matematica, riconosce che ha bisogno di precisione, chiama lo strumento, ottiene il risultato accurato e poi lo spiega in linguaggio naturale. Ogni componente fa ciò che sa fare meglio.

Oltre l’Aritmetica di Base

Dato che usiamo un motore simbolico, questo approccio gestisce cose che i semplici strumenti calcolatrice non possono toccare.

Vuoi risolvere equazioni algebriche? “Risolvi queste equazioni: 3x + 7 = 22 e 2y - 5 = 13” funziona benissimo.

Ti serve il calcolo infinitesimale? “Trova la derivata di x^3 + 2x^2 e valutala per x = 2” è solo un’altra chiamata allo strumento.

Il supporto LaTeX è particolarmente utile se stai costruendo app educative. Il motore comprende nativamente l’input LaTeX e può restituire risultati formattati per il rendering. Nessuna analisi aggiuntiva richiesta.

Il Quadro Più Ampio

Penso che questo pattern conti oltre la sola matematica. Quello che stiamo davvero facendo è riconoscere i limiti degli LLM sfruttandone i punti di forza. Sono incredibili nel comprendere l’intento, analizzare il linguaggio naturale e orchestrare flussi di lavoro. Non sono calcolatrici, database o file system.

Ogni volta che proviamo a far fare a un LLM qualcosa di deterministico, stiamo combattendo la sua natura. Ma quando accoppiamo quella comprensione del linguaggio naturale con strumenti specializzati che gestiscono le parti deterministiche? È lì che le cose si fanno interessanti.

Lo strumento matematico è solo un esempio. Lo stesso principio si applica alla manipolazione di date, calcoli finanziari, elaborazione di immagini, query di database… ovunque la precisione conti più della creatività. Lascia che il modello capisca cosa vuole l’utente, poi passa il lavoro effettivo a qualcosa costruito per quello scopo.

È un cambiamento nel modo di pensare alla costruzione con l’AI. Non “il modello può fare questo?” ma “il modello può orchestrare questo?” Piccola differenza nella formulazione, significativa differenza nell’affidabilità.

Risorse

Loading comments...