Jev with LangChain

Why there is no model adapter, and why that is fine

LangChain's LLM and BaseChatModel interfaces are contracts to turn messages into text. Every downstream piece — output parsers, streaming, the tool-calling loop, the memory abstractions — assumes tokens come out the other end.

Jev generates no tokens. It takes a state plus a map of named questions and returns typed answers: a chosen option with a probability for every alternative, a rubric score, or a bare 0–1 probability. Forcing that into a chat-model wrapper means serialising a distribution into a string so that an output parser can turn it back into a distribution. That is a lossy round trip in service of a type signature.

The three places it actually belongs

A router, as a Runnable

The highest-value one. A branch in front of the chain costs $0.000021 at a 500-token state and decides which of your expensive paths runs at all:

from langchain_core.runnables import RunnableLambda, RunnableBranch
from typesafe_sdk import Choice, TypeSafeClient

jev = TypeSafeClient()

def classify(inputs: dict) -> dict:
    """Attach an intent and a confidence. Adds a field; changes nothing else."""
    answer = jev.system_one(
        model="jev-latest",
        state=inputs["question"],
        questions={
            "intent": Choice(
                instructions="What is the user asking for?",
                criteria={
                    "factual":   "A specific fact that lives in the knowledge base",
                    "creative":  "Drafting, rewriting or brainstorming",
                    "troubleshoot": "Something is broken and they want it fixed",
                },
            )
        },
    ).answers["intent"]
    return {**inputs, "intent": answer.choice, "confidence": answer.confidence}

route = RunnableLambda(classify) | RunnableBranch(
    # Low confidence never picks a specialist path — it goes to the general one.
    (lambda x: x["confidence"] < 0.6, general_chain),
    (lambda x: x["intent"] == "factual", rag_chain),
    (lambda x: x["intent"] == "troubleshoot", support_chain),
    creative_chain,
)

As a tool an agent can call

The other shape worth having. Note the docstring is doing real work: it is what the agent reads to decide whether to call this at all.

from langchain_core.tools import tool
from typesafe_sdk import Noul

@tool
def check_policy(text: str, policy: str) -> dict:
    """Judge whether some text satisfies a policy.

    Returns a probability between 0 and 1, not a verdict — 0.5 means genuinely
    uncertain, and the caller decides what threshold matters.
    """
    answer = jev.system_one(
        model="jev-latest",
        state={"text": text, "policy": policy},
        questions={"ok": Noul(instructions="Does the text satisfy the policy as written?")},
    ).answers["ok"]
    return {"satisfies_policy": answer.noul}

Three things that will trip you up

• Do not put a chain's whole scratchpad in the state. Accuracy falls as the state fills with material unrelated to the decision — the vendor documents this directly. Pass the question, not the conversation.
• Ask several questions in one call, not several calls. The state is ingested once and every question is evaluated against it in parallel, so five questions cost what one costs. A chain that calls Jev three times in a row is usually one call written badly.
• Do not carry a threshold between primitives. A 0.6 tuned on a Noul does not mean the same thing on a Choice; the vendor publishes an example where the two disagree sharply on the same question.

Common questions

If a real package appears, this page should say so — awesome-jev is where it would show up first.