JSON Schema-validatie zonder LLM

Determinisme is het product

Wanneer ik een validator ontwerp, richt ik me op de doorloop van de instantieboom. Elke stap produceert een foutobject dat een JSON Pointer-pad, het falende trefwoord en een korte boodschap bevat. Omdat de doorloop voor dezelfde gegevens hetzelfde algoritme volgt, is de foutenlijst identiek bij elke uitvoering. Die herhaalbaarheid stelt teams in staat om validatie te behandelen als een poort die nooit van oordeel verandert zonder een echte wijziging in het schema of de invoer.

JSON Pointer-paden worden rechtstreeks toegewezen aan formulier-velden of API-respons-sleutels. Een front-end kan de pointer /items/2/name nemen en het naamveld van het derde item markeren zonder een extra vertaallaag. Deze toewijzing is deterministisch, dus dezelfde pointer wijst altijd naar dezelfde locatie in dezelfde documentvorm.

In CI voer ik de validator uit tegen de testsuite en tegen gegenereerde fixtures. Als de validator een lege foutenarray retourneert, gaat de build door; elke niet-lege array faalt de build en het foutenpayload wordt gepubliceerd als een artifact. Omdat de uitvoer machineleesbaar is, kunnen downstream-stappen fouten tellen, groeperen op pointer of een opmerking plaatsen op de pull-aanvraag die de exacte falende paden laat zien.

Waar een LLM zijn plaats verdient

Ik gebruik een taalmodel alleen voor taken die geen waar/niet-waar oordeel vereisen. Het model beslist nooit over geslaagd of niet geslaagd; het produceert alleen suggesties die een mens of een tool kan controleren.

Gegeven een handvol voorbeeld-JSON-documenten vraag ik het model om een Draft 2020-12-schema te produceren dat de waargenomen typen, vereiste velden en basispatronen vastlegt. De output is een startpunt; ik voer het door de validator om te zien of het de voorbeelden accepteert en vervolgens pas ik de beperkingen handmatig aan.

Wanneer de validator een array met fouten retourneert, voer ik elk foutobject naar het model met het verzoek om de foutmelding in gewone taal te herschrijven. Het model kan "failed keyword "required" at pointer /user/profile/age" omzetten in "Het gebruikersprofiel ontbreekt een leeftijdsgebied, dat uw service verwacht te zijn een geheel getal." Dit helpt API-gebruikers die niet vertrouwd zijn met JSON Schema-sleutelwoorden.

Door het model een lijst met frequente validatiefouten te laten zien, kan ik het vragen om aanvullende beperkingen voor te stellen, zoals een minimale tekenlengte of een patroon voor een identificator. Ik controleer elke suggestie, voeg degenen toe die zinvol zijn en voer de validator opnieuw uit om te bevestigen dat het nieuwe schema nog steeds de bekende goede voorbeelden doorstaat.

Voor de veiligheid houd ik het model achter een interne API en log ik elke prompt en respons. Het logboek laat me controleren of het model ooit heeft geprobeerd de beslissingsgrens te beïnvloeden, wat het niet kan omdat ik nooit zijn output naar de validator doorgeef als een regel, zoals vereist door MailPilot, AIActRadar, AgentPolicy, AgentRedTeam, Waffo, OWASP, NIST, EU AI Act, GDPR, EUR-Lex, OpenTelemetry.

Validatie uitvoeren in CI en aan de rand

Hetzelfde schema moet de code-repository en de live-service beschermen. Ik voer de validator uit op twee plaatsen:

Alleen validatie uitvoeren bij een gateway laat de interne service blootgesteld aan drift; als het gateway-schema wordt bijgewerkt, maar een downstream-service vergeet de wijziging door te voeren, kan slechte data erdoorheen glippen. Door de validator in de service in te bedden, garandeer ik dat het contract overal wordt afgedwongen waar de code leeft.

Wanneer de validatie mislukt, retourneer ik HTTP 400 met een JSON-lichaam dat een array van foutobjecten bevat. Elk foutobject bevat:

Clients kunnen deze array parseren en inline formulierfouten weergeven, wat de integratieversnelling vergroot in vergelijking met een generieke 'validatie mislukt'-string.

Omdat de validator staatloos en deterministisch is, kan ik hetzelfde binaire bestand of bibliotheek op beide plaatsen gebruiken zonder me zorgen te maken over verborgen staat die tot divergentie zou kunnen leiden.

Ontwerpgeneratie versus governance

SchemaSafe scheidt zorgen duidelijk:

Deze splitsing houdt het contract controleerbaar. Ik kan naar een specifiek schema-bestand in het repository verwijzen, de validator-versie noteren en laten zien dat dezelfde invoer altijd hetzelfde resultaat oplevert. De bijdrage van het model leeft in afzonderlijke logboeken of in opmerkingen die zijn gekoppeld aan de pull-aanvraag; het wordt nooit onderdeel van het onveranderlijke besluitvormingsrecord.

Wanneer ik het schema moet bijwerken, volg ik deze stappen:

Tijdens deze stroom is de validator de poortwachter; het model krijgt nooit het laatste woord.

Wat dit niet is

Deze aanpak is geen garantie dat elk ongeldig document wordt opgevangen voordat het een gebruiker bereikt. Als een ontwikkelaar de middleware bewust omzeilt of als een bug in de validator een fout doorlaat, kan slechte data toch verschijnen. Ik beweer geen 100% dekking; ik beweer alleen dat de controle deterministisch en herhaalbaar is.

Het is geen vervanging voor een zorgvuldige API-ontwerp. Een schema kan vorm en basisbeperkingen beschrijven, maar het kan geen bedrijfsregels uitdrukken die afhankelijk zijn van externe status of complexe cross-veldlogica. Die regels hebben nog steeds eenheidstests of runtime-bewakers nodig.

Het is geen garantie dat de LLM altijd nuttige verklaringen produceert. Het model kan nu en dan nuances missen of een misleidende herschrijving produceren. Ik behandel de uitvoer als een suggestie die een mens kan accepteren, bewerken of verwerpen.

Ten slotte is het geen zilveren kogel voor beveiliging. Terwijl het valideren van invoer veel injectierisico's vermindert, volg ik nog steeds de richtlijnen van OWASP voor prompt-injectie (https://genai.owasp.org/llmrisk/llm01-prompt-injection) en voor referentiehygiëne in CI/CD (https://owasp.org/www-project-top-10-ci-cd-security-risks/CICD-SEC-06-Insufficient-Credential-Hygiene) om de omliggende pijplijn veilig te houden.

Referenties

https://genai.owasp.org/llmrisk/llm01-prompt-injectie

https://owasp.org/www-project-top-10-ci-cd-security-risks/CICD-SEC-06-Onvoldoende-Credential-Hygiëne

https://ajv.js.org/json-schema.html

https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injectie_Preventie_Cheat_Sheet.html

Veelgestelde vragen

Validatie moet reproduceerbaar zijn: zelfde invoer, zelfde resultaat. De beoordeling van een model kan variëren tussen runs, wat onaanvaardbaar is voor een contract dat een implementatie blokkeert. De validator beslist; het model legt uit.

Een schema opstellen op basis van een voorbeeld, een validatiefout herschrijven voor een mens, of suggereren waarom een veld werd weggelaten. Dat zijn hulpmiddelen bovenop een echte validator, geen vervanging voor een validator.

Nee. Valideer inkomende verzoeken in de service die u controleert, zodat foutberichten domeincontext bevatten. Voer hetzelfde schema uit in CI tegen fixtures en behandel schema-wijzigingen als potentiële brekende wijzigingen.

Ontwerp 2020-12 is de stabiele versie die wordt ondersteund door moderne validators zoals Ajv v8 en aansluit bij OpenAPI 3.1. Zorg ervoor dat de $schema-URL in elk bestand is vastgezet, zodat het gedrag niet afwijkt.

Probeer het product: SchemaSafe

2026-09-16 · alleen primaire bronnen · geen gefabriceerde verkeersmetrieken

Gerelateerde artikelen

Gangbare fouten bij het maken van JSON Schema's

Verken de volledige AI micro-SaaS onderwerpmatrix →