vortx-ai/emem/emem-document-evidence

emem-document-evidence

Network use. The commands in this skill send JSON to https://emem.dev and receive JSON from it. https://emem.dev is the service that the MCP server of the plugin connects to. The commands do not execute what they download. The files under scripts/ read local files and make no network calls.

Each call signs its output. A hash chains each call to the call before it:

The responder does not store the document or the result. Each receipt is complete in itself. The verifier in step 3 needs only the response, and the document if you have it.

Limits

These limits come from crates/emem-api-rest/src/reader.rs. A responder operator can change the two quotas.

Step 1: run OCR on the image

Build the request body from the image:

base64 -w0 report.png | jq -Rs '{image_b64: ., lang: "eng"}' > ocr_req.json

The body has this shape:

{"image_b64": "<the base64 of report.png>", "lang": "eng"}

Send ocr_req.json as the body of POST https://emem.dev/v1/ocr. Through MCP, call emem_ocr with the same object as its arguments. emem_ocr is not in the short tool list of the plugin. The server runs it by name through tools/call. Save the answer as ocr.json. Then read it:

jq '{engine, lang, image_blake3_b32, text_blake3_b32, provenance_class}' ocr.json
jq -r .text ocr.json

You can send "url" instead of "image_b64". Send one of the two, not both. lang takes Tesseract language codes. Join two or more with +, for example eng+hin+mar. The default is eng.

Read the text before you trust a field parsed from it. The OCR receipt proves which image and engine produced the text. It does not prove that the reading is correct.

Step 2: parse the text

Each parse route takes one of these inputs:

The parse routes have no MCP tool. Use REST. To parse the OCR result from step 1:

jq '{ocr: .}' ocr.json > parse_req.json

Send parse_req.json as the body of POST https://emem.dev/v1/lab_report_parse. Save the answer as lab.json. Then read it:

jq '{verdict: .result.verdict, exceedances: .result.exceedances, sample_id: .result.sample_id.value,
     rows: [.result.rows[] | {analyte, raw: .result.raw, kind: .result.kind, result_mg_kg,
                              mrl_mg_kg, exceeds_printed_mrl, line_no}]}' lab.json

To parse your own text and compare each row with the EU MRL in force, add product:

jq -Rs '{text: ., product: "rice"}' report.txt > text_req.json

The body has this shape:

{"text": "<the text of report.txt>", "product": "rice"}

Send text_req.json as the body of POST https://emem.dev/v1/lab_report_parse. Save the answer as lab_text.json. Then read it:

jq '{verdict: .result.verdict, lookup: .result.eu_mrl_lookup.status,
     rows: [.result.rows[] | {analyte, result_mg_kg, eu_mrl: .eu_mrl.display, exceeds: .eu_mrl.exceeds}]}' lab_text.json

For a land record, send the same body to POST https://emem.dev/v1/land_record_parse. When the parse runs OCR for a land record, the default language is eng+hin+mar.

Lab report fields

Without product, the parser compares each result only with the MRL that the report prints. With product, the responder reads the MRLs in force from the EU Pesticides Database (DG SANTE, Regulation (EC) No 396/2005). Then it adds eu_mrl to each matched row. The reading text in the response still says that the parser does not check the EU MRL database. That text is out of date for a call with product.

Land record fields

The parser converts acres, gunthas and a three-part 7/12 area such as 1.20.50 (read as ha.are.m2) to hectares. It reports bigha raw, because the size of a bigha changes from place to place. It reads text in the Indian scripts, Portuguese, Spanish, French and Indonesian.

Each extracted value carries line, line_no and byte_offset. Use line to quote the exact line. line_no counts from 0.

Step 3: verify offline

scripts/verify_doc.py ships with this skill. Claude Code sets ${CLAUDE_SKILL_DIR}. The script makes no network calls. It gets BLAKE3 and Ed25519 from scripts/emem_crypto.py, which also ships with this skill. Both are plain Python with no third-party packages.

python3 "${CLAUDE_SKILL_DIR}/scripts/verify_doc.py" --self-test
python3 "${CLAUDE_SKILL_DIR}/scripts/verify_doc.py" ocr.json report.png
python3 "${CLAUDE_SKILL_DIR}/scripts/verify_doc.py" lab.json
python3 "${CLAUDE_SKILL_DIR}/scripts/verify_doc.py" lab_text.json report.txt

The second argument is optional. For an OCR response it is the image. For a parse response it is the text file.

A failed check prints MISMATCH or INVALID. The exit code is 0 when every check passed, 1 when a check failed, and 2 for bad input.

The script checks the signature with the key in the response. Compare the signer that it prints with the published key of the responder:

curl -sf https://emem.dev/.well-known/emem.json

Read responder.pubkey_b32 in the answer.

On 7 November 2026 this returned 777er3yihgifqmv5hmc2wwmyszgddzderzhsx6rex4yoakwomvka.

Example run on 7 November 2026

The test image was a rendered residue report with three analytes and a printed MRL of 0.01 mg/kg. It also had Test Report No: ER/2026/0912 and Sample ID: BAS-RICE-044. The text in report.txt was the same.

Both paths gave sample_id BAS-RICE-044. A run on 28 September 2026 gave the report number there. The parser no longer makes that mistake.

The OCR path shows the purpose of this skill. The chain proved exactly which image and text gave the answer. It did not make the reading correct. When a verdict depends on a column, find that column in the OCR text.

After the run, a test changed one result value in lab_text.json. The script then printed result MISMATCH and exited with 1.

Errors

The error body has schema: "emem.error.v1". The top-level code is invalid_argument for the 400 and 422 rows, and source_fetch_failed for the 502 rows. Read the specific code in details.code.