如何在 Swarms 中使用 Gemini Decision 1：DecisionModel 分步教程

pip install -U git+https://github.com/kyegomez/swarms.git

export GEMINI_API_KEY="..."

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

probability = model.noul(
    state="The blue mug I ordered on Monday arrived cracked on Wednesday.",
    instructions="Did the item arrive damaged?",
)

print(f"Damaged: {probability:.2f}")

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

probability = model.noul(
    state="I returned the sweater because I prefer green over blue.",
    instructions="Is the customer reporting a product defect?",
    criteria={
        "true": "The product itself is broken or faulty.",
        "false": "A preference, sizing, shipping or pricing complaint.",
    },
)

print(f"Defect: {probability:.2f}")

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

answer = model.choice(
    state="I was charged twice for my order.",
    instructions="Which department should handle this request?",
    criteria={
        "billing": "Payments, invoices and refunds.",
        "technical": "Problems using the product.",
        "shipping": "Delivery and tracking.",
        "other": "Anything outside these categories.",
    },
)

print(answer["choice"], answer["confidence"])
print(answer["probabilities"])

{
  "type": "choice",
  "choice": "billing",
  "probabilities": {"billing": 0.97, "technical": 0.01, "shipping": 0.01, "other": 0.01},
  "confidence": 0.97
}

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

answer = model.score(
    state="Export fails in Safari but works in Chrome.",
    instructions="How severe is this issue for the user?",
    criteria=[
        "Cosmetic: appearance only, no lost functionality.",
        "Workaround available: a task fails, but another way works.",
        "Fully blocked: a task fails with no workaround.",
    ],
)

print(f"Severity: {answer['score']:.2f} on a 0-2 scale")
print(answer["probabilities"])

{
  "type": "score",
  "score": 1.1,
  "legend": {"0": "Cosmetic: ...", "1": "Workaround available: ...", "2": "Fully blocked: ..."},
  "probabilities": {"0": 0.05, "1": 0.8, "2": 0.15},
  "confidence": 0.8
}

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

ticket = {
    "message": "The blue mug I ordered on Monday arrived cracked on Wednesday.",
    "order": {"id": "8821", "age_days": 2},
}

result = model.run(
    state=ticket,
    questions={
        "queue": {
            "type": "choice",
            "instructions": "Which support queue should handle this message?",
            "criteria": {
                "billing": "Payment, invoice or refund questions.",
                "replacements": "Damaged, missing or wrong items.",
                "general": "Product questions and account updates.",
            },
        },
        "severity": {
            "type": "score",
            "instructions": "How severe is this issue for the customer?",
            "criteria": [
                "Minor: the item is usable as it is.",
                "Moderate: the item is usable with a workaround.",
                "Severe: the item cannot be used.",
            ],
        },
        "is_damaged": {
            "type": "noul",
            "instructions": "Did the item arrive damaged?",
        },
        "within_window": {
            "type": "noul",
            "instructions": "Is order.age_days 30 or less?",
        },
    },
)

answers = result["answers"]
queue = answers["queue"]

print(f"Queue: {queue['choice']} (confidence {queue['confidence']:.2f})")
print(f"Severity: {answers['severity']['score']:.2f} on a 0-2 scale")
print(f"Damaged: {answers['is_damaged']['noul']:.2f}")
print(f"Within window: {answers['within_window']['noul']:.2f}")

approved = (
    queue["choice"] == "replacements"
    and queue["confidence"] >= 0.7
    and answers["is_damaged"]["noul"] >= 0.8
    and answers["within_window"]["noul"] >= 0.8
)

if approved:
    print("Action: send a replacement")
else:
    print("Action: send to a human")

import base64
from pathlib import Path

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

photo = base64.b64encode(Path("photo.jpg").read_bytes()).decode("ascii")

probability = model.noul(
    state=[
        {"type": "text", "text": "Customer photo for return request #8821."},
        {"type": "image", "data": photo, "mime_type": "image/jpeg"},
    ],
    instructions="Does the photo show physical damage to the item?",
)

print(f"Visible damage: {probability:.2f}")

import asyncio

from swarms import DecisionModel

model = DecisionModel(model_name="gemini-decision-1")

reviews = [
    "Arrived on time and works perfectly.",
    "The lid does not close. I want my money back.",
    "Fine for the price, though the colour is duller than the photo.",
]

questions = {
    "sentiment": {
        "type": "choice",
        "instructions": "What is the overall sentiment of this review?",
        "criteria": {
            "positive": "The customer is satisfied.",
            "neutral": "Mixed or no clear feeling.",
            "negative": "The customer is dissatisfied.",
        },
    },
    "wants_refund": {
        "type": "noul",
        "instructions": "Is the customer asking for a refund?",
    },
}


async def main() -> None:
    results = await asyncio.gather(
        *(model.arun(review, questions) for review in reviews)
    )

    for review, result in zip(reviews, results):
        answers = result["answers"]
        print(
            f"{answers['sentiment']['choice']:<9}"
            f"refund {answers['wants_refund']['noul']:.2f}  {review}"
        )


asyncio.run(main())

print(model.usage)
print(model.get_price())
print(model.calculate_cost())

from swarms import Agent, DecisionModel

agents = [
    Agent(
        agent_name="Billing-Agent",
        agent_description="Refunds, invoices, failed payments and subscription changes.",
        system_prompt="You resolve billing questions clearly and briefly.",
        model_name="gemini/gemini-2.5-pro",
        max_loops=1,
    ),
    Agent(
        agent_name="Technical-Agent",
        agent_description="Bugs, API errors, integrations and outages.",
        system_prompt="You debug technical problems step by step.",
        model_name="gemini/gemini-2.5-pro",
        max_loops=1,
    ),
    Agent(
        agent_name="Sales-Agent",
        agent_description="Pricing, plan upgrades and new accounts.",
        system_prompt="You answer pricing and plan questions.",
        model_name="gemini/gemini-2.5-pro",
        max_loops=1,
    ),
]
agents_by_name = {agent.agent_name: agent for agent in agents}

router = DecisionModel(model_name="gemini-decision-1")


def route(task: str) -> str:
    answers = router.run(
        state=task,
        questions={
            "agent": {
                "type": "choice",
                "instructions": "Which agent should handle this request?",
                "criteria": {
                    agent.agent_name: agent.agent_description
                    for agent in agents
                },
            },
            "in_scope": {
                "type": "noul",
                "instructions": "Is this a request a software company's support team should handle?",
            },
        },
    )["answers"]

    if answers["in_scope"]["noul"] < 0.5:
        return "Declined: out of scope for support."

    decision = answers["agent"]
    if decision["confidence"] < 0.6:
        return "Escalated to a human: the router is unsure who owns this."

    print(f"Routing to {decision['choice']}")
    return agents_by_name[decision["choice"]].run(task)


print(route("I was charged twice for my March invoice, can you refund one?"))

model = DecisionModel(model_name="gemini-decision-1")  # Google, GEMINI_API_KEY
model = DecisionModel(model_name="gpt-6-luna")         # OpenAI, OPENAI_API_KEY
model = DecisionModel(model_name="clef")               # Cloudflare Workers AI
model = DecisionModel()                                # TypeSafe jev-latest