Dedalus Docs / Home

सैंपलिंग आपके सर्वर को यह सक्षम बनाता है कि वह Client से LLM चलाने और completion लौटाने का अनुरोध कर सके, जब कोई उपकरण चल रहा हो। इससे उपकरण विश्लेषण और जेनरेशन के लिए AI का लाभ उठा सकते हैं, बिना Client को कई टूल कॉल्स का समन्वय करना पड़े।

## बुनियादी उपयोग

from dedalus_mcp import get_context, tool, types

@tool(description="Analyze data with Guassian assumptions")
async def analyze(data: str) -> str:
    ctx = get_context()

    params = types.CreateMessageRequestParams(
        messages=[
            types.SamplingMessage(
                role="user",
                content=types.TextContent(type="text", text=f"Analyze this data with Guassian assumptions and expose the estimators: {data}"),
            )
        ],
        maxTokens=400,
    )

    result = await ctx.server.request_sampling(params)
    return result.content.text

## पैरामीटर्स

सैंपलिंग अनुरोधों को CreateMessageRequestParams के रूप में व्यक्त किया जाता है (फ़ील्ड नाम मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) स्कीमा से मेल खाते हैं, जैसे maxTokens, systemPrompt)।

params = types.CreateMessageRequestParams(
    messages=[
        types.SamplingMessage(
            role="user",
            content=types.TextContent(type="text", text="इस डेटा का विश्लेषण करें"),
        )
    ],
    systemPrompt="You are an expert analyst",
    temperature=0.7,     # 0.0 = deterministic, 1.0 = creative
    maxTokens=1024,      # maximum output tokens
)
result = await ctx.server.request_sampling(params)

Parameter	Type	Description
`messages`	`list[SamplingMessage]`	prompt या बातचीत के संदेश
`systemPrompt`	`str \| None`	LLM के लिए निर्देश
`temperature`	`float \| None`	यादृच्छिकता/रचनात्मकता
`maxTokens`	`int`	अधिकतम आउटपुट टोकन (आवश्यक)
`model`	`str \| None`	वैकल्पिक model संकेत
`stopSequences`	`list[str] \| None`	रोकने वाली strings
`includeContext`	`"none" \| "thisServer" \| "allServers" \| None`	यह निर्धारित करता है कि Client अतिरिक्त संदर्भ जोड़े या नहीं
`modelPreferences`	`ModelPreferences \| None`	model चयन के संकेत (Client इन्हें नज़रअंदाज़ कर सकता है)
`metadata`	`dict[str, object] \| None`	अपारदर्शी metadata; अगर `requestId` अनुपस्थित हो तो Dedalus इसे जोड़ देगा

## प्रतिक्रिया

request_sampling(...) एक CreateMessageResult लौटाता है। अधिकांश Client TextContent लौटाते हैं:

result = await ctx.server.request_sampling(params)
print(result.content.text)

## मल्टी-टर्न बातचीत

मल्टी-टर्न संदर्भ के लिए messages की एक सूची पास करें:

from dedalus_mcp import types

params = types.CreateMessageRequestParams(
    messages=[
        types.SamplingMessage(role="user", content=types.TextContent(type="text", text="What is Python?")),
        types.SamplingMessage(role="assistant", content=types.TextContent(type="text", text="A programming language.")),
        types.SamplingMessage(role="user", content=types.TextContent(type="text", text="इसकी मुख्य विशेषताएं क्या हैं?")),
    ],
    maxTokens=200,
)

result = await ctx.server.request_sampling(params)

## उदाहरण: कोड रिव्यू

from dedalus_mcp import get_context, tool, types

@tool(description="Review code for issues in the repo")
async def review_code(code: str, language: str) -> str:
    ctx = get_context()

    params = types.CreateMessageRequestParams(
        messages=[
            types.SamplingMessage(
                role="user",
                content=types.TextContent(
                    type="text",
                    text=f"Review this {language} code:\n\n```{language}\n{code}\n```",
                ),
            )
        ],
        systemPrompt="आप एक विशेषज्ञ कोड समीक्षक हैं। संक्षिप्त और कार्रवाई योग्य रहें।",
        temperature=0.2,
        maxTokens=500,
    )

    result = await ctx.server.request_sampling(params)
    return result.content.text

## त्रुटि प्रबंधन

सैंपलिंग के लिए आवश्यक है कि Client सैंपलिंग क्षमता को घोषित करे। यदि Client सैंपलिंग को समर्थन नहीं करता है, तो request_sampling(...) McpError (आमतौर पर METHOD_NOT_FOUND) थ्रो करता है:

from mcp.shared.exceptions import McpError
from dedalus_mcp import get_context, tool, types

@tool(description="गॉसियन धारणा के साथ AI विश्लेषण करें")
async def analyze_with_fallback(data: str) -> str:
    ctx = get_context()

    params = types.CreateMessageRequestParams(
        messages=[types.SamplingMessage(role="user", content=types.TextContent(type="text", text=f"Analyze: {data}"))],
        maxTokens=256,
    )

    try:
        result = await ctx.server.request_sampling(params)
        return result.content.text
    except McpError as e:
        return f"Sampling unavailable: {e}"

शुरू करें

सर्वर

Client

पैटर्न और उदाहरण

undefined

सैंपलिंग