ต้นแบบ · รุ่นทดลอง: มีทุก server ในทะเบียนทางการ อัปเดตทุก 30 นาที เข้าสู่ระบบด้วย Google เพื่อเขียนรีวิวได้แล้ว
PopNx MCPที่รวม MCP สำหรับคนใช้ AI · วิธีติดตั้งภาษาไทยทุกตัว

Valem

โดย vlad-public-codeรุ่น 1.0.0i★ 0iรันบนคลาวด์
ชื่อใน registryio.github.vlad-public-code/valem

วิธีติดตั้ง

ใช้ทำอะไรได้

ยังไม่มีคำอธิบายภาษาไทย ดูข้อเท็จจริงด้านล่าง หรือเปิดคำอธิบายต้นฉบับจากผู้ทำ

  • ต่อแบบ คลาวด์ (ต่อผ่านอินเทอร์เน็ต)
  • บัญชีหรือคีย์ ไม่ต้องใส่คีย์
  • หมวด เอกสาร ตาราง และงานออฟฟิศ
คำอธิบายต้นฉบับจากผู้ทำ (อังกฤษ)
Valem - Deterministic reactive state models. Create your own calculators/forms with AI

ติดตั้ง

เลือกโปรแกรม AI ที่คุณใช้ แล้วคัดลอกค่าตั้งไปวาง

ผลตรวจผ่าน 5/5 · สิ่งที่คุณถามผ่านเซิร์ฟเวอร์ของผู้ทำ (valem.run)

ขั้นแรก: คุณใช้ AI ตัวไหน

เลือกแอปที่คุณใช้ ขั้นตอนจะขึ้นด้านล่าง

ต่อกับ Claude ได้ · ประมาณ 2 นาที

ไม่ต้องใช้คีย์ ไม่ต้องลงโปรแกรม · ตั้งครั้งเดียวที่ claude.ai หรือแอปบนคอม แล้วใช้ในแชตได้ · บัญชีฟรีเพิ่มได้ 1 ตัว · แผน Team/Enterprise ให้เจ้าของ (Owner) เป็นคนเพิ่ม

  1. เปิดหน้า Connectors ของ Claude

    CustomizeConnectors

    CustomizeConnectors1+ Add2https://…3Add4
  2. กด “+ Add” → “Add custom connector” แล้วกรอก 2 ช่องนี้

    คัดลอกจากที่นี่ไปวางในช่องชื่อเดียวกันบนหน้าจอของ Claude แล้วกด Continue

    Name · ชื่อValem
    Remote MCP server URL · ที่อยู่https://valem.run/mcp

    หัวข้อ Authentication ปล่อยตามที่ Claude ตรวจเจอ แล้วกด Add

  3. เปิดใช้ในแชต

    +ConnectorsValem

  4. ลองเลย

    ใช้ Valem บอกหน่อยว่าทำอะไรให้ฉันได้บ้าง แล้วลองทำให้ดูหนึ่งอย่าง

    ✓ ถ้า Claude บอกว่ากำลังใช้ Valem หรือมีชื่อเครื่องมือของ Valem ขึ้นในคำตอบ แปลว่าต่อสำเร็จ

ชื่อเมนูตรวจกับหน้าช่วยเหลือของ Anthropic เมื่อ 11 พ.ย. 2569 · หน้าจอของคุณอาจต่างเล็กน้อยตามรุ่นของแอป

ต่อกับ ChatGPT ได้ เฉพาะแผนองค์กร

ใช้ได้กับ ChatGPT Business, Enterprise หรือ Edu บนเว็บ และแอดมินหรือเจ้าของ workspace ต้องเป็นคนเพิ่ม · ถ้าใช้ Free, Plus หรือ Pro: ChatGPT แผนของคุณยังต่อ MCP เองไม่ได้

  1. เปิดหน้าเพิ่ม MCP ของ ChatGPT บนเว็บ

    Plugins+Add custom MCP server

    ChatGPTPlugins1+2https://…3Create4
  2. กรอกชื่อและที่อยู่

    ใส่ชื่อ แล้ววางที่อยู่ใต้ Connection ติ๊กยอมรับคำเตือน แล้วกด Create as a plugin

    Name · ชื่อValem
    Connection · ที่อยู่https://valem.run/mcp
  3. เลือก Valem ในแชต

    เปิดแชตใหม่แล้วเลือก Valem จากรายการปลั๊กอินก่อนพิมพ์

  4. ลองเลย

    ใช้ Valem บอกหน่อยว่าทำอะไรให้ฉันได้บ้าง แล้วลองทำให้ดูหนึ่งอย่าง

    ✓ ถ้า ChatGPT บอกว่ากำลังใช้ Valem หรือมีชื่อเครื่องมือของ Valem ขึ้นในคำตอบ แปลว่าต่อสำเร็จ

ชื่อเมนูตรวจกับหน้าช่วยเหลือของ OpenAI เมื่อ 11 พ.ย. 2569 · หน้าจอของคุณอาจต่างเล็กน้อยตามรุ่นของแอป

ต่อกับ Claude Code ได้ · ประมาณ 2 นาที

ไม่ต้องใช้คีย์ ไม่ต้องลงโปรแกรม

  1. เปิด Terminal

    Mac: กด Command+Space พิมพ์ Terminal · Windows: เปิด PowerShell

  2. วางคำสั่งนี้แล้วกด Enter

    claude mcp add --transport http --scope user valem https://valem.run/mcp
  3. พิมพ์ /mcp ใน Claude Code

    ต้องเห็น Valem ในรายการและขึ้นว่าเชื่อมต่อแล้ว

  4. ลองเลย

    ใช้ Valem บอกหน่อยว่าทำอะไรให้ฉันได้บ้าง แล้วลองทำให้ดูหนึ่งอย่าง

    ✓ ถ้า Claude Code บอกว่ากำลังใช้ Valem หรือมีชื่อเครื่องมือของ Valem ขึ้นในคำตอบ แปลว่าต่อสำเร็จ

ชื่อเมนูตรวจกับหน้าช่วยเหลือของ Anthropic เมื่อ 11 พ.ย. 2569 · หน้าจอของคุณอาจต่างเล็กน้อยตามรุ่นของแอป

ต่อกับ Cursor ได้ · ประมาณ 2 นาที

ไม่ต้องใช้คีย์ ไม่ต้องลงโปรแกรม

  1. กดปุ่มนี้เพื่อเปิด Cursor

    เปิดใน Cursor

    Cursor จะถามยืนยันการติดตั้ง ให้กด Install

  2. เปิดแชตของ AI ใน Cursor โหมด Agent

  3. ลองเลย

    ใช้ Valem บอกหน่อยว่าทำอะไรให้ฉันได้บ้าง แล้วลองทำให้ดูหนึ่งอย่าง

    ✓ ถ้า Cursor บอกว่ากำลังใช้ Valem หรือมีชื่อเครื่องมือของ Valem ขึ้นในคำตอบ แปลว่าต่อสำเร็จ

ชื่อเมนูตรวจกับหน้าช่วยเหลือของ Cursor เมื่อ 11 พ.ย. 2569 · หน้าจอของคุณอาจต่างเล็กน้อยตามรุ่นของแอป

ต่อกับ VS Code ได้ · ประมาณ 2 นาที

ไม่ต้องใช้คีย์ ไม่ต้องลงโปรแกรม

  1. กดปุ่มนี้เพื่อเปิด VS Code

    เปิดใน VS Code

    VS Code จะถามยืนยันการติดตั้ง ให้กด Install

  2. เปิดแชตของ AI ใน VS Code โหมด Agent

  3. ลองเลย

    ใช้ Valem บอกหน่อยว่าทำอะไรให้ฉันได้บ้าง แล้วลองทำให้ดูหนึ่งอย่าง

    ✓ ถ้า VS Code บอกว่ากำลังใช้ Valem หรือมีชื่อเครื่องมือของ Valem ขึ้นในคำตอบ แปลว่าต่อสำเร็จ

ชื่อเมนูตรวจกับหน้าช่วยเหลือของ VS Code เมื่อ 11 พ.ย. 2569 · หน้าจอของคุณอาจต่างเล็กน้อยตามรุ่นของแอป

โปรแกรมอื่นที่ใช้ MCP ได้ เช่น Windsurf, Zed หรือ Gemini CLI มีวิธีเพิ่มต่างกัน ดูวิธีของแต่ละตัวในหน้ารวมโปรแกรม

ดูโปรแกรมที่ใช้ MCP ทั้งหมด →

ที่อยู่สำหรับโปรแกรมที่ต่อผ่านเว็บ

ที่อยู่https://valem.run/mcp

ค่าตั้งแบบไฟล์ JSON อยู่ในหัวข้อ “สำหรับคนเขียนโค้ด” ด้านล่าง

ติดตรงไหน? ถามคนที่ใช้ Valem อยู่💬 พูดคุย →
สำหรับคนเขียนโค้ด: คำสั่ง Terminal และค่าตั้ง JSON

ต่อผ่านเว็บ

Claude Code

claude mcp add --transport http --scope user valem https://valem.run/mcp

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "valem": {
      "url": "https://valem.run/mcp"
    }
  }
}

VS Code (mcp.json)

{
  "servers": {
    "valem": {
      "type": "http",
      "url": "https://valem.run/mcp"
    }
  }
}

ค่าตั้งนี้สร้างจากข้อมูลใน registry ของผู้ทำ ถ้าไม่ตรงกับ README ให้เชื่อ README

สรุป

ดาวน์โหลดต่อสัปดาห์i
ไม่มียอดใน npm/PyPI
licensei
Apache-2.0
การเชื่อมต่อ
รันบนคลาวด์
รุ่นล่าสุดi
1.0.0
ส่งเข้า registryi
22 ส.ค. 2569
แก้โค้ดล่าสุดi
2 พ.ย. 2569
ผู้ทำ
vlad-public-code
เว็บผู้ทำ
valem.run
สถานะใน registry
ใช้งานอยู่

ใช้กับโปรแกรมไหนได้

ดูจากแบบการต่อของ server ตัวนี้ และเอกสารของผู้ทำโปรแกรมแต่ละตัว ตรวจเมื่อ 10 พ.ย. 2569

ต่อผ่านคลาวด์ได้ใน

ClaudeChatGPTGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatOpen WebUIRaycast

ดูโปรแกรมทั้งหมดพร้อมข้อดีข้อเสีย →

คู่มือที่เกี่ยวข้อง

ทำอะไรได้บ้าง

ชื่อและคำอธิบายเครื่องมือตามที่ server ตอบมาเมื่อ 10 พ.ย. 2569 ผู้ทำเป็นคนเขียน ไม่ใช่เรา แสดงเป็นข้อความล้วน

  • list_models

    List the ids of all currently registered Valem models (alphabetical).

  • create_model

    Create a new model from a declarative ModelSpec. The spec carries the JSON schema plus derivations (computed fields), constraints (invariants), and optional effects. Returns the created id. Fails (isError) on an invalid spec. If the requested id is already taken, a numeric postfi

  • get_model_info

    Get summary info for a model: id, version, and derivation/meta/constraint/effect counts.

  • get_spec

    Get the full stored ModelSpec JSON for a model.

  • get_library

    List the JSONata functions and values a model's library exports — what an expression in this model may call, with signature, arity and originating layer. Call it before writing an expression so you reuse the model's existing vocabulary instead of re-deriving it. Returns null when

  • get_state

    Get a model's merged state (base fields plus all computed derived fields). On a large model this is the biggest context cost — narrow it: pass 'paths' to project only specific subtrees (canonical addresses, each spliced back into a pruned document at its address), and/or 'depth'

  • get_field

    Get the value of a single field by its JSON Path address (e.g. "$.order.total"). Evaluates a LAZY derivation on demand.

  • mutate

    Apply field mutations to a model and run the reactive pipeline (derivations recompute, constraints enforce, effects dispatch). 'mutations' is a flat map keyed by canonical JSON Path address, e.g. {"$.order.qty": 3}. A ROLLBACK constraint violation returns isError with the structu

  • patch_model

    Apply an RFC 6902 JSON Patch document to a model and run the reactive pipeline. Unlike 'mutate' (a flat address→value map), a patch expresses array insert/remove/move and test/copy ops, e.g. [{"op":"add","path":"/order/items/-","value":{...}}, {"op":"remove","path":"/order/items/

  • get_effective_schema

    Get the effective JSON Schema for a field: the static schema overlaid with LIVE meta-derived constraints (current min/max/required/…). Check this BEFORE writing a value to learn what the reactive pipeline will accept, instead of discovering an invalid mutation only by trying it a

  • snapshot

    Capture an immutable point-in-time snapshot of a model's state (base document + derived/meta caches). A natural safety step before a risky evolve_spec: keep the returned snapshot and, if the change goes wrong, hand it back to 'restore' to roll the state back.

  • restore

    Restore a model's state from a snapshot previously returned by 'snapshot' (pass it back verbatim as 'snapshot'). Overwrites the model's current base state. The snapshot must be for the same model.

  • explain

    Explain why a field is what it is: returns the recent derivation/constraint trace records for a path from the in-memory ring buffer (inputs, expression, result). For a constraint use the synthetic path "$constraint: ". Trace records can be bulky — pass 'limit' to return only the

  • get_history

    List the ISO-8601 timestamps of a model's committed mutations (most recent 100).

  • get_audit

    Query a model's durable, append-only audit trail (newest-first): one record per committed reactive cycle (mutations, derivedUpdated, traces, flaggedConstraints, dispatchedEffects, source, sequence). This is the queryable superset of get_history/explain — it survives the in-memory

  • verify_audit

    Verify the tamper-evidence hash chain of a model's durable audit trail. Returns {valid, recordsChecked, firstBrokenSequence, detail}; a false 'valid' points at the first altered/reordered/deleted record. (Embedded mode has no hash chain and reports valid.)

  • upload_blob

    Store binary content (base64-encoded in 'data') in the content-addressed blob store and get back a BlobRef {$blobId, $mediaType, $bytes} to embed in a model's binary field. Storage is content-addressed (SHA-256), so uploading identical bytes returns the same $blobId.

  • download_blob

    Fetch a blob's bytes by id, base64-encoded in the result. Pass 'modelId' to fetch a blob referenced by a specific model (access-scoped); omit it for a direct store fetch. Large blobs may exceed the result-size limit — this channel suits small binaries only.

  • evolve_spec

    Apply an incremental SpecEvolution diff to a model, preserving live state. Returns the new version. Fails (isError) if the evolved spec is invalid, if expectedVersion no longer matches, or if a schema change would strand existing state. Prefer targeted diffs (upsertSchemaNodes/up

  • delete_model

    Remove a model from the registry. Fails (isError) if the model does not exist.

  • get_view

    Evaluate a model's embedded view definition against current state and return the resolved component tree. Pass an optional 'viewId' for a named view; omit for the default view.

  • get_domain_guidance

    Get vetted instructions for the hard modelling shapes this domain involves (progressive tax/fee charges, per-period schedules, classification, date math, group-by, …). Read the model description in ANY language, pick the matching topic ids, and call this BEFORE authoring the spec

  • validate_spec

    Validate a ModelSpec WITHOUT creating it: returns a 'valid' flag plus structured findings (errors + warnings, each with a location and message). Use this to iterate on a draft — fix the reported errors, re-validate — before committing with create_model.

  • eval_expression

    Evaluate a single JSONata expression against a sample input document and return the computed value, or the exact compile/eval error. Write the expr exactly as in a derivation/constraint 'expr': bare dot-paths, no leading $ (e.g. "loan.amount * loan.annualRate / 1200"). Use this t

  • test_spec

    Run a spec's embedded test cases (or ad-hoc given->expect cases) through the real reactive pipeline in a throwaway runtime, returning pass/fail plus per-field failures (path, expected, actual). Use this to certify domain behavior before create_model / promotion.

  • dry_run

    Compile a candidate ModelSpec in an ISOLATED throwaway runtime, apply optional sample mutations, and return the resulting merged state (base + derived) — WITHOUT registering it in the live registry. Use this to preview the full reactive cascade of a draft spec.

  • convert_spreadsheet

    Compile an uploaded .xlsx workbook's OWN formulas into a ready ModelSpec — deterministic transpilation (Excel formula language -> JSONata), never an LLM call: every number the compiled spec computes is checked to exactly match what the source workbook itself computed. One workshe

  • search_document

    Deterministic, LLM-free search over an uploaded PDF/DOCX: ranks the document's pages/sections against your query (term-overlap, no embedding model, no network call) and returns the top matches with page/section citations and verbatim quotes. Cost is bounded by topK, never by docu

  • pair_browser

    Pair this MCP session with a browser tab on the hosted Valem sandbox so both drive the same live model session. Mints a pairing on first call (or resumes an existing not-yet-approved one) and waits up to a minute for the developer to approve it. Returns {status:"paired"|"already_

  • valem_spec_guide

    How to write a Valem ModelSpec that render_model accepts: sections, path notation, JSONata rules, view components and common mistakes. Call this once before writing your first spec in a conversation.

  • render_model

    Show the user a Valem model as an interactive card they can edit in the chat: a form whose computed fields update on every change, checked by a deterministic engine. Use it when the user asks for a calculator, quote, budget, planner, pricing or any model with inputs and computed

  • explain_value

    Explain how a value in a Valem card was computed: the formula, the values it read and the inputs it ultimately comes from, as Valem's engine has them for the given inputs. Use it when the user asks why a number is what it is. Pass the specHash and current inputs from the latest r

  • valem_recompute

    Called by the Valem card when the user edits an input. Not for direct use: call render_model instead.

  • show_model

    Show the user one of this server's models (created with create_model) as an interactive card in the chat. Every edit the user makes in the card is a mutate on the model, so get_state and explain see it. Use it after create_model or evolve_spec when the user should see or try the

  • valem_card_edit

    Called by the Valem card when the user edits a stored model. Not for direct use: call mutate instead.

ผลตรวจเบื้องต้นi

เราตรวจจากข้อมูลที่ใครก็เปิดดูได้ ยังไม่ได้อ่านโค้ด ข้อที่ไม่เกี่ยวกับตัวนี้ไม่นับในตัวหาร · ตรวจเมื่อ 12 พ.ย. 2569

  • ✓ ผ่าน

    ตัวตนผู้ทำตรงกับ repo

    ชื่อใน registry ยืนยันด้วยบัญชี GitHub vlad-public-code ซึ่งเป็นเจ้าของ repo

  • ✓ ผ่าน

    ยังมีคนดูแล

    มีการแก้โค้ดล่าสุด 10 วันที่ผ่านมา

  • ✓ ผ่าน

    มีสัญญาอนุญาต (license)

    ใช้ Apache-2.0

  • ✓ ผ่าน

    endpoint ตอบ

    ตอบกลับใน 178 ms (HTTP 200)

  • – ไม่เกี่ยว

    ล็อกอินแบบ OAuth

    ไม่ต้องล็อกอิน

  • ✓ ผ่าน

    คำอธิบายเครื่องมือไม่มีคำสั่งแอบแฝง

    อ่านคำอธิบายเครื่องมือ 35 ตัวแล้ว ไม่พบคำสั่งแอบแฝงถึง AI

พูดคุย

ถาม แชร์เคล็ดลับ หรือแจ้งว่าใช้ไม่ได้ เรียงตามที่คนกดว่ามีประโยชน์

ยังไม่มีใครโพสต์ ถามหรือแชร์เป็นคนแรกได้เลย

ข้อความในส่วนนี้เขียนโดยผู้ใช้ ไม่ใช่ทีม PopNx

เข้าสู่ระบบด้วย Google เพื่อโพสต์

รีวิวจากผู้ใช้

ยังไม่มีรีวิว

เข้าสู่ระบบด้วย Google เพื่อเขียนรีวิว

เทียบกับตัวอื่นในหมวด เอกสาร ตาราง และงานออฟฟิศi

  • ดาวมากกว่า 0% ของอีก 3795 ตัวในหมวดนี้
  • ส่งรุ่นใหม่เข้า registry ล่าสุดกว่า 26% ของอีก 3795 ตัวในหมวดนี้
  • ผลตรวจเบื้องต้นดีกว่าหรือเท่ากับ 100% ของอีก 3795 ตัวในหมวดนี้

เทียบกับทุก server ที่ยังใช้งานในหมวดนี้ทั้งทะเบียน ดาวนับเฉพาะเมื่อผู้ลงทะเบียนเป็นเจ้าของ repo

คำถามที่พบบ่อย

Valem ปลอดภัยไหม?

จากการตรวจเบื้องต้นของเรา ผ่าน 5 จาก 5 ข้อที่ตรวจได้ เรายังไม่ได้อ่านโค้ด ก่อนใส่กุญแจหรือ token ให้ดูว่า server ขอสิทธิ์อะไร และเลือกกุญแจที่ทำได้เท่าที่จำเป็น

ต้องใช้กุญแจหรือรหัสอะไรบ้าง?

registry ไม่ได้ระบุว่าต้องใช้กุญแจ แต่บางตัวจะขอให้ล็อกอินตอนใช้ครั้งแรก

ตัวนี้รันบนเครื่องหรือบนคลาวด์?

รันบนคลาวด์ของผู้ทำ ต่อผ่านอินเทอร์เน็ตได้เลย ไม่ต้องลงโปรแกรม แต่ข้อมูลที่ส่งให้จะผ่านเซิร์ฟเวอร์ของผู้ทำ

ยังมีคนดูแลอยู่ไหม?

repo บน GitHub มีการแก้โค้ดล่าสุด 10 วันที่ผ่านมา และส่งรุ่นล่าสุด (1.0.0) เข้า registry 3 เดือนที่ผ่านมา

ใช้กับโปรแกรมไหนได้บ้าง?

โปรแกรมที่รองรับ MCP เช่น Claude Desktop, Claude Code, Cursor และ VS Code ตัวนี้ต่อผ่าน URL จึงใช้กับโปรแกรมที่รับ remote MCP ได้ เช่น ChatGPT แผน Business ขึ้นไป

มีตัวไหนใช้แทนได้บ้าง?

ในหมวดเดียวกันมี Puter MCP, XcodeBuildMCP, XcodeBuildMCP

ตัวอื่นในหมวดเดียวกัน

server หมวดเดียวกันจากผู้ทำคนอื่น เรียงตามดาว

อ่านการ์ด:↓ ดาวน์โหลดต่อสัปดาห์i★ ดาว GitHubiสามเสา: รีวิว · ผลตรวจ · การใช้งานiอัปเดต = วันที่ส่งรุ่นล่าสุดเข้า registryi

Puter MCP

Puter MCP enables AI tools to interact with Puter: manage files, websites, workers, and more

โดย HeyPuterใช้กันมาก★ 44.1Kอัปเดต 5 เดือนที่ผ่านมา

รันบนคลาวด์✓ เจ้าของบริการ · puter.com

XcodeBuildMCP

ให้ AI จัดการโปรเจกต์ Xcode สั่ง build และใช้ iOS Simulator

โดย getsentryใช้กันมาก↓ 130.5K/สัปดาห์ ยอดของแพ็กเกจที่ใช้ร่วม★ 6.6Kอัปเดต 4 เดือนที่ผ่านมา

รันบนเครื่อง✓ เจ้าของบริการ · xcodebuildmcp.com

XcodeBuildMCP

XcodeBuildMCP provides tools for Xcode project management, simulator management, and app utilities.

โดย cameroncookeใช้กันมาก↓ 130.5K/สัปดาห์ ยอดของแพ็กเกจที่ใช้ร่วม★ 6.6Kอัปเดต 14 เดือนที่ผ่านมา

รันบนเครื่อง

README จากผู้ทำ

เปิดอ่าน README

ส่วนนี้คัดจาก repo ของผู้ทำตามต้นฉบับ PopNx MCP ไม่ได้ตรวจหรือรับรองเนื้อหา ตัด HTML รูปภาพ และสคริปต์ออกแล้ว ลิงก์จะพาออกนอกเว็บ

Valem

A spreadsheet engine for AI agents. An LLM describes a domain as a JSON spec (fields, formulas, invariants); Valem compiles it into a live model that recomputes every dependent value on each change, refuses changes that break a rule, and can explain why any number is what it is.

Why

LLMs are good at *describing* a domain and bad at *keeping state consistent* over it. Ask one to maintain a quote, an order, or a loan application across twenty turns and the total drifts from its line items, a limit checked three messages ago is forgotten, and arithmetic is off by a rounding step.

Valem moves the rules out of the conversation and into a deterministic runtime:

  • Derivations are JSONata formulas over JSON paths, recomputed in dependency order (only what a change touches).
  • Constraints are invariants checked before a change commits: roll it back or flag it.
  • Effects (HTTP calls, LLM calls, timers) are emitted as data and run after the commit, so replay never re-fires I/O.
  • Explain and audit: every value has a derivation trace, and the audit trail is hash-chained.

The agent writes the spec; Valem validates it, tests it, and keeps it true.

Try it in 30 seconds

In the browser, no install. Open valem.run, describe a model in plain words ("a mortgage with overpayments", "an invoice with VAT and discounts"), then type into the live form and watch every derived value update.

From your agent (MCP, hosted, nothing to download):

# Claude Code

claude mcp add --transport http valem https://valem.run/mcp

Claude Desktop: Settings → Connectors → *Add custom connector* → https://valem.run/mcp. Then ask the agent to call pair_browser and it will build models you see live in a browser tab. The authoring tools (validate_spec, eval_expression, test_spec, dry_run) work without pairing. Guide: Connect your agent.

Self-hosted with Docker:

docker run --rm -p 8080:8080 ghcr.io/vlad-public-code/valem:latest

→ http://localhost:8080 (management UI, REST + WebSocket API, and /mcp)

What a spec looks like

{

"id": "order", "version": "1.0.0", "schema": {}, "derivations": [ { "path": "$.order.items[*].lineTotal", "expr": "$parent.qty * $parent.price" }, { "path": "$.order.total", "expr": "$sum(order.items.(qty * price))" } ], "constraints": [ { "id": "max-order", "expr": "order.total <= 5000", "message": "Order exceeds the cap", "policy": "rollback" } ] }

Write qty on any line item and lineTotal and total recompute; a write that pushes the total over 5,000 is rejected before it commits. Full format: ModelSpec reference.

Ways to run it

You wantUse
An agent that maintains structured stateThe MCP server, hosted (valem.run/mcp) or self-hosted (stdio jar from Releases)
A backend shared by many clientsvalem-web: REST + WebSocket, pluggable storage (filesystem, Postgres, Mongo, Redis, S3)
The engine inside your JVM appEmbed valem-core/valem-service
Scripting with no serverThe JSON console (one JSON command per line on stdin)
A live model inside your web pageEmbed a live model

Clients: TypeScript and Java SDKs.

Documentation

Published at [valem.run/docs](https://valem.run/docs/) (source in docs/), organised in six chapters: Getting started, Usage scenarios, Model guide, Reference, Deployment, Extending. Good first reads:

Building from source

Prerequisites
  • Java 21+
  • Maven 3.9+
  • Node.js 20+ and npm 9+ (UI only)

Running the console app (no HTTP server required)

The console app is the fastest way to use Valem from a script or an AI agent. It reads one JSON command per line from stdin and writes one JSON response per line to stdout. No HTTP, no browser, no server process. All state is held in memory for the lifetime of the process.

# Build the fat jar (first time)

mvn install -pl valem-core,valem-service -q mvn package -pl valem-console -q

Run interactively

java -jar valem-console/target/valem-console-1.0.0-SNAPSHOT.jar

Or pipe commands

echo '{"cmd":"list-models"}' | java -jar valem-console/target/valem-console-1.0.0-SNAPSHOT.jar

Example session:

// stdin

{"cmd":"create-model","spec":{"id":"order","version":"1.0.0","schema":{},"derivations":[{"path":"$.total","expr":"subtotal + tax"}]}} {"cmd":"mutate","id":"order","mutations":{"$.subtotal":100,"$.tax":8}} {"cmd":"get-state","id":"order"}

// stdout {"ok":true,"result":{"id":"order","status":"created"}} {"ok":true,"result":{"success":true,"mutatedPaths":["$.subtotal","$.tax"],"derivedUpdated":["$.total"],...}} {"ok":true,"result":{"subtotal":100,"tax":8,"total":108}}

Full command list: console JSON protocol.

Running the backend

# From the repo root — build and start the Spring Boot server on port 8080.

valem-web is the runnable deployable; valem-api is the headless library it wraps.

mvn install -pl valem-core,valem-service -q mvn spring-boot:run -pl valem-web

The API is now available at http://localhost:8080, with the management UI served at /. Storage is in-memory by default; other backends are à-la-carte adapter jars (mvn -Pweb-postgres -pl valem-web package, then --valem.storage.type=postgres) — see configuration.md. For durable setups, persistence layout, and the hardening checklist see operations.md.

To enable LLM-powered spec generation, configure a provider before starting (the key is read from valem.llm.api-key, settable as VALEM_LLM_API_KEY; there is no provider-specific env fallback):

# Anthropic (default provider)

export VALEM_LLM_API_KEY=sk-ant-... mvn spring-boot:run -pl valem-web

OpenAI

VALEM_LLM_PROVIDER=openai VALEM_LLM_MODEL=gpt-4o \ VALEM_LLM_API_KEY=$OPENAI_API_KEY mvn spring-boot:run -pl valem-web

Ollama (local, no API key needed; start ollama serve first)

VALEM_LLM_PROVIDER=ollama VALEM_LLM_MODEL=llama3 mvn spring-boot:run -pl valem-web

Without any provider configured the server starts normally; the /models/generate* endpoints return 503. All LLM knobs (providers, tool budgets, retries, temperatures): configuration.md.

Running the developer UI

In a separate terminal:

cd valem-ui

npm install # first time only npm run dev

Open http://localhost:5173 in your browser.

The UI proxies all /models and /blobs requests (including WebSocket connections) to the backend, which must be running.

Generating a model spec with an LLM

The UI's ✦ Generate button drives a human-in-the-loop workflow: enter a model ID and a plain-text domain description → Preview Prompt (editable) → send to the LLM → review/edit the generated spec → Register Model. The same workflow is available over REST (POST /models/generate/preview → /models/generate → /models).

See generating-specs-with-llm.md for the workflow and provider setup, and llm-prompts.md for the exact prompts and the validate-and-repair loop.

Example: create and mutate a model over REST

# Create a model

curl -s -X POST http://localhost:8080/models \ -H 'Content-Type: application/json' \ -d '{ "id": "order", "version": "1.0.0", "schema": {}, "derivations": [ { "path": "$.order.total", "expr": "order.subtotal + order.tax" } ], "constraints": [ { "id": "max-order", "expr": "order.total <= 5000", "message": "Order exceeds the cap", "policy": "rollback" } ] }'

Mutate base fields — total is derived automatically

curl -s -X POST http://localhost:8080/models/order/mutations \ -H 'Content-Type: application/json' \ -d '{ "$.order.subtotal": 200, "$.order.tax": 20 }'

Read merged state

curl -s http://localhost:8080/models/order/state | python -m json.tool

Every endpoint (audit, snapshots, views, blobs, spec evolution, composition, …): api-reference.md.

Running tests

# All modules

mvn test

Core only (faster — no Spring context)

mvn test -pl valem-core

Running end-to-end tests

The valem-e2e module contains Playwright browser tests that drive the full stack (backend + UI).

Prerequisites: the backend must be running on port 8080 (see Running the backend). The UI dev server is started automatically by Playwright.

cd valem-e2e

npm install # first time only npx playwright install # download browser binaries (first time only)

npm test # headless Chromium npm run test:headed # watch the browser npm run test:ui # Playwright interactive UI mode npm run report # open the last HTML report

License

Apache-2.0 — see LICENSE.