什么是决策模型？Jev 和 Clef 与 LLM 有何不同

pip install -U swarms
# or
uv pip install -U swarms

export TYPESAFE_API_KEY="..."
export OPENAI_API_KEY="sk-..."
# Only for Cloudflare Clef
export CLOUDFLARE_ACCOUNT_ID="..."
export CLOUDFLARE_AUTH_TOKEN="..."

python -c "import swarms; print(swarms.__version__)"

from swarms import DecisionModel

# Reads TYPESAFE_API_KEY and uses TypeSafe's jev-latest by default.
model = DecisionModel()

ticket = {
    "message": (
        "Checkout has been failing for every customer for an hour. "
        "We are losing orders. Please fix this now."
    ),
    "customer_plan": "enterprise",
}

result = model.run(
    state=ticket,
    questions={
        "team": {
            "type": "choice",
            "instructions": "Which team should handle `message`?",
            "criteria": {
                "billing": "Payments, invoices and refunds",
                "technical": "Outages, errors and integrations",
                "sales": "Pricing, plans and upgrades",
            },
        },
        "severity": {
            "type": "score",
            "instructions": "How severe is the customer impact in `message`?",
            "criteria": ["No impact", "Minor", "Major", "Critical"],
        },
        "urgent": {
            "type": "noul",
            "instructions": "Does `message` convey urgency or time pressure?",
        },
    },
)

answers = result["answers"]
print("Answered by:", result["model"])
print("team:", answers["team"])
print("severity:", answers["severity"])
print("urgent:", answers["urgent"])
print("usage:", result["usage"])
cost = model.calculate_cost(result["usage"])
print(f"cost: ${cost['total_cost']:.6f}")

from swarms import Agent, DecisionModel

router = DecisionModel()

agents = {
    "billing": Agent(
        agent_name="Billing-Agent",
        system_prompt="You are our billing support agent. Reply to the customer in two sentences.",
        model_name="gpt-5.4-mini",
        max_loops=1,
        output_type="final",
        print_on=False,
    ),
    "technical": Agent(
        agent_name="Technical-Agent",
        system_prompt="You are our technical support agent. Reply to the customer in two sentences.",
        model_name="gpt-5.4-mini",
        max_loops=1,
        output_type="final",
        print_on=False,
    ),
}


def handle(request: str) -> str:
    """
    Route a request to an agent, or to a person when the router is unsure.

    Args:
        request: The customer's message.

    Returns:
        The agent's reply or the reason the request went to a person.
    """
    answers = router.run(
        state=request,
        questions={
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this request?",
                "criteria": {
                    "billing": "Charges, invoices, refunds and subscriptions",
                    "technical": "Bugs, API errors, outages and integrations",
                    "other": "Not a billing or technical support request",
                },
            },
            "refund": {
                "type": "noul",
                "instructions": "Does the request ask for money back?",
            },
        },
    )["answers"]

    team = answers["team"]
    print(
        f"  team={team['choice']} confidence={team['confidence']:.2f} "
        f"refund={answers['refund']['noul']:.2f}"
    )

    if team["choice"] == "other":
        return "Declined: not a support request."
    if team["confidence"] < 0.6:
        return "Sent to a person: the router is unsure who owns this."
    # Refunds move money, so they need a higher bar than a reply does.
    if answers["refund"]["noul"] > 0.5 and team["confidence"] < 0.9:
        return "Sent to a person: refund with moderate confidence."
    return agents[team["choice"]].run(request)


requests = [
    "Our webhook endpoint has returned 500 errors since your API update this morning.",
    "I was charged twice for my March invoice. Please refund one of the charges.",
    "Your sync bug duplicated 300 orders and we paid shipping on all of them. We want compensation.",
    "Something is wrong with my account.",
    "Can you write my history essay on the French Revolution?",
]

for request in requests:
    print(f"\n{request}")
    print(handle(request))

from swarms import DecisionModel, get_decision_model_prices, get_decision_models

print(get_decision_models())
for name, price in get_decision_model_prices().items():
    print(f"{name}: ${price['input']} input, ${price['output']} output per million tokens")

model = DecisionModel(model_name="jev-latest")
review = "The battery lasts two days, but the screen scratched within a week."

sentiment = model.score(
    state=review,
    instructions="How positive is this product review overall?",
    criteria=["Negative", "Mixed", "Positive"],
)
topic = model.choice(
    state=review,
    instructions="What does the review complain about?",
    criteria={"battery": None, "screen": None, "price": None, "shipping": None},
)
defect = model.noul(
    state=review,
    instructions="Does the review report damage or a defect?",
)

print("sentiment:", sentiment["score"], sentiment["confidence"])
print("topic:", topic["choice"], topic["probabilities"])
print("defect:", defect)
print("usage:", model.usage)
print(f"cost: ${model.calculate_cost()['total_cost']:.6f}")

from swarms import DecisionModel

# Needs CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_AUTH_TOKEN in your environment or .env.
clef = DecisionModel(model_name="clef")  # or "clef-flash"

result = clef.run(
    state="Checkout has been failing for every customer for the last hour.",
    questions={
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "billing": "Payments, invoices and refunds",
                "technical": "Outages, errors and configuration",
            },
        },
        "urgent": {
            "type": "noul",
            "instructions": "Is this support request urgent?",
        },
    },
)

answers = result["answers"]
print(result["model"], answers["team"]["choice"], answers["urgent"]["noul"])
print(f"cost: ${clef.calculate_cost(result['usage'])['total_cost']:.6f}")