Extracción de valores: fechas, correos, teléfonos y montos
💡 Resumen en una frase: con Jev extracción de información se monta una línea de procesamiento de campos: la fecha se descompone en componentes que el código ensambla, y correos/teléfonos/montos primero se buscan como candidatos con regex y Jev elige el correcto; los valores solo pueden venir del texto original.
Para alimentar una base de datos con los campos de un documento, no quieres «un texto que parezca una respuesta». Para ello la documentación oficial ofrece dos cookbooks: Date extraction (extracción de fechas) pregunta por los componentes de la fecha: qué mes, qué día, si se escribió el año, si es una fecha absoluta o una relativa como «el jueves próximo»; toda la matemática de calendario queda para el código; y Pre-parsed value extraction (extracción de valores preparseados) consiste en buscar candidatos con regex, Jev elegir el correcto y que el código copie al pie de la letra. La división del trabajo es una sola: el modelo lee el texto, y la matemática y la normalización ocurren en el código.
¿Por qué esta línea merece una lección aparte? La documentación oficial lo dice sin rodeos en Pre-parsed: TypeSafe solo elige entre los candidatos que la regex ya encontró, así que no puede inventar un valor ni transcribir números con dígitos desplazados. Resultados de las pruebas oficiales: los seis ejemplos de fechas todos correctos (incluida una fecha que el documento ni siquiera mencionaba, correctamente clasificada como «no se puede dar una fecha» y enviada a revisión humana con 0.46); de las cuatro direcciones del correo, se eligió correctamente el correo del destinatario con 0.97; de los tres teléfonos, se eligió correctamente el móvil y se normalizó a +14155550177; de los cuatro montos de la factura, se eligieron correctamente el total y el descuento, con probabilidades de credit / charge de 0.03 y 0.98. Esta lección se completa en unos 15 minutos; la parte de correos/teléfonos/montos, tras descargar la caché oficial, se reproduce sin Key con todas las cifras oficiales (verificado en pruebas en esta página; por qué la parte de fechas no puede, se explica en el paso 1).
Qué podrás hacer al terminar
- Escribir
extract_date(document, role): dale un documento y la pregunta «¿cuál es la fecha límite para devolver el formulario» y recibe undatecon confidence; completa el año cuando no está escrito, resuelve «el jueves próximo» como fecha concreta y reporta error en fechas imposibles de ensamblar - Usar el dúo
find+pickpara extraer valores: la regex captura los candidatos de correos/teléfonos/montos, Jev elige el correcto, y la respuesta es una copia literal del candidato: sin inventos ni transcripciones desplazadas - Normalizar los valores elegidos: correos a minúsculas, teléfonos al formato internacional E.164, montos a
Decimalcon etiqueta credit / charge - Reproducir sin gastar un centavo las cifras oficiales de extracción de valores: repetición de la caché oficial
json_cache.json, reejecución con cero solicitudes
Por qué usar Jev y no dejar que el LLM extraiga directamente
«Dejar que el LLM extraiga la fecha del contrato» es la primera reacción de muchos: funciona, pero cada carácter lo escribe de nuevo.
| Capacidad | LLM extrae directamente | Jev Extracción de información |
|---|---|---|
| Origen del valor | ❌ El modelo lo regenera completo; puede inventar un valor o escribir 14 como 41 | ✅ Las opciones son los candidatos que encontró la regex, y la respuesta es una copia literal de uno de ellos o none: palabras oficiales: no puede invent, no puede transpose |
| Matemática de calendario | ❌ Preguntas como «¿qué día cae el jueves próximo» o «¿febrero (mes 2) tiene día 30» confiadas al modelo: no fiables | ✅ El modelo solo lee componentes (agosto / 14 / sin año escrito); ensamblar, inferir y validar ocurre todo en el código |
| Valores que el documento no escribió | ❌ Tiende a dar igualmente una fecha | ✅ mode=none, year=none y pick=none como tres válvulas de escape: el criterio oficial es que los componentes faltantes deben reportarse, no adivinarse |
| Grado de certeza | ❌ Hay que preguntar «¿estás seguro?» y aun así la respuesta es inestable | ✅ Cada componente trae confidence; la fecha toma el más débil de los componentes utilizados, y por debajo de 0.60 se envía a revisión humana |
| Forma de la respuesta | ❌ Texto libre o JSON: el parseo aguas abajo fallará | ✅ Respuesta tipada + distribución de probabilidades, lista para que el código la use directamente |
En una frase: el LLM reescribe el documento por ti, Jev solo lee el documento por ti: los números que quedan escritos siempre salen del texto original.
Tu situación actual
- «Al pedirle al LLM extraer el total de una factura, a veces transcribe
$1,315.50como$1,351.50: un dígito desplazado y toda la facturación aguas abajo sale mal, sin poder localizar en qué paso falló» - «El contrato no menciona ninguna fecha de entrega, y aun así el modelo inventa una; solo me queda escribir otra capa de validación para cazar sus alucinaciones»
- «Fechas relativas como 'devolver antes del próximo viernes' obligan al modelo a hacer cálculos de calendario, y cada ejecución da una respuesta distinta»
Cuándo usar esta técnica
Cuando necesitas:
- Extraer campos estructurados de contratos, correos, facturas y formularios: fechas, correos electrónicos, teléfonos, importes, que entren directamente en la base de datos o en el flujo de facturación
- Que los valores provengan literalmente del documento — sin inventar, sin transcribir en posición equivocada, y reportar explícitamente cuando falten
- Resolver fechas relativas («hoy», «el próximo jueves») en fechas concretas, con las reglas de resolución escritas en tu código: cambiar las reglas sin cambiar la pregunta
Y no quieres:
- Parsear el JSON que escupe el LLM y luego escribir otra capa de validación de «¿lo volvió a inventar?»
- Que un modelo generativo haga aritmética de calendario
- Reajustar el prompt cada vez que cambia un documento
🎒 Preparativos antes de empezar
- Completado Noul preguntas de sí/no: la clasificación credit / charge del importe se hace con Noul, 0.5 = cincuenta y cincuenta
- Completado Choice preguntas de selección: las siete preguntas sobre fechas son todas Choice; hay que saber escribir un
criteriamap de opciones y saber leerchoiceyconfidence - Se recomienda haber leído Confidence nivel de confianza: saber cómo ajustar 0.60, este umbral de revisión, según el riesgo
- Haber ejecutado con éxitoInstalación y primera solicitud:
.venvdisponible. La parte de extracción de valores funciona incluso sin Key (el paso 1 usa la caché oficial); la parte de fechas necesitaTYPESAFE_API_KEY - Un vaso de agua ☕ — esta lección es un proyecto completo pequeño: una función de fechas + tres escenarios de valores; el modelo solo lee texto, y toda la matemática y normalización ocurre en el código
Hazlo conmigo
Primero aclaremos cómo ejecutarlo: crea un nuevo value_extraction.py y pega los bloques de código de cada paso siguiente en orden en el mismo archivo. Esta lección tiene dos partes y dos formas de ejecutarla:
- Pasos 2–4 (fechas): la clave de caché oficial no coincide con la del código actual (se detalla en el paso 1); configura
TYPESAFE_API_KEYpara ejecutar en vivo — seis ejemplos, 6 solicitudes en total; las respuestas se guardan en caché local y al reejecutar no se vuelve a pagar - Pasos 5–6 (correo/teléfono/importe): tras descargar la
json_cache.jsonoficial, reproduce sin Key todas las cifras oficiales
¿Todavía no tienes Key? Salta directamente al paso 5 para dejar funcionando primero la extracción de valores, y lee la parte de fechas comparando con las cifras oficiales grabadas que aparecen en esta página — cada paso está anotado.
Paso 1: instala el entorno, descarga la caché oficial y prepara dos conjuntos de ejemplos de extracción
Por qué: cada uno de los dos ejemplos oficiales trae su propia caché de respuestas grabada json_cache.json — la de extracción de valores se reproduce literalmente en pruebas, sin Key; la de fechas tiene claves que no coinciden con el código actual y solo puede ejecutarse en vivo. Prepara primero el material para que cada paso posterior tenga respuestas con qué comparar.
Instala las dependencias (combinación de los comandos de instalación de los dos cookbooks oficiales; el rango de versiones de typesafe-sdk se fija explícitamente según la declaración de dependencias de cooksafe 0.2.0, es decir typesafe-sdk<0.8.0,>=0.7.0; cooksafe es la biblioteca de utilidades que acompaña a los cookbooks oficiales, con la descripción en PyPI «Shared helpers for the TypeSafe cookbooks»; esta página usa su caché JsonCache):
pip install 'typesafe-sdk>=0.7.0,<0.8.0' ipython phonenumbers 'cooksafe>=0.2.0,<0.3.0'Descarga la caché oficial de extracción de valores (enlace directo raw, verificado que funciona):
curl -sL -o values_cache.json https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/pre_parsed_value_extraction_cookbook/json_cache.jsonCrea un nuevo value_extraction.py y pega el encabezado del archivo — el cliente monta dos cachés, una para fechas y otra para valores:
import os
import re
from datetime import date, timedelta
from decimal import Decimal
from pathlib import Path
import phonenumbers
from cooksafe import JsonCache
from typesafe_sdk import Choice, Noul, TypeSafeClient
# 官方录制版本:Date extraction 用 jev-1.12,
# Pre-parsed value extraction 用 jev-1.14.0。
# live 跑日期部分时换成你锁定的版本 ID;jev-latest 别名会随版本漂移。
DATE_MODEL = "jev-1.14.0"
VALUE_MODEL = "jev-1.14.0"
client = TypeSafeClient(
api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"), # cached re-renders need no key
base_url=os.environ.get("TYPESAFE_BASE_URL"),
timeout=30.0,
)
# 日期:缓存你自己 live 跑的答案(官方那份对不上,见下方提示框)
date_cache = JsonCache(Path("date_cache.json"))
# 值:官方缓存,零 Key 重放第 5、6 步全部官方数字
values_cache = JsonCache(Path("values_cache.json"))
print("setup ok")Ejecuta python value_extraction.py.
Deberías ver: setup ok — este paso es solo de ensamblaje, todavía no se envían solicitudes.
⚠️ Por qué no se descarga la caché oficial de fechas
El repositorio oficial también publica la caché de la parte de fechas, pero lo comprobé: al reproducir con el código de esta página (es decir, el código vigente de la documentación oficial) más cooksafe 0.2.0, las seis llamadas fallan todas en la caché — las claves no coinciden (muy probablemente el script de grabación no está sincronizado con el código vigente de la documentación), y el SDK intenta entonces una solicitud real; sin Key el resultado es 401. Así que para la parte de fechas usa tu propio date_cache.json; las cifras oficiales se transcriben en esta página para que compares tus respuestas. La caché oficial de extracción de valores se comprobó que se reproduce literalmente, úsala con tranquilidad.
setup okse imprimió,values_cache.jsonestá en el directorio de ejecución
Paso 2: siete preguntas sobre fechas — Jev extracción de información primero lee componentes y no hace matemática
Por qué: pedirle al modelo que responda directamente «¿qué día es la fecha límite?» equivale a exigirle aritmética de calendario. El enfoque oficial hace que cada componente de la fecha caiga en un conjunto cerrado pequeño: doce meses, el día 1–31, una ventana de años; así cada componente es una Choice, y se preguntan todas en paralelo en una sola solicitud (el mecanismo de varias preguntas en una solicitud se explica en preguntas en paralelo y fan-out especulativo). El modelo lee el texto; el código calcula el calendario.
Prepara primero los cuatro documentos de ejemplo oficiales y luego pega la definición de las siete preguntas:
CONTRACT = "This agreement is effective January 1, 2025 and expires December 31, 2027."
FORM = "Please return the signed form by August 14."
SURVEY = "Heads up - the customer survey closes today at 5pm."
REVIEW = "Let's schedule the design review for next Thursday."
MONTHS = {
"January": 1, "February": 2, "March": 3, "April": 4,
"May": 5, "June": 6, "July": 7, "August": 8,
"September": 9, "October": 10, "November": 11, "December": 12,
}
WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
YEAR_WINDOW = list(range(1900, 2051)) # 1900..2050
def date_questions(role: str) -> dict[str, Choice]:
"""Seven typed choices that read a date's shape and parts off the text -- no math."""
absent = "The document does not state this, or it is not this kind of date."
return {
"mode": Choice(
instructions=(
f"How is {role} written? 'absolute' = a calendar date naming a month (e.g. "
"'August 14', 'the 3rd of March'); 'relative' = given relative to today (today, "
"tomorrow, the day after tomorrow, or a named weekday such as 'next Thursday'); "
"'none' = the document does not state this date."
),
criteria={"absolute": None, "relative": None, "none": None},
),
"month": Choice(
instructions=f"If {role} is an absolute calendar date, which month is it in?",
criteria={m: None for m in MONTHS} | {"none": absent},
),
"day": Choice(
instructions=f"If {role} is an absolute calendar date, which day of the month (1-31)?",
criteria={str(d): None for d in range(1, 32)} | {"none": absent},
),
"year": Choice(
instructions=(
f"If {role} is an absolute calendar date, which year? Pick 'none' if the document "
"states no year (code infers it), or 'out_of_range' if a year is stated but not "
"in the list."
),
criteria={str(y): None for y in YEAR_WINDOW}
| {
"out_of_range": "A year is stated for this date but is outside the listed range.",
"none": "No year is stated for this date.",
},
),
"day_anchor": Choice(
instructions=(
f"If {role} is relative to today, which day is it? 'today', 'tomorrow', "
"'day_after' (the day after tomorrow), or 'weekday' (a named day of the week)."
),
criteria={
"today": None, "tomorrow": None, "day_after": None,
"weekday": None, "none": absent,
},
),
"weekday": Choice(
instructions=f"If {role} names a day of the week, which one?",
criteria={w: None for w in WEEKDAYS} | {"none": absent},
),
"week_offset": Choice(
instructions=(
f"If {role} names a weekday, which week is it in? 'next' for 'next Thursday' or "
"'Thursday next week'; 'current' for 'this Thursday'; 'none' for a bare weekday "
"with no qualifier (just 'Thursday' / 'on Thursday')."
),
criteria={"current": None, "next": None, "none": absent},
),
}El reparto de las siete preguntas — mode dice cómo está escrita esta fecha (absoluta / relativa / no escrita); las otras seis leen los componentes: una fecha absoluta necesita month + day + year; una relativa necesita day_anchor (hoy / mañana / pasado mañana / algún día de la semana); cuando se menciona un día de la semana, weekday y week_offset dicen cuál y qué semana. El código solo lee las preguntas que necesita según mode.
Fíjate en las dos salidas de emergencia de year: none = el texto no menciona el año, lo completa el código; out_of_range = se menciona pero está fuera de 1900–2050, se reporta en lugar de adivinar. La documentación oficial ofrece además un enfoque alternativo para listas de opciones demasiado largas; ver técnicas avanzadas.
A continuación pega la función que envía la solicitud y, de paso, ejecuta la de la fecha de entrada en vigor del contrato:
@date_cache
def read_parts(document: str, role: str) -> dict:
"""One TypeSafe call -> {part: {choice, confidence}} for the seven questions."""
answers = client.system_one(
state=document, questions=date_questions(role), model=DATE_MODEL
).answers
return {
part: {"choice": ans.choice, "confidence": ans.confidence}
for part, ans in answers.items()
}
parts = read_parts(CONTRACT, "the date the agreement takes effect")
for name, part in sorted(parts.items()):
print(f"{name:<12}{part['choice']:<11}(conf {part['confidence']:.2f})")Ejecuta python value_extraction.py. Con Key configurada se envía una solicitud real (jev-1.14.0) y la respuesta entra en date_cache.json.
Deberías ver (cifras grabadas oficiales de jev-1.12; en tu ejecución en vivo las selecciones de componentes deberían coincidir, las confianzas tendrán pequeñas diferencias):
day 1 (conf 0.98)
day_anchor none (conf 0.89)
mode absolute (conf 1.00)
month January (conf 1.00)
week_offset none (conf 0.99)
weekday none (conf 0.86)
year 2025 (conf 0.97)Tres lecturas:
El modelo no hizo matemática: solo dijo «January», «1», «2025»; no dijo qué día de la semana es ni a cuánto está de hoy — eso es tarea del código del paso 3
Los componentes no aplicables se responden
none: una fecha absoluta no necesitaday_anchor/weekday, todononecon confianza altaCada componente trae su propio confidence: esta máquina sabe cuán firme es cada una de sus lecturas; el paso 4 las usará para calcular la confianza de la fecha completa
Puedo explicar qué lee cada una de las siete preguntas y cómo
modedecide el código cuáles leer
Paso 3: el código ensambla la fecha — la aritmética de calendario no entra al modelo
Por qué: con los componentes ya obtenidos, todo lo que queda es trabajo determinista: los años no escritos se completan con el día de hoy, «next Thursday» se resuelve según la convención que declaraste, y combinaciones imposibles de ensamblar como February 30 dan error. La parte oficial está escrita como una función pura — no envía solicitudes, no escribe logs, y puede ejecutarse sola en pruebas unitarias.
Pega el código de ensamblaje:
TODAY = date(2026, 7, 30) # fixed reference "today" so relative dates resolve reproducibly
REVIEW_BELOW = 0.60 # gate: a date below this confidence is flagged for a human
def resolve_weekday(today: date, weekday: str, week_offset: str) -> date:
"""Which date a named weekday points to, by our stated convention: a bare weekday is the next
occurrence on or after today; 'next' is the following calendar week; 'current' is this week."""
w = WEEKDAYS.index(weekday)
this_monday = today - timedelta(days=today.weekday())
if week_offset == "next":
return this_monday + timedelta(days=7 + w)
if week_offset == "current":
return this_monday + timedelta(days=w)
return today + timedelta(days=(w - today.weekday()) % 7)
def assemble(parts: dict, today: date = TODAY) -> dict:
"""Resolve the parts TypeSafe read into a concrete date, in code. Confidence is the weakest of
the parts the shape actually used."""
mode = parts["mode"]["choice"]
confs = [parts["mode"]["confidence"]]
def result(resolved: date | None, note: str) -> dict:
usable = [c for c in confs if c is not None]
confidence = min(usable) if usable else None
needs_review = resolved is None or confidence is None or confidence < REVIEW_BELOW
return {
"date": resolved,
"confidence": confidence,
"needs_review": needs_review,
"note": note,
}
if mode == "none":
return result(None, "no such date stated")
if mode == "absolute":
month, day, year = (
parts["month"]["choice"],
parts["day"]["choice"],
parts["year"]["choice"],
)
confs += [
parts["month"]["confidence"],
parts["day"]["confidence"],
parts["year"]["confidence"],
]
if "none" in (month, day) or not day.isdigit() or month not in MONTHS:
return result(None, "absolute date incomplete")
if year == "out_of_range": # a year is stated but off the list -> flag, don't guess
return result(None, f"year outside {YEAR_WINDOW[0]}-{YEAR_WINDOW[-1]}")
if year == "none": # no year stated -> infer this year, bumped to next if well past
try:
resolved = date(today.year, MONTHS[month], int(day))
except ValueError: # e.g. February 30 -- an inconsistent read, not a real date
return result(None, f"impossible date: {month} {day}")
if resolved < today - timedelta(days=31):
resolved = date(today.year + 1, MONTHS[month], int(day))
return result(resolved, "")
try: # a stated, in-range year
return result(date(int(year), MONTHS[month], int(day)), "")
except ValueError:
return result(None, f"impossible date: {year}-{month}-{day}")
if mode == "relative":
anchor = parts["day_anchor"]["choice"]
confs.append(parts["day_anchor"]["confidence"])
if anchor == "today":
return result(today, "")
if anchor == "tomorrow":
return result(today + timedelta(days=1), "")
if anchor == "day_after":
return result(today + timedelta(days=2), "")
if anchor == "weekday":
weekday, offset = parts["weekday"]["choice"], parts["week_offset"]["choice"]
confs += [parts["weekday"]["confidence"], parts["week_offset"]["confidence"]]
if weekday not in WEEKDAYS:
return result(None, "relative weekday not read")
return result(resolve_weekday(today, weekday, offset), "")
return result(None, "relative day not read")
return result(None, f"unrecognized mode: {mode}")
def extract_date(document: str, role: str) -> dict:
return assemble(read_parts(document, role))
print(extract_date(CONTRACT, "the date the agreement takes effect"))Ejecuta.
Deberías ver (grabación oficial: los tres componentes usados 1.00 / 0.98 / 0.97, se toma el más débil):
{'date': datetime.date(2025, 1, 1), 'confidence': 0.97, 'needs_review': False, 'note': ''}Lee los tres bloques de lógica; cada uno tiene su propia salida:
- La ambigüedad de «next Thursday» la resuelve el código: la convención declarada oficialmente — un weekday pelado = el próximo a partir de hoy (incluido hoy);
next= la próxima semana calendario;current= esta semana. Puedes cambiarla por la convención de tu equipo; lo que cambias es el código, no el problema - Si no se escribió el año, se infiere: primero se ensambla con el año actual; solo si ya pasó** hace más de 31 días** salta al año siguiente — un formulario del 14 de 8 visto el 30 de 7 es del año en curso
- Las fechas imposibles de ensamblar se reportan como impossible, sin forzar: una lectura contradictoria como February 30 devuelve directamente
Nonemás una nota; el paso 4 la enviará a revisión manual
💡 Este es el valor único de Jev
La confianza esel más débil de los componentes usados — las fechas absolutas solo miran cuatro elementos: mode + mes + día + año; da igual cómo responda day_anchor. A simple vista se ve qué componente frena, y quien revisa sabe qué media frase del original debe mirar. Un LLM común no puede ofrecer esto: escupe la fecha terminada de una sola vez y no sabes qué eslabón fue adivinado.
- Puedo explicar las reglas de inferencia con
year=none(arranca en el año actual, solo salta al siguiente si pasó hace más de 31 días) y la convención de resolución de un weekday pelado
Paso 4: contrastar los seis ejemplos oficiales, por debajo de 0.60 se envía a revisión manual
Por qué: si una extracción puede pasar a producción depende de cómo se comporta cuando «el documento no menciona esta fecha». Los seis ejemplos oficiales cubren cuatro formas de escribir más una trampa: dos fechas con año escrito en el contrato, una fecha límite de formulario sin año, una encuesta cerrada «hoy», una revisión de diseño «el próximo jueves», más una kickoff call queno se menciona en absoluto en el formulario (el formulario tiene fechas, solo que no esta — diseñada contra el reflejo de «extraer cualquier fecha que se vea»).
Pega los ejemplos y el marcador de puntuación:
# (document, question phrase, expected date) -- the expected value is only for the scorecard.
EXAMPLES = [
(CONTRACT, "the date the agreement takes effect", date(2025, 1, 1)),
(CONTRACT, "the date the agreement expires", date(2027, 12, 31)),
(FORM, "the deadline to return the form", date(2026, 8, 14)),
(FORM, "the date of the kickoff call", None),
(SURVEY, "the date the survey closes", date(2026, 7, 30)),
(REVIEW, "the date of the design review", date(2026, 8, 6)),
]
print(f"{'':3}{'question':<38}{'expected':<12}{'got':<12}{'conf':>6} flags")
print("-" * 84)
for document, role, expected in EXAMPLES:
r = extract_date(document, role)
got = r["date"].isoformat() if r["date"] else "none"
exp = expected.isoformat() if expected else "none"
mark = "OK" if r["date"] == expected else "XX"
conf = f"{r['confidence']:.2f}" if r["confidence"] is not None else " n/a"
flags = " <== review" if r["needs_review"] else ""
if r["note"]:
flags += f" ({r['note']})"
print(f"{mark:<3}{role:<38}{exp:<12}{got:<12}{conf:>6}{flags}")
print()
confident = [(doc, role) for doc, role, _ in EXAMPLES if not extract_date(doc, role)["needs_review"]]
review = [(doc, role) for doc, role, _ in EXAMPLES if extract_date(doc, role)["needs_review"]]
print(f"auto-accept ({len(confident)}):")
for _doc, role in confident:
print(f" - {role}")
print(f"\nsend to review ({len(review)}):")
for _doc, role in review:
r = extract_date(_doc, role)
print(f" - {role} (conf {r['confidence']:.2f} / {r['note'] or 'low confidence'})")Ejecuta. Los seis ejemplos suman 6 llamadas — la del paso 2 ya está en la caché, la primera corrida envía 5 solicitudes nuevas; los dos tramos posteriores auto-accept / review vuelven a llamar extract_date, todo por caché.
Deberías ver (grabación oficial jev-1.12, TODAY = 2026-07-30, un jueves; los números en vivo tendrán pequeñas diferencias):
question expected got conf flags
------------------------------------------------------------------------------------
OK the date the agreement takes effect 2025-01-01 2025-01-01 0.97
OK the date the agreement expires 2027-12-31 2027-12-31 0.91
OK the deadline to return the form 2026-08-14 2026-08-14 0.95
OK the date of the kickoff call none none 0.46 <== review (absolute date incomplete)
OK the date the survey closes 2026-07-30 2026-07-30 0.94
OK the date of the design review 2026-08-06 2026-08-06 0.92
auto-accept (5):
- the date the agreement takes effect
- the date the agreement expires
- the deadline to return the form
- the date the survey closes
- the date of the design review
send to review (1):
- the date of the kickoff call (conf 0.46 / absolute date incomplete)Tres cosas merecen una pausa:
- Las fechas no escritas se reportan, no se adivinan: en la línea de la kickoff call,
moderespondióabsoluteperomonthesnone— el código dictamina «absolute date incomplete», fecha vacía, confidence 0.46, needs_review. Este es justamente el sentido de la escotilla de escapenoneque la parte oficial añade a los componentes: los componentes que faltan se reportan, no se inventan - El formulario sin año se completa solo: August 14 → 2026-08-14 (
TODAYes 2026-07-30, el mes 8 aún no ha pasado, no hace falta saltar de año) - «Hoy» y «el próximo jueves» ambos aterrizaron: survey closes → 2026-07-30 (el mismo día); design review → 2026-08-06 (el 30 de julio, 7, es jueves, «next» = el día 4 de la próxima semana calendario). El requisito para que las fechas relativas sean reproducibles es que
TODAYesté fijo — cuando lo ejecutes tú, cambiaTODAYpordate.today(), o fíjalo de forma uniforme antes del lote
La acción de producción la decide un solo campo, needs_review: False entra directo a la base de datos, True va a revisión manual — cómo ajustar la confianza según el riesgo, ver Confidence 置信度.
- El marcador de seis líneas y el auto-accept 5 / send to review 1 coinciden; puedo señalar por qué la línea de la kickoff call no debería ser 2026-08-14
Paso 5: extracción de correos — la regex encuentra candidatos, Jev elige el correcto
Por qué: desde este paso se puede ejecutar sin Key. Lo difícil de los correos no es «encontrar todas las direcciones» — una regex se escribe en una hora — sinocuál de los cuatro candidatos es el que buscas: a qué buzón se envía el recibo depende de si se entendió la frase del cuerpo «no uses el alias de facturación, envíalo a mi correo personal». Este es justamente el método oficial de tres pasos: la regex encuentra candidatos (mejor capturar de más) → Jev elige el correcto → el código copia y normaliza literalmente.
Pega las cuatro funciones auxiliares y el ejemplo de correo:
NONE = "none" # the escape hatch on every selection: "none of the candidates fits"
EMAIL_RE = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
PHONE_RE = re.compile(r"\(?\+?\d[\d\s()\-.]{6,}\d")
MONEY_RE = re.compile(r"[$€£¥]\s?\d[\d,]*(?:\.\d{2})?")
def find(pattern: re.Pattern, text: str) -> list[str]:
"""Code-side candidate finder: recall-tuned regex, deduped, in document order."""
seen: set[str] = set()
out: list[str] = []
for match in pattern.findall(text):
span = match.strip()
if span and span not in seen:
seen.add(span)
out.append(span)
return out
@values_cache
def pick(document: str, candidates: list[str], question: str) -> dict:
"""TypeSafe selects which found span plays the role. Returns {choice, confidence}.
The options ARE the candidate spans, so ``choice`` is a verbatim copy of one of them (or the
``none`` hatch). The model chooses; code owns the string."""
criteria = {c: None for c in candidates} | {NONE: "None of these is the requested value."}
answer = client.system_one(
state=document,
questions={"pick": Choice(instructions=question, criteria=criteria)},
model=VALUE_MODEL,
).answers["pick"]
return {"choice": answer.choice, "confidence": answer.confidence}
@values_cache
def classify(document: str, question: str, options: list[str]) -> dict:
"""A small Choice over a fixed label set (currency, country, ...). Returns {choice, confidence}."""
answer = client.system_one(
state=document,
questions={"q": Choice(instructions=question, criteria={o: None for o in options})},
model=VALUE_MODEL,
).answers["q"]
return {"choice": answer.choice, "confidence": answer.confidence}
@values_cache
def is_true(document: str, question: str) -> float:
"""A yes/no Noul. Returns P(yes)."""
return (
client.system_one(
state=document,
questions={"q": Noul(instructions=question)},
model=VALUE_MODEL,
)
.answers["q"]
.noul
)
EMAIL_DOC = """From: Jane Doe <jane.doe@example.com>
To: billing@example.com
Cc: orders@example.com
Reply-To: jane.personal@example.net
Hi team - please don't use the billing alias for this one. Send my receipt to my
personal address instead. Thanks, Jane."""
emails = find(EMAIL_RE, EMAIL_DOC)
receipt = pick(EMAIL_DOC, emails, "Which email address does the sender want their receipt sent to?")
sender = pick(EMAIL_DOC, emails, "Which email address did this message come from (the From line)?")
print("candidates :", emails)
# code copies the picked value verbatim and normalizes (lowercase); it never re-types it
print(f"receipt -> : {receipt['choice'].lower():<28} (conf {receipt['confidence']:.2f})")
print(f"sender -> : {sender['choice'].lower():<28} (conf {sender['confidence']:.2f})")Ejecuta python value_extraction.py — todo acierta en la caché oficial, sin enviar ni una solicitud.
Deberías ver (grabación oficial jev-1.14.0; la prueba real de esta página lo reproduce literalmente):
candidates : ['jane.doe@example.com', 'billing@example.com', 'orders@example.com', 'jane.personal@example.net']
receipt -> : jane.personal@example.net (conf 0.97)
sender -> : jane.doe@example.com (conf 1.00)Dos puntos de diseño:
- Las opciones de
pickson los propios candidatos:criteriason las cuatro cadenas de dirección más unnone, así quechoicesolo puede ser unacopia literal de una de ellas — ni siquiera es posible inventar una quinta dirección, ni existe transcribir con desplazamiento, porque directamente no hay un paso de «volver a teclear» - Si no puede elegir, lo dice: cuando ningún candidato encaja, la respuesta es
none, y el código lo trata como «no encontrado», en vez de forzar una elección - Dos preguntas, dos solicitudes, el mismo conjunto de candidatos: la dirección de destino se decide leyendo el cuerpo (piden el correo personal), el remitente mirando la línea
From— el juicio está entre líneas, justo la parte que una regex no puede hacer
💡 Este es el valor único de Jev
La regex se encarga delrecall (capturar todo lo posible; capturar de más no importa), Jev se encarga de laselección (entender el cuerpo y elegir el correcto), y el código de lafidelidad (copia literal + normalización a minúsculas). Cada tramo cumple su función y si uno se rompe se repara por separado — la extracción directa con LLM mezcla las tres cosas en una sola generación y, cuando falla, ni siquiera sabes en qué tramo fue.
- Sin Key se obtuvo receipt 0.97 / sender 1.00; puedo explicar
pickpor qué es imposible que devuelva una dirección que no esté entre los candidatos
Paso 6: teléfonos y montos — normalizar a E.164 y Decimal
Por qué: elegir bien el valor es solo la mitad del trabajo; todavía hay que convertirlo en una forma que el sistema pueda usar. La dificultad con los teléfonos: tres números se ven exactamente iguales, cuál es un móvil y en qué país está — los dígitos en sí no contienen esa información, sí la tiene el texto circundante. La dificultad con los importes: sacar el total no basta, hay que saber si es charge o credit, si no Decimal no puede ni determinar el signo.
Pega el ejemplo de teléfono:
PHONE_DOC = """Reach our San Francisco office at these numbers: main desk (415) 555-0199,
billing fax (415) 555-0142, and my direct cell (415) 555-0177. Call the cell if it's urgent."""
phones = find(PHONE_RE, PHONE_DOC)
mobile = pick(PHONE_DOC, phones, "Which of these is the direct mobile / cell number?")
region = classify(PHONE_DOC, "In what country is this office located?", ["US", "GB", "DE", "FR", "CA", "AU"])
# code copies the picked value and normalizes it with the model-supplied country
parsed = phonenumbers.parse(mobile["choice"], region["choice"])
e164 = phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
print("candidates :", phones)
print(f"mobile -> : {mobile['choice']} (conf {mobile['confidence']:.2f})")
print(f"country -> : {region['choice']} (conf {region['confidence']:.2f})")
print(f"E.164 -> : {e164}")Luego pega el ejemplo de importe:
MONEY_DOC = """Invoice INV-2087.
Subtotal: $1,200.00
Sales tax: $115.50
Total due: $1,315.50
A $50.00 courtesy credit from last month has already been applied."""
amounts = find(MONEY_RE, MONEY_DOC)
currency = classify(MONEY_DOC, "What currency are these amounts in?", ["USD", "EUR", "GBP", "JPY", "CAD"])
total = pick(MONEY_DOC, amounts, "Which amount is the total the customer must pay?")
credit = pick(MONEY_DOC, amounts, "Which amount is the courtesy credit that was applied?")
def to_decimal(value: str) -> Decimal:
"""Copy the picked value and parse the number in code (US grouping/decimal here)."""
return Decimal(re.sub(r"[^\d.]", "", value))
for label, chosen in [("total due", total), ("credit", credit)]:
is_credit = is_true(
MONEY_DOC,
f"Is the amount {chosen['choice']} a credit or refund to the customer, not a charge?",
)
kind = "credit" if is_credit > 0.5 else "charge"
print(
f"{label:<10}: {chosen['choice']:<10} -> {to_decimal(chosen['choice'])} {currency['choice']} "
f"({kind}, P(credit)={is_credit:.2f})"
)
print("\ncandidates :", amounts)Ejecuta.
Deberías ver (grabación oficial jev-1.14.0; la prueba real de esta página lo reproduce literalmente):
candidates : ['(415) 555-0199', '(415) 555-0142', '(415) 555-0177']
mobile -> : (415) 555-0177 (conf 1.00)
country -> : US (conf 1.00)
E.164 -> : +14155550177
total due : $1,315.50 -> 1315.50 USD (charge, P(credit)=0.03)
credit : $50.00 -> 50.00 USD (credit, P(credit)=0.98)
candidates : ['$1,200.00', '$115.50', '$1,315.50', '$50.00']Veamos los cuatro bloques por separado:
- Teléfono: Jev elige el número + lee el país,
phonenumbersse encarga del formato —(415) 555-0177no tiene ni un dígito que diga «soy un móvil» o «estoy en Estados Unidos»; esas dos cosas vienen de palabras como «my direct cell» y «San Francisco office»; el ensamblado de E.164 es código puro, con el país pasado como parámetro - Importe: una sola pregunta a Noul determina el signo — «este importe, ¿es un credit o un charge para el cliente?» da respectivamente 0.03 y 0.98; una probabilidad tan abrumadora le da fundamento al signo de
Decimal;0.5traza el corte: lo que quede pegado a 0.5 debe pasar a revisión humana (Noul no tiene confidence) - Las etiquetas de
classifyson el conjunto cerrado que tú eliges: países[US, GB, DE, FR, CA, AU], monedas[USD, EUR, GBP, JPY, CAD]— para adaptarlo a tu región de negocio, cambia esas dos listas; si la lista oficial sugerida puede no cubrir todo, añade una opciónother/none of the above, para que el modelo tenga dónde decir «no se parece a ninguna» picktrae confidence de serie: en la caché oficial, la pregunta de selección sobre total registra 0.56 (no se imprime en la salida, pero queda anotado en la caché) — la respuesta se eligió bien, pero con confianza mediocre. Si conviene revisar los picks de baja confianza, escribe esa regla en tu código siguiendo la lógica deREVIEW_BELOWdel paso 4
Al final de la página, la documentación oficial señala dos límites; anótalos de momento, y se desarrollan en técnicas avanzadas:
Una sola pregunta Choice admite como máximo 255 opciones; con más candidatos, selecciona primero en dos rondas
Encontrar los candidatos es la parte laboriosa — correos, teléfonos e importes están a cubierto, pero los nombres de persona no tienen una buena regex; los candidatos deben salir de un roster o de NER
Sin Key se obtienen E.164
+14155550177y P(credit) 0.03 / 0.98; puedo decir quién determina el número de móvil y el país, respectivamente, y quién ensambla E.164
📋 Prompt mágico
Los «Prompt» de esta página son preguntas y plantillas de código para la API — cópialos, sustituye los marcadores 【】 (los que llevan ? son opcionales) y podrás conectarlos a tus propios documentos. El trío: la pregunta de componentes de fecha, la pregunta de selección de candidatos y la canalización de normalización.
📝 Las siete preguntas de componentes de fecha (versión Choice)
Resultado esperado: cualquier necesidad de «preguntar una fecha según su rol» — fecha de entrada en vigor de un contrato, fecha límite de un formulario, nueva fecha de una reunión — se resuelve con el mismo bloque de preguntas cambiando role, y la respuesta siempre son componentes, nunca una fecha terminada.
# 必填项:【日期角色】换成你要问的那个日期的自然语言描述
DATE_QUESTIONS = {
"mode": Choice(
instructions="【这个日期是怎么写的?absolute=点名月份的日历日期;relative=相对今天;none=文档没写】",
criteria={"absolute": None, "relative": None, "none": None},
),
"month": Choice(
instructions="【若是绝对日期,是几月?】",
criteria={【m: None for m in 十二个月】} | {"none": "文档没写或不是这种日期"},
),
"day": Choice(
instructions="【若是绝对日期,是几号(1-31)?】",
criteria={【str(d): None for d in range(1, 32)】} | {"none": "文档没写或不是这种日期"},
),
"year": Choice(
instructions="【若是绝对日期,是哪年?没写选 none,超出范围选 out_of_range】",
criteria={【str(y): None for y in 你的年份窗口】}
| {"out_of_range": "写了年份但在列表外", "none": "没写年份,代码来补"},
),
"day_anchor": Choice(
instructions="【若是相对日期,锚在哪天?today / tomorrow / day_after / weekday】",
criteria={"today": None, "tomorrow": None, "day_after": None, "weekday": None,
"none": "文档没写或不是这种日期"},
),
"weekday": Choice(
instructions="【若点名了星期几,是哪一个?】",
criteria={【w: None for w in 七个星期】} | {"none": "文档没写或不是这种日期"},
),
"week_offset": Choice(
instructions="【若点名星期几,是哪一周?next=下一日历周;current=本周;none=光秃秃没限定】",
criteria={"current": None, "next": None, "none": "文档没写或不是这种日期"},
),
}
# 选填项:窗口按你的业务改——1950–2035 或未来十年;列表太长见进阶技巧的预筛做法?
# 输出规范:每题 answer.choice + answer.confidence;代码只读 mode 用得上的部件
# 约束条件:
# ✅ 每道不适用的部件都给 none 出口——缺的部件要被报出来,不是被猜出来
# ✅ 日历数学(补年份、解析「下周四」、校验 2 月 30)全放代码
# ❌ 不要问「截止日期是几月几号」——那是让模型做数学+回答二合一✅ Pregunta de selección de candidatos (versión pick)
Resultado esperado: todo campo donde «la regex puede encontrar candidatos, pero hay que leer el contexto para saber cuál elegir» — correo del destinatario, número de móvil, total de factura, número de agente de soporte — usa esta misma plantilla.
from typesafe_sdk import Choice
# 必填项:candidates 传正则抓出的候选(去重、按文档序),问题问「角色」不问「形状」
picked = client.system_one(
state=【整份文档原文】,
questions={
"pick": Choice(
instructions="【哪个候选是……?例如:寄件人希望收据寄到的那个邮箱】",
criteria={c: None for c in 【candidates】}
| {"none": "None of these is the requested value."},
)
},
).answers["pick"]
# 选填项:同一批候选换一个 role 再问一次(发件人 vs 收件人)——两次请求、同一副选项?
# 输出规范:answer.choice 是某个候选的逐字拷贝或 "none";answer.confidence 可接复核线
# 约束条件:
# ✅ 选项就是候选字符串本身——答案是拷贝,不是重新生成
# ✅ 正则调召回不调精度:多抓的让 Jev 挑掉,漏抓的谁也救不回来
# ❌ 候选超过 255 个别硬塞——先分区块挑,再挑区块内的 span(见 C4)🔧 Normalización y revisión (versión código)
Resultado esperado: los valores elegidos se convierten en una forma directamente utilizable por el sistema; cada paso es código puro, testeable unitariamente y sin coste.
# 必填项:按字段类型选规范化器
normalized = {
"email": lambda v: v.lower(), # 逐字拷贝 + 小写
"phone": lambda v: phonenumbers.format_number( # 读国家 + E.164
phonenumbers.parse(v, region["choice"]),
phonenumbers.PhoneNumberFormat.E164),
"amount": lambda v: Decimal(re.sub(r"[^\d.]", "", v)), # $1,315.50 -> 1315.50
"date": assemble, # 部件 -> date,见第 3 步
}
# 选填项:credit/charge 用一道 Noul 定符号——P(credit) > 0.5 是 credit,贴着 0.5 转人工?
# 输出规范:值 + provenance(来自哪个候选/哪些部件)+ confidence + needs_review
# 约束条件:
# ✅ 规范化只处理「选中的那个字符串」,绝不重新生成
# ✅ 复核线(日期 0.60 起步)按风险调:进账单的金额从严,进统计报表的可松
# ❌ 别假设逗号一定是千分位——欧式格式 €1.315,50 正相反,先问一道 Noul「这份文档用逗号当小数点吗」再分支Punto de control ✅
- Los pasos 5 y 6 reproducen sin Key todas las cifras oficiales: receipt 0.97 / sender 1.00 / E.164
+14155550177/ total P(credit)=0.03 / credit P(credit)=0.98 - Puedo decir qué lee cada una de las siete preguntas de fecha, y que
modedecide cuáles componentes lee el código - Sé que el confidence de la fecha es el más débil de los componentes usados; por debajo de 0.60 se envía a revisión humana; una fecha que el documento no menciona se reporta como
none+ note, en lugar de inventar una - Puedo explicar por qué
pickno puede inventar valores ni transcribirlos con dígitos intercambiados: las opciones son los propios candidatos y la respuesta es una copia literal - Conozco los dos límites: Choice admite como máximo 255 opciones (si se supera, se selecciona en dos rondas); para valores como los nombres de persona, sin buena regex, los candidatos deben venir de un roster, de NER o de propuestas de un LLM
Avisos de errores comunes
❌ Pedir al LLM que «vuelva a teclear» el valor
La extracción directa con LLM consiste, en esencia, en pedirle que vuelva a teclear $1,315.50 — transcribir un dígito cambiado de posición ($1,351.50) o inventar un valor que no está en el documento: todo ocurre en ese paso de «regeneración». El método oficial de tres pasos elimina ese paso por completo: la regex encuentra los candidatos → Jev elige entre ellos → el código copia literalmente y normaliza. La frase más contundente de la documentación oficial: TypeSafe solo elige entre los candidatos encontrados por la regex, así que no puede inventar un valor ni transcribir mal los dígitos.
❌ Ajustar la regex demasiado estricta y dejar el valor real fuera de los candidatos
Las opciones de pick son exactamente los candidatos que le das — lo que no esté entre los candidatos, por listo que sea, no puede elegirlo. La documentación oficial define la tarea del primer paso como recall: al ajustar la regex, mejor capturar de más (que de paso atrape números de pedido, de fax, subtotales, no pasa nada, Jev los descartará) que dejar escapar el valor real. El coste de capturar de más son unas opciones extra en una solicitud; el coste de no capturar es que ese registro quede mal para siempre.
❌ Contar con que la caché de fechas se reproduzca sin Key
El json_cache.json de fechas publicado en el repositorio oficial no coincide con las claves de caché del código actual de la documentación (probado en esta página: las seis llamadas dieron miss, el SDK hizo solicitudes reales, y sin Key devolvió 401) — lo más probable es que la firma de las funciones al grabar no esté sincronizada con el código vigente. Para la parte de fechas, define TYPESAFE_API_KEY y corre con tu propia caché; al comparar con las cifras oficiales, guíate por el marcador transcrito en esta página. La caché oficial de extracción de valores no se ve afectada: se reproduce literalmente, según lo probado.
❌ Aplicar to_decimal a cualquier importe y, ante documentos en chino, lanzarlo directamente
Ambas cosas son fáciles de fracasar. Primera: Decimal(re.sub(r"[^\d.]", "", value)) asume que «coma = separador de miles, punto = decimal» — cierto para $1,315.50, justo lo contrario para €1.315,50; la recomendación oficial es preguntar primero a Noul «¿este documento usa la coma como separador decimal?» y ramificar según la respuesta. Segunda: la documentación oficial indica que Jev se entrenó principalmente en inglés, y que otros idiomas (incluido el chino) funcionan pero con menor precisión — antes de poner en producción contratos y facturas en chino, corre un lote con tus propios documentos y mira la distribución de probabilidades; la explicación del soporte de idiomas está en modelos y precios.
Técnicas avanzadas (opcional)
**¿La lista de años es demasiado larga? Prefiltra primero. ** El year de 1900–2050 tiene 151 opciones, y la propia documentación oficial dice «si esto te molesta, extrae primero del texto los números que parecen años y da solo esos como opciones al modelo» — con una ventana de candidatos más pequeña, la pregunta queda más enfocada. Es la misma idea del paso 5: la generación de candidatos que pueda hacer el código, no se le encarga al modelo.
**Más de 255 candidatos: selecciona en dos rondas. ** La estrategia oficial: elegir primero el bloque (qué párrafo / qué tabla), y luego el span dentro del bloque — cada pregunta Choice se queda por debajo de 255. La búsqueda línea a línea de búsqueda y coincidencia muestra justamente la primera ronda: etiqueta cada línea con un ID y hace que Choice apunte a la línea que coincide.
**Los nombres de persona no tienen buena regex. ** La documentación oficial lo dice claramente: encontrar candidatos es la parte laboriosa — correos, teléfonos e importes tienen regexes listas, los nombres no. Los candidatos pueden venir de un roster que ya tengas (sistema de RR. HH., lista de clientes), o de propuestas de NER / LLM; Jev se encarga de la elección final.
Juega gratis con el ejemplo oficial. Al final de la página oficial del cookbook hay enlaces listos para compartir al Playground — la pregunta pick del cuerpo del correo + cuatro direcciones candidatas; al abrirla (https://console.typesafe.ai/playground) puedes cambiar la redacción y ver la distribución de probabilidades en el navegador. Para generar tu propio enlace:
from cooksafe import make_playground_link
link = make_playground_link(EMAIL_DOC, {
"receipt": Choice(
instructions="Which email address does the sender want their receipt sent to?",
criteria={c: None for c in emails} | {"none": "None of these is the requested value."},
),
})
print(link) # 链接里带着完整 state 和问题,别放敏感数据Intégralo en tu flujo de documentos. Las preguntas son fijas, solo se cambia el state——sustituye EMAIL_DOC por el cuerpo del correo que hayas parseado y MONEY_DOC por el texto de la factura obtenido por OCR; las siete preguntas de fecha y las tres de valor se reutilizan tal cual. La composición de las claves de caché difiere en ambos lados; tenerlo claro ahorra mucho tiempo de depuración: la clave de la parte de valores incluye documento, candidatos y pregunta (todos los parámetros de pick / classify / is_true)——cambiar el documento, la regex o la pregunta provoca un miss y una solicitud real automática; la clave de la parte de fechas solo incluye documento y role——modificar las preguntas dentro de date_questions no provoca un miss (las preguntas están en el cuerpo de la función, y la documentación de cooksafe dice explícitamente que modificar el cuerpo de la función no invalida la caché), se devuelven las respuestas antiguas; si quieres una ejecución real tras cambiar las preguntas, elimina date_cache.json. Si el volumen de extracción crece, mira la extracción en cascada: el modelo barato hace primero el trabajo grueso y Jev solo verifica campo por campo.
Resumen de esta lección
✅ Jev extracción de información, así se resuelven las fechas: siete Choice en una sola solicitud leen forma y componentes; la matemática de calendario (completar el año, resolver «el próximo jueves», validación del 30 de 2) está toda en assemble(); confidence = el más débil de los componentes usados, por debajo de 0.60 se envía a revisión manual.
✅ valor = candidatos por regex + selección con Jev + copia literal: find se encarga del recall, pick de la selección (las opciones son los candidatos; la respuesta solo puede ser una copia del texto original o none), y el código de la normalización——sin inventar ni transcribir con desplazamientos.
✅ los tres tipos de valor quedan normalizados: correos en minúsculas 0.97 / 1.00, teléfonos en E.164 +14155550177 (el país se lee con classify), importes con Decimal más el signo credit/charge (Noul 0.03 / 0.98).
✅ reproducción con las cifras oficiales y sin Key: en la parte de valores, la caché oficial se reproduce literalmente según pruebas reales; en la parte de fechas, las claves de caché no coincidieron en las pruebas, así que se ejecuta en vivo con caché propia (6 solicitudes); el marcador se rige por la grabación oficial.
Repaso de los campos de configuración clave:
| Campo | Valor en esta página | Descripción |
|---|---|---|
DATE_MODEL / VALUE_MODEL | jev-1.14.0 | grabación oficial: fechas jev-1.12, valores jev-1.14.0; en la ejecución en vivo fija tu propio ID de versión, no uses jev-latest que deriva |
TODAY | date(2026, 7, 30) | fija «hoy» para que las fechas relativas sean reproducibles; si lo ejecutas tú, cambia a date.today() o, antes de ejecutar el lote, fija de forma uniforme |
REVIEW_BELOW | 0.60 | umbral de revisión de la confidence de fechas; ajusta el nivel según el riesgo |
YEAR_WINDOW | 1900–2050 + none / out_of_range | la ventana de opciones de año añade dos salidas de emergencia |
| Las tres regex | EMAIL_RE / PHONE_RE / MONEY_RE | prioridad de recall; deduplicación de candidatos y orden por documento |
| límite de opciones de Choice | 255 | si se supera, primero elige el bloque y luego el span (ver C4) |
| solicitudes por documento | fechas 1 vez (siete preguntas en paralelo); cada valor 1–3 veces (pick / classify / is_true) | todo pasa por caché; solo hay miss al cambiar documento o preguntas |
Tutoriales relacionados:
- extracción en cascada: el modelo barato trabaja, Jev verifica, el modelo caro hace de red de seguridad——la versión industrializada del pipeline de esta página: cómo ahorrarse el razonamiento campo por campo del modelo grande cuando hay muchos campos
- búsqueda y matching: reordenamiento, búsqueda línea por línea, alineación de entidades——práctica de la contracción en dos etapas cuando los candidatos superan 255, búsqueda semántica línea por línea en documentos de 218 líneas
- Confidence——el principio de esta línea de revisión 0.60 y el uso en tres niveles «alta = ejecución automática / media = marcar / baja = pasar a humano»
Avance de la próxima lección
Con los campos extraídos, la siguiente pregunta es qué hacer con el texto al que se le quitó el formato. Próxima lección: recuperación de estructura: reconstruir Markdown a partir de texto plano.
Aprenderás:
- dos solicitudes para restaurar a Markdown el texto plano que perdió el formato: en la primera, un Noul por cada par de líneas adyacentes reensambla las frases cortadas por saltos de línea duros; en la segunda, un Choice por cada bloque lo clasifica en título / párrafo / lista / cita / código / cuadro de aviso
- por qué cada carácter de la salida proviene de la entrada——el modelo solo juzga, todo el renderizado es código; un modelo que reescriba el texto cambiará tus palabras
- la misma división de tareas que en esta página: el modelo lee el texto, el código trabaja; solo que esta vez lo que se recupera no son valores sino estructura