LangChain.

Revisa cada query de un agente de LangChain antes de que llegue a la base, en Python y JavaScript: una herramienta que solo revisa y una SQLDatabase protegida, offline u online.

Disponible. Python: langchain-vericto 0.1.0 en PyPI (código, Apache-2.0). JavaScript: @vericto/sdk/langchain, en @vericto/sdk 0.6.0 (Apache-2.0). Vericto está en la documentación de LangChain: en Python, en la tabla Database de herramientas y en la lista de proveedores; en JavaScript, en el índice de herramientas y en la lista de proveedores.

Resumen

Vericto revisa cada sentencia SQL que escribe un agente de LangChain antes de que llegue a la base: la parsea a un árbol sintáctico y la evalúa contra reglas determinísticas (por ejemplo VERICTO-001, un DELETE sin WHERE). Una sentencia bloqueada no se ejecuta, y el modelo recibe la regla y la corrección sugerida para reintentar.

  • Una herramienta que solo revisa: VerictoSQLCheck (Python) y VerictoCheckSqlTool (JavaScript) devuelven el veredicto sin ejecutar nada.
  • Una base protegida: VerictoSQLDatabase (Python) y VerictoSqlDatabase (JavaScript) son un SQLDatabase de LangChain que revisa cada sentencia, también las que genera el toolkit SQL.
  • Seis dialectos: PostgreSQL, MySQL, Oracle, SQL Server, Snowflake y SQLite.

Offline u online

Offline (Python y JavaScript): el motor local de la CLI de Vericto 2.1.0 o posterior (la actual es la 2.4.0), sin cuenta y sin red; el SQL no sale de la máquina. Actívalo con offline=True en Python, new Vericto({ offline: true }) en JavaScript o VERICTO_OFFLINE=1 en los dos. Revisa las reglas estándar con su severidad por defecto, como la CLI offline con --sql: un DROP TABLE se bloquea.

Online (Python y JavaScript): las reglas de tu workspace a través de la API de runtime, con columnas sensibles enmascaradas, allowlists de agentes y audit trail. Necesita VERICTO_API_KEY (scope proxy:evaluate) y VERICTO_DATABASE_ID, la base registrada en el dashboard.

En JavaScript, el SDK busca la CLI en VERICTO_CLI, después en el @vericto/vericto-cli de tu node_modules y después en el PATH; nunca descarga nada. Offline junto con una API key es un error de configuración (VerictoConfigError, OFFLINE_CONFLICT): elige uno de los dos modos.

Python: langchain-vericto

Instala el paquete; el extra sql agrega VerictoSQLDatabase (con langchain-community y SQLAlchemy). Python 3.11 o posterior.

pip install -U "langchain-vericto[sql]"     # or: uv add "langchain-vericto[sql]"

# Offline mode: the Vericto CLI, 2.1.0 or later (2.4.0 is current)
npm i -g @vericto/vericto-cli                # or: brew install vericto/tap/vericto
export VERICTO_OFFLINE=1                     # or offline=True in code

# Online mode: your workspace
export VERICTO_API_KEY=vtro_...              # scope proxy:evaluate
export VERICTO_DATABASE_ID=<database-id>     # the database in the dashboard

Revisar una query: VerictoSQLCheck

La herramienta recibe query, el SQL exacto, y un dialect opcional. Devuelve el veredicto como JSON: decision, allowed, blocked, rule_codes, messages, suggested_fix y un summary con el que el modelo puede actuar. No ejecuta nada.

import json
from langchain_vericto import VerictoSQLCheck

tool = VerictoSQLCheck(offline=True, dialect="postgres")
verdict = json.loads(tool.invoke({"query": "DELETE FROM users"}))
print(verdict["decision"], verdict["rule_codes"], verdict["suggested_fix"])
print(verdict["summary"])
BLOCKED ['VERICTO-001'] DELETE FROM users WHERE id = $1
Vericto blocked this query (VERICTO-001, severity critical). It was NOT executed. Suggested fix: DELETE FROM users WHERE id = $1 Rewrite the query following the suggested fix and try again.

Llamada con un ToolCall generado por el modelo, devuelve un ToolMessage cuyo artifact es el veredicto como diccionario:

# Usually generated by the model; built by hand here.
tool_call = {"args": {"query": "DROP TABLE users"}, "id": "1", "name": tool.name, "type": "tool_call"}
message = tool.invoke(tool_call)
print(message.artifact["decision"], message.artifact["rule_codes"])
BLOCKED ['VERICTO-010']

Proteger una base: VerictoSQLDatabase

VerictoSQLDatabase es un SQLDatabase cuyas sentencias Vericto revisa antes de ejecutarlas, en el dialecto del engine de SQLAlchemy. Una sentencia bloqueada no se ejecuta: run y run_no_throw devuelven un mensaje con la regla y la corrección, para que el modelo corrija su query. Con on_block="raise" levanta vericto.VerictoBlocked.

from langchain_vericto import VerictoSQLDatabase

db = VerictoSQLDatabase.from_uri("sqlite:///shop.db", offline=True)
print(db.run("DELETE FROM orders"))
print(db.run("SELECT id, total FROM orders WHERE id = 1"))
Error: Vericto blocked this query (VERICTO-001, severity critical). It was NOT executed.
Suggested fix: DELETE FROM orders WHERE id = $1
Rewrite the query following the suggested fix and try again.
[(1, 9.5)]
import vericto

strict = VerictoSQLDatabase.from_uri("sqlite:///shop.db", offline=True, on_block="raise")
try:
    strict.run("DELETE FROM orders")
except vericto.VerictoBlocked as e:
    print("VerictoBlocked:", e)
VerictoBlocked: Query blocked by VERICTO-001 (severity critical). Suggested fix: DELETE FROM orders WHERE id = $1

Salida real: langchain-vericto 0.1.0 de PyPI con la CLI 2.4.0 en modo offline, en Python 3.13 y macOS el 16 de noviembre de 2026. El SDK además registra en stderr cada veredicto que no es ALLOWED, por ejemplo vericto: statement BLOCKED rule=VERICTO-001 severity=critical event_id=-.

En un agente

El toolkit SQL de LangChain sobre la base protegida, más la herramienta de revisión. Este ejemplo necesita un modelo con tool calling y su API key, así que no se ejecutó aquí; las demás salidas de esta página sí.

# pip install -U "langchain[anthropic]"   (or the provider of your model)
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain_community.agent_toolkits import SQLDatabaseToolkit
from langchain_vericto import VerictoSQLCheck, VerictoSQLDatabase

db = VerictoSQLDatabase.from_uri("sqlite:///shop.db", offline=True)
model = init_chat_model("claude-sonnet-4-6")

toolkit = SQLDatabaseToolkit(db=db, llm=model)
tools = [*toolkit.get_tools(), VerictoSQLCheck.from_database(db)]
agent = create_agent(
    model=model,
    tools=tools,
    system_prompt="Check every query with vericto_sql_check before running it, and never run a blocked query.",
)
agent.invoke({"messages": [{"role": "user", "content": "Delete all orders."}]})

JavaScript: @vericto/sdk/langchain

Para LangChain.js 1.x (@langchain/core y @langchain/classic >= 1 < 2) con un DataSource de TypeORM. Node.js 18 o posterior.

npm install @vericto/sdk @langchain/classic @langchain/core typeorm
npm install better-sqlite3   # or your database's TypeORM driver: pg, mysql2, mssql, oracledb

# Offline mode: the Vericto CLI, 2.1.0 or later (2.4.0 is current)
npm install -D @vericto/vericto-cli          # or on PATH, or VERICTO_CLI=/path/to/vericto
export VERICTO_OFFLINE=1                     # or new Vericto({ offline: true }) in code

# Online mode: your workspace
export VERICTO_API_KEY=vtro_...              # scope proxy:evaluate
export VERICTO_DATABASE_ID=<database-id>

VerictoSqlDatabase extiende el SqlDatabase de LangChain: su DataSource revisa cada query, las del agente, las filas de ejemplo que getTableInfo pone en el prompt y el SQL que genera SqlDatabaseChain. Un bloqueo vuelve al modelo como mensaje (onBlock: 'return', por defecto) o rechaza con VerictoBlockedError (onBlock: 'raise').

import { DataSource } from 'typeorm';
import { VerictoSqlDatabase } from '@vericto/sdk/langchain';

const appDataSource = new DataSource({ type: 'better-sqlite3', database: 'shop.db' });
await appDataSource.initialize();

// Reads VERICTO_* from the environment; the dialect comes from the TypeORM type.
const db = await VerictoSqlDatabase.fromDataSourceParams({ appDataSource });
console.log(await db.run('DELETE FROM orders'));
Vericto blocked this SQL query; it was NOT executed.
Rule: VERICTO-001 (severity critical)
Suggested fix: DELETE FROM orders WHERE id = $1
Use the suggested fix, or rewrite the query so that it complies with the rule, and try again.

Con createSqlAgent, VerictoSqlToolkit trae VerictoQuerySqlTool, que deja pasar los errores de Vericto a tu código en lugar de convertirlos en texto para el modelo. VerictoCheckSqlTool solo revisa.

import { createSqlAgent } from '@langchain/classic/agents/toolkits/sql';
import { VerictoCheckSqlTool, VerictoSqlToolkit } from '@vericto/sdk/langchain';

// llm: your chat model (ChatOpenAI, ChatAnthropic...). The run below used a scripted
// model that answers in the ReAct format, so it made no model call.
const agent = createSqlAgent(llm, new VerictoSqlToolkit(db, llm));
const result = await agent.invoke({ input: 'Delete order 2' });
console.log(result.intermediateSteps[0]?.observation.split('\n')[0]); // what the model read
console.log(result.output);
console.log(await appDataSource.query('SELECT id FROM orders')); // the unchecked DELETE never ran

// A check-only tool: asks Vericto, runs nothing.
const check = new VerictoCheckSqlTool({ db });
console.log(await check.invoke('DROP TABLE orders'));
Vericto blocked this SQL query; it was NOT executed.
deleted order 2
[ { id: 1 } ]
Vericto blocked this SQL query.
Rule: VERICTO-010 (severity critical)
Suggested fix: Use a versioned migration tool (Flyway, Prisma Migrate, Alembic, Rails migrations)
Use the suggested fix, or rewrite the query so that it complies with the rule, and try again.

Para otra cadena o tu propio código: guardDataSource envuelve un DataSource para que query() pase por Vericto, y describeVerdict convierte un veredicto en el texto que lee el modelo.

import { Vericto } from '@vericto/sdk';
import { guardDataSource, describeVerdict } from '@vericto/sdk/langchain';

const vericto = new Vericto();
const guarded = guardDataSource(appDataSource, vericto, 'sqlite'); // query() is checked first
try {
  await guarded.query('DELETE FROM orders');
} catch (e) {
  console.log(e.constructor.name + ':', e.message);
}
console.log(describeVerdict(await vericto.check('DROP TABLE orders', 'sqlite')));
VerictoBlockedError: Query blocked by VERICTO-001 (severity critical). Suggested fix: DELETE FROM orders WHERE id = $1
Vericto blocked this SQL query.
Rule: VERICTO-010 (severity critical)
Suggested fix: Use a versioned migration tool (Flyway, Prisma Migrate, Alembic, Rails migrations)
Use the suggested fix, or rewrite the query so that it complies with the rule, and try again.

Salida real: @vericto/sdk 0.6.0 de npm en modo offline (VERICTO_OFFLINE=1) con la CLI 2.4.0, @langchain/classic 1.0.61, @langchain/core 1.4.1 y typeorm 1.1.3, en Node.js 25.8.0 y macOS el 16 de noviembre de 2026. Online, las reglas, las severidades y las correcciones son las de tu workspace.

Para elegir el modo en el código en lugar del entorno, pasa tu propio cliente:

// Offline: the local engine of the Vericto CLI.
import { Vericto } from '@vericto/sdk';

const db = await VerictoSqlDatabase.fromDataSourceParams({
  appDataSource,
  vericto: new Vericto({ offline: true }), // or VERICTO_OFFLINE=1
});

Fallo cerrado

Cuando Vericto no puede responder (la CLI no está, la API no contesta, la key no sirve), el modo por defecto es cerrado: en Python fail_mode="closed" levanta vericto.VerictoUnavailable, en JavaScript se rechaza con VerictoUnavailableError, y no se ejecuta nada. Ese error nunca se convierte en un mensaje para el modelo. Con el modo abierto la query corre sin evaluar y la herramienta de revisión responde UNEVALUATED con el motivo. Ver Fallo cerrado y reintentos.

Límites

  • Offline revisa solo las 42 reglas estándar: sin reglas propias ni cambios de severidad, sin enmascaramiento, sin allowlists de agentes, sin políticas de negocio y sin audit trail. Todo eso necesita el modo online.
  • El punto de control es tu código. Solo se revisa el SQL que pasa por estos objetos. Otra conexión a la misma base no pasa por Vericto; para eso está el proxy TCP.
  • Un veredicto no sabe tu intención: comprueba que haya un WHERE y que no sea siempre verdadero, no qué filas toca.