मुख्य सामग्री पर जाएं
prompt उपयोगकर्ता-नियंत्रित संदेश टेम्पलेट होते हैं। टूल्स (जिन्हें LLM कॉल करता है) के विपरीत, prompt उपयोगकर्ता द्वारा चुने जाते हैं और वार्तालाप संदेशों में रेंडर किए जाते हैं। prompt, MCP प्रोटोकॉल के माध्यम से इस तरह प्रवाहित होते हैं:
  1. कोई Client prompts/list के ज़रिए prompt खोजता है (हर prompt में arguments और मेटाडेटा शामिल हो सकते हैं)।
  2. कोई Client string-valued arguments के साथ prompts/get के ज़रिए किसी prompt को रेंडर करता है।
  3. सर्वर आपका prompt renderer निष्पादित करता है।
  4. सर्वर MCP स्पेसिफिकेशन के अनुसार messages (और वैकल्पिक description) वाला GetPromptResult वापस करता है।
@prompt(...) के साथ prompt परिभाषित करें और उन्हें server.collect(...) (या with server.binding(): ... के अंदर) के ज़रिए रजिस्टर करें।

​
डेकोरेटर सिग्नेचर

  • prompt(...): prompt(name: str, *, description=None, title=None, arguments=None, icons=None, meta=None)
आपका renderer इस प्रकार कॉल किया जाता है:
  • fn(arguments: dict[str, str] | None) → messages / mapping / GetPromptResult / None लौटाता है

​
बेसिक prompt

from dedalus_mcp import MCPServer, prompt, types

@prompt(
    "code-review",
    description="Review code for issues",
    arguments=[
        types.PromptArgument(name="language", required=False),
        types.PromptArgument(name="focus", required=False),
    ],
)
def code_review(arguments: dict[str, str] | None):
    args = arguments or {}
    language = args.get("language", "python")
    focus = args.get("focus")
    focus_text = f" Focus on: {focus}." if focus else ""

    return [
        ("assistant", "You are a senior code reviewer."),
        ("user", f"निम्नलिखित {language} कोड की समीक्षा करें।{focus_text}"),
    ]

server = MCPServer("assistant")
server.collect(code_review)
विवरण Client/LLM को बताता है कि इस prompt का उद्देश्य क्या है। arguments=[...] यह परिभाषित करता है कि Client को prompts/get में कौन‑से arguments पास करने चाहिए।

​
Arguments (आवश्यक बनाम वैकल्पिक)

Dedalus MCP किसी argument को केवल तभी आवश्यक मानता है जब आप उसे डेकोरेटर के arguments=[...] में required=True के रूप में चिह्नित करते हैं। 
from dedalus_mcp import MCPServer, prompt, types

@prompt(
    "translate",
    description="टेक्स्ट का अनुवाद करें",
    arguments=[
        types.PromptArgument(name="text", required=True),
        types.PromptArgument(name="target_lang", required=False),
    ],
)
def translate(arguments: dict[str, str] | None):
    args = arguments or {}
    text = args["text"]
    target = args.get("target_lang", "English")
    return [("user", f"Translate this to {target}: {text}")]

server = MCPServer("assistant")
server.collect(translate)
यदि आवश्यक args मौजूद नहीं हैं, तो Dedalus INVALID_PARAMS के साथ एक मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) त्रुटि उत्पन्न करता है।

​
जटिल आर्ग्युमेंट मान (लिस्ट/डिक्ट)

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) prompt के आर्ग्युमेंट स्ट्रिंग होते हैं। यदि आपको structured मान चाहिए, तो JSON स्ट्रिंग पास करें और उन्हें खुद पार्स करें: 
import json
from dedalus_mcp import prompt, types

@prompt(
    "summarize",
    description="दस्तावेज़ का सारांश बनाएं",
    arguments=[types.PromptArgument(name="focus_areas_json", required=False)],
)
def summarize(arguments: dict[str, str] | None):
    args = arguments or {}
    focus_areas = json.loads(args.get("focus_areas_json", "[]"))
    return [("user", f"इस दस्तावेज़ का सारांश बनाएं। फोकस: {focus_areas}")]

​
रिटर्न फ़ॉर्मैट्स

Prompt renderer ये रिटर्न कर सकते हैं:
  • messages की एक list/iterable, जहाँ हर item इनमें से एक हो सकता है:
    • (role, content) tuple
    • {"role": "...", "content": ...} जैसा mapping
    • PromptMessage instance
  • एक mapping, जिसके ज़रिए explicit control मिलता है:
    • required: "messages"
    • optional: "description"
  • GetPromptResult
  • None (ज़ीरो संदेश पैदा करता है)
समर्थित नहीं: raw str रिटर्न करना (Dedalus TypeError raise करता है ताकि आप हमेशा role + content दोनों ही दें)।

​
स्पष्ट नियंत्रण (मैपिंग)

from dedalus_mcp import prompt

@prompt("status", description="Daily status template")
def status(arguments: dict[str, str] | None):
    return {
        "description": "Status template",
        "messages": [
            ("assistant", "You summarize daily status reports."),
            ("user", "Write yesterday/today/blockers."),
        ],
    }

​
संदेश सामग्री

संदेश content के लिए, आप उपयोग कर सकते हैं:
  • एक str (जो अपने‑आप टेक्स्ट सामग्री में बदल दिया जाएगा)
  • एक पूरा content-block मैपिंग (जैसे {"type": "text", "text": "..."})
  • dedalus_mcp.types से एक content-block इंस्टेंस (जैसे TextContent, ImageContent, आदि)

​
ऐसिंक prompts

from dedalus_mcp import prompt

@prompt("db-summary", description="Summarize database state")
async def db_summary(arguments: dict[str, str] | None):
    # await fetch_db_stats(...)
    return [
        ("assistant", "You analyze database metrics."),
        ("user", "Summarize current DB health and recent anomalies."),
    ]
I/O कार्यों के लिए async def को प्राथमिकता दें।

​
डेकोरेटर के विकल्प

from dedalus_mcp import prompt

@prompt(
    "analyze",
    description="कोड का विश्लेषण करें",
    title="कोड विश्लेषण",
    icons=[{"type": "url", "url": "https://example.com/icon.png"}],
    meta={"category": "code"},
    arguments=[{"name": "language", "required": False}],
)
def analyze(arguments: dict[str, str] | None):
    language = (arguments or {}).get("language", "python")
    return [("user", f"इस {language} कोड में बग्स, स्टाइल और सुरक्षा के लिए विश्लेषण करें।")]

​
कॉन्टेक्स्ट एक्सेस

यदि किसी MCP request के दौरान कोई prompt render की जाती है, तो वह get_context() के ज़रिए कॉन्टेक्स्ट एक्सेस कर सकती है (logging, progress आदि के लिए)। नोट: get_context() केवल एक सक्रिय MCP request handler के अंदर ही काम करता है; इसे request के बाहर call करने पर LookupError थ्रो होता है। 
from dedalus_mcp import prompt, get_context

@prompt("generate-report", description="Generate a report request")
async def generate_report(arguments: dict[str, str] | None):
    ctx = get_context()
    await ctx.info("Rendering prompt", data={"args": arguments or {}})
    return [("user", "Generate a concise weekly report for this project.")]

​
परीक्षण

prompt renderer को सामान्य functions की तरह ही टेस्ट करें: 
def test_code_review_prompt():
    msgs = code_review({"language": "python", "focus": "error handling"})
    assert len(msgs) == 2
सर्वर API (एप्लिकेशन प्रोग्रामिंग इंटरफ़ेस) के माध्यम से इंटीग्रेशन-स्टाइल परीक्षण (prompts/get जैसा): 
import pytest
from dedalus_mcp import MCPServer

@pytest.mark.asyncio
async def test_prompt_rendering():
    server = MCPServer("test")
    server.collect(code_review)

    result = await server.invoke_prompt("code-review", arguments={"language": "rust"})
    assert result.messages