मुख्य सामग्री पर जाएं
Resources वह केवल‑पठन (read-only) डेटा हैं जिन्हें Client/LLM संदर्भ (context) के रूप में ले सकते हैं। टूल्स (actions) के विपरीत, resources का उद्देश्य बिना किसी side effects के जानकारी प्रदान करना होता है। Clients resource URIs पर subscribe भी कर सकते हैं और बदलावों के बारे में सूचनाएँ प्राप्त कर सकते हैं। Resources मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) के माध्यम से इस तरह प्रवाहित होते हैं:
  1. कोई Client resources/list के ज़रिए resources खोजता है (हर resource में uri, वैकल्पिक name, वैकल्पिक mimeType आदि शामिल होते हैं)।
  2. कोई Client resources/read के ज़रिए किसी resource को उसके uri के साथ पढ़ता है।
  3. सर्वर आपका resource handler चलाता है।
  4. सर्वर मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) स्पेसिफिकेशन के अनुसार contents के साथ एक ReadResourceResult लौटाता है।
Resources को @resource(...) से परिभाषित करें और उन्हें server.collect(...) के साथ (या with server.binding(): ... के अंदर) रजिस्टर करें।

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

  • resource(...): resource(uri: str, *, name=None, description=None, mime_type=None)
आपका हैंडलर इस प्रकार कॉल किया जाता है:
  • fn() → str (टेक्स्ट) या bytes (बाइनरी) लौटाता है। (async def भी समर्थित है।)

​
मूलभूत संसाधन

from dedalus_mcp import MCPServer, resource

@resource("resource://config/app", name="config", description="Application config", mime_type="application/json")
def app_config() -> str:
    return '{"debug": true, "version": "1.2.0"}'

server = MCPServer("config-server")
server.collect(app_config)
डेकोरेटर resource URI को परिभाषित करता है। collect() उसे रजिस्टर करता है। Clients resources/list से resources की सूची प्राप्त करते हैं और resources/read से उन्हें पढ़ते हैं।

​
टेक्स्ट बनाम बाइनरी

टेक्स्ट के लिए str रिटर्न करें: 
from dedalus_mcp import resource

@resource("resource://docs/readme", mime_type="text/markdown")
def readme() -> str:
    with open("README.md", "r", encoding="utf-8") as f:
        return f.read()
बाइनरी डेटा के लिए bytes रिटर्न करें (Dedalus इसे MCP प्रतिक्रिया में base64 के रूप में एन्कोड करता है): 
from dedalus_mcp import resource

@resource("resource://assets/logo", mime_type="image/png")
def logo() -> bytes:
    with open("logo.png", "rb") as f:
        return f.read()

​
असिंक्रोनस संसाधन

import anyio
from dedalus_mcp import resource

@resource("resource://api/users", description="सक्रिय उपयोगकर्ता", mime_type="application/json")
async def users() -> str:
    await anyio.sleep(0.1)  # I/O का अनुकरण
    return '{"users": ["ada", "grace"]}'
I/O ऑपरेशन्स के लिए async def को प्राथमिकता दें। (टूल्स की तरह, sync handlers इनलाइन ही चलते हैं।)

​
MIME टाइप्स

import json
from dedalus_mcp import resource

@resource("resource://data/report", mime_type="application/json")
def report() -> str:
    return json.dumps({"users": 100, "active": 42})
सामान्य डिफ़ॉल्ट मान:
  • text/plain (str लौटाते समय और यदि कोई mime_type प्रदान नहीं किया गया हो, तो डिफ़ॉल्ट)
  • application/octet-stream (bytes लौटाते समय और यदि कोई mime_type प्रदान नहीं किया गया हो, तो डिफ़ॉल्ट)

​
Subscriptions

Clients resources/subscribe के ज़रिए resources में होने वाले परिवर्तनों को subscribe कर सकते हैं और resources/unsubscribe के ज़रिए unsubscribe कर सकते हैं। जब आपका underlying डेटा बदलता है, तो subscribers को सूचित करें: 
from dedalus_mcp import MCPServer

server = MCPServer("live-data")
server.collect(users)

# जब इस URI के पीछे का डेटा बदलता है:
await server.notify_resource_updated("resource://api/users")
सब्स्क्राइब किए हुए Client को notifications/resources/updated इवेंट प्राप्त होता है।

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

from dedalus_mcp import resource

@resource(
    "resource://config/app",
    name="app-config",           # मानव-अनुकूल नाम (resources/list में दिखाया जाता है)
    description="App settings",  # Shown to clients
    mime_type="application/json",
)
def config() -> str:
    return '{"debug": false}'

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

यदि आपका resource handler कोई exception उठाता है, तो Dedalus एक text fallback resource लौटाता है:
  • mimeType="text/plain"
  • text="Resource error: <exception message>"
यदि कोई URI पंजीकृत नहीं है, तो resources/read एक खाली contents सूची लौटाता है।

​
परीक्षण

रिसोर्स हैंडलर्स को सामान्य फ़ंक्शनों की तरह टेस्ट करें: 
import json

def test_config_resource():
    data = json.loads(app_config())
    assert data["version"] == "1.2.0"
सर्वर API (एप्लिकेशन प्रोग्रामिंग इंटरफ़ेस) के माध्यम से इंटीग्रेशन शैली का परीक्षण (resources/read जैसा ही): 
import pytest
from dedalus_mcp import MCPServer

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

    result = await server.invoke_resource("resource://config/app")
    assert result.contents[0].text == '{"debug": true, "version": "1.2.0"}'

​
Resource templates

@resource_template(...) का उपयोग करके resources/templates/list के माध्यम से URI patterns को प्रकाशित करें (Client द्वारा discovery और completions के लिए)। Dedalus मॉडल कॉन्टेक्स्ट प्रोटोकॉल (MCP) इस समय केवल listing के लिए templates रजिस्टर करता है, लेकिन resources/read को अपने‑आप किसी template function पर route नहीं करता — आपको अभी भी @resource(...) के साथ विशिष्ट resource URIs रजिस्टर करने की ज़रूरत होती है। 
from dedalus_mcp import resource_template

@resource_template(
    "user-profile",
    uri_template="resource://users/{user_id}",
    description="ID के आधार पर उपयोगकर्ता प्रोफ़ाइल",
)
async def user_profile(user_id: str) -> str:
    user = await fetch_user(user_id)
    return json.dumps(user)