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 v

Wir 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 result

Wir 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.

Snowflake Intelligence ist eine bahnbrechende Plattform, die es Geschäftsanwendern ermöglicht, Datenagenten zu erstellen, damit sie ihre Unternehmensdaten analysieren, zusammenfassen und Maßnahmen ergreifen können

Schneeflocke (NYSE: SNOW), das AI Information Cloud-Unternehmen, gab bekannt Schneeflocken-Intelligenz (bald in privater Vorschau), eine neue Plattform, die es Unternehmen ermöglicht, ganz einfach geschäftliche Fragen zu ihren Unternehmensdaten zu stellen, um datengesteuerte Antworten zu erhalten, und in nur wenigen Schritten Datenagenten zu erstellen, die auf der Grundlage dieser Erkenntnisse Maßnahmen ergreifen.

Snowflake Intelligence läutet eine neue Ära für die Artwork und Weise ein, wie Benutzer mit ihren Unternehmensdaten interagieren können, und baut dabei auf den einfachen, effizienten und vertrauenswürdigen KI-Diensten von Snowflake auf. Snowflake Intelligence stellt Unternehmen Datenagenten der Enterprise-Klasse zur Verfügung, die auf der Datengrundlage von Snowflake basieren und die organisatorische Arbeit effizient erledigen, gleichzeitig das geistige Eigentum der Kunden schützen und Antworten liefern, die auf zuverlässigen, vertrauenswürdigen Unternehmensdaten basieren. Snowflake Intelligence ermöglicht es jedem, einfach auf das volle Potenzial seiner Daten zuzugreifen und diese zu nutzen und sich nahtlos mit Instruments von Drittanbietern zu verbinden – einschließlich Verkaufstransaktionen in einer Datenbank, Dokumenten in Wissensdatenbanken wie SharePoint, Produktivitätstools wie Slack, Salesforce und Google Workspace neben Enterprise-Intelligence-Daten in Snowflake – damit sie in natürlicher Sprache mit ihren Daten kommunizieren können. Snowflake Intelligence unterstützt auch API-Aufrufe, um Aktionen und Datenänderungen zu ermöglichen und die Arbeit von Geschäftsbenutzern voranzutreiben.

„Mit Snowflake Intelligence können Groups ganz einfach Datenagenten erstellen, die es Geschäftsanwendern ermöglichen, in natürlicher Sprache mit ihren Unternehmensdaten zu kommunizieren und diese Ergebnisse dann von einer einheitlichen Plattform aus zu analysieren, zusammenzufassen und Maßnahmen zu ergreifen“, sagte Baris Gultekin, Head of AI , Schneeflocke. „Snowflake Intelligence stellt den nächsten Schritt auf der KI-Reise von Snowflake dar und ermöglicht es Groups, ihre Unternehmen mit datengesteuerten Erkenntnissen, auf die sie reagieren können, um messbare Auswirkungen zu erzielen, einfach und sicher voranzutreiben.“

Snowflake Intelligence definiert Enterprise Intelligence und datengesteuertes Handeln für alle Benutzer neu

Heutzutage fällt es vielen Unternehmen schwer, fundierte Entscheidungen zu treffen, da die Verwaltung ihrer Datenquellen fragmentiert ist, Infrastruktursilos zwischen unstrukturierten und strukturierten Datenformaten vorhanden sind und nur begrenzter Zugang zu Analysten besteht, die Code schreiben und die Zusammenhänge im gesamten Unternehmen verknüpfen können. Snowflake Intelligence wird sich all diesen Herausforderungen stellen, indem es Unternehmen zunächst dabei unterstützt, verschiedene Datensysteme mit einer einzigen Governance-Ebene zu integrieren. Mit dieser Grundlage können Groups dann Daten aus unstrukturierten und strukturierten Datenquellen mithilfe natürlicher Sprache präzise verarbeiten und abrufen, was den Daten- und KI-Zugriff wirklich demokratisiert und gleichzeitig jedem Benutzer die Möglichkeit gibt, datengesteuerte Maßnahmen zu ergreifen.

Dies ermöglicht es Benutzern wiederum, die Datensätze zu definieren, zu denen sie Fragen stellen möchten, einschließlich PDFs oder Tabellen in einer Datenbank, ohne Code schreiben zu müssen. Wenn Fragen gestellt werden, setzt Snowflake Intelligence dann Datenagenten in Aktion, um Analyse-, Zusammenfassungs- oder Generierungsaufgaben durchzuführen. Datenagenten können auch APIs verwenden oder in Snowflake-Tabellen schreiben, um Geschäftsentscheidungen aufzuzeichnen, wodurch es einfacher wird, Ergebnisse zu verfolgen und Auswirkungen zu messen.

Snowflake Cortex AI und der Snowflake Horizon Catalog – die KI-Engine und das Governance-Framework hinter Snowflake Intelligence

Um ihre KI- und Geschäftsanforderungen zu skalieren, benötigen Unternehmen Lösungen der Enterprise-Klasse, und Snowflake Intelligence ist darauf ausgelegt, diese Anforderungen für Unternehmen zu erfüllen. Snowflake Intelligence verwendet Schneeflocken-Cortex-KIder vollständig verwaltete KI-Dienst von Snowflake, der eine Reihe generativer KI-Funktionen als KI-Engine bereitstellt, die seine Fähigkeiten antreibt, und mit dem er erstellt wurde Cortex-Suche (jetzt allgemein verfügbar) zum Ausführen von Abfragen für unstrukturierte Daten und Cortex-Analyst (in der öffentlichen Vorschau), um Abfragen für strukturierte Daten auszuführen. Neu Innovationen Mit Cortex AI können mehr Benutzer die serverlose Giant Language Mannequin (LLM)-Inferenz, Feinabstimmung, Retrieval Augmented Technology (RAG) und Textual content-to-SQL von Cortex AI nutzen, sodass Datenteams unstrukturierte Daten verarbeiten können, während Entwickler schnell Unternehmens-KI aufbauen Apps.

Snowflake Intelligence ist ebenfalls nativ integriert Snowflake Horizon-Katalog auf grundlegender Ebene, wodurch es mit branchenführenden offenen Formaten kompatibel ist Apache Iceberg Und Apache Polaris (Inkubation). Diese Kombination bietet leistungsstarke Compliance-, Sicherheits-, Datenschutz-, Erkennungs- und Zusammenarbeitsfunktionen auf Unternehmensniveau. Dies erstreckt sich über Clouds und Regionen hinweg, sodass Unternehmen weniger Zeit damit verbringen müssen, sich Gedanken über die Implementierung von Sicherheit und Governance zum Schutz ihrer Daten zu machen, und sich stattdessen mehr auf die Wirkungsoptimierung konzentrieren können. Schneeflocke ist verstärkend den Horizon-Katalog, damit alle Benutzer umfassendere Möglichkeiten erhalten, sichere und kontrollierte KI in großem Maßstab bereitzustellen.

Melden Sie sich für die kostenlosen insideAI-Information an Publication.

Begleiten Sie uns auf Twitter: https://twitter.com/InsideBigData1

Treten Sie uns auf LinkedIn bei: https://www.linkedin.com/firm/insideainews/

Begleiten Sie uns auf Fb: https://www.fb.com/insideAINEWSNOW

Schauen Sie bei uns vorbei YouTube!