In diesem Tutorial zeigen wir, wie man mithilfe von ein vertragsorientiertes Agentenentscheidungssystem entwirft PydanticAIwobei strukturierte Schemata als nicht verhandelbare Governance-Verträge und nicht als optionale Ausgabeformate behandelt werden. Wir zeigen, wie wir ein striktes Entscheidungsmodell definieren, das die Einhaltung von Richtlinien, die Risikobewertung, die Vertrauenskalibrierung und umsetzbare nächste Schritte direkt im Ausgabeschema des Agenten kodiert. Durch die Kombination von Pydantic-Validatoren mit den Wiederholungs- und Selbstkorrekturmechanismen von PydanticAI stellen wir sicher, dass der Agent keine logisch inkonsistenten oder nicht konformen Entscheidungen treffen kann. Während des gesamten Workflows konzentrieren wir uns auf den Aufbau eines Entscheidungsagenten der Enterprise-Klasse, der unter Einschränkungen argumentiert und ihn für reale Risiko-, Compliance- und Governance-Szenarien geeignet macht, statt für auf Spielzeug-Eingabeaufforderungen basierende Demos. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
!pip -q set up -U pydantic-ai pydantic openai nest_asyncio
import os
import time
import asyncio
import getpass
from dataclasses import dataclass
from typing import Listing, Literal
import nest_asyncio
nest_asyncio.apply()
from pydantic import BaseModel, Area, field_validator
from pydantic_ai import Agent
from pydantic_ai.fashions.openai import OpenAIChatModel
from pydantic_ai.suppliers.openai import OpenAIProvider
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
attempt:
from google.colab import userdata
OPENAI_API_KEY = userdata.get("OPENAI_API_KEY")
besides Exception:
OPENAI_API_KEY = None
if not OPENAI_API_KEY:
OPENAI_API_KEY = getpass.getpass("Enter OPENAI_API_KEY: ").strip()Wir richten die Ausführungsumgebung ein, indem wir die erforderlichen Bibliotheken installieren und die asynchrone Ausführung für Google Colab konfigurieren. Wir laden den OpenAI-API-Schlüssel sicher und stellen sicher, dass die Laufzeit für die Verarbeitung asynchroner Agentenaufrufe bereit ist. Dies schafft eine stabile Grundlage für die Ausführung des Contract-First-Agenten ohne umgebungsbedingte Probleme. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class RiskItem(BaseModel):
danger: str = Area(..., min_length=8)
severity: Literal("low", "medium", "excessive")
mitigation: str = Area(..., min_length=12)
class DecisionOutput(BaseModel):
resolution: Literal("approve", "approve_with_conditions", "reject")
confidence: float = Area(..., ge=0.0, le=1.0)
rationale: str = Area(..., min_length=80)
identified_risks: Listing(RiskItem) = Area(..., min_length=2)
compliance_passed: bool
circumstances: Listing(str) = Area(default_factory=record)
next_steps: Listing(str) = Area(..., min_length=3)
timestamp_unix: int = Area(default_factory=lambda: int(time.time()))
@field_validator("confidence")
@classmethod
def confidence_vs_risk(cls, v, information):
dangers = information.knowledge.get("identified_risks") or ()
if any(r.severity == "excessive" for r in dangers) and v > 0.70:
elevate ValueError("confidence too excessive given high-severity dangers")
return v
@field_validator("resolution")
@classmethod
def reject_if_non_compliant(cls, v, information):
if information.knowledge.get("compliance_passed") is False and v != "reject":
elevate ValueError("non-compliant selections have to be reject")
return v
@field_validator("circumstances")
@classmethod
def conditions_required_for_conditional_approval(cls, v, information):
d = information.knowledge.get("resolution")
if d == "approve_with_conditions" and (not v or len(v) < 2):
elevate ValueError("approve_with_conditions requires no less than 2 circumstances")
if d == "approve" and v:
elevate ValueError("approve should not embody circumstances")
return vWir definieren den Kernentscheidungsvertrag mithilfe strenger Pydantic-Modelle, die eine gültige Entscheidung präzise beschreiben. Wir kodieren logische Einschränkungen wie Konfidenz-Risiko-Ausrichtung, Compliance-gesteuerte Ablehnung und bedingte Genehmigungen direkt im Schema. Dadurch wird sichergestellt, dass jede Agentenausgabe der Geschäftslogik und nicht nur der syntaktischen Struktur genügen muss. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
@dataclass
class DecisionContext:
company_policy: str
risk_threshold: float = 0.6
mannequin = OpenAIChatModel(
"gpt-5",
supplier=OpenAIProvider(api_key=OPENAI_API_KEY),
)
agent = Agent(
mannequin=mannequin,
deps_type=DecisionContext,
output_type=DecisionOutput,
system_prompt="""
You're a company resolution evaluation agent.
You could consider danger, compliance, and uncertainty.
All outputs should strictly fulfill the DecisionOutput schema.
"""
)
Wir injizieren Unternehmenskontext über ein typisiertes Abhängigkeitsobjekt und initialisieren den von OpenAI unterstützten PydanticAI-Agenten. Wir konfigurieren den Agenten so, dass er nur strukturierte Entscheidungsausgaben erzeugt, die dem vordefinierten Vertrag entsprechen. Dieser Schritt formalisiert die Trennung zwischen Geschäftskontext und Modellbegründung. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
@agent.output_validator
def ensure_risk_quality(end result: DecisionOutput) -> DecisionOutput:
if len(end result.identified_risks) < 2:
elevate ValueError("minimal two dangers required")
if not any(r.severity in ("medium", "excessive") for r in end result.identified_risks):
elevate ValueError("no less than one medium or excessive danger required")
return end result
@agent.output_validator
def enforce_policy_controls(end result: DecisionOutput) -> DecisionOutput:
coverage = CURRENT_DEPS.company_policy.decrease()
textual content = (
end result.rationale
+ " ".be a part of(end result.next_steps)
+ " ".be a part of(end result.circumstances)
).decrease()
if end result.compliance_passed:
if not any(okay in textual content for okay in ("encryption", "audit", "logging", "entry management", "key administration")):
elevate ValueError("lacking concrete safety controls")
return end resultWir fügen Ausgabevalidatoren hinzu, die als Governance-Kontrollpunkte fungieren, nachdem das Modell eine Antwort generiert. Wir zwingen den Agenten, bedeutsame Risiken zu identifizieren und bei der Geltendmachung von Compliance explizit auf konkrete Sicherheitskontrollen hinzuweisen. Wenn diese Einschränkungen verletzt werden, lösen wir automatische Wiederholungsversuche aus, um eine Selbstkorrektur zu erzwingen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
async def run_decision():
world CURRENT_DEPS
CURRENT_DEPS = DecisionContext(
company_policy=(
"No deployment of programs dealing with private knowledge or transaction metadata "
"with out encryption, audit logging, and least-privilege entry management."
)
)
immediate = """
Determination request:
Deploy an AI-powered buyer analytics dashboard utilizing a third-party cloud vendor.
The system processes person habits and transaction metadata.
Audit logging will not be applied and customer-managed keys are unsure.
"""
end result = await agent.run(immediate, deps=CURRENT_DEPS)
return end result.output
resolution = asyncio.run(run_decision())
from pprint import pprint
pprint(resolution.model_dump())Wir führen den Agenten auf einer realistischen Entscheidungsanfrage aus und erfassen die validierte strukturierte Ausgabe. Wir zeigen, wie der Agent das Risiko, die Einhaltung von Richtlinien und das Vertrauen bewertet, bevor er eine endgültige Entscheidung trifft. Damit ist der Finish-to-Finish-Workflow zur Vertragsentscheidung in einem produktionsähnlichen Setup abgeschlossen.
Abschließend zeigen wir, wie man mit PydanticAI von Freiform-LLM-Ausgaben zu kontrollierten, zuverlässigen Entscheidungssystemen übergeht. Wir zeigen, dass wir durch die Durchsetzung harter Verträge auf Schemaebene Entscheidungen automatisch an Richtlinienanforderungen, Risikoschwere und Vertrauensrealismus anpassen können, ohne dass eine manuelle Abstimmung der Eingabeaufforderung erforderlich ist. Dieser Ansatz ermöglicht es uns, Agenten zu entwickeln, die sicher ausfallen, sich selbst korrigieren, wenn Einschränkungen verletzt werden, und überprüfbare, strukturierte Ausgaben erzeugen, denen nachgelagerte Systeme vertrauen können. Letztendlich zeigen wir, dass das Contract-First-Agent-Design es uns ermöglicht, agentische KI als zuverlässige Entscheidungsebene in Produktions- und Unternehmensumgebungen einzusetzen.
Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.