Skip to main content
पॉलिसियाँ आपको एजेंट के निष्पादन के हर स्टेप पर लॉजिक इंजेक्ट करने देती हैं। निर्देश जोड़ें, व्यवहार संशोधित करें, बाधाएँ लागू करें—यह सब रनटाइम कॉन्टेक्स्ट जैसे स्टेप काउंट, पिछले आउटपुट या बाहरी स्टेट के आधार पर।

बुनियादी पॉलिसी

एक पॉलिसी एक फ़ंक्शन है जो कॉन्टेक्स्ट लेता है और परिवर्तन लौटाता है:
import asyncio
from dedalus_labs import AsyncDedalus, DedalusRunner
from dedalus_labs.utils.stream import stream_async
from dotenv import load_dotenv

load_dotenv()

def policy(ctx: dict) -> dict:
    step = ctx.get("step", 1)
    
    if step >= 3:
        # स्टेप 3 के बाद, मॉडल से अंतिम उत्तर देने के लिए कहें
        return {
            "message_prepend": [
                {"role": "system", "content": "अब अपना अंतिम उत्तर प्रदान करें।"}
            ],
            "max_steps": 4
        }
    
    return {}

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)

    result = runner.run(
        input="इंटरनेट के इतिहास पर शोध करें और मुख्य मील के पत्थरों का सारांश दें",
        model="openai/gpt-5.2",
        mcp_servers=["windsor/brave-search-mcp"],  # Brave Search MCP के माध्यम से वेब खोज
        stream=True,
        policy=policy
    )

    await stream_async(result)

if __name__ == "__main__":
    asyncio.run(main())

नीति संदर्भ

ctx dict में ये फ़ील्ड शामिल होते हैं:
FieldTypeDescription
stepintवर्तमान निष्पादन चरण (1-इंडेक्स्ड)
messageslistअब तक की बातचीत का इतिहास
tools_calledlistपिछले चरणों में कॉल किए गए टूल्स

नीति रिटर्न

नीतियाँ निम्नलिखित लौटा सकती हैं:
FieldEffect
message_prepend / messagePrependअगली model कॉल से पहले जोड़े जाने वाले संदेश
message_append / messageAppendवार्तालाप के बाद जोड़े जाने वाले संदेश
max_steps / maxStepsअधिकतम स्टेप काउंट को ओवरराइड करता है
stopनिष्पादन को समय से पहले रोकने के लिए बूलियन मान

उपयोग के मामले

रेट लिमिटिंग: कई चरणों में API (एप्लिकेशन प्रोग्रामिंग इंटरफ़ेस) कॉल्स को ट्रैक करें, सीमा के पास पहुँचने पर उन्हें अस्थायी रूप से रोक दें। गार्डरेल्स: आउटपुट में नीति उल्लंघनों की जाँच करें, सुधार के लिए correction prompts इंजेक्ट करें। डायनेमिक निर्देश: मध्यवर्ती परिणामों के आधार पर व्यवहार बदलें। लागत नियंत्रण: महँगे ऑपरेशन्स की एक निश्चित संख्या के बाद निष्पादन रोक दें।

टूल इवेंट कॉलबैक्स

on_tool_event के साथ tool execution को मॉनिटर करें:
import json

def on_tool(evt: dict) -> None:
    print(f"Tool called: {json.dumps(evt)}")

result = runner.run(
    input="Calculate shipping costs for a 5kg package to London",
    model="openai/gpt-5.2",
    tools=[calculate_shipping],
    on_tool_event=on_tool,
    policy=policy
)

अगले चरण

  • टूल्स — ऐसे टूल्स परिभाषित करें जिन्हें नीतियाँ नियंत्रित कर सकती हैं
इन डॉक्स को प्रोग्रामेटिक रूप से कनेक्ट करें Claude, VSCode और अन्य के साथ मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) के ज़रिए रीयल‑टाइम उत्तरों के लिए।