Servers Playground How we check Add a server Log in

Code civil (France)

Working · 236 ms

io.arxo/code-civilv0.1.10 Domain verified

French Civil Code (LEGI) as executable rules: facts and a legal date in, answers with grounds out

Legal & Government

Source Website Registry entry

Maintain this server? Claim it

Try it

Call this server's tools from your browser. Nothing to install.

https://mcp.arxo.io/mcp/code-civil

Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.

Tool list from our last check. Connect live to refresh it.

law_answer_capabilities Read-only

Une matrice lisible par machine des producteurs Lens réellement installés, des contrôles replay/projection, des profils, des limites et des tests de contrat qui les confirment. declared_only désigne un schéma sans témoin exécutable.

This tool takes no arguments.

Code civil (France) MCP server | mcptry

Tools (20)

law_answer_capabilities

read-only

No arguments.

Input schema (JSON)

{
  "type": "object",
  "additionalProperties": false
}

law_argue

Quelle est la solidité d'une conclusion : la carte du litige selon le profil d'argumentation §274 (DECISION-0039). La réponse tombe en quatre classes : SKEPTICALLY_ACCEPTED — la conclusion est invulnérable (elle survit dans l'extension grounded) ; CREDULOUSLY_ACCEPTED — seulement défendable (il existe une position pour et une contre) ; REJECTED — elle ne survit nulle part ; NO_ARGUMENT — il n'y a aucun argument. Elle construit TOUS les arguments à partir des faits et des règles de l'acte (y compris les chaînes qui n'ont pas tiré dans l'inférence ordinaire), les attaques rebut/undermine/undercut et les défaites par priorité. Les noms de prédicats viennent de law_packages. Sur les grands actes, un refus par plafond est possible — restreignez les faits ou augmentez limits.maxArguments.

read-only

Argument	Type	Description
args	array	les arguments du prédicat
facts	array	faits de l'affaire : [{predicate, args, negated?, provenance?}]. provenance est le même objet que pour law_ask : origin, document, citation, extractor. confidence est lu par l'EvidencePolicy du paquet, pas par le moteur
limits	object	les plafonds du profil §274 : maxArguments (64), maxExtensions (8), maxUndecided (16)
package	string	restreindre la question à un paquet de droit
legalTime	string	la date du droit (YYYY-MM-DD)
predicate*	string	la conclusion dont on mesure la solidité

Input schema (JSON)

{
  "type": "object",
  "required": [
    "predicate"
  ],
  "properties": {
    "args": {
      "type": "array",
      "description": "les arguments du prédicat"
    },
    "facts": {
      "type": "array",
      "description": "faits de l'affaire : [{predicate, args, negated?, provenance?}]. provenance est le même objet que pour law_ask : origin, document, citation, extractor. confidence est lu par l'EvidencePolicy du paquet, pas par le moteur"
    },
    "limits": {
      "type": "object",
      "description": "les plafonds du profil §274 : maxArguments (64), maxExtensions (8), maxUndecided (16)"
    },
    "package": {
      "type": "string",
      "description": "restreindre la question à un paquet de droit"
    },
    "legalTime": {
      "type": "string",
      "description": "la date du droit (YYYY-MM-DD)"
    },
    "predicate": {
      "type": "string",
      "description": "la conclusion dont on mesure la solidité"
    }
  },
  "additionalProperties": false
}

law_ask

Poser une question au droit formalisé. Quand la réponse est « non établi », elle porte whyNot — le rapport why_not §185 du moteur : les règles candidates et l'état de chaque conjonct (satisfait / non satisfait / indéterminé) ; les faits manquants y sont visibles et n'ont pas à être inventés. AVANT LE PREMIER appel, obtenez les noms de prédicats par law_search (une question dans vos propres mots → adresses) ou law_packages (les signatures d'un acte connu) — un nom inventé sera rejeté. Si l'outil a renvoyé une erreur ou « non établi », C'EST LA RÉPONSE : transmettez-la à l'utilisateur et ne la substituez pas par des connaissances générales sur le droit d'un autre pays. Mais « je n'ai trouvé aucun acte convenable » N'EST PAS une réponse tant que law_search n'a pas été interrogé : le silence du catalogue est une propriété de la recherche par titre, non une conclusion sur le corpus. kind='truth' — si un fait est établi (la réponse suit le §62 : établi / réfuté / contradiction / non établi) ; kind='collect' — énumérer les enregistrements ; kind='deadline' — calculer un délai sur le calendrier officiel ; kind='positions' — quelles OBLIGATIONS sont nées des faits et quels sont leurs statuts (active / fulfilled / violated, §134–§138) ; kind='why_not' — le rapport why_not §185 sur le même but, quel que soit le statut de la réponse. La réponse porte les règles appliquées, les avertissements et la provenance avec empreintes ; truth/collect portent aussi un bloc signature (types des paramètres, clôture des types, constantes ; DECISION-0139) pour la présentation. Le serveur n'invente pas : là où une norme n'est pas formalisée, la réponse est « non établi » ou une erreur.

read-only

Argument	Type	Description
args	array	les arguments du prédicat dans l'ordre de sa signature ; avec kind='collect', exactement l'un d'eux est la variable de sélection ?name (par exemple ['urn:x:water', 'urn:x:mix', '?value']), les autres sont des valeurs. Les valeurs suivent le type du paramètre : une entité — 'urn:…' ou un nom court ; Date — 'YYYY-MM-DD' ; Money — '<nombre> <devise>' ('43250 KZT') ; Quantity — '<nombre> <unité>' avec l'unité exactement telle que le paquet l'écrit ('25 calendar_year', '30 meter' ; law_packages montre les unités des constantes, les unités ne sont jamais converties — §49) ; une constante du paquet — son nom

law_capture_answer

Exécuter un producteur enregistré et obtenir producerControl/0.2 pour une préparation ultérieure vérifiable d'une Lens. Le producteur n'est choisi que dans le registre livré.

read-only

Argument	Type	Description
request*	object
producer*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "producer",
    "request"
  ],
  "properties": {
    "request": {
      "type": "object"
    },
    "producer": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

law_case_ask

L'opération ask §168.4 (DECISION-0165, DECISION-0399) : exécuter une affaire enregistrée d'un paquet-affaire sur ses dépendances épinglées et renvoyer le document d'évaluation canonique avec une preuve et un manifeste. La question est du JSON selon query.schema.json (query), une chaîne evaluate (evaluate + queryId), un queryId enregistré sans query, ou card + args. Un refus de préparation est une erreur avec un code LDC-*, jamais une réponse vide.

read-only

Argument	Type	Description
args	object	les paramètres de la carte : nom → expression textuelle du langage
card	string	l'id d'une carte d'un catalogue installé DECISION-0190
case	string	le nom de la déclaration d'affaire dans [[cases]] ; facultatif s'il n'y a qu'une affaire
query	object	la question en JSON selon query.schema.json ; queryId est un URN dans l'espace de noms du paquet, ou un nom court donné dans queryId
package*	string	le chemin du paquet-affaire (le répertoire qui contient law.toml) depuis la racine du dépôt
queryId	string	sans query/evaluate — le choix d'un queries/*.json enregistré par nom court ou URN complet ; avec evaluate — l'id de la question exécutée
evaluate

law_editions

L'axe des éditions (O-2) : ce qui a changé dans un acte entre deux dates du droit — l'état des éditions, le datage des normes et le diff sémantique §215 entre les projections D1. Le verdict NOT_DATED signifie « il n'y avait rien pour le dater », non « rien n'a changé ». L'issue d'une question particulière à une date vient de law_ask avec legalTime.

read-only

Argument	Type	Description
dateA*	string	la date du droit « avant » (YYYY-MM-DD)
dateB*	string	la date du droit « après » (YYYY-MM-DD)
package*	string	l'acte du corpus

Input schema (JSON)

{
  "type": "object",
  "required": [
    "package",
    "dateA",
    "dateB"
  ],
  "properties": {
    "dateA": {
      "type": "string",
      "description": "la date du droit « avant » (YYYY-MM-DD)"
    },
    "dateB": {
      "type": "string",
      "description": "la date du droit « après » (YYYY-MM-DD)"
    },
    "package": {
      "type": "string",
      "description": "l'acte du corpus"
    }
  },
  "additionalProperties": false
}

law_explain

Déplier la preuve d'une réponse law_ask en une chaîne « règle ← prémisses → conclusion ». L'entrée compacte : question (les arguments law_ask d'origine, truth/collect), resultHash et codeHash issus de la provenance de la réponse. Le serveur répète le calcul et compare les empreintes ; si quelque chose a changé, il refuse explicitement. Autrement, passer l'évaluation de law_ask(proof=true). answerResource=fullAnswer.uri explique un instantané compact stocké sans recalcul et sans que le client charge des pages ; par défaut seulement la chaîne proofRef. nodeId sélectionne un nœud et toutes ses prémisses (jusqu'à 24 Ko, sinon un refus explicite). proofHash se rapporte au graphe entier ; scope marque la partie sélectionnée.

read-only

Argument	Type	Description
nodeId	string
codeHash	string
question	object	les arguments law_ask d'origine
evaluation	object	le document d'évaluation issu de law_ask
resultHash	string
answerResource	string	le fullAnswer.uri d'une réponse stockée prise avec proof=true

Input schema (JSON)

{
  "type": "object",
  "oneOf": [
    {
      "not": {
        "anyOf": [
          {
            "required": [
              "question"
            ]
          },
          {
            "required": [
              "answerResource"
            ]
          }
        ]
      },
      "required": [
        "evaluation"
      ]
    },
    {
      "not": {
        "anyOf": [
          {
            "required": [
              "evaluation"
            ]
          },
          {
            "required": [
              "answerResource"
            ]
          }
        ]
      },
      "required": [
        "question",
        "resultHash",
        "codeHash"
      ]
    },
    {
      "not": {
        "anyOf": [
          {
            "required": [
              "evaluation"
            ]
          },
          {
            "required": [
              "question"
            ]
          },
          {
            "required": [
              "resultHash"
            ]
          },
          {
            "required": [
              "codeHash"
            ]
          }
        ]
      },
      "required": [
        "answerResource"
      ]
    }
  ],
  "properties": {
    "nodeId": {
      "type": "string",
      "minLength": 1
    },
    "codeHash": {
      "type": "string"
    },
    "question": {
      "type": "object",
      "description": "les arguments law_ask d'origine"
    },
    "evaluation": {
      "type": "object",
      "description": "le document d'évaluation issu de law_ask"
    },
    "resultHash": {
      "type": "string"
    },
    "answerResource": {
      "type": "string",
      "description": "le fullAnswer.uri d'une réponse stockée prise avec proof=true"
    }
  },
  "additionalProperties": false
}

law_packages

Le catalogue du droit formalisé : actes, prédicats avec signatures, frontières de couverture. C'est d'ici que viennent les NOMS des prédicats — ils ne doivent jamais être inventés. Mais ne commencez PAS par le catalogue pour trouver le bon acte : l'aperçu est vaste, et le titre d'un acte coïncide rarement avec les mots d'une question (« Newton's laws of motion » ne contient pas le mot « physics »). Une question dans vos propres mots va d'abord à law_search, qui renvoie des adresses ; le catalogue sert à la signature exacte de ce que vous avez trouvé. Sans arguments — l'aperçu : une ligne par acte (clé, titre, ordre juridique, compteurs de règles, faits, signatures, normes, constantes) ; un acte entier — package="kz-gpk" ; une recherche sur les signatures, étiquettes et constantes de tous les actes — query="substring". Les trois modes sont PAGINÉS : limit et offset, le reste nommé dans le texte (`showing a–b of N; k more`) et dans structuredContent (total, truncated, next — un appel de continuation tout prêt). L'unité d'une page est nommée par pageUnit : l'aperçu et query paginent les ACTES (20 et 20 par défaut), package=… pagine les SIGNATURES d'un acte (20 par défaut, 300 au plus) — les grands codes en portent des milliers. package=… avec catalog=… pagine une liste séparée de l'acte : "questions" — le CATALOGUE DES QUESTIONS (DECISION-0190) : quelles demandes sont prévues (une question en mots, une forme, un prédicat ou des normes) et à quoi l'acte NE répond PAS, avec le type de motif ; une fiche est un modèle de demande, non une réponse, et tous les actes n'en ont pas ; "norms" — les NORMES de l'acte (modalité §107 et étiquette), "constants" — les CONSTANTES (noms des déclarations). "task-guides" — les PARCOURS DE TÂCHE (DECISION-0414) : l'ordre d'application d'un canon à un document — quoi recueillir, quelles cartes interroger et comment lire les réponses ; un parcours ne répond à rien. catalog="task-guides" est admis aussi sans package — tous les parcours du profil ; guide=… — le détail d'un parcours ; le parcours lui-même — MCP Prompts sous le même nom. Le détail d'un acte imprime un aperçu de ces listes et nomme le compte et l'appel tout prêt du mode.

read-only

Argument	Type	Description

law_passport

Passeport d'une publication exacte : objet, interface, frontières, contrôles et performance. La section reports conserve l'historique des mesures, y compris les échecs. Les enregistrements sont paginés par JSON Pointer ; next poursuit la réponse.

read-only

Argument	Type	Description
name*	string
limit	integer
offset	integer
version*	string
sections	array
contentHash*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "name",
    "version",
    "contentHash"
  ],
  "properties": {
    "name": {
      "type": "string"
    },
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1
    },
    "offset": {
      "type": "integer",
      "minimum": 0
    },
    "version": {
      "type": "string"
    },
    "sections": {
      "type": "array",
      "items": {
        "enum": [
          "description",
          "interface",
          "semantics",
          "sources",
          "composition",
          "dependencies",
          "checks",
          "evidence",
          "reports"
        ]
      },
      "minItems": 1,
      "uniqueItems": true
    },
    "contentHash": {
      "type": "string",
      "pattern": "^sha256:[0-9a-f]{64}$"
    }
  },
  "additionalProperties": false
}

law_prepare_answer

À la demande explicite de l'utilisateur, répéter entre 1 et 12 appels law_ask ou law_process_run antérieurs (le cours d'une affaire, DECISION-0160), comparer strictement leurs replayControl, et préparer un document figé non public pour 24 heures. Le client ne fournit jamais la réponse machine : le serveur ne l'obtient qu'en exécutant à nouveau. Un écart dans une entrée, dans le droit, dans une ressource, dans le code du serveur, dans la bibliothèque du moteur ou dans le résultat rejette le document entier.

Argument	Type	Description
language	any
question*	string
assistant	object
calculations	array
producerRuns	array	Exécutions de producteurs enregistrés avec control/0.2 ; mutuellement exclusives avec calculations.
documentVersion	any	Version du document immuable ; 0.1 est conservée pour la compatibilité transitoire, 0.2 inclut tous les résultats natifs et le lecteur commun.

Input schema (JSON)

{
  "type": "object",
  "oneOf": [
    {
      "not": {
        "required": [
          "producerRuns"
        ]
      },
      "required": [
        "calculations"
      ]
    },
    {
      "not": {
        "required": [
          "calculations"
        ]
      },
      "required": [
        "producerRuns"
      ]
    }
  ],
  "required": [
    "question"
  ],
  "properties": {
    "language": {
      "enum": [
        "ru",
        "en"
      ]
    },
    "question": {
      "type": "string",
      "maxLength": 8000
    },
    "assistant": {
      "type": "object",
      "properties": {
        "summary": {
          "type": "string",
          "maxLength": 12000
        },
        "explanations": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "text",
              "calculationRefs"
            ],
            "properties": {
              "text": {
                "type": "string",
                "maxLength": 12000
              },
              "calculationRefs": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            },
            "additionalProperties": false
          },
          "maxItems": 48
        }
      },
      "additionalProperties": false
    },
    "calculations": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "request",
          "replayControl"
        ],
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 80
          },
          "label": {
            "type": "string",
            "maxLength": 300
          },
          "request": {
            "type": "object"
          },
          "replayControl": {
            "type": "object"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 12,
      "minItems": 1
    },
    "producerRuns": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "producer",
          "request",
          "control"
        ],
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 80
          },
          "text": {
            "type": "string"
          },
          "label": {
            "type": "string",
            "maxLength": 300
          },
          "control": {
            "type": "object"
          },
          "request": {
            "type": "object"
          },
          "producer": {
            "type": "string"
          },
          "executionContext": {
            "type": "object"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 12,
      "minItems": 1,
      "description": "Exécutions de producteurs enregistrés avec control/0.2 ; mutuellement exclusives avec calculations."
    },
    "documentVersion": {
      "enum": [
        "law.answers.document/0.1",
        "law.answers.document/0.2"
      ],
      "description": "Version du document immuable ; 0.1 est conservée pour la compatibilité transitoire, 0.2 inclut tous les résultats natifs et le lecteur commun."
    }
  },
  "additionalProperties": false
}

law_process

De quelles étapes se compose la procédure établie par un acte, et si elle porte un défaut structurel (O-5, DECISION-0052). Les étapes, les transitions et la condition de chaque transition sont reconstruites à partir de la formalisation, non racontées : ce qui mène d'où vers où, et sous quelle condition. Le contrôle du graphe : étapes inaccessibles, transitions mortes, une transition qui n'entre dans aucune étape. Sans package — la liste des actes dont la procédure est formalisée. Une étape sans sortie est nommée mais N'EST PAS comptée comme défaut : si elle est terminale par dessein, la formalisation ne le montre pas.

read-only

Argument	Type	Description
package	string	l'acte ; sans lui — la liste des actes qui portent des procédures

Input schema (JSON)

{
  "type": "object",
  "required": [],
  "properties": {
    "package": {
      "type": "string",
      "description": "l'acte ; sans lui — la liste des actes qui portent des procédures"
    }
  },
  "additionalProperties": false
}

law_process_run

Comment une affaire particulière se déroulera, étape par étape (O-5, DECISION-0052) : un journal {date, attempt?, facts?} est exécuté cadre par cadre, et le droit de chaque cadre est le droit de SA date. La réponse dit : quelles étapes ont été atteintes ; quelle transition tentée n'a produit AUCUN effet juridique (§164 — « l'acte a été accompli mais n'a pas eu lieu ») ; quelles obligations sont violées et quels délais courent ; ce qui est disponible ensuite et CE QUI MANQUE EXACTEMENT pour le reste. Les noms des transitions viennent de law_process. Étapes atteintes signifie « a-t-on déjà entré », non « où l'on est maintenant » : le noyau 0.1 ne calcule pas les points de l'état courant.

read-only

Argument	Type	Description
steps*	array	le journal de l'affaire : [{date, attempt?, time?, decisionTime?, knowledgeTime?, facts: [{predicate, args}]}] ; sur une transition tentée, `time` est l'instant de l'événement (ISO 8601 avec un décalage), et par lui le porteur prend sa place dans l'historique §161.1 (DECISION-0156) ; les axes de décision et de connaissance d'un cadre viennent de l'entrée, sinon de l'affaire, sinon de minuit UTC de la date ; chaque cadre nomme les axes qu'il a utilisés et d'où ils viennent
package*	string	l'acte
instance*	string	ce qui traverse la procédure : le numéro du lot, de la demande, de l'affaire
legalTime	string	la date de base (YYYY-MM-DD) ; la date d'un cadre est fixée par l'étape elle-même

law_publish_answer

Publier un document préparé. La répétition avec le même preparationId renvoie de façon idempotente la même URL et le même secret de révocation distinct.

Argument	Type	Description
preparationId*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "preparationId"
  ],
  "properties": {
    "preparationId": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

law_query

Une requête LawQL déterministe sur le CLIR d'une formalisation : une question sur le modèle de l'acte lui-même, pas sur une affaire. Relations : nodes(id,kind,package,package_name,path), edges(from,to,role), anchors(node,anchor,act,locator,path), labels(node,lang,text,status), fields(node,field,value,value_kind), rules(id,strength,head_predicate,head_polarity,head_variables,body_variables,body_predicates), norms(id,modality,goal_kind,condition_predicates), positions(norm,kind,bearer_type), windows(norm,kind,deadline), imports(package,imported,semantic_hash), links(from,to,kind: imports|alias|subtype|produces|reads|anchored), literals(node,context,predicate,polarity), variables(node,context,name,type), interpretations(id,predicate,role). Fonctions : anchor, labels, short, contains, overlaps, starts_with, ends_with, position, derivation ; exists/not exists sur une variable liée ; égalité et appartenance seulement, sans arithmétique ni comparaisons d'ordre. Périmètre : corpus par package.name (par exemple kz.corpus.labour_code, pas un nom de fichier) ou un glob ; sans corpus, toute la tranche du profil ; un périmètre hors profil est vide (CORPUS_EMPTY). Exemples : `from r in rules where r.head_predicate == "urn:…#eligible" select r.id as producer, r.strength as strength, anchor(r.id) as anchors` — qui produit ; `from l in literals where l.predicate == "urn:…#eligible" select l.node as reader, l.context as context` — qui lit ; `query eligible over "pkg" { for x: Person; where applicant(x); select eligible(x); }` — inférence par le noyau. C'est une orchestration au-dessus du CLIR et du noyau ; aucune sémantique juridique nouvelle n'est implémentée ici. Au lieu du texte, une question du catalogue avec arguments : producers, readers, anchors-of, imports-of, links-of, type-step (les paramètres predicate/node/type sont des URN, pkg un package.name ou un glob). La réponse structurelle est une queryPage : resultHash du queryResult complet, snapshot (hachage de la liste des paquets du périmètre), rowCount, rows selon rowLimit (20, au plus 5000) et rowOffset, next avec le snapshot pour continuer ; full: true renvoie le queryResult complet quand le périmètre est un seul paquet. Chaque ligne porte sa provenance (nœuds CLIR) ; une réponse vide porte l'entonnoir explain (emptyAt nomme la clause) ; les erreurs portent des codes LDC-Qxxxx avec des indices ; un produit de sources trop large est refusé avant exécution (QUERY_TOO_BROAD), une continuation sur un autre instantané — SNAPSHOT_CHANGED.

read-only

law_report

Un SIGNALEMENT d'écart entre la formalisation et la source : la réponse contredit le texte épinglé, une norme de la source n'est pas exprimée par une règle, une étiquette §218 diverge du texte, une adresse est introuvable. Un signalement est une hypothèse pour le triage par un formaliseur : il ne change PAS le droit, n'atteint jamais les réponses des autres outils, et « non dérivé » ne devient pas « dérivé » à cause de lui. Une adresse est requise et vérifiée contre le catalogue : package, fragment (un StableId issu de law_sources) et/ou predicate ; callId est le X-Law-Call-Id de la réponse que vous contestez. L'entrée va dans le journal du serveur.

read-only

Argument	Type	Description
callId	string	le X-Law-Call-Id de la réponse que vous contestez
package*	string	l'acte du corpus
category*	any	le type d'écart : norme non exprimée / issue contre le texte / étiquette contre le texte / adresse introuvable / texte contre l'officiel / autre
expected*	string	ce que dit la source (avec l'article)
fragment	string	le StableId du fragment source
observed*	string	ce que le système a répondu

law_revoke_answer

Révoquer un document publié au moyen de son secret distinct. L'identifiant public à lui seul ne donne aucun contrôle ; la révocation ferme la page HTML, l'API et le téléchargement.

destructive

Argument	Type	Description
publicId*	string
revokeSecret*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "publicId",
    "revokeSecret"
  ],
  "properties": {
    "publicId": {
      "type": "string"
    },
    "revokeSecret": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

law_rules

Les règles du droit formalisé mises en mots : comment exactement un prédicat est dérivé (prémisses, articles sources). Appelez ceci AVANT de fournir des faits à law_ask — les règles disent quels faits sont nécessaires au lieu de les laisser à inventer. Pour les grands actes, package=… renvoie une table des matières ; le texte complet vient de predicate=…. La liste par paquet est paginée : limit (20 par défaut, 500 au plus) et offset ; le reste est nommé dans le texte (`showing a–b of N; k more`) et dans structuredContent (total, truncated, next — un appel de continuation tout prêt).

read-only

Argument	Type	Description
lang	any	la langue dans laquelle les règles sont mises (DECISION-0032 ; la langue du profil par défaut ; les autres sont des paquets brouillons, avec des superpositions d'étiquettes §218)
limit	integer	package : combien de règles par page (20 ; le budget peut le baisser)
offset	integer	package : à partir de quelle règle (0)
package	string	toutes les règles de l'acte
predicate	string	les règles qui dérivent ce prédicat

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "lang": {
      "enum": [
        "ru",
        "kk",
        "en",
        "ky",
        "uz",
        "ar",
        "la",
        "zh",
        "de",
        "fr",
        "tr",
        "es",
        "fa",
        "ja"
      ],
      "description": "la langue dans laquelle les règles sont mises (DECISION-0032 ; la langue du profil par défaut ; les autres sont des paquets brouillons, avec des superpositions d'étiquettes §218)"
    },
    "limit": {
      "type": "integer",
      "maximum": 500,
      "minimum": 1,
      "description": "package : combien de règles par page (20 ; le budget peut le baisser)"
    },
    "offset": {
      "type": "integer",
      "minimum": 0,
      "description": "package : à partir de quelle règle (0)"
    },
    "package": {
      "type": "string",
      "description": "toutes les règles de l'acte"
    },
    "predicate": {
      "type": "string",
      "description": "les règles qui dérivent ce prédicat"
    }
  },
  "additionalProperties": false
}

law_screen

Construire une condition nécessaire — un surensemble — pour la présélection de lignes d'une source externe (DECISION-0120). Ce n'est PAS une réponse juridique et PAS du SQL : le résultat est un arbre typé et un manifeste des extensions jusqu'à TRUE. Chaque ligne qui passe doit ensuite être calculée en entier par le moteur, avec un graphe de preuve, sur le même instantané des données. Le binding est passé comme objet épinglable ; sourceSchemaContentHash est l'empreinte réelle du schéma source et est comparée bruyamment avec l'épingle. Les faits d'affaire qui portent une provenance (origin, document, citation, extractor) sont fournis à law_ask, pas ici. Le nombre confidence est lu par l'EvidencePolicy du paquet, pas par cet outil et pas par le moteur.

read-only

Argument	Type	Description
goal*	string	un StableId ou un nom court unique de l'objectif
binding*	object	un artefact law.screen.binding/0.1
package*	string	la clé de paquet depuis law_packages
legalTime	string	la date du droit YYYY-MM-DD ; sans elle, toutes les fenêtres de toutes les règles sont prises en compte
sourceSchemaContentHash*	string	le sha256 réel du schéma source

Input schema (JSON)

law_search

Une RECHERCHE sémantique sur le droit formalisé : une question ou une notion dans vos propres mots → des candidats avec adresses — prédicats avec signatures, règles, fragments d'articles. C'est la couche de DÉCOUVERTE, non de la réponse : le résultat dit QUOI demander ensuite (law_ask par signature, law_rules, law_sources) et n'établit ni un fait ni une norme. Le classement est un embedder lexical déterministe (DECISION-0040), et la similarité de texte n'est pas l'applicabilité d'une norme. Si vous connaissez le nom exact, allez directement à law_packages/law_ask ; un résultat vide ne signifie PAS que la norme n'existe pas.

read-only

Argument	Type	Description
kinds	array	restreindre les types de candidat
limit	integer	combien de candidats (8, 25 au plus)
query*	string	une question ou une notion dans vos propres mots
package	string	chercher uniquement dans cet acte

Input schema (JSON)

{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "kinds": {
      "type": "array",
      "items": {
        "enum": [
          "package",
          "predicate",
          "rule",
          "norm",
          "constraint",
          "fragment"
        ]
      },
      "description": "restreindre les types de candidat"
    },
    "limit": {
      "type": "integer",
      "description": "combien de candidats (8, 25 au plus)"
    },
    "query": {
      "type": "string",
      "description": "une question ou une notion dans vos propres mots"
    },
    "package": {
      "type": "string",
      "description": "chercher uniquement dans cet acte"
    }
  },
  "additionalProperties": false
}

law_sources

Sources : par défaut de courts extraits (view=summary), 5 textes par page, avec l'adresse du texte complet dans fragments[].full. package ou fragment est requis (un StableId issu de law_search/law_rules). view=full renvoie des parties exactes du texte : textRange fixe une plage de caractères Unicode, fragments[].next est la continuation avec un contentHash. L'empreinte se rapporte à la source ENTIÈRE, non à l'extrait ni à la partie. textOffset/textLimit exigent fragment ; une continuation exige contentHash. Les listes sont paginées avec offset/limit ; le budget de réponse peut réduire une page.

read-only

Argument	Type	Description
view	any
limit	integer	combien de textes : summary 5, full 1 (le budget peut le baisser)
offset	integer	à partir de quel fragment (0)
status	string	le statut de la variante, tel qu'indiqué sur la fiche source
package	string	la clé de paquet — tous les fragments de cet acte
fragment	string	le StableId d'un fragment
language	string	la langue de la variante, telle qu'indiquée sur la fiche source

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "args": {
      "type": "array",
      "description": "les arguments du prédicat dans l'ordre de sa signature ; avec kind='collect', exactement l'un d'eux est la variable de sélection ?name (par exemple ['urn:x:water', 'urn:x:mix', '?value']), les autres sont des valeurs. Les valeurs suivent le type du paramètre : une entité — 'urn:…' ou un nom court ; Date — 'YYYY-MM-DD' ; Money — '<nombre> <devise>' ('43250 KZT') ; Quantity — '<nombre> <unité>' avec l'unité exactement telle que le paquet l'écrit ('25 calendar_year', '30 meter' ; law_packages montre les unités des constantes, les unités ne sont jamais converties — §49) ; une constante du paquet — son nom"
    },
    "calc": {
      "description": "kind='calc' : un arbre {op,left,right}, op ∈ add|sub|mul|div|le|lt|ge|gt|eq|ne (les synonymes divide/multiply/plus/minus et les signes sont acceptés) ; les feuilles sont 5 | '3932 KZT' | '2 mrp' | {lookup: 'mrp', args: [2026]} — une valeur légale du corpus ; les agrégats §59 sont {aggregate: 'sum', element: '?v', over: [{predicate, args with '?variables'}]} sur les faits donnés dans facts"
    },
    "days": {
      "type": "integer",
      "description": "deadline : la durée de la période"
    },
    "kind": {
      "enum": [
        "truth",
        "collect",
        "deadline",
        "calc",
        "positions",
        "why_not"
      ],
      "description": "le type de question (truth par défaut)"
    },
    "unit": {
      "enum": [
        "calendar_day",
        "business_day"
      ]
    },
    "after": {
      "type": "string",
      "description": "deadline : la date de l'événement"
    },
    "facts": {
      "type": "array",
      "description": "faits de l'affaire : [{predicate, args, negated?, package?, provenance?, judgment?}]. package résout un nom court ambigu. provenance est {origin?, evidence?: StableId, span?: {page?, quote?, offset?}, extractor?: {name, version?, confidence?}, observedAt?, recordedAt?}. origin vaut case_input par défaut (section 73 ; l'extraction n'ajoute pas de valeur d'origin) : l'extracteur est abaissé en arête was_generated_by, le document en was_derived_from. confidence est une chaîne décimale ; le seuil est lu par l'EvidencePolicy du paquet (field confidence), pas par le moteur. Un fait avec extracteur et sans evidence est accepté comme case_input et produit l'avertissement FACT_WITHOUT_EVIDENCE. Un appel sans provenance ne change pas. args suit la même notation que les args de la question"
    },
    "proof": {
      "type": "boolean",
      "description": "renvoyer dans la réponse le champ evaluation avec le graphe de preuve — une entrée toute prête pour law_explain (kind truth|collect ; par défaut un résumé sans le graphe)"
    },
    "cutoff": {
      "type": "string",
      "description": "deadline : l'heure de clôture des opérations"
    },
    "focused": {
      "type": "boolean",
      "description": "kind='truth' : poser la question en focused_truth (§181.3) — la même réponse que le truth complet, mais la preuve et les avertissements ne couvrent que le cône de la question ; la réponse porte evaluationKind et les empreintes de la coupe (focus) ; dans focus, le cône est réduit à coneHash et au nombre de prédicats, le manifeste complet du cône vient dans evaluation.focusManifest avec proof=true. Une coupe n'est pas un document d'audit : law_prepare_answer ne l'accepte pas pour publication"
    },
    "package": {
      "type": "string",
      "description": "restreindre la question à un paquet de droit"
    },
    "version": {
      "type": "string",
      "description": "la version exacte du paquet figée par le client (open('name@version')) ; si elle diffère de la composition du profil, l'hôte refuse au lieu de répondre avec une autre version"
    },
    "evidence": {
      "type": "array",
      "description": "documents de l'affaire, section 74, nœuds evidence_item. Un document est référencé depuis provenance.evidence de plusieurs faits. payload.confidence est une donnée pour l'EvidencePolicy ; le moteur n'évalue pas le nombre"
    },
    "afterTime": {
      "type": "string",
      "description": "deadline : l'heure de dépôt"
    },
    "legalTime": {
      "type": "string",
      "description": "la date du droit (YYYY-MM-DD)"
    },
    "predicate": {
      "type": "string",
      "description": "ce qui est demandé, p. ex. 'duty_amount'"
    },
    "responseMode": {
      "enum": [
        "full",
        "compact"
      ],
      "description": "full (défaut) — la réponse complète. compact est accepté par compatibilité : ce serveur ne construit pas de réponse courte et renvoie la même réponse complète dans les deux modes ; il n'y a ni référence fullAnswer ni instantané enregistré de la réponse."
    },
    "supportEdges": {
      "type": "array",
      "description": "appuis, section 75, nœuds support_edge : from est l'id du document, to est le littéral du fait, relation est supports ou refutes. L'admission est décidée par l'EvidencePolicy du paquet, pas par l'hôte"
    },
    "deadlinePolicy": {
      "type": "object",
      "description": "la politique §86 de décompte des délais exprimés en jours : {start_count: 'same_day'|'next_day', include_end: true|false, roll: 'no_roll'|'next_working_day'|'previous_working_day'[, month_end: 'last_day_of_month' — pour les mois et les années seulement]}. Sans elle, une norme portant un délai répond par un avertissement DEADLINE_POLICY_* — la politique est fixée par le droit de la procédure et le serveur n'en suppose jamais une. L'instantané du calendrier officiel §85 pour les jours ouvrables est fourni par le serveur lui-même dès qu'un acte les compte."
    },
    "evidencePolicy": {
      "type": "string",
      "description": "StableId d'un nœud evidence_policy, section 78.2. Sans lui, les appels précédents gardent leur comportement. Le seuil de confidence est une règle de cette politique, pas un argument de l'appel"
    },
    "selectedInterpretations": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "lectures nommées §152 ; pour un groupe exactly_one, choisir exactement un StableId parmi law_packages/law_rules"
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [],
  "properties": {
    "case": {
      "type": "object",
      "description": "l'affaire pour query-over ; elle remplace la clause case"
    },
    "full": {
      "type": "boolean",
      "description": "renvoyer le queryResult complet au lieu d'une page ; seulement quand le périmètre est un seul paquet"
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "description": "un plafond explicite des matérialisations eval() (il ne borne PAS les lignes — voir rowLimit)"
    },
    "query": {
      "type": "string",
      "description": "inline LawQL"
    },
    "corpus": {
      "type": "string",
      "description": "le périmètre de l'instantané : un package.name (par exemple kz.corpus.labour_code) ou un glob sur package.name ; sans corpus, toute la tranche du profil"
    },
    "engine": {
      "enum": [
        "lawc"
      ],
      "default": "lawc",
      "description": "il y a un moteur — le noyau ; l'implémentation de référence est appelée par sa propre commande"
    },
    "question": {
      "type": "string",
      "description": "le nom d'une question du catalogue corpus/ql/questions (producers, readers, anchors-of, imports-of, links-of, type-step) ou d'un lint ; à la place de query"
    },
    "rowLimit": {
      "type": "integer",
      "maximum": 5000,
      "minimum": 1,
      "description": "combien de lignes dans structuredContent (20 ; le budget peut le baisser)"
    },
    "snapshot": {
      "type": "string",
      "description": "le hachage d'instantané de next.snapshot de la page précédente : une continuation sur un autre instantané est refusée (SNAPSHOT_CHANGED)"
    },
    "arguments": {
      "type": "object",
      "description": "les paramètres de la question : un objet « nom → chaîne » (predicate, node, type — des URN ; pkg — un package.name ou un glob)"
    },
    "rowOffset": {
      "type": "integer",
      "minimum": 0,
      "description": "à partir de quelle ligne (0) ; la continuation vient de next avec snapshot ; requêtes structurelles seulement"
    }
  },
  "additionalProperties": false
}

{
  "type": "object",
  "required": [
    "package",
    "goal",
    "binding",
    "sourceSchemaContentHash"
  ],
  "properties": {
    "goal": {
      "type": "string",
      "description": "un StableId ou un nom court unique de l'objectif"
    },
    "binding": {
      "type": "object",
      "description": "un artefact law.screen.binding/0.1"
    },
    "package": {
      "type": "string",
      "description": "la clé de paquet depuis law_packages"
    },
    "legalTime": {
      "type": "string",
      "description": "la date du droit YYYY-MM-DD ; sans elle, toutes les fenêtres de toutes les règles sont prises en compte"
    },
    "sourceSchemaContentHash": {
      "type": "string",
      "description": "le sha256 réel du schéma source"
    }
  },
  "additionalProperties": false
}

case	object	l'affaire pour query-over ; elle remplace la clause case
full	boolean	renvoyer le queryResult complet au lieu d'une page ; seulement quand le périmètre est un seul paquet
limit	integer	un plafond explicite des matérialisations eval() (il ne borne PAS les lignes — voir rowLimit)
query	string	inline LawQL
corpus	string	le périmètre de l'instantané : un package.name (par exemple kz.corpus.labour_code) ou un glob sur package.name ; sans corpus, toute la tranche du profil
engine	any	il y a un moteur — le noyau ; l'implémentation de référence est appelée par sa propre commande
question	string	le nom d'une question du catalogue corpus/ql/questions (producers, readers, anchors-of, imports-of, links-of, type-step) ou d'un lint ; à la place de query
rowLimit	integer	combien de lignes dans structuredContent (20 ; le budget peut le baisser)
snapshot	string	le hachage d'instantané de next.snapshot de la page précédente : une continuation sur un autre instantané est refusée (SNAPSHOT_CHANGED)
arguments	object	les paramètres de la question : un objet « nom → chaîne » (predicate, node, type — des URN ; pkg — un package.name ou un glob)
rowOffset	integer	à partir de quelle ligne (0) ; la continuation vient de next avec snapshot ; requêtes structurelles seulement